From b12f88a160d3c7ca4f61ab4f09665adb00e8717e Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Tue, 13 May 2014 14:49:50 +0100 Subject: [PATCH 01/26] US39: Add a logging facility - Add Log class, to format log messages with different priorities. - Add command line options to select verbose level. - Use Log class to output debug messages from MetaData. --- Launcher.cpp | 105 ++++++++++++++++++++++++++++++++----------------- Launcher.hpp | 11 +++--- Log.hpp | 76 +++++++++++++++++++++++++++++++++++ MetaData.cpp | 13 +++--- hdrmerge_es.ts | 24 ++++++++++- main.cpp | 3 +- 6 files changed, 178 insertions(+), 54 deletions(-) create mode 100644 Log.hpp diff --git a/Launcher.cpp b/Launcher.cpp index 8f1fd4e..5e49cfb 100644 --- a/Launcher.cpp +++ b/Launcher.cpp @@ -23,18 +23,21 @@ #include #include #include -#include #include #include #include #include #include "Launcher.hpp" #include "MainWindow.hpp" +#include "Log.hpp" using namespace std; namespace hdrmerge { -Launcher::Launcher() : automatic(false), help(false), previewWidth(nullptr) {} +Launcher::Launcher(int argc, char * argv[]) : argc(argc), argv(argv), help(false) { + Log::setOutputStream(cout); + wOptions.previewSize = 2; +} int Launcher::startGUI() { @@ -52,34 +55,33 @@ static std::ostream & operator<<(std::ostream & os, const QString & s) { } -class CoutProgressIndicator : public ProgressIndicator { -public: +struct CoutProgressIndicator : public ProgressIndicator { CoutProgressIndicator() : currentPercent(0) {} virtual void advance(int percent, const char * message, const char * arg) { - cout << '[' << setw(3) << (currentPercent = percent) << "%] "; + currentPercent = percent; if (arg) { - cout << QCoreApplication::translate("LoadSave", message).arg(arg) << endl; + Log::msg(Log::PROGRESS, '[', setw(3), currentPercent, "%] ", QCoreApplication::translate("LoadSave", message).arg(arg)); } else { - cout << QCoreApplication::translate("LoadSave", message) << endl; + Log::msg(Log::PROGRESS, '[', setw(3), currentPercent, "%] ", QCoreApplication::translate("LoadSave", message)); } } virtual int getPercent() const { return currentPercent; } -private: int currentPercent; }; int Launcher::automaticMerge() { - CoutProgressIndicator pi; + auto tr = [&] (const char * text) { return QCoreApplication::translate("LoadSave", text); }; + CoutProgressIndicator progress; ImageStack stack; - if (stack.load(options, pi)) { - int i = pi.getPercent() * (options.fileNames.size() + 1) / 100; + if (stack.load(options, progress)) { + int i = progress.getPercent() * (options.fileNames.size() + 1) / 100; if (i) { - cout << QCoreApplication::translate("LoadSave", "Error loading %1").arg(options.fileNames[i].c_str()) << endl; + cerr << tr("Error loading %1").arg(options.fileNames[i].c_str()) << endl; return 1; } } @@ -91,47 +93,54 @@ int Launcher::automaticMerge() { } else { wOptions.fileName = stack.buildOutputFileName() + ".dng"; } - cout << QCoreApplication::translate("LoadSave", "Writing result to %1").arg(wOptions.fileName.c_str()) << endl; - wOptions.previewSize = stack.getWidth(); - if (previewWidth != nullptr) { - if (string("half") == previewWidth) { - wOptions.previewSize /= 2; - } else if (string("none") == previewWidth) { - wOptions.previewSize = 0; - } - } - stack.save(wOptions, pi); + Log::msg(Log::PROGRESS, tr("Writing result to %1").arg(wOptions.fileName.c_str())); + wOptions.previewSize *= stack.getWidth(); + wOptions.previewSize /= 2; + stack.save(wOptions, progress); return 0; } -void Launcher::parseCommandLine(int argc, char * argv[]) { - argcGUI = argc; - argvGUI = argv; +void Launcher::parseCommandLine() { + auto tr = [&] (const char * text) { return QCoreApplication::translate("Help", text); }; for (int i = 1; i < argc; ++i) { if (string("-o") == argv[i]) { if (++i < argc) { wOptions.fileName = argv[i]; - automatic = true; } } else if (string("-m") == argv[i]) { if (++i < argc) { wOptions.maskFileName = argv[i]; } - } else if (string("-a") == argv[i]) { - automatic = true; + } else if (string("-v") == argv[i]) { + Log::setMinimumPriority(1); + } else if (string("-vv") == argv[i]) { + Log::setMinimumPriority(0); } else if (string("-n") == argv[i] || string("--no-align") == argv[i]) { options.align = false; } else if (string("--help") == argv[i]) { help = true; } else if (string("-b") == argv[i]) { if (++i < argc) { - int value = stoi(argv[i]); - if (value == 32 || value == 24 || value == 16) wOptions.bps = value; + try { + int value = stoi(argv[i]); + if (value == 32 || value == 24 || value == 16) wOptions.bps = value; + } catch (std::invalid_argument & e) { + cerr << tr("Invalid %1 parameter, using default.").arg("-b") << endl; + } } } else if (string("-p") == argv[i]) { if (++i < argc) { - previewWidth = argv[i]; + string previewWidth(argv[i]); + if (previewWidth == "full") { + wOptions.previewSize = 2; + } else if (previewWidth == "half") { + wOptions.previewSize = 1; + } else if (previewWidth == "none") { + wOptions.previewSize = 0; + } else { + cerr << tr("Invalid %1 parameter, using default.").arg("-p") << endl; + } } } else if (argv[i][0] != '-') { options.fileNames.push_back(argv[i]); @@ -144,27 +153,49 @@ void Launcher::showHelp() { auto tr = [&] (const char * text) { return QCoreApplication::translate("Help", text); }; cout << tr("Usage") << ": HDRMerge [--help] [OPTIONS ...] [RAW_FILES ...]" << endl; cout << tr("Merges RAW_FILES into an HDR DNG raw image.") << endl; + cout << tr("If neither -a nor -o options are given, the GUI will be presented.") << endl; cout << endl; cout << tr("Options:") << endl; cout << " " << "--help " << tr("Shows this message.") << endl; - cout << " " << "-a " << tr("Calculates the output file name automatically. Ignores -o.") << endl; + cout << " " << "-a " << tr("Calculates the output file name automatically.") << endl; cout << " " << "-b BPS " << tr("Bits per sample, can be 16, 24 or 32.") << endl; cout << " " << "-m MASK_FILE " << tr("Saves the mask to MASK_FILE as a PNG image.") << endl; cout << " " << "-n|--no-align " << tr("Do not auto-align source images.") << endl; cout << " " << "-o OUT_FILE " << tr("Sets OUT_FILE as the output file name.") << endl; cout << " " << "-p full|half|none " << tr("Preview width.") << endl; + cout << " " << "-v " << tr("Verbose mode.") << endl; + cout << " " << "-vv " << tr("Debug mode.") << endl; cout << " " << "RAW_FILES " << tr("The input raw files.") << endl; + cout << tr("If similar options are specified, only the last one prevails.") << endl; +} + + +bool Launcher::checkGUI() { + int numFiles = 0; + bool result = true; + for (int i = 1; i < argc; ++i) { + if (string("-o") == argv[i]) { + if (++i < argc) { + result = false; + } + } else if (string("-a") == argv[i]) { + result = false; + } else if (string("--help") == argv[i]) { + return false; + } else if (argv[i][0] != '-') { + numFiles++; + } + } + return result || numFiles == 0; } int Launcher::run() { - bool useGUI = !help && (!automatic || options.fileNames.empty()); + bool useGUI = checkGUI(); - QApplication app(argcGUI, argvGUI, useGUI); + QApplication app(argc, argv, useGUI); // Settings - QCoreApplication::setOrganizationName("JaviSoft"); - QCoreApplication::setOrganizationDomain("javisoft.com"); QCoreApplication::setApplicationName("HdrMerge"); // Translation @@ -177,6 +208,8 @@ int Launcher::run() { appTranslator.load("hdrmerge_" + QLocale::system().name(), ":/translators"); app.installTranslator(&appTranslator); + parseCommandLine(); + if (help) { showHelp(); return 0; diff --git a/Launcher.hpp b/Launcher.hpp index 5d57ad7..78350e8 100644 --- a/Launcher.hpp +++ b/Launcher.hpp @@ -31,24 +31,23 @@ namespace hdrmerge { class Launcher { public: - Launcher(); + Launcher(int argc, char * argv[]); - void parseCommandLine(int argc, char * argv[]); + void parseCommandLine(); int run(); private: + bool checkGUI(); int startGUI(); int automaticMerge(); void showHelp(); - int argcGUI; - char ** argvGUI; + int argc; + char ** argv; LoadOptions options; SaveOptions wOptions; - bool automatic; bool help; - char * previewWidth; }; } // namespace hdrmerge diff --git a/Log.hpp b/Log.hpp new file mode 100644 index 0000000..057d20b --- /dev/null +++ b/Log.hpp @@ -0,0 +1,76 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#ifndef _LOG_HPP_ +#define _LOG_HPP_ + +#include + +namespace hdrmerge { + +class Log { +public: + enum { + DEBUG = 0, + PROGRESS = 1, + } Priority; + + template + static void msg(int priority, const Args &... params) { + Log & l = getInstance(); + if (l.out && priority >= l.minPriority) { + l.output(params...); + *l.out << std::endl; + } + } + + static void setMinimumPriority(int p) { + getInstance().minPriority = p; + } + + static void setOutputStream(std::ostream & o) { + getInstance().out = &o; + } + +private: + int minPriority; + std::ostream * out; + + Log() : minPriority(2), out(nullptr) {} + + static Log & getInstance() { + static Log instance; + return instance; + } + + void output() {} + + template + void output(const T & value, const Args &... args) { + *out << value; + output(args...); + } +}; + +} // namespace hdrmerge + +#endif // _LOG_HPP_ diff --git a/MetaData.cpp b/MetaData.cpp index 0cdef14..f6dade0 100644 --- a/MetaData.cpp +++ b/MetaData.cpp @@ -24,6 +24,7 @@ #include #include #include +#include "Log.hpp" #include "MetaData.hpp" using namespace hdrmerge; using namespace std; @@ -94,14 +95,10 @@ void MetaData::adjustWhite() { void MetaData::dumpInfo() const { // Show idata - cout << "Image " << fileName << ", " << width << 'x' << height << ", by " << maker << ", model " << model << endl; - cout << colors << " colors with mask " << hex << filters << dec << ", " << cdesc << ", " << max << " max value" << endl; + Log::msg(Log::DEBUG, "Image ", fileName, ", ", width, 'x', height, ", by ", maker, ", model ", model); + Log::msg(Log::DEBUG, colors, " colors with mask ", hex, filters, dec, ", ", cdesc, ", ", max, " max value"); // Show other - cout << "ISO:" << isoSpeed << " shutter:1/" << (1.0/shutter) << " aperture:f" << aperture << " exposure:" << logExp() << " steps" << endl; + Log::msg(Log::DEBUG, "ISO:", isoSpeed, " shutter:1/", (1.0/shutter), " aperture:f", aperture, " exposure:", logExp(), " steps"); // Show matrices - cout << "White balance:"; - for (int c = 0; c < 3; ++c) { - cout << " " << camMul[c]; - } - cout << endl; + Log::msg(Log::DEBUG, "White balance: ", camMul[0], ' ', camMul[1], ' ', camMul[2], ' ', camMul[3]); } diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index 7a5fe44..fa2becf 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -24,8 +24,8 @@ Establece OUT_FILE como el nombre del fichero de salida. - Calculates the output file name automatically. Ignores -o. - Calcula el nombre del fichero de salida automáticamente. Ignora -o. + Calculates the output file name automatically. + Calcula el nombre del fichero de salida automáticamente. Bits per sample, can be 16, 24 or 32. @@ -47,6 +47,26 @@ Do not auto-align source images. No auto-alinear las imágenes de origen. + + Verbose mode. + Mostrar información de progreso. + + + Debug mode. + Modo depuración. + + + If similar options are specified, only the last one prevails. + Si se dan opciones similares, sólo la ultima de ellas se tiene en cuenta. + + + Invalid %1 parameter, using default. + Parámetro %1 inválido, se usará el valor por defecto. + + + If neither -a nor -o options are given, the GUI will be presented. + Si no se dan las opciones -a o -o, se mostrará la GUI. + LoadSave diff --git a/main.cpp b/main.cpp index e4eaa5a..dae8823 100644 --- a/main.cpp +++ b/main.cpp @@ -23,7 +23,6 @@ #include "Launcher.hpp" int main(int argc, char * argv[]) { - hdrmerge::Launcher launcher; - launcher.parseCommandLine(argc, argv); + hdrmerge::Launcher launcher(argc, argv); return launcher.run(); } From 74663d7d446ff7b469edef8431080a7a9184b641 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Tue, 13 May 2014 19:55:48 +0100 Subject: [PATCH 02/26] Fix stupid for loop --- Image.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Image.cpp b/Image.cpp index e9f4a6d..982112f 100644 --- a/Image.cpp +++ b/Image.cpp @@ -46,10 +46,8 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { uint16_t v = rawImage[rrow*md->rawWidth + rcol]; rawPixels[row*width + col] = v; brightness += v; - for (int c = 0; c < 4; ++c) { - if (v > maxPerColor[md->FC(row, col)]) { - maxPerColor[md->FC(row, col)] = v; - } + if (v > maxPerColor[md->FC(row, col)]) { + maxPerColor[md->FC(row, col)] = v; } } } From b2b768607da3ebea42b0c4f9569bb8e7c3f119ca Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 7 May 2014 21:03:32 +0100 Subject: [PATCH 03/26] US28 Start creating the IFD structures --- DngWriter.cpp | 106 +++++++++++++++++++++++++++++++++++++++++--------- DngWriter.hpp | 3 ++ 2 files changed, 91 insertions(+), 18 deletions(-) diff --git a/DngWriter.cpp b/DngWriter.cpp index 226147d..6721684 100644 --- a/DngWriter.cpp +++ b/DngWriter.cpp @@ -314,30 +314,100 @@ void DngWriter::buildIndexImage() { void DngWriter::write(const string & filename) { - progress.advance(0, "Initialize negative"); - dng_xmp_sdk::InitializeSDK(); +// progress.advance(0, "Initialize negative"); +// dng_xmp_sdk::InitializeSDK(); +// +// buildNegative(); +// +// progress.advance(25, "Rendering image"); +// AutoPtr imageData(new DngFloatImage(stack.getWidth(), stack.getHeight(), memalloc)); +// stack.compose(((DngFloatImage *)imageData.Get())->getImageBuffer()); +// negative.SetStage1Image(imageData); +// negative.SetRawFloatBitDepth(bps); +// +// if (!indexFile.isEmpty()) +// buildIndexImage(); +// +// progress.advance(50, "Rendering preview"); +// buildPreviewList(); +// +// progress.advance(75, "Writing output"); +// dng_image_writer writer; +// dng_file_stream filestream(filename.c_str(), true); +// writer.WriteDNG(host, filestream, negative, &previewList); +// +// dng_xmp_sdk::TerminateSDK(); +// progress.advance(100, "Done writing!"); + + file.open(filename, ios_base::binary); + createIFD(); + file.close(); +} + + +struct TiffHeader { + union { + uint32_t endian; + struct { + uint16_t endian; + uint16_t magic; + } sep; + }; + uint32_t offset; + // It sets the first two bytes to their correct value, given the architecture + TiffHeader() : endian(0x4D4D4949), offset(8) { + sep.magic = 42; + } +}; - buildNegative(); - progress.advance(25, "Rendering image"); - AutoPtr imageData(new DngFloatImage(stack.getWidth(), stack.getHeight(), memalloc)); - stack.compose(((DngFloatImage *)imageData.Get())->getImageBuffer()); - negative.SetStage1Image(imageData); - negative.SetRawFloatBitDepth(bps); +struct DirEntry { + uint16_t tag; + uint16_t type; + uint32_t count; + union { + uint32_t offset; + uint32_t value; + }; + int bytesPerValue() const { + static int bytesPerValue[12] = + { 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 }; + return bytesPerValue[type]; + } + uint32_t dataSize() const { + return count * bytesPerValue(); + } +}; - if (!indexFile.isEmpty()) - buildIndexImage(); - progress.advance(50, "Rendering preview"); - buildPreviewList(); +class IFD { +public: + void addEntry(const DirEntry & entry, std::initializer_list data) { + entries.push_back(entry); + if (entry.dataSize() > 4) { + entries.back().offset = entryData.size(); + entryData.insert(entryData.end(), data); + if (entryData.size() & 1) { + entryData.push_back(0); + } + } + } + + IFD() : offset(0) {} + +private: + uint32_t offset; + std::vector entries; + std::vector entryData; +}; + + +struct TiffFile { + TiffHeader header; +}; - progress.advance(75, "Writing output"); - dng_image_writer writer; - dng_file_stream filestream(filename.c_str(), true); - writer.WriteDNG(host, filestream, negative, &previewList); +void DngWriter::createIFD() { - dng_xmp_sdk::TerminateSDK(); - progress.advance(100, "Done writing!"); } diff --git a/DngWriter.hpp b/DngWriter.hpp index bc4ae70..2559485 100644 --- a/DngWriter.hpp +++ b/DngWriter.hpp @@ -23,6 +23,7 @@ #ifndef _DNGWRITER_HPP_ #define _DNGWRITER_HPP_ +#include #include #include #include "config.h" @@ -64,6 +65,7 @@ class DngWriter { }; ProgressIndicator & progress; + std::ofstream file; dng_memory_allocator memalloc; BasicHost host; DummyNegative negative; @@ -81,6 +83,7 @@ class DngWriter { void buildExifMetadata(); void addJpegPreview(); void buildIndexImage(); + void createIFD(); }; } // namespace hdrmerge From cee88e054da5ad391af9e5f3d3bd101807c5b03d Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sat, 10 May 2014 17:08:43 +0100 Subject: [PATCH 04/26] US28: New DngFloatWriter class - Move new code to a different class, DngFloatWriter. - Add support to write the main IFD with some example tags. --- CMakeLists.txt | 2 +- DngFloatWriter.cpp | 155 +++++++++++++++++++++++++++++++++++++++++++++ DngFloatWriter.hpp | 109 +++++++++++++++++++++++++++++++ DngWriter.cpp | 106 ++++++------------------------- DngWriter.hpp | 3 - 5 files changed, 283 insertions(+), 92 deletions(-) create mode 100644 DngFloatWriter.cpp create mode 100644 DngFloatWriter.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 274dfbc..87e8eaf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -67,7 +67,7 @@ include_directories("${PROJECT_BINARY_DIR}") # Sources and headers set(hdrmerge_sources Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp - Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngWriter.cpp + Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngWriter.cpp DngFloatWriter.cpp camxyz.cpp exiv2dngstreamio.cpp exiv2meta.cpp) set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp new file mode 100644 index 0000000..0de4838 --- /dev/null +++ b/DngFloatWriter.cpp @@ -0,0 +1,155 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#include +#include +#include +#include "config.h" +#include "DngFloatWriter.hpp" +using namespace std; + + +namespace hdrmerge { + +DngFloatWriter::DngFloatWriter(const ImageStack & s, ProgressIndicator & pi) + : progress(pi), stack(s), appVersion("HDRMerge " HDRMERGE_VERSION_STRING), + previewWidth(s.getWidth()), bps(16) {} + + +enum { + DNGVERSION = 50706, + DNGBACKVERSION = 50707, + CALIBRATIONILLUMINANT = 50778, + COLORMATRIX = 50721, + PROFILENAME = 50936, +} Tag; + + +enum { + BYTE = 1, + ASCII, + SHORT, + LONG, + RATIONAL, + SBYTE, + UNDEFINED, + SSHORT, + SLONG, + SRATIONAL, + FLOAT, + DOUBLE +} Type; + + +void DngFloatWriter::IFD::addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data) { + const uint8_t * castedData = reinterpret_cast(data); + entries.push_back(DirEntry({tag, type, count, 0})); + DirEntry & entry = entries.back(); + size_t dataSize = entry.dataSize(); + if (dataSize > 4) { + entry.offset = entryData.size(); + for (size_t i = 0; i < dataSize; ++i) + entryData.push_back(castedData[i]); + if (entryData.size() & 1) { + entryData.push_back(0); + } + } else { + std::copy_n(castedData, dataSize, (uint8_t *)&entry.offset); + } +} + +void DngFloatWriter::IFD::write(ofstream & file, bool hasNext) { + uint16_t numEntries = entries.size(); + uint32_t offsetData = (uint32_t)file.tellp() + 12*numEntries + 6; + sort(entries.begin(), entries.end()); + uint32_t offsetNext = hasNext ? offsetData + entryData.size() : 0; + for (auto & entry : entries) { + if (entry.dataSize() > 4) { + entry.offset += offsetData; + } + } + file.write((const char *)&numEntries, 2); + file.write((const char *)&entries[0], 12*numEntries); + file.write((const char *)&offsetNext, 4); + file.write((const char *)&entryData[0], entryData.size()); +} + + +size_t DngFloatWriter::IFD::length() const { + return 6 + 12*entries.size() + entryData.size(); +} + + + +void DngFloatWriter::createIFD() { + uint8_t dngVersion[] = { 1, 4, 0, 0 }; + mainIFD.addEntry(DNGVERSION, BYTE, 4, dngVersion); + mainIFD.addEntry(DNGBACKVERSION, BYTE, 4, dngVersion); + // Thumbnail set thumbnail->AddTagSet (mainIFD) + + // Profile + const MetaData & md = stack.getImage(0).getMetaData(); + mainIFD.addEntry(CALIBRATIONILLUMINANT, SHORT, 21); // D65 + string profName(md.maker + " " + md.model); + mainIFD.addEntry(PROFILENAME, ASCII, profName.length() + 1, profName.c_str()); + int32_t colorMatrix[18]; + for (int im = 0, id = 0; im < 9; ++im, ++id) { + colorMatrix[id] = std::round(md.camXyz[0][im] * 10000.0f); + colorMatrix[++id] = 10000; + } + mainIFD.addEntry(COLORMATRIX, SRATIONAL, 9, colorMatrix); + +} + + +struct TiffHeader { + union { + uint32_t endian; + struct { + uint16_t endian; + uint16_t magic; + } sep; + }; + uint32_t offset; + // It sets the first two bytes to their correct value, given the architecture + TiffHeader() : endian(0x4D4D4949), offset(8) { sep.magic = 42; } + void write(ofstream & file) const { file.write((const char *)this, 8); } +}; + + +void DngFloatWriter::write(const string & filename) { + file.open(filename, ios_base::binary); + + // Create IFD, maybe subIFDs too + createIFD(); + // Measure IFDs size plus header + size_t dataOffset = 8 + mainIFD.length() + rawIFD.length(); + // Seek file to that offset + // Write previews + // Write raw data + // Seek file to origin, write IFDs + TiffHeader().write(file); + mainIFD.write(file, false); + file.close(); +} + +} // namespace hdrmerge diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp new file mode 100644 index 0000000..fb8ef32 --- /dev/null +++ b/DngFloatWriter.hpp @@ -0,0 +1,109 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#ifndef _DNGFLOATWRITER_HPP_ +#define _DNGFLOATWRITER_HPP_ + +#include +#include +#include +#include +#include "config.h" +#include "ImageStack.hpp" +#include "ProgressIndicator.hpp" + +namespace hdrmerge { + +class DngFloatWriter { +public: + DngFloatWriter(const ImageStack & s, ProgressIndicator & pi); + + void setPreviewWidth(size_t w) { + previewWidth = w; + } + void setBitsPerSample(int b) { + bps = b; + } + void setIndexFileName(const QString & name) { + indexFile = name; + } + void write(const std::string & filename); + +private: + struct DirEntry { + uint16_t tag; + uint16_t type; + uint32_t count; + uint32_t offset; + int bytesPerValue() const { + static int bytesPerValue[12] = + { 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 }; + return bytesPerValue[type - 1]; + } + uint32_t dataSize() const { + return count * bytesPerValue(); + } + bool operator<(const DirEntry & r) const { + return tag < r.tag; + } + }; + + class IFD { + public: + template void addEntry(uint16_t tag, uint16_t type, const T & value) { + if (sizeof(T) > 4) { + addEntry(tag, type, 1, &value); + } else { + union { + uint32_t longValue; + T value; + } leftJustify; + leftJustify.longValue = 0; + leftJustify.value = value; + entries.push_back(DirEntry({tag, type, 1, leftJustify.longValue})); + } + } + void addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data); + void write(std::ofstream & file, bool hasNext); + size_t length() const; + + private: + std::vector entries; + std::vector entryData; + }; + + ProgressIndicator & progress; + std::ofstream file; + const ImageStack & stack; + const std::string appVersion; + IFD mainIFD, rawIFD, previewIFD; + + size_t previewWidth; + int bps; + QString indexFile; + + void createIFD(); +}; + +} // namespace hdrmerge + +#endif // _DNGFLOATWRITER_HPP_ diff --git a/DngWriter.cpp b/DngWriter.cpp index 6721684..226147d 100644 --- a/DngWriter.cpp +++ b/DngWriter.cpp @@ -314,100 +314,30 @@ void DngWriter::buildIndexImage() { void DngWriter::write(const string & filename) { -// progress.advance(0, "Initialize negative"); -// dng_xmp_sdk::InitializeSDK(); -// -// buildNegative(); -// -// progress.advance(25, "Rendering image"); -// AutoPtr imageData(new DngFloatImage(stack.getWidth(), stack.getHeight(), memalloc)); -// stack.compose(((DngFloatImage *)imageData.Get())->getImageBuffer()); -// negative.SetStage1Image(imageData); -// negative.SetRawFloatBitDepth(bps); -// -// if (!indexFile.isEmpty()) -// buildIndexImage(); -// -// progress.advance(50, "Rendering preview"); -// buildPreviewList(); -// -// progress.advance(75, "Writing output"); -// dng_image_writer writer; -// dng_file_stream filestream(filename.c_str(), true); -// writer.WriteDNG(host, filestream, negative, &previewList); -// -// dng_xmp_sdk::TerminateSDK(); -// progress.advance(100, "Done writing!"); - - file.open(filename, ios_base::binary); - createIFD(); - file.close(); -} - - -struct TiffHeader { - union { - uint32_t endian; - struct { - uint16_t endian; - uint16_t magic; - } sep; - }; - uint32_t offset; - // It sets the first two bytes to their correct value, given the architecture - TiffHeader() : endian(0x4D4D4949), offset(8) { - sep.magic = 42; - } -}; + progress.advance(0, "Initialize negative"); + dng_xmp_sdk::InitializeSDK(); + buildNegative(); -struct DirEntry { - uint16_t tag; - uint16_t type; - uint32_t count; - union { - uint32_t offset; - uint32_t value; - }; - int bytesPerValue() const { - static int bytesPerValue[12] = - { 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 }; - return bytesPerValue[type]; - } - uint32_t dataSize() const { - return count * bytesPerValue(); - } -}; + progress.advance(25, "Rendering image"); + AutoPtr imageData(new DngFloatImage(stack.getWidth(), stack.getHeight(), memalloc)); + stack.compose(((DngFloatImage *)imageData.Get())->getImageBuffer()); + negative.SetStage1Image(imageData); + negative.SetRawFloatBitDepth(bps); + if (!indexFile.isEmpty()) + buildIndexImage(); -class IFD { -public: - void addEntry(const DirEntry & entry, std::initializer_list data) { - entries.push_back(entry); - if (entry.dataSize() > 4) { - entries.back().offset = entryData.size(); - entryData.insert(entryData.end(), data); - if (entryData.size() & 1) { - entryData.push_back(0); - } - } - } - - IFD() : offset(0) {} - -private: - uint32_t offset; - std::vector entries; - std::vector entryData; -}; - - -struct TiffFile { - TiffHeader header; -}; + progress.advance(50, "Rendering preview"); + buildPreviewList(); -void DngWriter::createIFD() { + progress.advance(75, "Writing output"); + dng_image_writer writer; + dng_file_stream filestream(filename.c_str(), true); + writer.WriteDNG(host, filestream, negative, &previewList); + dng_xmp_sdk::TerminateSDK(); + progress.advance(100, "Done writing!"); } diff --git a/DngWriter.hpp b/DngWriter.hpp index 2559485..bc4ae70 100644 --- a/DngWriter.hpp +++ b/DngWriter.hpp @@ -23,7 +23,6 @@ #ifndef _DNGWRITER_HPP_ #define _DNGWRITER_HPP_ -#include #include #include #include "config.h" @@ -65,7 +64,6 @@ class DngWriter { }; ProgressIndicator & progress; - std::ofstream file; dng_memory_allocator memalloc; BasicHost host; DummyNegative negative; @@ -83,7 +81,6 @@ class DngWriter { void buildExifMetadata(); void addJpegPreview(); void buildIndexImage(); - void createIFD(); }; } // namespace hdrmerge From fed823cf0627c25c6c2fddd01bca6926e9ce993c Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sun, 11 May 2014 02:24:32 +0100 Subject: [PATCH 05/26] US28: Add raw data to the new writer. - The new writer writes all the required tags and the raw data. No previews yet. - Fixed orientation value in MetaData. --- DngFloatWriter.cpp | 343 +++++++++++++++++++++++++++++++++++++++------ DngFloatWriter.hpp | 65 +++++++-- MetaData.cpp | 2 + MetaData.hpp | 2 +- config.h.in | 3 +- 5 files changed, 358 insertions(+), 57 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 0de4838..bcadf1e 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include "config.h" #include "DngFloatWriter.hpp" using namespace std; @@ -32,51 +33,34 @@ namespace hdrmerge { DngFloatWriter::DngFloatWriter(const ImageStack & s, ProgressIndicator & pi) : progress(pi), stack(s), appVersion("HDRMerge " HDRMERGE_VERSION_STRING), - previewWidth(s.getWidth()), bps(16) {} + width(stack.getWidth()), height(stack.getHeight()), previewWidth(width), bps(16) {} -enum { - DNGVERSION = 50706, - DNGBACKVERSION = 50707, - CALIBRATIONILLUMINANT = 50778, - COLORMATRIX = 50721, - PROFILENAME = 50936, -} Tag; - - -enum { - BYTE = 1, - ASCII, - SHORT, - LONG, - RATIONAL, - SBYTE, - UNDEFINED, - SSHORT, - SLONG, - SRATIONAL, - FLOAT, - DOUBLE -} Type; +void DngFloatWriter::IFD::addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data) { + uint32_t newSize = entryData.size(); + DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, count, newSize}))); + uint32_t dataSize = entry->dataSize(); + if (dataSize > 4) { + newSize += dataSize; + if (newSize & 1) + ++newSize; + entryData.resize(newSize); + } + setValue(entry, data); +} -void DngFloatWriter::IFD::addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data) { +void DngFloatWriter::IFD::setValue(DirEntry * entry, const void * data) { const uint8_t * castedData = reinterpret_cast(data); - entries.push_back(DirEntry({tag, type, count, 0})); - DirEntry & entry = entries.back(); - size_t dataSize = entry.dataSize(); + size_t dataSize = entry->dataSize(); if (dataSize > 4) { - entry.offset = entryData.size(); - for (size_t i = 0; i < dataSize; ++i) - entryData.push_back(castedData[i]); - if (entryData.size() & 1) { - entryData.push_back(0); - } + std::copy_n(castedData, dataSize, &entryData[entry->offset]); } else { - std::copy_n(castedData, dataSize, (uint8_t *)&entry.offset); + std::copy_n(castedData, dataSize, (uint8_t *)&entry->offset); } } + void DngFloatWriter::IFD::write(ofstream & file, bool hasNext) { uint16_t numEntries = entries.size(); uint32_t offsetData = (uint32_t)file.tellp() + 12*numEntries + 6; @@ -99,8 +83,54 @@ size_t DngFloatWriter::IFD::length() const { } +DngFloatWriter::DirEntry * DngFloatWriter::IFD::getEntry(uint16_t tag) { + auto it = entries.begin(); + while (it != entries.end() && it->tag != tag) it++; + return it == entries.end() ? nullptr : &(*it); +} + + +enum { + DNGVERSION = 50706, + DNGBACKVERSION = 50707, + + CALIBRATIONILLUMINANT = 50778, + COLORMATRIX = 50721, + PROFILENAME = 50936, -void DngFloatWriter::createIFD() { + NEWSUBFILETYPE = 254, + IMAGEWIDTH = 256, + IMAGELENGTH = 257, + PHOTOINTERPRETATION = 262, + SAMPLESPERPIXEL = 277, + BITSPERSAMPLE = 258, + FILLORDER = 266, + + TILEWIDTH = 322, + TILELENGTH = 323, + TILEOFFSETS = 324, + TILEBYTES = 325, + + PLANARCONFIG = 284, + COMPRESSION = 259, + PREDICTOR = 317, + SAMPLEFORMAT = 339, + WHITELEVEL = 50717, + CFAPATTERNDIM = 33421, + CFAPATTERN = 33422, + CFAPLANECOLOR = 50710, + CFALAYOUT = 50711, + + ANALOGBALANCE = 50727, + CAMERANEUTRAL = 50728, + ORIENTATION = 274, + UNIQUENAME = 50708, + SUBIFDS = 330, + +} Tag; + + +void DngFloatWriter::createMainIFD() { uint8_t dngVersion[] = { 1, 4, 0, 0 }; mainIFD.addEntry(DNGVERSION, BYTE, 4, dngVersion); mainIFD.addEntry(DNGBACKVERSION, BYTE, 4, dngVersion); @@ -118,6 +148,78 @@ void DngFloatWriter::createIFD() { } mainIFD.addEntry(COLORMATRIX, SRATIONAL, 9, colorMatrix); + // Color + uint32_t analogBalance[] = { 1, 1, 1, 1, 1, 1 }; + mainIFD.addEntry(ANALOGBALANCE, RATIONAL, 3, analogBalance); + double minWb = std::min(md.camMul[0], std::min(md.camMul[1], md.camMul[2])); + double wb[] = { minWb/md.camMul[0], minWb/md.camMul[1], minWb/md.camMul[2] }; + uint32_t cameraNeutral[] = { + (uint32_t)std::round(1000000.0 * wb[0]), 1000000, + (uint32_t)std::round(1000000.0 * wb[1]), 1000000, + (uint32_t)std::round(1000000.0 * wb[2]), 1000000}; + mainIFD.addEntry(CAMERANEUTRAL, RATIONAL, 3, cameraNeutral); + + mainIFD.addEntry(ORIENTATION, SHORT, md.flip); + string cameraName(md.maker + " " + md.model); + mainIFD.addEntry(UNIQUENAME, ASCII, cameraName.length() + 1, &cameraName[0]); + // TODO: Add Digest and Unique ID + // TODO: Add XMP and Exif and private data + mainIFD.addEntry(SUBIFDS, LONG, 1); +} + + +void DngFloatWriter::calculateTiles() { + int bytesPerTile = 512 * 1024; + int cellSize = 16; + size_t bytesPerSample = bps >> 3; + size_t samplesPerTile = bytesPerTile / bytesPerSample; + size_t tileSide = std::round(std::sqrt(samplesPerTile)); + tileWidth = std::min(width, tileSide); + tilesAcross = (width + tileWidth - 1) / tileWidth;; + tileWidth = (width + tilesAcross - 1) / tilesAcross; + tileWidth = ((tileWidth + cellSize - 1) / cellSize) * cellSize; + tileLength = std::min(samplesPerTile / tileWidth, height); + tilesDown = (height + tileLength - 1) / tileLength; + tileLength = (height + tilesDown - 1) / tilesDown; + tileLength = ((tileLength + cellSize - 1) / cellSize) * cellSize; +} + + +void DngFloatWriter::createRawIFD() { + rawIFD.addEntry(NEWSUBFILETYPE, LONG, 0); + rawIFD.addEntry(IMAGEWIDTH, LONG, width); + rawIFD.addEntry(IMAGELENGTH, LONG, height); + rawIFD.addEntry(SAMPLESPERPIXEL, SHORT, 1); + rawIFD.addEntry(BITSPERSAMPLE, SHORT, bps); + if (bps == 24) { + rawIFD.addEntry(FILLORDER, SHORT, 1); + } + rawIFD.addEntry(PLANARCONFIG, SHORT, 1); + rawIFD.addEntry(COMPRESSION, SHORT, 8); // Deflate + rawIFD.addEntry(PREDICTOR, SHORT, 34894); //FP2X + rawIFD.addEntry(SAMPLEFORMAT, SHORT, 3); // Floating Point + + calculateTiles(); + uint32_t numTiles = tilesAcross * tilesDown; + uint32_t buffer[numTiles]; + rawIFD.addEntry(TILEWIDTH, LONG, tileWidth); + rawIFD.addEntry(TILELENGTH, LONG, tileLength); + rawIFD.addEntry(TILEOFFSETS, LONG, numTiles, buffer); + rawIFD.addEntry(TILEBYTES, LONG, numTiles, buffer); + + rawIFD.addEntry(WHITELEVEL, SHORT, 1); + rawIFD.addEntry(PHOTOINTERPRETATION, SHORT, 32803); // CFA + uint16_t cfaPatternDim[] = { 2, 2 }; + rawIFD.addEntry(CFAPATTERNDIM, SHORT, 2, cfaPatternDim); + const MetaData & md = stack.getImage(0).getMetaData(); + uint8_t cfaPattern[] = { md.FC(0, 0), md.FC(0, 1), md.FC(1, 0), md.FC(1, 1) }; + for (uint8_t & i : cfaPattern) { + if (i == 3) i = 1; + } + rawIFD.addEntry(CFAPATTERN, BYTE, 4, cfaPattern); + uint8_t cfaPlaneColor[] = { 0, 1, 2 }; + rawIFD.addEntry(CFAPLANECOLOR, BYTE, 3, cfaPlaneColor); + rawIFD.addEntry(CFALAYOUT, SHORT, 1); } @@ -139,17 +241,172 @@ struct TiffHeader { void DngFloatWriter::write(const string & filename) { file.open(filename, ios_base::binary); - // Create IFD, maybe subIFDs too - createIFD(); - // Measure IFDs size plus header - size_t dataOffset = 8 + mainIFD.length() + rawIFD.length(); - // Seek file to that offset + createMainIFD(); + createRawIFD(); + size_t rawIFDOffset = 8 + mainIFD.length(); + mainIFD.setValue(SUBIFDS, rawIFDOffset); + size_t dataOffset = rawIFDOffset + rawIFD.length(); + file.seekp(dataOffset); // Write previews - // Write raw data - // Seek file to origin, write IFDs + writeRawData(); + file.seekp(0); TiffHeader().write(file); mainIFD.write(file, false); + rawIFD.write(file, false); file.close(); } + +static void encodeFPDeltaRow(Bytef * src, Bytef * dst, size_t tileWidth, size_t realTileWidth, int bytesps, int factor) { + // Reorder bytes into the image + // 16 and 32-bit versions depend on local architecture, 24-bit does not + if (bytesps == 3) { + for (size_t col = 0; col < tileWidth; ++col) { + dst[col] = src[col*3]; + dst[col + realTileWidth] = src[col*3 + 1]; + dst[col + realTileWidth*2] = src[col*3 + 2]; + } + } else { + if (((union { uint32_t x; uint8_t c; }){1}).c) { + for (size_t col = 0; col < tileWidth; ++col) { + for (size_t byte = 0; byte < bytesps; ++byte) + dst[col + realTileWidth*(bytesps-byte-1)] = src[col*bytesps + byte]; // Little endian + } + } else { + for (size_t col = 0; col < tileWidth; ++col) { + for (size_t byte = 0; byte < bytesps; ++byte) + dst[col + realTileWidth*byte] = src[col*bytesps + byte]; + } + } + } + // EncodeDeltaBytes + for (size_t col = realTileWidth*bytesps - 1; col >= factor; --col) { + dst[col] -= dst[col - factor]; + } +} + + +// From DNG SDK dng_utils.h +inline uint16_t DNG_FloatToHalf(uint32_t i) { + int32_t sign = (i >> 16) & 0x00008000; + int32_t exponent = ((i >> 23) & 0x000000ff) - (127 - 15); + int32_t mantissa = i & 0x007fffff; + if (exponent <= 0) { + if (exponent < -10) { + return (uint16_t)sign; + } + mantissa = (mantissa | 0x00800000) >> (1 - exponent); + if (mantissa & 0x00001000) + mantissa += 0x00002000; + return (uint16_t)(sign | (mantissa >> 13)); + } else if (exponent == 0xff - (127 - 15)) { + if (mantissa == 0) { + return (uint16_t)(sign | 0x7c00); + } else { + return (uint16_t)(sign | 0x7c00 | (mantissa >> 13)); + } + } + if (mantissa & 0x00001000) { + mantissa += 0x00002000; + if (mantissa & 0x00800000) { + mantissa = 0; // overflow in significand, + exponent += 1; // adjust exponent + } + } + if (exponent > 30) { + return (uint16_t)(sign | 0x7c00); // infinity with the same sign as f. + } + return (uint16_t)(sign | (exponent << 10) | (mantissa >> 13)); +} + + +inline void DNG_FloatToFP24(uint32_t input, uint8_t *output) { + int32_t exponent = (int32_t) ((input >> 23) & 0xFF) - 128; + int32_t mantissa = input & 0x007FFFFF; + if (exponent == 127) { + if (mantissa != 0x007FFFFF && ((mantissa >> 7) == 0xFFFF)) { + mantissa &= 0x003FFFFF; // knock out msb to make it a NaN + } + } else if (exponent > 63) { + exponent = 63; + mantissa = 0x007FFFFF; + } else if (exponent <= -64) { + if (exponent >= -79) { + mantissa = (mantissa | 0x00800000) >> (-63 - exponent); + } else { + mantissa = 0; + } + exponent = -64; + } + output [0] = (uint8_t)(((input >> 24) & 0x80) | (uint32_t) (exponent + 64)); + output [1] = (mantissa >> 15) & 0x00FF; + output [2] = (mantissa >> 7) & 0x00FF; +} + + +static void compressFloats(Bytef * dst, int tileWidth, int bytesps) { + if (bytesps == 2) { + uint16_t * dst16 = (uint16_t *) dst; + uint32_t * dst32 = (uint32_t *) dst; + for (int index = 0; index < tileWidth; ++index) { + dst16[index] = DNG_FloatToHalf(dst32[index]); + } + } else if (bytesps == 3) { + uint8_t * dst8 = (uint8_t *) dst; + uint32_t * dst32 = (uint32_t *) dst; + for (int index = 0; index < tileWidth; ++index) { + DNG_FloatToFP24(dst32[index], dst8); + dst8 += 3; + } + } +} + + +void DngFloatWriter::writeRawData() { + unique_ptr rawData(new float[width * height]); + stack.compose(rawData.get()); + size_t tileCount = tilesAcross * tilesDown; + uint32_t tileOffsets[tileCount]; + uint32_t tileBytes[tileCount]; + uLongf dstLen = tileWidth * tileLength * 4; + int bytesps = bps >> 3; + +// #pragma omp parallel + { + Bytef cBuffer[dstLen]; + Bytef uBuffer[dstLen]; + +// #pragma omp for collapse(2) + for (size_t y = 0; y < height; y += tileLength) { + for (size_t x = 0; x < width; x += tileWidth) { + size_t t = (y / tileLength) * tilesAcross + (x / tileWidth); + fill_n(uBuffer, dstLen, 0); + size_t thisTileLength = y + tileLength > height ? height - y : tileLength; + size_t thisTileWidth = x + tileWidth > width ? width - x : tileWidth; + for (size_t row = 0; row < thisTileLength; ++row) { + Bytef * dst = uBuffer + row*tileWidth*bytesps; + Bytef * src = (Bytef *)&rawData[(y+row)*width + x]; + compressFloats(src, thisTileWidth, bytesps); + encodeFPDeltaRow(src, dst, thisTileWidth, tileWidth, bytesps, 2); + } + uLongf conpressedLength = dstLen; + int err = compress(cBuffer, &conpressedLength, uBuffer, dstLen); + tileBytes[t] = conpressedLength; + if (err != Z_OK) { + std::cerr << "DNG Deflate: Failed compressing tile " << t << ", with error " << err << std::endl; + } else { // Floating point data +// #pragma omp critical + { + tileOffsets[t] = file.tellp(); + file.write((const char *)cBuffer, tileBytes[t]); + } + } + } + } + } + + rawIFD.setValue(TILEOFFSETS, tileOffsets); + rawIFD.setValue(TILEBYTES, tileBytes); +} + } // namespace hdrmerge diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index fb8ef32..ccd9340 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -67,19 +67,37 @@ class DngFloatWriter { } }; + enum { + BYTE = 1, + ASCII, + SHORT, + LONG, + RATIONAL, + SBYTE, + UNDEFINED, + SSHORT, + SLONG, + SRATIONAL, + FLOAT, + DOUBLE + } Type; + class IFD { public: template void addEntry(uint16_t tag, uint16_t type, const T & value) { - if (sizeof(T) > 4) { - addEntry(tag, type, 1, &value); - } else { - union { - uint32_t longValue; - T value; - } leftJustify; - leftJustify.longValue = 0; - leftJustify.value = value; - entries.push_back(DirEntry({tag, type, 1, leftJustify.longValue})); + DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, 1, 0}))); + setValue(entry, value); + } + template void setValue(uint16_t tag, const T * value) { + DirEntry * entry = getEntry(tag); + if (entry) { + setValue(entry, (const void *)value); + } + } + template void setValue(uint16_t tag, const T & value) { + DirEntry * entry = getEntry(tag); + if (entry) { + setValue(entry, value); } } void addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data); @@ -89,6 +107,25 @@ class DngFloatWriter { private: std::vector entries; std::vector entryData; + + DirEntry * getEntry(uint16_t tag); + void setValue(DirEntry * entry, const void * data); + template void setValue(DirEntry * entry, const T & value) { + if (sizeof(T) > 4) { + setValue(entry, (const void *)&value); + } else { + uint32_t leftJustified = 0; + switch (entry->type) { + case BYTE: case ASCII: case SBYTE: case UNDEFINED: + *((uint8_t *)&leftJustified) = (uint8_t) value; break; + case SHORT: case SSHORT: + *((uint16_t *)&leftJustified) = (uint16_t) value; break; + case LONG: case SLONG: case FLOAT: + leftJustified = *((uint32_t *)&value); break; + } + entry->offset = leftJustified; + } + } }; ProgressIndicator & progress; @@ -96,12 +133,18 @@ class DngFloatWriter { const ImageStack & stack; const std::string appVersion; IFD mainIFD, rawIFD, previewIFD; + size_t width, height; + size_t tileWidth, tileLength; + size_t tilesAcross, tilesDown; size_t previewWidth; int bps; QString indexFile; - void createIFD(); + void createMainIFD(); + void createRawIFD(); + void calculateTiles(); + void writeRawData(); }; } // namespace hdrmerge diff --git a/MetaData.cpp b/MetaData.cpp index f6dade0..85c0053 100644 --- a/MetaData.cpp +++ b/MetaData.cpp @@ -60,6 +60,8 @@ MetaData::MetaData(const char * f, const LibRaw & rawData) : fileName(f) { model = r.idata.model; colors = r.idata.colors; flip = r.sizes.flip; + if (flip == 0) + flip = 1; // LibRaw does not create this matrix for DNG files!!! if (!camXyz[0][0]) { adobe_cam_xyz(maker, model, (float *)camXyz); diff --git a/MetaData.hpp b/MetaData.hpp index ba105d5..d19dc84 100644 --- a/MetaData.hpp +++ b/MetaData.hpp @@ -37,7 +37,7 @@ class MetaData { bool isSameFormat(const MetaData & r) { return width == r.width && height == r.height && filters == r.filters && cdesc == r.cdesc; } - int FC(int row, int col) const { + uint8_t FC(int row, int col) const { return (filters >> (((row << 1 & 14) | (col & 1)) << 1) & 3); } double logExp() const; diff --git a/config.h.in b/config.h.in index b89074f..a9393b9 100644 --- a/config.h.in +++ b/config.h.in @@ -1,6 +1,5 @@ // The configured options and settings for STaRS #define HDRMERGE_VERSION_MAJOR @HDRMERGE_VERSION_MAJOR@ #define HDRMERGE_VERSION_MINOR @HDRMERGE_VERSION_MINOR@ -#define VERSION_STRING(M,m) "v" #M "." #m -#define HDRMERGE_VERSION_STRING VERSION_STRING(HDRMERGE_VERSION_MAJOR, HDRMERGE_VERSION_MINOR) +#define HDRMERGE_VERSION_STRING "v@HDRMERGE_VERSION_MAJOR@.@HDRMERGE_VERSION_MINOR@" #define RESOURCE_PATH "@CMAKE_INSTALL_PREFIX@/share/hdrmerge" From d130dde5db679a79a9d3317d79abc51ab292f90e Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sun, 11 May 2014 09:49:47 +0100 Subject: [PATCH 06/26] US28: Separate TIFF structures from writer. - Put class IFD in its own file. - Add progress advances to DngFloatWriter::write --- CMakeLists.txt | 2 +- DngFloatWriter.cpp | 146 +++++++++++++++++++-------------------------- DngFloatWriter.hpp | 84 ++------------------------ TiffDirectory.cpp | 78 ++++++++++++++++++++++++ TiffDirectory.hpp | 112 ++++++++++++++++++++++++++++++++++ hdrmerge_es.ts | 4 +- 6 files changed, 257 insertions(+), 169 deletions(-) create mode 100644 TiffDirectory.cpp create mode 100644 TiffDirectory.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 87e8eaf..e85e4f7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -68,7 +68,7 @@ include_directories("${PROJECT_BINARY_DIR}") set(hdrmerge_sources Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngWriter.cpp DngFloatWriter.cpp - camxyz.cpp exiv2dngstreamio.cpp exiv2meta.cpp) + camxyz.cpp TiffDirectory.cpp exiv2dngstreamio.cpp exiv2meta.cpp) set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) set(hdrmerge_translations hdrmerge_es.ts) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index bcadf1e..b71d58c 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -36,60 +36,6 @@ DngFloatWriter::DngFloatWriter(const ImageStack & s, ProgressIndicator & pi) width(stack.getWidth()), height(stack.getHeight()), previewWidth(width), bps(16) {} -void DngFloatWriter::IFD::addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data) { - uint32_t newSize = entryData.size(); - DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, count, newSize}))); - uint32_t dataSize = entry->dataSize(); - if (dataSize > 4) { - newSize += dataSize; - if (newSize & 1) - ++newSize; - entryData.resize(newSize); - } - setValue(entry, data); -} - - -void DngFloatWriter::IFD::setValue(DirEntry * entry, const void * data) { - const uint8_t * castedData = reinterpret_cast(data); - size_t dataSize = entry->dataSize(); - if (dataSize > 4) { - std::copy_n(castedData, dataSize, &entryData[entry->offset]); - } else { - std::copy_n(castedData, dataSize, (uint8_t *)&entry->offset); - } -} - - -void DngFloatWriter::IFD::write(ofstream & file, bool hasNext) { - uint16_t numEntries = entries.size(); - uint32_t offsetData = (uint32_t)file.tellp() + 12*numEntries + 6; - sort(entries.begin(), entries.end()); - uint32_t offsetNext = hasNext ? offsetData + entryData.size() : 0; - for (auto & entry : entries) { - if (entry.dataSize() > 4) { - entry.offset += offsetData; - } - } - file.write((const char *)&numEntries, 2); - file.write((const char *)&entries[0], 12*numEntries); - file.write((const char *)&offsetNext, 4); - file.write((const char *)&entryData[0], entryData.size()); -} - - -size_t DngFloatWriter::IFD::length() const { - return 6 + 12*entries.size() + entryData.size(); -} - - -DngFloatWriter::DirEntry * DngFloatWriter::IFD::getEntry(uint16_t tag) { - auto it = entries.begin(); - while (it != entries.end() && it->tag != tag) it++; - return it == entries.end() ? nullptr : &(*it); -} - - enum { DNGVERSION = 50706, DNGBACKVERSION = 50707, @@ -132,39 +78,39 @@ enum { void DngFloatWriter::createMainIFD() { uint8_t dngVersion[] = { 1, 4, 0, 0 }; - mainIFD.addEntry(DNGVERSION, BYTE, 4, dngVersion); - mainIFD.addEntry(DNGBACKVERSION, BYTE, 4, dngVersion); + mainIFD.addEntry(DNGVERSION, IFD::IFD::BYTE, 4, dngVersion); + mainIFD.addEntry(DNGBACKVERSION, IFD::IFD::BYTE, 4, dngVersion); // Thumbnail set thumbnail->AddTagSet (mainIFD) // Profile const MetaData & md = stack.getImage(0).getMetaData(); - mainIFD.addEntry(CALIBRATIONILLUMINANT, SHORT, 21); // D65 + mainIFD.addEntry(CALIBRATIONILLUMINANT, IFD::SHORT, 21); // D65 string profName(md.maker + " " + md.model); - mainIFD.addEntry(PROFILENAME, ASCII, profName.length() + 1, profName.c_str()); + mainIFD.addEntry(PROFILENAME, IFD::ASCII, profName.length() + 1, profName.c_str()); int32_t colorMatrix[18]; for (int im = 0, id = 0; im < 9; ++im, ++id) { colorMatrix[id] = std::round(md.camXyz[0][im] * 10000.0f); colorMatrix[++id] = 10000; } - mainIFD.addEntry(COLORMATRIX, SRATIONAL, 9, colorMatrix); + mainIFD.addEntry(COLORMATRIX, IFD::SRATIONAL, 9, colorMatrix); // Color uint32_t analogBalance[] = { 1, 1, 1, 1, 1, 1 }; - mainIFD.addEntry(ANALOGBALANCE, RATIONAL, 3, analogBalance); + mainIFD.addEntry(ANALOGBALANCE, IFD::RATIONAL, 3, analogBalance); double minWb = std::min(md.camMul[0], std::min(md.camMul[1], md.camMul[2])); double wb[] = { minWb/md.camMul[0], minWb/md.camMul[1], minWb/md.camMul[2] }; uint32_t cameraNeutral[] = { (uint32_t)std::round(1000000.0 * wb[0]), 1000000, (uint32_t)std::round(1000000.0 * wb[1]), 1000000, (uint32_t)std::round(1000000.0 * wb[2]), 1000000}; - mainIFD.addEntry(CAMERANEUTRAL, RATIONAL, 3, cameraNeutral); + mainIFD.addEntry(CAMERANEUTRAL, IFD::RATIONAL, 3, cameraNeutral); - mainIFD.addEntry(ORIENTATION, SHORT, md.flip); + mainIFD.addEntry(ORIENTATION, IFD::SHORT, md.flip); string cameraName(md.maker + " " + md.model); - mainIFD.addEntry(UNIQUENAME, ASCII, cameraName.length() + 1, &cameraName[0]); + mainIFD.addEntry(UNIQUENAME, IFD::ASCII, cameraName.length() + 1, &cameraName[0]); // TODO: Add Digest and Unique ID // TODO: Add XMP and Exif and private data - mainIFD.addEntry(SUBIFDS, LONG, 1); + mainIFD.addEntry(SUBIFDS, IFD::LONG, 1); } @@ -186,40 +132,58 @@ void DngFloatWriter::calculateTiles() { void DngFloatWriter::createRawIFD() { - rawIFD.addEntry(NEWSUBFILETYPE, LONG, 0); - rawIFD.addEntry(IMAGEWIDTH, LONG, width); - rawIFD.addEntry(IMAGELENGTH, LONG, height); - rawIFD.addEntry(SAMPLESPERPIXEL, SHORT, 1); - rawIFD.addEntry(BITSPERSAMPLE, SHORT, bps); + rawIFD.addEntry(NEWSUBFILETYPE, IFD::LONG, 0); + rawIFD.addEntry(IMAGEWIDTH, IFD::LONG, width); + rawIFD.addEntry(IMAGELENGTH, IFD::LONG, height); + rawIFD.addEntry(SAMPLESPERPIXEL, IFD::SHORT, 1); + rawIFD.addEntry(BITSPERSAMPLE, IFD::SHORT, bps); if (bps == 24) { - rawIFD.addEntry(FILLORDER, SHORT, 1); + rawIFD.addEntry(FILLORDER, IFD::SHORT, 1); } - rawIFD.addEntry(PLANARCONFIG, SHORT, 1); - rawIFD.addEntry(COMPRESSION, SHORT, 8); // Deflate - rawIFD.addEntry(PREDICTOR, SHORT, 34894); //FP2X - rawIFD.addEntry(SAMPLEFORMAT, SHORT, 3); // Floating Point + rawIFD.addEntry(PLANARCONFIG, IFD::SHORT, 1); + rawIFD.addEntry(COMPRESSION, IFD::SHORT, 8); // Deflate + rawIFD.addEntry(PREDICTOR, IFD::SHORT, 34894); //FP2X + rawIFD.addEntry(SAMPLEFORMAT, IFD::SHORT, 3); // Floating Point calculateTiles(); uint32_t numTiles = tilesAcross * tilesDown; uint32_t buffer[numTiles]; - rawIFD.addEntry(TILEWIDTH, LONG, tileWidth); - rawIFD.addEntry(TILELENGTH, LONG, tileLength); - rawIFD.addEntry(TILEOFFSETS, LONG, numTiles, buffer); - rawIFD.addEntry(TILEBYTES, LONG, numTiles, buffer); + rawIFD.addEntry(TILEWIDTH, IFD::LONG, tileWidth); + rawIFD.addEntry(TILELENGTH, IFD::LONG, tileLength); + rawIFD.addEntry(TILEOFFSETS, IFD::LONG, numTiles, buffer); + rawIFD.addEntry(TILEBYTES, IFD::LONG, numTiles, buffer); - rawIFD.addEntry(WHITELEVEL, SHORT, 1); - rawIFD.addEntry(PHOTOINTERPRETATION, SHORT, 32803); // CFA + rawIFD.addEntry(WHITELEVEL, IFD::SHORT, 1); + rawIFD.addEntry(PHOTOINTERPRETATION, IFD::SHORT, 32803); // CFA uint16_t cfaPatternDim[] = { 2, 2 }; - rawIFD.addEntry(CFAPATTERNDIM, SHORT, 2, cfaPatternDim); + rawIFD.addEntry(CFAPATTERNDIM, IFD::SHORT, 2, cfaPatternDim); const MetaData & md = stack.getImage(0).getMetaData(); uint8_t cfaPattern[] = { md.FC(0, 0), md.FC(0, 1), md.FC(1, 0), md.FC(1, 1) }; for (uint8_t & i : cfaPattern) { if (i == 3) i = 1; } - rawIFD.addEntry(CFAPATTERN, BYTE, 4, cfaPattern); + rawIFD.addEntry(CFAPATTERN, IFD::BYTE, 4, cfaPattern); uint8_t cfaPlaneColor[] = { 0, 1, 2 }; - rawIFD.addEntry(CFAPLANECOLOR, BYTE, 3, cfaPlaneColor); - rawIFD.addEntry(CFALAYOUT, SHORT, 1); + rawIFD.addEntry(CFAPLANECOLOR, IFD::BYTE, 3, cfaPlaneColor); + rawIFD.addEntry(CFALAYOUT, IFD::SHORT, 1); +} + + +void DngFloatWriter::buildIndexImage() { + size_t width = stack.getWidth(), height = stack.getHeight(); + QImage indexImage(width, height, QImage::Format_Indexed8); + int numColors = stack.size() - 1; + for (int c = 0; c < numColors; ++c) { + int gray = (256 * c) / numColors; + indexImage.setColor(c, qRgb(gray, gray, gray)); + } + indexImage.setColor(numColors, qRgb(255, 255, 255)); + for (size_t row = 0; row < height; ++row) { + for (size_t col = 0; col < width; ++col) { + indexImage.setPixel(col, row, stack.getImageAt(col, row)); + } + } + indexImage.save(indexFile); } @@ -239,6 +203,7 @@ struct TiffHeader { void DngFloatWriter::write(const string & filename) { + progress.advance(0, "Initialize metadata"); file.open(filename, ios_base::binary); createMainIFD(); @@ -247,6 +212,16 @@ void DngFloatWriter::write(const string & filename) { mainIFD.setValue(SUBIFDS, rawIFDOffset); size_t dataOffset = rawIFDOffset + rawIFD.length(); file.seekp(dataOffset); + + progress.advance(25, "Rendering image"); + rawData.reset(new float[width * height]); + stack.compose(rawData.get()); + + progress.advance(50, "Rendering preview"); + + progress.advance(75, "Writing output"); + if (!indexFile.isEmpty()) + buildIndexImage(); // Write previews writeRawData(); file.seekp(0); @@ -254,6 +229,7 @@ void DngFloatWriter::write(const string & filename) { mainIFD.write(file, false); rawIFD.write(file, false); file.close(); + progress.advance(100, "Done writing!"); } @@ -363,8 +339,6 @@ static void compressFloats(Bytef * dst, int tileWidth, int bytesps) { void DngFloatWriter::writeRawData() { - unique_ptr rawData(new float[width * height]); - stack.compose(rawData.get()); size_t tileCount = tilesAcross * tilesDown; uint32_t tileOffsets[tileCount]; uint32_t tileBytes[tileCount]; diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index ccd9340..186429e 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -23,13 +23,14 @@ #ifndef _DNGFLOATWRITER_HPP_ #define _DNGFLOATWRITER_HPP_ +#include #include #include -#include #include #include "config.h" #include "ImageStack.hpp" #include "ProgressIndicator.hpp" +#include "TiffDirectory.hpp" namespace hdrmerge { @@ -49,84 +50,6 @@ class DngFloatWriter { void write(const std::string & filename); private: - struct DirEntry { - uint16_t tag; - uint16_t type; - uint32_t count; - uint32_t offset; - int bytesPerValue() const { - static int bytesPerValue[12] = - { 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 }; - return bytesPerValue[type - 1]; - } - uint32_t dataSize() const { - return count * bytesPerValue(); - } - bool operator<(const DirEntry & r) const { - return tag < r.tag; - } - }; - - enum { - BYTE = 1, - ASCII, - SHORT, - LONG, - RATIONAL, - SBYTE, - UNDEFINED, - SSHORT, - SLONG, - SRATIONAL, - FLOAT, - DOUBLE - } Type; - - class IFD { - public: - template void addEntry(uint16_t tag, uint16_t type, const T & value) { - DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, 1, 0}))); - setValue(entry, value); - } - template void setValue(uint16_t tag, const T * value) { - DirEntry * entry = getEntry(tag); - if (entry) { - setValue(entry, (const void *)value); - } - } - template void setValue(uint16_t tag, const T & value) { - DirEntry * entry = getEntry(tag); - if (entry) { - setValue(entry, value); - } - } - void addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data); - void write(std::ofstream & file, bool hasNext); - size_t length() const; - - private: - std::vector entries; - std::vector entryData; - - DirEntry * getEntry(uint16_t tag); - void setValue(DirEntry * entry, const void * data); - template void setValue(DirEntry * entry, const T & value) { - if (sizeof(T) > 4) { - setValue(entry, (const void *)&value); - } else { - uint32_t leftJustified = 0; - switch (entry->type) { - case BYTE: case ASCII: case SBYTE: case UNDEFINED: - *((uint8_t *)&leftJustified) = (uint8_t) value; break; - case SHORT: case SSHORT: - *((uint16_t *)&leftJustified) = (uint16_t) value; break; - case LONG: case SLONG: case FLOAT: - leftJustified = *((uint32_t *)&value); break; - } - entry->offset = leftJustified; - } - } - }; ProgressIndicator & progress; std::ofstream file; @@ -136,7 +59,7 @@ class DngFloatWriter { size_t width, height; size_t tileWidth, tileLength; size_t tilesAcross, tilesDown; - + std::unique_ptr rawData; size_t previewWidth; int bps; QString indexFile; @@ -145,6 +68,7 @@ class DngFloatWriter { void createRawIFD(); void calculateTiles(); void writeRawData(); + void buildIndexImage(); }; } // namespace hdrmerge diff --git a/TiffDirectory.cpp b/TiffDirectory.cpp new file mode 100644 index 0000000..075009e --- /dev/null +++ b/TiffDirectory.cpp @@ -0,0 +1,78 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#include +#include "TiffDirectory.hpp" +using namespace hdrmerge; + +void IFD::addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data) { + uint32_t newSize = entryData.size(); + DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, count, newSize}))); + uint32_t dataSize = entry->dataSize(); + if (dataSize > 4) { + newSize += dataSize; + if (newSize & 1) + ++newSize; + entryData.resize(newSize); + } + setValue(entry, data); +} + + +void IFD::setValue(DirEntry * entry, const void * data) { + const uint8_t * castedData = reinterpret_cast(data); + size_t dataSize = entry->dataSize(); + if (dataSize > 4) { + std::copy_n(castedData, dataSize, &entryData[entry->offset]); + } else { + std::copy_n(castedData, dataSize, (uint8_t *)&entry->offset); + } +} + + +void IFD::write(std::ostream & file, bool hasNext) { + uint16_t numEntries = entries.size(); + uint32_t offsetData = (uint32_t)file.tellp() + 12*numEntries + 6; + sort(entries.begin(), entries.end()); + uint32_t offsetNext = hasNext ? offsetData + entryData.size() : 0; + for (auto & entry : entries) { + if (entry.dataSize() > 4) { + entry.offset += offsetData; + } + } + file.write((const char *)&numEntries, 2); + file.write((const char *)&entries[0], 12*numEntries); + file.write((const char *)&offsetNext, 4); + file.write((const char *)&entryData[0], entryData.size()); +} + + +size_t IFD::length() const { + return 6 + 12*entries.size() + entryData.size(); +} + + +IFD::DirEntry * IFD::getEntry(uint16_t tag) { + auto it = entries.begin(); + while (it != entries.end() && it->tag != tag) it++; + return it == entries.end() ? nullptr : &(*it); +} diff --git a/TiffDirectory.hpp b/TiffDirectory.hpp new file mode 100644 index 0000000..2f9478d --- /dev/null +++ b/TiffDirectory.hpp @@ -0,0 +1,112 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#include +#include + +#ifndef _TIFFDIRECTORY_HPP_ +#define _TIFFDIRECTORY_HPP_ + +namespace hdrmerge { + +class IFD { +public: + enum { + BYTE = 1, + ASCII, + SHORT, + LONG, + RATIONAL, + SBYTE, + UNDEFINED, + SSHORT, + SLONG, + SRATIONAL, + FLOAT, + DOUBLE + } Type; + + template void addEntry(uint16_t tag, uint16_t type, const T & value) { + DirEntry * entry = &(*entries.insert(entries.end(), DirEntry({tag, type, 1, 0}))); + setValue(entry, value); + } + template void setValue(uint16_t tag, const T * value) { + DirEntry * entry = getEntry(tag); + if (entry) { + setValue(entry, (const void *)value); + } + } + template void setValue(uint16_t tag, const T & value) { + DirEntry * entry = getEntry(tag); + if (entry) { + setValue(entry, value); + } + } + void addEntry(uint16_t tag, uint16_t type, uint32_t count, const void * data); + void write(std::ostream & file, bool hasNext); + size_t length() const; + +private: + struct DirEntry { + uint16_t tag; + uint16_t type; + uint32_t count; + uint32_t offset; + int bytesPerValue() const { + static int bytesPerValue[12] = + { 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 }; + return bytesPerValue[type - 1]; + } + uint32_t dataSize() const { + return count * bytesPerValue(); + } + bool operator<(const DirEntry & r) const { + return tag < r.tag; + } + }; + + std::vector entries; + std::vector entryData; + + DirEntry * getEntry(uint16_t tag); + void setValue(DirEntry * entry, const void * data); + template void setValue(DirEntry * entry, const T & value) { + if (sizeof(T) > 4) { + setValue(entry, (const void *)&value); + } else { + uint32_t leftJustified = 0; + switch (entry->type) { + case BYTE: case ASCII: case SBYTE: case UNDEFINED: + *((uint8_t *)&leftJustified) = (uint8_t) value; break; + case SHORT: case SSHORT: + *((uint16_t *)&leftJustified) = (uint16_t) value; break; + case LONG: case SLONG: case FLOAT: + leftJustified = *((uint32_t *)&value); break; + } + entry->offset = leftJustified; + } + } +}; + +} // namespace hdrmerge + +#endif // _TIFFDIRECTORY_HPP_ diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index fa2becf..524a8ed 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -91,8 +91,8 @@ ¡Carga completada! - Initialize negative - Inicializar negativo + Initialize metadata + Inicializar metadatos Rendering image From 8f072c72aa6855e09a79d5248cc815c77f9ed020 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sun, 11 May 2014 15:21:51 +0100 Subject: [PATCH 07/26] US28: Get rid of third party libs - Remove the dependency on DNG and XMP SDK from CMakeLists.txt. Also, look for ZLib. - Add method to copy metadata from the least exposed image to the output file with Exiv2. - Add the standard TIFF/EP tags to the output file. --- CMakeLists.txt | 38 ++++------------- DngFloatWriter.cpp | 100 ++++++++++++++++++++++++++++++++++++--------- DngFloatWriter.hpp | 2 +- MainWindow.cpp | 2 +- MetaData.cpp | 7 ++++ MetaData.hpp | 2 +- TiffDirectory.hpp | 14 +++++++ 7 files changed, 113 insertions(+), 52 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e85e4f7..9467fd2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,9 +10,11 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") find_package(Qt4 REQUIRED) include(${QT_USE_FILE}) add_definitions(${QT_DEFINITIONS}) - -# Boost Test +find_package(LibRaw REQUIRED) +find_package(Exiv2 REQUIRED) +find_package(ZLIB REQUIRED) find_package(Boost 1.46 COMPONENTS unit_test_framework) +include_directories(${LibRaw_INCLUDE_DIR} ${EXIV2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS}) # OpenMP find_package(OpenMP) @@ -21,37 +23,13 @@ if(OPENMP_FOUND) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") endif() -# LibRaw -find_package(LibRaw REQUIRED) - -# Exiv2 -find_package(Exiv2 REQUIRED) - -# Build dngsdk and xmpsdk -if(WIN32) # Set Windows rules. - add_definitions(-DqWinOS=1 -DqMacOS=0 -DWIN_ENV=1) -else(WIN32) # Set Linux & co rules. - add_definitions(-DqWinOS=0 -DqMacOS=0 -DqLinux=1 -DqAndroid=1 -DUNIX_ENV=1 -DqDNGUseStdInt=1 -DqDNGThreadSafe=1) -endif(WIN32) -add_definitions(-DqDNGDebug=0 -DqDNGValidateTarget=0 -DqDNGUseLibJPEG=0 -DqDNGXMPDocOps=0) - -# Check processor endianness -include(TestBigEndian) -TEST_BIG_ENDIAN(IS_BIG_ENDIAN) -if(NOT IS_BIG_ENDIAN) - add_definitions(-DqDNGLittleEndian=1) -endif(NOT IS_BIG_ENDIAN) - -include_directories(third_party/dng_sdk third_party/xmp_sdk/public/include) -add_subdirectory(third_party) - if (NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE Release) endif(NOT CMAKE_BUILD_TYPE) # The version number. set (HDRMERGE_VERSION_MAJOR 0) -set (HDRMERGE_VERSION_MINOR 3) +set (HDRMERGE_VERSION_MINOR 4) # configure a header file to pass some of the CMake settings # to the source code @@ -67,14 +45,14 @@ include_directories("${PROJECT_BINARY_DIR}") # Sources and headers set(hdrmerge_sources Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp - Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngWriter.cpp DngFloatWriter.cpp - camxyz.cpp TiffDirectory.cpp exiv2dngstreamio.cpp exiv2meta.cpp) + Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngFloatWriter.cpp + camxyz.cpp TiffDirectory.cpp) set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) set(hdrmerge_translations hdrmerge_es.ts) # Libs -set(hdrmerge_libs ${QT_LIBRARIES} ${EXIV2_LIBRARY} ${LibRaw_LIBRARIES} dngsdk ${XMP_LIBRARIES} pthread dl) +set(hdrmerge_libs ${QT_LIBRARIES} ${EXIV2_LIBRARY} ${LibRaw_LIBRARIES} ${ZLIB_LIBRARIES}) # Qt4 intermediate files QT4_WRAP_CPP(hdrmerge_moc ${hdrmerge_qobject_headers}) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index b71d58c..8223c01 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -20,10 +20,13 @@ * */ +#include #include #include #include #include +#include +#include #include "config.h" #include "DngFloatWriter.hpp" using namespace std; @@ -32,7 +35,7 @@ using namespace std; namespace hdrmerge { DngFloatWriter::DngFloatWriter(const ImageStack & s, ProgressIndicator & pi) - : progress(pi), stack(s), appVersion("HDRMerge " HDRMERGE_VERSION_STRING), + : progress(pi), stack(s), width(stack.getWidth()), height(stack.getHeight()), previewWidth(width), bps(16) {} @@ -73,17 +76,49 @@ enum { UNIQUENAME = 50708, SUBIFDS = 330, + TIFFEPSTD = 37398, + MAKE = 271, + MODEL = 272, + SOFTWARE = 305, + DATETIMEORIGINAL = 36867, + DATETIME = 306, + IMAGEDESCRIPTION = 270, + RESOLUTIONUNIT = 269, + XRESOLUTION = 282, + YRESOLUTION = 283, + COPYRIGHT = 33432, } Tag; void DngFloatWriter::createMainIFD() { + const MetaData & md = stack.getImage(0).getMetaData(); uint8_t dngVersion[] = { 1, 4, 0, 0 }; - mainIFD.addEntry(DNGVERSION, IFD::IFD::BYTE, 4, dngVersion); - mainIFD.addEntry(DNGBACKVERSION, IFD::IFD::BYTE, 4, dngVersion); + mainIFD.addEntry(DNGVERSION, IFD::BYTE, 4, dngVersion); + mainIFD.addEntry(DNGBACKVERSION, IFD::BYTE, 4, dngVersion); // Thumbnail set thumbnail->AddTagSet (mainIFD) + uint8_t tiffep[] = { 1, 0, 0, 0 }; + mainIFD.addEntry(TIFFEPSTD, IFD::BYTE, 4, tiffep); + mainIFD.addEntry(MAKE, IFD::ASCII, md.maker.length() + 1, md.maker.c_str()); + mainIFD.addEntry(MODEL, IFD::ASCII, md.model.length() + 1, md.model.c_str()); + std::string appVersion("HDRMerge " HDRMERGE_VERSION_STRING); + mainIFD.addEntry(SOFTWARE, IFD::ASCII, appVersion.length() + 1, appVersion.c_str()); + mainIFD.addEntry(RESOLUTIONUNIT, IFD::SHORT, 3); // Cm + uint32_t resolution[] = { 100, 1 }; + mainIFD.addEntry(XRESOLUTION, IFD::RATIONAL, 1, resolution); + mainIFD.addEntry(YRESOLUTION, IFD::RATIONAL, 1, resolution); + char empty[] = { 0 }; + mainIFD.addEntry(COPYRIGHT, IFD::ASCII, 1, empty); + mainIFD.addEntry(IMAGEDESCRIPTION, IFD::ASCII, md.description.length() + 1, md.description.c_str()); + char dateTime[20] = { 0 }; + time_t rawtime; + struct tm * timeinfo; + time (&rawtime); + timeinfo = localtime (&rawtime); + int chars = strftime(dateTime, 20, "%Y:%m:%d %T", timeinfo); + mainIFD.addEntry(DATETIME, IFD::ASCII, chars + 1, dateTime); + mainIFD.addEntry(DATETIMEORIGINAL, IFD::ASCII, md.dateTime.length() + 1, md.dateTime.c_str()); // Profile - const MetaData & md = stack.getImage(0).getMetaData(); mainIFD.addEntry(CALIBRATIONILLUMINANT, IFD::SHORT, 21); // D65 string profName(md.maker + " " + md.model); mainIFD.addEntry(PROFILENAME, IFD::ASCII, profName.length() + 1, profName.c_str()); @@ -187,21 +222,6 @@ void DngFloatWriter::buildIndexImage() { } -struct TiffHeader { - union { - uint32_t endian; - struct { - uint16_t endian; - uint16_t magic; - } sep; - }; - uint32_t offset; - // It sets the first two bytes to their correct value, given the architecture - TiffHeader() : endian(0x4D4D4949), offset(8) { sep.magic = 42; } - void write(ofstream & file) const { file.write((const char *)this, 8); } -}; - - void DngFloatWriter::write(const string & filename) { progress.advance(0, "Initialize metadata"); file.open(filename, ios_base::binary); @@ -229,10 +249,52 @@ void DngFloatWriter::write(const string & filename) { mainIFD.write(file, false); rawIFD.write(file, false); file.close(); + + copyMetadata(filename); progress.advance(100, "Done writing!"); } +void DngFloatWriter::copyMetadata(const string & filename) { + try { + Exiv2::Image::AutoPtr src = Exiv2::ImageFactory::open(stack.getImage(stack.size() - 1).getMetaData().fileName); + src->readMetadata(); + Exiv2::Image::AutoPtr result = Exiv2::ImageFactory::open(filename); + result->readMetadata(); + + const Exiv2::XmpData & srcXmp = src->xmpData(); + Exiv2::XmpData & dstXmp = result->xmpData(); + for (const auto & datum : srcXmp) { + if (dstXmp.findKey(Exiv2::XmpKey(datum.key())) == dstXmp.end()) { + dstXmp.add(datum); + } + } + + const Exiv2::IptcData & srcIptc = src->iptcData(); + Exiv2::IptcData & dstIptc = result->iptcData(); + for (const auto & datum : srcIptc) { + if (dstIptc.findKey(Exiv2::IptcKey(datum.key())) == dstIptc.end()) { + dstIptc.add(datum); + } + } + + const Exiv2::ExifData & srcExif = src->exifData(); + Exiv2::ExifData & dstExif = result->exifData(); + for (const auto & datum : srcExif) { + if (datum.groupName() != "Image" && datum.groupName().substr(0, 8) != "SubImage" + && dstExif.findKey(Exiv2::ExifKey(datum.key())) == dstExif.end()) { + dstExif.add(datum); + } + } + + result->writeMetadata(); + } + catch (Exiv2::Error& e) { + std::cerr << "Exiv2 error: " << e.what() << std::endl; + } +} + + static void encodeFPDeltaRow(Bytef * src, Bytef * dst, size_t tileWidth, size_t realTileWidth, int bytesps, int factor) { // Reorder bytes into the image // 16 and 32-bit versions depend on local architecture, 24-bit does not diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index 186429e..9891894 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -54,7 +54,6 @@ class DngFloatWriter { ProgressIndicator & progress; std::ofstream file; const ImageStack & stack; - const std::string appVersion; IFD mainIFD, rawIFD, previewIFD; size_t width, height; size_t tileWidth, tileLength; @@ -69,6 +68,7 @@ class DngFloatWriter { void calculateTiles(); void writeRawData(); void buildIndexImage(); + void copyMetadata(const std::string & filename); }; } // namespace hdrmerge diff --git a/MainWindow.cpp b/MainWindow.cpp index 06125aa..c8bfb0e 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -40,7 +40,7 @@ #include #include "config.h" #include "AboutDialog.hpp" -#include "DngWriter.hpp" +#include "DngFloatWriter.hpp" #include "ImageStack.hpp" #include "PreviewWidget.hpp" #include "DraggableScrollArea.hpp" diff --git a/MetaData.cpp b/MetaData.cpp index 85c0053..7faa713 100644 --- a/MetaData.cpp +++ b/MetaData.cpp @@ -22,6 +22,7 @@ #include #include +#include #include #include #include "Log.hpp" @@ -58,6 +59,12 @@ MetaData::MetaData(const char * f, const LibRaw & rawData) : fileName(f) { aperture = r.other.aperture; maker = r.idata.make; model = r.idata.model; + description = r.other.desc; + char dateTimeTmp[20] = { 0 }; + struct tm * timeinfo; + timeinfo = localtime (&r.other.timestamp); + strftime(dateTimeTmp, 20, "%Y:%m:%d %T", timeinfo); + dateTime = dateTimeTmp; colors = r.idata.colors; flip = r.sizes.flip; if (flip == 0) diff --git a/MetaData.hpp b/MetaData.hpp index d19dc84..dcb78ff 100644 --- a/MetaData.hpp +++ b/MetaData.hpp @@ -67,7 +67,7 @@ class MetaData { float isoSpeed; float shutter; float aperture; - std::string maker, model; + std::string maker, model, description, dateTime; int colors; int flip; }; diff --git a/TiffDirectory.hpp b/TiffDirectory.hpp index 2f9478d..b4fdb50 100644 --- a/TiffDirectory.hpp +++ b/TiffDirectory.hpp @@ -28,6 +28,20 @@ namespace hdrmerge { +struct TiffHeader { + union { + uint32_t endian; + struct { + uint16_t endian; + uint16_t magic; + } sep; + }; + uint32_t offset; + // It sets the first two bytes to their correct value, given the architecture + TiffHeader() : endian(0x4D4D4949), offset(8) { sep.magic = 42; } + void write(std::ostream & file) const { file.write((const char *)this, 8); } +}; + class IFD { public: enum { From 659d7350a03e881fcf61821dd715cb1215ef369e Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sun, 11 May 2014 17:37:02 +0100 Subject: [PATCH 08/26] US28: Move tone curve to ImageStack --- DngFloatWriter.cpp | 23 +++++++++++++++-------- DngFloatWriter.hpp | 4 ++++ ImageStack.cpp | 8 ++++++++ ImageStack.hpp | 8 +++++++- MainWindow.cpp | 1 - PreviewWidget.cpp | 15 ++++----------- PreviewWidget.hpp | 2 -- 7 files changed, 38 insertions(+), 23 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 8223c01..f481a1c 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -223,9 +223,15 @@ void DngFloatWriter::buildIndexImage() { void DngFloatWriter::write(const string & filename) { - progress.advance(0, "Initialize metadata"); - file.open(filename, ios_base::binary); + progress.advance(0, "Rendering image"); + rawData.reset(new float[width * height]); + stack.compose(rawData.get()); + progress.advance(25, "Rendering preview"); + renderPreviews(); + + progress.advance(50, "Initialize metadata"); + file.open(filename, ios_base::binary); createMainIFD(); createRawIFD(); size_t rawIFDOffset = 8 + mainIFD.length(); @@ -233,12 +239,6 @@ void DngFloatWriter::write(const string & filename) { size_t dataOffset = rawIFDOffset + rawIFD.length(); file.seekp(dataOffset); - progress.advance(25, "Rendering image"); - rawData.reset(new float[width * height]); - stack.compose(rawData.get()); - - progress.advance(50, "Rendering preview"); - progress.advance(75, "Writing output"); if (!indexFile.isEmpty()) buildIndexImage(); @@ -255,6 +255,13 @@ void DngFloatWriter::write(const string & filename) { } +void DngFloatWriter::renderPreviews() { + QImage halfInterpolated(width, height, QImage::Format_RGB32); + // Make the half size interpolation, and apply tone curve + +} + + void DngFloatWriter::copyMetadata(const string & filename) { try { Exiv2::Image::AutoPtr src = Exiv2::ImageFactory::open(stack.getImage(stack.size() - 1).getMetaData().fileName); diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index 9891894..5cd5fb5 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -27,6 +27,7 @@ #include #include #include +#include #include "config.h" #include "ImageStack.hpp" #include "ProgressIndicator.hpp" @@ -62,6 +63,8 @@ class DngFloatWriter { size_t previewWidth; int bps; QString indexFile; + QImage thumbnail; + QImage preview; void createMainIFD(); void createRawIFD(); @@ -69,6 +72,7 @@ class DngFloatWriter { void writeRawData(); void buildIndexImage(); void copyMetadata(const std::string & filename); + void renderPreviews(); }; } // namespace hdrmerge diff --git a/ImageStack.cpp b/ImageStack.cpp index d5a57e6..b8cfa40 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -27,6 +27,14 @@ using namespace std; using namespace hdrmerge; +void ImageStack::setGamma(float g) { + g = 1.0f / g; + for (int i = 0; i < 65536; i++) { + toneCurve[i] = (int)std::floor(65536.0f * std::pow(i / 65536.0f, g)) >> 8; + } +} + + bool ImageStack::addImage(std::unique_ptr & i) { if (images.empty()) { width = i->getWidth(); diff --git a/ImageStack.hpp b/ImageStack.hpp index f21c225..b70e35e 100644 --- a/ImageStack.hpp +++ b/ImageStack.hpp @@ -26,6 +26,7 @@ #include #include #include +#include #include "Image.hpp" #include "ProgressIndicator.hpp" #include "MergeMap.hpp" @@ -52,7 +53,7 @@ struct SaveOptions { class ImageStack { public: - ImageStack() : width(0), height(0) {} + ImageStack() : width(0), height(0) { setGamma(2.2f); } int load(const LoadOptions & options, ProgressIndicator & progress); int save(const SaveOptions & options, ProgressIndicator & progress); @@ -89,12 +90,17 @@ class ImageStack { imageIndex[y*width + x] = i; } void compose(float * dst) const; + void setGamma(float g); + uint8_t toneMap(double v) { + return toneCurve[(int)std::floor(v)]; + } private: std::vector> images; ///< Images, from most to least exposed MergeMap imageIndex; size_t width; ///< Size of a row size_t height; ///< Size of a column + uint8_t toneCurve[65536]; void findIntersection(); }; diff --git a/MainWindow.cpp b/MainWindow.cpp index c8bfb0e..7fde8a5 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -103,7 +103,6 @@ void MainWindow::createGui() { layout->addWidget(previewArea); preview = new PreviewWidget(previewArea); - preview->setGamma(2.2f); previewArea->setWidget(preview); QWidget * toolArea = new QWidget(centralwidget); diff --git a/PreviewWidget.cpp b/PreviewWidget.cpp index 0f1df68..787fb4a 100644 --- a/PreviewWidget.cpp +++ b/PreviewWidget.cpp @@ -75,13 +75,6 @@ void PreviewWidget::rotate(int & x, int & y) const { } -void PreviewWidget::setGamma(float g) { - g = 1.0f / g; - for (int i = 0; i < 65536; i++) - gamma[i] = (int)std::floor(65536.0f * std::pow(i / 65536.0f, g)) >> 8; -} - - QSize PreviewWidget::sizeHint() const { return pixmap.get() ? pixmap->size() : QSize(0, 0); } @@ -97,10 +90,10 @@ void PreviewWidget::paintEvent(QPaintEvent * event) { QRgb PreviewWidget::rgb(int col, int row) const { rotate(col, row); - int v = stack->value(col, row); - if (v < 0) v = 0; - else if (v > 65535) v = 65535; - v = gamma[v]; + double d = stack->value(col, row); + if (d < 0) d = 0; + else if (d > 65535) d = 65535; + int v = stack->toneMap(d); int v70 = v*7/10; int color = stack->getImageAt(col, row); QRgb pixel; diff --git a/PreviewWidget.hpp b/PreviewWidget.hpp index 12aa5bf..2625b7d 100644 --- a/PreviewWidget.hpp +++ b/PreviewWidget.hpp @@ -37,7 +37,6 @@ class PreviewWidget : public QWidget { QSize sizeHint() const; public slots: - void setGamma(float g); void setImageStack(ImageStack * s); void toggleAddPixelsTool(bool toggled); void toggleRmPixelsTool(bool toggled); @@ -67,7 +66,6 @@ private slots: std::unique_ptr stack; size_t width, height; int flip; - int gamma[65536]; bool addPixels, rmPixels; int layer; int radius; From c9084372a634c6004c78899e6fe1d8993570a27a Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Mon, 12 May 2014 21:58:20 +0100 Subject: [PATCH 09/26] US28: Use DngFloatWriter in ImageStack --- ImageStack.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ImageStack.cpp b/ImageStack.cpp index b8cfa40..21f403b 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -22,7 +22,7 @@ #include #include "ImageStack.hpp" -#include "DngWriter.hpp" +#include "DngFloatWriter.hpp" using namespace std; using namespace hdrmerge; @@ -75,7 +75,7 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) int ImageStack::save(const SaveOptions & options, ProgressIndicator & progress) { - DngWriter writer(*this, progress); + DngFloatWriter writer(*this, progress); writer.setBitsPerSample(options.bps); writer.setPreviewWidth(options.previewSize); writer.setIndexFileName(options.maskFileName.c_str()); From d86cbd1672fc75980930d6804954e148df9f78fe Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Mon, 12 May 2014 22:12:35 +0100 Subject: [PATCH 10/26] US28 Fix gcc warning --- DngFloatWriter.cpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index f481a1c..e16826a 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -123,9 +123,11 @@ void DngFloatWriter::createMainIFD() { string profName(md.maker + " " + md.model); mainIFD.addEntry(PROFILENAME, IFD::ASCII, profName.length() + 1, profName.c_str()); int32_t colorMatrix[18]; - for (int im = 0, id = 0; im < 9; ++im, ++id) { - colorMatrix[id] = std::round(md.camXyz[0][im] * 10000.0f); - colorMatrix[++id] = 10000; + for (int row = 0, i = 0; row < 3; ++row) { + for (int col = 0; col < 3; ++col) { + colorMatrix[i++] = std::round(md.camXyz[row][col] * 10000.0f); + colorMatrix[i++] = 10000; + } } mainIFD.addEntry(COLORMATRIX, IFD::SRATIONAL, 9, colorMatrix); @@ -258,7 +260,7 @@ void DngFloatWriter::write(const string & filename) { void DngFloatWriter::renderPreviews() { QImage halfInterpolated(width, height, QImage::Format_RGB32); // Make the half size interpolation, and apply tone curve - + } From b344abe3783e65e2bb0cf07d90704cb11431676b Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 00:36:29 +0100 Subject: [PATCH 11/26] US28: Add preview renderer. - Add Renderer class to (fast) interpolate the raw data and create a preview of the image. - Use Renderer in DngFloatWriter to create the thumbnail and the preview. --- CMakeLists.txt | 2 +- DngFloatWriter.cpp | 163 ++++++++++++++++++++++++++++++++------------- DngFloatWriter.hpp | 11 +-- Image.cpp | 1 + MetaData.cpp | 3 +- MetaData.hpp | 1 + Renderer.cpp | 145 ++++++++++++++++++++++++++++++++++++++++ Renderer.hpp | 54 +++++++++++++++ 8 files changed, 328 insertions(+), 52 deletions(-) create mode 100644 Renderer.cpp create mode 100644 Renderer.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 9467fd2..749c352 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,7 +45,7 @@ include_directories("${PROJECT_BINARY_DIR}") # Sources and headers set(hdrmerge_sources Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp - Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngFloatWriter.cpp + Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngFloatWriter.cpp Renderer.cpp camxyz.cpp TiffDirectory.cpp) set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index e16826a..55c9aa8 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -21,14 +21,12 @@ */ #include -#include -#include #include #include -#include -#include +#include #include "config.h" #include "DngFloatWriter.hpp" +#include "Renderer.hpp" using namespace std; @@ -54,11 +52,15 @@ enum { SAMPLESPERPIXEL = 277, BITSPERSAMPLE = 258, FILLORDER = 266, + ACTIVEAREA = 50829, TILEWIDTH = 322, TILELENGTH = 323, TILEOFFSETS = 324, TILEBYTES = 325, + ROWSPERSTRIP = 278, + STRIPOFFSETS = 273, + STRIPBYTES = 279, PLANARCONFIG = 284, COMPRESSION = 259, @@ -87,15 +89,60 @@ enum { XRESOLUTION = 282, YRESOLUTION = 283, COPYRIGHT = 33432, + + YCBCRCOEFFS = 529, + YCBCRSUBSAMPLING = 530, + YCBCRPOSITIONING = 531, + REFBLACKWHITE = 532, } Tag; +void DngFloatWriter::write(const string & filename) { + progress.advance(0, "Rendering image"); + rawData.reset(new float[width * height]); + stack.compose(rawData.get()); + + progress.advance(25, "Rendering preview"); + renderPreviews(); + + progress.advance(50, "Initialize metadata"); + file.open(filename, ios_base::binary); + createMainIFD(); + subIFDoffsets[0] = 8 + mainIFD.length(); + createRawIFD(); + size_t dataOffset = subIFDoffsets[0] + rawIFD.length(); + if (previewWidth > 0) { + createPreviewIFD(); + subIFDoffsets[1] = subIFDoffsets[0] + rawIFD.length(); + dataOffset += previewIFD.length(); + } + mainIFD.setValue(SUBIFDS, (const void *)subIFDoffsets); + file.seekp(dataOffset); + + progress.advance(75, "Writing output"); + if (!indexFile.isEmpty()) + buildIndexImage(); + writePreviews(); + writeRawData(); + file.seekp(0); + TiffHeader().write(file); + mainIFD.write(file, false); + rawIFD.write(file, false); + if (previewWidth > 0) { + previewIFD.write(file, false); + } + file.close(); + + copyMetadata(filename); + progress.advance(100, "Done writing!"); +} + + void DngFloatWriter::createMainIFD() { const MetaData & md = stack.getImage(0).getMetaData(); uint8_t dngVersion[] = { 1, 4, 0, 0 }; mainIFD.addEntry(DNGVERSION, IFD::BYTE, 4, dngVersion); mainIFD.addEntry(DNGBACKVERSION, IFD::BYTE, 4, dngVersion); - // Thumbnail set thumbnail->AddTagSet (mainIFD) uint8_t tiffep[] = { 1, 0, 0, 0 }; mainIFD.addEntry(TIFFEPSTD, IFD::BYTE, 4, tiffep); mainIFD.addEntry(MAKE, IFD::ASCII, md.maker.length() + 1, md.maker.c_str()); @@ -146,17 +193,30 @@ void DngFloatWriter::createMainIFD() { string cameraName(md.maker + " " + md.model); mainIFD.addEntry(UNIQUENAME, IFD::ASCII, cameraName.length() + 1, &cameraName[0]); // TODO: Add Digest and Unique ID - // TODO: Add XMP and Exif and private data - mainIFD.addEntry(SUBIFDS, IFD::LONG, 1); + mainIFD.addEntry(SUBIFDS, IFD::LONG, previewWidth > 0 ? 2 : 1, subIFDoffsets); + + // Thumbnail + mainIFD.addEntry(NEWSUBFILETYPE, IFD::LONG, 1); + mainIFD.addEntry(IMAGEWIDTH, IFD::LONG, thumbnail.width()); + mainIFD.addEntry(IMAGELENGTH, IFD::LONG, thumbnail.height()); + mainIFD.addEntry(SAMPLESPERPIXEL, IFD::SHORT, 3); + uint16_t bpsthumb[] = {8, 8, 8}; + mainIFD.addEntry(BITSPERSAMPLE, IFD::SHORT, 3, bpsthumb); + mainIFD.addEntry(PLANARCONFIG, IFD::SHORT, 1); + mainIFD.addEntry(PHOTOINTERPRETATION, IFD::SHORT, 2); // RGB + mainIFD.addEntry(COMPRESSION, IFD::SHORT, 1); // Uncompressed + mainIFD.addEntry(ROWSPERSTRIP, IFD::LONG, thumbnail.height()); + mainIFD.addEntry(STRIPBYTES, IFD::LONG, 0); + mainIFD.addEntry(STRIPOFFSETS, IFD::LONG, 0); } void DngFloatWriter::calculateTiles() { int bytesPerTile = 512 * 1024; int cellSize = 16; - size_t bytesPerSample = bps >> 3; - size_t samplesPerTile = bytesPerTile / bytesPerSample; - size_t tileSide = std::round(std::sqrt(samplesPerTile)); + uint32_t bytesPerSample = bps >> 3; + uint32_t samplesPerTile = bytesPerTile / bytesPerSample; + uint32_t tileSide = std::round(std::sqrt(samplesPerTile)); tileWidth = std::min(width, tileSide); tilesAcross = (width + tileWidth - 1) / tileWidth;; tileWidth = (width + tilesAcross - 1) / tilesAcross; @@ -172,6 +232,8 @@ void DngFloatWriter::createRawIFD() { rawIFD.addEntry(NEWSUBFILETYPE, IFD::LONG, 0); rawIFD.addEntry(IMAGEWIDTH, IFD::LONG, width); rawIFD.addEntry(IMAGELENGTH, IFD::LONG, height); + uint32_t aa[] = { 0, 0, height, width }; + rawIFD.addEntry(ACTIVEAREA, IFD::LONG, 4, aa); rawIFD.addEntry(SAMPLESPERPIXEL, IFD::SHORT, 1); rawIFD.addEntry(BITSPERSAMPLE, IFD::SHORT, bps); if (bps == 24) { @@ -206,6 +268,29 @@ void DngFloatWriter::createRawIFD() { } +void DngFloatWriter::createPreviewIFD() { + previewIFD.addEntry(NEWSUBFILETYPE, IFD::LONG, 1); + previewIFD.addEntry(IMAGEWIDTH, IFD::LONG, preview.width()); + previewIFD.addEntry(IMAGELENGTH, IFD::LONG, preview.height()); + previewIFD.addEntry(SAMPLESPERPIXEL, IFD::SHORT, 3); + uint16_t bpspre[] = {8, 8, 8}; + previewIFD.addEntry(BITSPERSAMPLE, IFD::SHORT, 3, bpspre); + previewIFD.addEntry(PLANARCONFIG, IFD::SHORT, 1); + previewIFD.addEntry(PHOTOINTERPRETATION, IFD::SHORT, 6); // YCbCr + previewIFD.addEntry(COMPRESSION, IFD::SHORT, 7); // JPEG + previewIFD.addEntry(ROWSPERSTRIP, IFD::LONG, preview.height()); + previewIFD.addEntry(STRIPBYTES, IFD::LONG, 0); + previewIFD.addEntry(STRIPOFFSETS, IFD::LONG, 0); + uint16_t subsampling[] = { 2, 2 }; + previewIFD.addEntry(YCBCRSUBSAMPLING, IFD::SHORT, 2, subsampling); + previewIFD.addEntry(YCBCRPOSITIONING, IFD::SHORT, 2); + uint32_t coefficients[] = { 299, 1000, 587, 1000, 114, 1000 }; + previewIFD.addEntry(YCBCRCOEFFS, IFD::RATIONAL, 3, coefficients); + uint32_t refs[] = { 0, 1, 255, 1, 128, 1, 255, 1, 128, 1, 255, 1}; + previewIFD.addEntry(REFBLACKWHITE, IFD::RATIONAL, 6, refs); +} + + void DngFloatWriter::buildIndexImage() { size_t width = stack.getWidth(), height = stack.getHeight(); QImage indexImage(width, height, QImage::Format_Indexed8); @@ -224,43 +309,12 @@ void DngFloatWriter::buildIndexImage() { } -void DngFloatWriter::write(const string & filename) { - progress.advance(0, "Rendering image"); - rawData.reset(new float[width * height]); - stack.compose(rawData.get()); - - progress.advance(25, "Rendering preview"); - renderPreviews(); - - progress.advance(50, "Initialize metadata"); - file.open(filename, ios_base::binary); - createMainIFD(); - createRawIFD(); - size_t rawIFDOffset = 8 + mainIFD.length(); - mainIFD.setValue(SUBIFDS, rawIFDOffset); - size_t dataOffset = rawIFDOffset + rawIFD.length(); - file.seekp(dataOffset); - - progress.advance(75, "Writing output"); - if (!indexFile.isEmpty()) - buildIndexImage(); - // Write previews - writeRawData(); - file.seekp(0); - TiffHeader().write(file); - mainIFD.write(file, false); - rawIFD.write(file, false); - file.close(); - - copyMetadata(filename); - progress.advance(100, "Done writing!"); -} - - void DngFloatWriter::renderPreviews() { - QImage halfInterpolated(width, height, QImage::Format_RGB32); - // Make the half size interpolation, and apply tone curve - + Renderer r(rawData.get(), width, height, stack.getImage(0).getMetaData()); + r.process(); + thumbnail = r.getScaledVersion(256).convertToFormat(QImage::Format_RGB888); + if (previewWidth > 0) + preview = r.getScaledVersion(previewWidth); } @@ -304,6 +358,23 @@ void DngFloatWriter::copyMetadata(const string & filename) { } +void DngFloatWriter::writePreviews() { + size_t thumbsize = thumbnail.width() * thumbnail.height() * 3; + mainIFD.setValue(STRIPBYTES, thumbsize); + mainIFD.setValue(STRIPOFFSETS, file.tellp()); + file.write((const char *)thumbnail.bits(), thumbsize); + if (previewWidth > 0) { + QByteArray ba; + QBuffer buffer(&ba); + buffer.open(QIODevice::WriteOnly); + preview.save(&buffer, "JPEG", 90); + previewIFD.setValue(STRIPBYTES, ba.size()); + previewIFD.setValue(STRIPOFFSETS, file.tellp()); + file.write(ba.constData(), ba.size()); + } +} + + static void encodeFPDeltaRow(Bytef * src, Bytef * dst, size_t tileWidth, size_t realTileWidth, int bytesps, int factor) { // Reorder bytes into the image // 16 and 32-bit versions depend on local architecture, 24-bit does not diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index 5cd5fb5..68d6a90 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -56,15 +56,16 @@ class DngFloatWriter { std::ofstream file; const ImageStack & stack; IFD mainIFD, rawIFD, previewIFD; - size_t width, height; - size_t tileWidth, tileLength; - size_t tilesAcross, tilesDown; + uint32_t width, height; + uint32_t tileWidth, tileLength; + uint32_t tilesAcross, tilesDown; std::unique_ptr rawData; - size_t previewWidth; + uint32_t previewWidth; int bps; QString indexFile; QImage thumbnail; QImage preview; + uint32_t subIFDoffsets[2]; void createMainIFD(); void createRawIFD(); @@ -73,6 +74,8 @@ class DngFloatWriter { void buildIndexImage(); void copyMetadata(const std::string & filename); void renderPreviews(); + void writePreviews(); + void createPreviewIFD(); }; } // namespace hdrmerge diff --git a/Image.cpp b/Image.cpp index 982112f..7e82f79 100644 --- a/Image.cpp +++ b/Image.cpp @@ -60,6 +60,7 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { relExp = 65535.0 / max; brightness /= size; subtractBlack(); + metaData->max = max; preScale(); computeHalfLightPercentile(); metaData->dumpInfo(); diff --git a/MetaData.cpp b/MetaData.cpp index 7faa713..a655278 100644 --- a/MetaData.cpp +++ b/MetaData.cpp @@ -35,7 +35,7 @@ void adobe_cam_xyz(const string & t_make, const string & t_model, float * cam_xy MetaData::MetaData() : width(0), height(0), rawWidth(0), topMargin(0), leftMargin(0), filters(0), -max(0), black(0), cblack{}, camMul{}, camXyz{}, isoSpeed(0.0), shutter(0.0), aperture(0.0), colors(0) {} +max(0), black(0), cblack{}, camMul{}, camXyz{}, rgbCam{}, isoSpeed(0.0), shutter(0.0), aperture(0.0), colors(0) {} MetaData::MetaData(const char * f, const LibRaw & rawData) : fileName(f) { @@ -54,6 +54,7 @@ MetaData::MetaData(const char * f, const LibRaw & rawData) : fileName(f) { copy_n(r.color.cam_mul, 4, camMul); adjustWhite(); copy_n((float *)r.color.cam_xyz, 3*4, (float *)camXyz); + copy_n((float *)r.color.rgb_cam, 4*3, (float *)rgbCam); isoSpeed = r.other.iso_speed; shutter = r.other.shutter; aperture = r.other.aperture; diff --git a/MetaData.hpp b/MetaData.hpp index dcb78ff..3e76046 100644 --- a/MetaData.hpp +++ b/MetaData.hpp @@ -64,6 +64,7 @@ class MetaData { uint16_t cblack[4]; float camMul[4]; float camXyz[4][3]; + float rgbCam[3][4]; float isoSpeed; float shutter; float aperture; diff --git a/Renderer.cpp b/Renderer.cpp new file mode 100644 index 0000000..52904a1 --- /dev/null +++ b/Renderer.cpp @@ -0,0 +1,145 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + * Part of this file is generated from Dave Coffin's dcraw.c + * dcraw.c -- Dave Coffin's raw photo decoder + * Copyright 1997-2010 by Dave Coffin, dcoffin a cybercom o net + * + * Look into dcraw homepage (probably http://cybercom.net/~dcoffin/dcraw/) + * for more information + * + */ + +#include "Renderer.hpp" +using namespace hdrmerge; + +Renderer::Renderer(float * rawData, size_t w, size_t h, const MetaData & md) +: md(md), width(w/2), height(h/2) { + image.reset(new float[width*height][4]); + for (size_t row = 0; row < height; ++row) { + for (size_t col = 0; col < width; ++col) { + size_t posDst = row*width + col; + size_t row2 = row << 1, col2 = col << 1; + size_t posSrc = row2*w + col2; + image[posDst][md.FC(row2, col2)] = rawData[posSrc] * 65535.0; + image[posDst][md.FC(row2, col2 + 1)] = rawData[posSrc + 1] * 65535.0; + image[posDst][md.FC(row2 + 1, col2)] = rawData[posSrc + w] * 65535.0; + image[posDst][md.FC(row2 + 1, col2 + 1)] = rawData[posSrc + w + 1] * 65535.0; + } + } +} + + +QImage Renderer::getScaledVersion(size_t width) { + return halfInterpolated.scaledToWidth(width); +} + + +void Renderer::process() { + whiteBalance(); + for (size_t i = 0; i < width*height; ++i) { + image[i][1] = (image[i][1] + image[i][3]) / 2.0; + } + convertToRgb(); + buildResult(); +} + + +void Renderer::whiteBalance() { + double dmax = 0; + for (int c = 0; c < 4; ++c) { + if (dmax < md.camMul[c]) + dmax = md.camMul[c]; + } + float scale_mul[4]; + for (int c = 0; c < 4; ++c) { + scale_mul[c] = (md.camMul[c] /= dmax); + } + size_t size = height*width; + float * dst = image[0]; + for (size_t i = 0; i < size*4; ++i) { + dst[i] *= scale_mul[i & 3]; + } +} + + +void Renderer::autoWB() { +// unsigned bottom, right, sum[8]; +// double dsum[8]; +// if (use_auto_wb || (use_camera_wb && md.camMul[0] == -1)) { +// memset (dsum, 0, sizeof dsum); +// bottom = MIN (greybox[1]+greybox[3], height); +// right = MIN (greybox[0]+greybox[2], width); +// for (row=greybox[1]; row < bottom; row += 8) +// for (col=greybox[0]; col < right; col += 8) { +// memset (sum, 0, sizeof sum); +// for (y=row; y < row+8 && y < bottom; y++) +// for (x=col; x < col+8 && x < right; x++) +// FORC4 { +// if (filters) { +// c = fcol(y,x); +// val = BAYER2(y,x); +// } else +// val = image[y*width+x][c]; +// if (val > maximum-25) goto skip_block; +// if ((val -= cblack[c]) < 0) val = 0; +// sum[c] += val; +// sum[c+4]++; +// if (filters) break; +// } +// FORC(8) dsum[c] += sum[c]; +// skip_block: ; +// } +// FORC4 if (dsum[c]) pre_mul[c] = dsum[c+4] / dsum[c]; +// } +} + + +void Renderer::convertToRgb() { + float * end = image[0] + 4*width*height; + for (float * img = image[0]; img < end; img += 4) { + float out[3] = {0.0f, 0.0f, 0.0f }; + for(int c = 0; c < 3; ++c) { + out[0] += md.rgbCam[0][c] * img[c]; + out[1] += md.rgbCam[1][c] * img[c]; + out[2] += md.rgbCam[2][c] * img[c]; + } + for(int c = 0; c < 3; ++c) { + float v = out[c]; + if (v > 65535.0) v = 65535.0; + img[c] = v; + } + } +} + + +void Renderer::buildResult() { + uint8_t gamma[65536]; + float g = 1.0f / 2.2f; + for (int i = 0; i < 65536; i++) { + gamma[i] = (int)std::floor(65536.0f * std::pow(i / 65536.0f, g)) >> 8; + } + + halfInterpolated = QImage(width, height, QImage::Format_RGB32); + QRgb * dst = (QRgb *)halfInterpolated.bits(); + for (size_t i = 0; i < width*height; ++i) { + dst[i] = qRgb(gamma[(int)image[i][0]], gamma[(int)image[i][1]], gamma[(int)image[i][2]]); + } +} diff --git a/Renderer.hpp b/Renderer.hpp new file mode 100644 index 0000000..359add5 --- /dev/null +++ b/Renderer.hpp @@ -0,0 +1,54 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#ifndef _RENDERER_HPP_ +#define _RENDERER_HPP_ + +#include +#include +#include "MetaData.hpp" + +namespace hdrmerge { + + +class Renderer { +public: + Renderer(float * rawData, size_t width, size_t height, const MetaData & md); + + void process(); + QImage getScaledVersion(size_t width); + +private: + void convertToRgb(); + void whiteBalance(); + void autoWB(); + void buildResult(); + + MetaData md; + int width, height; + std::unique_ptr image; + QImage halfInterpolated; +}; + +} + +#endif // _RENDERER_HPP_ From ded5f6a31678686aed9ba5082b94da1ddf639d07 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 11:29:36 +0100 Subject: [PATCH 12/26] US28: Correctly copy most metadata. - Fix orientation tag with correct TIFF values. - Fix Make and Model tags with information from source images. LibRaw provides other names. - With correct Make tag, makernotes are correctly copied. --- DngFloatWriter.cpp | 34 ++++++++++++++++++++++++++++++---- MetaData.cpp | 9 +++++++-- MetaData.hpp | 1 + 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 55c9aa8..6a5f072 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -27,6 +27,7 @@ #include "config.h" #include "DngFloatWriter.hpp" #include "Renderer.hpp" +#include "Log.hpp" using namespace std; @@ -189,7 +190,7 @@ void DngFloatWriter::createMainIFD() { (uint32_t)std::round(1000000.0 * wb[2]), 1000000}; mainIFD.addEntry(CAMERANEUTRAL, IFD::RATIONAL, 3, cameraNeutral); - mainIFD.addEntry(ORIENTATION, IFD::SHORT, md.flip); + mainIFD.addEntry(ORIENTATION, IFD::SHORT, md.tiffOrientation); string cameraName(md.maker + " " + md.model); mainIFD.addEntry(UNIQUENAME, IFD::ASCII, cameraName.length() + 1, &cameraName[0]); // TODO: Add Digest and Unique ID @@ -327,26 +328,51 @@ void DngFloatWriter::copyMetadata(const string & filename) { const Exiv2::XmpData & srcXmp = src->xmpData(); Exiv2::XmpData & dstXmp = result->xmpData(); + Log::msg(Log::DEBUG, "Copying XMP metadata"); for (const auto & datum : srcXmp) { - if (dstXmp.findKey(Exiv2::XmpKey(datum.key())) == dstXmp.end()) { + if (datum.groupName() != "tiff" && dstXmp.findKey(Exiv2::XmpKey(datum.key())) == dstXmp.end()) { + Log::msg(Log::DEBUG, "Add ", datum.key()); dstXmp.add(datum); + } else { + Log::msg(Log::DEBUG, "Ignore ", datum.key()); } } const Exiv2::IptcData & srcIptc = src->iptcData(); Exiv2::IptcData & dstIptc = result->iptcData(); + Log::msg(Log::DEBUG, "Copying IPTC metadata"); for (const auto & datum : srcIptc) { if (dstIptc.findKey(Exiv2::IptcKey(datum.key())) == dstIptc.end()) { + Log::msg(Log::DEBUG, "Add ", datum.key()); dstIptc.add(datum); + } else { + Log::msg(Log::DEBUG, "Ignore ", datum.key()); } } const Exiv2::ExifData & srcExif = src->exifData(); Exiv2::ExifData & dstExif = result->exifData(); + Log::msg(Log::DEBUG, "Copying EXIF metadata"); + // Correct Make and Model + auto makeIterator = srcExif.findKey(Exiv2::ExifKey("Exif.Image.Make")); + if (makeIterator != srcExif.end()) { + Log::msg(Log::DEBUG, "Reset Exif.Image.Make to ", makeIterator->toString()); + dstExif["Exif.Image.Make"] = makeIterator->toString(); + } + auto modelIterator = srcExif.findKey(Exiv2::ExifKey("Exif.Image.Model")); + if (modelIterator != srcExif.end()) { + Log::msg(Log::DEBUG, "Reset Exif.Image.Model to ", modelIterator->toString()); + dstExif["Exif.Image.Model"] = modelIterator->toString(); + } for (const auto & datum : srcExif) { - if (datum.groupName() != "Image" && datum.groupName().substr(0, 8) != "SubImage" - && dstExif.findKey(Exiv2::ExifKey(datum.key())) == dstExif.end()) { + if (datum.groupName() != "Thumbnail" && + datum.groupName().substr(0, 5) != "Image" && + datum.groupName().substr(0, 8) != "SubImage" && + dstExif.findKey(Exiv2::ExifKey(datum.key())) == dstExif.end()) { + Log::msg(Log::DEBUG, "Add ", datum.key()); dstExif.add(datum); + } else { + Log::msg(Log::DEBUG, "Ignore ", datum.key()); } } diff --git a/MetaData.cpp b/MetaData.cpp index a655278..d3c5e95 100644 --- a/MetaData.cpp +++ b/MetaData.cpp @@ -68,8 +68,13 @@ MetaData::MetaData(const char * f, const LibRaw & rawData) : fileName(f) { dateTime = dateTimeTmp; colors = r.idata.colors; flip = r.sizes.flip; - if (flip == 0) - flip = 1; + switch (flip) { + case 0: tiffOrientation = 1; break; + case 3: tiffOrientation = 3; break; + case 5: tiffOrientation = 8; break; + case 6: tiffOrientation = 6; break; + default: tiffOrientation = 9; break; + } // LibRaw does not create this matrix for DNG files!!! if (!camXyz[0][0]) { adobe_cam_xyz(maker, model, (float *)camXyz); diff --git a/MetaData.hpp b/MetaData.hpp index 3e76046..babafb3 100644 --- a/MetaData.hpp +++ b/MetaData.hpp @@ -71,6 +71,7 @@ class MetaData { std::string maker, model, description, dateTime; int colors; int flip; + int tiffOrientation; }; } // namespace hdrmerge From 3b642c29fb8231d40a7a9e7531a4d4415a4518fc Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 11:38:01 +0100 Subject: [PATCH 13/26] US28: Remove the remaining files from DNG SDK - Remove all the third party files, exiv2meta and DngWriter classes. - Remove XMP SDK compilation instructions from README. --- DngWriter.cpp | 344 - DngWriter.hpp | 88 - README.md | 19 +- exiv2dngstreamio.cpp | 202 - exiv2dngstreamio.h | 61 - exiv2meta.cpp | 608 -- exiv2meta.h | 84 - third_party/CMakeLists.txt | 77 - third_party/dng_sdk/dng_1d_function.cpp | 195 - third_party/dng_sdk/dng_1d_function.h | 159 - third_party/dng_sdk/dng_1d_table.cpp | 195 - third_party/dng_sdk/dng_1d_table.h | 122 - third_party/dng_sdk/dng_abort_sniffer.cpp | 242 - third_party/dng_sdk/dng_abort_sniffer.h | 244 - third_party/dng_sdk/dng_area_task.cpp | 270 - third_party/dng_sdk/dng_area_task.h | 198 - third_party/dng_sdk/dng_assertions.h | 133 - third_party/dng_sdk/dng_auto_ptr.h | 259 - third_party/dng_sdk/dng_bad_pixels.cpp | 1856 ----- third_party/dng_sdk/dng_bad_pixels.h | 307 - third_party/dng_sdk/dng_bottlenecks.cpp | 72 - third_party/dng_sdk/dng_bottlenecks.h | 1715 ---- third_party/dng_sdk/dng_camera_profile.cpp | 1381 ---- third_party/dng_sdk/dng_camera_profile.h | 878 --- third_party/dng_sdk/dng_classes.h | 100 - third_party/dng_sdk/dng_color_space.cpp | 1072 --- third_party/dng_sdk/dng_color_space.h | 351 - third_party/dng_sdk/dng_color_spec.cpp | 559 -- third_party/dng_sdk/dng_color_spec.h | 146 - third_party/dng_sdk/dng_date_time.cpp | 959 --- third_party/dng_sdk/dng_date_time.h | 385 - third_party/dng_sdk/dng_errors.h | 58 - third_party/dng_sdk/dng_exceptions.cpp | 205 - third_party/dng_sdk/dng_exceptions.h | 301 - third_party/dng_sdk/dng_exif.cpp | 4390 ----------- third_party/dng_sdk/dng_exif.h | 351 - third_party/dng_sdk/dng_fast_module.h | 31 - third_party/dng_sdk/dng_file_stream.cpp | 135 - third_party/dng_sdk/dng_file_stream.h | 77 - third_party/dng_sdk/dng_filter_task.cpp | 167 - third_party/dng_sdk/dng_filter_task.h | 157 - third_party/dng_sdk/dng_fingerprint.cpp | 589 -- third_party/dng_sdk/dng_fingerprint.h | 377 - third_party/dng_sdk/dng_flags.h | 271 - third_party/dng_sdk/dng_gain_map.cpp | 583 -- third_party/dng_sdk/dng_gain_map.h | 219 - third_party/dng_sdk/dng_globals.cpp | 28 - third_party/dng_sdk/dng_globals.h | 46 - third_party/dng_sdk/dng_host.cpp | 539 -- third_party/dng_sdk/dng_host.h | 406 - third_party/dng_sdk/dng_hue_sat_map.cpp | 365 - third_party/dng_sdk/dng_hue_sat_map.h | 229 - third_party/dng_sdk/dng_ifd.cpp | 4260 ---------- third_party/dng_sdk/dng_ifd.h | 305 - third_party/dng_sdk/dng_image.cpp | 848 -- third_party/dng_sdk/dng_image.h | 433 - third_party/dng_sdk/dng_image_writer.cpp | 6961 ----------------- third_party/dng_sdk/dng_image_writer.h | 1245 --- third_party/dng_sdk/dng_info.cpp | 2505 ------ third_party/dng_sdk/dng_info.h | 163 - third_party/dng_sdk/dng_iptc.cpp | 985 --- third_party/dng_sdk/dng_iptc.h | 172 - third_party/dng_sdk/dng_jpeg_image.cpp | 385 - third_party/dng_sdk/dng_jpeg_image.h | 92 - third_party/dng_sdk/dng_lens_correction.cpp | 2373 ------ third_party/dng_sdk/dng_lens_correction.h | 638 -- .../dng_sdk/dng_linearization_info.cpp | 1517 ---- third_party/dng_sdk/dng_linearization_info.h | 164 - third_party/dng_sdk/dng_lossless_jpeg.cpp | 3764 --------- third_party/dng_sdk/dng_lossless_jpeg.h | 69 - third_party/dng_sdk/dng_matrix.cpp | 1080 --- third_party/dng_sdk/dng_matrix.h | 326 - third_party/dng_sdk/dng_memory.cpp | 205 - third_party/dng_sdk/dng_memory.h | 515 -- third_party/dng_sdk/dng_memory_stream.cpp | 254 - third_party/dng_sdk/dng_memory_stream.h | 97 - third_party/dng_sdk/dng_misc_opcodes.cpp | 1578 ---- third_party/dng_sdk/dng_misc_opcodes.h | 417 - third_party/dng_sdk/dng_mosaic_info.cpp | 1991 ----- third_party/dng_sdk/dng_mosaic_info.h | 200 - third_party/dng_sdk/dng_mutex.cpp | 394 - third_party/dng_sdk/dng_mutex.h | 177 - third_party/dng_sdk/dng_negative.cpp | 5076 ------------ third_party/dng_sdk/dng_negative.h | 2386 ------ third_party/dng_sdk/dng_opcode_list.cpp | 274 - third_party/dng_sdk/dng_opcode_list.h | 165 - third_party/dng_sdk/dng_opcodes.cpp | 572 -- third_party/dng_sdk/dng_opcodes.h | 507 -- third_party/dng_sdk/dng_orientation.cpp | 233 - third_party/dng_sdk/dng_orientation.h | 189 - third_party/dng_sdk/dng_parse_utils.cpp | 3326 -------- third_party/dng_sdk/dng_parse_utils.h | 232 - third_party/dng_sdk/dng_pixel_buffer.cpp | 1819 ----- third_party/dng_sdk/dng_pixel_buffer.h | 680 -- third_party/dng_sdk/dng_point.cpp | 22 - third_party/dng_sdk/dng_point.h | 198 - third_party/dng_sdk/dng_preview.cpp | 709 -- third_party/dng_sdk/dng_preview.h | 245 - third_party/dng_sdk/dng_pthread.cpp | 1141 --- third_party/dng_sdk/dng_pthread.h | 266 - third_party/dng_sdk/dng_rational.cpp | 150 - third_party/dng_sdk/dng_rational.h | 149 - third_party/dng_sdk/dng_read_image.cpp | 3394 -------- third_party/dng_sdk/dng_read_image.h | 182 - third_party/dng_sdk/dng_rect.cpp | 168 - third_party/dng_sdk/dng_rect.h | 494 -- third_party/dng_sdk/dng_ref_counted_block.cpp | 187 - third_party/dng_sdk/dng_ref_counted_block.h | 291 - third_party/dng_sdk/dng_reference.cpp | 2781 ------- third_party/dng_sdk/dng_reference.h | 521 -- third_party/dng_sdk/dng_render.cpp | 1328 ---- third_party/dng_sdk/dng_render.h | 312 - third_party/dng_sdk/dng_resample.cpp | 781 -- third_party/dng_sdk/dng_resample.h | 261 - third_party/dng_sdk/dng_sdk_limits.h | 78 - third_party/dng_sdk/dng_shared.cpp | 3289 -------- third_party/dng_sdk/dng_shared.h | 248 - third_party/dng_sdk/dng_simple_image.cpp | 197 - third_party/dng_sdk/dng_simple_image.h | 82 - third_party/dng_sdk/dng_spline.cpp | 233 - third_party/dng_sdk/dng_spline.h | 83 - third_party/dng_sdk/dng_stream.cpp | 1219 --- third_party/dng_sdk/dng_stream.h | 698 -- third_party/dng_sdk/dng_string.cpp | 2242 ------ third_party/dng_sdk/dng_string.h | 165 - third_party/dng_sdk/dng_string_list.cpp | 163 - third_party/dng_sdk/dng_string_list.h | 86 - third_party/dng_sdk/dng_tag_codes.h | 543 -- third_party/dng_sdk/dng_tag_types.cpp | 66 - third_party/dng_sdk/dng_tag_types.h | 52 - third_party/dng_sdk/dng_tag_values.h | 480 -- third_party/dng_sdk/dng_temperature.cpp | 259 - third_party/dng_sdk/dng_temperature.h | 97 - third_party/dng_sdk/dng_tile_iterator.cpp | 199 - third_party/dng_sdk/dng_tile_iterator.h | 76 - third_party/dng_sdk/dng_tone_curve.cpp | 138 - third_party/dng_sdk/dng_tone_curve.h | 66 - third_party/dng_sdk/dng_types.h | 115 - third_party/dng_sdk/dng_uncopyable.h | 48 - third_party/dng_sdk/dng_utils.cpp | 704 -- third_party/dng_sdk/dng_utils.h | 1237 --- third_party/dng_sdk/dng_validate.cpp | 879 --- third_party/dng_sdk/dng_xmp.cpp | 4415 ----------- third_party/dng_sdk/dng_xmp.h | 405 - third_party/dng_sdk/dng_xmp_sdk.cpp | 1679 ---- third_party/dng_sdk/dng_xmp_sdk.h | 238 - third_party/dng_sdk/dng_xy_coord.cpp | 89 - third_party/dng_sdk/dng_xy_coord.h | 187 - 148 files changed, 2 insertions(+), 106710 deletions(-) delete mode 100644 DngWriter.cpp delete mode 100644 DngWriter.hpp delete mode 100644 exiv2dngstreamio.cpp delete mode 100644 exiv2dngstreamio.h delete mode 100644 exiv2meta.cpp delete mode 100644 exiv2meta.h delete mode 100644 third_party/CMakeLists.txt delete mode 100644 third_party/dng_sdk/dng_1d_function.cpp delete mode 100644 third_party/dng_sdk/dng_1d_function.h delete mode 100644 third_party/dng_sdk/dng_1d_table.cpp delete mode 100644 third_party/dng_sdk/dng_1d_table.h delete mode 100644 third_party/dng_sdk/dng_abort_sniffer.cpp delete mode 100644 third_party/dng_sdk/dng_abort_sniffer.h delete mode 100644 third_party/dng_sdk/dng_area_task.cpp delete mode 100644 third_party/dng_sdk/dng_area_task.h delete mode 100644 third_party/dng_sdk/dng_assertions.h delete mode 100644 third_party/dng_sdk/dng_auto_ptr.h delete mode 100644 third_party/dng_sdk/dng_bad_pixels.cpp delete mode 100644 third_party/dng_sdk/dng_bad_pixels.h delete mode 100644 third_party/dng_sdk/dng_bottlenecks.cpp delete mode 100644 third_party/dng_sdk/dng_bottlenecks.h delete mode 100644 third_party/dng_sdk/dng_camera_profile.cpp delete mode 100644 third_party/dng_sdk/dng_camera_profile.h delete mode 100644 third_party/dng_sdk/dng_classes.h delete mode 100644 third_party/dng_sdk/dng_color_space.cpp delete mode 100644 third_party/dng_sdk/dng_color_space.h delete mode 100644 third_party/dng_sdk/dng_color_spec.cpp delete mode 100644 third_party/dng_sdk/dng_color_spec.h delete mode 100644 third_party/dng_sdk/dng_date_time.cpp delete mode 100644 third_party/dng_sdk/dng_date_time.h delete mode 100644 third_party/dng_sdk/dng_errors.h delete mode 100644 third_party/dng_sdk/dng_exceptions.cpp delete mode 100644 third_party/dng_sdk/dng_exceptions.h delete mode 100644 third_party/dng_sdk/dng_exif.cpp delete mode 100644 third_party/dng_sdk/dng_exif.h delete mode 100644 third_party/dng_sdk/dng_fast_module.h delete mode 100644 third_party/dng_sdk/dng_file_stream.cpp delete mode 100644 third_party/dng_sdk/dng_file_stream.h delete mode 100644 third_party/dng_sdk/dng_filter_task.cpp delete mode 100644 third_party/dng_sdk/dng_filter_task.h delete mode 100644 third_party/dng_sdk/dng_fingerprint.cpp delete mode 100644 third_party/dng_sdk/dng_fingerprint.h delete mode 100644 third_party/dng_sdk/dng_flags.h delete mode 100644 third_party/dng_sdk/dng_gain_map.cpp delete mode 100644 third_party/dng_sdk/dng_gain_map.h delete mode 100644 third_party/dng_sdk/dng_globals.cpp delete mode 100644 third_party/dng_sdk/dng_globals.h delete mode 100644 third_party/dng_sdk/dng_host.cpp delete mode 100644 third_party/dng_sdk/dng_host.h delete mode 100644 third_party/dng_sdk/dng_hue_sat_map.cpp delete mode 100644 third_party/dng_sdk/dng_hue_sat_map.h delete mode 100644 third_party/dng_sdk/dng_ifd.cpp delete mode 100644 third_party/dng_sdk/dng_ifd.h delete mode 100644 third_party/dng_sdk/dng_image.cpp delete mode 100644 third_party/dng_sdk/dng_image.h delete mode 100644 third_party/dng_sdk/dng_image_writer.cpp delete mode 100644 third_party/dng_sdk/dng_image_writer.h delete mode 100644 third_party/dng_sdk/dng_info.cpp delete mode 100644 third_party/dng_sdk/dng_info.h delete mode 100644 third_party/dng_sdk/dng_iptc.cpp delete mode 100644 third_party/dng_sdk/dng_iptc.h delete mode 100644 third_party/dng_sdk/dng_jpeg_image.cpp delete mode 100644 third_party/dng_sdk/dng_jpeg_image.h delete mode 100644 third_party/dng_sdk/dng_lens_correction.cpp delete mode 100644 third_party/dng_sdk/dng_lens_correction.h delete mode 100644 third_party/dng_sdk/dng_linearization_info.cpp delete mode 100644 third_party/dng_sdk/dng_linearization_info.h delete mode 100644 third_party/dng_sdk/dng_lossless_jpeg.cpp delete mode 100644 third_party/dng_sdk/dng_lossless_jpeg.h delete mode 100644 third_party/dng_sdk/dng_matrix.cpp delete mode 100644 third_party/dng_sdk/dng_matrix.h delete mode 100644 third_party/dng_sdk/dng_memory.cpp delete mode 100644 third_party/dng_sdk/dng_memory.h delete mode 100644 third_party/dng_sdk/dng_memory_stream.cpp delete mode 100644 third_party/dng_sdk/dng_memory_stream.h delete mode 100644 third_party/dng_sdk/dng_misc_opcodes.cpp delete mode 100644 third_party/dng_sdk/dng_misc_opcodes.h delete mode 100644 third_party/dng_sdk/dng_mosaic_info.cpp delete mode 100644 third_party/dng_sdk/dng_mosaic_info.h delete mode 100644 third_party/dng_sdk/dng_mutex.cpp delete mode 100644 third_party/dng_sdk/dng_mutex.h delete mode 100644 third_party/dng_sdk/dng_negative.cpp delete mode 100644 third_party/dng_sdk/dng_negative.h delete mode 100644 third_party/dng_sdk/dng_opcode_list.cpp delete mode 100644 third_party/dng_sdk/dng_opcode_list.h delete mode 100644 third_party/dng_sdk/dng_opcodes.cpp delete mode 100644 third_party/dng_sdk/dng_opcodes.h delete mode 100644 third_party/dng_sdk/dng_orientation.cpp delete mode 100644 third_party/dng_sdk/dng_orientation.h delete mode 100644 third_party/dng_sdk/dng_parse_utils.cpp delete mode 100644 third_party/dng_sdk/dng_parse_utils.h delete mode 100644 third_party/dng_sdk/dng_pixel_buffer.cpp delete mode 100644 third_party/dng_sdk/dng_pixel_buffer.h delete mode 100644 third_party/dng_sdk/dng_point.cpp delete mode 100644 third_party/dng_sdk/dng_point.h delete mode 100644 third_party/dng_sdk/dng_preview.cpp delete mode 100644 third_party/dng_sdk/dng_preview.h delete mode 100644 third_party/dng_sdk/dng_pthread.cpp delete mode 100644 third_party/dng_sdk/dng_pthread.h delete mode 100644 third_party/dng_sdk/dng_rational.cpp delete mode 100644 third_party/dng_sdk/dng_rational.h delete mode 100644 third_party/dng_sdk/dng_read_image.cpp delete mode 100644 third_party/dng_sdk/dng_read_image.h delete mode 100644 third_party/dng_sdk/dng_rect.cpp delete mode 100644 third_party/dng_sdk/dng_rect.h delete mode 100644 third_party/dng_sdk/dng_ref_counted_block.cpp delete mode 100644 third_party/dng_sdk/dng_ref_counted_block.h delete mode 100644 third_party/dng_sdk/dng_reference.cpp delete mode 100644 third_party/dng_sdk/dng_reference.h delete mode 100644 third_party/dng_sdk/dng_render.cpp delete mode 100644 third_party/dng_sdk/dng_render.h delete mode 100644 third_party/dng_sdk/dng_resample.cpp delete mode 100644 third_party/dng_sdk/dng_resample.h delete mode 100644 third_party/dng_sdk/dng_sdk_limits.h delete mode 100644 third_party/dng_sdk/dng_shared.cpp delete mode 100644 third_party/dng_sdk/dng_shared.h delete mode 100644 third_party/dng_sdk/dng_simple_image.cpp delete mode 100644 third_party/dng_sdk/dng_simple_image.h delete mode 100644 third_party/dng_sdk/dng_spline.cpp delete mode 100644 third_party/dng_sdk/dng_spline.h delete mode 100644 third_party/dng_sdk/dng_stream.cpp delete mode 100644 third_party/dng_sdk/dng_stream.h delete mode 100644 third_party/dng_sdk/dng_string.cpp delete mode 100644 third_party/dng_sdk/dng_string.h delete mode 100644 third_party/dng_sdk/dng_string_list.cpp delete mode 100644 third_party/dng_sdk/dng_string_list.h delete mode 100644 third_party/dng_sdk/dng_tag_codes.h delete mode 100644 third_party/dng_sdk/dng_tag_types.cpp delete mode 100644 third_party/dng_sdk/dng_tag_types.h delete mode 100644 third_party/dng_sdk/dng_tag_values.h delete mode 100644 third_party/dng_sdk/dng_temperature.cpp delete mode 100644 third_party/dng_sdk/dng_temperature.h delete mode 100644 third_party/dng_sdk/dng_tile_iterator.cpp delete mode 100644 third_party/dng_sdk/dng_tile_iterator.h delete mode 100644 third_party/dng_sdk/dng_tone_curve.cpp delete mode 100644 third_party/dng_sdk/dng_tone_curve.h delete mode 100644 third_party/dng_sdk/dng_types.h delete mode 100644 third_party/dng_sdk/dng_uncopyable.h delete mode 100644 third_party/dng_sdk/dng_utils.cpp delete mode 100644 third_party/dng_sdk/dng_utils.h delete mode 100644 third_party/dng_sdk/dng_validate.cpp delete mode 100644 third_party/dng_sdk/dng_xmp.cpp delete mode 100644 third_party/dng_sdk/dng_xmp.h delete mode 100644 third_party/dng_sdk/dng_xmp_sdk.cpp delete mode 100644 third_party/dng_sdk/dng_xmp_sdk.h delete mode 100644 third_party/dng_sdk/dng_xy_coord.cpp delete mode 100644 third_party/dng_sdk/dng_xy_coord.h diff --git a/DngWriter.cpp b/DngWriter.cpp deleted file mode 100644 index 226147d..0000000 --- a/DngWriter.cpp +++ /dev/null @@ -1,344 +0,0 @@ -/* - * HDRMerge - HDR exposure merging software. - * Copyright 2012 Javier Celaya - * jcelaya@gmail.com - * - * This file is part of HDRMerge. - * - * HDRMerge is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * HDRMerge is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with HDRMerge. If not, see . - * - */ - -#include -#include -#include "config.h" -#include "DngWriter.hpp" -#include "dng_image.h" -#include "dng_rect.h" -#include "dng_auto_ptr.h" -#include "dng_xmp_sdk.h" -#include "dng_xmp.h" -#include "dng_exif.h" -#include "dng_tag_values.h" -#include "dng_file_stream.h" -#include "dng_memory_stream.h" -#include "dng_color_space.h" -#include "dng_image_writer.h" -#include "dng_camera_profile.h" -#include "dng_render.h" -#include "dng_simple_image.h" -#include "exiv2meta.h" -using namespace std; - - -namespace hdrmerge { - -class DngFloatImage : public dng_image { -public: - DngFloatImage(size_t w, size_t h, dng_memory_allocator & a) - : dng_image(dng_rect(h, w), 1, ttFloat), allocator(a) { - memory.Reset(allocator.Allocate(w*h*4)); - buffer.fArea = fBounds; - buffer.fPlane = 0; - buffer.fPlanes = 1; - buffer.fRowStep = w; - buffer.fColStep = 1; - buffer.fPlaneStep = 1; - buffer.fPixelType = ttFloat; - buffer.fPixelSize = 4; - buffer.fData = memory->Buffer(); - } - - virtual dng_image * Clone () const { - DngFloatImage * result = new DngFloatImage(fBounds.W(), fBounds.H(), allocator); - result->buffer.CopyArea(buffer, fBounds, 0, 1); - return result; - } - - float * getImageBuffer() { - return (float *)memory->Buffer(); - } - -protected: - virtual void AcquireTileBuffer(dng_tile_buffer & tBuffer, const dng_rect & area, bool dirty) const { - (dng_pixel_buffer &)tBuffer = buffer; - tBuffer.fArea = area; - tBuffer.fData = (void *) buffer.ConstPixel(area.t, area.l); - tBuffer.fDirty = dirty; - } - -private: - dng_pixel_buffer buffer; - AutoPtr memory; - dng_memory_allocator & allocator; -}; - - -// This is the default behavior, but just in case it changes... -dng_image * DngWriter::BasicHost::Make_dng_image(const dng_rect &bounds, uint32 planes, uint32 pixelType) { - dng_image * result = new dng_simple_image(bounds, planes, pixelType, Allocator()); - if (!result) { - ThrowMemoryFull(); - } - return result; -} - - -DngWriter::DngWriter(const ImageStack & s, ProgressIndicator & pi) -: progress(pi), memalloc(gDefaultDNGMemoryAllocator), host(&memalloc), negative(host), -stack(s), appVersion("HDRMerge " HDRMERGE_VERSION_STRING), previewWidth(s.getWidth()), bps(16) { - host.SetSaveDNGVersion(dngVersion_SaveDefault); - host.SetSaveLinearDNG(false); - host.SetKeepOriginalFile(false); - CurrentDateTimeAndZone(dateTimeNow); -} - - -void DngWriter::buildExifMetadata() { - // Exif CFA Pattern - const dng_mosaic_info * mosaicinfo = negative.GetMosaicInfo(); - if (mosaicinfo != nullptr) { - dng_exif* exifData = negative.GetExif(); - exifData->fCFARepeatPatternCols = mosaicinfo->fCFAPatternSize.v; - exifData->fCFARepeatPatternRows = mosaicinfo->fCFAPatternSize.h; - for (uint16 c = 0; c < exifData->fCFARepeatPatternCols; c++) { - for (uint16 r = 0; r < exifData->fCFARepeatPatternRows; r++) { - exifData->fCFAPattern[r][c] = mosaicinfo->fCFAPattern[c][r]; - } - } - } - - dng_file_stream stream(stack.getImage(stack.size() - 1).getMetaData().fileName.c_str()); - Exiv2Meta exiv2Meta; - exiv2Meta.Parse(host, stream); - exiv2Meta.PostParse(host); - - // Exif Data - dng_xmp xmpSync(memalloc); - dng_exif * exifData = exiv2Meta.GetExif(); - exifData->fDateTime = dateTimeNow; - exifData->fSoftware.Set_ASCII(appVersion.c_str()); - if (exifData != nullptr) { - xmpSync.SyncExif(*exifData); - AutoPtr xmpBlock(xmpSync.Serialize()); - negative.SetXMP(host, xmpBlock->Buffer(), xmpBlock->LogicalSize()); - negative.SynchronizeMetadata(); - } - - // XMP Data - dng_xmp* xmpData = exiv2Meta.GetXMP(); - if (xmpData != nullptr) { - AutoPtr xmpBlock(xmpData->Serialize()); - negative.SetXMP(host, xmpBlock->Buffer(), xmpBlock->LogicalSize(), false); - negative.SynchronizeMetadata(); - } - - // Makernote backup. - if ((exiv2Meta.MakerNoteLength() > 0) && (exiv2Meta.MakerNoteByteOrder().Length() == 2)) { - dng_memory_stream streamPriv(memalloc); - streamPriv.SetBigEndian(); - streamPriv.Put("Adobe", 5); - streamPriv.Put_uint8(0x00); - streamPriv.Put("MakN", 4); - streamPriv.Put_uint32(exiv2Meta.MakerNoteLength() + exiv2Meta.MakerNoteByteOrder().Length() + 4); - streamPriv.Put(exiv2Meta.MakerNoteByteOrder().Get(), exiv2Meta.MakerNoteByteOrder().Length()); - streamPriv.Put_uint32(exiv2Meta.MakerNoteOffset()); - streamPriv.Put(exiv2Meta.MakerNoteData(), exiv2Meta.MakerNoteLength()); - AutoPtr blockPriv(host.Allocate(static_cast(streamPriv.Length()))); - streamPriv.SetReadPosition(0); - streamPriv.Get(blockPriv->Buffer(), static_cast(streamPriv.Length())); - negative.SetPrivateData(blockPriv); - } - - negative.RebuildIPTC(true); - negative.SetModelName(negative.GetExif()->fModel.Get()); -} - - -void DngWriter::buildNegative() { - const MetaData & md = stack.getImage(0).getMetaData(); - - negative.SetDefaultScale(dng_urational(1, 1), dng_urational(1, 1)); - negative.SetDefaultCropOrigin(dng_urational(0, 1), dng_urational(0, 1)); - negative.SetDefaultCropSize(dng_urational(stack.getWidth(), 1), dng_urational(stack.getHeight(), 1)); - negative.SetActiveArea(dng_rect(stack.getHeight(), stack.getWidth())); - negative.SetColorChannels(3); // RGBG - negative.SetColorKeys(colorKeyRed, colorKeyGreen, colorKeyBlue, colorKeyGreen); - - uint32_t patterns[4] = {0xe1e1e1e1, 0xb4b4b4b4, 0x1e1e1e1e, 0x4b4b4b4b}; - uint32 bayerMosaic = 0; - while (bayerMosaic < 4 && patterns[bayerMosaic] != md.filters) { - ++bayerMosaic; - } - if (bayerMosaic < 4) { - negative.SetBayerMosaic(bayerMosaic); - } - - for (int i = 0; i < 4; ++i) { - negative.SetWhiteLevel(1, i); - } - negative.SetBlackLevel(0, 0); - - negative.SetBaselineExposure(0.0); - negative.SetBaselineNoise(1.0); - negative.SetBaselineSharpness(1.0); - switch (md.flip) { - case 3: negative.SetBaseOrientation(dng_orientation::Rotate180()); break; - case 5: negative.SetBaseOrientation(dng_orientation::Rotate90CCW()); break; - case 6: negative.SetBaseOrientation(dng_orientation::Rotate90CW()); break; - default: negative.SetBaseOrientation(dng_orientation::Normal()); break; - } - negative.SetAntiAliasStrength(dng_urational(100, 100)); - negative.SetLinearResponseLimit(1.0); - negative.SetShadowScale(dng_urational(1, 1)); - negative.SetAnalogBalance(dng_vector_3(1.0, 1.0, 1.0)); - - AutoPtr prof(new dng_camera_profile); -// if (profilefilename != nullptr) { -// dng_file_stream profStream(profilefilename); -// prof->ParseExtended(profStream); -// } else - { - string profName(md.maker + " " + md.model); - prof->SetName(profName.c_str()); - dng_matrix_3by3 camXYZ; - camXYZ[0][0] = md.camXyz[0][0]; - camXYZ[0][1] = md.camXyz[0][1]; - camXYZ[0][2] = md.camXyz[0][2]; - camXYZ[1][0] = md.camXyz[1][0]; - camXYZ[1][1] = md.camXyz[1][1]; - camXYZ[1][2] = md.camXyz[1][2]; - camXYZ[2][0] = md.camXyz[2][0]; - camXYZ[2][1] = md.camXyz[2][1]; - camXYZ[2][2] = md.camXyz[2][2]; - if (camXYZ.MaxEntry() == 0.0) { - printf("Warning, camera XYZ Matrix is null\n"); - camXYZ = dng_matrix_3by3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0); - } - prof->SetColorMatrix1((dng_matrix) camXYZ); - prof->SetCalibrationIlluminant1(lsD65); - } - negative.AddProfile(prof); - dng_vector cameraNeutral(3); - for (int c = 0; c < 3; ++c) { - cameraNeutral[c] = 1.0 / md.camMul[c]; - } - negative.SetCameraNeutral(cameraNeutral); - - buildExifMetadata(); -} - - -void DngWriter::buildPreviewList() { - negative.BuildStage2Image(host); - negative.BuildStage3Image(host); - - AutoPtr thumbnail(new dng_image_preview); - dng_render thumbnail_render(host, negative); - thumbnail_render.SetFinalSpace(dng_space_sRGB::Get()); - thumbnail_render.SetFinalPixelType(ttByte); - thumbnail_render.SetMaximumSize(256); - ((dng_image_preview *)thumbnail.Get())->fImage.Reset(thumbnail_render.Render()); - previewList.Append(thumbnail); - - if (previewWidth) { - addJpegPreview(); - } -} - - -void DngWriter::addJpegPreview() { - AutoPtr renderedPreview; - dng_render jpeg_render(host, negative); - jpeg_render.SetFinalSpace(dng_space_sRGB::Get()); - jpeg_render.SetFinalPixelType(ttByte); - renderedPreview.Reset((dng_simple_image *)jpeg_render.Render()); - dng_pixel_buffer pbuffer; - renderedPreview->GetPixelBuffer(pbuffer); - - size_t width = pbuffer.fArea.W(), height = pbuffer.fArea.H(); - QImage pre_image(width, height, QImage::Format_RGB888); - std::copy_n((uchar *)pbuffer.fData, width*height*3, pre_image.bits()); - pre_image = pre_image.scaledToWidth(previewWidth); - QByteArray ba; - QBuffer buffer(&ba); - buffer.open(QIODevice::WriteOnly); - pre_image.save(&buffer, "JPEG", 90); - - // Load JPEG preview file data in DNG preview container. - AutoPtr jpeg_preview; - jpeg_preview.Reset(new dng_jpeg_preview); - jpeg_preview->fPhotometricInterpretation = piYCbCr; - jpeg_preview->fYCbCrSubSampling = dng_point(2, 2); - jpeg_preview->fPreviewSize.v = pre_image.height(); - jpeg_preview->fPreviewSize.h = pre_image.width(); - jpeg_preview->fCompressedData.Reset(host.Allocate(ba.size())); - jpeg_preview->fInfo.fApplicationName.Set_ASCII("HDRMerge"); - jpeg_preview->fInfo.fApplicationVersion.Set_ASCII(appVersion.c_str()); - jpeg_preview->fInfo.fDateTime = dateTimeNow.Encode_ISO_8601(); - jpeg_preview->fInfo.fColorSpace = previewColorSpace_sRGB; - std::copy_n(ba.data(), ba.size(), jpeg_preview->fCompressedData->Buffer_char()); - - AutoPtr pp((dng_preview *)jpeg_preview.Release()); - previewList.Append(pp); -} - - -void DngWriter::buildIndexImage() { - size_t width = stack.getWidth(), height = stack.getHeight(); - QImage indexImage(width, height, QImage::Format_Indexed8); - int numColors = stack.size() - 1; - for (int c = 0; c < numColors; ++c) { - int gray = (256 * c) / numColors; - indexImage.setColor(c, qRgb(gray, gray, gray)); - } - indexImage.setColor(numColors, qRgb(255, 255, 255)); - for (size_t row = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col) { - indexImage.setPixel(col, row, stack.getImageAt(col, row)); - } - } - indexImage.save(indexFile); -} - - -void DngWriter::write(const string & filename) { - progress.advance(0, "Initialize negative"); - dng_xmp_sdk::InitializeSDK(); - - buildNegative(); - - progress.advance(25, "Rendering image"); - AutoPtr imageData(new DngFloatImage(stack.getWidth(), stack.getHeight(), memalloc)); - stack.compose(((DngFloatImage *)imageData.Get())->getImageBuffer()); - negative.SetStage1Image(imageData); - negative.SetRawFloatBitDepth(bps); - - if (!indexFile.isEmpty()) - buildIndexImage(); - - progress.advance(50, "Rendering preview"); - buildPreviewList(); - - progress.advance(75, "Writing output"); - dng_image_writer writer; - dng_file_stream filestream(filename.c_str(), true); - writer.WriteDNG(host, filestream, negative, &previewList); - - dng_xmp_sdk::TerminateSDK(); - progress.advance(100, "Done writing!"); -} - - -} // namespace hdrmerge diff --git a/DngWriter.hpp b/DngWriter.hpp deleted file mode 100644 index bc4ae70..0000000 --- a/DngWriter.hpp +++ /dev/null @@ -1,88 +0,0 @@ -/* - * HDRMerge - HDR exposure merging software. - * Copyright 2012 Javier Celaya - * jcelaya@gmail.com - * - * This file is part of HDRMerge. - * - * HDRMerge is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * HDRMerge is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with HDRMerge. If not, see . - * - */ - -#ifndef _DNGWRITER_HPP_ -#define _DNGWRITER_HPP_ - -#include -#include -#include "config.h" -#include "dng_memory.h" -#include "dng_host.h" -#include "dng_negative.h" -#include "dng_preview.h" -#include "dng_date_time.h" -#include "ImageStack.hpp" -#include "ProgressIndicator.hpp" - -namespace hdrmerge { - -class DngWriter { -public: - DngWriter(const ImageStack & s, ProgressIndicator & pi); - - void setPreviewWidth(size_t w) { - previewWidth = w; - } - void setBitsPerSample(int b) { - bps = b; - } - void setIndexFileName(const QString & name) { - indexFile = name; - } - void write(const std::string & filename); - -private: - class BasicHost : public dng_host { - public: - BasicHost(dng_memory_allocator *allocator) : dng_host(allocator, NULL) {} - dng_image * Make_dng_image(const dng_rect &bounds, uint32 planes, uint32 pixelType); - }; - - class DummyNegative : public dng_negative { - public: - DummyNegative(dng_host & host) : dng_negative(host) {} - }; - - ProgressIndicator & progress; - dng_memory_allocator memalloc; - BasicHost host; - DummyNegative negative; - dng_preview_list previewList; - dng_date_time_info dateTimeNow; - const ImageStack & stack; - const std::string appVersion; - - size_t previewWidth; - int bps; - QString indexFile; - - void buildNegative(); - void buildPreviewList(); - void buildExifMetadata(); - void addJpegPreview(); - void buildIndexImage(); -}; - -} // namespace hdrmerge - -#endif // _DNGWRITER_HPP_ diff --git a/README.md b/README.md index 2376cc6..7ead29b 100644 --- a/README.md +++ b/README.md @@ -66,28 +66,13 @@ Currently, HDRMerge is only supported in Linux. HDRMerge depends on: * Qt (tested with version 4.8) * LibRaw (tested with version 0.16.0) * Exiv2 (tested with version 0.23) -* DNG SDK 1.4 (its source code is included with HDRMerge) -* XMP SDK (tested with version CC 2013.06) +* ZLib (tested with version 1.2.7) You will need the development files of these libraries, CMake version 2.8.8 or greater and gcc 4.8 or greater. -## Building the XMP SDK - -You can obtain the Adobe XMP SDK from . To build it: - -1. Unzip the sdk in the `third_party` directory. -+ Rename the XMP SDK directory as `xmp_sdk`. -+ Cd into `xmp_sdk/third_party` and follow the instructions to download libexpat and zlib. -+ Cd into `xmp_sdk/build` and run 'make StaticAll'. Known problems: - - Depending on your version of gcc, it may give lots of warnings, just ignore them. - - It may fail at `shared/SharedConfig_Common.cmake`, comment out the lines failing. - - Also, `XMPFiles/source/NativeMetadataSupport/ValueObject.h` should include `string.h`. -+ Move or symlink `public/libraries/*/release/staticXMPCore.ar` to - `public/libraries/libXMPCore.a` (note that you must change its name: starts with **lib**, ends with **.a**). The same with `public/libraries/*/release/staticXMPFiles.ar`, named as `libXMPFiles.a`. - ## Building HDRMerge -Once the XMP SDK is compiled, the steps to compile and install HDRMerge are: +The steps to compile and install HDRMerge are: $ mkdir build; cd build $ cmake .. diff --git a/exiv2dngstreamio.cpp b/exiv2dngstreamio.cpp deleted file mode 100644 index c561441..0000000 --- a/exiv2dngstreamio.cpp +++ /dev/null @@ -1,202 +0,0 @@ -/* This file is part of the dngconvert project - Copyright (C) 2011 Jens Mueller - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with this library; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#include "exiv2dngstreamio.h" - -#include "dng_exceptions.h" -#include "dng_memory_stream.h" - -#include -#include -#include - -using std::min; -using std::max; - -Exiv2DngStreamIO::Exiv2DngStreamIO(dng_stream& stream, dng_memory_allocator &allocator) - : m_Allocator(allocator), m_MemBlock(0), m_Stream(stream) -{ -} - -Exiv2DngStreamIO::~Exiv2DngStreamIO(void) -{ -} - -int Exiv2DngStreamIO::open() -{ - m_Stream.SetReadPosition(0); - return 0; -} - -int Exiv2DngStreamIO::close() -{ - m_Stream.Flush(); - return 0; -} - -long Exiv2DngStreamIO::write(const Exiv2::byte* data, long wcount) -{ - uint64 oldPos = m_Stream.Position(); - m_Stream.Get((void*)data, wcount); - return (long)(m_Stream.Position() - oldPos); -} - -long Exiv2DngStreamIO::write(BasicIo& src) -{ - if (static_cast(this) == &src) - return 0; - if (!src.isopen()) - return 0; - - Exiv2::byte buf[4096]; - long readCount = 0; - long writeTotal = 0; - while ((readCount = src.read(buf, sizeof(buf)))) - { - write(buf, readCount); - writeTotal += readCount; - } - - return writeTotal; -} - -int Exiv2DngStreamIO::putb(Exiv2::byte data) -{ - m_Stream.Put_uint8(data); - return data; -} - -Exiv2::DataBuf Exiv2DngStreamIO::read(long rcount) -{ - Exiv2::DataBuf buf(rcount); - long readCount = read(buf.pData_, buf.size_); - buf.size_ = readCount; - return buf; -} - -long Exiv2DngStreamIO::read(Exiv2::byte* buf, long rcount) -{ - uint64 oldPos = m_Stream.Position(); - uint64 bytes = min(static_cast(rcount), m_Stream.Length() - oldPos); - m_Stream.Get((void*)buf, static_cast(bytes)); - return (long)(m_Stream.Position() - oldPos); -} - -int Exiv2DngStreamIO::getb() -{ - return m_Stream.Get_uint8(); -} - -void Exiv2DngStreamIO::transfer(BasicIo& src) -{ - // Generic reopen to reset position to start - if (src.open() != 0) - { - throw Exiv2::Error(9, src.path(), Exiv2::strError()); - } - m_Stream.SetReadPosition(0); - m_Stream.SetLength(0); - write(src); - src.close(); - - if (error() || src.error()) - throw Exiv2::Error(19, Exiv2::strError()); -} - -int Exiv2DngStreamIO::seek(long offset, Position pos) -{ - uint64 newIdx = 0; - uint64 length = m_Stream.Length(); - switch (pos) - { - case BasicIo::cur: - newIdx = m_Stream.Position() + offset; - break; - case BasicIo::beg: - newIdx = offset; - break; - case BasicIo::end: - newIdx = length + offset; - break; - } - - if (newIdx > length) - return 1; - - m_Stream.SetReadPosition(newIdx); - - return 0; -} - -Exiv2::byte* Exiv2DngStreamIO::mmap(bool /*isWriteable*/) -{ - m_MemBlock = std::auto_ptr(m_Stream.AsMemoryBlock(m_Allocator)); - return (Exiv2::byte*)m_MemBlock.get()->Buffer(); -} - -int Exiv2DngStreamIO::munmap() -{ - m_Stream.SetReadPosition(0); - m_Stream.SetLength(0); - m_Stream.Put(m_MemBlock.get()->Buffer(), m_MemBlock.get()->LogicalSize()); - m_MemBlock.release(); - return 0; -} - -long Exiv2DngStreamIO::tell() const -{ - return (long)m_Stream.Position(); -} - -long Exiv2DngStreamIO::size() const -{ - return (long)m_Stream.Length(); -} - -bool Exiv2DngStreamIO::isopen() const -{ - return true; -} - -int Exiv2DngStreamIO::error() const -{ - return 0; -} - -bool Exiv2DngStreamIO::eof() const -{ - return m_Stream.Position() >= m_Stream.Length(); -} - -std::string Exiv2DngStreamIO::path() const -{ - return "Exiv2DngStreamIO"; -} - -#ifdef EXV_UNICODE_PATH -std::wstring Exiv2DngStreamIO::wpath() const -{ - return EXV_WIDEN("Exiv2DngStreamIO"); -} -#endif - -Exiv2::BasicIo::AutoPtr Exiv2DngStreamIO::temporary() const -{ - return Exiv2::BasicIo::AutoPtr(new Exiv2::MemIo()); -} diff --git a/exiv2dngstreamio.h b/exiv2dngstreamio.h deleted file mode 100644 index cf23be9..0000000 --- a/exiv2dngstreamio.h +++ /dev/null @@ -1,61 +0,0 @@ -/* This file is part of the dngconvert project - Copyright (C) 2011 Jens Mueller - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with this library; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#pragma once - -#include -#include - -#include "dng_stream.h" -#include "dng_memory.h" - -class Exiv2DngStreamIO : public Exiv2::BasicIo -{ -public: - Exiv2DngStreamIO(dng_stream& stream, dng_memory_allocator &allocator = gDefaultDNGMemoryAllocator); - ~Exiv2DngStreamIO(void); - - virtual int open(); - virtual int close(); - virtual long write(const Exiv2::byte* data, long wcount); - virtual long write(BasicIo& src); - virtual int putb(Exiv2::byte data); - virtual Exiv2::DataBuf read(long rcount); - virtual long read(Exiv2::byte* buf, long rcount); - virtual int getb(); - virtual void transfer(BasicIo& src); - virtual int seek(long offset, Position pos); - virtual Exiv2::byte* mmap(bool isWriteable =false); - virtual int munmap(); - virtual long tell() const; - virtual long size() const; - virtual bool isopen() const; - virtual int error() const; - virtual bool eof() const; - virtual std::string path() const; -#ifdef EXV_UNICODE_PATH - virtual std::wstring wpath() const; -#endif - virtual Exiv2::BasicIo::AutoPtr temporary() const; - -protected: - dng_memory_allocator &m_Allocator; - std::auto_ptr m_MemBlock; - dng_stream& m_Stream; -}; diff --git a/exiv2meta.cpp b/exiv2meta.cpp deleted file mode 100644 index 95cab20..0000000 --- a/exiv2meta.cpp +++ /dev/null @@ -1,608 +0,0 @@ -/* This file is part of the dngconvert project - Copyright (C) 2011 Jens Mueller - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with this library; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#include "exiv2meta.h" -#include "exiv2dngstreamio.h" - -#include -#include - -#include -#include - -#ifdef WIN32 -#define snprintf _snprintf -#include -#endif - -void printExiv2ExceptionError(const char* msg, Exiv2::Error& e) -{ - std::string s(e.what()); - fprintf(stderr, "Exiv2: %s (Error #%i: %s)\n", msg, e.code(), s.c_str()); -} - -bool getExifTag(const Exiv2::ExifData& exifData, const char* exifTagName, dng_string* value) -{ - try - { - Exiv2::ExifKey exifKey(exifTagName); - Exiv2::ExifData::const_iterator it = exifData.findKey(exifKey); - if (it != exifData.end()) - { - value->Set_ASCII((it->print(&exifData)).c_str()); - value->TrimLeadingBlanks(); - value->TrimTrailingBlanks(); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif String value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -bool getExifTag(const Exiv2::ExifData& exifData, const char* exifTagName, dng_date_time_info* value) -{ - try - { - Exiv2::ExifKey exifKey(exifTagName); - Exiv2::ExifData::const_iterator it = exifData.findKey(exifKey); - if (it != exifData.end()) - { - dng_date_time dt; - dt.Parse((it->print(&exifData)).c_str()); - value->SetDateTime(dt); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif String value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -bool getExifTag(const Exiv2::ExifData& exifData, const char* exifTagName, int32 component, dng_srational* rational) -{ - try - { - Exiv2::ExifData::const_iterator it = exifData.findKey(Exiv2::ExifKey(exifTagName)); - if (it != exifData.end()) - { - Exiv2::Rational exiv2Rational = (*it).toRational(component); - *rational = dng_srational(exiv2Rational.first, exiv2Rational.second); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif Rational value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -bool getExifTag(const Exiv2::ExifData& exifData, const char* exifTagName, int32 component, dng_urational* rational) -{ - try - { - Exiv2::ExifData::const_iterator it = exifData.findKey(Exiv2::ExifKey(exifTagName)); - if (it != exifData.end()) - { - Exiv2::URational exiv2Rational = (*it).toRational(component); - *rational = dng_urational(exiv2Rational.first, exiv2Rational.second); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif Rational value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -bool getExifTag(const Exiv2::ExifData& exifData, const char* exifTagName, int32 component, uint32* value) -{ - try - { - Exiv2::ExifData::const_iterator it = exifData.findKey(Exiv2::ExifKey(exifTagName)); - if (it != exifData.end() && it->count() > 0) - { - *value = static_cast(it->toLong(component)); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif Long value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -bool getExifTagData(const Exiv2::ExifData& exifData, const char* exifTagName, long* size, unsigned char** data) -{ - try - { - Exiv2::ExifData::const_iterator it = exifData.findKey(Exiv2::ExifKey(exifTagName)); - if (it != exifData.end()) - { - *data = new unsigned char[(*it).size()]; - *size = (*it).size(); - (*it).copy((Exiv2::byte*)*data, Exiv2::bigEndian); - return true; - } - } - catch(Exiv2::Error& e) - { - std::string err = std::string("Cannot find Exif value from key '") + std::string(exifTagName); - printExiv2ExceptionError(err.c_str(), e); - } - - return false; -} - -Exiv2Meta::Exiv2Meta() : - m_Exif(), - m_XMP(), - m_MakerNote(), - m_MakerNoteOffset(0) -{ - Exiv2::LogMsg::setLevel(Exiv2::LogMsg::mute); -} - -Exiv2Meta::~Exiv2Meta() -{ - -} - -void Exiv2Meta::Parse(dng_host &host, dng_stream &stream) -{ - m_Exif.Reset(new dng_exif()); - - try - { - Exiv2::BasicIo::AutoPtr exiv2Stream(new Exiv2DngStreamIO(stream)); - Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(exiv2Stream); - - if (!image.get()) - { - fprintf(stderr, "Exiv2Meta: Stream is not readable\n"); - return; - } - - image->readMetadata(); - - // Image comments --------------------------------- - std::string imageComments = image->comment(); - - // Exif metadata ---------------------------------- - Exiv2::ExifData exifData = image->exifData(); - - // Iptc metadata ---------------------------------- - Exiv2::IptcData iptcData = image->iptcData(); - - // Xmp metadata ----------------------------------- - Exiv2::XmpData xmpData = image->xmpData(); - - dng_string str; - dng_urational urat = dng_urational(0, 0); - uint32 val = 0; - - // Standard Exif tags - - getExifTag(exifData, "Exif.Image.Artist", &m_Exif->fArtist); - getExifTag(exifData, "Exif.Image.BatteryLevel", 0, &m_Exif->fBatteryLevelR); - getExifTag(exifData, "Exif.Image.CameraSerialNumber", &m_Exif->fCameraSerialNumber); - getExifTag(exifData, "Exif.Image.Copyright", &m_Exif->fCopyright); - getExifTag(exifData, "Exif.Image.DateTime", &m_Exif->fDateTime); - getExifTag(exifData, "Exif.Image.Make", &m_Exif->fMake); - getExifTag(exifData, "Exif.Image.Model", &m_Exif->fModel); - getExifTag(exifData, "Exif.Image.ImageDescription", &m_Exif->fImageDescription); - getExifTag(exifData, "Exif.Image.Software", &m_Exif->fSoftware); - getExifTag(exifData, "Exif.Photo.ApertureValue", 0, &m_Exif->fApertureValue); -#if (EXIV2_TEST_VERSION(0,22,0)) - getExifTag(exifData, "Exif.Photo.BodySerialNumber", &m_Exif->fCameraSerialNumber); -#endif - getExifTag(exifData, "Exif.Photo.BrightnessValue", 0, &m_Exif->fBrightnessValue); -#if (EXIV2_TEST_VERSION(0,22,0)) - getExifTag(exifData, "Exif.Photo.CameraOwnerName", &m_Exif->fOwnerName); -#endif - getExifTag(exifData, "Exif.Photo.ComponentsConfiguration", 0, &m_Exif->fComponentsConfiguration); - getExifTag(exifData, "Exif.Photo.Contrast", 0, &m_Exif->fContrast); - getExifTag(exifData, "Exif.Photo.CustomRendered", 0, &m_Exif->fCustomRendered); - getExifTag(exifData, "Exif.Photo.DateTimeDigitized", &m_Exif->fDateTimeDigitized); - getExifTag(exifData, "Exif.Photo.DateTimeOriginal", &m_Exif->fDateTimeOriginal); - getExifTag(exifData, "Exif.Photo.DigitalZoomRatio", 0, &m_Exif->fDigitalZoomRatio); - getExifTag(exifData, "Exif.Photo.ExposureBiasValue", 0, &m_Exif->fExposureBiasValue); - getExifTag(exifData, "Exif.Photo.ExposureMode", 0, &m_Exif->fExposureMode); - getExifTag(exifData, "Exif.Photo.ExposureProgram", 0, &m_Exif->fExposureProgram); - getExifTag(exifData, "Exif.Photo.ExposureTime", 0, &m_Exif->fExposureTime); - getExifTag(exifData, "Exif.Photo.FileSource", 0, &m_Exif->fFileSource); - getExifTag(exifData, "Exif.Photo.Flash", 0, &m_Exif->fFlash); - getExifTag(exifData, "Exif.Photo.FNumber", 0, &m_Exif->fFNumber); - getExifTag(exifData, "Exif.Photo.FocalPlaneResolutionUnit", 0, &m_Exif->fFocalPlaneResolutionUnit); - getExifTag(exifData, "Exif.Photo.FocalPlaneXResolution", 0, &m_Exif->fFocalPlaneXResolution); - getExifTag(exifData, "Exif.Photo.FocalPlaneYResolution", 0, &m_Exif->fFocalPlaneYResolution); - getExifTag(exifData, "Exif.Photo.FocalLength", 0, &m_Exif->fFocalLength); - getExifTag(exifData, "Exif.Photo.FocalLengthIn35mmFilm", 0, &m_Exif->fFocalLengthIn35mmFilm); - getExifTag(exifData, "Exif.Photo.GainControl", 0, &m_Exif->fGainControl); - getExifTag(exifData, "Exif.Photo.ISOSpeedRatings", 0, &m_Exif->fISOSpeedRatings[0]); - getExifTag(exifData, "Exif.Photo.LightSource", 0, &m_Exif->fLightSource); -#if (EXIV2_TEST_VERSION(0,22,0)) - getExifTag(exifData, "Exif.Photo.LensModel", &m_Exif->fLensName); - getExifTag(exifData, "Exif.Photo.LensSpecification", 0, &m_Exif->fLensInfo[0]); - getExifTag(exifData, "Exif.Photo.LensSpecification", 1, &m_Exif->fLensInfo[1]); - getExifTag(exifData, "Exif.Photo.LensSpecification", 2, &m_Exif->fLensInfo[2]); - getExifTag(exifData, "Exif.Photo.LensSpecification", 3, &m_Exif->fLensInfo[3]); - getExifTag(exifData, "Exif.Photo.LensSerialNumber", &m_Exif->fLensSerialNumber); -#endif - getExifTag(exifData, "Exif.Photo.MaxApertureValue", 0, &m_Exif->fMaxApertureValue); - getExifTag(exifData, "Exif.Photo.MeteringMode", 0, &m_Exif->fMeteringMode); - getExifTag(exifData, "Exif.Photo.PixelXDimension", 0, &m_Exif->fPixelXDimension); - getExifTag(exifData, "Exif.Photo.PixelYDimension", 0, &m_Exif->fPixelYDimension); - getExifTag(exifData, "Exif.Photo.Saturation", 0, &m_Exif->fSaturation); - getExifTag(exifData, "Exif.Photo.SceneCaptureType", 0, &m_Exif->fSceneCaptureType); - getExifTag(exifData, "Exif.Photo.SceneType", 0, &m_Exif->fSceneType); - getExifTag(exifData, "Exif.Photo.SensingMethod", 0, &m_Exif->fSensingMethod); - getExifTag(exifData, "Exif.Photo.Sharpness", 0, &m_Exif->fSharpness); - getExifTag(exifData, "Exif.Photo.ShutterSpeedValue", 0, &m_Exif->fShutterSpeedValue); - getExifTag(exifData, "Exif.Photo.SubjectDistance", 0, &m_Exif->fSubjectDistance); - getExifTag(exifData, "Exif.Photo.SubjectDistanceRange", 0, &m_Exif->fSubjectDistanceRange); - getExifTag(exifData, "Exif.Photo.UserComment", &m_Exif->fUserComment); - getExifTag(exifData, "Exif.Photo.WhiteBalance", 0, &m_Exif->fWhiteBalance); - getExifTag(exifData, "Exif.GPSInfo.GPSAltitude", 0, &m_Exif->fGPSAltitude); - getExifTag(exifData, "Exif.GPSInfo.GPSAltitudeRef", 0, &m_Exif->fGPSAltitudeRef); - getExifTag(exifData, "Exif.GPSInfo.GPSAreaInformation", &m_Exif->fGPSAreaInformation); - getExifTag(exifData, "Exif.GPSInfo.GPSDateStamp", &m_Exif->fGPSDateStamp); - getExifTag(exifData, "Exif.GPSInfo.GPSDestBearing", 0, &m_Exif->fGPSDestBearing); - getExifTag(exifData, "Exif.GPSInfo.GPSDestBearingRef", &m_Exif->fGPSDestBearingRef); - getExifTag(exifData, "Exif.GPSInfo.GPSDestDistance", 0, &m_Exif->fGPSDestDistance); - getExifTag(exifData, "Exif.GPSInfo.GPSDestDistanceRef", &m_Exif->fGPSDestDistanceRef); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLatitude", 0, &m_Exif->fGPSDestLatitude[0]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLatitude", 1, &m_Exif->fGPSDestLatitude[1]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLatitude", 2, &m_Exif->fGPSDestLatitude[2]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLatitudeRef", &m_Exif->fGPSDestLatitudeRef); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLongitude", 0, &m_Exif->fGPSDestLongitude[0]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLongitude", 1, &m_Exif->fGPSDestLongitude[1]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLongitude", 2, &m_Exif->fGPSDestLongitude[2]); - getExifTag(exifData, "Exif.GPSInfo.GPSDestLongitudeRef", &m_Exif->fGPSDestLongitudeRef); - getExifTag(exifData, "Exif.GPSInfo.GPSDifferential", 0, &m_Exif->fGPSDifferential); - getExifTag(exifData, "Exif.GPSInfo.GPSDOP", 0, &m_Exif->fGPSDOP); - getExifTag(exifData, "Exif.GPSInfo.GPSImgDirection", 0, &m_Exif->fGPSImgDirection); - getExifTag(exifData, "Exif.GPSInfo.GPSImgDirectionRef", &m_Exif->fGPSImgDirectionRef); - getExifTag(exifData, "Exif.GPSInfo.GPSLatitude", 0, &m_Exif->fGPSLatitude[0]); - getExifTag(exifData, "Exif.GPSInfo.GPSLatitude", 1, &m_Exif->fGPSLatitude[1]); - getExifTag(exifData, "Exif.GPSInfo.GPSLatitude", 2, &m_Exif->fGPSLatitude[2]); - getExifTag(exifData, "Exif.GPSInfo.GPSLatitudeRef", &m_Exif->fGPSLatitudeRef); - getExifTag(exifData, "Exif.GPSInfo.GPSLongitude", 0, &m_Exif->fGPSLongitude[0]); - getExifTag(exifData, "Exif.GPSInfo.GPSLongitude", 1, &m_Exif->fGPSLongitude[1]); - getExifTag(exifData, "Exif.GPSInfo.GPSLongitude", 2, &m_Exif->fGPSLongitude[2]); - getExifTag(exifData, "Exif.GPSInfo.GPSLongitudeRef", &m_Exif->fGPSLongitudeRef); - getExifTag(exifData, "Exif.GPSInfo.GPSMapDatum", &m_Exif->fGPSMapDatum); - getExifTag(exifData, "Exif.GPSInfo.GPSMeasureMode", &m_Exif->fGPSMeasureMode); - getExifTag(exifData, "Exif.GPSInfo.GPSProcessingMethod", &m_Exif->fGPSProcessingMethod); - getExifTag(exifData, "Exif.GPSInfo.GPSSatellites", &m_Exif->fGPSSatellites); - getExifTag(exifData, "Exif.GPSInfo.GPSSpeed", 0, &m_Exif->fGPSSpeed); - getExifTag(exifData, "Exif.GPSInfo.GPSSpeedRef", &m_Exif->fGPSSpeedRef); - getExifTag(exifData, "Exif.GPSInfo.GPSStatus", &m_Exif->fGPSStatus); - getExifTag(exifData, "Exif.GPSInfo.GPSTimeStamp", 0, &m_Exif->fGPSTimeStamp[0]); - getExifTag(exifData, "Exif.GPSInfo.GPSTimeStamp", 1, &m_Exif->fGPSTimeStamp[1]); - getExifTag(exifData, "Exif.GPSInfo.GPSTimeStamp", 2, &m_Exif->fGPSTimeStamp[2]); - getExifTag(exifData, "Exif.GPSInfo.GPSTrack", 0, &m_Exif->fGPSTrack); - getExifTag(exifData, "Exif.GPSInfo.GPSTrackRef", &m_Exif->fGPSTrackRef); - uint32 gpsVer1 = 0; - uint32 gpsVer2 = 0; - uint32 gpsVer3 = 0; - uint32 gpsVer4 = 0; - getExifTag(exifData, "Exif.GPSInfo.GPSVersionID", 0, &gpsVer1); - getExifTag(exifData, "Exif.GPSInfo.GPSVersionID", 1, &gpsVer2); - getExifTag(exifData, "Exif.GPSInfo.GPSVersionID", 2, &gpsVer3); - getExifTag(exifData, "Exif.GPSInfo.GPSVersionID", 3, &gpsVer4); - uint32 gpsVer = 0; - gpsVer += gpsVer1 << 24; - gpsVer += gpsVer2 << 16; - gpsVer += gpsVer3 << 8; - gpsVer += gpsVer4; - m_Exif->fGPSVersionID = gpsVer; - - // Nikon Makernotes - - getExifTag(exifData, "Exif.Nikon3.Lens", 0, &m_Exif->fLensInfo[0]); - getExifTag(exifData, "Exif.Nikon3.Lens", 1, &m_Exif->fLensInfo[1]); - getExifTag(exifData, "Exif.Nikon3.Lens", 2, &m_Exif->fLensInfo[2]); - getExifTag(exifData, "Exif.Nikon3.Lens", 3, &m_Exif->fLensInfo[3]); - if (getExifTag(exifData, "Exif.Nikon3.ISOSpeed", 1, &urat)) - m_Exif->fISOSpeedRatings[0] = urat.n; - - if (getExifTag(exifData, "Exif.Nikon3.SerialNO", &m_Exif->fCameraSerialNumber)) - { - m_Exif->fCameraSerialNumber.Replace("NO=", "", false); - m_Exif->fCameraSerialNumber.TrimLeadingBlanks(); - m_Exif->fCameraSerialNumber.TrimTrailingBlanks(); - } - - getExifTag(exifData, "Exif.Nikon3.SerialNumber", &m_Exif->fCameraSerialNumber); - - getExifTag(exifData, "Exif.Nikon3.ShutterCount", 0, &m_Exif->fImageNumber); - if (getExifTag(exifData, "Exif.NikonLd1.LensIDNumber", 0, &val)) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i", val); - m_Exif->fLensID.Set_ASCII(lensType); - } - if (getExifTag(exifData, "Exif.NikonLd2.LensIDNumber", 0, &val)) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i", val); - m_Exif->fLensID.Set_ASCII(lensType); - } - if (getExifTag(exifData, "Exif.NikonLd3.LensIDNumber", 0, &val)) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i", val); - m_Exif->fLensID.Set_ASCII(lensType); - } - if (getExifTag(exifData, "Exif.NikonLd2.FocusDistance", 0, &val)) - m_Exif->fSubjectDistance = dng_urational(static_cast(pow(10.0, val/40.0)), 100); - if (getExifTag(exifData, "Exif.NikonLd3.FocusDistance", 0, &val)) - m_Exif->fSubjectDistance = dng_urational(static_cast(pow(10.0, val/40.0)), 100); - getExifTag(exifData, "Exif.NikonLd1.LensIDNumber", &m_Exif->fLensName); - getExifTag(exifData, "Exif.NikonLd2.LensIDNumber", &m_Exif->fLensName); - getExifTag(exifData, "Exif.NikonLd3.LensIDNumber", &m_Exif->fLensName); - - // Canon Makernotes - - if (getExifTag(exifData, "Exif.Canon.SerialNumber", 0, &val)) - { - char serialNumber[256]; - snprintf(serialNumber, sizeof(serialNumber), "%i", val); - m_Exif->fCameraSerialNumber.Set_ASCII(serialNumber); - m_Exif->fCameraSerialNumber.TrimLeadingBlanks(); - m_Exif->fCameraSerialNumber.TrimTrailingBlanks(); - } - - if (getExifTag(exifData, "Exif.CanonCs.ExposureProgram", 0, &val)) - { - switch (val) - { - case 1: - m_Exif->fExposureProgram = 2; - break; - case 2: - m_Exif->fExposureProgram = 4; - break; - case 3: - m_Exif->fExposureProgram = 3; - break; - case 4: - m_Exif->fExposureProgram = 1; - break; - default: - break; - } - } - if (getExifTag(exifData, "Exif.CanonCs.MeteringMode", 0, &val)) - { - switch (val) - { - case 1: - m_Exif->fMeteringMode = 3; - break; - case 2: - m_Exif->fMeteringMode = 1; - break; - case 3: - m_Exif->fMeteringMode = 5; - break; - case 4: - m_Exif->fMeteringMode = 6; - break; - case 5: - m_Exif->fMeteringMode = 2; - break; - default: - break; - } - } - - if (getExifTag(exifData, "Exif.CanonCs.MaxAperture", 0, &val)) - m_Exif->fMaxApertureValue = dng_urational(val, 32); - - if (getExifTag(exifData, "Exif.CanonSi.SubjectDistance", 0, &val) && (val > 0)) - m_Exif->fSubjectDistance = dng_urational(val, 100); - - uint32 canonLensUnits = 1; - if (getExifTag(exifData, "Exif.CanonCs.Lens", 2, &urat)) - canonLensUnits = urat.n; - if (getExifTag(exifData, "Exif.CanonCs.Lens", 0, &urat)) - m_Exif->fLensInfo[1] = dng_urational(urat.n, canonLensUnits); - if (getExifTag(exifData, "Exif.CanonCs.Lens", 1, &urat)) - m_Exif->fLensInfo[0] = dng_urational(urat.n, canonLensUnits); - if (getExifTag(exifData, "Exif.Canon.FocalLength", 1, &urat)) - m_Exif->fFocalLength = dng_urational(urat.n, canonLensUnits); - uint32 canonLensType = 65535; - - if ((getExifTag(exifData, "Exif.CanonCs.LensType", 0, &canonLensType)) && - (canonLensType != 65535)) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i", canonLensType); - m_Exif->fLensID.Set_ASCII(lensType); - } - if (getExifTag(exifData, "Exif.Canon.LensModel", &m_Exif->fLensName)) - { - - } - else if (canonLensType != 65535) - { - getExifTag(exifData, "Exif.CanonCs.LensType", &m_Exif->fLensName); - } - - getExifTag(exifData, "Exif.Canon.OwnerName", &m_Exif->fOwnerName); - getExifTag(exifData, "Exif.Canon.OwnerName", &m_Exif->fArtist); - - if (getExifTag(exifData, "Exif.Canon.FirmwareVersion", &m_Exif->fFirmware)) - { - m_Exif->fFirmware.Replace("Firmware", ""); - m_Exif->fFirmware.Replace("Version", ""); - m_Exif->fFirmware.TrimLeadingBlanks(); - m_Exif->fFirmware.TrimTrailingBlanks(); - } - - if (getExifTag(exifData, "Exif.CanonSi.ISOSpeed", &str)) - { - sscanf(str.Get(), "%i", &val); - m_Exif->fISOSpeedRatings[0] = val; - } - - getExifTag(exifData, "Exif.Canon.FileNumber", 0, &m_Exif->fImageNumber); - getExifTag(exifData, "Exif.CanonFi.FileNumber", 0, &m_Exif->fImageNumber); - - // Pentax Makernotes - - getExifTag(exifData, "Exif.Pentax.LensType", &m_Exif->fLensName); - - uint32 pentaxLensId1 = 0; - uint32 pentaxLensId2 = 0; - if ((getExifTag(exifData, "Exif.Pentax.LensType", 0, &pentaxLensId1)) && - (getExifTag(exifData, "Exif.Pentax.LensType", 1, &pentaxLensId2))) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i %i", pentaxLensId1, pentaxLensId2); - m_Exif->fLensID.Set_ASCII(lensType); - } - - // Olympus Makernotes - - getExifTag(exifData, "Exif.OlympusEq.SerialNumber", &m_Exif->fCameraSerialNumber); - getExifTag(exifData, "Exif.OlympusEq.LensSerialNumber", &m_Exif->fLensSerialNumber); - getExifTag(exifData, "Exif.OlympusEq.LensModel", &m_Exif->fLensName); - - if (getExifTag(exifData, "Exif.OlympusEq.MinFocalLength", 0, &val)) - m_Exif->fLensInfo[0] = dng_urational(val, 1); - if (getExifTag(exifData, "Exif.OlympusEq.MaxFocalLength", 0, &val)) - m_Exif->fLensInfo[1] = dng_urational(val, 1); - - // Panasonic Makernotes - - getExifTag(exifData, "Exif.Panasonic.LensType", &m_Exif->fLensName); - getExifTag(exifData, "Exif.Panasonic.LensSerialNumber", &m_Exif->fLensSerialNumber); - - // Sony Makernotes - - if (getExifTag(exifData, "Exif.Sony2.LensID", 0, &val)) - { - char lensType[256]; - snprintf(lensType, sizeof(lensType), "%i", val); - m_Exif->fLensID.Set_ASCII(lensType); - } - - getExifTag(exifData, "Exif.Sony2.LensID", &m_Exif->fLensName); - - // - - if ((m_Exif->fLensName.IsEmpty()) && - (m_Exif->fLensInfo[0].As_real64() > 0) && - (m_Exif->fLensInfo[1].As_real64() > 0)) - { - char lensName1[256]; - if (m_Exif->fLensInfo[0].As_real64() == m_Exif->fLensInfo[1].As_real64()) - { - snprintf(lensName1, sizeof(lensName1), "%.1f mm", m_Exif->fLensInfo[0].As_real64()); - } - else - { - snprintf(lensName1, sizeof(lensName1), "%.1f-%.1f mm", m_Exif->fLensInfo[0].As_real64(), m_Exif->fLensInfo[1].As_real64()); - } - - std::string lensName(lensName1); - - if ((m_Exif->fLensInfo[2].As_real64() > 0) && - (m_Exif->fLensInfo[3].As_real64() > 0)) - { - char lensName2[256]; - if (m_Exif->fLensInfo[2].As_real64() == m_Exif->fLensInfo[3].As_real64()) - { - snprintf(lensName2, sizeof(lensName2), " f/%.1f", m_Exif->fLensInfo[2].As_real64()); - } - else - { - snprintf(lensName2, sizeof(lensName2), " f/%.1f-%.1f", m_Exif->fLensInfo[2].As_real64(), m_Exif->fLensInfo[3].As_real64()); - } - lensName.append(lensName2); - } - - m_Exif->fLensName.Set_ASCII(lensName.c_str()); - } - - // XMP - - std::string xmpPacket; - if (0 != Exiv2::XmpParser::encode(xmpPacket, xmpData)) - { - throw Exiv2::Error(1, "Failed to serialize XMP data"); - } - Exiv2::XmpParser::terminate(); - - m_XMP.Reset(new dng_xmp(host.Allocator())); - m_XMP->Parse(host, xmpPacket.c_str(), xmpPacket.length()); - if (getExifTag(exifData, "Exif.Image.Orientation", 0, &val)) - { - dng_orientation orientation; - orientation.SetTIFF(val); - m_XMP->SetOrientation(orientation); - } - - // Makernotes - - m_MakerNoteOffset = 0; - m_MakerNoteByteOrder.Set_ASCII(""); - if (getExifTag(exifData, "Exif.MakerNote.Offset", 0, &m_MakerNoteOffset) && - getExifTag(exifData, "Exif.MakerNote.ByteOrder", &m_MakerNoteByteOrder)) - { - long bufsize = 0; - unsigned char* buffer = 0; - if (getExifTagData(exifData, "Exif.Photo.MakerNote", &bufsize, &buffer)) - { - m_MakerNote.Reset(host.Allocate(bufsize)); - memcpy(m_MakerNote->Buffer(), buffer, bufsize); - delete[] buffer; - } - } - } - catch( Exiv2::Error& e ) - { - printExiv2ExceptionError("Cannot load metadata", e); - } -} - -void Exiv2Meta::PostParse (dng_host& /*host*/) -{ - -} diff --git a/exiv2meta.h b/exiv2meta.h deleted file mode 100644 index 0ad88c3..0000000 --- a/exiv2meta.h +++ /dev/null @@ -1,84 +0,0 @@ -/* This file is part of the dngconvert project - Copyright (C) 2011 Jens Mueller - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with this library; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#pragma once - -#include -#include -#include -#include -#include -#include - -class Exiv2Meta -{ -public: - Exiv2Meta(); - virtual ~Exiv2Meta(); - - virtual void Parse(dng_host &host, dng_stream &stream); - virtual void PostParse(dng_host &host); - - dng_exif* GetExif() - { - return m_Exif.Get(); - } - - const dng_exif* GetExif() const - { - return m_Exif.Get(); - } - - dng_xmp* GetXMP () - { - return m_XMP.Get (); - } - - const dng_xmp* GetXMP () const - { - return m_XMP.Get (); - } - - const void* MakerNoteData() const - { - return m_MakerNote.Get() ? m_MakerNote->Buffer() : NULL; - } - - uint32 MakerNoteLength() const - { - return m_MakerNote.Get() ? m_MakerNote->LogicalSize() : 0; - } - - uint32 MakerNoteOffset() const - { - return m_MakerNoteOffset; - } - - const dng_string& MakerNoteByteOrder() - { - return m_MakerNoteByteOrder; - } - -private: - AutoPtr m_Exif; - AutoPtr m_XMP; - AutoPtr m_MakerNote; - uint32 m_MakerNoteOffset; - dng_string m_MakerNoteByteOrder; -}; diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt deleted file mode 100644 index a5694f0..0000000 --- a/third_party/CMakeLists.txt +++ /dev/null @@ -1,77 +0,0 @@ -find_library(XMPCORE_LIBRARIES NAMES XMPCore PATHS xmp_sdk/public/libraries) -find_library(XMPFILES_LIBRARIES NAMES XMPFiles PATHS xmp_sdk/public/libraries) -if(XMPCORE_LIBRARIES AND XMPFILES_LIBRARIES) - set(XMP_LIBRARIES ${XMPCORE_LIBRARIES} ${XMPFILES_LIBRARIES} PARENT_SCOPE) -else() - message(FATAL_ERROR "XMP libs not found!") -endif() - -set(LIBDNGSDK_SRCS - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_1d_function.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_1d_table.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_abort_sniffer.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_area_task.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_bad_pixels.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_bottlenecks.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_camera_profile.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_color_space.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_color_spec.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_date_time.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_exceptions.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_exif.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_file_stream.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_filter_task.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_fingerprint.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_gain_map.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_globals.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_host.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_hue_sat_map.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_ifd.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_image.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_image_writer.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_info.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_iptc.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_jpeg_image.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_lens_correction.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_linearization_info.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_lossless_jpeg.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_matrix.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_memory.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_memory_stream.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_misc_opcodes.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_mosaic_info.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_mutex.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_negative.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_opcode_list.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_opcodes.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_orientation.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_parse_utils.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_pixel_buffer.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_point.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_preview.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_pthread.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_rational.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_read_image.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_rect.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_ref_counted_block.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_reference.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_render.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_resample.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_shared.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_simple_image.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_spline.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_stream.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_string.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_string_list.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_tag_types.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_temperature.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_tile_iterator.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_tone_curve.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_utils.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_xmp.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_xmp_sdk.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/dng_sdk/dng_xy_coord.cpp -) - -add_library( dngsdk ${LIBDNGSDK_SRCS} ) - diff --git a/third_party/dng_sdk/dng_1d_function.cpp b/third_party/dng_sdk/dng_1d_function.cpp deleted file mode 100644 index 3ff79f4..0000000 --- a/third_party/dng_sdk/dng_1d_function.cpp +++ /dev/null @@ -1,195 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_1d_function.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_1d_function.h" - -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_1d_function::~dng_1d_function () - { - - } - -/*****************************************************************************/ - -bool dng_1d_function::IsIdentity () const - { - - return false; - - } - -/*****************************************************************************/ - -real64 dng_1d_function::EvaluateInverse (real64 y) const - { - - const uint32 kMaxIterations = 30; - const real64 kNearZero = 1.0e-10; - - real64 x0 = 0.0; - real64 y0 = Evaluate (x0); - - real64 x1 = 1.0; - real64 y1 = Evaluate (x1); - - for (uint32 iteration = 0; iteration < kMaxIterations; iteration++) - { - - if (Abs_real64 (y1 - y0) < kNearZero) - { - break; - } - - real64 x2 = Pin_real64 (0.0, - x1 + (y - y1) * (x1 - x0) / (y1 - y0), - 1.0); - - real64 y2 = Evaluate (x2); - - x0 = x1; - y0 = y1; - - x1 = x2; - y1 = y2; - - } - - return x1; - - } - -/*****************************************************************************/ - -bool dng_1d_identity::IsIdentity () const - { - - return true; - - } - -/*****************************************************************************/ - -real64 dng_1d_identity::Evaluate (real64 x) const - { - - return x; - - } - -/*****************************************************************************/ - -real64 dng_1d_identity::EvaluateInverse (real64 x) const - { - - return x; - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_1d_identity::Get () - { - - static dng_1d_identity static_function; - - return static_function; - - } - -/*****************************************************************************/ - -dng_1d_concatenate::dng_1d_concatenate (const dng_1d_function &function1, - const dng_1d_function &function2) - - : fFunction1 (function1) - , fFunction2 (function2) - - { - - } - -/*****************************************************************************/ - -bool dng_1d_concatenate::IsIdentity () const - { - - return fFunction1.IsIdentity () && - fFunction2.IsIdentity (); - - } - -/*****************************************************************************/ - -real64 dng_1d_concatenate::Evaluate (real64 x) const - { - - real64 y = Pin_real64 (0.0, fFunction1.Evaluate (x), 1.0); - - return fFunction2.Evaluate (y); - - } - -/*****************************************************************************/ - -real64 dng_1d_concatenate::EvaluateInverse (real64 x) const - { - - real64 y = fFunction2.EvaluateInverse (x); - - return fFunction1.EvaluateInverse (y); - - } - -/*****************************************************************************/ - -dng_1d_inverse::dng_1d_inverse (const dng_1d_function &f) - - : fFunction (f) - - { - - } - -/*****************************************************************************/ - -bool dng_1d_inverse::IsIdentity () const - { - - return fFunction.IsIdentity (); - - } - -/*****************************************************************************/ - -real64 dng_1d_inverse::Evaluate (real64 x) const - { - - return fFunction.EvaluateInverse (x); - - } - -/*****************************************************************************/ - -real64 dng_1d_inverse::EvaluateInverse (real64 y) const - { - - return fFunction.Evaluate (y); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_1d_function.h b/third_party/dng_sdk/dng_1d_function.h deleted file mode 100644 index aee59ca..0000000 --- a/third_party/dng_sdk/dng_1d_function.h +++ /dev/null @@ -1,159 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_1d_function.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Classes for a 1D floating-point to floating-point function abstraction. - */ - -/*****************************************************************************/ - -#ifndef __dng_1d_function__ -#define __dng_1d_function__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief A 1D floating-point function. -/// -/// The domain (input) is always from 0.0 to 1.0, while the range (output) can be an arbitrary interval. - -class dng_1d_function - { - - public: - - virtual ~dng_1d_function (); - - /// Returns true if this function is the map x -> y such that x == y for all x . That is if Evaluate(x) == x for all x. - - virtual bool IsIdentity () const; - - /// Return the mapping for value x. - /// This method must be implemented by a derived class of dng_1d_function and the derived class determines the - /// lookup method and function used. - /// \param x A value between 0.0 and 1.0 (inclusive). - /// \retval Mapped value for x - - virtual real64 Evaluate (real64 x) const = 0; - - /// Return the reverse mapped value for y. - /// This method can be implemented by derived classes. The default implementation uses Newton's method to solve - /// for x such that Evaluate(x) == y. - /// \param y A value to reverse map. Should be within the range of the function implemented by this dng_1d_function . - /// \retval A value x such that Evaluate(x) == y (to very close approximation). - - virtual real64 EvaluateInverse (real64 y) const; - - }; - -/*****************************************************************************/ - -/// An identity (x -> y such that x == y for all x) mapping function. - -class dng_1d_identity: public dng_1d_function - { - - public: - /// Always returns true for this class. - - virtual bool IsIdentity () const; - - /// Always returns x for this class. - - virtual real64 Evaluate (real64 x) const; - - /// Always returns y for this class. - - virtual real64 EvaluateInverse (real64 y) const; - - /// This class is a singleton, and is entirely threadsafe. Use this method to get an instance of the class. - - static const dng_1d_function & Get (); - - }; - -/*****************************************************************************/ - -/// A dng_1d_function that represents the composition (curry) of two other dng_1d_functions. - -class dng_1d_concatenate: public dng_1d_function - { - - protected: - - const dng_1d_function &fFunction1; - - const dng_1d_function &fFunction2; - - public: - - /// Create a dng_1d_function which computes y = function2.Evaluate(function1.Evaluate(x)). - /// Compose function1 and function2 to compute y = function2.Evaluate(function1.Evaluate(x)). The range of function1.Evaluate must be a subset of 0.0 to 1.0 inclusive, - /// otherwise the result of function1(x) will be pinned (clipped) to 0.0 if <0.0 and to 1.0 if > 1.0 . - /// \param function1 Inner function of composition. - /// \param function2 Outer function of composition. - - dng_1d_concatenate (const dng_1d_function &function1, - const dng_1d_function &function2); - - /// Only true if both function1 and function2 have IsIdentity equal to true. - - virtual bool IsIdentity () const; - - /// Return the composed mapping for value x. - /// \param x A value between 0.0 and 1.0 (inclusive). - /// \retval function2.Evaluate(function1.Evaluate(x)). - - virtual real64 Evaluate (real64 x) const; - - /// Return the reverse mapped value for y. - /// Be careful using this method with compositions where the inner function does not have a range 0.0 to 1.0 . (Or better yet, do not use such functions.) - /// \param y A value to reverse map. Should be within the range of function2.Evaluate. - /// \retval A value x such that function2.Evaluate(function1.Evaluate(x)) == y (to very close approximation). - - virtual real64 EvaluateInverse (real64 y) const; - - }; - -/*****************************************************************************/ - -/// A dng_1d_function that represents the inverse of another dng_1d_function. - -class dng_1d_inverse: public dng_1d_function - { - - protected: - - const dng_1d_function &fFunction; - - public: - - dng_1d_inverse (const dng_1d_function &f); - - virtual bool IsIdentity () const; - - virtual real64 Evaluate (real64 x) const; - - virtual real64 EvaluateInverse (real64 y) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_1d_table.cpp b/third_party/dng_sdk/dng_1d_table.cpp deleted file mode 100644 index 267078e..0000000 --- a/third_party/dng_sdk/dng_1d_table.cpp +++ /dev/null @@ -1,195 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_1d_table.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_1d_table.h" - -#include "dng_1d_function.h" -#include "dng_memory.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_1d_table::dng_1d_table () - - : fBuffer () - , fTable (NULL) - - { - - } - -/*****************************************************************************/ - -dng_1d_table::~dng_1d_table () - { - - } - -/*****************************************************************************/ - -void dng_1d_table::SubDivide (const dng_1d_function &function, - uint32 lower, - uint32 upper, - real32 maxDelta) - { - - uint32 range = upper - lower; - - bool subDivide = (range > (kTableSize >> 8)); - - if (!subDivide) - { - - real32 delta = Abs_real32 (fTable [upper] - - fTable [lower]); - - if (delta > maxDelta) - { - - subDivide = true; - - } - - } - - if (subDivide) - { - - uint32 middle = (lower + upper) >> 1; - - fTable [middle] = (real32) function.Evaluate (middle * (1.0 / (real64) kTableSize)); - - if (range > 2) - { - - SubDivide (function, lower, middle, maxDelta); - - SubDivide (function, middle, upper, maxDelta); - - } - - } - - else - { - - real64 y0 = fTable [lower]; - real64 y1 = fTable [upper]; - - real64 delta = (y1 - y0) / (real64) range; - - for (uint32 j = lower + 1; j < upper; j++) - { - - y0 += delta; - - fTable [j] = (real32) y0; - - } - - } - - } - -/*****************************************************************************/ - -void dng_1d_table::Initialize (dng_memory_allocator &allocator, - const dng_1d_function &function, - bool subSample) - { - - fBuffer.Reset (allocator.Allocate ((kTableSize + 2) * sizeof (real32))); - - fTable = fBuffer->Buffer_real32 (); - - if (subSample) - { - - fTable [0 ] = (real32) function.Evaluate (0.0); - fTable [kTableSize] = (real32) function.Evaluate (1.0); - - real32 maxDelta = Max_real32 (Abs_real32 (fTable [kTableSize] - - fTable [0 ]), 1.0f) * - (1.0f / 256.0f); - - SubDivide (function, - 0, - kTableSize, - maxDelta); - - } - - else - { - - for (uint32 j = 0; j <= kTableSize; j++) - { - - real64 x = j * (1.0 / (real64) kTableSize); - - real64 y = function.Evaluate (x); - - fTable [j] = (real32) y; - - } - - } - - fTable [kTableSize + 1] = fTable [kTableSize]; - - } - -/*****************************************************************************/ - -void dng_1d_table::Expand16 (uint16 *table16) const - { - - real64 step = (real64) kTableSize / 65535.0; - - real64 y0 = fTable [0]; - real64 y1 = fTable [1]; - - real64 base = y0 * 65535.0 + 0.5; - real64 slope = (y1 - y0) * 65535.0; - - uint32 index = 1; - real64 fract = 0.0; - - for (uint32 j = 0; j < 0x10000; j++) - { - - table16 [j] = (uint16) (base + slope * fract); - - fract += step; - - if (fract > 1.0) - { - - index += 1; - fract -= 1.0; - - y0 = y1; - y1 = fTable [index]; - - base = y0 * 65535.0 + 0.5; - slope = (y1 - y0) * 65535.0; - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_1d_table.h b/third_party/dng_sdk/dng_1d_table.h deleted file mode 100644 index e24972a..0000000 --- a/third_party/dng_sdk/dng_1d_table.h +++ /dev/null @@ -1,122 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_1d_table.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Definition of a lookup table based 1D floating-point to floating-point function abstraction using linear interpolation. - */ - -/*****************************************************************************/ - -#ifndef __dng_1d_table__ -#define __dng_1d_table__ - -/*****************************************************************************/ - -#include "dng_assertions.h" -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief A 1D floating-point lookup table using linear interpolation. - -class dng_1d_table - { - - public: - - /// Constants denoting size of table. - - enum - { - kTableBits = 12, //< Table is always a power of 2 in size. This is log2(kTableSize). - kTableSize = (1 << kTableBits) //< Number of entries in table. - }; - - protected: - - AutoPtr fBuffer; - - real32 *fTable; - - public: - - dng_1d_table (); - - virtual ~dng_1d_table (); - - /// Set up table, initialize entries using functiion. - /// This method can throw an exception, e.g. if there is not enough memory. - /// \param allocator Memory allocator from which table memory is allocated. - /// \param function Table is initialized with values of finction.Evalluate(0.0) to function.Evaluate(1.0). - /// \param subSample If true, only sample the function a limited number of times and interpolate. - - void Initialize (dng_memory_allocator &allocator, - const dng_1d_function &function, - bool subSample = false); - - /// Lookup and interpolate mapping for an input. - /// \param x value from 0.0 to 1.0 used as input for mapping - /// \retval Approximation of function.Evaluate(x) - - real32 Interpolate (real32 x) const - { - - real32 y = x * (real32) kTableSize; - - int32 index = (int32) y; - - DNG_ASSERT (index >= 0 && index <= kTableSize, - "dng_1d_table::Interpolate parameter out of range"); - - real32 z = (real32) index; - - real32 fract = y - z; - - return fTable [index ] * (1.0f - fract) + - fTable [index + 1] * ( fract); - - } - - /// Direct access function for table data. - - const real32 * Table () const - { - return fTable; - } - - /// Expand the table to a 16-bit to 16-bit table. - - void Expand16 (uint16 *table16) const; - - private: - - void SubDivide (const dng_1d_function &function, - uint32 lower, - uint32 upper, - real32 maxDelta); - - // Hidden copy constructor and assignment operator. - - dng_1d_table (const dng_1d_table &table); - - dng_1d_table & operator= (const dng_1d_table &table); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_abort_sniffer.cpp b/third_party/dng_sdk/dng_abort_sniffer.cpp deleted file mode 100644 index 4c65733..0000000 --- a/third_party/dng_sdk/dng_abort_sniffer.cpp +++ /dev/null @@ -1,242 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_abort_sniffer.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_abort_sniffer.h" - -#include "dng_mutex.h" - -/*****************************************************************************/ - -#if qDNGThreadSafe - -/*****************************************************************************/ - -class dng_priority_manager - { - - private: - - dng_mutex fMutex; - - dng_condition fCondition; - - uint32 fCounter [dng_priority_count]; - - public: - - dng_priority_manager (); - - void Increment (dng_priority priority); - - void Decrement (dng_priority priority); - - void Wait (dng_priority priority); - - private: - - dng_priority MinPriority () - { - - // Assumes mutex is locked. - - for (uint32 level = dng_priority_maximum; - level > dng_priority_minimum; - level--) - { - - if (fCounter [level]) - { - return (dng_priority) level; - } - - } - - return dng_priority_minimum; - - } - - }; - -/*****************************************************************************/ - -dng_priority_manager::dng_priority_manager () - - : fMutex ("dng_priority_manager::fMutex") - , fCondition () - - { - - for (uint32 level = dng_priority_minimum; - level <= dng_priority_maximum; - level++) - { - - fCounter [level] = 0; - - } - - } - -/*****************************************************************************/ - -void dng_priority_manager::Increment (dng_priority priority) - { - - dng_lock_mutex lock (&fMutex); - - fCounter [priority] += 1; - - } - -/*****************************************************************************/ - -void dng_priority_manager::Decrement (dng_priority priority) - { - - dng_lock_mutex lock (&fMutex); - - dng_priority oldMin = MinPriority (); - - fCounter [priority] -= 1; - - dng_priority newMin = MinPriority (); - - if (newMin < oldMin) - { - - fCondition.Broadcast (); - - } - - } - -/*****************************************************************************/ - -void dng_priority_manager::Wait (dng_priority priority) - { - - if (priority < dng_priority_maximum) - { - - dng_lock_mutex lock (&fMutex); - - while (priority < MinPriority ()) - { - - fCondition.Wait (fMutex); - - } - - } - - } - -/*****************************************************************************/ - -static dng_priority_manager gPriorityManager; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -dng_set_minimum_priority::dng_set_minimum_priority (dng_priority priority) - - : fPriority (priority) - - { - - #if qDNGThreadSafe - - gPriorityManager.Increment (fPriority); - - #endif - - } - -/*****************************************************************************/ - -dng_set_minimum_priority::~dng_set_minimum_priority () - { - - #if qDNGThreadSafe - - gPriorityManager.Decrement (fPriority); - - #endif - - } - -/*****************************************************************************/ - -dng_abort_sniffer::dng_abort_sniffer () - - : fPriority (dng_priority_maximum) - - { - - } - -/*****************************************************************************/ - -dng_abort_sniffer::~dng_abort_sniffer () - { - - } - -/*****************************************************************************/ - -void dng_abort_sniffer::SniffForAbort (dng_abort_sniffer *sniffer) - { - - if (sniffer) - { - - #if qDNGThreadSafe - - gPriorityManager.Wait (sniffer->Priority ()); - - #endif - - sniffer->Sniff (); - - } - - } - -/*****************************************************************************/ - -void dng_abort_sniffer::StartTask (const char * /* name */, - real64 /* fract */) - { - - } - -/*****************************************************************************/ - -void dng_abort_sniffer::EndTask () - { - - } - -/*****************************************************************************/ - -void dng_abort_sniffer::UpdateProgress (real64 /* fract */) - { - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_abort_sniffer.h b/third_party/dng_sdk/dng_abort_sniffer.h deleted file mode 100644 index 3a2f553..0000000 --- a/third_party/dng_sdk/dng_abort_sniffer.h +++ /dev/null @@ -1,244 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_abort_sniffer.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Classes supporting user cancellation and progress tracking. - */ - -/*****************************************************************************/ - -#ifndef __dng_abort_sniffer__ -#define __dng_abort_sniffer__ - -/*****************************************************************************/ - -#include "dng_flags.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Thread priority level. - -enum dng_priority - { - - dng_priority_low, - dng_priority_medium, - dng_priority_high, - - dng_priority_count, - - dng_priority_minimum = dng_priority_low, - dng_priority_maximum = dng_priority_high - - }; - -/*****************************************************************************/ - -/// \brief Convenience class for setting thread priority level to minimum. - -class dng_set_minimum_priority - { - - private: - - dng_priority fPriority; - - public: - - dng_set_minimum_priority (dng_priority priority); - - ~dng_set_minimum_priority (); - - }; - -/*****************************************************************************/ - -/** \brief Class for signaling user cancellation and receiving progress updates. - * - * DNG SDK clients should derive a host application specific implementation - * from this class. - */ - -class dng_abort_sniffer - { - - friend class dng_sniffer_task; - - private: - - dng_priority fPriority; - - public: - - dng_abort_sniffer (); - - virtual ~dng_abort_sniffer (); - - /// Getter for priority level. - - dng_priority Priority () const - { - return fPriority; - } - - /// Setter for priority level. - - void SetPriority (dng_priority priority) - { - fPriority = priority; - } - - /// Check for pending user cancellation or other abort. ThrowUserCanceled - /// will be called if one is pending. This static method is provided as a - /// convenience for quickly testing for an abort and throwing an exception - /// if one is pending. - /// \param sniffer The dng_sniffer to test for a pending abort. Can be NULL, - /// in which case there an abort is never signalled. - - static void SniffForAbort (dng_abort_sniffer *sniffer); - - // A way to call Sniff while bypassing the priority wait. - - void SniffNoPriorityWait () - { - Sniff (); - } - - // Specifies whether or not the sniffer may be called by multiple threads - // in parallel. Default result is false. Subclass must override to return - // true. - - virtual bool ThreadSafe () const - { - return false; - } - - protected: - - /// Should be implemented by derived classes to check for an user - /// cancellation. - - virtual void Sniff () = 0; - - /// Signals the start of a named task withn processing in the DNG SDK. - /// Tasks may be nested. - /// \param name of the task - /// \param fract Percentage of total processing this task is expected to - /// take. From 0.0 to 1.0 . - - virtual void StartTask (const char *name, - real64 fract); - - /// Signals the end of the innermost task that has been started. - - virtual void EndTask (); - - /// Signals progress made on current task. - /// \param fract percentage of processing completed on current task. - /// From 0.0 to 1.0 . - - virtual void UpdateProgress (real64 fract); - - }; - -/******************************************************************************/ - -/// \brief Class to establish scope of a named subtask in DNG processing. -/// -/// Instances of this class are intended to be stack allocated. - -class dng_sniffer_task - { - - private: - - dng_abort_sniffer *fSniffer; - - public: - - /// Inform a sniffer of a subtask in DNG processing. - /// \param sniffer The sniffer associated with the host on which this - /// processing is occurring. - /// \param name The name of this subtask as a NUL terminated string. - /// \param fract Percentage of total processing this task is expected - /// to take, from 0.0 to 1.0 . - - dng_sniffer_task (dng_abort_sniffer *sniffer, - const char *name = NULL, - real64 fract = 0.0) - - : fSniffer (sniffer) - - { - if (fSniffer) - fSniffer->StartTask (name, fract); - } - - ~dng_sniffer_task () - { - if (fSniffer) - fSniffer->EndTask (); - } - - /// Check for pending user cancellation or other abort. ThrowUserCanceled - /// will be called if one is pending. - - void Sniff () - { - dng_abort_sniffer::SniffForAbort (fSniffer); - } - - /// Update progress on this subtask. - /// \param fract Percentage of processing completed on current task, - /// from 0.0 to 1.0 . - - void UpdateProgress (real64 fract) - { - if (fSniffer) - fSniffer->UpdateProgress (fract); - } - - /// Update progress on this subtask. - /// \param done Amount of task completed in arbitrary integer units. - /// \param total Total size of task in same arbitrary integer units as done. - - void UpdateProgress (uint32 done, - uint32 total) - { - UpdateProgress ((real64) done / - (real64) total); - } - - /// Signal task completed for progress purposes. - - void Finish () - { - UpdateProgress (1.0); - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_sniffer_task (const dng_sniffer_task &task); - - dng_sniffer_task & operator= (const dng_sniffer_task &task); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_area_task.cpp b/third_party/dng_sdk/dng_area_task.cpp deleted file mode 100644 index 25b100e..0000000 --- a/third_party/dng_sdk/dng_area_task.cpp +++ /dev/null @@ -1,270 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_area_task.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_area_task.h" - -#include "dng_abort_sniffer.h" -#include "dng_flags.h" -#include "dng_sdk_limits.h" -#include "dng_tile_iterator.h" -#include "dng_utils.h" - -#if qImagecore -extern bool gPrintTimings; -#endif - -/*****************************************************************************/ - -dng_area_task::dng_area_task () - - : fMaxThreads (kMaxMPThreads) - - , fMinTaskArea (256 * 256) - - , fUnitCell (1, 1) - - , fMaxTileSize (256, 256) - - { - - } - -/*****************************************************************************/ - -dng_area_task::~dng_area_task () - { - - } - -/*****************************************************************************/ - -dng_rect dng_area_task::RepeatingTile1 () const - { - - return dng_rect (); - - } - -/*****************************************************************************/ - -dng_rect dng_area_task::RepeatingTile2 () const - { - - return dng_rect (); - - } - -/*****************************************************************************/ - -dng_rect dng_area_task::RepeatingTile3 () const - { - - return dng_rect (); - - } - -/*****************************************************************************/ - -void dng_area_task::Start (uint32 /* threadCount */, - const dng_point & /* tileSize */, - dng_memory_allocator * /* allocator */, - dng_abort_sniffer * /* sniffer */) - { - - } - -/*****************************************************************************/ - -void dng_area_task::Finish (uint32 /* threadCount */) - { - - } - -/*****************************************************************************/ - -dng_point dng_area_task::FindTileSize (const dng_rect &area) const - { - - dng_rect repeatingTile1 = RepeatingTile1 (); - dng_rect repeatingTile2 = RepeatingTile2 (); - dng_rect repeatingTile3 = RepeatingTile3 (); - - if (repeatingTile1.IsEmpty ()) - { - repeatingTile1 = area; - } - - if (repeatingTile2.IsEmpty ()) - { - repeatingTile2 = area; - } - - if (repeatingTile3.IsEmpty ()) - { - repeatingTile3 = area; - } - - uint32 repeatV = Min_uint32 (Min_uint32 (repeatingTile1.H (), - repeatingTile2.H ()), - repeatingTile3.H ()); - - uint32 repeatH = Min_uint32 (Min_uint32 (repeatingTile1.W (), - repeatingTile2.W ()), - repeatingTile3.W ()); - - dng_point maxTileSize = MaxTileSize (); - - dng_point tileSize; - - tileSize.v = Min_int32 (repeatV, maxTileSize.v); - tileSize.h = Min_int32 (repeatH, maxTileSize.h); - - // What this is doing is, if the smallest repeating image tile is larger than the - // maximum tile size, adjusting the tile size down so that the tiles are as small - // as possible while still having the same number of tiles covering the - // repeat area. This makes the areas more equal in size, making MP - // algorithms work better. - - // The image core team did not understand this code, and disabled it. - // Really stupid idea to turn off code you don't understand! - // I'm undoing this removal, because I think the code is correct and useful. - - uint32 countV = (repeatV + tileSize.v - 1) / tileSize.v; - uint32 countH = (repeatH + tileSize.h - 1) / tileSize.h; - - tileSize.v = (repeatV + countV - 1) / countV; - tileSize.h = (repeatH + countH - 1) / countH; - - // Round up to unit cell size. - - dng_point unitCell = UnitCell (); - - if (unitCell.h != 1 || unitCell.v != 1) - { - tileSize.v = ((tileSize.v + unitCell.v - 1) / unitCell.v) * unitCell.v; - tileSize.h = ((tileSize.h + unitCell.h - 1) / unitCell.h) * unitCell.h; - } - - // But if that is larger than maximum tile size, round down to unit cell size. - - if (tileSize.v > maxTileSize.v) - { - tileSize.v = (maxTileSize.v / unitCell.v) * unitCell.v; - } - - if (tileSize.h > maxTileSize.h) - { - tileSize.h = (maxTileSize.h / unitCell.h) * unitCell.h; - } - - #if qImagecore - if (gPrintTimings) - { - fprintf (stdout, "\nRender tile for below: %d x %d\n", (int32) tileSize.h, (int32) tileSize.v); - } - #endif - - return tileSize; - - } - -/*****************************************************************************/ - -void dng_area_task::ProcessOnThread (uint32 threadIndex, - const dng_rect &area, - const dng_point &tileSize, - dng_abort_sniffer *sniffer) - { - - dng_rect repeatingTile1 = RepeatingTile1 (); - dng_rect repeatingTile2 = RepeatingTile2 (); - dng_rect repeatingTile3 = RepeatingTile3 (); - - if (repeatingTile1.IsEmpty ()) - { - repeatingTile1 = area; - } - - if (repeatingTile2.IsEmpty ()) - { - repeatingTile2 = area; - } - - if (repeatingTile3.IsEmpty ()) - { - repeatingTile3 = area; - } - - dng_rect tile1; - - dng_tile_iterator iter1 (repeatingTile3, area); - - while (iter1.GetOneTile (tile1)) - { - - dng_rect tile2; - - dng_tile_iterator iter2 (repeatingTile2, tile1); - - while (iter2.GetOneTile (tile2)) - { - - dng_rect tile3; - - dng_tile_iterator iter3 (repeatingTile1, tile2); - - while (iter3.GetOneTile (tile3)) - { - - dng_rect tile4; - - dng_tile_iterator iter4 (tileSize, tile3); - - while (iter4.GetOneTile (tile4)) - { - - dng_abort_sniffer::SniffForAbort (sniffer); - - Process (threadIndex, tile4, sniffer); - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_area_task::Perform (dng_area_task &task, - const dng_rect &area, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer) - { - - dng_point tileSize (task.FindTileSize (area)); - - task.Start (1, tileSize, allocator, sniffer); - - task.ProcessOnThread (0, area, tileSize, sniffer); - - task.Finish (1); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_area_task.h b/third_party/dng_sdk/dng_area_task.h deleted file mode 100644 index 4824873..0000000 --- a/third_party/dng_sdk/dng_area_task.h +++ /dev/null @@ -1,198 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_area_task.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Class to handle partitioning a rectangular image processing operation taking into account multiple processing resources and memory constraints. - */ - -/*****************************************************************************/ - -#ifndef __dng_area_task__ -#define __dng_area_task__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_point.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Abstract class for rectangular processing operations with support for partitioning across multiple processing resources and observing memory constraints. - -class dng_area_task - { - - protected: - - uint32 fMaxThreads; - - uint32 fMinTaskArea; - - dng_point fUnitCell; - - dng_point fMaxTileSize; - - public: - - dng_area_task (); - - virtual ~dng_area_task (); - - /// Getter for the maximum number of threads (resources) that can be used for processing - /// - /// \retval Number of threads, minimum of 1, that can be used for this task. - - virtual uint32 MaxThreads () const - { - return fMaxThreads; - } - - /// Getter for minimum area of a partitioned rectangle. - /// Often it is not profitable to use more resources if it requires partitioning the input into chunks that are too small, - /// as the overhead increases more than the speedup. This method can be ovreridden for a specific task to indicate the smallest - /// area for partitioning. Default is 256x256 pixels. - /// - /// \retval Minimum area for a partitoned tile in order to give performant operation. (Partitions can be smaller due to small inputs and edge cases.) - - virtual uint32 MinTaskArea () const - { - return fMinTaskArea; - } - - /// Getter for dimensions of which partitioned tiles should be a multiple. - /// Various methods of processing prefer certain alignments. The partitioning attempts to construct tiles such that the - /// sizes are a multiple of the dimensions of this point. - /// - /// \retval a point giving preferred alignment in x and y - - virtual dng_point UnitCell () const - { - return fUnitCell; - } - - /// Getter for maximum size of a tile for processing. - /// Often processing will need to allocate temporary buffers or use other resources that are either fixed or in limited supply. - /// The maximum tile size forces further partitioning if the tile is bigger than this size. - /// - /// \retval Maximum tile size allowed for this area task. - - virtual dng_point MaxTileSize () const - { - return fMaxTileSize; - } - - /// Getter for RepeatingTile1. - /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which - /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the - /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third - /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty. - /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must - /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met. - - virtual dng_rect RepeatingTile1 () const; - - /// Getter for RepeatingTile2. - /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which - /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the - /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third - /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty. - /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must - /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met. - - virtual dng_rect RepeatingTile2 () const; - - /// Getter for RepeatingTile3. - /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which - /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the - /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third - /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty. - /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must - /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met. - - virtual dng_rect RepeatingTile3 () const; - - /// Task startup method called before any processing is done on partitions. - /// The Start method is called before any processing is done and can be overridden to allocate temporary buffers, etc. - /// - /// \param threadCount Total number of threads that will be used for processing. Less than or equal to MaxThreads. - /// \param tileSize Size of source tiles which will be processed. (Not all tiles will be this size due to edge conditions.) - /// \param allocator dng_memory_allocator to use for allocating temporary buffers, etc. - /// \param sniffer Sniffer to test for user cancellation and to set up progress. - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer); - - /// Process one tile or fully partitioned area. - /// This method is overridden by derived classes to implement the actual image processing. Note that the sniffer can be ignored if it is certain that a - /// processing task will complete very quickly. - /// This method should never be called directly but rather accessed via Process. - /// There is no allocator parameter as all allocation should be done in Start. - /// - /// \param threadIndex 0 to threadCount - 1 index indicating which thread this is. (Can be used to get a thread-specific buffer allocated in the Start method.) - /// \param tile Area to process. - /// \param sniffer dng_abort_sniffer to use to check for user cancellation and progress updates. - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer *sniffer) = 0; - - /// Task computation finalization and teardown method. - /// Called after all resources have completed processing. Can be overridden to accumulate results and free resources allocated in Start. - /// - /// \param threadCount Number of threads used for processing. Same as value passed to Start. - - virtual void Finish (uint32 threadCount); - - /// Find tile size taking into account repeating tiles, unit cell, and maximum tile size. - /// \param area Computation area for which to find tile size. - /// \retval Tile size as height and width in point. - - dng_point FindTileSize (const dng_rect &area) const; - - /// Handle one resource's worth of partitioned tiles. - /// Called after thread partitioning has already been done. Area may be further subdivided to handle maximum tile size, etc. - /// It will be rare to override this method. - /// - /// \param threadIndex 0 to threadCount - 1 index indicating which thread this is. - /// \param area Tile area partitioned to this resource. - /// \param tileSize - /// \param sniffer dng_abort_sniffer to use to check for user cancellation and progress updates. - - void ProcessOnThread (uint32 threadIndex, - const dng_rect &area, - const dng_point &tileSize, - dng_abort_sniffer *sniffer); - - /// Default resource partitioner that assumes a single resource to be used for processing. - /// Implementations that are aware of multiple processing resources should override (replace) this method. - /// This is usually done in dng_host::PerformAreaTask . - /// \param task The task to perform. - /// \param area The area on which mage processing should be performed. - /// \param allocator dng_memory_allocator to use for allocating temporary buffers, etc. - /// \param sniffer dng_abort_sniffer to use to check for user cancellation and progress updates. - - static void Perform (dng_area_task &task, - const dng_rect &area, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_assertions.h b/third_party/dng_sdk/dng_assertions.h deleted file mode 100644 index 3c45957..0000000 --- a/third_party/dng_sdk/dng_assertions.h +++ /dev/null @@ -1,133 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_assertions.h#3 $ */ -/* $DateTime: 2012/09/05 12:31:51 $ */ -/* $Change: 847652 $ */ -/* $Author: tknoll $ */ - -/** \file - * Conditionally compiled assertion check support. - */ - -/*****************************************************************************/ - -#ifndef __dng_assertions__ -#define __dng_assertions__ - -/*****************************************************************************/ - -#include "dng_exceptions.h" -#include "dng_flags.h" - -/*****************************************************************************/ - -#if qDNGDebug - -/// Platform-specific function to display an assert. - -void dng_show_message (const char *s); - -/// Show a formatted error message. - -void dng_show_message_f (const char *fmt, ...); - -#endif - -/*****************************************************************************/ - -#ifndef DNG_ASSERT - -#if qDNGDebug - -/// Conditionally compiled macro to check an assertion and display a message if -/// it fails and assertions are compiled in via qDNGDebug -/// \param x Predicate which must be true. -/// \param y String to display if x is not true. - -#define DNG_ASSERT(x,y) { if (!(x)) dng_show_message (y); } - -#else - -/// Conditionally compiled macro to check an assertion and display a message if -/// it fails and assertions are compiled in via qDNGDebug -/// \param x Predicate which must be true. -/// \param y String to display if x is not true. - -#define DNG_ASSERT(x,y) - -#endif -#endif - -/*****************************************************************************/ - -#ifndef DNG_REQUIRE - -#if qDNGDebug - -/// Conditionally compiled macro to check an assertion, display a message, and throw -/// an exception if it fails and assertions are compiled in via qDNGDebug -/// \param condition Predicate which must be true. -/// \param msg String to display if condition is not true. - -#define DNG_REQUIRE(condition,msg) \ - do \ - { \ - \ - if (!(condition)) \ - { \ - \ - DNG_ASSERT(condition, msg); \ - \ - ThrowProgramError (msg); \ - \ - } \ - \ - } \ - while (0) - -#else - -/// Conditionally compiled macro to check an assertion, display a message, and throw -/// an exception if it fails and assertions are compiled in via qDNGDebug -/// \param condition Predicate which must be true. -/// \param msg String to display if condition is not true. - -#define DNG_REQUIRE(condition,msg) \ - do \ - { \ - \ - if (!(condition)) \ - { \ - \ - ThrowProgramError (msg); \ - \ - } \ - \ - } \ - while (0) - -#endif -#endif - -/*****************************************************************************/ - -#ifndef DNG_REPORT - -/// Macro to display an informational message -/// \param x String to display. - -#define DNG_REPORT(x) DNG_ASSERT (false, x) - -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_auto_ptr.h b/third_party/dng_sdk/dng_auto_ptr.h deleted file mode 100644 index 02154be..0000000 --- a/third_party/dng_sdk/dng_auto_ptr.h +++ /dev/null @@ -1,259 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_auto_ptr.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Class to implement std::auto_ptr like functionality even on platforms which do not - * have a full Standard C++ library. - */ - -/*****************************************************************************/ - -#ifndef __dng_auto_ptr__ -#define __dng_auto_ptr__ - -#include - -/*****************************************************************************/ - -// The following template has similar functionality to the STL auto_ptr, without -// requiring all the weight of STL. - -/*****************************************************************************/ - -/// \brief A class intended to be used in stack scope to hold a pointer from new. The -/// held pointer will be deleted automatically if the scope is left without calling -/// Release on the AutoPtr first. - -template -class AutoPtr - { - - private: - - T *p_; - - public: - - /// Construct an AutoPtr with no referent. - - AutoPtr () : p_ (0) { } - - /// Construct an AutoPtr which owns the argument pointer. - /// \param p pointer which constructed AutoPtr takes ownership of. p will be - /// deleted on destruction or Reset unless Release is called first. - - explicit AutoPtr (T *p) : p_( p ) { } - - /// Reset is called on destruction. - - ~AutoPtr (); - - /// Call Reset with a pointer from new. Uses T's default constructor. - - void Alloc (); - - /// Return the owned pointer of this AutoPtr, NULL if none. No change in - /// ownership or other effects occur. - - T *Get () const { return p_; } - - /// Return the owned pointer of this AutoPtr, NULL if none. The AutoPtr gives - /// up ownership and takes NULL as its value. - - T *Release (); - - /// If a pointer is owned, it is deleted. Ownership is taken of passed in - /// pointer. - /// \param p pointer which constructed AutoPtr takes ownership of. p will be - /// deleted on destruction or Reset unless Release is called first. - - void Reset (T *p); - - /// If a pointer is owned, it is deleted and the AutoPtr takes NULL as its - /// value. - - void Reset (); - - /// Allows members of the owned pointer to be accessed directly. It is an - /// error to call this if the AutoPtr has NULL as its value. - - T *operator-> () const { return p_; } - - /// Returns a reference to the object that the owned pointer points to. It is - /// an error to call this if the AutoPtr has NULL as its value. - - T &operator* () const { return *p_; } - - /// Swap with another auto ptr. - - friend inline void Swap (AutoPtr< T > &x, AutoPtr< T > &y) - { - T* temp = x.p_; - x.p_ = y.p_; - y.p_ = temp; - } - - private: - - // Hidden copy constructor and assignment operator. I don't think the STL - // "feature" of grabbing ownership of the pointer is a good idea. - - AutoPtr (AutoPtr &rhs); - - AutoPtr & operator= (AutoPtr &rhs); - - }; - -/*****************************************************************************/ - -template -AutoPtr::~AutoPtr () - { - - delete p_; - p_ = 0; - - } - -/*****************************************************************************/ - -template -T *AutoPtr::Release () - { - T *result = p_; - p_ = 0; - return result; - } - -/*****************************************************************************/ - -template -void AutoPtr::Reset (T *p) - { - - if (p_ != p) - { - if (p_ != 0) - delete p_; - p_ = p; - } - - } - -/*****************************************************************************/ - -template -void AutoPtr::Reset () - { - - if (p_ != 0) - { - delete p_; - p_ = 0; - } - - } - -/*****************************************************************************/ - -template -void AutoPtr::Alloc () - { - this->Reset (new T); - } - -/*****************************************************************************/ - -/// \brief A class intended to be used similarly to AutoPtr but for arrays. - -template -class AutoArray - { - - public: - - /// Construct an AutoArray which owns the argument pointer. - /// \param p array pointer which constructed AutoArray takes ownership of. p - /// will be deleted on destruction or Reset unless Release is called first. - - explicit AutoArray (T *p_ = 0) : p (p_) { } - - /// Reset is called on destruction. - - ~AutoArray () - { - delete [] p; - p = 0; - } - - /// Return the owned array pointer of this AutoArray, NULL if none. The - /// AutoArray gives up ownership and takes NULL as its value. - - T *Release () - { - T *p_ = p; - p = 0; - return p_; - } - - /// If a pointer is owned, it is deleted. Ownership is taken of passed in - /// pointer. - /// \param p array pointer which constructed AutoArray takes ownership of. p - /// will be deleted on destruction or Reset unless Release is called first. - - void Reset (T *p_ = 0) - { - if (p != p_) - { - delete [] p; - p = p_; - } - } - - /// Allows indexing into the AutoArray. It is an error to call this if the - /// AutoArray has NULL as its value. - - T &operator[] (ptrdiff_t i) const - { - return p [i]; - } - - /// Return the owned pointer of this AutoArray, NULL if none. No change in - /// ownership or other effects occur. - - T *Get () const - { - return p; - } - - private: - - // Hidden copy constructor and assignment operator. - - AutoArray (const AutoArray &); - - const AutoArray & operator= (const AutoArray &); - - private: - - // Owned pointer or NULL. - - T *p; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_bad_pixels.cpp b/third_party/dng_sdk/dng_bad_pixels.cpp deleted file mode 100644 index 920acd6..0000000 --- a/third_party/dng_sdk/dng_bad_pixels.cpp +++ /dev/null @@ -1,1856 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_bad_pixels.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_bad_pixels.h" - -#include "dng_filter_task.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_negative.h" - -#include - -/*****************************************************************************/ - -dng_opcode_FixBadPixelsConstant::dng_opcode_FixBadPixelsConstant - (uint32 constant, - uint32 bayerPhase) - - : dng_filter_opcode (dngOpcode_FixBadPixelsConstant, - dngVersion_1_3_0_0, - 0) - - , fConstant (constant) - , fBayerPhase (bayerPhase) - - { - - } - -/*****************************************************************************/ - -dng_opcode_FixBadPixelsConstant::dng_opcode_FixBadPixelsConstant - (dng_stream &stream) - - : dng_filter_opcode (dngOpcode_FixBadPixelsConstant, - stream, - "FixBadPixelsConstant") - - , fConstant (0) - , fBayerPhase (0) - - { - - if (stream.Get_uint32 () != 8) - { - ThrowBadFormat (); - } - - fConstant = stream.Get_uint32 (); - fBayerPhase = stream.Get_uint32 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Constant: %u\n", (unsigned) fConstant); - - printf ("Bayer Phase: %u\n", (unsigned) fBayerPhase); - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsConstant::PutData (dng_stream &stream) const - { - - stream.Put_uint32 (8); - - stream.Put_uint32 (fConstant ); - stream.Put_uint32 (fBayerPhase); - - } - -/*****************************************************************************/ - -dng_point dng_opcode_FixBadPixelsConstant::SrcRepeat () - { - - return dng_point (2, 2); - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_FixBadPixelsConstant::SrcArea (const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect srcArea = dstArea; - - srcArea.t -= 2; - srcArea.l -= 2; - - srcArea.b += 2; - srcArea.r += 2; - - return srcArea; - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsConstant::Prepare (dng_negative & /* negative */, - uint32 /* threadCount */, - const dng_point & /* tileSize */, - const dng_rect & /* imageBounds */, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator & /* allocator */) - { - - // This opcode is restricted to single channel images. - - if (imagePlanes != 1) - { - - ThrowBadFormat (); - - } - - // This opcode is restricted to 16-bit images. - - if (bufferPixelType != ttShort) - { - - ThrowBadFormat (); - - } - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsConstant::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dstBuffer.CopyArea (srcBuffer, - dstArea, - 0, - dstBuffer.fPlanes); - - uint16 badPixel = (uint16) fConstant; - - for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) - { - - const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (dstRow, dstArea.l, 0); - uint16 *dPtr = dstBuffer.DirtyPixel_uint16 (dstRow, dstArea.l, 0); - - for (int32 dstCol = dstArea.l; dstCol < dstArea.r; dstCol++) - { - - if (*sPtr == badPixel) - { - - uint32 count = 0; - uint32 total = 0; - - uint16 value; - - if (IsGreen (dstRow, dstCol)) // Green pixel - { - - value = sPtr [-srcBuffer.fRowStep - 1]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [-srcBuffer.fRowStep + 1]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [srcBuffer.fRowStep - 1]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [srcBuffer.fRowStep + 1]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - } - - else // Red/blue pixel. - { - - value = sPtr [-srcBuffer.fRowStep * 2]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [srcBuffer.fRowStep * 2]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [-2]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - value = sPtr [2]; - - if (value != badPixel) - { - count += 1; - total += value; - } - - } - - if (count == 4) // Most common case. - { - - *dPtr = (uint16) ((total + 2) >> 2); - - } - - else if (count > 0) - { - - *dPtr = (uint16) ((total + (count >> 1)) / count); - - } - - } - - sPtr++; - dPtr++; - - } - - } - - } - -/*****************************************************************************/ - -dng_bad_pixel_list::dng_bad_pixel_list () - - : fBadPoints () - , fBadRects () - - { - - } - -/*****************************************************************************/ - -void dng_bad_pixel_list::AddPoint (const dng_point &pt) - { - - fBadPoints.push_back (pt); - - } - -/*****************************************************************************/ - -void dng_bad_pixel_list::AddRect (const dng_rect &r) - { - - fBadRects.push_back (r); - - } - -/*****************************************************************************/ - -static bool SortBadPoints (const dng_point &a, - const dng_point &b) - { - - if (a.v < b.v) - return true; - - if (a.v > b.v) - return false; - - return a.h < b.h; - - } - -/*****************************************************************************/ - -static bool SortBadRects (const dng_rect &a, - const dng_rect &b) - { - - if (a.t < b.t) - return true; - - if (a.t > b.t) - return false; - - if (a.l < b.l) - return true; - - if (a.l > b.l) - return false; - - if (a.b < b.b) - return true; - - if (a.b > b.b) - return false; - - return a.r < b.r; - - } - -/*****************************************************************************/ - -void dng_bad_pixel_list::Sort () - { - - if (PointCount () > 1) - { - - std::sort (fBadPoints.begin (), - fBadPoints.end (), - SortBadPoints); - - } - - if (RectCount () > 1) - { - - std::sort (fBadRects.begin (), - fBadRects.end (), - SortBadRects); - - } - - } - -/*****************************************************************************/ - -bool dng_bad_pixel_list::IsPointIsolated (uint32 index, - uint32 radius) const - { - - dng_point pt = Point (index); - - // Search backward through bad point list. - - for (int32 j = index - 1; j >= 0; j--) - { - - const dng_point &pt2 = Point (j); - - if (pt2.v < pt.v - (int32) radius) - { - break; - } - - if (Abs_int32 (pt2.h - pt.h) <= radius) - { - return false; - } - - } - - // Search forward through bad point list. - - for (uint32 k = index + 1; k < PointCount (); k++) - { - - const dng_point &pt2 = Point (k); - - if (pt2.v > pt.v + (int32) radius) - { - break; - } - - if (Abs_int32 (pt2.h - pt.h) <= radius) - { - return false; - } - - } - - // Search through bad rectangle list. - - dng_rect testRect (pt.v - radius, - pt.h - radius, - pt.v + radius + 1, - pt.h + radius + 1); - - for (uint32 n = 0; n < RectCount (); n++) - { - - if ((testRect & Rect (n)).NotEmpty ()) - { - return false; - } - - } - - // Did not find point anywhere, so bad pixel is isolated. - - return true; - - } - -/*****************************************************************************/ - -bool dng_bad_pixel_list::IsRectIsolated (uint32 index, - uint32 radius) const - { - - dng_rect testRect = Rect (index); - - testRect.t -= radius; - testRect.l -= radius; - testRect.b += radius; - testRect.r += radius; - - for (uint32 n = 0; n < RectCount (); n++) - { - - if (n != index) - { - - if ((testRect & Rect (n)).NotEmpty ()) - { - return false; - } - - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_bad_pixel_list::IsPointValid (const dng_point &pt, - const dng_rect &imageBounds, - uint32 index) const - { - - // The point must be in the image bounds to be valid. - - if (pt.v < imageBounds.t || - pt.h < imageBounds.l || - pt.v >= imageBounds.b || - pt.h >= imageBounds.r) - { - return false; - } - - // Only search the bad point list if we have a starting search index. - - if (index != kNoIndex) - { - - // Search backward through bad point list. - - for (int32 j = index - 1; j >= 0; j--) - { - - const dng_point &pt2 = Point (j); - - if (pt2.v < pt.v) - { - break; - } - - if (pt2 == pt) - { - return false; - } - - } - - // Search forward through bad point list. - - for (uint32 k = index + 1; k < PointCount (); k++) - { - - const dng_point &pt2 = Point (k); - - if (pt2.v > pt.v) - { - break; - } - - if (pt2 == pt) - { - return false; - } - - } - - } - - // Search through bad rectangle list. - - for (uint32 n = 0; n < RectCount (); n++) - { - - const dng_rect &r = Rect (n); - - if (pt.v >= r.t && - pt.h >= r.l && - pt.v < r.b && - pt.h < r.r) - { - return false; - } - - } - - // Did not find point anywhere, so pixel is valid. - - return true; - - } - -/*****************************************************************************/ - -dng_opcode_FixBadPixelsList::dng_opcode_FixBadPixelsList - (AutoPtr &list, - uint32 bayerPhase) - - - : dng_filter_opcode (dngOpcode_FixBadPixelsList, - dngVersion_1_3_0_0, - 0) - - , fList () - - , fBayerPhase (bayerPhase) - - { - - fList.Reset (list.Release ()); - - fList->Sort (); - - } - -/*****************************************************************************/ - -dng_opcode_FixBadPixelsList::dng_opcode_FixBadPixelsList (dng_stream &stream) - - : dng_filter_opcode (dngOpcode_FixBadPixelsList, - stream, - "FixBadPixelsList") - - , fList () - - , fBayerPhase (0) - - { - - uint32 size = stream.Get_uint32 (); - - fBayerPhase = stream.Get_uint32 (); - - uint32 pCount = stream.Get_uint32 (); - uint32 rCount = stream.Get_uint32 (); - - if (size != 12 + pCount * 8 + rCount * 16) - { - ThrowBadFormat (); - } - - fList.Reset (new dng_bad_pixel_list); - - uint32 index; - - for (index = 0; index < pCount; index++) - { - - dng_point pt; - - pt.v = stream.Get_int32 (); - pt.h = stream.Get_int32 (); - - fList->AddPoint (pt); - - } - - for (index = 0; index < rCount; index++) - { - - dng_rect r; - - r.t = stream.Get_int32 (); - r.l = stream.Get_int32 (); - r.b = stream.Get_int32 (); - r.r = stream.Get_int32 (); - - fList->AddRect (r); - - } - - fList->Sort (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Bayer Phase: %u\n", (unsigned) fBayerPhase); - - printf ("Bad Pixels: %u\n", (unsigned) pCount); - - for (index = 0; index < pCount && index < gDumpLineLimit; index++) - { - printf (" Pixel [%u]: v=%d, h=%d\n", - (unsigned) index, - (int) fList->Point (index).v, - (int) fList->Point (index).h); - } - - if (pCount > gDumpLineLimit) - { - printf (" ... %u bad pixels skipped\n", (unsigned) (pCount - gDumpLineLimit)); - } - - printf ("Bad Rects: %u\n", (unsigned) rCount); - - for (index = 0; index < rCount && index < gDumpLineLimit; index++) - { - printf (" Rect [%u]: t=%d, l=%d, b=%d, r=%d\n", - (unsigned) index, - (int) fList->Rect (index).t, - (int) fList->Rect (index).l, - (int) fList->Rect (index).b, - (int) fList->Rect (index).r); - } - - if (rCount > gDumpLineLimit) - { - printf (" ... %u bad rects skipped\n", (unsigned) (rCount - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::PutData (dng_stream &stream) const - { - - uint32 pCount = fList->PointCount (); - uint32 rCount = fList->RectCount (); - - stream.Put_uint32 (12 + pCount * 8 + rCount * 16); - - stream.Put_uint32 (fBayerPhase); - - stream.Put_uint32 (pCount); - stream.Put_uint32 (rCount); - - uint32 index; - - for (index = 0; index < pCount; index++) - { - - const dng_point &pt (fList->Point (index)); - - stream.Put_int32 (pt.v); - stream.Put_int32 (pt.h); - - } - - for (index = 0; index < rCount; index++) - { - - const dng_rect &r (fList->Rect (index)); - - stream.Put_int32 (r.t); - stream.Put_int32 (r.l); - stream.Put_int32 (r.b); - stream.Put_int32 (r.r); - - } - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_FixBadPixelsList::SrcArea (const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - int32 padding = 0; - - if (fList->PointCount ()) - { - padding += kBadPointPadding; - } - - if (fList->RectCount ()) - { - padding += kBadRectPadding; - } - - dng_rect srcArea = dstArea; - - srcArea.t -= padding; - srcArea.l -= padding; - - srcArea.b += padding; - srcArea.r += padding; - - return srcArea; - - } - -/*****************************************************************************/ - -dng_point dng_opcode_FixBadPixelsList::SrcRepeat () - { - - return dng_point (2, 2); - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::Prepare (dng_negative & /* negative */, - uint32 /* threadCount */, - const dng_point & /* tileSize */, - const dng_rect & /* imageBounds */, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator & /* allocator */) - { - - // This opcode is restricted to single channel images. - - if (imagePlanes != 1) - { - - ThrowBadFormat (); - - } - - // This opcode is restricted to 16-bit images. - - if (bufferPixelType != ttShort) - { - - ThrowBadFormat (); - - } - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::FixIsolatedPixel (dng_pixel_buffer &buffer, - dng_point &badPoint) - { - - uint16 *p0 = buffer.DirtyPixel_uint16 (badPoint.v - 2, badPoint.h - 2, 0); - uint16 *p1 = buffer.DirtyPixel_uint16 (badPoint.v - 1, badPoint.h - 2, 0); - uint16 *p2 = buffer.DirtyPixel_uint16 (badPoint.v , badPoint.h - 2, 0); - uint16 *p3 = buffer.DirtyPixel_uint16 (badPoint.v + 1, badPoint.h - 2, 0); - uint16 *p4 = buffer.DirtyPixel_uint16 (badPoint.v + 2, badPoint.h - 2, 0); - - uint32 est0; - uint32 est1; - uint32 est2; - uint32 est3; - - uint32 grad0; - uint32 grad1; - uint32 grad2; - uint32 grad3; - - if (IsGreen (badPoint.v, badPoint.h)) // Green pixel - { - - // g00 b01 g02 b03 g04 - // r10 g11 r12 g13 r14 - // g20 b21 g22 b23 g24 - // r30 g31 r32 g33 r34 - // g40 b41 g42 b43 g44 - - int32 b01 = p0 [1]; - int32 g02 = p0 [2]; - int32 b03 = p0 [3]; - - int32 r10 = p1 [0]; - int32 g11 = p1 [1]; - int32 r12 = p1 [2]; - int32 g13 = p1 [3]; - int32 r14 = p1 [4]; - - int32 g20 = p2 [0]; - int32 b21 = p2 [1]; - int32 b23 = p2 [3]; - int32 g24 = p2 [4]; - - int32 r30 = p3 [0]; - int32 g31 = p3 [1]; - int32 r32 = p3 [2]; - int32 g33 = p3 [3]; - int32 r34 = p3 [4]; - - int32 b41 = p4 [1]; - int32 g42 = p4 [2]; - int32 b43 = p4 [3]; - - est0 = g02 + g42; - - grad0 = Abs_int32 (g02 - g42) + - Abs_int32 (g11 - g31) + - Abs_int32 (g13 - g33) + - Abs_int32 (b01 - b21) + - Abs_int32 (b03 - b23) + - Abs_int32 (b21 - b41) + - Abs_int32 (b23 - b43); - - est1 = g11 + g33; - - grad1 = Abs_int32 (g11 - g33) + - Abs_int32 (g02 - g24) + - Abs_int32 (g20 - g42) + - Abs_int32 (b01 - b23) + - Abs_int32 (r10 - r32) + - Abs_int32 (r12 - r34) + - Abs_int32 (b21 - b43); - - est2 = g20 + g24; - - grad2 = Abs_int32 (g20 - g24) + - Abs_int32 (g11 - g13) + - Abs_int32 (g31 - g33) + - Abs_int32 (r10 - r12) + - Abs_int32 (r30 - r32) + - Abs_int32 (r12 - r14) + - Abs_int32 (r32 - r34); - - est3 = g13 + g31; - - grad3 = Abs_int32 (g13 - g31) + - Abs_int32 (g02 - g20) + - Abs_int32 (g24 - g42) + - Abs_int32 (b03 - b21) + - Abs_int32 (r14 - r32) + - Abs_int32 (r12 - r30) + - Abs_int32 (b23 - b41); - - } - - else // Red/blue pixel - { - - // b00 g01 b02 g03 b04 - // g10 r11 g12 r13 g14 - // b20 g21 b22 g23 b24 - // g30 r31 g32 r33 g34 - // b40 g41 b42 g43 b44 - - int32 b00 = p0 [0]; - int32 g01 = p0 [1]; - int32 b02 = p0 [2]; - int32 g03 = p0 [3]; - int32 b04 = p0 [4]; - - int32 g10 = p1 [0]; - int32 r11 = p1 [1]; - int32 g12 = p1 [2]; - int32 r13 = p1 [3]; - int32 g14 = p1 [4]; - - int32 b20 = p2 [0]; - int32 g21 = p2 [1]; - int32 g23 = p2 [3]; - int32 b24 = p2 [4]; - - int32 g30 = p3 [0]; - int32 r31 = p3 [1]; - int32 g32 = p3 [2]; - int32 r33 = p3 [3]; - int32 g34 = p3 [4]; - - int32 b40 = p4 [0]; - int32 g41 = p4 [1]; - int32 b42 = p4 [2]; - int32 g43 = p4 [3]; - int32 b44 = p4 [4]; - - est0 = b02 + b42; - - grad0 = Abs_int32 (b02 - b42) + - Abs_int32 (g12 - g32) + - Abs_int32 (g01 - g21) + - Abs_int32 (g21 - g41) + - Abs_int32 (g03 - g23) + - Abs_int32 (g23 - g43) + - Abs_int32 (r11 - r31) + - Abs_int32 (r13 - r33); - - est1 = b00 + b44; - - grad1 = Abs_int32 (b00 - b44) + - Abs_int32 (r11 - r33) + - Abs_int32 (g01 - g23) + - Abs_int32 (g10 - g32) + - Abs_int32 (g12 - g34) + - Abs_int32 (g21 - g43) + - Abs_int32 (b02 - b24) + - Abs_int32 (b20 - b42); - - est2 = b20 + b24; - - grad2 = Abs_int32 (b20 - b24) + - Abs_int32 (g21 - g23) + - Abs_int32 (g10 - g12) + - Abs_int32 (g12 - g14) + - Abs_int32 (g30 - g32) + - Abs_int32 (g32 - g34) + - Abs_int32 (r11 - r13) + - Abs_int32 (r31 - r33); - - est3 = b04 + b40; - - grad3 = Abs_int32 (b04 - b40) + - Abs_int32 (r13 - r31) + - Abs_int32 (g03 - g21) + - Abs_int32 (g14 - g32) + - Abs_int32 (g12 - g30) + - Abs_int32 (g23 - g41) + - Abs_int32 (b02 - b20) + - Abs_int32 (b24 - b42); - - } - - uint32 minGrad = Min_uint32 (grad0, grad1); - - minGrad = Min_uint32 (minGrad, grad2); - minGrad = Min_uint32 (minGrad, grad3); - - uint32 limit = (minGrad * 3) >> 1; - - uint32 total = 0; - uint32 count = 0; - - if (grad0 <= limit) - { - total += est0; - count += 2; - } - - if (grad1 <= limit) - { - total += est1; - count += 2; - } - - if (grad2 <= limit) - { - total += est2; - count += 2; - } - - if (grad3 <= limit) - { - total += est3; - count += 2; - } - - uint32 estimate = (total + (count >> 1)) / count; - - p2 [2] = (uint16) estimate; - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::FixClusteredPixel (dng_pixel_buffer &buffer, - uint32 pointIndex, - const dng_rect &imageBounds) - { - - const uint32 kNumSets = 3; - const uint32 kSetSize = 4; - - static const int32 kOffset [kNumSets] [kSetSize] [2] = - { - { - { -1, 1 }, - { -1, -1 }, - { 1, -1 }, - { 1, 1 } - }, - { - { -2, 0 }, - { 2, 0 }, - { 0, -2 }, - { 0, 2 } - }, - { - { -2, -2 }, - { -2, 2 }, - { 2, -2 }, - { 2, 2 } - } - }; - - dng_point badPoint = fList->Point (pointIndex); - - bool isGreen = IsGreen (badPoint.v, badPoint.h); - - uint16 *p = buffer.DirtyPixel_uint16 (badPoint.v, badPoint.h, 0); - - for (uint32 set = 0; set < kNumSets; set++) - { - - if (!isGreen && (kOffset [set] [0] [0] & 1) == 1) - { - continue; - } - - uint32 total = 0; - uint32 count = 0; - - for (uint32 entry = 0; entry < kSetSize; entry++) - { - - dng_point offset (kOffset [set] [entry] [0], - kOffset [set] [entry] [1]); - - if (fList->IsPointValid (badPoint + offset, - imageBounds, - pointIndex)) - { - - total += p [offset.v * buffer.fRowStep + - offset.h * buffer.fColStep]; - - count++; - - } - - } - - if (count) - { - - uint32 estimate = (total + (count >> 1)) / count; - - p [0] = (uint16) estimate; - - return; - - } - - } - - // Unable to patch bad pixel. Leave pixel as is. - - #if qDNGValidate - - char s [256]; - - sprintf (s, "Unable to repair bad pixel, row %d, column %d", - (int) badPoint.v, - (int) badPoint.h); - - ReportWarning (s); - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::FixSingleColumn (dng_pixel_buffer &buffer, - const dng_rect &badRect) - { - - int32 cs = buffer.fColStep; - - for (int32 row = badRect.t; row < badRect.b; row++) - { - - uint16 *p0 = buffer.DirtyPixel_uint16 (row - 4, badRect.l - 4, 0); - uint16 *p1 = buffer.DirtyPixel_uint16 (row - 3, badRect.l - 4, 0); - uint16 *p2 = buffer.DirtyPixel_uint16 (row - 2, badRect.l - 4, 0); - uint16 *p3 = buffer.DirtyPixel_uint16 (row - 1, badRect.l - 4, 0); - uint16 *p4 = buffer.DirtyPixel_uint16 (row , badRect.l - 4, 0); - uint16 *p5 = buffer.DirtyPixel_uint16 (row + 1, badRect.l - 4, 0); - uint16 *p6 = buffer.DirtyPixel_uint16 (row + 2, badRect.l - 4, 0); - uint16 *p7 = buffer.DirtyPixel_uint16 (row + 3, badRect.l - 4, 0); - uint16 *p8 = buffer.DirtyPixel_uint16 (row + 4, badRect.l - 4, 0); - - uint32 est0; - uint32 est1; - uint32 est2; - uint32 est3; - uint32 est4; - uint32 est5; - uint32 est6; - - uint32 grad0; - uint32 grad1; - uint32 grad2; - uint32 grad3; - uint32 grad4; - uint32 grad5; - uint32 grad6; - - uint32 lower = 0; - uint32 upper = 0x0FFFF; - - if (IsGreen (row, badRect.l)) // Green pixel - { - - // g00 b01 g02 b03 g04 b05 g06 b07 g08 - // r10 g11 r12 g13 r14 g15 r16 g17 r18 - // g20 b21 g22 b23 g24 b25 g26 b27 g28 - // r30 g31 r32 g33 r34 g35 r36 g37 r38 - // g40 b41 g42 b43 g44 b45 g46 b47 g48 - // r50 g51 r52 g53 r54 g55 r56 g57 r58 - // g60 b61 g62 b63 g64 b65 g66 b67 g68 - // r70 g71 r72 g73 r74 g75 r76 g77 r78 - // g80 b81 g82 b83 g84 b85 g86 b87 g88 - - int32 b03 = p0 [3 * cs]; - int32 b05 = p0 [5 * cs]; - - int32 g11 = p1 [1 * cs]; - int32 g13 = p1 [3 * cs]; - int32 g15 = p1 [5 * cs]; - int32 g17 = p1 [7 * cs]; - - int32 g22 = p2 [2 * cs]; - int32 b23 = p2 [3 * cs]; - int32 b25 = p2 [5 * cs]; - int32 g26 = p2 [6 * cs]; - - int32 r30 = p3 [0 * cs]; - int32 g31 = p3 [1 * cs]; - int32 r32 = p3 [2 * cs]; - int32 g33 = p3 [3 * cs]; - int32 g35 = p3 [5 * cs]; - int32 r36 = p3 [6 * cs]; - int32 g37 = p3 [7 * cs]; - int32 r38 = p3 [8 * cs]; - - int32 g40 = p4 [0 * cs]; - int32 g42 = p4 [2 * cs]; - int32 b43 = p4 [3 * cs]; - int32 b45 = p4 [5 * cs]; - int32 g46 = p4 [6 * cs]; - int32 g48 = p4 [8 * cs]; - - int32 r50 = p5 [0 * cs]; - int32 g51 = p5 [1 * cs]; - int32 r52 = p5 [2 * cs]; - int32 g53 = p5 [3 * cs]; - int32 g55 = p5 [5 * cs]; - int32 r56 = p5 [6 * cs]; - int32 g57 = p5 [7 * cs]; - int32 r58 = p5 [8 * cs]; - - int32 g62 = p6 [2 * cs]; - int32 b63 = p6 [3 * cs]; - int32 b65 = p6 [5 * cs]; - int32 g66 = p6 [6 * cs]; - - int32 g71 = p7 [1 * cs]; - int32 g73 = p7 [3 * cs]; - int32 g75 = p7 [5 * cs]; - int32 g77 = p7 [7 * cs]; - - int32 b83 = p8 [3 * cs]; - int32 b85 = p8 [5 * cs]; - - // In case there is some green split, make an estimate of - // of the local difference between the greens, and adjust - // the estimated green values for the difference - // between the two types of green pixels when estimating - // across green types. - - int32 split = ((g22 + g62 + g26 + g66) * 4 + - (g42 + g46 ) * 8 - - (g11 + g13 + g15 + g17) - - (g31 + g33 + g35 + g37) * 3 - - (g51 + g53 + g55 + g57) * 3 - - (g71 + g73 + g75 + g77) + 16) >> 5; - - est0 = g13 + g75 + split * 2; - - grad0 = Abs_int32 (g13 - g75) + - Abs_int32 (g15 - g46) + - Abs_int32 (g22 - g53) + - Abs_int32 (g35 - g66) + - Abs_int32 (g42 - g73) + - Abs_int32 (b03 - b65) + - Abs_int32 (b23 - b85); - - est1 = g33 + g55 + split * 2; - - grad1 = Abs_int32 (g33 - g55) + - Abs_int32 (g22 - g55) + - Abs_int32 (g33 - g66) + - Abs_int32 (g13 - g35) + - Abs_int32 (g53 - g75) + - Abs_int32 (b23 - b45) + - Abs_int32 (b43 - b65); - - est2 = g31 + g57 + split * 2; - - grad2 = Abs_int32 (g31 - g57) + - Abs_int32 (g33 - g46) + - Abs_int32 (g35 - g48) + - Abs_int32 (g40 - g53) + - Abs_int32 (g42 - g55) + - Abs_int32 (r30 - r56) + - Abs_int32 (r32 - r58); - - est3 = g42 + g46; - - grad3 = Abs_int32 (g42 - g46) * 2 + - Abs_int32 (g33 - g35) + - Abs_int32 (g53 - g55) + - Abs_int32 (b23 - b25) + - Abs_int32 (b43 - b45) + - Abs_int32 (b63 - b65); - - est4 = g37 + g51 + split * 2; - - grad4 = Abs_int32 (g37 - g51) + - Abs_int32 (g35 - g42) + - Abs_int32 (g33 - g40) + - Abs_int32 (g48 - g55) + - Abs_int32 (g46 - g53) + - Abs_int32 (r38 - r52) + - Abs_int32 (r36 - r50); - - est5 = g35 + g53 + split * 2; - - grad5 = Abs_int32 (g35 - g53) + - Abs_int32 (g26 - g53) + - Abs_int32 (g35 - g62) + - Abs_int32 (g15 - g33) + - Abs_int32 (g55 - g73) + - Abs_int32 (b25 - b43) + - Abs_int32 (b45 - b63); - - est6 = g15 + g73 + split * 2; - - grad6 = Abs_int32 (g15 - g73) + - Abs_int32 (g13 - g42) + - Abs_int32 (g26 - g55) + - Abs_int32 (g33 - g62) + - Abs_int32 (g46 - g75) + - Abs_int32 (b05 - b63) + - Abs_int32 (b25 - b83); - - lower = Min_uint32 (Min_uint32 (g33, g35), - Min_uint32 (g53, g55)); - - upper = Max_uint32 (Max_uint32 (g33, g35), - Max_uint32 (g53, g55)); - - lower = Pin_int32 (0, lower + split, 65535); - upper = Pin_int32 (0, upper + split, 65535); - - } - - else // Red/blue pixel - { - - // b00 g01 b02 g03 b04 g05 b06 g07 b08 - // g10 r11 g12 r13 g14 r15 g16 r17 g18 - // b20 g21 b22 g23 b24 g25 b26 g27 b28 - // g30 r31 g32 r33 g34 r35 g36 r37 g38 - // b40 g41 b42 g43 b44 g45 b46 g47 b48 - // g50 r51 g52 r53 g54 r55 g56 r57 g58 - // b60 g61 b62 g63 b64 g65 b66 g67 b68 - // g70 r71 g72 r73 g74 r75 g76 r77 g78 - // b80 g81 b82 g83 b84 g85 b86 g87 b88 - - int32 b02 = p0 [2 * cs]; - int32 g03 = p0 [3 * cs]; - int32 g05 = p0 [5 * cs]; - int32 b06 = p0 [6 * cs]; - - int32 r13 = p1 [3 * cs]; - int32 r15 = p1 [5 * cs]; - - int32 b20 = p2 [0 * cs]; - int32 b22 = p2 [2 * cs]; - int32 g23 = p2 [3 * cs]; - int32 g25 = p2 [5 * cs]; - int32 b26 = p2 [6 * cs]; - int32 b28 = p2 [8 * cs]; - - int32 r31 = p3 [1 * cs]; - int32 g32 = p3 [2 * cs]; - int32 r33 = p3 [3 * cs]; - int32 r35 = p3 [5 * cs]; - int32 g36 = p3 [6 * cs]; - int32 r37 = p3 [7 * cs]; - - int32 g41 = p4 [1 * cs]; - int32 b42 = p4 [2 * cs]; - int32 g43 = p4 [3 * cs]; - int32 g45 = p4 [5 * cs]; - int32 b46 = p4 [6 * cs]; - int32 g47 = p4 [7 * cs]; - - int32 r51 = p5 [1 * cs]; - int32 g52 = p5 [2 * cs]; - int32 r53 = p5 [3 * cs]; - int32 r55 = p5 [5 * cs]; - int32 g56 = p5 [6 * cs]; - int32 r57 = p5 [7 * cs]; - - int32 b60 = p6 [0 * cs]; - int32 b62 = p6 [2 * cs]; - int32 g63 = p6 [3 * cs]; - int32 g65 = p6 [5 * cs]; - int32 b66 = p6 [6 * cs]; - int32 b68 = p6 [8 * cs]; - - int32 r73 = p7 [3 * cs]; - int32 r75 = p7 [5 * cs]; - - int32 b82 = p8 [2 * cs]; - int32 g83 = p8 [3 * cs]; - int32 g85 = p8 [5 * cs]; - int32 b86 = p8 [6 * cs]; - - est0 = b02 + b86; - - grad0 = Abs_int32 (b02 - b86) + - Abs_int32 (r13 - r55) + - Abs_int32 (r33 - r75) + - Abs_int32 (g03 - g45) + - Abs_int32 (g23 - g65) + - Abs_int32 (g43 - g85); - - est1 = b22 + b66; - - grad1 = Abs_int32 (b22 - b66) + - Abs_int32 (r13 - r35) + - Abs_int32 (r33 - r55) + - Abs_int32 (r53 - r75) + - Abs_int32 (g23 - g45) + - Abs_int32 (g43 - g65); - - est2 = b20 + b68; - - grad2 = Abs_int32 (b20 - b68) + - Abs_int32 (r31 - r55) + - Abs_int32 (r33 - r57) + - Abs_int32 (g23 - g47) + - Abs_int32 (g32 - g56) + - Abs_int32 (g41 - g65); - - est3 = b42 + b46; - - grad3 = Abs_int32 (b42 - b46) + - Abs_int32 (r33 - r35) + - Abs_int32 (r53 - r55) + - Abs_int32 (g32 - g36) + - Abs_int32 (g43 - g43) + - Abs_int32 (g52 - g56); - - est4 = b28 + b60; - - grad4 = Abs_int32 (b28 - b60) + - Abs_int32 (r37 - r53) + - Abs_int32 (r35 - r51) + - Abs_int32 (g25 - g41) + - Abs_int32 (g36 - g52) + - Abs_int32 (g47 - g63); - - est5 = b26 + b62; - - grad5 = Abs_int32 (b26 - b62) + - Abs_int32 (r15 - r33) + - Abs_int32 (r35 - r53) + - Abs_int32 (r55 - r73) + - Abs_int32 (g25 - g43) + - Abs_int32 (g45 - g63); - - est6 = b06 + b82; - - grad6 = Abs_int32 (b06 - b82) + - Abs_int32 (r15 - r53) + - Abs_int32 (r35 - r73) + - Abs_int32 (g05 - g43) + - Abs_int32 (g25 - g63) + - Abs_int32 (g45 - g83); - - lower = Min_uint32 (b42, b46); - upper = Max_uint32 (b42, b46); - - } - - uint32 minGrad = Min_uint32 (grad0, grad1); - - minGrad = Min_uint32 (minGrad, grad2); - minGrad = Min_uint32 (minGrad, grad3); - minGrad = Min_uint32 (minGrad, grad4); - minGrad = Min_uint32 (minGrad, grad5); - minGrad = Min_uint32 (minGrad, grad6); - - uint32 limit = (minGrad * 3) >> 1; - - uint32 total = 0; - uint32 count = 0; - - if (grad0 <= limit) - { - total += est0; - count += 2; - } - - if (grad1 <= limit) - { - total += est1; - count += 2; - } - - if (grad2 <= limit) - { - total += est2; - count += 2; - } - - if (grad3 <= limit) - { - total += est3; - count += 2; - } - - if (grad4 <= limit) - { - total += est4; - count += 2; - } - - if (grad5 <= limit) - { - total += est5; - count += 2; - } - - if (grad6 <= limit) - { - total += est6; - count += 2; - } - - uint32 estimate = (total + (count >> 1)) / count; - - p4 [4] = (uint16) Pin_uint32 (lower, estimate, upper); - - } - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::FixSingleRow (dng_pixel_buffer &buffer, - const dng_rect &badRect) - { - - dng_pixel_buffer tBuffer = buffer; - - tBuffer.fArea = Transpose (buffer.fArea); - - tBuffer.fRowStep = buffer.fColStep; - tBuffer.fColStep = buffer.fRowStep; - - dng_rect tBadRect = Transpose (badRect); - - FixSingleColumn (tBuffer, tBadRect); - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::FixClusteredRect (dng_pixel_buffer &buffer, - const dng_rect &badRect, - const dng_rect &imageBounds) - { - - const uint32 kNumSets = 8; - const uint32 kSetSize = 8; - - static const int32 kOffset [kNumSets] [kSetSize] [2] = - { - { - { -1, 1 }, - { -1, -1 }, - { 1, -1 }, - { 1, 1 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - }, - { - { -2, 0 }, - { 2, 0 }, - { 0, -2 }, - { 0, 2 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - }, - { - { -2, -2 }, - { -2, 2 }, - { 2, -2 }, - { 2, 2 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - }, - { - { -1, -3 }, - { -3, -1 }, - { 1, -3 }, - { 3, -1 }, - { -1, 3 }, - { -3, 1 }, - { 1, 3 }, - { 3, 1 } - }, - { - { -4, 0 }, - { 4, 0 }, - { 0, -4 }, - { 0, 4 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - }, - { - { -3, -3 }, - { -3, 3 }, - { 3, -3 }, - { 3, 3 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - }, - { - { -2, -4 }, - { -4, -2 }, - { 2, -4 }, - { 4, -2 }, - { -2, 4 }, - { -4, 2 }, - { 2, 4 }, - { 4, 2 } - }, - { - { -4, -4 }, - { -4, 4 }, - { 4, -4 }, - { 4, 4 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 } - } - }; - - bool didFail = false; - - for (int32 row = badRect.t; row < badRect.b; row++) - { - - for (int32 col = badRect.l; col < badRect.r; col++) - { - - uint16 *p = buffer.DirtyPixel_uint16 (row, col, 0); - - bool isGreen = IsGreen (row, col); - - bool didFixPixel = false; - - for (uint32 set = 0; set < kNumSets && !didFixPixel; set++) - { - - if (!isGreen && (kOffset [set] [0] [0] & 1) == 1) - { - continue; - } - - uint32 total = 0; - uint32 count = 0; - - for (uint32 entry = 0; entry < kSetSize; entry++) - { - - dng_point offset (kOffset [set] [entry] [0], - kOffset [set] [entry] [1]); - - if (offset.v == 0 && - offset.h == 0) - { - break; - } - - if (fList->IsPointValid (dng_point (row, col) + offset, - imageBounds)) - { - - total += p [offset.v * buffer.fRowStep + - offset.h * buffer.fColStep]; - - count++; - - } - - } - - if (count) - { - - uint32 estimate = (total + (count >> 1)) / count; - - p [0] = (uint16) estimate; - - didFixPixel = true; - - } - - } - - if (!didFixPixel) - { - - didFail = true; - - } - - } - - } - - #if qDNGValidate - - if (didFail) - { - - ReportWarning ("Unable to repair bad rectangle"); - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_FixBadPixelsList::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer, - const dng_rect &dstArea, - const dng_rect &imageBounds) - { - - uint32 pointCount = fList->PointCount (); - uint32 rectCount = fList->RectCount (); - - dng_rect fixArea = dstArea; - - if (rectCount) - { - fixArea.t -= kBadRectPadding; - fixArea.l -= kBadRectPadding; - fixArea.b += kBadRectPadding; - fixArea.r += kBadRectPadding; - } - - bool didFixPoint = false; - - if (pointCount) - { - - for (uint32 pointIndex = 0; pointIndex < pointCount; pointIndex++) - { - - dng_point badPoint = fList->Point (pointIndex); - - if (badPoint.v >= fixArea.t && - badPoint.h >= fixArea.l && - badPoint.v < fixArea.b && - badPoint.h < fixArea.r) - { - - bool isIsolated = fList->IsPointIsolated (pointIndex, - kBadPointPadding); - - if (isIsolated && - badPoint.v >= imageBounds.t + kBadPointPadding && - badPoint.h >= imageBounds.l + kBadPointPadding && - badPoint.v < imageBounds.b - kBadPointPadding && - badPoint.h < imageBounds.r - kBadPointPadding) - { - - FixIsolatedPixel (srcBuffer, - badPoint); - - } - - else - { - - FixClusteredPixel (srcBuffer, - pointIndex, - imageBounds); - - } - - didFixPoint = true; - - } - - } - - } - - if (rectCount) - { - - if (didFixPoint) - { - - srcBuffer.RepeatSubArea (imageBounds, - SrcRepeat ().v, - SrcRepeat ().h); - - } - - for (uint32 rectIndex = 0; rectIndex < rectCount; rectIndex++) - { - - dng_rect badRect = fList->Rect (rectIndex); - - dng_rect overlap = dstArea & badRect; - - if (overlap.NotEmpty ()) - { - - bool isIsolated = fList->IsRectIsolated (rectIndex, - kBadRectPadding); - - if (isIsolated && - badRect.r == badRect.l + 1 && - badRect.l >= imageBounds.l + SrcRepeat ().h && - badRect.r <= imageBounds.r - SrcRepeat ().v) - { - - FixSingleColumn (srcBuffer, - overlap); - - } - - else if (isIsolated && - badRect.b == badRect.t + 1 && - badRect.t >= imageBounds.t + SrcRepeat ().h && - badRect.b <= imageBounds.b - SrcRepeat ().v) - { - - FixSingleRow (srcBuffer, - overlap); - - } - - else - { - - FixClusteredRect (srcBuffer, - overlap, - imageBounds); - - } - - } - - } - - } - - dstBuffer.CopyArea (srcBuffer, - dstArea, - 0, - dstBuffer.fPlanes); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_bad_pixels.h b/third_party/dng_sdk/dng_bad_pixels.h deleted file mode 100644 index c7b65d6..0000000 --- a/third_party/dng_sdk/dng_bad_pixels.h +++ /dev/null @@ -1,307 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_bad_pixels.h#3 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Opcodes to fix defective pixels, including individual pixels and regions (such as - * defective rows and columns). - */ - -/*****************************************************************************/ - -#ifndef __dng_bad_pixels__ -#define __dng_bad_pixels__ - -/*****************************************************************************/ - -#include "dng_opcodes.h" - -#include - -/*****************************************************************************/ - -/// \brief An opcode to fix individual bad pixels that are marked with a constant -/// value (e.g., 0) in a Bayer image. - -class dng_opcode_FixBadPixelsConstant: public dng_filter_opcode - { - - private: - - uint32 fConstant; - - uint32 fBayerPhase; - - public: - - /// Construct an opcode to fix an individual bad pixels that are marked with - /// a constant value in a Bayer image. - /// \param constant The constant value that indicates a bad pixel. - /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3). - - dng_opcode_FixBadPixelsConstant (uint32 constant, - uint32 bayerPhase); - - dng_opcode_FixBadPixelsConstant (dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual dng_point SrcRepeat (); - - virtual dng_rect SrcArea (const dng_rect &dstArea, - const dng_rect &imageBounds); - - virtual void Prepare (dng_negative &negative, - uint32 threadCount, - const dng_point &tileSize, - const dng_rect &imageBounds, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator &allocator); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - protected: - - bool IsGreen (int32 row, int32 col) const - { - return (((uint32) row + (uint32) col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0; - } - - }; - -/*****************************************************************************/ - -/// \brief A list of bad pixels and rectangles (usually single rows or columns). - -class dng_bad_pixel_list - { - - public: - - enum - { - kNoIndex = 0xFFFFFFFF - }; - - private: - - // List of bad single pixels. - - std::vector fBadPoints; - - // List of bad rectangles (usually single rows or columns). - - std::vector fBadRects; - - public: - - /// Create an empty bad pixel list. - - dng_bad_pixel_list (); - - /// Returns the number of bad single pixels. - - uint32 PointCount () const - { - return (uint32) fBadPoints.size (); - } - - /// Retrieves the bad single pixel coordinate via the specified list index. - /// - /// \param index The list index from which to retrieve the bad single pixel - /// coordinate. - - const dng_point & Point (uint32 index) const - { - return fBadPoints [index]; - } - - /// Returns the number of bad rectangles. - - uint32 RectCount () const - { - return (uint32) fBadRects.size (); - } - - /// Retrieves the bad rectangle via the specified list index. - /// - /// \param index The list index from which to retrieve the bad rectangle - /// coordinates. - - const dng_rect & Rect (uint32 index) const - { - return fBadRects [index]; - } - - /// Returns true iff there are zero bad single pixels and zero bad - /// rectangles. - - bool IsEmpty () const - { - return PointCount () == 0 && - RectCount () == 0; - } - - /// Returns true iff there is at least one bad single pixel or at least one - /// bad rectangle. - - bool NotEmpty () const - { - return !IsEmpty (); - } - - /// Add the specified coordinate to the list of bad single pixels. - /// - /// \param pt The bad single pixel to add. - - void AddPoint (const dng_point &pt); - - /// Add the specified rectangle to the list of bad rectangles. - /// - /// \param pt The bad rectangle to add. - - void AddRect (const dng_rect &r); - - /// Sort the bad single pixels and bad rectangles by coordinates (top to - /// bottom, then left to right). - - void Sort (); - - /// Returns true iff the specified bad single pixel is isolated, i.e., there - /// is no other bad single pixel or bad rectangle that lies within radius - /// pixels of this bad single pixel. - /// - /// \param index The index of the bad single pixel to test. - /// \param radius The pixel radius to test for isolation. - - bool IsPointIsolated (uint32 index, - uint32 radius) const; - - /// Returns true iff the specified bad rectangle is isolated, i.e., there - /// is no other bad single pixel or bad rectangle that lies within radius - /// pixels of this bad rectangle. - /// - /// \param index The index of the bad rectangle to test. - /// \param radius The pixel radius to test for isolation. - - bool IsRectIsolated (uint32 index, - uint32 radius) const; - - /// Returns true iff the specified point is valid, i.e., lies within the - /// specified image bounds, is different from all other bad single pixels, - /// and is not contained in any bad rectangle. The second and third - /// conditions are only checked if provided with a starting search index. - /// - /// \param pt The point to test for validity. - /// \param imageBounds The pt must lie within imageBounds to be valid. - /// \index The search index to use (or kNoIndex, to avoid a search) for - /// checking for validity. - - bool IsPointValid (const dng_point &pt, - const dng_rect &imageBounds, - uint32 index = kNoIndex) const; - - }; - -/*****************************************************************************/ - -/// \brief An opcode to fix lists of bad pixels (indicated by position) in a Bayer -/// image. - -class dng_opcode_FixBadPixelsList: public dng_filter_opcode - { - - protected: - - enum - { - kBadPointPadding = 2, - kBadRectPadding = 4 - }; - - private: - - AutoPtr fList; - - uint32 fBayerPhase; - - public: - - /// Construct an opcode to fix lists of bad pixels (indicated by position) in - /// a Bayer image. - /// \param list The list of bad pixels to fix. - /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3). - - dng_opcode_FixBadPixelsList (AutoPtr &list, - uint32 bayerPhase); - - dng_opcode_FixBadPixelsList (dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual dng_point SrcRepeat (); - - virtual dng_rect SrcArea (const dng_rect &dstArea, - const dng_rect &imageBounds); - - virtual void Prepare (dng_negative &negative, - uint32 threadCount, - const dng_point &tileSize, - const dng_rect &imageBounds, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator &allocator); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - protected: - - bool IsGreen (int32 row, int32 col) const - { - return ((row + col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0; - } - - virtual void FixIsolatedPixel (dng_pixel_buffer &buffer, - dng_point &badPoint); - - virtual void FixClusteredPixel (dng_pixel_buffer &buffer, - uint32 pointIndex, - const dng_rect &imageBounds); - - virtual void FixSingleColumn (dng_pixel_buffer &buffer, - const dng_rect &badRect); - - virtual void FixSingleRow (dng_pixel_buffer &buffer, - const dng_rect &badRect); - - virtual void FixClusteredRect (dng_pixel_buffer &buffer, - const dng_rect &badRect, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_bottlenecks.cpp b/third_party/dng_sdk/dng_bottlenecks.cpp deleted file mode 100644 index 44fdb7a..0000000 --- a/third_party/dng_sdk/dng_bottlenecks.cpp +++ /dev/null @@ -1,72 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_bottlenecks.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_bottlenecks.h" - -#include "dng_reference.h" - -/*****************************************************************************/ - -dng_suite gDNGSuite = - { - RefZeroBytes, - RefCopyBytes, - RefSwapBytes16, - RefSwapBytes32, - RefSetArea8, - RefSetArea16, - RefSetArea32, - RefCopyArea8, - RefCopyArea16, - RefCopyArea32, - RefCopyArea8_16, - RefCopyArea8_S16, - RefCopyArea8_32, - RefCopyArea16_S16, - RefCopyArea16_32, - RefCopyArea8_R32, - RefCopyArea16_R32, - RefCopyAreaS16_R32, - RefCopyAreaR32_8, - RefCopyAreaR32_16, - RefCopyAreaR32_S16, - RefRepeatArea8, - RefRepeatArea16, - RefRepeatArea32, - RefShiftRight16, - RefBilinearRow16, - RefBilinearRow32, - RefBaselineABCtoRGB, - RefBaselineABCDtoRGB, - RefBaselineHueSatMap, - RefBaselineRGBtoGray, - RefBaselineRGBtoRGB, - RefBaseline1DTable, - RefBaselineRGBTone, - RefResampleDown16, - RefResampleDown32, - RefResampleAcross16, - RefResampleAcross32, - RefEqualBytes, - RefEqualArea8, - RefEqualArea16, - RefEqualArea32, - RefVignetteMask16, - RefVignette16, - RefVignette32, - RefMapArea16 - }; - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_bottlenecks.h b/third_party/dng_sdk/dng_bottlenecks.h deleted file mode 100644 index ff8cbb0..0000000 --- a/third_party/dng_sdk/dng_bottlenecks.h +++ /dev/null @@ -1,1715 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_bottlenecks.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Indirection mechanism for performance-critical routines that might be replaced - * with hand-optimized or hardware-specific implementations. - */ - -/*****************************************************************************/ - -#ifndef __dng_bottlenecks__ -#define __dng_bottlenecks__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -typedef void (ZeroBytesProc) - (void *dPtr, - uint32 count); - -typedef void (CopyBytesProc) - (const void *sPtr, - void *dPtr, - uint32 count); - -/*****************************************************************************/ - -typedef void (SwapBytes16Proc) - (uint16 *dPtr, - uint32 count); - -typedef void (SwapBytes32Proc) - (uint32 *dPtr, - uint32 count); - -/*****************************************************************************/ - -typedef void (SetArea8Proc) - (uint8 *dPtr, - uint8 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -typedef void (SetArea16Proc) - (uint16 *dPtr, - uint16 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -typedef void (SetArea32Proc) - (uint32 *dPtr, - uint32 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -/*****************************************************************************/ - -typedef void (CopyArea8Proc) - (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea16Proc) - (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea32Proc) - (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea8_16Proc) - (const uint8 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea8_S16Proc) - (const uint8 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea8_32Proc) - (const uint8 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea16_S16Proc) - (const uint16 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea16_32Proc) - (const uint16 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef void (CopyArea8_R32Proc) - (const uint8 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -typedef void (CopyArea16_R32Proc) - (const uint16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -typedef void (CopyAreaS16_R32Proc) - (const int16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -typedef void (CopyAreaR32_8Proc) - (const real32 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -typedef void (CopyAreaR32_16Proc) - (const real32 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -typedef void (CopyAreaR32_S16Proc) - (const real32 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -/*****************************************************************************/ - -typedef void (RepeatArea8Proc) - (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -typedef void (RepeatArea16Proc) - (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -typedef void (RepeatArea32Proc) - (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -/*****************************************************************************/ - -typedef void (ShiftRight16Proc) - (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 shift); - -/*****************************************************************************/ - -typedef void (BilinearRow16Proc) - (const uint16 *sPtr, - uint16 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const uint16 * const * kernWeights, - uint32 sShift); - -typedef void (BilinearRow32Proc) - (const real32 *sPtr, - real32 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const real32 * const * kernWeights, - uint32 sShift); - -/*****************************************************************************/ - -typedef void (BaselineABCtoRGBProc) - (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB); - -typedef void (BaselineABCDtoRGBProc) - (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - const real32 *sPtrD, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB); - -/*****************************************************************************/ - -typedef void (BaselineHueSatMapProc) - (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_hue_sat_map &lut, - const dng_1d_table *encodeTable, - const dng_1d_table *decodeTable); - -/*****************************************************************************/ - -typedef void (BaselineGrayToRGBProc) - (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrG, - uint32 count, - const dng_matrix &matrix); - -typedef void (BaselineRGBtoRGBProc) - (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_matrix &matrix); - -/*****************************************************************************/ - -typedef void (Baseline1DTableProc) - (const real32 *sPtr, - real32 *dPtr, - uint32 count, - const dng_1d_table &table); - -/*****************************************************************************/ - -typedef void (BaselineRGBToneProc) - (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_1d_table &table); - -/*****************************************************************************/ - -typedef void (ResampleDown16Proc) - (const uint16 *sPtr, - uint16 *dPtr, - uint32 sCount, - int32 sRowStep, - const int16 *wPtr, - uint32 wCount, - uint32 pixelRange); - -typedef void (ResampleDown32Proc) - (const real32 *sPtr, - real32 *dPtr, - uint32 sCount, - int32 sRowStep, - const real32 *wPtr, - uint32 wCount); - -/*****************************************************************************/ - -typedef void (ResampleAcross16Proc) - (const uint16 *sPtr, - uint16 *dPtr, - uint32 dCount, - const int32 *coord, - const int16 *wPtr, - uint32 wCount, - uint32 wStep, - uint32 pixelRange); - -typedef void (ResampleAcross32Proc) - (const real32 *sPtr, - real32 *dPtr, - uint32 dCount, - const int32 *coord, - const real32 *wPtr, - uint32 wCount, - uint32 wStep); - -/*****************************************************************************/ - -typedef bool (EqualBytesProc) - (const void *sPtr, - const void *dPtr, - uint32 count); - -typedef bool (EqualArea8Proc) - (const uint8 *sPtr, - const uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef bool (EqualArea16Proc) - (const uint16 *sPtr, - const uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -typedef bool (EqualArea32Proc) - (const uint32 *sPtr, - const uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -/*****************************************************************************/ - -typedef void (VignetteMask16Proc) - (uint16 *mPtr, - uint32 rows, - uint32 cols, - int32 rowStep, - int64 offsetH, - int64 offsetV, - int64 stepH, - int64 stepV, - uint32 tBits, - const uint16 *table); - -typedef void (Vignette16Proc) - (int16 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits); - -/*****************************************************************************/ - -typedef void (Vignette32Proc) - (real32 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits); - -/*****************************************************************************/ - -typedef void (MapArea16Proc) - (uint16 *dPtr, - uint32 count0, - uint32 count1, - uint32 count2, - int32 step0, - int32 step1, - int32 step2, - const uint16 *map); - -/*****************************************************************************/ - -struct dng_suite - { - ZeroBytesProc *ZeroBytes; - CopyBytesProc *CopyBytes; - SwapBytes16Proc *SwapBytes16; - SwapBytes32Proc *SwapBytes32; - SetArea8Proc *SetArea8; - SetArea16Proc *SetArea16; - SetArea32Proc *SetArea32; - CopyArea8Proc *CopyArea8; - CopyArea16Proc *CopyArea16; - CopyArea32Proc *CopyArea32; - CopyArea8_16Proc *CopyArea8_16; - CopyArea8_S16Proc *CopyArea8_S16; - CopyArea8_32Proc *CopyArea8_32; - CopyArea16_S16Proc *CopyArea16_S16; - CopyArea16_32Proc *CopyArea16_32; - CopyArea8_R32Proc *CopyArea8_R32; - CopyArea16_R32Proc *CopyArea16_R32; - CopyAreaS16_R32Proc *CopyAreaS16_R32; - CopyAreaR32_8Proc *CopyAreaR32_8; - CopyAreaR32_16Proc *CopyAreaR32_16; - CopyAreaR32_S16Proc *CopyAreaR32_S16; - RepeatArea8Proc *RepeatArea8; - RepeatArea16Proc *RepeatArea16; - RepeatArea32Proc *RepeatArea32; - ShiftRight16Proc *ShiftRight16; - BilinearRow16Proc *BilinearRow16; - BilinearRow32Proc *BilinearRow32; - BaselineABCtoRGBProc *BaselineABCtoRGB; - BaselineABCDtoRGBProc *BaselineABCDtoRGB; - BaselineHueSatMapProc *BaselineHueSatMap; - BaselineGrayToRGBProc *BaselineRGBtoGray; - BaselineRGBtoRGBProc *BaselineRGBtoRGB; - Baseline1DTableProc *Baseline1DTable; - BaselineRGBToneProc *BaselineRGBTone; - ResampleDown16Proc *ResampleDown16; - ResampleDown32Proc *ResampleDown32; - ResampleAcross16Proc *ResampleAcross16; - ResampleAcross32Proc *ResampleAcross32; - EqualBytesProc *EqualBytes; - EqualArea8Proc *EqualArea8; - EqualArea16Proc *EqualArea16; - EqualArea32Proc *EqualArea32; - VignetteMask16Proc *VignetteMask16; - Vignette16Proc *Vignette16; - Vignette32Proc *Vignette32; - MapArea16Proc *MapArea16; - }; - -/*****************************************************************************/ - -extern dng_suite gDNGSuite; - -/*****************************************************************************/ - -inline void DoZeroBytes (void *dPtr, - uint32 count) - { - - (gDNGSuite.ZeroBytes) (dPtr, - count); - - } - -inline void DoCopyBytes (const void *sPtr, - void *dPtr, - uint32 count) - { - - (gDNGSuite.CopyBytes) (sPtr, - dPtr, - count); - - } - -/*****************************************************************************/ - -inline void DoSwapBytes16 (uint16 *dPtr, - uint32 count) - { - - (gDNGSuite.SwapBytes16) (dPtr, - count); - - } - -inline void DoSwapBytes32 (uint32 *dPtr, - uint32 count) - { - - (gDNGSuite.SwapBytes32) (dPtr, - count); - - } - -/*****************************************************************************/ - -inline void DoSetArea8 (uint8 *dPtr, - uint8 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - (gDNGSuite.SetArea8) (dPtr, - value, - rows, - cols, - planes, - rowStep, - colStep, - planeStep); - - } - -inline void DoSetArea16 (uint16 *dPtr, - uint16 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - (gDNGSuite.SetArea16) (dPtr, - value, - rows, - cols, - planes, - rowStep, - colStep, - planeStep); - - } - -inline void DoSetArea32 (uint32 *dPtr, - uint32 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - (gDNGSuite.SetArea32) (dPtr, - value, - rows, - cols, - planes, - rowStep, - colStep, - planeStep); - - } - -/*****************************************************************************/ - -inline void DoCopyArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea8) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea8_16 (const uint8 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea8_16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea8_S16 (const uint8 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea8_S16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea8_32 (const uint8 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea8_32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea16_S16 (const uint16 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea16_S16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea16_32 (const uint16 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - (gDNGSuite.CopyArea16_32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline void DoCopyArea8_R32 (const uint8 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyArea8_R32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -inline void DoCopyArea16_R32 (const uint16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyArea16_R32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -inline void DoCopyAreaS16_R32 (const int16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyAreaS16_R32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -inline void DoCopyAreaR32_8 (const real32 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyAreaR32_8) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -inline void DoCopyAreaR32_16 (const real32 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyAreaR32_16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -inline void DoCopyAreaR32_S16 (const real32 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - (gDNGSuite.CopyAreaR32_S16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - pixelRange); - - } - -/*****************************************************************************/ - -inline void DoRepeatArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - (gDNGSuite.RepeatArea8) (sPtr, - dPtr, - rows, - cols, - planes, - rowStep, - colStep, - planeStep, - repeatV, - repeatH, - phaseV, - phaseH); - - } - -inline void DoRepeatArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - (gDNGSuite.RepeatArea16) (sPtr, - dPtr, - rows, - cols, - planes, - rowStep, - colStep, - planeStep, - repeatV, - repeatH, - phaseV, - phaseH); - - } - -inline void DoRepeatArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - (gDNGSuite.RepeatArea32) (sPtr, - dPtr, - rows, - cols, - planes, - rowStep, - colStep, - planeStep, - repeatV, - repeatH, - phaseV, - phaseH); - - } - -/*****************************************************************************/ - -inline void DoShiftRight16 (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 shift) - { - - (gDNGSuite.ShiftRight16) (dPtr, - rows, - cols, - planes, - rowStep, - colStep, - planeStep, - shift); - - } - -/*****************************************************************************/ - -inline void DoBilinearRow16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const uint16 * const * kernWeights, - uint32 sShift) - { - - (gDNGSuite.BilinearRow16) (sPtr, - dPtr, - cols, - patPhase, - patCount, - kernCounts, - kernOffsets, - kernWeights, - sShift); - - } - -inline void DoBilinearRow32 (const real32 *sPtr, - real32 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const real32 * const * kernWeights, - uint32 sShift) - { - - (gDNGSuite.BilinearRow32) (sPtr, - dPtr, - cols, - patPhase, - patCount, - kernCounts, - kernOffsets, - kernWeights, - sShift); - - } - -/*****************************************************************************/ - -inline void DoBaselineABCtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB) - { - - (gDNGSuite.BaselineABCtoRGB) (sPtrA, - sPtrB, - sPtrC, - dPtrR, - dPtrG, - dPtrB, - count, - cameraWhite, - cameraToRGB); - - } - -inline void DoBaselineABCDtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - const real32 *sPtrD, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB) - { - - (gDNGSuite.BaselineABCDtoRGB) (sPtrA, - sPtrB, - sPtrC, - sPtrD, - dPtrR, - dPtrG, - dPtrB, - count, - cameraWhite, - cameraToRGB); - - } - -/*****************************************************************************/ - -inline void DoBaselineHueSatMap (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_hue_sat_map &lut, - const dng_1d_table *encodeTable, - const dng_1d_table *decodeTable) - { - - (gDNGSuite.BaselineHueSatMap) (sPtrR, - sPtrG, - sPtrB, - dPtrR, - dPtrG, - dPtrB, - count, - lut, - encodeTable, - decodeTable); - - } - -/*****************************************************************************/ - -inline void DoBaselineRGBtoGray (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrG, - uint32 count, - const dng_matrix &matrix) - { - - (gDNGSuite.BaselineRGBtoGray) (sPtrR, - sPtrG, - sPtrB, - dPtrG, - count, - matrix); - - } - -inline void DoBaselineRGBtoRGB (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_matrix &matrix) - { - - (gDNGSuite.BaselineRGBtoRGB) (sPtrR, - sPtrG, - sPtrB, - dPtrR, - dPtrG, - dPtrB, - count, - matrix); - - } - -/*****************************************************************************/ - -inline void DoBaseline1DTable (const real32 *sPtr, - real32 *dPtr, - uint32 count, - const dng_1d_table &table) - { - - (gDNGSuite.Baseline1DTable) (sPtr, - dPtr, - count, - table); - - } - -/*****************************************************************************/ - -inline void DoBaselineRGBTone (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_1d_table &table) - { - - (gDNGSuite.BaselineRGBTone) (sPtrR, - sPtrG, - sPtrB, - dPtrR, - dPtrG, - dPtrB, - count, - table); - - } - -/*****************************************************************************/ - -inline void DoResampleDown16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 sCount, - int32 sRowStep, - const int16 *wPtr, - uint32 wCount, - uint32 pixelRange) - { - - (gDNGSuite.ResampleDown16) (sPtr, - dPtr, - sCount, - sRowStep, - wPtr, - wCount, - pixelRange); - - } - -inline void DoResampleDown32 (const real32 *sPtr, - real32 *dPtr, - uint32 sCount, - int32 sRowStep, - const real32 *wPtr, - uint32 wCount) - { - - (gDNGSuite.ResampleDown32) (sPtr, - dPtr, - sCount, - sRowStep, - wPtr, - wCount); - - } - -/*****************************************************************************/ - -inline void DoResampleAcross16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 dCount, - const int32 *coord, - const int16 *wPtr, - uint32 wCount, - uint32 wStep, - uint32 pixelRange) - { - - (gDNGSuite.ResampleAcross16) (sPtr, - dPtr, - dCount, - coord, - wPtr, - wCount, - wStep, - pixelRange); - - } - -inline void DoResampleAcross32 (const real32 *sPtr, - real32 *dPtr, - uint32 dCount, - const int32 *coord, - const real32 *wPtr, - uint32 wCount, - uint32 wStep) - { - - (gDNGSuite.ResampleAcross32) (sPtr, - dPtr, - dCount, - coord, - wPtr, - wCount, - wStep); - - } - -/*****************************************************************************/ - -inline bool DoEqualBytes (const void *sPtr, - const void *dPtr, - uint32 count) - { - - return (gDNGSuite.EqualBytes) (sPtr, - dPtr, - count); - - } - -inline bool DoEqualArea8 (const uint8 *sPtr, - const uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - return (gDNGSuite.EqualArea8) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline bool DoEqualArea16 (const uint16 *sPtr, - const uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - return (gDNGSuite.EqualArea16) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -inline bool DoEqualArea32 (const uint32 *sPtr, - const uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - return (gDNGSuite.EqualArea32) (sPtr, - dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - } - -/*****************************************************************************/ - -inline void DoVignetteMask16 (uint16 *mPtr, - uint32 rows, - uint32 cols, - int32 rowStep, - int64 offsetH, - int64 offsetV, - int64 stepH, - int64 stepV, - uint32 tBits, - const uint16 *table) - { - - (gDNGSuite.VignetteMask16) (mPtr, - rows, - cols, - rowStep, - offsetH, - offsetV, - stepH, - stepV, - tBits, - table); - - } - -/*****************************************************************************/ - -inline void DoVignette16 (int16 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits) - { - - (gDNGSuite.Vignette16) (sPtr, - mPtr, - rows, - cols, - planes, - sRowStep, - sPlaneStep, - mRowStep, - mBits); - - } - -/*****************************************************************************/ - -inline void DoVignette32 (real32 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits) - { - - (gDNGSuite.Vignette32) (sPtr, - mPtr, - rows, - cols, - planes, - sRowStep, - sPlaneStep, - mRowStep, - mBits); - - } - -/*****************************************************************************/ - -inline void DoMapArea16 (uint16 *dPtr, - uint32 count0, - uint32 count1, - uint32 count2, - int32 step0, - int32 step1, - int32 step2, - const uint16 *map) - { - - (gDNGSuite.MapArea16) (dPtr, - count0, - count1, - count2, - step0, - step1, - step2, - map); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_camera_profile.cpp b/third_party/dng_sdk/dng_camera_profile.cpp deleted file mode 100644 index 6983b6d..0000000 --- a/third_party/dng_sdk/dng_camera_profile.cpp +++ /dev/null @@ -1,1381 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_camera_profile.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -#include "dng_camera_profile.h" - -#include "dng_1d_table.h" -#include "dng_assertions.h" -#include "dng_color_space.h" -#include "dng_host.h" -#include "dng_exceptions.h" -#include "dng_image_writer.h" -#include "dng_info.h" -#include "dng_parse_utils.h" -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_temperature.h" -#include "dng_xy_coord.h" - -/*****************************************************************************/ - -const char * kProfileName_Embedded = "Embedded"; - -const char * kAdobeCalibrationSignature = "com.adobe"; - -/*****************************************************************************/ - -dng_camera_profile::dng_camera_profile () - - : fName () - , fCalibrationIlluminant1 (lsUnknown) - , fCalibrationIlluminant2 (lsUnknown) - , fColorMatrix1 () - , fColorMatrix2 () - , fForwardMatrix1 () - , fForwardMatrix2 () - , fReductionMatrix1 () - , fReductionMatrix2 () - , fFingerprint () - , fCopyright () - , fEmbedPolicy (pepAllowCopying) - , fHueSatDeltas1 () - , fHueSatDeltas2 () - , fHueSatMapEncoding (encoding_Linear) - , fLookTable () - , fLookTableEncoding (encoding_Linear) - , fBaselineExposureOffset (0, 100) - , fDefaultBlackRender (defaultBlackRender_Auto) - , fToneCurve () - , fProfileCalibrationSignature () - , fUniqueCameraModelRestriction () - , fWasReadFromDNG (false) - , fWasReadFromDisk (false) - , fWasBuiltinMatrix (false) - , fWasStubbed (false) - - { - - fToneCurve.SetInvalid (); - - } - -/*****************************************************************************/ - -dng_camera_profile::~dng_camera_profile () - { - - } - -/*****************************************************************************/ - -real64 dng_camera_profile::IlluminantToTemperature (uint32 light) - { - - switch (light) - { - - case lsStandardLightA: - case lsTungsten: - { - return 2850.0; - } - - case lsISOStudioTungsten: - { - return 3200.0; - } - - case lsD50: - { - return 5000.0; - } - - case lsD55: - case lsDaylight: - case lsFineWeather: - case lsFlash: - case lsStandardLightB: - { - return 5500.0; - } - - case lsD65: - case lsStandardLightC: - case lsCloudyWeather: - { - return 6500.0; - } - - case lsD75: - case lsShade: - { - return 7500.0; - } - - case lsDaylightFluorescent: - { - return (5700.0 + 7100.0) * 0.5; - } - - case lsDayWhiteFluorescent: - { - return (4600.0 + 5500.0) * 0.5; - } - - case lsCoolWhiteFluorescent: - case lsFluorescent: - { - return (3800.0 + 4500.0) * 0.5; - } - - case lsWhiteFluorescent: - { - return (3250.0 + 3800.0) * 0.5; - } - - case lsWarmWhiteFluorescent: - { - return (2600.0 + 3250.0) * 0.5; - } - - default: - { - return 0.0; - } - - } - - } - -/******************************************************************************/ - -void dng_camera_profile::NormalizeColorMatrix (dng_matrix &m) - { - - if (m.NotEmpty ()) - { - - // Find scale factor to normalize the matrix. - - dng_vector coord = m * PCStoXYZ (); - - real64 maxCoord = coord.MaxEntry (); - - if (maxCoord > 0.0 && (maxCoord < 0.99 || maxCoord > 1.01)) - { - - m.Scale (1.0 / maxCoord); - - } - - // Round to four decimal places. - - m.Round (10000); - - } - - } - -/******************************************************************************/ - -void dng_camera_profile::SetColorMatrix1 (const dng_matrix &m) - { - - fColorMatrix1 = m; - - NormalizeColorMatrix (fColorMatrix1); - - ClearFingerprint (); - - } - -/******************************************************************************/ - -void dng_camera_profile::SetColorMatrix2 (const dng_matrix &m) - { - - fColorMatrix2 = m; - - NormalizeColorMatrix (fColorMatrix2); - - ClearFingerprint (); - - } - -/******************************************************************************/ - -// Make sure the forward matrix maps to exactly the PCS. - -void dng_camera_profile::NormalizeForwardMatrix (dng_matrix &m) - { - - if (m.NotEmpty ()) - { - - dng_vector cameraOne; - - cameraOne.SetIdentity (m.Cols ()); - - dng_vector xyz = m * cameraOne; - - m = PCStoXYZ ().AsDiagonal () * - Invert (xyz.AsDiagonal ()) * - m; - - } - - } - -/******************************************************************************/ - -void dng_camera_profile::SetForwardMatrix1 (const dng_matrix &m) - { - - fForwardMatrix1 = m; - - fForwardMatrix1.Round (10000); - - ClearFingerprint (); - - } - -/******************************************************************************/ - -void dng_camera_profile::SetForwardMatrix2 (const dng_matrix &m) - { - - fForwardMatrix2 = m; - - fForwardMatrix2.Round (10000); - - ClearFingerprint (); - - } - -/*****************************************************************************/ - -void dng_camera_profile::SetReductionMatrix1 (const dng_matrix &m) - { - - fReductionMatrix1 = m; - - fReductionMatrix1.Round (10000); - - ClearFingerprint (); - - } - -/******************************************************************************/ - -void dng_camera_profile::SetReductionMatrix2 (const dng_matrix &m) - { - - fReductionMatrix2 = m; - - fReductionMatrix2.Round (10000); - - ClearFingerprint (); - - } - -/*****************************************************************************/ - -bool dng_camera_profile::HasColorMatrix1 () const - { - - return fColorMatrix1.Cols () == 3 && - fColorMatrix1.Rows () > 1; - - } - -/*****************************************************************************/ - -bool dng_camera_profile::HasColorMatrix2 () const - { - - return fColorMatrix2.Cols () == 3 && - fColorMatrix2.Rows () == fColorMatrix1.Rows (); - - } - -/*****************************************************************************/ - -void dng_camera_profile::SetHueSatDeltas1 (const dng_hue_sat_map &deltas1) - { - - fHueSatDeltas1 = deltas1; - - ClearFingerprint (); - - } - -/*****************************************************************************/ - -void dng_camera_profile::SetHueSatDeltas2 (const dng_hue_sat_map &deltas2) - { - - fHueSatDeltas2 = deltas2; - - ClearFingerprint (); - - } - -/*****************************************************************************/ - -void dng_camera_profile::SetLookTable (const dng_hue_sat_map &table) - { - - fLookTable = table; - - ClearFingerprint (); - - } - -/*****************************************************************************/ - -static void FingerprintMatrix (dng_md5_printer_stream &printer, - const dng_matrix &matrix) - { - - tag_matrix tag (0, matrix); - - // Tag's Put routine doesn't write the header, only the data - - tag.Put (printer); - - } - -/*****************************************************************************/ - -static void FingerprintHueSatMap (dng_md5_printer_stream &printer, - const dng_hue_sat_map &map) - { - - if (map.IsNull ()) - return; - - uint32 hues; - uint32 sats; - uint32 vals; - - map.GetDivisions (hues, sats, vals); - - printer.Put_uint32 (hues); - printer.Put_uint32 (sats); - printer.Put_uint32 (vals); - - for (uint32 val = 0; val < vals; val++) - for (uint32 hue = 0; hue < hues; hue++) - for (uint32 sat = 0; sat < sats; sat++) - { - - dng_hue_sat_map::HSBModify modify; - - map.GetDelta (hue, sat, val, modify); - - printer.Put_real32 (modify.fHueShift); - printer.Put_real32 (modify.fSatScale); - printer.Put_real32 (modify.fValScale); - - } - - } - -/*****************************************************************************/ - -void dng_camera_profile::CalculateFingerprint () const - { - - DNG_ASSERT (!fWasStubbed, "CalculateFingerprint on stubbed profile"); - - dng_md5_printer_stream printer; - - // MD5 hash is always calculated on little endian data. - - printer.SetLittleEndian (); - - // The data that we fingerprint closely matches that saved - // by the profile_tag_set class in dng_image_writer.cpp, with - // the exception of the fingerprint itself. - - if (HasColorMatrix1 ()) - { - - uint32 colorChannels = ColorMatrix1 ().Rows (); - - printer.Put_uint16 ((uint16) fCalibrationIlluminant1); - - FingerprintMatrix (printer, fColorMatrix1); - - if (fForwardMatrix1.Rows () == fColorMatrix1.Cols () && - fForwardMatrix1.Cols () == fColorMatrix1.Rows ()) - { - - FingerprintMatrix (printer, fForwardMatrix1); - - } - - if (colorChannels > 3 && fReductionMatrix1.Rows () * - fReductionMatrix1.Cols () == colorChannels * 3) - { - - FingerprintMatrix (printer, fReductionMatrix1); - - } - - if (HasColorMatrix2 ()) - { - - printer.Put_uint16 ((uint16) fCalibrationIlluminant2); - - FingerprintMatrix (printer, fColorMatrix2); - - if (fForwardMatrix2.Rows () == fColorMatrix2.Cols () && - fForwardMatrix2.Cols () == fColorMatrix2.Rows ()) - { - - FingerprintMatrix (printer, fForwardMatrix2); - - } - - if (colorChannels > 3 && fReductionMatrix2.Rows () * - fReductionMatrix2.Cols () == colorChannels * 3) - { - - FingerprintMatrix (printer, fReductionMatrix2); - - } - - } - - printer.Put (fName.Get (), - fName.Length ()); - - printer.Put (fProfileCalibrationSignature.Get (), - fProfileCalibrationSignature.Length ()); - - printer.Put_uint32 (fEmbedPolicy); - - printer.Put (fCopyright.Get (), - fCopyright.Length ()); - - bool haveHueSat1 = HueSatDeltas1 ().IsValid (); - - bool haveHueSat2 = HueSatDeltas2 ().IsValid () && - HasColorMatrix2 (); - - if (haveHueSat1) - { - - FingerprintHueSatMap (printer, fHueSatDeltas1); - - } - - if (haveHueSat2) - { - - FingerprintHueSatMap (printer, fHueSatDeltas2); - - } - - if (haveHueSat1 || haveHueSat2) - { - - if (fHueSatMapEncoding != 0) - { - - printer.Put_uint32 (fHueSatMapEncoding); - - } - - } - - if (fLookTable.IsValid ()) - { - - FingerprintHueSatMap (printer, fLookTable); - - if (fLookTableEncoding != 0) - { - - printer.Put_uint32 (fLookTableEncoding); - - } - - } - - if (fBaselineExposureOffset.IsValid ()) - { - - if (fBaselineExposureOffset.As_real64 () != 0.0) - { - - printer.Put_real64 (fBaselineExposureOffset.As_real64 ()); - - } - - } - - if (fDefaultBlackRender != 0) - { - - printer.Put_int32 (fDefaultBlackRender); - - } - - if (fToneCurve.IsValid ()) - { - - for (uint32 i = 0; i < fToneCurve.fCoord.size (); i++) - { - - printer.Put_real32 ((real32) fToneCurve.fCoord [i].h); - printer.Put_real32 ((real32) fToneCurve.fCoord [i].v); - - } - - } - - } - - fFingerprint = printer.Result (); - - } - -/******************************************************************************/ - -bool dng_camera_profile::ValidForwardMatrix (const dng_matrix &m) - { - - const real64 kThreshold = 0.01; - - if (m.NotEmpty ()) - { - - dng_vector cameraOne; - - cameraOne.SetIdentity (m.Cols ()); - - dng_vector xyz = m * cameraOne; - - dng_vector pcs = PCStoXYZ (); - - if (Abs_real64 (xyz [0] - pcs [0]) > kThreshold || - Abs_real64 (xyz [1] - pcs [1]) > kThreshold || - Abs_real64 (xyz [2] - pcs [2]) > kThreshold) - { - - return false; - - } - - } - - return true; - - } - -/******************************************************************************/ - -bool dng_camera_profile::IsValid (uint32 channels) const - { - - // For Monochrome images, we ignore the camera profile. - - if (channels == 1) - { - - return true; - - } - - // ColorMatrix1 is required for all color images. - - if (fColorMatrix1.Cols () != 3 || - fColorMatrix1.Rows () != channels) - { - - #if qDNGValidate - - ReportError ("ColorMatrix1 is wrong size"); - - #endif - - return false; - - } - - // ColorMatrix2 is optional, but it must be valid if present. - - if (fColorMatrix2.Cols () != 0 || - fColorMatrix2.Rows () != 0) - { - - if (fColorMatrix2.Cols () != 3 || - fColorMatrix2.Rows () != channels) - { - - #if qDNGValidate - - ReportError ("ColorMatrix2 is wrong size"); - - #endif - - return false; - - } - - } - - // ForwardMatrix1 is optional, but it must be valid if present. - - if (fForwardMatrix1.Cols () != 0 || - fForwardMatrix1.Rows () != 0) - { - - if (fForwardMatrix1.Rows () != 3 || - fForwardMatrix1.Cols () != channels) - { - - #if qDNGValidate - - ReportError ("ForwardMatrix1 is wrong size"); - - #endif - - return false; - - } - - // Make sure ForwardMatrix1 does a valid mapping. - - if (!ValidForwardMatrix (fForwardMatrix1)) - { - - #if qDNGValidate - - ReportError ("ForwardMatrix1 does not map equal camera values to XYZ D50"); - - #endif - - return false; - - } - - } - - // ForwardMatrix2 is optional, but it must be valid if present. - - if (fForwardMatrix2.Cols () != 0 || - fForwardMatrix2.Rows () != 0) - { - - if (fForwardMatrix2.Rows () != 3 || - fForwardMatrix2.Cols () != channels) - { - - #if qDNGValidate - - ReportError ("ForwardMatrix2 is wrong size"); - - #endif - - return false; - - } - - // Make sure ForwardMatrix2 does a valid mapping. - - if (!ValidForwardMatrix (fForwardMatrix2)) - { - - #if qDNGValidate - - ReportError ("ForwardMatrix2 does not map equal camera values to XYZ D50"); - - #endif - - return false; - - } - - } - - // ReductionMatrix1 is optional, but it must be valid if present. - - if (fReductionMatrix1.Cols () != 0 || - fReductionMatrix1.Rows () != 0) - { - - if (fReductionMatrix1.Cols () != channels || - fReductionMatrix1.Rows () != 3) - { - - #if qDNGValidate - - ReportError ("ReductionMatrix1 is wrong size"); - - #endif - - return false; - - } - - } - - // ReductionMatrix2 is optional, but it must be valid if present. - - if (fReductionMatrix2.Cols () != 0 || - fReductionMatrix2.Rows () != 0) - { - - if (fReductionMatrix2.Cols () != channels || - fReductionMatrix2.Rows () != 3) - { - - #if qDNGValidate - - ReportError ("ReductionMatrix2 is wrong size"); - - #endif - - return false; - - } - - } - - // Make sure ColorMatrix1 is invertable. - - try - { - - if (fReductionMatrix1.NotEmpty ()) - { - - (void) Invert (fColorMatrix1, - fReductionMatrix1); - - } - - else - { - - (void) Invert (fColorMatrix1); - - } - - } - - catch (...) - { - - #if qDNGValidate - - ReportError ("ColorMatrix1 is not invertable"); - - #endif - - return false; - - } - - // Make sure ColorMatrix2 is invertable. - - if (fColorMatrix2.NotEmpty ()) - { - - try - { - - if (fReductionMatrix2.NotEmpty ()) - { - - (void) Invert (fColorMatrix2, - fReductionMatrix2); - - } - - else - { - - (void) Invert (fColorMatrix2); - - } - - } - - catch (...) - { - - #if qDNGValidate - - ReportError ("ColorMatrix2 is not invertable"); - - #endif - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_camera_profile::EqualData (const dng_camera_profile &profile) const - { - - return fCalibrationIlluminant1 == profile.fCalibrationIlluminant1 && - fCalibrationIlluminant2 == profile.fCalibrationIlluminant2 && - fColorMatrix1 == profile.fColorMatrix1 && - fColorMatrix2 == profile.fColorMatrix2 && - fForwardMatrix1 == profile.fForwardMatrix1 && - fForwardMatrix2 == profile.fForwardMatrix2 && - fReductionMatrix1 == profile.fReductionMatrix1 && - fReductionMatrix2 == profile.fReductionMatrix2 && - fHueSatDeltas1 == profile.fHueSatDeltas1 && - fHueSatDeltas2 == profile.fHueSatDeltas2 && - fHueSatMapEncoding == profile.fHueSatMapEncoding && - fLookTable == profile.fLookTable && - fLookTableEncoding == profile.fLookTableEncoding && - fDefaultBlackRender == profile.fDefaultBlackRender && - fToneCurve == profile.fToneCurve && - fBaselineExposureOffset.As_real64 () == profile.fBaselineExposureOffset.As_real64 () && - fProfileCalibrationSignature == profile.fProfileCalibrationSignature; - - } - -/*****************************************************************************/ - -void dng_camera_profile::ReadHueSatMap (dng_stream &stream, - dng_hue_sat_map &hueSatMap, - uint32 hues, - uint32 sats, - uint32 vals, - bool skipSat0) - { - - hueSatMap.SetDivisions (hues, sats, vals); - - for (uint32 val = 0; val < vals; val++) - { - - for (uint32 hue = 0; hue < hues; hue++) - { - - for (uint32 sat = skipSat0 ? 1 : 0; sat < sats; sat++) - { - - dng_hue_sat_map::HSBModify modify; - - modify.fHueShift = stream.Get_real32 (); - modify.fSatScale = stream.Get_real32 (); - modify.fValScale = stream.Get_real32 (); - - hueSatMap.SetDelta (hue, sat, val, modify); - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_camera_profile::Parse (dng_stream &stream, - dng_camera_profile_info &profileInfo) - { - - SetUniqueCameraModelRestriction (profileInfo.fUniqueCameraModel.Get ()); - - if (profileInfo.fProfileName.NotEmpty ()) - { - - SetName (profileInfo.fProfileName.Get ()); - - } - - SetCopyright (profileInfo.fProfileCopyright.Get ()); - - SetEmbedPolicy (profileInfo.fEmbedPolicy); - - SetCalibrationIlluminant1 (profileInfo.fCalibrationIlluminant1); - - SetColorMatrix1 (profileInfo.fColorMatrix1); - - if (profileInfo.fForwardMatrix1.NotEmpty ()) - { - - SetForwardMatrix1 (profileInfo.fForwardMatrix1); - - } - - if (profileInfo.fReductionMatrix1.NotEmpty ()) - { - - SetReductionMatrix1 (profileInfo.fReductionMatrix1); - - } - - if (profileInfo.fColorMatrix2.NotEmpty ()) - { - - SetCalibrationIlluminant2 (profileInfo.fCalibrationIlluminant2); - - SetColorMatrix2 (profileInfo.fColorMatrix2); - - if (profileInfo.fForwardMatrix2.NotEmpty ()) - { - - SetForwardMatrix2 (profileInfo.fForwardMatrix2); - - } - - if (profileInfo.fReductionMatrix2.NotEmpty ()) - { - - SetReductionMatrix2 (profileInfo.fReductionMatrix2); - - } - - } - - SetProfileCalibrationSignature (profileInfo.fProfileCalibrationSignature.Get ()); - - if (profileInfo.fHueSatDeltas1Offset != 0 && - profileInfo.fHueSatDeltas1Count != 0) - { - - TempBigEndian setEndianness (stream, profileInfo.fBigEndian); - - stream.SetReadPosition (profileInfo.fHueSatDeltas1Offset); - - bool skipSat0 = (profileInfo.fHueSatDeltas1Count == profileInfo.fProfileHues * - (profileInfo.fProfileSats - 1) * - profileInfo.fProfileVals * 3); - - ReadHueSatMap (stream, - fHueSatDeltas1, - profileInfo.fProfileHues, - profileInfo.fProfileSats, - profileInfo.fProfileVals, - skipSat0); - - } - - if (profileInfo.fHueSatDeltas2Offset != 0 && - profileInfo.fHueSatDeltas2Count != 0) - { - - TempBigEndian setEndianness (stream, profileInfo.fBigEndian); - - stream.SetReadPosition (profileInfo.fHueSatDeltas2Offset); - - bool skipSat0 = (profileInfo.fHueSatDeltas2Count == profileInfo.fProfileHues * - (profileInfo.fProfileSats - 1) * - profileInfo.fProfileVals * 3); - - ReadHueSatMap (stream, - fHueSatDeltas2, - profileInfo.fProfileHues, - profileInfo.fProfileSats, - profileInfo.fProfileVals, - skipSat0); - - } - - if (profileInfo.fLookTableOffset != 0 && - profileInfo.fLookTableCount != 0) - { - - TempBigEndian setEndianness (stream, profileInfo.fBigEndian); - - stream.SetReadPosition (profileInfo.fLookTableOffset); - - bool skipSat0 = (profileInfo.fLookTableCount == profileInfo.fLookTableHues * - (profileInfo.fLookTableSats - 1) * - profileInfo.fLookTableVals * 3); - - ReadHueSatMap (stream, - fLookTable, - profileInfo.fLookTableHues, - profileInfo.fLookTableSats, - profileInfo.fLookTableVals, - skipSat0); - - } - - if ((profileInfo.fToneCurveCount & 1) == 0) - { - - TempBigEndian setEndianness (stream, profileInfo.fBigEndian); - - stream.SetReadPosition (profileInfo.fToneCurveOffset); - - uint32 points = profileInfo.fToneCurveCount / 2; - - fToneCurve.fCoord.resize (points); - - for (size_t i = 0; i < points; i++) - { - - dng_point_real64 point; - - point.h = stream.Get_real32 (); - point.v = stream.Get_real32 (); - - fToneCurve.fCoord [i] = point; - - } - - } - - SetHueSatMapEncoding (profileInfo.fHueSatMapEncoding); - - SetLookTableEncoding (profileInfo.fLookTableEncoding); - - SetBaselineExposureOffset (profileInfo.fBaselineExposureOffset.As_real64 ()); - - SetDefaultBlackRender (profileInfo.fDefaultBlackRender); - - } - -/*****************************************************************************/ - -bool dng_camera_profile::ParseExtended (dng_stream &stream) - { - - try - { - - dng_camera_profile_info profileInfo; - - if (!profileInfo.ParseExtended (stream)) - { - return false; - } - - Parse (stream, profileInfo); - - return true; - - } - - catch (...) - { - - // Eat parsing errors. - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_camera_profile::SetFourColorBayer () - { - - uint32 j; - - if (!IsValid (3)) - { - ThrowProgramError (); - } - - if (fColorMatrix1.NotEmpty ()) - { - - dng_matrix m (4, 3); - - for (j = 0; j < 3; j++) - { - m [0] [j] = fColorMatrix1 [0] [j]; - m [1] [j] = fColorMatrix1 [1] [j]; - m [2] [j] = fColorMatrix1 [2] [j]; - m [3] [j] = fColorMatrix1 [1] [j]; - } - - fColorMatrix1 = m; - - } - - if (fColorMatrix2.NotEmpty ()) - { - - dng_matrix m (4, 3); - - for (j = 0; j < 3; j++) - { - m [0] [j] = fColorMatrix2 [0] [j]; - m [1] [j] = fColorMatrix2 [1] [j]; - m [2] [j] = fColorMatrix2 [2] [j]; - m [3] [j] = fColorMatrix2 [1] [j]; - } - - fColorMatrix2 = m; - - } - - fReductionMatrix1.Clear (); - fReductionMatrix2.Clear (); - - fForwardMatrix1.Clear (); - fForwardMatrix2.Clear (); - - } - -/*****************************************************************************/ - -dng_hue_sat_map * dng_camera_profile::HueSatMapForWhite (const dng_xy_coord &white) const - { - - if (fHueSatDeltas1.IsValid ()) - { - - // If we only have the first table, just use it for any color temperature. - - if (!fHueSatDeltas2.IsValid ()) - { - - return new dng_hue_sat_map (fHueSatDeltas1); - - } - - // Else we need to interpolate based on color temperature. - - real64 temperature1 = CalibrationTemperature1 (); - real64 temperature2 = CalibrationTemperature2 (); - - if (temperature1 <= 0.0 || - temperature2 <= 0.0 || - temperature1 == temperature2) - { - - return new dng_hue_sat_map (fHueSatDeltas1); - - } - - bool reverseOrder = temperature1 > temperature2; - - if (reverseOrder) - { - real64 temp = temperature1; - temperature1 = temperature2; - temperature2 = temp; - } - - // Convert to temperature/offset space. - - dng_temperature td (white); - - // Find fraction to weight the first calibration. - - real64 g; - - if (td.Temperature () <= temperature1) - g = 1.0; - - else if (td.Temperature () >= temperature2) - g = 0.0; - - else - { - - real64 invT = 1.0 / td.Temperature (); - - g = (invT - (1.0 / temperature2)) / - ((1.0 / temperature1) - (1.0 / temperature2)); - - } - - // Fix up if we swapped the order. - - if (reverseOrder) - { - g = 1.0 - g; - } - - // Do the interpolation. - - return dng_hue_sat_map::Interpolate (HueSatDeltas1 (), - HueSatDeltas2 (), - g); - - } - - return NULL; - - } - -/*****************************************************************************/ - -void dng_camera_profile::Stub () - { - - (void) Fingerprint (); - - dng_hue_sat_map nullTable; - - fHueSatDeltas1 = nullTable; - fHueSatDeltas2 = nullTable; - - fLookTable = nullTable; - - fToneCurve.SetInvalid (); - - fWasStubbed = true; - - } - -/*****************************************************************************/ - -void SplitCameraProfileName (const dng_string &name, - dng_string &baseName, - int32 &version) - { - - baseName = name; - - version = 0; - - uint32 len = baseName.Length (); - - if (len > 5 && baseName.EndsWith (" beta")) - { - - baseName.Truncate (len - 5); - - version += -10; - - } - - else if (len > 7) - { - - char lastChar = name.Get () [len - 1]; - - if (lastChar >= '0' && lastChar <= '9') - { - - dng_string temp = name; - - temp.Truncate (len - 1); - - if (temp.EndsWith (" beta ")) - { - - baseName.Truncate (len - 7); - - version += ((int32) (lastChar - '0')) - 10; - - } - - } - - } - - len = baseName.Length (); - - if (len > 3) - { - - char lastChar = name.Get () [len - 1]; - - if (lastChar >= '0' && lastChar <= '9') - { - - dng_string temp = name; - - temp.Truncate (len - 1); - - if (temp.EndsWith (" v")) - { - - baseName.Truncate (len - 3); - - version += ((int32) (lastChar - '0')) * 100; - - } - - } - - } - - } - -/*****************************************************************************/ - -void BuildHueSatMapEncodingTable (dng_memory_allocator &allocator, - uint32 encoding, - AutoPtr &encodeTable, - AutoPtr &decodeTable, - bool subSample) - { - - encodeTable.Reset (); - decodeTable.Reset (); - - switch (encoding) - { - - case encoding_Linear: - { - - break; - - } - - case encoding_sRGB: - { - - encodeTable.Reset (new dng_1d_table); - decodeTable.Reset (new dng_1d_table); - - const dng_1d_function & curve = dng_function_GammaEncode_sRGB::Get (); - - encodeTable->Initialize (allocator, - curve, - subSample); - - const dng_1d_inverse inverse (curve); - - decodeTable->Initialize (allocator, - inverse, - subSample); - - break; - - } - - default: - { - - DNG_REPORT ("Unsupported hue sat map / look table encoding."); - - break; - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_camera_profile.h b/third_party/dng_sdk/dng_camera_profile.h deleted file mode 100644 index df14a8a..0000000 --- a/third_party/dng_sdk/dng_camera_profile.h +++ /dev/null @@ -1,878 +0,0 @@ -/******************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/******************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_camera_profile.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for DNG camera color profile information. - * Per the \ref spec_dng "DNG 1.1.0 specification", a DNG file can store up to - * two sets of color profile information for a camera in the DNG file from that - * camera. The second set is optional and when there are two sets, they represent - * profiles made under different illumination. - * - * Profiling information is optionally separated into two parts. One part represents - * a profile for a reference camera. (ColorMatrix1 and ColorMatrix2 here.) The - * second is a per-camera calibration that takes into account unit-to-unit variation. - * This is designed to allow replacing the reference color matrix with one of one's - * own construction while maintaining any unit-specific calibration the camera - * manufacturer may have provided. - * - * See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification" for more information. - */ - -#ifndef __dng_camera_profile__ -#define __dng_camera_profile__ - -/******************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_assertions.h" -#include "dng_classes.h" -#include "dng_fingerprint.h" -#include "dng_hue_sat_map.h" -#include "dng_matrix.h" -#include "dng_string.h" -#include "dng_tag_values.h" -#include "dng_tone_curve.h" - -/******************************************************************************/ - -extern const char * kProfileName_Embedded; - -extern const char * kAdobeCalibrationSignature; - -/******************************************************************************/ - -/// \brief An ID for a camera profile consisting of a name and optional fingerprint. - -class dng_camera_profile_id - { - - private: - - dng_string fName; - - dng_fingerprint fFingerprint; - - public: - - /// Construct an invalid camera profile ID (empty name and fingerprint). - - dng_camera_profile_id () - - : fName () - , fFingerprint () - - { - } - - /// Construct a camera profile ID with the specified name and no fingerprint. - /// \param name The name of the camera profile ID. - - dng_camera_profile_id (const char *name) - - : fName () - , fFingerprint () - - { - fName.Set (name); - } - - /// Construct a camera profile ID with the specified name and no fingerprint. - /// \param name The name of the camera profile ID. - - dng_camera_profile_id (const dng_string &name) - - : fName (name) - , fFingerprint () - - { - } - - /// Construct a camera profile ID with the specified name and fingerprint. - /// \param name The name of the camera profile ID. - /// \param fingerprint The fingerprint of the camera profile ID. - - dng_camera_profile_id (const char *name, - const dng_fingerprint &fingerprint) - - : fName () - , fFingerprint (fingerprint) - - { - fName.Set (name); - DNG_ASSERT (!fFingerprint.IsValid () || fName.NotEmpty (), - "Cannot have profile fingerprint without name"); - } - - /// Construct a camera profile ID with the specified name and fingerprint. - /// \param name The name of the camera profile ID. - /// \param fingerprint The fingerprint of the camera profile ID. - - dng_camera_profile_id (const dng_string &name, - const dng_fingerprint &fingerprint) - - : fName (name) - , fFingerprint (fingerprint) - - { - DNG_ASSERT (!fFingerprint.IsValid () || fName.NotEmpty (), - "Cannot have profile fingerprint without name"); - } - - /// Getter for the name of the camera profile ID. - /// \retval The name of the camera profile ID. - - const dng_string & Name () const - { - return fName; - } - - /// Getter for the fingerprint of the camera profile ID. - /// \retval The fingerprint of the camera profile ID. - - const dng_fingerprint & Fingerprint () const - { - return fFingerprint; - } - - /// Test for equality of two camera profile IDs. - /// \param The id of the camera profile ID to compare. - - bool operator== (const dng_camera_profile_id &id) const - { - return fName == id.fName && - fFingerprint == id.fFingerprint; - } - - /// Test for inequality of two camera profile IDs. - /// \param The id of the camera profile ID to compare. - - bool operator!= (const dng_camera_profile_id &id) const - { - return !(*this == id); - } - - /// Returns true iff the camera profile ID is valid. - - bool IsValid () const - { - return fName.NotEmpty (); // Fingerprint is optional. - } - - /// Resets the name and fingerprint, thereby making this camera profile ID - /// invalid. - - void Clear () - { - *this = dng_camera_profile_id (); - } - - }; - -/******************************************************************************/ - -/// \brief Container for DNG camera color profile and calibration data. - -class dng_camera_profile - { - - protected: - - // Name of this camera profile. - - dng_string fName; - - // Light sources for up to two calibrations. These use the EXIF - // encodings for illuminant and are used to distinguish which - // matrix to use. - - uint32 fCalibrationIlluminant1; - uint32 fCalibrationIlluminant2; - - // Color matrices for up to two calibrations. - - // These matrices map XYZ values to non-white balanced camera values. - // Adobe needs to go that direction in order to determine the clipping - // points for highlight recovery logic based on the white point. If - // cameras were all 3-color, the matrix could be stored as a forward matrix, - // but we need the backwards matrix to deal with 4-color cameras. - - dng_matrix fColorMatrix1; - dng_matrix fColorMatrix2; - - // These matrices map white balanced camera values to XYZ chromatically - // adapted to D50 (the ICC profile PCS white point). If the matrices - // exist, then this implies that white balancing should be done by scaling - // camera values with a diagonal matrix. - - dng_matrix fForwardMatrix1; - dng_matrix fForwardMatrix2; - - // Dimensionality reduction hints for more than three color cameras. - // This is an optional matrix that maps the camera's color components - // to 3 components. These are only used if the forward matrices don't - // exist, and are used invert the color matrices. - - dng_matrix fReductionMatrix1; - dng_matrix fReductionMatrix2; - - // MD5 hash for all data bits of the profile. - - mutable dng_fingerprint fFingerprint; - - // Copyright notice from creator of profile. - - dng_string fCopyright; - - // Rules for how this profile can be embedded and/or copied. - - uint32 fEmbedPolicy; - - // 2-D (or 3-D) hue/sat tables to modify colors. - - dng_hue_sat_map fHueSatDeltas1; - dng_hue_sat_map fHueSatDeltas2; - - // Value (V of HSV) encoding for hue/sat tables. - - uint32 fHueSatMapEncoding; - - // 3-D hue/sat table to apply a "look". - - dng_hue_sat_map fLookTable; - - // Value (V of HSV) encoding for look table. - - uint32 fLookTableEncoding; - - // Baseline exposure offset. When using this profile, this offset value is - // added to the BaselineExposure value for the negative to determine the - // overall baseline exposure to apply. - - dng_srational fBaselineExposureOffset; - - // Default black rendering. - - uint32 fDefaultBlackRender; - - // The "as shot" tone curve for this profile. Check IsValid method - // to tell if one exists in profile. - - dng_tone_curve fToneCurve; - - // If this string matches the fCameraCalibrationSignature of the - // negative, then use the calibration matrix values from the negative. - - dng_string fProfileCalibrationSignature; - - // If non-empty, only allow use of this profile with camera having - // same unique model name. - - dng_string fUniqueCameraModelRestriction; - - // Was this profile read from inside a DNG file? (If so, we wnat - // to be sure to include it again when writing out an updated - // DNG file) - - bool fWasReadFromDNG; - - // Was this profile read from disk (i.e., an external profile)? (If so, we - // may need to refresh when changes are made externally to the profile - // directory.) - - bool fWasReadFromDisk; - - // Was this profile a built-in "Matrix" profile? (If so, we may need to - // refresh -- i.e., remove it from the list of available profiles -- when - // changes are made externally to the profile directory.) - - bool fWasBuiltinMatrix; - - // Was this profile stubbed to save memory (and no longer valid - // for building color conversion tables)? - - bool fWasStubbed; - - public: - - dng_camera_profile (); - - virtual ~dng_camera_profile (); - - // API for profile name: - - /// Setter for camera profile name. - /// \param name Name to use for this camera profile. - - void SetName (const char *name) - { - fName.Set (name); - ClearFingerprint (); - } - - /// Getter for camera profile name. - /// \retval Name of profile. - - const dng_string & Name () const - { - return fName; - } - - /// Test if this name is embedded. - /// \retval true if the name matches the name of the embedded camera profile. - - bool NameIsEmbedded () const - { - return fName.Matches (kProfileName_Embedded, true); - } - - // API for calibration illuminants: - - /// Setter for first of up to two light sources used for calibration. - /// Uses the EXIF encodings for illuminant and is used to distinguish which - /// matrix to use. - /// Corresponds to the DNG CalibrationIlluminant1 tag. - - void SetCalibrationIlluminant1 (uint32 light) - { - fCalibrationIlluminant1 = light; - ClearFingerprint (); - } - - /// Setter for second of up to two light sources used for calibration. - /// Uses the EXIF encodings for illuminant and is used to distinguish which - /// matrix to use. - /// Corresponds to the DNG CalibrationIlluminant2 tag. - - void SetCalibrationIlluminant2 (uint32 light) - { - fCalibrationIlluminant2 = light; - ClearFingerprint (); - } - - /// Getter for first of up to two light sources used for calibration. - /// Uses the EXIF encodings for illuminant and is used to distinguish which - /// matrix to use. - /// Corresponds to the DNG CalibrationIlluminant1 tag. - - uint32 CalibrationIlluminant1 () const - { - return fCalibrationIlluminant1; - } - - /// Getter for second of up to two light sources used for calibration. - /// Uses the EXIF encodings for illuminant and is used to distinguish which - /// matrix to use. - /// Corresponds to the DNG CalibrationIlluminant2 tag. - - uint32 CalibrationIlluminant2 () const - { - return fCalibrationIlluminant2; - } - - /// Getter for first of up to two light sources used for calibration, returning - /// result as color temperature. - - real64 CalibrationTemperature1 () const - { - return IlluminantToTemperature (CalibrationIlluminant1 ()); - } - - /// Getter for second of up to two light sources used for calibration, returning - /// result as color temperature. - - real64 CalibrationTemperature2 () const - { - return IlluminantToTemperature (CalibrationIlluminant2 ()); - } - - // API for color matrices: - - /// Utility function to normalize the scale of the color matrix. - - static void NormalizeColorMatrix (dng_matrix &m); - - /// Setter for first of up to two color matrices used for reference camera calibrations. - /// These matrices map XYZ values to camera values. The DNG SDK needs to map colors - /// that direction in order to determine the clipping points for - /// highlight recovery logic based on the white point. If cameras - /// were all three-color, the matrix could be stored as a forward matrix. - /// The inverse matrix is requried to support four-color cameras. - - void SetColorMatrix1 (const dng_matrix &m); - - /// Setter for second of up to two color matrices used for reference camera calibrations. - /// These matrices map XYZ values to camera values. The DNG SDK needs to map colors - /// that direction in order to determine the clipping points for - /// highlight recovery logic based on the white point. If cameras - /// were all three-color, the matrix could be stored as a forward matrix. - /// The inverse matrix is requried to support four-color cameras. - - void SetColorMatrix2 (const dng_matrix &m); - - /// Predicate to test if first camera matrix is set - - bool HasColorMatrix1 () const; - - /// Predicate to test if second camera matrix is set - - bool HasColorMatrix2 () const; - - /// Getter for first of up to two color matrices used for calibrations. - - const dng_matrix & ColorMatrix1 () const - { - return fColorMatrix1; - } - - /// Getter for second of up to two color matrices used for calibrations. - - const dng_matrix & ColorMatrix2 () const - { - return fColorMatrix2; - } - - // API for forward matrices: - - /// Utility function to normalize the scale of the forward matrix. - - static void NormalizeForwardMatrix (dng_matrix &m); - - /// Setter for first of up to two forward matrices used for calibrations. - - void SetForwardMatrix1 (const dng_matrix &m); - - /// Setter for second of up to two forward matrices used for calibrations. - - void SetForwardMatrix2 (const dng_matrix &m); - - /// Getter for first of up to two forward matrices used for calibrations. - - const dng_matrix & ForwardMatrix1 () const - { - return fForwardMatrix1; - } - - /// Getter for second of up to two forward matrices used for calibrations. - - const dng_matrix & ForwardMatrix2 () const - { - return fForwardMatrix2; - } - - // API for reduction matrices: - - /// Setter for first of up to two dimensionality reduction hints for four-color cameras. - /// This is an optional matrix that maps four components to three. - /// See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification." - - void SetReductionMatrix1 (const dng_matrix &m); - - /// Setter for second of up to two dimensionality reduction hints for four-color cameras. - /// This is an optional matrix that maps four components to three. - /// See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification." - - void SetReductionMatrix2 (const dng_matrix &m); - - /// Getter for first of up to two dimensionality reduction hints for four color cameras. - - const dng_matrix & ReductionMatrix1 () const - { - return fReductionMatrix1; - } - - /// Getter for second of up to two dimensionality reduction hints for four color cameras. - - const dng_matrix & ReductionMatrix2 () const - { - return fReductionMatrix2; - } - - /// Getter function from profile fingerprint. - - const dng_fingerprint &Fingerprint () const - { - - if (!fFingerprint.IsValid ()) - CalculateFingerprint (); - - return fFingerprint; - - } - - /// Getter for camera profile id. - /// \retval ID of profile. - - dng_camera_profile_id ProfileID () const - { - return dng_camera_profile_id (Name (), Fingerprint ()); - } - - /// Setter for camera profile copyright. - /// \param copyright Copyright string to use for this camera profile. - - void SetCopyright (const char *copyright) - { - fCopyright.Set (copyright); - ClearFingerprint (); - } - - /// Getter for camera profile copyright. - /// \retval Copyright string for profile. - - const dng_string & Copyright () const - { - return fCopyright; - } - - // Accessors for embed policy. - - /// Setter for camera profile embed policy. - /// \param policy Policy to use for this camera profile. - - void SetEmbedPolicy (uint32 policy) - { - fEmbedPolicy = policy; - ClearFingerprint (); - } - - /// Getter for camera profile embed policy. - /// \param Policy for profile. - - uint32 EmbedPolicy () const - { - return fEmbedPolicy; - } - - /// Returns true iff the profile is legal to embed in a DNG, per the - /// profile's embed policy. - - bool IsLegalToEmbed () const - { - return WasReadFromDNG () || - EmbedPolicy () == pepAllowCopying || - EmbedPolicy () == pepEmbedIfUsed || - EmbedPolicy () == pepNoRestrictions; - } - - // Accessors for hue sat maps. - - /// Returns true iff the profile has a valid HueSatMap color table. - - bool HasHueSatDeltas () const - { - return fHueSatDeltas1.IsValid (); - } - - /// Getter for first HueSatMap color table (for calibration illuminant 1). - - const dng_hue_sat_map & HueSatDeltas1 () const - { - return fHueSatDeltas1; - } - - /// Setter for first HueSatMap color table (for calibration illuminant 1). - - void SetHueSatDeltas1 (const dng_hue_sat_map &deltas1); - - /// Getter for second HueSatMap color table (for calibration illuminant 2). - - const dng_hue_sat_map & HueSatDeltas2 () const - { - return fHueSatDeltas2; - } - - /// Setter for second HueSatMap color table (for calibration illuminant 2). - - void SetHueSatDeltas2 (const dng_hue_sat_map &deltas2); - - // Accessors for hue sat map encoding. - - /// Returns the hue sat map encoding (see ProfileHueSatMapEncoding tag). - - uint32 HueSatMapEncoding () const - { - return fHueSatMapEncoding; - } - - /// Sets the hue sat map encoding (see ProfileHueSatMapEncoding tag) to the - /// specified encoding. - - void SetHueSatMapEncoding (uint32 encoding) - { - fHueSatMapEncoding = encoding; - ClearFingerprint (); - } - - // Accessors for look table. - - /// Returns true if the profile has a LookTable. - - bool HasLookTable () const - { - return fLookTable.IsValid (); - } - - /// Getter for LookTable. - - const dng_hue_sat_map & LookTable () const - { - return fLookTable; - } - - /// Setter for LookTable. - - void SetLookTable (const dng_hue_sat_map &table); - - // Accessors for look table encoding. - - /// Returns the LookTable encoding (see ProfileLookTableEncoding tag). - - uint32 LookTableEncoding () const - { - return fLookTableEncoding; - } - - /// Sets the LookTable encoding (see ProfileLookTableEncoding tag) to the - /// specified encoding. - - void SetLookTableEncoding (uint32 encoding) - { - fLookTableEncoding = encoding; - ClearFingerprint (); - } - - // Accessors for baseline exposure offset. - - /// Sets the baseline exposure offset of the profile (see - /// BaselineExposureOffset tag) to the specified value. - - void SetBaselineExposureOffset (real64 exposureOffset) - { - fBaselineExposureOffset.Set_real64 (exposureOffset, 100); - ClearFingerprint (); - } - - /// Returns the baseline exposure offset of the profile (see - /// BaselineExposureOffset tag). - - const dng_srational & BaselineExposureOffset () const - { - return fBaselineExposureOffset; - } - - // Accessors for default black render. - - /// Sets the default black render of the profile (see DefaultBlackRender tag) - /// to the specified option. - - void SetDefaultBlackRender (uint32 defaultBlackRender) - { - fDefaultBlackRender = defaultBlackRender; - ClearFingerprint (); - } - - /// Returns the default black render of the profile (see DefaultBlackRender - /// tag). - - uint32 DefaultBlackRender () const - { - return fDefaultBlackRender; - } - - // Accessors for tone curve. - - /// Returns the tone curve of the profile. - - const dng_tone_curve & ToneCurve () const - { - return fToneCurve; - } - - /// Sets the tone curve of the profile to the specified curve. - - void SetToneCurve (const dng_tone_curve &curve) - { - fToneCurve = curve; - ClearFingerprint (); - } - - // Accessors for profile calibration signature. - - /// Sets the profile calibration signature (see ProfileCalibrationSignature - /// tag) to the specified string. - - void SetProfileCalibrationSignature (const char *signature) - { - fProfileCalibrationSignature.Set (signature); - } - - /// Returns the profile calibration signature (see ProfileCalibrationSignature - /// tag) of the profile. - - const dng_string & ProfileCalibrationSignature () const - { - return fProfileCalibrationSignature; - } - - /// Setter for camera unique model name to restrict use of this profile. - /// \param camera Camera unique model name designating only camera this - /// profile can be used with. (Empty string for no restriction.) - - void SetUniqueCameraModelRestriction (const char *camera) - { - fUniqueCameraModelRestriction.Set (camera); - // Not included in fingerprint, so don't need ClearFingerprint (). - } - - /// Getter for camera unique model name to restrict use of this profile. - /// \retval Unique model name of only camera this profile can be used with - /// or empty if no restriction. - - const dng_string & UniqueCameraModelRestriction () const - { - return fUniqueCameraModelRestriction; - } - - // Accessors for was read from DNG flag. - - /// Sets internal flag to indicate this profile was originally read from a - /// DNG file. - - void SetWasReadFromDNG (bool state = true) - { - fWasReadFromDNG = state; - } - - /// Was this profile read from a DNG? - - bool WasReadFromDNG () const - { - return fWasReadFromDNG; - } - - // Accessors for was read from disk flag. - - /// Sets internal flag to indicate this profile was originally read from - /// disk. - - void SetWasReadFromDisk (bool state = true) - { - fWasReadFromDisk = state; - } - - /// Was this profile read from disk? - - bool WasReadFromDisk () const - { - return fWasReadFromDisk; - } - - // Accessors for was built-in matrix flag. - - /// Sets internal flag to indicate this profile was originally a built-in - /// matrix profile. - - void SetWasBuiltinMatrix (bool state = true) - { - fWasBuiltinMatrix = state; - } - - /// Was this profile a built-in matrix profile? - - bool WasBuiltinMatrix () const - { - return fWasBuiltinMatrix; - } - - /// Determines if this a valid profile for this number of color channels? - /// \retval true if the profile is valid. - - bool IsValid (uint32 channels) const; - - /// Predicate to check if two camera profiles are colorwise equal, thus ignores - /// the profile name. - /// \param profile Camera profile to compare to. - - bool EqualData (const dng_camera_profile &profile) const; - - /// Parse profile from dng_camera_profile_info data. - - void Parse (dng_stream &stream, - dng_camera_profile_info &profileInfo); - - /// Parse from an extended profile stream, which is similar to stand alone - /// TIFF file. - - bool ParseExtended (dng_stream &stream); - - /// Convert from a three-color to a four-color Bayer profile. - - virtual void SetFourColorBayer (); - - /// Find the hue/sat table to use for a given white point, if any. - /// The calling routine owns the resulting table. - - dng_hue_sat_map * HueSatMapForWhite (const dng_xy_coord &white) const; - - /// Stub out the profile (free memory used by large tables). - - void Stub (); - - /// Was this profile stubbed? - - bool WasStubbed () const - { - return fWasStubbed; - } - - protected: - - static real64 IlluminantToTemperature (uint32 light); - - void ClearFingerprint () - { - fFingerprint.Clear (); - } - - void CalculateFingerprint () const; - - static bool ValidForwardMatrix (const dng_matrix &m); - - static void ReadHueSatMap (dng_stream &stream, - dng_hue_sat_map &hueSatMap, - uint32 hues, - uint32 sats, - uint32 vals, - bool skipSat0); - - }; - -/******************************************************************************/ - -void SplitCameraProfileName (const dng_string &name, - dng_string &baseName, - int32 &version); - -/*****************************************************************************/ - -void BuildHueSatMapEncodingTable (dng_memory_allocator &allocator, - uint32 encoding, - AutoPtr &encodeTable, - AutoPtr &decodeTable, - bool subSample); - -/******************************************************************************/ - -#endif - -/******************************************************************************/ diff --git a/third_party/dng_sdk/dng_classes.h b/third_party/dng_sdk/dng_classes.h deleted file mode 100644 index be72c4a..0000000 --- a/third_party/dng_sdk/dng_classes.h +++ /dev/null @@ -1,100 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_classes.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*** \file - * Forward class declarations to avoid having to include many .h files in most places. - */ - -/*****************************************************************************/ - -#ifndef __dng_classes__ -#define __dng_classes__ - -/*****************************************************************************/ - -class dng_1d_function; -class dng_1d_table; -class dng_abort_sniffer; -class dng_area_task; -class dng_basic_tag_set; -class dng_camera_profile; -class dng_camera_profile_id; -class dng_camera_profile_info; -class dng_color_space; -class dng_color_spec; -class dng_date_time; -class dng_date_time_info; -class dng_exif; -class dng_fingerprint; -class dng_host; -class dng_hue_sat_map; -class dng_ifd; -class dng_image; -class dng_image_preview; -class dng_image_writer; -class dng_info; -class dng_iptc; -class dng_jpeg_image; -class dng_jpeg_preview; -class dng_linearization_info; -class dng_matrix; -class dng_matrix_3by3; -class dng_matrix_4by3; -class dng_md5_printer; -class dng_memory_allocator; -class dng_memory_block; -class dng_memory_data; -class dng_memory_stream; -class dng_metadata; -class dng_mosaic_info; -class dng_mutex; -class dng_noise_function; -class dng_noise_profile; -class dng_opcode; -class dng_opcode_list; -class dng_orientation; -class dng_negative; -class dng_pixel_buffer; -class dng_point; -class dng_point_real64; -class dng_preview; -class dng_preview_info; -class dng_preview_list; -class dng_raw_preview; -class dng_read_image; -class dng_rect; -class dng_rect_real64; -class dng_render; -class dng_resolution; -class dng_shared; -class dng_spline_solver; -class dng_srational; -class dng_stream; -class dng_string; -class dng_string_list; -class dng_tiff_directory; -class dng_tile_buffer; -class dng_time_zone; -class dng_tone_curve; -class dng_urational; -class dng_vector; -class dng_vector_3; -class dng_xmp; -class dng_xmp_sdk; -class dng_xy_coord; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_color_space.cpp b/third_party/dng_sdk/dng_color_space.cpp deleted file mode 100644 index 72d465f..0000000 --- a/third_party/dng_sdk/dng_color_space.cpp +++ /dev/null @@ -1,1072 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_color_space.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -#include "dng_color_space.h" - -#include "dng_1d_table.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_matrix.h" -#include "dng_spline.h" -#include "dng_utils.h" -#include "dng_xy_coord.h" - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_sRGB::Evaluate (real64 x) const - { - - if (x <= 0.0031308) - return x * 12.92; - - else - return 1.055 * pow (x, 1.0 / 2.4) - 0.055; - - } - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_sRGB::EvaluateInverse (real64 y) const - { - - if (y <= 0.0031308 * 12.92) - return y * (1.0 / 12.92); - - else - return pow ((y + 0.055) * (1.0 / 1.055), 2.4); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_function_GammaEncode_sRGB::Get () - { - - static dng_function_GammaEncode_sRGB static_function; - - return static_function; - - } - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_1_8::Evaluate (real64 x) const - { - - const real64 gamma = 1.0 / 1.8; - - const real64 slope0 = 32.0; - - const real64 x1 = 8.2118790552e-4; // pow (slope0, 1.0 / (gamma - 1.0)) * 2.0 - - const real64 y1 = 0.019310851; // pow (x1, gamma) - - const real64 slope1 = 13.064306598; // gamma * pow (x1, gamma - 1.0) - - if (x <= x1) - return EvaluateSplineSegment (x, - 0.0, - 0.0, - slope0, - x1, - y1, - slope1); - - else - return pow (x, gamma); - - } - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_1_8::EvaluateInverse (real64 y) const - { - - if (y > 0.0 && y < 0.019310851) - { - - return dng_1d_function::EvaluateInverse (y); - - } - - return pow (y, 1.8); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_function_GammaEncode_1_8::Get () - { - - static dng_function_GammaEncode_1_8 static_function; - - return static_function; - - } - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_2_2::Evaluate (real64 x) const - { - - const real64 gamma = 1.0 / 2.2; - - const real64 slope0 = 32.0; - - const real64 x1 = 0.0034800731; // pow (slope0, 1.0 / (gamma - 1.0)) * 2.0 - - const real64 y1 = 0.0763027458; // pow (x1, gamma) - - const real64 slope1 = 9.9661890075; // gamma * pow (x1, gamma - 1.0) - - if (x <= x1) - return EvaluateSplineSegment (x, - 0.0, - 0.0, - slope0, - x1, - y1, - slope1); - - else - return pow (x, gamma); - - } - -/*****************************************************************************/ - -real64 dng_function_GammaEncode_2_2::EvaluateInverse (real64 y) const - { - - if (y > 0.0 && y < 0.0763027458) - { - - return dng_1d_function::EvaluateInverse (y); - - } - - return pow (y, 2.2); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_function_GammaEncode_2_2::Get () - { - - static dng_function_GammaEncode_2_2 static_function; - - return static_function; - - } - -/*****************************************************************************/ - -dng_color_space::dng_color_space () - - : fMatrixToPCS () - , fMatrixFromPCS () - - { - - } - -/*****************************************************************************/ - -dng_color_space::~dng_color_space () - { - - } - -/*****************************************************************************/ - -void dng_color_space::SetMonochrome () - { - - fMatrixToPCS = PCStoXYZ ().AsColumn (); - - dng_matrix m (1, 3); - - m [0] [0] = 0.0; - m [0] [1] = 1.0; - m [0] [2] = 0.0; - - fMatrixFromPCS = m; - - } - -/*****************************************************************************/ - -void dng_color_space::SetMatrixToPCS (const dng_matrix_3by3 &M) - { - - // The matrix values are often rounded, so adjust to - // get them to convert device white exactly to the PCS. - - dng_vector_3 W1 = M * dng_vector_3 (1.0, 1.0, 1.0); - dng_vector_3 W2 = PCStoXYZ (); - - real64 s0 = W2 [0] / W1 [0]; - real64 s1 = W2 [1] / W1 [1]; - real64 s2 = W2 [2] / W1 [2]; - - dng_matrix_3by3 S (s0, 0, 0, - 0, s1, 0, - 0, 0, s2); - - fMatrixToPCS = S * M; - - // Find reverse matrix. - - fMatrixFromPCS = Invert (fMatrixToPCS); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_color_space::GammaFunction () const - { - - return dng_1d_identity::Get (); - - } - -/*****************************************************************************/ - -bool dng_color_space::ICCProfile (uint32 &size, - const uint8 *&data) const - { - - size = 0; - data = NULL; - - return false; - - } - -/*****************************************************************************/ - -dng_space_sRGB::dng_space_sRGB () - { - - SetMatrixToPCS (dng_matrix_3by3 (0.4361, 0.3851, 0.1431, - 0.2225, 0.7169, 0.0606, - 0.0139, 0.0971, 0.7141)); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_sRGB::GammaFunction () const - { - - return dng_function_GammaEncode_sRGB::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_sRGB::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 ksRGBProfileData [] = - { - 0x00, 0x00, 0x0C, 0x48, 0x4C, 0x69, 0x6E, 0x6F, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCE, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, - 0x61, 0x63, 0x73, 0x70, 0x4D, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00, - 0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x48, 0x50, 0x20, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x6C, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xF0, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14, - 0x72, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14, - 0x67, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14, - 0x64, 0x6D, 0x6E, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70, - 0x64, 0x6D, 0x64, 0x64, 0x00, 0x00, 0x02, 0xC4, 0x00, 0x00, 0x00, 0x88, - 0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4C, 0x00, 0x00, 0x00, 0x86, - 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xD4, 0x00, 0x00, 0x00, 0x24, - 0x6C, 0x75, 0x6D, 0x69, 0x00, 0x00, 0x03, 0xF8, 0x00, 0x00, 0x00, 0x14, - 0x6D, 0x65, 0x61, 0x73, 0x00, 0x00, 0x04, 0x0C, 0x00, 0x00, 0x00, 0x24, - 0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x0C, - 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3C, 0x00, 0x00, 0x08, 0x0C, - 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3C, 0x00, 0x00, 0x08, 0x0C, - 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3C, 0x00, 0x00, 0x08, 0x0C, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39, - 0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6C, 0x65, 0x74, 0x74, 0x2D, 0x50, - 0x61, 0x63, 0x6B, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6F, 0x6D, 0x70, 0x61, - 0x6E, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, - 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, 0x31, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, - 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, - 0x2E, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xF3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCC, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6F, 0xA2, 0x00, 0x00, 0x38, 0xF5, - 0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x62, 0x99, 0x00, 0x00, 0xB7, 0x85, 0x00, 0x00, 0x18, 0xDA, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xA0, - 0x00, 0x00, 0x0F, 0x84, 0x00, 0x00, 0xB6, 0xCF, 0x64, 0x65, 0x73, 0x63, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, - 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x69, - 0x65, 0x63, 0x2E, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, - 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x69, 0x65, 0x63, 0x2E, - 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, - 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, - 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x52, 0x47, - 0x42, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x20, 0x2D, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x49, 0x45, 0x43, - 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, 0x31, 0x20, 0x44, - 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63, - 0x6F, 0x6C, 0x6F, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, - 0x2D, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x2C, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, - 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x43, 0x6F, - 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x49, - 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, 0x31, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x52, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65, - 0x77, 0x69, 0x6E, 0x67, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, - 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, - 0x36, 0x36, 0x2D, 0x32, 0x2E, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xA4, 0xFE, 0x00, 0x14, 0x5F, 0x2E, - 0x00, 0x10, 0xCF, 0x14, 0x00, 0x03, 0xED, 0xCC, 0x00, 0x04, 0x13, 0x0B, - 0x00, 0x03, 0x5C, 0x9E, 0x00, 0x00, 0x00, 0x01, 0x58, 0x59, 0x5A, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00, - 0x00, 0x57, 0x1F, 0xE7, 0x6D, 0x65, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8F, - 0x00, 0x00, 0x00, 0x02, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0A, 0x00, 0x0F, - 0x00, 0x14, 0x00, 0x19, 0x00, 0x1E, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2D, - 0x00, 0x32, 0x00, 0x37, 0x00, 0x3B, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4A, - 0x00, 0x4F, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5E, 0x00, 0x63, 0x00, 0x68, - 0x00, 0x6D, 0x00, 0x72, 0x00, 0x77, 0x00, 0x7C, 0x00, 0x81, 0x00, 0x86, - 0x00, 0x8B, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9A, 0x00, 0x9F, 0x00, 0xA4, - 0x00, 0xA9, 0x00, 0xAE, 0x00, 0xB2, 0x00, 0xB7, 0x00, 0xBC, 0x00, 0xC1, - 0x00, 0xC6, 0x00, 0xCB, 0x00, 0xD0, 0x00, 0xD5, 0x00, 0xDB, 0x00, 0xE0, - 0x00, 0xE5, 0x00, 0xEB, 0x00, 0xF0, 0x00, 0xF6, 0x00, 0xFB, 0x01, 0x01, - 0x01, 0x07, 0x01, 0x0D, 0x01, 0x13, 0x01, 0x19, 0x01, 0x1F, 0x01, 0x25, - 0x01, 0x2B, 0x01, 0x32, 0x01, 0x38, 0x01, 0x3E, 0x01, 0x45, 0x01, 0x4C, - 0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67, 0x01, 0x6E, 0x01, 0x75, - 0x01, 0x7C, 0x01, 0x83, 0x01, 0x8B, 0x01, 0x92, 0x01, 0x9A, 0x01, 0xA1, - 0x01, 0xA9, 0x01, 0xB1, 0x01, 0xB9, 0x01, 0xC1, 0x01, 0xC9, 0x01, 0xD1, - 0x01, 0xD9, 0x01, 0xE1, 0x01, 0xE9, 0x01, 0xF2, 0x01, 0xFA, 0x02, 0x03, - 0x02, 0x0C, 0x02, 0x14, 0x02, 0x1D, 0x02, 0x26, 0x02, 0x2F, 0x02, 0x38, - 0x02, 0x41, 0x02, 0x4B, 0x02, 0x54, 0x02, 0x5D, 0x02, 0x67, 0x02, 0x71, - 0x02, 0x7A, 0x02, 0x84, 0x02, 0x8E, 0x02, 0x98, 0x02, 0xA2, 0x02, 0xAC, - 0x02, 0xB6, 0x02, 0xC1, 0x02, 0xCB, 0x02, 0xD5, 0x02, 0xE0, 0x02, 0xEB, - 0x02, 0xF5, 0x03, 0x00, 0x03, 0x0B, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2D, - 0x03, 0x38, 0x03, 0x43, 0x03, 0x4F, 0x03, 0x5A, 0x03, 0x66, 0x03, 0x72, - 0x03, 0x7E, 0x03, 0x8A, 0x03, 0x96, 0x03, 0xA2, 0x03, 0xAE, 0x03, 0xBA, - 0x03, 0xC7, 0x03, 0xD3, 0x03, 0xE0, 0x03, 0xEC, 0x03, 0xF9, 0x04, 0x06, - 0x04, 0x13, 0x04, 0x20, 0x04, 0x2D, 0x04, 0x3B, 0x04, 0x48, 0x04, 0x55, - 0x04, 0x63, 0x04, 0x71, 0x04, 0x7E, 0x04, 0x8C, 0x04, 0x9A, 0x04, 0xA8, - 0x04, 0xB6, 0x04, 0xC4, 0x04, 0xD3, 0x04, 0xE1, 0x04, 0xF0, 0x04, 0xFE, - 0x05, 0x0D, 0x05, 0x1C, 0x05, 0x2B, 0x05, 0x3A, 0x05, 0x49, 0x05, 0x58, - 0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96, 0x05, 0xA6, 0x05, 0xB5, - 0x05, 0xC5, 0x05, 0xD5, 0x05, 0xE5, 0x05, 0xF6, 0x06, 0x06, 0x06, 0x16, - 0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59, 0x06, 0x6A, 0x06, 0x7B, - 0x06, 0x8C, 0x06, 0x9D, 0x06, 0xAF, 0x06, 0xC0, 0x06, 0xD1, 0x06, 0xE3, - 0x06, 0xF5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2B, 0x07, 0x3D, 0x07, 0x4F, - 0x07, 0x61, 0x07, 0x74, 0x07, 0x86, 0x07, 0x99, 0x07, 0xAC, 0x07, 0xBF, - 0x07, 0xD2, 0x07, 0xE5, 0x07, 0xF8, 0x08, 0x0B, 0x08, 0x1F, 0x08, 0x32, - 0x08, 0x46, 0x08, 0x5A, 0x08, 0x6E, 0x08, 0x82, 0x08, 0x96, 0x08, 0xAA, - 0x08, 0xBE, 0x08, 0xD2, 0x08, 0xE7, 0x08, 0xFB, 0x09, 0x10, 0x09, 0x25, - 0x09, 0x3A, 0x09, 0x4F, 0x09, 0x64, 0x09, 0x79, 0x09, 0x8F, 0x09, 0xA4, - 0x09, 0xBA, 0x09, 0xCF, 0x09, 0xE5, 0x09, 0xFB, 0x0A, 0x11, 0x0A, 0x27, - 0x0A, 0x3D, 0x0A, 0x54, 0x0A, 0x6A, 0x0A, 0x81, 0x0A, 0x98, 0x0A, 0xAE, - 0x0A, 0xC5, 0x0A, 0xDC, 0x0A, 0xF3, 0x0B, 0x0B, 0x0B, 0x22, 0x0B, 0x39, - 0x0B, 0x51, 0x0B, 0x69, 0x0B, 0x80, 0x0B, 0x98, 0x0B, 0xB0, 0x0B, 0xC8, - 0x0B, 0xE1, 0x0B, 0xF9, 0x0C, 0x12, 0x0C, 0x2A, 0x0C, 0x43, 0x0C, 0x5C, - 0x0C, 0x75, 0x0C, 0x8E, 0x0C, 0xA7, 0x0C, 0xC0, 0x0C, 0xD9, 0x0C, 0xF3, - 0x0D, 0x0D, 0x0D, 0x26, 0x0D, 0x40, 0x0D, 0x5A, 0x0D, 0x74, 0x0D, 0x8E, - 0x0D, 0xA9, 0x0D, 0xC3, 0x0D, 0xDE, 0x0D, 0xF8, 0x0E, 0x13, 0x0E, 0x2E, - 0x0E, 0x49, 0x0E, 0x64, 0x0E, 0x7F, 0x0E, 0x9B, 0x0E, 0xB6, 0x0E, 0xD2, - 0x0E, 0xEE, 0x0F, 0x09, 0x0F, 0x25, 0x0F, 0x41, 0x0F, 0x5E, 0x0F, 0x7A, - 0x0F, 0x96, 0x0F, 0xB3, 0x0F, 0xCF, 0x0F, 0xEC, 0x10, 0x09, 0x10, 0x26, - 0x10, 0x43, 0x10, 0x61, 0x10, 0x7E, 0x10, 0x9B, 0x10, 0xB9, 0x10, 0xD7, - 0x10, 0xF5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4F, 0x11, 0x6D, 0x11, 0x8C, - 0x11, 0xAA, 0x11, 0xC9, 0x11, 0xE8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45, - 0x12, 0x64, 0x12, 0x84, 0x12, 0xA3, 0x12, 0xC3, 0x12, 0xE3, 0x13, 0x03, - 0x13, 0x23, 0x13, 0x43, 0x13, 0x63, 0x13, 0x83, 0x13, 0xA4, 0x13, 0xC5, - 0x13, 0xE5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49, 0x14, 0x6A, 0x14, 0x8B, - 0x14, 0xAD, 0x14, 0xCE, 0x14, 0xF0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56, - 0x15, 0x78, 0x15, 0x9B, 0x15, 0xBD, 0x15, 0xE0, 0x16, 0x03, 0x16, 0x26, - 0x16, 0x49, 0x16, 0x6C, 0x16, 0x8F, 0x16, 0xB2, 0x16, 0xD6, 0x16, 0xFA, - 0x17, 0x1D, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89, 0x17, 0xAE, 0x17, 0xD2, - 0x17, 0xF7, 0x18, 0x1B, 0x18, 0x40, 0x18, 0x65, 0x18, 0x8A, 0x18, 0xAF, - 0x18, 0xD5, 0x18, 0xFA, 0x19, 0x20, 0x19, 0x45, 0x19, 0x6B, 0x19, 0x91, - 0x19, 0xB7, 0x19, 0xDD, 0x1A, 0x04, 0x1A, 0x2A, 0x1A, 0x51, 0x1A, 0x77, - 0x1A, 0x9E, 0x1A, 0xC5, 0x1A, 0xEC, 0x1B, 0x14, 0x1B, 0x3B, 0x1B, 0x63, - 0x1B, 0x8A, 0x1B, 0xB2, 0x1B, 0xDA, 0x1C, 0x02, 0x1C, 0x2A, 0x1C, 0x52, - 0x1C, 0x7B, 0x1C, 0xA3, 0x1C, 0xCC, 0x1C, 0xF5, 0x1D, 0x1E, 0x1D, 0x47, - 0x1D, 0x70, 0x1D, 0x99, 0x1D, 0xC3, 0x1D, 0xEC, 0x1E, 0x16, 0x1E, 0x40, - 0x1E, 0x6A, 0x1E, 0x94, 0x1E, 0xBE, 0x1E, 0xE9, 0x1F, 0x13, 0x1F, 0x3E, - 0x1F, 0x69, 0x1F, 0x94, 0x1F, 0xBF, 0x1F, 0xEA, 0x20, 0x15, 0x20, 0x41, - 0x20, 0x6C, 0x20, 0x98, 0x20, 0xC4, 0x20, 0xF0, 0x21, 0x1C, 0x21, 0x48, - 0x21, 0x75, 0x21, 0xA1, 0x21, 0xCE, 0x21, 0xFB, 0x22, 0x27, 0x22, 0x55, - 0x22, 0x82, 0x22, 0xAF, 0x22, 0xDD, 0x23, 0x0A, 0x23, 0x38, 0x23, 0x66, - 0x23, 0x94, 0x23, 0xC2, 0x23, 0xF0, 0x24, 0x1F, 0x24, 0x4D, 0x24, 0x7C, - 0x24, 0xAB, 0x24, 0xDA, 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97, - 0x25, 0xC7, 0x25, 0xF7, 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xB7, - 0x26, 0xE8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7A, 0x27, 0xAB, 0x27, 0xDC, - 0x28, 0x0D, 0x28, 0x3F, 0x28, 0x71, 0x28, 0xA2, 0x28, 0xD4, 0x29, 0x06, - 0x29, 0x38, 0x29, 0x6B, 0x29, 0x9D, 0x29, 0xD0, 0x2A, 0x02, 0x2A, 0x35, - 0x2A, 0x68, 0x2A, 0x9B, 0x2A, 0xCF, 0x2B, 0x02, 0x2B, 0x36, 0x2B, 0x69, - 0x2B, 0x9D, 0x2B, 0xD1, 0x2C, 0x05, 0x2C, 0x39, 0x2C, 0x6E, 0x2C, 0xA2, - 0x2C, 0xD7, 0x2D, 0x0C, 0x2D, 0x41, 0x2D, 0x76, 0x2D, 0xAB, 0x2D, 0xE1, - 0x2E, 0x16, 0x2E, 0x4C, 0x2E, 0x82, 0x2E, 0xB7, 0x2E, 0xEE, 0x2F, 0x24, - 0x2F, 0x5A, 0x2F, 0x91, 0x2F, 0xC7, 0x2F, 0xFE, 0x30, 0x35, 0x30, 0x6C, - 0x30, 0xA4, 0x30, 0xDB, 0x31, 0x12, 0x31, 0x4A, 0x31, 0x82, 0x31, 0xBA, - 0x31, 0xF2, 0x32, 0x2A, 0x32, 0x63, 0x32, 0x9B, 0x32, 0xD4, 0x33, 0x0D, - 0x33, 0x46, 0x33, 0x7F, 0x33, 0xB8, 0x33, 0xF1, 0x34, 0x2B, 0x34, 0x65, - 0x34, 0x9E, 0x34, 0xD8, 0x35, 0x13, 0x35, 0x4D, 0x35, 0x87, 0x35, 0xC2, - 0x35, 0xFD, 0x36, 0x37, 0x36, 0x72, 0x36, 0xAE, 0x36, 0xE9, 0x37, 0x24, - 0x37, 0x60, 0x37, 0x9C, 0x37, 0xD7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8C, - 0x38, 0xC8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7F, 0x39, 0xBC, 0x39, 0xF9, - 0x3A, 0x36, 0x3A, 0x74, 0x3A, 0xB2, 0x3A, 0xEF, 0x3B, 0x2D, 0x3B, 0x6B, - 0x3B, 0xAA, 0x3B, 0xE8, 0x3C, 0x27, 0x3C, 0x65, 0x3C, 0xA4, 0x3C, 0xE3, - 0x3D, 0x22, 0x3D, 0x61, 0x3D, 0xA1, 0x3D, 0xE0, 0x3E, 0x20, 0x3E, 0x60, - 0x3E, 0xA0, 0x3E, 0xE0, 0x3F, 0x21, 0x3F, 0x61, 0x3F, 0xA2, 0x3F, 0xE2, - 0x40, 0x23, 0x40, 0x64, 0x40, 0xA6, 0x40, 0xE7, 0x41, 0x29, 0x41, 0x6A, - 0x41, 0xAC, 0x41, 0xEE, 0x42, 0x30, 0x42, 0x72, 0x42, 0xB5, 0x42, 0xF7, - 0x43, 0x3A, 0x43, 0x7D, 0x43, 0xC0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8A, - 0x44, 0xCE, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9A, 0x45, 0xDE, 0x46, 0x22, - 0x46, 0x67, 0x46, 0xAB, 0x46, 0xF0, 0x47, 0x35, 0x47, 0x7B, 0x47, 0xC0, - 0x48, 0x05, 0x48, 0x4B, 0x48, 0x91, 0x48, 0xD7, 0x49, 0x1D, 0x49, 0x63, - 0x49, 0xA9, 0x49, 0xF0, 0x4A, 0x37, 0x4A, 0x7D, 0x4A, 0xC4, 0x4B, 0x0C, - 0x4B, 0x53, 0x4B, 0x9A, 0x4B, 0xE2, 0x4C, 0x2A, 0x4C, 0x72, 0x4C, 0xBA, - 0x4D, 0x02, 0x4D, 0x4A, 0x4D, 0x93, 0x4D, 0xDC, 0x4E, 0x25, 0x4E, 0x6E, - 0x4E, 0xB7, 0x4F, 0x00, 0x4F, 0x49, 0x4F, 0x93, 0x4F, 0xDD, 0x50, 0x27, - 0x50, 0x71, 0x50, 0xBB, 0x51, 0x06, 0x51, 0x50, 0x51, 0x9B, 0x51, 0xE6, - 0x52, 0x31, 0x52, 0x7C, 0x52, 0xC7, 0x53, 0x13, 0x53, 0x5F, 0x53, 0xAA, - 0x53, 0xF6, 0x54, 0x42, 0x54, 0x8F, 0x54, 0xDB, 0x55, 0x28, 0x55, 0x75, - 0x55, 0xC2, 0x56, 0x0F, 0x56, 0x5C, 0x56, 0xA9, 0x56, 0xF7, 0x57, 0x44, - 0x57, 0x92, 0x57, 0xE0, 0x58, 0x2F, 0x58, 0x7D, 0x58, 0xCB, 0x59, 0x1A, - 0x59, 0x69, 0x59, 0xB8, 0x5A, 0x07, 0x5A, 0x56, 0x5A, 0xA6, 0x5A, 0xF5, - 0x5B, 0x45, 0x5B, 0x95, 0x5B, 0xE5, 0x5C, 0x35, 0x5C, 0x86, 0x5C, 0xD6, - 0x5D, 0x27, 0x5D, 0x78, 0x5D, 0xC9, 0x5E, 0x1A, 0x5E, 0x6C, 0x5E, 0xBD, - 0x5F, 0x0F, 0x5F, 0x61, 0x5F, 0xB3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xAA, - 0x60, 0xFC, 0x61, 0x4F, 0x61, 0xA2, 0x61, 0xF5, 0x62, 0x49, 0x62, 0x9C, - 0x62, 0xF0, 0x63, 0x43, 0x63, 0x97, 0x63, 0xEB, 0x64, 0x40, 0x64, 0x94, - 0x64, 0xE9, 0x65, 0x3D, 0x65, 0x92, 0x65, 0xE7, 0x66, 0x3D, 0x66, 0x92, - 0x66, 0xE8, 0x67, 0x3D, 0x67, 0x93, 0x67, 0xE9, 0x68, 0x3F, 0x68, 0x96, - 0x68, 0xEC, 0x69, 0x43, 0x69, 0x9A, 0x69, 0xF1, 0x6A, 0x48, 0x6A, 0x9F, - 0x6A, 0xF7, 0x6B, 0x4F, 0x6B, 0xA7, 0x6B, 0xFF, 0x6C, 0x57, 0x6C, 0xAF, - 0x6D, 0x08, 0x6D, 0x60, 0x6D, 0xB9, 0x6E, 0x12, 0x6E, 0x6B, 0x6E, 0xC4, - 0x6F, 0x1E, 0x6F, 0x78, 0x6F, 0xD1, 0x70, 0x2B, 0x70, 0x86, 0x70, 0xE0, - 0x71, 0x3A, 0x71, 0x95, 0x71, 0xF0, 0x72, 0x4B, 0x72, 0xA6, 0x73, 0x01, - 0x73, 0x5D, 0x73, 0xB8, 0x74, 0x14, 0x74, 0x70, 0x74, 0xCC, 0x75, 0x28, - 0x75, 0x85, 0x75, 0xE1, 0x76, 0x3E, 0x76, 0x9B, 0x76, 0xF8, 0x77, 0x56, - 0x77, 0xB3, 0x78, 0x11, 0x78, 0x6E, 0x78, 0xCC, 0x79, 0x2A, 0x79, 0x89, - 0x79, 0xE7, 0x7A, 0x46, 0x7A, 0xA5, 0x7B, 0x04, 0x7B, 0x63, 0x7B, 0xC2, - 0x7C, 0x21, 0x7C, 0x81, 0x7C, 0xE1, 0x7D, 0x41, 0x7D, 0xA1, 0x7E, 0x01, - 0x7E, 0x62, 0x7E, 0xC2, 0x7F, 0x23, 0x7F, 0x84, 0x7F, 0xE5, 0x80, 0x47, - 0x80, 0xA8, 0x81, 0x0A, 0x81, 0x6B, 0x81, 0xCD, 0x82, 0x30, 0x82, 0x92, - 0x82, 0xF4, 0x83, 0x57, 0x83, 0xBA, 0x84, 0x1D, 0x84, 0x80, 0x84, 0xE3, - 0x85, 0x47, 0x85, 0xAB, 0x86, 0x0E, 0x86, 0x72, 0x86, 0xD7, 0x87, 0x3B, - 0x87, 0x9F, 0x88, 0x04, 0x88, 0x69, 0x88, 0xCE, 0x89, 0x33, 0x89, 0x99, - 0x89, 0xFE, 0x8A, 0x64, 0x8A, 0xCA, 0x8B, 0x30, 0x8B, 0x96, 0x8B, 0xFC, - 0x8C, 0x63, 0x8C, 0xCA, 0x8D, 0x31, 0x8D, 0x98, 0x8D, 0xFF, 0x8E, 0x66, - 0x8E, 0xCE, 0x8F, 0x36, 0x8F, 0x9E, 0x90, 0x06, 0x90, 0x6E, 0x90, 0xD6, - 0x91, 0x3F, 0x91, 0xA8, 0x92, 0x11, 0x92, 0x7A, 0x92, 0xE3, 0x93, 0x4D, - 0x93, 0xB6, 0x94, 0x20, 0x94, 0x8A, 0x94, 0xF4, 0x95, 0x5F, 0x95, 0xC9, - 0x96, 0x34, 0x96, 0x9F, 0x97, 0x0A, 0x97, 0x75, 0x97, 0xE0, 0x98, 0x4C, - 0x98, 0xB8, 0x99, 0x24, 0x99, 0x90, 0x99, 0xFC, 0x9A, 0x68, 0x9A, 0xD5, - 0x9B, 0x42, 0x9B, 0xAF, 0x9C, 0x1C, 0x9C, 0x89, 0x9C, 0xF7, 0x9D, 0x64, - 0x9D, 0xD2, 0x9E, 0x40, 0x9E, 0xAE, 0x9F, 0x1D, 0x9F, 0x8B, 0x9F, 0xFA, - 0xA0, 0x69, 0xA0, 0xD8, 0xA1, 0x47, 0xA1, 0xB6, 0xA2, 0x26, 0xA2, 0x96, - 0xA3, 0x06, 0xA3, 0x76, 0xA3, 0xE6, 0xA4, 0x56, 0xA4, 0xC7, 0xA5, 0x38, - 0xA5, 0xA9, 0xA6, 0x1A, 0xA6, 0x8B, 0xA6, 0xFD, 0xA7, 0x6E, 0xA7, 0xE0, - 0xA8, 0x52, 0xA8, 0xC4, 0xA9, 0x37, 0xA9, 0xA9, 0xAA, 0x1C, 0xAA, 0x8F, - 0xAB, 0x02, 0xAB, 0x75, 0xAB, 0xE9, 0xAC, 0x5C, 0xAC, 0xD0, 0xAD, 0x44, - 0xAD, 0xB8, 0xAE, 0x2D, 0xAE, 0xA1, 0xAF, 0x16, 0xAF, 0x8B, 0xB0, 0x00, - 0xB0, 0x75, 0xB0, 0xEA, 0xB1, 0x60, 0xB1, 0xD6, 0xB2, 0x4B, 0xB2, 0xC2, - 0xB3, 0x38, 0xB3, 0xAE, 0xB4, 0x25, 0xB4, 0x9C, 0xB5, 0x13, 0xB5, 0x8A, - 0xB6, 0x01, 0xB6, 0x79, 0xB6, 0xF0, 0xB7, 0x68, 0xB7, 0xE0, 0xB8, 0x59, - 0xB8, 0xD1, 0xB9, 0x4A, 0xB9, 0xC2, 0xBA, 0x3B, 0xBA, 0xB5, 0xBB, 0x2E, - 0xBB, 0xA7, 0xBC, 0x21, 0xBC, 0x9B, 0xBD, 0x15, 0xBD, 0x8F, 0xBE, 0x0A, - 0xBE, 0x84, 0xBE, 0xFF, 0xBF, 0x7A, 0xBF, 0xF5, 0xC0, 0x70, 0xC0, 0xEC, - 0xC1, 0x67, 0xC1, 0xE3, 0xC2, 0x5F, 0xC2, 0xDB, 0xC3, 0x58, 0xC3, 0xD4, - 0xC4, 0x51, 0xC4, 0xCE, 0xC5, 0x4B, 0xC5, 0xC8, 0xC6, 0x46, 0xC6, 0xC3, - 0xC7, 0x41, 0xC7, 0xBF, 0xC8, 0x3D, 0xC8, 0xBC, 0xC9, 0x3A, 0xC9, 0xB9, - 0xCA, 0x38, 0xCA, 0xB7, 0xCB, 0x36, 0xCB, 0xB6, 0xCC, 0x35, 0xCC, 0xB5, - 0xCD, 0x35, 0xCD, 0xB5, 0xCE, 0x36, 0xCE, 0xB6, 0xCF, 0x37, 0xCF, 0xB8, - 0xD0, 0x39, 0xD0, 0xBA, 0xD1, 0x3C, 0xD1, 0xBE, 0xD2, 0x3F, 0xD2, 0xC1, - 0xD3, 0x44, 0xD3, 0xC6, 0xD4, 0x49, 0xD4, 0xCB, 0xD5, 0x4E, 0xD5, 0xD1, - 0xD6, 0x55, 0xD6, 0xD8, 0xD7, 0x5C, 0xD7, 0xE0, 0xD8, 0x64, 0xD8, 0xE8, - 0xD9, 0x6C, 0xD9, 0xF1, 0xDA, 0x76, 0xDA, 0xFB, 0xDB, 0x80, 0xDC, 0x05, - 0xDC, 0x8A, 0xDD, 0x10, 0xDD, 0x96, 0xDE, 0x1C, 0xDE, 0xA2, 0xDF, 0x29, - 0xDF, 0xAF, 0xE0, 0x36, 0xE0, 0xBD, 0xE1, 0x44, 0xE1, 0xCC, 0xE2, 0x53, - 0xE2, 0xDB, 0xE3, 0x63, 0xE3, 0xEB, 0xE4, 0x73, 0xE4, 0xFC, 0xE5, 0x84, - 0xE6, 0x0D, 0xE6, 0x96, 0xE7, 0x1F, 0xE7, 0xA9, 0xE8, 0x32, 0xE8, 0xBC, - 0xE9, 0x46, 0xE9, 0xD0, 0xEA, 0x5B, 0xEA, 0xE5, 0xEB, 0x70, 0xEB, 0xFB, - 0xEC, 0x86, 0xED, 0x11, 0xED, 0x9C, 0xEE, 0x28, 0xEE, 0xB4, 0xEF, 0x40, - 0xEF, 0xCC, 0xF0, 0x58, 0xF0, 0xE5, 0xF1, 0x72, 0xF1, 0xFF, 0xF2, 0x8C, - 0xF3, 0x19, 0xF3, 0xA7, 0xF4, 0x34, 0xF4, 0xC2, 0xF5, 0x50, 0xF5, 0xDE, - 0xF6, 0x6D, 0xF6, 0xFB, 0xF7, 0x8A, 0xF8, 0x19, 0xF8, 0xA8, 0xF9, 0x38, - 0xF9, 0xC7, 0xFA, 0x57, 0xFA, 0xE7, 0xFB, 0x77, 0xFC, 0x07, 0xFC, 0x98, - 0xFD, 0x29, 0xFD, 0xBA, 0xFE, 0x4B, 0xFE, 0xDC, 0xFF, 0x6D, 0xFF, 0xFF - }; - - size = sizeof (ksRGBProfileData); - data = ksRGBProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_sRGB::Get () - { - - static dng_space_sRGB static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_AdobeRGB::dng_space_AdobeRGB () - { - - SetMatrixToPCS (dng_matrix_3by3 (0.6097, 0.2053, 0.1492, - 0.3111, 0.6257, 0.0632, - 0.0195, 0.0609, 0.7446)); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_AdobeRGB::GammaFunction () const - { - - return dng_function_GammaEncode_2_2::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_AdobeRGB::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 kAdobeRGBProfileData [] = - { - 0x00, 0x00, 0x02, 0x30, 0x41, 0x44, 0x42, 0x45, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCF, 0x00, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00, - 0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x41, 0x44, 0x42, 0x45, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x32, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x6B, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x9C, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0xB0, 0x00, 0x00, 0x00, 0x14, - 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xC4, 0x00, 0x00, 0x00, 0x0E, - 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xD4, 0x00, 0x00, 0x00, 0x0E, - 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xE4, 0x00, 0x00, 0x00, 0x0E, - 0x72, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x14, - 0x67, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x00, 0x14, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x31, 0x39, 0x39, 0x39, 0x20, 0x41, - 0x64, 0x6F, 0x62, 0x65, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x73, - 0x20, 0x49, 0x6E, 0x63, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x65, - 0x64, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x11, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x52, 0x47, - 0x42, 0x20, 0x28, 0x31, 0x39, 0x39, 0x38, 0x29, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xF3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCC, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x33, 0x00, 0x00, - 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, - 0x02, 0x33, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x01, 0x02, 0x33, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x18, 0x00, 0x00, 0x4F, 0xA5, - 0x00, 0x00, 0x04, 0xFC, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x34, 0x8D, 0x00, 0x00, 0xA0, 0x2C, 0x00, 0x00, 0x0F, 0x95, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x31, - 0x00, 0x00, 0x10, 0x2F, 0x00, 0x00, 0xBE, 0x9C - }; - - size = sizeof (kAdobeRGBProfileData); - data = kAdobeRGBProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_AdobeRGB::Get () - { - - static dng_space_AdobeRGB static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_ColorMatch::dng_space_ColorMatch () - { - - SetMatrixToPCS (dng_matrix_3by3 (0.5094, 0.3208, 0.1339, - 0.2749, 0.6581, 0.0670, - 0.0243, 0.1087, 0.6919)); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_ColorMatch::GammaFunction () const - { - - return dng_function_GammaEncode_1_8::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_ColorMatch::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 kColorMatchProfileData [] = - { - 0x00, 0x00, 0x02, 0x30, 0x41, 0x44, 0x42, 0x45, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCF, 0x00, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00, - 0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x41, 0x44, 0x42, 0x45, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x32, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x69, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x9C, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0xB0, 0x00, 0x00, 0x00, 0x14, - 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xC4, 0x00, 0x00, 0x00, 0x0E, - 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xD4, 0x00, 0x00, 0x00, 0x0E, - 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xE4, 0x00, 0x00, 0x00, 0x0E, - 0x72, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x14, - 0x67, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x00, 0x14, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x31, 0x39, 0x39, 0x39, 0x20, 0x41, - 0x64, 0x6F, 0x62, 0x65, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x73, - 0x20, 0x49, 0x6E, 0x63, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x65, - 0x64, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x0F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x61, 0x74, - 0x63, 0x68, 0x20, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xF6, 0xDC, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x3A, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xCD, 0x00, 0x00, - 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, - 0x01, 0xCD, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x01, 0x01, 0xCD, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x6B, 0x00, 0x00, 0x46, 0x63, - 0x00, 0x00, 0x06, 0x36, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x52, 0x23, 0x00, 0x00, 0xA8, 0x79, 0x00, 0x00, 0x1B, 0xD7, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x48, - 0x00, 0x00, 0x11, 0x25, 0x00, 0x00, 0xB1, 0x20 - }; - - size = sizeof (kColorMatchProfileData); - data = kColorMatchProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_ColorMatch::Get () - { - - static dng_space_ColorMatch static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_ProPhoto::dng_space_ProPhoto () - { - - SetMatrixToPCS (dng_matrix_3by3 (0.7977, 0.1352, 0.0313, - 0.2880, 0.7119, 0.0001, - 0.0000, 0.0000, 0.8249)); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_ProPhoto::GammaFunction () const - { - - return dng_function_GammaEncode_1_8::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_ProPhoto::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 kProPhotoProfileData [] = - { - 0x00, 0x00, 0x03, 0xAC, 0x4B, 0x43, 0x4D, 0x53, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCE, 0x00, 0x0C, 0x00, 0x01, 0x00, 0x12, 0x00, 0x3A, 0x00, 0x15, - 0x61, 0x63, 0x73, 0x70, 0x4D, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00, - 0x4B, 0x4F, 0x44, 0x41, 0x52, 0x4F, 0x4D, 0x4D, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2B, 0x4B, 0x4F, 0x44, 0x41, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x00, 0x48, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x83, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x14, - 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x0E, - 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x0E, - 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x0E, - 0x72, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14, - 0x67, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x00, 0x14, - 0x64, 0x6D, 0x6E, 0x64, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x6E, - 0x64, 0x6D, 0x64, 0x64, 0x00, 0x00, 0x02, 0xB0, 0x00, 0x00, 0x00, 0xD1, - 0x6D, 0x6D, 0x6F, 0x64, 0x00, 0x00, 0x03, 0x84, 0x00, 0x00, 0x00, 0x28, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x45, 0x61, - 0x73, 0x74, 0x6D, 0x61, 0x6E, 0x20, 0x4B, 0x6F, 0x64, 0x61, 0x6B, 0x20, - 0x43, 0x6F, 0x6D, 0x70, 0x61, 0x6E, 0x79, 0x2C, 0x20, 0x31, 0x39, 0x39, - 0x39, 0x2C, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2E, 0x00, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, - 0x50, 0x72, 0x6F, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x20, 0x52, 0x47, 0x42, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0xFE, 0xFF, 0x00, - 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x50, 0x00, 0x68, 0x00, 0x6F, 0x00, - 0x74, 0x00, 0x6F, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, - 0x00, 0x00, 0x00, 0x0D, 0x50, 0x72, 0x6F, 0x50, 0x68, 0x6F, 0x74, 0x6F, - 0x20, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2C, 0x63, 0x75, 0x72, 0x76, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xCD, 0x00, 0x00, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x34, - 0x00, 0x00, 0x49, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x9C, 0x00, 0x00, 0xB6, 0x3E, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0xD3, 0x2D, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, - 0x4B, 0x4F, 0x44, 0x41, 0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x07, 0xFE, 0xFF, 0x00, 0x4B, 0x00, 0x4F, 0x00, 0x44, 0x00, 0x41, - 0x00, 0x4B, 0x00, 0x00, 0x00, 0x00, 0x06, 0x4B, 0x4F, 0x44, 0x41, 0x4B, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x27, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, - 0x65, 0x20, 0x4F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x4D, 0x65, 0x64, - 0x69, 0x75, 0x6D, 0x20, 0x4D, 0x65, 0x74, 0x72, 0x69, 0x63, 0x28, 0x52, - 0x4F, 0x4D, 0x4D, 0x29, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x28, 0xFE, 0xFF, 0x00, 0x52, 0x00, 0x65, 0x00, 0x66, 0x00, - 0x65, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, - 0x20, 0x00, 0x4F, 0x00, 0x75, 0x00, 0x74, 0x00, 0x70, 0x00, 0x75, 0x00, - 0x74, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x65, 0x00, 0x64, 0x00, 0x69, 0x00, - 0x75, 0x00, 0x6D, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x65, 0x00, 0x74, 0x00, - 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x28, 0x00, 0x52, 0x00, 0x4F, 0x00, - 0x4D, 0x00, 0x4D, 0x00, 0x29, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x00, 0x27, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x20, - 0x4F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x4D, 0x65, 0x64, 0x69, 0x75, - 0x6D, 0x20, 0x4D, 0x65, 0x74, 0x72, 0x69, 0x63, 0x28, 0x52, 0x4F, 0x4D, - 0x4D, 0x29, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x6D, 0x6D, 0x6F, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, - 0x00, 0x00, 0x9D, 0x03, 0x01, 0x01, 0x01, 0x01, 0xB0, 0xCF, 0x3B, 0x80, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 - }; - - size = sizeof (kProPhotoProfileData); - data = kProPhotoProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_ProPhoto::Get () - { - - static dng_space_ProPhoto static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_GrayGamma18::dng_space_GrayGamma18 () - { - - SetMonochrome (); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_GrayGamma18::GammaFunction () const - { - - return dng_function_GammaEncode_1_8::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_GrayGamma18::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 kGamma18ProfileData [] = - { - 0x00, 0x00, 0x01, 0x98, 0x41, 0x44, 0x42, 0x45, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCF, 0x00, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00, - 0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x41, 0x44, 0x42, 0x45, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x32, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xF4, 0x00, 0x00, 0x00, 0x69, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x00, 0x14, - 0x6B, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x88, 0x00, 0x00, 0x00, 0x0E, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x31, 0x39, 0x39, 0x39, 0x20, 0x41, - 0x64, 0x6F, 0x62, 0x65, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x73, - 0x20, 0x49, 0x6E, 0x63, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x65, - 0x64, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x0F, 0x47, 0x72, 0x61, 0x79, 0x20, 0x47, 0x61, 0x6D, - 0x6D, 0x61, 0x20, 0x31, 0x2E, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xF3, 0x54, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCF, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xCD, 0x00, 0x00 - }; - - size = sizeof (kGamma18ProfileData); - data = kGamma18ProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_GrayGamma18::Get () - { - - static dng_space_GrayGamma18 static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_GrayGamma22::dng_space_GrayGamma22 () - { - - SetMonochrome (); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_space_GrayGamma22::GammaFunction () const - { - - return dng_function_GammaEncode_2_2::Get (); - - } - -/*****************************************************************************/ - -bool dng_space_GrayGamma22::ICCProfile (uint32 &size, - const uint8 *&data) const - - { - - static const uint8 kGamma22ProfileData [] = - { - 0x00, 0x00, 0x01, 0x98, 0x41, 0x44, 0x42, 0x45, 0x02, 0x10, 0x00, 0x00, - 0x6D, 0x6E, 0x74, 0x72, 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5A, 0x20, - 0x07, 0xCF, 0x00, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00, - 0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x41, 0x44, 0x42, 0x45, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, - 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x32, - 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xF4, 0x00, 0x00, 0x00, 0x69, - 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x00, 0x14, - 0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x00, 0x14, - 0x6B, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x88, 0x00, 0x00, 0x00, 0x0E, - 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6F, 0x70, 0x79, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x31, 0x39, 0x39, 0x39, 0x20, 0x41, - 0x64, 0x6F, 0x62, 0x65, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x73, - 0x20, 0x49, 0x6E, 0x63, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x65, - 0x64, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x0F, 0x47, 0x72, 0x61, 0x79, 0x20, 0x47, 0x61, 0x6D, - 0x6D, 0x61, 0x20, 0x32, 0x2E, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xF3, 0x54, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCF, - 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x33, 0x00, 0x00 - }; - - size = sizeof (kGamma22ProfileData); - data = kGamma22ProfileData; - - return true; - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_GrayGamma22::Get () - { - - static dng_space_GrayGamma22 static_space; - - return static_space; - - } - -/*****************************************************************************/ - -dng_space_fakeRGB::dng_space_fakeRGB () - { - - SetMatrixToPCS (dng_matrix_3by3 (0.6097, 0.2053, 0.1492, - 0.3111, 0.6257, 0.0632, - 0.0195, 0.0609, 0.7446)); - - } - -/*****************************************************************************/ - -const dng_color_space & dng_space_fakeRGB::Get () - { - - static dng_space_fakeRGB static_space; - - return static_space; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_color_space.h b/third_party/dng_sdk/dng_color_space.h deleted file mode 100644 index 00d0d14..0000000 --- a/third_party/dng_sdk/dng_color_space.h +++ /dev/null @@ -1,351 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_color_space.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Standard gamma functions and color spaces used within the DNG SDK. - */ - -#ifndef __dng_color_space__ -#define __dng_color_space__ - -/*****************************************************************************/ - -#include "dng_1d_function.h" -#include "dng_classes.h" -#include "dng_matrix.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief A dng_1d_function for gamma encoding in sRGB color space - -class dng_function_GammaEncode_sRGB: public dng_1d_function - { - - public: - - virtual real64 Evaluate (real64 x) const; - - virtual real64 EvaluateInverse (real64 y) const; - - static const dng_1d_function & Get (); - - }; - -/*****************************************************************************/ - -/// \brief A dng_1d_function for gamma encoding with 1.8 gamma. - -class dng_function_GammaEncode_1_8: public dng_1d_function - { - - public: - - virtual real64 Evaluate (real64 x) const; - - virtual real64 EvaluateInverse (real64 y) const; - - static const dng_1d_function & Get (); - - }; - -/*****************************************************************************/ - -/// \brief A dng_1d_function for gamma encoding with 2.2 gamma. - -class dng_function_GammaEncode_2_2: public dng_1d_function - { - - public: - - virtual real64 Evaluate (real64 x) const; - - virtual real64 EvaluateInverse (real64 y) const; - - static const dng_1d_function & Get (); - - }; - -/*****************************************************************************/ - -/// \brief An abstract color space - -class dng_color_space - { - - protected: - - dng_matrix fMatrixToPCS; - - dng_matrix fMatrixFromPCS; - - public: - - virtual ~dng_color_space (); - - /// Return a matrix which transforms source data in this color space into the - /// Profile Connection Space. - - const dng_matrix & MatrixToPCS () const - { - return fMatrixToPCS; - } - - /// Return a matrix which transforms Profile Connection Space data into this - /// color space. - - const dng_matrix & MatrixFromPCS () const - { - return fMatrixFromPCS; - } - - /// Predicate which is true if this color space is monochrome (has only a - /// single column). - - bool IsMonochrome () const - { - return fMatrixToPCS.Cols () == 1; - } - - /// Getter for the gamma function for this color space. - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns true if this color space is linear. (I.e. has gamma 1.0.) - - bool IsLinear () const - { - return GammaFunction ().IsIdentity (); - } - - /// Map an input value through this color space's encoding gamma. - - real64 GammaEncode (real64 x) const - { - return GammaFunction ().Evaluate (x); - } - - /// Map an input value through this color space's decoding gamma (inverse of - /// the encoding gamma). - - real64 GammaDecode (real64 y) const - { - return GammaFunction ().EvaluateInverse (y); - } - - /// Getter for ICC profile, if this color space has one. - /// \param size Out parameter which receives size on return. - /// \param data Receives bytes of profile. - /// \retval Returns true if this color space has an ICC profile, false otherwise. - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - protected: - - dng_color_space (); - - void SetMonochrome (); - - void SetMatrixToPCS (const dng_matrix_3by3 &M); - - }; - -/*****************************************************************************/ - -/// Singleton class for sRGB color space. - -class dng_space_sRGB: public dng_color_space - { - - protected: - - dng_space_sRGB (); - - public: - - /// Returns dng_function_GammaEncode_sRGB - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns sRGB IEC61966-2.1 ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Singleton class for AdobeRGB color space. - -class dng_space_AdobeRGB: public dng_color_space - { - - protected: - - dng_space_AdobeRGB (); - - public: - - /// Returns dng_function_GammaEncode_1_8 - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns AdobeRGB (1998) ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Singleton class for ColorMatch color space. - -class dng_space_ColorMatch: public dng_color_space - { - - protected: - - dng_space_ColorMatch (); - - public: - - /// Returns dng_function_GammaEncode_1_8 - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns ColorMatch RGB ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Singleton class for ProPhoto RGB color space. - -class dng_space_ProPhoto: public dng_color_space - { - - protected: - - dng_space_ProPhoto (); - - public: - - /// Returns dng_function_GammaEncode_1_8 - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns ProPhoto RGB ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Singleton class for gamma 1.8 grayscale color space. - -class dng_space_GrayGamma18: public dng_color_space - { - - protected: - - dng_space_GrayGamma18 (); - - public: - - /// Returns dng_function_GammaEncode_1_8 - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns simple grayscale gamma 1.8 ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Singleton class for gamma 2.2 grayscale color space. - -class dng_space_GrayGamma22: public dng_color_space - { - - protected: - - dng_space_GrayGamma22 (); - - public: - - /// Returns dng_function_GammaEncode_2_2 - - virtual const dng_1d_function & GammaFunction () const; - - /// Returns simple grayscale gamma 2.2 ICC profile - - virtual bool ICCProfile (uint32 &size, - const uint8 *&data) const; - - /// Static method for getting single global instance of this color space. - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -class dng_space_fakeRGB: public dng_color_space - { - - protected: - - dng_space_fakeRGB (); - - public: - - static const dng_color_space & Get (); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_color_spec.cpp b/third_party/dng_sdk/dng_color_spec.cpp deleted file mode 100644 index 139cdee..0000000 --- a/third_party/dng_sdk/dng_color_spec.cpp +++ /dev/null @@ -1,559 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_color_spec.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -#include "dng_color_spec.h" - -#include "dng_assertions.h" -#include "dng_camera_profile.h" -#include "dng_exceptions.h" -#include "dng_matrix.h" -#include "dng_negative.h" -#include "dng_temperature.h" -#include "dng_utils.h" -#include "dng_xy_coord.h" - -/*****************************************************************************/ - -dng_matrix_3by3 MapWhiteMatrix (const dng_xy_coord &white1, - const dng_xy_coord &white2) - { - - // Use the linearized Bradford adaptation matrix. - - dng_matrix_3by3 Mb ( 0.8951, 0.2664, -0.1614, - -0.7502, 1.7135, 0.0367, - 0.0389, -0.0685, 1.0296); - - dng_vector_3 w1 = Mb * XYtoXYZ (white1); - dng_vector_3 w2 = Mb * XYtoXYZ (white2); - - // Negative white coordinates are kind of meaningless. - - w1 [0] = Max_real64 (w1 [0], 0.0); - w1 [1] = Max_real64 (w1 [1], 0.0); - w1 [2] = Max_real64 (w1 [2], 0.0); - - w2 [0] = Max_real64 (w2 [0], 0.0); - w2 [1] = Max_real64 (w2 [1], 0.0); - w2 [2] = Max_real64 (w2 [2], 0.0); - - // Limit scaling to something reasonable. - - dng_matrix_3by3 A; - - A [0] [0] = Pin_real64 (0.1, w1 [0] > 0.0 ? w2 [0] / w1 [0] : 10.0, 10.0); - A [1] [1] = Pin_real64 (0.1, w1 [1] > 0.0 ? w2 [1] / w1 [1] : 10.0, 10.0); - A [2] [2] = Pin_real64 (0.1, w1 [2] > 0.0 ? w2 [2] / w1 [2] : 10.0, 10.0); - - dng_matrix_3by3 B = Invert (Mb) * A * Mb; - - return B; - - } - -/******************************************************************************/ - -dng_color_spec::dng_color_spec (const dng_negative &negative, - const dng_camera_profile *profile) - - : fChannels (negative.ColorChannels ()) - - , fTemperature1 (0.0) - , fTemperature2 (0.0) - - , fColorMatrix1 () - , fColorMatrix2 () - - , fForwardMatrix1 () - , fForwardMatrix2 () - - , fReductionMatrix1 () - , fReductionMatrix2 () - - , fCameraCalibration1 () - , fCameraCalibration2 () - - , fAnalogBalance () - - , fWhiteXY () - - , fCameraWhite () - , fCameraToPCS () - - , fPCStoCamera () - - { - - if (fChannels > 1) - { - - if (!profile || !profile->IsValid (fChannels)) - { - ThrowBadFormat (); - } - - if (profile->WasStubbed ()) - { - ThrowProgramError ("Using stubbed profile"); - } - - fTemperature1 = profile->CalibrationTemperature1 (); - fTemperature2 = profile->CalibrationTemperature2 (); - - fColorMatrix1 = profile->ColorMatrix1 (); - fColorMatrix2 = profile->ColorMatrix2 (); - - fForwardMatrix1 = profile->ForwardMatrix1 (); - fForwardMatrix2 = profile->ForwardMatrix2 (); - - fReductionMatrix1 = profile->ReductionMatrix1 (); - fReductionMatrix2 = profile->ReductionMatrix2 (); - - fCameraCalibration1.SetIdentity (fChannels); - fCameraCalibration2.SetIdentity (fChannels); - - if (negative. CameraCalibrationSignature () == - profile->ProfileCalibrationSignature ()) - { - - if (negative.CameraCalibration1 ().Rows () == fChannels && - negative.CameraCalibration1 ().Cols () == fChannels) - { - - fCameraCalibration1 = negative.CameraCalibration1 (); - - } - - if (negative.CameraCalibration2 ().Rows () == fChannels && - negative.CameraCalibration2 ().Cols () == fChannels) - { - - fCameraCalibration2 = negative.CameraCalibration2 (); - - } - - } - - fAnalogBalance = dng_matrix (fChannels, fChannels); - - for (uint32 j = 0; j < fChannels; j++) - { - - fAnalogBalance [j] [j] = negative.AnalogBalance (j); - - } - - dng_camera_profile::NormalizeForwardMatrix (fForwardMatrix1); - - fColorMatrix1 = fAnalogBalance * fCameraCalibration1 * fColorMatrix1; - - if (!profile->HasColorMatrix2 () || - fTemperature1 <= 0.0 || - fTemperature2 <= 0.0 || - fTemperature1 == fTemperature2) - { - - fTemperature1 = 5000.0; - fTemperature2 = 5000.0; - - fColorMatrix2 = fColorMatrix1; - fForwardMatrix2 = fForwardMatrix1; - fReductionMatrix2 = fReductionMatrix1; - fCameraCalibration2 = fCameraCalibration1; - - } - - else - { - - dng_camera_profile::NormalizeForwardMatrix (fForwardMatrix2); - - fColorMatrix2 = fAnalogBalance * fCameraCalibration2 * fColorMatrix2; - - // Swap values if temperatures are out of order. - - if (fTemperature1 > fTemperature2) - { - - real64 temp = fTemperature1; - fTemperature1 = fTemperature2; - fTemperature2 = temp; - - dng_matrix T = fColorMatrix1; - fColorMatrix1 = fColorMatrix2; - fColorMatrix2 = T; - - T = fForwardMatrix1; - fForwardMatrix1 = fForwardMatrix2; - fForwardMatrix2 = T; - - T = fReductionMatrix1; - fReductionMatrix1 = fReductionMatrix2; - fReductionMatrix2 = T; - - T = fCameraCalibration1; - fCameraCalibration1 = fCameraCalibration2; - fCameraCalibration2 = T; - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_matrix dng_color_spec::FindXYZtoCamera (const dng_xy_coord &white, - dng_matrix *forwardMatrix, - dng_matrix *reductionMatrix, - dng_matrix *cameraCalibration) - { - - // Convert to temperature/offset space. - - dng_temperature td (white); - - // Find fraction to weight the first calibration. - - real64 g; - - if (td.Temperature () <= fTemperature1) - g = 1.0; - - else if (td.Temperature () >= fTemperature2) - g = 0.0; - - else - { - - real64 invT = 1.0 / td.Temperature (); - - g = (invT - (1.0 / fTemperature2)) / - ((1.0 / fTemperature1) - (1.0 / fTemperature2)); - - } - - // Interpolate the color matrix. - - dng_matrix colorMatrix; - - if (g >= 1.0) - colorMatrix = fColorMatrix1; - - else if (g <= 0.0) - colorMatrix = fColorMatrix2; - - else - colorMatrix = (g ) * fColorMatrix1 + - (1.0 - g) * fColorMatrix2; - - // Interpolate forward matrix, if any. - - if (forwardMatrix) - { - - bool has1 = fForwardMatrix1.NotEmpty (); - bool has2 = fForwardMatrix2.NotEmpty (); - - if (has1 && has2) - { - - if (g >= 1.0) - *forwardMatrix = fForwardMatrix1; - - else if (g <= 0.0) - *forwardMatrix = fForwardMatrix2; - - else - *forwardMatrix = (g ) * fForwardMatrix1 + - (1.0 - g) * fForwardMatrix2; - - } - - else if (has1) - { - - *forwardMatrix = fForwardMatrix1; - - } - - else if (has2) - { - - *forwardMatrix = fForwardMatrix2; - - } - - else - { - - forwardMatrix->Clear (); - - } - - } - - // Interpolate reduction matrix, if any. - - if (reductionMatrix) - { - - bool has1 = fReductionMatrix1.NotEmpty (); - bool has2 = fReductionMatrix2.NotEmpty (); - - if (has1 && has2) - { - - if (g >= 1.0) - *reductionMatrix = fReductionMatrix1; - - else if (g <= 0.0) - *reductionMatrix = fReductionMatrix2; - - else - *reductionMatrix = (g ) * fReductionMatrix1 + - (1.0 - g) * fReductionMatrix2; - - } - - else if (has1) - { - - *reductionMatrix = fReductionMatrix1; - - } - - else if (has2) - { - - *reductionMatrix = fReductionMatrix2; - - } - - else - { - - reductionMatrix->Clear (); - - } - - } - - // Interpolate camera calibration matrix. - - if (cameraCalibration) - { - - if (g >= 1.0) - *cameraCalibration = fCameraCalibration1; - - else if (g <= 0.0) - *cameraCalibration = fCameraCalibration2; - - else - *cameraCalibration = (g ) * fCameraCalibration1 + - (1.0 - g) * fCameraCalibration2; - - } - - // Return the interpolated color matrix. - - return colorMatrix; - - } - -/*****************************************************************************/ - -void dng_color_spec::SetWhiteXY (const dng_xy_coord &white) - { - - fWhiteXY = white; - - // Deal with monochrome cameras. - - if (fChannels == 1) - { - - fCameraWhite.SetIdentity (1); - - fCameraToPCS = PCStoXYZ ().AsColumn (); - - return; - - } - - // Interpolate an matric values for this white point. - - dng_matrix colorMatrix; - dng_matrix forwardMatrix; - dng_matrix reductionMatrix; - dng_matrix cameraCalibration; - - colorMatrix = FindXYZtoCamera (fWhiteXY, - &forwardMatrix, - &reductionMatrix, - &cameraCalibration); - - // Find the camera white values. - - fCameraWhite = colorMatrix * XYtoXYZ (fWhiteXY); - - real64 whiteScale = 1.0 / MaxEntry (fCameraWhite); - - for (uint32 j = 0; j < fChannels; j++) - { - - // We don't support non-positive values for camera neutral values. - - fCameraWhite [j] = Pin_real64 (0.001, - whiteScale * fCameraWhite [j], - 1.0); - - } - - // Find PCS to Camera transform. Scale matrix so PCS white can just be - // reached when the first camera channel saturates - - fPCStoCamera = colorMatrix * MapWhiteMatrix (PCStoXY (), fWhiteXY); - - real64 scale = MaxEntry (fPCStoCamera * PCStoXYZ ()); - - fPCStoCamera = (1.0 / scale) * fPCStoCamera; - - // If we have a forward matrix, then just use that. - - if (forwardMatrix.NotEmpty ()) - { - - dng_matrix individualToReference = Invert (fAnalogBalance * cameraCalibration); - - dng_vector refCameraWhite = individualToReference * fCameraWhite; - - fCameraToPCS = forwardMatrix * - Invert (refCameraWhite.AsDiagonal ()) * - individualToReference; - - } - - // Else we need to use the adapt in XYZ method. - - else - { - - // Invert this PCS to camera matrix. Note that if there are more than three - // camera channels, this inversion is non-unique. - - fCameraToPCS = Invert (fPCStoCamera, reductionMatrix); - - } - - } - -/*****************************************************************************/ - -const dng_xy_coord & dng_color_spec::WhiteXY () const - { - - DNG_ASSERT (fWhiteXY.IsValid (), "Using invalid WhiteXY"); - - return fWhiteXY; - - } - -/*****************************************************************************/ - -const dng_vector & dng_color_spec::CameraWhite () const - { - - DNG_ASSERT (fCameraWhite.NotEmpty (), "Using invalid CameraWhite"); - - return fCameraWhite; - - } - -/*****************************************************************************/ - -const dng_matrix & dng_color_spec::CameraToPCS () const - { - - DNG_ASSERT (fCameraToPCS.NotEmpty (), "Using invalid CameraToPCS"); - - return fCameraToPCS; - - } - -/*****************************************************************************/ - -const dng_matrix & dng_color_spec::PCStoCamera () const - { - - DNG_ASSERT (fPCStoCamera.NotEmpty (), "Using invalid PCStoCamera"); - - return fPCStoCamera; - - } - -/*****************************************************************************/ - -dng_xy_coord dng_color_spec::NeutralToXY (const dng_vector &neutral) - { - - const uint32 kMaxPasses = 30; - - if (fChannels == 1) - { - - return PCStoXY (); - - } - - dng_xy_coord last = D50_xy_coord (); - - for (uint32 pass = 0; pass < kMaxPasses; pass++) - { - - dng_matrix xyzToCamera = FindXYZtoCamera (last); - - dng_xy_coord next = XYZtoXY (Invert (xyzToCamera) * neutral); - - if (Abs_real64 (next.x - last.x) + - Abs_real64 (next.y - last.y) < 0.0000001) - { - - return next; - - } - - // If we reach the limit without converging, we are most likely - // in a two value oscillation. So take the average of the last - // two estimates and give up. - - if (pass == kMaxPasses - 1) - { - - next.x = (last.x + next.x) * 0.5; - next.y = (last.y + next.y) * 0.5; - - } - - last = next; - - } - - return last; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_color_spec.h b/third_party/dng_sdk/dng_color_spec.h deleted file mode 100644 index 0d06dde..0000000 --- a/third_party/dng_sdk/dng_color_spec.h +++ /dev/null @@ -1,146 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_color_spec.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Class for holding a specific color transform. -*/ - -#ifndef __dng_color_spec__ -#define __dng_color_spec__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_matrix.h" -#include "dng_types.h" -#include "dng_xy_coord.h" - -/*****************************************************************************/ - -/// \brief Compute a 3x3 matrix which maps colors from white point white1 to -/// white point white2 -/// -/// Uses linearized Bradford adaptation matrix to compute a mapping from -/// colors measured with one white point (white1) to another (white2). - -dng_matrix_3by3 MapWhiteMatrix (const dng_xy_coord &white1, - const dng_xy_coord &white2); - -/*****************************************************************************/ - -/// Color transform taking into account white point and camera calibration and -/// individual calibration from DNG negative. - -class dng_color_spec - { - - private: - - uint32 fChannels; - - real64 fTemperature1; - real64 fTemperature2; - - dng_matrix fColorMatrix1; - dng_matrix fColorMatrix2; - - dng_matrix fForwardMatrix1; - dng_matrix fForwardMatrix2; - - dng_matrix fReductionMatrix1; - dng_matrix fReductionMatrix2; - - dng_matrix fCameraCalibration1; - dng_matrix fCameraCalibration2; - - dng_matrix fAnalogBalance; - - dng_xy_coord fWhiteXY; - - dng_vector fCameraWhite; - dng_matrix fCameraToPCS; - - dng_matrix fPCStoCamera; - - public: - - /// Read calibration info from DNG negative and construct a - /// dng_color_spec. - - dng_color_spec (const dng_negative &negative, - const dng_camera_profile *profile); - - virtual ~dng_color_spec () - { - } - - /// Number of channels used for this color transform. Three - /// for most cameras. - - uint32 Channels () const - { - return fChannels; - } - - /// Setter for white point. Value is as XY colorspace coordinate. - /// \param white White point to set as an XY value. - - void SetWhiteXY (const dng_xy_coord &white); - - /// Getter for white point. Value is as XY colorspace coordinate. - /// \retval XY value of white point. - - const dng_xy_coord & WhiteXY () const; - - /// Return white point in camera native color coordinates. - /// \retval A dng_vector with components ranging from 0.0 to 1.0 - /// that is normalized such that one component is equal to 1.0 . - - const dng_vector & CameraWhite () const; - - /// Getter for camera to Profile Connection Space color transform. - /// \retval A transform that takes into account all camera calibration - /// transforms and white point. - - const dng_matrix & CameraToPCS () const; - - /// Getter for Profile Connection Space to camera color transform. - /// \retval A transform that takes into account all camera calibration - /// transforms and white point. - - const dng_matrix & PCStoCamera () const; - - /// Return the XY value to use for SetWhiteXY for a given camera color - /// space coordinate as the white point. - /// \param neutral A camera color space value to use for white point. - /// Components range from 0.0 to 1.0 and should be normalized such that - /// the largest value is 1.0 . - /// \retval White point in XY space that makes neutral map to this - /// XY value as closely as possible. - - dng_xy_coord NeutralToXY (const dng_vector &neutral); - - private: - - dng_matrix FindXYZtoCamera (const dng_xy_coord &white, - dng_matrix *forwardMatrix = NULL, - dng_matrix *reductionMatrix = NULL, - dng_matrix *cameraCalibration = NULL); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_date_time.cpp b/third_party/dng_sdk/dng_date_time.cpp deleted file mode 100644 index e5d6423..0000000 --- a/third_party/dng_sdk/dng_date_time.cpp +++ /dev/null @@ -1,959 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_date_time.cpp#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_date_time.h" - -#include "dng_exceptions.h" -#include "dng_mutex.h" -#include "dng_stream.h" -#include "dng_string.h" -#include "dng_utils.h" - -#include - -#if qMacOS -#include -#endif - -#if qWinOS -#include -#endif - -/******************************************************************************/ - -// MWG says don't use fake time zones in XMP, but there is some -// old software that requires them to work correctly. - -bool gDNGUseFakeTimeZonesInXMP = false; - -/******************************************************************************/ - -dng_date_time::dng_date_time () - - : fYear (0) - , fMonth (0) - , fDay (0) - , fHour (0) - , fMinute (0) - , fSecond (0) - - { - - } - -/******************************************************************************/ - -dng_date_time::dng_date_time (uint32 year, - uint32 month, - uint32 day, - uint32 hour, - uint32 minute, - uint32 second) - - : fYear (year) - , fMonth (month) - , fDay (day) - , fHour (hour) - , fMinute (minute) - , fSecond (second) - - { - - } - -/******************************************************************************/ - -bool dng_date_time::IsValid () const - { - - return fYear >= 1 && fYear <= 9999 && - fMonth >= 1 && fMonth <= 12 && - fDay >= 1 && fDay <= 31 && - fHour <= 23 && - fMinute <= 59 && - fSecond <= 59; - - } - -/*****************************************************************************/ - -void dng_date_time::Clear () - { - - *this = dng_date_time (); - - } - -/*****************************************************************************/ - -static uint32 DateTimeParseU32 (const char *&s) - { - - uint32 x = 0; - - while (*s == ' ' || *s == ':') - s++; - - while (*s >= '0' && *s <= '9') - { - x = x * 10 + (uint32) (*(s++) - '0'); - } - - return x; - - } - -/*****************************************************************************/ - -bool dng_date_time::Parse (const char *s) - { - - fYear = DateTimeParseU32 (s); - fMonth = DateTimeParseU32 (s); - fDay = DateTimeParseU32 (s); - fHour = DateTimeParseU32 (s); - fMinute = DateTimeParseU32 (s); - fSecond = DateTimeParseU32 (s); - - return IsValid (); - - } - -/*****************************************************************************/ - -dng_string dng_time_zone::Encode_ISO_8601 () const - { - - dng_string result; - - if (IsValid ()) - { - - if (OffsetMinutes () == 0) - { - - result.Set ("Z"); - - } - - else - { - - char s [64]; - - int offset = OffsetMinutes (); - - if (offset > 0) - { - - sprintf (s, "+%02d:%02d", offset / 60, offset % 60); - - } - - else - { - - offset = -offset; - - sprintf (s, "-%02d:%02d", offset / 60, offset % 60); - - } - - result.Set (s); - - } - - } - - return result; - - } - -/*****************************************************************************/ - -dng_date_time_info::dng_date_time_info () - - : fDateOnly (true) - , fDateTime () - , fSubseconds () - , fTimeZone () - - { - - } - -/*****************************************************************************/ - -bool dng_date_time_info::IsValid () const - { - - return fDateTime.IsValid (); - - } - -/*****************************************************************************/ - -void dng_date_time_info::SetDate (uint32 year, - uint32 month, - uint32 day) - { - - fDateTime.fYear = year; - fDateTime.fMonth = month; - fDateTime.fDay = day; - - } - -/*****************************************************************************/ - -void dng_date_time_info::SetTime (uint32 hour, - uint32 minute, - uint32 second) - { - - fDateOnly = false; - - fDateTime.fHour = hour; - fDateTime.fMinute = minute; - fDateTime.fSecond = second; - - } - -/*****************************************************************************/ - -void dng_date_time_info::Decode_ISO_8601 (const char *s) - { - - Clear (); - - uint32 len = (uint32) strlen (s); - - if (!len) - { - return; - } - - unsigned year = 0; - unsigned month = 0; - unsigned day = 0; - - if (sscanf (s, - "%u-%u-%u", - &year, - &month, - &day) != 3) - { - return; - } - - SetDate ((uint32) year, - (uint32) month, - (uint32) day); - - if (fDateTime.NotValid ()) - { - Clear (); - return; - } - - for (uint32 j = 0; j < len; j++) - { - - if (s [j] == 'T') - { - - unsigned hour = 0; - unsigned minute = 0; - unsigned second = 0; - - int items = sscanf (s + j + 1, - "%u:%u:%u", - &hour, - &minute, - &second); - - if (items >= 2 && items <= 3) - { - - SetTime ((uint32) hour, - (uint32) minute, - (uint32) second); - - if (fDateTime.NotValid ()) - { - Clear (); - return; - } - - if (items == 3) - { - - for (uint32 k = j + 1; k < len; k++) - { - - if (s [k] == '.') - { - - while (++k < len && s [k] >= '0' && s [k] <= '9') - { - - char ss [2]; - - ss [0] = s [k]; - ss [1] = 0; - - fSubseconds.Append (ss); - - } - - break; - - } - - } - - } - - for (uint32 k = j + 1; k < len; k++) - { - - if (s [k] == 'Z') - { - - fTimeZone.SetOffsetMinutes (0); - - break; - - } - - if (s [k] == '+' || s [k] == '-') - { - - int32 sign = (s [k] == '-' ? -1 : 1); - - unsigned tzhour = 0; - unsigned tzmin = 0; - - if (sscanf (s + k + 1, - "%u:%u", - &tzhour, - &tzmin) > 0) - { - - fTimeZone.SetOffsetMinutes (sign * (tzhour * 60 + tzmin)); - - } - - break; - - } - - } - - } - - break; - - } - - } - - } - -/*****************************************************************************/ - -dng_string dng_date_time_info::Encode_ISO_8601 () const - { - - dng_string result; - - if (IsValid ()) - { - - char s [256]; - - sprintf (s, - "%04u-%02u-%02u", - (unsigned) fDateTime.fYear, - (unsigned) fDateTime.fMonth, - (unsigned) fDateTime.fDay); - - result.Set (s); - - if (!fDateOnly) - { - - sprintf (s, - "T%02u:%02u:%02u", - (unsigned) fDateTime.fHour, - (unsigned) fDateTime.fMinute, - (unsigned) fDateTime.fSecond); - - result.Append (s); - - if (fSubseconds.NotEmpty ()) - { - - bool subsecondsValid = true; - - uint32 len = fSubseconds.Length (); - - for (uint32 index = 0; index < len; index++) - { - - if (fSubseconds.Get () [index] < '0' || - fSubseconds.Get () [index] > '9') - { - subsecondsValid = false; - break; - } - - } - - if (subsecondsValid) - { - result.Append ("."); - result.Append (fSubseconds.Get ()); - } - - } - - if (gDNGUseFakeTimeZonesInXMP) - { - - // Kludge: Early versions of the XMP toolkit assume Zulu time - // if the time zone is missing. It is safer for fill in the - // local time zone. - - dng_time_zone tempZone = fTimeZone; - - if (tempZone.NotValid ()) - { - tempZone = LocalTimeZone (fDateTime); - } - - result.Append (tempZone.Encode_ISO_8601 ().Get ()); - - } - - else - { - - // MWG: Now we don't fill in the local time zone. So only - // add the time zone if it is known and valid. - - if (fTimeZone.IsValid ()) - { - result.Append (fTimeZone.Encode_ISO_8601 ().Get ()); - } - - } - - } - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_date_time_info::Decode_IPTC_Date (const char *s) - { - - if (strlen (s) == 8) - { - - unsigned year = 0; - unsigned month = 0; - unsigned day = 0; - - if (sscanf (s, - "%4u%2u%2u", - &year, - &month, - &day) == 3) - { - - SetDate ((uint32) year, - (uint32) month, - (uint32) day); - - } - - } - - } - -/*****************************************************************************/ - -dng_string dng_date_time_info::Encode_IPTC_Date () const - { - - dng_string result; - - if (IsValid ()) - { - - char s [64]; - - sprintf (s, - "%04u%02u%02u", - (unsigned) fDateTime.fYear, - (unsigned) fDateTime.fMonth, - (unsigned) fDateTime.fDay); - - result.Set (s); - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_date_time_info::Decode_IPTC_Time (const char *s) - { - - if (strlen (s) == 11) - { - - char time [12]; - - memcpy (time, s, sizeof (time)); - - if (time [6] == '+' || - time [6] == '-') - { - - int tzsign = (time [6] == '-') ? -1 : 1; - - time [6] = 0; - - unsigned hour = 0; - unsigned minute = 0; - unsigned second = 0; - unsigned tzhour = 0; - unsigned tzmin = 0; - - if (sscanf (time, - "%2u%2u%2u", - &hour, - &minute, - &second) == 3 && - sscanf (time + 7, - "%2u%2u", - &tzhour, - &tzmin) == 2) - { - - dng_time_zone zone; - - zone.SetOffsetMinutes (tzsign * (tzhour * 60 + tzmin)); - - if (zone.IsValid ()) - { - - SetTime ((uint32) hour, - (uint32) minute, - (uint32) second); - - SetZone (zone); - - } - - } - - } - - } - - else if (strlen (s) == 6) - { - - unsigned hour = 0; - unsigned minute = 0; - unsigned second = 0; - - if (sscanf (s, - "%2u%2u%2u", - &hour, - &minute, - &second) == 3) - { - - SetTime ((uint32) hour, - (uint32) minute, - (uint32) second); - - } - - } - - else if (strlen (s) == 4) - { - - unsigned hour = 0; - unsigned minute = 0; - - if (sscanf (s, - "%2u%2u", - &hour, - &minute) == 2) - { - - SetTime ((uint32) hour, - (uint32) minute, - 0); - - } - - } - - } - -/*****************************************************************************/ - -dng_string dng_date_time_info::Encode_IPTC_Time () const - { - - dng_string result; - - if (IsValid () && !fDateOnly) - { - - char s [64]; - - if (fTimeZone.IsValid ()) - { - - sprintf (s, - "%02u%02u%02u%c%02u%02u", - (unsigned) fDateTime.fHour, - (unsigned) fDateTime.fMinute, - (unsigned) fDateTime.fSecond, - (int) (fTimeZone.OffsetMinutes () >= 0 ? '+' : '-'), - (unsigned) (Abs_int32 (fTimeZone.OffsetMinutes ()) / 60), - (unsigned) (Abs_int32 (fTimeZone.OffsetMinutes ()) % 60)); - - } - - else - { - - sprintf (s, - "%02u%02u%02u", - (unsigned) fDateTime.fHour, - (unsigned) fDateTime.fMinute, - (unsigned) fDateTime.fSecond); - - } - - result.Set (s); - - } - - return result; - - } - -/*****************************************************************************/ - -static dng_mutex gDateTimeMutex ("gDateTimeMutex"); - -/*****************************************************************************/ - -void CurrentDateTimeAndZone (dng_date_time_info &info) - { - - time_t sec; - - time (&sec); - - tm t; - tm zt; - - { - - dng_lock_mutex lock (&gDateTimeMutex); - - t = *localtime (&sec); - zt = *gmtime (&sec); - - } - - dng_date_time dt; - - dt.fYear = t.tm_year + 1900; - dt.fMonth = t.tm_mon + 1; - dt.fDay = t.tm_mday; - dt.fHour = t.tm_hour; - dt.fMinute = t.tm_min; - dt.fSecond = t.tm_sec; - - info.SetDateTime (dt); - - int tzHour = t.tm_hour - zt.tm_hour; - int tzMin = t.tm_min - zt.tm_min; - - bool zonePositive = (t.tm_year > zt.tm_year) || - (t.tm_year == zt.tm_year && t.tm_yday > zt.tm_yday) || - (t.tm_year == zt.tm_year && t.tm_yday == zt.tm_yday && tzHour > 0) || - (t.tm_year == zt.tm_year && t.tm_yday == zt.tm_yday && tzHour == 0 && tzMin >= 0); - - tzMin += tzHour * 60; - - if (zonePositive) - { - - while (tzMin < 0) - tzMin += 24 * 60; - - } - - else - { - - while (tzMin > 0) - tzMin -= 24 * 60; - - } - - dng_time_zone zone; - - zone.SetOffsetMinutes (tzMin); - - info.SetZone (zone); - - } - -/*****************************************************************************/ - -void DecodeUnixTime (uint32 unixTime, dng_date_time &dt) - { - - time_t sec = (time_t) unixTime; - - tm t; - - { - - dng_lock_mutex lock (&gDateTimeMutex); - - #if qMacOS && !defined(__MACH__) - - // Macintosh CFM stores time in local time zone. - - tm *tp = localtime (&sec); - - #else - - // Macintosh Mach-O and Windows stores time in Zulu time. - - tm *tp = gmtime (&sec); - - #endif - - if (!tp) - { - dt.Clear (); - return; - } - - t = *tp; - - } - - dt.fYear = t.tm_year + 1900; - dt.fMonth = t.tm_mon + 1; - dt.fDay = t.tm_mday; - dt.fHour = t.tm_hour; - dt.fMinute = t.tm_min; - dt.fSecond = t.tm_sec; - - } - -/*****************************************************************************/ - -dng_time_zone LocalTimeZone (const dng_date_time &dt) - { - - dng_time_zone result; - - if (dt.IsValid ()) - { - - #if qMacOS - - CFTimeZoneRef zoneRef = CFTimeZoneCopyDefault (); - - if (zoneRef) - { - - CFGregorianDate gregDate; - - gregDate.year = dt.fYear; - gregDate.month = (SInt8) dt.fMonth; - gregDate.day = (SInt8) dt.fDay; - gregDate.hour = (SInt8) dt.fHour; - gregDate.minute = (SInt8) dt.fMinute; - gregDate.second = (SInt8) dt.fSecond; - - CFAbsoluteTime absTime = CFGregorianDateGetAbsoluteTime (gregDate, zoneRef); - - CFTimeInterval secondsDelta = CFTimeZoneGetSecondsFromGMT (zoneRef, absTime); - - CFRelease (zoneRef); - - result.SetOffsetSeconds (Round_int32 (secondsDelta)); - - if (result.IsValid ()) - { - return result; - } - - } - - #endif - - #if qWinOS - - if (GetTimeZoneInformation != NULL && - SystemTimeToTzSpecificLocalTime != NULL && - SystemTimeToFileTime != NULL) - { - - TIME_ZONE_INFORMATION tzInfo; - - DWORD x = GetTimeZoneInformation (&tzInfo); - - SYSTEMTIME localST; - - memset (&localST, 0, sizeof (localST)); - - localST.wYear = (WORD) dt.fYear; - localST.wMonth = (WORD) dt.fMonth; - localST.wDay = (WORD) dt.fDay; - localST.wHour = (WORD) dt.fHour; - localST.wMinute = (WORD) dt.fMinute; - localST.wSecond = (WORD) dt.fSecond; - - SYSTEMTIME utcST; - - if (TzSpecificLocalTimeToSystemTime (&tzInfo, &localST, &utcST)) - { - - FILETIME localFT; - FILETIME utcFT; - - (void) SystemTimeToFileTime (&localST, &localFT); - (void) SystemTimeToFileTime (&utcST , &utcFT ); - - uint64 time1 = (((uint64) localFT.dwHighDateTime) << 32) + localFT.dwLowDateTime; - uint64 time2 = (((uint64) utcFT .dwHighDateTime) << 32) + utcFT .dwLowDateTime; - - // FILETIMEs are in units to 100 ns. Convert to seconds. - - int64 time1Sec = time1 / 10000000; - int64 time2Sec = time2 / 10000000; - - int32 delta = (int32) (time1Sec - time2Sec); - - result.SetOffsetSeconds (delta); - - if (result.IsValid ()) - { - return result; - } - - } - - } - - #endif - - } - - // Figure out local time zone. - - dng_date_time_info current_info; - - CurrentDateTimeAndZone (current_info); - - result = current_info.TimeZone (); - - return result; - - } - -/*****************************************************************************/ - -dng_date_time_storage_info::dng_date_time_storage_info () - - : fOffset (kDNGStreamInvalidOffset ) - , fFormat (dng_date_time_format_unknown) - - { - - } - -/*****************************************************************************/ - -dng_date_time_storage_info::dng_date_time_storage_info (uint64 offset, - dng_date_time_format format) - - : fOffset (offset) - , fFormat (format) - - { - - } - -/*****************************************************************************/ - -bool dng_date_time_storage_info::IsValid () const - { - - return fOffset != kDNGStreamInvalidOffset; - - } - -/*****************************************************************************/ - -uint64 dng_date_time_storage_info::Offset () const - { - - if (!IsValid ()) - ThrowProgramError (); - - return fOffset; - - } - -/*****************************************************************************/ - -dng_date_time_format dng_date_time_storage_info::Format () const - { - - if (!IsValid ()) - ThrowProgramError (); - - return fFormat; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_date_time.h b/third_party/dng_sdk/dng_date_time.h deleted file mode 100644 index 3f923f2..0000000 --- a/third_party/dng_sdk/dng_date_time.h +++ /dev/null @@ -1,385 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_date_time.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Functions and classes for working with dates and times in DNG files. - */ - -/*****************************************************************************/ - -#ifndef __dng_date_time__ -#define __dng_date_time__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_string.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Class for holding a date/time and converting to and from relevant -/// date/time formats - -class dng_date_time - { - - public: - - uint32 fYear; - uint32 fMonth; - uint32 fDay; - uint32 fHour; - uint32 fMinute; - uint32 fSecond; - - public: - - /// Construct an invalid date/time - - dng_date_time (); - - /// Construct a date/time with specific values. - /// \param year Year to use as actual integer value, such as 2006. - /// \param month Month to use from 1 - 12, where 1 is January. - /// \param day Day of month to use from 1 -31, where 1 is the first. - /// \param hour Hour of day to use from 0 - 23, where 0 is midnight. - /// \param minute Minute of hour to use from 0 - 59. - /// \param second Second of minute to use from 0 - 59. - - dng_date_time (uint32 year, - uint32 month, - uint32 day, - uint32 hour, - uint32 minute, - uint32 second); - - /// Predicate to determine if a date is valid. - /// \retval true if all fields are within range. - - bool IsValid () const; - - /// Predicate to determine if a date is invalid. - /// \retval true if any field is out of range. - - bool NotValid () const - { - return !IsValid (); - } - - /// Equal operator. - - bool operator== (const dng_date_time &dt) const - { - return fYear == dt.fYear && - fMonth == dt.fMonth && - fDay == dt.fDay && - fHour == dt.fHour && - fMinute == dt.fMinute && - fSecond == dt.fSecond; - } - - // Not-equal operator. - - bool operator!= (const dng_date_time &dt) const - { - return !(*this == dt); - } - - /// Set date to an invalid value. - - void Clear (); - - /// Parse an EXIF format date string. - /// \param s Input date string to parse. - /// \retval true if date was parsed successfully and date is valid. - - bool Parse (const char *s); - - }; - -/*****************************************************************************/ - -/// \brief Class for holding a time zone. - -class dng_time_zone - { - - private: - - enum - { - - kMaxOffsetHours = 15, - kMinOffsetHours = -kMaxOffsetHours, - - kMaxOffsetMinutes = kMaxOffsetHours * 60, - kMinOffsetMinutes = kMinOffsetHours * 60, - - kInvalidOffset = kMinOffsetMinutes - 1 - - }; - - // Offset from GMT in minutes. Positive numbers are - // ahead of GMT, negative number are behind GMT. - - int32 fOffsetMinutes; - - public: - - dng_time_zone () - : fOffsetMinutes (kInvalidOffset) - { - } - - void Clear () - { - fOffsetMinutes = kInvalidOffset; - } - - void SetOffsetHours (int32 offset) - { - fOffsetMinutes = offset * 60; - } - - void SetOffsetMinutes (int32 offset) - { - fOffsetMinutes = offset; - } - - void SetOffsetSeconds (int32 offset) - { - fOffsetMinutes = (offset > 0) ? ((offset + 30) / 60) - : ((offset - 30) / 60); - } - - bool IsValid () const - { - return fOffsetMinutes >= kMinOffsetMinutes && - fOffsetMinutes <= kMaxOffsetMinutes; - } - - bool NotValid () const - { - return !IsValid (); - } - - int32 OffsetMinutes () const - { - return fOffsetMinutes; - } - - bool IsExactHourOffset () const - { - return IsValid () && ((fOffsetMinutes % 60) == 0); - } - - int32 ExactHourOffset () const - { - return fOffsetMinutes / 60; - } - - dng_string Encode_ISO_8601 () const; - - }; - -/*****************************************************************************/ - -/// \brief Class for holding complete data/time/zone information. - -class dng_date_time_info - { - - private: - - // Is only the date valid and not the time? - - bool fDateOnly; - - // Date and time. - - dng_date_time fDateTime; - - // Subseconds string (stored in a separate tag in EXIF). - - dng_string fSubseconds; - - // Time zone, if known. - - dng_time_zone fTimeZone; - - public: - - dng_date_time_info (); - - bool IsValid () const; - - bool NotValid () const - { - return !IsValid (); - } - - void Clear () - { - *this = dng_date_time_info (); - } - - const dng_date_time & DateTime () const - { - return fDateTime; - } - - void SetDateTime (const dng_date_time &dt) - { - fDateOnly = false; - fDateTime = dt; - } - - const dng_string & Subseconds () const - { - return fSubseconds; - } - - void SetSubseconds (const dng_string &s) - { - fSubseconds = s; - } - - const dng_time_zone & TimeZone () const - { - return fTimeZone; - } - - void SetZone (const dng_time_zone &zone) - { - fTimeZone = zone; - } - - void Decode_ISO_8601 (const char *s); - - dng_string Encode_ISO_8601 () const; - - void Decode_IPTC_Date (const char *s); - - dng_string Encode_IPTC_Date () const; - - void Decode_IPTC_Time (const char *s); - - dng_string Encode_IPTC_Time () const; - - private: - - void SetDate (uint32 year, - uint32 month, - uint32 day); - - void SetTime (uint32 hour, - uint32 minute, - uint32 second); - - }; - -/*****************************************************************************/ - -/// Get the current date/time and timezone. -/// \param info Receives current data/time/zone. - -void CurrentDateTimeAndZone (dng_date_time_info &info); - -/*****************************************************************************/ - -/// Convert UNIX "seconds since Jan 1, 1970" time to a dng_date_time - -void DecodeUnixTime (uint32 unixTime, dng_date_time &dt); - -/*****************************************************************************/ - -/// Return timezone of current location at a given date. -/// \param dt Date at which to compute timezone difference. (For example, used -/// to determine Daylight Savings, etc.) -/// \retval Time zone for date/time dt. - -dng_time_zone LocalTimeZone (const dng_date_time &dt); - -/*****************************************************************************/ - -/// Tag to encode date represenation format - -enum dng_date_time_format - { - dng_date_time_format_unknown = 0, /// Date format not known - dng_date_time_format_exif = 1, /// EXIF date string - dng_date_time_format_unix_little_endian = 2, /// 32-bit UNIX time as 4-byte little endian - dng_date_time_format_unix_big_endian = 3 /// 32-bit UNIX time as 4-byte big endian - }; - -/*****************************************************************************/ - -/// \brief Store file offset from which date was read. -/// -/// Used internally by Adobe to update date in original file. -/// \warning Use at your own risk. - -class dng_date_time_storage_info - { - - private: - - uint64 fOffset; - - dng_date_time_format fFormat; - - public: - - /// The default constructor initializes to an invalid state. - - dng_date_time_storage_info (); - - /// Construct with file offset and date format. - - dng_date_time_storage_info (uint64 offset, - dng_date_time_format format); - - /// Predicate to determine if an offset is valid. - /// \retval true if offset is valid. - - bool IsValid () const; - - // The accessors throw if the data is not valid. - - /// Getter for offset in file. - /// \exception dng_exception with fErrorCode equal to dng_error_unknown - /// if offset is not valid. - - uint64 Offset () const; - - /// Get for format date was originally stored in file. Throws a - /// dng_error_unknown exception if offset is invalid. - /// \exception dng_exception with fErrorCode equal to dng_error_unknown - /// if offset is not valid. - - dng_date_time_format Format () const; - - }; - -/*****************************************************************************/ - -// Kludge: Global boolean to turn on fake time zones in XMP for old software. - -extern bool gDNGUseFakeTimeZonesInXMP; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_errors.h b/third_party/dng_sdk/dng_errors.h deleted file mode 100644 index 44feb5a..0000000 --- a/third_party/dng_sdk/dng_errors.h +++ /dev/null @@ -1,58 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_errors.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Error code values. - */ - -/*****************************************************************************/ - -#ifndef __dng_errors__ -#define __dng_errors__ - -/*****************************************************************************/ - -#include "dng_types.h" - -/*****************************************************************************/ - -/// Type for all errors used in DNG SDK. Generally held inside a dng_exception. - -typedef int32 dng_error_code; - -enum - { - dng_error_none = 0, //!< No error. Success. - dng_error_unknown = 100000, //!< Logic or program error or other unclassifiable error. - dng_error_not_yet_implemented, //!< Functionality requested is not yet implemented. - dng_error_silent, //!< An error which should not be signalled to user. - dng_error_user_canceled, //!< Processing stopped by user (or host application) request - dng_error_host_insufficient, //!< Necessary host functionality is not present. - dng_error_memory, //!< Out of memory. - dng_error_bad_format, //!< File format is not valid. - dng_error_matrix_math, //!< Matrix has wrong shape, is badly conditioned, or similar problem. - dng_error_open_file, //!< Could not open file. - dng_error_read_file, //!< Error reading file. - dng_error_write_file, //!< Error writing file. - dng_error_end_of_file, //!< Unexpected end of file. - dng_error_file_is_damaged, //!< File is damaged in some way. - dng_error_image_too_big_dng, //!< Image is too big to save as DNG. - dng_error_image_too_big_tiff, //!< Image is too big to save as TIFF. - dng_error_unsupported_dng //!< DNG version is unsupported. - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_exceptions.cpp b/third_party/dng_sdk/dng_exceptions.cpp deleted file mode 100644 index 6ca4ece..0000000 --- a/third_party/dng_sdk/dng_exceptions.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_exceptions.cpp#2 $ */ -/* $DateTime: 2012/06/06 12:08:58 $ */ -/* $Change: 833617 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_exceptions.h" - -#include "dng_flags.h" -#include "dng_globals.h" - -/*****************************************************************************/ - -#ifndef qDNGReportErrors -// assuming this isn't enable on Win, because it's using printf, but an app can redirect that to console -#define qDNGReportErrors ((qDNGDebug && qMacOS) || qDNGValidate) -#endif - -/*****************************************************************************/ - -void ReportWarning (const char *message, - const char *sub_message) - { - - - #if qDNGReportErrors - - if (sub_message) - fprintf (stderr, "*** Warning: %s (%s) ***\n", message, sub_message); - else - fprintf (stderr, "*** Warning: %s ***\n", message); - - #else - - (void) message; - (void) sub_message; - - #endif - - } - -/*****************************************************************************/ - -void ReportError (const char *message, - const char *sub_message) - { - - #if qDNGReportErrors - - if (sub_message) - fprintf (stderr, "*** Error: %s (%s) ***\n", message, sub_message); - else - fprintf (stderr, "*** Error: %s ***\n", message); - - #else - - (void) message; - (void) sub_message; - - #endif - - } - -/*****************************************************************************/ - -void Throw_dng_error (dng_error_code err, - const char *message, - const char *sub_message, - bool silent) - { - - #if qDNGReportErrors - - { - - if (!message) - { - - switch (err) - { - - case dng_error_none: - case dng_error_silent: - case dng_error_user_canceled: - { - break; - } - - case dng_error_not_yet_implemented: - { - message = "Not yet implemented"; - break; - } - - case dng_error_host_insufficient: - { - message = "Host insufficient"; - break; - } - - case dng_error_memory: - { - message = "Unable to allocate memory"; - break; - } - - case dng_error_bad_format: - { - message = "File format is invalid"; - break; - } - - case dng_error_matrix_math: - { - message = "Matrix math error"; - break; - } - - case dng_error_open_file: - { - message = "Unable to open file"; - break; - } - - case dng_error_read_file: - { - message = "File read error"; - break; - } - - case dng_error_write_file: - { - message = "File write error"; - break; - } - - case dng_error_end_of_file: - { - message = "Unexpected end-of-file"; - break; - } - - case dng_error_file_is_damaged: - { - message = "File is damaged"; - break; - } - - case dng_error_image_too_big_dng: - { - message = "Image is too big to save as DNG"; - break; - } - - case dng_error_image_too_big_tiff: - { - message = "Image is too big to save as TIFF"; - break; - } - - case dng_error_unsupported_dng: - { - message = "DNG version is unsupported"; - break; - } - - default: - { - message = "Unknown error"; - break; - } - - } - - } - - if (message && !silent) - { - ReportError (message, sub_message); - } - - } - - #else - - (void) message; - (void) sub_message; - (void) silent; - - #endif - - throw dng_exception (err); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_exceptions.h b/third_party/dng_sdk/dng_exceptions.h deleted file mode 100644 index 7bfb1cd..0000000 --- a/third_party/dng_sdk/dng_exceptions.h +++ /dev/null @@ -1,301 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_exceptions.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * C++ exception support for DNG SDK. -*/ - -/*****************************************************************************/ - -#ifndef __dng_exceptions__ -#define __dng_exceptions__ - -/*****************************************************************************/ - -#include "dng_errors.h" -#include "dng_flags.h" - -/*****************************************************************************/ - -/// Display a warning message. Note that this may just eat the message. - -void ReportWarning (const char *message, - const char *sub_message = NULL); - -/*****************************************************************************/ - -/// Display an error message. Note that this may just eat the message. - -void ReportError (const char *message, - const char *sub_message = NULL); - -/*****************************************************************************/ - -/// \brief All exceptions thrown by the DNG SDK use this exception class. - -class dng_exception - { - - private: - - dng_error_code fErrorCode; - - public: - - /// Construct an exception representing the given error code. - /// \param code Error code this exception is for. - - dng_exception (dng_error_code code) - - : fErrorCode (code) - - { - } - - virtual ~dng_exception () - { - } - - /// Getter for error code of this exception - /// \retval The error code of this exception. - - dng_error_code ErrorCode () const - { - return fErrorCode; - } - - }; - -/******************************************************************************/ - -/// \brief Throw an exception based on an arbitrary error code. - -void Throw_dng_error (dng_error_code err, - const char * message = NULL, - const char * sub_message = NULL, - bool silent = false); - -/******************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code if -/// error_code is not dng_error_none . - -inline void Fail_dng_error (dng_error_code err) - { - - if (err != dng_error_none) - { - - Throw_dng_error (err); - - } - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_unknown . - -inline void ThrowProgramError (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_unknown, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_not_yet_implemented . - -inline void ThrowNotYetImplemented (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_not_yet_implemented, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_silent . - -inline void ThrowSilentError () - { - - Throw_dng_error (dng_error_silent); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_user_canceled . - -inline void ThrowUserCanceled () - { - - Throw_dng_error (dng_error_user_canceled); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_host_insufficient . - -inline void ThrowHostInsufficient (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_host_insufficient, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_memory . - -inline void ThrowMemoryFull (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_memory, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_bad_format . - -inline void ThrowBadFormat (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_bad_format, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_matrix_math . - -inline void ThrowMatrixMath (const char * sub_message = NULL) - { - - Throw_dng_error (dng_error_matrix_math, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_open_file . - -inline void ThrowOpenFile (const char * sub_message = NULL, bool silent = false) - { - - Throw_dng_error (dng_error_open_file, NULL, sub_message, silent); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_read_file . - -inline void ThrowReadFile (const char *sub_message = NULL) - { - - Throw_dng_error (dng_error_read_file, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_write_file . - -inline void ThrowWriteFile (const char *sub_message = NULL) - { - - Throw_dng_error (dng_error_write_file, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_end_of_file . - -inline void ThrowEndOfFile (const char *sub_message = NULL) - { - - Throw_dng_error (dng_error_end_of_file, NULL, sub_message); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_file_is_damaged . - -inline void ThrowFileIsDamaged () - { - - Throw_dng_error (dng_error_file_is_damaged); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_image_too_big_dng . - -inline void ThrowImageTooBigDNG () - { - - Throw_dng_error (dng_error_image_too_big_dng); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_image_too_big_tiff . - -inline void ThrowImageTooBigTIFF () - { - - Throw_dng_error (dng_error_image_too_big_tiff); - - } - -/*****************************************************************************/ - -/// \brief Convenience function to throw dng_exception with error code -/// dng_error_unsupported_dng . - -inline void ThrowUnsupportedDNG () - { - - Throw_dng_error (dng_error_unsupported_dng); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_exif.cpp b/third_party/dng_sdk/dng_exif.cpp deleted file mode 100644 index 289c184..0000000 --- a/third_party/dng_sdk/dng_exif.cpp +++ /dev/null @@ -1,4390 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_exif.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_exif.h" - -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_parse_utils.h" -#include "dng_globals.h" -#include "dng_exceptions.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_exif::dng_exif () - - : fImageDescription () - , fMake () - , fModel () - , fSoftware () - , fArtist () - , fCopyright () - , fCopyright2 () - , fUserComment () - - , fDateTime () - , fDateTimeStorageInfo () - - , fDateTimeOriginal () - , fDateTimeOriginalStorageInfo () - - , fDateTimeDigitized () - , fDateTimeDigitizedStorageInfo () - - , fTIFF_EP_StandardID (0) - , fExifVersion (0) - , fFlashPixVersion (0) - - , fExposureTime () - , fFNumber () - , fShutterSpeedValue () - , fApertureValue () - , fBrightnessValue () - , fExposureBiasValue () - , fMaxApertureValue () - , fFocalLength () - , fDigitalZoomRatio () - , fExposureIndex () - , fSubjectDistance () - , fGamma () - - , fBatteryLevelR () - , fBatteryLevelA () - - , fExposureProgram (0xFFFFFFFF) - , fMeteringMode (0xFFFFFFFF) - , fLightSource (0xFFFFFFFF) - , fFlash (0xFFFFFFFF) - , fFlashMask (0x0000FFFF) - , fSensingMethod (0xFFFFFFFF) - , fColorSpace (0xFFFFFFFF) - , fFileSource (0xFFFFFFFF) - , fSceneType (0xFFFFFFFF) - , fCustomRendered (0xFFFFFFFF) - , fExposureMode (0xFFFFFFFF) - , fWhiteBalance (0xFFFFFFFF) - , fSceneCaptureType (0xFFFFFFFF) - , fGainControl (0xFFFFFFFF) - , fContrast (0xFFFFFFFF) - , fSaturation (0xFFFFFFFF) - , fSharpness (0xFFFFFFFF) - , fSubjectDistanceRange (0xFFFFFFFF) - , fSelfTimerMode (0xFFFFFFFF) - , fImageNumber (0xFFFFFFFF) - - , fFocalLengthIn35mmFilm (0) - - , fSensitivityType (0) - , fStandardOutputSensitivity (0) - , fRecommendedExposureIndex (0) - , fISOSpeed (0) - , fISOSpeedLatitudeyyy (0) - , fISOSpeedLatitudezzz (0) - - , fSubjectAreaCount (0) - - , fComponentsConfiguration (0) - - , fCompresssedBitsPerPixel () - - , fPixelXDimension (0) - , fPixelYDimension (0) - - , fFocalPlaneXResolution () - , fFocalPlaneYResolution () - - , fFocalPlaneResolutionUnit (0xFFFFFFFF) - - , fCFARepeatPatternRows (0) - , fCFARepeatPatternCols (0) - - , fImageUniqueID () - - , fGPSVersionID (0) - , fGPSLatitudeRef () - , fGPSLongitudeRef () - , fGPSAltitudeRef (0xFFFFFFFF) - , fGPSAltitude () - , fGPSSatellites () - , fGPSStatus () - , fGPSMeasureMode () - , fGPSDOP () - , fGPSSpeedRef () - , fGPSSpeed () - , fGPSTrackRef () - , fGPSTrack () - , fGPSImgDirectionRef () - , fGPSImgDirection () - , fGPSMapDatum () - , fGPSDestLatitudeRef () - , fGPSDestLongitudeRef () - , fGPSDestBearingRef () - , fGPSDestBearing () - , fGPSDestDistanceRef () - , fGPSDestDistance () - , fGPSProcessingMethod () - , fGPSAreaInformation () - , fGPSDateStamp () - , fGPSDifferential (0xFFFFFFFF) - , fGPSHPositioningError () - - , fInteroperabilityIndex () - - , fInteroperabilityVersion (0) - - , fRelatedImageFileFormat () - - , fRelatedImageWidth (0) - , fRelatedImageLength (0) - - , fCameraSerialNumber () - - , fLensID () - , fLensMake () - , fLensName () - , fLensSerialNumber () - - , fLensNameWasReadFromExif (false) - - , fApproxFocusDistance () - - , fFlashCompensation () - - , fOwnerName () - , fFirmware () - - { - - uint32 j; - uint32 k; - - fISOSpeedRatings [0] = 0; - fISOSpeedRatings [1] = 0; - fISOSpeedRatings [2] = 0; - - for (j = 0; j < kMaxCFAPattern; j++) - for (k = 0; k < kMaxCFAPattern; k++) - { - fCFAPattern [j] [k] = 255; - } - - } - -/*****************************************************************************/ - -dng_exif::~dng_exif () - { - - } - -/*****************************************************************************/ - -dng_exif * dng_exif::Clone () const - { - - dng_exif *result = new dng_exif (*this); - - if (!result) - { - ThrowMemoryFull (); - } - - return result; - - } - -/*****************************************************************************/ - -void dng_exif::SetEmpty () - { - - *this = dng_exif (); - - } - -/*****************************************************************************/ - -void dng_exif::CopyGPSFrom (const dng_exif &exif) - { - - fGPSVersionID = exif.fGPSVersionID; - fGPSLatitudeRef = exif.fGPSLatitudeRef; - fGPSLatitude [0] = exif.fGPSLatitude [0]; - fGPSLatitude [1] = exif.fGPSLatitude [1]; - fGPSLatitude [2] = exif.fGPSLatitude [2]; - fGPSLongitudeRef = exif.fGPSLongitudeRef; - fGPSLongitude [0] = exif.fGPSLongitude [0]; - fGPSLongitude [1] = exif.fGPSLongitude [1]; - fGPSLongitude [2] = exif.fGPSLongitude [2]; - fGPSAltitudeRef = exif.fGPSAltitudeRef; - fGPSAltitude = exif.fGPSAltitude; - fGPSTimeStamp [0] = exif.fGPSTimeStamp [0]; - fGPSTimeStamp [1] = exif.fGPSTimeStamp [1]; - fGPSTimeStamp [2] = exif.fGPSTimeStamp [2]; - fGPSSatellites = exif.fGPSSatellites; - fGPSStatus = exif.fGPSStatus; - fGPSMeasureMode = exif.fGPSMeasureMode; - fGPSDOP = exif.fGPSDOP; - fGPSSpeedRef = exif.fGPSSpeedRef; - fGPSSpeed = exif.fGPSSpeed; - fGPSTrackRef = exif.fGPSTrackRef; - fGPSTrack = exif.fGPSTrack; - fGPSImgDirectionRef = exif.fGPSImgDirectionRef; - fGPSImgDirection = exif.fGPSImgDirection; - fGPSMapDatum = exif.fGPSMapDatum; - fGPSDestLatitudeRef = exif.fGPSDestLatitudeRef; - fGPSDestLatitude [0] = exif.fGPSDestLatitude [0]; - fGPSDestLatitude [1] = exif.fGPSDestLatitude [1]; - fGPSDestLatitude [2] = exif.fGPSDestLatitude [2]; - fGPSDestLongitudeRef = exif.fGPSDestLongitudeRef; - fGPSDestLongitude [0] = exif.fGPSDestLongitude [0]; - fGPSDestLongitude [1] = exif.fGPSDestLongitude [1]; - fGPSDestLongitude [2] = exif.fGPSDestLongitude [2]; - fGPSDestBearingRef = exif.fGPSDestBearingRef; - fGPSDestBearing = exif.fGPSDestBearing; - fGPSDestDistanceRef = exif.fGPSDestDistanceRef; - fGPSDestDistance = exif.fGPSDestDistance; - fGPSProcessingMethod = exif.fGPSProcessingMethod; - fGPSAreaInformation = exif.fGPSAreaInformation; - fGPSDateStamp = exif.fGPSDateStamp; - fGPSDifferential = exif.fGPSDifferential; - fGPSHPositioningError = exif.fGPSHPositioningError; - - } - -/*****************************************************************************/ - -// Fix up common errors and rounding issues with EXIF exposure times. - -real64 dng_exif::SnapExposureTime (real64 et) - { - - // Protection against invalid values. - - if (et <= 0.0) - return 0.0; - - // If near a standard shutter speed, snap to it. - - static const real64 kStandardSpeed [] = - { - 30.0, - 25.0, - 20.0, - 15.0, - 13.0, - 10.0, - 8.0, - 6.0, - 5.0, - 4.0, - 3.2, - 3.0, - 2.5, - 2.0, - 1.6, - 1.5, - 1.3, - 1.0, - 0.8, - 0.7, - 0.6, - 0.5, - 0.4, - 0.3, - 1.0 / 4.0, - 1.0 / 5.0, - 1.0 / 6.0, - 1.0 / 8.0, - 1.0 / 10.0, - 1.0 / 13.0, - 1.0 / 15.0, - 1.0 / 20.0, - 1.0 / 25.0, - 1.0 / 30.0, - 1.0 / 40.0, - 1.0 / 45.0, - 1.0 / 50.0, - 1.0 / 60.0, - 1.0 / 80.0, - 1.0 / 90.0, - 1.0 / 100.0, - 1.0 / 125.0, - 1.0 / 160.0, - 1.0 / 180.0, - 1.0 / 200.0, - 1.0 / 250.0, - 1.0 / 320.0, - 1.0 / 350.0, - 1.0 / 400.0, - 1.0 / 500.0, - 1.0 / 640.0, - 1.0 / 750.0, - 1.0 / 800.0, - 1.0 / 1000.0, - 1.0 / 1250.0, - 1.0 / 1500.0, - 1.0 / 1600.0, - 1.0 / 2000.0, - 1.0 / 2500.0, - 1.0 / 3000.0, - 1.0 / 3200.0, - 1.0 / 4000.0, - 1.0 / 5000.0, - 1.0 / 6000.0, - 1.0 / 6400.0, - 1.0 / 8000.0, - 1.0 / 10000.0, - 1.0 / 12000.0, - 1.0 / 12800.0, - 1.0 / 16000.0 - }; - - uint32 count = sizeof (kStandardSpeed ) / - sizeof (kStandardSpeed [0]); - - for (uint32 fudge = 0; fudge <= 1; fudge++) - { - - real64 testSpeed = et; - - if (fudge == 1) - { - - // Often APEX values are rounded to a power of two, - // which results in non-standard shutter speeds. - - if (et >= 0.1) - { - - // No fudging slower than 1/10 second - - break; - - } - - else if (et >= 0.01) - { - - // Between 1/10 and 1/100 the commonly misrounded - // speeds are 1/15, 1/30, 1/60, which are often encoded as - // 1/16, 1/32, 1/64. Try fudging and see if we get - // near a standard speed. - - testSpeed *= 16.0 / 15.0; - - } - - else - { - - // Faster than 1/100, the commonly misrounded - // speeds are 1/125, 1/250, 1/500, etc., which - // are often encoded as 1/128, 1/256, 1/512. - - testSpeed *= 128.0 / 125.0; - - } - - } - - for (uint32 index = 0; index < count; index++) - { - - if (testSpeed >= kStandardSpeed [index] * 0.98 && - testSpeed <= kStandardSpeed [index] * 1.02) - { - - return kStandardSpeed [index]; - - } - - } - - } - - // We are not near any standard speeds. Round the non-standard value to something - // that looks reasonable. - - if (et >= 10.0) - { - - // Round to nearest second. - - et = floor (et + 0.5); - - } - - else if (et >= 0.5) - { - - // Round to nearest 1/10 second - - et = floor (et * 10.0 + 0.5) * 0.1; - - } - - else if (et >= 1.0 / 20.0) - { - - // Round to an exact inverse. - - et = 1.0 / floor (1.0 / et + 0.5); - - } - - else if (et >= 1.0 / 130.0) - { - - // Round inverse to multiple of 5 - - et = 0.2 / floor (0.2 / et + 0.5); - - } - - else if (et >= 1.0 / 750.0) - { - - // Round inverse to multiple of 10 - - et = 0.1 / floor (0.1 / et + 0.5); - - } - - else if (et >= 1.0 / 1300.0) - { - - // Round inverse to multiple of 50 - - et = 0.02 / floor (0.02 / et + 0.5); - - } - - else if (et >= 1.0 / 15000.0) - { - - // Round inverse to multiple of 100 - - et = 0.01 / floor (0.01 / et + 0.5); - - } - - else - { - - // Round inverse to multiple of 1000 - - et = 0.001 / floor (0.001 / et + 0.5); - - } - - return et; - - } - -/*****************************************************************************/ - -void dng_exif::SetExposureTime (real64 et, bool snap) - { - - fExposureTime.Clear (); - - fShutterSpeedValue.Clear (); - - if (snap) - { - - et = SnapExposureTime (et); - - } - - if (et >= 1.0 / 32768.0 && et <= 32768.0) - { - - if (et >= 100.0) - { - - fExposureTime.Set_real64 (et, 1); - - } - - else if (et >= 1.0) - { - - fExposureTime.Set_real64 (et, 10); - - fExposureTime.ReduceByFactor (10); - - } - - else if (et <= 0.1) - { - - fExposureTime = dng_urational (1, Round_uint32 (1.0 / et)); - - } - - else - { - - fExposureTime.Set_real64 (et, 100); - - fExposureTime.ReduceByFactor (10); - - for (uint32 f = 2; f <= 9; f++) - { - - real64 z = 1.0 / (real64) f / et; - - if (z >= 0.99 && z <= 1.01) - { - - fExposureTime = dng_urational (1, f); - - break; - - } - - } - - } - - // Now mirror this value to the ShutterSpeedValue field. - - et = fExposureTime.As_real64 (); - - fShutterSpeedValue.Set_real64 (-log (et) / log (2.0), 1000000); - - fShutterSpeedValue.ReduceByFactor (10); - fShutterSpeedValue.ReduceByFactor (10); - fShutterSpeedValue.ReduceByFactor (10); - fShutterSpeedValue.ReduceByFactor (10); - fShutterSpeedValue.ReduceByFactor (10); - fShutterSpeedValue.ReduceByFactor (10); - - } - - } - -/*****************************************************************************/ - -void dng_exif::SetShutterSpeedValue (real64 ss) - { - - if (fExposureTime.NotValid ()) - { - - real64 et = pow (2.0, -ss); - - SetExposureTime (et, true); - - } - - } - -/******************************************************************************/ - -dng_urational dng_exif::EncodeFNumber (real64 fs) - { - - dng_urational y; - - if (fs > 10.0) - { - - y.Set_real64 (fs, 1); - - } - - else if (fs < 1.0) - { - - y.Set_real64 (fs, 100); - - y.ReduceByFactor (10); - y.ReduceByFactor (10); - - } - - else - { - - y.Set_real64 (fs, 10); - - y.ReduceByFactor (10); - - } - - return y; - - } - -/*****************************************************************************/ - -void dng_exif::SetFNumber (real64 fs) - { - - fFNumber.Clear (); - - fApertureValue.Clear (); - - // Allow f-number values less than 1.0 (e.g., f/0.95), even though they would - // correspond to negative APEX values, which the EXIF specification does not - // support (ApertureValue is a rational, not srational). The ApertureValue tag - // will be omitted in the case where fs < 1.0. - - if (fs > 0.0 && fs <= 32768.0) - { - - fFNumber = EncodeFNumber (fs); - - // Now mirror this value to the ApertureValue field. - - real64 av = FNumberToApertureValue (fFNumber); - - if (av >= 0.0 && av <= 99.99) - { - - fApertureValue.Set_real64 (av, 1000000); - - fApertureValue.ReduceByFactor (10); - fApertureValue.ReduceByFactor (10); - fApertureValue.ReduceByFactor (10); - fApertureValue.ReduceByFactor (10); - fApertureValue.ReduceByFactor (10); - fApertureValue.ReduceByFactor (10); - - } - - } - - } - -/*****************************************************************************/ - -void dng_exif::SetApertureValue (real64 av) - { - - if (fFNumber.NotValid ()) - { - - SetFNumber (ApertureValueToFNumber (av)); - - } - - } - -/*****************************************************************************/ - -real64 dng_exif::ApertureValueToFNumber (real64 av) - { - - return pow (2.0, 0.5 * av); - - } - -/*****************************************************************************/ - -real64 dng_exif::ApertureValueToFNumber (const dng_urational &av) - { - - return ApertureValueToFNumber (av.As_real64 ()); - - } - -/*****************************************************************************/ - -real64 dng_exif::FNumberToApertureValue (real64 fNumber) - { - - return 2.0 * log (fNumber) / log (2.0); - - } - -/*****************************************************************************/ - -real64 dng_exif::FNumberToApertureValue (const dng_urational &fNumber) - { - - return FNumberToApertureValue (fNumber.As_real64 ()); - - } - -/*****************************************************************************/ - -void dng_exif::UpdateDateTime (const dng_date_time_info &dt) - { - - fDateTime = dt; - - } - -/*****************************************************************************/ - -bool dng_exif::AtLeastVersion0230 () const - { - - uint32 b0 = (fExifVersion >> 24) & 0xff; - uint32 b1 = (fExifVersion >> 16) & 0xff; - uint32 b2 = (fExifVersion >> 8) & 0xff; - - return (b0 > 0) || (b1 >= 2 && b2 >= 3); - - } - -/*****************************************************************************/ - -bool dng_exif::ParseTag (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - bool isMainIFD, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset) - { - - if (parentCode == 0) - { - - if (Parse_ifd0 (stream, - shared, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - if (parentCode == 0 || isMainIFD) - { - - if (Parse_ifd0_main (stream, - shared, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - if (parentCode == 0 || - parentCode == tcExifIFD) - { - - if (Parse_ifd0_exif (stream, - shared, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - if (parentCode == tcGPSInfo) - { - - if (Parse_gps (stream, - shared, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - if (parentCode == tcInteroperabilityIFD) - { - - if (Parse_interoperability (stream, - shared, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFD 0. - -bool dng_exif::Parse_ifd0 (dng_stream &stream, - dng_shared & /* shared */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 /* tagOffset */) - { - - switch (tagCode) - { - - case tcImageDescription: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fImageDescription); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ImageDescription: "); - - DumpString (fImageDescription); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcMake: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fMake); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Make: "); - - DumpString (fMake); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcModel: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fModel); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Model: "); - - DumpString (fModel); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSoftware: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fSoftware); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Software: "); - - DumpString (fSoftware); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcDateTime: - { - - uint64 tagPosition = stream.PositionInOriginalFile (); - - dng_date_time dt; - - if (!ParseDateTimeTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - dt)) - { - return false; - } - - fDateTime.SetDateTime (dt); - - fDateTimeStorageInfo = dng_date_time_storage_info (tagPosition, - dng_date_time_format_exif); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DateTime: "); - - DumpDateTime (fDateTime.DateTime ()); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcArtist: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fArtist); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Artist: "); - - DumpString (fArtist); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcCopyright: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseDualStringTag (stream, - parentCode, - tagCode, - tagCount, - fCopyright, - fCopyright2); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Copyright: "); - - DumpString (fCopyright); - - if (fCopyright2.Get () [0] != 0) - { - - printf (" "); - - DumpString (fCopyright2); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcTIFF_EP_StandardID: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fTIFF_EP_StandardID = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - printf ("TIFF/EPStandardID: %u.%u.%u.%u\n", - (unsigned) b0, - (unsigned) b1, - (unsigned) b2, - (unsigned) b3); - } - - #endif - - break; - - } - - case tcCameraSerialNumber: - case tcKodakCameraSerialNumber: // Kodak uses a very similar tag. - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fCameraSerialNumber); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (fCameraSerialNumber); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcLensInfo: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) - return false; - - fLensInfo [0] = stream.TagValue_urational (tagType); - fLensInfo [1] = stream.TagValue_urational (tagType); - fLensInfo [2] = stream.TagValue_urational (tagType); - fLensInfo [3] = stream.TagValue_urational (tagType); - - // Some third party software wrote zero rather and undefined values - // for unknown entries. Work around this bug. - - for (uint32 j = 0; j < 4; j++) - { - - if (fLensInfo [j].IsValid () && fLensInfo [j].As_real64 () <= 0.0) - { - - fLensInfo [j] = dng_urational (0, 0); - - #if qDNGValidate - - ReportWarning ("Zero entry in LensInfo tag--should be undefined"); - - #endif - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("LensInfo: "); - - real64 minFL = fLensInfo [0].As_real64 (); - real64 maxFL = fLensInfo [1].As_real64 (); - - if (minFL == maxFL) - printf ("%0.1f mm", minFL); - else - printf ("%0.1f-%0.1f mm", minFL, maxFL); - - if (fLensInfo [2].d) - { - - real64 minFS = fLensInfo [2].As_real64 (); - real64 maxFS = fLensInfo [3].As_real64 (); - - if (minFS == maxFS) - printf (" f/%0.1f", minFS); - else - printf (" f/%0.1f-%0.1f", minFS, maxFS); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFD 0 or the main image IFD. - -bool dng_exif::Parse_ifd0_main (dng_stream &stream, - dng_shared & /* shared */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 /* tagOffset */) - { - - switch (tagCode) - { - - case tcFocalPlaneXResolution: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneXResolution = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneXResolution: %0.4f\n", - fFocalPlaneXResolution.As_real64 ()); - - } - - #endif - - break; - - } - - case tcFocalPlaneYResolution: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneYResolution = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneYResolution: %0.4f\n", - fFocalPlaneYResolution.As_real64 ()); - - } - - #endif - - break; - - } - - case tcFocalPlaneResolutionUnit: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneResolutionUnit = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneResolutionUnit: %s\n", - LookupResolutionUnit (fFocalPlaneResolutionUnit)); - - } - - #endif - - break; - - } - - case tcSensingMethod: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSensingMethod = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SensingMethod: %s\n", - LookupSensingMethod (fSensingMethod)); - - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFD 0 or EXIF IFD. - -bool dng_exif::Parse_ifd0_exif (dng_stream &stream, - dng_shared & /* shared */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 /* tagOffset */) - { - - switch (tagCode) - { - - case tcBatteryLevel: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational, ttAscii); - - if (tagType == ttAscii) - { - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fBatteryLevelA); - - } - - else - { - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBatteryLevelR = stream.TagValue_urational (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BatteryLevel: "); - - if (tagType == ttAscii) - { - - DumpString (fBatteryLevelA); - - } - - else - { - - printf ("%0.2f", fBatteryLevelR.As_real64 ()); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcExposureTime: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - dng_urational et = stream.TagValue_urational (tagType); - - SetExposureTime (et.As_real64 (), true); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ExposureTime: "); - - DumpExposureTime (et.As_real64 ()); - - printf ("\n"); - - } - - if (et.As_real64 () <= 0.0) - { - - ReportWarning ("The ExposureTime is <= 0"); - - } - - #endif - - break; - - } - - case tcFNumber: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - dng_urational fs = stream.TagValue_urational (tagType); - - // Sometimes "unknown" is recorded as zero. - - if (fs.As_real64 () <= 0.0) - { - fs.Clear (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FNumber: f/%0.2f\n", - fs.As_real64 ()); - - } - - #endif - - SetFNumber (fs.As_real64 ()); - - break; - - } - - case tcExposureProgram: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fExposureProgram = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ExposureProgram: %s\n", - LookupExposureProgram (fExposureProgram)); - - } - - #endif - - break; - - } - - case tcISOSpeedRatings: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1, 3); - - for (uint32 j = 0; j < tagCount && j < 3; j++) - { - - fISOSpeedRatings [j] = stream.TagValue_uint32 (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ISOSpeedRatings:"); - - for (uint32 j = 0; j < tagCount && j < 3; j++) - { - - printf (" %u", (unsigned) fISOSpeedRatings [j]); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSensitivityType: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSensitivityType = (uint32) stream.Get_uint16 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SensitivityType: %s\n", - LookupSensitivityType (fSensitivityType)); - - } - - #endif - - break; - - } - - case tcStandardOutputSensitivity: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fStandardOutputSensitivity = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("StandardOutputSensitivity: %u\n", - (unsigned) fStandardOutputSensitivity); - - } - - #endif - - break; - - } - - case tcRecommendedExposureIndex: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fRecommendedExposureIndex = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RecommendedExposureIndex: %u\n", - (unsigned) fRecommendedExposureIndex); - - } - - #endif - - break; - - } - - case tcISOSpeed: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fISOSpeed = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ISOSpeed: %u\n", - (unsigned) fISOSpeed); - - } - - #endif - - break; - - } - - case tcISOSpeedLatitudeyyy: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fISOSpeedLatitudeyyy = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ISOSpeedLatitudeyyy: %u\n", - (unsigned) fISOSpeedLatitudeyyy); - - } - - #endif - - break; - - } - - case tcISOSpeedLatitudezzz: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fISOSpeedLatitudezzz = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ISOSpeedLatitudezzz: %u\n", - (unsigned) fISOSpeedLatitudezzz); - - } - - #endif - - break; - - } - - case tcTimeZoneOffset: - { - - CheckTagType (parentCode, tagCode, tagType, ttSShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1, 2); - - dng_time_zone zoneOriginal; - - zoneOriginal.SetOffsetHours (stream.TagValue_int32 (tagType)); - - fDateTimeOriginal.SetZone (zoneOriginal); - - #if 0 // MWG: Not filling in time zones unless we are sure. - - // Note that there is no "TimeZoneOffsetDigitized" field, so - // we assume the same tone zone as the original. - - fDateTimeDigitized.SetZone (zoneOriginal); - - #endif - - dng_time_zone zoneCurrent; - - if (tagCount >= 2) - { - - zoneCurrent.SetOffsetHours (stream.TagValue_int32 (tagType)); - - fDateTime.SetZone (zoneCurrent); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("TimeZoneOffset: DateTimeOriginal = %d", - (int) zoneOriginal.ExactHourOffset ()); - - if (tagCount >= 2) - { - - printf (", DateTime = %d", - (int) zoneCurrent.ExactHourOffset ()); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSelfTimerMode: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSelfTimerMode = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SelfTimerMode: "); - - if (fSelfTimerMode) - { - - printf ("%u sec", (unsigned) fSelfTimerMode); - - } - - else - { - - printf ("Off"); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcExifVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fExifVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - - real64 x = (b0 - '0') * 10.00 + - (b1 - '0') * 1.00 + - (b2 - '0') * 0.10 + - (b3 - '0') * 0.01; - - printf ("ExifVersion: %0.2f\n", x); - - } - - #endif - - break; - - } - - case tcDateTimeOriginal: - { - - uint64 tagPosition = stream.PositionInOriginalFile (); - - dng_date_time dt; - - if (!ParseDateTimeTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - dt)) - { - return false; - } - - fDateTimeOriginal.SetDateTime (dt); - - fDateTimeOriginalStorageInfo = dng_date_time_storage_info (tagPosition, - dng_date_time_format_exif); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DateTimeOriginal: "); - - DumpDateTime (fDateTimeOriginal.DateTime ()); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcDateTimeDigitized: - { - - uint64 tagPosition = stream.PositionInOriginalFile (); - - dng_date_time dt; - - if (!ParseDateTimeTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - dt)) - { - return false; - } - - fDateTimeDigitized.SetDateTime (dt); - - fDateTimeDigitizedStorageInfo = dng_date_time_storage_info (tagPosition, - dng_date_time_format_exif); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DateTimeDigitized: "); - - DumpDateTime (fDateTimeDigitized.DateTime ()); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcComponentsConfiguration: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fComponentsConfiguration = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ComponentsConfiguration: %s %s %s %s\n", - LookupComponent (b0), - LookupComponent (b1), - LookupComponent (b2), - LookupComponent (b3)); - - } - - #endif - - break; - - } - - case tcCompressedBitsPerPixel: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCompresssedBitsPerPixel = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CompressedBitsPerPixel: %0.2f\n", - fCompresssedBitsPerPixel.As_real64 ()); - - } - - #endif - - break; - - } - - case tcShutterSpeedValue: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - dng_srational ss = stream.TagValue_srational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ShutterSpeedValue: "); - - real64 x = pow (2.0, -ss.As_real64 ()); - - DumpExposureTime (x); - - printf ("\n"); - - } - - // The ExposureTime and ShutterSpeedValue tags should be consistent. - - if (fExposureTime.IsValid ()) - { - - real64 et = fExposureTime.As_real64 (); - - real64 tv1 = -1.0 * log (et) / log (2.0); - - real64 tv2 = ss.As_real64 (); - - // Make sure they are within 0.25 APEX values. - - if (Abs_real64 (tv1 - tv2) > 0.25) - { - - ReportWarning ("The ExposureTime and ShutterSpeedValue tags have conflicting values"); - - } - - } - - #endif - - SetShutterSpeedValue (ss.As_real64 ()); - - break; - - } - - case tcApertureValue: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - dng_urational av = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - real64 x = pow (2.0, 0.5 * av.As_real64 ()); - - printf ("ApertureValue: f/%0.2f\n", x); - - } - - // The FNumber and ApertureValue tags should be consistent. - - if (fFNumber.IsValid () && av.IsValid ()) - { - - real64 fs = fFNumber.As_real64 (); - - real64 av1 = FNumberToApertureValue (fs); - - real64 av2 = av.As_real64 (); - - if (Abs_real64 (av1 - av2) > 0.25) - { - - ReportWarning ("The FNumber and ApertureValue tags have conflicting values"); - - } - - } - - #endif - - SetApertureValue (av.As_real64 ()); - - break; - - } - - case tcBrightnessValue: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBrightnessValue = stream.TagValue_srational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BrightnessValue: %0.2f\n", - fBrightnessValue.As_real64 ()); - - } - - #endif - - break; - - } - - case tcExposureBiasValue: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fExposureBiasValue = stream.TagValue_srational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ExposureBiasValue: %0.2f\n", - fExposureBiasValue.As_real64 ()); - - } - - #endif - - break; - - } - - case tcMaxApertureValue: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fMaxApertureValue = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - real64 x = pow (2.0, 0.5 * fMaxApertureValue.As_real64 ()); - - printf ("MaxApertureValue: f/%0.1f\n", x); - - } - - #endif - - break; - - } - - case tcSubjectDistance: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSubjectDistance = stream.TagValue_urational (tagType); - - fApproxFocusDistance = fSubjectDistance; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubjectDistance: %u/%u\n", - (unsigned) fSubjectDistance.n, - (unsigned) fSubjectDistance.d); - - } - - #endif - - break; - - } - - case tcMeteringMode: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fMeteringMode = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("MeteringMode: %s\n", - LookupMeteringMode (fMeteringMode)); - - } - - #endif - - break; - - } - - case tcLightSource: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fLightSource = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("LightSource: %s\n", - LookupLightSource (fLightSource)); - - } - - #endif - - break; - - } - - case tcFlash: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFlash = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Flash: %u\n", (unsigned) fFlash); - - if ((fFlash >> 5) & 1) - { - printf (" No flash function\n"); - } - - else - { - - if (fFlash & 0x1) - { - - printf (" Flash fired\n"); - - switch ((fFlash >> 1) & 0x3) - { - - case 2: - printf (" Strobe return light not detected\n"); - break; - - case 3: - printf (" Strobe return light detected\n"); - break; - - } - - } - - else - { - printf (" Flash did not fire\n"); - } - - switch ((fFlash >> 3) & 0x3) - { - - case 1: - printf (" Compulsory flash firing\n"); - break; - - case 2: - printf (" Compulsory flash suppression\n"); - break; - - case 3: - printf (" Auto mode\n"); - break; - - } - - if ((fFlash >> 6) & 1) - { - printf (" Red-eye reduction supported\n"); - } - - } - - } - - #endif - - break; - - } - - case tcFocalLength: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalLength = stream.TagValue_urational (tagType); - - // Sometimes "unknown" is recorded as zero. - - if (fFocalLength.As_real64 () <= 0.0) - { - fFocalLength.Clear (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalLength: %0.1f mm\n", - fFocalLength.As_real64 ()); - - } - - #endif - - break; - - } - - case tcImageNumber: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fImageNumber = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("ImageNumber: %u\n", (unsigned) fImageNumber); - } - - #endif - - break; - - } - - case tcExposureIndex: - case tcExposureIndexExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fExposureIndex = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ISO %0.1f\n", - LookupTagCode (parentCode, tagCode), - fExposureIndex.As_real64 ()); - - } - - #endif - - break; - - } - - case tcUserComment: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - ParseEncodedStringTag (stream, - parentCode, - tagCode, - tagCount, - fUserComment); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("UserComment: "); - - DumpString (fUserComment); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSubsecTime: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - dng_string subsecs; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - subsecs); - - fDateTime.SetSubseconds (subsecs); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubsecTime: "); - - DumpString (subsecs); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSubsecTimeOriginal: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - dng_string subsecs; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - subsecs); - - fDateTimeOriginal.SetSubseconds (subsecs); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubsecTimeOriginal: "); - - DumpString (subsecs); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcSubsecTimeDigitized: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - dng_string subsecs; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - subsecs); - - fDateTimeDigitized.SetSubseconds (subsecs); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubsecTimeDigitized: "); - - DumpString (subsecs); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcFlashPixVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fFlashPixVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - - real64 x = (b0 - '0') * 10.00 + - (b1 - '0') * 1.00 + - (b2 - '0') * 0.10 + - (b3 - '0') * 0.01; - - printf ("FlashPixVersion: %0.2f\n", x); - - } - - #endif - - break; - - } - - case tcColorSpace: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fColorSpace = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ColorSpace: %s\n", - LookupColorSpace (fColorSpace)); - - } - - #endif - - break; - - } - - case tcPixelXDimension: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPixelXDimension = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("PixelXDimension: %u\n", (unsigned) fPixelXDimension); - } - - #endif - - break; - - } - - case tcPixelYDimension: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPixelYDimension = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("PixelYDimension: %u\n", (unsigned) fPixelYDimension); - } - - #endif - - break; - - } - - case tcFocalPlaneXResolutionExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneXResolution = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneXResolutionExif: %0.4f\n", - fFocalPlaneXResolution.As_real64 ()); - - } - - #endif - - break; - - } - - case tcFocalPlaneYResolutionExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneYResolution = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneYResolutionExif: %0.4f\n", - fFocalPlaneYResolution.As_real64 ()); - - } - - #endif - - break; - - } - - case tcFocalPlaneResolutionUnitExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalPlaneResolutionUnit = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalPlaneResolutionUnitExif: %s\n", - LookupResolutionUnit (fFocalPlaneResolutionUnit)); - - } - - #endif - - break; - - } - - case tcSensingMethodExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSensingMethod = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SensingMethodExif: %s\n", - LookupSensingMethod (fSensingMethod)); - - } - - #endif - - break; - - } - - case tcFileSource: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFileSource = stream.Get_uint8 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FileSource: %s\n", - LookupFileSource (fFileSource)); - - } - - #endif - - break; - - } - - case tcSceneType: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSceneType = stream.Get_uint8 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SceneType: %s\n", - LookupSceneType (fSceneType)); - - } - - #endif - - break; - - } - - case tcCFAPatternExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - if (tagCount <= 4) - { - return false; - } - - uint32 cols = stream.Get_uint16 (); - uint32 rows = stream.Get_uint16 (); - - if (tagCount != 4 + cols * rows) - { - return false; - } - - if (cols < 1 || cols > kMaxCFAPattern || - rows < 1 || rows > kMaxCFAPattern) - { - return false; - } - - fCFARepeatPatternCols = cols; - fCFARepeatPatternRows = rows; - - // Note that the Exif spec stores this array in a different - // scan order than the TIFF-EP spec. - - for (uint32 j = 0; j < fCFARepeatPatternCols; j++) - for (uint32 k = 0; k < fCFARepeatPatternRows; k++) - { - - fCFAPattern [k] [j] = stream.Get_uint8 (); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CFAPatternExif:\n"); - - for (uint32 j = 0; j < fCFARepeatPatternRows; j++) - { - - int32 spaces = 4; - - for (uint32 k = 0; k < fCFARepeatPatternCols; k++) - { - - while (spaces-- > 0) - { - printf (" "); - } - - const char *name = LookupCFAColor (fCFAPattern [j] [k]); - - spaces = 9 - (int32) strlen (name); - - printf ("%s", name); - - } - - printf ("\n"); - - } - - } - - #endif - - break; - - } - - case tcCustomRendered: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCustomRendered = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CustomRendered: %s\n", - LookupCustomRendered (fCustomRendered)); - - } - - #endif - - break; - - } - - case tcExposureMode: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fExposureMode = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ExposureMode: %s\n", - LookupExposureMode (fExposureMode)); - - } - - #endif - - break; - - } - - case tcWhiteBalance: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fWhiteBalance = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("WhiteBalance: %s\n", - LookupWhiteBalance (fWhiteBalance)); - - } - - #endif - - break; - - } - - case tcDigitalZoomRatio: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fDigitalZoomRatio = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DigitalZoomRatio: "); - - if (fDigitalZoomRatio.n == 0 || - fDigitalZoomRatio.d == 0) - { - - printf ("Not used\n"); - - } - - else - { - - printf ("%0.2f\n", fDigitalZoomRatio.As_real64 ()); - - } - - } - - #endif - - break; - - } - - case tcFocalLengthIn35mmFilm: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFocalLengthIn35mmFilm = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("FocalLengthIn35mmFilm: %u mm\n", - (unsigned) fFocalLengthIn35mmFilm); - - } - - #endif - - break; - - } - - case tcSceneCaptureType: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSceneCaptureType = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SceneCaptureType: %s\n", - LookupSceneCaptureType (fSceneCaptureType)); - - } - - #endif - - break; - - } - - case tcGainControl: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fGainControl = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("GainControl: %s\n", - LookupGainControl (fGainControl)); - - } - - #endif - - break; - - } - - case tcContrast: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fContrast = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Contrast: %s\n", - LookupContrast (fContrast)); - - } - - #endif - - break; - - } - - case tcSaturation: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSaturation = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Saturation: %s\n", - LookupSaturation (fSaturation)); - - } - - #endif - - break; - - } - - case tcSharpness: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSharpness = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Sharpness: %s\n", - LookupSharpness (fSharpness)); - - } - - #endif - - break; - - } - - case tcSubjectDistanceRange: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSubjectDistanceRange = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubjectDistanceRange: %s\n", - LookupSubjectDistanceRange (fSubjectDistanceRange)); - - } - - #endif - - break; - - } - - case tcSubjectArea: - case tcSubjectLocation: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2, 4)) - { - return false; - } - - if (tagCode == tcSubjectLocation) - { - CheckTagCount (parentCode, tagCode, tagCount, 2); - } - - fSubjectAreaCount = tagCount; - - for (uint32 j = 0; j < tagCount; j++) - { - - fSubjectArea [j] = stream.TagValue_uint32 (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s:", LookupTagCode (parentCode, tagCode)); - - for (uint32 j = 0; j < fSubjectAreaCount; j++) - { - - printf (" %u", (unsigned) fSubjectArea [j]); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGamma: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fGamma = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Gamma: %0.2f\n", - fGamma.As_real64 ()); - - } - - #endif - - break; - - } - - case tcImageUniqueID: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttAscii)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 33)) - return false; - - dng_string s; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - s); - - if (s.Length () != 32) - return false; - - dng_fingerprint f; - - for (uint32 j = 0; j < 32; j++) - { - - char c = ForceUppercase (s.Get () [j]); - - uint32 digit; - - if (c >= '0' && c <= '9') - { - digit = c - '0'; - } - - else if (c >= 'A' && c <= 'F') - { - digit = c - 'A' + 10; - } - - else - return false; - - f.data [j >> 1] *= 16; - f.data [j >> 1] += (uint8) digit; - - } - - fImageUniqueID = f; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ImageUniqueID: "); - - DumpFingerprint (fImageUniqueID); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcCameraOwnerNameExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fOwnerName); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CameraOwnerName: "); - - DumpString (fOwnerName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcCameraSerialNumberExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fCameraSerialNumber); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (fCameraSerialNumber); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcLensSpecificationExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) - return false; - - fLensInfo [0] = stream.TagValue_urational (tagType); - fLensInfo [1] = stream.TagValue_urational (tagType); - fLensInfo [2] = stream.TagValue_urational (tagType); - fLensInfo [3] = stream.TagValue_urational (tagType); - - // Some third party software wrote zero rather than undefined values for - // unknown entries. Work around this bug. - - for (uint32 j = 0; j < 4; j++) - { - - if (fLensInfo [j].IsValid () && fLensInfo [j].As_real64 () <= 0.0) - { - - fLensInfo [j] = dng_urational (0, 0); - - #if qDNGValidate - - ReportWarning ("Zero entry in LensSpecification tag--should be undefined"); - - #endif - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("LensSpecificationExif: "); - - real64 minFL = fLensInfo [0].As_real64 (); - real64 maxFL = fLensInfo [1].As_real64 (); - - if (minFL == maxFL) - printf ("%0.1f mm", minFL); - else - printf ("%0.1f-%0.1f mm", minFL, maxFL); - - if (fLensInfo [2].d) - { - - real64 minFS = fLensInfo [2].As_real64 (); - real64 maxFS = fLensInfo [3].As_real64 (); - - if (minFS == maxFS) - printf (" f/%0.1f", minFS); - else - printf (" f/%0.1f-%0.1f", minFS, maxFS); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcLensMakeExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fLensMake); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (fLensMake); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcLensModelExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fLensName); - - fLensNameWasReadFromExif = fLensName.NotEmpty (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (fLensName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcLensSerialNumberExif: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fLensSerialNumber); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (fLensSerialNumber); - - printf ("\n"); - - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in GPS IFD - -bool dng_exif::Parse_gps (dng_stream &stream, - dng_shared & /* shared */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 /* tagOffset */) - { - - switch (tagCode) - { - - case tcGPSVersionID: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fGPSVersionID = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - printf ("GPSVersionID: %u.%u.%u.%u\n", - (unsigned) b0, - (unsigned) b1, - (unsigned) b2, - (unsigned) b3); - } - - #endif - - break; - - } - - case tcGPSLatitudeRef: - case tcGPSLongitudeRef: - case tcGPSSatellites: - case tcGPSStatus: - case tcGPSMeasureMode: - case tcGPSSpeedRef: - case tcGPSTrackRef: - case tcGPSImgDirectionRef: - case tcGPSMapDatum: - case tcGPSDestLatitudeRef: - case tcGPSDestLongitudeRef: - case tcGPSDestBearingRef: - case tcGPSDestDistanceRef: - case tcGPSDateStamp: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttAscii)) - return false; - - dng_string *s; - - switch (tagCode) - { - - case tcGPSLatitudeRef: - s = &fGPSLatitudeRef; - break; - - case tcGPSLongitudeRef: - s = &fGPSLongitudeRef; - break; - - case tcGPSSatellites: - s = &fGPSSatellites; - break; - - case tcGPSStatus: - s = &fGPSStatus; - break; - - case tcGPSMeasureMode: - s = &fGPSMeasureMode; - break; - - case tcGPSSpeedRef: - s = &fGPSSpeedRef; - break; - - case tcGPSTrackRef: - s = &fGPSTrackRef; - break; - - case tcGPSImgDirectionRef: - s = &fGPSImgDirectionRef; - break; - - case tcGPSMapDatum: - s = &fGPSMapDatum; - break; - - case tcGPSDestLatitudeRef: - s = &fGPSDestLatitudeRef; - break; - - case tcGPSDestLongitudeRef: - s = &fGPSDestLongitudeRef; - break; - - case tcGPSDestBearingRef: - s = &fGPSDestBearingRef; - break; - - case tcGPSDestDistanceRef: - s = &fGPSDestDistanceRef; - break; - - case tcGPSDateStamp: - s = &fGPSDateStamp; - break; - - default: - return false; - - } - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - *s); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (*s); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGPSLatitude: - case tcGPSLongitude: - case tcGPSTimeStamp: - case tcGPSDestLatitude: - case tcGPSDestLongitude: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttRational)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 3)) - return false; - - dng_urational *u; - - switch (tagCode) - { - - case tcGPSLatitude: - u = fGPSLatitude; - break; - - case tcGPSLongitude: - u = fGPSLongitude; - break; - - case tcGPSTimeStamp: - u = fGPSTimeStamp; - break; - - case tcGPSDestLatitude: - u = fGPSDestLatitude; - break; - - case tcGPSDestLongitude: - u = fGPSDestLongitude; - break; - - default: - return false; - - } - - u [0] = stream.TagValue_urational (tagType); - u [1] = stream.TagValue_urational (tagType); - u [2] = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s:", LookupTagCode (parentCode, tagCode)); - - for (uint32 j = 0; j < 3; j++) - { - - if (u [j].d == 0) - printf (" -"); - - else - printf (" %0.4f", u [j].As_real64 ()); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGPSAltitudeRef: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fGPSAltitudeRef = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("GPSAltitudeRef: "); - - switch (fGPSAltitudeRef) - { - - case 0: - printf ("Sea level"); - break; - - case 1: - printf ("Sea level reference (negative value)"); - break; - - default: - printf ("%u", (unsigned) fGPSAltitudeRef); - break; - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGPSAltitude: - case tcGPSDOP: - case tcGPSSpeed: - case tcGPSTrack: - case tcGPSImgDirection: - case tcGPSDestBearing: - case tcGPSDestDistance: - case tcGPSHPositioningError: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttRational)) - return false; - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - dng_urational *u; - - switch (tagCode) - { - - case tcGPSAltitude: - u = &fGPSAltitude; - break; - - case tcGPSDOP: - u = &fGPSDOP; - break; - - case tcGPSSpeed: - u = &fGPSSpeed; - break; - - case tcGPSTrack: - u = &fGPSTrack; - break; - - case tcGPSImgDirection: - u = &fGPSImgDirection; - break; - - case tcGPSDestBearing: - u = &fGPSDestBearing; - break; - - case tcGPSDestDistance: - u = &fGPSDestDistance; - break; - - case tcGPSHPositioningError: - u = &fGPSHPositioningError; - break; - - default: - return false; - - } - - *u = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s:", LookupTagCode (parentCode, tagCode)); - - if (u->d == 0) - printf (" -"); - - else - printf (" %0.4f", u->As_real64 ()); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGPSProcessingMethod: - case tcGPSAreaInformation: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttUndefined)) - return false; - - dng_string *s; - - switch (tagCode) - { - - case tcGPSProcessingMethod: - s = &fGPSProcessingMethod; - break; - - case tcGPSAreaInformation: - s = &fGPSAreaInformation; - break; - - default: - return false; - - } - - ParseEncodedStringTag (stream, - parentCode, - tagCode, - tagCount, - *s); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: ", LookupTagCode (parentCode, tagCode)); - - DumpString (*s); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcGPSDifferential: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fGPSDifferential = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("GPSDifferential: "); - - switch (fGPSDifferential) - { - - case 0: - printf ("Measurement without differential correction"); - break; - - case 1: - printf ("Differential correction applied"); - break; - - default: - printf ("%u", (unsigned) fGPSDifferential); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in Interoperability IFD - -bool dng_exif::Parse_interoperability (dng_stream &stream, - dng_shared & /* shared */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 /* tagOffset */) - { - - switch (tagCode) - { - - case tcInteroperabilityIndex: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fInteroperabilityIndex); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("InteroperabilityIndex: "); - - DumpString (fInteroperabilityIndex); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcInteroperabilityVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fInteroperabilityVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - - real64 x = (b0 - '0') * 10.00 + - (b1 - '0') * 1.00 + - (b2 - '0') * 0.10 + - (b3 - '0') * 0.01; - - printf ("InteroperabilityVersion: %0.2f\n", x); - - } - - #endif - - break; - - } - - case tcRelatedImageFileFormat: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fRelatedImageFileFormat); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RelatedImageFileFormat: "); - - DumpString (fRelatedImageFileFormat); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcRelatedImageWidth: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fRelatedImageWidth = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("RelatedImageWidth: %u\n", (unsigned) fRelatedImageWidth); - } - - #endif - - break; - - } - - case tcRelatedImageLength: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fRelatedImageLength = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("RelatedImageLength: %u\n", (unsigned) fRelatedImageLength); - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_exif::PostParse (dng_host & /* host */, - dng_shared & /* shared */) - { - - #if qDNGValidate - - const real64 kAPEX_Slop = 0.25; - - // Sanity check on MaxApertureValue. - - if (fMaxApertureValue.d) - { - - real64 mav = fMaxApertureValue.As_real64 (); - - // Compare against ApertureValue or FNumber. - - real64 av = mav; - - if (fApertureValue.d) - { - - av = fApertureValue.As_real64 (); - - } - - else if (fFNumber.d) - { - - real64 fs = fFNumber.As_real64 (); - - if (fs >= 1.0) - { - - av = FNumberToApertureValue (fs); - - } - - } - - if (mav > av + kAPEX_Slop) - { - - ReportWarning ("MaxApertureValue conflicts with ApertureValue and/or FNumber"); - - } - - // Compare against LensInfo - - if (fLensInfo [2].d && fLensInfo [3].d) - { - - real64 fs1 = fLensInfo [2].As_real64 (); - real64 fs2 = fLensInfo [3].As_real64 (); - - if (fs1 >= 1.0 && fs2 >= 1.0 && fs2 >= fs1) - { - - real64 av1 = FNumberToApertureValue (fs1); - real64 av2 = FNumberToApertureValue (fs2); - - // Wide angle adapters might create an effective - // wide FS, and tele-extenders always result - // in a higher FS. - - if (mav < av1 - kAPEX_Slop - 1.0 || - mav > av2 + kAPEX_Slop + 2.0) - { - - ReportWarning ("Possible MaxApertureValue conflict with LensInfo"); - - } - - } - - } - - } - - // Sanity check on FocalLength. - - if (fFocalLength.d) - { - - real64 fl = fFocalLength.As_real64 (); - - if (fl < 1.0) - { - - ReportWarning ("FocalLength is less than 1.0 mm (legal but unlikely)"); - - } - - else if (fLensInfo [0].d && fLensInfo [1].d) - { - - real64 minFL = fLensInfo [0].As_real64 (); - real64 maxFL = fLensInfo [1].As_real64 (); - - // Allow for wide-angle converters and tele-extenders. - - if (fl < minFL * 0.6 || - fl > maxFL * 2.1) - { - - ReportWarning ("Possible FocalLength conflict with LensInfo"); - - } - - } - - } - - #endif - - // Mirror DateTimeOriginal to DateTime. - - if (fDateTime.NotValid () && fDateTimeOriginal.IsValid ()) - { - - fDateTime = fDateTimeOriginal; - - } - - // Mirror EXIF 2.3 sensitivity tags to ISOSpeedRatings. - - if (fISOSpeedRatings [0] == 0 || fISOSpeedRatings [0] == 65535) - { - - // Prefer Recommended Exposure Index, then Standard Output Sensitivity, then - // ISO Speed, then Exposure Index. - - if (fRecommendedExposureIndex != 0 && - (fSensitivityType == stRecommendedExposureIndex || - fSensitivityType == stSOSandREI || - fSensitivityType == stREIandISOSpeed || - fSensitivityType == stSOSandREIandISOSpeed)) - { - - fISOSpeedRatings [0] = fRecommendedExposureIndex; - - } - - else if (fStandardOutputSensitivity != 0 && - (fSensitivityType == stStandardOutputSensitivity || - fSensitivityType == stSOSandREI || - fSensitivityType == stSOSandISOSpeed || - fSensitivityType == stSOSandREIandISOSpeed)) - { - - fISOSpeedRatings [0] = fStandardOutputSensitivity; - - } - - else if (fISOSpeed != 0 && - (fSensitivityType == stISOSpeed || - fSensitivityType == stSOSandISOSpeed || - fSensitivityType == stREIandISOSpeed || - fSensitivityType == stSOSandREIandISOSpeed)) - { - - fISOSpeedRatings [0] = fISOSpeed; - - } - - } - - // Mirror ExposureIndex to ISOSpeedRatings. - - if (fExposureIndex.IsValid () && fISOSpeedRatings [0] == 0) - { - - fISOSpeedRatings [0] = Round_uint32 (fExposureIndex.As_real64 ()); - - } - - // Kodak sets the GPSAltitudeRef without setting the GPSAltitude. - - if (fGPSAltitude.NotValid ()) - { - - fGPSAltitudeRef = 0xFFFFFFFF; - - } - - // If there is no valid GPS data, clear the GPS version number. - - if (fGPSLatitude [0].NotValid () && - fGPSLongitude [0].NotValid () && - fGPSAltitude .NotValid () && - fGPSTimeStamp [0].NotValid () && - fGPSDateStamp .IsEmpty ()) - { - - fGPSVersionID = 0; - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_exif.h b/third_party/dng_sdk/dng_exif.h deleted file mode 100644 index a85fc7d..0000000 --- a/third_party/dng_sdk/dng_exif.h +++ /dev/null @@ -1,351 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_exif.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * EXIF read access support. See the \ref spec_exif "EXIF specification" for full - * description of tags. - */ - -/*****************************************************************************/ - -#ifndef __dng_exif__ -#define __dng_exif__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_date_time.h" -#include "dng_fingerprint.h" -#include "dng_types.h" -#include "dng_matrix.h" -#include "dng_rational.h" -#include "dng_string.h" -#include "dng_stream.h" -#include "dng_sdk_limits.h" - -/*****************************************************************************/ - -/// \brief Container class for parsing and holding EXIF tags. -/// -/// Public member fields are documented in \ref spec_exif "EXIF specification." - -class dng_exif - { - - public: - - dng_string fImageDescription; - dng_string fMake; - dng_string fModel; - dng_string fSoftware; - dng_string fArtist; - dng_string fCopyright; - dng_string fCopyright2; - dng_string fUserComment; - - dng_date_time_info fDateTime; - dng_date_time_storage_info fDateTimeStorageInfo; - - dng_date_time_info fDateTimeOriginal; - dng_date_time_storage_info fDateTimeOriginalStorageInfo; - - dng_date_time_info fDateTimeDigitized; - dng_date_time_storage_info fDateTimeDigitizedStorageInfo; - - uint32 fTIFF_EP_StandardID; - uint32 fExifVersion; - uint32 fFlashPixVersion; - - dng_urational fExposureTime; - dng_urational fFNumber; - dng_srational fShutterSpeedValue; - dng_urational fApertureValue; - dng_srational fBrightnessValue; - dng_srational fExposureBiasValue; - dng_urational fMaxApertureValue; - dng_urational fFocalLength; - dng_urational fDigitalZoomRatio; - dng_urational fExposureIndex; - dng_urational fSubjectDistance; - dng_urational fGamma; - - dng_urational fBatteryLevelR; - dng_string fBatteryLevelA; - - uint32 fExposureProgram; - uint32 fMeteringMode; - uint32 fLightSource; - uint32 fFlash; - uint32 fFlashMask; - uint32 fSensingMethod; - uint32 fColorSpace; - uint32 fFileSource; - uint32 fSceneType; - uint32 fCustomRendered; - uint32 fExposureMode; - uint32 fWhiteBalance; - uint32 fSceneCaptureType; - uint32 fGainControl; - uint32 fContrast; - uint32 fSaturation; - uint32 fSharpness; - uint32 fSubjectDistanceRange; - uint32 fSelfTimerMode; - uint32 fImageNumber; - - uint32 fFocalLengthIn35mmFilm; - - uint32 fISOSpeedRatings [3]; // EXIF 2.3: PhotographicSensitivity. - - // Sensitivity tags added in EXIF 2.3. - - uint32 fSensitivityType; - uint32 fStandardOutputSensitivity; - uint32 fRecommendedExposureIndex; - uint32 fISOSpeed; - uint32 fISOSpeedLatitudeyyy; - uint32 fISOSpeedLatitudezzz; - - uint32 fSubjectAreaCount; - uint32 fSubjectArea [4]; - - uint32 fComponentsConfiguration; - - dng_urational fCompresssedBitsPerPixel; - - uint32 fPixelXDimension; - uint32 fPixelYDimension; - - dng_urational fFocalPlaneXResolution; - dng_urational fFocalPlaneYResolution; - - uint32 fFocalPlaneResolutionUnit; - - uint32 fCFARepeatPatternRows; - uint32 fCFARepeatPatternCols; - - uint8 fCFAPattern [kMaxCFAPattern] [kMaxCFAPattern]; - - dng_fingerprint fImageUniqueID; - - uint32 fGPSVersionID; - dng_string fGPSLatitudeRef; - dng_urational fGPSLatitude [3]; - dng_string fGPSLongitudeRef; - dng_urational fGPSLongitude [3]; - uint32 fGPSAltitudeRef; - dng_urational fGPSAltitude; - dng_urational fGPSTimeStamp [3]; - dng_string fGPSSatellites; - dng_string fGPSStatus; - dng_string fGPSMeasureMode; - dng_urational fGPSDOP; - dng_string fGPSSpeedRef; - dng_urational fGPSSpeed; - dng_string fGPSTrackRef; - dng_urational fGPSTrack; - dng_string fGPSImgDirectionRef; - dng_urational fGPSImgDirection; - dng_string fGPSMapDatum; - dng_string fGPSDestLatitudeRef; - dng_urational fGPSDestLatitude [3]; - dng_string fGPSDestLongitudeRef; - dng_urational fGPSDestLongitude [3]; - dng_string fGPSDestBearingRef; - dng_urational fGPSDestBearing; - dng_string fGPSDestDistanceRef; - dng_urational fGPSDestDistance; - dng_string fGPSProcessingMethod; - dng_string fGPSAreaInformation; - dng_string fGPSDateStamp; - uint32 fGPSDifferential; - dng_urational fGPSHPositioningError; - - dng_string fInteroperabilityIndex; - - uint32 fInteroperabilityVersion; - - dng_string fRelatedImageFileFormat; - - uint32 fRelatedImageWidth; - uint32 fRelatedImageLength; - - dng_string fCameraSerialNumber; // EXIF 2.3: BodySerialNumber. - - dng_urational fLensInfo [4]; // EXIF 2.3: LensSpecification. - - dng_string fLensID; - dng_string fLensMake; - dng_string fLensName; // EXIF 2.3: LensModel. - dng_string fLensSerialNumber; - - // Was the lens name field read from a LensModel tag? - - bool fLensNameWasReadFromExif; - - // Private field to hold the approximate focus distance of the lens, in - // meters. This value is often coarsely measured/reported and hence should be - // interpreted only as a rough estimate of the true distance from the plane - // of focus (in object space) to the focal plane. It is still useful for the - // purposes of applying lens corrections. - - dng_urational fApproxFocusDistance; - - dng_srational fFlashCompensation; - - dng_string fOwnerName; // EXIF 2.3: CameraOwnerName. - dng_string fFirmware; - - public: - - dng_exif (); - - virtual ~dng_exif (); - - /// Make clone. - - virtual dng_exif * Clone () const; - - /// Clear all EXIF fields. - - void SetEmpty (); - - /// Copy all GPS-related fields. - /// \param exif Source object from which to copy GPS fields. - - void CopyGPSFrom (const dng_exif &exif); - - /// Utility to fix up common errors and rounding issues with EXIF exposure - /// times. - - static real64 SnapExposureTime (real64 et); - - /// Set exposure time and shutter speed fields. Optionally fix up common - /// errors and rounding issues with EXIF exposure times. - /// \param et Exposure time in seconds. - /// \param snap Set to true to fix up common errors and rounding issues with - /// EXIF exposure times. - - void SetExposureTime (real64 et, - bool snap = true); - - /// Set shutter speed value (APEX units) and exposure time. - /// \param Shutter speed in APEX units. - - void SetShutterSpeedValue (real64 ss); - - /// Utility to encode f-number as a rational. - /// \param fs The f-number to encode. - - static dng_urational EncodeFNumber (real64 fs); - - /// Set the FNumber and ApertureValue fields. - /// \param fs The f-number to set. - - void SetFNumber (real64 fs); - - /// Set the FNumber and ApertureValue fields. - /// \param av The aperture value (APEX units). - - void SetApertureValue (real64 av); - - /// Utility to convert aperture value (APEX units) to f-number. - /// \param av The aperture value (APEX units) to convert. - - static real64 ApertureValueToFNumber (real64 av); - - /// Utility to convert aperture value (APEX units) to f-number. - /// \param av The aperture value (APEX units) to convert. - - static real64 ApertureValueToFNumber (const dng_urational &av); - - /// Utility to convert f-number to aperture value (APEX units). - /// \param fNumber The f-number to convert. - - static real64 FNumberToApertureValue (real64 fNumber); - - /// Utility to convert f-number to aperture value (APEX units). - /// \param fNumber The f-number to convert. - - static real64 FNumberToApertureValue (const dng_urational &fNumber); - - /// Set the DateTime field. - /// \param dt The DateTime value. - - void UpdateDateTime (const dng_date_time_info &dt); - - /// Returns true iff the EXIF version is at least 2.3. - - bool AtLeastVersion0230 () const; - - virtual bool ParseTag (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - bool isMainIFD, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual void PostParse (dng_host &host, - dng_shared &shared); - - protected: - - virtual bool Parse_ifd0 (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual bool Parse_ifd0_main (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual bool Parse_ifd0_exif (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual bool Parse_gps (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual bool Parse_interoperability (dng_stream &stream, - dng_shared &shared, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_fast_module.h b/third_party/dng_sdk/dng_fast_module.h deleted file mode 100644 index ee6a10f..0000000 --- a/third_party/dng_sdk/dng_fast_module.h +++ /dev/null @@ -1,31 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_fast_module.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Include file to set optimization to highest level for performance-critical routines. - * Normal files should have otpimization set to normal level to save code size as there is less - * cache pollution this way. - */ - -/*****************************************************************************/ - -// Include this file in modules that contain routines that should be as fast -// as possible, even at the expense of slight code size increases. - -/*****************************************************************************/ - -#ifdef _MSC_VER -#pragma optimize ("t", on) -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_file_stream.cpp b/third_party/dng_sdk/dng_file_stream.cpp deleted file mode 100644 index 4a8a79f..0000000 --- a/third_party/dng_sdk/dng_file_stream.cpp +++ /dev/null @@ -1,135 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_file_stream.cpp#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_file_stream.h" - -#include "dng_exceptions.h" - -/*****************************************************************************/ - -dng_file_stream::dng_file_stream (const char *filename, - bool output, - uint32 bufferSize) - - : dng_stream ((dng_abort_sniffer *) NULL, - bufferSize, - 0) - - , fFile (NULL) - - { - - fFile = fopen (filename, output ? "wb" : "rb"); - - if (!fFile) - { - - #if qDNGValidate - - ReportError ("Unable to open file", - filename); - - ThrowSilentError (); - - #else - - ThrowOpenFile (); - - #endif - - } - - } - -/*****************************************************************************/ - -dng_file_stream::~dng_file_stream () - { - - if (fFile) - { - fclose (fFile); - fFile = NULL; - } - - } - -/*****************************************************************************/ - -uint64 dng_file_stream::DoGetLength () - { - - if (fseek (fFile, 0, SEEK_END) != 0) - { - - ThrowReadFile (); - - } - - return (uint64) ftell (fFile); - - } - -/*****************************************************************************/ - -void dng_file_stream::DoRead (void *data, - uint32 count, - uint64 offset) - { - - if (fseek (fFile, (long) offset, SEEK_SET) != 0) - { - - ThrowReadFile (); - - } - - uint32 bytesRead = (uint32) fread (data, 1, count, fFile); - - if (bytesRead != count) - { - - ThrowReadFile (); - - } - - } - -/*****************************************************************************/ - -void dng_file_stream::DoWrite (const void *data, - uint32 count, - uint64 offset) - { - - if (fseek (fFile, (uint32) offset, SEEK_SET) != 0) - { - - ThrowWriteFile (); - - } - - uint32 bytesWritten = (uint32) fwrite (data, 1, count, fFile); - - if (bytesWritten != count) - { - - ThrowWriteFile (); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_file_stream.h b/third_party/dng_sdk/dng_file_stream.h deleted file mode 100644 index 2326c4e..0000000 --- a/third_party/dng_sdk/dng_file_stream.h +++ /dev/null @@ -1,77 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_file_stream.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Simple, portable, file read/write support. - */ - -/*****************************************************************************/ - -#ifndef __dng_file_stream__ -#define __dng_file_stream__ - -/*****************************************************************************/ - -#include "dng_stream.h" - -/*****************************************************************************/ - -/// \brief A stream to/from a disk file. See dng_stream for read/write interface - -class dng_file_stream: public dng_stream - { - - private: - - FILE *fFile; - - public: - - /// Open a stream on a file. - /// \param filename Pathname in platform synax. - /// \param output Set to true if writing, false otherwise. - /// \param bufferSize size of internal buffer to use. Defaults to 4k. - - dng_file_stream (const char *filename, - bool output = false, - uint32 bufferSize = kDefaultBufferSize); - - virtual ~dng_file_stream (); - - protected: - - virtual uint64 DoGetLength (); - - virtual void DoRead (void *data, - uint32 count, - uint64 offset); - - virtual void DoWrite (const void *data, - uint32 count, - uint64 offset); - - private: - - // Hidden copy constructor and assignment operator. - - dng_file_stream (const dng_file_stream &stream); - - dng_file_stream & operator= (const dng_file_stream &stream); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_filter_task.cpp b/third_party/dng_sdk/dng_filter_task.cpp deleted file mode 100644 index f8fc560..0000000 --- a/third_party/dng_sdk/dng_filter_task.cpp +++ /dev/null @@ -1,167 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_filter_task.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_filter_task.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_image.h" -#include "dng_memory.h" -#include "dng_tag_types.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_filter_task::dng_filter_task (const dng_image &srcImage, - dng_image &dstImage) - - : fSrcImage (srcImage) - , fDstImage (dstImage) - - , fSrcPlane (0 ) - , fSrcPlanes (srcImage.Planes ()) - , fSrcPixelType (srcImage.PixelType ()) - - , fDstPlane (0 ) - , fDstPlanes (dstImage.Planes ()) - , fDstPixelType (dstImage.PixelType ()) - - , fSrcRepeat (1, 1) - - { - - } - -/*****************************************************************************/ - -dng_filter_task::~dng_filter_task () - { - - } - -/*****************************************************************************/ - -void dng_filter_task::Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer * /* sniffer */) - { - - dng_point srcTileSize = SrcTileSize (tileSize); - - uint32 srcPixelSize = TagTypeSize (fSrcPixelType); - - uint32 srcBufferSize = srcTileSize.v * - RoundUpForPixelSize (srcTileSize.h, srcPixelSize) * - srcPixelSize * - fSrcPlanes; - - uint32 dstPixelSize = TagTypeSize (fDstPixelType); - - uint32 dstBufferSize = tileSize.v * - RoundUpForPixelSize (tileSize.h, dstPixelSize) * - dstPixelSize * - fDstPlanes; - - for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) - { - - fSrcBuffer [threadIndex] . Reset (allocator->Allocate (srcBufferSize)); - - fDstBuffer [threadIndex] . Reset (allocator->Allocate (dstBufferSize)); - - // Zero buffers so any pad bytes have defined values. - - DoZeroBytes (fSrcBuffer [threadIndex]->Buffer (), - fSrcBuffer [threadIndex]->LogicalSize ()); - - DoZeroBytes (fDstBuffer [threadIndex]->Buffer (), - fDstBuffer [threadIndex]->LogicalSize ()); - - } - - } - -/*****************************************************************************/ - -void dng_filter_task::Process (uint32 threadIndex, - const dng_rect &area, - dng_abort_sniffer * /* sniffer */) - { - - // Find source area for this destination area. - - dng_rect srcArea = SrcArea (area); - - // Setup srcBuffer. - - dng_pixel_buffer srcBuffer; - - srcBuffer.fArea = srcArea; - - srcBuffer.fPlane = fSrcPlane; - srcBuffer.fPlanes = fSrcPlanes; - - srcBuffer.fPixelType = fSrcPixelType; - srcBuffer.fPixelSize = TagTypeSize (fSrcPixelType); - - srcBuffer.fPlaneStep = RoundUpForPixelSize (srcArea.W (), - srcBuffer.fPixelSize); - - srcBuffer.fRowStep = srcBuffer.fPlaneStep * - srcBuffer.fPlanes; - - srcBuffer.fData = fSrcBuffer [threadIndex]->Buffer (); - - // Setup dstBuffer. - - dng_pixel_buffer dstBuffer; - - dstBuffer.fArea = area; - - dstBuffer.fPlane = fDstPlane; - dstBuffer.fPlanes = fDstPlanes; - - dstBuffer.fPixelType = fDstPixelType; - dstBuffer.fPixelSize = TagTypeSize (fDstPixelType); - - dstBuffer.fPlaneStep = RoundUpForPixelSize (area.W (), - dstBuffer.fPixelSize); - - dstBuffer.fRowStep = dstBuffer.fPlaneStep * - dstBuffer.fPlanes; - - dstBuffer.fData = fDstBuffer [threadIndex]->Buffer (); - - // Get source pixels. - - fSrcImage.Get (srcBuffer, - dng_image::edge_repeat, - fSrcRepeat.v, - fSrcRepeat.h); - - // Process area. - - ProcessArea (threadIndex, - srcBuffer, - dstBuffer); - - // Save result pixels. - - fDstImage.Put (dstBuffer); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_filter_task.h b/third_party/dng_sdk/dng_filter_task.h deleted file mode 100644 index e5f932d..0000000 --- a/third_party/dng_sdk/dng_filter_task.h +++ /dev/null @@ -1,157 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_filter_task.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Specialization of dng_area_task for processing an area from one dng_image to an - * area of another. - */ - -/*****************************************************************************/ - -#ifndef __dng_filter_task__ -#define __dng_filter_task__ - -/*****************************************************************************/ - -#include "dng_area_task.h" -#include "dng_auto_ptr.h" -#include "dng_point.h" -#include "dng_rect.h" -#include "dng_sdk_limits.h" - -/*****************************************************************************/ - -/// \brief Represents a task which filters an area of a source dng_image to an area -/// of a destination dng_image. - -class dng_filter_task: public dng_area_task - { - - protected: - - const dng_image &fSrcImage; - - dng_image &fDstImage; - - uint32 fSrcPlane; - uint32 fSrcPlanes; - uint32 fSrcPixelType; - - uint32 fDstPlane; - uint32 fDstPlanes; - uint32 fDstPixelType; - - dng_point fSrcRepeat; - - AutoPtr fSrcBuffer [kMaxMPThreads]; - AutoPtr fDstBuffer [kMaxMPThreads]; - - public: - - /// Construct a filter task given a source and destination images. - /// \param srcImage Image from which source pixels are read. - /// \param dstImage Image to which result pixels are written. - - dng_filter_task (const dng_image &srcImage, - dng_image &dstImage); - - virtual ~dng_filter_task (); - - /// Compute the source area needed for a given destination area. Default - /// implementation assumes destination area is equal to source area for all - /// cases. - /// - /// \param dstArea Area to for which pixels will be computed. - /// - /// \retval The source area needed as input to calculate the requested - /// destination area. - - virtual dng_rect SrcArea (const dng_rect &dstArea) - { - return dstArea; - } - - /// Given a destination tile size, calculate input tile size. Simlar to - /// SrcArea, and should seldom be overridden. - /// - /// \param dstTileSize The destination tile size that is targeted for output. - /// - /// \retval The source tile size needed to compute a tile of the destination - /// size. - - virtual dng_point SrcTileSize (const dng_point &dstTileSize) - { - return SrcArea (dng_rect (dstTileSize)).Size (); - } - - /// Implements filtering operation from one buffer to another. Source and - /// destination pixels are set up in member fields of this class. Ideally, no - /// allocation should be done in this routine. - /// - /// \param threadIndex The thread on which this routine is being called, - /// between 0 and threadCount - 1 for the threadCount passed to Start method. - /// - /// \param srcBuffer Input area and source pixels. - /// - /// \param dstBuffer Output area and destination pixels. - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) = 0; - - /// Called prior to processing on specific threads. Can be used to allocate - /// per-thread memory buffers, etc. - /// - /// \param threadCount Total number of threads that will be used for - /// processing. Less than or equal to MaxThreads of dng_area_task. - /// - /// \param tileSize Size of source tiles which will be processed. (Not all - /// tiles will be this size due to edge conditions.) - /// - /// \param allocator dng_memory_allocator to use for allocating temporary - /// buffers, etc. - /// - /// \param sniffer Sniffer to test for user cancellation and to set up - /// progress. - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer); - - /// Process one tile or partitioned area. Should not be overridden. Instead, - /// override ProcessArea, which is where to implement filter processing for a - /// specific type of dng_filter_task. There is no allocator parameter as all - /// allocation should be done in Start. - /// - /// \param threadIndex 0 to threadCount - 1 index indicating which thread - /// this is. (Can be used to get a thread-specific buffer allocated in the - /// Start method.) - /// - /// \param area Size of tiles to be used for sizing buffers, etc. (Edges of - /// processing can be smaller.) - /// - /// \param sniffer dng_abort_sniffer to use to check for user cancellation - /// and progress updates. - - virtual void Process (uint32 threadIndex, - const dng_rect &area, - dng_abort_sniffer *sniffer); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_fingerprint.cpp b/third_party/dng_sdk/dng_fingerprint.cpp deleted file mode 100644 index 5256873..0000000 --- a/third_party/dng_sdk/dng_fingerprint.cpp +++ /dev/null @@ -1,589 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_fingerprint.cpp#3 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_fingerprint.h" - -#include "dng_assertions.h" -#include "dng_flags.h" - -/*****************************************************************************/ - -dng_fingerprint::dng_fingerprint () - { - - for (uint32 j = 0; j < 16; j++) - { - - data [j] = 0; - - } - - } - -/*****************************************************************************/ - -bool dng_fingerprint::IsNull () const - { - - for (uint32 j = 0; j < 16; j++) - { - - if (data [j] != 0) - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_fingerprint::operator== (const dng_fingerprint &print) const - { - - for (uint32 j = 0; j < 16; j++) - { - - if (data [j] != print.data [j]) - { - - return false; - - } - - } - - return true; - - } - -/******************************************************************************/ - -uint32 dng_fingerprint::Collapse32 () const - { - - uint32 x = 0; - - for (uint32 j = 0; j < 4; j++) - { - - uint32 y = 0; - - for (uint32 k = 0; k < 4; k++) - { - - y = (y << 8) + (uint32) data [j * 4 + k]; - - } - - x = x ^ y; - - } - - return x; - - } - -/******************************************************************************/ - -static char NumToHexChar (unsigned int c) - { - - if (c < 10) - { - return (char) ('0' + c); - } - - else - { - return (char) ('A' + c - 10); - } - - } - -/*****************************************************************************/ - -void dng_fingerprint::ToUtf8HexString (char resultStr [2 * kDNGFingerprintSize + 1]) const - { - - for (size_t i = 0; i < kDNGFingerprintSize; i++) - { - - unsigned char c = data [i]; - - resultStr [i * 2] = NumToHexChar (c >> 4); - resultStr [i * 2 + 1] = NumToHexChar (c & 15); - - } - - resultStr [kDNGFingerprintSize * 2] = '\0'; - - } - -/******************************************************************************/ - -static int HexCharToNum (char hexChar) - { - - if (hexChar >= '0' && hexChar <= '9') - { - return hexChar - '0'; - } - - else if (hexChar >= 'A' && hexChar <= 'F') - { - return hexChar - 'A' + 10; - } - - else if (hexChar >= 'a' && hexChar <= 'f') - { - return hexChar - 'a' + 10; - } - - return -1; - - } - -/*****************************************************************************/ - -bool dng_fingerprint::FromUtf8HexString (const char inputStr [2 * kDNGFingerprintSize + 1]) - { - - for (size_t i = 0; i < kDNGFingerprintSize; i++) - { - - int highNibble = HexCharToNum (inputStr [i * 2]); - - if (highNibble < 0) - { - return false; - } - - int lowNibble = HexCharToNum (inputStr [i * 2 + 1]); - - if (lowNibble < 0) - { - return false; - } - - data [i] = (uint8) ((highNibble << 4) + lowNibble); - - } - - return true; - - } - -/******************************************************************************/ - -// Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm - -// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All -// rights reserved. -// -// License to copy and use this software is granted provided that it -// is identified as the "RSA Data Security, Inc. MD5 Message-Digest -// Algorithm" in all material mentioning or referencing this software -// or this function. -// -// License is also granted to make and use derivative works provided -// that such works are identified as "derived from the RSA Data -// Security, Inc. MD5 Message-Digest Algorithm" in all material -// mentioning or referencing the derived work. -// -// RSA Data Security, Inc. makes no representations concerning either -// the merchantability of this software or the suitability of this -// software for any particular purpose. It is provided "as is" -// without express or implied warranty of any kind. -// -// These notices must be retained in any copies of any part of this -// documentation and/or software. - -/******************************************************************************/ - -dng_md5_printer::dng_md5_printer () - - : final (false) - , result () - - { - - Reset (); - - } - -/******************************************************************************/ - -void dng_md5_printer::Reset () - { - - // No bits processed yet. - - count [0] = 0; - count [1] = 0; - - // Load magic initialization constants. - - state [0] = 0x67452301; - state [1] = 0xefcdab89; - state [2] = 0x98badcfe; - state [3] = 0x10325476; - - // Not finalized yet. - - final = false; - - } - -/******************************************************************************/ - -void dng_md5_printer::Process (const void *data, - uint32 inputLen) - { - - DNG_ASSERT (!final, "Fingerprint already finalized!"); - - const uint8 *input = (const uint8 *) data; - - // Compute number of bytes mod 64 - - uint32 index = (count [0] >> 3) & 0x3F; - - // Update number of bits - - if ((count [0] += inputLen << 3) < (inputLen << 3)) - { - count [1]++; - } - - count [1] += inputLen >> 29; - - // Transform as many times as possible. - - uint32 i = 0; - - uint32 partLen = 64 - index; - - if (inputLen >= partLen) - { - - memcpy (&buffer [index], - input, - partLen); - - MD5Transform (state, buffer); - - for (i = partLen; i + 63 < inputLen; i += 64) - { - - MD5Transform (state, &input [i]); - - } - - index = 0; - - } - - // Buffer remaining input - - memcpy (&buffer [index], - &input [i], - inputLen - i); - - } - -/******************************************************************************/ - -const dng_fingerprint & dng_md5_printer::Result () - { - - if (!final) - { - - static uint8 PADDING [64] = - { - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 - }; - - // Save number of bits - - uint8 bits [8]; - - Encode (bits, count, 8); - - // Pad out to 56 mod 64. - - uint32 index = (count [0] >> 3) & 0x3f; - - uint32 padLen = (index < 56) ? (56 - index) : (120 - index); - - Process (PADDING, padLen); - - // Append length (before padding) - - Process (bits, 8); - - // Store state in digest - - Encode (result.data, state, 16); - - // We are now finalized. - - final = true; - - } - - return result; - - } - -/******************************************************************************/ - -// Encodes input (uint32) into output (uint8). Assumes len is -// a multiple of 4. - -void dng_md5_printer::Encode (uint8 *output, - const uint32 *input, - uint32 len) - { - - uint32 i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) - { - output [j ] = (uint8) ((input [i] ) & 0xff); - output [j+1] = (uint8) ((input [i] >> 8) & 0xff); - output [j+2] = (uint8) ((input [i] >> 16) & 0xff); - output [j+3] = (uint8) ((input [i] >> 24) & 0xff); - } - - } - -/******************************************************************************/ - -// Decodes input (uint8) into output (uint32). Assumes len is -// a multiple of 4. - -void dng_md5_printer::Decode (uint32 *output, - const uint8 *input, - uint32 len) - { - - // Check for non-aligned case. - - if (((uintptr) input) & 3) - { - - uint32 i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) - { - - output [i] = (((uint32) input [j ]) ) | - (((uint32) input [j+1]) << 8) | - (((uint32) input [j+2]) << 16) | - (((uint32) input [j+3]) << 24); - - } - - } - - // Else use optimized code for aligned case. - - else - { - - len = len >> 2; - - const uint32 *sPtr = (const uint32 *) input; - - uint32 *dPtr = output; - - while (len--) - { - - #if qDNGBigEndian - - uint32 data = *(sPtr++); - - data = (data >> 24) | - ((data >> 8) & 0x0000FF00) | - ((data << 8) & 0x00FF0000) | - (data << 24); - - *(dPtr++) = data; - - #else - - *(dPtr++) = *(sPtr++); - - #endif - - } - - } - - } - -/******************************************************************************/ - -// MD5 basic transformation. Transforms state based on block. - -void dng_md5_printer::MD5Transform (uint32 state [4], - const uint8 block [64]) - { - - enum - { - S11 = 7, - S12 = 12, - S13 = 17, - S14 = 22, - S21 = 5, - S22 = 9, - S23 = 14, - S24 = 20, - S31 = 4, - S32 = 11, - S33 = 16, - S34 = 23, - S41 = 6, - S42 = 10, - S43 = 15, - S44 = 21 - }; - - #if qDNGBigEndian - - uint32 x [16]; - - Decode (x, block, 64); - - #else - - uint32 temp [16]; - - const uint32 *x; - - if (((uintptr) block) & 3) - { - - Decode (temp, block, 64); - - x = temp; - - } - - else - x = (const uint32 *) block; - - #endif - - uint32 a = state [0]; - uint32 b = state [1]; - uint32 c = state [2]; - uint32 d = state [3]; - - /* Round 1 */ - FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ - FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ - FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ - FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ - FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ - FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ - FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ - FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ - FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ - FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ - FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ - FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ - FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ - FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ - FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ - FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ - - /* Round 2 */ - GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ - GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ - GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ - GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ - GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ - GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ - GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ - GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ - GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ - GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ - GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ - GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ - GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ - GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ - GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ - GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ - - /* Round 3 */ - HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ - HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ - HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ - HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ - HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ - HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ - HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ - HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ - HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ - HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ - HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ - HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ - HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ - HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ - HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ - HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ - - /* Round 4 */ - II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ - II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ - II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ - II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ - II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ - II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ - II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ - II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ - II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ - II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ - II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ - II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ - II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ - II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ - II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ - II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ - - state [0] += a; - state [1] += b; - state [2] += c; - state [3] += d; - - } - -/*****************************************************************************/ - -// End of RSA Data Security, Inc. derived code. - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_fingerprint.h b/third_party/dng_sdk/dng_fingerprint.h deleted file mode 100644 index b8c5cfb..0000000 --- a/third_party/dng_sdk/dng_fingerprint.h +++ /dev/null @@ -1,377 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_fingerprint.h#2 $ */ -/* $DateTime: 2012/07/11 10:36:56 $ */ -/* $Change: 838485 $ */ -/* $Author: tknoll $ */ - -/** \file - * Fingerprint (cryptographic hashing) support for generating strong hashes of image - * data. - */ - -/*****************************************************************************/ - -#ifndef __dng_fingerprint__ -#define __dng_fingerprint__ - -/*****************************************************************************/ - -#include "dng_exceptions.h" -#include "dng_types.h" -#include "dng_stream.h" - -#include - -/*****************************************************************************/ - -/// \brief Container fingerprint (MD5 only at present). - -class dng_fingerprint - { - - public: - - static const size_t kDNGFingerprintSize = 16; - - uint8 data [kDNGFingerprintSize]; - - public: - - dng_fingerprint (); - - /// Check if fingerprint is all zeros. - - bool IsNull () const; - - /// Same as IsNull but expresses intention of testing validity. - - bool IsValid () const - { - return !IsNull (); - } - - /// Set to all zeros, a value used to indicate an invalid fingerprint. - - void Clear () - { - *this = dng_fingerprint (); - } - - /// Test if two fingerprints are equal. - - bool operator== (const dng_fingerprint &print) const; - - /// Test if two fingerprints are not equal. - - bool operator!= (const dng_fingerprint &print) const - { - return !(*this == print); - } - - /// Produce a 32-bit hash value from fingerprint used for faster hashing of - /// fingerprints. - - uint32 Collapse32 () const; - - /// Convert fingerprint to UTF-8 string. - /// - /// \param resultStr The output array to which the UTF-8 encoding of the - /// fingerprint will be written. - - void ToUtf8HexString (char resultStr [2 * kDNGFingerprintSize + 1]) const; - - /// Convert UTF-8 string to fingerprint. Returns true on success, false on - /// failure. - /// - /// \param inputStr The input array from which the UTF-8 encoding of the - /// fingerprint will be read. - /// - /// \retval True indicates success. - - bool FromUtf8HexString (const char inputStr [2 * kDNGFingerprintSize + 1]); - - }; - -/*****************************************************************************/ - -/// \brief Utility to compare fingerprints (e.g., for sorting). - -struct dng_fingerprint_less_than - { - - /// Less-than comparison. - - bool operator() (const dng_fingerprint &a, - const dng_fingerprint &b) const - { - - return memcmp (a.data, - b.data, - sizeof (a.data)) < 0; - - } - - }; - -/******************************************************************************/ - -// Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm. - -// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All -// rights reserved. -// -// License to copy and use this software is granted provided that it -// is identified as the "RSA Data Security, Inc. MD5 Message-Digest -// Algorithm" in all material mentioning or referencing this software -// or this function. -// -// License is also granted to make and use derivative works provided -// that such works are identified as "derived from the RSA Data -// Security, Inc. MD5 Message-Digest Algorithm" in all material -// mentioning or referencing the derived work. -// -// RSA Data Security, Inc. makes no representations concerning either -// the merchantability of this software or the suitability of this -// software for any particular purpose. It is provided "as is" -// without express or implied warranty of any kind. -// -// These notices must be retained in any copies of any part of this -// documentation and/or software. - -/// \brief Class to hash binary data to a fingerprint using the MD5 Message-Digest -/// Algorithm. - -class dng_md5_printer - { - - public: - - dng_md5_printer (); - - virtual ~dng_md5_printer () - { - } - - /// Reset the fingerprint. - - void Reset (); - - /// Append the data to the stream to be hashed. - /// \param data The data to be hashed. - /// \param inputLen The length of data, in bytes. - - void Process (const void *data, - uint32 inputLen); - - /// Append the string to the stream to be hashed. - /// \param text The string to be hashed. - - void Process (const char *text) - { - - Process (text, (uint32) strlen (text)); - - } - - /// Get the fingerprint (i.e., result of the hash). - - const dng_fingerprint & Result (); - - private: - - static void Encode (uint8 *output, - const uint32 *input, - uint32 len); - - static void Decode (uint32 *output, - const uint8 *input, - uint32 len); - - // F, G, H and I are basic MD5 functions. - - static inline uint32 F (uint32 x, - uint32 y, - uint32 z) - { - return (x & y) | (~x & z); - } - - static inline uint32 G (uint32 x, - uint32 y, - uint32 z) - { - return (x & z) | (y & ~z); - } - - static inline uint32 H (uint32 x, - uint32 y, - uint32 z) - { - return x ^ y ^ z; - } - - static inline uint32 I (uint32 x, - uint32 y, - uint32 z) - { - return y ^ (x | ~z); - } - - // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. - - static inline void FF (uint32 &a, - uint32 b, - uint32 c, - uint32 d, - uint32 x, - uint32 s, - uint32 ac) - { - a += F (b, c, d) + x + ac; - a = (a << s) | (a >> (32 - s)); - a += b; - } - - static inline void GG (uint32 &a, - uint32 b, - uint32 c, - uint32 d, - uint32 x, - uint32 s, - uint32 ac) - { - a += G (b, c, d) + x + ac; - a = (a << s) | (a >> (32 - s)); - a += b; - } - - static inline void HH (uint32 &a, - uint32 b, - uint32 c, - uint32 d, - uint32 x, - uint32 s, - uint32 ac) - { - a += H (b, c, d) + x + ac; - a = (a << s) | (a >> (32 - s)); - a += b; - } - - static inline void II (uint32 &a, - uint32 b, - uint32 c, - uint32 d, - uint32 x, - uint32 s, - uint32 ac) - { - a += I (b, c, d) + x + ac; - a = (a << s) | (a >> (32 - s)); - a += b; - } - - static void MD5Transform (uint32 state [4], - const uint8 block [64]); - - private: - - uint32 state [4]; - - uint32 count [2]; - - uint8 buffer [64]; - - bool final; - - dng_fingerprint result; - - }; - -/*****************************************************************************/ - -/// \brief A dng_stream based interface to the MD5 printing logic. - -class dng_md5_printer_stream : public dng_stream, dng_md5_printer - { - - private: - - uint64 fNextOffset; - - public: - - /// Create an empty MD5 printer stream. - - dng_md5_printer_stream () - - : fNextOffset (0) - - { - } - - virtual uint64 DoGetLength () - { - - return fNextOffset; - - } - - virtual void DoRead (void * /* data */, - uint32 /* count */, - uint64 /* offset */) - { - - ThrowProgramError (); - - } - - virtual void DoSetLength (uint64 length) - { - - if (length != fNextOffset) - { - ThrowProgramError (); - } - - } - - virtual void DoWrite (const void *data, - uint32 count2, - uint64 offset) - { - - if (offset != fNextOffset) - { - ThrowProgramError (); - } - - Process (data, count2); - - fNextOffset += count2; - - } - - const dng_fingerprint & Result () - { - - Flush (); - - return dng_md5_printer::Result (); - - } - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_flags.h b/third_party/dng_sdk/dng_flags.h deleted file mode 100644 index 1614568..0000000 --- a/third_party/dng_sdk/dng_flags.h +++ /dev/null @@ -1,271 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_flags.h#5 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Conditional compilation flags for DNG SDK. - * - * All conditional compilation macros for the DNG SDK begin with a lowercase 'q'. - */ - -/*****************************************************************************/ - -#ifndef __dng_flags__ -#define __dng_flags__ - -/*****************************************************************************/ - -/// \def qMacOS -/// 1 if compiling for Mac OS X. - -/// \def qWinOS -/// 1 if compiling for Windows. - -// Make sure qMacOS and qWinOS are defined. - -#if !defined(qMacOS) || !defined(qWinOS) -#include "RawEnvironment.h" -#endif - -#if !defined(qMacOS) || !defined(qWinOS) -#error Unable to figure out platform -#endif - -/*****************************************************************************/ - -// Platforms. - -#ifndef qImagecore -#define qImagecore 0 -#endif - -#ifndef qiPhone -#define qiPhone 0 -#endif - -#ifndef qiPhoneSimulator -#define qiPhoneSimulator 0 -#endif - -#ifndef qAndroid -#define qAndroid 0 -#endif - -#ifndef qAndroidArm7 -#define qAndroidArm7 0 -#endif - -/*****************************************************************************/ - -// Establish WIN32 and WIN64 definitions. - -#if defined(_WIN32) && !defined(WIN32) -#define WIN32 1 -#endif - -#if defined(_WIN64) && !defined(WIN64) -#define WIN64 1 -#endif - -/*****************************************************************************/ - -/// \def qDNGDebug -/// 1 if debug code is compiled in, 0 otherwise. Enables assertions and other debug -/// checks in exchange for slower processing. - -// Figure out if debug build or not. - -#ifndef qDNGDebug - -#if defined(Debug) -#define qDNGDebug Debug - -#elif defined(_DEBUG) -#define qDNGDebug _DEBUG - -#else -#define qDNGDebug 0 - -#endif -#endif - -/*****************************************************************************/ - -// Figure out byte order. - -/// \def qDNGBigEndian -/// 1 if this target platform is big endian (e.g. PowerPC Macintosh), else 0. -/// -/// \def qDNGLittleEndian -/// 1 if this target platform is little endian (e.g. x86 processors), else 0. - -#ifndef qDNGBigEndian - -#if defined(qDNGLittleEndian) -#define qDNGBigEndian !qDNGLittleEndian - -#elif defined(__POWERPC__) -#define qDNGBigEndian 1 - -#elif defined(__INTEL__) -#define qDNGBigEndian 0 - -#elif defined(_M_IX86) -#define qDNGBigEndian 0 - -#elif defined(_M_X64) || defined(__amd64__) -#define qDNGBigEndian 0 - -#elif defined(__LITTLE_ENDIAN__) -#define qDNGBigEndian 0 - -#elif defined(__BIG_ENDIAN__) -#define qDNGBigEndian 1 - -#elif defined(_ARM_) -#define qDNGBigEndian 0 - -#else - -#ifndef qXCodeRez -#error Unable to figure out byte order. -#endif - -#endif -#endif - -#ifndef qXCodeRez - -#ifndef qDNGLittleEndian -#define qDNGLittleEndian !qDNGBigEndian -#endif - -#endif - -/*****************************************************************************/ - -/// \def qDNG64Bit -/// 1 if this target platform uses 64-bit addresses, 0 otherwise. - -#ifndef qDNG64Bit - -#if qMacOS - -#ifdef __LP64__ -#if __LP64__ -#define qDNG64Bit 1 -#endif -#endif - -#elif qWinOS - -#ifdef WIN64 -#if WIN64 -#define qDNG64Bit 1 -#endif -#endif - -#endif - -#ifndef qDNG64Bit -#define qDNG64Bit 0 -#endif - -#endif - -/*****************************************************************************/ - -/// \def qDNGThreadSafe -/// 1 if target platform has thread support and threadsafe libraries, 0 otherwise. - -#ifndef qDNGThreadSafe -#define qDNGThreadSafe (qMacOS || qWinOS) -#endif - -/*****************************************************************************/ - -/// \def qDNGValidateTarget -/// 1 if dng_validate command line tool is being built, 0 otherwise. - -#ifndef qDNGValidateTarget -#define qDNGValidateTarget 0 -#endif - -/*****************************************************************************/ - -/// \def qDNGValidate -/// 1 if DNG validation code is enabled, 0 otherwise. - -#ifndef qDNGValidate -#define qDNGValidate qDNGValidateTarget -#endif - -/*****************************************************************************/ - -/// \def qDNGPrintMessages -/// 1 if dng_show_message should use fprintf to stderr. 0 if it should use a platform -/// specific interrupt mechanism. - -#ifndef qDNGPrintMessages -#define qDNGPrintMessages qDNGValidate -#endif - -/*****************************************************************************/ - -/// \def qDNGCodec -/// 1 to build the Windows Imaging Component Codec (e.g. for Vista). - -#ifndef qDNGCodec -#define qDNGCodec 0 -#endif - -/*****************************************************************************/ - -// Experimental features -- work in progress for Lightroom 4.0 and Camera Raw 7.0. -// Turn this off for Lightroom 3.x & Camera Raw 6.x dot releases. - -#ifndef qDNGExperimental -#define qDNGExperimental 1 -#endif - -/*****************************************************************************/ - -/// \def qDNGXMPFiles -/// 1 to use XMPFiles. - -#ifndef qDNGXMPFiles -#define qDNGXMPFiles 1 -#endif - -/*****************************************************************************/ - -/// \def qDNGXMPDocOps -/// 1 to use XMPDocOps. - -#ifndef qDNGXMPDocOps -#define qDNGXMPDocOps (!qDNGValidateTarget) -#endif - -/*****************************************************************************/ - -/// \def qDNGUseLibJPEG -/// 1 to use open-source libjpeg for lossy jpeg processing. - -#ifndef qDNGUseLibJPEG -#define qDNGUseLibJPEG qDNGValidateTarget -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_gain_map.cpp b/third_party/dng_sdk/dng_gain_map.cpp deleted file mode 100644 index 4c4e867..0000000 --- a/third_party/dng_sdk/dng_gain_map.cpp +++ /dev/null @@ -1,583 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_gain_map.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_gain_map.h" - -#include "dng_exceptions.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_pixel_buffer.h" -#include "dng_stream.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -class dng_gain_map_interpolator - { - - private: - - const dng_gain_map &fMap; - - dng_point_real64 fScale; - dng_point_real64 fOffset; - - int32 fColumn; - int32 fPlane; - - uint32 fRowIndex1; - uint32 fRowIndex2; - real32 fRowFract; - - int32 fResetColumn; - - real32 fValueBase; - real32 fValueStep; - real32 fValueIndex; - - public: - - dng_gain_map_interpolator (const dng_gain_map &map, - const dng_rect &mapBounds, - int32 row, - int32 column, - uint32 plane); - - real32 Interpolate () const - { - - return fValueBase + fValueStep * fValueIndex; - - } - - void Increment () - { - - if (++fColumn >= fResetColumn) - { - - ResetColumn (); - - } - - else - { - - fValueIndex += 1.0f; - - } - - } - - private: - - real32 InterpolateEntry (uint32 colIndex); - - void ResetColumn (); - - }; - -/*****************************************************************************/ - -dng_gain_map_interpolator::dng_gain_map_interpolator (const dng_gain_map &map, - const dng_rect &mapBounds, - int32 row, - int32 column, - uint32 plane) - - : fMap (map) - - , fScale (1.0 / mapBounds.H (), - 1.0 / mapBounds.W ()) - - , fOffset (0.5 - mapBounds.t, - 0.5 - mapBounds.l) - - , fColumn (column) - , fPlane (plane) - - , fRowIndex1 (0) - , fRowIndex2 (0) - , fRowFract (0.0f) - - , fResetColumn (0) - - , fValueBase (0.0f) - , fValueStep (0.0f) - , fValueIndex (0.0f) - - { - - real64 rowIndexF = (fScale.v * (row + fOffset.v) - - fMap.Origin ().v) / fMap.Spacing ().v; - - if (rowIndexF <= 0.0) - { - - fRowIndex1 = 0; - fRowIndex2 = 0; - - fRowFract = 0.0f; - - } - - else - { - - fRowIndex1 = (uint32) rowIndexF; - - if ((int32) fRowIndex1 >= fMap.Points ().v - 1) - { - - fRowIndex1 = fMap.Points ().v - 1; - fRowIndex2 = fRowIndex1; - - fRowFract = 0.0f; - - } - - else - { - - fRowIndex2 = fRowIndex1 + 1; - - fRowFract = (real32) (rowIndexF - (real64) fRowIndex1); - - } - - } - - ResetColumn (); - - } - -/*****************************************************************************/ - -real32 dng_gain_map_interpolator::InterpolateEntry (uint32 colIndex) - { - - return fMap.Entry (fRowIndex1, colIndex, fPlane) * (1.0f - fRowFract) + - fMap.Entry (fRowIndex2, colIndex, fPlane) * ( fRowFract); - - } - -/*****************************************************************************/ - -void dng_gain_map_interpolator::ResetColumn () - { - - real64 colIndexF = ((fScale.h * (fColumn + fOffset.h)) - - fMap.Origin ().h) / fMap.Spacing ().h; - - if (colIndexF <= 0.0) - { - - fValueBase = InterpolateEntry (0); - - fValueStep = 0.0f; - - fResetColumn = (int32) ceil (fMap.Origin ().h / fScale.h - fOffset.h); - - } - - else - { - - uint32 colIndex = (uint32) colIndexF; - - if ((int32) colIndex >= fMap.Points ().h - 1) - { - - fValueBase = InterpolateEntry (fMap.Points ().h - 1); - - fValueStep = 0.0f; - - fResetColumn = 0x7FFFFFFF; - - } - - else - { - - real64 base = InterpolateEntry (colIndex); - real64 delta = InterpolateEntry (colIndex + 1) - base; - - fValueBase = (real32) (base + delta * (colIndexF - (real64) colIndex)); - - fValueStep = (real32) ((delta * fScale.h) / fMap.Spacing ().h); - - fResetColumn = (int32) ceil (((colIndex + 1) * fMap.Spacing ().h + - fMap.Origin ().h) / fScale.h - fOffset.h); - - } - - } - - fValueIndex = 0.0f; - - } - -/*****************************************************************************/ - -dng_gain_map::dng_gain_map (dng_memory_allocator &allocator, - const dng_point &points, - const dng_point_real64 &spacing, - const dng_point_real64 &origin, - uint32 planes) - - : fPoints (points) - , fSpacing (spacing) - , fOrigin (origin) - , fPlanes (planes) - - , fRowStep (planes * points.h) - - , fBuffer () - - { - - fBuffer.Reset (allocator.Allocate (fPoints.v * - fPoints.h * - fPlanes * (uint32) sizeof (real32))); - - } - -/*****************************************************************************/ - -real32 dng_gain_map::Interpolate (int32 row, - int32 col, - uint32 plane, - const dng_rect &bounds) const - { - - dng_gain_map_interpolator interp (*this, - bounds, - row, - col, - plane); - - return interp.Interpolate (); - - } - -/*****************************************************************************/ - -uint32 dng_gain_map::PutStreamSize () const - { - - return 44 + fPoints.v * fPoints.h * fPlanes * 4; - - } - -/*****************************************************************************/ - -void dng_gain_map::PutStream (dng_stream &stream) const - { - - stream.Put_uint32 (fPoints.v); - stream.Put_uint32 (fPoints.h); - - stream.Put_real64 (fSpacing.v); - stream.Put_real64 (fSpacing.h); - - stream.Put_real64 (fOrigin.v); - stream.Put_real64 (fOrigin.h); - - stream.Put_uint32 (fPlanes); - - for (int32 rowIndex = 0; rowIndex < fPoints.v; rowIndex++) - { - - for (int32 colIndex = 0; colIndex < fPoints.h; colIndex++) - { - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - stream.Put_real32 (Entry (rowIndex, - colIndex, - plane)); - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_gain_map * dng_gain_map::GetStream (dng_host &host, - dng_stream &stream) - { - - dng_point mapPoints; - - mapPoints.v = stream.Get_uint32 (); - mapPoints.h = stream.Get_uint32 (); - - dng_point_real64 mapSpacing; - - mapSpacing.v = stream.Get_real64 (); - mapSpacing.h = stream.Get_real64 (); - - dng_point_real64 mapOrigin; - - mapOrigin.v = stream.Get_real64 (); - mapOrigin.h = stream.Get_real64 (); - - uint32 mapPlanes = stream.Get_uint32 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Points: v=%d, h=%d\n", - (int) mapPoints.v, - (int) mapPoints.h); - - printf ("Spacing: v=%.6f, h=%.6f\n", - mapSpacing.v, - mapSpacing.h); - - printf ("Origin: v=%.6f, h=%.6f\n", - mapOrigin.v, - mapOrigin.h); - - printf ("Planes: %u\n", - (unsigned) mapPlanes); - - } - - #endif - - if (mapPoints.v == 1) - { - mapSpacing.v = 1.0; - mapOrigin.v = 0.0; - } - - if (mapPoints.h == 1) - { - mapSpacing.h = 1.0; - mapOrigin.h = 0.0; - } - - if (mapPoints.v < 1 || - mapPoints.h < 1 || - mapSpacing.v <= 0.0 || - mapSpacing.h <= 0.0 || - mapPlanes < 1) - { - ThrowBadFormat (); - } - - AutoPtr map (new dng_gain_map (host.Allocator (), - mapPoints, - mapSpacing, - mapOrigin, - mapPlanes)); - - #if qDNGValidate - - uint32 linesPrinted = 0; - uint32 linesSkipped = 0; - - #endif - - for (int32 rowIndex = 0; rowIndex < mapPoints.v; rowIndex++) - { - - for (int32 colIndex = 0; colIndex < mapPoints.h; colIndex++) - { - - for (uint32 plane = 0; plane < mapPlanes; plane++) - { - - real32 x = stream.Get_real32 (); - - map->Entry (rowIndex, colIndex, plane) = x; - - #if qDNGValidate - - if (gVerbose) - { - - if (linesPrinted < gDumpLineLimit) - { - - printf (" Map [%3u] [%3u] [%u] = %.4f\n", - (unsigned) rowIndex, - (unsigned) colIndex, - (unsigned) plane, - x); - - linesPrinted++; - - } - - else - linesSkipped++; - - } - - #endif - - } - - } - - } - - #if qDNGValidate - - if (linesSkipped) - { - - printf (" ... %u map entries skipped\n", (unsigned) linesSkipped); - - } - - #endif - - return map.Release (); - - } - -/*****************************************************************************/ - -dng_opcode_GainMap::dng_opcode_GainMap (const dng_area_spec &areaSpec, - AutoPtr &gainMap) - - : dng_inplace_opcode (dngOpcode_GainMap, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - - , fGainMap () - - { - - fGainMap.Reset (gainMap.Release ()); - - } - -/*****************************************************************************/ - -dng_opcode_GainMap::dng_opcode_GainMap (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_GainMap, - stream, - "GainMap") - - , fAreaSpec () - - , fGainMap () - - { - - uint32 byteCount = stream.Get_uint32 (); - - uint64 startPosition = stream.Position (); - - fAreaSpec.GetData (stream); - - fGainMap.Reset (dng_gain_map::GetStream (host, stream)); - - if (stream.Position () != startPosition + byteCount) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -void dng_opcode_GainMap::PutData (dng_stream &stream) const - { - - stream.Put_uint32 (dng_area_spec::kDataSize + - fGainMap->PutStreamSize ()); - - fAreaSpec.PutData (stream); - - fGainMap->PutStream (stream); - - } - -/*****************************************************************************/ - -void dng_opcode_GainMap::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 cols = overlap.W (); - - uint32 colPitch = fAreaSpec.ColPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - uint32 mapPlane = Min_uint32 (plane, fGainMap->Planes () - 1); - - for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) - { - - real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); - - dng_gain_map_interpolator interp (*fGainMap, - imageBounds, - row, - overlap.l, - mapPlane); - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 gain = interp.Interpolate (); - - dPtr [col] = Min_real32 (dPtr [col] * gain, 1.0f); - - for (uint32 j = 0; j < colPitch; j++) - { - interp.Increment (); - } - - } - - } - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_gain_map.h b/third_party/dng_sdk/dng_gain_map.h deleted file mode 100644 index a8db499..0000000 --- a/third_party/dng_sdk/dng_gain_map.h +++ /dev/null @@ -1,219 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_gain_map.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Opcode to fix 2D uniformity defects, such as shading. - */ - -/*****************************************************************************/ - -#ifndef __dng_gain_map__ -#define __dng_gain_map__ - -/*****************************************************************************/ - -#include "dng_memory.h" -#include "dng_misc_opcodes.h" -#include "dng_tag_types.h" - -/*****************************************************************************/ - -/// \brief Holds a discrete (i.e., sampled) 2D representation of a gain map. This is -/// effectively an image containing scale factors. - -class dng_gain_map - { - - private: - - dng_point fPoints; - - dng_point_real64 fSpacing; - - dng_point_real64 fOrigin; - - uint32 fPlanes; - - uint32 fRowStep; - - AutoPtr fBuffer; - - public: - - /// Construct a gain map with the specified memory allocator, number of - /// samples (points), sample spacing, origin, and number of color planes. - - dng_gain_map (dng_memory_allocator &allocator, - const dng_point &points, - const dng_point_real64 &spacing, - const dng_point_real64 &origin, - uint32 planes); - - /// The number of samples in the horizontal and vertical directions. - - const dng_point & Points () const - { - return fPoints; - } - - /// The space between adjacent samples in the horizontal and vertical - /// directions. - - const dng_point_real64 & Spacing () const - { - return fSpacing; - } - - /// The 2D coordinate for the first (i.e., top-left-most) sample. - - const dng_point_real64 & Origin () const - { - return fOrigin; - } - - /// The number of color planes. - - uint32 Planes () const - { - return fPlanes; - } - - /// Getter for a gain map sample (specified by row, column, and plane). - - real32 & Entry (uint32 rowIndex, - uint32 colIndex, - uint32 plane) - { - - return *(fBuffer->Buffer_real32 () + - rowIndex * fRowStep + - colIndex * fPlanes + - plane); - - } - - /// Getter for a gain map sample (specified by row index, column index, and - /// plane index). - - const real32 & Entry (uint32 rowIndex, - uint32 colIndex, - uint32 plane) const - { - - return *(fBuffer->Buffer_real32 () + - rowIndex * fRowStep + - colIndex * fPlanes + - plane); - - } - - /// Compute the interpolated gain (i.e., scale factor) at the specified pixel - /// position and color plane, within the specified image bounds (in pixels). - - real32 Interpolate (int32 row, - int32 col, - uint32 plane, - const dng_rect &bounds) const; - - /// The number of bytes needed to hold the gain map data. - - uint32 PutStreamSize () const; - - /// Write the gain map to the specified stream. - - void PutStream (dng_stream &stream) const; - - /// Read a gain map from the specified stream. - - static dng_gain_map * GetStream (dng_host &host, - dng_stream &stream); - - private: - - // Hidden copy constructor and assignment operator. - - dng_gain_map (const dng_gain_map &map); - - dng_gain_map & operator= (const dng_gain_map &map); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to fix 2D spatially-varying light falloff or color casts (i.e., -/// uniformity issues). This is commonly due to shading. - -class dng_opcode_GainMap: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fGainMap; - - public: - - /// Construct a GainMap opcode for the specified image area and the specified - /// gain map. - - dng_opcode_GainMap (const dng_area_spec &areaSpec, - AutoPtr &gainMap); - - /// Construct a GainMap opcode from the specified stream. - - dng_opcode_GainMap (dng_host &host, - dng_stream &stream); - - /// Write the opcode to the specified stream. - - virtual void PutData (dng_stream &stream) const; - - /// The pixel data type of this opcode. - - virtual uint32 BufferPixelType (uint32 /* imagePixelType */) - { - return ttFloat; - } - - /// The adjusted bounds (processing area) of this opcode. It is limited to - /// the intersection of the specified image area and the GainMap area. - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds) - { - return fAreaSpec.Overlap (imageBounds); - } - - /// Apply the gain map. - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - private: - - // Hidden copy constructor and assignment operator. - - dng_opcode_GainMap (const dng_opcode_GainMap &opcode); - - dng_opcode_GainMap & operator= (const dng_opcode_GainMap &opcode); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_globals.cpp b/third_party/dng_sdk/dng_globals.cpp deleted file mode 100644 index b279295..0000000 --- a/third_party/dng_sdk/dng_globals.cpp +++ /dev/null @@ -1,28 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_globals.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_globals.h" - -/*****************************************************************************/ - -#if qDNGValidate - -bool gVerbose = false; - -uint32 gDumpLineLimit = 100; - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_globals.h b/third_party/dng_sdk/dng_globals.h deleted file mode 100644 index ad48017..0000000 --- a/third_party/dng_sdk/dng_globals.h +++ /dev/null @@ -1,46 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_globals.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Definitions of global variables controling DNG SDK behavior. Currenntly only used for validation control. - */ - -/*****************************************************************************/ - -#ifndef __dng_globals__ -#define __dng_globals__ - -/*****************************************************************************/ - -#include "dng_flags.h" -#include "dng_types.h" - -/*****************************************************************************/ - -#if qDNGValidate - -/// When validation (qValidate) is turned on, this globale enables verbose output about DNG tags and other properties. - -extern bool gVerbose; - -/// When validation (qValidate) is turned on, and verbose mode (gVerbose) is enabled, limits the number of lines of text that are dumped for each tag. - -extern uint32 gDumpLineLimit; - -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_host.cpp b/third_party/dng_sdk/dng_host.cpp deleted file mode 100644 index 91ebdc0..0000000 --- a/third_party/dng_sdk/dng_host.cpp +++ /dev/null @@ -1,539 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_host.cpp#2 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_host.h" - -#include "dng_abort_sniffer.h" -#include "dng_area_task.h" -#include "dng_bad_pixels.h" -#include "dng_exceptions.h" -#include "dng_exif.h" -#include "dng_gain_map.h" -#include "dng_ifd.h" -#include "dng_lens_correction.h" -#include "dng_memory.h" -#include "dng_misc_opcodes.h" -#include "dng_negative.h" -#include "dng_resample.h" -#include "dng_shared.h" -#include "dng_simple_image.h" -#include "dng_xmp.h" - -/*****************************************************************************/ - -dng_host::dng_host (dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer) - - : fAllocator (allocator) - , fSniffer (sniffer) - - , fNeedsMeta (true) - , fNeedsImage (true) - , fForPreview (false) - , fMinimumSize (0) - , fPreferredSize (0) - , fMaximumSize (0) - , fCropFactor (1.0) - , fSaveDNGVersion (dngVersion_None) - , fSaveLinearDNG (false) - , fKeepOriginalFile (false) - - { - - } - -/*****************************************************************************/ - -dng_host::~dng_host () - { - - } - -/*****************************************************************************/ - -dng_memory_allocator & dng_host::Allocator () - { - - if (fAllocator) - { - - return *fAllocator; - - } - - else - { - - return gDefaultDNGMemoryAllocator; - - } - - } - -/*****************************************************************************/ - -dng_memory_block * dng_host::Allocate (uint32 logicalSize) - { - - return Allocator ().Allocate (logicalSize); - - } - -/*****************************************************************************/ - -void dng_host::SniffForAbort () - { - - dng_abort_sniffer::SniffForAbort (Sniffer ()); - - } - -/*****************************************************************************/ - -void dng_host::ValidateSizes () - { - - // The maximum size limits the other two sizes. - - if (MaximumSize ()) - { - SetMinimumSize (Min_uint32 (MinimumSize (), MaximumSize ())); - SetPreferredSize (Min_uint32 (PreferredSize (), MaximumSize ())); - } - - // If we have a preferred size, it limits the minimum size. - - if (PreferredSize ()) - { - SetMinimumSize (Min_uint32 (MinimumSize (), PreferredSize ())); - } - - // Else find default value for preferred size. - - else - { - - // If preferred size is zero, then we want the maximim - // size image. - - if (MaximumSize ()) - { - SetPreferredSize (MaximumSize ()); - } - - } - - // If we don't have a minimum size, find default. - - if (!MinimumSize ()) - { - - // A common size for embedded thumbnails is 120 by 160 pixels, - // So allow 120 by 160 pixels to be used for thumbnails when the - // preferred size is 256 pixel. - - if (PreferredSize () >= 160 && PreferredSize () <= 256) - { - SetMinimumSize (160); - } - - // Many sensors are near a multiple of 1024 pixels in size, but after - // the default crop, they are a just under. We can get an extra factor - // of size reduction if we allow a slight undershoot in the final size - // when computing large previews. - - else if (PreferredSize () >= 490 && PreferredSize () <= 512) - { - SetMinimumSize (490); - } - - else if (PreferredSize () >= 980 && PreferredSize () <= 1024) - { - SetMinimumSize (980); - } - - else if (PreferredSize () >= 1470 && PreferredSize () <= 1536) - { - SetMinimumSize (1470); - } - - else if (PreferredSize () >= 1960 && PreferredSize () <= 2048) - { - SetMinimumSize (1960); - } - - // Else minimum size is same as preferred size. - - else - { - SetMinimumSize (PreferredSize ()); - } - - } - - } - -/*****************************************************************************/ - -uint32 dng_host::SaveDNGVersion () const - { - - return fSaveDNGVersion; - - } - -/*****************************************************************************/ - -bool dng_host::SaveLinearDNG (const dng_negative & /* negative */) const - { - - return fSaveLinearDNG; - - } - -/*****************************************************************************/ - -bool dng_host::IsTransientError (dng_error_code code) - { - - switch (code) - { - - case dng_error_memory: - case dng_error_user_canceled: - { - return true; - } - - default: - break; - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_host::PerformAreaTask (dng_area_task &task, - const dng_rect &area) - { - - dng_area_task::Perform (task, - area, - &Allocator (), - Sniffer ()); - - } - -/*****************************************************************************/ - -uint32 dng_host::PerformAreaTaskThreads () - { - - return 1; - - } - -/*****************************************************************************/ - -dng_exif * dng_host::Make_dng_exif () - { - - dng_exif *result = new dng_exif (); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_xmp * dng_host::Make_dng_xmp () - { - - dng_xmp *result = new dng_xmp (Allocator ()); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_shared * dng_host::Make_dng_shared () - { - - dng_shared *result = new dng_shared (); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_ifd * dng_host::Make_dng_ifd () - { - - dng_ifd *result = new dng_ifd (); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_negative * dng_host::Make_dng_negative () - { - - return dng_negative::Make (*this); - - } - -/*****************************************************************************/ - -dng_image * dng_host::Make_dng_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType) - { - - dng_image *result = new dng_simple_image (bounds, - planes, - pixelType, - Allocator ()); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_opcode * dng_host::Make_dng_opcode (uint32 opcodeID, - dng_stream &stream) - { - - dng_opcode *result = NULL; - - switch (opcodeID) - { - - case dngOpcode_WarpRectilinear: - { - - result = new dng_opcode_WarpRectilinear (stream); - - break; - - } - - case dngOpcode_WarpFisheye: - { - - result = new dng_opcode_WarpFisheye (stream); - - break; - - } - - case dngOpcode_FixVignetteRadial: - { - - result = new dng_opcode_FixVignetteRadial (stream); - - break; - - } - - case dngOpcode_FixBadPixelsConstant: - { - - result = new dng_opcode_FixBadPixelsConstant (stream); - - break; - - } - - case dngOpcode_FixBadPixelsList: - { - - result = new dng_opcode_FixBadPixelsList (stream); - - break; - - } - - case dngOpcode_TrimBounds: - { - - result = new dng_opcode_TrimBounds (stream); - - break; - - } - - case dngOpcode_MapTable: - { - - result = new dng_opcode_MapTable (*this, - stream); - - break; - - } - - case dngOpcode_MapPolynomial: - { - - result = new dng_opcode_MapPolynomial (stream); - - break; - - } - - case dngOpcode_GainMap: - { - - result = new dng_opcode_GainMap (*this, - stream); - - break; - - } - - case dngOpcode_DeltaPerRow: - { - - result = new dng_opcode_DeltaPerRow (*this, - stream); - - break; - - } - - case dngOpcode_DeltaPerColumn: - { - - result = new dng_opcode_DeltaPerColumn (*this, - stream); - - break; - - } - - case dngOpcode_ScalePerRow: - { - - result = new dng_opcode_ScalePerRow (*this, - stream); - - break; - - } - - case dngOpcode_ScalePerColumn: - { - - result = new dng_opcode_ScalePerColumn (*this, - stream); - - break; - - } - - default: - { - - result = new dng_opcode_Unknown (*this, - opcodeID, - stream); - - } - - } - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_host::ApplyOpcodeList (dng_opcode_list &list, - dng_negative &negative, - AutoPtr &image) - { - - list.Apply (*this, - negative, - image); - - } - -/*****************************************************************************/ - -void dng_host::ResampleImage (const dng_image &srcImage, - dng_image &dstImage) - { - - ::ResampleImage (*this, - srcImage, - dstImage, - srcImage.Bounds (), - dstImage.Bounds (), - dng_resample_bicubic::Get ()); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_host.h b/third_party/dng_sdk/dng_host.h deleted file mode 100644 index 38d449d..0000000 --- a/third_party/dng_sdk/dng_host.h +++ /dev/null @@ -1,406 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_host.h#2 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/** \file - * Class definition for dng_host, initial point of contact and control between - * host application and DNG SDK. - */ - -/*****************************************************************************/ - -#ifndef __dng_host__ -#define __dng_host__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_errors.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief The main class for communication between the application and the -/// DNG SDK. Used to customize memory allocation and other behaviors. -/// -/// dng_host allows setting parameters for the DNG conversion, mediates callback -/// style interactions between the host application and the DNG SDK, and allows -/// controlling certain internal behavior of the SDK such as memory allocation. -/// Many applications will be able to use the default implementation of dng_host -/// by just setting the dng_memory_allocator and dng_abort_sniffer in the -/// constructor. More complex interactions will require deriving a class from -/// dng_host. -/// -/// Multiple dng_host objects can be allocated in a single process. This may -/// be useful for DNG processing on separate threads. (Distinct dng_host objects -/// are completely threadsafe for read/write. The application is responsible for -/// establishing mutual exclusion for read/write access to a single dng_host -/// object if it is used in multiple threads.) - -class dng_host - { - - private: - - dng_memory_allocator *fAllocator; - - dng_abort_sniffer *fSniffer; - - // Does the host require all the image metadata (vs. just checking - // to see if the file is readable)? - - bool fNeedsMeta; - - // Does the host require actual image data (vs. just getting metadata - // or just checking to see if the file is readable)? - - bool fNeedsImage; - - // If we need the image data, can it be read at preview quality? - - bool fForPreview; - - // If non-zero, the minimum size (longer of the two pixel dimensions) - // image to read. If zero, or if the full size image is smaller than - // this, read the full size image. - - uint32 fMinimumSize; - - // What is the preferred size for a preview image? This can - // be slightly larger than the minimum size. Zero if we want - // the full resolution image. - - uint32 fPreferredSize; - - // What is the maximum size for a preview image? Zero if there - // is no maximum size limit. - - uint32 fMaximumSize; - - // The fraction of the image kept after a crop. This is used to - // adjust the sizes to take into account the cropping that - // will be peformed. - - real64 fCropFactor; - - // What DNG version should we keep enough data to save? - - uint32 fSaveDNGVersion; - - // Do we want to force saving to a linear DNG? - - bool fSaveLinearDNG; - - // Keep the original raw file data block? - - bool fKeepOriginalFile; - - public: - - /// Allocate a dng_host object, possiblly with custom allocator and sniffer. - /// \param allocator Allows controlling all memory allocation done via this - /// dng_host. Defaults to singleton global dng_memory_allocator, which calls - /// new/delete dng_malloc_block for appropriate size. - /// \param sniffer Used to periodically check if pending DNG conversions - /// should be aborted and to communicate progress updates. Defaults to singleton - /// global dng_abort_sniffer, which never aborts and ignores progress updated. - - dng_host (dng_memory_allocator *allocator = NULL, - dng_abort_sniffer *sniffer = NULL); - - /// Clean up direct memory for dng_host. Memory allocator and abort sniffer - /// are not deleted. Objects such as dng_image and others returned from - /// host can still be used after host is deleted. - - virtual ~dng_host (); - - /// Getter for host's memory allocator. - - dng_memory_allocator & Allocator (); - - /// Alocate a new dng_memory_block using the host's memory allocator. - /// Uses the Allocator() property of host to allocate a new block of memory. - /// Will call ThrowMemoryFull if block cannot be allocated. - /// \param logicalSize Number of usable bytes returned dng_memory_block - /// must contain. - - virtual dng_memory_block * Allocate (uint32 logicalSize); - - /// Setter for host's abort sniffer. - - void SetSniffer (dng_abort_sniffer *sniffer) - { - fSniffer = sniffer; - } - - /// Getter for host's abort sniffer. - - dng_abort_sniffer * Sniffer () - { - return fSniffer; - } - - /// Check for pending abort. Should call ThrowUserCanceled if an abort - /// is pending. - - virtual void SniffForAbort (); - - /// Setter for flag determining whether all XMP metadata should be parsed. - /// Defaults to true. One might not want metadata when doing a quick check - /// to see if a file is readable. - /// \param needs If true, metadata is needed. - - void SetNeedsMeta (bool needs) - { - fNeedsMeta = needs; - } - - /// Getter for flag determining whether all XMP metadata should be parsed. - - bool NeedsMeta () const - { - return fNeedsMeta; - } - - /// Setter for flag determining whether DNG image data is needed. Defaults - /// to true. Image data might not be needed for applications which only - /// manipulate metadata. - /// \param needs If true, image data is needed. - - void SetNeedsImage (bool needs) - { - fNeedsImage = needs; - } - - /// Setter for flag determining whether DNG image data is needed. - - bool NeedsImage () const - { - return fNeedsImage; - } - - /// Setter for flag determining whether image should be preview quality, - /// or full quality. - /// \param preview If true, rendered images are for preview. - - void SetForPreview (bool preview) - { - fForPreview = preview; - } - - /// Getter for flag determining whether image should be preview quality. - /// Preview quality images may be rendered more quickly. Current DNG SDK - /// does not change rendering behavior based on this flag, but derived - /// versions may use this getter to choose between a slower more accurate path - /// and a faster "good enough for preview" one. Data produce with ForPreview set - /// to true should not be written back to a DNG file, except as a preview image. - - bool ForPreview () const - { - return fForPreview; - } - - /// Setter for the minimum preview size. - /// \param size Minimum pixel size (long side of image). - - void SetMinimumSize (uint32 size) - { - fMinimumSize = size; - } - - /// Getter for the minimum preview size. - - uint32 MinimumSize () const - { - return fMinimumSize; - } - - /// Setter for the preferred preview size. - /// \param size Preferred pixel size (long side of image). - - void SetPreferredSize (uint32 size) - { - fPreferredSize = size; - } - - /// Getter for the preferred preview size. - - uint32 PreferredSize () const - { - return fPreferredSize; - } - - /// Setter for the maximum preview size. - /// \param size Maximum pixel size (long side of image). - - void SetMaximumSize (uint32 size) - { - fMaximumSize = size; - } - - /// Getter for the maximum preview size. - - uint32 MaximumSize () const - { - return fMaximumSize; - } - - /// Setter for the cropping factor. - /// \param cropFactor Fraction of image to be used after crop. - - void SetCropFactor (real64 cropFactor) - { - fCropFactor = cropFactor; - } - - /// Getter for the cropping factor. - - real64 CropFactor () const - { - return fCropFactor; - } - - /// Makes sures minimum, preferred, and maximum sizes are reasonable. - - void ValidateSizes (); - - /// Setter for what version to save DNG file compatible with. - /// \param version What version to save DNG file compatible with. - - void SetSaveDNGVersion (uint32 version) - { - fSaveDNGVersion = version; - } - - /// Getter for what version to save DNG file compatible with. - - virtual uint32 SaveDNGVersion () const; - - /// Setter for flag determining whether to force saving a linear DNG file. - /// \param linear If true, we should force saving a linear DNG file. - - void SetSaveLinearDNG (bool linear) - { - fSaveLinearDNG = linear; - } - - /// Getter for flag determining whether to save a linear DNG file. - - virtual bool SaveLinearDNG (const dng_negative &negative) const; - - /// Setter for flag determining whether to keep original RAW file data. - /// \param keep If true, origianl RAW data will be kept. - - void SetKeepOriginalFile (bool keep) - { - fKeepOriginalFile = keep; - } - - /// Getter for flag determining whether to keep original RAW file data. - - bool KeepOriginalFile () - { - return fKeepOriginalFile; - } - - /// Determine if an error is the result of a temporary, but planned-for - /// occurence such as user cancellation or memory exhaustion. This method is - /// sometimes used to determine whether to try and continue processing a DNG - /// file despite errors in the file format, etc. In such cases, processing will - /// be continued if IsTransientError returns false. This is so that user cancellation - /// and memory exhaustion always terminate processing. - /// \param code Error to test for transience. - - virtual bool IsTransientError (dng_error_code code); - - /// General top-level botttleneck for image processing tasks. - /// Default implementation calls dng_area_task::PerformAreaTask method on - /// task. Can be overridden in derived classes to support multiprocessing, - /// for example. - /// \param task Image processing task to perform on area. - /// \param area Rectangle over which to perform image processing task. - - virtual void PerformAreaTask (dng_area_task &task, - const dng_rect &area); - - /// How many multiprocessing threads does PerformAreaTask use? - /// Default implementation always returns 1 since it is single threaded. - - virtual uint32 PerformAreaTaskThreads (); - - /// Factory method for dng_exif class. Can be used to customize allocation or - /// to ensure a derived class is used instead of dng_exif. - - virtual dng_exif * Make_dng_exif (); - - /// Factory method for dng_xmp class. Can be used to customize allocation or - /// to ensure a derived class is used instead of dng_xmp. - - virtual dng_xmp * Make_dng_xmp (); - - /// Factory method for dng_shared class. Can be used to customize allocation - /// or to ensure a derived class is used instead of dng_shared. - - virtual dng_shared * Make_dng_shared (); - - /// Factory method for dng_ifd class. Can be used to customize allocation or - /// to ensure a derived class is used instead of dng_ifd. - - virtual dng_ifd * Make_dng_ifd (); - - /// Factory method for dng_negative class. Can be used to customize allocation - /// or to ensure a derived class is used instead of dng_negative. - - virtual dng_negative * Make_dng_negative (); - - /// Factory method for dng_image class. Can be used to customize allocation - /// or to ensure a derived class is used instead of dng_simple_image. - - virtual dng_image * Make_dng_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType); - - /// Factory method for parsing dng_opcode based classs. Can be used to - /// override opcode implementations. - - virtual dng_opcode * Make_dng_opcode (uint32 opcodeID, - dng_stream &stream); - - /// Factory method to apply a dng_opcode_list. Can be used to override - /// opcode list applications. - - virtual void ApplyOpcodeList (dng_opcode_list &list, - dng_negative &negative, - AutoPtr &image); - - /// Factory method to resample an image. Can be used to override - /// image method used to resample images. - - virtual void ResampleImage (const dng_image &srcImage, - dng_image &dstImage); - - private: - - // Hidden copy constructor and assignment operator. - - dng_host (const dng_host &host); - - dng_host & operator= (const dng_host &host); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_hue_sat_map.cpp b/third_party/dng_sdk/dng_hue_sat_map.cpp deleted file mode 100644 index e6fa36a..0000000 --- a/third_party/dng_sdk/dng_hue_sat_map.cpp +++ /dev/null @@ -1,365 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_hue_sat_map.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_hue_sat_map.h" - -#include "dng_assertions.h" -#include "dng_auto_ptr.h" -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_host.h" - -/*****************************************************************************/ - -dng_hue_sat_map::dng_hue_sat_map () - - : fHueDivisions (0) - , fSatDivisions (0) - , fValDivisions (0) - , fHueStep (0) - , fValStep (0) - , fDeltas () - - { - - } - -/*****************************************************************************/ - -dng_hue_sat_map::dng_hue_sat_map (const dng_hue_sat_map &src) - - : fHueDivisions (0) - , fSatDivisions (0) - , fValDivisions (0) - , fHueStep (0) - , fValStep (0) - , fDeltas () - - { - - *this = src; - - } - -/*****************************************************************************/ - -dng_hue_sat_map &dng_hue_sat_map::operator= (const dng_hue_sat_map &rhs) - { - - if (this != &rhs) - { - - if (!rhs.IsValid ()) - { - - SetInvalid (); - - } - - else - { - - fHueDivisions = rhs.fHueDivisions; - fSatDivisions = rhs.fSatDivisions; - fValDivisions = rhs.fValDivisions; - - fHueStep = rhs.fHueStep; - fValStep = rhs.fValStep; - - fDeltas = rhs.fDeltas; - - } - - } - - return *this; - - } - -/*****************************************************************************/ - -dng_hue_sat_map::~dng_hue_sat_map () - { - - } - -/*****************************************************************************/ - -void dng_hue_sat_map::SetDivisions (uint32 hueDivisions, - uint32 satDivisions, - uint32 valDivisions) - { - - DNG_ASSERT (hueDivisions >= 1, "Must have at least 1 hue division."); - DNG_ASSERT (satDivisions >= 2, "Must have at least 2 sat divisions."); - - if (valDivisions == 0) - valDivisions = 1; - - if (hueDivisions == fHueDivisions && - satDivisions == fSatDivisions && - valDivisions == fValDivisions) - { - return; - } - - fHueDivisions = hueDivisions; - fSatDivisions = satDivisions; - fValDivisions = valDivisions; - - fHueStep = satDivisions; - fValStep = hueDivisions * fHueStep; - - uint32 size = DeltasCount () * (uint32) sizeof (HSBModify); - - fDeltas.Allocate (size); - - DoZeroBytes (fDeltas.Buffer (), size); - - } - -/*****************************************************************************/ - -void dng_hue_sat_map::GetDelta (uint32 hueDiv, - uint32 satDiv, - uint32 valDiv, - HSBModify &modify) const - { - - if (hueDiv >= fHueDivisions || - satDiv >= fSatDivisions || - valDiv >= fValDivisions || - fDeltas.Buffer () == NULL) - { - - DNG_REPORT ("Bad parameters to dng_hue_sat_map::GetDelta"); - - ThrowProgramError (); - - } - - int32 offset = valDiv * fValStep + - hueDiv * fHueStep + - satDiv; - - const HSBModify *deltas = GetConstDeltas (); - - modify.fHueShift = deltas [offset].fHueShift; - modify.fSatScale = deltas [offset].fSatScale; - modify.fValScale = deltas [offset].fValScale; - - } - -/*****************************************************************************/ - -void dng_hue_sat_map::SetDeltaKnownWriteable (uint32 hueDiv, - uint32 satDiv, - uint32 valDiv, - const HSBModify &modify) - { - - if (hueDiv >= fHueDivisions || - satDiv >= fSatDivisions || - valDiv >= fValDivisions || - fDeltas.Buffer () == NULL) - { - - DNG_REPORT ("Bad parameters to dng_hue_sat_map::SetDelta"); - - ThrowProgramError (); - - } - - // Set this entry. - - int32 offset = valDiv * fValStep + - hueDiv * fHueStep + - satDiv; - - SafeGetDeltas () [offset] = modify; - - // The zero saturation entry is required to have a value scale - // of 1.0f. - - if (satDiv == 0) - { - - if (modify.fValScale != 1.0f) - { - - #if qDNGValidate - - ReportWarning ("Value scale for zero saturation entries must be 1.0"); - - #endif - - SafeGetDeltas () [offset] . fValScale = 1.0f; - - } - - } - - // If we are settings the first saturation entry and we have not - // set the zero saturation entry yet, fill in the zero saturation entry - // by extrapolating first saturation entry. - - if (satDiv == 1) - { - - HSBModify zeroSatModify; - - GetDelta (hueDiv, 0, valDiv, zeroSatModify); - - if (zeroSatModify.fValScale != 1.0f) - { - - zeroSatModify.fHueShift = modify.fHueShift; - zeroSatModify.fSatScale = modify.fSatScale; - zeroSatModify.fValScale = 1.0f; - - SetDelta (hueDiv, 0, valDiv, zeroSatModify); - - } - - } - - } - -/*****************************************************************************/ - -bool dng_hue_sat_map::operator== (const dng_hue_sat_map &rhs) const - { - - if (fHueDivisions != rhs.fHueDivisions || - fSatDivisions != rhs.fSatDivisions || - fValDivisions != rhs.fValDivisions) - return false; - - if (!IsValid ()) - return true; - - return memcmp (GetConstDeltas (), - rhs.GetConstDeltas (), - DeltasCount () * sizeof (HSBModify)) == 0; - - } - -/*****************************************************************************/ - -dng_hue_sat_map * dng_hue_sat_map::Interpolate (const dng_hue_sat_map &map1, - const dng_hue_sat_map &map2, - real64 weight1) - { - - if (weight1 >= 1.0) - { - - if (!map1.IsValid ()) - { - - DNG_REPORT ("map1 is not valid"); - - ThrowProgramError (); - - } - - return new dng_hue_sat_map (map1); - - } - - if (weight1 <= 0.0) - { - - if (!map2.IsValid ()) - { - DNG_REPORT ("map2 is not valid"); - - ThrowProgramError (); - - } - - return new dng_hue_sat_map (map2); - - } - - // Both maps must be valid if we are using both. - - if (!map1.IsValid () || !map2.IsValid ()) - { - - DNG_REPORT ("map1 or map2 is not valid"); - - ThrowProgramError (); - - } - - // Must have the same dimensions. - - if (map1.fHueDivisions != map2.fHueDivisions || - map1.fSatDivisions != map2.fSatDivisions || - map1.fValDivisions != map2.fValDivisions) - { - - DNG_REPORT ("map1 and map2 have different sizes"); - - ThrowProgramError (); - - } - - // Make table to hold interpolated results. - - AutoPtr result (new dng_hue_sat_map); - - result->SetDivisions (map1.fHueDivisions, - map1.fSatDivisions, - map1.fValDivisions); - - // Interpolate between the tables. - - real32 w1 = (real32) weight1; - real32 w2 = 1.0f - w1; - - const HSBModify *data1 = map1.GetConstDeltas (); - const HSBModify *data2 = map2.GetConstDeltas (); - - HSBModify *data3 = result->SafeGetDeltas (); - - uint32 count = map1.DeltasCount (); - - for (uint32 index = 0; index < count; index++) - { - - data3->fHueShift = w1 * data1->fHueShift + - w2 * data2->fHueShift; - - data3->fSatScale = w1 * data1->fSatScale + - w2 * data2->fSatScale; - - data3->fValScale = w1 * data1->fValScale + - w2 * data2->fValScale; - - data1++; - data2++; - data3++; - - } - - // Return interpolated tables. - - return result.Release (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_hue_sat_map.h b/third_party/dng_sdk/dng_hue_sat_map.h deleted file mode 100644 index c0816e2..0000000 --- a/third_party/dng_sdk/dng_hue_sat_map.h +++ /dev/null @@ -1,229 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_hue_sat_map.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Table-based color correction data structure. - */ - -/*****************************************************************************/ - -#ifndef __dng_hue_sat_map__ -#define __dng_hue_sat_map__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_ref_counted_block.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief A 3D table that maps HSV (hue, saturation, and value) floating-point -/// input coordinates in the range [0,1] to delta signals. The table must have at -/// least 1 sample in the hue dimension, at least 2 samples in the saturation -/// dimension, and at least 1 sample in the value dimension. Tables are stored in -/// value-hue-saturation order. - -class dng_hue_sat_map - { - - public: - - /// HSV delta signal. \param fHueShift is a delta value specified in degrees. - /// This parameter, added to the original hue, determines the output hue. A - /// value of 0 means no change. \param fSatScale and \param fValScale are - /// scale factors that are applied to saturation and value components, - /// respectively. These scale factors, multiplied by the original saturation - /// and value, determine the output saturation and value. A scale factor of - /// 1.0 means no change. - - struct HSBModify - { - real32 fHueShift; - real32 fSatScale; - real32 fValScale; - }; - - private: - - uint32 fHueDivisions; - uint32 fSatDivisions; - uint32 fValDivisions; - - uint32 fHueStep; - uint32 fValStep; - - dng_ref_counted_block fDeltas; - - HSBModify *SafeGetDeltas () - { - return (HSBModify *) fDeltas.Buffer_real32 (); - } - - public: - - /// Construct an empty (and invalid) hue sat map. - - dng_hue_sat_map (); - - /// Copy an existing hue sat map. - - dng_hue_sat_map (const dng_hue_sat_map &src); - - /// Copy an existing hue sat map. - - dng_hue_sat_map & operator= (const dng_hue_sat_map &rhs); - - /// Destructor. - - virtual ~dng_hue_sat_map (); - - /// Is this hue sat map invalid? - - bool IsNull () const - { - return !IsValid (); - } - - /// Is this hue sat map valid? - - bool IsValid () const - { - - return fHueDivisions > 0 && - fSatDivisions > 1 && - fValDivisions > 0 && - fDeltas.Buffer (); - - } - - /// Clear the hue sat map, making it invalid. - - void SetInvalid () - { - - fHueDivisions = 0; - fSatDivisions = 0; - fValDivisions = 0; - - fHueStep = 0; - fValStep = 0; - - fDeltas.Clear (); - - } - - /// Get the table dimensions (number of samples in each dimension). - - void GetDivisions (uint32 &hueDivisions, - uint32 &satDivisions, - uint32 &valDivisions) const - { - hueDivisions = fHueDivisions; - satDivisions = fSatDivisions; - valDivisions = fValDivisions; - } - - /// Set the table dimensions (number of samples in each dimension). This - /// erases any existing table data. - - void SetDivisions (uint32 hueDivisions, - uint32 satDivisions, - uint32 valDivisions = 1); - - /// Get a specific table entry, specified by table indices. - - void GetDelta (uint32 hueDiv, - uint32 satDiv, - uint32 valDiv, - HSBModify &modify) const; - - /// Make sure the table is writeable. - - void EnsureWriteable () - { - fDeltas.EnsureWriteable (); - } - - /// Set a specific table entry, specified by table indices. - - void SetDelta (uint32 hueDiv, - uint32 satDiv, - uint32 valDiv, - const HSBModify &modify) - { - - EnsureWriteable (); - - SetDeltaKnownWriteable (hueDiv, - satDiv, - valDiv, - modify); - - } - - /// Same as SetDelta, without checking that the table is writeable. - - void SetDeltaKnownWriteable (uint32 hueDiv, - uint32 satDiv, - uint32 valDiv, - const HSBModify &modify); - - /// Get the total number of samples (across all dimensions). - - uint32 DeltasCount () const - { - return fValDivisions * - fHueDivisions * - fSatDivisions; - } - - /// Direct read/write access to table entries. The entries are stored in - /// value-hue-saturation order (outer to inner). - - HSBModify *GetDeltas () - { - - EnsureWriteable (); - - return (HSBModify *) fDeltas.Buffer_real32 (); - - } - - /// Direct read-only access to table entries. The entries are stored in - /// value-hue-saturation order (outer to inner). - - const HSBModify *GetConstDeltas () const - { - return (const HSBModify *) fDeltas.Buffer_real32 (); - } - - /// Equality test. - - bool operator== (const dng_hue_sat_map &rhs) const; - - /// Compute a linearly-interpolated hue sat map (i.e., delta and scale factors) - /// from the specified tables, with the specified weight. map1 and map2 must - /// have the same dimensions. - - static dng_hue_sat_map * Interpolate (const dng_hue_sat_map &map1, - const dng_hue_sat_map &map2, - real64 weight1); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_ifd.cpp b/third_party/dng_sdk/dng_ifd.cpp deleted file mode 100644 index f506889..0000000 --- a/third_party/dng_sdk/dng_ifd.cpp +++ /dev/null @@ -1,4260 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_ifd.cpp#3 $ */ -/* $DateTime: 2012/06/05 11:05:39 $ */ -/* $Change: 833352 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_ifd.h" - -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_globals.h" -#include "dng_ifd.h" -#include "dng_types.h" -#include "dng_parse_utils.h" -#include "dng_read_image.h" -#include "dng_stream.h" -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_preview_info::dng_preview_info () - - : fIsPrimary (true) - , fApplicationName () - , fApplicationVersion () - , fSettingsName () - , fSettingsDigest () - , fColorSpace (previewColorSpace_MaxEnum) - , fDateTime () - , fRawToPreviewGain (1.0) - , fCacheVersion (0) - - { - - } - -/*****************************************************************************/ - -dng_preview_info::~dng_preview_info () - { - - } - -/*****************************************************************************/ - -dng_ifd::dng_ifd () - - : fUsesNewSubFileType (false) - , fNewSubFileType (0) - - , fImageWidth (0) - , fImageLength (0) - - , fCompression (ccUncompressed) - , fPredictor (cpNullPredictor) - - , fPhotometricInterpretation (0xFFFFFFFF) - - , fFillOrder (1) - - , fOrientation (0) - , fOrientationType (0) - , fOrientationOffset (kDNGStreamInvalidOffset) - , fOrientationBigEndian (false) - - , fSamplesPerPixel (1) - - , fPlanarConfiguration (pcInterleaved) - - , fXResolution (0.0) - , fYResolution (0.0) - , fResolutionUnit (0) - - , fUsesStrips (false) - , fUsesTiles (false) - - , fTileWidth (0) - , fTileLength (0) - - , fTileOffsetsType (0) - , fTileOffsetsCount (0) - , fTileOffsetsOffset (0) - - , fTileByteCountsType (0) - , fTileByteCountsCount (0) - , fTileByteCountsOffset (0) - - , fSubIFDsCount (0) - , fSubIFDsOffset (0) - - , fExtraSamplesCount (0) - - , fJPEGTablesCount (0) - , fJPEGTablesOffset (0) - - , fJPEGInterchangeFormat (0) - , fJPEGInterchangeFormatLength (0) - - , fYCbCrCoefficientR (0.0) - , fYCbCrCoefficientG (0.0) - , fYCbCrCoefficientB (0.0) - - , fYCbCrSubSampleH (0) - , fYCbCrSubSampleV (0) - - , fYCbCrPositioning (0) - - , fCFARepeatPatternRows (0) - , fCFARepeatPatternCols (0) - - , fCFALayout (1) - - , fLinearizationTableType (0) - , fLinearizationTableCount (0) - , fLinearizationTableOffset (0) - - , fBlackLevelRepeatRows (1) - , fBlackLevelRepeatCols (1) - - , fBlackLevelDeltaHType (0) - , fBlackLevelDeltaHCount (0) - , fBlackLevelDeltaHOffset (0) - - , fBlackLevelDeltaVType (0) - , fBlackLevelDeltaVCount (0) - , fBlackLevelDeltaVOffset (0) - - , fDefaultScaleH (1, 1) - , fDefaultScaleV (1, 1) - - , fBestQualityScale (1, 1) - - , fDefaultCropOriginH (0, 1) - , fDefaultCropOriginV (0, 1) - - , fDefaultCropSizeH () - , fDefaultCropSizeV () - - , fDefaultUserCropT (0, 1) - , fDefaultUserCropL (0, 1) - , fDefaultUserCropB (1, 1) - , fDefaultUserCropR (1, 1) - - , fBayerGreenSplit (0) - - , fChromaBlurRadius () - - , fAntiAliasStrength (1, 1) - - , fActiveArea () - - , fMaskedAreaCount (0) - - , fRowInterleaveFactor (1) - - , fSubTileBlockRows (1) - , fSubTileBlockCols (1) - - , fPreviewInfo () - - , fOpcodeList1Count (0) - , fOpcodeList1Offset (0) - - , fOpcodeList2Count (0) - , fOpcodeList2Offset (0) - - , fOpcodeList3Count (0) - , fOpcodeList3Offset (0) - - , fLosslessJPEGBug16 (false) - - , fSampleBitShift (0) - - , fThisIFD (0) - , fNextIFD (0) - - , fCompressionQuality (-1) - - , fPatchFirstJPEGByte (false) - - { - - uint32 j; - uint32 k; - uint32 n; - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - fBitsPerSample [j] = 0; - } - - for (j = 0; j < kMaxTileInfo; j++) - { - fTileOffset [j] = 0; - fTileByteCount [j] = 0; - } - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - fExtraSamples [j] = esUnspecified; - } - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - fSampleFormat [j] = sfUnsignedInteger; - } - - for (j = 0; j < 6; j++) - { - fReferenceBlackWhite [j] = 0.0; - } - - for (j = 0; j < kMaxCFAPattern; j++) - for (k = 0; k < kMaxCFAPattern; k++) - { - fCFAPattern [j] [k] = 255; - } - - for (j = 0; j < kMaxColorPlanes; j++) - { - fCFAPlaneColor [j] = (uint8) (j < 3 ? j : 255); - } - - for (j = 0; j < kMaxBlackPattern; j++) - for (k = 0; k < kMaxBlackPattern; k++) - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - fBlackLevel [j] [k] [n] = 0.0; - } - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - fWhiteLevel [j] = -1.0; // Don't know real default yet. - } - - } - -/*****************************************************************************/ - -dng_ifd::~dng_ifd () - { - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFDs that contain images. - -bool dng_ifd::ParseTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset) - { - - uint32 j; - uint32 k; - uint32 n; - - switch (tagCode) - { - - case tcNewSubFileType: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fUsesNewSubFileType = true; - - fNewSubFileType = stream.TagValue_uint32 (tagType); - - fPreviewInfo.fIsPrimary = (fNewSubFileType == sfPreviewImage); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("NewSubFileType: %s\n", - LookupNewSubFileType (fNewSubFileType)); - - } - - #endif - - break; - - } - - case tcImageWidth: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fImageWidth = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("ImageWidth: %u\n", (unsigned) fImageWidth); - } - - #endif - - break; - - } - - case tcImageLength: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fImageLength = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("ImageLength: %u\n", (unsigned) fImageLength); - } - - #endif - - break; - - } - - case tcBitsPerSample: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1, 0x0FFFF); - - #if qDNGValidate - - if (gVerbose) - { - printf ("BitsPerSample:"); - } - - #endif - - bool extrasMatch = true; - - for (j = 0; j < tagCount; j++) - { - - uint32 x = stream.TagValue_uint32 (tagType); - - if (j < kMaxSamplesPerPixel) - { - fBitsPerSample [j] = x; - } - - else if (x != fBitsPerSample [kMaxSamplesPerPixel - 1]) - { - extrasMatch = false; - } - - #if qDNGValidate - - if (gVerbose) - { - printf (" %u", (unsigned) x); - } - - #endif - - } - - #if qDNGValidate - - if (gVerbose) - { - printf ("\n"); - } - - #endif - - if (!extrasMatch) - { - - #if qDNGValidate - - ReportError ("BitsPerSample not constant"); - - #endif - - ThrowBadFormat (); - - } - - break; - - } - - case tcCompression: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCompression = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Compression: %s\n", - LookupCompression (fCompression)); - - } - - #endif - - // Correct a common TIFF writer mistake. - - if (fCompression == 0) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s has invalid zero compression code", - LookupParentCode (parentCode)); - - ReportWarning (message); - - } - - #endif - - fCompression = ccUncompressed; - - } - - break; - - } - - case tcPhotometricInterpretation: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPhotometricInterpretation = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PhotometricInterpretation: %s\n", - LookupPhotometricInterpretation (fPhotometricInterpretation)); - - } - - #endif - - break; - - } - - case tcFillOrder: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fFillOrder = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("FillOrder: %u\n", (unsigned) fFillOrder); - } - - #endif - - break; - - } - - case tcStripOffsets: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - fUsesStrips = true; - - fTileOffsetsType = tagType; - fTileOffsetsCount = tagCount; - fTileOffsetsOffset = tagOffset; - - if (tagCount <= kMaxTileInfo) - { - - for (j = 0; j < tagCount; j++) - { - - fTileOffset [j] = stream.TagValue_uint32 (tagType); - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - stream.SetReadPosition (tagOffset); - - DumpTagValues (stream, - "Offset", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcOrientation: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fOrientationType = tagType; - fOrientationOffset = stream.PositionInOriginalFile (); - fOrientationBigEndian = stream.BigEndian (); - - fOrientation = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Orientation: %s\n", - LookupOrientation (fOrientation)); - - } - - #endif - - break; - - } - - case tcSamplesPerPixel: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fSamplesPerPixel = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("SamplesPerPixel: %u\n", (unsigned) fSamplesPerPixel); - } - - #endif - - break; - - } - - case tcRowsPerStrip: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fUsesStrips = true; - - fTileLength = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("RowsPerStrip: %u\n", (unsigned) fTileLength); - } - - #endif - - break; - - } - - case tcStripByteCounts: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - fUsesStrips = true; - - fTileByteCountsType = tagType; - fTileByteCountsCount = tagCount; - fTileByteCountsOffset = tagOffset; - - if (tagCount <= kMaxTileInfo) - { - - for (j = 0; j < tagCount; j++) - { - - fTileByteCount [j] = stream.TagValue_uint32 (tagType); - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - stream.SetReadPosition (tagOffset); - - DumpTagValues (stream, - "Count", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcXResolution: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fXResolution = stream.TagValue_real64 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("XResolution: %0.2f\n", fXResolution); - } - - #endif - - break; - - } - - case tcYResolution: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fYResolution = stream.TagValue_real64 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("YResolution: %0.2f\n", fYResolution); - } - - #endif - - break; - - } - - case tcPlanarConfiguration: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPlanarConfiguration = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("PlanarConfiguration: %u\n", (unsigned) fPlanarConfiguration); - } - - #endif - - break; - - } - - case tcResolutionUnit: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fResolutionUnit = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ResolutionUnit: %s\n", - LookupResolutionUnit (fResolutionUnit)); - - } - - #endif - - break; - - } - - case tcPredictor: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPredictor = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Predictor: %s\n", - LookupPredictor (fPredictor)); - - } - - #endif - - break; - - } - - case tcTileWidth: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fUsesTiles = true; - - fTileWidth = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("TileWidth: %u\n", (unsigned) fTileWidth); - } - - #endif - - break; - - } - - case tcTileLength: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fUsesTiles = true; - - fTileLength = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("TileLength: %u\n", (unsigned) fTileLength); - } - - #endif - - break; - - } - - case tcTileOffsets: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - fUsesTiles = true; - - fTileOffsetsType = tagType; - fTileOffsetsCount = tagCount; - fTileOffsetsOffset = tagOffset; - - if (tagCount <= kMaxTileInfo) - { - - for (j = 0; j < tagCount; j++) - { - - fTileOffset [j] = stream.TagValue_uint32 (tagType); - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - stream.SetReadPosition (tagOffset); - - DumpTagValues (stream, - "Offset", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcTileByteCounts: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - fUsesTiles = true; - - fTileByteCountsType = tagType; - fTileByteCountsCount = tagCount; - fTileByteCountsOffset = tagOffset; - - if (tagCount <= kMaxTileInfo) - { - - for (j = 0; j < tagCount; j++) - { - - fTileByteCount [j] = stream.TagValue_uint32 (tagType); - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - stream.SetReadPosition (tagOffset); - - DumpTagValues (stream, - "Count", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcSubIFDs: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - fSubIFDsCount = tagCount; - fSubIFDsOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - DumpTagValues (stream, - "IFD", - parentCode, - tagCode, - ttLong, - tagCount); - - } - - #endif - - break; - - } - - case tcExtraSamples: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1, fSamplesPerPixel); - - #if qDNGValidate - - if (gVerbose) - { - printf ("ExtraSamples:"); - } - - #endif - - fExtraSamplesCount = tagCount; - - for (j = 0; j < tagCount; j++) - { - - uint32 x = stream.TagValue_uint32 (tagType); - - if (j < kMaxSamplesPerPixel) - { - fExtraSamples [j] = x; - } - - #if qDNGValidate - - if (gVerbose) - { - printf (" %u", (unsigned) x); - } - - #endif - - } - - #if qDNGValidate - - if (gVerbose) - { - printf ("\n"); - } - - #endif - - break; - - } - - case tcSampleFormat: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, fSamplesPerPixel); - - #if qDNGValidate - - if (gVerbose) - { - printf ("SampleFormat:"); - } - - #endif - - bool extrasMatch = true; - - for (j = 0; j < tagCount; j++) - { - - uint32 x = stream.TagValue_uint32 (tagType); - - if (j < kMaxSamplesPerPixel) - { - fSampleFormat [j] = x; - } - - else if (x != fSampleFormat [kMaxSamplesPerPixel - 1]) - { - extrasMatch = false; - } - - #if qDNGValidate - - if (gVerbose) - { - printf (" %s", LookupSampleFormat (x)); - } - - #endif - - } - - #if qDNGValidate - - if (gVerbose) - { - printf ("\n"); - } - - #endif - - if (!extrasMatch) - { - - #if qDNGValidate - - ReportError ("SampleFormat not constant"); - - #endif - - ThrowBadFormat (); - - } - - break; - - } - - case tcJPEGTables: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fJPEGTablesCount = tagCount; - fJPEGTablesOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("JPEGTables: count = %u, offset = %u\n", - (unsigned) fJPEGTablesCount, - (unsigned) fJPEGTablesOffset); - - } - - #endif - - break; - - } - - case tcJPEGInterchangeFormat: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fJPEGInterchangeFormat = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("JPEGInterchangeFormat: %u\n", - (unsigned) fJPEGInterchangeFormat); - } - - #endif - - break; - - } - - case tcJPEGInterchangeFormatLength: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fJPEGInterchangeFormatLength = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("JPEGInterchangeFormatLength: %u\n", - (unsigned) fJPEGInterchangeFormatLength); - } - - #endif - - break; - - } - - case tcYCbCrCoefficients: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 3)) - { - return false; - } - - fYCbCrCoefficientR = stream.TagValue_real64 (tagType); - fYCbCrCoefficientG = stream.TagValue_real64 (tagType); - fYCbCrCoefficientB = stream.TagValue_real64 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("YCbCrCoefficients: R = %0.3f, G = %0.3f, B = %0.3f\n", - fYCbCrCoefficientR, - fYCbCrCoefficientG, - fYCbCrCoefficientB); - - } - - #endif - - break; - - } - - case tcYCbCrSubSampling: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - { - return false; - } - - fYCbCrSubSampleH = stream.TagValue_uint32 (tagType); - fYCbCrSubSampleV = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("YCbCrSubSampling: H = %u, V = %u\n", - (unsigned) fYCbCrSubSampleH, - (unsigned) fYCbCrSubSampleV); - - } - - #endif - - break; - - } - - case tcYCbCrPositioning: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fYCbCrPositioning = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("YCbCrPositioning: %u\n", - (unsigned) fYCbCrPositioning); - - } - - #endif - - break; - - } - - case tcReferenceBlackWhite: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 6)) - { - return false; - } - - for (j = 0; j < 6; j++) - { - fReferenceBlackWhite [j] = stream.TagValue_real64 (tagType); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ReferenceBlackWhite: %0.1f %0.1f %0.1f %0.1f %0.1f %0.1f\n", - fReferenceBlackWhite [0], - fReferenceBlackWhite [1], - fReferenceBlackWhite [2], - fReferenceBlackWhite [3], - fReferenceBlackWhite [4], - fReferenceBlackWhite [5]); - - } - - #endif - - break; - - } - - case tcCFARepeatPatternDim: - { - - CheckCFA (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - { - return false; - } - - fCFARepeatPatternRows = stream.TagValue_uint32 (tagType); - fCFARepeatPatternCols = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CFARepeatPatternDim: Rows = %u, Cols = %u\n", - (unsigned) fCFARepeatPatternRows, - (unsigned) fCFARepeatPatternCols); - - } - - #endif - - break; - - } - - case tcCFAPattern: - { - - CheckCFA (parentCode, tagCode, fPhotometricInterpretation); - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - { - return false; - } - - if (!CheckTagCount (parentCode, tagCode, tagCount, fCFARepeatPatternRows * - fCFARepeatPatternCols)) - { - return false; - } - - if (fCFARepeatPatternRows < 1 || fCFARepeatPatternRows > kMaxCFAPattern || - fCFARepeatPatternCols < 1 || fCFARepeatPatternCols > kMaxCFAPattern) - { - return false; - } - - // Note that the Exif spec stores this array in a different - // scan order than the TIFF-EP spec. - - for (j = 0; j < fCFARepeatPatternRows; j++) - for (k = 0; k < fCFARepeatPatternCols; k++) - { - - fCFAPattern [j] [k] = stream.Get_uint8 (); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CFAPattern:\n"); - - for (j = 0; j < fCFARepeatPatternRows; j++) - { - - int32 spaces = 4; - - for (k = 0; k < fCFARepeatPatternCols; k++) - { - - while (spaces-- > 0) - { - printf (" "); - } - - const char *name = LookupCFAColor (fCFAPattern [j] [k]); - - spaces = 9 - (int32) strlen (name); - - printf ("%s", name); - - } - - printf ("\n"); - - } - - } - - #endif - - break; - - } - - case tcCFAPlaneColor: - { - - CheckCFA (parentCode, tagCode, fPhotometricInterpretation); - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - { - return false; - } - - if (!CheckTagCount (parentCode, tagCode, tagCount, 3, kMaxColorPlanes)) - { - return false; - } - - for (j = 0; j < kMaxColorPlanes; j++) - { - - if (j < tagCount) - fCFAPlaneColor [j] = stream.Get_uint8 (); - - else - fCFAPlaneColor [j] = 255; - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CFAPlaneColor:"); - - for (j = 0; j < tagCount; j++) - { - - printf (" %s", LookupCFAColor (fCFAPlaneColor [j])); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcCFALayout: - { - - CheckCFA (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCFALayout = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CFALayout: %s\n", - LookupCFALayout (fCFALayout)); - - } - - #endif - - break; - - } - - case tcLinearizationTable: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - fLinearizationTableType = tagType; - fLinearizationTableCount = tagCount; - fLinearizationTableOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - DumpTagValues (stream, - "Table", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcBlackLevelRepeatDim: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - { - return false; - } - - fBlackLevelRepeatRows = stream.TagValue_uint32 (tagType); - fBlackLevelRepeatCols = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BlackLevelRepeatDim: Rows = %u, Cols = %u\n", - (unsigned) fBlackLevelRepeatRows, - (unsigned) fBlackLevelRepeatCols); - - } - - #endif - - break; - - } - - case tcBlackLevel: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, fBlackLevelRepeatRows * - fBlackLevelRepeatCols * - fSamplesPerPixel)) - { - return false; - } - - if (fBlackLevelRepeatRows < 1 || fBlackLevelRepeatRows > kMaxBlackPattern || - fBlackLevelRepeatCols < 1 || fBlackLevelRepeatCols > kMaxBlackPattern || - fSamplesPerPixel < 1 || fSamplesPerPixel > kMaxSamplesPerPixel) - { - return false; - } - - for (j = 0; j < fBlackLevelRepeatRows; j++) - for (k = 0; k < fBlackLevelRepeatCols; k++) - for (n = 0; n < fSamplesPerPixel; n++) - { - - fBlackLevel [j] [k] [n] = stream.TagValue_real64 (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BlackLevel:"); - - if (fBlackLevelRepeatRows == 1 && - fBlackLevelRepeatCols == 1) - { - - for (n = 0; n < fSamplesPerPixel; n++) - { - printf (" %0.2f", fBlackLevel [0] [0] [n]); - } - - printf ("\n"); - - } - - else - { - - printf ("\n"); - - for (n = 0; n < fSamplesPerPixel; n++) - { - - if (fSamplesPerPixel > 1) - { - printf (" Sample: %u\n", (unsigned) n); - } - - for (j = 0; j < fBlackLevelRepeatRows; j++) - { - - printf (" "); - - for (k = 0; k < fBlackLevelRepeatCols; k++) - { - - printf (" %8.2f", fBlackLevel [j] [k] [n]); - - } - - printf ("\n"); - - } - - } - - } - - } - - #endif - - break; - - } - - case tcBlackLevelDeltaH: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - fBlackLevelDeltaHType = tagType; - fBlackLevelDeltaHCount = tagCount; - fBlackLevelDeltaHOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - DumpTagValues (stream, - "Delta", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcBlackLevelDeltaV: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - fBlackLevelDeltaVType = tagType; - fBlackLevelDeltaVCount = tagCount; - fBlackLevelDeltaVOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - DumpTagValues (stream, - "Delta", - parentCode, - tagCode, - tagType, - tagCount); - - } - - #endif - - break; - - } - - case tcWhiteLevel: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, fSamplesPerPixel)) - return false; - - for (j = 0; j < tagCount && j < kMaxSamplesPerPixel; j++) - { - - fWhiteLevel [j] = stream.TagValue_real64 (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("WhiteLevel:"); - - for (j = 0; j < tagCount && j < kMaxSamplesPerPixel; j++) - { - - printf (" %0.0f", fWhiteLevel [j]); - - } - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcDefaultScale: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fDefaultScaleH = stream.TagValue_urational (tagType); - fDefaultScaleV = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DefaultScale: H = %0.4f V = %0.4f\n", - fDefaultScaleH.As_real64 (), - fDefaultScaleV.As_real64 ()); - - } - - #endif - - break; - - } - - case tcDefaultCropOrigin: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fDefaultCropOriginH = stream.TagValue_urational (tagType); - fDefaultCropOriginV = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DefaultCropOrigin: H = %0.2f V = %0.2f\n", - fDefaultCropOriginH.As_real64 (), - fDefaultCropOriginV.As_real64 ()); - - } - - #endif - - break; - - } - - case tcDefaultCropSize: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fDefaultCropSizeH = stream.TagValue_urational (tagType); - fDefaultCropSizeV = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DefaultCropSize: H = %0.2f V = %0.2f\n", - fDefaultCropSizeH.As_real64 (), - fDefaultCropSizeV.As_real64 ()); - - } - - #endif - - break; - - } - - case tcDefaultUserCrop: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) - return false; - - fDefaultUserCropT = stream.TagValue_urational (tagType); - fDefaultUserCropL = stream.TagValue_urational (tagType); - fDefaultUserCropB = stream.TagValue_urational (tagType); - fDefaultUserCropR = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DefaultUserCrop: T = %0.2lf L = %0.2lf B = %0.2lf R = %0.2lf\n", - (double) fDefaultUserCropT.As_real64 (), - (double) fDefaultUserCropL.As_real64 (), - (double) fDefaultUserCropB.As_real64 (), - (double) fDefaultUserCropR.As_real64 ()); - - - } - - #endif // qDNGValidate - - break; - - } - - case tcBayerGreenSplit: - { - - CheckCFA (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBayerGreenSplit = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("BayerGreenSplit: %u\n", (unsigned) fBayerGreenSplit); - } - - #endif - - break; - - } - - case tcChromaBlurRadius: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fChromaBlurRadius = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ChromaBlurRadius: %0.2f\n", - fChromaBlurRadius.As_real64 ()); - - } - - #endif - - break; - - } - - case tcAntiAliasStrength: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fAntiAliasStrength = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AntiAliasStrength: %0.2f\n", - fAntiAliasStrength.As_real64 ()); - - } - - #endif - - break; - - } - - case tcBestQualityScale: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBestQualityScale = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BestQualityScale: %0.4f\n", - fBestQualityScale.As_real64 ()); - - } - - #endif - - break; - - } - - case tcActiveArea: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) - return false; - - fActiveArea.t = stream.TagValue_int32 (tagType); - fActiveArea.l = stream.TagValue_int32 (tagType); - fActiveArea.b = stream.TagValue_int32 (tagType); - fActiveArea.r = stream.TagValue_int32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ActiveArea: T = %d L = %d B = %d R = %d\n", - (int) fActiveArea.t, - (int) fActiveArea.l, - (int) fActiveArea.b, - (int) fActiveArea.r); - - } - - #endif - - break; - - } - - case tcMaskedAreas: - { - - CheckMainIFD (parentCode, tagCode, fNewSubFileType); - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - uint32 rect_count = tagCount / 4; - - if (!CheckTagCount (parentCode, tagCode, tagCount, rect_count * 4)) - return false; - - fMaskedAreaCount = rect_count; - - if (fMaskedAreaCount > kMaxMaskedAreas) - fMaskedAreaCount = kMaxMaskedAreas; - - for (j = 0; j < fMaskedAreaCount; j++) - { - - fMaskedArea [j].t = stream.TagValue_int32 (tagType); - fMaskedArea [j].l = stream.TagValue_int32 (tagType); - fMaskedArea [j].b = stream.TagValue_int32 (tagType); - fMaskedArea [j].r = stream.TagValue_int32 (tagType); - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("MaskedAreas: %u\n", (unsigned) fMaskedAreaCount); - - for (j = 0; j < fMaskedAreaCount; j++) - { - - printf (" Area [%u]: T = %d L = %d B = %d R = %d\n", - (unsigned) j, - (int) fMaskedArea [j].t, - (int) fMaskedArea [j].l, - (int) fMaskedArea [j].b, - (int) fMaskedArea [j].r); - - } - - } - - #endif - - break; - - } - - case tcPreviewApplicationName: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fPreviewInfo.fApplicationName, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewApplicationName: "); - - DumpString (fPreviewInfo.fApplicationName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcPreviewApplicationVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fPreviewInfo.fApplicationVersion, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewApplicationVersion: "); - - DumpString (fPreviewInfo.fApplicationVersion); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcPreviewSettingsName: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fPreviewInfo.fSettingsName, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewSettingsName: "); - - DumpString (fPreviewInfo.fSettingsName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcPreviewSettingsDigest: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) - return false; - - stream.Get (fPreviewInfo.fSettingsDigest.data, 16); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewSettingsDigest: "); - - DumpFingerprint (fPreviewInfo.fSettingsDigest); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcPreviewColorSpace: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fPreviewInfo.fColorSpace = (PreviewColorSpaceEnum) - stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewColorSpace: %s\n", - LookupPreviewColorSpace ((uint32) fPreviewInfo.fColorSpace)); - - } - - #endif - - break; - - } - - case tcPreviewDateTime: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fPreviewInfo.fDateTime, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("PreviewDateTime: "); - - DumpString (fPreviewInfo.fDateTime); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcRowInterleaveFactor: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) - return false; - - fRowInterleaveFactor = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RowInterleaveFactor: %u\n", - (unsigned) fRowInterleaveFactor); - - } - - #endif - - break; - - } - - case tcSubTileBlockSize: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fSubTileBlockRows = stream.TagValue_uint32 (tagType); - fSubTileBlockCols = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("SubTileBlockSize: rows = %u, cols = %u\n", - (unsigned) fSubTileBlockRows, - (unsigned) fSubTileBlockCols); - - } - - #endif - - break; - - } - - case tcOpcodeList1: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fOpcodeList1Count = tagCount; - fOpcodeList1Offset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OpcodeList1: count = %u, offset = %u\n", - (unsigned) fOpcodeList1Count, - (unsigned) fOpcodeList1Offset); - - } - - #endif - - break; - - } - - case tcOpcodeList2: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fOpcodeList2Count = tagCount; - fOpcodeList2Offset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OpcodeList2: count = %u, offset = %u\n", - (unsigned) fOpcodeList2Count, - (unsigned) fOpcodeList2Offset); - - } - - #endif - - break; - - } - - case tcOpcodeList3: - { - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fOpcodeList3Count = tagCount; - fOpcodeList3Offset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OpcodeList3: count = %u, offset = %u\n", - (unsigned) fOpcodeList3Count, - (unsigned) fOpcodeList3Offset); - - } - - #endif - - break; - - } - - case tcRawToPreviewGain: - { - - #if qDNGValidate - - if (fNewSubFileType != sfPreviewImage) - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed IFDs with NewSubFileType != PreviewImage", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttDouble); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) - return false; - - fPreviewInfo.fRawToPreviewGain = stream.TagValue_real64 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RawToPreviewGain = %f\n", - fPreviewInfo.fRawToPreviewGain); - - } - - #endif - - break; - - } - - case tcCacheVersion: - { - - #if qDNGValidate - - if (fNewSubFileType != sfPreviewImage) - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed IFDs with NewSubFileType != PreviewImage", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) - return false; - - fPreviewInfo.fCacheVersion = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CacheVersion = 0x%x\n", - (unsigned) fPreviewInfo.fCacheVersion); - - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_ifd::PostParse () - { - - uint32 j; - uint32 k; - - // There is only one PlanarConfiguration for single sample imaages. - - if (fSamplesPerPixel == 1) - { - fPlanarConfiguration = pcInterleaved; - } - - // Default tile size. - - if (fTileWidth == 0) - { - fTileWidth = fImageWidth; - } - - if (fTileLength == 0) - { - fTileLength = fImageLength; - } - - // Default ActiveArea. - - dng_rect imageArea (0, 0, fImageLength, fImageWidth); - - if (fActiveArea.IsZero ()) - { - fActiveArea = imageArea; - } - - // Default crop size. - - if (fDefaultCropSizeH.d == 0) - { - fDefaultCropSizeH = dng_urational (fActiveArea.W (), 1); - } - - if (fDefaultCropSizeV.d == 0) - { - fDefaultCropSizeV = dng_urational (fActiveArea.H (), 1); - } - - // Default white level. - - uint32 defaultWhite = (fSampleFormat [0] == sfFloatingPoint) ? - 1 : - (uint32) ((((uint64) 1) << fBitsPerSample [0]) - 1); - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - - if (fWhiteLevel [j] < 0.0) - { - fWhiteLevel [j] = (real64) defaultWhite; - } - - } - - // Check AntiAliasStrength. - - if (fAntiAliasStrength.As_real64 () < 0.0 || - fAntiAliasStrength.As_real64 () > 1.0) - { - - #if qDNGValidate - - ReportWarning ("Invalid AntiAliasStrength"); - - #endif - - fAntiAliasStrength = dng_urational (1, 1); - - } - - // Check MaskedAreas. - - for (j = 0; j < fMaskedAreaCount; j++) - { - - const dng_rect &r = fMaskedArea [j]; - - if (r.IsEmpty () || ((r & imageArea) != r)) - { - - #if qDNGValidate - - ReportWarning ("Invalid MaskedArea"); - - #endif - - fMaskedAreaCount = 0; - - break; - - } - - if ((r & fActiveArea).NotEmpty ()) - { - - #if qDNGValidate - - ReportWarning ("MaskedArea overlaps ActiveArea"); - - #endif - - fMaskedAreaCount = 0; - - break; - - } - - for (k = 0; k < j; k++) - { - - if ((r & fMaskedArea [k]).NotEmpty ()) - { - - #if qDNGValidate - - ReportWarning ("MaskedAreas overlap each other"); - - #endif - - fMaskedAreaCount = 0; - - break; - - } - - } - - } - - } - -/*****************************************************************************/ - -bool dng_ifd::IsValidCFA (dng_shared &shared, - uint32 parentCode) - { - - uint32 j; - uint32 k; - uint32 n; - - #if !qDNGValidate - - (void) parentCode; // Unused - - #endif - - if (fCFARepeatPatternRows < 1 || fCFARepeatPatternRows > kMaxCFAPattern || - fCFARepeatPatternCols < 1 || fCFARepeatPatternCols > kMaxCFAPattern) - { - - #if qDNGValidate - - ReportError ("Missing or invalid CFAPatternRepeatDim", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - uint32 count [kMaxColorPlanes]; - - for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) - { - count [n] = 0; - } - - for (j = 0; j < fCFARepeatPatternRows; j++) - { - - for (k = 0; k < fCFARepeatPatternCols; k++) - { - - bool found = false; - - for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) - { - - if (fCFAPattern [j] [k] == fCFAPlaneColor [n]) - { - found = true; - count [n] ++; - break; - } - - } - - if (!found) - { - - #if qDNGValidate - - ReportError ("CFAPattern contains colors not included in the CFAPlaneColor tag", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - } - - for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) - { - - if (count [n] == 0) - { - - #if qDNGValidate - - ReportError ("CFAPattern does not contain all the colors in the CFAPlaneColor tag", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - if (fCFALayout < 1 || fCFALayout > 9) - { - - #if qDNGValidate - - ReportError ("Invalid CFALayout", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_ifd::IsValidDNG (dng_shared &shared, - uint32 parentCode) - { - - uint32 j; - - bool isFloatingPoint = (fSampleFormat [0] == sfFloatingPoint); - - dng_rect imageArea (0, 0, fImageLength, fImageWidth); - - uint32 defaultWhite = isFloatingPoint ? - 1 : - (uint32) ((((uint64) 1) << fBitsPerSample [0]) - 1); - - bool isMonochrome = (shared.fCameraProfile.fColorPlanes == 1); - bool isColor = !isMonochrome; - - bool isMainIFD = (fNewSubFileType == sfMainImage); - - // Check NewSubFileType. - - if (!fUsesNewSubFileType) - { - - #if qDNGValidate - - ReportError ("Missing NewSubFileType", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fNewSubFileType != sfMainImage && - fNewSubFileType != sfPreviewImage && - fNewSubFileType != sfTransparencyMask && - fNewSubFileType != sfPreviewMask && - fNewSubFileType != sfAltPreviewImage) - { - - #if qDNGValidate - - ReportError ("Unexpected NewSubFileType", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check ImageWidth and ImageLength. - - if (fImageWidth < 1) - { - - #if qDNGValidate - - ReportError ("Missing or invalid ImageWidth", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fImageLength < 1) - { - - #if qDNGValidate - - ReportError ("Missing or invalid ImageLength", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fImageWidth > kMaxImageSide || - fImageLength > kMaxImageSide) - { - - #if qDNGValidate - - ReportWarning ("Image size is larger than supported"); - - #endif - - return false; - - } - - // Check PhotometricInterpretation. - - if (fNewSubFileType == sfTransparencyMask || - fNewSubFileType == sfPreviewMask) - { - - if (fPhotometricInterpretation != piTransparencyMask) - { - - #if qDNGValidate - - ReportError ("NewSubFileType requires PhotometricInterpretation = TransparencyMask", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - else - { - - switch (fPhotometricInterpretation) - { - - case piBlackIsZero: - case piRGB: - case piYCbCr: - { - - if (isMainIFD) - { - - #if qDNGValidate - - ReportError ("PhotometricInterpretation requires NewSubFileType = 1", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - case piCFA: - { - - if (!isMainIFD) - { - - #if qDNGValidate - - ReportError ("PhotometricInterpretation requires NewSubFileType = 0", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - case piLinearRaw: - break; - - default: - { - - #if qDNGValidate - - ReportError ("Missing or invalid PhotometricInterpretation", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - } - - switch (fPhotometricInterpretation) - { - - case piBlackIsZero: - { - - // Allow black in white previews even in color images since the - // raw processing software may be converting to grayscale. - - if (isColor && isMainIFD) - { - - #if qDNGValidate - - ReportError ("PhotometricInterpretation forbids use of ColorMatrix1 tag", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - case piRGB: - case piYCbCr: - { - - // Allow color previews even in monochrome DNG files, since the - // raw procesing software may be adding color effects. - - break; - - } - - case piCFA: - { - - if (isMonochrome) - { - - #if qDNGValidate - - ReportError ("PhotometricInterpretation requires use of ColorMatrix1 tag", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - } - - if (isFloatingPoint) - { - - if (fPhotometricInterpretation != piCFA && - fPhotometricInterpretation != piLinearRaw && - fPhotometricInterpretation != piTransparencyMask) - { - - #if qDNGValidate - - ReportError ("Floating point data requires PhotometricInterpretation CFA or LinearRaw or TransparencyMask", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check SamplesPerPixel and BitsPerSample. - - uint32 minSamplesPerPixel = 1; - uint32 maxSamplesPerPixel = 1; - - uint32 minBitsPerSample = 8; - uint32 maxBitsPerSample = 16; - - switch (fPhotometricInterpretation) - { - - case piBlackIsZero: - break; - - case piRGB: - case piYCbCr: - { - minSamplesPerPixel = 3; - maxSamplesPerPixel = 3; - break; - } - - case piCFA: - { - maxSamplesPerPixel = kMaxSamplesPerPixel; - maxBitsPerSample = 32; - break; - } - - case piLinearRaw: - { - minSamplesPerPixel = shared.fCameraProfile.fColorPlanes; - maxSamplesPerPixel = shared.fCameraProfile.fColorPlanes; - maxBitsPerSample = 32; - break; - } - - case piTransparencyMask: - { - minBitsPerSample = 8; - maxBitsPerSample = 16; - break; - } - - } - - if (isFloatingPoint) - { - minBitsPerSample = 16; - maxBitsPerSample = 32; - } - - if (fSamplesPerPixel < minSamplesPerPixel || - fSamplesPerPixel > maxSamplesPerPixel) - { - - #if qDNGValidate - - ReportError ("Missing or invalid SamplesPerPixel", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - for (j = 0; j < kMaxSamplesPerPixel; j++) - { - - if (j < fSamplesPerPixel) - { - - if (fBitsPerSample [j] < minBitsPerSample || - fBitsPerSample [j] > maxBitsPerSample) - { - - #if qDNGValidate - - ReportError ("Missing or invalid BitsPerSample", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (isFloatingPoint && - fBitsPerSample [j] != 16 && - fBitsPerSample [j] != 24 && - fBitsPerSample [j] != 32) - { - - #if qDNGValidate - - ReportError ("Invalid BitsPerSample for floating point", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (minBitsPerSample == 8 && - maxBitsPerSample == 16 && - fBitsPerSample [j] != 8 && - fBitsPerSample [j] != 16) - { - - #if qDNGValidate - - ReportError ("Rendered previews and integer masks require 8 or 16 bits per sample", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (j > 0 && fBitsPerSample [j] != fBitsPerSample [0]) - { - - #if qDNGValidate - - ReportError ("BitsPerSample not equal for all samples", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - else - { - - if (fBitsPerSample [j] != 0) - { - - #if qDNGValidate - - ReportError ("Too many values specified in BitsPerSample", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - } - - // Check Compression. - - switch (fCompression) - { - - case ccUncompressed: - break; - - case ccJPEG: - { - - if (fPhotometricInterpretation == piRGB) - { - - #if qDNGValidate - - ReportError ("JPEG previews should use PhotometricInterpretation = YCbYb", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fBitsPerSample [0] > 16) - { - - #if qDNGValidate - - ReportError ("JPEG compression is limited to 16 bits/sample", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - case ccLossyJPEG: - { - - if (fPhotometricInterpretation != piLinearRaw) - { - - #if qDNGValidate - - ReportError ("Lossy JPEG compression code requires PhotometricInterpretation = LinearRaw", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fBitsPerSample [0] != 8) - { - - #if qDNGValidate - - ReportError ("Lossy JPEG compression is limited to 8 bits/sample", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - break; - - } - - case ccDeflate: - { - - if (!isFloatingPoint && - fBitsPerSample [0] != 32 && - fPhotometricInterpretation != piTransparencyMask) - { - - #if qDNGValidate - - ReportError ("ZIP compression is limited to floating point and 32-bit integer and transparency masks", - LookupParentCode (parentCode)); - - #endif - - } - - break; - - } - - default: - { - - #if qDNGValidate - - ReportError ("Unsupported Compression", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check Predictor. - - if (isFloatingPoint && fCompression == ccDeflate && - (fPredictor == cpFloatingPoint || - fPredictor == cpFloatingPointX2 || - fPredictor == cpFloatingPointX4)) - { - - // These combinations are supported. - - } - - else if (!isFloatingPoint && fCompression == ccDeflate && - (fPredictor == cpHorizontalDifference || - fPredictor == cpHorizontalDifferenceX2 || - fPredictor == cpHorizontalDifferenceX4)) - { - - // These combinations are supported. - - } - - else if (fPredictor != cpNullPredictor) - { - - #if qDNGValidate - - ReportError ("Unsupported Predictor", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check FillOrder. - - if (fFillOrder != 1) - { - - #if qDNGValidate - - ReportError ("Unsupported FillOrder", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check PlanarConfiguration. - - if (fPlanarConfiguration != pcInterleaved) - { - - #if qDNGValidate - - ReportError ("Unsupported PlanarConfiguration", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check ExtraSamples. - - if (fExtraSamplesCount != 0) - { - - #if qDNGValidate - - ReportError ("Unsupported ExtraSamples", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check SampleFormat. - - for (j = 0; j < fSamplesPerPixel; j++) - { - - if (fSampleFormat [j] != (isFloatingPoint ? sfFloatingPoint : sfUnsignedInteger)) - { - - #if qDNGValidate - - ReportError ("Unsupported SampleFormat", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check Orientation. - - if (fOrientation > 9) - { - - #if qDNGValidate - - ReportError ("Unknown Orientation", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - #if qDNGValidate - - if (fOrientation != 0 && parentCode != 0) - { - - ReportWarning ("Unexpected Orientation tag", - LookupParentCode (parentCode)); - - } - - if (fOrientation == 0 && parentCode == 0) - { - - ReportWarning ("Missing Orientation tag", - LookupParentCode (parentCode)); - - } - - #endif - - // Check Strips vs. Tiles. - - if (!fUsesStrips && !fUsesTiles) - { - - #if qDNGValidate - - ReportError ("IFD uses neither strips nor tiles", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fUsesStrips && fUsesTiles) - { - - #if qDNGValidate - - ReportError ("IFD uses both strips and tiles", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check tile info. - - uint32 tilesWide = (fImageWidth + fTileWidth - 1) / fTileWidth; - uint32 tilesHigh = (fImageLength + fTileLength - 1) / fTileLength; - - uint32 tileCount = tilesWide * tilesHigh; - - if (fTileOffsetsCount != tileCount) - { - - #if qDNGValidate - - ReportError ("Missing or invalid Strip/TileOffsets", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fTileByteCountsCount != tileCount) - { - - #if qDNGValidate - - ReportError ("Missing or invalid Strip/TileByteCounts", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check CFA pattern. - - if (fPhotometricInterpretation == piCFA) - { - - if (!IsValidCFA (shared, parentCode)) - { - - return false; - - } - - } - - // Check ActiveArea. - - if (((fActiveArea & imageArea) != fActiveArea) || fActiveArea.IsEmpty ()) - { - - #if qDNGValidate - - ReportError ("Invalid ActiveArea", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fActiveArea != imageArea) - { - - if (shared.fDNGBackwardVersion < dngVersion_1_1_0_0) - { - - #if qDNGValidate - - ReportError ("Non-default ActiveArea tag not allowed in this DNG version", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check LinearizationTable. - - if (fLinearizationTableCount) - { - - if (fLinearizationTableType != ttShort) - { - - #if qDNGValidate - - ReportError ("Invalidate LinearizationTable type", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (fLinearizationTableCount < 2 || - fLinearizationTableCount > 65536) - { - - #if qDNGValidate - - ReportError ("Invalidate LinearizationTable count", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (isFloatingPoint || fBitsPerSample [0] > 16) - { - - #if qDNGValidate - - ReportError ("Linearization table not allowed for this data type", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check BlackLevelRepeatDim. - - if (fBlackLevelRepeatRows < 1 || fBlackLevelRepeatRows > kMaxBlackPattern || - fBlackLevelRepeatCols < 1 || fBlackLevelRepeatCols > kMaxBlackPattern) - { - - #if qDNGValidate - - ReportError ("Invalid BlackLevelRepeatDim", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check BlackLevelDeltaH. - - if (fBlackLevelDeltaHCount != 0 && - fBlackLevelDeltaHCount != fActiveArea.W ()) - { - - #if qDNGValidate - - ReportError ("Invalid BlackLevelDeltaH count", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check BlackLevelDeltaV. - - if (fBlackLevelDeltaVCount != 0 && - fBlackLevelDeltaVCount != fActiveArea.H ()) - { - - #if qDNGValidate - - ReportError ("Invalid BlackLevelDeltaV count", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - // Check WhiteLevel. - - real64 maxWhite = fLinearizationTableCount ? 65535.0 - : (real64) defaultWhite; - - for (j = 0; j < fSamplesPerPixel; j++) - { - - if (fWhiteLevel [j] < 1.0 || (fWhiteLevel [j] > maxWhite && !isFloatingPoint)) - { - - #if qDNGValidate - - ReportError ("Invalid WhiteLevel", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check BlackLevel. - - for (j = 0; j < kMaxBlackPattern; j++) - { - - for (uint32 k = 0; k < kMaxBlackPattern; k++) - { - - for (uint32 s = 0; s < kMaxSamplesPerPixel; s++) - { - - const real64 black = fBlackLevel [j][k][s]; - - if (black >= fWhiteLevel [s]) - { - - #if qDNGValidate - - ReportError ("Invalid BlackLevel", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - } - - } - - // Check DefaultScale. - - if (fDefaultScaleH.As_real64 () <= 0.0 || - fDefaultScaleV.As_real64 () <= 0.0) - { - - #if qDNGValidate - - ReportError ("Invalid DefaultScale"); - - #endif - - return false; - - } - - // Check BestQualityScale. - - if (fBestQualityScale.As_real64 () < 1.0) - { - - #if qDNGValidate - - ReportError ("Invalid BestQualityScale"); - - #endif - - return false; - - } - - // Check DefaultCropOrigin. - - if (fDefaultCropOriginH.As_real64 () < 0.0 || - fDefaultCropOriginV.As_real64 () < 0.0 || - fDefaultCropOriginH.As_real64 () >= (real64) fActiveArea.W () || - fDefaultCropOriginV.As_real64 () >= (real64) fActiveArea.H ()) - { - - #if qDNGValidate - - ReportError ("Invalid DefaultCropOrigin"); - - #endif - - return false; - - } - - // Check DefaultCropSize. - - if (fDefaultCropSizeH.As_real64 () <= 0.0 || - fDefaultCropSizeV.As_real64 () <= 0.0 || - fDefaultCropSizeH.As_real64 () > (real64) fActiveArea.W () || - fDefaultCropSizeV.As_real64 () > (real64) fActiveArea.H ()) - { - - #if qDNGValidate - - ReportError ("Invalid DefaultCropSize"); - - #endif - - return false; - - } - - // Check DefaultCrop area. - - if (fDefaultCropOriginH.As_real64 () + - fDefaultCropSizeH .As_real64 () > (real64) fActiveArea.W () || - fDefaultCropOriginV.As_real64 () + - fDefaultCropSizeV .As_real64 () > (real64) fActiveArea.H ()) - { - - #if qDNGValidate - - ReportError ("Default crop extends outside ActiveArea"); - - #endif - - return false; - - } - - // Check DefaultUserCrop. - - if (fDefaultUserCropT.As_real64 () < 0.0 || - fDefaultUserCropL.As_real64 () < 0.0 || - fDefaultUserCropB.As_real64 () > 1.0 || - fDefaultUserCropR.As_real64 () > 1.0 || - fDefaultUserCropT.As_real64 () >= fDefaultUserCropB.As_real64 () || - fDefaultUserCropL.As_real64 () >= fDefaultUserCropR.As_real64 ()) - { - - #if qDNGValidate - - ReportError ("Invalid DefaultUserCrop"); - - #endif // qDNGValidate - - return false; - - } - - // The default crop and default user crop tags are not allowed for the - // non-main image. If they are there, at least require that they be NOPs. - - if (!isMainIFD) - { - - if (Round_int32 (fDefaultCropOriginH.As_real64 ()) != 0 || - Round_int32 (fDefaultCropOriginV.As_real64 ()) != 0) - { - - #if qDNGValidate - - ReportError ("non-default DefaultCropOrigin on non-main image"); - - #endif - - return false; - - } - - if (Round_int32 (fDefaultCropSizeH.As_real64 ()) != (int32) fImageWidth || - Round_int32 (fDefaultCropSizeV.As_real64 ()) != (int32) fImageLength) - { - - #if qDNGValidate - - ReportError ("non-default DefaultCropSize on non-main image"); - - #endif - - return false; - - } - - if (fDefaultUserCropT.As_real64 () != 0.0 || - fDefaultUserCropL.As_real64 () != 0.0 || - fDefaultUserCropB.As_real64 () != 1.0 || - fDefaultUserCropR.As_real64 () != 1.0) - { - - #if qDNGValidate - - ReportError ("non-default DefaultCUserCrop on non-main image"); - - #endif // qDNGValidate - - return false; - - } - - } - - // Warning if too little padding on CFA image. - - #if qDNGValidate - - if (fPhotometricInterpretation == piCFA) - { - - const real64 kMinPad = 1.9; - - if (fDefaultCropOriginH.As_real64 () < kMinPad) - { - - ReportWarning ("Too little padding on left edge of CFA image", - "possible interpolation artifacts"); - - } - - if (fDefaultCropOriginV.As_real64 () < kMinPad) - { - - ReportWarning ("Too little padding on top edge of CFA image", - "possible interpolation artifacts"); - - } - - if (fDefaultCropOriginH.As_real64 () + - fDefaultCropSizeH .As_real64 () > (real64) fActiveArea.W () - kMinPad) - { - - ReportWarning ("Too little padding on right edge of CFA image", - "possible interpolation artifacts"); - - } - - if (fDefaultCropOriginV.As_real64 () + - fDefaultCropSizeV .As_real64 () > (real64) fActiveArea.H () - kMinPad) - { - - ReportWarning ("Too little padding on bottom edge of CFA image", - "possible interpolation artifacts"); - - } - - } - - #endif - - // Check RowInterleaveFactor - - if (fRowInterleaveFactor != 1) - { - - if (fRowInterleaveFactor < 1 || - fRowInterleaveFactor > fImageLength) - { - - #if qDNGValidate - - ReportError ("RowInterleaveFactor out of valid range", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (shared.fDNGBackwardVersion < dngVersion_1_2_0_0) - { - - #if qDNGValidate - - ReportError ("Non-default RowInterleaveFactor tag not allowed in this DNG version", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - // Check SubTileBlockSize - - if (fSubTileBlockRows != 1 || fSubTileBlockCols != 1) - { - - if (fSubTileBlockRows < 2 || fSubTileBlockRows > fTileLength || - fSubTileBlockCols < 1 || fSubTileBlockCols > fTileWidth) - { - - #if qDNGValidate - - ReportError ("SubTileBlockSize out of valid range", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if ((fTileLength % fSubTileBlockRows) != 0 || - (fTileWidth % fSubTileBlockCols) != 0) - { - - #if qDNGValidate - - ReportError ("TileSize not exact multiple of SubTileBlockSize", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - if (shared.fDNGBackwardVersion < dngVersion_1_2_0_0) - { - - #if qDNGValidate - - ReportError ("Non-default SubTileBlockSize tag not allowed in this DNG version", - LookupParentCode (parentCode)); - - #endif - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -uint32 dng_ifd::TilesAcross () const - { - - if (fTileWidth) - { - - return (fImageWidth + fTileWidth - 1) / fTileWidth; - - } - - return 0; - - } - -/*****************************************************************************/ - -uint32 dng_ifd::TilesDown () const - { - - if (fTileLength) - { - - return (fImageLength + fTileLength - 1) / fTileLength; - - } - - return 0; - - } - -/*****************************************************************************/ - -uint32 dng_ifd::TilesPerImage () const - { - - uint32 total = TilesAcross () * TilesDown (); - - if (fPlanarConfiguration == pcPlanar) - { - - total *= fSamplesPerPixel; - - } - - return total; - - } - -/*****************************************************************************/ - -dng_rect dng_ifd::TileArea (uint32 rowIndex, - uint32 colIndex) const - { - - dng_rect r; - - r.t = rowIndex * fTileLength; - r.b = r.t + fTileLength; - - r.l = colIndex * fTileWidth; - r.r = r.l + fTileWidth; - - // If this IFD is using strips rather than tiles, the last strip - // is trimmed so it does not extend beyond the end of the image. - - if (fUsesStrips) - { - - r.b = Min_uint32 (r.b, fImageLength); - - } - - return r; - - } - -/*****************************************************************************/ - -uint32 dng_ifd::TileByteCount (const dng_rect &tile) const - { - - if (fCompression == ccUncompressed) - { - - uint32 bitsPerRow = tile.W () * - fBitsPerSample [0]; - - if (fPlanarConfiguration == pcInterleaved) - { - - bitsPerRow *= fSamplesPerPixel; - - } - - uint32 bytesPerRow = (bitsPerRow + 7) >> 3; - - if (fPlanarConfiguration == pcRowInterleaved) - { - - bytesPerRow *= fSamplesPerPixel; - - } - - return bytesPerRow * tile.H (); - - } - - return 0; - - } - -/*****************************************************************************/ - -void dng_ifd::SetSingleStrip () - { - - fTileWidth = fImageWidth; - fTileLength = fImageLength; - - fUsesTiles = false; - fUsesStrips = true; - - } - -/*****************************************************************************/ - -void dng_ifd::FindTileSize (uint32 bytesPerTile, - uint32 cellH, - uint32 cellV) - { - - uint32 bytesPerSample = fSamplesPerPixel * - ((fBitsPerSample [0] + 7) >> 3); - - uint32 samplesPerTile = bytesPerTile / bytesPerSample; - - uint32 tileSide = Round_uint32 (sqrt ((real64) samplesPerTile)); - - fTileWidth = Min_uint32 (fImageWidth, tileSide); - - uint32 across = TilesAcross (); - - fTileWidth = (fImageWidth + across - 1) / across; - - fTileWidth = ((fTileWidth + cellH - 1) / cellH) * cellH; - - fTileLength = Pin_uint32 (1, - samplesPerTile / fTileWidth, - fImageLength); - - uint32 down = TilesDown (); - - fTileLength = (fImageLength + down - 1) / down; - - fTileLength = ((fTileLength + cellV - 1) / cellV) * cellV; - - fUsesTiles = true; - fUsesStrips = false; - - } - -/*****************************************************************************/ - -void dng_ifd::FindStripSize (uint32 bytesPerStrip, - uint32 cellV) - { - - uint32 bytesPerSample = fSamplesPerPixel * - ((fBitsPerSample [0] + 7) >> 3); - - uint32 samplesPerStrip = bytesPerStrip / bytesPerSample; - - fTileWidth = fImageWidth; - - fTileLength = Pin_uint32 (1, - samplesPerStrip / fTileWidth, - fImageLength); - - uint32 down = TilesDown (); - - fTileLength = (fImageLength + down - 1) / down; - - fTileLength = ((fTileLength + cellV - 1) / cellV) * cellV; - - fUsesTiles = false; - fUsesStrips = true; - - } - -/*****************************************************************************/ - -uint32 dng_ifd::PixelType () const - { - - if (fSampleFormat [0] == sfFloatingPoint) - { - return ttFloat; - } - - if (fBitsPerSample [0] <= 8) - { - return ttByte; - } - - else if (fBitsPerSample [0] <= 16) - { - return ttShort; - } - - return ttLong; - - } - -/*****************************************************************************/ - -bool dng_ifd::IsBaselineJPEG () const - { - - if (fBitsPerSample [0] != 8) - { - return false; - } - - if (fSampleFormat [0] != sfUnsignedInteger) - { - return false; - } - - if (fCompression == ccLossyJPEG) - { - return true; - } - - if (fCompression != ccJPEG) - { - return false; - } - - switch (fPhotometricInterpretation) - { - - case piBlackIsZero: - { - return (fSamplesPerPixel == 1); - } - - case piYCbCr: - { - return (fSamplesPerPixel == 3 ) && - (fPlanarConfiguration == pcInterleaved); - } - - default: - break; - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_ifd::CanRead () const - { - - dng_read_image reader; - - return reader.CanRead (*this); - - } - -/*****************************************************************************/ - -void dng_ifd::ReadImage (dng_host &host, - dng_stream &stream, - dng_image &image, - dng_jpeg_image *jpegImage, - dng_fingerprint *jpegDigest) const - { - - dng_read_image reader; - - reader.Read (host, - *this, - stream, - image, - jpegImage, - jpegDigest); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_ifd.h b/third_party/dng_sdk/dng_ifd.h deleted file mode 100644 index c0b681d..0000000 --- a/third_party/dng_sdk/dng_ifd.h +++ /dev/null @@ -1,305 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_ifd.h#3 $ */ -/* $DateTime: 2012/06/05 11:05:39 $ */ -/* $Change: 833352 $ */ -/* $Author: tknoll $ */ - -/** \file - * DNG image file directory support. - */ - -/*****************************************************************************/ - -#ifndef __dng_ifd__ -#define __dng_ifd__ - -/*****************************************************************************/ - -#include "dng_fingerprint.h" -#include "dng_rect.h" -#include "dng_shared.h" -#include "dng_stream.h" -#include "dng_string.h" -#include "dng_sdk_limits.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -class dng_preview_info - { - - public: - - bool fIsPrimary; - - dng_string fApplicationName; - - dng_string fApplicationVersion; - - dng_string fSettingsName; - - dng_fingerprint fSettingsDigest; - - PreviewColorSpaceEnum fColorSpace; - - dng_string fDateTime; - - real64 fRawToPreviewGain; - - uint32 fCacheVersion; - - public: - - dng_preview_info (); - - ~dng_preview_info (); - - }; - -/*****************************************************************************/ - -/// \brief Container for a single image file directory of a digital negative. -/// -/// See \ref spec_dng "DNG 1.1.0 specification" for documentation of specific tags. - -class dng_ifd - { - - public: - - bool fUsesNewSubFileType; - - uint32 fNewSubFileType; - - uint32 fImageWidth; - uint32 fImageLength; - - uint32 fBitsPerSample [kMaxSamplesPerPixel]; - - uint32 fCompression; - - uint32 fPredictor; - - uint32 fPhotometricInterpretation; - - uint32 fFillOrder; - - uint32 fOrientation; - uint32 fOrientationType; - uint64 fOrientationOffset; - bool fOrientationBigEndian; - - uint32 fSamplesPerPixel; - - uint32 fPlanarConfiguration; - - real64 fXResolution; - real64 fYResolution; - - uint32 fResolutionUnit; - - bool fUsesStrips; - bool fUsesTiles; - - uint32 fTileWidth; - uint32 fTileLength; - - enum - { - kMaxTileInfo = 32 - }; - - uint32 fTileOffsetsType; - uint32 fTileOffsetsCount; - uint64 fTileOffsetsOffset; - uint64 fTileOffset [kMaxTileInfo]; - - uint32 fTileByteCountsType; - uint32 fTileByteCountsCount; - uint64 fTileByteCountsOffset; - uint32 fTileByteCount [kMaxTileInfo]; - - uint32 fSubIFDsCount; - uint64 fSubIFDsOffset; - - uint32 fExtraSamplesCount; - uint32 fExtraSamples [kMaxSamplesPerPixel]; - - uint32 fSampleFormat [kMaxSamplesPerPixel]; - - uint32 fJPEGTablesCount; - uint64 fJPEGTablesOffset; - - uint64 fJPEGInterchangeFormat; - uint32 fJPEGInterchangeFormatLength; - - real64 fYCbCrCoefficientR; - real64 fYCbCrCoefficientG; - real64 fYCbCrCoefficientB; - - uint32 fYCbCrSubSampleH; - uint32 fYCbCrSubSampleV; - - uint32 fYCbCrPositioning; - - real64 fReferenceBlackWhite [6]; - - uint32 fCFARepeatPatternRows; - uint32 fCFARepeatPatternCols; - - uint8 fCFAPattern [kMaxCFAPattern] [kMaxCFAPattern]; - - uint8 fCFAPlaneColor [kMaxColorPlanes]; - - uint32 fCFALayout; - - uint32 fLinearizationTableType; - uint32 fLinearizationTableCount; - uint64 fLinearizationTableOffset; - - uint32 fBlackLevelRepeatRows; - uint32 fBlackLevelRepeatCols; - - real64 fBlackLevel [kMaxBlackPattern] [kMaxBlackPattern] [kMaxSamplesPerPixel]; - - uint32 fBlackLevelDeltaHType; - uint32 fBlackLevelDeltaHCount; - uint64 fBlackLevelDeltaHOffset; - - uint32 fBlackLevelDeltaVType; - uint32 fBlackLevelDeltaVCount; - uint64 fBlackLevelDeltaVOffset; - - real64 fWhiteLevel [kMaxSamplesPerPixel]; - - dng_urational fDefaultScaleH; - dng_urational fDefaultScaleV; - - dng_urational fBestQualityScale; - - dng_urational fDefaultCropOriginH; - dng_urational fDefaultCropOriginV; - - dng_urational fDefaultCropSizeH; - dng_urational fDefaultCropSizeV; - - dng_urational fDefaultUserCropT; - dng_urational fDefaultUserCropL; - dng_urational fDefaultUserCropB; - dng_urational fDefaultUserCropR; - - uint32 fBayerGreenSplit; - - dng_urational fChromaBlurRadius; - - dng_urational fAntiAliasStrength; - - dng_rect fActiveArea; - - uint32 fMaskedAreaCount; - dng_rect fMaskedArea [kMaxMaskedAreas]; - - uint32 fRowInterleaveFactor; - - uint32 fSubTileBlockRows; - uint32 fSubTileBlockCols; - - dng_preview_info fPreviewInfo; - - uint32 fOpcodeList1Count; - uint64 fOpcodeList1Offset; - - uint32 fOpcodeList2Count; - uint64 fOpcodeList2Offset; - - uint32 fOpcodeList3Count; - uint64 fOpcodeList3Offset; - - bool fLosslessJPEGBug16; - - uint32 fSampleBitShift; - - uint64 fThisIFD; - uint64 fNextIFD; - - int32 fCompressionQuality; - - bool fPatchFirstJPEGByte; - - public: - - dng_ifd (); - - virtual ~dng_ifd (); - - virtual bool ParseTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual void PostParse (); - - virtual bool IsValidDNG (dng_shared &shared, - uint32 parentCode); - - dng_rect Bounds () const - { - return dng_rect (0, - 0, - fImageLength, - fImageWidth); - } - - uint32 TilesAcross () const; - - uint32 TilesDown () const; - - uint32 TilesPerImage () const; - - dng_rect TileArea (uint32 rowIndex, - uint32 colIndex) const; - - virtual uint32 TileByteCount (const dng_rect &tile) const; - - void SetSingleStrip (); - - void FindTileSize (uint32 bytesPerTile = 128 * 1024, - uint32 cellH = 16, - uint32 cellV = 16); - - void FindStripSize (uint32 bytesPerStrip = 128 * 1024, - uint32 cellV = 16); - - virtual uint32 PixelType () const; - - virtual bool IsBaselineJPEG () const; - - virtual bool CanRead () const; - - virtual void ReadImage (dng_host &host, - dng_stream &stream, - dng_image &image, - dng_jpeg_image *jpegImage = NULL, - dng_fingerprint *jpegDigest = NULL) const; - - protected: - - virtual bool IsValidCFA (dng_shared &shared, - uint32 parentCode); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_image.cpp b/third_party/dng_sdk/dng_image.cpp deleted file mode 100644 index 50fd085..0000000 --- a/third_party/dng_sdk/dng_image.cpp +++ /dev/null @@ -1,848 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_image.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_image.h" - -#include "dng_assertions.h" -#include "dng_exceptions.h" -#include "dng_orientation.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_tile_iterator.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_tile_buffer::dng_tile_buffer (const dng_image &image, - const dng_rect &tile, - bool dirty) - - : fImage (image) - , fRefData (NULL) - - { - - fImage.AcquireTileBuffer (*this, - tile, - dirty); - - } - -/*****************************************************************************/ - -dng_tile_buffer::~dng_tile_buffer () - { - - fImage.ReleaseTileBuffer (*this); - - } - -/*****************************************************************************/ - -dng_const_tile_buffer::dng_const_tile_buffer (const dng_image &image, - const dng_rect &tile) - - : dng_tile_buffer (image, tile, false) - - { - - } - -/*****************************************************************************/ - -dng_const_tile_buffer::~dng_const_tile_buffer () - { - - } - -/*****************************************************************************/ - -dng_dirty_tile_buffer::dng_dirty_tile_buffer (dng_image &image, - const dng_rect &tile) - - : dng_tile_buffer (image, tile, true) - - { - - } - -/*****************************************************************************/ - -dng_dirty_tile_buffer::~dng_dirty_tile_buffer () - { - - } - -/*****************************************************************************/ - -dng_image::dng_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType) - - : fBounds (bounds) - , fPlanes (planes) - , fPixelType (pixelType) - - { - - if (bounds.IsEmpty () || planes == 0 || PixelSize () == 0) - { - - #if qDNGValidate - - ReportError ("Fuzz: Attempt to create zero size image"); - - #endif - - ThrowBadFormat (); - - } - - } - -/*****************************************************************************/ - -dng_image::~dng_image () - { - - } - -/*****************************************************************************/ - -dng_image * dng_image::Clone () const - { - - ThrowProgramError ("Clone is not supported by this dng_image subclass"); - - return NULL; - - } - -/*****************************************************************************/ - -void dng_image::SetPixelType (uint32 pixelType) - { - - if (TagTypeSize (pixelType) != PixelSize ()) - { - - ThrowProgramError ("Cannot change pixel size for existing image"); - - } - - fPixelType = pixelType; - - } - -/*****************************************************************************/ - -uint32 dng_image::PixelSize () const - { - - return TagTypeSize (PixelType ()); - - } - -/*****************************************************************************/ - -uint32 dng_image::PixelRange () const - { - - switch (fPixelType) - { - - case ttByte: - case ttSByte: - { - return 0x0FF; - } - - case ttShort: - case ttSShort: - { - return 0x0FFFF; - } - - case ttLong: - case ttSLong: - { - return 0xFFFFFFFF; - } - - default: - break; - - } - - return 0; - - } - -/*****************************************************************************/ - -dng_rect dng_image::RepeatingTile () const - { - - return fBounds; - - } - -/*****************************************************************************/ - -void dng_image::AcquireTileBuffer (dng_tile_buffer & /* buffer */, - const dng_rect & /* area */, - bool /* dirty */) const - { - - ThrowProgramError (); - - } - -/*****************************************************************************/ - -void dng_image::ReleaseTileBuffer (dng_tile_buffer & /* buffer */) const - { - - } - -/*****************************************************************************/ - -void dng_image::DoGet (dng_pixel_buffer &buffer) const - { - - dng_rect tile; - - dng_tile_iterator iter (*this, buffer.fArea); - - while (iter.GetOneTile (tile)) - { - - dng_const_tile_buffer tileBuffer (*this, tile); - - buffer.CopyArea (tileBuffer, - tile, - buffer.fPlane, - buffer.fPlanes); - - } - - } - -/*****************************************************************************/ - -void dng_image::DoPut (const dng_pixel_buffer &buffer) - { - - dng_rect tile; - - dng_tile_iterator iter (*this, buffer.fArea); - - while (iter.GetOneTile (tile)) - { - - dng_dirty_tile_buffer tileBuffer (*this, tile); - - tileBuffer.CopyArea (buffer, - tile, - buffer.fPlane, - buffer.fPlanes); - - } - - } - -/*****************************************************************************/ - -void dng_image::GetRepeat (dng_pixel_buffer &buffer, - const dng_rect &srcArea, - const dng_rect &dstArea) const - { - - // If we already have the entire srcArea in the - // buffer, we can just repeat that. - - if ((srcArea & buffer.fArea) == srcArea) - { - - buffer.RepeatArea (srcArea, - dstArea); - - } - - // Else we first need to get the srcArea into the buffer area. - - else - { - - // Find repeating pattern size. - - dng_point repeat = srcArea.Size (); - - // Find pattern phase at top-left corner of destination area. - - dng_point phase = dng_pixel_buffer::RepeatPhase (srcArea, - dstArea); - - // Find new source area at top-left of dstArea. - - dng_rect newArea = srcArea + (dstArea.TL () - - srcArea.TL ()); - - // Find quadrant split coordinates. - - int32 splitV = newArea.t + repeat.v - phase.v; - int32 splitH = newArea.l + repeat.h - phase.h; - - // Top-left quadrant. - - dng_rect dst1 (dng_rect (newArea.t, - newArea.l, - splitV, - splitH) & dstArea); - - if (dst1.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = dst1 + (srcArea.TL () - - dstArea.TL () + - dng_point (phase.v, phase.h)); - - temp.fData = buffer.DirtyPixel (dst1.t, - dst1.l, - buffer.fPlane); - - DoGet (temp); - - } - - // Top-right quadrant. - - dng_rect dst2 (dng_rect (newArea.t, - splitH, - splitV, - newArea.r) & dstArea); - - if (dst2.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = dst2 + (srcArea.TL () - - dstArea.TL () + - dng_point (phase.v, -phase.h)); - - temp.fData = buffer.DirtyPixel (dst2.t, - dst2.l, - buffer.fPlane); - - DoGet (temp); - - } - - // Bottom-left quadrant. - - dng_rect dst3 (dng_rect (splitV, - newArea.l, - newArea.b, - splitH) & dstArea); - - if (dst3.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = dst3 + (srcArea.TL () - - dstArea.TL () + - dng_point (-phase.v, phase.h)); - - temp.fData = buffer.DirtyPixel (dst3.t, - dst3.l, - buffer.fPlane); - - DoGet (temp); - - } - - // Bottom-right quadrant. - - dng_rect dst4 (dng_rect (splitV, - splitH, - newArea.b, - newArea.r) & dstArea); - - if (dst4.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = dst4 + (srcArea.TL () - - dstArea.TL () + - dng_point (-phase.v, -phase.h)); - - temp.fData = buffer.DirtyPixel (dst4.t, - dst4.l, - buffer.fPlane); - - DoGet (temp); - - } - - // Replicate this new source area. - - buffer.RepeatArea (newArea, - dstArea); - - } - - } - -/*****************************************************************************/ - -void dng_image::GetEdge (dng_pixel_buffer &buffer, - edge_option edgeOption, - const dng_rect &srcArea, - const dng_rect &dstArea) const - { - - switch (edgeOption) - { - - case edge_zero: - { - - buffer.SetZero (dstArea, - buffer.fPlane, - buffer.fPlanes); - - break; - - } - - case edge_repeat: - { - - GetRepeat (buffer, - srcArea, - dstArea); - - break; - - } - - case edge_repeat_zero_last: - { - - if (buffer.fPlanes > 1) - { - - dng_pixel_buffer buffer1 (buffer); - - buffer1.fPlanes--; - - GetEdge (buffer1, - edge_repeat, - srcArea, - dstArea); - - } - - dng_pixel_buffer buffer2 (buffer); - - buffer2.fPlane = buffer.fPlanes - 1; - buffer2.fPlanes = 1; - - buffer2.fData = buffer.DirtyPixel (buffer2.fArea.t, - buffer2.fArea.l, - buffer2.fPlane); - - GetEdge (buffer2, - edge_zero, - srcArea, - dstArea); - - break; - - } - - default: - { - - ThrowProgramError (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_image::Get (dng_pixel_buffer &buffer, - edge_option edgeOption, - uint32 repeatV, - uint32 repeatH) const - { - - // Find the overlap with the image bounds. - - dng_rect overlap = buffer.fArea & fBounds; - - // Move the overlapping pixels. - - if (overlap.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = overlap; - - temp.fData = buffer.DirtyPixel (overlap.t, - overlap.l, - buffer.fPlane); - - DoGet (temp); - - } - - // See if we need to pad the edge values. - - if ((edgeOption != edge_none) && (overlap != buffer.fArea)) - { - - dng_rect areaT (buffer.fArea); - dng_rect areaL (buffer.fArea); - dng_rect areaB (buffer.fArea); - dng_rect areaR (buffer.fArea); - - areaT.b = Min_int32 (areaT.b, fBounds.t); - areaL.r = Min_int32 (areaL.r, fBounds.l); - areaB.t = Max_int32 (areaB.t, fBounds.b); - areaR.l = Max_int32 (areaR.l, fBounds.r); - - dng_rect areaH (buffer.fArea); - dng_rect areaV (buffer.fArea); - - areaH.l = Max_int32 (areaH.l, fBounds.l); - areaH.r = Min_int32 (areaH.r, fBounds.r); - - areaV.t = Max_int32 (areaV.t, fBounds.t); - areaV.b = Min_int32 (areaV.b, fBounds.b); - - // Top left. - - dng_rect areaTL = areaT & areaL; - - if (areaTL.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.t, - fBounds.l, - fBounds.t + repeatV, - fBounds.l + repeatH), - areaTL); - - } - - // Top middle. - - dng_rect areaTM = areaT & areaH; - - if (areaTM.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.t, - areaTM.l, - fBounds.t + repeatV, - areaTM.r), - areaTM); - - } - - // Top right. - - dng_rect areaTR = areaT & areaR; - - if (areaTR.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.t, - fBounds.r - repeatH, - fBounds.t + repeatV, - fBounds.r), - areaTR); - - } - - // Left middle. - - dng_rect areaLM = areaL & areaV; - - if (areaLM.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (areaLM.t, - fBounds.l, - areaLM.b, - fBounds.l + repeatH), - areaLM); - - } - - // Right middle. - - dng_rect areaRM = areaR & areaV; - - if (areaRM.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (areaRM.t, - fBounds.r - repeatH, - areaRM.b, - fBounds.r), - areaRM); - - } - - // Bottom left. - - dng_rect areaBL = areaB & areaL; - - if (areaBL.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.b - repeatV, - fBounds.l, - fBounds.b, - fBounds.l + repeatH), - areaBL); - - } - - // Bottom middle. - - dng_rect areaBM = areaB & areaH; - - if (areaBM.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.b - repeatV, - areaBM.l, - fBounds.b, - areaBM.r), - areaBM); - - } - - // Bottom right. - - dng_rect areaBR = areaB & areaR; - - if (areaBR.NotEmpty ()) - { - - GetEdge (buffer, - edgeOption, - dng_rect (fBounds.b - repeatV, - fBounds.r - repeatH, - fBounds.b, - fBounds.r), - areaBR); - - } - - } - - } - -/*****************************************************************************/ - -void dng_image::Put (const dng_pixel_buffer &buffer) - { - - // Move the overlapping pixels. - - dng_rect overlap = buffer.fArea & fBounds; - - if (overlap.NotEmpty ()) - { - - dng_pixel_buffer temp (buffer); - - temp.fArea = overlap; - - temp.fData = (void *) buffer.ConstPixel (overlap.t, - overlap.l, - buffer.fPlane); - - // Move the overlapping planes. - - if (temp.fPlane < Planes ()) - { - - temp.fPlanes = Min_uint32 (temp.fPlanes, - Planes () - temp.fPlane); - - DoPut (temp); - - } - - } - - } - -/*****************************************************************************/ - -void dng_image::Trim (const dng_rect &r) - { - - if (r != Bounds ()) - { - - ThrowProgramError ("Trim is not support by this dng_image subclass"); - - } - - } - -/*****************************************************************************/ - -void dng_image::Rotate (const dng_orientation &orientation) - { - - if (orientation != dng_orientation::Normal ()) - { - - ThrowProgramError ("Rotate is not support by this dng_image subclass"); - - } - - } - -/*****************************************************************************/ - -void dng_image::CopyArea (const dng_image &src, - const dng_rect &area, - uint32 srcPlane, - uint32 dstPlane, - uint32 planes) - { - - if (&src == this) - return; - - dng_tile_iterator destIter(*this, area); - dng_rect destTileArea; - - while (destIter.GetOneTile(destTileArea)) - { - dng_tile_iterator srcIter(src, destTileArea); - dng_rect srcTileArea; - - while (srcIter.GetOneTile(srcTileArea)) - { - - dng_dirty_tile_buffer destTile(*this, srcTileArea); - dng_const_tile_buffer srcTile(src, srcTileArea); - - destTile.CopyArea (srcTile, srcTileArea, srcPlane, dstPlane, planes); - - } - - } - - } - -/*****************************************************************************/ - -bool dng_image::EqualArea (const dng_image &src, - const dng_rect &area, - uint32 plane, - uint32 planes) const - { - - if (&src == this) - return true; - - dng_tile_iterator destIter (*this, area); - - dng_rect destTileArea; - - while (destIter.GetOneTile (destTileArea)) - { - - dng_tile_iterator srcIter (src, destTileArea); - - dng_rect srcTileArea; - - while (srcIter.GetOneTile (srcTileArea)) - { - - dng_const_tile_buffer destTile (*this, srcTileArea); - dng_const_tile_buffer srcTile (src , srcTileArea); - - if (!destTile.EqualArea (srcTile, srcTileArea, plane, planes)) - { - return false; - } - - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_image::SetConstant (uint32 value, - const dng_rect &area) - { - - dng_tile_iterator iter (*this, area); - - dng_rect tileArea; - - while (iter.GetOneTile (tileArea)) - { - - dng_dirty_tile_buffer buffer (*this, tileArea); - - buffer.SetConstant (tileArea, - 0, - fPlanes, - value); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_image.h b/third_party/dng_sdk/dng_image.h deleted file mode 100644 index 013182d..0000000 --- a/third_party/dng_sdk/dng_image.h +++ /dev/null @@ -1,433 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_image.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for working with image data in DNG SDK. - */ - -/*****************************************************************************/ - -#ifndef __dng_image__ -#define __dng_image__ - -/*****************************************************************************/ - -#include "dng_assertions.h" -#include "dng_classes.h" -#include "dng_pixel_buffer.h" -#include "dng_point.h" -#include "dng_rect.h" -#include "dng_tag_types.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Class to get resource acquisition is instantiation behavior for tile -/// buffers. Can be dirty or constant tile access. - -class dng_tile_buffer: public dng_pixel_buffer - { - - protected: - - const dng_image &fImage; - - void *fRefData; - - protected: - - /// Obtain a tile from an image. - /// \param image Image tile will come from. - /// \param tile Rectangle denoting extent of tile. - /// \param dirty Flag indicating whether this is read-only or read-write acesss. - - dng_tile_buffer (const dng_image &image, - const dng_rect &tile, - bool dirty); - - virtual ~dng_tile_buffer (); - - public: - - void SetRefData (void *refData) - { - fRefData = refData; - } - - void * GetRefData () const - { - return fRefData; - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_tile_buffer (const dng_tile_buffer &buffer); - - dng_tile_buffer & operator= (const dng_tile_buffer &buffer); - - }; - -/*****************************************************************************/ - -/// \brief Class to get resource acquisition is instantiation behavior for -/// constant (read-only) tile buffers. - -class dng_const_tile_buffer: public dng_tile_buffer - { - - public: - - /// Obtain a read-only tile from an image. - /// \param image Image tile will come from. - /// \param tile Rectangle denoting extent of tile. - - dng_const_tile_buffer (const dng_image &image, - const dng_rect &tile); - - virtual ~dng_const_tile_buffer (); - - }; - -/*****************************************************************************/ - -/// \brief Class to get resource acquisition is instantiation behavior for -/// dirty (writable) tile buffers. - -class dng_dirty_tile_buffer: public dng_tile_buffer - { - - public: - - /// Obtain a writable tile from an image. - /// \param image Image tile will come from. - /// \param tile Rectangle denoting extent of tile. - - dng_dirty_tile_buffer (dng_image &image, - const dng_rect &tile); - - virtual ~dng_dirty_tile_buffer (); - - }; - -/*****************************************************************************/ - -/// \brief Base class for holding image data in DNG SDK. See dng_simple_image -/// for derived class most often used in DNG SDK. - -class dng_image - { - - friend class dng_tile_buffer; - - protected: - - // Bounds for this image. - - dng_rect fBounds; - - // Number of image planes. - - uint32 fPlanes; - - // Basic pixel type (TIFF tag type code). - - uint32 fPixelType; - - public: - - /// How to handle requests to get image areas outside the image bounds. - - enum edge_option - { - - /// Leave edge pixels unchanged. - - edge_none, - - /// Pad with zeros. - - edge_zero, - - /// Repeat edge pixels. - - edge_repeat, - - /// Repeat edge pixels, except for last plane which is zero padded. - - edge_repeat_zero_last - - }; - - protected: - - dng_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType); - - public: - - virtual ~dng_image (); - - virtual dng_image * Clone () const; - - /// Getter method for bounds of an image. - - const dng_rect & Bounds () const - { - return fBounds; - } - - /// Getter method for size of an image. - - dng_point Size () const - { - return Bounds ().Size (); - } - - /// Getter method for width of an image. - - uint32 Width () const - { - return Bounds ().W (); - } - - /// Getter method for height of an image. - - uint32 Height () const - { - return Bounds ().H (); - } - - /// Getter method for number of planes in an image. - - uint32 Planes () const - { - return fPlanes; - } - - /// Getter for pixel type. - /// \retval See dng_tagtypes.h . Valid values are ttByte, ttShort, ttSShort, - /// ttLong, ttFloat . - - uint32 PixelType () const - { - return fPixelType; - } - - /// Setter for pixel type. - /// \param pixelType The new pixel type . - - virtual void SetPixelType (uint32 pixelType); - - /// Getter for pixel size. - /// \retval Size, in bytes, of pixel type for this image . - - uint32 PixelSize () const; - - /// Getter for pixel range. - /// For unsigned types, range is 0 to return value. - /// For signed types, range is return value - 0x8000U. - /// For ttFloat type, pixel range is 0.0 to 1.0 and this routine returns 1. - - uint32 PixelRange () const; - - /// Getter for best "tile stride" for accessing image. - - virtual dng_rect RepeatingTile () const; - - /// Get a pixel buffer of data on image with proper edge padding. - /// \param buffer Receives resulting pixel buffer. - /// \param edgeOption edge_option describing how to pad edges. - /// \param repeatV Amount of repeated padding needed in vertical for - /// edge_repeat and edge_repeat_zero_last edgeOption cases. - /// \param repeatH Amount of repeated padding needed in horizontal for - /// edge_repeat and edge_repeat_zero_last edgeOption cases. - - void Get (dng_pixel_buffer &buffer, - edge_option edgeOption = edge_none, - uint32 repeatV = 1, - uint32 repeatH = 1) const; - - /// Put a pixel buffer into image. - /// \param buffer Pixel buffer to copy from. - - void Put (const dng_pixel_buffer &buffer); - - /// Shrink bounds of image to given rectangle. - /// \param r Rectangle to crop to. - - virtual void Trim (const dng_rect &r); - - /// Rotate image to reflect given orientation change. - /// \param orientation Directive to rotate image in a certain way. - - virtual void Rotate (const dng_orientation &orientation); - - /// Copy image data from an area of one image to same area of another. - /// \param src Image to copy from. - /// \param area Rectangle of images to copy. - /// \param srcPlane Plane to start copying in src. - /// \param dstPlane Plane to start copying in this. - /// \param planes Number of planes to copy. - - void CopyArea (const dng_image &src, - const dng_rect &area, - uint32 srcPlane, - uint32 dstPlane, - uint32 planes); - - /// Copy image data from an area of one image to same area of another. - /// \param src Image to copy from. - /// \param area Rectangle of images to copy. - /// \param plane Plane to start copying in src and this. - /// \param planes Number of planes to copy. - - void CopyArea (const dng_image &src, - const dng_rect &area, - uint32 plane, - uint32 planes) - { - - CopyArea (src, area, plane, plane, planes); - - } - - /// Return true if the contents of an area of the image are the same as those of another. - /// \param rhs Image to compare against. - /// \param area Rectangle of image to test. - /// \param plane Plane to start comparing. - /// \param planes Number of planes to compare. - - bool EqualArea (const dng_image &rhs, - const dng_rect &area, - uint32 plane, - uint32 planes) const; - - // Routines to set the entire image to a constant value. - - void SetConstant_uint8 (uint8 value, - const dng_rect &area) - { - - DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type"); - - SetConstant ((uint32) value, area); - - } - - void SetConstant_uint8 (uint8 value) - { - SetConstant (value, Bounds ()); - } - - void SetConstant_uint16 (uint16 value, - const dng_rect &area) - { - - DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type"); - - SetConstant ((uint32) value, area); - - } - - void SetConstant_uint16 (uint16 value) - { - SetConstant_uint16 (value, Bounds ()); - } - - void SetConstant_int16 (int16 value, - const dng_rect &area) - { - - DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type"); - - SetConstant ((uint32) (uint16) value, area); - - } - - void SetConstant_int16 (int16 value) - { - SetConstant_int16 (value, Bounds ()); - } - - void SetConstant_uint32 (uint32 value, - const dng_rect &area) - { - - DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type"); - - SetConstant (value, area); - - } - - void SetConstant_uint32 (uint32 value) - { - SetConstant_uint32 (value, Bounds ()); - } - - void SetConstant_real32 (real32 value, - const dng_rect &area) - { - - DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type"); - - union - { - uint32 i; - real32 f; - } x; - - x.f = value; - - SetConstant (x.i, area); - - } - - void SetConstant_real32 (real32 value) - { - SetConstant_real32 (value, Bounds ()); - } - - virtual void GetRepeat (dng_pixel_buffer &buffer, - const dng_rect &srcArea, - const dng_rect &dstArea) const; - - protected: - - virtual void AcquireTileBuffer (dng_tile_buffer &buffer, - const dng_rect &area, - bool dirty) const; - - virtual void ReleaseTileBuffer (dng_tile_buffer &buffer) const; - - virtual void DoGet (dng_pixel_buffer &buffer) const; - - virtual void DoPut (const dng_pixel_buffer &buffer); - - void GetEdge (dng_pixel_buffer &buffer, - edge_option edgeOption, - const dng_rect &srcArea, - const dng_rect &dstArea) const; - - virtual void SetConstant (uint32 value, - const dng_rect &area); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_image_writer.cpp b/third_party/dng_sdk/dng_image_writer.cpp deleted file mode 100644 index dd5900b..0000000 --- a/third_party/dng_sdk/dng_image_writer.cpp +++ /dev/null @@ -1,6961 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_image_writer.cpp#4 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_image_writer.h" - -#include "dng_abort_sniffer.h" -#include "dng_area_task.h" -#include "dng_bottlenecks.h" -#include "dng_camera_profile.h" -#include "dng_color_space.h" -#include "dng_exif.h" -#include "dng_flags.h" -#include "dng_exceptions.h" -#include "dng_host.h" -#include "dng_ifd.h" -#include "dng_image.h" -#include "dng_jpeg_image.h" -#include "dng_lossless_jpeg.h" -#include "dng_memory_stream.h" -#include "dng_negative.h" -#include "dng_pixel_buffer.h" -#include "dng_preview.h" -#include "dng_read_image.h" -#include "dng_stream.h" -#include "dng_string_list.h" -#include "dng_tag_codes.h" -#include "dng_tag_values.h" -#include "dng_utils.h" -#include "dng_xmp.h" - -#include "zlib.h" - -#if qDNGUseLibJPEG -#include "jpeglib.h" -#include "jerror.h" -#endif - -/*****************************************************************************/ - -// Defines for testing DNG 1.2 features. - -//#define qTestRowInterleave 2 - -//#define qTestSubTileBlockRows 2 -//#define qTestSubTileBlockCols 2 - -/*****************************************************************************/ - -dng_resolution::dng_resolution () - - : fXResolution () - , fYResolution () - - , fResolutionUnit (0) - - { - - } - -/******************************************************************************/ - -static void SpoolAdobeData (dng_stream &stream, - const dng_metadata *metadata, - const dng_jpeg_preview *preview, - const dng_memory_block *imageResources) - { - - TempBigEndian tempEndian (stream); - - if (metadata && metadata->GetXMP ()) - { - - bool marked = false; - - if (metadata->GetXMP ()->GetBoolean (XMP_NS_XAP_RIGHTS, - "Marked", - marked)) - { - - stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M')); - stream.Put_uint16 (1034); - stream.Put_uint16 (0); - - stream.Put_uint32 (1); - - stream.Put_uint8 (marked ? 1 : 0); - - stream.Put_uint8 (0); - - } - - dng_string webStatement; - - if (metadata->GetXMP ()->GetString (XMP_NS_XAP_RIGHTS, - "WebStatement", - webStatement)) - { - - dng_memory_data buffer; - - uint32 size = webStatement.Get_SystemEncoding (buffer); - - if (size > 0) - { - - stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M')); - stream.Put_uint16 (1035); - stream.Put_uint16 (0); - - stream.Put_uint32 (size); - - stream.Put (buffer.Buffer (), size); - - if (size & 1) - stream.Put_uint8 (0); - - } - - } - - } - - if (preview) - { - - preview->SpoolAdobeThumbnail (stream); - - } - - if (metadata && metadata->IPTCLength ()) - { - - dng_fingerprint iptcDigest = metadata->IPTCDigest (); - - if (iptcDigest.IsValid ()) - { - - stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M')); - stream.Put_uint16 (1061); - stream.Put_uint16 (0); - - stream.Put_uint32 (16); - - stream.Put (iptcDigest.data, 16); - - } - - } - - if (imageResources) - { - - uint32 size = imageResources->LogicalSize (); - - stream.Put (imageResources->Buffer (), size); - - if (size & 1) - stream.Put_uint8 (0); - - } - - } - -/******************************************************************************/ - -static dng_memory_block * BuildAdobeData (dng_host &host, - const dng_metadata *metadata, - const dng_jpeg_preview *preview, - const dng_memory_block *imageResources) - { - - dng_memory_stream stream (host.Allocator ()); - - SpoolAdobeData (stream, - metadata, - preview, - imageResources); - - return stream.AsMemoryBlock (host.Allocator ()); - - } - -/*****************************************************************************/ - -tag_string::tag_string (uint16 code, - const dng_string &s, - bool forceASCII) - - : tiff_tag (code, ttAscii, 0) - - , fString (s) - - { - - if (forceASCII) - { - - // Metadata working group recommendation - go ahead - // write UTF-8 into ASCII tag strings, rather than - // actually force the strings to ASCII. There is a matching - // change on the reading side to assume UTF-8 if the string - // contains a valid UTF-8 string. - // - // fString.ForceASCII (); - - } - - else if (!fString.IsASCII ()) - { - - fType = ttByte; - - } - - fCount = fString.Length () + 1; - - } - -/*****************************************************************************/ - -void tag_string::Put (dng_stream &stream) const - { - - stream.Put (fString.Get (), Size ()); - - } - -/*****************************************************************************/ - -tag_encoded_text::tag_encoded_text (uint16 code, - const dng_string &text) - - : tiff_tag (code, ttUndefined, 0) - - , fText (text) - - , fUTF16 () - - { - - if (fText.IsASCII ()) - { - - fCount = 8 + fText.Length (); - - } - - else - { - - fCount = 8 + fText.Get_UTF16 (fUTF16) * 2; - - } - - } - -/*****************************************************************************/ - -void tag_encoded_text::Put (dng_stream &stream) const - { - - if (fUTF16.Buffer ()) - { - - stream.Put ("UNICODE\000", 8); - - uint32 chars = (fCount - 8) >> 1; - - const uint16 *buf = fUTF16.Buffer_uint16 (); - - for (uint32 j = 0; j < chars; j++) - { - - stream.Put_uint16 (buf [j]); - - } - - } - - else - { - - stream.Put ("ASCII\000\000\000", 8); - - stream.Put (fText.Get (), fCount - 8); - - } - - } - -/*****************************************************************************/ - -void tag_data_ptr::Put (dng_stream &stream) const - { - - // If we are swapping bytes, we need to swap with the right size - // entries. - - if (stream.SwapBytes ()) - { - - switch (Type ()) - { - - // Two byte entries. - - case ttShort: - case ttSShort: - case ttUnicode: - { - - const uint16 *p = (const uint16 *) fData; - - uint32 entries = (Size () >> 1); - - for (uint32 j = 0; j < entries; j++) - { - - stream.Put_uint16 (p [j]); - - } - - return; - - } - - // Four byte entries. - - case ttLong: - case ttSLong: - case ttRational: - case ttSRational: - case ttIFD: - case ttFloat: - case ttComplex: - { - - const uint32 *p = (const uint32 *) fData; - - uint32 entries = (Size () >> 2); - - for (uint32 j = 0; j < entries; j++) - { - - stream.Put_uint32 (p [j]); - - } - - return; - - } - - // Eight byte entries. - - case ttDouble: - { - - const real64 *p = (const real64 *) fData; - - uint32 entries = (Size () >> 3); - - for (uint32 j = 0; j < entries; j++) - { - - stream.Put_real64 (p [j]); - - } - - return; - - } - - // Entries don't need to be byte swapped. Fall through - // to non-byte swapped case. - - default: - { - - break; - - } - - } - - } - - // Non-byte swapped case. - - stream.Put (fData, Size ()); - - } - -/******************************************************************************/ - -tag_matrix::tag_matrix (uint16 code, - const dng_matrix &m) - - : tag_srational_ptr (code, fEntry, m.Rows () * m.Cols ()) - - { - - uint32 index = 0; - - for (uint32 r = 0; r < m.Rows (); r++) - for (uint32 c = 0; c < m.Cols (); c++) - { - - fEntry [index].Set_real64 (m [r] [c], 10000); - - index++; - - } - - } - -/******************************************************************************/ - -tag_icc_profile::tag_icc_profile (const void *profileData, - uint32 profileSize) - - : tag_data_ptr (tcICCProfile, - ttUndefined, - 0, - NULL) - - { - - if (profileData && profileSize) - { - - SetCount (profileSize); - SetData (profileData); - - } - - } - -/******************************************************************************/ - -void tag_cfa_pattern::Put (dng_stream &stream) const - { - - stream.Put_uint16 ((uint16) fCols); - stream.Put_uint16 ((uint16) fRows); - - for (uint32 col = 0; col < fCols; col++) - for (uint32 row = 0; row < fRows; row++) - { - - stream.Put_uint8 (fPattern [row * kMaxCFAPattern + col]); - - } - - } - -/******************************************************************************/ - -tag_exif_date_time::tag_exif_date_time (uint16 code, - const dng_date_time &dt) - - : tag_data_ptr (code, ttAscii, 20, fData) - - { - - if (dt.IsValid ()) - { - - sprintf (fData, - "%04d:%02d:%02d %02d:%02d:%02d", - (int) dt.fYear, - (int) dt.fMonth, - (int) dt.fDay, - (int) dt.fHour, - (int) dt.fMinute, - (int) dt.fSecond); - - } - - } - -/******************************************************************************/ - -tag_iptc::tag_iptc (const void *data, - uint32 length) - - : tiff_tag (tcIPTC_NAA, ttLong, (length + 3) >> 2) - - , fData (data ) - , fLength (length) - - { - - } - -/******************************************************************************/ - -void tag_iptc::Put (dng_stream &stream) const - { - - // Note: For historical compatiblity reasons, the standard TIFF data - // type for IPTC data is ttLong, but without byte swapping. This really - // should be ttUndefined, but doing the right thing would break some - // existing readers. - - stream.Put (fData, fLength); - - // Pad with zeros to get to long word boundary. - - uint32 extra = fCount * 4 - fLength; - - while (extra--) - { - stream.Put_uint8 (0); - } - - } - -/******************************************************************************/ - -tag_xmp::tag_xmp (const dng_xmp *xmp) - - : tag_uint8_ptr (tcXMP, NULL, 0) - - , fBuffer () - - { - - if (xmp) - { - - fBuffer.Reset (xmp->Serialize (true)); - - if (fBuffer.Get ()) - { - - SetData (fBuffer->Buffer_uint8 ()); - - SetCount (fBuffer->LogicalSize ()); - - } - - } - - } - -/******************************************************************************/ - -void dng_tiff_directory::Add (const tiff_tag *tag) - { - - if (fEntries >= kMaxEntries) - { - ThrowProgramError (); - } - - // Tags must be sorted in increasing order of tag code. - - uint32 index = fEntries; - - for (uint32 j = 0; j < fEntries; j++) - { - - if (tag->Code () < fTag [j]->Code ()) - { - index = j; - break; - } - - } - - for (uint32 k = fEntries; k > index; k--) - { - - fTag [k] = fTag [k - 1]; - - } - - fTag [index] = tag; - - fEntries++; - - } - -/******************************************************************************/ - -uint32 dng_tiff_directory::Size () const - { - - if (!fEntries) return 0; - - uint32 size = fEntries * 12 + 6; - - for (uint32 index = 0; index < fEntries; index++) - { - - uint32 tagSize = fTag [index]->Size (); - - if (tagSize > 4) - { - - size += (tagSize + 1) & ~1; - - } - - } - - return size; - - } - -/******************************************************************************/ - -void dng_tiff_directory::Put (dng_stream &stream, - OffsetsBase offsetsBase, - uint32 explicitBase) const - { - - if (!fEntries) return; - - uint32 index; - - uint32 bigData = fEntries * 12 + 6; - - if (offsetsBase == offsetsRelativeToStream) - bigData += (uint32) stream.Position (); - - else if (offsetsBase == offsetsRelativeToExplicitBase) - bigData += explicitBase; - - stream.Put_uint16 ((uint16) fEntries); - - for (index = 0; index < fEntries; index++) - { - - const tiff_tag &tag = *fTag [index]; - - stream.Put_uint16 (tag.Code ()); - stream.Put_uint16 (tag.Type ()); - stream.Put_uint32 (tag.Count ()); - - uint32 size = tag.Size (); - - if (size <= 4) - { - - tag.Put (stream); - - while (size < 4) - { - stream.Put_uint8 (0); - size++; - } - - } - - else - { - - stream.Put_uint32 (bigData); - - bigData += (size + 1) & ~1; - - } - - } - - stream.Put_uint32 (fChained); // Next IFD offset - - for (index = 0; index < fEntries; index++) - { - - const tiff_tag &tag = *fTag [index]; - - uint32 size = tag.Size (); - - if (size > 4) - { - - tag.Put (stream); - - if (size & 1) - stream.Put_uint8 (0); - - } - - } - - } - -/******************************************************************************/ - -dng_basic_tag_set::dng_basic_tag_set (dng_tiff_directory &directory, - const dng_ifd &info) - - : fNewSubFileType (tcNewSubFileType, info.fNewSubFileType) - - , fImageWidth (tcImageWidth , info.fImageWidth ) - , fImageLength (tcImageLength, info.fImageLength) - - , fPhotoInterpretation (tcPhotometricInterpretation, - (uint16) info.fPhotometricInterpretation) - - , fFillOrder (tcFillOrder, 1) - - , fSamplesPerPixel (tcSamplesPerPixel, (uint16) info.fSamplesPerPixel) - - , fBitsPerSample (tcBitsPerSample, - fBitsPerSampleData, - info.fSamplesPerPixel) - - , fStrips (info.fUsesStrips) - - , fTileWidth (tcTileWidth, info.fTileWidth) - - , fTileLength (fStrips ? tcRowsPerStrip : tcTileLength, - info.fTileLength) - - , fTileInfoBuffer (info.TilesPerImage () * 8) - - , fTileOffsetData (fTileInfoBuffer.Buffer_uint32 ()) - - , fTileOffsets (fStrips ? tcStripOffsets : tcTileOffsets, - fTileOffsetData, - info.TilesPerImage ()) - - , fTileByteCountData (fTileOffsetData + info.TilesPerImage ()) - - , fTileByteCounts (fStrips ? tcStripByteCounts : tcTileByteCounts, - fTileByteCountData, - info.TilesPerImage ()) - - , fPlanarConfiguration (tcPlanarConfiguration, pcInterleaved) - - , fCompression (tcCompression, (uint16) info.fCompression) - , fPredictor (tcPredictor , (uint16) info.fPredictor ) - - , fExtraSamples (tcExtraSamples, - fExtraSamplesData, - info.fExtraSamplesCount) - - , fSampleFormat (tcSampleFormat, - fSampleFormatData, - info.fSamplesPerPixel) - - , fRowInterleaveFactor (tcRowInterleaveFactor, - (uint16) info.fRowInterleaveFactor) - - , fSubTileBlockSize (tcSubTileBlockSize, - fSubTileBlockSizeData, - 2) - - { - - uint32 j; - - for (j = 0; j < info.fSamplesPerPixel; j++) - { - - fBitsPerSampleData [j] = (uint16) info.fBitsPerSample [0]; - - } - - directory.Add (&fNewSubFileType); - - directory.Add (&fImageWidth); - directory.Add (&fImageLength); - - directory.Add (&fPhotoInterpretation); - - directory.Add (&fSamplesPerPixel); - - directory.Add (&fBitsPerSample); - - if (info.fBitsPerSample [0] != 8 && - info.fBitsPerSample [0] != 16 && - info.fBitsPerSample [0] != 32) - { - - directory.Add (&fFillOrder); - - } - - if (!fStrips) - { - - directory.Add (&fTileWidth); - - } - - directory.Add (&fTileLength); - - directory.Add (&fTileOffsets); - directory.Add (&fTileByteCounts); - - directory.Add (&fPlanarConfiguration); - - directory.Add (&fCompression); - - if (info.fPredictor != cpNullPredictor) - { - - directory.Add (&fPredictor); - - } - - if (info.fExtraSamplesCount != 0) - { - - for (j = 0; j < info.fExtraSamplesCount; j++) - { - fExtraSamplesData [j] = (uint16) info.fExtraSamples [j]; - } - - directory.Add (&fExtraSamples); - - } - - if (info.fSampleFormat [0] != sfUnsignedInteger) - { - - for (j = 0; j < info.fSamplesPerPixel; j++) - { - fSampleFormatData [j] = (uint16) info.fSampleFormat [j]; - } - - directory.Add (&fSampleFormat); - - } - - if (info.fRowInterleaveFactor != 1) - { - - directory.Add (&fRowInterleaveFactor); - - } - - if (info.fSubTileBlockRows != 1 || - info.fSubTileBlockCols != 1) - { - - fSubTileBlockSizeData [0] = (uint16) info.fSubTileBlockRows; - fSubTileBlockSizeData [1] = (uint16) info.fSubTileBlockCols; - - directory.Add (&fSubTileBlockSize); - - } - - } - -/******************************************************************************/ - -exif_tag_set::exif_tag_set (dng_tiff_directory &directory, - const dng_exif &exif, - bool makerNoteSafe, - const void *makerNoteData, - uint32 makerNoteLength, - bool insideDNG) - - : fExifIFD () - , fGPSIFD () - - , fExifLink (tcExifIFD, 0) - , fGPSLink (tcGPSInfo, 0) - - , fAddedExifLink (false) - , fAddedGPSLink (false) - - , fExifVersion (tcExifVersion, ttUndefined, 4, fExifVersionData) - - , fExposureTime (tcExposureTime , exif.fExposureTime ) - , fShutterSpeedValue (tcShutterSpeedValue, exif.fShutterSpeedValue) - - , fFNumber (tcFNumber , exif.fFNumber ) - , fApertureValue (tcApertureValue, exif.fApertureValue) - - , fBrightnessValue (tcBrightnessValue, exif.fBrightnessValue) - - , fExposureBiasValue (tcExposureBiasValue, exif.fExposureBiasValue) - - , fMaxApertureValue (tcMaxApertureValue , exif.fMaxApertureValue) - - , fSubjectDistance (tcSubjectDistance, exif.fSubjectDistance) - - , fFocalLength (tcFocalLength, exif.fFocalLength) - - // Special case: the EXIF 2.2 standard represents ISO speed ratings with 2 bytes, - // which cannot hold ISO speed ratings above 65535 (e.g., 102400). In these - // cases, we write the maximum representable ISO speed rating value in the EXIF - // tag, i.e., 65535. - - , fISOSpeedRatings (tcISOSpeedRatings, - (uint16) Min_uint32 (65535, - exif.fISOSpeedRatings [0])) - - , fSensitivityType (tcSensitivityType, (uint16) exif.fSensitivityType) - - , fStandardOutputSensitivity (tcStandardOutputSensitivity, exif.fStandardOutputSensitivity) - - , fRecommendedExposureIndex (tcRecommendedExposureIndex, exif.fRecommendedExposureIndex) - - , fISOSpeed (tcISOSpeed, exif.fISOSpeed) - - , fISOSpeedLatitudeyyy (tcISOSpeedLatitudeyyy, exif.fISOSpeedLatitudeyyy) - - , fISOSpeedLatitudezzz (tcISOSpeedLatitudezzz, exif.fISOSpeedLatitudezzz) - - , fFlash (tcFlash, (uint16) exif.fFlash) - - , fExposureProgram (tcExposureProgram, (uint16) exif.fExposureProgram) - - , fMeteringMode (tcMeteringMode, (uint16) exif.fMeteringMode) - - , fLightSource (tcLightSource, (uint16) exif.fLightSource) - - , fSensingMethod (tcSensingMethodExif, (uint16) exif.fSensingMethod) - - , fFocalLength35mm (tcFocalLengthIn35mmFilm, (uint16) exif.fFocalLengthIn35mmFilm) - - , fFileSourceData ((uint8) exif.fFileSource) - , fFileSource (tcFileSource, ttUndefined, 1, &fFileSourceData) - - , fSceneTypeData ((uint8) exif.fSceneType) - , fSceneType (tcSceneType, ttUndefined, 1, &fSceneTypeData) - - , fCFAPattern (tcCFAPatternExif, - exif.fCFARepeatPatternRows, - exif.fCFARepeatPatternCols, - &exif.fCFAPattern [0] [0]) - - , fCustomRendered (tcCustomRendered , (uint16) exif.fCustomRendered ) - , fExposureMode (tcExposureMode , (uint16) exif.fExposureMode ) - , fWhiteBalance (tcWhiteBalance , (uint16) exif.fWhiteBalance ) - , fSceneCaptureType (tcSceneCaptureType , (uint16) exif.fSceneCaptureType ) - , fGainControl (tcGainControl , (uint16) exif.fGainControl ) - , fContrast (tcContrast , (uint16) exif.fContrast ) - , fSaturation (tcSaturation , (uint16) exif.fSaturation ) - , fSharpness (tcSharpness , (uint16) exif.fSharpness ) - , fSubjectDistanceRange (tcSubjectDistanceRange, (uint16) exif.fSubjectDistanceRange) - - , fDigitalZoomRatio (tcDigitalZoomRatio, exif.fDigitalZoomRatio) - - , fExposureIndex (tcExposureIndexExif, exif.fExposureIndex) - - , fImageNumber (tcImageNumber, exif.fImageNumber) - - , fSelfTimerMode (tcSelfTimerMode, (uint16) exif.fSelfTimerMode) - - , fBatteryLevelA (tcBatteryLevel, exif.fBatteryLevelA) - , fBatteryLevelR (tcBatteryLevel, exif.fBatteryLevelR) - - , fFocalPlaneXResolution (tcFocalPlaneXResolutionExif, exif.fFocalPlaneXResolution) - , fFocalPlaneYResolution (tcFocalPlaneYResolutionExif, exif.fFocalPlaneYResolution) - - , fFocalPlaneResolutionUnit (tcFocalPlaneResolutionUnitExif, (uint16) exif.fFocalPlaneResolutionUnit) - - , fSubjectArea (tcSubjectArea, fSubjectAreaData, exif.fSubjectAreaCount) - - , fLensInfo (tcLensInfo, fLensInfoData, 4) - - , fDateTime (tcDateTime , exif.fDateTime .DateTime ()) - , fDateTimeOriginal (tcDateTimeOriginal , exif.fDateTimeOriginal .DateTime ()) - , fDateTimeDigitized (tcDateTimeDigitized, exif.fDateTimeDigitized.DateTime ()) - - , fSubsecTime (tcSubsecTime, exif.fDateTime .Subseconds ()) - , fSubsecTimeOriginal (tcSubsecTimeOriginal, exif.fDateTimeOriginal .Subseconds ()) - , fSubsecTimeDigitized (tcSubsecTimeDigitized, exif.fDateTimeDigitized.Subseconds ()) - - , fMake (tcMake, exif.fMake) - - , fModel (tcModel, exif.fModel) - - , fArtist (tcArtist, exif.fArtist) - - , fSoftware (tcSoftware, exif.fSoftware) - - , fCopyright (tcCopyright, exif.fCopyright) - - , fMakerNoteSafety (tcMakerNoteSafety, makerNoteSafe ? 1 : 0) - - , fMakerNote (tcMakerNote, ttUndefined, makerNoteLength, makerNoteData) - - , fImageDescription (tcImageDescription, exif.fImageDescription) - - , fSerialNumber (tcCameraSerialNumber, exif.fCameraSerialNumber) - - , fUserComment (tcUserComment, exif.fUserComment) - - , fImageUniqueID (tcImageUniqueID, ttAscii, 33, fImageUniqueIDData) - - // EXIF 2.3 tags. - - , fCameraOwnerName (tcCameraOwnerNameExif, exif.fOwnerName ) - , fBodySerialNumber (tcCameraSerialNumberExif, exif.fCameraSerialNumber) - , fLensSpecification (tcLensSpecificationExif, fLensInfoData, 4 ) - , fLensMake (tcLensMakeExif, exif.fLensMake ) - , fLensModel (tcLensModelExif, exif.fLensName ) - , fLensSerialNumber (tcLensSerialNumberExif, exif.fLensSerialNumber ) - - , fGPSVersionID (tcGPSVersionID, fGPSVersionData, 4) - - , fGPSLatitudeRef (tcGPSLatitudeRef, exif.fGPSLatitudeRef) - , fGPSLatitude (tcGPSLatitude, exif.fGPSLatitude, 3) - - , fGPSLongitudeRef (tcGPSLongitudeRef, exif.fGPSLongitudeRef) - , fGPSLongitude (tcGPSLongitude, exif.fGPSLongitude, 3) - - , fGPSAltitudeRef (tcGPSAltitudeRef, (uint8) exif.fGPSAltitudeRef) - , fGPSAltitude (tcGPSAltitude, exif.fGPSAltitude ) - - , fGPSTimeStamp (tcGPSTimeStamp, exif.fGPSTimeStamp, 3) - - , fGPSSatellites (tcGPSSatellites , exif.fGPSSatellites ) - , fGPSStatus (tcGPSStatus , exif.fGPSStatus ) - , fGPSMeasureMode (tcGPSMeasureMode, exif.fGPSMeasureMode) - - , fGPSDOP (tcGPSDOP, exif.fGPSDOP) - - , fGPSSpeedRef (tcGPSSpeedRef, exif.fGPSSpeedRef) - , fGPSSpeed (tcGPSSpeed , exif.fGPSSpeed ) - - , fGPSTrackRef (tcGPSTrackRef, exif.fGPSTrackRef) - , fGPSTrack (tcGPSTrack , exif.fGPSTrack ) - - , fGPSImgDirectionRef (tcGPSImgDirectionRef, exif.fGPSImgDirectionRef) - , fGPSImgDirection (tcGPSImgDirection , exif.fGPSImgDirection ) - - , fGPSMapDatum (tcGPSMapDatum, exif.fGPSMapDatum) - - , fGPSDestLatitudeRef (tcGPSDestLatitudeRef, exif.fGPSDestLatitudeRef) - , fGPSDestLatitude (tcGPSDestLatitude, exif.fGPSDestLatitude, 3) - - , fGPSDestLongitudeRef (tcGPSDestLongitudeRef, exif.fGPSDestLongitudeRef) - , fGPSDestLongitude (tcGPSDestLongitude, exif.fGPSDestLongitude, 3) - - , fGPSDestBearingRef (tcGPSDestBearingRef, exif.fGPSDestBearingRef) - , fGPSDestBearing (tcGPSDestBearing , exif.fGPSDestBearing ) - - , fGPSDestDistanceRef (tcGPSDestDistanceRef, exif.fGPSDestDistanceRef) - , fGPSDestDistance (tcGPSDestDistance , exif.fGPSDestDistance ) - - , fGPSProcessingMethod (tcGPSProcessingMethod, exif.fGPSProcessingMethod) - , fGPSAreaInformation (tcGPSAreaInformation , exif.fGPSAreaInformation ) - - , fGPSDateStamp (tcGPSDateStamp, exif.fGPSDateStamp) - - , fGPSDifferential (tcGPSDifferential, (uint16) exif.fGPSDifferential) - - , fGPSHPositioningError (tcGPSHPositioningError, exif.fGPSHPositioningError) - - { - - if (exif.fExifVersion) - { - - fExifVersionData [0] = (uint8) (exif.fExifVersion >> 24); - fExifVersionData [1] = (uint8) (exif.fExifVersion >> 16); - fExifVersionData [2] = (uint8) (exif.fExifVersion >> 8); - fExifVersionData [3] = (uint8) (exif.fExifVersion ); - - fExifIFD.Add (&fExifVersion); - - } - - if (exif.fExposureTime.IsValid ()) - { - fExifIFD.Add (&fExposureTime); - } - - if (exif.fShutterSpeedValue.IsValid ()) - { - fExifIFD.Add (&fShutterSpeedValue); - } - - if (exif.fFNumber.IsValid ()) - { - fExifIFD.Add (&fFNumber); - } - - if (exif.fApertureValue.IsValid ()) - { - fExifIFD.Add (&fApertureValue); - } - - if (exif.fBrightnessValue.IsValid ()) - { - fExifIFD.Add (&fBrightnessValue); - } - - if (exif.fExposureBiasValue.IsValid ()) - { - fExifIFD.Add (&fExposureBiasValue); - } - - if (exif.fMaxApertureValue.IsValid ()) - { - fExifIFD.Add (&fMaxApertureValue); - } - - if (exif.fSubjectDistance.IsValid ()) - { - fExifIFD.Add (&fSubjectDistance); - } - - if (exif.fFocalLength.IsValid ()) - { - fExifIFD.Add (&fFocalLength); - } - - if (exif.fISOSpeedRatings [0] != 0) - { - fExifIFD.Add (&fISOSpeedRatings); - } - - if (exif.fFlash <= 0x0FFFF) - { - fExifIFD.Add (&fFlash); - } - - if (exif.fExposureProgram <= 0x0FFFF) - { - fExifIFD.Add (&fExposureProgram); - } - - if (exif.fMeteringMode <= 0x0FFFF) - { - fExifIFD.Add (&fMeteringMode); - } - - if (exif.fLightSource <= 0x0FFFF) - { - fExifIFD.Add (&fLightSource); - } - - if (exif.fSensingMethod <= 0x0FFFF) - { - fExifIFD.Add (&fSensingMethod); - } - - if (exif.fFocalLengthIn35mmFilm != 0) - { - fExifIFD.Add (&fFocalLength35mm); - } - - if (exif.fFileSource <= 0x0FF) - { - fExifIFD.Add (&fFileSource); - } - - if (exif.fSceneType <= 0x0FF) - { - fExifIFD.Add (&fSceneType); - } - - if (exif.fCFARepeatPatternRows && - exif.fCFARepeatPatternCols) - { - fExifIFD.Add (&fCFAPattern); - } - - if (exif.fCustomRendered <= 0x0FFFF) - { - fExifIFD.Add (&fCustomRendered); - } - - if (exif.fExposureMode <= 0x0FFFF) - { - fExifIFD.Add (&fExposureMode); - } - - if (exif.fWhiteBalance <= 0x0FFFF) - { - fExifIFD.Add (&fWhiteBalance); - } - - if (exif.fSceneCaptureType <= 0x0FFFF) - { - fExifIFD.Add (&fSceneCaptureType); - } - - if (exif.fGainControl <= 0x0FFFF) - { - fExifIFD.Add (&fGainControl); - } - - if (exif.fContrast <= 0x0FFFF) - { - fExifIFD.Add (&fContrast); - } - - if (exif.fSaturation <= 0x0FFFF) - { - fExifIFD.Add (&fSaturation); - } - - if (exif.fSharpness <= 0x0FFFF) - { - fExifIFD.Add (&fSharpness); - } - - if (exif.fSubjectDistanceRange <= 0x0FFFF) - { - fExifIFD.Add (&fSubjectDistanceRange); - } - - if (exif.fDigitalZoomRatio.IsValid ()) - { - fExifIFD.Add (&fDigitalZoomRatio); - } - - if (exif.fExposureIndex.IsValid ()) - { - fExifIFD.Add (&fExposureIndex); - } - - if (insideDNG) // TIFF-EP only tags - { - - if (exif.fImageNumber != 0xFFFFFFFF) - { - directory.Add (&fImageNumber); - } - - if (exif.fSelfTimerMode <= 0x0FFFF) - { - directory.Add (&fSelfTimerMode); - } - - if (exif.fBatteryLevelA.NotEmpty ()) - { - directory.Add (&fBatteryLevelA); - } - - else if (exif.fBatteryLevelR.IsValid ()) - { - directory.Add (&fBatteryLevelR); - } - - } - - if (exif.fFocalPlaneXResolution.IsValid ()) - { - fExifIFD.Add (&fFocalPlaneXResolution); - } - - if (exif.fFocalPlaneYResolution.IsValid ()) - { - fExifIFD.Add (&fFocalPlaneYResolution); - } - - if (exif.fFocalPlaneResolutionUnit <= 0x0FFFF) - { - fExifIFD.Add (&fFocalPlaneResolutionUnit); - } - - if (exif.fSubjectAreaCount) - { - - fSubjectAreaData [0] = (uint16) exif.fSubjectArea [0]; - fSubjectAreaData [1] = (uint16) exif.fSubjectArea [1]; - fSubjectAreaData [2] = (uint16) exif.fSubjectArea [2]; - fSubjectAreaData [3] = (uint16) exif.fSubjectArea [3]; - - fExifIFD.Add (&fSubjectArea); - - } - - if (exif.fLensInfo [0].IsValid () && - exif.fLensInfo [1].IsValid ()) - { - - fLensInfoData [0] = exif.fLensInfo [0]; - fLensInfoData [1] = exif.fLensInfo [1]; - fLensInfoData [2] = exif.fLensInfo [2]; - fLensInfoData [3] = exif.fLensInfo [3]; - - if (insideDNG) - { - directory.Add (&fLensInfo); - } - - } - - if (exif.fDateTime.IsValid ()) - { - - directory.Add (&fDateTime); - - if (exif.fDateTime.Subseconds ().NotEmpty ()) - { - fExifIFD.Add (&fSubsecTime); - } - - } - - if (exif.fDateTimeOriginal.IsValid ()) - { - - fExifIFD.Add (&fDateTimeOriginal); - - if (exif.fDateTimeOriginal.Subseconds ().NotEmpty ()) - { - fExifIFD.Add (&fSubsecTimeOriginal); - } - - } - - if (exif.fDateTimeDigitized.IsValid ()) - { - - fExifIFD.Add (&fDateTimeDigitized); - - if (exif.fDateTimeDigitized.Subseconds ().NotEmpty ()) - { - fExifIFD.Add (&fSubsecTimeDigitized); - } - - } - - if (exif.fMake.NotEmpty ()) - { - directory.Add (&fMake); - } - - if (exif.fModel.NotEmpty ()) - { - directory.Add (&fModel); - } - - if (exif.fArtist.NotEmpty ()) - { - directory.Add (&fArtist); - } - - if (exif.fSoftware.NotEmpty ()) - { - directory.Add (&fSoftware); - } - - if (exif.fCopyright.NotEmpty ()) - { - directory.Add (&fCopyright); - } - - if (exif.fImageDescription.NotEmpty ()) - { - directory.Add (&fImageDescription); - } - - if (exif.fCameraSerialNumber.NotEmpty () && insideDNG) - { - directory.Add (&fSerialNumber); - } - - if (makerNoteSafe && makerNoteData) - { - - directory.Add (&fMakerNoteSafety); - - fExifIFD.Add (&fMakerNote); - - } - - if (exif.fUserComment.NotEmpty ()) - { - fExifIFD.Add (&fUserComment); - } - - if (exif.fImageUniqueID.IsValid ()) - { - - for (uint32 j = 0; j < 16; j++) - { - - sprintf (fImageUniqueIDData + j * 2, - "%02X", - (unsigned) exif.fImageUniqueID.data [j]); - - } - - fExifIFD.Add (&fImageUniqueID); - - } - - if (exif.AtLeastVersion0230 ()) - { - - if (exif.fSensitivityType != 0) - { - - fExifIFD.Add (&fSensitivityType); - - } - - // Sensitivity tags. Do not write these extra tags unless the SensitivityType - // and PhotographicSensitivity (i.e., ISOSpeedRatings) values are valid. - - if (exif.fSensitivityType != 0 && - exif.fISOSpeedRatings [0] != 0) - { - - // Standard Output Sensitivity (SOS). - - if (exif.fStandardOutputSensitivity != 0) - { - fExifIFD.Add (&fStandardOutputSensitivity); - } - - // Recommended Exposure Index (REI). - - if (exif.fRecommendedExposureIndex != 0) - { - fExifIFD.Add (&fRecommendedExposureIndex); - } - - // ISO Speed. - - if (exif.fISOSpeed != 0) - { - - fExifIFD.Add (&fISOSpeed); - - if (exif.fISOSpeedLatitudeyyy != 0 && - exif.fISOSpeedLatitudezzz != 0) - { - - fExifIFD.Add (&fISOSpeedLatitudeyyy); - fExifIFD.Add (&fISOSpeedLatitudezzz); - - } - - } - - } - - if (exif.fOwnerName.NotEmpty ()) - { - fExifIFD.Add (&fCameraOwnerName); - } - - if (exif.fCameraSerialNumber.NotEmpty ()) - { - fExifIFD.Add (&fBodySerialNumber); - } - - if (exif.fLensInfo [0].IsValid () && - exif.fLensInfo [1].IsValid ()) - { - fExifIFD.Add (&fLensSpecification); - } - - if (exif.fLensMake.NotEmpty ()) - { - fExifIFD.Add (&fLensMake); - } - - if (exif.fLensName.NotEmpty ()) - { - fExifIFD.Add (&fLensModel); - } - - if (exif.fLensSerialNumber.NotEmpty ()) - { - fExifIFD.Add (&fLensSerialNumber); - } - - } - - if (exif.fGPSVersionID) - { - - fGPSVersionData [0] = (uint8) (exif.fGPSVersionID >> 24); - fGPSVersionData [1] = (uint8) (exif.fGPSVersionID >> 16); - fGPSVersionData [2] = (uint8) (exif.fGPSVersionID >> 8); - fGPSVersionData [3] = (uint8) (exif.fGPSVersionID ); - - fGPSIFD.Add (&fGPSVersionID); - - } - - if (exif.fGPSLatitudeRef.NotEmpty () && - exif.fGPSLatitude [0].IsValid ()) - { - fGPSIFD.Add (&fGPSLatitudeRef); - fGPSIFD.Add (&fGPSLatitude ); - } - - if (exif.fGPSLongitudeRef.NotEmpty () && - exif.fGPSLongitude [0].IsValid ()) - { - fGPSIFD.Add (&fGPSLongitudeRef); - fGPSIFD.Add (&fGPSLongitude ); - } - - if (exif.fGPSAltitudeRef <= 0x0FF) - { - fGPSIFD.Add (&fGPSAltitudeRef); - } - - if (exif.fGPSAltitude.IsValid ()) - { - fGPSIFD.Add (&fGPSAltitude); - } - - if (exif.fGPSTimeStamp [0].IsValid ()) - { - fGPSIFD.Add (&fGPSTimeStamp); - } - - if (exif.fGPSSatellites.NotEmpty ()) - { - fGPSIFD.Add (&fGPSSatellites); - } - - if (exif.fGPSStatus.NotEmpty ()) - { - fGPSIFD.Add (&fGPSStatus); - } - - if (exif.fGPSMeasureMode.NotEmpty ()) - { - fGPSIFD.Add (&fGPSMeasureMode); - } - - if (exif.fGPSDOP.IsValid ()) - { - fGPSIFD.Add (&fGPSDOP); - } - - if (exif.fGPSSpeedRef.NotEmpty ()) - { - fGPSIFD.Add (&fGPSSpeedRef); - } - - if (exif.fGPSSpeed.IsValid ()) - { - fGPSIFD.Add (&fGPSSpeed); - } - - if (exif.fGPSTrackRef.NotEmpty ()) - { - fGPSIFD.Add (&fGPSTrackRef); - } - - if (exif.fGPSTrack.IsValid ()) - { - fGPSIFD.Add (&fGPSTrack); - } - - if (exif.fGPSImgDirectionRef.NotEmpty ()) - { - fGPSIFD.Add (&fGPSImgDirectionRef); - } - - if (exif.fGPSImgDirection.IsValid ()) - { - fGPSIFD.Add (&fGPSImgDirection); - } - - if (exif.fGPSMapDatum.NotEmpty ()) - { - fGPSIFD.Add (&fGPSMapDatum); - } - - if (exif.fGPSDestLatitudeRef.NotEmpty () && - exif.fGPSDestLatitude [0].IsValid ()) - { - fGPSIFD.Add (&fGPSDestLatitudeRef); - fGPSIFD.Add (&fGPSDestLatitude ); - } - - if (exif.fGPSDestLongitudeRef.NotEmpty () && - exif.fGPSDestLongitude [0].IsValid ()) - { - fGPSIFD.Add (&fGPSDestLongitudeRef); - fGPSIFD.Add (&fGPSDestLongitude ); - } - - if (exif.fGPSDestBearingRef.NotEmpty ()) - { - fGPSIFD.Add (&fGPSDestBearingRef); - } - - if (exif.fGPSDestBearing.IsValid ()) - { - fGPSIFD.Add (&fGPSDestBearing); - } - - if (exif.fGPSDestDistanceRef.NotEmpty ()) - { - fGPSIFD.Add (&fGPSDestDistanceRef); - } - - if (exif.fGPSDestDistance.IsValid ()) - { - fGPSIFD.Add (&fGPSDestDistance); - } - - if (exif.fGPSProcessingMethod.NotEmpty ()) - { - fGPSIFD.Add (&fGPSProcessingMethod); - } - - if (exif.fGPSAreaInformation.NotEmpty ()) - { - fGPSIFD.Add (&fGPSAreaInformation); - } - - if (exif.fGPSDateStamp.NotEmpty ()) - { - fGPSIFD.Add (&fGPSDateStamp); - } - - if (exif.fGPSDifferential <= 0x0FFFF) - { - fGPSIFD.Add (&fGPSDifferential); - } - - if (exif.AtLeastVersion0230 ()) - { - - if (exif.fGPSHPositioningError.IsValid ()) - { - fGPSIFD.Add (&fGPSHPositioningError); - } - - } - - AddLinks (directory); - - } - -/******************************************************************************/ - -void exif_tag_set::AddLinks (dng_tiff_directory &directory) - { - - if (fExifIFD.Size () != 0 && !fAddedExifLink) - { - - directory.Add (&fExifLink); - - fAddedExifLink = true; - - } - - if (fGPSIFD.Size () != 0 && !fAddedGPSLink) - { - - directory.Add (&fGPSLink); - - fAddedGPSLink = true; - - } - - } - -/******************************************************************************/ - -class range_tag_set - { - - private: - - uint32 fActiveAreaData [4]; - - tag_uint32_ptr fActiveArea; - - uint32 fMaskedAreaData [kMaxMaskedAreas * 4]; - - tag_uint32_ptr fMaskedAreas; - - tag_uint16_ptr fLinearizationTable; - - uint16 fBlackLevelRepeatDimData [2]; - - tag_uint16_ptr fBlackLevelRepeatDim; - - dng_urational fBlackLevelData [kMaxBlackPattern * - kMaxBlackPattern * - kMaxSamplesPerPixel]; - - tag_urational_ptr fBlackLevel; - - dng_memory_data fBlackLevelDeltaHData; - dng_memory_data fBlackLevelDeltaVData; - - tag_srational_ptr fBlackLevelDeltaH; - tag_srational_ptr fBlackLevelDeltaV; - - uint16 fWhiteLevelData16 [kMaxSamplesPerPixel]; - uint32 fWhiteLevelData32 [kMaxSamplesPerPixel]; - - tag_uint16_ptr fWhiteLevel16; - tag_uint32_ptr fWhiteLevel32; - - public: - - range_tag_set (dng_tiff_directory &directory, - const dng_negative &negative); - - }; - -/******************************************************************************/ - -range_tag_set::range_tag_set (dng_tiff_directory &directory, - const dng_negative &negative) - - : fActiveArea (tcActiveArea, - fActiveAreaData, - 4) - - , fMaskedAreas (tcMaskedAreas, - fMaskedAreaData, - 0) - - , fLinearizationTable (tcLinearizationTable, - NULL, - 0) - - , fBlackLevelRepeatDim (tcBlackLevelRepeatDim, - fBlackLevelRepeatDimData, - 2) - - , fBlackLevel (tcBlackLevel, - fBlackLevelData) - - , fBlackLevelDeltaHData () - , fBlackLevelDeltaVData () - - , fBlackLevelDeltaH (tcBlackLevelDeltaH) - , fBlackLevelDeltaV (tcBlackLevelDeltaV) - - , fWhiteLevel16 (tcWhiteLevel, - fWhiteLevelData16) - - , fWhiteLevel32 (tcWhiteLevel, - fWhiteLevelData32) - - { - - const dng_image &rawImage (negative.RawImage ()); - - const dng_linearization_info *rangeInfo = negative.GetLinearizationInfo (); - - if (rangeInfo) - { - - // ActiveArea: - - { - - const dng_rect &r = rangeInfo->fActiveArea; - - if (r.NotEmpty ()) - { - - fActiveAreaData [0] = r.t; - fActiveAreaData [1] = r.l; - fActiveAreaData [2] = r.b; - fActiveAreaData [3] = r.r; - - directory.Add (&fActiveArea); - - } - - } - - // MaskedAreas: - - if (rangeInfo->fMaskedAreaCount) - { - - fMaskedAreas.SetCount (rangeInfo->fMaskedAreaCount * 4); - - for (uint32 index = 0; index < rangeInfo->fMaskedAreaCount; index++) - { - - const dng_rect &r = rangeInfo->fMaskedArea [index]; - - fMaskedAreaData [index * 4 + 0] = r.t; - fMaskedAreaData [index * 4 + 1] = r.l; - fMaskedAreaData [index * 4 + 2] = r.b; - fMaskedAreaData [index * 4 + 3] = r.r; - - } - - directory.Add (&fMaskedAreas); - - } - - // LinearizationTable: - - if (rangeInfo->fLinearizationTable.Get ()) - { - - fLinearizationTable.SetData (rangeInfo->fLinearizationTable->Buffer_uint16 () ); - fLinearizationTable.SetCount (rangeInfo->fLinearizationTable->LogicalSize () >> 1); - - directory.Add (&fLinearizationTable); - - } - - // BlackLevelRepeatDim: - - { - - fBlackLevelRepeatDimData [0] = (uint16) rangeInfo->fBlackLevelRepeatRows; - fBlackLevelRepeatDimData [1] = (uint16) rangeInfo->fBlackLevelRepeatCols; - - directory.Add (&fBlackLevelRepeatDim); - - } - - // BlackLevel: - - { - - uint32 index = 0; - - for (uint16 v = 0; v < rangeInfo->fBlackLevelRepeatRows; v++) - { - - for (uint32 h = 0; h < rangeInfo->fBlackLevelRepeatCols; h++) - { - - for (uint32 c = 0; c < rawImage.Planes (); c++) - { - - fBlackLevelData [index++] = rangeInfo->BlackLevel (v, h, c); - - } - - } - - } - - fBlackLevel.SetCount (rangeInfo->fBlackLevelRepeatRows * - rangeInfo->fBlackLevelRepeatCols * rawImage.Planes ()); - - directory.Add (&fBlackLevel); - - } - - // BlackLevelDeltaH: - - if (rangeInfo->ColumnBlackCount ()) - { - - uint32 count = rangeInfo->ColumnBlackCount (); - - fBlackLevelDeltaHData.Allocate (count * (uint32) sizeof (dng_srational)); - - dng_srational *blacks = (dng_srational *) fBlackLevelDeltaHData.Buffer (); - - for (uint32 col = 0; col < count; col++) - { - - blacks [col] = rangeInfo->ColumnBlack (col); - - } - - fBlackLevelDeltaH.SetData (blacks); - fBlackLevelDeltaH.SetCount (count ); - - directory.Add (&fBlackLevelDeltaH); - - } - - // BlackLevelDeltaV: - - if (rangeInfo->RowBlackCount ()) - { - - uint32 count = rangeInfo->RowBlackCount (); - - fBlackLevelDeltaVData.Allocate (count * (uint32) sizeof (dng_srational)); - - dng_srational *blacks = (dng_srational *) fBlackLevelDeltaVData.Buffer (); - - for (uint32 row = 0; row < count; row++) - { - - blacks [row] = rangeInfo->RowBlack (row); - - } - - fBlackLevelDeltaV.SetData (blacks); - fBlackLevelDeltaV.SetCount (count ); - - directory.Add (&fBlackLevelDeltaV); - - } - - } - - // WhiteLevel: - - // Only use the 32-bit data type if we must use it since there - // are some lazy (non-Adobe) DNG readers out there. - - bool needs32 = false; - - fWhiteLevel16.SetCount (rawImage.Planes ()); - fWhiteLevel32.SetCount (rawImage.Planes ()); - - for (uint32 c = 0; c < fWhiteLevel16.Count (); c++) - { - - fWhiteLevelData32 [c] = negative.WhiteLevel (c); - - if (fWhiteLevelData32 [c] > 0x0FFFF) - { - needs32 = true; - } - - fWhiteLevelData16 [c] = (uint16) fWhiteLevelData32 [c]; - - } - - if (needs32) - { - directory.Add (&fWhiteLevel32); - } - - else - { - directory.Add (&fWhiteLevel16); - } - - } - -/******************************************************************************/ - -class mosaic_tag_set - { - - private: - - uint16 fCFARepeatPatternDimData [2]; - - tag_uint16_ptr fCFARepeatPatternDim; - - uint8 fCFAPatternData [kMaxCFAPattern * - kMaxCFAPattern]; - - tag_uint8_ptr fCFAPattern; - - uint8 fCFAPlaneColorData [kMaxColorPlanes]; - - tag_uint8_ptr fCFAPlaneColor; - - tag_uint16 fCFALayout; - - tag_uint32 fGreenSplit; - - public: - - mosaic_tag_set (dng_tiff_directory &directory, - const dng_mosaic_info &info); - - }; - -/******************************************************************************/ - -mosaic_tag_set::mosaic_tag_set (dng_tiff_directory &directory, - const dng_mosaic_info &info) - - : fCFARepeatPatternDim (tcCFARepeatPatternDim, - fCFARepeatPatternDimData, - 2) - - , fCFAPattern (tcCFAPattern, - fCFAPatternData) - - , fCFAPlaneColor (tcCFAPlaneColor, - fCFAPlaneColorData) - - , fCFALayout (tcCFALayout, - (uint16) info.fCFALayout) - - , fGreenSplit (tcBayerGreenSplit, - info.fBayerGreenSplit) - - { - - if (info.IsColorFilterArray ()) - { - - // CFARepeatPatternDim: - - fCFARepeatPatternDimData [0] = (uint16) info.fCFAPatternSize.v; - fCFARepeatPatternDimData [1] = (uint16) info.fCFAPatternSize.h; - - directory.Add (&fCFARepeatPatternDim); - - // CFAPattern: - - fCFAPattern.SetCount (info.fCFAPatternSize.v * - info.fCFAPatternSize.h); - - for (int32 r = 0; r < info.fCFAPatternSize.v; r++) - { - - for (int32 c = 0; c < info.fCFAPatternSize.h; c++) - { - - fCFAPatternData [r * info.fCFAPatternSize.h + c] = info.fCFAPattern [r] [c]; - - } - - } - - directory.Add (&fCFAPattern); - - // CFAPlaneColor: - - fCFAPlaneColor.SetCount (info.fColorPlanes); - - for (uint32 j = 0; j < info.fColorPlanes; j++) - { - - fCFAPlaneColorData [j] = info.fCFAPlaneColor [j]; - - } - - directory.Add (&fCFAPlaneColor); - - // CFALayout: - - fCFALayout.Set ((uint16) info.fCFALayout); - - directory.Add (&fCFALayout); - - // BayerGreenSplit: (only include if the pattern is a Bayer pattern) - - if (info.fCFAPatternSize == dng_point (2, 2) && - info.fColorPlanes == 3) - { - - directory.Add (&fGreenSplit); - - } - - } - - } - -/******************************************************************************/ - -class color_tag_set - { - - private: - - uint32 fColorChannels; - - tag_matrix fCameraCalibration1; - tag_matrix fCameraCalibration2; - - tag_string fCameraCalibrationSignature; - - tag_string fAsShotProfileName; - - dng_urational fAnalogBalanceData [4]; - - tag_urational_ptr fAnalogBalance; - - dng_urational fAsShotNeutralData [4]; - - tag_urational_ptr fAsShotNeutral; - - dng_urational fAsShotWhiteXYData [2]; - - tag_urational_ptr fAsShotWhiteXY; - - tag_urational fLinearResponseLimit; - - public: - - color_tag_set (dng_tiff_directory &directory, - const dng_negative &negative); - - }; - -/******************************************************************************/ - -color_tag_set::color_tag_set (dng_tiff_directory &directory, - const dng_negative &negative) - - : fColorChannels (negative.ColorChannels ()) - - , fCameraCalibration1 (tcCameraCalibration1, - negative.CameraCalibration1 ()) - - , fCameraCalibration2 (tcCameraCalibration2, - negative.CameraCalibration2 ()) - - , fCameraCalibrationSignature (tcCameraCalibrationSignature, - negative.CameraCalibrationSignature ()) - - , fAsShotProfileName (tcAsShotProfileName, - negative.AsShotProfileName ()) - - , fAnalogBalance (tcAnalogBalance, - fAnalogBalanceData, - fColorChannels) - - , fAsShotNeutral (tcAsShotNeutral, - fAsShotNeutralData, - fColorChannels) - - , fAsShotWhiteXY (tcAsShotWhiteXY, - fAsShotWhiteXYData, - 2) - - , fLinearResponseLimit (tcLinearResponseLimit, - negative.LinearResponseLimitR ()) - - { - - if (fColorChannels > 1) - { - - uint32 channels2 = fColorChannels * fColorChannels; - - if (fCameraCalibration1.Count () == channels2) - { - - directory.Add (&fCameraCalibration1); - - } - - if (fCameraCalibration2.Count () == channels2) - { - - directory.Add (&fCameraCalibration2); - - } - - if (fCameraCalibration1.Count () == channels2 || - fCameraCalibration2.Count () == channels2) - { - - if (negative.CameraCalibrationSignature ().NotEmpty ()) - { - - directory.Add (&fCameraCalibrationSignature); - - } - - } - - if (negative.AsShotProfileName ().NotEmpty ()) - { - - directory.Add (&fAsShotProfileName); - - } - - for (uint32 j = 0; j < fColorChannels; j++) - { - - fAnalogBalanceData [j] = negative.AnalogBalanceR (j); - - } - - directory.Add (&fAnalogBalance); - - if (negative.HasCameraNeutral ()) - { - - for (uint32 k = 0; k < fColorChannels; k++) - { - - fAsShotNeutralData [k] = negative.CameraNeutralR (k); - - } - - directory.Add (&fAsShotNeutral); - - } - - else if (negative.HasCameraWhiteXY ()) - { - - negative.GetCameraWhiteXY (fAsShotWhiteXYData [0], - fAsShotWhiteXYData [1]); - - directory.Add (&fAsShotWhiteXY); - - } - - directory.Add (&fLinearResponseLimit); - - } - - } - -/******************************************************************************/ - -class profile_tag_set - { - - private: - - tag_uint16 fCalibrationIlluminant1; - tag_uint16 fCalibrationIlluminant2; - - tag_matrix fColorMatrix1; - tag_matrix fColorMatrix2; - - tag_matrix fForwardMatrix1; - tag_matrix fForwardMatrix2; - - tag_matrix fReductionMatrix1; - tag_matrix fReductionMatrix2; - - tag_string fProfileName; - - tag_string fProfileCalibrationSignature; - - tag_uint32 fEmbedPolicyTag; - - tag_string fCopyrightTag; - - uint32 fHueSatMapDimData [3]; - - tag_uint32_ptr fHueSatMapDims; - - tag_data_ptr fHueSatData1; - tag_data_ptr fHueSatData2; - - tag_uint32 fHueSatMapEncodingTag; - - uint32 fLookTableDimData [3]; - - tag_uint32_ptr fLookTableDims; - - tag_data_ptr fLookTableData; - - tag_uint32 fLookTableEncodingTag; - - tag_srational fBaselineExposureOffsetTag; - - tag_uint32 fDefaultBlackRenderTag; - - dng_memory_data fToneCurveBuffer; - - tag_data_ptr fToneCurveTag; - - public: - - profile_tag_set (dng_tiff_directory &directory, - const dng_camera_profile &profile); - - }; - -/******************************************************************************/ - -profile_tag_set::profile_tag_set (dng_tiff_directory &directory, - const dng_camera_profile &profile) - - : fCalibrationIlluminant1 (tcCalibrationIlluminant1, - (uint16) profile.CalibrationIlluminant1 ()) - - , fCalibrationIlluminant2 (tcCalibrationIlluminant2, - (uint16) profile.CalibrationIlluminant2 ()) - - , fColorMatrix1 (tcColorMatrix1, - profile.ColorMatrix1 ()) - - , fColorMatrix2 (tcColorMatrix2, - profile.ColorMatrix2 ()) - - , fForwardMatrix1 (tcForwardMatrix1, - profile.ForwardMatrix1 ()) - - , fForwardMatrix2 (tcForwardMatrix2, - profile.ForwardMatrix2 ()) - - , fReductionMatrix1 (tcReductionMatrix1, - profile.ReductionMatrix1 ()) - - , fReductionMatrix2 (tcReductionMatrix2, - profile.ReductionMatrix2 ()) - - , fProfileName (tcProfileName, - profile.Name (), - false) - - , fProfileCalibrationSignature (tcProfileCalibrationSignature, - profile.ProfileCalibrationSignature (), - false) - - , fEmbedPolicyTag (tcProfileEmbedPolicy, - profile.EmbedPolicy ()) - - , fCopyrightTag (tcProfileCopyright, - profile.Copyright (), - false) - - , fHueSatMapDims (tcProfileHueSatMapDims, - fHueSatMapDimData, - 3) - - , fHueSatData1 (tcProfileHueSatMapData1, - ttFloat, - profile.HueSatDeltas1 ().DeltasCount () * 3, - profile.HueSatDeltas1 ().GetConstDeltas ()) - - , fHueSatData2 (tcProfileHueSatMapData2, - ttFloat, - profile.HueSatDeltas2 ().DeltasCount () * 3, - profile.HueSatDeltas2 ().GetConstDeltas ()) - - , fHueSatMapEncodingTag (tcProfileHueSatMapEncoding, - profile.HueSatMapEncoding ()) - - , fLookTableDims (tcProfileLookTableDims, - fLookTableDimData, - 3) - - , fLookTableData (tcProfileLookTableData, - ttFloat, - profile.LookTable ().DeltasCount () * 3, - profile.LookTable ().GetConstDeltas ()) - - , fLookTableEncodingTag (tcProfileLookTableEncoding, - profile.LookTableEncoding ()) - - , fBaselineExposureOffsetTag (tcBaselineExposureOffset, - profile.BaselineExposureOffset ()) - - , fDefaultBlackRenderTag (tcDefaultBlackRender, - profile.DefaultBlackRender ()) - - , fToneCurveBuffer () - - , fToneCurveTag (tcProfileToneCurve, - ttFloat, - 0, - NULL) - - { - - if (profile.HasColorMatrix1 ()) - { - - uint32 colorChannels = profile.ColorMatrix1 ().Rows (); - - directory.Add (&fCalibrationIlluminant1); - - directory.Add (&fColorMatrix1); - - if (fForwardMatrix1.Count () == colorChannels * 3) - { - - directory.Add (&fForwardMatrix1); - - } - - if (colorChannels > 3 && fReductionMatrix1.Count () == colorChannels * 3) - { - - directory.Add (&fReductionMatrix1); - - } - - if (profile.HasColorMatrix2 ()) - { - - directory.Add (&fCalibrationIlluminant2); - - directory.Add (&fColorMatrix2); - - if (fForwardMatrix2.Count () == colorChannels * 3) - { - - directory.Add (&fForwardMatrix2); - - } - - if (colorChannels > 3 && fReductionMatrix2.Count () == colorChannels * 3) - { - - directory.Add (&fReductionMatrix2); - - } - - } - - if (profile.Name ().NotEmpty ()) - { - - directory.Add (&fProfileName); - - } - - if (profile.ProfileCalibrationSignature ().NotEmpty ()) - { - - directory.Add (&fProfileCalibrationSignature); - - } - - directory.Add (&fEmbedPolicyTag); - - if (profile.Copyright ().NotEmpty ()) - { - - directory.Add (&fCopyrightTag); - - } - - bool haveHueSat1 = profile.HueSatDeltas1 ().IsValid (); - - bool haveHueSat2 = profile.HueSatDeltas2 ().IsValid () && - profile.HasColorMatrix2 (); - - if (haveHueSat1 || haveHueSat2) - { - - uint32 hueDivs = 0; - uint32 satDivs = 0; - uint32 valDivs = 0; - - if (haveHueSat1) - { - - profile.HueSatDeltas1 ().GetDivisions (hueDivs, - satDivs, - valDivs); - - } - - else - { - - profile.HueSatDeltas2 ().GetDivisions (hueDivs, - satDivs, - valDivs); - - } - - fHueSatMapDimData [0] = hueDivs; - fHueSatMapDimData [1] = satDivs; - fHueSatMapDimData [2] = valDivs; - - directory.Add (&fHueSatMapDims); - - // Don't bother including the ProfileHueSatMapEncoding tag unless it's - // non-linear. - - if (profile.HueSatMapEncoding () != encoding_Linear) - { - - directory.Add (&fHueSatMapEncodingTag); - - } - - } - - if (haveHueSat1) - { - - directory.Add (&fHueSatData1); - - } - - if (haveHueSat2) - { - - directory.Add (&fHueSatData2); - - } - - if (profile.HasLookTable ()) - { - - uint32 hueDivs = 0; - uint32 satDivs = 0; - uint32 valDivs = 0; - - profile.LookTable ().GetDivisions (hueDivs, - satDivs, - valDivs); - - fLookTableDimData [0] = hueDivs; - fLookTableDimData [1] = satDivs; - fLookTableDimData [2] = valDivs; - - directory.Add (&fLookTableDims); - - directory.Add (&fLookTableData); - - // Don't bother including the ProfileLookTableEncoding tag unless it's - // non-linear. - - if (profile.LookTableEncoding () != encoding_Linear) - { - - directory.Add (&fLookTableEncodingTag); - - } - - } - - // Don't bother including the BaselineExposureOffset tag unless it's both - // valid and non-zero. - - if (profile.BaselineExposureOffset ().IsValid ()) - { - - if (profile.BaselineExposureOffset ().As_real64 () != 0.0) - { - - directory.Add (&fBaselineExposureOffsetTag); - - } - - } - - if (profile.DefaultBlackRender () != defaultBlackRender_Auto) - { - - directory.Add (&fDefaultBlackRenderTag); - - } - - if (profile.ToneCurve ().IsValid ()) - { - - // Tone curve stored as pairs of 32-bit coordinates. Probably could do with - // 16-bits here, but should be small number of points so... - - uint32 toneCurvePoints = (uint32) (profile.ToneCurve ().fCoord.size ()); - - fToneCurveBuffer.Allocate (toneCurvePoints * 2 * (uint32) sizeof (real32)); - - real32 *points = fToneCurveBuffer.Buffer_real32 (); - - fToneCurveTag.SetCount (toneCurvePoints * 2); - fToneCurveTag.SetData (points); - - for (uint32 i = 0; i < toneCurvePoints; i++) - { - - // Transpose coordinates so they are in a more expected - // order (domain -> range). - - points [i * 2 ] = (real32) profile.ToneCurve ().fCoord [i].h; - points [i * 2 + 1] = (real32) profile.ToneCurve ().fCoord [i].v; - - } - - directory.Add (&fToneCurveTag); - - } - - } - - } - -/******************************************************************************/ - -tiff_dng_extended_color_profile::tiff_dng_extended_color_profile - (const dng_camera_profile &profile) - - : fProfile (profile) - - { - - } - -/******************************************************************************/ - -void tiff_dng_extended_color_profile::Put (dng_stream &stream, - bool includeModelRestriction) - { - - // Profile header. - - stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII); - - stream.Put_uint16 (magicExtendedProfile); - - stream.Put_uint32 (8); - - // Profile tags. - - profile_tag_set tagSet (*this, fProfile); - - // Camera this profile is for. - - tag_string cameraModelTag (tcUniqueCameraModel, - fProfile.UniqueCameraModelRestriction ()); - - if (includeModelRestriction) - { - - if (fProfile.UniqueCameraModelRestriction ().NotEmpty ()) - { - - Add (&cameraModelTag); - - } - - } - - // Write it all out. - - dng_tiff_directory::Put (stream, offsetsRelativeToExplicitBase, 8); - - } - -/*****************************************************************************/ - -tag_dng_noise_profile::tag_dng_noise_profile (const dng_noise_profile &profile) - - : tag_data_ptr (tcNoiseProfile, - ttDouble, - 2 * profile.NumFunctions (), - fValues) - - { - - DNG_REQUIRE (profile.NumFunctions () <= kMaxColorPlanes, - "Too many noise functions in tag_dng_noise_profile."); - - for (uint32 i = 0; i < profile.NumFunctions (); i++) - { - - fValues [(2 * i) ] = profile.NoiseFunction (i).Scale (); - fValues [(2 * i) + 1] = profile.NoiseFunction (i).Offset (); - - } - - } - -/*****************************************************************************/ - -dng_image_writer::dng_image_writer () - { - - } - -/*****************************************************************************/ - -dng_image_writer::~dng_image_writer () - { - - } - -/*****************************************************************************/ - -uint32 dng_image_writer::CompressedBufferSize (const dng_ifd &ifd, - uint32 uncompressedSize) - { - - switch (ifd.fCompression) - { - - case ccLZW: - { - - // Add lots of slop for LZW to expand data. - - return uncompressedSize * 2 + 1024; - - } - - case ccDeflate: - { - - // ZLib says maximum is source size + 0.1% + 12 bytes. - - return uncompressedSize + (uncompressedSize >> 8) + 64; - - } - - case ccJPEG: - { - - // If we are saving lossless JPEG from an 8-bit image, reserve - // space to pad the data out to 16-bits. - - if (ifd.fBitsPerSample [0] <= 8) - { - - return uncompressedSize * 2; - - } - - break; - - } - - default: - break; - - } - - return 0; - - } - -/******************************************************************************/ - -static void EncodeDelta8 (uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = cols - 1; col > 0; col--) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/******************************************************************************/ - -static void EncodeDelta16 (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = cols - 1; col > 0; col--) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/******************************************************************************/ - -static void EncodeDelta32 (uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = cols - 1; col > 0; col--) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -inline void EncodeDeltaBytes (uint8 *bytePtr, int32 cols, int32 channels) - { - - if (channels == 1) - { - - bytePtr += (cols - 1); - - uint8 this0 = bytePtr [0]; - - for (int32 col = 1; col < cols; col++) - { - - uint8 prev0 = bytePtr [-1]; - - this0 -= prev0; - - bytePtr [0] = this0; - - this0 = prev0; - - bytePtr -= 1; - - } - - } - - else if (channels == 3) - { - - bytePtr += (cols - 1) * 3; - - uint8 this0 = bytePtr [0]; - uint8 this1 = bytePtr [1]; - uint8 this2 = bytePtr [2]; - - for (int32 col = 1; col < cols; col++) - { - - uint8 prev0 = bytePtr [-3]; - uint8 prev1 = bytePtr [-2]; - uint8 prev2 = bytePtr [-1]; - - this0 -= prev0; - this1 -= prev1; - this2 -= prev2; - - bytePtr [0] = this0; - bytePtr [1] = this1; - bytePtr [2] = this2; - - this0 = prev0; - this1 = prev1; - this2 = prev2; - - bytePtr -= 3; - - } - - } - - else - { - - uint32 rowBytes = cols * channels; - - bytePtr += rowBytes - 1; - - for (uint32 col = channels; col < rowBytes; col++) - { - - bytePtr [0] -= bytePtr [-channels]; - - bytePtr--; - - } - - } - - } - -/*****************************************************************************/ - -static void EncodeFPDelta (uint8 *buffer, - uint8 *temp, - int32 cols, - int32 channels, - int32 bytesPerSample) - { - - int32 rowIncrement = cols * channels; - - if (bytesPerSample == 2) - { - - const uint8 *src = buffer; - - #if qDNGBigEndian - uint8 *dst0 = temp; - uint8 *dst1 = temp + rowIncrement; - #else - uint8 *dst1 = temp; - uint8 *dst0 = temp + rowIncrement; - #endif - - for (int32 col = 0; col < rowIncrement; ++col) - { - - dst0 [col] = src [0]; - dst1 [col] = src [1]; - - src += 2; - - } - - } - - else if (bytesPerSample == 3) - { - - const uint8 *src = buffer; - - uint8 *dst0 = temp; - uint8 *dst1 = temp + rowIncrement; - uint8 *dst2 = temp + rowIncrement * 2; - - for (int32 col = 0; col < rowIncrement; ++col) - { - - dst0 [col] = src [0]; - dst1 [col] = src [1]; - dst2 [col] = src [2]; - - src += 3; - - } - - } - - else - { - - const uint8 *src = buffer; - - #if qDNGBigEndian - uint8 *dst0 = temp; - uint8 *dst1 = temp + rowIncrement; - uint8 *dst2 = temp + rowIncrement * 2; - uint8 *dst3 = temp + rowIncrement * 3; - #else - uint8 *dst3 = temp; - uint8 *dst2 = temp + rowIncrement; - uint8 *dst1 = temp + rowIncrement * 2; - uint8 *dst0 = temp + rowIncrement * 3; - #endif - - for (int32 col = 0; col < rowIncrement; ++col) - { - - dst0 [col] = src [0]; - dst1 [col] = src [1]; - dst2 [col] = src [2]; - dst3 [col] = src [3]; - - src += 4; - - } - - } - - EncodeDeltaBytes (temp, cols*bytesPerSample, channels); - - memcpy (buffer, temp, cols*bytesPerSample*channels); - - } - -/*****************************************************************************/ - -void dng_image_writer::EncodePredictor (dng_host &host, - const dng_ifd &ifd, - dng_pixel_buffer &buffer, - AutoPtr &tempBuffer) - { - - switch (ifd.fPredictor) - { - - case cpHorizontalDifference: - case cpHorizontalDifferenceX2: - case cpHorizontalDifferenceX4: - { - - int32 xFactor = 1; - - if (ifd.fPredictor == cpHorizontalDifferenceX2) - { - xFactor = 2; - } - - else if (ifd.fPredictor == cpHorizontalDifferenceX4) - { - xFactor = 4; - } - - switch (buffer.fPixelType) - { - - case ttByte: - { - - EncodeDelta8 ((uint8 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - case ttShort: - { - - EncodeDelta16 ((uint16 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - case ttLong: - { - - EncodeDelta32 ((uint32 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - default: - break; - - } - - break; - - } - - case cpFloatingPoint: - case cpFloatingPointX2: - case cpFloatingPointX4: - { - - int32 xFactor = 1; - - if (ifd.fPredictor == cpFloatingPointX2) - { - xFactor = 2; - } - - else if (ifd.fPredictor == cpFloatingPointX4) - { - xFactor = 4; - } - - uint32 tempBufferSize = buffer.fRowStep * buffer.fPixelSize; - - if (!tempBuffer.Get () || tempBuffer->LogicalSize () < tempBufferSize) - { - - tempBuffer.Reset (host.Allocate (tempBufferSize)); - - } - - for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++) - { - - EncodeFPDelta ((uint8 *) buffer.DirtyPixel (row, buffer.fArea.l, buffer.fPlane), - tempBuffer->Buffer_uint8 (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor, - buffer.fPixelSize); - - } - - return; - - } - - default: - break; - - } - - if (ifd.fPredictor != cpNullPredictor) - { - - ThrowProgramError (); - - } - - } - -/*****************************************************************************/ - -void dng_image_writer::ByteSwapBuffer (dng_host & /* host */, - dng_pixel_buffer &buffer) - { - - uint32 pixels = buffer.fRowStep * buffer.fArea.H (); - - switch (buffer.fPixelSize) - { - - case 2: - { - - DoSwapBytes16 ((uint16 *) buffer.fData, - pixels); - - break; - - } - - case 4: - { - - DoSwapBytes32 ((uint32 *) buffer.fData, - pixels); - - break; - - } - - default: - break; - - } - - } - -/*****************************************************************************/ - -void dng_image_writer::ReorderSubTileBlocks (const dng_ifd &ifd, - dng_pixel_buffer &buffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer) - { - - uint32 blockRows = ifd.fSubTileBlockRows; - uint32 blockCols = ifd.fSubTileBlockCols; - - uint32 rowBlocks = buffer.fArea.H () / blockRows; - uint32 colBlocks = buffer.fArea.W () / blockCols; - - int32 rowStep = buffer.fRowStep * buffer.fPixelSize; - int32 colStep = buffer.fColStep * buffer.fPixelSize; - - int32 rowBlockStep = rowStep * blockRows; - int32 colBlockStep = colStep * blockCols; - - uint32 blockColBytes = blockCols * buffer.fPlanes * buffer.fPixelSize; - - const uint8 *s0 = uncompressedBuffer->Buffer_uint8 (); - uint8 *d0 = subTileBlockBuffer->Buffer_uint8 (); - - for (uint32 rowBlock = 0; rowBlock < rowBlocks; rowBlock++) - { - - const uint8 *s1 = s0; - - for (uint32 colBlock = 0; colBlock < colBlocks; colBlock++) - { - - const uint8 *s2 = s1; - - for (uint32 blockRow = 0; blockRow < blockRows; blockRow++) - { - - for (uint32 j = 0; j < blockColBytes; j++) - { - - d0 [j] = s2 [j]; - - } - - d0 += blockColBytes; - - s2 += rowStep; - - } - - s1 += colBlockStep; - - } - - s0 += rowBlockStep; - - } - - // Copy back reordered pixels. - - DoCopyBytes (subTileBlockBuffer->Buffer (), - uncompressedBuffer->Buffer (), - uncompressedBuffer->LogicalSize ()); - - } - -/******************************************************************************/ - -class dng_lzw_compressor - { - - private: - - enum - { - kResetCode = 256, - kEndCode = 257, - kTableSize = 4096 - }; - - // Compressor nodes have two son pointers. The low order bit of - // the next code determines which pointer is used. This cuts the - // number of nodes searched for the next code by two on average. - - struct LZWCompressorNode - { - int16 final; - int16 son0; - int16 son1; - int16 brother; - }; - - dng_memory_data fBuffer; - - LZWCompressorNode *fTable; - - uint8 *fDstPtr; - - int32 fDstCount; - - int32 fBitOffset; - - int32 fNextCode; - - int32 fCodeSize; - - public: - - dng_lzw_compressor (); - - void Compress (const uint8 *sPtr, - uint8 *dPtr, - uint32 sCount, - uint32 &dCount); - - private: - - void InitTable (); - - int32 SearchTable (int32 w, int32 k) const - { - - DNG_ASSERT ((w >= 0) && (w <= kTableSize), - "Bad w value in dng_lzw_compressor::SearchTable"); - - int32 son0 = fTable [w] . son0; - int32 son1 = fTable [w] . son1; - - // Branchless version of: - // int32 code = (k & 1) ? son1 : son0; - - int32 code = son0 + ((-((int32) (k & 1))) & (son1 - son0)); - - while (code > 0 && fTable [code].final != k) - { - code = fTable [code].brother; - } - - return code; - - } - - void AddTable (int32 w, int32 k); - - void PutCodeWord (int32 code); - - // Hidden copy constructor and assignment operator. - - dng_lzw_compressor (const dng_lzw_compressor &compressor); - - dng_lzw_compressor & operator= (const dng_lzw_compressor &compressor); - - }; - -/******************************************************************************/ - -dng_lzw_compressor::dng_lzw_compressor () - - : fBuffer () - , fTable (NULL) - , fDstPtr (NULL) - , fDstCount (0) - , fBitOffset (0) - , fNextCode (0) - , fCodeSize (0) - - { - - fBuffer.Allocate (kTableSize * sizeof (LZWCompressorNode)); - - fTable = (LZWCompressorNode *) fBuffer.Buffer (); - - } - -/******************************************************************************/ - -void dng_lzw_compressor::InitTable () - { - - fCodeSize = 9; - - fNextCode = 258; - - LZWCompressorNode *node = &fTable [0]; - - for (int32 code = 0; code < 256; ++code) - { - - node->final = (int16) code; - node->son0 = -1; - node->son1 = -1; - node->brother = -1; - - node++; - - } - - } - -/******************************************************************************/ - -void dng_lzw_compressor::AddTable (int32 w, int32 k) - { - - DNG_ASSERT ((w >= 0) && (w <= kTableSize), - "Bad w value in dng_lzw_compressor::AddTable"); - - LZWCompressorNode *node = &fTable [w]; - - int32 nextCode = fNextCode; - - DNG_ASSERT ((nextCode >= 0) && (nextCode <= kTableSize), - "Bad fNextCode value in dng_lzw_compressor::AddTable"); - - LZWCompressorNode *node2 = &fTable [nextCode]; - - fNextCode++; - - int32 oldSon; - - if( k&1 ) - { - oldSon = node->son1; - node->son1 = (int16) nextCode; - } - else - { - oldSon = node->son0; - node->son0 = (int16) nextCode; - } - - node2->final = (int16) k; - node2->son0 = -1; - node2->son1 = -1; - node2->brother = (int16) oldSon; - - if (nextCode == (1 << fCodeSize) - 1) - { - if (fCodeSize != 12) - fCodeSize++; - } - - } - -/******************************************************************************/ - -void dng_lzw_compressor::PutCodeWord (int32 code) - { - - int32 bit = (int32) (fBitOffset & 7); - - int32 offset1 = fBitOffset >> 3; - int32 offset2 = (fBitOffset + fCodeSize - 1) >> 3; - - int32 shift1 = (fCodeSize + bit) - 8; - int32 shift2 = (fCodeSize + bit) - 16; - - uint8 byte1 = (uint8) (code >> shift1); - - uint8 *dstPtr1 = fDstPtr + offset1; - uint8 *dstPtr3 = fDstPtr + offset2; - - if (offset1 + 1 == offset2) - { - - uint8 byte2 = (uint8) (code << (-shift2)); - - if (bit) - *dstPtr1 |= byte1; - else - *dstPtr1 = byte1; - - *dstPtr3 = byte2; - - } - - else - { - - int32 shift3 = (fCodeSize + bit) - 24; - - uint8 byte2 = (uint8) (code >> shift2); - uint8 byte3 = (uint8) (code << (-shift3)); - - uint8 *dstPtr2 = fDstPtr + (offset1 + 1); - - if (bit) - *dstPtr1 |= byte1; - else - *dstPtr1 = byte1; - - *dstPtr2 = byte2; - - *dstPtr3 = byte3; - - } - - fBitOffset += fCodeSize; - - } - -/******************************************************************************/ - -void dng_lzw_compressor::Compress (const uint8 *sPtr, - uint8 *dPtr, - uint32 sCount, - uint32 &dCount) - { - - fDstPtr = dPtr; - - fBitOffset = 0; - - InitTable (); - - PutCodeWord (kResetCode); - - int32 code = -1; - - int32 pixel; - - if (sCount > 0) - { - - pixel = *sPtr; - sPtr = sPtr + 1; - code = pixel; - - sCount--; - - while (sCount--) - { - - pixel = *sPtr; - sPtr = sPtr + 1; - - int32 newCode = SearchTable (code, pixel); - - if (newCode == -1) - { - - PutCodeWord (code); - - if (fNextCode < 4093) - { - AddTable (code, pixel); - } - else - { - PutCodeWord (kResetCode); - InitTable (); - } - - code = pixel; - - } - - else - code = newCode; - - } - - } - - if (code != -1) - { - PutCodeWord (code); - AddTable (code, 0); - } - - PutCodeWord (kEndCode); - - dCount = (fBitOffset + 7) >> 3; - - } - -/*****************************************************************************/ - -#if qDNGUseLibJPEG - -/*****************************************************************************/ - -static void dng_error_exit (j_common_ptr cinfo) - { - - // Output message. - - (*cinfo->err->output_message) (cinfo); - - // Convert to a dng_exception. - - switch (cinfo->err->msg_code) - { - - case JERR_OUT_OF_MEMORY: - { - ThrowMemoryFull (); - break; - } - - default: - { - ThrowBadFormat (); - } - - } - - } - -/*****************************************************************************/ - -static void dng_output_message (j_common_ptr cinfo) - { - - // Format message to string. - - char buffer [JMSG_LENGTH_MAX]; - - (*cinfo->err->format_message) (cinfo, buffer); - - // Report the libjpeg message as a warning. - - ReportWarning ("libjpeg", buffer); - - } - -/*****************************************************************************/ - -struct dng_jpeg_stream_dest - { - - struct jpeg_destination_mgr pub; - - dng_stream *fStream; - - uint8 fBuffer [4096]; - - }; - -/*****************************************************************************/ - -static void dng_init_destination (j_compress_ptr cinfo) - { - - dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest; - - dest->pub.next_output_byte = dest->fBuffer; - dest->pub.free_in_buffer = sizeof (dest->fBuffer); - - } - -/*****************************************************************************/ - -static boolean dng_empty_output_buffer (j_compress_ptr cinfo) - { - - dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest; - - dest->fStream->Put (dest->fBuffer, sizeof (dest->fBuffer)); - - dest->pub.next_output_byte = dest->fBuffer; - dest->pub.free_in_buffer = sizeof (dest->fBuffer); - - return TRUE; - - } - -/*****************************************************************************/ - -static void dng_term_destination (j_compress_ptr cinfo) - { - - dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest; - - uint32 datacount = sizeof (dest->fBuffer) - - (uint32) dest->pub.free_in_buffer; - - if (datacount) - { - dest->fStream->Put (dest->fBuffer, datacount); - } - - } - -/*****************************************************************************/ - -static void jpeg_set_adobe_quality (struct jpeg_compress_struct *cinfo, - int32 quality) - { - - // If out of range, map to default. - - if (quality < 0 || quality > 12) - { - quality = 10; - } - - // Adobe turns off chroma downsampling at high quality levels. - - bool useChromaDownsampling = (quality <= 6); - - // Approximate mapping from Adobe quality levels to LibJPEG levels. - - const int kLibJPEGQuality [13] = - { - 5, 11, 23, 34, 46, 63, 76, 77, 86, 90, 94, 97, 99 - }; - - quality = kLibJPEGQuality [quality]; - - jpeg_set_quality (cinfo, quality, TRUE); - - // LibJPEG defaults to always using chroma downsampling. Turn if off - // if we need it off to match Adobe. - - if (!useChromaDownsampling) - { - - cinfo->comp_info [0].h_samp_factor = 1; - cinfo->comp_info [0].h_samp_factor = 1; - - } - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -void dng_image_writer::WriteData (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_pixel_buffer &buffer, - AutoPtr &compressedBuffer) - { - - switch (ifd.fCompression) - { - - case ccUncompressed: - { - - // Special case support for when we save to 8-bits from - // 16-bit data. - - if (ifd.fBitsPerSample [0] == 8 && buffer.fPixelType == ttShort) - { - - uint32 count = buffer.fRowStep * - buffer.fArea.H (); - - const uint16 *sPtr = (const uint16 *) buffer.fData; - - for (uint32 j = 0; j < count; j++) - { - - stream.Put_uint8 ((uint8) sPtr [j]); - - } - - } - - else - { - - // Swap bytes if required. - - if (stream.SwapBytes ()) - { - - ByteSwapBuffer (host, buffer); - - } - - // Write the bytes. - - stream.Put (buffer.fData, buffer.fRowStep * - buffer.fArea.H () * - buffer.fPixelSize); - - } - - break; - - } - - case ccLZW: - case ccDeflate: - { - - // Both these compression algorithms are byte based. The floating - // point predictor already does byte ordering, so don't ever swap - // when using it. - - if (stream.SwapBytes () && ifd.fPredictor != cpFloatingPoint) - { - - ByteSwapBuffer (host, - buffer); - - } - - // Run the compression algorithm. - - uint32 sBytes = buffer.fRowStep * - buffer.fArea.H () * - buffer.fPixelSize; - - uint8 *sBuffer = (uint8 *) buffer.fData; - - uint32 dBytes = 0; - - uint8 *dBuffer = compressedBuffer->Buffer_uint8 (); - - if (ifd.fCompression == ccLZW) - { - - dng_lzw_compressor lzwCompressor; - - lzwCompressor.Compress (sBuffer, - dBuffer, - sBytes, - dBytes); - - } - - else - { - - uLongf dCount = compressedBuffer->LogicalSize (); - - int32 level = Z_DEFAULT_COMPRESSION; - - if (ifd.fCompressionQuality >= Z_BEST_SPEED && - ifd.fCompressionQuality <= Z_BEST_COMPRESSION) - { - - level = ifd.fCompressionQuality; - - } - - int zResult = ::compress2 (dBuffer, - &dCount, - sBuffer, - sBytes, - level); - - if (zResult != Z_OK) - { - - ThrowMemoryFull (); - - } - - dBytes = (uint32) dCount; - - } - - if (dBytes > compressedBuffer->LogicalSize ()) - { - - DNG_REPORT ("Compression output buffer overflow"); - - ThrowProgramError (); - - } - - stream.Put (dBuffer, dBytes); - - return; - - } - - case ccJPEG: - { - - dng_pixel_buffer temp (buffer); - - if (buffer.fPixelType == ttByte) - { - - // The lossless JPEG encoder needs 16-bit data, so if we are - // are saving 8 bit data, we need to pad it out to 16-bits. - - temp.fData = compressedBuffer->Buffer (); - - temp.fPixelType = ttShort; - temp.fPixelSize = 2; - - temp.CopyArea (buffer, - buffer.fArea, - buffer.fPlane, - buffer.fPlanes); - - } - - EncodeLosslessJPEG ((const uint16 *) temp.fData, - temp.fArea.H (), - temp.fArea.W (), - temp.fPlanes, - ifd.fBitsPerSample [0], - temp.fRowStep, - temp.fColStep, - stream); - - break; - - } - - #if qDNGUseLibJPEG - - case ccLossyJPEG: - { - - struct jpeg_compress_struct cinfo; - - // Setup the error manager. - - struct jpeg_error_mgr jerr; - - cinfo.err = jpeg_std_error (&jerr); - - jerr.error_exit = dng_error_exit; - jerr.output_message = dng_output_message; - - try - { - - // Create the compression context. - - jpeg_create_compress (&cinfo); - - // Setup the destination manager to write to stream. - - dng_jpeg_stream_dest dest; - - dest.fStream = &stream; - - dest.pub.init_destination = dng_init_destination; - dest.pub.empty_output_buffer = dng_empty_output_buffer; - dest.pub.term_destination = dng_term_destination; - - cinfo.dest = &dest.pub; - - // Setup basic image info. - - cinfo.image_width = buffer.fArea.W (); - cinfo.image_height = buffer.fArea.H (); - cinfo.input_components = buffer.fPlanes; - - switch (buffer.fPlanes) - { - - case 1: - cinfo.in_color_space = JCS_GRAYSCALE; - break; - - case 3: - cinfo.in_color_space = JCS_RGB; - break; - - case 4: - cinfo.in_color_space = JCS_CMYK; - break; - - default: - ThrowProgramError (); - - } - - // Setup the compression parameters. - - jpeg_set_defaults (&cinfo); - - jpeg_set_adobe_quality (&cinfo, ifd.fCompressionQuality); - - // Write the JPEG header. - - jpeg_start_compress (&cinfo, TRUE); - - // Write the scanlines. - - for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++) - { - - uint8 *sampArray [1]; - - sampArray [0] = buffer.DirtyPixel_uint8 (row, - buffer.fArea.l, - 0); - - jpeg_write_scanlines (&cinfo, sampArray, 1); - - } - - // Cleanup. - - jpeg_finish_compress (&cinfo); - - jpeg_destroy_compress (&cinfo); - - } - - catch (...) - { - - jpeg_destroy_compress (&cinfo); - - throw; - - } - - return; - - } - - #endif - - default: - { - - ThrowProgramError (); - - } - - } - - } - -/******************************************************************************/ - -void dng_image_writer::EncodeJPEGPreview (dng_host &host, - const dng_image &image, - dng_jpeg_preview &preview, - int32 quality) - { - - #if qDNGUseLibJPEG - - dng_memory_stream stream (host.Allocator ()); - - struct jpeg_compress_struct cinfo; - - // Setup the error manager. - - struct jpeg_error_mgr jerr; - - cinfo.err = jpeg_std_error (&jerr); - - jerr.error_exit = dng_error_exit; - jerr.output_message = dng_output_message; - - try - { - - // Create the compression context. - - jpeg_create_compress (&cinfo); - - // Setup the destination manager to write to stream. - - dng_jpeg_stream_dest dest; - - dest.fStream = &stream; - - dest.pub.init_destination = dng_init_destination; - dest.pub.empty_output_buffer = dng_empty_output_buffer; - dest.pub.term_destination = dng_term_destination; - - cinfo.dest = &dest.pub; - - // Setup basic image info. - - cinfo.image_width = image.Bounds ().W (); - cinfo.image_height = image.Bounds ().H (); - cinfo.input_components = image.Planes (); - - switch (image.Planes ()) - { - - case 1: - cinfo.in_color_space = JCS_GRAYSCALE; - break; - - case 3: - cinfo.in_color_space = JCS_RGB; - break; - - default: - ThrowProgramError (); - - } - - // Setup the compression parameters. - - jpeg_set_defaults (&cinfo); - - jpeg_set_adobe_quality (&cinfo, quality); - - // Find some preview information based on the compression settings. - - preview.fPreviewSize = image.Size (); - - if (image.Planes () == 1) - { - - preview.fPhotometricInterpretation = piBlackIsZero; - - } - - else - { - - preview.fPhotometricInterpretation = piYCbCr; - - preview.fYCbCrSubSampling.h = cinfo.comp_info [0].h_samp_factor; - preview.fYCbCrSubSampling.v = cinfo.comp_info [0].v_samp_factor; - - } - - // Write the JPEG header. - - jpeg_start_compress (&cinfo, TRUE); - - // Write the scanlines. - - dng_pixel_buffer buffer; - - buffer.fArea = image.Bounds (); - buffer.fPlanes = image.Planes (); - - buffer.fColStep = buffer.fPlanes; - buffer.fRowStep = buffer.fColStep * buffer.fArea.W (); - - buffer.fPixelType = ttByte; - buffer.fPixelSize = 1; - - AutoPtr bufferData (host.Allocate (buffer.fRowStep)); - - buffer.fData = bufferData->Buffer (); - - for (uint32 row = 0; row < cinfo.image_height; row++) - { - - buffer.fArea.t = row; - buffer.fArea.b = row + 1; - - image.Get (buffer); - - uint8 *sampArray [1]; - - sampArray [0] = buffer.DirtyPixel_uint8 (row, - buffer.fArea.l, - 0); - - jpeg_write_scanlines (&cinfo, sampArray, 1); - - } - - // Cleanup. - - jpeg_finish_compress (&cinfo); - - jpeg_destroy_compress (&cinfo); - - } - - catch (...) - { - - jpeg_destroy_compress (&cinfo); - - throw; - - } - - preview.fCompressedData.Reset (stream.AsMemoryBlock (host.Allocator ())); - - #else - - (void) host; - (void) image; - (void) preview; - (void) quality; - - ThrowProgramError ("No JPEG encoder"); - - #endif - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteTile (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - const dng_image &image, - const dng_rect &tileArea, - uint32 fakeChannels, - AutoPtr &compressedBuffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer, - AutoPtr &tempBuffer) - { - - // Create pixel buffer to hold uncompressed tile. - - dng_pixel_buffer buffer; - - buffer.fArea = tileArea; - - buffer.fPlane = 0; - buffer.fPlanes = ifd.fSamplesPerPixel; - - buffer.fRowStep = buffer.fPlanes * tileArea.W (); - buffer.fColStep = buffer.fPlanes; - buffer.fPlaneStep = 1; - - buffer.fPixelType = image.PixelType (); - buffer.fPixelSize = image.PixelSize (); - - buffer.fData = uncompressedBuffer->Buffer (); - - // Get the uncompressed data. - - image.Get (buffer, dng_image::edge_zero); - - // Deal with sub-tile blocks. - - if (ifd.fSubTileBlockRows > 1) - { - - ReorderSubTileBlocks (ifd, - buffer, - uncompressedBuffer, - subTileBlockBuffer); - - } - - // Floating point depth conversion. - - if (ifd.fSampleFormat [0] == sfFloatingPoint) - { - - if (ifd.fBitsPerSample [0] == 16) - { - - uint32 *srcPtr = (uint32 *) buffer.fData; - uint16 *dstPtr = (uint16 *) buffer.fData; - - uint32 pixels = tileArea.W () * tileArea.H () * buffer.fPlanes; - - for (uint32 j = 0; j < pixels; j++) - { - - dstPtr [j] = DNG_FloatToHalf (srcPtr [j]); - - } - - buffer.fPixelSize = 2; - - } - - if (ifd.fBitsPerSample [0] == 24) - { - - uint32 *srcPtr = (uint32 *) buffer.fData; - uint8 *dstPtr = (uint8 *) buffer.fData; - - uint32 pixels = tileArea.W () * tileArea.H () * buffer.fPlanes; - - if (stream.BigEndian () || ifd.fPredictor == cpFloatingPoint || - ifd.fPredictor == cpFloatingPointX2 || - ifd.fPredictor == cpFloatingPointX4) - { - - for (uint32 j = 0; j < pixels; j++) - { - - DNG_FloatToFP24 (srcPtr [j], dstPtr); - - dstPtr += 3; - - } - - } - - else - { - - for (uint32 j = 0; j < pixels; j++) - { - - uint8 output [3]; - - DNG_FloatToFP24 (srcPtr [j], output); - - dstPtr [0] = output [2]; - dstPtr [1] = output [1]; - dstPtr [2] = output [0]; - - dstPtr += 3; - - } - - } - - buffer.fPixelSize = 3; - - } - - } - - // Run predictor. - - EncodePredictor (host, - ifd, - buffer, - tempBuffer); - - // Adjust pixel buffer for fake channels. - - if (fakeChannels > 1) - { - - buffer.fPlanes *= fakeChannels; - buffer.fColStep *= fakeChannels; - - buffer.fArea.r = buffer.fArea.l + (buffer.fArea.W () / fakeChannels); - - } - - // Compress (if required) and write out the data. - - WriteData (host, - ifd, - stream, - buffer, - compressedBuffer); - - } - -/*****************************************************************************/ - -class dng_write_tiles_task : public dng_area_task - { - - private: - - dng_image_writer &fImageWriter; - - dng_host &fHost; - - const dng_ifd &fIFD; - - dng_basic_tag_set &fBasic; - - dng_stream &fStream; - - const dng_image &fImage; - - uint32 fFakeChannels; - - uint32 fTilesDown; - - uint32 fTilesAcross; - - uint32 fCompressedSize; - - uint32 fUncompressedSize; - - dng_mutex fMutex1; - - uint32 fNextTileIndex; - - dng_mutex fMutex2; - - dng_condition fCondition; - - bool fTaskFailed; - - uint32 fWriteTileIndex; - - public: - - dng_write_tiles_task (dng_image_writer &imageWriter, - dng_host &host, - const dng_ifd &ifd, - dng_basic_tag_set &basic, - dng_stream &stream, - const dng_image &image, - uint32 fakeChannels, - uint32 tilesDown, - uint32 tilesAcross, - uint32 compressedSize, - uint32 uncompressedSize) - - : fImageWriter (imageWriter) - , fHost (host) - , fIFD (ifd) - , fBasic (basic) - , fStream (stream) - , fImage (image) - , fFakeChannels (fakeChannels) - , fTilesDown (tilesDown) - , fTilesAcross (tilesAcross) - , fCompressedSize (compressedSize) - , fUncompressedSize (uncompressedSize) - , fMutex1 ("dng_write_tiles_task_1") - , fNextTileIndex (0) - , fMutex2 ("dng_write_tiles_task_2") - , fCondition () - , fTaskFailed (false) - , fWriteTileIndex (0) - - { - - fMinTaskArea = 16 * 16; - fUnitCell = dng_point (16, 16); - fMaxTileSize = dng_point (16, 16); - - } - - void Process (uint32 /* threadIndex */, - const dng_rect & /* tile */, - dng_abort_sniffer *sniffer) - { - - try - { - - AutoPtr compressedBuffer; - AutoPtr uncompressedBuffer; - AutoPtr subTileBlockBuffer; - AutoPtr tempBuffer; - - if (fCompressedSize) - { - compressedBuffer.Reset (fHost.Allocate (fCompressedSize)); - } - - if (fUncompressedSize) - { - uncompressedBuffer.Reset (fHost.Allocate (fUncompressedSize)); - } - - if (fIFD.fSubTileBlockRows > 1 && fUncompressedSize) - { - subTileBlockBuffer.Reset (fHost.Allocate (fUncompressedSize)); - } - - while (true) - { - - // Find tile index to compress. - - uint32 tileIndex; - - { - - dng_lock_mutex lock (&fMutex1); - - if (fNextTileIndex == fTilesDown * fTilesAcross) - { - return; - } - - tileIndex = fNextTileIndex++; - - } - - dng_abort_sniffer::SniffForAbort (sniffer); - - // Compress tile. - - uint32 rowIndex = tileIndex / fTilesAcross; - - uint32 colIndex = tileIndex - rowIndex * fTilesAcross; - - dng_rect tileArea = fIFD.TileArea (rowIndex, colIndex); - - dng_memory_stream tileStream (fHost.Allocator ()); - - tileStream.SetLittleEndian (fStream.LittleEndian ()); - - dng_host host (&fHost.Allocator (), - sniffer); - - fImageWriter.WriteTile (host, - fIFD, - tileStream, - fImage, - tileArea, - fFakeChannels, - compressedBuffer, - uncompressedBuffer, - subTileBlockBuffer, - tempBuffer); - - tileStream.Flush (); - - uint32 tileByteCount = (uint32) tileStream.Length (); - - tileStream.SetReadPosition (0); - - // Wait until it is our turn to write tile. - - { - - dng_lock_mutex lock (&fMutex2); - - while (!fTaskFailed && - fWriteTileIndex != tileIndex) - { - - fCondition.Wait (fMutex2); - - } - - // If the task failed in another thread, that thread already threw an exception. - - if (fTaskFailed) - return; - - } - - dng_abort_sniffer::SniffForAbort (sniffer); - - // Remember this offset. - - uint32 tileOffset = (uint32) fStream.Position (); - - fBasic.SetTileOffset (tileIndex, tileOffset); - - // Copy tile stream for tile into main stream. - - tileStream.CopyToStream (fStream, tileByteCount); - - // Update tile count. - - fBasic.SetTileByteCount (tileIndex, tileByteCount); - - // Keep the tiles on even byte offsets. - - if (tileByteCount & 1) - { - fStream.Put_uint8 (0); - } - - // Let other threads know it is safe to write to stream. - - { - - dng_lock_mutex lock (&fMutex2); - - // If the task failed in another thread, that thread already threw an exception. - - if (fTaskFailed) - return; - - fWriteTileIndex++; - - fCondition.Broadcast (); - - } - - } - - } - - catch (...) - { - - // If first to fail, wake up any threads waiting on condition. - - bool needBroadcast = false; - - { - - dng_lock_mutex lock (&fMutex2); - - needBroadcast = !fTaskFailed; - fTaskFailed = true; - - } - - if (needBroadcast) - fCondition.Broadcast (); - - throw; - - } - - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_write_tiles_task (const dng_write_tiles_task &); - - dng_write_tiles_task & operator= (const dng_write_tiles_task &); - - }; - -/*****************************************************************************/ - -void dng_image_writer::WriteImage (dng_host &host, - const dng_ifd &ifd, - dng_basic_tag_set &basic, - dng_stream &stream, - const dng_image &image, - uint32 fakeChannels) - { - - // Deal with row interleaved images. - - if (ifd.fRowInterleaveFactor > 1 && - ifd.fRowInterleaveFactor < ifd.fImageLength) - { - - dng_ifd tempIFD (ifd); - - tempIFD.fRowInterleaveFactor = 1; - - dng_row_interleaved_image tempImage (*((dng_image *) &image), - ifd.fRowInterleaveFactor); - - WriteImage (host, - tempIFD, - basic, - stream, - tempImage, - fakeChannels); - - return; - - } - - // Compute basic information. - - uint32 bytesPerSample = TagTypeSize (image.PixelType ()); - - uint32 bytesPerPixel = ifd.fSamplesPerPixel * bytesPerSample; - - uint32 tileRowBytes = ifd.fTileWidth * bytesPerPixel; - - // If we can compute the number of bytes needed to store the - // data, we can split the write for each tile into sub-tiles. - - uint32 subTileLength = ifd.fTileLength; - - if (ifd.TileByteCount (ifd.TileArea (0, 0)) != 0) - { - - subTileLength = Pin_uint32 (ifd.fSubTileBlockRows, - kImageBufferSize / tileRowBytes, - ifd.fTileLength); - - // Don't split sub-tiles across subTileBlocks. - - subTileLength = subTileLength / ifd.fSubTileBlockRows - * ifd.fSubTileBlockRows; - - } - - // Find size of uncompressed buffer. - - uint32 uncompressedSize = subTileLength * tileRowBytes; - - // Find size of compressed buffer, if required. - - uint32 compressedSize = CompressedBufferSize (ifd, uncompressedSize); - - // See if we can do this write using multiple threads. - - uint32 tilesAcross = ifd.TilesAcross (); - uint32 tilesDown = ifd.TilesDown (); - - bool useMultipleThreads = (tilesDown * tilesAcross >= 2) && - (host.PerformAreaTaskThreads () > 1) && - (subTileLength == ifd.fTileLength) && - (ifd.fCompression != ccUncompressed); - - -#if qImagecore - useMultipleThreads = false; -#endif - - if (useMultipleThreads) - { - - uint32 threadCount = Min_uint32 (tilesDown * tilesAcross, - host.PerformAreaTaskThreads ()); - - dng_write_tiles_task task (*this, - host, - ifd, - basic, - stream, - image, - fakeChannels, - tilesDown, - tilesAcross, - compressedSize, - uncompressedSize); - - host.PerformAreaTask (task, - dng_rect (0, 0, 16, 16 * threadCount)); - - } - - else - { - - AutoPtr compressedBuffer; - AutoPtr uncompressedBuffer; - AutoPtr subTileBlockBuffer; - AutoPtr tempBuffer; - - if (compressedSize) - { - compressedBuffer.Reset (host.Allocate (compressedSize)); - } - - if (uncompressedSize) - { - uncompressedBuffer.Reset (host.Allocate (uncompressedSize)); - } - - if (ifd.fSubTileBlockRows > 1 && uncompressedSize) - { - subTileBlockBuffer.Reset (host.Allocate (uncompressedSize)); - } - - // Write out each tile. - - uint32 tileIndex = 0; - - for (uint32 rowIndex = 0; rowIndex < tilesDown; rowIndex++) - { - - for (uint32 colIndex = 0; colIndex < tilesAcross; colIndex++) - { - - // Remember this offset. - - uint32 tileOffset = (uint32) stream.Position (); - - basic.SetTileOffset (tileIndex, tileOffset); - - // Split tile into sub-tiles if possible. - - dng_rect tileArea = ifd.TileArea (rowIndex, colIndex); - - uint32 subTileCount = (tileArea.H () + subTileLength - 1) / - subTileLength; - - for (uint32 subIndex = 0; subIndex < subTileCount; subIndex++) - { - - host.SniffForAbort (); - - dng_rect subArea (tileArea); - - subArea.t = tileArea.t + subIndex * subTileLength; - - subArea.b = Min_int32 (subArea.t + subTileLength, - tileArea.b); - - // Write the sub-tile. - - WriteTile (host, - ifd, - stream, - image, - subArea, - fakeChannels, - compressedBuffer, - uncompressedBuffer, - subTileBlockBuffer, - tempBuffer); - - } - - // Update tile count. - - uint32 tileByteCount = (uint32) stream.Position () - tileOffset; - - basic.SetTileByteCount (tileIndex, tileByteCount); - - tileIndex++; - - // Keep the tiles on even byte offsets. - - if (tileByteCount & 1) - { - stream.Put_uint8 (0); - } - - } - - } - - } - - } - -/*****************************************************************************/ - -static void CopyString (const dng_xmp &oldXMP, - dng_xmp &newXMP, - const char *ns, - const char *path, - dng_string *exif = NULL) - { - - dng_string s; - - if (oldXMP.GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - newXMP.SetString (ns, path, s); - - if (exif) - { - - *exif = s; - - } - - } - - } - - } - -/*****************************************************************************/ - -static void CopyStringList (const dng_xmp &oldXMP, - dng_xmp &newXMP, - const char *ns, - const char *path, - bool isBag) - { - - dng_string_list list; - - if (oldXMP.GetStringList (ns, path, list)) - { - - if (list.Count ()) - { - - newXMP.SetStringList (ns, path, list, isBag); - - } - - } - - } - -/*****************************************************************************/ - -static void CopyAltLangDefault (const dng_xmp &oldXMP, - dng_xmp &newXMP, - const char *ns, - const char *path, - dng_string *exif = NULL) - { - - dng_string s; - - if (oldXMP.GetAltLangDefault (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - newXMP.SetAltLangDefault (ns, path, s); - - if (exif) - { - - *exif = s; - - } - - } - - } - - } - -/*****************************************************************************/ - -static void CopyStructField (const dng_xmp &oldXMP, - dng_xmp &newXMP, - const char *ns, - const char *path, - const char *field) - { - - dng_string s; - - if (oldXMP.GetStructField (ns, path, ns, field, s)) - { - - if (s.NotEmpty ()) - { - - newXMP.SetStructField (ns, path, ns, field, s); - - } - - } - - } - -/*****************************************************************************/ - -static void CopyBoolean (const dng_xmp &oldXMP, - dng_xmp &newXMP, - const char *ns, - const char *path) - { - - bool b; - - if (oldXMP.GetBoolean (ns, path, b)) - { - - newXMP.SetBoolean (ns, path, b); - - } - - } - -/*****************************************************************************/ - -void dng_image_writer::CleanUpMetadata (dng_host &host, - dng_metadata &metadata, - dng_metadata_subset metadataSubset, - const char *dstMIMI, - const char *software) - { - - if (metadata.GetXMP () && metadata.GetExif ()) - { - - dng_xmp &newXMP (*metadata.GetXMP ()); - dng_exif &newEXIF (*metadata.GetExif ()); - - // Update software tag. - - if (software) - { - - newEXIF.fSoftware.Set (software); - - newXMP.Set (XMP_NS_XAP, - "CreatorTool", - software); - - } - - #if qDNGXMPDocOps - - newXMP.DocOpsPrepareForSave (metadata.SourceMIMI ().Get (), - dstMIMI); - - #else - - metadata.UpdateDateTimeToNow (); - - #endif - - // Update EXIF version to at least 2.3 so all the exif tags - // can be written. - - if (newEXIF.fExifVersion < DNG_CHAR4 ('0','2','3','0')) - { - - newEXIF.fExifVersion = DNG_CHAR4 ('0','2','3','0'); - - newXMP.Set (XMP_NS_EXIF, "ExifVersion", "0230"); - - } - - // Resync EXIF, remove EXIF tags from XMP. - - newXMP.SyncExif (newEXIF, - metadata.GetOriginalExif (), - false, - true); - - // Deal with ImageIngesterPro bug. This program is adding lots of - // empty metadata strings into the XMP, which is screwing up Adobe CS4. - // We are saving a new file, so this is a chance to clean up this mess. - - newXMP.RemoveEmptyStringsAndArrays (XMP_NS_DC); - newXMP.RemoveEmptyStringsAndArrays (XMP_NS_XAP); - newXMP.RemoveEmptyStringsAndArrays (XMP_NS_PHOTOSHOP); - newXMP.RemoveEmptyStringsAndArrays (XMP_NS_IPTC); - newXMP.RemoveEmptyStringsAndArrays (XMP_NS_XAP_RIGHTS); - newXMP.RemoveEmptyStringsAndArrays ("http://ns.iview-multimedia.com/mediapro/1.0/"); - - // Process metadata subset. - - if (metadataSubset == kMetadataSubset_CopyrightOnly || - metadataSubset == kMetadataSubset_CopyrightAndContact) - { - - dng_xmp oldXMP (newXMP ); - dng_exif oldEXIF (newEXIF); - - // For these options, we start from nothing, and only fill in the - // fields that we absolutely need. - - newXMP.RemoveProperties (NULL); - - newEXIF.SetEmpty (); - - metadata.ClearMakerNote (); - - // Move copyright related fields over. - - CopyAltLangDefault (oldXMP, - newXMP, - XMP_NS_DC, - "rights", - &newEXIF.fCopyright); - - CopyAltLangDefault (oldXMP, - newXMP, - XMP_NS_XAP_RIGHTS, - "UsageTerms"); - - CopyString (oldXMP, - newXMP, - XMP_NS_XAP_RIGHTS, - "WebStatement"); - - CopyBoolean (oldXMP, - newXMP, - XMP_NS_XAP_RIGHTS, - "Marked"); - - #if qDNGXMPDocOps - - // Include basic DocOps fields, but not the full history. - - CopyString (oldXMP, - newXMP, - XMP_NS_MM, - "OriginalDocumentID"); - - CopyString (oldXMP, - newXMP, - XMP_NS_MM, - "DocumentID"); - - CopyString (oldXMP, - newXMP, - XMP_NS_MM, - "InstanceID"); - - CopyString (oldXMP, - newXMP, - XMP_NS_XAP, - "MetadataDate"); - - #endif - - // Copyright and Contact adds the contact info fields. - - if (metadataSubset == kMetadataSubset_CopyrightAndContact) - { - - // Note: Save for Web is not including the dc:creator list, but it - // is part of the IPTC contract info metadata panel, so I - // think it should be copied as part of the contact info. - - CopyStringList (oldXMP, - newXMP, - XMP_NS_DC, - "creator", - false); - - // The first string dc:creator list is mirrored to the - // the exif artist tag, so copy that also. - - newEXIF.fArtist = oldEXIF.fArtist; - - // Copy other contact fields. - - CopyString (oldXMP, - newXMP, - XMP_NS_PHOTOSHOP, - "AuthorsPosition"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiEmailWork"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiAdrExtadr"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiAdrCity"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiAdrRegion"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiAdrPcode"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiAdrCtry"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiTelWork"); - - CopyStructField (oldXMP, - newXMP, - XMP_NS_IPTC, - "CreatorContactInfo", - "CiUrlWork"); - - CopyAltLangDefault (oldXMP, - newXMP, - XMP_NS_DC, - "title"); - - } - - } - - else if (metadataSubset == kMetadataSubset_AllExceptCameraInfo || - metadataSubset == kMetadataSubset_AllExceptCameraAndLocation || - metadataSubset == kMetadataSubset_AllExceptLocationInfo) - { - - dng_xmp oldXMP (newXMP ); - dng_exif oldEXIF (newEXIF); - - if (metadataSubset == kMetadataSubset_AllExceptCameraInfo || - metadataSubset == kMetadataSubset_AllExceptCameraAndLocation) - { - - // This removes most of the EXIF info, so just copy the fields - // we are not deleting. - - newEXIF.SetEmpty (); - - newEXIF.fImageDescription = oldEXIF.fImageDescription; // Note: Differs from SFW - newEXIF.fSoftware = oldEXIF.fSoftware; - newEXIF.fArtist = oldEXIF.fArtist; - newEXIF.fCopyright = oldEXIF.fCopyright; - newEXIF.fCopyright2 = oldEXIF.fCopyright2; - newEXIF.fDateTime = oldEXIF.fDateTime; - newEXIF.fDateTimeOriginal = oldEXIF.fDateTimeOriginal; - newEXIF.fDateTimeDigitized = oldEXIF.fDateTimeDigitized; - newEXIF.fExifVersion = oldEXIF.fExifVersion; - newEXIF.fImageUniqueID = oldEXIF.fImageUniqueID; - - newEXIF.CopyGPSFrom (oldEXIF); - - // Remove exif info from XMP. - - newXMP.RemoveProperties (XMP_NS_EXIF); - newXMP.RemoveProperties (XMP_NS_AUX); - - // Remove Camera Raw info - - newXMP.RemoveProperties (XMP_NS_CRS); - newXMP.RemoveProperties (XMP_NS_CRSS); - newXMP.RemoveProperties (XMP_NS_CRX); - - // Remove DocOps history, since it contains the original - // camera format. - - newXMP.Remove (XMP_NS_MM, "History"); - - // MakerNote contains camera info. - - metadata.ClearMakerNote (); - - } - - if (metadataSubset == kMetadataSubset_AllExceptLocationInfo || - metadataSubset == kMetadataSubset_AllExceptCameraAndLocation) - { - - // Remove GPS fields. - - dng_exif blankExif; - - newEXIF.CopyGPSFrom (blankExif); - - // Remove MakerNote just in case, because we don't know - // all of what is in it. - - metadata.ClearMakerNote (); - - // Remove XMP & IPTC location fields. - - newXMP.Remove (XMP_NS_PHOTOSHOP, "City"); - newXMP.Remove (XMP_NS_PHOTOSHOP, "State"); - newXMP.Remove (XMP_NS_PHOTOSHOP, "Country"); - newXMP.Remove (XMP_NS_IPTC, "Location"); - newXMP.Remove (XMP_NS_IPTC, "CountryCode"); - newXMP.Remove (XMP_NS_IPTC_EXT, "LocationCreated"); - newXMP.Remove (XMP_NS_IPTC_EXT, "LocationShown"); - - } - - } - - // Rebuild the legacy IPTC block, if needed. - - bool isTIFF = (strcmp (dstMIMI, "image/tiff") == 0); - bool isDNG = (strcmp (dstMIMI, "image/dng" ) == 0); - - if (!isDNG) - { - - metadata.RebuildIPTC (host.Allocator (), - isTIFF); - - } - - else - { - - metadata.ClearIPTC (); - - } - - // Clear format related XMP. - - newXMP.ClearOrientation (); - - newXMP.ClearImageInfo (); - - newXMP.RemoveProperties (XMP_NS_DNG); - - // All the formats we care about already keep the IPTC digest - // elsewhere, do we don't need to write it to the XMP. - - newXMP.ClearIPTCDigest (); - - // Make sure that sidecar specific tags never get written to files. - - newXMP.Remove (XMP_NS_PHOTOSHOP, "SidecarForExtension"); - newXMP.Remove (XMP_NS_PHOTOSHOP, "EmbeddedXMPDigest"); - - } - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteTIFF (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - dng_negative *negative, - const dng_color_space *space, - const dng_resolution *resolution, - const dng_jpeg_preview *thumbnail, - const dng_memory_block *imageResources, - dng_metadata_subset metadataSubset) - { - - WriteTIFF (host, - stream, - image, - photometricInterpretation, - compression, - negative ? &(negative->Metadata ()) : NULL, - space, - resolution, - thumbnail, - imageResources, - metadataSubset); - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteTIFF (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - const dng_metadata *metadata, - const dng_color_space *space, - const dng_resolution *resolution, - const dng_jpeg_preview *thumbnail, - const dng_memory_block *imageResources, - dng_metadata_subset metadataSubset) - { - - const void *profileData = NULL; - uint32 profileSize = 0; - - const uint8 *data = NULL; - uint32 size = 0; - - if (space && space->ICCProfile (size, data)) - { - - profileData = data; - profileSize = size; - - } - - WriteTIFFWithProfile (host, - stream, - image, - photometricInterpretation, - compression, - metadata, - profileData, - profileSize, - resolution, - thumbnail, - imageResources, - metadataSubset); - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteTIFFWithProfile (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - dng_negative *negative, - const void *profileData, - uint32 profileSize, - const dng_resolution *resolution, - const dng_jpeg_preview *thumbnail, - const dng_memory_block *imageResources, - dng_metadata_subset metadataSubset) - { - - WriteTIFFWithProfile (host, - stream, - image, - photometricInterpretation, - compression, - negative ? &(negative->Metadata ()) : NULL, - profileData, - profileSize, - resolution, - thumbnail, - imageResources, - metadataSubset); - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteTIFFWithProfile (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - const dng_metadata *constMetadata, - const void *profileData, - uint32 profileSize, - const dng_resolution *resolution, - const dng_jpeg_preview *thumbnail, - const dng_memory_block *imageResources, - dng_metadata_subset metadataSubset) - { - - uint32 j; - - AutoPtr metadata; - - if (constMetadata) - { - - metadata.Reset (constMetadata->Clone (host.Allocator ())); - - CleanUpMetadata (host, - *metadata, - metadataSubset, - "image/tiff"); - - } - - dng_ifd ifd; - - ifd.fNewSubFileType = sfMainImage; - - ifd.fImageWidth = image.Bounds ().W (); - ifd.fImageLength = image.Bounds ().H (); - - ifd.fSamplesPerPixel = image.Planes (); - - ifd.fBitsPerSample [0] = TagTypeSize (image.PixelType ()) * 8; - - for (j = 1; j < ifd.fSamplesPerPixel; j++) - { - ifd.fBitsPerSample [j] = ifd.fBitsPerSample [0]; - } - - ifd.fPhotometricInterpretation = photometricInterpretation; - - ifd.fCompression = compression; - - if (ifd.fCompression == ccUncompressed) - { - - ifd.SetSingleStrip (); - - } - - else - { - - ifd.FindStripSize (128 * 1024); - - ifd.fPredictor = cpHorizontalDifference; - - } - - uint32 extraSamples = 0; - - switch (photometricInterpretation) - { - - case piBlackIsZero: - { - extraSamples = image.Planes () - 1; - break; - } - - case piRGB: - { - extraSamples = image.Planes () - 3; - break; - } - - default: - break; - - } - - ifd.fExtraSamplesCount = extraSamples; - - if (image.PixelType () == ttFloat) - { - - for (j = 0; j < ifd.fSamplesPerPixel; j++) - { - ifd.fSampleFormat [j] = sfFloatingPoint; - } - - } - - dng_tiff_directory mainIFD; - - dng_basic_tag_set basic (mainIFD, ifd); - - // Resolution. - - dng_resolution res; - - if (resolution) - { - res = *resolution; - } - - tag_urational tagXResolution (tcXResolution, res.fXResolution); - tag_urational tagYResolution (tcYResolution, res.fYResolution); - - tag_uint16 tagResolutionUnit (tcResolutionUnit, res.fResolutionUnit); - - if (resolution) - { - mainIFD.Add (&tagXResolution ); - mainIFD.Add (&tagYResolution ); - mainIFD.Add (&tagResolutionUnit); - } - - // ICC Profile. - - tag_icc_profile iccProfileTag (profileData, profileSize); - - if (iccProfileTag.Count ()) - { - mainIFD.Add (&iccProfileTag); - } - - // XMP metadata. - - tag_xmp tagXMP (metadata.Get () ? metadata->GetXMP () : NULL); - - if (tagXMP.Count ()) - { - mainIFD.Add (&tagXMP); - } - - // IPTC metadata. - - tag_iptc tagIPTC (metadata.Get () ? metadata->IPTCData () : NULL, - metadata.Get () ? metadata->IPTCLength () : 0); - - if (tagIPTC.Count ()) - { - mainIFD.Add (&tagIPTC); - } - - // Adobe data (thumbnail and IPTC digest) - - AutoPtr adobeData (BuildAdobeData (host, - metadata.Get (), - thumbnail, - imageResources)); - - tag_uint8_ptr tagAdobe (tcAdobeData, - adobeData->Buffer_uint8 (), - adobeData->LogicalSize ()); - - if (tagAdobe.Count ()) - { - mainIFD.Add (&tagAdobe); - } - - // Exif metadata. - - exif_tag_set exifSet (mainIFD, - metadata.Get () && metadata->GetExif () ? *metadata->GetExif () - : dng_exif (), - metadata.Get () ? metadata->IsMakerNoteSafe () : false, - metadata.Get () ? metadata->MakerNoteData () : NULL, - metadata.Get () ? metadata->MakerNoteLength () : 0, - false); - - // Find offset to main image data. - - uint32 offsetMainIFD = 8; - - uint32 offsetExifData = offsetMainIFD + mainIFD.Size (); - - exifSet.Locate (offsetExifData); - - uint32 offsetMainData = offsetExifData + exifSet.Size (); - - stream.SetWritePosition (offsetMainData); - - // Write the main image data. - - WriteImage (host, - ifd, - basic, - stream, - image); - - // Trim the file to this length. - - stream.SetLength (stream.Position ()); - - // TIFF has a 4G size limit. - - if (stream.Length () > 0x0FFFFFFFFL) - { - ThrowImageTooBigTIFF (); - } - - // Write TIFF Header. - - stream.SetWritePosition (0); - - stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII); - - stream.Put_uint16 (42); - - stream.Put_uint32 (offsetMainIFD); - - // Write the IFDs. - - mainIFD.Put (stream); - - exifSet.Put (stream); - - stream.Flush (); - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteDNG (dng_host &host, - dng_stream &stream, - dng_negative &negative, - const dng_preview_list *previewList, - uint32 maxBackwardVersion, - bool uncompressed) - { - - WriteDNG (host, - stream, - negative, - negative.Metadata (), - previewList, - maxBackwardVersion, - uncompressed); - - } - -/*****************************************************************************/ - -void dng_image_writer::WriteDNG (dng_host &host, - dng_stream &stream, - const dng_negative &negative, - const dng_metadata &constMetadata, - const dng_preview_list *previewList, - uint32 maxBackwardVersion, - bool uncompressed) - { - - uint32 j; - - // Clean up metadata per MWG recommendations. - - AutoPtr metadata (constMetadata.Clone (host.Allocator ())); - - CleanUpMetadata (host, - *metadata, - kMetadataSubset_All, - "image/dng"); - - // Figure out the compression to use. Most of the time this is lossless - // JPEG. - - uint32 compression = uncompressed ? ccUncompressed : ccJPEG; - - // Was the the original file lossy JPEG compressed? - - const dng_jpeg_image *rawJPEGImage = negative.RawJPEGImage (); - - // If so, can we save it using the requested compression and DNG version? - - if (uncompressed || maxBackwardVersion < dngVersion_1_4_0_0) - { - - if (rawJPEGImage || negative.RawJPEGImageDigest ().IsValid ()) - { - - rawJPEGImage = NULL; - - negative.ClearRawJPEGImageDigest (); - - negative.ClearRawImageDigest (); - - } - - } - - else if (rawJPEGImage) - { - - compression = ccLossyJPEG; - - } - - // Are we saving the original size tags? - - bool saveOriginalDefaultFinalSize = false; - bool saveOriginalBestQualityFinalSize = false; - bool saveOriginalDefaultCropSize = false; - - { - - // See if we are saving a proxy image. - - dng_point defaultFinalSize (negative.DefaultFinalHeight (), - negative.DefaultFinalWidth ()); - - saveOriginalDefaultFinalSize = (negative.OriginalDefaultFinalSize () != - defaultFinalSize); - - if (saveOriginalDefaultFinalSize) - { - - // If the save OriginalDefaultFinalSize tag, this changes the defaults - // for the OriginalBestQualityFinalSize and OriginalDefaultCropSize tags. - - saveOriginalBestQualityFinalSize = (negative.OriginalBestQualityFinalSize () != - defaultFinalSize); - - saveOriginalDefaultCropSize = (negative.OriginalDefaultCropSizeV () != - dng_urational (defaultFinalSize.v, 1)) || - (negative.OriginalDefaultCropSizeH () != - dng_urational (defaultFinalSize.h, 1)); - - } - - else - { - - // Else these two tags default to the normal non-proxy size image values. - - dng_point bestQualityFinalSize (negative.BestQualityFinalHeight (), - negative.BestQualityFinalWidth ()); - - saveOriginalBestQualityFinalSize = (negative.OriginalBestQualityFinalSize () != - bestQualityFinalSize); - - saveOriginalDefaultCropSize = (negative.OriginalDefaultCropSizeV () != - negative.DefaultCropSizeV ()) || - (negative.OriginalDefaultCropSizeH () != - negative.DefaultCropSizeH ()); - - } - - } - - // Is this a floating point image that we are saving? - - bool isFloatingPoint = (negative.RawImage ().PixelType () == ttFloat); - - // Does this image have a transparency mask? - - bool hasTransparencyMask = (negative.RawTransparencyMask () != NULL); - - // Should we save a compressed 32-bit integer file? - - bool isCompressed32BitInteger = (negative.RawImage ().PixelType () == ttLong) && - (maxBackwardVersion >= dngVersion_1_4_0_0) && - (!uncompressed); - - // Figure out what main version to use. - - uint32 dngVersion = dngVersion_Current; - - // Don't write version 1.4 files unless we actually use some feature of the 1.4 spec. - - if (dngVersion == dngVersion_1_4_0_0) - { - - if (!rawJPEGImage && - !isFloatingPoint && - !hasTransparencyMask && - !isCompressed32BitInteger && - !saveOriginalDefaultFinalSize && - !saveOriginalBestQualityFinalSize && - !saveOriginalDefaultCropSize ) - { - - dngVersion = dngVersion_1_3_0_0; - - } - - } - - // Figure out what backward version to use. - - uint32 dngBackwardVersion = dngVersion_1_1_0_0; - - #if defined(qTestRowInterleave) || defined(qTestSubTileBlockRows) || defined(qTestSubTileBlockCols) - dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_2_0_0); - #endif - - dngBackwardVersion = Max_uint32 (dngBackwardVersion, - negative.OpcodeList1 ().MinVersion (false)); - - dngBackwardVersion = Max_uint32 (dngBackwardVersion, - negative.OpcodeList2 ().MinVersion (false)); - - dngBackwardVersion = Max_uint32 (dngBackwardVersion, - negative.OpcodeList3 ().MinVersion (false)); - - if (negative.GetMosaicInfo () && - negative.GetMosaicInfo ()->fCFALayout >= 6) - { - dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_3_0_0); - } - - if (rawJPEGImage || isFloatingPoint || hasTransparencyMask || isCompressed32BitInteger) - { - dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_4_0_0); - } - - if (dngBackwardVersion > dngVersion) - { - ThrowProgramError (); - } - - // Find best thumbnail from preview list, if any. - - const dng_preview *thumbnail = NULL; - - if (previewList) - { - - uint32 thumbArea = 0; - - for (j = 0; j < previewList->Count (); j++) - { - - const dng_image_preview *imagePreview = dynamic_cast(&previewList->Preview (j)); - - if (imagePreview) - { - - uint32 thisArea = imagePreview->fImage->Bounds ().W () * - imagePreview->fImage->Bounds ().H (); - - if (!thumbnail || thisArea < thumbArea) - { - - thumbnail = &previewList->Preview (j); - - thumbArea = thisArea; - - } - - } - - const dng_jpeg_preview *jpegPreview = dynamic_cast(&previewList->Preview (j)); - - if (jpegPreview) - { - - uint32 thisArea = jpegPreview->fPreviewSize.h * - jpegPreview->fPreviewSize.v; - - if (!thumbnail || thisArea < thumbArea) - { - - thumbnail = &previewList->Preview (j); - - thumbArea = thisArea; - - } - - } - - } - - } - - // Create the main IFD - - dng_tiff_directory mainIFD; - - // Create the IFD for the raw data. If there is no thumnail, this is - // just a reference the main IFD. Otherwise allocate a new one. - - AutoPtr rawIFD_IfNotMain; - - if (thumbnail) - { - rawIFD_IfNotMain.Reset (new dng_tiff_directory); - } - - dng_tiff_directory &rawIFD (thumbnail ? *rawIFD_IfNotMain : mainIFD); - - // Include DNG version tags. - - uint8 dngVersionData [4]; - - dngVersionData [0] = (uint8) (dngVersion >> 24); - dngVersionData [1] = (uint8) (dngVersion >> 16); - dngVersionData [2] = (uint8) (dngVersion >> 8); - dngVersionData [3] = (uint8) (dngVersion ); - - tag_uint8_ptr tagDNGVersion (tcDNGVersion, dngVersionData, 4); - - mainIFD.Add (&tagDNGVersion); - - uint8 dngBackwardVersionData [4]; - - dngBackwardVersionData [0] = (uint8) (dngBackwardVersion >> 24); - dngBackwardVersionData [1] = (uint8) (dngBackwardVersion >> 16); - dngBackwardVersionData [2] = (uint8) (dngBackwardVersion >> 8); - dngBackwardVersionData [3] = (uint8) (dngBackwardVersion ); - - tag_uint8_ptr tagDNGBackwardVersion (tcDNGBackwardVersion, dngBackwardVersionData, 4); - - mainIFD.Add (&tagDNGBackwardVersion); - - // The main IFD contains the thumbnail, if there is a thumbnail. - - AutoPtr thmBasic; - - if (thumbnail) - { - thmBasic.Reset (thumbnail->AddTagSet (mainIFD)); - } - - // Get the raw image we are writing. - - const dng_image &rawImage (negative.RawImage ()); - - // For floating point, we only support ZIP compression. - - if (isFloatingPoint && !uncompressed) - { - - compression = ccDeflate; - - } - - // For 32-bit integer images, we only support ZIP and uncompressed. - - if (rawImage.PixelType () == ttLong) - { - - if (isCompressed32BitInteger) - { - compression = ccDeflate; - } - - else - { - compression = ccUncompressed; - } - - } - - // Get a copy of the mosaic info. - - dng_mosaic_info mosaicInfo; - - if (negative.GetMosaicInfo ()) - { - mosaicInfo = *(negative.GetMosaicInfo ()); - } - - // Create a dng_ifd record for the raw image. - - dng_ifd info; - - info.fImageWidth = rawImage.Width (); - info.fImageLength = rawImage.Height (); - - info.fSamplesPerPixel = rawImage.Planes (); - - info.fPhotometricInterpretation = mosaicInfo.IsColorFilterArray () ? piCFA - : piLinearRaw; - - info.fCompression = compression; - - if (isFloatingPoint && compression == ccDeflate) - { - - info.fPredictor = cpFloatingPoint; - - if (mosaicInfo.IsColorFilterArray ()) - { - - if (mosaicInfo.fCFAPatternSize.h == 2) - { - info.fPredictor = cpFloatingPointX2; - } - - else if (mosaicInfo.fCFAPatternSize.h == 4) - { - info.fPredictor = cpFloatingPointX4; - } - - } - - } - - if (isCompressed32BitInteger) - { - - info.fPredictor = cpHorizontalDifference; - - if (mosaicInfo.IsColorFilterArray ()) - { - - if (mosaicInfo.fCFAPatternSize.h == 2) - { - info.fPredictor = cpHorizontalDifferenceX2; - } - - else if (mosaicInfo.fCFAPatternSize.h == 4) - { - info.fPredictor = cpHorizontalDifferenceX4; - } - - } - - } - - uint32 rawPixelType = rawImage.PixelType (); - - if (rawPixelType == ttShort) - { - - // See if we are using a linearization table with <= 256 entries, in which - // case the useful data will all fit within 8-bits. - - const dng_linearization_info *rangeInfo = negative.GetLinearizationInfo (); - - if (rangeInfo) - { - - if (rangeInfo->fLinearizationTable.Get ()) - { - - uint32 entries = rangeInfo->fLinearizationTable->LogicalSize () >> 1; - - if (entries <= 256) - { - - rawPixelType = ttByte; - - } - - } - - } - - } - - switch (rawPixelType) - { - - case ttByte: - { - info.fBitsPerSample [0] = 8; - break; - } - - case ttShort: - { - info.fBitsPerSample [0] = 16; - break; - } - - case ttLong: - { - info.fBitsPerSample [0] = 32; - break; - } - - case ttFloat: - { - - if (negative.RawFloatBitDepth () == 16) - { - info.fBitsPerSample [0] = 16; - } - - else if (negative.RawFloatBitDepth () == 24) - { - info.fBitsPerSample [0] = 24; - } - - else - { - info.fBitsPerSample [0] = 32; - } - - for (j = 0; j < info.fSamplesPerPixel; j++) - { - info.fSampleFormat [j] = sfFloatingPoint; - } - - break; - - } - - default: - { - ThrowProgramError (); - } - - } - - // For lossless JPEG compression, we often lie about the - // actual channel count to get the predictors to work across - // same color mosaic pixels. - - uint32 fakeChannels = 1; - - if (info.fCompression == ccJPEG) - { - - if (mosaicInfo.IsColorFilterArray ()) - { - - if (mosaicInfo.fCFAPatternSize.h == 4) - { - fakeChannels = 4; - } - - else if (mosaicInfo.fCFAPatternSize.h == 2) - { - fakeChannels = 2; - } - - // However, lossless JEPG is limited to four channels, - // so compromise might be required. - - while (fakeChannels * info.fSamplesPerPixel > 4 && - fakeChannels > 1) - { - - fakeChannels >>= 1; - - } - - } - - } - - // Figure out tile sizes. - - if (rawJPEGImage) - { - - DNG_ASSERT (rawPixelType == ttByte, - "Unexpected jpeg pixel type"); - - DNG_ASSERT (info.fImageWidth == (uint32) rawJPEGImage->fImageSize.h && - info.fImageLength == (uint32) rawJPEGImage->fImageSize.v, - "Unexpected jpeg image size"); - - info.fTileWidth = rawJPEGImage->fTileSize.h; - info.fTileLength = rawJPEGImage->fTileSize.v; - - info.fUsesStrips = rawJPEGImage->fUsesStrips; - - info.fUsesTiles = !info.fUsesStrips; - - } - - else if (info.fCompression == ccJPEG) - { - - info.FindTileSize (128 * 1024); - - } - - else if (info.fCompression == ccDeflate) - { - - info.FindTileSize (512 * 1024); - - } - - else if (info.fCompression == ccLossyJPEG) - { - - ThrowProgramError ("No JPEG compressed image"); - - } - - // Don't use tiles for uncompressed images. - - else - { - - info.SetSingleStrip (); - - } - - #ifdef qTestRowInterleave - - info.fRowInterleaveFactor = qTestRowInterleave; - - #endif - - #if defined(qTestSubTileBlockRows) && defined(qTestSubTileBlockCols) - - info.fSubTileBlockRows = qTestSubTileBlockRows; - info.fSubTileBlockCols = qTestSubTileBlockCols; - - if (fakeChannels == 2) - fakeChannels = 4; - - #endif - - // Basic information. - - dng_basic_tag_set rawBasic (rawIFD, info); - - // JPEG tables, if any. - - tag_data_ptr tagJPEGTables (tcJPEGTables, - ttUndefined, - 0, - NULL); - - if (rawJPEGImage && rawJPEGImage->fJPEGTables.Get ()) - { - - tagJPEGTables.SetData (rawJPEGImage->fJPEGTables->Buffer ()); - - tagJPEGTables.SetCount (rawJPEGImage->fJPEGTables->LogicalSize ()); - - rawIFD.Add (&tagJPEGTables); - - } - - // DefaultScale tag. - - dng_urational defaultScaleData [2]; - - defaultScaleData [0] = negative.DefaultScaleH (); - defaultScaleData [1] = negative.DefaultScaleV (); - - tag_urational_ptr tagDefaultScale (tcDefaultScale, - defaultScaleData, - 2); - - rawIFD.Add (&tagDefaultScale); - - // Best quality scale tag. - - tag_urational tagBestQualityScale (tcBestQualityScale, - negative.BestQualityScale ()); - - rawIFD.Add (&tagBestQualityScale); - - // DefaultCropOrigin tag. - - dng_urational defaultCropOriginData [2]; - - defaultCropOriginData [0] = negative.DefaultCropOriginH (); - defaultCropOriginData [1] = negative.DefaultCropOriginV (); - - tag_urational_ptr tagDefaultCropOrigin (tcDefaultCropOrigin, - defaultCropOriginData, - 2); - - rawIFD.Add (&tagDefaultCropOrigin); - - // DefaultCropSize tag. - - dng_urational defaultCropSizeData [2]; - - defaultCropSizeData [0] = negative.DefaultCropSizeH (); - defaultCropSizeData [1] = negative.DefaultCropSizeV (); - - tag_urational_ptr tagDefaultCropSize (tcDefaultCropSize, - defaultCropSizeData, - 2); - - rawIFD.Add (&tagDefaultCropSize); - - // DefaultUserCrop tag. - - dng_urational defaultUserCropData [4]; - - defaultUserCropData [0] = negative.DefaultUserCropT (); - defaultUserCropData [1] = negative.DefaultUserCropL (); - defaultUserCropData [2] = negative.DefaultUserCropB (); - defaultUserCropData [3] = negative.DefaultUserCropR (); - - tag_urational_ptr tagDefaultUserCrop (tcDefaultUserCrop, - defaultUserCropData, - 4); - - rawIFD.Add (&tagDefaultUserCrop); - - // Range mapping tag set. - - range_tag_set rangeSet (rawIFD, negative); - - // Mosaic pattern information. - - mosaic_tag_set mosaicSet (rawIFD, mosaicInfo); - - // Chroma blur radius. - - tag_urational tagChromaBlurRadius (tcChromaBlurRadius, - negative.ChromaBlurRadius ()); - - if (negative.ChromaBlurRadius ().IsValid ()) - { - - rawIFD.Add (&tagChromaBlurRadius); - - } - - // Anti-alias filter strength. - - tag_urational tagAntiAliasStrength (tcAntiAliasStrength, - negative.AntiAliasStrength ()); - - if (negative.AntiAliasStrength ().IsValid ()) - { - - rawIFD.Add (&tagAntiAliasStrength); - - } - - // Profile and other color related tags. - - AutoPtr profileSet; - - AutoPtr colorSet; - - std::vector extraProfileIndex; - - if (!negative.IsMonochrome ()) - { - - const dng_camera_profile &mainProfile (*negative.ComputeCameraProfileToEmbed (constMetadata)); - - profileSet.Reset (new profile_tag_set (mainIFD, - mainProfile)); - - colorSet.Reset (new color_tag_set (mainIFD, - negative)); - - // Build list of profile indices to include in extra profiles tag. - - uint32 profileCount = negative.ProfileCount (); - - for (uint32 index = 0; index < profileCount; index++) - { - - const dng_camera_profile &profile (negative.ProfileByIndex (index)); - - if (&profile != &mainProfile) - { - - if (profile.WasReadFromDNG ()) - { - - extraProfileIndex.push_back (index); - - } - - } - - } - - } - - // Extra camera profiles tag. - - uint32 extraProfileCount = (uint32) extraProfileIndex.size (); - - dng_memory_data extraProfileOffsets (extraProfileCount * (uint32) sizeof (uint32)); - - tag_uint32_ptr extraProfileTag (tcExtraCameraProfiles, - extraProfileOffsets.Buffer_uint32 (), - extraProfileCount); - - if (extraProfileCount) - { - - mainIFD.Add (&extraProfileTag); - - } - - // Other tags. - - tag_uint16 tagOrientation (tcOrientation, - (uint16) negative.ComputeOrientation (constMetadata).GetTIFF ()); - - mainIFD.Add (&tagOrientation); - - tag_srational tagBaselineExposure (tcBaselineExposure, - negative.BaselineExposureR ()); - - mainIFD.Add (&tagBaselineExposure); - - tag_urational tagBaselineNoise (tcBaselineNoise, - negative.BaselineNoiseR ()); - - mainIFD.Add (&tagBaselineNoise); - - tag_urational tagNoiseReductionApplied (tcNoiseReductionApplied, - negative.NoiseReductionApplied ()); - - if (negative.NoiseReductionApplied ().IsValid ()) - { - - mainIFD.Add (&tagNoiseReductionApplied); - - } - - tag_dng_noise_profile tagNoiseProfile (negative.NoiseProfile ()); - - if (negative.NoiseProfile ().IsValidForNegative (negative)) - { - - mainIFD.Add (&tagNoiseProfile); - - } - - tag_urational tagBaselineSharpness (tcBaselineSharpness, - negative.BaselineSharpnessR ()); - - mainIFD.Add (&tagBaselineSharpness); - - tag_string tagUniqueName (tcUniqueCameraModel, - negative.ModelName (), - true); - - mainIFD.Add (&tagUniqueName); - - tag_string tagLocalName (tcLocalizedCameraModel, - negative.LocalName (), - false); - - if (negative.LocalName ().NotEmpty ()) - { - - mainIFD.Add (&tagLocalName); - - } - - tag_urational tagShadowScale (tcShadowScale, - negative.ShadowScaleR ()); - - mainIFD.Add (&tagShadowScale); - - tag_uint16 tagColorimetricReference (tcColorimetricReference, - (uint16) negative.ColorimetricReference ()); - - if (negative.ColorimetricReference () != crSceneReferred) - { - - mainIFD.Add (&tagColorimetricReference); - - } - - bool useNewDigest = (maxBackwardVersion >= dngVersion_1_4_0_0); - - if (compression == ccLossyJPEG) - { - - negative.FindRawJPEGImageDigest (host); - - } - - else - { - - if (useNewDigest) - { - negative.FindNewRawImageDigest (host); - } - else - { - negative.FindRawImageDigest (host); - } - - } - - tag_uint8_ptr tagRawImageDigest (useNewDigest ? tcNewRawImageDigest : tcRawImageDigest, - compression == ccLossyJPEG ? - negative.RawJPEGImageDigest ().data : - (useNewDigest ? negative.NewRawImageDigest ().data - : negative.RawImageDigest ().data), - 16); - - mainIFD.Add (&tagRawImageDigest); - - negative.FindRawDataUniqueID (host); - - tag_uint8_ptr tagRawDataUniqueID (tcRawDataUniqueID, - negative.RawDataUniqueID ().data, - 16); - - if (negative.RawDataUniqueID ().IsValid ()) - { - - mainIFD.Add (&tagRawDataUniqueID); - - } - - tag_string tagOriginalRawFileName (tcOriginalRawFileName, - negative.OriginalRawFileName (), - false); - - if (negative.HasOriginalRawFileName ()) - { - - mainIFD.Add (&tagOriginalRawFileName); - - } - - negative.FindOriginalRawFileDigest (); - - tag_data_ptr tagOriginalRawFileData (tcOriginalRawFileData, - ttUndefined, - negative.OriginalRawFileDataLength (), - negative.OriginalRawFileData ()); - - tag_uint8_ptr tagOriginalRawFileDigest (tcOriginalRawFileDigest, - negative.OriginalRawFileDigest ().data, - 16); - - if (negative.OriginalRawFileData ()) - { - - mainIFD.Add (&tagOriginalRawFileData); - - mainIFD.Add (&tagOriginalRawFileDigest); - - } - - // XMP metadata. - - tag_xmp tagXMP (metadata->GetXMP ()); - - if (tagXMP.Count ()) - { - - mainIFD.Add (&tagXMP); - - } - - // Exif tags. - - exif_tag_set exifSet (mainIFD, - *metadata->GetExif (), - metadata->IsMakerNoteSafe (), - metadata->MakerNoteData (), - metadata->MakerNoteLength (), - true); - - // Private data. - - tag_uint8_ptr tagPrivateData (tcDNGPrivateData, - negative.PrivateData (), - negative.PrivateLength ()); - - if (negative.PrivateLength ()) - { - - mainIFD.Add (&tagPrivateData); - - } - - // Proxy size tags. - - uint32 originalDefaultFinalSizeData [2]; - - originalDefaultFinalSizeData [0] = negative.OriginalDefaultFinalSize ().h; - originalDefaultFinalSizeData [1] = negative.OriginalDefaultFinalSize ().v; - - tag_uint32_ptr tagOriginalDefaultFinalSize (tcOriginalDefaultFinalSize, - originalDefaultFinalSizeData, - 2); - - if (saveOriginalDefaultFinalSize) - { - - mainIFD.Add (&tagOriginalDefaultFinalSize); - - } - - uint32 originalBestQualityFinalSizeData [2]; - - originalBestQualityFinalSizeData [0] = negative.OriginalBestQualityFinalSize ().h; - originalBestQualityFinalSizeData [1] = negative.OriginalBestQualityFinalSize ().v; - - tag_uint32_ptr tagOriginalBestQualityFinalSize (tcOriginalBestQualityFinalSize, - originalBestQualityFinalSizeData, - 2); - - if (saveOriginalBestQualityFinalSize) - { - - mainIFD.Add (&tagOriginalBestQualityFinalSize); - - } - - dng_urational originalDefaultCropSizeData [2]; - - originalDefaultCropSizeData [0] = negative.OriginalDefaultCropSizeH (); - originalDefaultCropSizeData [1] = negative.OriginalDefaultCropSizeV (); - - tag_urational_ptr tagOriginalDefaultCropSize (tcOriginalDefaultCropSize, - originalDefaultCropSizeData, - 2); - - if (saveOriginalDefaultCropSize) - { - - mainIFD.Add (&tagOriginalDefaultCropSize); - - } - - // Opcode list 1. - - AutoPtr opcodeList1Data (negative.OpcodeList1 ().Spool (host)); - - tag_data_ptr tagOpcodeList1 (tcOpcodeList1, - ttUndefined, - opcodeList1Data.Get () ? opcodeList1Data->LogicalSize () : 0, - opcodeList1Data.Get () ? opcodeList1Data->Buffer () : NULL); - - if (opcodeList1Data.Get ()) - { - - rawIFD.Add (&tagOpcodeList1); - - } - - // Opcode list 2. - - AutoPtr opcodeList2Data (negative.OpcodeList2 ().Spool (host)); - - tag_data_ptr tagOpcodeList2 (tcOpcodeList2, - ttUndefined, - opcodeList2Data.Get () ? opcodeList2Data->LogicalSize () : 0, - opcodeList2Data.Get () ? opcodeList2Data->Buffer () : NULL); - - if (opcodeList2Data.Get ()) - { - - rawIFD.Add (&tagOpcodeList2); - - } - - // Opcode list 3. - - AutoPtr opcodeList3Data (negative.OpcodeList3 ().Spool (host)); - - tag_data_ptr tagOpcodeList3 (tcOpcodeList3, - ttUndefined, - opcodeList3Data.Get () ? opcodeList3Data->LogicalSize () : 0, - opcodeList3Data.Get () ? opcodeList3Data->Buffer () : NULL); - - if (opcodeList3Data.Get ()) - { - - rawIFD.Add (&tagOpcodeList3); - - } - - // Transparency mask, if any. - - AutoPtr maskInfo; - - AutoPtr maskIFD; - - AutoPtr maskBasic; - - if (hasTransparencyMask) - { - - // Create mask IFD. - - maskInfo.Reset (new dng_ifd); - - maskInfo->fNewSubFileType = sfTransparencyMask; - - maskInfo->fImageWidth = negative.RawTransparencyMask ()->Bounds ().W (); - maskInfo->fImageLength = negative.RawTransparencyMask ()->Bounds ().H (); - - maskInfo->fSamplesPerPixel = 1; - - maskInfo->fBitsPerSample [0] = negative.RawTransparencyMaskBitDepth (); - - maskInfo->fPhotometricInterpretation = piTransparencyMask; - - maskInfo->fCompression = uncompressed ? ccUncompressed : ccDeflate; - maskInfo->fPredictor = uncompressed ? cpNullPredictor : cpHorizontalDifference; - - if (negative.RawTransparencyMask ()->PixelType () == ttFloat) - { - - maskInfo->fSampleFormat [0] = sfFloatingPoint; - - if (maskInfo->fCompression == ccDeflate) - { - maskInfo->fPredictor = cpFloatingPoint; - } - - } - - if (maskInfo->fCompression == ccDeflate) - { - maskInfo->FindTileSize (512 * 1024); - } - else - { - maskInfo->SetSingleStrip (); - } - - // Create mask tiff directory. - - maskIFD.Reset (new dng_tiff_directory); - - // Add mask basic tag set. - - maskBasic.Reset (new dng_basic_tag_set (*maskIFD, *maskInfo)); - - } - - // Add other subfiles. - - uint32 subFileCount = thumbnail ? 1 : 0; - - if (hasTransparencyMask) - { - subFileCount++; - } - - // Add previews. - - uint32 previewCount = previewList ? previewList->Count () : 0; - - AutoPtr previewIFD [kMaxDNGPreviews]; - - AutoPtr previewBasic [kMaxDNGPreviews]; - - for (j = 0; j < previewCount; j++) - { - - if (thumbnail != &previewList->Preview (j)) - { - - previewIFD [j] . Reset (new dng_tiff_directory); - - previewBasic [j] . Reset (previewList->Preview (j).AddTagSet (*previewIFD [j])); - - subFileCount++; - - } - - } - - // And a link to the raw and JPEG image IFDs. - - uint32 subFileData [kMaxDNGPreviews + 2]; - - tag_uint32_ptr tagSubFile (tcSubIFDs, - subFileData, - subFileCount); - - if (subFileCount) - { - - mainIFD.Add (&tagSubFile); - - } - - // Skip past the header and IFDs for now. - - uint32 currentOffset = 8; - - currentOffset += mainIFD.Size (); - - uint32 subFileIndex = 0; - - if (thumbnail) - { - - subFileData [subFileIndex++] = currentOffset; - - currentOffset += rawIFD.Size (); - - } - - if (hasTransparencyMask) - { - - subFileData [subFileIndex++] = currentOffset; - - currentOffset += maskIFD->Size (); - - } - - for (j = 0; j < previewCount; j++) - { - - if (thumbnail != &previewList->Preview (j)) - { - - subFileData [subFileIndex++] = currentOffset; - - currentOffset += previewIFD [j]->Size (); - - } - - } - - exifSet.Locate (currentOffset); - - currentOffset += exifSet.Size (); - - stream.SetWritePosition (currentOffset); - - // Write the extra profiles. - - if (extraProfileCount) - { - - for (j = 0; j < extraProfileCount; j++) - { - - extraProfileOffsets.Buffer_uint32 () [j] = (uint32) stream.Position (); - - uint32 index = extraProfileIndex [j]; - - const dng_camera_profile &profile (negative.ProfileByIndex (index)); - - tiff_dng_extended_color_profile extraWriter (profile); - - extraWriter.Put (stream, false); - - } - - } - - // Write the thumbnail data. - - if (thumbnail) - { - - thumbnail->WriteData (host, - *this, - *thmBasic, - stream); - - } - - // Write the preview data. - - for (j = 0; j < previewCount; j++) - { - - if (thumbnail != &previewList->Preview (j)) - { - - previewList->Preview (j).WriteData (host, - *this, - *previewBasic [j], - stream); - - } - - } - - // Write the raw data. - - if (rawJPEGImage) - { - - uint32 tileCount = info.TilesAcross () * - info.TilesDown (); - - for (uint32 tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - // Remember this offset. - - uint32 tileOffset = (uint32) stream.Position (); - - rawBasic.SetTileOffset (tileIndex, tileOffset); - - // Write JPEG data. - - stream.Put (rawJPEGImage->fJPEGData [tileIndex]->Buffer (), - rawJPEGImage->fJPEGData [tileIndex]->LogicalSize ()); - - // Update tile count. - - uint32 tileByteCount = (uint32) stream.Position () - tileOffset; - - rawBasic.SetTileByteCount (tileIndex, tileByteCount); - - // Keep the tiles on even byte offsets. - - if (tileByteCount & 1) - { - stream.Put_uint8 (0); - } - - } - - } - - else - { - - #if qDNGValidate - dng_timer timer ("Write raw image time"); - #endif - - WriteImage (host, - info, - rawBasic, - stream, - rawImage, - fakeChannels); - - } - - // Write transparency mask image. - - if (hasTransparencyMask) - { - - #if qDNGValidate - dng_timer timer ("Write transparency mask time"); - #endif - - WriteImage (host, - *maskInfo, - *maskBasic, - stream, - *negative.RawTransparencyMask ()); - - } - - // Trim the file to this length. - - stream.SetLength (stream.Position ()); - - // DNG has a 4G size limit. - - if (stream.Length () > 0x0FFFFFFFFL) - { - ThrowImageTooBigDNG (); - } - - // Write TIFF Header. - - stream.SetWritePosition (0); - - stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII); - - stream.Put_uint16 (42); - - stream.Put_uint32 (8); - - // Write the IFDs. - - mainIFD.Put (stream); - - if (thumbnail) - { - - rawIFD.Put (stream); - - } - - if (hasTransparencyMask) - { - - maskIFD->Put (stream); - - } - - for (j = 0; j < previewCount; j++) - { - - if (thumbnail != &previewList->Preview (j)) - { - - previewIFD [j]->Put (stream); - - } - - } - - exifSet.Put (stream); - - stream.Flush (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_image_writer.h b/third_party/dng_sdk/dng_image_writer.h deleted file mode 100644 index 0b90c23..0000000 --- a/third_party/dng_sdk/dng_image_writer.h +++ /dev/null @@ -1,1245 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_image_writer.h#3 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for writing DNG images to files. - */ - -/*****************************************************************************/ - -#ifndef __dng_image_writer__ -#define __dng_image_writer__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_fingerprint.h" -#include "dng_memory.h" -#include "dng_point.h" -#include "dng_rational.h" -#include "dng_sdk_limits.h" -#include "dng_string.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Image resolution. - -class dng_resolution - { - - public: - - dng_urational fXResolution; - dng_urational fYResolution; - - uint16 fResolutionUnit; - - public: - - dng_resolution (); - - }; - -/*****************************************************************************/ - -class tiff_tag - { - - protected: - - uint16 fCode; - - uint16 fType; - - uint32 fCount; - - protected: - - tiff_tag (uint16 code, - uint16 type, - uint32 count) - - : fCode (code) - , fType (type) - , fCount (count) - - { - } - - public: - - virtual ~tiff_tag () - { - } - - uint16 Code () const - { - return fCode; - } - - uint16 Type () const - { - return fType; - } - - uint32 Count () const - { - return fCount; - } - - void SetCount (uint32 count) - { - fCount = count; - } - - uint32 Size () const - { - return TagTypeSize (Type ()) * Count (); - } - - virtual void Put (dng_stream &stream) const = 0; - - private: - - // Hidden copy constructor and assignment operator. - - tiff_tag (const tiff_tag &tag); - - tiff_tag & operator= (const tiff_tag &tag); - - }; - -/******************************************************************************/ - -class tag_data_ptr: public tiff_tag - { - - protected: - - const void *fData; - - public: - - tag_data_ptr (uint16 code, - uint16 type, - uint32 count, - const void *data) - - : tiff_tag (code, type, count) - - , fData (data) - - { - } - - void SetData (const void *data) - { - fData = data; - } - - virtual void Put (dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - tag_data_ptr (const tag_data_ptr &tag); - - tag_data_ptr & operator= (const tag_data_ptr &tag); - - }; - -/******************************************************************************/ - -class tag_string: public tiff_tag - { - - protected: - - dng_string fString; - - public: - - tag_string (uint16 code, - const dng_string &s, - bool forceASCII = true); - - virtual void Put (dng_stream &stream) const; - - }; - -/******************************************************************************/ - -class tag_encoded_text: public tiff_tag - { - - private: - - dng_string fText; - - dng_memory_data fUTF16; - - public: - - tag_encoded_text (uint16 code, - const dng_string &text); - - virtual void Put (dng_stream &stream) const; - - }; - -/******************************************************************************/ - -class tag_uint8: public tag_data_ptr - { - - private: - - uint8 fValue; - - public: - - tag_uint8 (uint16 code, - uint8 value = 0) - - : tag_data_ptr (code, ttByte, 1, &fValue) - - , fValue (value) - - { - } - - void Set (uint8 value) - { - fValue = value; - } - - }; - -/******************************************************************************/ - -class tag_uint8_ptr: public tag_data_ptr - { - - public: - - tag_uint8_ptr (uint16 code, - const uint8 *data, - uint32 count = 1) - - : tag_data_ptr (code, ttByte, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_uint16: public tag_data_ptr - { - - private: - - uint16 fValue; - - public: - - tag_uint16 (uint16 code, - uint16 value = 0) - - : tag_data_ptr (code, ttShort, 1, &fValue) - - , fValue (value) - - { - } - - void Set (uint16 value) - { - fValue = value; - } - - }; - -/******************************************************************************/ - -class tag_int16_ptr: public tag_data_ptr - { - - public: - - tag_int16_ptr (uint16 code, - const int16 *data, - uint32 count = 1) - - : tag_data_ptr (code, ttSShort, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_uint16_ptr: public tag_data_ptr - { - - public: - - tag_uint16_ptr (uint16 code, - const uint16 *data, - uint32 count = 1) - - : tag_data_ptr (code, ttShort, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_uint32: public tag_data_ptr - { - - private: - - uint32 fValue; - - public: - - tag_uint32 (uint16 code, - uint32 value = 0) - - : tag_data_ptr (code, ttLong, 1, &fValue) - - , fValue (value) - - { - } - - void Set (uint32 value) - { - fValue = value; - } - - }; - -/******************************************************************************/ - -class tag_uint32_ptr: public tag_data_ptr - { - - public: - - tag_uint32_ptr (uint16 code, - const uint32 *data, - uint32 count = 1) - - : tag_data_ptr (code, ttLong, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_urational: public tag_data_ptr - { - - private: - - const dng_urational fValue; - - public: - - tag_urational (uint16 code, - const dng_urational &value) - - : tag_data_ptr (code, ttRational, 1, &fValue) - - , fValue (value) - - { - } - - }; - -/******************************************************************************/ - -class tag_urational_ptr: public tag_data_ptr - { - - public: - - tag_urational_ptr (uint16 code, - const dng_urational *data = NULL, - uint32 count = 1) - - : tag_data_ptr (code, ttRational, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_srational: public tag_data_ptr - { - - private: - - const dng_srational fValue; - - public: - - tag_srational (uint16 code, - const dng_srational &value) - - : tag_data_ptr (code, ttSRational, 1, &fValue) - - , fValue (value) - - { - } - - }; - -/******************************************************************************/ - -class tag_srational_ptr: public tag_data_ptr - { - - public: - - tag_srational_ptr (uint16 code, - const dng_srational *data = NULL, - uint32 count = 1) - - : tag_data_ptr (code, ttSRational, count, data) - - { - } - - }; - -/******************************************************************************/ - -class tag_real64: public tag_data_ptr - { - - private: - - real64 fValue; - - public: - - tag_real64 (uint16 code, - real64 value = 0.0) - - : tag_data_ptr (code, ttDouble, 1, &fValue) - - , fValue (value) - - { - } - - void Set (real64 value) - { - fValue = value; - } - - }; - -/******************************************************************************/ - -class tag_matrix: public tag_srational_ptr - { - - private: - - dng_srational fEntry [kMaxColorPlanes * - kMaxColorPlanes]; - - public: - - tag_matrix (uint16 code, - const dng_matrix &m); - - }; - -/******************************************************************************/ - -class tag_icc_profile: public tag_data_ptr - { - - public: - - tag_icc_profile (const void *profileData, uint32 profileSize); - - }; - -/******************************************************************************/ - -class tag_cfa_pattern: public tiff_tag - { - - private: - - uint32 fRows; - uint32 fCols; - - const uint8 *fPattern; - - public: - - tag_cfa_pattern (uint16 code, - uint32 rows, - uint32 cols, - const uint8 *pattern) - - : tiff_tag (code, ttUndefined, 4 + rows * cols) - - , fRows (rows ) - , fCols (cols ) - , fPattern (pattern) - - { - } - - virtual void Put (dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - tag_cfa_pattern (const tag_cfa_pattern &tag); - - tag_cfa_pattern & operator= (const tag_cfa_pattern &tag); - - }; - -/******************************************************************************/ - -class tag_exif_date_time: public tag_data_ptr - { - - private: - - char fData [20]; - - public: - - tag_exif_date_time (uint16 code, - const dng_date_time &dt); - - }; - -/******************************************************************************/ - -class tag_iptc: public tiff_tag - { - - private: - - const void *fData; - - uint32 fLength; - - public: - - tag_iptc (const void *data, - uint32 length); - - virtual void Put (dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - tag_iptc (const tag_iptc &tag); - - tag_iptc & operator= (const tag_iptc &tag); - - }; - -/******************************************************************************/ - -class tag_xmp: public tag_uint8_ptr - { - - private: - - AutoPtr fBuffer; - - public: - - tag_xmp (const dng_xmp *xmp); - - private: - - // Hidden copy constructor and assignment operator. - - tag_xmp (const tag_xmp &tag); - - tag_xmp & operator= (const tag_xmp &tag); - - }; - -/******************************************************************************/ - -class dng_tiff_directory - { - - private: - - enum - { - kMaxEntries = 100 - }; - - uint32 fEntries; - - const tiff_tag *fTag [kMaxEntries]; - - uint32 fChained; - - public: - - dng_tiff_directory () - - : fEntries (0) - , fChained (0) - - { - } - - virtual ~dng_tiff_directory () - { - } - - void Add (const tiff_tag *tag); - - void SetChained (uint32 offset) - { - fChained = offset; - } - - uint32 Size () const; - - enum OffsetsBase - { - offsetsRelativeToStream = 0, - offsetsRelativeToExplicitBase = 1, - offsetsRelativeToIFD = 2 - }; - - void Put (dng_stream &stream, - OffsetsBase offsetsBase = offsetsRelativeToStream, - uint32 explicitBase = 0) const; - - private: - - // Hidden copy constructor and assignment operator. - - dng_tiff_directory (const dng_tiff_directory &dir); - - dng_tiff_directory & operator= (const dng_tiff_directory &dir); - - }; - -/******************************************************************************/ - -class dng_basic_tag_set - { - - private: - - tag_uint32 fNewSubFileType; - - tag_uint32 fImageWidth; - tag_uint32 fImageLength; - - tag_uint16 fPhotoInterpretation; - - tag_uint16 fFillOrder; - - tag_uint16 fSamplesPerPixel; - - uint16 fBitsPerSampleData [kMaxSamplesPerPixel]; - - tag_uint16_ptr fBitsPerSample; - - bool fStrips; - - tag_uint32 fTileWidth; - tag_uint32 fTileLength; - - dng_memory_data fTileInfoBuffer; - - uint32 *fTileOffsetData; - - tag_uint32_ptr fTileOffsets; - - uint32 *fTileByteCountData; - - tag_uint32_ptr fTileByteCounts; - - tag_uint16 fPlanarConfiguration; - - tag_uint16 fCompression; - - tag_uint16 fPredictor; - - uint16 fExtraSamplesData [kMaxSamplesPerPixel]; - - tag_uint16_ptr fExtraSamples; - - uint16 fSampleFormatData [kMaxSamplesPerPixel]; - - tag_uint16_ptr fSampleFormat; - - tag_uint16 fRowInterleaveFactor; - - uint16 fSubTileBlockSizeData [2]; - - tag_uint16_ptr fSubTileBlockSize; - - public: - - dng_basic_tag_set (dng_tiff_directory &directory, - const dng_ifd &info); - - virtual ~dng_basic_tag_set () - { - } - - void SetTileOffset (uint32 index, - uint32 offset) - { - fTileOffsetData [index] = offset; - } - - void SetTileByteCount (uint32 index, - uint32 count) - { - fTileByteCountData [index] = count; - } - - bool WritingStrips () const - { - return fStrips; - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_basic_tag_set (const dng_basic_tag_set &set); - - dng_basic_tag_set & operator= (const dng_basic_tag_set &set); - - }; - -/******************************************************************************/ - -class exif_tag_set - { - - protected: - - dng_tiff_directory fExifIFD; - dng_tiff_directory fGPSIFD; - - private: - - tag_uint32 fExifLink; - tag_uint32 fGPSLink; - - bool fAddedExifLink; - bool fAddedGPSLink; - - uint8 fExifVersionData [4]; - - tag_data_ptr fExifVersion; - - tag_urational fExposureTime; - tag_srational fShutterSpeedValue; - - tag_urational fFNumber; - tag_urational fApertureValue; - - tag_srational fBrightnessValue; - - tag_srational fExposureBiasValue; - - tag_urational fMaxApertureValue; - - tag_urational fSubjectDistance; - - tag_urational fFocalLength; - - tag_uint16 fISOSpeedRatings; - - tag_uint16 fSensitivityType; - tag_uint32 fStandardOutputSensitivity; - tag_uint32 fRecommendedExposureIndex; - tag_uint32 fISOSpeed; - tag_uint32 fISOSpeedLatitudeyyy; - tag_uint32 fISOSpeedLatitudezzz; - - tag_uint16 fFlash; - - tag_uint16 fExposureProgram; - - tag_uint16 fMeteringMode; - - tag_uint16 fLightSource; - - tag_uint16 fSensingMethod; - - tag_uint16 fFocalLength35mm; - - uint8 fFileSourceData; - tag_data_ptr fFileSource; - - uint8 fSceneTypeData; - tag_data_ptr fSceneType; - - tag_cfa_pattern fCFAPattern; - - tag_uint16 fCustomRendered; - tag_uint16 fExposureMode; - tag_uint16 fWhiteBalance; - tag_uint16 fSceneCaptureType; - tag_uint16 fGainControl; - tag_uint16 fContrast; - tag_uint16 fSaturation; - tag_uint16 fSharpness; - tag_uint16 fSubjectDistanceRange; - - tag_urational fDigitalZoomRatio; - - tag_urational fExposureIndex; - - tag_uint32 fImageNumber; - - tag_uint16 fSelfTimerMode; - - tag_string fBatteryLevelA; - tag_urational fBatteryLevelR; - - tag_urational fFocalPlaneXResolution; - tag_urational fFocalPlaneYResolution; - - tag_uint16 fFocalPlaneResolutionUnit; - - uint16 fSubjectAreaData [4]; - - tag_uint16_ptr fSubjectArea; - - dng_urational fLensInfoData [4]; - - tag_urational_ptr fLensInfo; - - tag_exif_date_time fDateTime; - tag_exif_date_time fDateTimeOriginal; - tag_exif_date_time fDateTimeDigitized; - - tag_string fSubsecTime; - tag_string fSubsecTimeOriginal; - tag_string fSubsecTimeDigitized; - - tag_string fMake; - tag_string fModel; - tag_string fArtist; - tag_string fSoftware; - tag_string fCopyright; - tag_string fImageDescription; - - tag_string fSerialNumber; - - tag_uint16 fMakerNoteSafety; - - tag_data_ptr fMakerNote; - - tag_encoded_text fUserComment; - - char fImageUniqueIDData [33]; - - tag_data_ptr fImageUniqueID; - - // EXIF 2.3 tags. - - tag_string fCameraOwnerName; - tag_string fBodySerialNumber; - tag_urational_ptr fLensSpecification; - tag_string fLensMake; - tag_string fLensModel; - tag_string fLensSerialNumber; - - uint8 fGPSVersionData [4]; - - tag_uint8_ptr fGPSVersionID; - - tag_string fGPSLatitudeRef; - tag_urational_ptr fGPSLatitude; - - tag_string fGPSLongitudeRef; - tag_urational_ptr fGPSLongitude; - - tag_uint8 fGPSAltitudeRef; - tag_urational fGPSAltitude; - - tag_urational_ptr fGPSTimeStamp; - - tag_string fGPSSatellites; - tag_string fGPSStatus; - tag_string fGPSMeasureMode; - - tag_urational fGPSDOP; - - tag_string fGPSSpeedRef; - tag_urational fGPSSpeed; - - tag_string fGPSTrackRef; - tag_urational fGPSTrack; - - tag_string fGPSImgDirectionRef; - tag_urational fGPSImgDirection; - - tag_string fGPSMapDatum; - - tag_string fGPSDestLatitudeRef; - tag_urational_ptr fGPSDestLatitude; - - tag_string fGPSDestLongitudeRef; - tag_urational_ptr fGPSDestLongitude; - - tag_string fGPSDestBearingRef; - tag_urational fGPSDestBearing; - - tag_string fGPSDestDistanceRef; - tag_urational fGPSDestDistance; - - tag_encoded_text fGPSProcessingMethod; - tag_encoded_text fGPSAreaInformation; - - tag_string fGPSDateStamp; - - tag_uint16 fGPSDifferential; - - tag_urational fGPSHPositioningError; - - public: - - exif_tag_set (dng_tiff_directory &directory, - const dng_exif &exif, - bool makerNoteSafe = false, - const void *makerNoteData = NULL, - uint32 makerNoteLength = 0, - bool insideDNG = false); - - void Locate (uint32 offset) - { - fExifLink.Set (offset); - fGPSLink .Set (offset + fExifIFD.Size ()); - } - - uint32 Size () const - { - return fExifIFD.Size () + - fGPSIFD .Size (); - } - - void Put (dng_stream &stream) const - { - fExifIFD.Put (stream); - fGPSIFD .Put (stream); - } - - protected: - - void AddLinks (dng_tiff_directory &directory); - - private: - - // Hidden copy constructor and assignment operator. - - exif_tag_set (const exif_tag_set &set); - - exif_tag_set & operator= (const exif_tag_set &set); - - }; - -/******************************************************************************/ - -class tiff_dng_extended_color_profile: private dng_tiff_directory - { - - protected: - - const dng_camera_profile &fProfile; - - public: - - tiff_dng_extended_color_profile (const dng_camera_profile &profile); - - void Put (dng_stream &stream, - bool includeModelRestriction = true); - - }; - -/*****************************************************************************/ - -class tag_dng_noise_profile: public tag_data_ptr - { - - protected: - - real64 fValues [2 * kMaxColorPlanes]; - - public: - - explicit tag_dng_noise_profile (const dng_noise_profile &profile); - - }; - -/*****************************************************************************/ - -// Enum to control the subset of metadata to save to a file. - -enum dng_metadata_subset - { - - kMetadataSubset_CopyrightOnly = 0, - kMetadataSubset_CopyrightAndContact, - kMetadataSubset_AllExceptCameraInfo, - kMetadataSubset_All, - kMetadataSubset_AllExceptLocationInfo, - kMetadataSubset_AllExceptCameraAndLocation, - - kMetadataSubset_Last = kMetadataSubset_AllExceptCameraAndLocation - - }; - -/*****************************************************************************/ - -/// \brief Support for writing dng_image or dng_negative instances to a -/// dng_stream in TIFF or DNG format. - -class dng_image_writer - { - - friend class dng_jpeg_image; - friend class dng_jpeg_image_encode_task; - friend class dng_write_tiles_task; - - protected: - - enum - { - - // Target size for buffer used to copy data to the image. - - kImageBufferSize = 128 * 1024 - - }; - - public: - - dng_image_writer (); - - virtual ~dng_image_writer (); - - virtual void EncodeJPEGPreview (dng_host &host, - const dng_image &image, - dng_jpeg_preview &preview, - int32 quality = -1); - - virtual void WriteImage (dng_host &host, - const dng_ifd &ifd, - dng_basic_tag_set &basic, - dng_stream &stream, - const dng_image &image, - uint32 fakeChannels = 1); - - /// Write a dng_image to a dng_stream in TIFF format. - /// \param host Host interface used for progress updates, abort testing, buffer allocation, etc. - /// \param stream The dng_stream on which to write the TIFF. - /// \param image The actual image data to be written. - /// \param photometricInterpretation Either piBlackIsZero for monochrome or piRGB for RGB images. - /// \param compression Must be ccUncompressed. - /// \param negative or metadata If non-NULL, EXIF, IPTC, and XMP metadata from this negative is written to TIFF. - /// \param space If non-null and color space has an ICC profile, TIFF will be tagged with this - /// profile. No color space conversion of image data occurs. - /// \param resolution If non-NULL, TIFF will be tagged with this resolution. - /// \param thumbnail If non-NULL, will be stored in TIFF as preview image. - /// \param imageResources If non-NULL, will image resources be stored in TIFF as well. - /// \param metadataSubset The subset of metadata (e.g., copyright only) to include in the TIFF. - - void WriteTIFF (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - dng_negative *negative, - const dng_color_space *space = NULL, - const dng_resolution *resolution = NULL, - const dng_jpeg_preview *thumbnail = NULL, - const dng_memory_block *imageResources = NULL, - dng_metadata_subset metadataSubset = kMetadataSubset_All); - - void WriteTIFF (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation = piBlackIsZero, - uint32 compression = ccUncompressed, - const dng_metadata *metadata = NULL, - const dng_color_space *space = NULL, - const dng_resolution *resolution = NULL, - const dng_jpeg_preview *thumbnail = NULL, - const dng_memory_block *imageResources = NULL, - dng_metadata_subset metadataSubset = kMetadataSubset_All); - - /// Write a dng_image to a dng_stream in TIFF format. - /// \param host Host interface used for progress updates, abort testing, buffer allocation, etc. - /// \param stream The dng_stream on which to write the TIFF. - /// \param image The actual image data to be written. - /// \param photometricInterpretation Either piBlackIsZero for monochrome or piRGB for RGB images. - /// \param compression Must be ccUncompressed. - /// \param negative or metadata If non-NULL, EXIF, IPTC, and XMP metadata from this negative is written to TIFF. - /// \param profileData If non-null, TIFF will be tagged with this profile. No color space conversion - /// of image data occurs. - /// \param profileSize The size for the profile data. - /// \param resolution If non-NULL, TIFF will be tagged with this resolution. - /// \param thumbnail If non-NULL, will be stored in TIFF as preview image. - /// \param imageResources If non-NULL, will image resources be stored in TIFF as well. - /// \param metadataSubset The subset of metadata (e.g., copyright only) to include in the TIFF. - - void WriteTIFFWithProfile (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation, - uint32 compression, - dng_negative *negative, - const void *profileData = NULL, - uint32 profileSize = 0, - const dng_resolution *resolution = NULL, - const dng_jpeg_preview *thumbnail = NULL, - const dng_memory_block *imageResources = NULL, - dng_metadata_subset metadataSubset = kMetadataSubset_All); - - virtual void WriteTIFFWithProfile (dng_host &host, - dng_stream &stream, - const dng_image &image, - uint32 photometricInterpretation = piBlackIsZero, - uint32 compression = ccUncompressed, - const dng_metadata *metadata = NULL, - const void *profileData = NULL, - uint32 profileSize = 0, - const dng_resolution *resolution = NULL, - const dng_jpeg_preview *thumbnail = NULL, - const dng_memory_block *imageResources = NULL, - dng_metadata_subset metadataSubset = kMetadataSubset_All); - - /// Write a dng_image to a dng_stream in DNG format. - /// \param host Host interface used for progress updates, abort testing, buffer allocation, etc. - /// \param stream The dng_stream on which to write the TIFF. - /// \param negative The image data and metadata (EXIF, IPTC, XMP) to be written. - /// \param previewList List of previews (not counting thumbnail) to write to the file. Defaults to empty. - /// \param maxBackwardVersion The DNG file should be readable by readers at least back to this version. - /// \param uncompressed True to force uncompressed images. Otherwise use normal compression. - - void WriteDNG (dng_host &host, - dng_stream &stream, - dng_negative &negative, - const dng_preview_list *previewList = NULL, - uint32 maxBackwardVersion = dngVersion_SaveDefault, - bool uncompressed = false); - - /// Write a dng_image to a dng_stream in DNG format. - /// \param host Host interface used for progress updates, abort testing, buffer allocation, etc. - /// \param stream The dng_stream on which to write the TIFF. - /// \param negative The image data to be written. - /// \param metadata The metadata (EXIF, IPTC, XMP) to be written. - /// \param previewList List of previews (not counting thumbnail) to write to the file. Defaults to empty. - /// \param maxBackwardVersion The DNG file should be readable by readers at least back to this version. - /// \param uncompressed True to force uncompressed images. Otherwise use normal compression. - - virtual void WriteDNG (dng_host &host, - dng_stream &stream, - const dng_negative &negative, - const dng_metadata &metadata, - const dng_preview_list *previewList = NULL, - uint32 maxBackwardVersion = dngVersion_SaveDefault, - bool uncompressed = false); - - /// Resolve metadata conflicts and apply metadata policies in keeping - /// with Metadata Working Group (MWG) guidelines. - - virtual void CleanUpMetadata (dng_host &host, - dng_metadata &metadata, - dng_metadata_subset metadataSubset, - const char *dstMIMI, - const char *software = NULL); - - protected: - - virtual uint32 CompressedBufferSize (const dng_ifd &ifd, - uint32 uncompressedSize); - - virtual void EncodePredictor (dng_host &host, - const dng_ifd &ifd, - dng_pixel_buffer &buffer, - AutoPtr &tempBuffer); - - virtual void ByteSwapBuffer (dng_host &host, - dng_pixel_buffer &buffer); - - void ReorderSubTileBlocks (const dng_ifd &ifd, - dng_pixel_buffer &buffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer); - - virtual void WriteData (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_pixel_buffer &buffer, - AutoPtr &compressedBuffer); - - virtual void WriteTile (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - const dng_image &image, - const dng_rect &tileArea, - uint32 fakeChannels, - AutoPtr &compressedBuffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer, - AutoPtr &tempBuffer); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_info.cpp b/third_party/dng_sdk/dng_info.cpp deleted file mode 100644 index 35bec3c..0000000 --- a/third_party/dng_sdk/dng_info.cpp +++ /dev/null @@ -1,2505 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_info.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_info.h" - -#include "dng_camera_profile.h" -#include "dng_exceptions.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_tag_codes.h" -#include "dng_parse_utils.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_info::dng_info () - - : fTIFFBlockOffset (0) - , fTIFFBlockOriginalOffset (kDNGStreamInvalidOffset) - , fBigEndian (false) - , fMagic (0) - , fExif () - , fShared () - , fMainIndex (-1) - , fMaskIndex (-1) - , fIFDCount (0) - , fChainedIFDCount (0) - , fMakerNoteNextIFD (0) - - { - - } - -/*****************************************************************************/ - -dng_info::~dng_info () - { - - } - -/*****************************************************************************/ - -void dng_info::ValidateMagic () - { - - switch (fMagic) - { - - case magicTIFF: - case magicExtendedProfile: - case magicRawCache: - case magicPanasonic: - case magicOlympusA: - case magicOlympusB: - { - - return; - - } - - default: - { - - #if qDNGValidate - - ReportError ("Invalid TIFF magic number"); - - #endif - - ThrowBadFormat (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_info::ParseTag (dng_host &host, - dng_stream &stream, - dng_exif *exif, - dng_shared *shared, - dng_ifd *ifd, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset, - int64 offsetDelta) - { - - bool isSubIFD = parentCode >= tcFirstSubIFD && - parentCode <= tcLastSubIFD; - - bool isMainIFD = (parentCode == 0 || isSubIFD) && - ifd && - ifd->fUsesNewSubFileType && - ifd->fNewSubFileType == sfMainImage; - - // Panasonic RAW format stores private tags using tag codes < 254 in - // IFD 0. Redirect the parsing of these tags into a logical - // "PanasonicRAW" IFD. - - // Panasonic is starting to use some higher numbers also (280..283). - - if (fMagic == 85 && parentCode == 0 && (tagCode < tcNewSubFileType || - (tagCode >= 280 && tagCode <= 283))) - { - - parentCode = tcPanasonicRAW; - - ifd = NULL; - - } - - stream.SetReadPosition (tagOffset); - - if (ifd && ifd->ParseTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return; - - } - - stream.SetReadPosition (tagOffset); - - if (exif && shared && exif->ParseTag (stream, - *shared, - parentCode, - isMainIFD, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return; - - } - - stream.SetReadPosition (tagOffset); - - if (shared && exif && shared->ParseTag (stream, - *exif, - parentCode, - isMainIFD, - tagCode, - tagType, - tagCount, - tagOffset, - offsetDelta)) - { - - return; - - } - - if (parentCode == tcLeicaMakerNote && - tagType == ttUndefined && - tagCount >= 14) - { - - if (ParseMakerNoteIFD (host, - stream, - tagCount, - tagOffset, - offsetDelta, - tagOffset, - stream.Length (), - tcLeicaMakerNote)) - { - - return; - - } - - } - - if (parentCode == tcOlympusMakerNote && - tagType == ttUndefined && - tagCount >= 14) - { - - uint32 olympusMakerParent = 0; - - switch (tagCode) - { - - case 8208: - olympusMakerParent = tcOlympusMakerNote8208; - break; - - case 8224: - olympusMakerParent = tcOlympusMakerNote8224; - break; - - case 8240: - olympusMakerParent = tcOlympusMakerNote8240; - break; - - case 8256: - olympusMakerParent = tcOlympusMakerNote8256; - break; - - case 8272: - olympusMakerParent = tcOlympusMakerNote8272; - break; - - case 12288: - olympusMakerParent = tcOlympusMakerNote12288; - break; - - default: - break; - - } - - if (olympusMakerParent) - { - - // Olympus made a mistake in some camera models in computing - // the size of these sub-tags, so we fudge the count. - - if (ParseMakerNoteIFD (host, - stream, - stream.Length () - tagOffset, - tagOffset, - offsetDelta, - tagOffset, - stream.Length (), - olympusMakerParent)) - { - - return; - - } - - } - - } - - if (parentCode == tcRicohMakerNote && - tagCode == 0x2001 && - tagType == ttUndefined && - tagCount > 22) - { - - char header [20]; - - stream.SetReadPosition (tagOffset); - - stream.Get (header, sizeof (header)); - - if (memcmp (header, "[Ricoh Camera Info]", 19) == 0) - { - - ParseMakerNoteIFD (host, - stream, - tagCount - 20, - tagOffset + 20, - offsetDelta, - tagOffset + 20, - tagOffset + tagCount, - tcRicohMakerNoteCameraInfo); - - return; - - } - - } - - #if qDNGValidate - - { - - stream.SetReadPosition (tagOffset); - - if (gVerbose) - { - - printf ("*"); - - DumpTagValues (stream, - LookupTagType (tagType), - parentCode, - tagCode, - tagType, - tagCount); - - } - - // If type is ASCII, then parse anyway so we report any ASCII - // NULL termination or character set errors. - - else if (tagType == ttAscii) - { - - dng_string s; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - s, - false); - - } - - } - - #endif - - } - -/*****************************************************************************/ - -bool dng_info::ValidateIFD (dng_stream &stream, - uint64 ifdOffset, - int64 offsetDelta) - { - - // Make sure we have a count. - - if (ifdOffset + 2 > stream.Length ()) - { - return false; - } - - // Get entry count. - - stream.SetReadPosition (ifdOffset); - - uint32 ifdEntries = stream.Get_uint16 (); - - if (ifdEntries < 1) - { - return false; - } - - // Make sure we have room for all entries and next IFD link. - - if (ifdOffset + 2 + ifdEntries * 12 + 4 > stream.Length ()) - { - return false; - } - - // Check each entry. - - for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++) - { - - stream.SetReadPosition (ifdOffset + 2 + tag_index * 12); - - stream.Skip (2); // Ignore tag code. - - uint32 tagType = stream.Get_uint16 (); - uint32 tagCount = stream.Get_uint32 (); - - uint32 tag_type_size = TagTypeSize (tagType); - - if (tag_type_size == 0) - { - return false; - } - - uint32 tag_data_size = tagCount * tag_type_size; - - if (tag_data_size > 4) - { - - uint64 tagOffset = stream.Get_uint32 (); - - tagOffset += offsetDelta; - - if (tagOffset + tag_data_size > stream.Length ()) - { - return false; - } - - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_info::ParseIFD (dng_host &host, - dng_stream &stream, - dng_exif *exif, - dng_shared *shared, - dng_ifd *ifd, - uint64 ifdOffset, - int64 offsetDelta, - uint32 parentCode) - { - - #if qDNGValidate - - bool isMakerNote = (parentCode >= tcFirstMakerNoteIFD && - parentCode <= tcLastMakerNoteIFD); - - #endif - - stream.SetReadPosition (ifdOffset); - - if (ifd) - { - ifd->fThisIFD = ifdOffset; - } - - uint32 ifdEntries = stream.Get_uint16 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: Offset = %u, Entries = %u\n\n", - LookupParentCode (parentCode), - (unsigned) ifdOffset, - (unsigned) ifdEntries); - - } - - if ((ifdOffset & 1) && !isMakerNote) - { - - char message [256]; - - sprintf (message, - "%s has odd offset (%u)", - LookupParentCode (parentCode), - (unsigned) ifdOffset); - - ReportWarning (message); - - } - - #endif - - uint32 prev_tag_code = 0; - - for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++) - { - - stream.SetReadPosition (ifdOffset + 2 + tag_index * 12); - - uint32 tagCode = stream.Get_uint16 (); - uint32 tagType = stream.Get_uint16 (); - - // Minolta 7D files have a bug in the EXIF block where the count - // is wrong, and we run off into next IFD link. So if abort parsing - // if we get a zero code/type combinations. - - if (tagCode == 0 && tagType == 0) - { - - #if qDNGValidate - - char message [256]; - - sprintf (message, - "%s had zero/zero tag code/type entry", - LookupParentCode (parentCode)); - - ReportWarning (message); - - #endif - - return; - - } - - uint32 tagCount = stream.Get_uint32 (); - - #if qDNGValidate - - { - - if (tag_index > 0 && tagCode <= prev_tag_code && !isMakerNote) - { - - char message [256]; - - sprintf (message, - "%s tags are not sorted in ascending numerical order", - LookupParentCode (parentCode)); - - ReportWarning (message); - - } - - } - - #endif - - prev_tag_code = tagCode; - - uint32 tag_type_size = TagTypeSize (tagType); - - if (tag_type_size == 0) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s has unknown type (%u)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - (unsigned) tagType); - - ReportWarning (message); - - } - - #endif - - continue; - - } - - uint64 tagOffset = ifdOffset + 2 + tag_index * 12 + 8; - - if (tagCount * tag_type_size > 4) - { - - tagOffset = stream.Get_uint32 (); - - #if qDNGValidate - - { - - if (!(ifdOffset & 1) && - (tagOffset & 1) && - !isMakerNote && - parentCode != tcKodakDCRPrivateIFD && - parentCode != tcKodakKDCPrivateIFD) - { - - char message [256]; - - sprintf (message, - "%s %s has odd data offset (%u)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - (unsigned) tagOffset); - - ReportWarning (message); - - } - - } - - #endif - - tagOffset += offsetDelta; - - stream.SetReadPosition (tagOffset); - - } - - ParseTag (host, - stream, - exif, - shared, - ifd, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset, - offsetDelta); - - } - - stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12); - - uint32 nextIFD = stream.Get_uint32 (); - - #if qDNGValidate - - if (gVerbose) - { - printf ("NextIFD = %u\n", (unsigned) nextIFD); - } - - #endif - - if (ifd) - { - ifd->fNextIFD = nextIFD; - } - - #if qDNGValidate - - if (nextIFD) - { - - if (parentCode != 0 && - (parentCode < tcFirstChainedIFD || - parentCode > tcLastChainedIFD )) - { - - char message [256]; - - sprintf (message, - "%s has an unexpected non-zero NextIFD (%u)", - LookupParentCode (parentCode), - (unsigned) nextIFD); - - ReportWarning (message); - - } - - } - - if (gVerbose) - { - printf ("\n"); - } - - #endif - - } - -/*****************************************************************************/ - -bool dng_info::ParseMakerNoteIFD (dng_host &host, - dng_stream &stream, - uint64 ifdSize, - uint64 ifdOffset, - int64 offsetDelta, - uint64 minOffset, - uint64 maxOffset, - uint32 parentCode) - { - - uint32 tagIndex; - uint32 tagCode; - uint32 tagType; - uint32 tagCount; - - // Assume there is no next IFD pointer. - - fMakerNoteNextIFD = 0; - - // If size is too small to hold a single entry IFD, abort. - - if (ifdSize < 14) - { - return false; - } - - // Get entry count. - - stream.SetReadPosition (ifdOffset); - - uint32 ifdEntries = stream.Get_uint16 (); - - // Make the entry count if reasonable for the MakerNote size. - - if (ifdEntries < 1 || 2 + ifdEntries * 12 > ifdSize) - { - return false; - } - - // Scan IFD to verify all the tag types are all valid. - - for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++) - { - - stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12 + 2); - - tagType = stream.Get_uint16 (); - - // Kludge: Some Canon MakerNotes contain tagType = 0 tags, so we - // need to ignore them. This was a "firmware 1.0.4" Canon 40D raw file. - - if (parentCode == tcCanonMakerNote && tagType == 0) - { - continue; - } - - if (TagTypeSize (tagType) == 0) - { - return false; - } - - } - - // OK, the IFD looks reasonable enough to parse. - - #if qDNGValidate - - if (gVerbose) - { - - printf ("%s: Offset = %u, Entries = %u\n\n", - LookupParentCode (parentCode), - (unsigned) ifdOffset, - (unsigned) ifdEntries); - - } - - #endif - - for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++) - { - - stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12); - - tagCode = stream.Get_uint16 (); - tagType = stream.Get_uint16 (); - tagCount = stream.Get_uint32 (); - - if (tagType == 0) - { - continue; - } - - uint32 tagSize = tagCount * TagTypeSize (tagType); - - uint64 tagOffset = ifdOffset + 2 + tagIndex * 12 + 8; - - if (tagSize > 4) - { - - tagOffset = stream.Get_uint32 () + offsetDelta; - - if (tagOffset < minOffset || - tagOffset + tagSize > maxOffset) - { - - // Tag data is outside the valid offset range, - // so ignore this tag. - - continue; - - } - - stream.SetReadPosition (tagOffset); - - } - - // Olympus switched to using IFDs in version 3 makernotes. - - if (parentCode == tcOlympusMakerNote && - tagType == ttIFD && - tagCount == 1) - { - - uint32 olympusMakerParent = 0; - - switch (tagCode) - { - - case 8208: - olympusMakerParent = tcOlympusMakerNote8208; - break; - - case 8224: - olympusMakerParent = tcOlympusMakerNote8224; - break; - - case 8240: - olympusMakerParent = tcOlympusMakerNote8240; - break; - - case 8256: - olympusMakerParent = tcOlympusMakerNote8256; - break; - - case 8272: - olympusMakerParent = tcOlympusMakerNote8272; - break; - - case 12288: - olympusMakerParent = tcOlympusMakerNote12288; - break; - - default: - break; - - } - - if (olympusMakerParent) - { - - stream.SetReadPosition (tagOffset); - - uint64 subMakerNoteOffset = stream.Get_uint32 () + offsetDelta; - - if (subMakerNoteOffset >= minOffset && - subMakerNoteOffset < maxOffset) - { - - if (ParseMakerNoteIFD (host, - stream, - maxOffset - subMakerNoteOffset, - subMakerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - olympusMakerParent)) - { - - continue; - - } - - } - - } - - stream.SetReadPosition (tagOffset); - - } - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset, - offsetDelta); - - } - - // Grab next IFD pointer, for possible use. - - if (ifdSize >= 2 + ifdEntries * 12 + 4) - { - - stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12); - - fMakerNoteNextIFD = stream.Get_uint32 (); - - } - - #if qDNGValidate - - if (gVerbose) - { - printf ("\n"); - } - - #endif - - return true; - - } - -/*****************************************************************************/ - -void dng_info::ParseMakerNote (dng_host &host, - dng_stream &stream, - uint32 makerNoteCount, - uint64 makerNoteOffset, - int64 offsetDelta, - uint64 minOffset, - uint64 maxOffset) - { - - uint8 firstBytes [16]; - - memset (firstBytes, 0, sizeof (firstBytes)); - - stream.SetReadPosition (makerNoteOffset); - - stream.Get (firstBytes, (uint32) Min_uint64 (sizeof (firstBytes), - makerNoteCount)); - - // Epson MakerNote with header. - - if (memcmp (firstBytes, "EPSON\000\001\000", 8) == 0) - { - - if (makerNoteCount > 8) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 8, - makerNoteOffset + 8, - offsetDelta, - minOffset, - maxOffset, - tcEpsonMakerNote); - - } - - return; - - } - - // Fujifilm MakerNote. - - if (memcmp (firstBytes, "FUJIFILM", 8) == 0) - { - - stream.SetReadPosition (makerNoteOffset + 8); - - TempLittleEndian tempEndian (stream); - - uint32 ifd_offset = stream.Get_uint32 (); - - if (ifd_offset >= 12 && ifd_offset < makerNoteCount) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - ifd_offset, - makerNoteOffset + ifd_offset, - makerNoteOffset, - minOffset, - maxOffset, - tcFujiMakerNote); - - } - - return; - - } - - // Leica MakerNote for models that store entry offsets relative to the start of - // the MakerNote (e.g., M9). - - if ((memcmp (firstBytes, "LEICA\000\000\000", 8) == 0) || - (memcmp (firstBytes, "LEICA0\003\000", 8) == 0) || - (memcmp (firstBytes, "LEICA\000\001\000", 8) == 0) || - (memcmp (firstBytes, "LEICA\000\005\000", 8) == 0)) - { - - if (makerNoteCount > 8) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 8, - makerNoteOffset + 8, - makerNoteOffset, - minOffset, - maxOffset, - tcLeicaMakerNote); - - } - - return; - - } - - // Leica MakerNote for models that store absolute entry offsets (i.e., relative - // to the start of the file, e.g., S2). - - if (memcmp (firstBytes, "LEICA\000\002\377", 8) == 0) - { - - if (makerNoteCount > 8) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 8, - makerNoteOffset + 8, - offsetDelta, - minOffset, - maxOffset, - tcLeicaMakerNote); - - } - - return; - - } - - // Nikon version 2 MakerNote with header. - - if (memcmp (firstBytes, "Nikon\000\002", 7) == 0) - { - - stream.SetReadPosition (makerNoteOffset + 10); - - bool bigEndian = false; - - uint16 endianMark = stream.Get_uint16 (); - - if (endianMark == byteOrderMM) - { - bigEndian = true; - } - - else if (endianMark != byteOrderII) - { - return; - } - - TempBigEndian temp_endian (stream, bigEndian); - - uint16 magic = stream.Get_uint16 (); - - if (magic != 42) - { - return; - } - - uint32 ifd_offset = stream.Get_uint32 (); - - if (ifd_offset >= 8 && ifd_offset < makerNoteCount - 10) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 10 - ifd_offset, - makerNoteOffset + 10 + ifd_offset, - makerNoteOffset + 10, - minOffset, - maxOffset, - tcNikonMakerNote); - - } - - return; - - } - - // Newer version of Olympus MakerNote with byte order mark. - - if (memcmp (firstBytes, "OLYMPUS\000", 8) == 0) - { - - stream.SetReadPosition (makerNoteOffset + 8); - - bool bigEndian = false; - - uint16 endianMark = stream.Get_uint16 (); - - if (endianMark == byteOrderMM) - { - bigEndian = true; - } - - else if (endianMark != byteOrderII) - { - return; - } - - TempBigEndian temp_endian (stream, bigEndian); - - uint16 version = stream.Get_uint16 (); - - if (version != 3) - { - return; - } - - if (makerNoteCount > 12) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 12, - makerNoteOffset + 12, - makerNoteOffset, - minOffset, - maxOffset, - tcOlympusMakerNote); - - } - - return; - - } - - // Olympus MakerNote with header. - - if (memcmp (firstBytes, "OLYMP", 5) == 0) - { - - if (makerNoteCount > 8) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 8, - makerNoteOffset + 8, - offsetDelta, - minOffset, - maxOffset, - tcOlympusMakerNote); - - } - - return; - - } - - // Panasonic MakerNote. - - if (memcmp (firstBytes, "Panasonic\000\000\000", 12) == 0) - { - - if (makerNoteCount > 12) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 12, - makerNoteOffset + 12, - offsetDelta, - minOffset, - maxOffset, - tcPanasonicMakerNote); - - } - - return; - - } - - // Pentax MakerNote. - - if (memcmp (firstBytes, "AOC", 4) == 0) - { - - if (makerNoteCount > 6) - { - - stream.SetReadPosition (makerNoteOffset + 4); - - bool bigEndian = stream.BigEndian (); - - uint16 endianMark = stream.Get_uint16 (); - - if (endianMark == byteOrderMM) - { - bigEndian = true; - } - - else if (endianMark == byteOrderII) - { - bigEndian = false; - } - - TempBigEndian temp_endian (stream, bigEndian); - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 6, - makerNoteOffset + 6, - offsetDelta, - minOffset, - maxOffset, - tcPentaxMakerNote); - - } - - return; - - } - - // Ricoh MakerNote. - - if (memcmp (firstBytes, "RICOH", 5) == 0 || - memcmp (firstBytes, "Ricoh", 5) == 0) - { - - if (makerNoteCount > 8) - { - - TempBigEndian tempEndian (stream); - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 8, - makerNoteOffset + 8, - offsetDelta, - minOffset, - maxOffset, - tcRicohMakerNote); - - } - - return; - - } - - // Nikon MakerNote without header. - - if (fExif->fMake.StartsWith ("NIKON")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcNikonMakerNote); - - return; - - } - - // Canon MakerNote. - - if (fExif->fMake.StartsWith ("CANON")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcCanonMakerNote); - - return; - - } - - // Minolta MakerNote. - - if (fExif->fMake.StartsWith ("MINOLTA" ) || - fExif->fMake.StartsWith ("KONICA MINOLTA")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcMinoltaMakerNote); - - return; - - } - - // Sony MakerNote. - - if (fExif->fMake.StartsWith ("SONY")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcSonyMakerNote); - - return; - - } - - // Kodak MakerNote. - - if (fExif->fMake.StartsWith ("EASTMAN KODAK")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcKodakMakerNote); - - return; - - } - - // Mamiya MakerNote. - - if (fExif->fMake.StartsWith ("Mamiya")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcMamiyaMakerNote); - - // Mamiya uses a MakerNote chain. - - while (fMakerNoteNextIFD) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - offsetDelta + fMakerNoteNextIFD, - offsetDelta, - minOffset, - maxOffset, - tcMamiyaMakerNote); - - } - - return; - - } - - // Nikon MakerNote without header. - - if (fExif->fMake.StartsWith ("Hasselblad")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - offsetDelta, - minOffset, - maxOffset, - tcHasselbladMakerNote); - - return; - - } - - // Samsung MakerNote. - - if (fExif->fMake.StartsWith ("Samsung")) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount, - makerNoteOffset, - makerNoteOffset, - minOffset, - maxOffset, - tcSamsungMakerNote); - - return; - - } - - // Casio MakerNote. - - if (fExif->fMake.StartsWith ("CASIO COMPUTER") && - memcmp (firstBytes, "QVC\000\000\000", 6) == 0) - { - - ParseMakerNoteIFD (host, - stream, - makerNoteCount - 6, - makerNoteOffset + 6, - makerNoteOffset, - minOffset, - maxOffset, - tcCasioMakerNote); - - return; - - } - - } - -/*****************************************************************************/ - -void dng_info::ParseSonyPrivateData (dng_host & /* host */, - dng_stream & /* stream */, - uint64 /* count */, - uint64 /* oldOffset */, - uint64 /* newOffset */) - { - - // Sony private data is encrypted, sorry. - - } - -/*****************************************************************************/ - -void dng_info::ParseDNGPrivateData (dng_host &host, - dng_stream &stream) - { - - if (fShared->fDNGPrivateDataCount < 2) - { - return; - } - - // DNG private data should always start with a null-terminated - // company name, to define the format of the private data. - - dng_string privateName; - - { - - char buffer [64]; - - stream.SetReadPosition (fShared->fDNGPrivateDataOffset); - - uint32 readLength = Min_uint32 (fShared->fDNGPrivateDataCount, - sizeof (buffer) - 1); - - stream.Get (buffer, readLength); - - buffer [readLength] = 0; - - privateName.Set (buffer); - - } - - // Pentax is storing their MakerNote in the DNGPrivateData data. - - if (privateName.StartsWith ("PENTAX" ) || - privateName.StartsWith ("SAMSUNG")) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Parsing Pentax/Samsung DNGPrivateData\n\n"); - } - - #endif - - stream.SetReadPosition (fShared->fDNGPrivateDataOffset + 8); - - bool bigEndian = stream.BigEndian (); - - uint16 endianMark = stream.Get_uint16 (); - - if (endianMark == byteOrderMM) - { - bigEndian = true; - } - - else if (endianMark == byteOrderII) - { - bigEndian = false; - } - - TempBigEndian temp_endian (stream, bigEndian); - - ParseMakerNoteIFD (host, - stream, - fShared->fDNGPrivateDataCount - 10, - fShared->fDNGPrivateDataOffset + 10, - fShared->fDNGPrivateDataOffset, - fShared->fDNGPrivateDataOffset, - fShared->fDNGPrivateDataOffset + fShared->fDNGPrivateDataCount, - tcPentaxMakerNote); - - return; - - } - - // Stop parsing if this is not an Adobe format block. - - if (!privateName.Matches ("Adobe")) - { - return; - } - - TempBigEndian temp_order (stream); - - uint32 section_offset = 6; - - while (section_offset + 8 < fShared->fDNGPrivateDataCount) - { - - stream.SetReadPosition (fShared->fDNGPrivateDataOffset + section_offset); - - uint32 section_key = stream.Get_uint32 (); - uint32 section_count = stream.Get_uint32 (); - - if (section_key == DNG_CHAR4 ('M','a','k','N') && section_count > 6) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found MakerNote inside DNGPrivateData\n\n"); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - uint64 old_offset = stream.Get_uint32 (); - - uint32 tempSize = section_count - 6; - - AutoPtr tempBlock (host.Allocate (tempSize)); - - uint64 positionInOriginalFile = stream.PositionInOriginalFile(); - - stream.Get (tempBlock->Buffer (), tempSize); - - dng_stream tempStream (tempBlock->Buffer (), - tempSize, - positionInOriginalFile); - - tempStream.SetBigEndian (order_mark == byteOrderMM); - - ParseMakerNote (host, - tempStream, - tempSize, - 0, - 0 - old_offset, - 0, - tempSize); - - } - - else if (section_key == DNG_CHAR4 ('S','R','2',' ') && section_count > 6) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found Sony private data inside DNGPrivateData\n\n"); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - uint64 old_offset = stream.Get_uint32 (); - - uint64 new_offset = fShared->fDNGPrivateDataOffset + section_offset + 14; - - TempBigEndian sr2_order (stream, order_mark == byteOrderMM); - - ParseSonyPrivateData (host, - stream, - section_count - 6, - old_offset, - new_offset); - - } - - else if (section_key == DNG_CHAR4 ('R','A','F',' ') && section_count > 4) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found Fuji RAF tags inside DNGPrivateData\n\n"); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - - uint32 tagCount = stream.Get_uint32 (); - - uint64 tagOffset = stream.Position (); - - if (tagCount) - { - - TempBigEndian raf_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - tcFujiRAF, - tcFujiHeader, - ttUndefined, - tagCount, - tagOffset, - 0); - - stream.SetReadPosition (tagOffset + tagCount); - - } - - tagCount = stream.Get_uint32 (); - - tagOffset = stream.Position (); - - if (tagCount) - { - - TempBigEndian raf_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - tcFujiRAF, - tcFujiRawInfo1, - ttUndefined, - tagCount, - tagOffset, - 0); - - stream.SetReadPosition (tagOffset + tagCount); - - } - - tagCount = stream.Get_uint32 (); - - tagOffset = stream.Position (); - - if (tagCount) - { - - TempBigEndian raf_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - tcFujiRAF, - tcFujiRawInfo2, - ttUndefined, - tagCount, - tagOffset, - 0); - - stream.SetReadPosition (tagOffset + tagCount); - - } - - } - - else if (section_key == DNG_CHAR4 ('C','n','t','x') && section_count > 4) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found Contax Raw header inside DNGPrivateData\n\n"); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - - uint32 tagCount = stream.Get_uint32 (); - - uint64 tagOffset = stream.Position (); - - if (tagCount) - { - - TempBigEndian contax_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - tcContaxRAW, - tcContaxHeader, - ttUndefined, - tagCount, - tagOffset, - 0); - - } - - } - - else if (section_key == DNG_CHAR4 ('C','R','W',' ') && section_count > 4) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found Canon CRW tags inside DNGPrivateData\n\n"); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - uint32 entries = stream.Get_uint16 (); - - uint64 crwTagStart = stream.Position (); - - for (uint32 parsePass = 1; parsePass <= 2; parsePass++) - { - - stream.SetReadPosition (crwTagStart); - - for (uint32 index = 0; index < entries; index++) - { - - uint32 tagCode = stream.Get_uint16 (); - - uint32 tagCount = stream.Get_uint32 (); - - uint64 tagOffset = stream.Position (); - - // We need to grab the model id tag first, and then all the - // other tags. - - if ((parsePass == 1) == (tagCode == 0x5834)) - { - - TempBigEndian tag_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - tcCanonCRW, - tagCode, - ttUndefined, - tagCount, - tagOffset, - 0); - - } - - stream.SetReadPosition (tagOffset + tagCount); - - } - - } - - } - - else if (section_count > 4) - { - - uint32 parentCode = 0; - - bool code32 = false; - bool hasType = true; - - switch (section_key) - { - - case DNG_CHAR4 ('M','R','W',' '): - { - parentCode = tcMinoltaMRW; - code32 = true; - hasType = false; - break; - } - - case DNG_CHAR4 ('P','a','n','o'): - { - parentCode = tcPanasonicRAW; - break; - } - - case DNG_CHAR4 ('L','e','a','f'): - { - parentCode = tcLeafMOS; - break; - } - - case DNG_CHAR4 ('K','o','d','a'): - { - parentCode = tcKodakDCRPrivateIFD; - break; - } - - case DNG_CHAR4 ('K','D','C',' '): - { - parentCode = tcKodakKDCPrivateIFD; - break; - } - - default: - break; - - } - - if (parentCode) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("Found %s tags inside DNGPrivateData\n\n", - LookupParentCode (parentCode)); - } - - #endif - - uint16 order_mark = stream.Get_uint16 (); - uint32 entries = stream.Get_uint16 (); - - for (uint32 index = 0; index < entries; index++) - { - - uint32 tagCode = code32 ? stream.Get_uint32 () - : stream.Get_uint16 (); - - uint32 tagType = hasType ? stream.Get_uint16 () - : ttUndefined; - - uint32 tagCount = stream.Get_uint32 (); - - uint32 tagSize = tagCount * TagTypeSize (tagType); - - uint64 tagOffset = stream.Position (); - - TempBigEndian tag_order (stream, order_mark == byteOrderMM); - - ParseTag (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset, - 0); - - stream.SetReadPosition (tagOffset + tagSize); - - } - - } - - } - - section_offset += 8 + section_count; - - if (section_offset & 1) - { - section_offset++; - } - - } - - } - -/*****************************************************************************/ - -void dng_info::Parse (dng_host &host, - dng_stream &stream) - { - - fTIFFBlockOffset = stream.Position (); - - fTIFFBlockOriginalOffset = stream.PositionInOriginalFile (); - - // Check byte order indicator. - - uint16 byteOrder = stream.Get_uint16 (); - - if (byteOrder == byteOrderII) - { - - fBigEndian = false; - - #if qDNGValidate - - if (gVerbose) - { - printf ("\nUses little-endian byte order\n"); - } - - #endif - - stream.SetLittleEndian (); - - } - - else if (byteOrder == byteOrderMM) - { - - fBigEndian = true; - - #if qDNGValidate - - if (gVerbose) - { - printf ("\nUses big-endian byte order\n"); - } - - #endif - - stream.SetBigEndian (); - - } - - else - { - - #if qDNGValidate - - ReportError ("Unknown byte order"); - - #endif - - ThrowBadFormat (); - - } - - // Check "magic number" indicator. - - fMagic = stream.Get_uint16 (); - - #if qDNGValidate - - if (gVerbose) - { - printf ("Magic number = %u\n\n", (unsigned) fMagic); - } - - #endif - - ValidateMagic (); - - // Parse IFD 0. - - uint64 next_offset = stream.Get_uint32 (); - - fExif.Reset (host.Make_dng_exif ()); - - fShared.Reset (host.Make_dng_shared ()); - - fIFD [0].Reset (host.Make_dng_ifd ()); - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - fIFD [0].Get (), - fTIFFBlockOffset + next_offset, - fTIFFBlockOffset, - 0); - - next_offset = fIFD [0]->fNextIFD; - - fIFDCount = 1; - - // Parse chained IFDs. - - while (next_offset) - { - - if (next_offset >= stream.Length ()) - { - - #if qDNGValidate - - { - - ReportWarning ("Chained IFD offset past end of stream"); - - } - - #endif - - break; - - } - - // Some TIFF file writers forget about the next IFD offset, so - // validate the IFD at that offset before parsing it. - - if (!ValidateIFD (stream, - fTIFFBlockOffset + next_offset, - fTIFFBlockOffset)) - { - - #if qDNGValidate - - { - - ReportWarning ("Chained IFD is not valid"); - - } - - #endif - - break; - - } - - if (fChainedIFDCount == kMaxChainedIFDs) - { - - #if qDNGValidate - - { - - ReportWarning ("Chained IFD count exceeds DNG SDK parsing limit"); - - } - - #endif - - break; - - } - - fChainedIFD [fChainedIFDCount].Reset (host.Make_dng_ifd ()); - - ParseIFD (host, - stream, - NULL, - NULL, - fChainedIFD [fChainedIFDCount].Get (), - fTIFFBlockOffset + next_offset, - fTIFFBlockOffset, - tcFirstChainedIFD + fChainedIFDCount); - - next_offset = fChainedIFD [fChainedIFDCount]->fNextIFD; - - fChainedIFDCount++; - - } - - // Parse SubIFDs. - - uint32 searchedIFDs = 0; - - bool tooManySubIFDs = false; - - while (searchedIFDs < fIFDCount && !tooManySubIFDs) - { - - uint32 searchLimit = fIFDCount; - - for (uint32 searchIndex = searchedIFDs; - searchIndex < searchLimit && !tooManySubIFDs; - searchIndex++) - { - - for (uint32 subIndex = 0; - subIndex < fIFD [searchIndex]->fSubIFDsCount; - subIndex++) - { - - if (fIFDCount == kMaxSubIFDs + 1) - { - - tooManySubIFDs = true; - - break; - - } - - stream.SetReadPosition (fIFD [searchIndex]->fSubIFDsOffset + - subIndex * 4); - - uint32 sub_ifd_offset = stream.Get_uint32 (); - - fIFD [fIFDCount].Reset (host.Make_dng_ifd ()); - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - fIFD [fIFDCount].Get (), - fTIFFBlockOffset + sub_ifd_offset, - fTIFFBlockOffset, - tcFirstSubIFD + fIFDCount - 1); - - fIFDCount++; - - } - - searchedIFDs = searchLimit; - - } - - } - - #if qDNGValidate - - { - - if (tooManySubIFDs) - { - - ReportWarning ("SubIFD count exceeds DNG SDK parsing limit"); - - } - - } - - #endif - - // Parse EXIF IFD. - - if (fShared->fExifIFD) - { - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - fTIFFBlockOffset + fShared->fExifIFD, - fTIFFBlockOffset, - tcExifIFD); - - } - - // Parse GPS IFD. - - if (fShared->fGPSInfo) - { - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - fTIFFBlockOffset + fShared->fGPSInfo, - fTIFFBlockOffset, - tcGPSInfo); - - } - - // Parse Interoperability IFD. - - if (fShared->fInteroperabilityIFD) - { - - // Some Kodak KDC files have bogus Interoperability IFDs, so - // validate the IFD before trying to parse it. - - if (ValidateIFD (stream, - fTIFFBlockOffset + fShared->fInteroperabilityIFD, - fTIFFBlockOffset)) - { - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - fTIFFBlockOffset + fShared->fInteroperabilityIFD, - fTIFFBlockOffset, - tcInteroperabilityIFD); - - } - - #if qDNGValidate - - else - { - - ReportWarning ("The Interoperability IFD is not a valid IFD"); - - } - - #endif - - } - - // Parse Kodak DCR Private IFD. - - if (fShared->fKodakDCRPrivateIFD) - { - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - fTIFFBlockOffset + fShared->fKodakDCRPrivateIFD, - fTIFFBlockOffset, - tcKodakDCRPrivateIFD); - - } - - // Parse Kodak KDC Private IFD. - - if (fShared->fKodakKDCPrivateIFD) - { - - ParseIFD (host, - stream, - fExif.Get (), - fShared.Get (), - NULL, - fTIFFBlockOffset + fShared->fKodakKDCPrivateIFD, - fTIFFBlockOffset, - tcKodakKDCPrivateIFD); - - } - - // Parse MakerNote tag. - - if (fShared->fMakerNoteCount) - { - - ParseMakerNote (host, - stream, - (uint32) (fTIFFBlockOffset + fShared->fMakerNoteCount), - fShared->fMakerNoteOffset, - fTIFFBlockOffset, - 0, - stream.Length ()); - - } - - // Parse DNGPrivateData tag. - - if (fShared->fDNGPrivateDataCount && - fShared->fDNGVersion) - { - - ParseDNGPrivateData (host, stream); - - } - - #if qDNGValidate - - // If we are running dng_validate on stand-alone camera profile file, - // complete the validation of the profile. - - if (fMagic == magicExtendedProfile) - { - - dng_camera_profile_info &profileInfo = fShared->fCameraProfile; - - dng_camera_profile profile; - - profile.Parse (stream, profileInfo); - - if (profileInfo.fColorPlanes < 3 || !profile.IsValid (profileInfo.fColorPlanes)) - { - - ReportError ("Invalid camera profile file"); - - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_info::PostParse (dng_host &host) - { - - uint32 index; - - fExif->PostParse (host, *fShared.Get ()); - - fShared->PostParse (host, *fExif.Get ()); - - for (index = 0; index < fIFDCount; index++) - { - - fIFD [index]->PostParse (); - - } - - for (index = 0; index < fChainedIFDCount; index++) - { - - fChainedIFD [index]->PostParse (); - - } - - if (fShared->fDNGVersion != 0) - { - - // Find main IFD. - - fMainIndex = -1; - - for (index = 0; index < fIFDCount; index++) - { - - if (fIFD [index]->fUsesNewSubFileType && - fIFD [index]->fNewSubFileType == sfMainImage) - { - - if (fMainIndex == -1) - { - - fMainIndex = index; - - } - - #if qDNGValidate - - else - { - - ReportError ("Multiple IFDs marked as main image"); - - } - - #endif - - } - - else if (fIFD [index]->fNewSubFileType == sfPreviewImage || - fIFD [index]->fNewSubFileType == sfAltPreviewImage) - { - - // Fill in default color space for DNG previews if not included. - - if (fIFD [index]->fPreviewInfo.fColorSpace == previewColorSpace_MaxEnum) - { - - if (fIFD [index]->fSamplesPerPixel == 1) - { - - fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_GrayGamma22; - - } - - else - { - - fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_sRGB; - - } - - } - - } - - } - - // Deal with lossless JPEG bug in early DNG versions. - - if (fShared->fDNGVersion < dngVersion_1_1_0_0) - { - - if (fMainIndex != -1) - { - - fIFD [fMainIndex]->fLosslessJPEGBug16 = true; - - } - - } - - // Find mask index. - - for (index = 0; index < fIFDCount; index++) - { - - if (fIFD [index]->fNewSubFileType == sfTransparencyMask) - { - - if (fMaskIndex == -1) - { - - fMaskIndex = index; - - } - - #if qDNGValidate - - else - { - - ReportError ("Multiple IFDs marked as transparency mask image"); - - } - - #endif - - } - - } - - // Warn about Chained IFDs. - - #if qDNGValidate - - if (fChainedIFDCount > 0) - { - - ReportWarning ("This file has Chained IFDs, which will be ignored by DNG readers"); - - } - - #endif - - } - - } - -/*****************************************************************************/ - -bool dng_info::IsValidDNG () - { - - // Check shared info. - - if (!fShared->IsValidDNG ()) - { - - return false; - - } - - // Check TIFF magic number. - - if (fMagic != 42) - { - - #if qDNGValidate - - ReportError ("Invalid TIFF magic number"); - - #endif - - return false; - - } - - // Make sure we have a main image IFD. - - if (fMainIndex == -1) - { - - #if qDNGValidate - - ReportError ("Unable to find main image IFD"); - - #endif - - return false; - - } - - // Make sure is each IFD is valid. - - for (uint32 index = 0; index < fIFDCount; index++) - { - - uint32 parentCode = (index == 0 ? 0 : tcFirstSubIFD + index - 1); - - if (!fIFD [index]->IsValidDNG (*fShared.Get (), - parentCode)) - { - - // Only errors in the main and transparency mask IFDs are fatal to parsing. - - if (index == (uint32) fMainIndex || - index == (uint32) fMaskIndex) - { - - return false; - - } - - } - - } - - return true; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_info.h b/third_party/dng_sdk/dng_info.h deleted file mode 100644 index 3ccefd1..0000000 --- a/third_party/dng_sdk/dng_info.h +++ /dev/null @@ -1,163 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_info.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Class for holding top-level information about a DNG image. - */ - -/*****************************************************************************/ - -#ifndef __dng_info__ -#define __dng_info__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_ifd.h" -#include "dng_exif.h" -#include "dng_shared.h" -#include "dng_errors.h" -#include "dng_sdk_limits.h" -#include "dng_auto_ptr.h" - -/*****************************************************************************/ - -/// \brief Top-level structure of DNG file with access to metadata. -/// -/// See \ref spec_dng "DNG 1.1.0 specification" for information on member fields of this class. - -class dng_info - { - - public: - - uint64 fTIFFBlockOffset; - - uint64 fTIFFBlockOriginalOffset; - - bool fBigEndian; - - uint32 fMagic; - - AutoPtr fExif; - - AutoPtr fShared; - - int32 fMainIndex; - - int32 fMaskIndex; - - uint32 fIFDCount; - - AutoPtr fIFD [kMaxSubIFDs + 1]; - - uint32 fChainedIFDCount; - - AutoPtr fChainedIFD [kMaxChainedIFDs]; - - protected: - - uint32 fMakerNoteNextIFD; - - public: - - dng_info (); - - virtual ~dng_info (); - - /// Read dng_info from a dng_stream - /// \param host DNG host used for progress updating, abort testing, buffer allocation, etc. - /// \param stream Stream to read DNG data from. - - virtual void Parse (dng_host &host, - dng_stream &stream); - - /// Must be called immediately after a successful Parse operation. - - virtual void PostParse (dng_host &host); - - /// Test validity of DNG data. - /// \retval true if stream provided a valid DNG. - - virtual bool IsValidDNG (); - - protected: - - virtual void ValidateMagic (); - - virtual void ParseTag (dng_host &host, - dng_stream &stream, - dng_exif *exif, - dng_shared *shared, - dng_ifd *ifd, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset, - int64 offsetDelta); - - virtual bool ValidateIFD (dng_stream &stream, - uint64 ifdOffset, - int64 offsetDelta); - - virtual void ParseIFD (dng_host &host, - dng_stream &stream, - dng_exif *exif, - dng_shared *shared, - dng_ifd *ifd, - uint64 ifdOffset, - int64 offsetDelta, - uint32 parentCode); - - virtual bool ParseMakerNoteIFD (dng_host &host, - dng_stream &stream, - uint64 ifdSize, - uint64 ifdOffset, - int64 offsetDelta, - uint64 minOffset, - uint64 maxOffset, - uint32 parentCode); - - virtual void ParseMakerNote (dng_host &host, - dng_stream &stream, - uint32 makerNoteCount, - uint64 makerNoteOffset, - int64 offsetDelta, - uint64 minOffset, - uint64 maxOffset); - - virtual void ParseSonyPrivateData (dng_host &host, - dng_stream &stream, - uint64 count, - uint64 oldOffset, - uint64 newOffset); - - virtual void ParseDNGPrivateData (dng_host &host, - dng_stream &stream); - - private: - - // Hidden copy constructor and assignment operator. - - dng_info (const dng_info &info); - - dng_info & operator= (const dng_info &info); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_iptc.cpp b/third_party/dng_sdk/dng_iptc.cpp deleted file mode 100644 index 5b51904..0000000 --- a/third_party/dng_sdk/dng_iptc.cpp +++ /dev/null @@ -1,985 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_iptc.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_iptc.h" - -#include "dng_assertions.h" -#include "dng_auto_ptr.h" -#include "dng_memory_stream.h" -#include "dng_stream.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_iptc::dng_iptc () - - : fTitle () - - , fUrgency (-1) - - , fCategory () - - , fSupplementalCategories () - - , fKeywords () - - , fInstructions () - - , fDateTimeCreated () - - , fDigitalCreationDateTime () - - , fAuthors () - , fAuthorsPosition () - - , fCity () - , fState () - , fCountry () - , fCountryCode () - - , fLocation () - - , fTransmissionReference () - - , fHeadline () - - , fCredit () - - , fSource () - - , fCopyrightNotice () - - , fDescription () - , fDescriptionWriter () - - { - - } - -/*****************************************************************************/ - -dng_iptc::~dng_iptc () - { - - } - -/*****************************************************************************/ - -bool dng_iptc::IsEmpty () const - { - - if (fTitle.NotEmpty ()) - { - return false; - } - - if (fUrgency >= 0) - { - return false; - } - - if (fCategory.NotEmpty ()) - { - return false; - } - - if (fSupplementalCategories.Count () > 0) - { - return false; - } - - if (fKeywords.Count () > 0) - { - return false; - } - - if (fInstructions.NotEmpty ()) - { - return false; - } - - if (fDateTimeCreated.IsValid ()) - { - return false; - } - - if (fDigitalCreationDateTime.IsValid ()) - { - return false; - } - - if (fAuthors.Count () != 0 || - fAuthorsPosition.NotEmpty ()) - { - return false; - } - - if (fCity .NotEmpty () || - fState .NotEmpty () || - fCountry.NotEmpty ()) - { - return false; - } - - if (fCountryCode.NotEmpty ()) - { - return false; - } - - if (fLocation.NotEmpty ()) - { - return false; - } - - if (fTransmissionReference.NotEmpty ()) - { - return false; - } - - if (fHeadline.NotEmpty ()) - { - return false; - } - - if (fCredit.NotEmpty ()) - { - return false; - } - - if (fSource.NotEmpty ()) - { - return false; - } - - if (fCopyrightNotice.NotEmpty ()) - { - return false; - } - - if (fDescription .NotEmpty () || - fDescriptionWriter.NotEmpty ()) - { - return false; - } - - return true; - - } - -/*****************************************************************************/ - -void dng_iptc::ParseString (dng_stream &stream, - dng_string &s, - CharSet charSet) - { - - uint32 length = stream.Get_uint16 (); - - dng_memory_data buffer (length + 1); - - char *c = buffer.Buffer_char (); - - stream.Get (c, length); - - c [length] = 0; - - switch (charSet) - { - - case kCharSetUTF8: - { - s.Set_UTF8 (c); - break; - } - - default: - { - s.Set_SystemEncoding (c); - } - - } - - s.SetLineEndingsToNewLines (); - - s.StripLowASCII (); - - s.TrimTrailingBlanks (); - - } - -/*****************************************************************************/ - -void dng_iptc::Parse (const void *blockData, - uint32 blockSize, - uint64 offsetInOriginalFile) - { - - dng_stream stream (blockData, - blockSize, - offsetInOriginalFile); - - stream.SetBigEndian (); - - // Make a first pass though the data, trying to figure out the - // character set. - - CharSet charSet = kCharSetUnknown; - - bool isValidUTF8 = true; - - bool hasEncodingMarker = false; - - uint64 firstOffset = stream.Position (); - - uint64 nextOffset = firstOffset; - - while (nextOffset + 5 < stream.Length ()) - { - - stream.SetReadPosition (nextOffset); - - uint8 firstByte = stream.Get_uint8 (); - - if (firstByte != 0x1C) break; - - uint8 record = stream.Get_uint8 (); - uint8 dataSet = stream.Get_uint8 (); - uint32 dataSize = stream.Get_uint16 (); - - nextOffset = stream.Position () + dataSize; - - if (record == 1) - { - - switch (dataSet) - { - - case 90: - { - - hasEncodingMarker = true; - - if (dataSize == 3) - { - - uint32 byte1 = stream.Get_uint8 (); - uint32 byte2 = stream.Get_uint8 (); - uint32 byte3 = stream.Get_uint8 (); - - if (byte1 == 27 /* Escape */ && - byte2 == 0x25 && - byte3 == 0x47) - { - - charSet = kCharSetUTF8; - - } - - } - - break; - - } - - default: - break; - - } - - } - - else if (record == 2) - { - - dng_memory_data buffer (dataSize + 1); - - char *s = buffer.Buffer_char (); - - stream.Get (s, dataSize); - - s [dataSize] = 0; - - isValidUTF8 = isValidUTF8 && dng_string::IsUTF8 (s); - - } - - } - - // If we don't have an encoding marker, and the data is valid - // UTF-8, then assume that it is UTF-8 (rather than system encoding). - - if (!hasEncodingMarker && isValidUTF8) - { - - charSet = kCharSetUTF8; - - } - - // Make a second pass though the data, actually reading the data. - - nextOffset = firstOffset; - - while (nextOffset + 5 < stream.Length ()) - { - - stream.SetReadPosition (nextOffset); - - uint8 firstByte = stream.Get_uint8 (); - - if (firstByte != 0x1C) break; - - uint8 record = stream.Get_uint8 (); - uint8 dataSet = stream.Get_uint8 (); - uint32 dataSize = stream.Get_uint16 (); - - nextOffset = stream.Position () + dataSize; - - if (record == 2) - { - - stream.SetReadPosition (stream.Position () - 2); - - switch ((DataSet) dataSet) - { - - case kObjectNameSet: - { - ParseString (stream, fTitle, charSet); - break; - } - - case kUrgencySet: - { - - int32 size = stream.Get_uint16 (); - - if (size == 1) - { - - char c = stream.Get_int8 (); - - if (c >= '0' && c <= '9') - { - fUrgency = c - '0'; - } - - } - - break; - - } - - case kCategorySet: - { - ParseString (stream, fCategory, charSet); - break; - } - - case kSupplementalCategoriesSet: - { - - dng_string category; - - ParseString (stream, category, charSet); - - if (category.NotEmpty ()) - { - fSupplementalCategories.Append (category); - } - - break; - - } - - case kKeywordsSet: - { - - dng_string keyword; - - ParseString (stream, keyword, charSet); - - if (keyword.NotEmpty ()) - { - fKeywords.Append (keyword); - } - - break; - - } - - case kSpecialInstructionsSet: - { - ParseString (stream, fInstructions, charSet); - break; - } - - case kDateCreatedSet: - { - - uint32 length = stream.Get_uint16 (); - - if (length == 8) - { - - char date [9]; - - stream.Get (date, 8); - - date [8] = 0; - - fDateTimeCreated.Decode_IPTC_Date (date); - - } - - break; - - } - - case kTimeCreatedSet: - { - - uint32 length = stream.Get_uint16 (); - - if (length >= 4 && length <= 11) - { - - char time [12]; - - stream.Get (time, length); - - time [length] = 0; - - fDateTimeCreated.Decode_IPTC_Time (time); - - } - - break; - - } - - case kDigitalCreationDateSet: - { - - uint32 length = stream.Get_uint16 (); - - if (length == 8) - { - - char date [9]; - - stream.Get (date, 8); - - date [8] = 0; - - fDigitalCreationDateTime.Decode_IPTC_Date (date); - - } - - break; - - } - - case kDigitalCreationTimeSet: - { - - uint32 length = stream.Get_uint16 (); - - if (length >= 4 && length <= 11) - { - - char time [12]; - - stream.Get (time, length); - - time [length] = 0; - - fDigitalCreationDateTime.Decode_IPTC_Time (time); - - } - - break; - - } - - case kBylineSet: - { - - dng_string author; - - ParseString (stream, author, charSet); - - if (author.NotEmpty ()) - { - fAuthors.Append (author); - } - - break; - - } - - case kBylineTitleSet: - { - ParseString (stream, fAuthorsPosition, charSet); - break; - } - - case kCitySet: - { - ParseString (stream, fCity, charSet); - break; - } - - case kProvinceStateSet: - { - ParseString (stream, fState, charSet); - break; - } - - case kCountryNameSet: - { - ParseString (stream, fCountry, charSet); - break; - } - - case kCountryCodeSet: - { - ParseString (stream, fCountryCode, charSet); - break; - } - - case kSublocationSet: - { - ParseString (stream, fLocation, charSet); - break; - } - - case kOriginalTransmissionReferenceSet: - { - ParseString (stream, fTransmissionReference, charSet); - break; - } - - case kHeadlineSet: - { - ParseString (stream, fHeadline, charSet); - break; - } - - case kCreditSet: - { - ParseString (stream, fCredit, charSet); - break; - } - - case kSourceSet: - { - ParseString (stream, fSource, charSet); - break; - } - - case kCopyrightNoticeSet: - { - ParseString (stream, fCopyrightNotice, charSet); - break; - } - - case kCaptionSet: - { - ParseString (stream, fDescription, charSet); - break; - } - - case kCaptionWriterSet: - { - ParseString (stream, fDescriptionWriter, charSet); - break; - } - - // All other IPTC records are not part of the IPTC core - // and/or are not kept in sync with XMP tags, so we ignore - // them. - - default: - break; - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_iptc::SpoolString (dng_stream &stream, - const dng_string &s, - uint8 dataSet, - uint32 maxChars, - CharSet charSet) - { - - if (s.IsEmpty ()) - { - return; - } - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (dataSet); - - dng_string ss (s); - - ss.SetLineEndingsToReturns (); - - if (charSet == kCharSetUTF8) - { - - // UTF-8 encoding. - - if (ss.Length () > maxChars) - { - ss.Truncate (maxChars); - } - - uint32 len = ss.Length (); - - stream.Put_uint16 ((uint16) len); - - stream.Put (ss.Get (), len); - - } - - else - { - - // System character set encoding. - - dng_memory_data buffer; - - uint32 len = ss.Get_SystemEncoding (buffer); - - if (len > maxChars) - { - - uint32 lower = 0; - uint32 upper = ss.Length () - 1; - - while (upper > lower) - { - - uint32 middle = (upper + lower + 1) >> 1; - - dng_string sss (ss); - - sss.Truncate (middle); - - len = sss.Get_SystemEncoding (buffer); - - if (len <= maxChars) - { - - lower = middle; - - } - - else - { - - upper = middle - 1; - - } - - } - - ss.Truncate (lower); - - len = ss.Get_SystemEncoding (buffer); - - } - - stream.Put_uint16 ((uint16) len); - - stream.Put (buffer.Buffer_char (), len); - - } - - } -/*****************************************************************************/ - -dng_memory_block * dng_iptc::Spool (dng_memory_allocator &allocator, - bool padForTIFF) - { - - uint32 j; - - char s [64]; - - dng_memory_stream stream (allocator, NULL, 2048); - - stream.SetBigEndian (); - - // Medata working group - now we just always write UTF-8. - - CharSet charSet = kCharSetUTF8; - - // UTF-8 encoding marker. - - if (charSet == kCharSetUTF8) - { - - stream.Put_uint16 (0x1C01); - stream.Put_uint8 (90); - stream.Put_uint16 (3); - stream.Put_uint8 (27); - stream.Put_uint8 (0x25); - stream.Put_uint8 (0x47); - - } - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kRecordVersionSet); - stream.Put_uint16 (2); - stream.Put_uint16 (4); - - SpoolString (stream, - fTitle, - kObjectNameSet, - 64, - charSet); - - if (fUrgency >= 0) - { - - sprintf (s, "%1u", (unsigned) fUrgency); - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kUrgencySet); - - stream.Put_uint16 (1); - - stream.Put (s, 1); - - } - - SpoolString (stream, - fCategory, - kCategorySet, - 3, - charSet); - - for (j = 0; j < fSupplementalCategories.Count (); j++) - { - - SpoolString (stream, - fSupplementalCategories [j], - kSupplementalCategoriesSet, - 32, - charSet); - - } - - for (j = 0; j < fKeywords.Count (); j++) - { - - SpoolString (stream, - fKeywords [j], - kKeywordsSet, - 64, - charSet); - - } - - SpoolString (stream, - fInstructions, - kSpecialInstructionsSet, - 255, - charSet); - - if (fDateTimeCreated.IsValid ()) - { - - dng_string dateString = fDateTimeCreated.Encode_IPTC_Date (); - - if (dateString.NotEmpty ()) - { - - DNG_ASSERT (dateString.Length () == 8, "Wrong length IPTC date"); - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kDateCreatedSet); - - stream.Put_uint16 (8); - - stream.Put (dateString.Get (), 8); - - } - - dng_string timeString = fDateTimeCreated.Encode_IPTC_Time (); - - if (timeString.NotEmpty ()) - { - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kTimeCreatedSet); - - stream.Put_uint16 ((uint16)timeString.Length ()); - - stream.Put (timeString.Get (), timeString.Length ()); - - } - - } - - if (fDigitalCreationDateTime.IsValid ()) - { - - dng_string dateString = fDigitalCreationDateTime.Encode_IPTC_Date (); - - if (dateString.NotEmpty ()) - { - - DNG_ASSERT (dateString.Length () == 8, "Wrong length IPTC date"); - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kDigitalCreationDateSet); - - stream.Put_uint16 (8); - - stream.Put (dateString.Get (), 8); - - } - - dng_string timeString = fDigitalCreationDateTime.Encode_IPTC_Time (); - - if (timeString.NotEmpty ()) - { - - stream.Put_uint16 (0x1C02); - stream.Put_uint8 (kDigitalCreationTimeSet); - - stream.Put_uint16 ((uint16)timeString.Length ()); - - stream.Put (timeString.Get (), timeString.Length ()); - - } - - } - - for (j = 0; j < fAuthors.Count (); j++) - { - - SpoolString (stream, - fAuthors [j], - kBylineSet, - 32, - charSet); - - } - - SpoolString (stream, - fAuthorsPosition, - kBylineTitleSet, - 32, - charSet); - - SpoolString (stream, - fCity, - kCitySet, - 32, - charSet); - - SpoolString (stream, - fLocation, - kSublocationSet, - 32, - charSet); - - SpoolString (stream, - fState, - kProvinceStateSet, - 32, - charSet); - - SpoolString (stream, - fCountryCode, - kCountryCodeSet, - 3, - charSet); - - SpoolString (stream, - fCountry, - kCountryNameSet, - 64, - charSet); - - SpoolString (stream, - fTransmissionReference, - kOriginalTransmissionReferenceSet, - 32, - charSet); - - SpoolString (stream, - fHeadline, - kHeadlineSet, - 255, - charSet); - - SpoolString (stream, - fCredit, - kCreditSet, - 32, - charSet); - - SpoolString (stream, - fSource, - kSourceSet, - 32, - charSet); - - SpoolString (stream, - fCopyrightNotice, - kCopyrightNoticeSet, - 128, - charSet); - - SpoolString (stream, - fDescription, - kCaptionSet, - 2000, - charSet); - - SpoolString (stream, - fDescriptionWriter, - kCaptionWriterSet, - 32, - charSet); - - if (padForTIFF) - { - - while (stream.Length () & 3) - { - stream.Put_uint8 (0); - } - - } - - stream.Flush (); - - return stream.AsMemoryBlock (allocator); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_iptc.h b/third_party/dng_sdk/dng_iptc.h deleted file mode 100644 index 82ebaeb..0000000 --- a/third_party/dng_sdk/dng_iptc.h +++ /dev/null @@ -1,172 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_iptc.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for IPTC metadata within DNG files. - */ - -/*****************************************************************************/ - -#ifndef __dng_iptc__ -#define __dng_iptc__ - -/*****************************************************************************/ - -#include "dng_date_time.h" -#include "dng_string.h" -#include "dng_string_list.h" - -/*****************************************************************************/ - -/// \brief Class for reading and holding IPTC metadata associated with a DNG file. -/// -/// See the \ref spec_iptc "IPTC specification" -/// for information on member fields of this class. - -class dng_iptc - { - - public: - - dng_string fTitle; - - int32 fUrgency; - - dng_string fCategory; - - dng_string_list fSupplementalCategories; - - dng_string_list fKeywords; - - dng_string fInstructions; - - dng_date_time_info fDateTimeCreated; - - dng_date_time_info fDigitalCreationDateTime; - - dng_string_list fAuthors; - - dng_string fAuthorsPosition; - - dng_string fCity; - dng_string fState; - dng_string fCountry; - dng_string fCountryCode; - - dng_string fLocation; - - dng_string fTransmissionReference; - - dng_string fHeadline; - - dng_string fCredit; - - dng_string fSource; - - dng_string fCopyrightNotice; - - dng_string fDescription; - dng_string fDescriptionWriter; - - protected: - - enum DataSet - { - kRecordVersionSet = 0, - kObjectNameSet = 5, - kUrgencySet = 10, - kCategorySet = 15, - kSupplementalCategoriesSet = 20, - kKeywordsSet = 25, - kSpecialInstructionsSet = 40, - kDateCreatedSet = 55, - kTimeCreatedSet = 60, - kDigitalCreationDateSet = 62, - kDigitalCreationTimeSet = 63, - kBylineSet = 80, - kBylineTitleSet = 85, - kCitySet = 90, - kSublocationSet = 92, - kProvinceStateSet = 95, - kCountryCodeSet = 100, - kCountryNameSet = 101, - kOriginalTransmissionReferenceSet = 103, - kHeadlineSet = 105, - kCreditSet = 110, - kSourceSet = 115, - kCopyrightNoticeSet = 116, - kCaptionSet = 120, - kCaptionWriterSet = 122 - }; - - enum CharSet - { - kCharSetUnknown = 0, - kCharSetUTF8 = 1 - }; - - public: - - dng_iptc (); - - virtual ~dng_iptc (); - - /// Test if IPTC metadata exists. - /// \retval true if no IPTC metadata exists for this DNG. - - bool IsEmpty () const; - - /// Test if IPTC metadata exists. - /// \retval true if IPTC metadata exists for this DNG. - - bool NotEmpty () const - { - return !IsEmpty (); - } - - /// Parse a complete block of IPTC data. - /// \param blockData The block of IPTC data. - /// \param blockSize Size in bytes of data block. - /// \param offsetInOriginalFile Used to enable certain file patching operations such as updating date/time in place. - - void Parse (const void *blockData, - uint32 blockSize, - uint64 offsetInOriginalFile); - - /// Serialize IPTC data to a memory block. - /// \param allocator Memory allocator used to acquire memory block. - /// \param padForTIFF Forces length of block to be a multiple of four bytes in accordance with TIFF standard. - /// \retval Memory block - - dng_memory_block * Spool (dng_memory_allocator &allocator, - bool padForTIFF); - - protected: - - void ParseString (dng_stream &stream, - dng_string &s, - CharSet charSet); - - void SpoolString (dng_stream &stream, - const dng_string &s, - uint8 dataSet, - uint32 maxChars, - CharSet charSet); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_jpeg_image.cpp b/third_party/dng_sdk/dng_jpeg_image.cpp deleted file mode 100644 index 362cc83..0000000 --- a/third_party/dng_sdk/dng_jpeg_image.cpp +++ /dev/null @@ -1,385 +0,0 @@ -/*****************************************************************************/ -// Copyright 2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_jpeg_image.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_jpeg_image.h" - -#include "dng_abort_sniffer.h" -#include "dng_area_task.h" -#include "dng_assertions.h" -#include "dng_host.h" -#include "dng_ifd.h" -#include "dng_image.h" -#include "dng_image_writer.h" -#include "dng_memory_stream.h" -#include "dng_mutex.h" - -/*****************************************************************************/ - -dng_jpeg_image::dng_jpeg_image () - - : fImageSize () - , fTileSize () - , fUsesStrips (false) - , fJPEGTables () - , fJPEGData () - - { - - } - -/*****************************************************************************/ - -class dng_jpeg_image_encode_task : public dng_area_task - { - - private: - - dng_host &fHost; - - dng_image_writer &fWriter; - - const dng_image &fImage; - - dng_jpeg_image &fJPEGImage; - - uint32 fTileCount; - - const dng_ifd &fIFD; - - dng_mutex fMutex; - - uint32 fNextTileIndex; - - public: - - dng_jpeg_image_encode_task (dng_host &host, - dng_image_writer &writer, - const dng_image &image, - dng_jpeg_image &jpegImage, - uint32 tileCount, - const dng_ifd &ifd) - - : fHost (host) - , fWriter (writer) - , fImage (image) - , fJPEGImage (jpegImage) - , fTileCount (tileCount) - , fIFD (ifd) - , fMutex ("dng_jpeg_image_encode_task") - , fNextTileIndex (0) - - { - - fMinTaskArea = 16 * 16; - fUnitCell = dng_point (16, 16); - fMaxTileSize = dng_point (16, 16); - - } - - void Process (uint32 /* threadIndex */, - const dng_rect & /* tile */, - dng_abort_sniffer *sniffer) - { - - AutoPtr compressedBuffer; - AutoPtr uncompressedBuffer; - AutoPtr subTileBlockBuffer; - AutoPtr tempBuffer; - - uint32 uncompressedSize = fIFD.fTileLength * - fIFD.fTileWidth * - fIFD.fSamplesPerPixel; - - uncompressedBuffer.Reset (fHost.Allocate (uncompressedSize)); - - uint32 tilesAcross = fIFD.TilesAcross (); - - while (true) - { - - uint32 tileIndex; - - { - - dng_lock_mutex lock (&fMutex); - - if (fNextTileIndex == fTileCount) - { - return; - } - - tileIndex = fNextTileIndex++; - - } - - dng_abort_sniffer::SniffForAbort (sniffer); - - uint32 rowIndex = tileIndex / tilesAcross; - uint32 colIndex = tileIndex % tilesAcross; - - dng_rect tileArea = fIFD.TileArea (rowIndex, colIndex); - - dng_memory_stream stream (fHost.Allocator ()); - - fWriter.WriteTile (fHost, - fIFD, - stream, - fImage, - tileArea, - 1, - compressedBuffer, - uncompressedBuffer, - subTileBlockBuffer, - tempBuffer); - - fJPEGImage.fJPEGData [tileIndex].Reset (stream.AsMemoryBlock (fHost.Allocator ())); - - } - - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_jpeg_image_encode_task (const dng_jpeg_image_encode_task &); - - dng_jpeg_image_encode_task & operator= (const dng_jpeg_image_encode_task &); - - }; - -/*****************************************************************************/ - -void dng_jpeg_image::Encode (dng_host &host, - const dng_negative &negative, - dng_image_writer &writer, - const dng_image &image) - { - - #if qDNGValidate - dng_timer timer ("Encode JPEG Proxy time"); - #endif - - DNG_ASSERT (image.PixelType () == ttByte, "Cannot JPEG encode non-byte image"); - - fImageSize = image.Bounds ().Size (); - - dng_ifd ifd; - - ifd.fImageWidth = fImageSize.h; - ifd.fImageLength = fImageSize.v; - - ifd.fSamplesPerPixel = image.Planes (); - - ifd.fBitsPerSample [0] = 8; - ifd.fBitsPerSample [1] = 8; - ifd.fBitsPerSample [2] = 8; - ifd.fBitsPerSample [3] = 8; - - ifd.fPhotometricInterpretation = piLinearRaw; - - ifd.fCompression = ccLossyJPEG; - - ifd.FindTileSize (512 * 512 * ifd.fSamplesPerPixel); - - fTileSize.h = ifd.fTileWidth; - fTileSize.v = ifd.fTileLength; - - // Need a higher quality for raw proxies than non-raw proxies, - // since users often perform much greater color changes. Also, use - // we are targeting a "large" size proxy (larger than 5MP pixels), or this - // is a full size proxy, then use a higher quality. - - bool useHigherQuality = (uint64) ifd.fImageWidth * - (uint64) ifd.fImageLength > 5000000 || - image.Bounds ().Size () == negative.OriginalDefaultFinalSize (); - - if (negative.ColorimetricReference () == crSceneReferred) - { - ifd.fCompressionQuality = useHigherQuality ? 11 : 10; - } - else - { - ifd.fCompressionQuality = useHigherQuality ? 10 : 8; - } - - uint32 tilesAcross = ifd.TilesAcross (); - uint32 tilesDown = ifd.TilesDown (); - - uint32 tileCount = tilesAcross * tilesDown; - - fJPEGData.Reset (new dng_jpeg_image_tile_ptr [tileCount]); - - uint32 threadCount = Min_uint32 (tileCount, - host.PerformAreaTaskThreads ()); - - dng_jpeg_image_encode_task task (host, - writer, - image, - *this, - tileCount, - ifd); - - host.PerformAreaTask (task, - dng_rect (0, 0, 16, 16 * threadCount)); - - } - -/*****************************************************************************/ - -class dng_jpeg_image_find_digest_task : public dng_area_task - { - - private: - - const dng_jpeg_image &fJPEGImage; - - uint32 fTileCount; - - dng_fingerprint *fDigests; - - dng_mutex fMutex; - - uint32 fNextTileIndex; - - public: - - dng_jpeg_image_find_digest_task (const dng_jpeg_image &jpegImage, - uint32 tileCount, - dng_fingerprint *digests) - - : fJPEGImage (jpegImage) - , fTileCount (tileCount) - , fDigests (digests) - , fMutex ("dng_jpeg_image_find_digest_task") - , fNextTileIndex (0) - - { - - fMinTaskArea = 16 * 16; - fUnitCell = dng_point (16, 16); - fMaxTileSize = dng_point (16, 16); - - } - - void Process (uint32 /* threadIndex */, - const dng_rect & /* tile */, - dng_abort_sniffer *sniffer) - { - - while (true) - { - - uint32 tileIndex; - - { - - dng_lock_mutex lock (&fMutex); - - if (fNextTileIndex == fTileCount) - { - return; - } - - tileIndex = fNextTileIndex++; - - } - - dng_abort_sniffer::SniffForAbort (sniffer); - - dng_md5_printer printer; - - printer.Process (fJPEGImage.fJPEGData [tileIndex]->Buffer (), - fJPEGImage.fJPEGData [tileIndex]->LogicalSize ()); - - fDigests [tileIndex] = printer.Result (); - - } - - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_jpeg_image_find_digest_task (const dng_jpeg_image_find_digest_task &); - - dng_jpeg_image_find_digest_task & operator= (const dng_jpeg_image_find_digest_task &); - - }; - -/*****************************************************************************/ - -dng_fingerprint dng_jpeg_image::FindDigest (dng_host &host) const - { - - uint32 tileCount = TileCount (); - - uint32 arrayCount = tileCount + (fJPEGTables.Get () ? 1 : 0); - - AutoArray digests (new dng_fingerprint [arrayCount]); - - // Compute digest of each compressed tile. - - { - - uint32 threadCount = Min_uint32 (tileCount, - host.PerformAreaTaskThreads ()); - - dng_jpeg_image_find_digest_task task (*this, - tileCount, - digests.Get ()); - - host.PerformAreaTask (task, - dng_rect (0, 0, 16, 16 * threadCount)); - - } - - // Compute digest of JPEG tables, if any. - - if (fJPEGTables.Get ()) - { - - dng_md5_printer printer; - - printer.Process (fJPEGTables->Buffer (), - fJPEGTables->LogicalSize ()); - - digests [tileCount] = printer.Result (); - - } - - // Combine digests into a single digest. - - { - - dng_md5_printer printer; - - for (uint32 k = 0; k < arrayCount; k++) - { - - printer.Process (digests [k].data, - dng_fingerprint::kDNGFingerprintSize); - - } - - return printer.Result (); - - } - - } - -/*****************************************************************************/ - diff --git a/third_party/dng_sdk/dng_jpeg_image.h b/third_party/dng_sdk/dng_jpeg_image.h deleted file mode 100644 index 01748bb..0000000 --- a/third_party/dng_sdk/dng_jpeg_image.h +++ /dev/null @@ -1,92 +0,0 @@ -/*****************************************************************************/ -// Copyright 2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_jpeg_image.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_jpeg_image__ -#define __dng_jpeg_image__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_memory.h" -#include "dng_point.h" - -/*****************************************************************************/ - -typedef AutoPtr dng_jpeg_image_tile_ptr; - -/*****************************************************************************/ - -class dng_jpeg_image - { - - public: - - dng_point fImageSize; - - dng_point fTileSize; - - bool fUsesStrips; - - AutoPtr fJPEGTables; - - AutoArray fJPEGData; - - public: - - dng_jpeg_image (); - - uint32 TilesAcross () const - { - if (fTileSize.h) - { - return (fImageSize.h + fTileSize.h - 1) / fTileSize.h; - } - else - { - return 0; - } - } - - uint32 TilesDown () const - { - if (fTileSize.v) - { - return (fImageSize.v + fTileSize.v - 1) / fTileSize.v; - } - else - { - return 0; - } - } - - uint32 TileCount () const - { - return TilesAcross () * TilesDown (); - } - - void Encode (dng_host &host, - const dng_negative &negative, - dng_image_writer &writer, - const dng_image &image); - - dng_fingerprint FindDigest (dng_host &host) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_lens_correction.cpp b/third_party/dng_sdk/dng_lens_correction.cpp deleted file mode 100644 index 74f3c54..0000000 --- a/third_party/dng_sdk/dng_lens_correction.cpp +++ /dev/null @@ -1,2373 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_lens_correction.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include -#include - -#include "dng_1d_table.h" -#include "dng_assertions.h" -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_filter_task.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_lens_correction.h" -#include "dng_negative.h" -#include "dng_sdk_limits.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -dng_warp_params::dng_warp_params () - - : fPlanes (1) - , fCenter (0.5, 0.5) - - { - - } - -/*****************************************************************************/ - -dng_warp_params::dng_warp_params (uint32 planes, - const dng_point_real64 ¢er) - - : fPlanes (planes) - , fCenter (center) - - { - - DNG_ASSERT (planes >= 1, "Too few planes." ); - DNG_ASSERT (planes <= kMaxColorPlanes, "Too many planes."); - - DNG_ASSERT (fCenter.h >= 0.0 && fCenter.h <= 1.0, - "Center (horizontal) out of range."); - - DNG_ASSERT (fCenter.v >= 0.0 && fCenter.v <= 1.0, - "Center (vertical) out of range."); - - } - -/*****************************************************************************/ - -dng_warp_params::~dng_warp_params () - { - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsNOPAll () const - { - - return IsRadNOPAll () && - IsTanNOPAll (); - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsNOP (uint32 plane) const - { - - return IsRadNOP (plane) && - IsTanNOP (plane); - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsRadNOPAll () const - { - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - if (!IsRadNOP (plane)) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsRadNOP (uint32 /* plane */) const - { - - return false; - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsTanNOPAll () const - { - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - if (!IsTanNOP (plane)) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsTanNOP (uint32 /* plane */) const - { - - return false; - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsValid () const - { - - if (fPlanes < 1 || fPlanes > kMaxColorPlanes) - { - - return false; - - } - - if (fCenter.h < 0.0 || - fCenter.h > 1.0 || - fCenter.v < 0.0 || - fCenter.v > 1.0) - { - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_warp_params::IsValidForNegative (const dng_negative &negative) const - { - - if (!IsValid ()) - { - return false; - } - - if ((fPlanes != 1) && - (fPlanes != negative.ColorChannels ())) - { - return false; - } - - return true; - - } - -/*****************************************************************************/ - -real64 dng_warp_params::EvaluateInverse (uint32 plane, - real64 y) const - { - - const uint32 kMaxIterations = 30; - const real64 kNearZero = 1.0e-10; - - real64 x0 = 0.0; - real64 y0 = Evaluate (plane, - x0); - - real64 x1 = 1.0; - real64 y1 = Evaluate (plane, - x1); - - for (uint32 iteration = 0; iteration < kMaxIterations; iteration++) - { - - if (Abs_real64 (y1 - y0) < kNearZero) - { - break; - } - - const real64 x2 = Pin_real64 (0.0, - x1 + (y - y1) * (x1 - x0) / (y1 - y0), - 1.0); - - const real64 y2 = Evaluate (plane, - x2); - - x0 = x1; - y0 = y1; - - x1 = x2; - y1 = y2; - - } - - return x1; - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params::EvaluateTangential2 (uint32 plane, - const dng_point_real64 &diff) const - { - - const real64 dvdv = diff.v * diff.v; - const real64 dhdh = diff.h * diff.h; - - const real64 rr = dvdv + dhdh; - - dng_point_real64 diffSqr (dvdv, - dhdh); - - return EvaluateTangential (plane, - rr, - diff, - diffSqr); - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params::EvaluateTangential3 (uint32 plane, - real64 r2, - const dng_point_real64 &diff) const - { - - dng_point_real64 diffSqr (diff.v * diff.v, - diff.h * diff.h); - - return EvaluateTangential (plane, - r2, - diff, - diffSqr); - - } - -/*****************************************************************************/ - -void dng_warp_params::Dump () const - { - - #if qDNGValidate - - printf ("Planes: %u\n", (unsigned) fPlanes); - - printf (" Optical center:\n" - " h = %.6lf\n" - " v = %.6lf\n", - fCenter.h, - fCenter.v); - - #endif - - } - -/*****************************************************************************/ - -dng_warp_params_rectilinear::dng_warp_params_rectilinear () - - : dng_warp_params () - - { - - for (uint32 plane = 0; plane < kMaxColorPlanes; plane++) - { - - fRadParams [plane] = dng_vector (4); - fTanParams [plane] = dng_vector (2); - - fRadParams [plane][0] = 1.0; - - } - - } - -/*****************************************************************************/ - -dng_warp_params_rectilinear::dng_warp_params_rectilinear (uint32 planes, - const dng_vector radParams [], - const dng_vector tanParams [], - const dng_point_real64 ¢er) - - : dng_warp_params (planes, - center) - - { - - for (uint32 i = 0; i < fPlanes; i++) - { - fRadParams [i] = radParams [i]; - fTanParams [i] = tanParams [i]; - } - - } - -/*****************************************************************************/ - -dng_warp_params_rectilinear::~dng_warp_params_rectilinear () - { - - } - -/*****************************************************************************/ - -bool dng_warp_params_rectilinear::IsRadNOP (uint32 plane) const - { - - DNG_ASSERT (plane < fPlanes, "plane out of range."); - - const dng_vector &r = fRadParams [plane]; - - return (r [0] == 1.0 && - r [1] == 0.0 && - r [2] == 0.0 && - r [3] == 0.0); - - } - -/*****************************************************************************/ - -bool dng_warp_params_rectilinear::IsTanNOP (uint32 plane) const - { - - DNG_ASSERT (plane < fPlanes, "plane out of range."); - - const dng_vector &t = fTanParams [plane]; - - return (t [0] == 0.0 && - t [1] == 0.0); - - } - -/*****************************************************************************/ - -bool dng_warp_params_rectilinear::IsValid () const - { - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - if (fRadParams [plane].Count () != 4) - { - return false; - } - - if (fTanParams [plane].Count () < 2) - { - return false; - } - - } - - return dng_warp_params::IsValid (); - - } - -/*****************************************************************************/ - -void dng_warp_params_rectilinear::PropagateToAllPlanes (uint32 totalPlanes) - { - - for (uint32 plane = fPlanes; plane < totalPlanes; plane++) - { - - fRadParams [plane] = fRadParams [0]; - fTanParams [plane] = fTanParams [0]; - - } - - } - -/*****************************************************************************/ - -real64 dng_warp_params_rectilinear::Evaluate (uint32 plane, - real64 x) const - { - - const dng_vector &K = fRadParams [plane]; // Coefficients. - - const real64 x2 = x * x; - - return x * (K [0] + x2 * (K [1] + x2 * (K [2] + x2 * K [3]))); - - } - -/*****************************************************************************/ - -real64 dng_warp_params_rectilinear::EvaluateRatio (uint32 plane, - real64 r2) const - { - - const dng_vector &K = fRadParams [plane]; // Coefficients. - - return K [0] + r2 * (K [1] + r2 * (K [2] + r2 * K [3])); - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params_rectilinear::EvaluateTangential (uint32 plane, - real64 r2, - const dng_point_real64 &diff, - const dng_point_real64 &diff2) const - { - - const real64 kt0 = fTanParams [plane][0]; - const real64 kt1 = fTanParams [plane][1]; - - const real64 dh = diff.h; - const real64 dv = diff.v; - - const real64 dhdh = diff2.h; - const real64 dvdv = diff2.v; - - return dng_point_real64 (kt0 * (r2 + 2.0 * dvdv) + (2.0 * kt1 * dh * dv), // v - kt1 * (r2 + 2.0 * dhdh) + (2.0 * kt0 * dh * dv)); // h - - } - -/*****************************************************************************/ - -real64 dng_warp_params_rectilinear::MaxSrcRadiusGap (real64 maxDstGap) const - { - - real64 maxSrcGap = 0.0; - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - const dng_vector &coefs = fRadParams [plane]; - - const real64 k3 = coefs [1]; - const real64 k5 = coefs [2]; - const real64 k7 = coefs [3]; - - // - // Let f (r) be the radius warp function. Consider the function - // - // gap (r) = f (r + maxDstGap) - f (r) - // - // We wish to maximize gap (r) over the domain [0, 1 - maxDstGap]. This will - // give us a reasonable upper bound on the src tile size, independent of - // dstBounds. - // - // As usual, we maximize gap (r) by examining its critical points, i.e., by - // considering the roots of its derivative which lie in the domain [0, 1 - - // maxDstGap]. gap' (r) is a 5th-order polynomial. One of its roots is - // -maxDstGap / 2, which is negative and hence lies outside the domain of - // interest. This leaves 4 other possible roots. We solve for these - // analytically below. - // - - real64 roots [4]; - uint32 numRoots = 0; - - if (k7 == 0.0) - { - - if (k5 == 0.0) - { - - // No roots in [0,1]. - - } - - else - { - - // k7 is zero, but k5 is non-zero. At most two real roots. - - const real64 discrim = 25.0 * (-6.0 * k3 * k5 - 5.0 * k5 * maxDstGap * maxDstGap); - - if (discrim >= 0.0) - { - - // Two real roots. - - const real64 scale = 0.1 * k5; - const real64 offset = -5.0 * maxDstGap * k5; - const real64 sDiscrim = sqrt (discrim); - - roots [numRoots++] = scale * (offset + sDiscrim); - roots [numRoots++] = scale * (offset - sDiscrim); - - } - - } - - } - - else - { - - // k7 is non-zero. Up to 4 real roots. - - const real64 d = maxDstGap; - const real64 d2 = d * d; - const real64 d4 = d2 * d2; - - const real64 discrim = 25.0 * k5 * k5 - - 63.0 * k3 * k7 - + 35.0 * d2 * k5 * k7 - + 49.0 * d4 * k7 * k7; - - if (discrim >= 0.0) - { - - const real64 sDiscrim = 4.0 * k7 * sqrt (discrim); - - const real64 offset = -20.0 * k5 * k7 - 35.0 * d2 * k7 * k7; - - const real64 discrim1 = offset - sDiscrim; - const real64 discrim2 = offset + sDiscrim; - - const real64 scale = sqrt (21.0) / (42.0 * k7); - - if (discrim1 >= 0.0) - { - - const real64 offset1 = -d * 0.5; - const real64 sDiscrim1 = scale * sqrt (discrim1); - - roots [numRoots++] = offset1 + sDiscrim1; - roots [numRoots++] = offset1 - sDiscrim1; - - } - - if (discrim2 >= 0.0) - { - - const real64 offset2 = -d * 0.5; - const real64 sDiscrim2 = scale * sqrt (discrim2); - - roots [numRoots++] = offset2 + sDiscrim2; - roots [numRoots++] = offset2 - sDiscrim2; - - } - - } - - } - - real64 planeMaxSrcGap = 0.0; - - // Examine the endpoints. - - { - - // Check left endpoint: f (maxDstGap) - f (0). Remember that f (0) == 0. - - const real64 gap1 = Evaluate (plane, maxDstGap); - - planeMaxSrcGap = Max_real64 (planeMaxSrcGap, gap1); - - // Check right endpoint: f (1) - f (1 - maxDstGap). - - const real64 gap2 = Evaluate (plane, 1.0) - - Evaluate (plane, 1.0 - maxDstGap); - - planeMaxSrcGap = Max_real64 (planeMaxSrcGap, gap2); - - } - - // Examine the roots we found, if any. - - for (uint32 i = 0; i < numRoots; i++) - { - - const real64 r = roots [i]; - - if (r > 0.0 && r < 1.0 - maxDstGap) - { - - const real64 gap = Evaluate (plane, r + maxDstGap) - - Evaluate (plane, r); - - planeMaxSrcGap = Max_real64 (planeMaxSrcGap, gap); - - } - - } - - maxSrcGap = Max_real64 (maxSrcGap, - planeMaxSrcGap); - - } - - return maxSrcGap; - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params_rectilinear::MaxSrcTanGap (dng_point_real64 minDst, - dng_point_real64 maxDst) const - { - - const real64 v [] = { minDst.v, maxDst.v, 0.0 }; - const real64 h [] = { minDst.h, maxDst.h, 0.0 }; - - dng_point_real64 maxGap; - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - real64 hMin = +FLT_MAX; - real64 hMax = -FLT_MAX; - - real64 vMin = +FLT_MAX; - real64 vMax = -FLT_MAX; - - for (uint32 i = 0; i < 3; i++) - { - - for (uint32 j = 0; j < 3; j++) - { - - dng_point_real64 dstDiff (v [i], - h [j]); - - dng_point_real64 srcDiff = EvaluateTangential2 (plane, - dstDiff); - - hMin = Min_real64 (hMin, srcDiff.h); - hMax = Max_real64 (hMax, srcDiff.h); - - vMin = Min_real64 (vMin, srcDiff.v); - vMax = Max_real64 (vMax, srcDiff.v); - - } - - } - - const real64 hGap = hMax - hMin; - const real64 vGap = vMax - vMin; - - maxGap.h = Max_real64 (maxGap.h, hGap); - maxGap.v = Max_real64 (maxGap.v, vGap); - - } - - return maxGap; - - } - -/*****************************************************************************/ - -void dng_warp_params_rectilinear::Dump () const - { - - #if qDNGValidate - - dng_warp_params::Dump (); - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - printf (" Plane %u:\n", (unsigned) plane); - - printf (" Radial params: %.6lf, %.6lf, %.6lf, %.6lf\n", - fRadParams [plane][0], - fRadParams [plane][1], - fRadParams [plane][2], - fRadParams [plane][3]); - - printf (" Tangential params: %.6lf, %.6lf\n", - fTanParams [plane][0], - fTanParams [plane][1]); - - } - - #endif - - } - -/*****************************************************************************/ - -dng_warp_params_fisheye::dng_warp_params_fisheye () - - : dng_warp_params () - - { - - for (uint32 plane = 0; plane < kMaxColorPlanes; plane++) - { - - fRadParams [plane] = dng_vector (4); - - } - - } - -/*****************************************************************************/ - -dng_warp_params_fisheye::dng_warp_params_fisheye (uint32 planes, - const dng_vector radParams [], - const dng_point_real64 ¢er) - - : dng_warp_params (planes, center) - - { - - for (uint32 i = 0; i < fPlanes; i++) - { - - fRadParams [i] = radParams [i]; - - } - - } - -/*****************************************************************************/ - -dng_warp_params_fisheye::~dng_warp_params_fisheye () - { - - } - -/*****************************************************************************/ - -bool dng_warp_params_fisheye::IsRadNOP (uint32 /* plane */) const - { - - return false; - - } - -/*****************************************************************************/ - -bool dng_warp_params_fisheye::IsTanNOP (uint32 /* plane */) const - { - - return true; - - } - -/*****************************************************************************/ - -bool dng_warp_params_fisheye::IsValid () const - { - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - if (fRadParams [plane].Count () != 4) - { - return false; - } - - } - - return dng_warp_params::IsValid (); - - } - -/*****************************************************************************/ - -void dng_warp_params_fisheye::PropagateToAllPlanes (uint32 totalPlanes) - { - - for (uint32 plane = fPlanes; plane < totalPlanes; plane++) - { - - fRadParams [plane] = fRadParams [0]; - - } - - } - -/*****************************************************************************/ - -real64 dng_warp_params_fisheye::Evaluate (uint32 plane, - real64 r) const - { - - const real64 t = atan (r); - - const dng_vector &K = fRadParams [plane]; - - const real64 t2 = t * t; - - return t * (K [0] + t2 * (K [1] + t2 * (K [2] + t2 * K [3]))); - - } - -/*****************************************************************************/ - -real64 dng_warp_params_fisheye::EvaluateRatio (uint32 plane, - real64 rSqr) const - { - - const real64 eps = 1.0e-12; - - if (rSqr < eps) - { - - // r is very close to zero. - - return 1.0; - - } - - const real64 r = sqrt (rSqr); - - return Evaluate (plane, r) / r; - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params_fisheye::EvaluateTangential (uint32 /* plane */, - real64 /* r2 */, - const dng_point_real64 & /* diff */, - const dng_point_real64 & /* diff2 */) const - { - - // This fisheye model does not support tangential warping. - - ThrowProgramError (); - - return dng_point_real64 (0.0, 0.0); - - } - -/*****************************************************************************/ - -real64 dng_warp_params_fisheye::MaxSrcRadiusGap (real64 maxDstGap) const - { - - // - // Let f (r) be the radius warp function. Consider the function - // - // gap (r) = f (r + maxDstGap) - f (r) - // - // We wish to maximize gap (r) over the domain [0, 1 - maxDstGap]. This will - // give us a reasonable upper bound on the src tile size, independent of - // dstBounds. - // - // Ideally, we'd like to maximize gap (r) by examining its critical points, - // i.e., by considering the roots of its derivative which lie in the domain [0, - // 1 - maxDstGap]. However, gap' (r) is too complex to find its roots - // analytically. - // - - real64 maxSrcGap = 0.0; - - DNG_REQUIRE (maxDstGap > 0.0, "maxDstGap must be positive."); - - const real64 kMaxValue = 1.0 - maxDstGap; - - const uint32 kSteps = 128; - - const real64 kNorm = kMaxValue / real64 (kSteps - 1); - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - for (uint32 i = 0; i < kSteps; i++) - { - - const real64 tt = i * kNorm; - - const real64 gap = Evaluate (plane, tt + maxDstGap) - - Evaluate (plane, tt); - - maxSrcGap = Max_real64 (maxSrcGap, - gap); - - } - - } - - return maxSrcGap; - - } - -/*****************************************************************************/ - -dng_point_real64 dng_warp_params_fisheye::MaxSrcTanGap (dng_point_real64 /* minDst */, - dng_point_real64 /* maxDst */) const - { - - // This fisheye model does not support tangential distortion. - - return dng_point_real64 (0.0, 0.0); - - } - -/*****************************************************************************/ - -void dng_warp_params_fisheye::Dump () const - { - - #if qDNGValidate - - dng_warp_params::Dump (); - - for (uint32 plane = 0; plane < fPlanes; plane++) - { - - printf (" Plane %u:\n", (unsigned) plane); - - printf (" Radial params: %.6lf, %.6lf, %.6lf, %.6lf\n", - fRadParams [plane][0], - fRadParams [plane][1], - fRadParams [plane][2], - fRadParams [plane][3]); - - } - - #endif - - } - -/*****************************************************************************/ - -class dng_filter_warp: public dng_filter_task - { - - protected: - - AutoPtr fParams; - - dng_point_real64 fCenter; - - dng_resample_weights_2d fWeights; - - real64 fNormRadius; - real64 fInvNormRadius; - - bool fIsRadNOP; - bool fIsTanNOP; - - const real64 fPixelScaleV; - const real64 fPixelScaleVInv; - - public: - - dng_filter_warp (const dng_image &srcImage, - dng_image &dstImage, - const dng_negative &negative, - AutoPtr ¶ms); - - virtual void Initialize (dng_host &host); - - virtual dng_rect SrcArea (const dng_rect &dstArea); - - virtual dng_point SrcTileSize (const dng_point &dstTileSize); - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer); - - virtual dng_point_real64 GetSrcPixelPosition (const dng_point_real64 &dst, - uint32 plane); - - }; - -/*****************************************************************************/ - -dng_filter_warp::dng_filter_warp (const dng_image &srcImage, - dng_image &dstImage, - const dng_negative &negative, - AutoPtr ¶ms) - - : dng_filter_task (srcImage, - dstImage) - - , fParams (params.Release ()) - - , fCenter () - - , fWeights () - - , fNormRadius (1.0) - , fInvNormRadius (1.0) - - , fIsRadNOP (false) - , fIsTanNOP (false) - - , fPixelScaleV (1.0 / negative.PixelAspectRatio ()) - , fPixelScaleVInv (1.0 / fPixelScaleV) - - { - - // Force float processing. - - fSrcPixelType = ttFloat; - fDstPixelType = ttFloat; - - fIsRadNOP = fParams->IsRadNOPAll (); - fIsTanNOP = fParams->IsTanNOPAll (); - - const uint32 negPlanes = negative.ColorChannels (); - - DNG_ASSERT (negPlanes >= 1, "Too few planes." ); - DNG_ASSERT (negPlanes <= kMaxColorPlanes, "Too many planes."); - - (void) negPlanes; - - // At least one set of params must do something interesting. - - if (fIsRadNOP && fIsTanNOP) - { - ThrowProgramError (); - } - - // Make sure the warp params are valid for this negative. - - if (!fParams->IsValidForNegative (negative)) - { - ThrowBadFormat (); - } - - // Compute center. - - const dng_rect bounds = srcImage.Bounds (); - - fCenter.h = Lerp_real64 ((real64) bounds.l, - (real64) bounds.r, - fParams->fCenter.h); - - fCenter.v = Lerp_real64 ((real64) bounds.t, - (real64) bounds.b, - fParams->fCenter.v); - - // Compute max pixel radius and derive various normalized radius values. Note - // that when computing the max pixel radius, we must take into account the pixel - // aspect ratio. - - { - - dng_rect squareBounds (bounds); - - squareBounds.b = squareBounds.t + - Round_int32 (fPixelScaleV * (real64) squareBounds.H ()); - - const dng_point_real64 squareCenter (Lerp_real64 ((real64) squareBounds.t, - (real64) squareBounds.b, - fParams->fCenter.v), - - Lerp_real64 ((real64) squareBounds.l, - (real64) squareBounds.r, - fParams->fCenter.h)); - - fNormRadius = MaxDistancePointToRect (squareCenter, - squareBounds); - - fInvNormRadius = 1.0 / fNormRadius; - - } - - // Propagate warp params to other planes. - - fParams->PropagateToAllPlanes (fDstPlanes); - - } - -/*****************************************************************************/ - -void dng_filter_warp::Initialize (dng_host &host) - { - - // Make resample weights. - - const dng_resample_function &kernel = dng_resample_bicubic::Get (); - - fWeights.Initialize (kernel, - host.Allocator ()); - - } - -/*****************************************************************************/ - -dng_rect dng_filter_warp::SrcArea (const dng_rect &dstArea) - { - - // Walk each pixel of the boundary of dstArea, map it to the uncorrected src - // pixel position, and return the rectangle that contains all such src pixels. - - int32 xMin = INT_MAX; - int32 xMax = INT_MIN; - int32 yMin = INT_MAX; - int32 yMax = INT_MIN; - - for (uint32 plane = 0; plane < fDstPlanes; plane++) - { - - // Top and bottom edges. - - for (int32 c = dstArea.l; c < dstArea.r; c++) - { - - // Top edge. - - { - - const dng_point_real64 dst (dstArea.t, c); - - const dng_point_real64 src = GetSrcPixelPosition (dst, plane); - - const int32 y = (int32) floor (src.v); - - yMin = Min_int32 (yMin, y); - - } - - // Bottom edge. - - { - - const dng_point_real64 dst (dstArea.b - 1, c); - - const dng_point_real64 src = GetSrcPixelPosition (dst, plane); - - const int32 y = (int32) ceil (src.v); - - yMax = Max_int32 (yMax, y); - - } - - } - - // Left and right edges. - - for (int32 r = dstArea.t; r < dstArea.b; r++) - { - - // Left edge. - - { - - const dng_point_real64 dst (r, dstArea.l); - - const dng_point_real64 src = GetSrcPixelPosition (dst, plane); - - const int32 x = (int32) floor (src.h); - - xMin = Min_int32 (xMin, x); - - } - - // Right edge. - - { - - const dng_point_real64 dst (r, dstArea.r - 1); - - const dng_point_real64 src = GetSrcPixelPosition (dst, plane); - - const int32 x = (int32) ceil (src.h); - - xMax = Max_int32 (xMax, x); - - } - - } - - } - - // Pad each side by filter radius. - - const int32 pad = (int32) fWeights.Radius (); - - xMin -= pad; - yMin -= pad; - xMax += pad; - yMax += pad; - - xMax += 1; - yMax += 1; - - const dng_rect srcArea (yMin, - xMin, - yMax, - xMax); - - return srcArea; - - } - -/*****************************************************************************/ - -dng_point dng_filter_warp::SrcTileSize (const dng_point &dstTileSize) - { - - // Obtain an upper bound on the source tile size. We'll do this by considering - // upper bounds on the radial and tangential warp components separately, then add - // them together. This is not a tight bound but is good enough because the - // tangential terms are usually quite small. - - // Get upper bound on src tile size from radial warp. - - DNG_REQUIRE (dstTileSize.v > 0, "Invalid tile height."); - DNG_REQUIRE (dstTileSize.h > 0, "Invalid tile width."); - - const real64 maxDstGap = fInvNormRadius * hypot ((real64) dstTileSize.h, - (real64) dstTileSize.v); - - dng_point srcTileSize; - - if (maxDstGap >= 1.0) - { - - // The proposed tile size is unusually large, i.e., its hypotenuse is larger - // than the maximum radius. Bite the bullet and just return a tile size big - // enough to process the whole image. - - srcTileSize = SrcArea (fDstImage.Bounds ()).Size (); - - } - - else - { - - // maxDstGap < 1.0. - - const real64 maxSrcGap = fParams->MaxSrcRadiusGap (maxDstGap); - - const int32 dim = (int32) ceil (maxSrcGap * fNormRadius); - - srcTileSize = dng_point (dim, dim); - - } - - srcTileSize.h += (int32) (fWeights.Width ()); - srcTileSize.v += (int32) (fWeights.Width ()); - - // Get upper bound on src tile size from tangential warp. - - const dng_rect_real64 bounds (fSrcImage.Bounds ()); - - const dng_point_real64 minDst ((bounds.t - fCenter.v) * fInvNormRadius, - (bounds.l - fCenter.h) * fInvNormRadius); - - const dng_point_real64 maxDst ((bounds.b - 1.0 - fCenter.v) * fInvNormRadius, - (bounds.r - 1.0 - fCenter.h) * fInvNormRadius); - - const dng_point_real64 srcTanGap = fParams->MaxSrcTanGap (minDst, - maxDst); - - // Add the two bounds together. - - srcTileSize.v += (int32) ceil (srcTanGap.v * fNormRadius); - srcTileSize.h += (int32) ceil (srcTanGap.h * fNormRadius); - - return srcTileSize; - - } - -/*****************************************************************************/ - -void dng_filter_warp::ProcessArea (uint32 /* threadIndex */, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - // Prepare resample constants. - - const int32 wCount = fWeights.Width (); - - const dng_point srcOffset (fWeights.Offset (), - fWeights.Offset ()); - - const real64 numSubsamples = (real64) kResampleSubsampleCount2D; - - // Prepare area and step constants. - - const dng_rect srcArea = srcBuffer.fArea; - const dng_rect dstArea = dstBuffer.fArea; - - const int32 srcRowStep = (int32) srcBuffer.RowStep (); - - const int32 hMin = srcArea.l; - const int32 hMax = srcArea.r - wCount - 1; - - const int32 vMin = srcArea.t; - const int32 vMax = srcArea.b - wCount - 1; - - // Warp each plane. - - for (uint32 plane = 0; plane < dstBuffer.fPlanes; plane++) - { - - real32 *dPtr = dstBuffer.DirtyPixel_real32 (dstArea.t, - dstArea.l, - plane); - - for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) - { - - uint32 dstIndex = 0; - - for (int32 dstCol = dstArea.l; dstCol < dstArea.r; dstCol++, dstIndex++) - { - - // Get destination (corrected) pixel position. - - const dng_point_real64 dPos ((real64) dstRow, - (real64) dstCol); - - // Warp to source (uncorrected) pixel position. - - const dng_point_real64 sPos = GetSrcPixelPosition (dPos, - plane); - - // Decompose into integer and fractional parts. - - dng_point sInt ((int32) floor (sPos.v), - (int32) floor (sPos.h)); - - dng_point sFct ((int32) ((sPos.v - (real64) sInt.v) * numSubsamples), - (int32) ((sPos.h - (real64) sInt.h) * numSubsamples)); - - // Add resample offset. - - sInt = sInt + srcOffset; - - // Clip. - - if (sInt.h < hMin) - { - sInt.h = hMin; - sFct.h = 0; - } - - else if (sInt.h > hMax) - { - sInt.h = hMax; - sFct.h = 0; - } - - if (sInt.v < vMin) - { - sInt.v = vMin; - sFct.v = 0; - } - - else if (sInt.v > vMax) - { - sInt.v = vMax; - sFct.v = 0; - } - - // Perform 2D resample. - - const real32 *w = fWeights.Weights32 (sFct); - - const real32 *s = srcBuffer.ConstPixel_real32 (sInt.v, - sInt.h, - plane); - - real32 total = 0.0f; - - for (int32 i = 0; i < wCount; i++) - { - - for (int32 j = 0; j < wCount; j++) - { - - total += w [j] * s [j]; - - } - - w += wCount; - s += srcRowStep; - - } - - // Store final pixel value. - - dPtr [dstIndex] = Pin_real32 (total); - - } - - // Advance to next row. - - dPtr += dstBuffer.RowStep (); - - } - - } - - } - -/*****************************************************************************/ - -dng_point_real64 dng_filter_warp::GetSrcPixelPosition (const dng_point_real64 &dst, - uint32 plane) - { - - const dng_point_real64 diff = dst - fCenter; - - const dng_point_real64 diffNorm (diff.v * fInvNormRadius, - diff.h * fInvNormRadius); - - const dng_point_real64 diffNormScaled (diffNorm.v * fPixelScaleV, - diffNorm.h); - - const dng_point_real64 diffNormSqr (diffNormScaled.v * diffNormScaled.v, - diffNormScaled.h * diffNormScaled.h); - - const real64 rr = Min_real64 (diffNormSqr.v + diffNormSqr.h, - 1.0); - - dng_point_real64 dSrc; - - if (fIsTanNOP) - { - - // Radial only. - - const real64 ratio = fParams->EvaluateRatio (plane, - rr); - - dSrc.h = diff.h * ratio; - dSrc.v = diff.v * ratio; - - } - - else if (fIsRadNOP) - { - - // Tangential only. - - const dng_point_real64 tan = fParams->EvaluateTangential (plane, - rr, - diffNormScaled, - diffNormSqr); - - dSrc.h = diff.h + (fNormRadius * tan.h); - dSrc.v = diff.v + (fNormRadius * tan.v * fPixelScaleVInv); - - } - - else - { - - // Radial and tangential. - - const real64 ratio = fParams->EvaluateRatio (plane, - rr); - - const dng_point_real64 tan = fParams->EvaluateTangential (plane, - rr, - diffNormScaled, - diffNormSqr); - - dSrc.h = fNormRadius * (diffNorm.h * ratio + tan.h); - dSrc.v = fNormRadius * (diffNorm.v * ratio + tan.v * fPixelScaleVInv); - - } - - return fCenter + dSrc; - - } - -/*****************************************************************************/ - -dng_opcode_WarpRectilinear::dng_opcode_WarpRectilinear (const dng_warp_params_rectilinear ¶ms, - uint32 flags) - - : dng_opcode (dngOpcode_WarpRectilinear, - dngVersion_1_3_0_0, - flags) - - , fWarpParams (params) - - { - - if (!params.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -dng_opcode_WarpRectilinear::dng_opcode_WarpRectilinear (dng_stream &stream) - - : dng_opcode (dngOpcode_WarpRectilinear, - stream, - "WarpRectilinear") - - , fWarpParams () - - { - - // Grab the size in bytes. - - const uint32 bytes = stream.Get_uint32 (); - - // Grab the number of planes to warp. - - fWarpParams.fPlanes = stream.Get_uint32 (); - - // Verify number of planes. - - if (fWarpParams.fPlanes == 0 || - fWarpParams.fPlanes > kMaxColorPlanes) - { - ThrowBadFormat (); - } - - // Verify the size. - - if (bytes != ParamBytes (fWarpParams.fPlanes)) - { - ThrowBadFormat (); - } - - // Read warp parameters for each plane. - - for (uint32 plane = 0; plane < fWarpParams.fPlanes; plane++) - { - - fWarpParams.fRadParams [plane][0] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][1] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][2] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][3] = stream.Get_real64 (); - - fWarpParams.fTanParams [plane][0] = stream.Get_real64 (); - fWarpParams.fTanParams [plane][1] = stream.Get_real64 (); - - } - - // Read the image center. - - fWarpParams.fCenter.h = stream.Get_real64 (); - fWarpParams.fCenter.v = stream.Get_real64 (); - - #if qDNGValidate - - if (gVerbose) - { - - fWarpParams.Dump (); - - } - - #endif - - if (!fWarpParams.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -bool dng_opcode_WarpRectilinear::IsNOP () const - { - - return fWarpParams.IsNOPAll (); - - } - -/*****************************************************************************/ - -bool dng_opcode_WarpRectilinear::IsValidForNegative (const dng_negative &negative) const - { - - return fWarpParams.IsValidForNegative (negative); - - } - -/*****************************************************************************/ - -void dng_opcode_WarpRectilinear::PutData (dng_stream &stream) const - { - - const uint32 bytes = ParamBytes (fWarpParams.fPlanes); - - stream.Put_uint32 (bytes); - - stream.Put_uint32 (fWarpParams.fPlanes); - - for (uint32 plane = 0; plane < fWarpParams.fPlanes; plane++) - { - - stream.Put_real64 (fWarpParams.fRadParams [plane][0]); - stream.Put_real64 (fWarpParams.fRadParams [plane][1]); - stream.Put_real64 (fWarpParams.fRadParams [plane][2]); - stream.Put_real64 (fWarpParams.fRadParams [plane][3]); - - stream.Put_real64 (fWarpParams.fTanParams [plane][0]); - stream.Put_real64 (fWarpParams.fTanParams [plane][1]); - - } - - stream.Put_real64 (fWarpParams.fCenter.h); - stream.Put_real64 (fWarpParams.fCenter.v); - - } - -/*****************************************************************************/ - -void dng_opcode_WarpRectilinear::Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) - { - - #if qDNGValidate - - dng_timer timer ("WarpRectilinear time"); - - #endif - - // Allocate destination image. - - AutoPtr dstImage (host.Make_dng_image (image->Bounds (), - image->Planes (), - image->PixelType ())); - - // Warp the image. - - AutoPtr params (new dng_warp_params_rectilinear (fWarpParams)); - - dng_filter_warp filter (*image, - *dstImage, - negative, - params); - - filter.Initialize (host); - - host.PerformAreaTask (filter, - image->Bounds ()); - - // Return the new image. - - image.Reset (dstImage.Release ()); - - } - -/*****************************************************************************/ - -uint32 dng_opcode_WarpRectilinear::ParamBytes (uint32 planes) - { - - return (1 * (uint32) sizeof (uint32) ) + // Number of planes. - (6 * (uint32) sizeof (real64) * planes) + // Warp coefficients. - (2 * (uint32) sizeof (real64) ); // Optical center. - - } - -/*****************************************************************************/ - -dng_opcode_WarpFisheye::dng_opcode_WarpFisheye (const dng_warp_params_fisheye ¶ms, - uint32 flags) - - : dng_opcode (dngOpcode_WarpFisheye, - dngVersion_1_3_0_0, - flags) - - , fWarpParams (params) - - { - - if (!params.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -dng_opcode_WarpFisheye::dng_opcode_WarpFisheye (dng_stream &stream) - - : dng_opcode (dngOpcode_WarpFisheye, - stream, - "WarpFisheye") - - , fWarpParams () - - { - - // Grab the size in bytes. - - const uint32 bytes = stream.Get_uint32 (); - - // Grab the number of planes to warp. - - fWarpParams.fPlanes = stream.Get_uint32 (); - - // Verify number of planes. - - if (fWarpParams.fPlanes == 0 || - fWarpParams.fPlanes > kMaxColorPlanes) - { - ThrowBadFormat (); - } - - // Verify the size. - - if (bytes != ParamBytes (fWarpParams.fPlanes)) - { - ThrowBadFormat (); - } - - // Read warp parameters for each plane. - - for (uint32 plane = 0; plane < fWarpParams.fPlanes; plane++) - { - - fWarpParams.fRadParams [plane][0] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][1] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][2] = stream.Get_real64 (); - fWarpParams.fRadParams [plane][3] = stream.Get_real64 (); - - } - - // Read the image center. - - fWarpParams.fCenter.h = stream.Get_real64 (); - fWarpParams.fCenter.v = stream.Get_real64 (); - - #if qDNGValidate - - if (gVerbose) - { - - fWarpParams.Dump (); - - } - - #endif - - if (!fWarpParams.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -bool dng_opcode_WarpFisheye::IsNOP () const - { - - return fWarpParams.IsNOPAll (); - - } - -/*****************************************************************************/ - -bool dng_opcode_WarpFisheye::IsValidForNegative (const dng_negative &negative) const - { - - return fWarpParams.IsValidForNegative (negative); - - } - -/*****************************************************************************/ - -void dng_opcode_WarpFisheye::PutData (dng_stream &stream) const - { - - const uint32 bytes = ParamBytes (fWarpParams.fPlanes); - - stream.Put_uint32 (bytes); - - // Write the number of planes. - - stream.Put_uint32 (fWarpParams.fPlanes); - - // Write the warp coefficients. - - for (uint32 plane = 0; plane < fWarpParams.fPlanes; plane++) - { - - stream.Put_real64 (fWarpParams.fRadParams [plane][0]); - stream.Put_real64 (fWarpParams.fRadParams [plane][1]); - stream.Put_real64 (fWarpParams.fRadParams [plane][2]); - stream.Put_real64 (fWarpParams.fRadParams [plane][3]); - - } - - // Write the optical center. - - stream.Put_real64 (fWarpParams.fCenter.h); - stream.Put_real64 (fWarpParams.fCenter.v); - - } - -/*****************************************************************************/ - -void dng_opcode_WarpFisheye::Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) - { - - #if qDNGValidate - - dng_timer timer ("WarpFisheye time"); - - #endif - - // Allocate destination image. - - AutoPtr dstImage (host.Make_dng_image (image->Bounds (), - image->Planes (), - image->PixelType ())); - - // Warp the image. - - AutoPtr params (new dng_warp_params_fisheye (fWarpParams)); - - dng_filter_warp filter (*image, - *dstImage, - negative, - params); - - filter.Initialize (host); - - host.PerformAreaTask (filter, - image->Bounds ()); - - // Return the new image. - - image.Reset (dstImage.Release ()); - - } - -/*****************************************************************************/ - -uint32 dng_opcode_WarpFisheye::ParamBytes (uint32 planes) - { - - return (1 * (uint32) sizeof (uint32) ) + // Number of planes. - (4 * (uint32) sizeof (real64) * planes) + // Warp coefficients. - (2 * (uint32) sizeof (real64) ); // Optical center. - - } - -/*****************************************************************************/ - -dng_vignette_radial_params::dng_vignette_radial_params () - - : fParams (kNumTerms) - , fCenter (0.5, 0.5) - - { - - } - -/*****************************************************************************/ - -dng_vignette_radial_params::dng_vignette_radial_params (const std::vector ¶ms, - const dng_point_real64 ¢er) - - : fParams (params) - , fCenter (center) - - { - - } - -/*****************************************************************************/ - -bool dng_vignette_radial_params::IsNOP () const - { - - for (uint32 i = 0; i < fParams.size (); i++) - { - - if (fParams [i] != 0.0) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_vignette_radial_params::IsValid () const - { - - if (fParams.size () != kNumTerms) - { - return false; - } - - if (fCenter.h < 0.0 || - fCenter.h > 1.0 || - fCenter.v < 0.0 || - fCenter.v > 1.0) - { - return false; - } - - return true; - - } - -/*****************************************************************************/ - -void dng_vignette_radial_params::Dump () const - { - - #if qDNGValidate - - printf (" Radial vignette params: "); - - for (uint32 i = 0; i < fParams.size (); i++) - { - - printf ("%s%.6lf", - (i == 0) ? "" : ", ", - fParams [i]); - - } - - printf ("\n"); - - printf (" Optical center:\n" - " h = %.6lf\n" - " v = %.6lf\n", - fCenter.h, - fCenter.v); - - #endif - - } - -/*****************************************************************************/ - -class dng_vignette_radial_function: public dng_1d_function - { - - protected: - - const dng_vignette_radial_params fParams; - - public: - - explicit dng_vignette_radial_function (const dng_vignette_radial_params ¶ms) - - : fParams (params) - - { - - } - - // x represents r^2, where r is the normalized Euclidean distance from the - // optical center to a pixel. r lies in [0,1], so r^2 (and hence x) also lies - // in [0,1]. - - virtual real64 Evaluate (real64 x) const - { - - DNG_REQUIRE (fParams.fParams.size () == dng_vignette_radial_params::kNumTerms, - "Bad number of vignette opcode coefficients."); - - real64 sum = 0.0; - - const std::vector &v = fParams.fParams; - - for (std::vector::const_reverse_iterator i = v.rbegin (); i != v.rend (); i++) - { - sum = x * ((*i) + sum); - } - - sum += 1.0; - - return sum; - - } - - }; - -/*****************************************************************************/ - -dng_opcode_FixVignetteRadial::dng_opcode_FixVignetteRadial (const dng_vignette_radial_params ¶ms, - uint32 flags) - - : dng_inplace_opcode (dngOpcode_FixVignetteRadial, - dngVersion_1_3_0_0, - flags) - - , fParams (params) - - , fImagePlanes (1) - - , fSrcOriginH (0) - , fSrcOriginV (0) - - , fSrcStepH (0) - , fSrcStepV (0) - - , fTableInputBits (0) - , fTableOutputBits (0) - - , fGainTable () - - { - - if (!params.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -dng_opcode_FixVignetteRadial::dng_opcode_FixVignetteRadial (dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_FixVignetteRadial, - stream, - "FixVignetteRadial") - - , fParams () - - , fImagePlanes (1) - - , fSrcOriginH (0) - , fSrcOriginV (0) - - , fSrcStepH (0) - , fSrcStepV (0) - - , fTableInputBits (0) - , fTableOutputBits (0) - - , fGainTable () - - { - - // Grab the size in bytes. - - const uint32 bytes = stream.Get_uint32 (); - - // Verify the size. - - if (bytes != ParamBytes ()) - { - ThrowBadFormat (); - } - - // Read vignette coefficients. - - fParams.fParams = std::vector (dng_vignette_radial_params::kNumTerms); - - for (uint32 i = 0; i < dng_vignette_radial_params::kNumTerms; i++) - { - fParams.fParams [i] = stream.Get_real64 (); - } - - // Read the image center. - - fParams.fCenter.h = stream.Get_real64 (); - fParams.fCenter.v = stream.Get_real64 (); - - // Debug. - - #if qDNGValidate - - if (gVerbose) - { - - fParams.Dump (); - - } - - #endif - - if (!fParams.IsValid ()) - { - ThrowBadFormat (); - } - - } - -/*****************************************************************************/ - -bool dng_opcode_FixVignetteRadial::IsNOP () const - { - - return fParams.IsNOP (); - - } - -/*****************************************************************************/ - -bool dng_opcode_FixVignetteRadial::IsValidForNegative (const dng_negative & /* negative */) const - { - - return fParams.IsValid (); - - } - -/*****************************************************************************/ - -void dng_opcode_FixVignetteRadial::PutData (dng_stream &stream) const - { - - const uint32 bytes = ParamBytes (); - - stream.Put_uint32 (bytes); - - DNG_REQUIRE (fParams.fParams.size () == dng_vignette_radial_params::kNumTerms, - "Bad number of vignette opcode coefficients."); - - for (uint32 i = 0; i < dng_vignette_radial_params::kNumTerms; i++) - { - stream.Put_real64 (fParams.fParams [i]); - } - - stream.Put_real64 (fParams.fCenter.h); - stream.Put_real64 (fParams.fCenter.v); - - } - -/*****************************************************************************/ - -void dng_opcode_FixVignetteRadial::Prepare (dng_negative &negative, - uint32 threadCount, - const dng_point &tileSize, - const dng_rect &imageBounds, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator &allocator) - { - - // This opcode is restricted to 32-bit images. - - if (bufferPixelType != ttFloat) - { - ThrowBadFormat (); - } - - // Sanity check number of planes. - - DNG_ASSERT (imagePlanes >= 1 && imagePlanes <= kMaxColorPlanes, - "Bad number of planes."); - - if (imagePlanes < 1 || imagePlanes > kMaxColorPlanes) - { - ThrowProgramError (); - } - - fImagePlanes = imagePlanes; - - // Set the vignette correction curve. - - const dng_vignette_radial_function curve (fParams); - - // Grab the destination image area. - - const dng_rect_real64 bounds (imageBounds); - - // Determine the optical center and maximum radius in pixel coordinates. - - const dng_point_real64 centerPixel (Lerp_real64 (bounds.t, - bounds.b, - fParams.fCenter.v), - - Lerp_real64 (bounds.l, - bounds.r, - fParams.fCenter.h)); - - const real64 pixelScaleV = 1.0 / negative.PixelAspectRatio (); - - const real64 maxRadius = hypot (Max_real64 (Abs_real64 (centerPixel.v - bounds.t), - Abs_real64 (centerPixel.v - bounds.b)) * pixelScaleV, - - Max_real64 (Abs_real64 (centerPixel.h - bounds.l), - Abs_real64 (centerPixel.h - bounds.r))); - - const dng_point_real64 radius (maxRadius, - maxRadius); - - // Find origin and scale. - - const real64 pixelScaleH = 1.0; - - fSrcOriginH = Real64ToFixed64 (-centerPixel.h * pixelScaleH / radius.h); - fSrcOriginV = Real64ToFixed64 (-centerPixel.v * pixelScaleV / radius.v); - - fSrcStepH = Real64ToFixed64 (pixelScaleH / radius.h); - fSrcStepV = Real64ToFixed64 (pixelScaleV / radius.v); - - // Adjust for pixel centers. - - fSrcOriginH += fSrcStepH >> 1; - fSrcOriginV += fSrcStepV >> 1; - - // Evaluate 32-bit vignette correction table. - - dng_1d_table table32; - - table32.Initialize (allocator, - curve, - false); - - // Find maximum scale factor. - - const real64 maxScale = Max_real32 (table32.Interpolate (0.0f), - table32.Interpolate (1.0f)); - - // Find table input bits. - - fTableInputBits = 16; - - // Find table output bits. - - fTableOutputBits = 15; - - while ((1 << fTableOutputBits) * maxScale > 65535.0) - { - fTableOutputBits--; - } - - // Allocate 16-bit scale table. - - const uint32 tableEntries = (1 << fTableInputBits) + 1; - - fGainTable.Reset (allocator.Allocate (tableEntries * (uint32) sizeof (uint16))); - - uint16 *table16 = fGainTable->Buffer_uint16 (); - - // Interpolate 32-bit table into 16-bit table. - - const real32 scale0 = 1.0f / (1 << fTableInputBits ); - const real32 scale1 = 1.0f * (1 << fTableOutputBits); - - for (uint32 index = 0; index < tableEntries; index++) - { - - real32 x = index * scale0; - - real32 y = table32.Interpolate (x) * scale1; - - table16 [index] = (uint16) Round_uint32 (y); - - } - - // Prepare vignette mask buffers. - - { - - const uint32 pixelType = ttShort; - const uint32 pixelSize = TagTypeSize (pixelType); - - const uint32 bufferSize = tileSize.v * - RoundUpForPixelSize (tileSize.h, pixelSize) * - pixelSize * - imagePlanes; - - for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) - { - - fMaskBuffers [threadIndex] . Reset (allocator.Allocate (bufferSize)); - - } - - } - - } - -/*****************************************************************************/ - -void dng_opcode_FixVignetteRadial::ProcessArea (dng_negative & /* negative */, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - // Setup mask pixel buffer. - - dng_pixel_buffer maskPixelBuffer; - - maskPixelBuffer.fArea = dstArea; - - maskPixelBuffer.fPlane = 0; - maskPixelBuffer.fPlanes = fImagePlanes; - - maskPixelBuffer.fPixelType = ttShort; - maskPixelBuffer.fPixelSize = TagTypeSize (maskPixelBuffer.fPixelType); - - maskPixelBuffer.fPlaneStep = RoundUpForPixelSize (dstArea.W (), - maskPixelBuffer.fPixelSize); - - maskPixelBuffer.fRowStep = maskPixelBuffer.fPlaneStep * maskPixelBuffer.fPlanes; - - maskPixelBuffer.fData = fMaskBuffers [threadIndex]->Buffer (); - - // Compute mask. - - DoVignetteMask16 (maskPixelBuffer.DirtyPixel_uint16 (dstArea.t, dstArea.l), - dstArea.H (), - dstArea.W (), - maskPixelBuffer.RowStep (), - fSrcOriginH + fSrcStepH * dstArea.l, - fSrcOriginV + fSrcStepV * dstArea.t, - fSrcStepH, - fSrcStepV, - fTableInputBits, - fGainTable->Buffer_uint16 ()); - - // Apply mask. - - DoVignette32 (buffer.DirtyPixel_real32 (dstArea.t, dstArea.l), - maskPixelBuffer.ConstPixel_uint16 (dstArea.t, dstArea.l), - dstArea.H (), - dstArea.W (), - fImagePlanes, - buffer.RowStep (), - buffer.PlaneStep (), - maskPixelBuffer.RowStep (), - fTableOutputBits); - - } - -/*****************************************************************************/ - -uint32 dng_opcode_FixVignetteRadial::ParamBytes () - { - - const uint32 N = dng_vignette_radial_params::kNumTerms; - - return ((N * sizeof (real64)) + // Vignette coefficients. - (2 * sizeof (real64))); // Optical center. - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_lens_correction.h b/third_party/dng_sdk/dng_lens_correction.h deleted file mode 100644 index ae1ca6b..0000000 --- a/third_party/dng_sdk/dng_lens_correction.h +++ /dev/null @@ -1,638 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_lens_correction.h#2 $ */ -/* $DateTime: 2012/08/02 06:09:06 $ */ -/* $Change: 841096 $ */ -/* $Author: erichan $ */ - -/** \file - * Opcodes to fix lens aberrations such as geometric distortion, lateral chromatic - * aberration, and vignetting (peripheral illumination falloff). - */ - -/*****************************************************************************/ - -#ifndef __dng_lens_correction__ -#define __dng_lens_correction__ - -/*****************************************************************************/ - -#include "dng_1d_function.h" -#include "dng_matrix.h" -#include "dng_opcodes.h" -#include "dng_pixel_buffer.h" -#include "dng_point.h" -#include "dng_resample.h" -#include "dng_sdk_limits.h" - -#include - -/*****************************************************************************/ - -/// \brief Abstract base class holding common warp opcode parameters (e.g., -/// number of planes, optical center) and common warp routines. - -class dng_warp_params - { - - public: - - // Number of planes to be warped. Must be either 1 or equal to the - // number of planes of the image to be processed. If set to 1, then a - // single set of warp parameters applies to all planes of the image. - // fPlanes must be at least 1 and no greater than kMaxColorPlanes (see - // dng_sdk_limits.h). - - uint32 fPlanes; - - // The optical center of the lens in normalized [0,1] coordinates with - // respect to the image's active area. For example, a value of (0.5, - // 0.5) indicates that the optical center of the lens is at the center - // of the image's active area. A normalized radius of 1.0 corresponds to - // the distance from fCenter to the farthest corner of the image's - // active area. Each component of fCenter must lie in the range [0,1]. - - dng_point_real64 fCenter; - - public: - - /// Create empty (invalid) warp parameters. - - dng_warp_params (); - - /// Create warp parameters with specified number of planes and image - /// center. - /// - /// \param planes The number of planes of parameters specified: It must - /// be either 1 or equal to the number of planes of the image to be - /// processed. - /// - /// \param fCenter The image center in relative coordinates. - - dng_warp_params (uint32 planes, - const dng_point_real64 &fCenter); - - virtual ~dng_warp_params (); - - /// Is the entire correction a NOP for all planes? - - virtual bool IsNOPAll () const; - - /// Is the entire correction a NOP for the specified plane? - - virtual bool IsNOP (uint32 plane) const; - - /// Is the radial correction a NOP for all planes? - - virtual bool IsRadNOPAll () const; - - /// Is the radial correction a NOP for the specified plane? - - virtual bool IsRadNOP (uint32 plane) const; - - /// Is the tangential correction a NOP for all planes? - - virtual bool IsTanNOPAll () const; - - /// Is the tangential correction a NOP for the specified plane? - - virtual bool IsTanNOP (uint32 plane) const; - - /// Do these warp params appear valid? - - virtual bool IsValid () const; - - /// Are these warp params valid for the specified negative? - - virtual bool IsValidForNegative (const dng_negative &negative) const; - - /// Propagate warp parameters from first plane to all other planes. - - virtual void PropagateToAllPlanes (uint32 totalPlanes) = 0; - - /// Evaluate the 1D radial warp function for the specified plane. - /// Parameter r is the destination (i.e., corrected) normalized radius, - /// i.e., the normalized Euclidean distance between a corrected pixel - /// position and the optical center in the image. r lies in the range - /// [0,1]. The returned result is non-negative. - - virtual real64 Evaluate (uint32 plane, - real64 r) const = 0; - - /// Compute and return the inverse of Evaluate () above. The base - /// implementation uses Newton's method to perform the inversion. - /// Parameter r is the source (i.e., uncorrected) normalized radius, - /// i.e., normalized Euclidean distance between a corrected pixel - /// position and the optical center in the image. Both r and the - /// computed result are non-negative. - - virtual real64 EvaluateInverse (uint32 plane, - real64 r) const; - - /// Evaluate the 1D radial warp ratio function for the specified plane. - /// Parameter r2 is the square of the destination (i.e., corrected) - /// normalized radius, i.e., the square of the normalized Euclidean - /// distance between a corrected pixel position and the optical center - /// in the image. r2 must lie in the range [0,1]. Note that this is - /// different than the Evaluate () function, above, in that the argument - /// to EvaluateRatio () is the square of the radius, not the radius - /// itself. The returned result is non-negative. Mathematically, - /// EvaluateRatio (r * r) is the same as Evaluate (r) / r. - - virtual real64 EvaluateRatio (uint32 plane, - real64 r2) const = 0; - - /// Evaluate the 2D tangential warp for the specified plane. Parameter - /// r2 is the square of the destination (i.e., corrected) normalized - /// radius, i.e., the square of the normalized Euclidean distance - /// between a corrected pixel position P and the optical center in the - /// image. r2 must lie in the range [0,1]. diff contains the vertical - /// and horizontal Euclidean distances (in pixels) between P and the - /// optical center. diff2 contains the squares of the vertical and - /// horizontal Euclidean distances (in pixels) between P and the optical - /// center. The returned result is the tangential warp offset, measured - /// in pixels. - - virtual dng_point_real64 EvaluateTangential (uint32 plane, - real64 r2, - const dng_point_real64 &diff, - const dng_point_real64 &diff2) const = 0; - - /// Evaluate the 2D tangential warp for the specified plane. diff - /// contains the vertical and horizontal Euclidean distances (in pixels) - /// between the destination (i.e., corrected) pixel position and the - /// optical center in the image. The returned result is the tangential - /// warp offset, measured in pixels. - - dng_point_real64 EvaluateTangential2 (uint32 plane, - const dng_point_real64 &diff) const; - - /// Evaluate the 2D tangential warp for the specified plane. Parameter - /// r2 is the square of the destination (i.e., corrected) normalized - /// radius, i.e., the square of the normalized Euclidean distance - /// between a corrected pixel position P and the optical center in the - /// image. r2 must lie in the range [0,1]. diff contains the vertical - /// and horizontal Euclidean distances (in pixels) between P and the - /// optical center. The returned result is the tangential warp offset, - /// measured in pixels. - - dng_point_real64 EvaluateTangential3 (uint32 plane, - real64 r2, - const dng_point_real64 &diff) const; - - /// Compute and return the maximum warped radius gap. Let D be a - /// rectangle in a destination (corrected) image. Let rDstFar and - /// rDstNear be the farthest and nearest points to the image center, - /// respectively. Then the specified parameter maxDstGap is the - /// Euclidean distance between rDstFar and rDstNear. Warp D through this - /// warp function to a closed and bounded (generally not rectangular) - /// region S. Let rSrcfar and rSrcNear be the farthest and nearest - /// points to the image center, respectively. This routine returns a - /// value that is at least (rSrcFar - rSrcNear). - - virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const = 0; - - /// Compute and return the maximum warped tangential gap. minDst is the - /// top-left pixel of the image in normalized pixel coordinates. maxDst - /// is the bottom-right pixel of the image in normalized pixel - /// coordinates. MaxSrcTanGap () computes the maximum absolute shift in - /// normalized pixels in the horizontal and vertical directions that can - /// occur as a result of the tangential warp. - - virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, - dng_point_real64 maxDst) const = 0; - - /// Debug parameters. - - virtual void Dump () const; - - }; - -/*****************************************************************************/ - -/// \brief Warp parameters for pinhole perspective rectilinear (not fisheye) -/// camera model. Supports radial and tangential (decentering) distortion -/// correction parameters. -/// -/// Note the restrictions described below. - -class dng_warp_params_rectilinear: public dng_warp_params - { - - public: - - // Radial and tangential polynomial coefficients. These define a warp - // from corrected pixel coordinates (xDst, yDst) to uncorrected pixel - // coordinates (xSrc, ySrc) for each plane P as follows: - // - // Let kr0 = fRadParams [P][0] - // kr1 = fRadParams [P][1] - // kr2 = fRadParams [P][2] - // kr3 = fRadParams [P][3] - // - // kt0 = fTanParams [P][0] - // kt1 = fTanParams [P][1] - // - // Let (xCenter, yCenter) be the optical image center (see fCenter, - // below) expressed in pixel coordinates. Let maxDist be the Euclidean - // distance (in pixels) from (xCenter, yCenter) to the farthest image - // corner. - // - // First, compute the normalized distance of the corrected pixel - // position (xDst, yDst) from the image center: - // - // dx = (xDst - xCenter) / maxDist - // dy = (yDst - yCenter) / maxDist - // - // r^2 = dx^2 + dy^2 - // - // Compute the radial correction term: - // - // ratio = kr0 + (kr1 * r^2) + (kr2 * r^4) + (kr3 * r^6) - // - // dxRad = dx * ratio - // dyRad = dy * ratio - // - // Compute the tangential correction term: - // - // dxTan = (2 * kt0 * dx * dy) + kt1 * (r^2 + 2 * dx^2) - // dyTan = (2 * kt1 * dx * dy) + kt0 * (r^2 + 2 * dy^2) - // - // Compute the uncorrected pixel position (xSrc, ySrc): - // - // xSrc = xCenter + (dxRad + dxTan) * maxDist - // ySrc = yCenter + (dyRad + dyTan) * maxDist - // - // Mathematical definitions and restrictions: - // - // Let { xSrc, ySrc } = f (xDst, yDst) be the warp function defined - // above. - // - // Let xSrc = fx (xDst, yDst) be the x-component of the warp function. - // Let ySrc = fy (xDst, yDst) be the y-component of the warp function. - // - // f (x, y) must be an invertible function. - // - // fx (x, y) must be an increasing function of x. - // fy (x, y) must be an increasing function of x. - // - // The parameters kr0, kr1, kr2, and kr3 must define an increasing - // radial warp function. Specifically, let w (r) be the radial warp - // function: - // - // w (r) = (kr0 * r) + (kr1 * r^3) + (kr2 * r^5) + (kr3 * r^7). - // - // w (r) must be an increasing function. - - dng_vector fRadParams [kMaxColorPlanes]; - dng_vector fTanParams [kMaxColorPlanes]; - - public: - - /// Create empty (invalid) rectilinear warp parameters. - - dng_warp_params_rectilinear (); - - /// Create rectilinear warp parameters with the specified number of - /// planes, radial component terms, tangential component terms, and - /// image center in relative coordinates. - - dng_warp_params_rectilinear (uint32 planes, - const dng_vector radParams [], - const dng_vector tanParams [], - const dng_point_real64 &fCenter); - - virtual ~dng_warp_params_rectilinear (); - - // Overridden methods. - - virtual bool IsRadNOP (uint32 plane) const; - - virtual bool IsTanNOP (uint32 plane) const; - - virtual bool IsValid () const; - - virtual void PropagateToAllPlanes (uint32 totalPlanes); - - virtual real64 Evaluate (uint32 plane, - real64 r) const; - - virtual real64 EvaluateRatio (uint32 plane, - real64 r2) const; - - virtual dng_point_real64 EvaluateTangential (uint32 plane, - real64 r2, - const dng_point_real64 &diff, - const dng_point_real64 &diff2) const; - - virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const; - - virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, - dng_point_real64 maxDst) const; - - virtual void Dump () const; - - }; - -/*****************************************************************************/ - -/// \brief Warp parameters for fisheye camera model (radial component only). -/// Note the restrictions described below. - -class dng_warp_params_fisheye: public dng_warp_params - { - - public: - - // Radial warp coefficients. These define a warp from corrected pixel - // coordinates (xDst, yDst) to uncorrected pixel coordinates (xSrc, - // ySrc) for each plane P as follows: - // - // Let kr0 = fRadParams [P][0] - // kr1 = fRadParams [P][1] - // kr2 = fRadParams [P][2] - // kr3 = fRadParams [P][3] - // - // Let (xCenter, yCenter) be the optical image center (see fCenter, - // below) expressed in pixel coordinates. Let maxDist be the Euclidean - // distance (in pixels) from (xCenter, yCenter) to the farthest image - // corner. - // - // First, compute the normalized distance of the corrected pixel - // position (xDst, yDst) from the image center: - // - // dx = (xDst - xCenter) / maxDist - // dy = (yDst - yCenter) / maxDist - // - // r = sqrt (dx^2 + dy^2) - // - // Compute the radial correction term: - // - // t = atan (r) - // - // rWarp = (kr0 * t) + (kr1 * t^3) + (kr2 * t^5) + (kr3 * t^7) - // - // ratio = rWarp / r - // - // dxRad = dx * ratio - // dyRad = dy * ratio - // - // Compute the uncorrected pixel position (xSrc, ySrc): - // - // xSrc = xCenter + (dxRad * maxDist) - // ySrc = yCenter + (dyRad * maxDist) - // - // The parameters kr0, kr1, kr2, and kr3 must define an increasing - // radial warp function. Specifically, let w (r) be the radial warp - // function: - // - // t = atan (r) - // - // w (r) = (kr0 * t) + (kr1 * t^3) + (kr2 * t^5) + (kr3 * t^7). - // - // w (r) must be an increasing function. - - dng_vector fRadParams [kMaxColorPlanes]; - - public: - - /// Create empty (invalid) fisheye warp parameters. - - dng_warp_params_fisheye (); - - /// Create rectilinear warp parameters with the specified number of - /// planes, radial component terms, and image center in relative - /// coordinates. - - dng_warp_params_fisheye (uint32 planes, - const dng_vector radParams [], - const dng_point_real64 &fCenter); - - virtual ~dng_warp_params_fisheye (); - - // Overridden methods. - - virtual bool IsRadNOP (uint32 plane) const; - - virtual bool IsTanNOP (uint32 plane) const; - - virtual bool IsValid () const; - - virtual void PropagateToAllPlanes (uint32 totalPlanes); - - virtual real64 Evaluate (uint32 plane, - real64 r) const; - - virtual real64 EvaluateRatio (uint32 plane, - real64 r2) const; - - virtual dng_point_real64 EvaluateTangential (uint32 plane, - real64 r2, - const dng_point_real64 &diff, - const dng_point_real64 &diff2) const; - - virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const; - - virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, - dng_point_real64 maxDst) const; - - virtual void Dump () const; - - }; - -/*****************************************************************************/ - -/// \brief Warp opcode for pinhole perspective (rectilinear) camera model. - -class dng_opcode_WarpRectilinear: public dng_opcode - { - - protected: - - dng_warp_params_rectilinear fWarpParams; - - public: - - dng_opcode_WarpRectilinear (const dng_warp_params_rectilinear ¶ms, - uint32 flags); - - explicit dng_opcode_WarpRectilinear (dng_stream &stream); - - // Overridden methods. - - virtual bool IsNOP () const; - - virtual bool IsValidForNegative (const dng_negative &negative) const; - - virtual void PutData (dng_stream &stream) const; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - protected: - - static uint32 ParamBytes (uint32 planes); - - }; - -/*****************************************************************************/ - -/// \brief Warp opcode for fisheye camera model. - -class dng_opcode_WarpFisheye: public dng_opcode - { - - protected: - - dng_warp_params_fisheye fWarpParams; - - public: - - dng_opcode_WarpFisheye (const dng_warp_params_fisheye ¶ms, - uint32 flags); - - explicit dng_opcode_WarpFisheye (dng_stream &stream); - - // Overridden methods. - - virtual bool IsNOP () const; - - virtual bool IsValidForNegative (const dng_negative &negative) const; - - virtual void PutData (dng_stream &stream) const; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - protected: - - static uint32 ParamBytes (uint32 planes); - - }; - -/*****************************************************************************/ - -/// \brief Radially-symmetric vignette (peripheral illuminational falloff) -/// correction parameters. - -class dng_vignette_radial_params - { - - public: - - static const uint32 kNumTerms = 5; - - public: - - // Let v be an uncorrected pixel value of a pixel p in linear space. - // - // Let r be the Euclidean distance between p and the optical center. - // - // Compute corrected pixel value v' = v * g, where g is the gain. - // - // Let k0 = fParams [0] - // Let k1 = fParams [1] - // Let k2 = fParams [2] - // Let k3 = fParams [3] - // Let k4 = fParams [4] - // - // Gain g = 1 + (k0 * r^2) + (k1 * r^4) + (k2 * r^6) + (k3 * r^8) + (k4 * r^10) - - std::vector fParams; - - dng_point_real64 fCenter; - - public: - - dng_vignette_radial_params (); - - dng_vignette_radial_params (const std::vector ¶ms, - const dng_point_real64 ¢er); - - bool IsNOP () const; - - bool IsValid () const; - - // For debugging. - - void Dump () const; - - }; - -/*****************************************************************************/ - -/// \brief Radially-symmetric lens vignette correction opcode. - -class dng_opcode_FixVignetteRadial: public dng_inplace_opcode - { - - protected: - - dng_vignette_radial_params fParams; - - uint32 fImagePlanes; - - int64 fSrcOriginH; - int64 fSrcOriginV; - - int64 fSrcStepH; - int64 fSrcStepV; - - uint32 fTableInputBits; - uint32 fTableOutputBits; - - AutoPtr fGainTable; - - AutoPtr fMaskBuffers [kMaxMPThreads]; - - public: - - dng_opcode_FixVignetteRadial (const dng_vignette_radial_params ¶ms, - uint32 flags); - - explicit dng_opcode_FixVignetteRadial (dng_stream &stream); - - virtual bool IsNOP () const; - - virtual bool IsValidForNegative (const dng_negative &) const; - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 /* imagePixelType */) - { - return ttFloat; - } - - virtual void Prepare (dng_negative &negative, - uint32 threadCount, - const dng_point &tileSize, - const dng_rect &imageBounds, - uint32 imagePlanes, - uint32 bufferPixelType, - dng_memory_allocator &allocator); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - protected: - - static uint32 ParamBytes (); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_linearization_info.cpp b/third_party/dng_sdk/dng_linearization_info.cpp deleted file mode 100644 index 1c1309b..0000000 --- a/third_party/dng_sdk/dng_linearization_info.cpp +++ /dev/null @@ -1,1517 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_linearization_info.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_linearization_info.h" - -#include "dng_area_task.h" -#include "dng_exceptions.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_info.h" -#include "dng_negative.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_tile_iterator.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -class dng_linearize_plane - { - - private: - - const dng_image & fSrcImage; - dng_image & fDstImage; - - uint32 fPlane; - - dng_rect fActiveArea; - - uint32 fSrcPixelType; - uint32 fDstPixelType; - - bool fReal32; - - real32 fScale; - - AutoPtr fScale_buffer; - - uint32 fBlack_2D_rows; - uint32 fBlack_2D_cols; - - AutoPtr fBlack_2D_buffer; - - uint32 fBlack_1D_rows; - - AutoPtr fBlack_1D_buffer; - - public: - - dng_linearize_plane (dng_host &host, - dng_linearization_info &info, - const dng_image &srcImage, - dng_image &dstImage, - uint32 plane); - - ~dng_linearize_plane (); - - void Process (const dng_rect &tile); - - }; - -/*****************************************************************************/ - -dng_linearize_plane::dng_linearize_plane (dng_host &host, - dng_linearization_info &info, - const dng_image &srcImage, - dng_image &dstImage, - uint32 plane) - - : fSrcImage (srcImage) - , fDstImage (dstImage) - , fPlane (plane) - , fActiveArea (info.fActiveArea) - , fSrcPixelType (srcImage.PixelType ()) - , fDstPixelType (dstImage.PixelType ()) - , fReal32 (false) - , fScale (0.0f) - , fScale_buffer () - , fBlack_2D_rows (0) - , fBlack_2D_cols (0) - , fBlack_2D_buffer () - , fBlack_1D_rows (0) - , fBlack_1D_buffer () - - { - - uint32 j; - uint32 k; - - // Make sure the source pixel type is supported. - - if (fSrcPixelType != ttByte && - fSrcPixelType != ttShort && - fSrcPixelType != ttLong && - fSrcPixelType != ttFloat) - { - - DNG_REPORT ("Unsupported source pixel type"); - - ThrowProgramError (); - - } - - if (fDstPixelType != ttShort && - fDstPixelType != ttFloat) - { - - DNG_REPORT ("Unsupported destination pixel type"); - - ThrowProgramError (); - - } - - if (fSrcPixelType == ttFloat && - fDstPixelType != ttFloat) - { - - DNG_REPORT ("Cannot convert floating point stage1 to non-floating stage2"); - - ThrowProgramError (); - - } - - // Are we using floating point math? - - fReal32 = (fSrcPixelType == ttLong || - fDstPixelType == ttFloat); - - // Find the scale for this plane. - - real64 maxBlack = info.MaxBlackLevel (plane); - - real64 minRange = info.fWhiteLevel [plane] - maxBlack; - - if (minRange <= 0.0) - { - ThrowBadFormat (); - } - - real64 scale = 1.0 / minRange; - - fScale = (real32) scale; - - // Calculate two-dimensional black pattern, if any. - - if (info.fBlackDeltaH.Get ()) - { - - fBlack_2D_rows = info.fBlackLevelRepeatRows; - fBlack_2D_cols = info.fActiveArea.W (); - - } - - else if (info.fBlackLevelRepeatCols > 1) - { - - fBlack_2D_rows = info.fBlackLevelRepeatRows; - fBlack_2D_cols = info.fBlackLevelRepeatCols; - - } - - if (fBlack_2D_rows) - { - - fBlack_2D_buffer.Reset (host.Allocate (fBlack_2D_rows * fBlack_2D_cols * 4)); - - for (j = 0; j < fBlack_2D_rows; j++) - { - - for (k = 0; k < fBlack_2D_cols; k++) - { - - real64 x = info.fBlackLevel [j] - [k % info.fBlackLevelRepeatCols] - [plane]; - - if (info.fBlackDeltaH.Get ()) - { - - x += info.fBlackDeltaH->Buffer_real64 () [k]; - - } - - x *= scale; - - uint32 index = j * fBlack_2D_cols + k; - - if (fReal32) - { - - fBlack_2D_buffer->Buffer_real32 () [index] = (real32) x; - - } - - else - { - - x *= 0x0FFFF * 256.0; - - int32 y = Round_int32 (x); - - fBlack_2D_buffer->Buffer_int32 () [index] = y; - - } - - } - - } - - } - - // Calculate one-dimensional (per row) black pattern, if any. - - if (info.fBlackDeltaV.Get ()) - { - - fBlack_1D_rows = info.fActiveArea.H (); - - } - - else if (fBlack_2D_rows == 0 && - (info.fBlackLevelRepeatRows > 1 || fSrcPixelType != ttShort)) - { - - fBlack_1D_rows = info.fBlackLevelRepeatRows; - - } - - if (fBlack_1D_rows) - { - - fBlack_1D_buffer.Reset (host.Allocate (fBlack_1D_rows * 4)); - - bool allZero = true; - - for (j = 0; j < fBlack_1D_rows; j++) - { - - real64 x = 0.0; - - if (fBlack_2D_rows == 0) - { - - x = info.fBlackLevel [j % info.fBlackLevelRepeatRows] - [0] - [plane]; - - } - - if (info.fBlackDeltaV.Get ()) - { - - x += info.fBlackDeltaV->Buffer_real64 () [j]; - - } - - allZero = allZero && (x == 0.0); - - x *= scale; - - if (fReal32) - { - - fBlack_1D_buffer->Buffer_real32 () [j] = (real32) x; - - } - - else - { - - x *= 0x0FFFF * 256.0; - - int32 y = Round_int32 (x); - - fBlack_1D_buffer->Buffer_int32 () [j] = y; - - } - - } - - if (allZero) - { - - fBlack_1D_rows = 0; - - fBlack_1D_buffer.Reset (); - - } - - } - - // Calculate scale table, if any. - - if (fSrcPixelType != ttLong && - fSrcPixelType != ttFloat) - { - - // Find linearization table, if any. - - uint16 *lut = NULL; - - uint32 lutEntries = 0; - - if (info.fLinearizationTable.Get ()) - { - - lut = info.fLinearizationTable->Buffer_uint16 (); - - lutEntries = info.fLinearizationTable->LogicalSize () >> 1; - - } - - // If the black level does not vary from pixel to pixel, then - // the entire process can be a single LUT. - - if (fBlack_1D_rows == 0 && - fBlack_2D_rows == 0) - { - - fScale_buffer.Reset (host.Allocate (0x10000 * - TagTypeSize (fDstPixelType))); - - for (j = 0; j < 0x10000; j++) - { - - uint32 x = j; - - // Apply linearization table, if any. - - if (lut) - { - - x = Min_uint32 (x, lutEntries - 1); - - x = lut [x]; - - } - - // Subtract constant black level. - - real64 y = x - info.fBlackLevel [0] [0] [plane]; - - // Apply scale. - - y *= scale; - - // We can burn in the clipping also. - - y = Pin_real64 (0.0, y, 1.0); - - // Store output value in table. - - if (fDstPixelType == ttShort) - { - - uint16 z = (uint16) Round_uint32 (y * 0x0FFFF); - - fScale_buffer->Buffer_uint16 () [j] = z; - - } - - else - { - - fScale_buffer->Buffer_real32 () [j] = (real32) y; - - } - - } - - } - - // Else we only do the scaling operation in the scale table. - - else - { - - fScale_buffer.Reset (host.Allocate (0x10000 * 4)); - - for (j = 0; j < 0x10000; j++) - { - - uint32 x = j; - - // Apply linearization table, if any. - - if (lut) - { - - x = Min_uint32 (x, lutEntries - 1); - - x = lut [x]; - - } - - // Apply scale. - - real64 y = x * scale; - - // Store output value in table. - - if (fReal32) - { - - fScale_buffer->Buffer_real32 () [j] = (real32) y; - - } - - else - { - - int32 z = Round_int32 (y * 0x0FFFF * 256.0); - - fScale_buffer->Buffer_int32 () [j] = z; - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_linearize_plane::~dng_linearize_plane () - { - - } - -/*****************************************************************************/ - -void dng_linearize_plane::Process (const dng_rect &srcTile) - { - - // Process tile. - - dng_rect dstTile = srcTile - fActiveArea.TL (); - - dng_const_tile_buffer srcBuffer (fSrcImage, srcTile); - dng_dirty_tile_buffer dstBuffer (fDstImage, dstTile); - - int32 sStep = srcBuffer.fColStep; - int32 dStep = dstBuffer.fColStep; - - uint32 count = srcTile.W (); - - uint32 dstCol = dstTile.l; - - uint32 rows = srcTile.H (); - - for (uint32 row = 0; row < rows; row++) - { - - uint32 dstRow = dstTile.t + row; - - const void *sPtr = srcBuffer.ConstPixel (srcTile.t + row, - srcTile.l, - fPlane); - - void *dPtr = dstBuffer.DirtyPixel (dstRow, - dstCol, - fPlane); - - // Floating point source case. - - if (fSrcPixelType == ttFloat) - { - - real32 scale = fScale; - - const real32 *srcPtr = (const real32 *) sPtr; - - real32 *dstPtr = (real32 *) dPtr; - - // Optimize scale only case, which is the most common. - - if (fBlack_1D_rows == 0 && - fBlack_2D_cols == 0) - { - - for (uint32 j = 0; j < count; j++) - { - - *dstPtr = (*srcPtr) * scale; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - else - { - - real32 b1 = 0.0f; - - if (fBlack_1D_rows) - { - b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows]; - } - - const real32 *b2 = NULL; - - uint32 b2_count = fBlack_2D_cols; - uint32 b2_phase = 0; - - if (b2_count) - { - - b2 = fBlack_2D_buffer->Buffer_real32 () + - b2_count * (dstRow % fBlack_2D_rows); - - b2_phase = dstCol % b2_count; - - } - - for (uint32 j = 0; j < count; j++) - { - - real32 x = (*srcPtr) * scale - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - *dstPtr = x; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - // Simple LUT case. - - else if (fBlack_1D_rows == 0 && - fBlack_2D_rows == 0 && fSrcPixelType != ttLong) - { - - if (fDstPixelType == ttShort) - { - - const uint16 *lut = fScale_buffer->Buffer_uint16 (); - - uint16 *dstPtr = (uint16 *) dPtr; - - if (fSrcPixelType == ttByte) - { - - const uint8 *srcPtr = (const uint8 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - *dstPtr = lut [*srcPtr]; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - else - { - - const uint16 *srcPtr = (const uint16 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - *dstPtr = lut [*srcPtr]; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - else - { - - const real32 *lut = fScale_buffer->Buffer_real32 (); - - real32 *dstPtr = (real32 *) dPtr; - - if (fSrcPixelType == ttByte) - { - - const uint8 *srcPtr = (const uint8 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - *dstPtr = lut [*srcPtr]; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - else - { - - const uint16 *srcPtr = (const uint16 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - *dstPtr = lut [*srcPtr]; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - } - - // Integer math case. - - else if (!fReal32) - { - - const int32 *lut = fScale_buffer->Buffer_int32 (); - - int32 b1 = 0; - - if (fBlack_1D_rows) - { - b1 = fBlack_1D_buffer->Buffer_int32 () [dstRow % fBlack_1D_rows]; - } - - const int32 *b2 = NULL; - - uint32 b2_count = fBlack_2D_cols; - uint32 b2_phase = 0; - - if (b2_count) - { - - b2 = fBlack_2D_buffer->Buffer_int32 () + - b2_count * (dstRow % fBlack_2D_rows); - - b2_phase = dstCol % b2_count; - - } - - uint16 *dstPtr = (uint16 *) dPtr; - - b1 -= 128; // Rounding for 8 bit shift - - if (fSrcPixelType == ttByte) - { - - const uint8 *srcPtr = (const uint8 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - int32 x = lut [*srcPtr] - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x >>= 8; - - *dstPtr = Pin_uint16 (x); - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - else - { - - const uint16 *srcPtr = (const uint16 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - int32 x = lut [*srcPtr] - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x >>= 8; - - *dstPtr = Pin_uint16 (x); - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - // Floating point math cases. - - else - { - - real32 b1 = 0.0f; - - if (fBlack_1D_rows) - { - b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows]; - } - - const real32 *b2 = NULL; - - uint32 b2_count = fBlack_2D_cols; - uint32 b2_phase = 0; - - if (b2_count) - { - - b2 = fBlack_2D_buffer->Buffer_real32 () + - b2_count * (dstRow % fBlack_2D_rows); - - b2_phase = dstCol % b2_count; - - } - - // Case 1: uint8/uint16 -> real32 - - if (fSrcPixelType != ttLong) - { - - const real32 *lut = fScale_buffer->Buffer_real32 (); - - real32 *dstPtr = (real32 *) dPtr; - - if (fSrcPixelType == ttByte) - { - - const uint8 *srcPtr = (const uint8 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - real32 x = lut [*srcPtr] - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x = Pin_real32 (0.0f, x, 1.0f); - - *dstPtr = x; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - else - { - - const uint16 *srcPtr = (const uint16 *) sPtr; - - for (uint32 j = 0; j < count; j++) - { - - real32 x = lut [*srcPtr] - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x = Pin_real32 (0.0f, x, 1.0f); - - *dstPtr = x; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - // Otherwise source is uint32 - - else - { - - real32 scale = fScale; - - const uint32 *srcPtr = (const uint32 *) sPtr; - - // Case 2: uint32 -> real32 - - if (fDstPixelType == ttFloat) - { - - real32 *dstPtr = (real32 *) dPtr; - - for (uint32 j = 0; j < count; j++) - { - - real32 x = ((real32) *srcPtr) * scale - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x = Pin_real32 (0.0f, x, 1.0f); - - *dstPtr = x; - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - // Case 3: uint32 -> uint16 - - else - { - - uint16 *dstPtr = (uint16 *) dPtr; - - real32 dstScale = (real32) 0x0FFFF; - - for (uint32 j = 0; j < count; j++) - { - - real32 x = ((real32) *srcPtr) * scale - b1; - - if (b2_count) - { - - x -= b2 [b2_phase]; - - if (++b2_phase == b2_count) - { - b2_phase = 0; - } - - } - - x = Pin_real32 (0.0f, x, 1.0f); - - *dstPtr = (uint16) (x * dstScale + 0.5f); - - srcPtr += sStep; - dstPtr += dStep; - - } - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -class dng_linearize_image: public dng_area_task - { - - private: - - const dng_image & fSrcImage; - dng_image & fDstImage; - - dng_rect fActiveArea; - - AutoPtr fPlaneTask [kMaxColorPlanes]; - - public: - - dng_linearize_image (dng_host &host, - dng_linearization_info &info, - const dng_image &srcImage, - dng_image &dstImage); - - virtual ~dng_linearize_image (); - - virtual dng_rect RepeatingTile1 () const; - - virtual dng_rect RepeatingTile2 () const; - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer *sniffer); - - }; - -/*****************************************************************************/ - -dng_linearize_image::dng_linearize_image (dng_host &host, - dng_linearization_info &info, - const dng_image &srcImage, - dng_image &dstImage) - - : fSrcImage (srcImage) - , fDstImage (dstImage) - , fActiveArea (info.fActiveArea) - - { - - // Build linearization table for each plane. - - for (uint32 plane = 0; plane < srcImage.Planes (); plane++) - { - - fPlaneTask [plane].Reset (new dng_linearize_plane (host, - info, - srcImage, - dstImage, - plane)); - - } - - // Adjust maximum tile size. - - fMaxTileSize = dng_point (1024, 1024); - - } - -/*****************************************************************************/ - -dng_linearize_image::~dng_linearize_image () - { - - } - -/*****************************************************************************/ - -dng_rect dng_linearize_image::RepeatingTile1 () const - { - - return fSrcImage.RepeatingTile (); - - } - -/*****************************************************************************/ - -dng_rect dng_linearize_image::RepeatingTile2 () const - { - - return fDstImage.RepeatingTile () + fActiveArea.TL (); - - } - -/*****************************************************************************/ - -void dng_linearize_image::Process (uint32 /* threadIndex */, - const dng_rect &srcTile, - dng_abort_sniffer * /* sniffer */) - { - - // Process each plane. - - for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++) - { - - fPlaneTask [plane]->Process (srcTile); - - } - - } - -/*****************************************************************************/ - -dng_linearization_info::dng_linearization_info () - - : fActiveArea () - , fMaskedAreaCount (0) - , fLinearizationTable () - , fBlackLevelRepeatRows (1) - , fBlackLevelRepeatCols (1) - , fBlackDeltaH () - , fBlackDeltaV () - , fBlackDenom (256) - - { - - uint32 j; - uint32 k; - uint32 n; - - for (j = 0; j < kMaxBlackPattern; j++) - for (k = 0; k < kMaxBlackPattern; k++) - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - fBlackLevel [j] [k] [n] = 0.0; - } - - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - fWhiteLevel [n] = 65535.0; - } - - } - -/*****************************************************************************/ - -dng_linearization_info::~dng_linearization_info () - { - - } - -/*****************************************************************************/ - -void dng_linearization_info::RoundBlacks () - { - - uint32 j; - uint32 k; - uint32 n; - - real64 maxAbs = 0.0; - - for (j = 0; j < fBlackLevelRepeatRows; j++) - for (k = 0; k < fBlackLevelRepeatCols; k++) - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - - maxAbs = Max_real64 (maxAbs, - Abs_real64 (fBlackLevel [j] [k] [n])); - - } - - uint32 count = RowBlackCount (); - - for (j = 0; j < count; j++) - { - - maxAbs = Max_real64 (maxAbs, - Abs_real64 (fBlackDeltaV->Buffer_real64 () [j])); - - } - - count = ColumnBlackCount (); - - for (j = 0; j < count; j++) - { - - maxAbs = Max_real64 (maxAbs, - Abs_real64 (fBlackDeltaH->Buffer_real64 () [j])); - - - } - - fBlackDenom = 256; - - while (fBlackDenom > 1 && (maxAbs * fBlackDenom) >= 30000.0 * 65536.0) - { - fBlackDenom >>= 1; - } - - for (j = 0; j < fBlackLevelRepeatRows; j++) - for (k = 0; k < fBlackLevelRepeatCols; k++) - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - - fBlackLevel [j] [k] [n] = BlackLevel (j, k, n).As_real64 (); - - } - - count = RowBlackCount (); - - for (j = 0; j < count; j++) - { - - fBlackDeltaV->Buffer_real64 () [j] = RowBlack (j).As_real64 (); - - } - - count = ColumnBlackCount (); - - for (j = 0; j < count; j++) - { - - fBlackDeltaH->Buffer_real64 () [j] = ColumnBlack (j).As_real64 (); - - } - - } - -/*****************************************************************************/ - -void dng_linearization_info::Parse (dng_host &host, - dng_stream &stream, - dng_info &info) - { - - uint32 j; - uint32 k; - uint32 n; - - // Find main image IFD. - - dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get (); - - // Copy active area. - - fActiveArea = rawIFD.fActiveArea; - - // Copy masked areas. - - fMaskedAreaCount = rawIFD.fMaskedAreaCount; - - for (j = 0; j < fMaskedAreaCount; j++) - { - fMaskedArea [j] = rawIFD.fMaskedArea [j]; - } - - // Read linearization LUT. - - if (rawIFD.fLinearizationTableCount) - { - - uint32 size = rawIFD.fLinearizationTableCount * (uint32) sizeof (uint16); - - fLinearizationTable.Reset (host.Allocate (size)); - - uint16 *table = fLinearizationTable->Buffer_uint16 (); - - stream.SetReadPosition (rawIFD.fLinearizationTableOffset); - - for (j = 0; j < rawIFD.fLinearizationTableCount; j++) - { - table [j] = stream.Get_uint16 (); - } - - } - - // Copy black level pattern. - - fBlackLevelRepeatRows = rawIFD.fBlackLevelRepeatRows; - fBlackLevelRepeatCols = rawIFD.fBlackLevelRepeatCols; - - for (j = 0; j < kMaxBlackPattern; j++) - for (k = 0; k < kMaxBlackPattern; k++) - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - fBlackLevel [j] [k] [n] = rawIFD.fBlackLevel [j] [k] [n]; - } - - // Read BlackDeltaH. - - if (rawIFD.fBlackLevelDeltaHCount) - { - - uint32 size = rawIFD.fBlackLevelDeltaHCount * (uint32) sizeof (real64); - - fBlackDeltaH.Reset (host.Allocate (size)); - - real64 *blacks = fBlackDeltaH->Buffer_real64 (); - - stream.SetReadPosition (rawIFD.fBlackLevelDeltaHOffset); - - for (j = 0; j < rawIFD.fBlackLevelDeltaHCount; j++) - { - blacks [j] = stream.TagValue_real64 (rawIFD.fBlackLevelDeltaHType); - } - - } - - // Read BlackDeltaV. - - if (rawIFD.fBlackLevelDeltaVCount) - { - - uint32 size = rawIFD.fBlackLevelDeltaVCount * (uint32) sizeof (real64); - - fBlackDeltaV.Reset (host.Allocate (size)); - - real64 *blacks = fBlackDeltaV->Buffer_real64 (); - - stream.SetReadPosition (rawIFD.fBlackLevelDeltaVOffset); - - for (j = 0; j < rawIFD.fBlackLevelDeltaVCount; j++) - { - blacks [j] = stream.TagValue_real64 (rawIFD.fBlackLevelDeltaVType); - } - - } - - // Copy white level. - - for (n = 0; n < kMaxSamplesPerPixel; n++) - { - fWhiteLevel [n] = rawIFD.fWhiteLevel [n]; - } - - // Round off black levels. - - RoundBlacks (); - - } - -/*****************************************************************************/ - -void dng_linearization_info::PostParse (dng_host & /* host */, - dng_negative &negative) - { - - if (fActiveArea.IsEmpty ()) - { - - fActiveArea = negative.Stage1Image ()->Bounds (); - - } - - } - -/*****************************************************************************/ - -real64 dng_linearization_info::MaxBlackLevel (uint32 plane) const - { - - uint32 j; - uint32 k; - - // Find maximum value of fBlackDeltaH for each phase of black pattern. - - real64 maxDeltaH [kMaxBlackPattern]; - - for (j = 0; j < fBlackLevelRepeatCols; j++) - { - maxDeltaH [j] = 0.0; - } - - if (fBlackDeltaH.Get ()) - { - - real64 *table = fBlackDeltaH->Buffer_real64 (); - - uint32 entries = fBlackDeltaH->LogicalSize () / (uint32) sizeof (table [0]); - - for (j = 0; j < entries; j++) - { - - real64 &entry = maxDeltaH [j % fBlackLevelRepeatCols]; - - if (j < fBlackLevelRepeatCols) - { - entry = table [j]; - } - else - { - entry = Max_real64 (entry, table [j]); - } - - } - - } - - // Find maximum value of fBlackDeltaV for each phase of black pattern. - - real64 maxDeltaV [kMaxBlackPattern]; - - for (j = 0; j < fBlackLevelRepeatRows; j++) - { - maxDeltaV [j] = 0.0; - } - - if (fBlackDeltaV.Get ()) - { - - real64 *table = fBlackDeltaV->Buffer_real64 (); - - uint32 entries = fBlackDeltaV->LogicalSize () / (uint32) sizeof (table [0]); - - for (j = 0; j < entries; j++) - { - - real64 &entry = maxDeltaV [j % fBlackLevelRepeatRows]; - - if (j < fBlackLevelRepeatRows) - { - entry = table [j]; - } - else - { - entry = Max_real64 (entry, table [j]); - } - - } - - } - - // Now scan the pattern and find the maximum value after row and column - // deltas. - - real64 maxBlack = 0.0; - - for (j = 0; j < fBlackLevelRepeatRows; j++) - { - - for (k = 0; k < fBlackLevelRepeatCols; k++) - { - - real64 black = fBlackLevel [j] [k] [plane]; - - black += maxDeltaH [k]; - black += maxDeltaV [j]; - - if (j == 0 && k == 0) - { - maxBlack = black; - } - else - { - maxBlack = Max_real64 (maxBlack, black); - } - - } - - } - - return maxBlack; - - } - -/*****************************************************************************/ - -void dng_linearization_info::Linearize (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage) - { - - dng_linearize_image processor (host, - *this, - srcImage, - dstImage); - - host.PerformAreaTask (processor, - fActiveArea); - - } - -/*****************************************************************************/ - -dng_urational dng_linearization_info::BlackLevel (uint32 row, - uint32 col, - uint32 plane) const - { - - dng_urational r; - - r.Set_real64 (fBlackLevel [row] [col] [plane], fBlackDenom); - - return r; - - } - -/*****************************************************************************/ - -uint32 dng_linearization_info::RowBlackCount () const - { - - if (fBlackDeltaV.Get ()) - { - - return fBlackDeltaV->LogicalSize () >> 3; - - } - - return 0; - - } - -/*****************************************************************************/ - -dng_srational dng_linearization_info::RowBlack (uint32 row) const - { - - if (fBlackDeltaV.Get ()) - { - - dng_srational r; - - r.Set_real64 (fBlackDeltaV->Buffer_real64 () [row], fBlackDenom); - - return r; - - } - - return dng_srational (0, 1); - - } - -/*****************************************************************************/ - -uint32 dng_linearization_info::ColumnBlackCount () const - { - - if (fBlackDeltaH.Get ()) - { - - return fBlackDeltaH->LogicalSize () >> 3; - - } - - return 0; - - } - -/*****************************************************************************/ - -dng_srational dng_linearization_info::ColumnBlack (uint32 col) const - { - - if (fBlackDeltaH.Get ()) - { - - dng_srational r; - - r.Set_real64 (fBlackDeltaH->Buffer_real64 () [col], fBlackDenom); - - return r; - - } - - return dng_srational (0, 1); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_linearization_info.h b/third_party/dng_sdk/dng_linearization_info.h deleted file mode 100644 index 510cf11..0000000 --- a/third_party/dng_sdk/dng_linearization_info.h +++ /dev/null @@ -1,164 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_linearization_info.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for linearization table and black level tags. - */ - -/*****************************************************************************/ - -#ifndef __dng_linearization_info__ -#define __dng_linearization_info__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_memory.h" -#include "dng_rational.h" -#include "dng_rect.h" -#include "dng_sdk_limits.h" - -/*****************************************************************************/ - -/// \brief Class for managing data values related to DNG linearization. -/// -/// See LinearizationTable, BlackLevel, BlackLevelRepeatDim, BlackLevelDeltaH, -/// BlackLevelDeltaV and WhiteLevel tags in the \ref spec_dng "DNG 1.1.0 specification". - -class dng_linearization_info - { - - public: - - /// This rectangle defines the active (non-masked) pixels of the sensor. - /// The order of the rectangle coordinates is: top, left, bottom, right. - - dng_rect fActiveArea; - - /// Number of rectangles in fMaskedArea - - uint32 fMaskedAreaCount; - - /// List of non-overlapping rectangle coordinates of fully masked pixels. - /// Can be optionally used by DNG readers to measure the black encoding level. - /// The order of each rectangle's coordinates is: top, left, bottom, right. - /// If the raw image data has already had its black encoding level subtracted, then this tag should - /// not be used, since the masked pixels are no longer useful. - /// Note that DNG writers are still required to include an estimate and store the black encoding level - /// using the black level DNG tags. Support for the MaskedAreas tag is not required of DNG - /// readers. - - dng_rect fMaskedArea [kMaxMaskedAreas]; - - /// A lookup table that maps stored values into linear values. - /// This tag is typically used to increase compression ratios by storing the raw data in a non-linear, more - /// visually uniform space with fewer total encoding levels. - /// If SamplesPerPixel is not equal to one, e.g. Fuji S3 type sensor, this single table applies to all the samples for each - /// pixel. - - AutoPtr fLinearizationTable; - - /// Actual number of rows in fBlackLevel pattern - - uint32 fBlackLevelRepeatRows; - - /// Actual number of columns in fBlackLevel pattern - - uint32 fBlackLevelRepeatCols; - - /// Repeating pattern of black level deltas fBlackLevelRepeatRows by fBlackLevelRepeatCols in size. - - real64 fBlackLevel [kMaxBlackPattern] [kMaxBlackPattern] [kMaxSamplesPerPixel]; - - /// Memory block of double-precision floating point deltas between baseline black level and a given column's black level - - AutoPtr fBlackDeltaH; - - /// Memory block of double-precision floating point deltas between baseline black level and a given row's black level - - AutoPtr fBlackDeltaV; - - /// Single white level (maximum sensor value) for each sample plane. - - real64 fWhiteLevel [kMaxSamplesPerPixel]; - - protected: - - int32 fBlackDenom; - - public: - - dng_linearization_info (); - - virtual ~dng_linearization_info (); - - void RoundBlacks (); - - virtual void Parse (dng_host &host, - dng_stream &stream, - dng_info &info); - - virtual void PostParse (dng_host &host, - dng_negative &negative); - - /// Compute the maximum black level for a given sample plane taking into account base - /// black level, repeated black level patter, and row/column delta maps. - - real64 MaxBlackLevel (uint32 plane) const; - - /// Convert raw data from in-file format to a true linear image using linearization data from DNG. - /// \param host Used to allocate buffers, check for aborts, and post progress updates. - /// \param srcImage Input pre-linearization RAW samples. - /// \param dstImage Output linearized image. - - virtual void Linearize (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage); - - /// Compute black level for one coordinate and sample plane in the image. - /// \param row Row to compute black level for. - /// \param col Column to compute black level for. - /// \param plane Sample plane to compute black level for. - - dng_urational BlackLevel (uint32 row, - uint32 col, - uint32 plane) const; - - /// Number of per-row black level deltas in fBlackDeltaV. - - uint32 RowBlackCount () const; - - /// Lookup black level delta for a given row. - /// \param row Row to get black level for. - /// \retval black level for indicated row. - - dng_srational RowBlack (uint32 row) const; - - /// Number of per-column black level deltas in fBlackDeltaV. - - uint32 ColumnBlackCount () const; - - /// Lookup black level delta for a given column. - /// \param col Column to get black level for. - /// \retval black level for indicated column. - - dng_srational ColumnBlack (uint32 col) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_lossless_jpeg.cpp b/third_party/dng_sdk/dng_lossless_jpeg.cpp deleted file mode 100644 index 5f764dc..0000000 --- a/third_party/dng_sdk/dng_lossless_jpeg.cpp +++ /dev/null @@ -1,3764 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_lossless_jpeg.cpp#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -// Lossless JPEG code adapted from: - -/* Copyright (C) 1991, 1992, Thomas G. Lane. - * Part of the Independent JPEG Group's software. - * See the file Copyright for more details. - * - * Copyright (c) 1993 Brian C. Smith, The Regents of the University - * of California - * All rights reserved. - * - * Copyright (c) 1994 Kongji Huang and Brian C. Smith. - * Cornell University - * All rights reserved. - * - * Permission to use, copy, modify, and distribute this software and its - * documentation for any purpose, without fee, and without written agreement is - * hereby granted, provided that the above copyright notice and the following - * two paragraphs appear in all copies of this software. - * - * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR - * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT - * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL - * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS - * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO - * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. - */ - -/*****************************************************************************/ - -#include "dng_lossless_jpeg.h" - -#include "dng_assertions.h" -#include "dng_exceptions.h" -#include "dng_memory.h" -#include "dng_stream.h" -#include "dng_tag_codes.h" - -/*****************************************************************************/ - -// This module contains routines that should be as fast as possible, even -// at the expense of slight code size increases. - -#include "dng_fast_module.h" - -/*****************************************************************************/ - -// The qSupportCanon_sRAW stuff not actually required for DNG support, but -// only included to allow this code to be used on Canon sRAW files. - -#ifndef qSupportCanon_sRAW -#define qSupportCanon_sRAW 1 -#endif - -// The qSupportHasselblad_3FR stuff not actually required for DNG support, but -// only included to allow this code to be used on Hasselblad 3FR files. - -#ifndef qSupportHasselblad_3FR -#define qSupportHasselblad_3FR 1 -#endif - -/*****************************************************************************/ - -/* - * One of the following structures is created for each huffman coding - * table. We use the same structure for encoding and decoding, so there - * may be some extra fields for encoding that aren't used in the decoding - * and vice-versa. - */ - -struct HuffmanTable - { - - /* - * These two fields directly represent the contents of a JPEG DHT - * marker - */ - uint8 bits[17]; - uint8 huffval[256]; - - /* - * The remaining fields are computed from the above to allow more - * efficient coding and decoding. These fields should be considered - * private to the Huffman compression & decompression modules. - */ - - uint16 mincode[17]; - int32 maxcode[18]; - int16 valptr[17]; - int32 numbits[256]; - int32 value[256]; - - uint16 ehufco[256]; - int8 ehufsi[256]; - - }; - -/*****************************************************************************/ - -// Computes the derived fields in the Huffman table structure. - -static void FixHuffTbl (HuffmanTable *htbl) - { - - int32 l; - int32 i; - - const uint32 bitMask [] = - { - 0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff, - 0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff, - 0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff, - 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, - 0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff, - 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff, - 0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f, - 0x0000000f, 0x00000007, 0x00000003, 0x00000001 - }; - - // Figure C.1: make table of Huffman code length for each symbol - // Note that this is in code-length order. - - int8 huffsize [257]; - - int32 p = 0; - - for (l = 1; l <= 16; l++) - { - - for (i = 1; i <= (int32) htbl->bits [l]; i++) - huffsize [p++] = (int8) l; - - } - - huffsize [p] = 0; - - int32 lastp = p; - - // Figure C.2: generate the codes themselves - // Note that this is in code-length order. - - uint16 huffcode [257]; - - uint16 code = 0; - - int32 si = huffsize [0]; - - p = 0; - - while (huffsize [p]) - { - - while (((int32) huffsize [p]) == si) - { - huffcode [p++] = code; - code++; - } - - code <<= 1; - - si++; - - } - - // Figure C.3: generate encoding tables - // These are code and size indexed by symbol value - // Set any codeless symbols to have code length 0; this allows - // EmitBits to detect any attempt to emit such symbols. - - memset (htbl->ehufsi, 0, sizeof (htbl->ehufsi)); - - for (p = 0; p < lastp; p++) - { - - htbl->ehufco [htbl->huffval [p]] = huffcode [p]; - htbl->ehufsi [htbl->huffval [p]] = huffsize [p]; - - } - - // Figure F.15: generate decoding tables - - p = 0; - - for (l = 1; l <= 16; l++) - { - - if (htbl->bits [l]) - { - - htbl->valptr [l] = (int16) p; - htbl->mincode [l] = huffcode [p]; - - p += htbl->bits [l]; - - htbl->maxcode [l] = huffcode [p - 1]; - - } - - else - { - htbl->maxcode [l] = -1; - } - - } - - // We put in this value to ensure HuffDecode terminates. - - htbl->maxcode[17] = 0xFFFFFL; - - // Build the numbits, value lookup tables. - // These table allow us to gather 8 bits from the bits stream, - // and immediately lookup the size and value of the huffman codes. - // If size is zero, it means that more than 8 bits are in the huffman - // code (this happens about 3-4% of the time). - - memset (htbl->numbits, 0, sizeof (htbl->numbits)); - - for (p = 0; p < lastp; p++) - { - - int32 size = huffsize [p]; - - if (size <= 8) - { - - int32 value = htbl->huffval [p]; - - code = huffcode [p]; - - int32 ll = code << (8 -size); - - int32 ul = (size < 8 ? ll | bitMask [24 + size] - : ll); - - for (i = ll; i <= ul; i++) - { - htbl->numbits [i] = size; - htbl->value [i] = value; - } - - } - - } - - } - -/*****************************************************************************/ - -/* - * The following structure stores basic information about one component. - */ - -struct JpegComponentInfo - { - - /* - * These values are fixed over the whole image. - * They are read from the SOF marker. - */ - int16 componentId; /* identifier for this component (0..255) */ - int16 componentIndex; /* its index in SOF or cPtr->compInfo[] */ - - /* - * Downsampling is not normally used in lossless JPEG, although - * it is permitted by the JPEG standard (DIS). We set all sampling - * factors to 1 in this program. - */ - int16 hSampFactor; /* horizontal sampling factor */ - int16 vSampFactor; /* vertical sampling factor */ - - /* - * Huffman table selector (0..3). The value may vary - * between scans. It is read from the SOS marker. - */ - int16 dcTblNo; - - }; - -/* - * One of the following structures is used to pass around the - * decompression information. - */ - -struct DecompressInfo - { - - /* - * Image width, height, and image data precision (bits/sample) - * These fields are set by ReadFileHeader or ReadScanHeader - */ - int32 imageWidth; - int32 imageHeight; - int32 dataPrecision; - - /* - * compInfo[i] describes component that appears i'th in SOF - * numComponents is the # of color components in JPEG image. - */ - JpegComponentInfo *compInfo; - int16 numComponents; - - /* - * *curCompInfo[i] describes component that appears i'th in SOS. - * compsInScan is the # of color components in current scan. - */ - JpegComponentInfo *curCompInfo[4]; - int16 compsInScan; - - /* - * MCUmembership[i] indexes the i'th component of MCU into the - * curCompInfo array. - */ - int16 MCUmembership[10]; - - /* - * ptrs to Huffman coding tables, or NULL if not defined - */ - HuffmanTable *dcHuffTblPtrs[4]; - - /* - * prediction selection value (PSV) and point transform parameter (Pt) - */ - int32 Ss; - int32 Pt; - - /* - * In lossless JPEG, restart interval shall be an integer - * multiple of the number of MCU in a MCU row. - */ - int32 restartInterval;/* MCUs per restart interval, 0 = no restart */ - int32 restartInRows; /*if > 0, MCU rows per restart interval; 0 = no restart*/ - - /* - * these fields are private data for the entropy decoder - */ - int32 restartRowsToGo; /* MCUs rows left in this restart interval */ - int16 nextRestartNum; /* # of next RSTn marker (0..7) */ - - }; - -/*****************************************************************************/ - -// An MCU (minimum coding unit) is an array of samples. - -typedef uint16 ComponentType; // the type of image components - -typedef ComponentType *MCU; // MCU - array of samples - -/*****************************************************************************/ - -class dng_lossless_decoder - { - - private: - - dng_stream *fStream; // Input data. - - dng_spooler *fSpooler; // Output data. - - bool fBug16; // Decode data with the "16-bit" bug. - - dng_memory_data huffmanBuffer [4]; - - dng_memory_data compInfoBuffer; - - DecompressInfo info; - - dng_memory_data mcuBuffer1; - dng_memory_data mcuBuffer2; - dng_memory_data mcuBuffer3; - dng_memory_data mcuBuffer4; - - MCU *mcuROW1; - MCU *mcuROW2; - - uint64 getBuffer; // current bit-extraction buffer - int32 bitsLeft; // # of unused bits in it - - #if qSupportHasselblad_3FR - bool fHasselblad3FR; - #endif - - public: - - dng_lossless_decoder (dng_stream *stream, - dng_spooler *spooler, - bool bug16); - - void StartRead (uint32 &imageWidth, - uint32 &imageHeight, - uint32 &imageChannels); - - void FinishRead (); - - private: - - uint8 GetJpegChar () - { - return fStream->Get_uint8 (); - } - - void UnGetJpegChar () - { - fStream->SetReadPosition (fStream->Position () - 1); - } - - uint16 Get2bytes (); - - void SkipVariable (); - - void GetDht (); - - void GetDri (); - - void GetApp0 (); - - void GetSof (int32 code); - - void GetSos (); - - void GetSoi (); - - int32 NextMarker (); - - JpegMarker ProcessTables (); - - void ReadFileHeader (); - - int32 ReadScanHeader (); - - void DecoderStructInit (); - - void HuffDecoderInit (); - - void ProcessRestart (); - - int32 QuickPredict (int32 col, - int32 curComp, - MCU *curRowBuf, - MCU *prevRowBuf); - - void FillBitBuffer (int32 nbits); - - int32 show_bits8 (); - - void flush_bits (int32 nbits); - - int32 get_bits (int32 nbits); - - int32 get_bit (); - - int32 HuffDecode (HuffmanTable *htbl); - - void HuffExtend (int32 &x, int32 s); - - void PmPutRow (MCU *buf, - int32 numComp, - int32 numCol, - int32 row); - - void DecodeFirstRow (MCU *curRowBuf); - - void DecodeImage (); - - // Hidden copy constructor and assignment operator. - - dng_lossless_decoder (const dng_lossless_decoder &decoder); - - dng_lossless_decoder & operator= (const dng_lossless_decoder &decoder); - - }; - -/*****************************************************************************/ - -dng_lossless_decoder::dng_lossless_decoder (dng_stream *stream, - dng_spooler *spooler, - bool bug16) - - : fStream (stream ) - , fSpooler (spooler) - , fBug16 (bug16 ) - - , compInfoBuffer () - , info () - , mcuBuffer1 () - , mcuBuffer2 () - , mcuBuffer3 () - , mcuBuffer4 () - , mcuROW1 (NULL) - , mcuROW2 (NULL) - , getBuffer (0) - , bitsLeft (0) - - #if qSupportHasselblad_3FR - , fHasselblad3FR (false) - #endif - - { - - memset (&info, 0, sizeof (info)); - - } - -/*****************************************************************************/ - -uint16 dng_lossless_decoder::Get2bytes () - { - - uint16 a = GetJpegChar (); - - return (uint16) ((a << 8) + GetJpegChar ()); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * SkipVariable -- - * - * Skip over an unknown or uninteresting variable-length marker - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed over marker. - * - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::SkipVariable () - { - - uint32 length = Get2bytes () - 2; - - fStream->Skip (length); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetDht -- - * - * Process a DHT marker - * - * Results: - * None - * - * Side effects: - * A huffman table is read. - * Exits on error. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetDht () - { - - int32 length = Get2bytes () - 2; - - while (length > 0) - { - - int32 index = GetJpegChar (); - - if (index < 0 || index >= 4) - { - ThrowBadFormat (); - } - - HuffmanTable *&htblptr = info.dcHuffTblPtrs [index]; - - if (htblptr == NULL) - { - - huffmanBuffer [index] . Allocate (sizeof (HuffmanTable)); - - htblptr = (HuffmanTable *) huffmanBuffer [index] . Buffer (); - - } - - htblptr->bits [0] = 0; - - int32 count = 0; - - for (int32 i = 1; i <= 16; i++) - { - - htblptr->bits [i] = GetJpegChar (); - - count += htblptr->bits [i]; - - } - - if (count > 256) - { - ThrowBadFormat (); - } - - for (int32 j = 0; j < count; j++) - { - - htblptr->huffval [j] = GetJpegChar (); - - } - - length -= 1 + 16 + count; - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetDri -- - * - * Process a DRI marker - * - * Results: - * None - * - * Side effects: - * Exits on error. - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetDri () - { - - if (Get2bytes () != 4) - { - ThrowBadFormat (); - } - - info.restartInterval = Get2bytes (); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetApp0 -- - * - * Process an APP0 marker. - * - * Results: - * None - * - * Side effects: - * Bitstream is parsed - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetApp0 () - { - - SkipVariable (); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetSof -- - * - * Process a SOFn marker - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed - * Exits on error - * info structure is filled in - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetSof (int32 /*code*/) - { - - int32 length = Get2bytes (); - - info.dataPrecision = GetJpegChar (); - info.imageHeight = Get2bytes (); - info.imageWidth = Get2bytes (); - info.numComponents = GetJpegChar (); - - // We don't support files in which the image height is initially - // specified as 0 and is later redefined by DNL. As long as we - // have to check that, might as well have a general sanity check. - - if ((info.imageHeight <= 0) || - (info.imageWidth <= 0) || - (info.numComponents <= 0)) - { - ThrowBadFormat (); - } - - // Lossless JPEG specifies data precision to be from 2 to 16 bits/sample. - - const int32 MinPrecisionBits = 2; - const int32 MaxPrecisionBits = 16; - - if ((info.dataPrecision < MinPrecisionBits) || - (info.dataPrecision > MaxPrecisionBits)) - { - ThrowBadFormat (); - } - - // Check length of tag. - - if (length != (info.numComponents * 3 + 8)) - { - ThrowBadFormat (); - } - - // Allocate per component info. - - compInfoBuffer.Allocate (info.numComponents * - (uint32) sizeof (JpegComponentInfo)); - - info.compInfo = (JpegComponentInfo *) compInfoBuffer.Buffer (); - - // Read in the per compent info. - - for (int32 ci = 0; ci < info.numComponents; ci++) - { - - JpegComponentInfo *compptr = &info.compInfo [ci]; - - compptr->componentIndex = (int16) ci; - - compptr->componentId = GetJpegChar (); - - int32 c = GetJpegChar (); - - compptr->hSampFactor = (int16) ((c >> 4) & 15); - compptr->vSampFactor = (int16) ((c ) & 15); - - (void) GetJpegChar (); /* skip Tq */ - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetSos -- - * - * Process a SOS marker - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed. - * Exits on error. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetSos () - { - - int32 length = Get2bytes (); - - // Get the number of image components. - - int32 n = GetJpegChar (); - info.compsInScan = (int16) n; - - // Check length. - - length -= 3; - - if (length != (n * 2 + 3) || n < 1 || n > 4) - { - ThrowBadFormat (); - } - - // Find index and huffman table for each component. - - for (int32 i = 0; i < n; i++) - { - - int32 cc = GetJpegChar (); - int32 c = GetJpegChar (); - - int32 ci; - - for (ci = 0; ci < info.numComponents; ci++) - { - - if (cc == info.compInfo[ci].componentId) - { - break; - } - - } - - if (ci >= info.numComponents) - { - ThrowBadFormat (); - } - - JpegComponentInfo *compptr = &info.compInfo [ci]; - - info.curCompInfo [i] = compptr; - - compptr->dcTblNo = (int16) ((c >> 4) & 15); - - } - - // Get the PSV, skip Se, and get the point transform parameter. - - info.Ss = GetJpegChar (); - - (void) GetJpegChar (); - - info.Pt = GetJpegChar () & 0x0F; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GetSoi -- - * - * Process an SOI marker - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed. - * Exits on error. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::GetSoi () - { - - // Reset all parameters that are defined to be reset by SOI - - info.restartInterval = 0; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * NextMarker -- - * - * Find the next JPEG marker Note that the output might not - * be a valid marker code but it will never be 0 or FF - * - * Results: - * The marker found. - * - * Side effects: - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -int32 dng_lossless_decoder::NextMarker () - { - - int32 c; - - do - { - - // skip any non-FF bytes - - do - { - c = GetJpegChar (); - } - while (c != 0xFF); - - // skip any duplicate FFs, since extra FFs are legal - - do - { - c = GetJpegChar(); - } - while (c == 0xFF); - - } - while (c == 0); // repeat if it was a stuffed FF/00 - - return c; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * ProcessTables -- - * - * Scan and process JPEG markers that can appear in any order - * Return when an SOI, EOI, SOFn, or SOS is found - * - * Results: - * The marker found. - * - * Side effects: - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -JpegMarker dng_lossless_decoder::ProcessTables () - { - - while (true) - { - - int32 c = NextMarker (); - - switch (c) - { - - case M_SOF0: - case M_SOF1: - case M_SOF2: - case M_SOF3: - case M_SOF5: - case M_SOF6: - case M_SOF7: - case M_JPG: - case M_SOF9: - case M_SOF10: - case M_SOF11: - case M_SOF13: - case M_SOF14: - case M_SOF15: - case M_SOI: - case M_EOI: - case M_SOS: - return (JpegMarker) c; - - case M_DHT: - GetDht (); - break; - - case M_DQT: - break; - - case M_DRI: - GetDri (); - break; - - case M_APP0: - GetApp0 (); - break; - - case M_RST0: // these are all parameterless - case M_RST1: - case M_RST2: - case M_RST3: - case M_RST4: - case M_RST5: - case M_RST6: - case M_RST7: - case M_TEM: - break; - - default: // must be DNL, DHP, EXP, APPn, JPGn, COM, or RESn - SkipVariable (); - break; - - } - - } - - return M_ERROR; - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * ReadFileHeader -- - * - * Initialize and read the stream header (everything through - * the SOF marker). - * - * Results: - * None - * - * Side effects: - * Exit on error. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::ReadFileHeader () - { - - // Demand an SOI marker at the start of the stream --- otherwise it's - // probably not a JPEG stream at all. - - int32 c = GetJpegChar (); - int32 c2 = GetJpegChar (); - - if ((c != 0xFF) || (c2 != M_SOI)) - { - ThrowBadFormat (); - } - - // OK, process SOI - - GetSoi (); - - // Process markers until SOF - - c = ProcessTables (); - - switch (c) - { - - case M_SOF0: - case M_SOF1: - case M_SOF3: - GetSof (c); - break; - - default: - ThrowBadFormat (); - break; - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * ReadScanHeader -- - * - * Read the start of a scan (everything through the SOS marker). - * - * Results: - * 1 if find SOS, 0 if find EOI - * - * Side effects: - * Bitstream is parsed, may exit on errors. - * - *-------------------------------------------------------------- - */ - -int32 dng_lossless_decoder::ReadScanHeader () - { - - // Process markers until SOS or EOI - - int32 c = ProcessTables (); - - switch (c) - { - - case M_SOS: - GetSos (); - return 1; - - case M_EOI: - return 0; - - default: - ThrowBadFormat (); - break; - - } - - return 0; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * DecoderStructInit -- - * - * Initalize the rest of the fields in the decompression - * structure. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::DecoderStructInit () - { - - int32 ci; - - #if qSupportCanon_sRAW - - bool canon_sRAW = (info.numComponents == 3) && - (info.compInfo [0].hSampFactor == 2) && - (info.compInfo [1].hSampFactor == 1) && - (info.compInfo [2].hSampFactor == 1) && - (info.compInfo [0].vSampFactor == 1) && - (info.compInfo [1].vSampFactor == 1) && - (info.compInfo [2].vSampFactor == 1) && - (info.dataPrecision == 15) && - (info.Ss == 1) && - ((info.imageWidth & 1) == 0); - - bool canon_sRAW2 = (info.numComponents == 3) && - (info.compInfo [0].hSampFactor == 2) && - (info.compInfo [1].hSampFactor == 1) && - (info.compInfo [2].hSampFactor == 1) && - (info.compInfo [0].vSampFactor == 2) && - (info.compInfo [1].vSampFactor == 1) && - (info.compInfo [2].vSampFactor == 1) && - (info.dataPrecision == 15) && - (info.Ss == 1) && - ((info.imageWidth & 1) == 0) && - ((info.imageHeight & 1) == 0); - - if (!canon_sRAW && !canon_sRAW2) - - #endif - - { - - // Check sampling factor validity. - - for (ci = 0; ci < info.numComponents; ci++) - { - - JpegComponentInfo *compPtr = &info.compInfo [ci]; - - if (compPtr->hSampFactor != 1 || - compPtr->vSampFactor != 1) - { - ThrowBadFormat (); - } - - } - - } - - // Prepare array describing MCU composition. - - if (info.compsInScan > 4) - { - ThrowBadFormat (); - } - - for (ci = 0; ci < info.compsInScan; ci++) - { - info.MCUmembership [ci] = (int16) ci; - } - - // Initialize mucROW1 and mcuROW2 which buffer two rows of - // pixels for predictor calculation. - - int32 mcuSize = info.compsInScan * (uint32) sizeof (ComponentType); - - mcuBuffer1.Allocate (info.imageWidth * (uint32) sizeof (MCU)); - mcuBuffer2.Allocate (info.imageWidth * (uint32) sizeof (MCU)); - - mcuROW1 = (MCU *) mcuBuffer1.Buffer (); - mcuROW2 = (MCU *) mcuBuffer2.Buffer (); - - mcuBuffer3.Allocate (info.imageWidth * mcuSize); - mcuBuffer4.Allocate (info.imageWidth * mcuSize); - - mcuROW1 [0] = (ComponentType *) mcuBuffer3.Buffer (); - mcuROW2 [0] = (ComponentType *) mcuBuffer4.Buffer (); - - for (int32 j = 1; j < info.imageWidth; j++) - { - - mcuROW1 [j] = mcuROW1 [j - 1] + info.compsInScan; - mcuROW2 [j] = mcuROW2 [j - 1] + info.compsInScan; - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * HuffDecoderInit -- - * - * Initialize for a Huffman-compressed scan. - * This is invoked after reading the SOS marker. - * - * Results: - * None - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::HuffDecoderInit () - { - - // Initialize bit parser state - - getBuffer = 0; - bitsLeft = 0; - - // Prepare Huffman tables. - - for (int16 ci = 0; ci < info.compsInScan; ci++) - { - - JpegComponentInfo *compptr = info.curCompInfo [ci]; - - // Make sure requested tables are present - - if (compptr->dcTblNo < 0 || compptr->dcTblNo > 3) - { - ThrowBadFormat (); - } - - if (info.dcHuffTblPtrs [compptr->dcTblNo] == NULL) - { - ThrowBadFormat (); - } - - // Compute derived values for Huffman tables. - // We may do this more than once for same table, but it's not a - // big deal - - FixHuffTbl (info.dcHuffTblPtrs [compptr->dcTblNo]); - - } - - // Initialize restart stuff - - info.restartInRows = info.restartInterval / info.imageWidth; - info.restartRowsToGo = info.restartInRows; - info.nextRestartNum = 0; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * ProcessRestart -- - * - * Check for a restart marker & resynchronize decoder. - * - * Results: - * None. - * - * Side effects: - * BitStream is parsed, bit buffer is reset, etc. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::ProcessRestart () - { - - // Throw away and unused odd bits in the bit buffer. - - fStream->SetReadPosition (fStream->Position () - bitsLeft / 8); - - bitsLeft = 0; - getBuffer = 0; - - // Scan for next JPEG marker - - int32 c; - - do - { - - // skip any non-FF bytes - - do - { - c = GetJpegChar (); - } - while (c != 0xFF); - - // skip any duplicate FFs - - do - { - c = GetJpegChar (); - } - while (c == 0xFF); - - } - while (c == 0); // repeat if it was a stuffed FF/00 - - // Verify correct restart code. - - if (c != (M_RST0 + info.nextRestartNum)) - { - ThrowBadFormat (); - } - - // Update restart state. - - info.restartRowsToGo = info.restartInRows; - info.nextRestartNum = (info.nextRestartNum + 1) & 7; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * QuickPredict -- - * - * Calculate the predictor for sample curRowBuf[col][curComp]. - * It does not handle the special cases at image edges, such - * as first row and first column of a scan. We put the special - * case checkings outside so that the computations in main - * loop can be simpler. This has enhenced the performance - * significantly. - * - * Results: - * predictor is passed out. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -inline int32 dng_lossless_decoder::QuickPredict (int32 col, - int32 curComp, - MCU *curRowBuf, - MCU *prevRowBuf) - { - - int32 diag = prevRowBuf [col - 1] [curComp]; - int32 upper = prevRowBuf [col ] [curComp]; - int32 left = curRowBuf [col - 1] [curComp]; - - switch (info.Ss) - { - - case 0: - return 0; - - case 1: - return left; - - case 2: - return upper; - - case 3: - return diag; - - case 4: - return left + upper - diag; - - case 5: - return left + ((upper - diag) >> 1); - - case 6: - return upper + ((left - diag) >> 1); - - case 7: - return (left + upper) >> 1; - - default: - { - ThrowBadFormat (); - return 0; - } - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * FillBitBuffer -- - * - * Load up the bit buffer with at least nbits - * Process any stuffed bytes at this time. - * - * Results: - * None - * - * Side effects: - * The bitwise global variables are updated. - * - *-------------------------------------------------------------- - */ - -inline void dng_lossless_decoder::FillBitBuffer (int32 nbits) - { - - const int32 kMinGetBits = sizeof (uint32) * 8 - 7; - - #if qSupportHasselblad_3FR - - if (fHasselblad3FR) - { - - while (bitsLeft < kMinGetBits) - { - - int32 c0 = GetJpegChar (); - int32 c1 = GetJpegChar (); - int32 c2 = GetJpegChar (); - int32 c3 = GetJpegChar (); - - getBuffer = (getBuffer << 8) | c3; - getBuffer = (getBuffer << 8) | c2; - getBuffer = (getBuffer << 8) | c1; - getBuffer = (getBuffer << 8) | c0; - - bitsLeft += 32; - - } - - return; - - } - - #endif - - while (bitsLeft < kMinGetBits) - { - - int32 c = GetJpegChar (); - - // If it's 0xFF, check and discard stuffed zero byte - - if (c == 0xFF) - { - - int32 c2 = GetJpegChar (); - - if (c2 != 0) - { - - // Oops, it's actually a marker indicating end of - // compressed data. Better put it back for use later. - - UnGetJpegChar (); - UnGetJpegChar (); - - // There should be enough bits still left in the data - // segment; if so, just break out of the while loop. - - if (bitsLeft >= nbits) - break; - - // Uh-oh. Corrupted data: stuff zeroes into the data - // stream, since this sometimes occurs when we are on the - // last show_bits8 during decoding of the Huffman - // segment. - - c = 0; - - } - - } - - getBuffer = (getBuffer << 8) | c; - - bitsLeft += 8; - - } - - } - -/*****************************************************************************/ - -inline int32 dng_lossless_decoder::show_bits8 () - { - - if (bitsLeft < 8) - FillBitBuffer (8); - - return (int32) ((getBuffer >> (bitsLeft - 8)) & 0xff); - - } - -/*****************************************************************************/ - -inline void dng_lossless_decoder::flush_bits (int32 nbits) - { - - bitsLeft -= nbits; - - } - -/*****************************************************************************/ - -inline int32 dng_lossless_decoder::get_bits (int32 nbits) - { - - if (bitsLeft < nbits) - FillBitBuffer (nbits); - - return (int32) ((getBuffer >> (bitsLeft -= nbits)) & (0x0FFFF >> (16 - nbits))); - - } - -/*****************************************************************************/ - -inline int32 dng_lossless_decoder::get_bit () - { - - if (!bitsLeft) - FillBitBuffer (1); - - return (int32) ((getBuffer >> (--bitsLeft)) & 1); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * HuffDecode -- - * - * Taken from Figure F.16: extract next coded symbol from - * input stream. This should becode a macro. - * - * Results: - * Next coded symbol - * - * Side effects: - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -inline int32 dng_lossless_decoder::HuffDecode (HuffmanTable *htbl) - { - - // If the huffman code is less than 8 bits, we can use the fast - // table lookup to get its value. It's more than 8 bits about - // 3-4% of the time. - - int32 code = show_bits8 (); - - if (htbl->numbits [code]) - { - - flush_bits (htbl->numbits [code]); - - return htbl->value [code]; - - } - - else - { - - flush_bits (8); - - int32 l = 8; - - while (code > htbl->maxcode [l]) - { - code = (code << 1) | get_bit (); - l++; - } - - // With garbage input we may reach the sentinel value l = 17. - - if (l > 16) - { - return 0; // fake a zero as the safest result - } - else - { - return htbl->huffval [htbl->valptr [l] + - ((int32) (code - htbl->mincode [l]))]; - } - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * HuffExtend -- - * - * Code and table for Figure F.12: extend sign bit - * - * Results: - * The extended value. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -inline void dng_lossless_decoder::HuffExtend (int32 &x, int32 s) - { - - if (x < (0x08000 >> (16 - s))) - { - x += (-1 << s) + 1; - } - - } - -/*****************************************************************************/ - -// Called from DecodeImage () to write one row. - -void dng_lossless_decoder::PmPutRow (MCU *buf, - int32 numComp, - int32 numCol, - int32 /* row */) - { - - uint16 *sPtr = &buf [0] [0]; - - uint32 pixels = numCol * numComp; - - fSpooler->Spool (sPtr, pixels * (uint32) sizeof (uint16)); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * DecodeFirstRow -- - * - * Decode the first raster line of samples at the start of - * the scan and at the beginning of each restart interval. - * This includes modifying the component value so the real - * value, not the difference is returned. - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::DecodeFirstRow (MCU *curRowBuf) - { - - int32 compsInScan = info.compsInScan; - - // Process the first column in the row. - - for (int32 curComp = 0; curComp < compsInScan; curComp++) - { - - int32 ci = info.MCUmembership [curComp]; - - JpegComponentInfo *compptr = info.curCompInfo [ci]; - - HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo]; - - // Section F.2.2.1: decode the difference - - int32 d = 0; - - int32 s = HuffDecode (dctbl); - - if (s) - { - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - // Add the predictor to the difference. - - int32 Pr = info.dataPrecision; - int32 Pt = info.Pt; - - curRowBuf [0] [curComp] = (ComponentType) (d + (1 << (Pr-Pt-1))); - - } - - // Process the rest of the row. - - int32 numCOL = info.imageWidth; - - for (int32 col = 1; col < numCOL; col++) - { - - for (int32 curComp = 0; curComp < compsInScan; curComp++) - { - - int32 ci = info.MCUmembership [curComp]; - - JpegComponentInfo *compptr = info.curCompInfo [ci]; - - HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo]; - - // Section F.2.2.1: decode the difference - - int32 d = 0; - - int32 s = HuffDecode (dctbl); - - if (s) - { - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - // Add the predictor to the difference. - - curRowBuf [col] [curComp] = (ComponentType) (d + curRowBuf [col-1] [curComp]); - - } - - } - - // Update the restart counter - - if (info.restartInRows) - { - info.restartRowsToGo--; - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * DecodeImage -- - * - * Decode the input stream. This includes modifying - * the component value so the real value, not the - * difference is returned. - * - * Results: - * None. - * - * Side effects: - * Bitstream is parsed. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_decoder::DecodeImage () - { - - #define swap(type,a,b) {type c; c=(a); (a)=(b); (b)=c;} - - int32 numCOL = info.imageWidth; - int32 numROW = info.imageHeight; - int32 compsInScan = info.compsInScan; - - // Precompute the decoding table for each table. - - HuffmanTable *ht [4]; - - for (int32 curComp = 0; curComp < compsInScan; curComp++) - { - - int32 ci = info.MCUmembership [curComp]; - - JpegComponentInfo *compptr = info.curCompInfo [ci]; - - ht [curComp] = info.dcHuffTblPtrs [compptr->dcTblNo]; - - } - - MCU *prevRowBuf = mcuROW1; - MCU *curRowBuf = mcuROW2; - - #if qSupportCanon_sRAW - - // Canon sRAW support - - if (info.compInfo [0].hSampFactor == 2 && - info.compInfo [0].vSampFactor == 1) - { - - for (int32 row = 0; row < numROW; row++) - { - - // Initialize predictors. - - int32 p0; - int32 p1; - int32 p2; - - if (row == 0) - { - p0 = 1 << 14; - p1 = 1 << 14; - p2 = 1 << 14; - } - - else - { - p0 = prevRowBuf [0] [0]; - p1 = prevRowBuf [0] [1]; - p2 = prevRowBuf [0] [2]; - } - - for (int32 col = 0; col < numCOL; col += 2) - { - - // Read first luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - curRowBuf [col] [0] = (ComponentType) p0; - - } - - // Read second luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - curRowBuf [col + 1] [0] = (ComponentType) p0; - - } - - // Read first chroma component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [1]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p1 += d; - - curRowBuf [col ] [1] = (ComponentType) p1; - curRowBuf [col + 1] [1] = (ComponentType) p1; - - } - - // Read second chroma component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [2]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p2 += d; - - curRowBuf [col ] [2] = (ComponentType) p2; - curRowBuf [col + 1] [2] = (ComponentType) p2; - - } - - } - - PmPutRow (curRowBuf, compsInScan, numCOL, row); - - swap (MCU *, prevRowBuf, curRowBuf); - - } - - return; - - } - - if (info.compInfo [0].hSampFactor == 2 && - info.compInfo [0].vSampFactor == 2) - { - - for (int32 row = 0; row < numROW; row += 2) - { - - // Initialize predictors. - - int32 p0; - int32 p1; - int32 p2; - - if (row == 0) - { - p0 = 1 << 14; - p1 = 1 << 14; - p2 = 1 << 14; - } - - else - { - p0 = prevRowBuf [0] [0]; - p1 = prevRowBuf [0] [1]; - p2 = prevRowBuf [0] [2]; - } - - for (int32 col = 0; col < numCOL; col += 2) - { - - // Read first luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - prevRowBuf [col] [0] = (ComponentType) p0; - - } - - // Read second luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - prevRowBuf [col + 1] [0] = (ComponentType) p0; - - } - - // Read third luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - curRowBuf [col] [0] = (ComponentType) p0; - - } - - // Read fourth luminance component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p0 += d; - - curRowBuf [col + 1] [0] = (ComponentType) p0; - - } - - // Read first chroma component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [1]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p1 += d; - - prevRowBuf [col ] [1] = (ComponentType) p1; - prevRowBuf [col + 1] [1] = (ComponentType) p1; - - curRowBuf [col ] [1] = (ComponentType) p1; - curRowBuf [col + 1] [1] = (ComponentType) p1; - - } - - // Read second chroma component. - - { - - int32 d = 0; - - int32 s = HuffDecode (ht [2]); - - if (s) - { - - if (s == 16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - p2 += d; - - prevRowBuf [col ] [2] = (ComponentType) p2; - prevRowBuf [col + 1] [2] = (ComponentType) p2; - - curRowBuf [col ] [2] = (ComponentType) p2; - curRowBuf [col + 1] [2] = (ComponentType) p2; - - } - - } - - PmPutRow (prevRowBuf, compsInScan, numCOL, row); - PmPutRow (curRowBuf, compsInScan, numCOL, row); - - } - - return; - - } - - #endif - - #if qSupportHasselblad_3FR - - if (info.Ss == 8) - { - - fHasselblad3FR = true; - - for (int32 row = 0; row < numROW; row++) - { - - int32 p0 = 32768; - int32 p1 = 32768; - - for (int32 col = 0; col < numCOL; col += 2) - { - - int32 s0 = HuffDecode (ht [0]); - int32 s1 = HuffDecode (ht [0]); - - if (s0) - { - int32 d = get_bits (s0); - if (s0 == 16) - { - d = -32768; - } - else - { - HuffExtend (d, s0); - } - p0 += d; - } - - if (s1) - { - int32 d = get_bits (s1); - if (s1 == 16) - { - d = -32768; - } - else - { - HuffExtend (d, s1); - } - p1 += d; - } - - curRowBuf [col ] [0] = (ComponentType) p0; - curRowBuf [col + 1] [0] = (ComponentType) p1; - - } - - PmPutRow (curRowBuf, compsInScan, numCOL, row); - - } - - return; - - } - - #endif - - // Decode the first row of image. Output the row and - // turn this row into a previous row for later predictor - // calculation. - - DecodeFirstRow (mcuROW1); - - PmPutRow (mcuROW1, compsInScan, numCOL, 0); - - // Process each row. - - for (int32 row = 1; row < numROW; row++) - { - - // Account for restart interval, process restart marker if needed. - - if (info.restartInRows) - { - - if (info.restartRowsToGo == 0) - { - - ProcessRestart (); - - // Reset predictors at restart. - - DecodeFirstRow (curRowBuf); - - PmPutRow (curRowBuf, compsInScan, numCOL, row); - - swap (MCU *, prevRowBuf, curRowBuf); - - continue; - - } - - info.restartRowsToGo--; - - } - - // The upper neighbors are predictors for the first column. - - for (int32 curComp = 0; curComp < compsInScan; curComp++) - { - - // Section F.2.2.1: decode the difference - - int32 d = 0; - - int32 s = HuffDecode (ht [curComp]); - - if (s) - { - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - // First column of row above is predictor for first column. - - curRowBuf [0] [curComp] = (ComponentType) (d + prevRowBuf [0] [curComp]); - - } - - // For the rest of the column on this row, predictor - // calculations are based on PSV. - - if (compsInScan == 2 && info.Ss == 1) - { - - // This is the combination used by both the Canon and Kodak raw formats. - // Unrolling the general case logic results in a significant speed increase. - - uint16 *dPtr = &curRowBuf [1] [0]; - - int32 prev0 = dPtr [-2]; - int32 prev1 = dPtr [-1]; - - for (int32 col = 1; col < numCOL; col++) - { - - int32 s = HuffDecode (ht [0]); - - if (s) - { - - int32 d; - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - prev0 += d; - - } - - s = HuffDecode (ht [1]); - - if (s) - { - - int32 d; - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - prev1 += d; - - } - - dPtr [0] = (uint16) prev0; - dPtr [1] = (uint16) prev1; - - dPtr += 2; - - } - - } - - else - { - - for (int32 col = 1; col < numCOL; col++) - { - - for (int32 curComp = 0; curComp < compsInScan; curComp++) - { - - // Section F.2.2.1: decode the difference - - int32 d = 0; - - int32 s = HuffDecode (ht [curComp]); - - if (s) - { - - if (s == 16 && !fBug16) - { - d = -32768; - } - - else - { - d = get_bits (s); - HuffExtend (d, s); - } - - } - - // Predict the pixel value. - - int32 predictor = QuickPredict (col, - curComp, - curRowBuf, - prevRowBuf); - - // Save the difference. - - curRowBuf [col] [curComp] = (ComponentType) (d + predictor); - - } - - } - - } - - PmPutRow (curRowBuf, compsInScan, numCOL, row); - - swap (MCU *, prevRowBuf, curRowBuf); - - } - - #undef swap - - } - -/*****************************************************************************/ - -void dng_lossless_decoder::StartRead (uint32 &imageWidth, - uint32 &imageHeight, - uint32 &imageChannels) - { - - ReadFileHeader (); - ReadScanHeader (); - DecoderStructInit (); - HuffDecoderInit (); - - imageWidth = info.imageWidth; - imageHeight = info.imageHeight; - imageChannels = info.compsInScan; - - } - -/*****************************************************************************/ - -void dng_lossless_decoder::FinishRead () - { - - DecodeImage (); - - } - -/*****************************************************************************/ - -void DecodeLosslessJPEG (dng_stream &stream, - dng_spooler &spooler, - uint32 minDecodedSize, - uint32 maxDecodedSize, - bool bug16) - { - - dng_lossless_decoder decoder (&stream, - &spooler, - bug16); - - uint32 imageWidth; - uint32 imageHeight; - uint32 imageChannels; - - decoder.StartRead (imageWidth, - imageHeight, - imageChannels); - - uint32 decodedSize = imageWidth * - imageHeight * - imageChannels * - (uint32) sizeof (uint16); - - if (decodedSize < minDecodedSize || - decodedSize > maxDecodedSize) - { - ThrowBadFormat (); - } - - decoder.FinishRead (); - - } - -/*****************************************************************************/ - -class dng_lossless_encoder - { - - private: - - const uint16 *fSrcData; - - uint32 fSrcRows; - uint32 fSrcCols; - uint32 fSrcChannels; - uint32 fSrcBitDepth; - - int32 fSrcRowStep; - int32 fSrcColStep; - - dng_stream &fStream; - - HuffmanTable huffTable [4]; - - uint32 freqCount [4] [257]; - - // Current bit-accumulation buffer - - int32 huffPutBuffer; - int32 huffPutBits; - - // Lookup table for number of bits in an 8 bit value. - - int numBitsTable [256]; - - public: - - dng_lossless_encoder (const uint16 *srcData, - uint32 srcRows, - uint32 srcCols, - uint32 srcChannels, - uint32 srcBitDepth, - int32 srcRowStep, - int32 srcColStep, - dng_stream &stream); - - void Encode (); - - private: - - void EmitByte (uint8 value); - - void EmitBits (int code, int size); - - void FlushBits (); - - void CountOneDiff (int diff, uint32 *countTable); - - void EncodeOneDiff (int diff, HuffmanTable *dctbl); - - void FreqCountSet (); - - void HuffEncode (); - - void GenHuffCoding (HuffmanTable *htbl, uint32 *freq); - - void HuffOptimize (); - - void EmitMarker (JpegMarker mark); - - void Emit2bytes (int value); - - void EmitDht (int index); - - void EmitSof (JpegMarker code); - - void EmitSos (); - - void WriteFileHeader (); - - void WriteScanHeader (); - - void WriteFileTrailer (); - - }; - -/*****************************************************************************/ - -dng_lossless_encoder::dng_lossless_encoder (const uint16 *srcData, - uint32 srcRows, - uint32 srcCols, - uint32 srcChannels, - uint32 srcBitDepth, - int32 srcRowStep, - int32 srcColStep, - dng_stream &stream) - - : fSrcData (srcData ) - , fSrcRows (srcRows ) - , fSrcCols (srcCols ) - , fSrcChannels (srcChannels) - , fSrcBitDepth (srcBitDepth) - , fSrcRowStep (srcRowStep ) - , fSrcColStep (srcColStep ) - , fStream (stream ) - - , huffPutBuffer (0) - , huffPutBits (0) - - { - - // Initialize number of bits lookup table. - - numBitsTable [0] = 0; - - for (int i = 1; i < 256; i++) - { - - int temp = i; - int nbits = 1; - - while (temp >>= 1) - { - nbits++; - } - - numBitsTable [i] = nbits; - - } - - } - -/*****************************************************************************/ - -inline void dng_lossless_encoder::EmitByte (uint8 value) - { - - fStream.Put_uint8 (value); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EmitBits -- - * - * Code for outputting bits to the file - * - * Only the right 24 bits of huffPutBuffer are used; the valid - * bits are left-justified in this part. At most 16 bits can be - * passed to EmitBits in one call, and we never retain more than 7 - * bits in huffPutBuffer between calls, so 24 bits are - * sufficient. - * - * Results: - * None. - * - * Side effects: - * huffPutBuffer and huffPutBits are updated. - * - *-------------------------------------------------------------- - */ - -inline void dng_lossless_encoder::EmitBits (int code, int size) - { - - DNG_ASSERT (size != 0, "Bad Huffman table entry"); - - int putBits = size; - int putBuffer = code; - - putBits += huffPutBits; - - putBuffer <<= 24 - putBits; - putBuffer |= huffPutBuffer; - - while (putBits >= 8) - { - - uint8 c = (uint8) (putBuffer >> 16); - - // Output whole bytes we've accumulated with byte stuffing - - EmitByte (c); - - if (c == 0xFF) - { - EmitByte (0); - } - - putBuffer <<= 8; - putBits -= 8; - - } - - huffPutBuffer = putBuffer; - huffPutBits = putBits; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * FlushBits -- - * - * Flush any remaining bits in the bit buffer. Used before emitting - * a marker. - * - * Results: - * None. - * - * Side effects: - * huffPutBuffer and huffPutBits are reset - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::FlushBits () - { - - // The first call forces output of any partial bytes. - - EmitBits (0x007F, 7); - - // We can then zero the buffer. - - huffPutBuffer = 0; - huffPutBits = 0; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * CountOneDiff -- - * - * Count the difference value in countTable. - * - * Results: - * diff is counted in countTable. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -inline void dng_lossless_encoder::CountOneDiff (int diff, uint32 *countTable) - { - - // Encode the DC coefficient difference per section F.1.2.1 - - int temp = diff; - - if (temp < 0) - { - - temp = -temp; - - } - - // Find the number of bits needed for the magnitude of the coefficient - - int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8 - : numBitsTable [temp & 0xFF]; - - // Update count for this bit length - - countTable [nbits] ++; - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EncodeOneDiff -- - * - * Encode a single difference value. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -inline void dng_lossless_encoder::EncodeOneDiff (int diff, HuffmanTable *dctbl) - { - - // Encode the DC coefficient difference per section F.1.2.1 - - int temp = diff; - int temp2 = diff; - - if (temp < 0) - { - - temp = -temp; - - // For a negative input, want temp2 = bitwise complement of - // abs (input). This code assumes we are on a two's complement - // machine. - - temp2--; - - } - - // Find the number of bits needed for the magnitude of the coefficient - - int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8 - : numBitsTable [temp & 0xFF]; - - // Emit the Huffman-coded symbol for the number of bits - - EmitBits (dctbl->ehufco [nbits], - dctbl->ehufsi [nbits]); - - // Emit that number of bits of the value, if positive, - // or the complement of its magnitude, if negative. - - // If the number of bits is 16, there is only one possible difference - // value (-32786), so the lossless JPEG spec says not to output anything - // in that case. So we only need to output the diference value if - // the number of bits is between 1 and 15. - - if (nbits & 15) - { - - EmitBits (temp2 & (0x0FFFF >> (16 - nbits)), - nbits); - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * FreqCountSet -- - * - * Count the times each category symbol occurs in this image. - * - * Results: - * None. - * - * Side effects: - * The freqCount has counted all category - * symbols appeared in the image. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::FreqCountSet () - { - - memset (freqCount, 0, sizeof (freqCount)); - - DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::FreqCountSet: fSrcRpws too large."); - - for (int32 row = 0; row < (int32)fSrcRows; row++) - { - - const uint16 *sPtr = fSrcData + row * fSrcRowStep; - - // Initialize predictors for this row. - - int32 predictor [4]; - - for (int32 channel = 0; channel < (int32)fSrcChannels; channel++) - { - - if (row == 0) - predictor [channel] = 1 << (fSrcBitDepth - 1); - - else - predictor [channel] = sPtr [channel - fSrcRowStep]; - - } - - // Unroll most common case of two channels - - if (fSrcChannels == 2) - { - - int32 pred0 = predictor [0]; - int32 pred1 = predictor [1]; - - uint32 srcCols = fSrcCols; - int32 srcColStep = fSrcColStep; - - for (uint32 col = 0; col < srcCols; col++) - { - - int32 pixel0 = sPtr [0]; - int32 pixel1 = sPtr [1]; - - int16 diff0 = (int16) (pixel0 - pred0); - int16 diff1 = (int16) (pixel1 - pred1); - - CountOneDiff (diff0, freqCount [0]); - CountOneDiff (diff1, freqCount [1]); - - pred0 = pixel0; - pred1 = pixel1; - - sPtr += srcColStep; - - } - - } - - // General case. - - else - { - - for (uint32 col = 0; col < fSrcCols; col++) - { - - for (uint32 channel = 0; channel < fSrcChannels; channel++) - { - - int32 pixel = sPtr [channel]; - - int16 diff = (int16) (pixel - predictor [channel]); - - CountOneDiff (diff, freqCount [channel]); - - predictor [channel] = pixel; - - } - - sPtr += fSrcColStep; - - } - - } - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * HuffEncode -- - * - * Encode and output Huffman-compressed image data. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::HuffEncode () - { - - DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::HuffEncode: fSrcRows too large."); - - for (int32 row = 0; row < (int32)fSrcRows; row++) - { - - const uint16 *sPtr = fSrcData + row * fSrcRowStep; - - // Initialize predictors for this row. - - int32 predictor [4]; - - for (int32 channel = 0; channel < (int32)fSrcChannels; channel++) - { - - if (row == 0) - predictor [channel] = 1 << (fSrcBitDepth - 1); - - else - predictor [channel] = sPtr [channel - fSrcRowStep]; - - } - - // Unroll most common case of two channels - - if (fSrcChannels == 2) - { - - int32 pred0 = predictor [0]; - int32 pred1 = predictor [1]; - - uint32 srcCols = fSrcCols; - int32 srcColStep = fSrcColStep; - - for (uint32 col = 0; col < srcCols; col++) - { - - int32 pixel0 = sPtr [0]; - int32 pixel1 = sPtr [1]; - - int16 diff0 = (int16) (pixel0 - pred0); - int16 diff1 = (int16) (pixel1 - pred1); - - EncodeOneDiff (diff0, &huffTable [0]); - EncodeOneDiff (diff1, &huffTable [1]); - - pred0 = pixel0; - pred1 = pixel1; - - sPtr += srcColStep; - - } - - } - - // General case. - - else - { - - for (uint32 col = 0; col < fSrcCols; col++) - { - - for (uint32 channel = 0; channel < fSrcChannels; channel++) - { - - int32 pixel = sPtr [channel]; - - int16 diff = (int16) (pixel - predictor [channel]); - - EncodeOneDiff (diff, &huffTable [channel]); - - predictor [channel] = pixel; - - } - - sPtr += fSrcColStep; - - } - - } - - } - - FlushBits (); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * GenHuffCoding -- - * - * Generate the optimal coding for the given counts. - * This algorithm is explained in section K.2 of the - * JPEG standard. - * - * Results: - * htbl->bits and htbl->huffval are constructed. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::GenHuffCoding (HuffmanTable *htbl, uint32 *freq) - { - - int i; - int j; - - const int MAX_CLEN = 32; // assumed maximum initial code length - - uint8 bits [MAX_CLEN + 1]; // bits [k] = # of symbols with code length k - short codesize [257]; // codesize [k] = code length of symbol k - short others [257]; // next symbol in current branch of tree - - memset (bits , 0, sizeof (bits )); - memset (codesize, 0, sizeof (codesize)); - - for (i = 0; i < 257; i++) - others [i] = -1; // init links to empty - - // Including the pseudo-symbol 256 in the Huffman procedure guarantees - // that no real symbol is given code-value of all ones, because 256 - // will be placed in the largest codeword category. - - freq [256] = 1; // make sure there is a nonzero count - - // Huffman's basic algorithm to assign optimal code lengths to symbols - - while (true) - { - - // Find the smallest nonzero frequency, set c1 = its symbol. - // In case of ties, take the larger symbol number. - - int c1 = -1; - - uint32 v = 0xFFFFFFFF; - - for (i = 0; i <= 256; i++) - { - - if (freq [i] && freq [i] <= v) - { - v = freq [i]; - c1 = i; - } - - } - - // Find the next smallest nonzero frequency, set c2 = its symbol. - // In case of ties, take the larger symbol number. - - int c2 = -1; - - v = 0xFFFFFFFF; - - for (i = 0; i <= 256; i++) - { - - if (freq [i] && freq [i] <= v && i != c1) - { - v = freq [i]; - c2 = i; - } - - } - - // Done if we've merged everything into one frequency. - - if (c2 < 0) - break; - - // Else merge the two counts/trees. - - freq [c1] += freq [c2]; - freq [c2] = 0; - - // Increment the codesize of everything in c1's tree branch. - - codesize [c1] ++; - - while (others [c1] >= 0) - { - c1 = others [c1]; - codesize [c1] ++; - } - - // chain c2 onto c1's tree branch - - others [c1] = (short) c2; - - // Increment the codesize of everything in c2's tree branch. - - codesize [c2] ++; - - while (others [c2] >= 0) - { - c2 = others [c2]; - codesize [c2] ++; - } - - } - - // Now count the number of symbols of each code length. - - for (i = 0; i <= 256; i++) - { - - if (codesize [i]) - { - - // The JPEG standard seems to think that this can't happen, - // but I'm paranoid... - - if (codesize [i] > MAX_CLEN) - { - - DNG_REPORT ("Huffman code size table overflow"); - - ThrowProgramError (); - - } - - bits [codesize [i]]++; - - } - - } - - // JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure - // Huffman procedure assigned any such lengths, we must adjust the coding. - // Here is what the JPEG spec says about how this next bit works: - // Since symbols are paired for the longest Huffman code, the symbols are - // removed from this length category two at a time. The prefix for the pair - // (which is one bit shorter) is allocated to one of the pair; then, - // skipping the BITS entry for that prefix length, a code word from the next - // shortest nonzero BITS entry is converted into a prefix for two code words - // one bit longer. - - for (i = MAX_CLEN; i > 16; i--) - { - - while (bits [i] > 0) - { - - // Kludge: I have never been able to test this logic, and there - // are comments on the web that this encoder has bugs with 16-bit - // data, so just throw an error if we get here and revert to a - // default table. - tknoll 12/1/03. - - DNG_REPORT ("Info: Optimal huffman table bigger than 16 bits"); - - ThrowProgramError (); - - // Original logic: - - j = i - 2; // find length of new prefix to be used - - while (bits [j] == 0) - j--; - - bits [i ] -= 2; // remove two symbols - bits [i - 1] ++; // one goes in this length - bits [j + 1] += 2; // two new symbols in this length - bits [j ] --; // symbol of this length is now a prefix - - } - - } - - // Remove the count for the pseudo-symbol 256 from - // the largest codelength. - - while (bits [i] == 0) // find largest codelength still in use - i--; - - bits [i] --; - - // Return final symbol counts (only for lengths 0..16). - - memcpy (htbl->bits, bits, sizeof (htbl->bits)); - - // Return a list of the symbols sorted by code length. - // It's not real clear to me why we don't need to consider the codelength - // changes made above, but the JPEG spec seems to think this works. - - int p = 0; - - for (i = 1; i <= MAX_CLEN; i++) - { - - for (j = 0; j <= 255; j++) - { - - if (codesize [j] == i) - { - htbl->huffval [p] = (uint8) j; - p++; - } - - } - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * HuffOptimize -- - * - * Find the best coding parameters for a Huffman-coded scan. - * When called, the scan data has already been converted to - * a sequence of MCU groups of source image samples, which - * are stored in a "big" array, mcuTable. - * - * It counts the times each category symbol occurs. Based on - * this counting, optimal Huffman tables are built. Then it - * uses this optimal Huffman table and counting table to find - * the best PSV. - * - * Results: - * Optimal Huffman tables are retured in cPtr->dcHuffTblPtrs[tbl]. - * Best PSV is retured in cPtr->Ss. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::HuffOptimize () - { - - // Collect the frequency counts. - - FreqCountSet (); - - // Generate Huffman encoding tables. - - for (uint32 channel = 0; channel < fSrcChannels; channel++) - { - - try - { - - GenHuffCoding (&huffTable [channel], freqCount [channel]); - - } - - catch (...) - { - - DNG_REPORT ("Info: Reverting to default huffman table"); - - for (uint32 j = 0; j <= 256; j++) - { - - freqCount [channel] [j] = (j <= 16 ? 1 : 0); - - } - - GenHuffCoding (&huffTable [channel], freqCount [channel]); - - } - - FixHuffTbl (&huffTable [channel]); - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EmitMarker -- - * - * Emit a marker code into the output stream. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::EmitMarker (JpegMarker mark) - { - - EmitByte (0xFF); - EmitByte ((uint8) mark); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * Emit2bytes -- - * - * Emit a 2-byte integer; these are always MSB first in JPEG - * files - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::Emit2bytes (int value) - { - - EmitByte ((value >> 8) & 0xFF); - EmitByte (value & 0xFF); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EmitDht -- - * - * Emit a DHT marker, follwed by the huffman data. - * - * Results: - * None - * - * Side effects: - * None - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::EmitDht (int index) - { - - int i; - - HuffmanTable *htbl = &huffTable [index]; - - EmitMarker (M_DHT); - - int length = 0; - - for (i = 1; i <= 16; i++) - length += htbl->bits [i]; - - Emit2bytes (length + 2 + 1 + 16); - - EmitByte ((uint8) index); - - for (i = 1; i <= 16; i++) - EmitByte (htbl->bits [i]); - - for (i = 0; i < length; i++) - EmitByte (htbl->huffval [i]); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EmitSof -- - * - * Emit a SOF marker plus data. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::EmitSof (JpegMarker code) - { - - EmitMarker (code); - - Emit2bytes (3 * fSrcChannels + 2 + 5 + 1); // length - - EmitByte ((uint8) fSrcBitDepth); - - Emit2bytes (fSrcRows); - Emit2bytes (fSrcCols); - - EmitByte ((uint8) fSrcChannels); - - for (uint32 i = 0; i < fSrcChannels; i++) - { - - EmitByte ((uint8) i); - - EmitByte ((uint8) ((1 << 4) + 1)); // Not subsampled. - - EmitByte (0); // Tq shall be 0 for lossless. - - } - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * EmitSos -- - * - * Emit a SOS marker plus data. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::EmitSos () - { - - EmitMarker (M_SOS); - - Emit2bytes (2 * fSrcChannels + 2 + 1 + 3); // length - - EmitByte ((uint8) fSrcChannels); // Ns - - for (uint32 i = 0; i < fSrcChannels; i++) - { - - // Cs,Td,Ta - - EmitByte ((uint8) i); - EmitByte ((uint8) (i << 4)); - - } - - EmitByte (1); // PSV - hardcoded - tknoll - EmitByte (0); // Spectral selection end - Se - EmitByte (0); // The point transform parameter - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * WriteFileHeader -- - * - * Write the file header. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::WriteFileHeader () - { - - EmitMarker (M_SOI); // first the SOI - - EmitSof (M_SOF3); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * WriteScanHeader -- - * - * Write the start of a scan (everything through the SOS marker). - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::WriteScanHeader () - { - - // Emit Huffman tables. - - for (uint32 i = 0; i < fSrcChannels; i++) - { - - EmitDht (i); - - } - - EmitSos (); - - } - -/*****************************************************************************/ - -/* - *-------------------------------------------------------------- - * - * WriteFileTrailer -- - * - * Write the End of image marker at the end of a JPEG file. - * - * Results: - * None. - * - * Side effects: - * None. - * - *-------------------------------------------------------------- - */ - -void dng_lossless_encoder::WriteFileTrailer () - { - - EmitMarker (M_EOI); - - } - -/*****************************************************************************/ - -void dng_lossless_encoder::Encode () - { - - DNG_ASSERT (fSrcChannels <= 4, "Too many components in scan"); - - // Count the times each difference category occurs. - // Construct the optimal Huffman table. - - HuffOptimize (); - - // Write the frame and scan headers. - - WriteFileHeader (); - - WriteScanHeader (); - - // Encode the image. - - HuffEncode (); - - // Clean up everything. - - WriteFileTrailer (); - - } - -/*****************************************************************************/ - -void EncodeLosslessJPEG (const uint16 *srcData, - uint32 srcRows, - uint32 srcCols, - uint32 srcChannels, - uint32 srcBitDepth, - int32 srcRowStep, - int32 srcColStep, - dng_stream &stream) - { - - dng_lossless_encoder encoder (srcData, - srcRows, - srcCols, - srcChannels, - srcBitDepth, - srcRowStep, - srcColStep, - stream); - - encoder.Encode (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_lossless_jpeg.h b/third_party/dng_sdk/dng_lossless_jpeg.h deleted file mode 100644 index be8bb50..0000000 --- a/third_party/dng_sdk/dng_lossless_jpeg.h +++ /dev/null @@ -1,69 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_lossless_jpeg.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Functions for encoding and decoding lossless JPEG format. - */ - -/*****************************************************************************/ - -#ifndef __dng_lossless_jpeg__ -#define __dng_lossless_jpeg__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_spooler - { - - protected: - - virtual ~dng_spooler () - { - } - - public: - - virtual void Spool (const void *data, - uint32 count) = 0; - - }; - -/*****************************************************************************/ - -void DecodeLosslessJPEG (dng_stream &stream, - dng_spooler &spooler, - uint32 minDecodedSize, - uint32 maxDecodedSize, - bool bug16); - -/*****************************************************************************/ - -void EncodeLosslessJPEG (const uint16 *srcData, - uint32 srcRows, - uint32 srcCols, - uint32 srcChannels, - uint32 srcBitDepth, - int32 srcRowStep, - int32 srcColStep, - dng_stream &stream); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_matrix.cpp b/third_party/dng_sdk/dng_matrix.cpp deleted file mode 100644 index b96f80b..0000000 --- a/third_party/dng_sdk/dng_matrix.cpp +++ /dev/null @@ -1,1080 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_matrix.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_matrix.h" - -#include "dng_exceptions.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_matrix::dng_matrix () - - : fRows (0) - , fCols (0) - - { - - } - -/*****************************************************************************/ - -dng_matrix::dng_matrix (uint32 rows, - uint32 cols) - - : fRows (0) - , fCols (0) - - { - - if (rows < 1 || rows > kMaxColorPlanes || - cols < 1 || cols > kMaxColorPlanes) - { - - ThrowProgramError (); - - } - - fRows = rows; - fCols = cols; - - for (uint32 row = 0; row < fRows; row++) - for (uint32 col = 0; col < fCols; col++) - { - - fData [row] [col] = 0.0; - - } - - } - -/*****************************************************************************/ - -dng_matrix::dng_matrix (const dng_matrix &m) - - : fRows (m.fRows) - , fCols (m.fCols) - - { - - for (uint32 row = 0; row < fRows; row++) - for (uint32 col = 0; col < fCols; col++) - { - - fData [row] [col] = m.fData [row] [col]; - - } - - } - -/*****************************************************************************/ - -void dng_matrix::Clear () - { - - fRows = 0; - fCols = 0; - - } - -/*****************************************************************************/ - -void dng_matrix::SetIdentity (uint32 count) - { - - *this = dng_matrix (count, count); - - for (uint32 j = 0; j < count; j++) - { - - fData [j] [j] = 1.0; - - } - - } - -/******************************************************************************/ - -bool dng_matrix::operator== (const dng_matrix &m) const - { - - if (Rows () != m.Rows () || - Cols () != m.Cols ()) - { - - return false; - - } - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - if (fData [j] [k] != m.fData [j] [k]) - { - - return false; - - } - - } - - return true; - - } - -/******************************************************************************/ - -bool dng_matrix::IsDiagonal () const - { - - if (IsEmpty ()) - { - return false; - } - - if (Rows () != Cols ()) - { - return false; - } - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - if (j != k) - { - - if (fData [j] [k] != 0.0) - { - return false; - } - - } - - } - - return true; - - } - -/******************************************************************************/ - -real64 dng_matrix::MaxEntry () const - { - - if (IsEmpty ()) - { - - return 0.0; - - } - - real64 m = fData [0] [0]; - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - m = Max_real64 (m, fData [j] [k]); - - } - - return m; - - } - -/******************************************************************************/ - -real64 dng_matrix::MinEntry () const - { - - if (IsEmpty ()) - { - - return 0.0; - - } - - real64 m = fData [0] [0]; - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - m = Min_real64 (m, fData [j] [k]); - - } - - return m; - - } - -/*****************************************************************************/ - -void dng_matrix::Scale (real64 factor) - { - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - fData [j] [k] *= factor; - - } - - } - -/*****************************************************************************/ - -void dng_matrix::Round (real64 factor) - { - - real64 invFactor = 1.0 / factor; - - for (uint32 j = 0; j < Rows (); j++) - for (uint32 k = 0; k < Cols (); k++) - { - - fData [j] [k] = Round_int32 (fData [j] [k] * factor) * invFactor; - - } - - } - -/*****************************************************************************/ - -void dng_matrix::SafeRound (real64 factor) - { - - real64 invFactor = 1.0 / factor; - - for (uint32 j = 0; j < Rows (); j++) - { - - // Round each row to the specified accuracy, but make sure the - // a rounding does not affect the total of the elements in a row - // more than necessary. - - real64 error = 0.0; - - for (uint32 k = 0; k < Cols (); k++) - { - - fData [j] [k] += error; - - real64 rounded = Round_int32 (fData [j] [k] * factor) * invFactor; - - error = fData [j] [k] - rounded; - - fData [j] [k] = rounded; - - } - - } - - } - -/*****************************************************************************/ - -dng_matrix_3by3::dng_matrix_3by3 () - - : dng_matrix (3, 3) - - { - } - -/*****************************************************************************/ - -dng_matrix_3by3::dng_matrix_3by3 (const dng_matrix &m) - - : dng_matrix (m) - - { - - if (Rows () != 3 || - Cols () != 3) - { - - ThrowMatrixMath (); - - } - - } - -/*****************************************************************************/ - -dng_matrix_3by3::dng_matrix_3by3 (real64 a00, real64 a01, real64 a02, - real64 a10, real64 a11, real64 a12, - real64 a20, real64 a21, real64 a22) - - - : dng_matrix (3, 3) - - { - - fData [0] [0] = a00; - fData [0] [1] = a01; - fData [0] [2] = a02; - - fData [1] [0] = a10; - fData [1] [1] = a11; - fData [1] [2] = a12; - - fData [2] [0] = a20; - fData [2] [1] = a21; - fData [2] [2] = a22; - - } - -/*****************************************************************************/ - -dng_matrix_3by3::dng_matrix_3by3 (real64 a00, real64 a11, real64 a22) - - : dng_matrix (3, 3) - - { - - fData [0] [0] = a00; - fData [1] [1] = a11; - fData [2] [2] = a22; - - } - -/*****************************************************************************/ - -dng_matrix_4by3::dng_matrix_4by3 () - - : dng_matrix (4, 3) - - { - } - -/*****************************************************************************/ - -dng_matrix_4by3::dng_matrix_4by3 (const dng_matrix &m) - - : dng_matrix (m) - - { - - if (Rows () != 4 || - Cols () != 3) - { - - ThrowMatrixMath (); - - } - - } - -/*****************************************************************************/ - -dng_matrix_4by3::dng_matrix_4by3 (real64 a00, real64 a01, real64 a02, - real64 a10, real64 a11, real64 a12, - real64 a20, real64 a21, real64 a22, - real64 a30, real64 a31, real64 a32) - - - : dng_matrix (4, 3) - - { - - fData [0] [0] = a00; - fData [0] [1] = a01; - fData [0] [2] = a02; - - fData [1] [0] = a10; - fData [1] [1] = a11; - fData [1] [2] = a12; - - fData [2] [0] = a20; - fData [2] [1] = a21; - fData [2] [2] = a22; - - fData [3] [0] = a30; - fData [3] [1] = a31; - fData [3] [2] = a32; - - } - -/*****************************************************************************/ - -dng_vector::dng_vector () - - : fCount (0) - - { - - } - -/*****************************************************************************/ - -dng_vector::dng_vector (uint32 count) - - : fCount (0) - - { - - if (count < 1 || count > kMaxColorPlanes) - { - - ThrowProgramError (); - - } - - fCount = count; - - for (uint32 index = 0; index < fCount; index++) - { - - fData [index] = 0.0; - - } - - } - -/*****************************************************************************/ - -dng_vector::dng_vector (const dng_vector &v) - - : fCount (v.fCount) - - { - - for (uint32 index = 0; index < fCount; index++) - { - - fData [index] = v.fData [index]; - - } - - } - -/*****************************************************************************/ - -void dng_vector::Clear () - { - - fCount = 0; - - } - -/*****************************************************************************/ - -void dng_vector::SetIdentity (uint32 count) - { - - *this = dng_vector (count); - - for (uint32 j = 0; j < count; j++) - { - - fData [j] = 1.0; - - } - - } - -/******************************************************************************/ - -bool dng_vector::operator== (const dng_vector &v) const - { - - if (Count () != v.Count ()) - { - - return false; - - } - - for (uint32 j = 0; j < Count (); j++) - { - - if (fData [j] != v.fData [j]) - { - - return false; - - } - - } - - return true; - - } - -/******************************************************************************/ - -real64 dng_vector::MaxEntry () const - { - - if (IsEmpty ()) - { - - return 0.0; - - } - - real64 m = fData [0]; - - for (uint32 j = 0; j < Count (); j++) - { - - m = Max_real64 (m, fData [j]); - - } - - return m; - - } - -/******************************************************************************/ - -real64 dng_vector::MinEntry () const - { - - if (IsEmpty ()) - { - - return 0.0; - - } - - real64 m = fData [0]; - - for (uint32 j = 0; j < Count (); j++) - { - - m = Min_real64 (m, fData [j]); - - } - - return m; - - } - -/*****************************************************************************/ - -void dng_vector::Scale (real64 factor) - { - - for (uint32 j = 0; j < Count (); j++) - { - - fData [j] *= factor; - - } - - } - -/*****************************************************************************/ - -void dng_vector::Round (real64 factor) - { - - real64 invFactor = 1.0 / factor; - - for (uint32 j = 0; j < Count (); j++) - { - - fData [j] = Round_int32 (fData [j] * factor) * invFactor; - - } - - } - -/*****************************************************************************/ - -dng_matrix dng_vector::AsDiagonal () const - { - - dng_matrix M (Count (), Count ()); - - for (uint32 j = 0; j < Count (); j++) - { - - M [j] [j] = fData [j]; - - } - - return M; - - } - -/*****************************************************************************/ - -dng_matrix dng_vector::AsColumn () const - { - - dng_matrix M (Count (), 1); - - for (uint32 j = 0; j < Count (); j++) - { - - M [j] [0] = fData [j]; - - } - - return M; - - } - -/******************************************************************************/ - -dng_vector_3::dng_vector_3 () - - : dng_vector (3) - - { - } - -/******************************************************************************/ - -dng_vector_3::dng_vector_3 (const dng_vector &v) - - : dng_vector (v) - - { - - if (Count () != 3) - { - - ThrowMatrixMath (); - - } - - } - -/******************************************************************************/ - -dng_vector_3::dng_vector_3 (real64 a0, - real64 a1, - real64 a2) - - : dng_vector (3) - - { - - fData [0] = a0; - fData [1] = a1; - fData [2] = a2; - - } - -/******************************************************************************/ - -dng_vector_4::dng_vector_4 () - - : dng_vector (4) - - { - } - -/******************************************************************************/ - -dng_vector_4::dng_vector_4 (const dng_vector &v) - - : dng_vector (v) - - { - - if (Count () != 4) - { - - ThrowMatrixMath (); - - } - - } - -/******************************************************************************/ - -dng_vector_4::dng_vector_4 (real64 a0, - real64 a1, - real64 a2, - real64 a3) - - : dng_vector (4) - - { - - fData [0] = a0; - fData [1] = a1; - fData [2] = a2; - fData [3] = a3; - - } - -/******************************************************************************/ - -dng_matrix operator* (const dng_matrix &A, - const dng_matrix &B) - { - - if (A.Cols () != B.Rows ()) - { - - ThrowMatrixMath (); - - } - - dng_matrix C (A.Rows (), B.Cols ()); - - for (uint32 j = 0; j < C.Rows (); j++) - for (uint32 k = 0; k < C.Cols (); k++) - { - - C [j] [k] = 0.0; - - for (uint32 m = 0; m < A.Cols (); m++) - { - - real64 aa = A [j] [m]; - - real64 bb = B [m] [k]; - - C [j] [k] += aa * bb; - - } - - } - - return C; - - } - -/******************************************************************************/ - -dng_vector operator* (const dng_matrix &A, - const dng_vector &B) - { - - if (A.Cols () != B.Count ()) - { - - ThrowMatrixMath (); - - } - - dng_vector C (A.Rows ()); - - for (uint32 j = 0; j < C.Count (); j++) - { - - C [j] = 0.0; - - for (uint32 m = 0; m < A.Cols (); m++) - { - - real64 aa = A [j] [m]; - - real64 bb = B [m]; - - C [j] += aa * bb; - - } - - } - - return C; - - } - -/******************************************************************************/ - -dng_matrix operator* (real64 scale, - const dng_matrix &A) - { - - dng_matrix B (A); - - B.Scale (scale); - - return B; - - } - -/******************************************************************************/ - -dng_vector operator* (real64 scale, - const dng_vector &A) - { - - dng_vector B (A); - - B.Scale (scale); - - return B; - - } - -/******************************************************************************/ - -dng_matrix operator+ (const dng_matrix &A, - const dng_matrix &B) - { - - if (A.Cols () != B.Cols () || - A.Rows () != B.Rows ()) - { - - ThrowMatrixMath (); - - } - - dng_matrix C (A); - - for (uint32 j = 0; j < C.Rows (); j++) - for (uint32 k = 0; k < C.Cols (); k++) - { - - C [j] [k] += B [j] [k]; - - } - - return C; - - } - -/******************************************************************************/ - -const real64 kNearZero = 1.0E-10; - -/******************************************************************************/ - -// Work around bug #1294195, which may be a hardware problem on a specific machine. -// This pragma turns on "improved" floating-point consistency. -#ifdef _MSC_VER -#pragma optimize ("p", on) -#endif - -static dng_matrix Invert3by3 (const dng_matrix &A) - { - - real64 a00 = A [0] [0]; - real64 a01 = A [0] [1]; - real64 a02 = A [0] [2]; - real64 a10 = A [1] [0]; - real64 a11 = A [1] [1]; - real64 a12 = A [1] [2]; - real64 a20 = A [2] [0]; - real64 a21 = A [2] [1]; - real64 a22 = A [2] [2]; - - real64 temp [3] [3]; - - temp [0] [0] = a11 * a22 - a21 * a12; - temp [0] [1] = a21 * a02 - a01 * a22; - temp [0] [2] = a01 * a12 - a11 * a02; - temp [1] [0] = a20 * a12 - a10 * a22; - temp [1] [1] = a00 * a22 - a20 * a02; - temp [1] [2] = a10 * a02 - a00 * a12; - temp [2] [0] = a10 * a21 - a20 * a11; - temp [2] [1] = a20 * a01 - a00 * a21; - temp [2] [2] = a00 * a11 - a10 * a01; - - real64 det = (a00 * temp [0] [0] + - a01 * temp [1] [0] + - a02 * temp [2] [0]); - - if (Abs_real64 (det) < kNearZero) - { - - ThrowMatrixMath (); - - } - - dng_matrix B (3, 3); - - for (uint32 j = 0; j < 3; j++) - for (uint32 k = 0; k < 3; k++) - { - - B [j] [k] = temp [j] [k] / det; - - } - - return B; - - } - -// Reset floating-point optimization. See comment above. -#ifdef _MSC_VER -#pragma optimize ("p", off) -#endif - -/******************************************************************************/ - -static dng_matrix InvertNbyN (const dng_matrix &A) - { - - uint32 i; - uint32 j; - uint32 k; - - uint32 n = A.Rows (); - - real64 temp [kMaxColorPlanes] [kMaxColorPlanes * 2]; - - for (i = 0; i < n; i++) - for (j = 0; j < n; j++) - { - - temp [i] [j ] = A [i] [j]; - - temp [i] [j + n] = (i == j ? 1.0 : 0.0); - - } - - for (i = 0; i < n; i++) - { - - real64 alpha = temp [i] [i]; - - if (Abs_real64 (alpha) < kNearZero) - { - - ThrowMatrixMath (); - - } - - for (j = 0; j < n * 2; j++) - { - - temp [i] [j] /= alpha; - - } - - for (k = 0; k < n; k++) - { - - if (i != k) - { - - real64 beta = temp [k] [i]; - - for (j = 0; j < n * 2; j++) - { - - temp [k] [j] -= beta * temp [i] [j]; - - } - - } - - } - - } - - dng_matrix B (n, n); - - for (i = 0; i < n; i++) - for (j = 0; j < n; j++) - { - - B [i] [j] = temp [i] [j + n]; - - } - - return B; - - } - -/******************************************************************************/ - -dng_matrix Transpose (const dng_matrix &A) - { - - dng_matrix B (A.Cols (), A.Rows ()); - - for (uint32 j = 0; j < B.Rows (); j++) - for (uint32 k = 0; k < B.Cols (); k++) - { - - B [j] [k] = A [k] [j]; - - } - - return B; - - } - -/******************************************************************************/ - -dng_matrix Invert (const dng_matrix &A) - { - - if (A.Rows () < 2 || A.Cols () < 2) - { - - ThrowMatrixMath (); - - } - - if (A.Rows () == A.Cols ()) - { - - if (A.Rows () == 3) - { - - return Invert3by3 (A); - - } - - return InvertNbyN (A); - - } - - else - { - - // Compute the pseudo inverse. - - dng_matrix B = Transpose (A); - - return Invert (B * A) * B; - - } - - } - -/******************************************************************************/ - -dng_matrix Invert (const dng_matrix &A, - const dng_matrix &hint) - { - - if (A.Rows () == A .Cols () || - A.Rows () != hint.Cols () || - A.Cols () != hint.Rows ()) - { - - return Invert (A); - - } - - else - { - - // Use the specified hint matrix. - - return Invert (hint * A) * hint; - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_matrix.h b/third_party/dng_sdk/dng_matrix.h deleted file mode 100644 index cdac55a..0000000 --- a/third_party/dng_sdk/dng_matrix.h +++ /dev/null @@ -1,326 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_matrix.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Matrix and vector classes, including specialized 3x3 and 4x3 versions as - * well as length 3 vectors. - */ - -/*****************************************************************************/ - -#ifndef __dng_matrix__ -#define __dng_matrix__ - -/*****************************************************************************/ - -#include "dng_sdk_limits.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Class to represent 2D matrix up to kMaxColorPlanes x kMaxColorPlanes -/// in size. - -class dng_matrix - { - - protected: - - uint32 fRows; - uint32 fCols; - - real64 fData [kMaxColorPlanes] [kMaxColorPlanes]; - - public: - - dng_matrix (); - - dng_matrix (uint32 rows, - uint32 cols); - - dng_matrix (const dng_matrix &m); - - virtual ~dng_matrix () - { - } - - void Clear (); - - void SetIdentity (uint32 count); - - uint32 Rows () const - { - return fRows; - } - - uint32 Cols () const - { - return fCols; - } - - real64 * operator [] (uint32 row) - { - return fData [row]; - } - - const real64 * operator [] (uint32 row) const - { - return fData [row]; - } - - bool operator== (const dng_matrix &m) const; - - bool operator!= (const dng_matrix &m) const - { - return !(*this == m); - } - - bool IsEmpty () const - { - return fRows == 0 || fCols == 0; - } - - bool NotEmpty () const - { - return !IsEmpty (); - } - - bool IsDiagonal () const; - - real64 MaxEntry () const; - - real64 MinEntry () const; - - void Scale (real64 factor); - - void Round (real64 factor); - - void SafeRound (real64 factor); - - }; - -/*****************************************************************************/ - -/// \brief A 3x3 matrix. - -class dng_matrix_3by3: public dng_matrix - { - - public: - - dng_matrix_3by3 (); - - dng_matrix_3by3 (const dng_matrix &m); - - dng_matrix_3by3 (real64 a00, real64 a01, real64 a02, - real64 a10, real64 a11, real64 a12, - real64 a20, real64 a21, real64 a22); - - dng_matrix_3by3 (real64 a00, real64 a11, real64 a22); - - }; - -/*****************************************************************************/ - -/// \brief A 4x3 matrix. Handy for working with 4-color cameras. - -class dng_matrix_4by3: public dng_matrix - { - - public: - - dng_matrix_4by3 (); - - dng_matrix_4by3 (const dng_matrix &m); - - dng_matrix_4by3 (real64 a00, real64 a01, real64 a02, - real64 a10, real64 a11, real64 a12, - real64 a20, real64 a21, real64 a22, - real64 a30, real64 a31, real64 a32); - - }; - -/*****************************************************************************/ - -/// \brief Class to represent 1-dimensional vector with up to kMaxColorPlanes -/// components. - -class dng_vector - { - - protected: - - uint32 fCount; - - real64 fData [kMaxColorPlanes]; - - public: - - dng_vector (); - - dng_vector (uint32 count); - - dng_vector (const dng_vector &v); - - virtual ~dng_vector () - { - } - - void Clear (); - - void SetIdentity (uint32 count); - - uint32 Count () const - { - return fCount; - } - - real64 & operator [] (uint32 index) - { - return fData [index]; - } - - const real64 & operator [] (uint32 index) const - { - return fData [index]; - } - - bool operator== (const dng_vector &v) const; - - bool operator!= (const dng_vector &v) const - { - return !(*this == v); - } - - bool IsEmpty () const - { - return fCount == 0; - } - - bool NotEmpty () const - { - return !IsEmpty (); - } - - real64 MaxEntry () const; - - real64 MinEntry () const; - - void Scale (real64 factor); - - void Round (real64 factor); - - dng_matrix AsDiagonal () const; - - dng_matrix AsColumn () const; - - }; - -/*****************************************************************************/ - -/// \brief A 3-element vector. - -class dng_vector_3: public dng_vector - { - - public: - - dng_vector_3 (); - - dng_vector_3 (const dng_vector &v); - - dng_vector_3 (real64 a0, - real64 a1, - real64 a2); - - }; - -/*****************************************************************************/ - -/// \brief A 4-element vector. - -class dng_vector_4: public dng_vector - { - - public: - - dng_vector_4 (); - - dng_vector_4 (const dng_vector &v); - - dng_vector_4 (real64 a0, - real64 a1, - real64 a2, - real64 a3); - - }; - -/*****************************************************************************/ - -dng_matrix operator* (const dng_matrix &A, - const dng_matrix &B); - -dng_vector operator* (const dng_matrix &A, - const dng_vector &B); - -dng_matrix operator* (real64 scale, - const dng_matrix &A); - -dng_vector operator* (real64 scale, - const dng_vector &A); - -/*****************************************************************************/ - -dng_matrix operator+ (const dng_matrix &A, - const dng_matrix &B); - -/*****************************************************************************/ - -dng_matrix Transpose (const dng_matrix &A); - -/*****************************************************************************/ - -dng_matrix Invert (const dng_matrix &A); - -dng_matrix Invert (const dng_matrix &A, - const dng_matrix &hint); - -/*****************************************************************************/ - -inline real64 MaxEntry (const dng_matrix &A) - { - return A.MaxEntry (); - } - -inline real64 MaxEntry (const dng_vector &A) - { - return A.MaxEntry (); - } - -/*****************************************************************************/ - -inline real64 MinEntry (const dng_matrix &A) - { - return A.MinEntry (); - } - -inline real64 MinEntry (const dng_vector &A) - { - return A.MinEntry (); - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_memory.cpp b/third_party/dng_sdk/dng_memory.cpp deleted file mode 100644 index 3e50b97..0000000 --- a/third_party/dng_sdk/dng_memory.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_memory.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_memory.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" - -/*****************************************************************************/ - -dng_memory_data::dng_memory_data () - - : fBuffer (NULL) - - { - - } - -/*****************************************************************************/ - -dng_memory_data::dng_memory_data (uint32 size) - - : fBuffer (NULL) - - { - - Allocate (size); - - } - -/*****************************************************************************/ - -dng_memory_data::~dng_memory_data () - { - - Clear (); - - } - -/*****************************************************************************/ - -void dng_memory_data::Allocate (uint32 size) - { - - Clear (); - - if (size) - { - - fBuffer = (char*)malloc (size); - - if (!fBuffer) - { - - ThrowMemoryFull (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_memory_data::Clear () - { - - if (fBuffer) - { - - free (fBuffer); - - fBuffer = NULL; - - } - - } - -/*****************************************************************************/ - -dng_memory_block * dng_memory_block::Clone (dng_memory_allocator &allocator) const - { - - uint32 size = LogicalSize (); - - dng_memory_block * result = allocator.Allocate (size); - - DoCopyBytes (Buffer (), result->Buffer (), size); - - return result; - - } - -/*****************************************************************************/ - -class dng_malloc_block : public dng_memory_block - { - - private: - - void *fMalloc; - - public: - - dng_malloc_block (uint32 logicalSize); - - virtual ~dng_malloc_block (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_malloc_block (const dng_malloc_block &block); - - dng_malloc_block & operator= (const dng_malloc_block &block); - - }; - -/*****************************************************************************/ - -dng_malloc_block::dng_malloc_block (uint32 logicalSize) - - : dng_memory_block (logicalSize) - - , fMalloc (NULL) - - { - -#if qLinux - - int err = ::posix_memalign( (void **) &fMalloc, 16, (size_t) PhysicalSize() ); - - if (err) - { - - ThrowMemoryFull (); - - } - -#else - - fMalloc = (char*)malloc (PhysicalSize ()); - - if (!fMalloc) - { - - ThrowMemoryFull (); - - } - -#endif - - SetBuffer (fMalloc); - - } - -/*****************************************************************************/ - -dng_malloc_block::~dng_malloc_block () - { - - if (fMalloc) - { - - free (fMalloc); - - } - - } - -/*****************************************************************************/ - -dng_memory_block * dng_memory_allocator::Allocate (uint32 size) - { - - dng_memory_block *result = new dng_malloc_block (size); - - if (!result) - { - - ThrowMemoryFull (); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_memory_allocator gDefaultDNGMemoryAllocator; - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_memory.h b/third_party/dng_sdk/dng_memory.h deleted file mode 100644 index 809e68a..0000000 --- a/third_party/dng_sdk/dng_memory.h +++ /dev/null @@ -1,515 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_memory.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** Support for memory allocation. - */ - -/*****************************************************************************/ - -#ifndef __dng_memory__ -#define __dng_memory__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Class to provide resource acquisition is instantiation discipline -/// for small memory allocations. -/// -/// This class does not use dng_memory_allocator for memory allocation. - -class dng_memory_data - { - - private: - - char *fBuffer; - - public: - - /// Construct an empty memory buffer using malloc. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - dng_memory_data (); - - /// Construct memory buffer of size bytes using malloc. - /// \param size Number of bytes of memory needed. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - dng_memory_data (uint32 size); - - /// Release memory buffer using free. - - ~dng_memory_data (); - - /// Clear existing memory buffer and allocate new memory of size bytes. - /// \param size Number of bytes of memory needed. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - void Allocate (uint32 size); - - /// Release any allocated memory using free. Object is still valid and - /// Allocate can be called again. - - void Clear (); - - /// Return pointer to allocated memory as a void *.. - /// \retval void * valid for as many bytes as were allocated. - - void * Buffer () - { - return fBuffer; - } - - /// Return pointer to allocated memory as a const void *. - /// \retval const void * valid for as many bytes as were allocated. - - const void * Buffer () const - { - return fBuffer; - } - - /// Return pointer to allocated memory as a char *. - /// \retval char * valid for as many bytes as were allocated. - - char * Buffer_char () - { - return (char *) Buffer (); - } - - /// Return pointer to allocated memory as a const char *. - /// \retval const char * valid for as many bytes as were allocated. - - const char * Buffer_char () const - { - return (const char *) Buffer (); - } - - /// Return pointer to allocated memory as a uint8 *. - /// \retval uint8 * valid for as many bytes as were allocated. - - uint8 * Buffer_uint8 () - { - return (uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint8 *. - /// \retval const uint8 * valid for as many bytes as were allocated. - - const uint8 * Buffer_uint8 () const - { - return (const uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint16 *. - /// \retval uint16 * valid for as many bytes as were allocated. - - uint16 * Buffer_uint16 () - { - return (uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint16 *. - /// \retval const uint16 * valid for as many bytes as were allocated. - - const uint16 * Buffer_uint16 () const - { - return (const uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a int16 *. - /// \retval int16 * valid for as many bytes as were allocated. - - int16 * Buffer_int16 () - { - return (int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int16 *. - /// \retval const int16 * valid for as many bytes as were allocated. - - const int16 * Buffer_int16 () const - { - return (const int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint32 *. - /// \retval uint32 * valid for as many bytes as were allocated. - - uint32 * Buffer_uint32 () - { - return (uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint32 *. - /// \retval uint32 * valid for as many bytes as were allocated. - - const uint32 * Buffer_uint32 () const - { - return (const uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int32 *. - /// \retval const int32 * valid for as many bytes as were allocated. - - int32 * Buffer_int32 () - { - return (int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int32 *. - /// \retval const int32 * valid for as many bytes as were allocated. - - const int32 * Buffer_int32 () const - { - return (const int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint64 *. - /// \retval uint64 * valid for as many bytes as were allocated. - - uint64 * Buffer_uint64 () - { - return (uint64 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint64 *. - /// \retval uint64 * valid for as many bytes as were allocated. - - const uint64 * Buffer_uint64 () const - { - return (const uint64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int64 *. - /// \retval const int64 * valid for as many bytes as were allocated. - - int64 * Buffer_int64 () - { - return (int64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int64 *. - /// \retval const int64 * valid for as many bytes as were allocated. - - const int64 * Buffer_int64 () const - { - return (const int64 *) Buffer (); - } - - /// Return pointer to allocated memory as a real32 *. - /// \retval real32 * valid for as many bytes as were allocated. - - real32 * Buffer_real32 () - { - return (real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real32 *. - /// \retval const real32 * valid for as many bytes as were allocated. - - const real32 * Buffer_real32 () const - { - return (const real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a real64 *. - /// \retval real64 * valid for as many bytes as were allocated. - - real64 * Buffer_real64 () - { - return (real64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real64 *. - /// \retval const real64 * valid for as many bytes as were allocated. - - const real64 * Buffer_real64 () const - { - return (const real64 *) Buffer (); - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_memory_data (const dng_memory_data &data); - - dng_memory_data & operator= (const dng_memory_data &data); - - }; - -/*****************************************************************************/ - -/// \brief Class to provide resource acquisition is instantiation discipline for -/// image buffers and other larger memory allocations. -/// -/// This class requires a dng_memory_allocator for allocation. - -class dng_memory_block - { - - private: - - uint32 fLogicalSize; - - char *fBuffer; - - protected: - - dng_memory_block (uint32 logicalSize) - : fLogicalSize (logicalSize) - , fBuffer (NULL) - { - } - - uint32 PhysicalSize () - { - - // This size is padded for TWO reasons! The first is allow alignment - // to 16-byte boundaries if the allocator does not do that already. The - // second, which is very important, so to provide safe overread areas for - // SSE2-type bottlenecks, which can often be written faster by allowing them - // to reading slightly block. Someone on the image core them did not - // understand this and removed this padding. I'm undoing this removal - // and restoring this padding, since removing it might lead to memory - // access crashes in some cases. - - // This padding is throwing off all of our allocations (f.e. dng_string, pixel buffers, etc) - // that uses dng_memory_block on iOS/Android that is memory limited. Imagecore carefully - // allocates pow2 tile buffers, but this bumps us to the next ssd block (+4K). - // This also makes it difficult to identify memory reports in Instruments since all - // numbers are off by 64. Imagecore never crashed from the removal of the padding. - // The allocator on Win64/Mac64 is 16-byte aligned already. iOS is too. - // Linux is 8 byte, but it's using mem_align. - // We should fix the SIMD routines and revisit removing this padding - Alec. - - return fLogicalSize + 64; - - } - - void SetBuffer (void *p) - { - fBuffer = (char *) ((((uintptr) p) + 15) & ~((uintptr) 15)); - } - - public: - - virtual ~dng_memory_block () - { - } - - dng_memory_block * Clone (dng_memory_allocator &allocator) const; - - /// Getter for available size, in bytes, of memory block. - /// \retval size in bytes of available memory in memory block. - - uint32 LogicalSize () const - { - return fLogicalSize; - } - - /// Return pointer to allocated memory as a void *.. - /// \retval void * valid for as many bytes as were allocated. - - void * Buffer () - { - return fBuffer; - } - - /// Return pointer to allocated memory as a const void *. - /// \retval const void * valid for as many bytes as were allocated. - - const void * Buffer () const - { - return fBuffer; - } - - /// Return pointer to allocated memory as a char *. - /// \retval char * valid for as many bytes as were allocated. - - char * Buffer_char () - { - return (char *) Buffer (); - } - - /// Return pointer to allocated memory as a const char *. - /// \retval const char * valid for as many bytes as were allocated. - - const char * Buffer_char () const - { - return (const char *) Buffer (); - } - - /// Return pointer to allocated memory as a uint8 *. - /// \retval uint8 * valid for as many bytes as were allocated. - - uint8 * Buffer_uint8 () - { - return (uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint8 *. - /// \retval const uint8 * valid for as many bytes as were allocated. - - const uint8 * Buffer_uint8 () const - { - return (const uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint16 *. - /// \retval uint16 * valid for as many bytes as were allocated. - - uint16 * Buffer_uint16 () - { - return (uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint16 *. - /// \retval const uint16 * valid for as many bytes as were allocated. - - const uint16 * Buffer_uint16 () const - { - return (const uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a int16 *. - /// \retval int16 * valid for as many bytes as were allocated. - - int16 * Buffer_int16 () - { - return (int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int16 *. - /// \retval const int16 * valid for as many bytes as were allocated. - - const int16 * Buffer_int16 () const - { - return (const int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint32 *. - /// \retval uint32 * valid for as many bytes as were allocated. - - uint32 * Buffer_uint32 () - { - return (uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint32 *. - /// \retval const uint32 * valid for as many bytes as were allocated. - - const uint32 * Buffer_uint32 () const - { - return (const uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a int32 *. - /// \retval int32 * valid for as many bytes as were allocated. - - int32 * Buffer_int32 () - { - return (int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int32 *. - /// \retval const int32 * valid for as many bytes as were allocated. - - const int32 * Buffer_int32 () const - { - return (const int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a real32 *. - /// \retval real32 * valid for as many bytes as were allocated. - - real32 * Buffer_real32 () - { - return (real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real32 *. - /// \retval const real32 * valid for as many bytes as were allocated. - - const real32 * Buffer_real32 () const - { - return (const real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a real64 *. - /// \retval real64 * valid for as many bytes as were allocated. - - real64 * Buffer_real64 () - { - return (real64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real64 *. - /// \retval const real64 * valid for as many bytes as were allocated. - - const real64 * Buffer_real64 () const - { - return (const real64 *) Buffer (); - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_memory_block (const dng_memory_block &data); - - dng_memory_block & operator= (const dng_memory_block &data); - - }; - -/*****************************************************************************/ - -/// \brief Interface for dng_memory_block allocator. - -class dng_memory_allocator - { - - public: - - virtual ~dng_memory_allocator () - { - } - - /// Allocate a dng_memory block. - /// \param size Number of bytes in memory block. - /// \retval A dng_memory_block with at least size bytes of valid storage. - /// \exception dng_exception with fErrorCode equal to dng_error_memory. - - virtual dng_memory_block * Allocate (uint32 size); - - }; - -/*****************************************************************************/ - -/// \brief Default memory allocator used if NULL is passed in for allocator -/// when constructing a dng_host. -/// -/// Uses new and delete for memory block object and malloc/free for underlying -/// buffer. - -extern dng_memory_allocator gDefaultDNGMemoryAllocator; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_memory_stream.cpp b/third_party/dng_sdk/dng_memory_stream.cpp deleted file mode 100644 index 6b8f38e..0000000 --- a/third_party/dng_sdk/dng_memory_stream.cpp +++ /dev/null @@ -1,254 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_memory_stream.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_memory_stream.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_memory_stream::dng_memory_stream (dng_memory_allocator &allocator, - dng_abort_sniffer *sniffer, - uint32 pageSize) - - : dng_stream (sniffer, - kDefaultBufferSize, - kDNGStreamInvalidOffset) - - , fAllocator (allocator) - , fPageSize (pageSize ) - - , fPageCount (0) - , fPagesAllocated (0) - , fPageList (NULL) - - , fMemoryStreamLength (0) - - { - - } - -/*****************************************************************************/ - -dng_memory_stream::~dng_memory_stream () - { - - if (fPageList) - { - - for (uint32 index = 0; index < fPageCount; index++) - { - - delete fPageList [index]; - - } - - free (fPageList); - - } - - } - -/*****************************************************************************/ - -uint64 dng_memory_stream::DoGetLength () - { - - return fMemoryStreamLength; - - } - -/*****************************************************************************/ - -void dng_memory_stream::DoRead (void *data, - uint32 count, - uint64 offset) - { - - if (offset + count > fMemoryStreamLength) - { - - ThrowEndOfFile (); - - } - - uint64 baseOffset = offset; - - while (count) - { - - uint32 pageIndex = (uint32) (offset / fPageSize); - uint32 pageOffset = (uint32) (offset % fPageSize); - - uint32 blockCount = Min_uint32 (fPageSize - pageOffset, count); - - const uint8 *sPtr = fPageList [pageIndex]->Buffer_uint8 () + - pageOffset; - - uint8 *dPtr = ((uint8 *) data) + (uint32) (offset - baseOffset); - - DoCopyBytes (sPtr, dPtr, blockCount); - - offset += blockCount; - count -= blockCount; - - } - - } - -/*****************************************************************************/ - -void dng_memory_stream::DoSetLength (uint64 length) - { - - while (length > fPageCount * (uint64) fPageSize) - { - - if (fPageCount == fPagesAllocated) - { - - uint32 newSize = Max_uint32 (fPagesAllocated + 32, - fPagesAllocated * 2); - - dng_memory_block **list = (dng_memory_block **) - malloc (newSize * sizeof (dng_memory_block *)); - - if (!list) - { - - ThrowMemoryFull (); - - } - - if (fPageCount) - { - - DoCopyBytes (fPageList, - list, - fPageCount * (uint32) sizeof (dng_memory_block *)); - - } - - if (fPageList) - { - - free (fPageList); - - } - - fPageList = list; - - fPagesAllocated = newSize; - - } - - fPageList [fPageCount] = fAllocator.Allocate (fPageSize); - - fPageCount++; - - } - - fMemoryStreamLength = length; - - } - -/*****************************************************************************/ - -void dng_memory_stream::DoWrite (const void *data, - uint32 count, - uint64 offset) - { - - DoSetLength (Max_uint64 (fMemoryStreamLength, - offset + count)); - - uint64 baseOffset = offset; - - while (count) - { - - uint32 pageIndex = (uint32) (offset / fPageSize); - uint32 pageOffset = (uint32) (offset % fPageSize); - - uint32 blockCount = Min_uint32 (fPageSize - pageOffset, count); - - const uint8 *sPtr = ((const uint8 *) data) + (uint32) (offset - baseOffset); - - uint8 *dPtr = fPageList [pageIndex]->Buffer_uint8 () + - pageOffset; - - DoCopyBytes (sPtr, dPtr, blockCount); - - offset += blockCount; - count -= blockCount; - - } - - } - -/*****************************************************************************/ - -void dng_memory_stream::CopyToStream (dng_stream &dstStream, - uint64 count) - { - - if (count < kBigBufferSize) - { - - dng_stream::CopyToStream (dstStream, count); - - } - - else - { - - Flush (); - - uint64 offset = Position (); - - if (offset + count > Length ()) - { - - ThrowEndOfFile (); - - } - - while (count) - { - - uint32 pageIndex = (uint32) (offset / fPageSize); - uint32 pageOffset = (uint32) (offset % fPageSize); - - uint32 blockCount = (uint32) Min_uint64 (fPageSize - pageOffset, count); - - const uint8 *sPtr = fPageList [pageIndex]->Buffer_uint8 () + - pageOffset; - - dstStream.Put (sPtr, blockCount); - - offset += blockCount; - count -= blockCount; - - } - - SetReadPosition (offset); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_memory_stream.h b/third_party/dng_sdk/dng_memory_stream.h deleted file mode 100644 index 4477936..0000000 --- a/third_party/dng_sdk/dng_memory_stream.h +++ /dev/null @@ -1,97 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_memory_stream.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Stream abstraction to/from in-memory data. - */ - -/*****************************************************************************/ - -#ifndef __dng_memory_stream__ -#define __dng_memory_stream__ - -/*****************************************************************************/ - -#include "dng_stream.h" - -/*****************************************************************************/ - -/// \brief A dng_stream which can be read from or written to memory. -/// -/// Stream is populated via writing and either read or accessed by asking for contents as a pointer. - -class dng_memory_stream: public dng_stream - { - - protected: - - dng_memory_allocator &fAllocator; - - uint32 fPageSize; - - uint32 fPageCount; - uint32 fPagesAllocated; - - dng_memory_block **fPageList; - - uint64 fMemoryStreamLength; - - public: - - /// Construct a new memory-based stream. - /// \param allocator Allocator to use to allocate memory in stream as needed. - /// \param sniffer If non-NULL used to check for user cancellation. - /// \param pageSize Unit of allocation for data stored in stream. - - dng_memory_stream (dng_memory_allocator &allocator, - dng_abort_sniffer *sniffer = NULL, - uint32 pageSize = 64 * 1024); - - virtual ~dng_memory_stream (); - - /// Copy a specified number of bytes to a target stream. - /// \param dstStream The target stream. - /// \param count The number of bytes to copy. - - virtual void CopyToStream (dng_stream &dstStream, - uint64 count); - - protected: - - virtual uint64 DoGetLength (); - - virtual void DoRead (void *data, - uint32 count, - uint64 offset); - - virtual void DoSetLength (uint64 length); - - virtual void DoWrite (const void *data, - uint32 count, - uint64 offset); - - private: - - // Hidden copy constructor and assignment operator. - - dng_memory_stream (const dng_memory_stream &stream); - - dng_memory_stream & operator= (const dng_memory_stream &stream); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_misc_opcodes.cpp b/third_party/dng_sdk/dng_misc_opcodes.cpp deleted file mode 100644 index 139b79f..0000000 --- a/third_party/dng_sdk/dng_misc_opcodes.cpp +++ /dev/null @@ -1,1578 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_misc_opcodes.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_misc_opcodes.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_rect.h" -#include "dng_stream.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -dng_opcode_TrimBounds::dng_opcode_TrimBounds (const dng_rect &bounds) - - : dng_opcode (dngOpcode_TrimBounds, - dngVersion_1_3_0_0, - kFlag_None) - - , fBounds (bounds) - - { - - } - -/*****************************************************************************/ - -dng_opcode_TrimBounds::dng_opcode_TrimBounds (dng_stream &stream) - - : dng_opcode (dngOpcode_TrimBounds, - stream, - "TrimBounds") - - , fBounds () - - { - - if (stream.Get_uint32 () != 16) - { - ThrowBadFormat (); - } - - fBounds.t = stream.Get_int32 (); - fBounds.l = stream.Get_int32 (); - fBounds.b = stream.Get_int32 (); - fBounds.r = stream.Get_int32 (); - - if (fBounds.IsEmpty ()) - { - ThrowBadFormat (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Bounds: t=%d, l=%d, b=%d, r=%d\n", - (int) fBounds.t, - (int) fBounds.l, - (int) fBounds.b, - (int) fBounds.r); - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_TrimBounds::PutData (dng_stream &stream) const - { - - stream.Put_uint32 (16); - - stream.Put_int32 (fBounds.t); - stream.Put_int32 (fBounds.l); - stream.Put_int32 (fBounds.b); - stream.Put_int32 (fBounds.r); - - } - -/*****************************************************************************/ - -void dng_opcode_TrimBounds::Apply (dng_host & /* host */, - dng_negative & /* negative */, - AutoPtr &image) - { - - if (fBounds.IsEmpty () || (fBounds & image->Bounds ()) != fBounds) - { - ThrowBadFormat (); - } - - image->Trim (fBounds); - - } - -/*****************************************************************************/ - -void dng_area_spec::GetData (dng_stream &stream) - { - - fArea.t = stream.Get_int32 (); - fArea.l = stream.Get_int32 (); - fArea.b = stream.Get_int32 (); - fArea.r = stream.Get_int32 (); - - fPlane = stream.Get_uint32 (); - fPlanes = stream.Get_uint32 (); - - fRowPitch = stream.Get_uint32 (); - fColPitch = stream.Get_uint32 (); - - if (fPlanes < 1) - { - ThrowBadFormat (); - } - - if (fRowPitch < 1 || fColPitch < 1) - { - ThrowBadFormat (); - } - - if (fArea.IsEmpty () && (fRowPitch != 1 || fColPitch != 1)) - { - ThrowBadFormat (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AreaSpec: t=%d, l=%d, b=%d, r=%d, p=%u:%u, rp=%u, cp=%u\n", - (int) fArea.t, - (int) fArea.l, - (int) fArea.b, - (int) fArea.r, - (unsigned) fPlane, - (unsigned) fPlanes, - (unsigned) fRowPitch, - (unsigned) fColPitch); - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_area_spec::PutData (dng_stream &stream) const - { - - stream.Put_int32 (fArea.t); - stream.Put_int32 (fArea.l); - stream.Put_int32 (fArea.b); - stream.Put_int32 (fArea.r); - - stream.Put_uint32 (fPlane); - stream.Put_uint32 (fPlanes); - - stream.Put_uint32 (fRowPitch); - stream.Put_uint32 (fColPitch); - - } - -/*****************************************************************************/ - -dng_rect dng_area_spec::Overlap (const dng_rect &tile) const - { - - // Special case - if the fArea is empty, then dng_area_spec covers - // the entire image, no matter how large it is. - - if (fArea.IsEmpty ()) - { - return tile; - } - - dng_rect overlap = fArea & tile; - - if (overlap.NotEmpty ()) - { - - overlap.t = fArea.t + ((overlap.t - fArea.t + fRowPitch - 1) / fRowPitch) * fRowPitch; - overlap.l = fArea.l + ((overlap.l - fArea.l + fColPitch - 1) / fColPitch) * fColPitch; - - if (overlap.NotEmpty ()) - { - - overlap.b = overlap.t + ((overlap.H () - 1) / fRowPitch) * fRowPitch + 1; - overlap.r = overlap.l + ((overlap.W () - 1) / fColPitch) * fColPitch + 1; - - return overlap; - - } - - } - - return dng_rect (); - - } - -/*****************************************************************************/ - -dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host, - const dng_area_spec &areaSpec, - const uint16 *table, - uint32 count) - - : dng_inplace_opcode (dngOpcode_MapTable, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fTable () - , fCount (count) - - { - - if (count == 0 || count > 0x10000) - { - ThrowProgramError (); - } - - fTable.Reset (host.Allocate (0x10000 * sizeof (uint16))); - - DoCopyBytes (table, - fTable->Buffer (), - count * (uint32) sizeof (uint16)); - - ReplicateLastEntry (); - - } - -/*****************************************************************************/ - -dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_MapTable, - stream, - "MapTable") - - , fAreaSpec () - , fTable () - , fCount (0) - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - fCount = stream.Get_uint32 (); - - if (dataSize != dng_area_spec::kDataSize + 4 + fCount * 2) - { - ThrowBadFormat (); - } - - if (fCount == 0 || fCount > 0x10000) - { - ThrowBadFormat (); - } - - fTable.Reset (host.Allocate (0x10000 * sizeof (uint16))); - - uint16 *table = fTable->Buffer_uint16 (); - - for (uint32 index = 0; index < fCount; index++) - { - table [index] = stream.Get_uint16 (); - } - - ReplicateLastEntry (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Count: %u\n", (unsigned) fCount); - - for (uint32 j = 0; j < fCount && j < gDumpLineLimit; j++) - { - printf (" Table [%5u] = %5u\n", (unsigned) j, (unsigned) table [j]); - } - - if (fCount > gDumpLineLimit) - { - printf (" ... %u table entries skipped\n", (unsigned) (fCount - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_MapTable::ReplicateLastEntry () - { - - uint16 *table = fTable->Buffer_uint16 (); - - uint16 lastEntry = table [fCount]; - - for (uint32 index = fCount; index < 0x10000; index++) - { - table [index] = lastEntry; - } - - } - -/*****************************************************************************/ - -void dng_opcode_MapTable::PutData (dng_stream &stream) const - { - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + fCount * 2); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (fCount); - - uint16 *table = fTable->Buffer_uint16 (); - - for (uint32 index = 0; index < fCount; index++) - { - stream.Put_uint16 (table [index]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_MapTable::BufferPixelType (uint32 /* imagePixelType */) - { - - return ttShort; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_MapTable::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_MapTable::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - DoMapArea16 (buffer.DirtyPixel_uint16 (overlap.t, overlap.l, plane), - 1, - (overlap.H () + fAreaSpec.RowPitch () - 1) / fAreaSpec.RowPitch (), - (overlap.W () + fAreaSpec.ColPitch () - 1) / fAreaSpec.ColPitch (), - 0, - fAreaSpec.RowPitch () * buffer.RowStep (), - fAreaSpec.ColPitch (), - fTable->Buffer_uint16 ()); - - } - - } - - } - -/*****************************************************************************/ - -dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (const dng_area_spec &areaSpec, - uint32 degree, - const real64 *coefficient) - - : dng_inplace_opcode (dngOpcode_MapPolynomial, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fDegree (degree) - - { - - for (uint32 j = 0; j <= kMaxDegree; j++) - { - - if (j <= fDegree) - { - fCoefficient [j] = coefficient [j]; - } - - else - { - fCoefficient [j] = 0.0; - } - - } - - // Reduce degree if possible. - - while (fDegree > 0 && fCoefficient [fDegree] == 0.0) - { - fDegree--; - } - - } - -/*****************************************************************************/ - -dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_MapPolynomial, - stream, - "MapPolynomial") - - , fAreaSpec () - , fDegree (0) - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - fDegree = stream.Get_uint32 (); - - if (dataSize != dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8) - { - ThrowBadFormat (); - } - - if (fDegree > kMaxDegree) - { - ThrowBadFormat (); - } - - for (uint32 j = 0; j <= kMaxDegree; j++) - { - - if (j <= fDegree) - { - fCoefficient [j] = stream.Get_real64 (); - } - else - { - fCoefficient [j] = 0.0; - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - for (uint32 k = 0; k <= fDegree; k++) - { - printf (" Coefficient [%u] = %f\n", (unsigned) k, fCoefficient [k]); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_MapPolynomial::PutData (dng_stream &stream) const - { - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (fDegree); - - for (uint32 j = 0; j <= fDegree; j++) - { - stream.Put_real64 (fCoefficient [j]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_MapPolynomial::BufferPixelType (uint32 imagePixelType) - { - - // If we are operating on the stage 1 image, then we need - // to adjust the coefficients to convert from the image - // values to the 32-bit floating point values that this - // opcode operates on. - - // If we are operating on the stage 2 or 3 image, the logical - // range of the image is already 0.0 to 1.0, so we don't - // need to adjust the values. - - real64 scale32 = 1.0; - - if (Stage () == 1) - { - - switch (imagePixelType) - { - - case ttFloat: - break; - - case ttShort: - { - scale32 = (real64) 0xFFFF; - break; - } - - case ttLong: - { - scale32 = (real64) 0xFFFFFFFF; - break; - } - - default: - ThrowBadFormat (); - - } - - } - - real64 factor32 = 1.0 / scale32; - - for (uint32 j = 0; j <= kMaxDegree; j++) - { - - fCoefficient32 [j] = (real32) (fCoefficient [j] * factor32); - - factor32 *= scale32; - - } - - return ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_MapPolynomial::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_MapPolynomial::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 cols = overlap.W (); - - uint32 colPitch = fAreaSpec.ColPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) - { - - real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); - - switch (fDegree) - { - - case 0: - { - - real32 y = Pin_real32 (0.0f, - fCoefficient32 [0], - 1.0f); - - for (uint32 col = 0; col < cols; col += colPitch) - { - - dPtr [col] = y; - - } - - break; - - } - - case 1: - { - - real32 c0 = fCoefficient32 [0]; - real32 c1 = fCoefficient32 [1]; - - if (c0 == 0.0f) - { - - if (c1 > 0.0f) - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = c1 * x; - - dPtr [col] = Min_real32 (y, 1.0f); - - } - - } - - else - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - dPtr [col] = 0.0f; - - } - - } - - } - - else - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = c0 + - c1 * x; - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - } - - break; - - } - - case 2: - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = fCoefficient32 [0] + x * - (fCoefficient32 [1] + x * - (fCoefficient32 [2])); - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - break; - - } - - case 3: - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = fCoefficient32 [0] + x * - (fCoefficient32 [1] + x * - (fCoefficient32 [2] + x * - (fCoefficient32 [3]))); - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - break; - - } - - case 4: - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = fCoefficient32 [0] + x * - (fCoefficient32 [1] + x * - (fCoefficient32 [2] + x * - (fCoefficient32 [3] + x * - (fCoefficient32 [4])))); - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - break; - - } - - default: - { - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = fCoefficient32 [0]; - - real32 xx = x; - - for (uint32 j = 1; j <= fDegree; j++) - { - - y += fCoefficient32 [j] * xx; - - xx *= x; - - } - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - } - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec, - AutoPtr &table) - - : dng_inplace_opcode (dngOpcode_DeltaPerRow, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fTable () - , fScale (1.0f) - - { - - fTable.Reset (table.Release ()); - - } - -/*****************************************************************************/ - -dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_DeltaPerRow, - stream, - "DeltaPerRow") - - , fAreaSpec () - , fTable () - , fScale (1.0f) - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - uint32 deltas = (fAreaSpec.Area ().H () + - fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - if (deltas != stream.Get_uint32 ()) - { - ThrowBadFormat (); - } - - if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4) - { - ThrowBadFormat (); - } - - fTable.Reset (host.Allocate (deltas * (uint32) sizeof (real32))); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < deltas; j++) - { - table [j] = stream.Get_real32 (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Count: %u\n", (unsigned) deltas); - - for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++) - { - printf (" Delta [%u] = %f\n", (unsigned) k, table [k]); - } - - if (deltas > gDumpLineLimit) - { - printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_DeltaPerRow::PutData (dng_stream &stream) const - { - - uint32 deltas = (fAreaSpec.Area ().H () + - fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (deltas); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < deltas; j++) - { - stream.Put_real32 (table [j]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_DeltaPerRow::BufferPixelType (uint32 imagePixelType) - { - - real64 scale32 = 1.0; - - switch (imagePixelType) - { - - case ttFloat: - break; - - case ttShort: - { - scale32 = (real64) 0xFFFF; - break; - } - - case ttLong: - { - scale32 = (real64) 0xFFFFFFFF; - break; - } - - default: - ThrowBadFormat (); - - } - - fScale = (real32) (1.0 / scale32); - - return ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_DeltaPerRow::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_DeltaPerRow::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 cols = overlap.W (); - - uint32 colPitch = fAreaSpec.ColPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - const real32 *table = fTable->Buffer_real32 () + - ((overlap.t - fAreaSpec.Area ().t) / - fAreaSpec.RowPitch ()); - - for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) - { - - real32 rowDelta = *(table++) * fScale; - - real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = x + rowDelta; - - dPtr [col] = Pin_real32 (0.0f, y, 1.0f); - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (const dng_area_spec &areaSpec, - AutoPtr &table) - - : dng_inplace_opcode (dngOpcode_DeltaPerColumn, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fTable () - , fScale (1.0f) - - { - - fTable.Reset (table.Release ()); - - } - -/*****************************************************************************/ - -dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_DeltaPerColumn, - stream, - "DeltaPerColumn") - - , fAreaSpec () - , fTable () - , fScale (1.0f) - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - uint32 deltas = (fAreaSpec.Area ().W () + - fAreaSpec.ColPitch () - 1) / - fAreaSpec.ColPitch (); - - if (deltas != stream.Get_uint32 ()) - { - ThrowBadFormat (); - } - - if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4) - { - ThrowBadFormat (); - } - - fTable.Reset (host.Allocate (deltas * (uint32) sizeof (real32))); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < deltas; j++) - { - table [j] = stream.Get_real32 (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Count: %u\n", (unsigned) deltas); - - for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++) - { - printf (" Delta [%u] = %f\n", (unsigned) k, table [k]); - } - - if (deltas > gDumpLineLimit) - { - printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_DeltaPerColumn::PutData (dng_stream &stream) const - { - - uint32 deltas = (fAreaSpec.Area ().W () + - fAreaSpec.ColPitch () - 1) / - fAreaSpec.ColPitch (); - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (deltas); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < deltas; j++) - { - stream.Put_real32 (table [j]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_DeltaPerColumn::BufferPixelType (uint32 imagePixelType) - { - - real64 scale32 = 1.0; - - switch (imagePixelType) - { - - case ttFloat: - break; - - case ttShort: - { - scale32 = (real64) 0xFFFF; - break; - } - - case ttLong: - { - scale32 = (real64) 0xFFFFFFFF; - break; - } - - default: - ThrowBadFormat (); - - } - - fScale = (real32) (1.0 / scale32); - - return ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_DeltaPerColumn::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_DeltaPerColumn::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - const real32 *table = fTable->Buffer_real32 () + - ((overlap.l - fAreaSpec.Area ().l) / - fAreaSpec.ColPitch ()); - - for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ()) - { - - real32 colDelta = *(table++) * fScale; - - real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane); - - for (uint32 row = 0; row < rows; row++) - { - - real32 x = dPtr [0]; - - real32 y = x + colDelta; - - dPtr [0] = Pin_real32 (0.0f, y, 1.0f); - - dPtr += rowStep; - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (const dng_area_spec &areaSpec, - AutoPtr &table) - - : dng_inplace_opcode (dngOpcode_ScalePerRow, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fTable () - - { - - fTable.Reset (table.Release ()); - - } - -/*****************************************************************************/ - -dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_ScalePerRow, - stream, - "ScalePerRow") - - , fAreaSpec () - , fTable () - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - uint32 scales = (fAreaSpec.Area ().H () + - fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - if (scales != stream.Get_uint32 ()) - { - ThrowBadFormat (); - } - - if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4) - { - ThrowBadFormat (); - } - - fTable.Reset (host.Allocate (scales * (uint32) sizeof (real32))); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < scales; j++) - { - table [j] = stream.Get_real32 (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Count: %u\n", (unsigned) scales); - - for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++) - { - printf (" Scale [%u] = %f\n", (unsigned) k, table [k]); - } - - if (scales > gDumpLineLimit) - { - printf (" ... %u scales skipped\n", (unsigned) (scales - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_ScalePerRow::PutData (dng_stream &stream) const - { - - uint32 scales = (fAreaSpec.Area ().H () + - fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (scales); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < scales; j++) - { - stream.Put_real32 (table [j]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_ScalePerRow::BufferPixelType (uint32 /* imagePixelType */) - { - - return ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_ScalePerRow::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_ScalePerRow::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 cols = overlap.W (); - - uint32 colPitch = fAreaSpec.ColPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - const real32 *table = fTable->Buffer_real32 () + - ((overlap.t - fAreaSpec.Area ().t) / - fAreaSpec.RowPitch ()); - - for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) - { - - real32 rowScale = *(table++); - - real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); - - for (uint32 col = 0; col < cols; col += colPitch) - { - - real32 x = dPtr [col]; - - real32 y = x * rowScale; - - dPtr [col] = Min_real32 (y, 1.0f); - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (const dng_area_spec &areaSpec, - AutoPtr &table) - - : dng_inplace_opcode (dngOpcode_ScalePerColumn, - dngVersion_1_3_0_0, - kFlag_None) - - , fAreaSpec (areaSpec) - , fTable () - - { - - fTable.Reset (table.Release ()); - - } - -/*****************************************************************************/ - -dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (dng_host &host, - dng_stream &stream) - - : dng_inplace_opcode (dngOpcode_ScalePerColumn, - stream, - "ScalePerColumn") - - , fAreaSpec () - , fTable () - - { - - uint32 dataSize = stream.Get_uint32 (); - - fAreaSpec.GetData (stream); - - uint32 scales = (fAreaSpec.Area ().W () + - fAreaSpec.ColPitch () - 1) / - fAreaSpec.ColPitch (); - - if (scales != stream.Get_uint32 ()) - { - ThrowBadFormat (); - } - - if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4) - { - ThrowBadFormat (); - } - - fTable.Reset (host.Allocate (scales * (uint32) sizeof (real32))); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < scales; j++) - { - table [j] = stream.Get_real32 (); - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("Count: %u\n", (unsigned) scales); - - for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++) - { - printf (" Scale [%u] = %f\n", (unsigned) k, table [k]); - } - - if (scales > gDumpLineLimit) - { - printf (" ... %u deltas skipped\n", (unsigned) (scales - gDumpLineLimit)); - } - - } - - #endif - - } - -/*****************************************************************************/ - -void dng_opcode_ScalePerColumn::PutData (dng_stream &stream) const - { - - uint32 scales = (fAreaSpec.Area ().W () + - fAreaSpec.ColPitch () - 1) / - fAreaSpec.ColPitch (); - - stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4); - - fAreaSpec.PutData (stream); - - stream.Put_uint32 (scales); - - real32 *table = fTable->Buffer_real32 (); - - for (uint32 j = 0; j < scales; j++) - { - stream.Put_real32 (table [j]); - } - - } - -/*****************************************************************************/ - -uint32 dng_opcode_ScalePerColumn::BufferPixelType (uint32 /* imagePixelType */) - { - - return ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_opcode_ScalePerColumn::ModifiedBounds (const dng_rect &imageBounds) - { - - return fAreaSpec.Overlap (imageBounds); - - } - -/*****************************************************************************/ - -void dng_opcode_ScalePerColumn::ProcessArea (dng_negative & /* negative */, - uint32 /* threadIndex */, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - - dng_rect overlap = fAreaSpec.Overlap (dstArea); - - if (overlap.NotEmpty ()) - { - - uint32 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) / - fAreaSpec.RowPitch (); - - int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch (); - - for (uint32 plane = fAreaSpec.Plane (); - plane < fAreaSpec.Plane () + fAreaSpec.Planes () && - plane < buffer.Planes (); - plane++) - { - - const real32 *table = fTable->Buffer_real32 () + - ((overlap.l - fAreaSpec.Area ().l) / - fAreaSpec.ColPitch ()); - - for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ()) - { - - real32 colScale = *(table++); - - real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane); - - for (uint32 row = 0; row < rows; row++) - { - - real32 x = dPtr [0]; - - real32 y = x * colScale; - - dPtr [0] = Min_real32 (y, 1.0f); - - dPtr += rowStep; - - } - - } - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_misc_opcodes.h b/third_party/dng_sdk/dng_misc_opcodes.h deleted file mode 100644 index a211a9a..0000000 --- a/third_party/dng_sdk/dng_misc_opcodes.h +++ /dev/null @@ -1,417 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_misc_opcodes.h#2 $ */ -/* $DateTime: 2012/08/02 06:09:06 $ */ -/* $Change: 841096 $ */ -/* $Author: erichan $ */ - -/** \file - * Miscellaneous DNG opcodes. - */ - -/*****************************************************************************/ - -#ifndef __dng_misc_opcodes__ -#define __dng_misc_opcodes__ - -/*****************************************************************************/ - -#include "dng_opcodes.h" - -/*****************************************************************************/ - -/// \brief Opcode to trim image to a specified rectangle. - -class dng_opcode_TrimBounds: public dng_opcode - { - - private: - - dng_rect fBounds; - - public: - - /// Create opcode to trim image to the specified bounds. - - dng_opcode_TrimBounds (const dng_rect &bounds); - - dng_opcode_TrimBounds (dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - }; - -/*****************************************************************************/ - -/// \brief A class to describe an area of an image, including a pixel subrectangle, -/// plane range, and row/column pitch (e.g., for mosaic images). Useful for -/// specifying opcodes that only apply to specific color planes or pixel types (e.g., -/// only one of the two green Bayer pixels). - -class dng_area_spec - { - - public: - - enum - { - kDataSize = 32 - }; - - private: - - dng_rect fArea; - - uint32 fPlane; - uint32 fPlanes; - - uint32 fRowPitch; - uint32 fColPitch; - - public: - - /// Create an empty area. - - dng_area_spec (const dng_rect &area = dng_rect (), - uint32 plane = 0, - uint32 planes = 1, - uint32 rowPitch = 1, - uint32 colPitch = 1) - - : fArea (area) - , fPlane (plane) - , fPlanes (planes) - , fRowPitch (rowPitch) - , fColPitch (colPitch) - - { - } - - /// The pixel area. - - const dng_rect & Area () const - { - return fArea; - } - - /// The first plane. - - const uint32 Plane () const - { - return fPlane; - } - - /// The total number of planes. - - const uint32 Planes () const - { - return fPlanes; - } - - /// The row pitch (i.e., stride). A pitch of 1 means all rows. - - const uint32 RowPitch () const - { - return fRowPitch; - } - - /// The column pitch (i.e., stride). A pitch of 1 means all columns. - - const uint32 ColPitch () const - { - return fColPitch; - } - - /// Read area data from the specified stream. - - void GetData (dng_stream &stream); - - /// Write area data to the specified stream. - - void PutData (dng_stream &stream) const; - - /// Compute and return pixel area overlap (i.e., intersection) between this - /// area and the specified tile. - - dng_rect Overlap (const dng_rect &tile) const; - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a 1D function (represented as a 16-bit table) to an -/// image area. - -class dng_opcode_MapTable: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fTable; - - uint32 fCount; - - public: - - /// Create a MapTable opcode with the specified area, table, and number of - /// table entries. - - dng_opcode_MapTable (dng_host &host, - const dng_area_spec &areaSpec, - const uint16 *table, - uint32 count = 0x10000); - - dng_opcode_MapTable (dng_host &host, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - private: - - void ReplicateLastEntry (); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a 1D function (represented as a polynomial) to an -/// image area. - -class dng_opcode_MapPolynomial: public dng_inplace_opcode - { - - public: - - enum - { - kMaxDegree = 8 - }; - - private: - - dng_area_spec fAreaSpec; - - uint32 fDegree; - - real64 fCoefficient [kMaxDegree + 1]; - - real32 fCoefficient32 [kMaxDegree + 1]; - - public: - - /// Create a MapPolynomial opcode with the specified area, polynomial - /// degree, and polynomial coefficients. The function that will be - /// applied to each pixel x is: - /// - /// f (x) = coefficient [0] + ((x * coefficient [1]) + - /// (x^2 * coefficient [2]) + - /// (x^3 * coefficient [3]) + - /// (x^4 * coefficient [4]) ... - - dng_opcode_MapPolynomial (const dng_area_spec &areaSpec, - uint32 degree, - const real64 *coefficient); - - dng_opcode_MapPolynomial (dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a delta (i.e., offset) that varies per row. Within -/// a row, the same delta value is applied to all specified pixels. - -class dng_opcode_DeltaPerRow: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fTable; - - real32 fScale; - - public: - - /// Create a DeltaPerRow opcode with the specified area and row deltas - /// (specified as a table of 32-bit floats). - - dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec, - AutoPtr &table); - - dng_opcode_DeltaPerRow (dng_host &host, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a delta (i.e., offset) that varies per column. -/// Within a column, the same delta value is applied to all specified pixels. - -class dng_opcode_DeltaPerColumn: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fTable; - - real32 fScale; - - public: - - /// Create a DeltaPerColumn opcode with the specified area and column - /// deltas (specified as a table of 32-bit floats). - - dng_opcode_DeltaPerColumn (const dng_area_spec &areaSpec, - AutoPtr &table); - - dng_opcode_DeltaPerColumn (dng_host &host, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a scale factor that varies per row. Within a row, -/// the same scale factor is applied to all specified pixels. - -class dng_opcode_ScalePerRow: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fTable; - - public: - - /// Create a ScalePerRow opcode with the specified area and row scale - /// factors (specified as a table of 32-bit floats). - - dng_opcode_ScalePerRow (const dng_area_spec &areaSpec, - AutoPtr &table); - - dng_opcode_ScalePerRow (dng_host &host, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -/// \brief An opcode to apply a scale factor that varies per column. Within a -/// column, the same scale factor is applied to all specified pixels. - -class dng_opcode_ScalePerColumn: public dng_inplace_opcode - { - - private: - - dng_area_spec fAreaSpec; - - AutoPtr fTable; - - public: - - /// Create a ScalePerColumn opcode with the specified area and column - /// scale factors (specified as a table of 32-bit floats). - - dng_opcode_ScalePerColumn (const dng_area_spec &areaSpec, - AutoPtr &table); - - dng_opcode_ScalePerColumn (dng_host &host, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual uint32 BufferPixelType (uint32 imagePixelType); - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_mosaic_info.cpp b/third_party/dng_sdk/dng_mosaic_info.cpp deleted file mode 100644 index a98a59f..0000000 --- a/third_party/dng_sdk/dng_mosaic_info.cpp +++ /dev/null @@ -1,1991 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_mosaic_info.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_mosaic_info.h" - -#include "dng_area_task.h" -#include "dng_assertions.h" -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_filter_task.h" -#include "dng_host.h" -#include "dng_ifd.h" -#include "dng_image.h" -#include "dng_info.h" -#include "dng_negative.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_tile_iterator.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -// A interpolation kernel for a single pixel of a single plane. - -class dng_bilinear_kernel - { - - public: - - enum - { - kMaxCount = 8 - }; - - uint32 fCount; - - dng_point fDelta [kMaxCount]; - - real32 fWeight32 [kMaxCount]; - uint16 fWeight16 [kMaxCount]; - - int32 fOffset [kMaxCount]; - - public: - - dng_bilinear_kernel () - : fCount (0) - { - } - - void Add (const dng_point &delta, - real32 weight); - - void Finalize (const dng_point &scale, - uint32 patRow, - uint32 patCol, - int32 rowStep, - int32 colStep); - - }; - -/*****************************************************************************/ - -void dng_bilinear_kernel::Add (const dng_point &delta, - real32 weight) - { - - // Don't add zero weight elements. - - if (weight <= 0.0f) - { - return; - } - - // If the delta already matches an existing element, just combine the - // weights. - - for (uint32 j = 0; j < fCount; j++) - { - - if (fDelta [j] == delta) - { - - fWeight32 [j] += weight; - - return; - - } - - } - - // Add element to list. - - DNG_ASSERT (fCount < kMaxCount, "Too many kernel entries") - - fDelta [fCount] = delta; - fWeight32 [fCount] = weight; - - fCount++; - - } - -/*****************************************************************************/ - -void dng_bilinear_kernel::Finalize (const dng_point &scale, - uint32 patRow, - uint32 patCol, - int32 rowStep, - int32 colStep) - { - - uint32 j; - - // Adjust deltas to compensate for interpolation upscaling. - - for (j = 0; j < fCount; j++) - { - - dng_point &delta = fDelta [j]; - - if (scale.v == 2) - { - - delta.v = (delta.v + (int32) (patRow & 1)) >> 1; - - } - - if (scale.h == 2) - { - - delta.h = (delta.h + (int32) (patCol & 1)) >> 1; - - } - - } - - // Sort entries into row-column scan order. - - while (true) - { - - bool didSwap = false; - - for (j = 1; j < fCount; j++) - { - - dng_point &delta0 = fDelta [j - 1]; - dng_point &delta1 = fDelta [j ]; - - if (delta0.v > delta1.v || - (delta0.v == delta1.v && - delta0.h > delta1.h)) - { - - didSwap = true; - - dng_point tempDelta = delta0; - - delta0 = delta1; - delta1 = tempDelta; - - real32 tempWeight = fWeight32 [j - 1]; - - fWeight32 [j - 1] = fWeight32 [j]; - fWeight32 [j ] = tempWeight; - - } - - } - - if (!didSwap) - { - break; - } - - } - - // Calculate offsets. - - for (j = 0; j < fCount; j++) - { - - fOffset [j] = rowStep * fDelta [j].v + - colStep * fDelta [j].h; - - } - - // Calculate 16-bit weights. - - uint16 total = 0; - uint32 biggest = 0; - - for (j = 0; j < fCount; j++) - { - - // Round weights to 8 fractional bits. - - fWeight16 [j] = (uint16) Round_uint32 (fWeight32 [j] * 256.0); - - // Keep track of total of weights. - - total += fWeight16 [j]; - - // Keep track of which weight is biggest. - - if (fWeight16 [biggest] < fWeight16 [j]) - { - - biggest = j; - - } - - } - - // Adjust largest entry so total of weights is exactly 256. - - fWeight16 [biggest] += (256 - total); - - // Recompute the floating point weights from the rounded integer weights - // so results match more closely. - - for (j = 0; j < fCount; j++) - { - - fWeight32 [j] = fWeight16 [j] * (1.0f / 256.0f); - - } - - } - -/*****************************************************************************/ - -class dng_bilinear_pattern - { - - public: - - enum - { - kMaxPattern = kMaxCFAPattern * 2 - }; - - dng_point fScale; - - uint32 fPatRows; - uint32 fPatCols; - - dng_bilinear_kernel fKernel [kMaxPattern] - [kMaxPattern]; - - uint32 fCounts [kMaxPattern] - [kMaxPattern]; - - int32 *fOffsets [kMaxPattern] - [kMaxPattern]; - - uint16 *fWeights16 [kMaxPattern] - [kMaxPattern]; - - real32 *fWeights32 [kMaxPattern] - [kMaxPattern]; - - public: - - dng_bilinear_pattern () - - : fScale () - , fPatRows (0) - , fPatCols (0) - - { - } - - private: - - uint32 DeltaRow (uint32 row, int32 delta) - { - return (row + fPatRows + delta) % fPatRows; - } - - uint32 DeltaCol (uint32 col, int32 delta) - { - return (col + fPatCols + delta) % fPatCols; - } - - real32 LinearWeight1 (int32 d1, int32 d2) - { - if (d1 == d2) - return 1.0f; - else - return d2 / (real32) (d2 - d1); - } - - real32 LinearWeight2 (int32 d1, int32 d2) - { - if (d1 == d2) - return 0.0f; - else - return -d1 / (real32) (d2 - d1); - } - - public: - - void Calculate (const dng_mosaic_info &info, - uint32 dstPlane, - int32 rowStep, - int32 colStep); - - }; - -/*****************************************************************************/ - -void dng_bilinear_pattern::Calculate (const dng_mosaic_info &info, - uint32 dstPlane, - int32 rowStep, - int32 colStep) - { - - uint32 j; - uint32 k; - uint32 patRow; - uint32 patCol; - - // Find destination pattern size. - - fScale = info.FullScale (); - - fPatRows = info.fCFAPatternSize.v * fScale.v; - fPatCols = info.fCFAPatternSize.h * fScale.h; - - // See if we need to scale up just while computing the kernels. - - dng_point tempScale (1, 1); - - if (info.fCFALayout >= 6) - { - - tempScale = dng_point (2, 2); - - fPatRows *= tempScale.v; - fPatCols *= tempScale.h; - - } - - // Find a boolean map for this plane color and layout. - - bool map [kMaxPattern] - [kMaxPattern]; - - uint8 planeColor = info.fCFAPlaneColor [dstPlane]; - - switch (info.fCFALayout) - { - - case 1: // Rectangular (or square) layout - { - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - map [j] [k] = (info.fCFAPattern [j] [k] == planeColor); - - } - - } - - break; - - } - - // Note that when the descriptions of the staggered patterns refer to even rows or - // columns, this mean the second, fourth, etc. (i.e. using one-based numbering). - // This needs to be clarified in the DNG specification. - - case 2: // Staggered layout A: even (1-based) columns are offset down by 1/2 row - { - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - if ((j & 1) != (k & 1)) - { - - map [j] [k] = false; - - } - - else - { - - map [j] [k] = (info.fCFAPattern [j >> 1] [k] == planeColor); - - } - - } - - } - - break; - - } - - case 3: // Staggered layout B: even (1-based) columns are offset up by 1/2 row - { - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - if ((j & 1) == (k & 1)) - { - - map [j] [k] = false; - - } - - else - { - - map [j] [k] = (info.fCFAPattern [j >> 1] [k] == planeColor); - - } - - } - - } - - break; - - } - - case 4: // Staggered layout C: even (1-based) rows are offset right by 1/2 column - { - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - if ((j & 1) != (k & 1)) - { - - map [j] [k] = false; - - } - - else - { - - map [j] [k] = (info.fCFAPattern [j] [k >> 1] == planeColor); - - } - - } - - } - - break; - - } - - case 5: // Staggered layout D: even (1-based) rows are offset left by 1/2 column - { - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - if ((j & 1) == (k & 1)) - { - - map [j] [k] = false; - - } - - else - { - - map [j] [k] = (info.fCFAPattern [j] [k >> 1] == planeColor); - - } - - } - - } - - break; - - } - - case 6: // Staggered layout E: even rows are offset up by 1/2 row, even columns are offset left by 1/2 column - case 7: // Staggered layout F: even rows are offset up by 1/2 row, even columns are offset right by 1/2 column - case 8: // Staggered layout G: even rows are offset down by 1/2 row, even columns are offset left by 1/2 column - case 9: // Staggered layout H: even rows are offset down by 1/2 row, even columns are offset right by 1/2 column - { - - uint32 eRow = (info.fCFALayout == 6 || - info.fCFALayout == 7) ? 1 : 3; - - uint32 eCol = (info.fCFALayout == 6 || - info.fCFALayout == 8) ? 1 : 3; - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - uint32 jj = j & 3; - uint32 kk = k & 3; - - if ((jj != 0 && jj != eRow) || - (kk != 0 && kk != eCol)) - { - - map [j] [k] = false; - - } - - else - { - - map [j] [k] = (info.fCFAPattern [((j >> 1) & ~1) + Min_uint32 (jj, 1)] - [((k >> 1) & ~1) + Min_uint32 (kk, 1)] == planeColor); - - } - - } - - } - - break; - - } - - default: - ThrowProgramError (); - - } - - // Find projections of maps. - - bool mapH [kMaxPattern]; - bool mapV [kMaxPattern]; - - for (j = 0; j < kMaxPattern; j++) - { - - mapH [j] = false; - mapV [j] = false; - - } - - for (j = 0; j < fPatRows; j++) - { - - for (k = 0; k < fPatCols; k++) - { - - if (map [j] [k]) - { - - mapV [j] = true; - mapH [k] = true; - - } - - } - - } - - // Find kernel for each patten entry. - - for (patRow = 0; patRow < fPatRows; patRow += tempScale.v) - { - - for (patCol = 0; patCol < fPatCols; patCol += tempScale.h) - { - - dng_bilinear_kernel &kernel = fKernel [patRow] [patCol]; - - // Special case no interpolation case. - - if (map [patRow] [patCol]) - { - - kernel.Add (dng_point (0, 0), 1.0f); - - continue; - - } - - // Special case common patterns in 3 by 3 neighborhood. - - uint32 n = DeltaRow (patRow, -1); - uint32 s = DeltaRow (patRow, 1); - uint32 w = DeltaCol (patCol, -1); - uint32 e = DeltaCol (patCol, 1); - - bool mapNW = map [n] [w]; - bool mapN = map [n] [patCol]; - bool mapNE = map [n] [e]; - - bool mapW = map [patRow] [w]; - bool mapE = map [patRow] [e]; - - bool mapSW = map [s] [w]; - bool mapS = map [s] [patCol]; - bool mapSE = map [s] [e]; - - // All sides. - - if (mapN && mapS && mapW && mapW) - { - - kernel.Add (dng_point (-1, 0), 0.25f); - kernel.Add (dng_point ( 0, -1), 0.25f); - kernel.Add (dng_point ( 0, 1), 0.25f); - kernel.Add (dng_point ( 1, 0), 0.25f); - - continue; - - } - - // N & S. - - if (mapN && mapS) - { - - kernel.Add (dng_point (-1, 0), 0.5f); - kernel.Add (dng_point ( 1, 0), 0.5f); - - continue; - - } - - // E & W. - - if (mapW && mapE) - { - - kernel.Add (dng_point ( 0, -1), 0.5f); - kernel.Add (dng_point ( 0, 1), 0.5f); - - continue; - - } - - // N & SW & SE. - - if (mapN && mapSW && mapSE) - { - - kernel.Add (dng_point (-1, 0), 0.50f); - kernel.Add (dng_point ( 1, -1), 0.25f); - kernel.Add (dng_point ( 1, 1), 0.25f); - - continue; - - } - - // S & NW & NE. - - if (mapS && mapNW && mapNE) - { - - kernel.Add (dng_point (-1, -1), 0.25f); - kernel.Add (dng_point (-1, 1), 0.25f); - kernel.Add (dng_point ( 1, 0), 0.50f); - - continue; - - } - - // W & NE & SE. - - if (mapW && mapNE && mapSE) - { - - kernel.Add (dng_point (-1, 1), 0.25f); - kernel.Add (dng_point ( 0, -1), 0.50f); - kernel.Add (dng_point ( 1, 1), 0.25f); - - continue; - - } - - // E & NW & SW. - - if (mapE && mapNW && mapSW) - { - - kernel.Add (dng_point (-1, -1), 0.25f); - kernel.Add (dng_point ( 0, 1), 0.50f); - kernel.Add (dng_point ( 1, -1), 0.25f); - - continue; - - } - - // Four corners. - - if (mapNW && mapNE && mapSE && mapSW) - { - - kernel.Add (dng_point (-1, -1), 0.25f); - kernel.Add (dng_point (-1, 1), 0.25f); - kernel.Add (dng_point ( 1, -1), 0.25f); - kernel.Add (dng_point ( 1, 1), 0.25f); - - continue; - - } - - // NW & SE - - if (mapNW && mapSE) - { - - kernel.Add (dng_point (-1, -1), 0.50f); - kernel.Add (dng_point ( 1, 1), 0.50f); - - continue; - - } - - // NE & SW - - if (mapNE && mapSW) - { - - kernel.Add (dng_point (-1, 1), 0.50f); - kernel.Add (dng_point ( 1, -1), 0.50f); - - continue; - - } - - // Else use double-bilinear kernel. - - int32 dv1 = 0; - int32 dv2 = 0; - - while (!mapV [DeltaRow (patRow, dv1)]) - { - dv1--; - } - - while (!mapV [DeltaRow (patRow, dv2)]) - { - dv2++; - } - - real32 w1 = LinearWeight1 (dv1, dv2) * 0.5f; - real32 w2 = LinearWeight2 (dv1, dv2) * 0.5f; - - int32 v1 = DeltaRow (patRow, dv1); - int32 v2 = DeltaRow (patRow, dv2); - - int32 dh1 = 0; - int32 dh2 = 0; - - while (!map [v1] [DeltaCol (patCol, dh1)]) - { - dh1--; - } - - while (!map [v1] [DeltaCol (patCol, dh2)]) - { - dh2++; - } - - kernel.Add (dng_point (dv1, dh1), - LinearWeight1 (dh1, dh2) * w1); - - kernel.Add (dng_point (dv1, dh2), - LinearWeight2 (dh1, dh2) * w1); - - dh1 = 0; - dh2 = 0; - - while (!map [v2] [DeltaCol (patCol, dh1)]) - { - dh1--; - } - - while (!map [v2] [DeltaCol (patCol, dh2)]) - { - dh2++; - } - - kernel.Add (dng_point (dv2, dh1), - LinearWeight1 (dh1, dh2) * w2); - - kernel.Add (dng_point (dv2, dh2), - LinearWeight2 (dh1, dh2) * w2); - - dh1 = 0; - dh2 = 0; - - while (!mapH [DeltaCol (patCol, dh1)]) - { - dh1--; - } - - while (!mapH [DeltaCol (patCol, dh2)]) - { - dh2++; - } - - w1 = LinearWeight1 (dh1, dh2) * 0.5f; - w2 = LinearWeight2 (dh1, dh2) * 0.5f; - - int32 h1 = DeltaCol (patCol, dh1); - int32 h2 = DeltaCol (patCol, dh2); - - dv1 = 0; - dv2 = 0; - - while (!map [DeltaRow (patRow, dv1)] [h1]) - { - dv1--; - } - - while (!map [DeltaRow (patRow, dv2)] [h1]) - { - dv2++; - } - - kernel.Add (dng_point (dv1, dh1), - LinearWeight1 (dv1, dv2) * w1); - - kernel.Add (dng_point (dv2, dh1), - LinearWeight2 (dv1, dv2) * w1); - - dv1 = 0; - dv2 = 0; - - while (!map [DeltaRow (patRow, dv1)] [h2]) - { - dv1--; - } - - while (!map [DeltaRow (patRow, dv2)] [h2]) - { - dv2++; - } - - kernel.Add (dng_point (dv1, dh2), - LinearWeight1 (dv1, dv2) * w2); - - kernel.Add (dng_point (dv2, dh2), - LinearWeight2 (dv1, dv2) * w2); - - } - - } - - // Deal with temp scale case. - - if (tempScale == dng_point (2, 2)) - { - - fPatRows /= tempScale.v; - fPatCols /= tempScale.h; - - for (patRow = 0; patRow < fPatRows; patRow++) - { - - for (patCol = 0; patCol < fPatCols; patCol++) - { - - int32 patRow2 = patRow << 1; - int32 patCol2 = patCol << 1; - - dng_bilinear_kernel &kernel = fKernel [patRow2] [patCol2]; - - for (j = 0; j < kernel.fCount; j++) - { - - int32 x = patRow2 + kernel.fDelta [j].v; - - if ((x & 3) != 0) - { - x = (x & ~3) + 2; - } - - kernel.fDelta [j].v = ((x - patRow2) >> 1); - - x = patCol2 + kernel.fDelta [j].h; - - if ((x & 3) != 0) - { - x = (x & ~3) + 2; - } - - kernel.fDelta [j].h = ((x - patCol2) >> 1); - - } - - kernel.Finalize (fScale, - patRow, - patCol, - rowStep, - colStep); - - fCounts [patRow] [patCol] = kernel.fCount; - fOffsets [patRow] [patCol] = kernel.fOffset; - fWeights16 [patRow] [patCol] = kernel.fWeight16; - fWeights32 [patRow] [patCol] = kernel.fWeight32; - - } - - } - - } - - // Non-temp scale case. - - else - { - - for (patRow = 0; patRow < fPatRows; patRow++) - { - - for (patCol = 0; patCol < fPatCols; patCol++) - { - - dng_bilinear_kernel &kernel = fKernel [patRow] [patCol]; - - kernel.Finalize (fScale, - patRow, - patCol, - rowStep, - colStep); - - fCounts [patRow] [patCol] = kernel.fCount; - fOffsets [patRow] [patCol] = kernel.fOffset; - fWeights16 [patRow] [patCol] = kernel.fWeight16; - fWeights32 [patRow] [patCol] = kernel.fWeight32; - - } - - } - - } - - } - -/*****************************************************************************/ - -class dng_bilinear_interpolator - { - - private: - - dng_bilinear_pattern fPattern [kMaxColorPlanes]; - - public: - - dng_bilinear_interpolator (const dng_mosaic_info &info, - int32 rowStep, - int32 colStep); - - void Interpolate (dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer); - - }; - -/*****************************************************************************/ - -dng_bilinear_interpolator::dng_bilinear_interpolator (const dng_mosaic_info &info, - int32 rowStep, - int32 colStep) - { - - for (uint32 dstPlane = 0; dstPlane < info.fColorPlanes; dstPlane++) - { - - fPattern [dstPlane] . Calculate (info, - dstPlane, - rowStep, - colStep); - - } - - } - -/*****************************************************************************/ - -void dng_bilinear_interpolator::Interpolate (dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - uint32 patCols = fPattern [0] . fPatCols; - uint32 patRows = fPattern [0] . fPatRows; - - dng_point scale = fPattern [0] . fScale; - - uint32 sRowShift = scale.v - 1; - uint32 sColShift = scale.h - 1; - - int32 dstCol = dstBuffer.fArea.l; - - int32 srcCol = dstCol >> sColShift; - - uint32 patPhase = dstCol % patCols; - - for (int32 dstRow = dstBuffer.fArea.t; - dstRow < dstBuffer.fArea.b; - dstRow++) - { - - int32 srcRow = dstRow >> sRowShift; - - uint32 patRow = dstRow % patRows; - - for (uint32 dstPlane = 0; - dstPlane < dstBuffer.fPlanes; - dstPlane++) - { - - const void *sPtr = srcBuffer.ConstPixel (srcRow, - srcCol, - srcBuffer.fPlane); - - void *dPtr = dstBuffer.DirtyPixel (dstRow, - dstCol, - dstPlane); - - if (dstBuffer.fPixelType == ttShort) - { - - DoBilinearRow16 ((const uint16 *) sPtr, - (uint16 *) dPtr, - dstBuffer.fArea.W (), - patPhase, - patCols, - fPattern [dstPlane].fCounts [patRow], - fPattern [dstPlane].fOffsets [patRow], - fPattern [dstPlane].fWeights16 [patRow], - sColShift); - - } - - else - { - - DoBilinearRow32 ((const real32 *) sPtr, - (real32 *) dPtr, - dstBuffer.fArea.W (), - patPhase, - patCols, - fPattern [dstPlane].fCounts [patRow], - fPattern [dstPlane].fOffsets [patRow], - fPattern [dstPlane].fWeights32 [patRow], - sColShift); - - } - - } - - } - - } - -/*****************************************************************************/ - -class dng_fast_interpolator: public dng_filter_task - { - - protected: - - const dng_mosaic_info &fInfo; - - dng_point fDownScale; - - uint32 fFilterColor [kMaxCFAPattern] [kMaxCFAPattern]; - - public: - - dng_fast_interpolator (const dng_mosaic_info &info, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane); - - virtual dng_rect SrcArea (const dng_rect &dstArea); - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer); - - }; - -/*****************************************************************************/ - -dng_fast_interpolator::dng_fast_interpolator (const dng_mosaic_info &info, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane) - - : dng_filter_task (srcImage, - dstImage) - - , fInfo (info ) - , fDownScale (downScale) - - { - - fSrcPlane = srcPlane; - fSrcPlanes = 1; - - fSrcPixelType = ttShort; - fDstPixelType = ttShort; - - fSrcRepeat = fInfo.fCFAPatternSize; - - fUnitCell = fInfo.fCFAPatternSize; - - fMaxTileSize = dng_point (256 / fDownScale.v, - 256 / fDownScale.h); - - fMaxTileSize.h = Max_int32 (fMaxTileSize.h, fUnitCell.h); - fMaxTileSize.v = Max_int32 (fMaxTileSize.v, fUnitCell.v); - - // Find color map. - - { - - for (int32 r = 0; r < fInfo.fCFAPatternSize.v; r++) - { - - for (int32 c = 0; c < fInfo.fCFAPatternSize.h; c++) - { - - uint8 key = fInfo.fCFAPattern [r] [c]; - - for (uint32 index = 0; index < fInfo.fColorPlanes; index++) - { - - if (key == fInfo.fCFAPlaneColor [index]) - { - - fFilterColor [r] [c] = index; - - break; - - } - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -dng_rect dng_fast_interpolator::SrcArea (const dng_rect &dstArea) - { - - return dng_rect (dstArea.t * fDownScale.v, - dstArea.l * fDownScale.h, - dstArea.b * fDownScale.v, - dstArea.r * fDownScale.h); - - } - -/*****************************************************************************/ - -void dng_fast_interpolator::ProcessArea (uint32 /* threadIndex */, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - dng_rect srcArea = srcBuffer.fArea; - dng_rect dstArea = dstBuffer.fArea; - - // Downsample buffer. - - int32 srcRow = srcArea.t; - - uint32 srcRowPhase1 = 0; - uint32 srcRowPhase2 = 0; - - uint32 patRows = fInfo.fCFAPatternSize.v; - uint32 patCols = fInfo.fCFAPatternSize.h; - - uint32 cellRows = fDownScale.v; - uint32 cellCols = fDownScale.h; - - uint32 plane; - uint32 planes = fInfo.fColorPlanes; - - int32 dstPlaneStep = dstBuffer.fPlaneStep; - - uint32 total [kMaxColorPlanes]; - uint32 count [kMaxColorPlanes]; - - for (plane = 0; plane < planes; plane++) - { - total [plane] = 0; - count [plane] = 0; - } - - for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) - { - - const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (srcRow, - srcArea.l, - fSrcPlane); - - uint16 *dPtr = dstBuffer.DirtyPixel_uint16 (dstRow, - dstArea.l, - 0); - - uint32 srcColPhase1 = 0; - uint32 srcColPhase2 = 0; - - for (int32 dstCol = dstArea.l; dstCol < dstArea.r; dstCol++) - { - - const uint16 *ssPtr = sPtr; - - srcRowPhase2 = srcRowPhase1; - - for (uint32 cellRow = 0; cellRow < cellRows; cellRow++) - { - - const uint32 *filterRow = fFilterColor [srcRowPhase2]; - - if (++srcRowPhase2 == patRows) - { - srcRowPhase2 = 0; - } - - srcColPhase2 = srcColPhase1; - - for (uint32 cellCol = 0; cellCol < cellCols; cellCol++) - { - - uint32 color = filterRow [srcColPhase2]; - - if (++srcColPhase2 == patCols) - { - srcColPhase2 = 0; - } - - total [color] += (uint32) ssPtr [cellCol]; - count [color] ++; - - } - - ssPtr += srcBuffer.fRowStep; - - } - - for (plane = 0; plane < planes; plane++) - { - - uint32 t = total [plane]; - uint32 c = count [plane]; - - dPtr [plane * dstPlaneStep] = (uint16) ((t + (c >> 1)) / c); - - total [plane] = 0; - count [plane] = 0; - - } - - srcColPhase1 = srcColPhase2; - - sPtr += cellCols; - - dPtr ++; - - } - - srcRowPhase1 = srcRowPhase2; - - srcRow += cellRows; - - } - - } - -/*****************************************************************************/ - -dng_mosaic_info::dng_mosaic_info () - - : fCFAPatternSize () - , fColorPlanes (0) - , fCFALayout (1) - , fBayerGreenSplit (0) - , fSrcSize () - , fCroppedSize () - , fAspectRatio (1.0) - - { - - } - -/*****************************************************************************/ - -dng_mosaic_info::~dng_mosaic_info () - { - - } - -/*****************************************************************************/ - -void dng_mosaic_info::Parse (dng_host & /* host */, - dng_stream & /* stream */, - dng_info &info) - { - - // Find main image IFD. - - dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get (); - - // This information only applies to CFA images. - - if (rawIFD.fPhotometricInterpretation != piCFA) - { - return; - } - - // Copy CFA pattern. - - fCFAPatternSize.v = rawIFD.fCFARepeatPatternRows; - fCFAPatternSize.h = rawIFD.fCFARepeatPatternCols; - - for (int32 j = 0; j < fCFAPatternSize.v; j++) - { - for (int32 k = 0; k < fCFAPatternSize.h; k++) - { - fCFAPattern [j] [k] = rawIFD.fCFAPattern [j] [k]; - } - } - - // Copy CFA plane information. - - fColorPlanes = info.fShared->fCameraProfile.fColorPlanes; - - for (uint32 n = 0; n < fColorPlanes; n++) - { - fCFAPlaneColor [n] = rawIFD.fCFAPlaneColor [n]; - } - - // Copy CFA layout information. - - fCFALayout = rawIFD.fCFALayout; - - // Green split value for Bayer patterns. - - fBayerGreenSplit = rawIFD.fBayerGreenSplit; - - } - -/*****************************************************************************/ - -void dng_mosaic_info::PostParse (dng_host & /* host */, - dng_negative &negative) - { - - // Keep track of source image size. - - fSrcSize = negative.Stage2Image ()->Size (); - - // Default cropped size. - - fCroppedSize.v = Round_int32 (negative.DefaultCropSizeV ().As_real64 ()); - fCroppedSize.h = Round_int32 (negative.DefaultCropSizeH ().As_real64 ()); - - // Pixel aspect ratio. - - fAspectRatio = negative.DefaultScaleH ().As_real64 () / - negative.DefaultScaleV ().As_real64 (); - - } - -/*****************************************************************************/ - -bool dng_mosaic_info::SetFourColorBayer () - { - - if (fCFAPatternSize != dng_point (2, 2)) - { - return false; - } - - if (fColorPlanes != 3) - { - return false; - } - - uint8 color0 = fCFAPlaneColor [0]; - uint8 color1 = fCFAPlaneColor [1]; - uint8 color2 = fCFAPlaneColor [2]; - - // Look for color 1 repeated twice in a diagonal. - - if ((fCFAPattern [0] [0] == color1 && fCFAPattern [1] [1] == color1) || - (fCFAPattern [0] [1] == color1 && fCFAPattern [1] [0] == color1)) - { - - // OK, this looks like a Bayer pattern. - - // Find unused color code. - - uint8 color3 = 0; - - while (color3 == color0 || - color3 == color1 || - color3 == color2) - { - color3++; - } - - // Switch the four color mosaic. - - fColorPlanes = 4; - - fCFAPlaneColor [3] = color3; - - // Replace the "green" in the "blue" rows with the new color. - - if (fCFAPattern [0] [0] == color0) - { - fCFAPattern [1] [0] = color3; - } - - else if (fCFAPattern [0] [1] == color0) - { - fCFAPattern [1] [1] = color3; - } - - else if (fCFAPattern [1] [0] == color0) - { - fCFAPattern [0] [0] = color3; - } - - else - { - fCFAPattern [0] [1] = color3; - } - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -dng_point dng_mosaic_info::FullScale () const - { - - switch (fCFALayout) - { - - // Staggered layouts with offset columns double the row count - // during interpolation. - - case 2: - case 3: - return dng_point (2, 1); - - // Staggered layouts with offset rows double the column count - // during interpolation. - - case 4: - case 5: - return dng_point (1, 2); - - // Otherwise there is no size change during interpolation. - - default: - break; - - } - - return dng_point (1, 1); - - } - -/*****************************************************************************/ - -bool dng_mosaic_info::IsSafeDownScale (const dng_point &downScale) const - { - - if (downScale.v >= fCFAPatternSize.v && - downScale.h >= fCFAPatternSize.h) - { - - return true; - - } - - dng_point test; - - test.v = Min_int32 (downScale.v, fCFAPatternSize.v); - test.h = Min_int32 (downScale.h, fCFAPatternSize.h); - - for (int32 phaseV = 0; phaseV <= fCFAPatternSize.v - test.v; phaseV++) - { - - for (int32 phaseH = 0; phaseH <= fCFAPatternSize.h - test.h; phaseH++) - { - - uint32 plane; - - bool contains [kMaxColorPlanes]; - - for (plane = 0; plane < fColorPlanes; plane++) - { - - contains [plane] = false; - - } - - for (int32 srcRow = 0; srcRow < test.v; srcRow++) - { - - for (int32 srcCol = 0; srcCol < test.h; srcCol++) - { - - uint8 srcKey = fCFAPattern [srcRow + phaseV] - [srcCol + phaseH]; - - for (plane = 0; plane < fColorPlanes; plane++) - { - - if (srcKey == fCFAPlaneColor [plane]) - { - - contains [plane] = true; - - } - - } - - - } - - } - - for (plane = 0; plane < fColorPlanes; plane++) - { - - if (!contains [plane]) - { - - return false; - - } - - } - - } - - } - - return true; - - } - -/*****************************************************************************/ - -uint32 dng_mosaic_info::SizeForDownScale (const dng_point &downScale) const - { - - uint32 sizeV = Max_uint32 (1, (fCroppedSize.v + (downScale.v >> 1)) / downScale.v); - uint32 sizeH = Max_uint32 (1, (fCroppedSize.h + (downScale.h >> 1)) / downScale.h); - - return Max_int32 (sizeV, sizeH); - - } - -/*****************************************************************************/ - -bool dng_mosaic_info::ValidSizeDownScale (const dng_point &downScale, - uint32 minSize) const - { - - const int32 kMaxDownScale = 64; - - if (downScale.h > kMaxDownScale || - downScale.v > kMaxDownScale) - { - - return false; - - } - - return SizeForDownScale (downScale) >= minSize; - - } - -/*****************************************************************************/ - -dng_point dng_mosaic_info::DownScale (uint32 minSize, - uint32 prefSize, - real64 cropFactor) const - { - - dng_point bestScale (1, 1); - - if (prefSize && IsColorFilterArray ()) - { - - // Adjust sizes for crop factor. - - minSize = Round_uint32 (minSize / cropFactor); - prefSize = Round_uint32 (prefSize / cropFactor); - - prefSize = Max_uint32 (prefSize, minSize); - - // Start by assuming we need the full size image. - - int32 bestSize = SizeForDownScale (bestScale); - - // Find size of nearly square cell. - - dng_point squareCell (1, 1); - - if (fAspectRatio < 1.0 / 1.8) - { - - squareCell.h = Min_int32 (4, Round_int32 (1.0 / fAspectRatio)); - - } - - if (fAspectRatio > 1.8) - { - - squareCell.v = Min_int32 (4, Round_int32 (fAspectRatio)); - - } - - // Find minimum safe cell size. - - dng_point testScale = squareCell; - - while (!IsSafeDownScale (testScale)) - { - - testScale.v += squareCell.v; - testScale.h += squareCell.h; - - } - - // See if this scale is usable. - - if (!ValidSizeDownScale (testScale, minSize)) - { - - // We cannot downsample at all... - - return bestScale; - - } - - // See if this is closer to the preferred size. - - int32 testSize = SizeForDownScale (testScale); - - if (Abs_int32 (testSize - (int32) prefSize) <= - Abs_int32 (bestSize - (int32) prefSize)) - { - bestScale = testScale; - bestSize = testSize; - } - - else - { - return bestScale; - } - - // Now keep adding square cells as long as possible. - - while (true) - { - - testScale.v += squareCell.v; - testScale.h += squareCell.h; - - if (IsSafeDownScale (testScale)) - { - - if (!ValidSizeDownScale (testScale, minSize)) - { - return bestScale; - } - - // See if this is closer to the preferred size. - - testSize = SizeForDownScale (testScale); - - if (Abs_int32 (testSize - (int32) prefSize) <= - Abs_int32 (bestSize - (int32) prefSize)) - { - bestScale = testScale; - bestSize = testSize; - } - - else - { - return bestScale; - } - - } - - } - - } - - return bestScale; - - } - -/*****************************************************************************/ - -dng_point dng_mosaic_info::DstSize (const dng_point &downScale) const - { - - if (downScale == dng_point (1, 1)) - { - - dng_point scale = FullScale (); - - return dng_point (fSrcSize.v * scale.v, - fSrcSize.h * scale.h); - - } - - const int32 kMaxDownScale = 64; - - if (downScale.h > kMaxDownScale || - downScale.v > kMaxDownScale) - { - - return dng_point (0, 0); - - } - - dng_point size; - - size.v = Max_int32 (1, (fSrcSize.v + (downScale.v >> 1)) / downScale.v); - size.h = Max_int32 (1, (fSrcSize.h + (downScale.h >> 1)) / downScale.h); - - return size; - - } - -/*****************************************************************************/ - -void dng_mosaic_info::InterpolateGeneric (dng_host &host, - dng_negative & /* negative */, - const dng_image &srcImage, - dng_image &dstImage, - uint32 srcPlane) const - { - - // Find destination to source bit shifts. - - dng_point scale = FullScale (); - - uint32 srcShiftV = scale.v - 1; - uint32 srcShiftH = scale.h - 1; - - // Find tile sizes. - - const uint32 kMaxDstTileRows = 128; - const uint32 kMaxDstTileCols = 128; - - dng_point dstTileSize = dstImage.RepeatingTile ().Size (); - - dstTileSize.v = Min_int32 (dstTileSize.v, kMaxDstTileRows); - dstTileSize.h = Min_int32 (dstTileSize.h, kMaxDstTileCols); - - dng_point srcTileSize = dstTileSize; - - srcTileSize.v >>= srcShiftV; - srcTileSize.h >>= srcShiftH; - - srcTileSize.v += fCFAPatternSize.v * 2; - srcTileSize.h += fCFAPatternSize.h * 2; - - // Allocate source buffer. - - dng_pixel_buffer srcBuffer; - - srcBuffer.fPlane = srcPlane; - - srcBuffer.fRowStep = srcTileSize.h; - - srcBuffer.fPixelType = srcImage.PixelType (); - srcBuffer.fPixelSize = srcImage.PixelSize (); - - uint32 srcBufferSize = srcBuffer.fPixelSize * - srcBuffer.fRowStep * - srcTileSize.v; - - AutoPtr srcData (host.Allocate (srcBufferSize)); - - srcBuffer.fData = srcData->Buffer (); - - // Allocate destination buffer. - - dng_pixel_buffer dstBuffer; - - dstBuffer.fPlanes = fColorPlanes; - - dstBuffer.fRowStep = dstTileSize.h * fColorPlanes; - dstBuffer.fPlaneStep = dstTileSize.h; - - dstBuffer.fPixelType = dstImage.PixelType (); - dstBuffer.fPixelSize = dstImage.PixelSize (); - - uint32 dstBufferSize = dstBuffer.fPixelSize * - dstBuffer.fRowStep * - dstTileSize.v; - - AutoPtr dstData (host.Allocate (dstBufferSize)); - - dstBuffer.fData = dstData->Buffer (); - - // Create interpolator. - - AutoPtr interpolator (new dng_bilinear_interpolator (*this, - srcBuffer.fRowStep, - srcBuffer.fColStep)); - - // Iterate over destination tiles. - - dng_rect dstArea; - - dng_tile_iterator iter1 (dstImage, dstImage.Bounds ()); - - while (iter1.GetOneTile (dstArea)) - { - - // Break into buffer sized tiles. - - dng_rect dstTile; - - dng_tile_iterator iter2 (dstTileSize, dstArea); - - while (iter2.GetOneTile (dstTile)) - { - - host.SniffForAbort (); - - // Setup buffers for this tile. - - dng_rect srcTile (dstTile); - - srcTile.t >>= srcShiftV; - srcTile.b >>= srcShiftV; - - srcTile.l >>= srcShiftH; - srcTile.r >>= srcShiftH; - - srcTile.t -= fCFAPatternSize.v; - srcTile.b += fCFAPatternSize.v; - - srcTile.l -= fCFAPatternSize.h; - srcTile.r += fCFAPatternSize.h; - - srcBuffer.fArea = srcTile; - dstBuffer.fArea = dstTile; - - // Get source data. - - srcImage.Get (srcBuffer, - dng_image::edge_repeat, - fCFAPatternSize.v, - fCFAPatternSize.h); - - // Process data. - - interpolator->Interpolate (srcBuffer, - dstBuffer); - - // Save results. - - dstImage.Put (dstBuffer); - - } - - } - - } - -/*****************************************************************************/ - -void dng_mosaic_info::InterpolateFast (dng_host &host, - dng_negative & /* negative */, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane) const - { - - // Create fast interpolator task. - - dng_fast_interpolator interpolator (*this, - srcImage, - dstImage, - downScale, - srcPlane); - - // Find area to process. - - dng_rect bounds = dstImage.Bounds (); - - // Do the interpolation. - - host.PerformAreaTask (interpolator, - bounds); - - } - -/*****************************************************************************/ - -void dng_mosaic_info::Interpolate (dng_host &host, - dng_negative &negative, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane) const - { - - if (downScale == dng_point (1, 1)) - { - - InterpolateGeneric (host, - negative, - srcImage, - dstImage, - srcPlane); - - } - - else - { - - InterpolateFast (host, - negative, - srcImage, - dstImage, - downScale, - srcPlane); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_mosaic_info.h b/third_party/dng_sdk/dng_mosaic_info.h deleted file mode 100644 index 477c105..0000000 --- a/third_party/dng_sdk/dng_mosaic_info.h +++ /dev/null @@ -1,200 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_mosaic_info.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for descriptive information about color filter array patterns. - */ - -/*****************************************************************************/ - -#ifndef __dng_mosaic_info__ -#define __dng_mosaic_info__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_rect.h" -#include "dng_sdk_limits.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief Support for describing color filter array patterns and manipulating mosaic sample data. -/// -/// See CFAPattern tag in \ref spec_tiff_ep "TIFF/EP specification" and CFAPlaneColor, CFALayout, and BayerGreenSplit -/// tags in the \ref spec_dng "DNG 1.1.0 specification". - -class dng_mosaic_info - { - - public: - - /// Size of fCFAPattern. - - dng_point fCFAPatternSize; - - /// CFA pattern from CFAPattern tag in the \ref spec_tiff_ep "TIFF/EP specification." - - uint8 fCFAPattern [kMaxCFAPattern] [kMaxCFAPattern]; - - /// Number of color planes in DNG input. - - uint32 fColorPlanes; - - uint8 fCFAPlaneColor [kMaxColorPlanes]; - - /// Value of CFALayout tag in the \ref spec_dng "DNG 1.3 specification." - /// CFALayout describes the spatial layout of the CFA. The currently defined values are: - /// - 1 = Rectangular (or square) layout. - /// - 2 = Staggered layout A: even columns are offset down by 1/2 row. - /// - 3 = Staggered layout B: even columns are offset up by 1/2 row. - /// - 4 = Staggered layout C: even rows are offset right by 1/2 column. - /// - 5 = Staggered layout D: even rows are offset left by 1/2 column. - /// - 6 = Staggered layout E: even rows are offset up by 1/2 row, even columns are offset left by 1/2 column. - /// - 7 = Staggered layout F: even rows are offset up by 1/2 row, even columns are offset right by 1/2 column. - /// - 8 = Staggered layout G: even rows are offset down by 1/2 row, even columns are offset left by 1/2 column. - /// - 9 = Staggered layout H: even rows are offset down by 1/2 row, even columns are offset right by 1/2 column. - - uint32 fCFALayout; - - /// Value of BayerGreeSplit tag in DNG file. - /// BayerGreenSplit only applies to CFA images using a Bayer pattern filter array. This tag - /// specifies, in arbitrary units, how closely the values of the green pixels in the blue/green rows - /// track the values of the green pixels in the red/green rows. - /// - /// A value of zero means the two kinds of green pixels track closely, while a non-zero value - /// means they sometimes diverge. The useful range for this tag is from 0 (no divergence) to about - /// 5000 (large divergence). - - uint32 fBayerGreenSplit; - - protected: - - dng_point fSrcSize; - - dng_point fCroppedSize; - - real64 fAspectRatio; - - public: - - dng_mosaic_info (); - - virtual ~dng_mosaic_info (); - - virtual void Parse (dng_host &host, - dng_stream &stream, - dng_info &info); - - virtual void PostParse (dng_host &host, - dng_negative &negative); - - /// Returns whether the RAW data in this DNG file from a color filter array (mosaiced) source. - /// \retval true if this DNG file is from a color filter array (mosiaced) source. - - bool IsColorFilterArray () const - { - return fCFAPatternSize != dng_point (0, 0); - } - - /// Enable generating four-plane output from three-plane Bayer input. - /// Extra plane is a second version of the green channel. First green is produced - /// using green mosaic samples from one set of rows/columns (even/odd) and the second - /// green channel is produced using the other set of rows/columns. One can compare the - /// two versions to judge whether BayerGreenSplit needs to be set for a given input source. - - virtual bool SetFourColorBayer (); - - /// Returns scaling factor relative to input size needed to capture output data. - /// Staggered (or rotated) sensing arrays are produced to a larger output than the number of input samples. - /// This method indicates how much larger. - /// \retval a point with integer scaling factors for the horizotal and vertical dimensions. - - virtual dng_point FullScale () const; - - /// Returns integer factors by which mosaic data must be downsampled to produce an image which is as close - /// to prefSize as possible in longer dimension, but no smaller than minSize. - /// \param minSize Number of pixels as minium for longer dimension of downsampled image. - /// \param prefSize Number of pixels as target for longer dimension of downsampled image. - /// \param cropFactor Faction of the image to be used after cropping. - /// \retval Point containing integer factors by which image must be downsampled. - - virtual dng_point DownScale (uint32 minSize, - uint32 prefSize, - real64 cropFactor) const; - - /// Return size of demosaiced image for passed in downscaling factor. - /// \param downScale Integer downsampling factor obtained from DownScale method. - /// \retval Size of resulting demosaiced image. - - virtual dng_point DstSize (const dng_point &downScale) const; - - /// Demosaic interpolation of a single plane for non-downsampled case. - /// \param host dng_host to use for buffer allocation requests, user cancellation testing, and progress updates. - /// \param negative DNG negative of mosaiced data. - /// \param srcImage Source image for mosaiced data. - /// \param dstImage Destination image for resulting interpolated data. - /// \param srcPlane Which plane to interpolate. - - virtual void InterpolateGeneric (dng_host &host, - dng_negative &negative, - const dng_image &srcImage, - dng_image &dstImage, - uint32 srcPlane = 0) const; - - /// Demosaic interpolation of a single plane for downsampled case. - /// \param host dng_host to use for buffer allocation requests, user cancellation testing, and progress updates. - /// \param negative DNG negative of mosaiced data. - /// \param srcImage Source image for mosaiced data. - /// \param dstImage Destination image for resulting interpolated data. - /// \param downScale Amount (in horizontal and vertical) by which to subsample image. - /// \param srcPlane Which plane to interpolate. - - virtual void InterpolateFast (dng_host &host, - dng_negative &negative, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane = 0) const; - - /// Demosaic interpolation of a single plane. Chooses between generic and fast interpolators based on parameters. - /// \param host dng_host to use for buffer allocation requests, user cancellation testing, and progress updates. - /// \param negative DNG negative of mosaiced data. - /// \param srcImage Source image for mosaiced data. - /// \param dstImage Destination image for resulting interpolated data. - /// \param downScale Amount (in horizontal and vertical) by which to subsample image. - /// \param srcPlane Which plane to interpolate. - - virtual void Interpolate (dng_host &host, - dng_negative &negative, - const dng_image &srcImage, - dng_image &dstImage, - const dng_point &downScale, - uint32 srcPlane = 0) const; - - protected: - - virtual bool IsSafeDownScale (const dng_point &downScale) const; - - uint32 SizeForDownScale (const dng_point &downScale) const; - - virtual bool ValidSizeDownScale (const dng_point &downScale, - uint32 minSize) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_mutex.cpp b/third_party/dng_sdk/dng_mutex.cpp deleted file mode 100644 index 7451c7c..0000000 --- a/third_party/dng_sdk/dng_mutex.cpp +++ /dev/null @@ -1,394 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_mutex.cpp#3 $ */ -/* $DateTime: 2012/09/05 12:31:51 $ */ -/* $Change: 847652 $ */ -/* $Author: tknoll $ */ - -#include "dng_mutex.h" - -#include "dng_assertions.h" -#include "dng_exceptions.h" - -#include - -/*****************************************************************************/ - -#if qDNGThreadSafe - -namespace - { - - class InnermostMutexHolder - { - - private: - - pthread_key_t fInnermostMutexKey; - - public: - - InnermostMutexHolder () - - : fInnermostMutexKey () - - { - - int result = pthread_key_create (&fInnermostMutexKey, NULL); - - DNG_ASSERT (result == 0, "pthread_key_create failed."); - - if (result != 0) - ThrowProgramError (); - - } - - ~InnermostMutexHolder () - { - - pthread_key_delete (fInnermostMutexKey); - - } - - void SetInnermostMutex (dng_mutex *mutex) - { - - int result; - - result = pthread_setspecific (fInnermostMutexKey, (void *)mutex); - - DNG_ASSERT (result == 0, "pthread_setspecific failed."); - - #if 0 // Hard failure here was causing crash on quit. - - if (result != 0) - ThrowProgramError (); - - #endif - - } - - dng_mutex *GetInnermostMutex () - { - - void *result = pthread_getspecific (fInnermostMutexKey); - - return reinterpret_cast (result); - - } - - }; - - InnermostMutexHolder gInnermostMutexHolder; - - } - -#endif - -/*****************************************************************************/ - -dng_mutex::dng_mutex (const char *mutexName, uint32 mutexLevel) - - #if qDNGThreadSafe - - : fPthreadMutex () - , fMutexLevel (mutexLevel) - , fRecursiveLockCount (0) - , fPrevHeldMutex (NULL) - , fMutexName (mutexName) - - #endif - - { - - #if qDNGThreadSafe - - if (pthread_mutex_init (&fPthreadMutex, NULL) != 0) - { - ThrowMemoryFull (); - } - - #endif - - } - -/*****************************************************************************/ - -dng_mutex::~dng_mutex () - { - - #if qDNGThreadSafe - - pthread_mutex_destroy (&fPthreadMutex); - - #endif - - } - -/*****************************************************************************/ - -void dng_mutex::Lock () - { - - #if qDNGThreadSafe - - dng_mutex *innermostMutex = gInnermostMutexHolder.GetInnermostMutex (); - - if (innermostMutex != NULL) - { - - if (innermostMutex == this) - { - - fRecursiveLockCount++; - - return; - - } - - bool lockOrderPreserved = fMutexLevel > innermostMutex->fMutexLevel /* || - (fMutexLevel == innermostMutex->fMutexLevel && innermostMutex < this) */; - - if (!lockOrderPreserved) - { - - DNG_REPORT ("Lock ordering violation."); - - #if qDNGDebug - - dng_show_message_f ("This mutex: %s v Innermost mutex: %s", - this->MutexName (), - innermostMutex->MutexName ()); - - #endif - - } - - } - - pthread_mutex_lock (&fPthreadMutex); - - fPrevHeldMutex = innermostMutex; - - gInnermostMutexHolder.SetInnermostMutex (this); - - #endif - - } - -/*****************************************************************************/ - -void dng_mutex::Unlock () - { - - #if qDNGThreadSafe - - DNG_ASSERT (gInnermostMutexHolder.GetInnermostMutex () == this, "Mutexes unlocked out of order!!!"); - - if (fRecursiveLockCount > 0) - { - - fRecursiveLockCount--; - - return; - - } - - gInnermostMutexHolder.SetInnermostMutex (fPrevHeldMutex); - - fPrevHeldMutex = NULL; - - pthread_mutex_unlock (&fPthreadMutex); - - #endif - - } - -/*****************************************************************************/ - -const char *dng_mutex::MutexName () const - { - - #if qDNGThreadSafe - - if (fMutexName) - return fMutexName; - - #endif - - return "< unknown >"; - - } - -/*****************************************************************************/ - -dng_lock_mutex::dng_lock_mutex (dng_mutex *mutex) - - : fMutex (mutex) - - { - - if (fMutex) - fMutex->Lock (); - - } - -/*****************************************************************************/ - -dng_lock_mutex::~dng_lock_mutex () - { - - if (fMutex) - fMutex->Unlock (); - - } - -/*****************************************************************************/ - -dng_unlock_mutex::dng_unlock_mutex (dng_mutex *mutex) - - : fMutex (mutex) - - { - - if (fMutex) - fMutex->Unlock (); - - } - -/*****************************************************************************/ - -dng_unlock_mutex::~dng_unlock_mutex () - { - - if (fMutex) - fMutex->Lock (); - - } - -/*****************************************************************************/ - -#if qDNGThreadSafe - -/*****************************************************************************/ - -dng_condition::dng_condition () - - : fPthreadCondition () - - { - - int result; - - result = pthread_cond_init (&fPthreadCondition, NULL); - - DNG_ASSERT (result == 0, "pthread_cond_init failed."); - - if (result != 0) - { - ThrowProgramError (); - } - - } - -/*****************************************************************************/ - -dng_condition::~dng_condition () - { - - pthread_cond_destroy (&fPthreadCondition); - - } - -/*****************************************************************************/ - -bool dng_condition::Wait (dng_mutex &mutex, double timeoutSecs) - { - - bool timedOut = false; - - dng_mutex *innermostMutex = gInnermostMutexHolder.GetInnermostMutex (); - - DNG_ASSERT (innermostMutex == &mutex, "Attempt to wait on non-innermost mutex."); - - innermostMutex = mutex.fPrevHeldMutex; - - gInnermostMutexHolder.SetInnermostMutex (innermostMutex); - - mutex.fPrevHeldMutex = NULL; - - if (timeoutSecs < 0) - { - - pthread_cond_wait (&fPthreadCondition, &mutex.fPthreadMutex); - - } - - else - { - - struct timespec now; - - dng_pthread_now (&now); - - timeoutSecs += now.tv_sec; - timeoutSecs += now.tv_nsec / 1000000000.0; - - now.tv_sec = (long) timeoutSecs; - now.tv_nsec = (long) ((timeoutSecs - now.tv_sec) * 1000000000); - - timedOut = (pthread_cond_timedwait (&fPthreadCondition, &mutex.fPthreadMutex, &now) == ETIMEDOUT); - - } - - mutex.fPrevHeldMutex = innermostMutex; - - gInnermostMutexHolder.SetInnermostMutex (&mutex); - - return !timedOut; - - } - -/*****************************************************************************/ - -void dng_condition::Signal () - { - - int result; - - result = pthread_cond_signal (&fPthreadCondition); - - DNG_ASSERT (result == 0, "pthread_cond_signal failed."); - - if (result != 0) - ThrowProgramError (); - - } - -/*****************************************************************************/ - -void dng_condition::Broadcast () - { - - int result; - - result = pthread_cond_broadcast (&fPthreadCondition); - - DNG_ASSERT (result == 0, "pthread_cond_broadcast failed."); - - if (result != 0) - ThrowProgramError (); - - } - -/*****************************************************************************/ - -#endif // qDNGThreadSafe - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_mutex.h b/third_party/dng_sdk/dng_mutex.h deleted file mode 100644 index b067728..0000000 --- a/third_party/dng_sdk/dng_mutex.h +++ /dev/null @@ -1,177 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_mutex.h#2 $ */ -/* $DateTime: 2012/09/05 12:31:51 $ */ -/* $Change: 847652 $ */ -/* $Author: tknoll $ */ - -/******************************************************************************/ - -#ifndef __dng_mutex__ -#define __dng_mutex__ - -/******************************************************************************/ - -#include "dng_flags.h" - -/******************************************************************************/ - -#include "dng_types.h" - -#if qDNGThreadSafe - -#include "dng_pthread.h" - -#endif - -/******************************************************************************/ - -class dng_mutex - { - - public: - - enum - { - kDNGMutexLevelLeaf = 0x70000000u - }; - - dng_mutex (const char *mutexName, - uint32 mutexLevel = kDNGMutexLevelLeaf); - - virtual ~dng_mutex (); - - void Lock (); - - void Unlock (); - - const char *MutexName () const; - - protected: - - #if qDNGThreadSafe - - pthread_mutex_t fPthreadMutex; - - const uint32 fMutexLevel; - - uint32 fRecursiveLockCount; - - dng_mutex *fPrevHeldMutex; - - const char * const fMutexName; - - friend class dng_condition; - - #endif - - private: - - // Hidden copy constructor and assignment operator. - - dng_mutex (const dng_mutex &mutex); - - dng_mutex & operator= (const dng_mutex &mutex); - - }; - -/*****************************************************************************/ - -class dng_lock_mutex - { - - private: - - dng_mutex *fMutex; - - public: - - dng_lock_mutex (dng_mutex *mutex); - - ~dng_lock_mutex (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_lock_mutex (const dng_lock_mutex &lock); - - dng_lock_mutex & operator= (const dng_lock_mutex &lock); - - }; - -/*****************************************************************************/ - -class dng_unlock_mutex - { - - private: - - dng_mutex *fMutex; - - public: - - dng_unlock_mutex (dng_mutex *mutex); - - ~dng_unlock_mutex (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_unlock_mutex (const dng_unlock_mutex &unlock); - - dng_unlock_mutex & operator= (const dng_unlock_mutex &unlock); - - }; - -/*****************************************************************************/ - -#if qDNGThreadSafe - -/*****************************************************************************/ - -class dng_condition - { - - public: - - dng_condition (); - - ~dng_condition (); - - bool Wait (dng_mutex &mutex, double timeoutSecs = -1.0); - - void Signal (); - - void Broadcast (); - - protected: - - pthread_cond_t fPthreadCondition; - - private: - - // Hidden copy constructor and assignment operator. - - dng_condition (const dng_condition &condition); - - dng_condition & operator= (const dng_condition &condition); - - }; - -/*****************************************************************************/ - -#endif // qDNGThreadSafe - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_negative.cpp b/third_party/dng_sdk/dng_negative.cpp deleted file mode 100644 index 5c9d6cf..0000000 --- a/third_party/dng_sdk/dng_negative.cpp +++ /dev/null @@ -1,5076 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_negative.cpp#3 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_negative.h" - -#include "dng_1d_table.h" -#include "dng_abort_sniffer.h" -#include "dng_area_task.h" -#include "dng_assertions.h" -#include "dng_bottlenecks.h" -#include "dng_camera_profile.h" -#include "dng_color_space.h" -#include "dng_color_spec.h" -#include "dng_exceptions.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_image_writer.h" -#include "dng_info.h" -#include "dng_jpeg_image.h" -#include "dng_linearization_info.h" -#include "dng_memory_stream.h" -#include "dng_misc_opcodes.h" -#include "dng_mosaic_info.h" -#include "dng_preview.h" -#include "dng_resample.h" -#include "dng_simple_image.h" -#include "dng_tag_codes.h" -#include "dng_tag_values.h" -#include "dng_tile_iterator.h" -#include "dng_utils.h" -#include "dng_xmp.h" - -/*****************************************************************************/ - -dng_noise_profile::dng_noise_profile () - - : fNoiseFunctions () - - { - - } - -/*****************************************************************************/ - -dng_noise_profile::dng_noise_profile (const std::vector &functions) - - : fNoiseFunctions (functions) - - { - - } - -/*****************************************************************************/ - -bool dng_noise_profile::IsValid () const - { - - if (NumFunctions () == 0 || NumFunctions () > kMaxColorPlanes) - { - return false; - } - - for (uint32 plane = 0; plane < NumFunctions (); plane++) - { - - if (!NoiseFunction (plane).IsValid ()) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_noise_profile::IsValidForNegative (const dng_negative &negative) const - { - - if (!(NumFunctions () == 1 || NumFunctions () == negative.ColorChannels ())) - { - return false; - } - - return IsValid (); - - } - -/*****************************************************************************/ - -const dng_noise_function & dng_noise_profile::NoiseFunction (uint32 plane) const - { - - if (NumFunctions () == 1) - { - return fNoiseFunctions.front (); - } - - DNG_REQUIRE (plane < NumFunctions (), - "Bad plane index argument for NoiseFunction ()."); - - return fNoiseFunctions [plane]; - - } - -/*****************************************************************************/ - -uint32 dng_noise_profile::NumFunctions () const - { - return (uint32) fNoiseFunctions.size (); - } - -/*****************************************************************************/ - -dng_metadata::dng_metadata (dng_host &host) - - : fHasBaseOrientation (false) - , fBaseOrientation () - , fIsMakerNoteSafe (false) - , fMakerNote () - , fExif (host.Make_dng_exif ()) - , fOriginalExif () - , fIPTCBlock () - , fIPTCOffset (kDNGStreamInvalidOffset) - , fXMP (host.Make_dng_xmp ()) - , fEmbeddedXMPDigest () - , fXMPinSidecar (false) - , fXMPisNewer (false) - , fSourceMIMI () - - { - } - -/*****************************************************************************/ - -dng_metadata::~dng_metadata () - { - } - -/******************************************************************************/ - -template< class T > -T * CloneAutoPtr (const AutoPtr< T > &ptr) - { - - return ptr.Get () ? ptr->Clone () : NULL; - - } - -/******************************************************************************/ - -template< class T, typename U > -T * CloneAutoPtr (const AutoPtr< T > &ptr, U &u) - { - - return ptr.Get () ? ptr->Clone (u) : NULL; - - } - -/******************************************************************************/ - -dng_metadata::dng_metadata (const dng_metadata &rhs, - dng_memory_allocator &allocator) - - : fHasBaseOrientation (rhs.fHasBaseOrientation) - , fBaseOrientation (rhs.fBaseOrientation) - , fIsMakerNoteSafe (rhs.fIsMakerNoteSafe) - , fMakerNote (CloneAutoPtr (rhs.fMakerNote, allocator)) - , fExif (CloneAutoPtr (rhs.fExif)) - , fOriginalExif (CloneAutoPtr (rhs.fOriginalExif)) - , fIPTCBlock (CloneAutoPtr (rhs.fIPTCBlock, allocator)) - , fIPTCOffset (rhs.fIPTCOffset) - , fXMP (CloneAutoPtr (rhs.fXMP)) - , fEmbeddedXMPDigest (rhs.fEmbeddedXMPDigest) - , fXMPinSidecar (rhs.fXMPinSidecar) - , fXMPisNewer (rhs.fXMPisNewer) - , fSourceMIMI (rhs.fSourceMIMI) - - { - - } - -/******************************************************************************/ - -dng_metadata * dng_metadata::Clone (dng_memory_allocator &allocator) const - { - - return new dng_metadata (*this, allocator); - - } - -/******************************************************************************/ - -void dng_metadata::SetBaseOrientation (const dng_orientation &orientation) - { - - fHasBaseOrientation = true; - - fBaseOrientation = orientation; - - } - -/******************************************************************************/ - -void dng_metadata::ApplyOrientation (const dng_orientation &orientation) - { - - fBaseOrientation += orientation; - - fXMP->SetOrientation (fBaseOrientation); - - } - -/*****************************************************************************/ - -void dng_metadata::ResetExif (dng_exif * newExif) - { - - fExif.Reset (newExif); - - } - -/******************************************************************************/ - -dng_memory_block * dng_metadata::BuildExifBlock (dng_memory_allocator &allocator, - const dng_resolution *resolution, - bool includeIPTC, - const dng_jpeg_preview *thumbnail) const - { - - dng_memory_stream stream (allocator); - - { - - // Create the main IFD - - dng_tiff_directory mainIFD; - - // Optionally include the resolution tags. - - dng_resolution res; - - if (resolution) - { - res = *resolution; - } - - tag_urational tagXResolution (tcXResolution, res.fXResolution); - tag_urational tagYResolution (tcYResolution, res.fYResolution); - - tag_uint16 tagResolutionUnit (tcResolutionUnit, res.fResolutionUnit); - - if (resolution) - { - mainIFD.Add (&tagXResolution ); - mainIFD.Add (&tagYResolution ); - mainIFD.Add (&tagResolutionUnit); - } - - // Optionally include IPTC block. - - tag_iptc tagIPTC (IPTCData (), - IPTCLength ()); - - if (includeIPTC && tagIPTC.Count ()) - { - mainIFD.Add (&tagIPTC); - } - - // Exif tags. - - exif_tag_set exifSet (mainIFD, - *GetExif (), - IsMakerNoteSafe (), - MakerNoteData (), - MakerNoteLength (), - false); - - // Figure out the Exif IFD offset. - - uint32 exifOffset = 8 + mainIFD.Size (); - - exifSet.Locate (exifOffset); - - // Thumbnail IFD (if any). - - dng_tiff_directory thumbIFD; - - tag_uint16 thumbCompression (tcCompression, ccOldJPEG); - - tag_urational thumbXResolution (tcXResolution, dng_urational (72, 1)); - tag_urational thumbYResolution (tcYResolution, dng_urational (72, 1)); - - tag_uint16 thumbResolutionUnit (tcResolutionUnit, ruInch); - - tag_uint32 thumbDataOffset (tcJPEGInterchangeFormat , 0); - tag_uint32 thumbDataLength (tcJPEGInterchangeFormatLength, 0); - - if (thumbnail) - { - - thumbIFD.Add (&thumbCompression); - - thumbIFD.Add (&thumbXResolution); - thumbIFD.Add (&thumbYResolution); - thumbIFD.Add (&thumbResolutionUnit); - - thumbIFD.Add (&thumbDataOffset); - thumbIFD.Add (&thumbDataLength); - - thumbDataLength.Set (thumbnail->fCompressedData->LogicalSize ()); - - uint32 thumbOffset = exifOffset + exifSet.Size (); - - mainIFD.SetChained (thumbOffset); - - thumbDataOffset.Set (thumbOffset + thumbIFD.Size ()); - - } - - // Don't write anything unless the main IFD has some tags. - - if (mainIFD.Size () != 0) - { - - // Write TIFF Header. - - stream.SetWritePosition (0); - - stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII); - - stream.Put_uint16 (42); - - stream.Put_uint32 (8); - - // Write the IFDs. - - mainIFD.Put (stream); - - exifSet.Put (stream); - - if (thumbnail) - { - - thumbIFD.Put (stream); - - stream.Put (thumbnail->fCompressedData->Buffer (), - thumbnail->fCompressedData->LogicalSize ()); - - } - - // Trim the file to this length. - - stream.Flush (); - - stream.SetLength (stream.Position ()); - - } - - } - - return stream.AsMemoryBlock (allocator); - - } - -/******************************************************************************/ - -void dng_metadata::SetIPTC (AutoPtr &block, uint64 offset) - { - - fIPTCBlock.Reset (block.Release ()); - - fIPTCOffset = offset; - - } - -/******************************************************************************/ - -void dng_metadata::SetIPTC (AutoPtr &block) - { - - SetIPTC (block, kDNGStreamInvalidOffset); - - } - -/******************************************************************************/ - -void dng_metadata::ClearIPTC () - { - - fIPTCBlock.Reset (); - - fIPTCOffset = kDNGStreamInvalidOffset; - - } - -/*****************************************************************************/ - -const void * dng_metadata::IPTCData () const - { - - if (fIPTCBlock.Get ()) - { - - return fIPTCBlock->Buffer (); - - } - - return NULL; - - } - -/*****************************************************************************/ - -uint32 dng_metadata::IPTCLength () const - { - - if (fIPTCBlock.Get ()) - { - - return fIPTCBlock->LogicalSize (); - - } - - return 0; - - } - -/*****************************************************************************/ - -uint64 dng_metadata::IPTCOffset () const - { - - if (fIPTCBlock.Get ()) - { - - return fIPTCOffset; - - } - - return kDNGStreamInvalidOffset; - - } - -/*****************************************************************************/ - -dng_fingerprint dng_metadata::IPTCDigest (bool includePadding) const - { - - if (IPTCLength ()) - { - - dng_md5_printer printer; - - const uint8 *data = (const uint8 *) IPTCData (); - - uint32 count = IPTCLength (); - - // Because of some stupid ways of storing the IPTC data, the IPTC - // data might be padded with up to three zeros. The official Adobe - // logic is to include these zeros in the digest. However, older - // versions of the Camera Raw code did not include the padding zeros - // in the digest, so we support both methods and allow either to - // match. - - if (!includePadding) - { - - uint32 removed = 0; - - while ((removed < 3) && (count > 0) && (data [count - 1] == 0)) - { - removed++; - count--; - } - - } - - printer.Process (data, count); - - return printer.Result (); - - } - - return dng_fingerprint (); - - } - -/******************************************************************************/ - -void dng_metadata::RebuildIPTC (dng_memory_allocator &allocator, - bool padForTIFF) - { - - ClearIPTC (); - - fXMP->RebuildIPTC (*this, allocator, padForTIFF); - - dng_fingerprint digest = IPTCDigest (); - - fXMP->SetIPTCDigest (digest); - - } - -/*****************************************************************************/ - -void dng_metadata::ResetXMP (dng_xmp * newXMP) - { - - fXMP.Reset (newXMP); - - } - -/*****************************************************************************/ - -void dng_metadata::ResetXMPSidecarNewer (dng_xmp * newXMP, - bool inSidecar, - bool isNewer ) - { - - fXMP.Reset (newXMP); - - fXMPinSidecar = inSidecar; - - fXMPisNewer = isNewer; - - } - -/*****************************************************************************/ - -bool dng_metadata::SetXMP (dng_host &host, - const void *buffer, - uint32 count, - bool xmpInSidecar, - bool xmpIsNewer) - { - - bool result = false; - - try - { - - AutoPtr tempXMP (host.Make_dng_xmp ()); - - tempXMP->Parse (host, buffer, count); - - ResetXMPSidecarNewer (tempXMP.Release (), xmpInSidecar, xmpIsNewer); - - result = true; - - } - - catch (dng_exception &except) - { - - // Don't ignore transient errors. - - if (host.IsTransientError (except.ErrorCode ())) - { - - throw; - - } - - // Eat other parsing errors. - - } - - catch (...) - { - - // Eat unknown parsing exceptions. - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_metadata::SetEmbeddedXMP (dng_host &host, - const void *buffer, - uint32 count) - { - - if (SetXMP (host, buffer, count)) - { - - dng_md5_printer printer; - - printer.Process (buffer, count); - - fEmbeddedXMPDigest = printer.Result (); - - // Remove any sidecar specific tags from embedded XMP. - - if (fXMP.Get ()) - { - - fXMP->Remove (XMP_NS_PHOTOSHOP, "SidecarForExtension"); - fXMP->Remove (XMP_NS_PHOTOSHOP, "EmbeddedXMPDigest"); - - } - - } - - else - { - - fEmbeddedXMPDigest.Clear (); - - } - - } - -/*****************************************************************************/ - -void dng_metadata::SynchronizeMetadata () - { - - if (!fOriginalExif.Get ()) - { - - fOriginalExif.Reset (fExif->Clone ()); - - } - - fXMP->ValidateMetadata (); - - fXMP->IngestIPTC (*this, fXMPisNewer); - - fXMP->SyncExif (*fExif.Get ()); - - fXMP->SyncOrientation (*this, fXMPinSidecar); - - } - -/*****************************************************************************/ - -void dng_metadata::UpdateDateTime (const dng_date_time_info &dt) - { - - fExif->UpdateDateTime (dt); - - fXMP->UpdateDateTime (dt); - - } - -/*****************************************************************************/ - -void dng_metadata::UpdateDateTimeToNow () - { - - dng_date_time_info dt; - - CurrentDateTimeAndZone (dt); - - UpdateDateTime (dt); - - fXMP->UpdateMetadataDate (dt); - - } - -/*****************************************************************************/ - -void dng_metadata::UpdateMetadataDateTimeToNow () - { - - dng_date_time_info dt; - - CurrentDateTimeAndZone (dt); - - fXMP->UpdateMetadataDate (dt); - - } - -/*****************************************************************************/ - -dng_negative::dng_negative (dng_host &host) - - : fAllocator (host.Allocator ()) - - , fModelName () - , fLocalName () - , fDefaultCropSizeH () - , fDefaultCropSizeV () - , fDefaultCropOriginH (0, 1) - , fDefaultCropOriginV (0, 1) - , fDefaultUserCropT (0, 1) - , fDefaultUserCropL (0, 1) - , fDefaultUserCropB (1, 1) - , fDefaultUserCropR (1, 1) - , fDefaultScaleH (1, 1) - , fDefaultScaleV (1, 1) - , fBestQualityScale (1, 1) - , fOriginalDefaultFinalSize () - , fOriginalBestQualityFinalSize () - , fOriginalDefaultCropSizeH () - , fOriginalDefaultCropSizeV () - , fRawToFullScaleH (1.0) - , fRawToFullScaleV (1.0) - , fBaselineNoise (100, 100) - , fNoiseReductionApplied (0, 0) - , fNoiseProfile () - , fBaselineExposure ( 0, 100) - , fBaselineSharpness (100, 100) - , fChromaBlurRadius () - , fAntiAliasStrength (100, 100) - , fLinearResponseLimit (100, 100) - , fShadowScale (1, 1) - , fColorimetricReference (crSceneReferred) - , fColorChannels (0) - , fAnalogBalance () - , fCameraNeutral () - , fCameraWhiteXY () - , fCameraCalibration1 () - , fCameraCalibration2 () - , fCameraCalibrationSignature () - , fCameraProfile () - , fAsShotProfileName () - , fRawImageDigest () - , fNewRawImageDigest () - , fRawDataUniqueID () - , fOriginalRawFileName () - , fHasOriginalRawFileData (false) - , fOriginalRawFileData () - , fOriginalRawFileDigest () - , fDNGPrivateData () - , fMetadata (host) - , fLinearizationInfo () - , fMosaicInfo () - , fOpcodeList1 (1) - , fOpcodeList2 (2) - , fOpcodeList3 (3) - , fStage1Image () - , fStage2Image () - , fStage3Image () - , fStage3Gain (1.0) - , fIsPreview (false) - , fIsDamaged (false) - , fRawImageStage (rawImageStageNone) - , fRawImage () - , fRawFloatBitDepth (0) - , fRawJPEGImage () - , fRawJPEGImageDigest () - , fTransparencyMask () - , fRawTransparencyMask () - , fRawTransparencyMaskBitDepth (0) - , fUnflattenedStage3Image () - - { - - } - -/*****************************************************************************/ - -dng_negative::~dng_negative () - { - - // Delete any camera profiles owned by this negative. - - ClearProfiles (); - - } - -/******************************************************************************/ - -void dng_negative::Initialize () - { - - } - -/******************************************************************************/ - -dng_negative * dng_negative::Make (dng_host &host) - { - - AutoPtr result (new dng_negative (host)); - - if (!result.Get ()) - { - ThrowMemoryFull (); - } - - result->Initialize (); - - return result.Release (); - - } - -/******************************************************************************/ - -dng_metadata * dng_negative::CloneInternalMetadata () const - { - - return InternalMetadata ().Clone (Allocator ()); - - } - -/******************************************************************************/ - -dng_orientation dng_negative::ComputeOrientation (const dng_metadata &metadata) const - { - - return metadata.BaseOrientation (); - - } - -/******************************************************************************/ - -void dng_negative::SetAnalogBalance (const dng_vector &b) - { - - real64 minEntry = b.MinEntry (); - - if (b.NotEmpty () && minEntry > 0.0) - { - - fAnalogBalance = b; - - fAnalogBalance.Scale (1.0 / minEntry); - - fAnalogBalance.Round (1000000.0); - - } - - else - { - - fAnalogBalance.Clear (); - - } - - } - -/*****************************************************************************/ - -real64 dng_negative::AnalogBalance (uint32 channel) const - { - - DNG_ASSERT (channel < ColorChannels (), "Channel out of bounds"); - - if (channel < fAnalogBalance.Count ()) - { - - return fAnalogBalance [channel]; - - } - - return 1.0; - - } - -/*****************************************************************************/ - -dng_urational dng_negative::AnalogBalanceR (uint32 channel) const - { - - dng_urational result; - - result.Set_real64 (AnalogBalance (channel), 1000000); - - return result; - - } - -/******************************************************************************/ - -void dng_negative::SetCameraNeutral (const dng_vector &n) - { - - real64 maxEntry = n.MaxEntry (); - - if (n.NotEmpty () && maxEntry > 0.0) - { - - fCameraNeutral = n; - - fCameraNeutral.Scale (1.0 / maxEntry); - - fCameraNeutral.Round (1000000.0); - - } - - else - { - - fCameraNeutral.Clear (); - - } - - } - -/*****************************************************************************/ - -dng_urational dng_negative::CameraNeutralR (uint32 channel) const - { - - dng_urational result; - - result.Set_real64 (CameraNeutral () [channel], 1000000); - - return result; - - } - -/******************************************************************************/ - -void dng_negative::SetCameraWhiteXY (const dng_xy_coord &coord) - { - - if (coord.IsValid ()) - { - - fCameraWhiteXY.x = Round_int32 (coord.x * 1000000.0) / 1000000.0; - fCameraWhiteXY.y = Round_int32 (coord.y * 1000000.0) / 1000000.0; - - } - - else - { - - fCameraWhiteXY.Clear (); - - } - - } - -/*****************************************************************************/ - -const dng_xy_coord & dng_negative::CameraWhiteXY () const - { - - DNG_ASSERT (HasCameraWhiteXY (), "Using undefined CameraWhiteXY"); - - return fCameraWhiteXY; - - } - -/*****************************************************************************/ - -void dng_negative::GetCameraWhiteXY (dng_urational &x, - dng_urational &y) const - { - - dng_xy_coord coord = CameraWhiteXY (); - - x.Set_real64 (coord.x, 1000000); - y.Set_real64 (coord.y, 1000000); - - } - -/*****************************************************************************/ - -void dng_negative::SetCameraCalibration1 (const dng_matrix &m) - { - - fCameraCalibration1 = m; - - fCameraCalibration1.Round (10000); - - } - -/******************************************************************************/ - -void dng_negative::SetCameraCalibration2 (const dng_matrix &m) - { - - fCameraCalibration2 = m; - - fCameraCalibration2.Round (10000); - - } - -/******************************************************************************/ - -void dng_negative::AddProfile (AutoPtr &profile) - { - - // Make sure we have a profile to add. - - if (!profile.Get ()) - { - - return; - - } - - // We must have some profile name. Use "embedded" if nothing else. - - if (profile->Name ().IsEmpty ()) - { - - profile->SetName (kProfileName_Embedded); - - } - - // Special case support for reading older DNG files which did not store - // the profile name in the main IFD profile. - - if (fCameraProfile.size ()) - { - - // See the first profile has a default "embedded" name, and has - // the same data as the profile we are adding. - - if (fCameraProfile [0]->NameIsEmbedded () && - fCameraProfile [0]->EqualData (*profile.Get ())) - { - - // If the profile we are deleting was read from DNG - // then the new profile should be marked as such also. - - if (fCameraProfile [0]->WasReadFromDNG ()) - { - - profile->SetWasReadFromDNG (); - - } - - // If the profile we are deleting wasn't read from disk then the new - // profile should be marked as such also. - - if (!fCameraProfile [0]->WasReadFromDisk ()) - { - - profile->SetWasReadFromDisk (false); - - } - - // Delete the profile with default name. - - delete fCameraProfile [0]; - - fCameraProfile [0] = NULL; - - fCameraProfile.erase (fCameraProfile.begin ()); - - } - - } - - // Duplicate detection logic. We give a preference to last added profile - // so the profiles end up in a more consistent order no matter what profiles - // happen to be embedded in the DNG. - - for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++) - { - - // Instead of checking for matching fingerprints, we check that the two - // profiles have the same color and have the same name. This allows two - // profiles that are identical except for copyright string and embed policy - // to be considered duplicates. - - const bool equalColorAndSameName = (fCameraProfile [index]->EqualData (*profile.Get ()) && - fCameraProfile [index]->Name () == profile->Name ()); - - if (equalColorAndSameName) - { - - // If the profile we are deleting was read from DNG - // then the new profile should be marked as such also. - - if (fCameraProfile [index]->WasReadFromDNG ()) - { - - profile->SetWasReadFromDNG (); - - } - - // If the profile we are deleting wasn't read from disk then the new - // profile should be marked as such also. - - if (!fCameraProfile [index]->WasReadFromDisk ()) - { - - profile->SetWasReadFromDisk (false); - - } - - // Delete the duplicate profile. - - delete fCameraProfile [index]; - - fCameraProfile [index] = NULL; - - fCameraProfile.erase (fCameraProfile.begin () + index); - - break; - - } - - } - - // Now add to profile list. - - fCameraProfile.push_back (NULL); - - fCameraProfile [fCameraProfile.size () - 1] = profile.Release (); - - } - -/******************************************************************************/ - -void dng_negative::ClearProfiles () - { - - // Delete any camera profiles owned by this negative. - - for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++) - { - - if (fCameraProfile [index]) - { - - delete fCameraProfile [index]; - - fCameraProfile [index] = NULL; - - } - - } - - // Now empty list. - - fCameraProfile.clear (); - - } - -/*****************************************************************************/ - -void dng_negative::ClearProfiles (bool clearBuiltinMatrixProfiles, - bool clearReadFromDisk) - { - - // If neither flag is set, then there's nothing to do. - - if (!clearBuiltinMatrixProfiles && - !clearReadFromDisk) - { - return; - } - - // Delete any camera profiles in this negative that match the specified criteria. - - std::vector::iterator iter = fCameraProfile.begin (); - std::vector::iterator next; - - for (; iter != fCameraProfile.end (); iter = next) - { - - dng_camera_profile *profile = *iter; - - // If the profile is invalid (i.e., NULL pointer), or meets one of the - // specified criteria, then axe it. - - if (!profile || - (clearBuiltinMatrixProfiles && profile->WasBuiltinMatrix ()) || - (clearReadFromDisk && profile->WasReadFromDisk ())) - { - - delete profile; - - next = fCameraProfile.erase (iter); - - } - - // Otherwise, just advance to the next element. - - else - { - - next = iter + 1; - - } - - } - - } - -/******************************************************************************/ - -uint32 dng_negative::ProfileCount () const - { - - return (uint32) fCameraProfile.size (); - - } - -/******************************************************************************/ - -const dng_camera_profile & dng_negative::ProfileByIndex (uint32 index) const - { - - DNG_ASSERT (index < ProfileCount (), - "Invalid index for ProfileByIndex"); - - return *fCameraProfile [index]; - - } - -/*****************************************************************************/ - -const dng_camera_profile * dng_negative::ProfileByID (const dng_camera_profile_id &id, - bool useDefaultIfNoMatch) const - { - - uint32 index; - - // If this negative does not have any profiles, we are not going to - // find a match. - - uint32 profileCount = ProfileCount (); - - if (profileCount == 0) - { - return NULL; - } - - // If we have both a profile name and fingerprint, try matching both. - - if (id.Name ().NotEmpty () && id.Fingerprint ().IsValid ()) - { - - for (index = 0; index < profileCount; index++) - { - - const dng_camera_profile &profile = ProfileByIndex (index); - - if (id.Name () == profile.Name () && - id.Fingerprint () == profile.Fingerprint ()) - { - - return &profile; - - } - - } - - } - - // If we have a name, try matching that. - - if (id.Name ().NotEmpty ()) - { - - for (index = 0; index < profileCount; index++) - { - - const dng_camera_profile &profile = ProfileByIndex (index); - - if (id.Name () == profile.Name ()) - { - - return &profile; - - } - - } - - } - - // If we have a valid fingerprint, try matching that. - - if (id.Fingerprint ().IsValid ()) - { - - for (index = 0; index < profileCount; index++) - { - - const dng_camera_profile &profile = ProfileByIndex (index); - - if (id.Fingerprint () == profile.Fingerprint ()) - { - - return &profile; - - } - - } - - } - - // Try "upgrading" profile name versions. - - if (id.Name ().NotEmpty ()) - { - - dng_string baseName; - int32 version; - - SplitCameraProfileName (id.Name (), - baseName, - version); - - int32 bestIndex = -1; - int32 bestVersion = 0; - - for (index = 0; index < profileCount; index++) - { - - const dng_camera_profile &profile = ProfileByIndex (index); - - if (profile.Name ().StartsWith (baseName.Get ())) - { - - dng_string testBaseName; - int32 testVersion; - - SplitCameraProfileName (profile.Name (), - testBaseName, - testVersion); - - if (bestIndex == -1 || testVersion > bestVersion) - { - - bestIndex = index; - bestVersion = testVersion; - - } - - } - - } - - if (bestIndex != -1) - { - - return &ProfileByIndex (bestIndex); - - } - - } - - // Did not find a match any way. See if we should return a default value. - - if (useDefaultIfNoMatch) - { - - return &ProfileByIndex (0); - - } - - // Found nothing. - - return NULL; - - } - -/*****************************************************************************/ - -const dng_camera_profile * dng_negative::ComputeCameraProfileToEmbed - (const dng_metadata & /* metadata */) const - { - - uint32 index; - - uint32 count = ProfileCount (); - - if (count == 0) - { - - return NULL; - - } - - // First try to look for the first profile that was already in the DNG - // when we read it. - - for (index = 0; index < count; index++) - { - - const dng_camera_profile &profile (ProfileByIndex (index)); - - if (profile.WasReadFromDNG ()) - { - - return &profile; - - } - - } - - // Next we look for the first profile that is legal to embed. - - for (index = 0; index < count; index++) - { - - const dng_camera_profile &profile (ProfileByIndex (index)); - - if (profile.IsLegalToEmbed ()) - { - - return &profile; - - } - - } - - // Else just return the first profile. - - return fCameraProfile [0]; - - } - -/*****************************************************************************/ - -dng_color_spec * dng_negative::MakeColorSpec (const dng_camera_profile_id &id) const - { - - dng_color_spec *spec = new dng_color_spec (*this, ProfileByID (id)); - - if (!spec) - { - ThrowMemoryFull (); - } - - return spec; - - } - -/*****************************************************************************/ - -dng_fingerprint dng_negative::FindImageDigest (dng_host &host, - const dng_image &image) const - { - - dng_md5_printer printer; - - dng_pixel_buffer buffer; - - buffer.fPlane = 0; - buffer.fPlanes = image.Planes (); - - buffer.fRowStep = image.Planes () * image.Width (); - buffer.fColStep = image.Planes (); - buffer.fPlaneStep = 1; - - buffer.fPixelType = image.PixelType (); - buffer.fPixelSize = image.PixelSize (); - - // Sometimes we expand 8-bit data to 16-bit data while reading or - // writing, so always compute the digest of 8-bit data as 16-bits. - - if (buffer.fPixelType == ttByte) - { - buffer.fPixelType = ttShort; - buffer.fPixelSize = 2; - } - - const uint32 kBufferRows = 16; - - uint32 bufferBytes = kBufferRows * buffer.fRowStep * buffer.fPixelSize; - - AutoPtr bufferData (host.Allocate (bufferBytes)); - - buffer.fData = bufferData->Buffer (); - - dng_rect area; - - dng_tile_iterator iter (dng_point (kBufferRows, - image.Width ()), - image.Bounds ()); - - while (iter.GetOneTile (area)) - { - - host.SniffForAbort (); - - buffer.fArea = area; - - image.Get (buffer); - - uint32 count = buffer.fArea.H () * - buffer.fRowStep * - buffer.fPixelSize; - - #if qDNGBigEndian - - // We need to use the same byte order to compute - // the digest, no matter the native order. Little-endian - // is more common now, so use that. - - switch (buffer.fPixelSize) - { - - case 1: - break; - - case 2: - { - DoSwapBytes16 ((uint16 *) buffer.fData, count >> 1); - break; - } - - case 4: - { - DoSwapBytes32 ((uint32 *) buffer.fData, count >> 2); - break; - } - - default: - { - DNG_REPORT ("Unexpected pixel size"); - break; - } - - } - - #endif - - printer.Process (buffer.fData, - count); - - } - - return printer.Result (); - - } - -/*****************************************************************************/ - -void dng_negative::FindRawImageDigest (dng_host &host) const - { - - if (fRawImageDigest.IsNull ()) - { - - // Since we are adding the floating point and transparency support - // in DNG 1.4, and there are no legacy floating point or transparent - // DNGs, switch to using the more MP friendly algorithm to compute - // the digest for these images. - - if (RawImage ().PixelType () == ttFloat || RawTransparencyMask ()) - { - - FindNewRawImageDigest (host); - - fRawImageDigest = fNewRawImageDigest; - - } - - else - { - - #if qDNGValidate - - dng_timer timeScope ("FindRawImageDigest time"); - - #endif - - fRawImageDigest = FindImageDigest (host, RawImage ()); - - } - - } - - } - -/*****************************************************************************/ - -class dng_find_new_raw_image_digest_task : public dng_area_task - { - - private: - - enum - { - kTileSize = 256 - }; - - const dng_image &fImage; - - uint32 fPixelType; - uint32 fPixelSize; - - uint32 fTilesAcross; - uint32 fTilesDown; - - uint32 fTileCount; - - AutoArray fTileHash; - - AutoPtr fBufferData [kMaxMPThreads]; - - public: - - dng_find_new_raw_image_digest_task (const dng_image &image, - uint32 pixelType) - - : fImage (image) - , fPixelType (pixelType) - , fPixelSize (TagTypeSize (pixelType)) - , fTilesAcross (0) - , fTilesDown (0) - , fTileCount (0) - , fTileHash (NULL) - - { - - fMinTaskArea = 1; - - fUnitCell = dng_point (Min_int32 (kTileSize, fImage.Bounds ().H ()), - Min_int32 (kTileSize, fImage.Bounds ().W ())); - - fMaxTileSize = fUnitCell; - - } - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer * /* sniffer */) - { - - if (tileSize != fUnitCell) - { - ThrowProgramError (); - } - - fTilesAcross = (fImage.Bounds ().W () + fUnitCell.h - 1) / fUnitCell.h; - fTilesDown = (fImage.Bounds ().H () + fUnitCell.v - 1) / fUnitCell.v; - - fTileCount = fTilesAcross * fTilesDown; - - fTileHash.Reset (new dng_fingerprint [fTileCount]); - - uint32 bufferSize = fImage.Planes () * - fPixelSize * - tileSize.h * - tileSize.v; - - for (uint32 index = 0; index < threadCount; index++) - { - - fBufferData [index].Reset (allocator->Allocate (bufferSize)); - - } - - } - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer * /* sniffer */) - { - - int32 colIndex = (tile.l - fImage.Bounds ().l) / fUnitCell.h; - int32 rowIndex = (tile.t - fImage.Bounds ().t) / fUnitCell.v; - - DNG_ASSERT (tile.l == fImage.Bounds ().l + colIndex * fUnitCell.h && - tile.t == fImage.Bounds ().t + rowIndex * fUnitCell.v, - "Bad tile origin"); - - uint32 tileIndex = rowIndex * fTilesAcross + colIndex; - - dng_pixel_buffer buffer; - - buffer.fArea = tile; - - buffer.fPlane = 0; - buffer.fPlanes = fImage.Planes (); - - buffer.fRowStep = tile.W (); - buffer.fColStep = 1; - buffer.fPlaneStep = tile.W () * tile.H (); - - buffer.fPixelType = fPixelType; - buffer.fPixelSize = fPixelSize; - - buffer.fData = fBufferData [threadIndex]->Buffer (); - - fImage.Get (buffer); - - uint32 count = buffer.fPlaneStep * - buffer.fPlanes * - buffer.fPixelSize; - - #if qDNGBigEndian - - // We need to use the same byte order to compute - // the digest, no matter the native order. Little-endian - // is more common now, so use that. - - switch (buffer.fPixelSize) - { - - case 1: - break; - - case 2: - { - DoSwapBytes16 ((uint16 *) buffer.fData, count >> 1); - break; - } - - case 4: - { - DoSwapBytes32 ((uint32 *) buffer.fData, count >> 2); - break; - } - - default: - { - DNG_REPORT ("Unexpected pixel size"); - break; - } - - } - - #endif - - dng_md5_printer printer; - - printer.Process (buffer.fData, count); - - fTileHash [tileIndex] = printer.Result (); - - } - - dng_fingerprint Result () - { - - dng_md5_printer printer; - - for (uint32 tileIndex = 0; tileIndex < fTileCount; tileIndex++) - { - - printer.Process (fTileHash [tileIndex] . data, 16); - - } - - return printer.Result (); - - } - - }; - -/*****************************************************************************/ - -void dng_negative::FindNewRawImageDigest (dng_host &host) const - { - - if (fNewRawImageDigest.IsNull ()) - { - - #if qDNGValidate - - dng_timer timeScope ("FindNewRawImageDigest time"); - - #endif - - // Find fast digest of the raw image. - - { - - const dng_image &rawImage = RawImage (); - - // Find pixel type that will be saved in the file. When saving DNGs, we convert - // some 16-bit data to 8-bit data, so we need to do the matching logic here. - - uint32 rawPixelType = rawImage.PixelType (); - - if (rawPixelType == ttShort) - { - - // See if we are using a linearization table with <= 256 entries, in which - // case the useful data will all fit within 8-bits. - - const dng_linearization_info *rangeInfo = GetLinearizationInfo (); - - if (rangeInfo) - { - - if (rangeInfo->fLinearizationTable.Get ()) - { - - uint32 entries = rangeInfo->fLinearizationTable->LogicalSize () >> 1; - - if (entries <= 256) - { - - rawPixelType = ttByte; - - } - - } - - } - - } - - // Find the fast digest on the raw image. - - dng_find_new_raw_image_digest_task task (rawImage, rawPixelType); - - host.PerformAreaTask (task, rawImage.Bounds ()); - - fNewRawImageDigest = task.Result (); - - } - - // If there is a transparancy mask, we need to include that in the - // digest also. - - if (RawTransparencyMask () != NULL) - { - - // Find the fast digest on the raw mask. - - dng_fingerprint maskDigest; - - { - - dng_find_new_raw_image_digest_task task (*RawTransparencyMask (), - RawTransparencyMask ()->PixelType ()); - - host.PerformAreaTask (task, RawTransparencyMask ()->Bounds ()); - - maskDigest = task.Result (); - - } - - // Combine the two digests into a single digest. - - dng_md5_printer printer; - - printer.Process (fNewRawImageDigest.data, 16); - - printer.Process (maskDigest.data, 16); - - fNewRawImageDigest = printer.Result (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_negative::ValidateRawImageDigest (dng_host &host) - { - - if (Stage1Image () && !IsPreview () && (fRawImageDigest .IsValid () || - fNewRawImageDigest.IsValid ())) - { - - bool isNewDigest = fNewRawImageDigest.IsValid (); - - dng_fingerprint &rawDigest = isNewDigest ? fNewRawImageDigest - : fRawImageDigest; - - // For lossy compressed JPEG images, we need to compare the stored - // digest to the digest computed from the compressed data, since - // decompressing lossy JPEG data is itself a lossy process. - - if (RawJPEGImageDigest ().IsValid () || RawJPEGImage ()) - { - - // Compute the raw JPEG image digest if we have not done so - // already. - - FindRawJPEGImageDigest (host); - - if (rawDigest != RawJPEGImageDigest ()) - { - - #if qDNGValidate - - ReportError ("RawImageDigest does not match raw jpeg image"); - - #else - - SetIsDamaged (true); - - #endif - - } - - } - - // Else we can compare the stored digest to the image in memory. - - else - { - - dng_fingerprint oldDigest = rawDigest; - - try - { - - rawDigest.Clear (); - - if (isNewDigest) - { - - FindNewRawImageDigest (host); - - } - - else - { - - FindRawImageDigest (host); - - } - - } - - catch (...) - { - - rawDigest = oldDigest; - - throw; - - } - - if (oldDigest != rawDigest) - { - - #if qDNGValidate - - if (isNewDigest) - { - ReportError ("NewRawImageDigest does not match raw image"); - } - else - { - ReportError ("RawImageDigest does not match raw image"); - } - - SetIsDamaged (true); - - #else - - if (!isNewDigest) - { - - // Note that Lightroom 1.4 Windows had a bug that corrupts the - // first four bytes of the RawImageDigest tag. So if the last - // twelve bytes match, this is very likely the result of the - // bug, and not an actual corrupt file. So don't report this - // to the user--just fix it. - - { - - bool matchLast12 = true; - - for (uint32 j = 4; j < 16; j++) - { - matchLast12 = matchLast12 && (oldDigest.data [j] == fRawImageDigest.data [j]); - } - - if (matchLast12) - { - return; - } - - } - - // Sometimes Lightroom 1.4 would corrupt more than the first four - // bytes, but for all those files that I have seen so far the - // resulting first four bytes are 0x08 0x00 0x00 0x00. - - if (oldDigest.data [0] == 0x08 && - oldDigest.data [1] == 0x00 && - oldDigest.data [2] == 0x00 && - oldDigest.data [3] == 0x00) - { - return; - } - - } - - SetIsDamaged (true); - - #endif - - } - - } - - } - - } - -/*****************************************************************************/ - -// If the raw data unique ID is missing, compute one based on a MD5 hash of -// the raw image hash and the model name, plus other commonly changed -// data that can affect rendering. - -void dng_negative::FindRawDataUniqueID (dng_host &host) const - { - - if (fRawDataUniqueID.IsNull ()) - { - - dng_md5_printer_stream printer; - - // If we have a raw jpeg image, it is much faster to - // use its digest as part of the unique ID since - // the data size is much smaller. We cannot use it - // if there a transparency mask, since that is not - // included in the RawJPEGImageDigest. - - if (RawJPEGImage () && !RawTransparencyMask ()) - { - - FindRawJPEGImageDigest (host); - - printer.Put (fRawJPEGImageDigest.data, 16); - - } - - // Include the new raw image digest in the unique ID. - - else - { - - FindNewRawImageDigest (host); - - printer.Put (fNewRawImageDigest.data, 16); - - } - - // Include model name. - - printer.Put (ModelName ().Get (), - ModelName ().Length ()); - - // Include default crop area, since DNG Recover Edges can modify - // these values and they affect rendering. - - printer.Put_uint32 (fDefaultCropSizeH.n); - printer.Put_uint32 (fDefaultCropSizeH.d); - - printer.Put_uint32 (fDefaultCropSizeV.n); - printer.Put_uint32 (fDefaultCropSizeV.d); - - printer.Put_uint32 (fDefaultCropOriginH.n); - printer.Put_uint32 (fDefaultCropOriginH.d); - - printer.Put_uint32 (fDefaultCropOriginV.n); - printer.Put_uint32 (fDefaultCropOriginV.d); - - // Include default user crop. - - printer.Put_uint32 (fDefaultUserCropT.n); - printer.Put_uint32 (fDefaultUserCropT.d); - - printer.Put_uint32 (fDefaultUserCropL.n); - printer.Put_uint32 (fDefaultUserCropL.d); - - printer.Put_uint32 (fDefaultUserCropB.n); - printer.Put_uint32 (fDefaultUserCropB.d); - - printer.Put_uint32 (fDefaultUserCropR.n); - printer.Put_uint32 (fDefaultUserCropR.d); - - // Include opcode lists, since lens correction utilities can modify - // these values and they affect rendering. - - fOpcodeList1.FingerprintToStream (printer); - fOpcodeList2.FingerprintToStream (printer); - fOpcodeList3.FingerprintToStream (printer); - - fRawDataUniqueID = printer.Result (); - - } - - } - -/******************************************************************************/ - -// Forces recomputation of RawDataUniqueID, useful to call -// after modifying the opcode lists, etc. - -void dng_negative::RecomputeRawDataUniqueID (dng_host &host) - { - - fRawDataUniqueID.Clear (); - - FindRawDataUniqueID (host); - - } - -/******************************************************************************/ - -void dng_negative::FindOriginalRawFileDigest () const - { - - if (fOriginalRawFileDigest.IsNull () && fOriginalRawFileData.Get ()) - { - - dng_md5_printer printer; - - printer.Process (fOriginalRawFileData->Buffer (), - fOriginalRawFileData->LogicalSize ()); - - fOriginalRawFileDigest = printer.Result (); - - } - - } - -/*****************************************************************************/ - -void dng_negative::ValidateOriginalRawFileDigest () - { - - if (fOriginalRawFileDigest.IsValid () && fOriginalRawFileData.Get ()) - { - - dng_fingerprint oldDigest = fOriginalRawFileDigest; - - try - { - - fOriginalRawFileDigest.Clear (); - - FindOriginalRawFileDigest (); - - } - - catch (...) - { - - fOriginalRawFileDigest = oldDigest; - - throw; - - } - - if (oldDigest != fOriginalRawFileDigest) - { - - #if qDNGValidate - - ReportError ("OriginalRawFileDigest does not match OriginalRawFileData"); - - #else - - SetIsDamaged (true); - - #endif - - // Don't "repair" the original image data digest. Once it is - // bad, it stays bad. The user cannot tell by looking at the image - // whether the damage is acceptable and can be ignored in the - // future. - - fOriginalRawFileDigest = oldDigest; - - } - - } - - } - -/******************************************************************************/ - -dng_rect dng_negative::DefaultCropArea () const - { - - // First compute the area using simple rounding. - - dng_rect result; - - result.l = Round_int32 (fDefaultCropOriginH.As_real64 () * fRawToFullScaleH); - result.t = Round_int32 (fDefaultCropOriginV.As_real64 () * fRawToFullScaleV); - - result.r = result.l + Round_int32 (fDefaultCropSizeH.As_real64 () * fRawToFullScaleH); - result.b = result.t + Round_int32 (fDefaultCropSizeV.As_real64 () * fRawToFullScaleV); - - // Sometimes the simple rounding causes the resulting default crop - // area to slide off the scaled image area. So we force this not - // to happen. We only do this if the image is not stubbed. - - const dng_image *image = Stage3Image (); - - if (image) - { - - dng_point imageSize = image->Size (); - - if (result.r > imageSize.h) - { - result.l -= result.r - imageSize.h; - result.r = imageSize.h; - } - - if (result.b > imageSize.v) - { - result.t -= result.b - imageSize.v; - result.b = imageSize.v; - } - - } - - return result; - - } - -/*****************************************************************************/ - -real64 dng_negative::TotalBaselineExposure (const dng_camera_profile_id &profileID) const - { - - real64 total = BaselineExposure (); - - const dng_camera_profile *profile = ProfileByID (profileID); - - if (profile) - { - - real64 offset = profile->BaselineExposureOffset ().As_real64 (); - - total += offset; - - } - - return total; - - } - -/******************************************************************************/ - -void dng_negative::SetShadowScale (const dng_urational &scale) - { - - if (scale.d > 0) - { - - real64 s = scale.As_real64 (); - - if (s > 0.0 && s <= 1.0) - { - - fShadowScale = scale; - - } - - } - - } - -/******************************************************************************/ - -void dng_negative::SetActiveArea (const dng_rect &area) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fActiveArea = area; - - } - -/******************************************************************************/ - -void dng_negative::SetMaskedAreas (uint32 count, - const dng_rect *area) - { - - DNG_ASSERT (count <= kMaxMaskedAreas, "Too many masked areas"); - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fMaskedAreaCount = Min_uint32 (count, kMaxMaskedAreas); - - for (uint32 index = 0; index < info.fMaskedAreaCount; index++) - { - - info.fMaskedArea [index] = area [index]; - - } - - } - -/*****************************************************************************/ - -void dng_negative::SetLinearization (AutoPtr &curve) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fLinearizationTable.Reset (curve.Release ()); - - } - -/*****************************************************************************/ - -void dng_negative::SetBlackLevel (real64 black, - int32 plane) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fBlackLevelRepeatRows = 1; - info.fBlackLevelRepeatCols = 1; - - if (plane < 0) - { - - for (uint32 j = 0; j < kMaxSamplesPerPixel; j++) - { - - info.fBlackLevel [0] [0] [j] = black; - - } - - } - - else - { - - info.fBlackLevel [0] [0] [plane] = black; - - } - - info.RoundBlacks (); - - } - -/*****************************************************************************/ - -void dng_negative::SetQuadBlacks (real64 black0, - real64 black1, - real64 black2, - real64 black3, - int32 plane) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fBlackLevelRepeatRows = 2; - info.fBlackLevelRepeatCols = 2; - - if (plane < 0) - { - - for (uint32 j = 0; j < kMaxSamplesPerPixel; j++) - { - - info.fBlackLevel [0] [0] [j] = black0; - info.fBlackLevel [0] [1] [j] = black1; - info.fBlackLevel [1] [0] [j] = black2; - info.fBlackLevel [1] [1] [j] = black3; - - } - - } - - else - { - - info.fBlackLevel [0] [0] [plane] = black0; - info.fBlackLevel [0] [1] [plane] = black1; - info.fBlackLevel [1] [0] [plane] = black2; - info.fBlackLevel [1] [1] [plane] = black3; - - } - - info.RoundBlacks (); - - } - -/*****************************************************************************/ - -void dng_negative::SetRowBlacks (const real64 *blacks, - uint32 count) - { - - if (count) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - uint32 byteCount = count * (uint32) sizeof (real64); - - info.fBlackDeltaV.Reset (Allocator ().Allocate (byteCount)); - - DoCopyBytes (blacks, - info.fBlackDeltaV->Buffer (), - byteCount); - - info.RoundBlacks (); - - } - - else if (fLinearizationInfo.Get ()) - { - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fBlackDeltaV.Reset (); - - } - - } - -/*****************************************************************************/ - -void dng_negative::SetColumnBlacks (const real64 *blacks, - uint32 count) - { - - if (count) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - uint32 byteCount = count * (uint32) sizeof (real64); - - info.fBlackDeltaH.Reset (Allocator ().Allocate (byteCount)); - - DoCopyBytes (blacks, - info.fBlackDeltaH->Buffer (), - byteCount); - - info.RoundBlacks (); - - } - - else if (fLinearizationInfo.Get ()) - { - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.fBlackDeltaH.Reset (); - - } - - } - -/*****************************************************************************/ - -uint32 dng_negative::WhiteLevel (uint32 plane) const - { - - if (fLinearizationInfo.Get ()) - { - - const dng_linearization_info &info = *fLinearizationInfo.Get (); - - return Round_uint32 (info.fWhiteLevel [plane]); - - } - - if (RawImage ().PixelType () == ttFloat) - { - - return 1; - - } - - return 0x0FFFF; - - } - -/*****************************************************************************/ - -void dng_negative::SetWhiteLevel (uint32 white, - int32 plane) - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - if (plane < 0) - { - - for (uint32 j = 0; j < kMaxSamplesPerPixel; j++) - { - - info.fWhiteLevel [j] = (real64) white; - - } - - } - - else - { - - info.fWhiteLevel [plane] = (real64) white; - - } - - } - -/******************************************************************************/ - -void dng_negative::SetColorKeys (ColorKeyCode color0, - ColorKeyCode color1, - ColorKeyCode color2, - ColorKeyCode color3) - { - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - info.fCFAPlaneColor [0] = color0; - info.fCFAPlaneColor [1] = color1; - info.fCFAPlaneColor [2] = color2; - info.fCFAPlaneColor [3] = color3; - - } - -/******************************************************************************/ - -void dng_negative::SetBayerMosaic (uint32 phase) - { - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0]; - ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1]; - ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2]; - - info.fCFAPatternSize = dng_point (2, 2); - - switch (phase) - { - - case 0: - { - info.fCFAPattern [0] [0] = color1; - info.fCFAPattern [0] [1] = color0; - info.fCFAPattern [1] [0] = color2; - info.fCFAPattern [1] [1] = color1; - break; - } - - case 1: - { - info.fCFAPattern [0] [0] = color0; - info.fCFAPattern [0] [1] = color1; - info.fCFAPattern [1] [0] = color1; - info.fCFAPattern [1] [1] = color2; - break; - } - - case 2: - { - info.fCFAPattern [0] [0] = color2; - info.fCFAPattern [0] [1] = color1; - info.fCFAPattern [1] [0] = color1; - info.fCFAPattern [1] [1] = color0; - break; - } - - case 3: - { - info.fCFAPattern [0] [0] = color1; - info.fCFAPattern [0] [1] = color2; - info.fCFAPattern [1] [0] = color0; - info.fCFAPattern [1] [1] = color1; - break; - } - - } - - info.fColorPlanes = 3; - - info.fCFALayout = 1; - - } - -/******************************************************************************/ - -void dng_negative::SetFujiMosaic (uint32 phase) - { - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0]; - ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1]; - ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2]; - - info.fCFAPatternSize = dng_point (2, 4); - - switch (phase) - { - - case 0: - { - info.fCFAPattern [0] [0] = color0; - info.fCFAPattern [0] [1] = color1; - info.fCFAPattern [0] [2] = color2; - info.fCFAPattern [0] [3] = color1; - info.fCFAPattern [1] [0] = color2; - info.fCFAPattern [1] [1] = color1; - info.fCFAPattern [1] [2] = color0; - info.fCFAPattern [1] [3] = color1; - break; - } - - case 1: - { - info.fCFAPattern [0] [0] = color2; - info.fCFAPattern [0] [1] = color1; - info.fCFAPattern [0] [2] = color0; - info.fCFAPattern [0] [3] = color1; - info.fCFAPattern [1] [0] = color0; - info.fCFAPattern [1] [1] = color1; - info.fCFAPattern [1] [2] = color2; - info.fCFAPattern [1] [3] = color1; - break; - } - - } - - info.fColorPlanes = 3; - - info.fCFALayout = 2; - - } - -/*****************************************************************************/ - -void dng_negative::SetFujiMosaic6x6 (uint32 phase) - { - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0]; - ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1]; - ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2]; - - const uint32 patSize = 6; - - info.fCFAPatternSize = dng_point (patSize, patSize); - - info.fCFAPattern [0] [0] = color1; - info.fCFAPattern [0] [1] = color2; - info.fCFAPattern [0] [2] = color1; - info.fCFAPattern [0] [3] = color1; - info.fCFAPattern [0] [4] = color0; - info.fCFAPattern [0] [5] = color1; - - info.fCFAPattern [1] [0] = color0; - info.fCFAPattern [1] [1] = color1; - info.fCFAPattern [1] [2] = color0; - info.fCFAPattern [1] [3] = color2; - info.fCFAPattern [1] [4] = color1; - info.fCFAPattern [1] [5] = color2; - - info.fCFAPattern [2] [0] = color1; - info.fCFAPattern [2] [1] = color2; - info.fCFAPattern [2] [2] = color1; - info.fCFAPattern [2] [3] = color1; - info.fCFAPattern [2] [4] = color0; - info.fCFAPattern [2] [5] = color1; - - info.fCFAPattern [3] [0] = color1; - info.fCFAPattern [3] [1] = color0; - info.fCFAPattern [3] [2] = color1; - info.fCFAPattern [3] [3] = color1; - info.fCFAPattern [3] [4] = color2; - info.fCFAPattern [3] [5] = color1; - - info.fCFAPattern [4] [0] = color2; - info.fCFAPattern [4] [1] = color1; - info.fCFAPattern [4] [2] = color2; - info.fCFAPattern [4] [3] = color0; - info.fCFAPattern [4] [4] = color1; - info.fCFAPattern [4] [5] = color0; - - info.fCFAPattern [5] [0] = color1; - info.fCFAPattern [5] [1] = color0; - info.fCFAPattern [5] [2] = color1; - info.fCFAPattern [5] [3] = color1; - info.fCFAPattern [5] [4] = color2; - info.fCFAPattern [5] [5] = color1; - - DNG_REQUIRE (phase >= 0 && phase < patSize * patSize, - "Bad phase in SetFujiMosaic6x6."); - - if (phase > 0) - { - - dng_mosaic_info temp = info; - - uint32 phaseRow = phase / patSize; - - uint32 phaseCol = phase - (phaseRow * patSize); - - for (uint32 dstRow = 0; dstRow < patSize; dstRow++) - { - - uint32 srcRow = (dstRow + phaseRow) % patSize; - - for (uint32 dstCol = 0; dstCol < patSize; dstCol++) - { - - uint32 srcCol = (dstCol + phaseCol) % patSize; - - temp.fCFAPattern [dstRow] [dstCol] = info.fCFAPattern [srcRow] [srcCol]; - - } - - } - - info = temp; - - } - - info.fColorPlanes = 3; - - info.fCFALayout = 1; - - } - -/******************************************************************************/ - -void dng_negative::SetQuadMosaic (uint32 pattern) - { - - // The pattern of the four colors is assumed to be repeat at least every two - // columns and eight rows. The pattern is encoded as a 32-bit integer, - // with every two bits encoding a color, in scan order for two columns and - // eight rows (lsb is first). The usual color coding is: - // - // 0 = Green - // 1 = Magenta - // 2 = Cyan - // 3 = Yellow - // - // Examples: - // - // PowerShot 600 uses 0xe1e4e1e4: - // - // 0 1 2 3 4 5 - // 0 G M G M G M - // 1 C Y C Y C Y - // 2 M G M G M G - // 3 C Y C Y C Y - // - // PowerShot A5 uses 0x1e4e1e4e: - // - // 0 1 2 3 4 5 - // 0 C Y C Y C Y - // 1 G M G M G M - // 2 C Y C Y C Y - // 3 M G M G M G - // - // PowerShot A50 uses 0x1b4e4b1e: - // - // 0 1 2 3 4 5 - // 0 C Y C Y C Y - // 1 M G M G M G - // 2 Y C Y C Y C - // 3 G M G M G M - // 4 C Y C Y C Y - // 5 G M G M G M - // 6 Y C Y C Y C - // 7 M G M G M G - // - // PowerShot Pro70 uses 0x1e4b4e1b: - // - // 0 1 2 3 4 5 - // 0 Y C Y C Y C - // 1 M G M G M G - // 2 C Y C Y C Y - // 3 G M G M G M - // 4 Y C Y C Y C - // 5 G M G M G M - // 6 C Y C Y C Y - // 7 M G M G M G - // - // PowerShots Pro90 and G1 use 0xb4b4b4b4: - // - // 0 1 2 3 4 5 - // 0 G M G M G M - // 1 Y C Y C Y C - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - if (((pattern >> 16) & 0x0FFFF) != (pattern & 0x0FFFF)) - { - info.fCFAPatternSize = dng_point (8, 2); - } - - else if (((pattern >> 8) & 0x0FF) != (pattern & 0x0FF)) - { - info.fCFAPatternSize = dng_point (4, 2); - } - - else - { - info.fCFAPatternSize = dng_point (2, 2); - } - - for (int32 row = 0; row < info.fCFAPatternSize.v; row++) - { - - for (int32 col = 0; col < info.fCFAPatternSize.h; col++) - { - - uint32 index = (pattern >> ((((row << 1) & 14) + (col & 1)) << 1)) & 3; - - info.fCFAPattern [row] [col] = info.fCFAPlaneColor [index]; - - } - - } - - info.fColorPlanes = 4; - - info.fCFALayout = 1; - - } - -/******************************************************************************/ - -void dng_negative::SetGreenSplit (uint32 split) - { - - NeedMosaicInfo (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - info.fBayerGreenSplit = split; - - } - -/*****************************************************************************/ - -void dng_negative::Parse (dng_host &host, - dng_stream &stream, - dng_info &info) - { - - // Shared info. - - dng_shared &shared = *(info.fShared.Get ()); - - // Find IFD holding the main raw information. - - dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get (); - - // Model name. - - SetModelName (shared.fUniqueCameraModel.Get ()); - - // Localized model name. - - SetLocalName (shared.fLocalizedCameraModel.Get ()); - - // Base orientation. - - { - - uint32 orientation = info.fIFD [0]->fOrientation; - - if (orientation >= 1 && orientation <= 8) - { - - SetBaseOrientation (dng_orientation::TIFFtoDNG (orientation)); - - } - - } - - // Default crop rectangle. - - SetDefaultCropSize (rawIFD.fDefaultCropSizeH, - rawIFD.fDefaultCropSizeV); - - SetDefaultCropOrigin (rawIFD.fDefaultCropOriginH, - rawIFD.fDefaultCropOriginV); - - // Default user crop rectangle. - - SetDefaultUserCrop (rawIFD.fDefaultUserCropT, - rawIFD.fDefaultUserCropL, - rawIFD.fDefaultUserCropB, - rawIFD.fDefaultUserCropR); - - // Default scale. - - SetDefaultScale (rawIFD.fDefaultScaleH, - rawIFD.fDefaultScaleV); - - // Best quality scale. - - SetBestQualityScale (rawIFD.fBestQualityScale); - - // Baseline noise. - - SetBaselineNoise (shared.fBaselineNoise.As_real64 ()); - - // NoiseReductionApplied. - - SetNoiseReductionApplied (shared.fNoiseReductionApplied); - - // NoiseProfile. - - SetNoiseProfile (shared.fNoiseProfile); - - // Baseline exposure. - - SetBaselineExposure (shared.fBaselineExposure.As_real64 ()); - - // Baseline sharpness. - - SetBaselineSharpness (shared.fBaselineSharpness.As_real64 ()); - - // Chroma blur radius. - - SetChromaBlurRadius (rawIFD.fChromaBlurRadius); - - // Anti-alias filter strength. - - SetAntiAliasStrength (rawIFD.fAntiAliasStrength); - - // Linear response limit. - - SetLinearResponseLimit (shared.fLinearResponseLimit.As_real64 ()); - - // Shadow scale. - - SetShadowScale (shared.fShadowScale); - - // Colorimetric reference. - - SetColorimetricReference (shared.fColorimetricReference); - - // Color channels. - - SetColorChannels (shared.fCameraProfile.fColorPlanes); - - // Analog balance. - - if (shared.fAnalogBalance.NotEmpty ()) - { - - SetAnalogBalance (shared.fAnalogBalance); - - } - - // Camera calibration matrices - - if (shared.fCameraCalibration1.NotEmpty ()) - { - - SetCameraCalibration1 (shared.fCameraCalibration1); - - } - - if (shared.fCameraCalibration2.NotEmpty ()) - { - - SetCameraCalibration2 (shared.fCameraCalibration2); - - } - - if (shared.fCameraCalibration1.NotEmpty () || - shared.fCameraCalibration2.NotEmpty ()) - { - - SetCameraCalibrationSignature (shared.fCameraCalibrationSignature.Get ()); - - } - - // Embedded camera profiles. - - if (shared.fCameraProfile.fColorPlanes > 1) - { - - if (qDNGValidate || host.NeedsMeta () || host.NeedsImage ()) - { - - // Add profile from main IFD. - - { - - AutoPtr profile (new dng_camera_profile ()); - - dng_camera_profile_info &profileInfo = shared.fCameraProfile; - - profile->Parse (stream, profileInfo); - - // The main embedded profile must be valid. - - if (!profile->IsValid (shared.fCameraProfile.fColorPlanes)) - { - - ThrowBadFormat (); - - } - - profile->SetWasReadFromDNG (); - - AddProfile (profile); - - } - - // Extra profiles. - - for (uint32 index = 0; index < (uint32) shared.fExtraCameraProfiles.size (); index++) - { - - try - { - - AutoPtr profile (new dng_camera_profile ()); - - dng_camera_profile_info &profileInfo = shared.fExtraCameraProfiles [index]; - - profile->Parse (stream, profileInfo); - - if (!profile->IsValid (shared.fCameraProfile.fColorPlanes)) - { - - ThrowBadFormat (); - - } - - profile->SetWasReadFromDNG (); - - AddProfile (profile); - - } - - catch (dng_exception &except) - { - - // Don't ignore transient errors. - - if (host.IsTransientError (except.ErrorCode ())) - { - - throw; - - } - - // Eat other parsing errors. - - #if qDNGValidate - - ReportWarning ("Unable to parse extra profile"); - - #endif - - } - - } - - } - - // As shot profile name. - - if (shared.fAsShotProfileName.NotEmpty ()) - { - - SetAsShotProfileName (shared.fAsShotProfileName.Get ()); - - } - - } - - // Raw image data digest. - - if (shared.fRawImageDigest.IsValid ()) - { - - SetRawImageDigest (shared.fRawImageDigest); - - } - - // New raw image data digest. - - if (shared.fNewRawImageDigest.IsValid ()) - { - - SetNewRawImageDigest (shared.fNewRawImageDigest); - - } - - // Raw data unique ID. - - if (shared.fRawDataUniqueID.IsValid ()) - { - - SetRawDataUniqueID (shared.fRawDataUniqueID); - - } - - // Original raw file name. - - if (shared.fOriginalRawFileName.NotEmpty ()) - { - - SetOriginalRawFileName (shared.fOriginalRawFileName.Get ()); - - } - - // Original raw file data. - - if (shared.fOriginalRawFileDataCount) - { - - SetHasOriginalRawFileData (true); - - if (host.KeepOriginalFile ()) - { - - uint32 count = shared.fOriginalRawFileDataCount; - - AutoPtr block (host.Allocate (count)); - - stream.SetReadPosition (shared.fOriginalRawFileDataOffset); - - stream.Get (block->Buffer (), count); - - SetOriginalRawFileData (block); - - SetOriginalRawFileDigest (shared.fOriginalRawFileDigest); - - ValidateOriginalRawFileDigest (); - - } - - } - - // DNG private data. - - if (shared.fDNGPrivateDataCount && (host.SaveDNGVersion () != dngVersion_None)) - { - - uint32 length = shared.fDNGPrivateDataCount; - - AutoPtr block (host.Allocate (length)); - - stream.SetReadPosition (shared.fDNGPrivateDataOffset); - - stream.Get (block->Buffer (), length); - - SetPrivateData (block); - - } - - // Hand off EXIF metadata to negative. - - ResetExif (info.fExif.Release ()); - - // Parse linearization info. - - NeedLinearizationInfo (); - - fLinearizationInfo.Get ()->Parse (host, - stream, - info); - - // Parse mosaic info. - - if (rawIFD.fPhotometricInterpretation == piCFA) - { - - NeedMosaicInfo (); - - fMosaicInfo.Get ()->Parse (host, - stream, - info); - - } - - // Fill in original sizes. - - if (shared.fOriginalDefaultFinalSize.h > 0 && - shared.fOriginalDefaultFinalSize.v > 0) - { - - SetOriginalDefaultFinalSize (shared.fOriginalDefaultFinalSize); - - SetOriginalBestQualityFinalSize (shared.fOriginalDefaultFinalSize); - - SetOriginalDefaultCropSize (dng_urational (shared.fOriginalDefaultFinalSize.h, 1), - dng_urational (shared.fOriginalDefaultFinalSize.v, 1)); - - } - - if (shared.fOriginalBestQualityFinalSize.h > 0 && - shared.fOriginalBestQualityFinalSize.v > 0) - { - - SetOriginalBestQualityFinalSize (shared.fOriginalBestQualityFinalSize); - - } - - if (shared.fOriginalDefaultCropSizeH.As_real64 () >= 1.0 && - shared.fOriginalDefaultCropSizeV.As_real64 () >= 1.0) - { - - SetOriginalDefaultCropSize (shared.fOriginalDefaultCropSizeH, - shared.fOriginalDefaultCropSizeV); - - } - - } - -/*****************************************************************************/ - -void dng_negative::SetDefaultOriginalSizes () - { - - // Fill in original sizes if we don't have them already. - - if (OriginalDefaultFinalSize () == dng_point ()) - { - - SetOriginalDefaultFinalSize (dng_point (DefaultFinalHeight (), - DefaultFinalWidth ())); - - } - - if (OriginalBestQualityFinalSize () == dng_point ()) - { - - SetOriginalBestQualityFinalSize (dng_point (BestQualityFinalHeight (), - BestQualityFinalWidth ())); - - } - - if (OriginalDefaultCropSizeH ().NotValid () || - OriginalDefaultCropSizeV ().NotValid ()) - { - - SetOriginalDefaultCropSize (DefaultCropSizeH (), - DefaultCropSizeV ()); - - } - - } - -/*****************************************************************************/ - -void dng_negative::PostParse (dng_host &host, - dng_stream &stream, - dng_info &info) - { - - // Shared info. - - dng_shared &shared = *(info.fShared.Get ()); - - if (host.NeedsMeta ()) - { - - // Fill in original sizes if we don't have them already. - - SetDefaultOriginalSizes (); - - // MakerNote. - - if (shared.fMakerNoteCount) - { - - // See if we know if the MakerNote is safe or not. - - SetMakerNoteSafety (shared.fMakerNoteSafety == 1); - - // If the MakerNote is safe, preserve it as a MakerNote. - - if (IsMakerNoteSafe ()) - { - - AutoPtr block (host.Allocate (shared.fMakerNoteCount)); - - stream.SetReadPosition (shared.fMakerNoteOffset); - - stream.Get (block->Buffer (), shared.fMakerNoteCount); - - SetMakerNote (block); - - } - - } - - // IPTC metadata. - - if (shared.fIPTC_NAA_Count) - { - - AutoPtr block (host.Allocate (shared.fIPTC_NAA_Count)); - - stream.SetReadPosition (shared.fIPTC_NAA_Offset); - - uint64 iptcOffset = stream.PositionInOriginalFile(); - - stream.Get (block->Buffer (), - block->LogicalSize ()); - - SetIPTC (block, iptcOffset); - - } - - // XMP metadata. - - if (shared.fXMPCount) - { - - AutoPtr block (host.Allocate (shared.fXMPCount)); - - stream.SetReadPosition (shared.fXMPOffset); - - stream.Get (block->Buffer (), - block->LogicalSize ()); - - Metadata ().SetEmbeddedXMP (host, - block->Buffer (), - block->LogicalSize ()); - - #if qDNGValidate - - if (!Metadata ().HaveValidEmbeddedXMP ()) - { - ReportError ("The embedded XMP is invalid"); - } - - #endif - - } - - // Color info. - - if (!IsMonochrome ()) - { - - // If the ColorimetricReference is the ICC profile PCS, - // then the data must be already be white balanced to the - // ICC profile PCS white point. - - if (ColorimetricReference () == crICCProfilePCS) - { - - ClearCameraNeutral (); - - SetCameraWhiteXY (PCStoXY ()); - - } - - else - { - - // AsShotNeutral. - - if (shared.fAsShotNeutral.Count () == ColorChannels ()) - { - - SetCameraNeutral (shared.fAsShotNeutral); - - } - - // AsShotWhiteXY. - - if (shared.fAsShotWhiteXY.IsValid () && !HasCameraNeutral ()) - { - - SetCameraWhiteXY (shared.fAsShotWhiteXY); - - } - - } - - } - - } - - } - -/*****************************************************************************/ - -bool dng_negative::SetFourColorBayer () - { - - if (ColorChannels () != 3) - { - return false; - } - - if (!fMosaicInfo.Get ()) - { - return false; - } - - if (!fMosaicInfo.Get ()->SetFourColorBayer ()) - { - return false; - } - - SetColorChannels (4); - - if (fCameraNeutral.Count () == 3) - { - - dng_vector n (4); - - n [0] = fCameraNeutral [0]; - n [1] = fCameraNeutral [1]; - n [2] = fCameraNeutral [2]; - n [3] = fCameraNeutral [1]; - - fCameraNeutral = n; - - } - - fCameraCalibration1.Clear (); - fCameraCalibration2.Clear (); - - fCameraCalibrationSignature.Clear (); - - for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++) - { - - fCameraProfile [index]->SetFourColorBayer (); - - } - - return true; - - } - -/*****************************************************************************/ - -const dng_image & dng_negative::RawImage () const - { - - if (fRawImage.Get ()) - { - return *fRawImage.Get (); - } - - if (fStage1Image.Get ()) - { - return *fStage1Image.Get (); - } - - if (fUnflattenedStage3Image.Get ()) - { - return *fUnflattenedStage3Image.Get (); - } - - DNG_ASSERT (fStage3Image.Get (), - "dng_negative::RawImage with no raw image"); - - return *fStage3Image.Get (); - - } - -/*****************************************************************************/ - -const dng_jpeg_image * dng_negative::RawJPEGImage () const - { - - return fRawJPEGImage.Get (); - - } - -/*****************************************************************************/ - -void dng_negative::SetRawJPEGImage (AutoPtr &jpegImage) - { - - fRawJPEGImage.Reset (jpegImage.Release ()); - - } - -/*****************************************************************************/ - -void dng_negative::ClearRawJPEGImage () - { - - fRawJPEGImage.Reset (); - - } - -/*****************************************************************************/ - -void dng_negative::FindRawJPEGImageDigest (dng_host &host) const - { - - if (fRawJPEGImageDigest.IsNull ()) - { - - if (fRawJPEGImage.Get ()) - { - - #if qDNGValidate - - dng_timer timer ("FindRawJPEGImageDigest time"); - - #endif - - fRawJPEGImageDigest = fRawJPEGImage->FindDigest (host); - - } - - else - { - - ThrowProgramError ("No raw JPEG image"); - - } - - } - - } - -/*****************************************************************************/ - -void dng_negative::ReadStage1Image (dng_host &host, - dng_stream &stream, - dng_info &info) - { - - // Allocate image we are reading. - - dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get (); - - fStage1Image.Reset (host.Make_dng_image (rawIFD.Bounds (), - rawIFD.fSamplesPerPixel, - rawIFD.PixelType ())); - - // See if we should grab the compressed JPEG data. - - AutoPtr jpegImage; - - if (host.SaveDNGVersion () >= dngVersion_1_4_0_0 && - !host.PreferredSize () && - !host.ForPreview () && - rawIFD.fCompression == ccLossyJPEG) - { - - jpegImage.Reset (new dng_jpeg_image); - - } - - // See if we need to compute the digest of the compressed JPEG data - // while reading. - - bool needJPEGDigest = (RawImageDigest ().IsValid () || - NewRawImageDigest ().IsValid ()) && - rawIFD.fCompression == ccLossyJPEG && - jpegImage.Get () == NULL; - - dng_fingerprint jpegDigest; - - // Read the image. - - rawIFD.ReadImage (host, - stream, - *fStage1Image.Get (), - jpegImage.Get (), - needJPEGDigest ? &jpegDigest : NULL); - - // Remember the raw floating point bit depth, if reading from - // a floating point image. - - if (fStage1Image->PixelType () == ttFloat) - { - - SetRawFloatBitDepth (rawIFD.fBitsPerSample [0]); - - } - - // Remember the compressed JPEG data if we read it. - - if (jpegImage.Get ()) - { - - SetRawJPEGImage (jpegImage); - - } - - // Remember the compressed JPEG digest if we computed it. - - if (jpegDigest.IsValid ()) - { - - SetRawJPEGImageDigest (jpegDigest); - - } - - // We are are reading the main image, we should read the opcode lists - // also. - - if (rawIFD.fOpcodeList1Count) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("\nParsing OpcodeList1: "); - } - - #endif - - fOpcodeList1.Parse (host, - stream, - rawIFD.fOpcodeList1Count, - rawIFD.fOpcodeList1Offset); - - } - - if (rawIFD.fOpcodeList2Count) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("\nParsing OpcodeList2: "); - } - - #endif - - fOpcodeList2.Parse (host, - stream, - rawIFD.fOpcodeList2Count, - rawIFD.fOpcodeList2Offset); - - } - - if (rawIFD.fOpcodeList3Count) - { - - #if qDNGValidate - - if (gVerbose) - { - printf ("\nParsing OpcodeList3: "); - } - - #endif - - fOpcodeList3.Parse (host, - stream, - rawIFD.fOpcodeList3Count, - rawIFD.fOpcodeList3Offset); - - } - - } - -/*****************************************************************************/ - -void dng_negative::SetStage1Image (AutoPtr &image) - { - - fStage1Image.Reset (image.Release ()); - - } - -/*****************************************************************************/ - -void dng_negative::SetStage2Image (AutoPtr &image) - { - - fStage2Image.Reset (image.Release ()); - - } - -/*****************************************************************************/ - -void dng_negative::SetStage3Image (AutoPtr &image) - { - - fStage3Image.Reset (image.Release ()); - - } - -/*****************************************************************************/ - -void dng_negative::DoBuildStage2 (dng_host &host) - { - - dng_image &stage1 = *fStage1Image.Get (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - uint32 pixelType = ttShort; - - if (stage1.PixelType () == ttLong || - stage1.PixelType () == ttFloat) - { - - pixelType = ttFloat; - - } - - fStage2Image.Reset (host.Make_dng_image (info.fActiveArea.Size (), - stage1.Planes (), - pixelType)); - - info.Linearize (host, - stage1, - *fStage2Image.Get ()); - - } - -/*****************************************************************************/ - -void dng_negative::DoPostOpcodeList2 (dng_host & /* host */) - { - - // Nothing by default. - - } - -/*****************************************************************************/ - -bool dng_negative::NeedDefloatStage2 (dng_host &host) - { - - if (fStage2Image->PixelType () == ttFloat) - { - - if (fRawImageStage >= rawImageStagePostOpcode2 && - host.SaveDNGVersion () != dngVersion_None && - host.SaveDNGVersion () < dngVersion_1_4_0_0) - { - - return true; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_negative::DefloatStage2 (dng_host & /* host */) - { - - ThrowNotYetImplemented ("dng_negative::DefloatStage2"); - - } - -/*****************************************************************************/ - -void dng_negative::BuildStage2Image (dng_host &host) - { - - // If reading the negative to save in DNG format, figure out - // when to grab a copy of the raw data. - - if (host.SaveDNGVersion () != dngVersion_None) - { - - // Transparency masks are only supported in DNG version 1.4 and - // later. In this case, the flattening of the transparency mask happens - // on the the stage3 image. - - if (TransparencyMask () && host.SaveDNGVersion () < dngVersion_1_4_0_0) - { - fRawImageStage = rawImageStagePostOpcode3; - } - - else if (fOpcodeList3.MinVersion (false) > host.SaveDNGVersion () || - fOpcodeList3.AlwaysApply ()) - { - fRawImageStage = rawImageStagePostOpcode3; - } - - else if (host.SaveLinearDNG (*this)) - { - - // If the opcode list 3 has optional tags that are beyond the - // the minimum version, and we are saving a linear DNG anyway, - // then go ahead and apply them. - - if (fOpcodeList3.MinVersion (true) > host.SaveDNGVersion ()) - { - fRawImageStage = rawImageStagePostOpcode3; - } - - else - { - fRawImageStage = rawImageStagePreOpcode3; - } - - } - - else if (fOpcodeList2.MinVersion (false) > host.SaveDNGVersion () || - fOpcodeList2.AlwaysApply ()) - { - fRawImageStage = rawImageStagePostOpcode2; - } - - else if (fOpcodeList1.MinVersion (false) > host.SaveDNGVersion () || - fOpcodeList1.AlwaysApply ()) - { - fRawImageStage = rawImageStagePostOpcode1; - } - - else - { - fRawImageStage = rawImageStagePreOpcode1; - } - - // We should not save floating point stage1 images unless the target - // DNG version is high enough to understand floating point images. - // We handle this by converting from floating point to integer if - // required after building stage2 image. - - if (fStage1Image->PixelType () == ttFloat) - { - - if (fRawImageStage < rawImageStagePostOpcode2) - { - - if (host.SaveDNGVersion () < dngVersion_1_4_0_0) - { - - fRawImageStage = rawImageStagePostOpcode2; - - } - - } - - } - - } - - // Grab clone of raw image if required. - - if (fRawImageStage == rawImageStagePreOpcode1) - { - - fRawImage.Reset (fStage1Image->Clone ()); - - if (fTransparencyMask.Get ()) - { - fRawTransparencyMask.Reset (fTransparencyMask->Clone ()); - } - - } - - else - { - - // If we are not keeping the most raw image, we need - // to recompute the raw image digest. - - ClearRawImageDigest (); - - // If we don't grab the unprocessed stage 1 image, then - // the raw JPEG image is no longer valid. - - ClearRawJPEGImage (); - - // Nor is the digest of the raw JPEG data. - - ClearRawJPEGImageDigest (); - - // We also don't know the raw floating point bit depth. - - SetRawFloatBitDepth (0); - - } - - // Process opcode list 1. - - host.ApplyOpcodeList (fOpcodeList1, *this, fStage1Image); - - // See if we are done with the opcode list 1. - - if (fRawImageStage > rawImageStagePreOpcode1) - { - - fOpcodeList1.Clear (); - - } - - // Grab clone of raw image if required. - - if (fRawImageStage == rawImageStagePostOpcode1) - { - - fRawImage.Reset (fStage1Image->Clone ()); - - if (fTransparencyMask.Get ()) - { - fRawTransparencyMask.Reset (fTransparencyMask->Clone ()); - } - - } - - // Finalize linearization info. - - { - - NeedLinearizationInfo (); - - dng_linearization_info &info = *fLinearizationInfo.Get (); - - info.PostParse (host, *this); - - } - - // Perform the linearization. - - DoBuildStage2 (host); - - // Delete the stage1 image now that we have computed the stage 2 image. - - fStage1Image.Reset (); - - // Are we done with the linearization info. - - if (fRawImageStage > rawImageStagePostOpcode1) - { - - ClearLinearizationInfo (); - - } - - // Process opcode list 2. - - host.ApplyOpcodeList (fOpcodeList2, *this, fStage2Image); - - // See if we are done with the opcode list 2. - - if (fRawImageStage > rawImageStagePostOpcode1) - { - - fOpcodeList2.Clear (); - - } - - // Hook for any required processing just after opcode list 2. - - DoPostOpcodeList2 (host); - - // Convert from floating point to integer if required. - - if (NeedDefloatStage2 (host)) - { - - DefloatStage2 (host); - - } - - // Grab clone of raw image if required. - - if (fRawImageStage == rawImageStagePostOpcode2) - { - - fRawImage.Reset (fStage2Image->Clone ()); - - if (fTransparencyMask.Get ()) - { - fRawTransparencyMask.Reset (fTransparencyMask->Clone ()); - } - - } - - } - -/*****************************************************************************/ - -void dng_negative::DoInterpolateStage3 (dng_host &host, - int32 srcPlane) - { - - dng_image &stage2 = *fStage2Image.Get (); - - dng_mosaic_info &info = *fMosaicInfo.Get (); - - dng_point downScale = info.DownScale (host.MinimumSize (), - host.PreferredSize (), - host.CropFactor ()); - - if (downScale != dng_point (1, 1)) - { - SetIsPreview (true); - } - - dng_point dstSize = info.DstSize (downScale); - - fStage3Image.Reset (host.Make_dng_image (dng_rect (dstSize), - info.fColorPlanes, - stage2.PixelType ())); - - if (srcPlane < 0 || srcPlane >= (int32) stage2.Planes ()) - { - srcPlane = 0; - } - - info.Interpolate (host, - *this, - stage2, - *fStage3Image.Get (), - downScale, - srcPlane); - - } - -/*****************************************************************************/ - -// Interpolate and merge a multi-channel CFA image. - -void dng_negative::DoMergeStage3 (dng_host &host) - { - - // The DNG SDK does not provide multi-channel CFA image merging code. - // It just grabs the first channel and uses that. - - DoInterpolateStage3 (host, 0); - - // Just grabbing the first channel would often result in the very - // bright image using the baseline exposure value. - - fStage3Gain = pow (2.0, BaselineExposure ()); - - } - -/*****************************************************************************/ - -void dng_negative::DoBuildStage3 (dng_host &host, - int32 srcPlane) - { - - // If we don't have a mosaic pattern, then just move the stage 2 - // image on to stage 3. - - dng_mosaic_info *info = fMosaicInfo.Get (); - - if (!info || !info->IsColorFilterArray ()) - { - - fStage3Image.Reset (fStage2Image.Release ()); - - } - - else - { - - // Remember the size of the stage 2 image. - - dng_point stage2_size = fStage2Image->Size (); - - // Special case multi-channel CFA interpolation. - - if ((fStage2Image->Planes () > 1) && (srcPlane < 0)) - { - - DoMergeStage3 (host); - - } - - // Else do a single channel interpolation. - - else - { - - DoInterpolateStage3 (host, srcPlane); - - } - - // Calculate the ratio of the stage 3 image size to stage 2 image size. - - dng_point stage3_size = fStage3Image->Size (); - - fRawToFullScaleH = (real64) stage3_size.h / (real64) stage2_size.h; - fRawToFullScaleV = (real64) stage3_size.v / (real64) stage2_size.v; - - } - - } - -/*****************************************************************************/ - -void dng_negative::BuildStage3Image (dng_host &host, - int32 srcPlane) - { - - // Finalize the mosaic information. - - dng_mosaic_info *info = fMosaicInfo.Get (); - - if (info) - { - - info->PostParse (host, *this); - - } - - // Do the interpolation as required. - - DoBuildStage3 (host, srcPlane); - - // Delete the stage2 image now that we have computed the stage 3 image. - - fStage2Image.Reset (); - - // Are we done with the mosaic info? - - if (fRawImageStage >= rawImageStagePreOpcode3) - { - - ClearMosaicInfo (); - - // To support saving linear DNG files, to need to account for - // and upscaling during interpolation. - - if (fRawToFullScaleH > 1.0) - { - - uint32 adjust = Round_uint32 (fRawToFullScaleH); - - fDefaultCropSizeH .n *= adjust; - fDefaultCropOriginH.n *= adjust; - fDefaultScaleH .d *= adjust; - - fRawToFullScaleH /= (real64) adjust; - - } - - if (fRawToFullScaleV > 1.0) - { - - uint32 adjust = Round_uint32 (fRawToFullScaleV); - - fDefaultCropSizeV .n *= adjust; - fDefaultCropOriginV.n *= adjust; - fDefaultScaleV .d *= adjust; - - fRawToFullScaleV /= (real64) adjust; - - } - - } - - // Resample the transparency mask if required. - - ResizeTransparencyToMatchStage3 (host); - - // Grab clone of raw image if required. - - if (fRawImageStage == rawImageStagePreOpcode3) - { - - fRawImage.Reset (fStage3Image->Clone ()); - - if (fTransparencyMask.Get ()) - { - fRawTransparencyMask.Reset (fTransparencyMask->Clone ()); - } - - } - - // Process opcode list 3. - - host.ApplyOpcodeList (fOpcodeList3, *this, fStage3Image); - - // See if we are done with the opcode list 3. - - if (fRawImageStage > rawImageStagePreOpcode3) - { - - fOpcodeList3.Clear (); - - } - - // Just in case the opcode list 3 changed the image size, resample the - // transparency mask again if required. This is nearly always going - // to be a fast NOP operation. - - ResizeTransparencyToMatchStage3 (host); - - // Don't need to grab a copy of raw data at this stage since - // it is kept around as the stage 3 image. - - } - -/******************************************************************************/ - -class dng_gamma_encode_proxy : public dng_1d_function - { - - private: - - real64 fBlack; - real64 fWhite; - - bool fIsSceneReferred; - - real64 scale; - real64 t1; - - public: - - dng_gamma_encode_proxy (real64 black, - real64 white, - bool isSceneReferred) - - : fBlack (black) - , fWhite (white) - , fIsSceneReferred (isSceneReferred) - - , scale (1.0 / (fWhite - fBlack)) - , t1 (1.0 / (27.0 * pow (5.0, 3.0 / 2.0))) - - { - } - - virtual real64 Evaluate (real64 x) const - { - - x = Pin_real64 (0.0, (x - fBlack) * scale, 1.0); - - real64 y; - - if (fIsSceneReferred) - { - - real64 t = pow (sqrt (25920.0 * x * x + 1.0) * t1 + x * (8.0 / 15.0), 1.0 / 3.0); - - y = t - 1.0 / (45.0 * t); - - DNG_ASSERT (Abs_real64 (x - (y / 16.0 + y * y * y * 15.0 / 16.0)) < 0.0000001, - "Round trip error"); - - } - - else - { - - y = (sqrt (960.0 * x + 1.0) - 1.0) / 30.0; - - DNG_ASSERT (Abs_real64 (x - (y / 16.0 + y * y * (15.0 / 16.0))) < 0.0000001, - "Round trip error"); - - } - - return y; - - } - - }; - -/*****************************************************************************/ - -class dng_encode_proxy_task: public dng_area_task - { - - private: - - const dng_image &fSrcImage; - - dng_image &fDstImage; - - AutoPtr fTable16 [kMaxColorPlanes]; - - public: - - dng_encode_proxy_task (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - const real64 *black, - const real64 *white, - bool isSceneReferred); - - virtual dng_rect RepeatingTile1 () const - { - return fSrcImage.RepeatingTile (); - } - - virtual dng_rect RepeatingTile2 () const - { - return fDstImage.RepeatingTile (); - } - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer *sniffer); - - private: - - // Hidden copy constructor and assignment operator. - - dng_encode_proxy_task (const dng_encode_proxy_task &task); - - dng_encode_proxy_task & operator= (const dng_encode_proxy_task &task); - - }; - -/*****************************************************************************/ - -dng_encode_proxy_task::dng_encode_proxy_task (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - const real64 *black, - const real64 *white, - bool isSceneReferred) - - : fSrcImage (srcImage) - , fDstImage (dstImage) - - { - - for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++) - { - - dng_gamma_encode_proxy gamma (black [plane], - white [plane], - isSceneReferred); - - dng_1d_table table32; - - table32.Initialize (host.Allocator (), gamma); - - fTable16 [plane] . Reset (host.Allocate (0x10000 * sizeof (uint16))); - - table32.Expand16 (fTable16 [plane]->Buffer_uint16 ()); - - } - - } - -/*****************************************************************************/ - -void dng_encode_proxy_task::Process (uint32 /* threadIndex */, - const dng_rect &tile, - dng_abort_sniffer * /* sniffer */) - { - - dng_const_tile_buffer srcBuffer (fSrcImage, tile); - dng_dirty_tile_buffer dstBuffer (fDstImage, tile); - - int32 sColStep = srcBuffer.fColStep; - int32 dColStep = dstBuffer.fColStep; - - const uint16 *noise = dng_dither::Get ().NoiseBuffer16 (); - - for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++) - { - - const uint16 *map = fTable16 [plane]->Buffer_uint16 (); - - for (int32 row = tile.t; row < tile.b; row++) - { - - const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (row, tile.l, plane); - - uint8 *dPtr = dstBuffer.DirtyPixel_uint8 (row, tile.l, plane); - - const uint16 *rPtr = &noise [(row & dng_dither::kRNGMask) * dng_dither::kRNGSize]; - - for (int32 col = tile.l; col < tile.r; col++) - { - - uint32 x = *sPtr; - - uint32 r = rPtr [col & dng_dither::kRNGMask]; - - x = map [x]; - - x = (((x << 8) - x) + r) >> 16; - - *dPtr = (uint8) x; - - sPtr += sColStep; - dPtr += dColStep; - - } - - } - - } - - } - -/******************************************************************************/ - -dng_image * dng_negative::EncodeRawProxy (dng_host &host, - const dng_image &srcImage, - dng_opcode_list &opcodeList) const - { - - if (srcImage.PixelType () != ttShort) - { - return NULL; - } - - real64 black [kMaxColorPlanes]; - real64 white [kMaxColorPlanes]; - - bool isSceneReferred = (ColorimetricReference () == crSceneReferred); - - { - - const real64 kClipFraction = 0.00001; - - uint64 pixels = (uint64) srcImage.Bounds ().H () * - (uint64) srcImage.Bounds ().W (); - - uint32 limit = Round_int32 ((real64) pixels * kClipFraction); - - AutoPtr histData (host.Allocate (65536 * sizeof (uint32))); - - uint32 *hist = histData->Buffer_uint32 (); - - for (uint32 plane = 0; plane < srcImage.Planes (); plane++) - { - - HistogramArea (host, - srcImage, - srcImage.Bounds (), - hist, - 65535, - plane); - - uint32 total = 0; - - uint32 upper = 65535; - - while (total + hist [upper] <= limit && upper > 255) - { - - total += hist [upper]; - - upper--; - - } - - total = 0; - - uint32 lower = 0; - - while (total + hist [lower] <= limit && lower < upper - 255) - { - - total += hist [lower]; - - lower++; - - } - - black [plane] = lower / 65535.0; - white [plane] = upper / 65535.0; - - } - - } - - // Apply the gamma encoding, using dither when downsampling to 8-bit. - - AutoPtr dstImage (host.Make_dng_image (srcImage.Bounds (), - srcImage.Planes (), - ttByte)); - - { - - dng_encode_proxy_task task (host, - srcImage, - *dstImage, - black, - white, - isSceneReferred); - - host.PerformAreaTask (task, - srcImage.Bounds ()); - - } - - // Add opcodes to undo the gamma encoding. - - { - - for (uint32 plane = 0; plane < srcImage.Planes (); plane++) - { - - dng_area_spec areaSpec (srcImage.Bounds (), - plane); - - real64 coefficient [4]; - - coefficient [0] = 0.0; - coefficient [1] = 1.0 / 16.0; - - if (isSceneReferred) - { - coefficient [2] = 0.0; - coefficient [3] = 15.0 / 16.0; - } - else - { - coefficient [2] = 15.0 / 16.0; - coefficient [3] = 0.0; - } - - coefficient [0] *= white [plane] - black [plane]; - coefficient [1] *= white [plane] - black [plane]; - coefficient [2] *= white [plane] - black [plane]; - coefficient [3] *= white [plane] - black [plane]; - - coefficient [0] += black [plane]; - - AutoPtr opcode (new dng_opcode_MapPolynomial (areaSpec, - isSceneReferred ? 3 : 2, - coefficient)); - - opcodeList.Append (opcode); - - } - - } - - return dstImage.Release (); - - } - -/******************************************************************************/ - -void dng_negative::AdjustProfileForStage3 () - { - - // For dng_sdk, the stage3 image's color space is always the same as the - // raw image's color space. - - } - -/******************************************************************************/ - -void dng_negative::ConvertToProxy (dng_host &host, - dng_image_writer &writer, - uint32 proxySize, - uint64 proxyCount) - { - - if (!proxySize) - { - proxySize = kMaxImageSide; - } - - if (!proxyCount) - { - proxyCount = (uint64) proxySize * proxySize; - } - - // Don't need to private data around in non-full size proxies. - - if (proxySize < kMaxImageSide || - proxyCount < kMaxImageSide * kMaxImageSide) - { - - ClearMakerNote (); - - ClearPrivateData (); - - } - - // See if we already have an acceptable proxy image. - - if (fRawImage.Get () && - fRawImage->PixelType () == ttByte && - fRawImage->Bounds () == DefaultCropArea () && - fRawImage->Bounds ().H () <= proxySize && - fRawImage->Bounds ().W () <= proxySize && - (uint64) fRawImage->Bounds ().H () * - (uint64) fRawImage->Bounds ().W () <= proxyCount && - (!GetMosaicInfo () || !GetMosaicInfo ()->IsColorFilterArray ()) && - fRawJPEGImage.Get () && - (!RawTransparencyMask () || RawTransparencyMask ()->PixelType () == ttByte)) - { - - return; - - } - - if (fRawImage.Get () && - fRawImage->PixelType () == ttFloat && - fRawImage->Bounds ().H () <= proxySize && - fRawImage->Bounds ().W () <= proxySize && - (uint64) fRawImage->Bounds ().H () * - (uint64) fRawImage->Bounds ().W () <= proxyCount && - RawFloatBitDepth () == 16 && - (!RawTransparencyMask () || RawTransparencyMask ()->PixelType () == ttByte)) - { - - return; - - } - - // Clear any grabbed raw image, since we are going to start - // building the proxy with the stage3 image. - - fRawImage.Reset (); - - ClearRawJPEGImage (); - - SetRawFloatBitDepth (0); - - ClearLinearizationInfo (); - - ClearMosaicInfo (); - - fOpcodeList1.Clear (); - fOpcodeList2.Clear (); - fOpcodeList3.Clear (); - - // Adjust the profile to match the stage 3 image, if required. - - AdjustProfileForStage3 (); - - // Not saving the raw-most image, do the old raw digest is no - // longer valid. - - ClearRawImageDigest (); - - ClearRawJPEGImageDigest (); - - // Trim off extra pixels outside the default crop area. - - dng_rect defaultCropArea = DefaultCropArea (); - - if (Stage3Image ()->Bounds () != defaultCropArea) - { - - fStage3Image->Trim (defaultCropArea); - - if (fTransparencyMask.Get ()) - { - fTransparencyMask->Trim (defaultCropArea); - } - - fDefaultCropOriginH = dng_urational (0, 1); - fDefaultCropOriginV = dng_urational (0, 1); - - } - - // Figure out the requested proxy pixel size. - - real64 aspectRatio = AspectRatio (); - - dng_point newSize (proxySize, proxySize); - - if (aspectRatio >= 1.0) - { - newSize.v = Max_int32 (1, Round_int32 (proxySize / aspectRatio)); - } - else - { - newSize.h = Max_int32 (1, Round_int32 (proxySize * aspectRatio)); - } - - newSize.v = Min_int32 (newSize.v, DefaultFinalHeight ()); - newSize.h = Min_int32 (newSize.h, DefaultFinalWidth ()); - - if ((uint64) newSize.v * - (uint64) newSize.h > proxyCount) - { - - if (aspectRatio >= 1.0) - { - - newSize.h = (uint32) sqrt (proxyCount * aspectRatio); - - newSize.v = Max_int32 (1, Round_int32 (newSize.h / aspectRatio)); - - } - - else - { - - newSize.v = (uint32) sqrt (proxyCount / aspectRatio); - - newSize.h = Max_int32 (1, Round_int32 (newSize.v * aspectRatio)); - - } - - } - - // If this is fewer pixels, downsample the stage 3 image to that size. - - dng_point oldSize = defaultCropArea.Size (); - - if ((uint64) newSize.v * (uint64) newSize.h < - (uint64) oldSize.v * (uint64) oldSize.h) - { - - const dng_image &srcImage (*Stage3Image ()); - - AutoPtr dstImage (host.Make_dng_image (newSize, - srcImage.Planes (), - srcImage.PixelType ())); - - host.ResampleImage (srcImage, - *dstImage); - - fStage3Image.Reset (dstImage.Release ()); - - fDefaultCropSizeH = dng_urational (newSize.h, 1); - fDefaultCropSizeV = dng_urational (newSize.v, 1); - - fDefaultScaleH = dng_urational (1, 1); - fDefaultScaleV = dng_urational (1, 1); - - fBestQualityScale = dng_urational (1, 1); - - fRawToFullScaleH = 1.0; - fRawToFullScaleV = 1.0; - - } - - // Convert 32-bit floating point images to 16-bit floating point to - // save space. - - if (Stage3Image ()->PixelType () == ttFloat) - { - - fRawImage.Reset (host.Make_dng_image (Stage3Image ()->Bounds (), - Stage3Image ()->Planes (), - ttFloat)); - - LimitFloatBitDepth (host, - *Stage3Image (), - *fRawImage, - 16, - 32768.0f); - - SetRawFloatBitDepth (16); - - SetWhiteLevel (32768); - - } - - else - { - - // Convert 16-bit deep images to 8-bit deep image for saving. - - fRawImage.Reset (EncodeRawProxy (host, - *Stage3Image (), - fOpcodeList2)); - - if (fRawImage.Get ()) - { - - SetWhiteLevel (255); - - // Compute JPEG compressed version. - - if (fRawImage->PixelType () == ttByte && - host.SaveDNGVersion () >= dngVersion_1_4_0_0) - { - - AutoPtr jpegImage (new dng_jpeg_image); - - jpegImage->Encode (host, - *this, - writer, - *fRawImage); - - SetRawJPEGImage (jpegImage); - - } - - } - - } - - // Deal with transparency mask. - - if (TransparencyMask ()) - { - - const bool convertTo8Bit = true; - - ResizeTransparencyToMatchStage3 (host, convertTo8Bit); - - fRawTransparencyMask.Reset (fTransparencyMask->Clone ()); - - } - - // Recompute the raw data unique ID, since we changed the image data. - - RecomputeRawDataUniqueID (host); - - } - -/*****************************************************************************/ - -dng_linearization_info * dng_negative::MakeLinearizationInfo () - { - - dng_linearization_info *info = new dng_linearization_info (); - - if (!info) - { - ThrowMemoryFull (); - } - - return info; - - } - -/*****************************************************************************/ - -void dng_negative::NeedLinearizationInfo () - { - - if (!fLinearizationInfo.Get ()) - { - - fLinearizationInfo.Reset (MakeLinearizationInfo ()); - - } - - } - -/*****************************************************************************/ - -dng_mosaic_info * dng_negative::MakeMosaicInfo () - { - - dng_mosaic_info *info = new dng_mosaic_info (); - - if (!info) - { - ThrowMemoryFull (); - } - - return info; - - } - -/*****************************************************************************/ - -void dng_negative::NeedMosaicInfo () - { - - if (!fMosaicInfo.Get ()) - { - - fMosaicInfo.Reset (MakeMosaicInfo ()); - - } - - } - -/*****************************************************************************/ - -void dng_negative::SetTransparencyMask (AutoPtr &image, - uint32 bitDepth) - { - - fTransparencyMask.Reset (image.Release ()); - - fRawTransparencyMaskBitDepth = bitDepth; - - } - -/*****************************************************************************/ - -const dng_image * dng_negative::TransparencyMask () const - { - - return fTransparencyMask.Get (); - - } - -/*****************************************************************************/ - -const dng_image * dng_negative::RawTransparencyMask () const - { - - if (fRawTransparencyMask.Get ()) - { - - return fRawTransparencyMask.Get (); - - } - - return TransparencyMask (); - - } - -/*****************************************************************************/ - -uint32 dng_negative::RawTransparencyMaskBitDepth () const - { - - if (fRawTransparencyMaskBitDepth) - { - - return fRawTransparencyMaskBitDepth; - - } - - const dng_image *mask = RawTransparencyMask (); - - if (mask) - { - - switch (mask->PixelType ()) - { - - case ttByte: - return 8; - - case ttShort: - return 16; - - case ttFloat: - return 32; - - default: - ThrowProgramError (); - - } - - } - - return 0; - - } - -/*****************************************************************************/ - -void dng_negative::ReadTransparencyMask (dng_host &host, - dng_stream &stream, - dng_info &info) - { - - if (info.fMaskIndex != -1) - { - - // Allocate image we are reading. - - dng_ifd &maskIFD = *info.fIFD [info.fMaskIndex].Get (); - - fTransparencyMask.Reset (host.Make_dng_image (maskIFD.Bounds (), - 1, - maskIFD.PixelType ())); - - // Read the image. - - maskIFD.ReadImage (host, - stream, - *fTransparencyMask.Get ()); - - // Remember the pixel depth. - - fRawTransparencyMaskBitDepth = maskIFD.fBitsPerSample [0]; - - } - - } - -/*****************************************************************************/ - -void dng_negative::ResizeTransparencyToMatchStage3 (dng_host &host, - bool convertTo8Bit) - { - - if (TransparencyMask ()) - { - - if ((TransparencyMask ()->Bounds () != fStage3Image->Bounds ()) || - (TransparencyMask ()->PixelType () != ttByte && convertTo8Bit)) - { - - AutoPtr newMask (host.Make_dng_image (fStage3Image->Bounds (), - 1, - convertTo8Bit ? - ttByte : - TransparencyMask ()->PixelType ())); - - host.ResampleImage (*TransparencyMask (), - *newMask); - - fTransparencyMask.Reset (newMask.Release ()); - - if (!fRawTransparencyMask.Get ()) - { - fRawTransparencyMaskBitDepth = 0; - } - - } - - } - - } - -/*****************************************************************************/ - -bool dng_negative::NeedFlattenTransparency (dng_host & /* host */) - { - - if (TransparencyMask ()) - { - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_negative::FlattenTransparency (dng_host & /* host */) - { - - ThrowNotYetImplemented (); - - } - -/*****************************************************************************/ - -const dng_image * dng_negative::UnflattenedStage3Image () const - { - - if (fUnflattenedStage3Image.Get ()) - { - - return fUnflattenedStage3Image.Get (); - - } - - return fStage3Image.Get (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_negative.h b/third_party/dng_sdk/dng_negative.h deleted file mode 100644 index 3a3e29d..0000000 --- a/third_party/dng_sdk/dng_negative.h +++ /dev/null @@ -1,2386 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_negative.h#4 $ */ -/* $DateTime: 2012/08/02 06:09:06 $ */ -/* $Change: 841096 $ */ -/* $Author: erichan $ */ - -/** \file - * Functions and classes for working with a digital negative (image data and - * corresponding metadata). - */ - -/*****************************************************************************/ - -#ifndef __dng_negative__ -#define __dng_negative__ - -/*****************************************************************************/ - -#include "dng_1d_function.h" -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_fingerprint.h" -#include "dng_image.h" -#include "dng_linearization_info.h" -#include "dng_matrix.h" -#include "dng_mosaic_info.h" -#include "dng_opcode_list.h" -#include "dng_orientation.h" -#include "dng_rational.h" -#include "dng_sdk_limits.h" -#include "dng_string.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_types.h" -#include "dng_utils.h" -#include "dng_xy_coord.h" - -#include - -/*****************************************************************************/ - -// To prevent using the internal metadata when we meant to use override -// metadata, the following definitions allow us to only allow access to -// the internal metadata on non-const negatives. This allows the old API -// to keep working essentially unchanged provided one does not use const -// negatives, but will prevent access to the embedded data on const -// negatives. - -#if 1 - -#define qMetadataOnConst 0 -#define METACONST - -#else - -#define qMetadataOnConst 1 -#define METACONST const - -#endif - -/*****************************************************************************/ - -/// \brief Noise model for photon and sensor read noise, assuming that they are -/// independent random variables and spatially invariant. -/// -/// The noise model is N (x) = sqrt (scale*x + offset), where x represents a linear -/// signal value in the range [0,1], and N (x) is the standard deviation (i.e., -/// noise). The parameters scale and offset are both sensor-dependent and -/// ISO-dependent. scale must be positive, and offset must be non-negative. - -class dng_noise_function: public dng_1d_function - { - - protected: - - real64 fScale; - real64 fOffset; - - public: - - /// Create empty and invalid noise function. - - dng_noise_function () - - : fScale (0.0) - , fOffset (0.0) - - { - - } - - /// Create noise function with the specified scale and offset. - - dng_noise_function (real64 scale, - real64 offset) - - : fScale (scale) - , fOffset (offset) - - { - - } - - /// Compute noise (standard deviation) at the specified average signal level - /// x. - - virtual real64 Evaluate (real64 x) const - { - return sqrt (fScale * x + fOffset); - } - - /// The scale (slope, gain) of the noise function. - - real64 Scale () const - { - return fScale; - } - - /// The offset (square of the noise floor) of the noise function. - - real64 Offset () const - { - return fOffset; - } - - /// Set the scale (slope, gain) of the noise function. - - void SetScale (real64 scale) - { - fScale = scale; - } - - /// Set the offset (square of the noise floor) of the noise function. - - void SetOffset (real64 offset) - { - fOffset = offset; - } - - /// Is the noise function valid? - - bool IsValid () const - { - return (fScale > 0.0 && fOffset >= 0.0); - } - - }; - -/*****************************************************************************/ - -/// \brief Noise profile for a negative. -/// -/// For mosaiced negatives, the noise profile describes the approximate noise -/// characteristics of a mosaic negative after linearization, but prior to -/// demosaicing. For demosaiced negatives (i.e., linear DNGs), the noise profile -/// describes the approximate noise characteristics of the image data immediately -/// following the demosaic step, prior to the processing of opcode list 3. -/// -/// A noise profile may contain 1 or N noise functions, where N is the number of -/// color planes for the negative. Otherwise the noise profile is considered to be -/// invalid for that negative. If the noise profile contains 1 noise function, then -/// it is assumed that this single noise function applies to all color planes of the -/// negative. Otherwise, the N noise functions map to the N planes of the negative in -/// order specified in the CFAPlaneColor tag. - -class dng_noise_profile - { - - protected: - - std::vector fNoiseFunctions; - - public: - - /// Create empty (invalid) noise profile. - - dng_noise_profile (); - - /// Create noise profile with the specified noise functions (1 per plane). - - explicit dng_noise_profile (const std::vector &functions); - - /// Is the noise profile valid? - - bool IsValid () const; - - /// Is the noise profile valid for the specified negative? - - bool IsValidForNegative (const dng_negative &negative) const; - - /// The noise function for the specified plane. - - const dng_noise_function & NoiseFunction (uint32 plane) const; - - /// The number of noise functions in this profile. - - uint32 NumFunctions () const; - - }; - -/*****************************************************************************/ - -/// \brief Main class for holding metadata. - -class dng_metadata - { - - private: - - // Base orientation of both the thumbnail and raw data. This is - // generally based on the EXIF values. - - bool fHasBaseOrientation; - - dng_orientation fBaseOrientation; - - // Is the maker note safe to copy from file to file? Defaults to false - // because many maker notes are not safe. - - bool fIsMakerNoteSafe; - - // MakerNote binary data block. - - AutoPtr fMakerNote; - - // EXIF data. - - AutoPtr fExif; - - // A copy of the EXIF data before is was synchronized with other metadata sources. - - AutoPtr fOriginalExif; - - // IPTC binary data block and offset in original file. - - AutoPtr fIPTCBlock; - - uint64 fIPTCOffset; - - // XMP data. - - AutoPtr fXMP; - - // If there a valid embedded XMP block, has is its digest? NULL if no valid - // embedded XMP. - - dng_fingerprint fEmbeddedXMPDigest; - - // Is the XMP data from a sidecar file? - - bool fXMPinSidecar; - - // If the XMP data is from a sidecar file, is the sidecar file newer - // than the raw file? - - bool fXMPisNewer; - - // Source file mimi-type, if known. - - dng_string fSourceMIMI; - - public: - - dng_metadata (dng_host &host); - - dng_metadata (const dng_metadata &rhs, - dng_memory_allocator &allocator); - - virtual ~dng_metadata (); - - /// Copy this metadata. - - virtual dng_metadata * Clone (dng_memory_allocator &allocator) const; - - /// Setter for BaseOrientation. - - void SetBaseOrientation (const dng_orientation &orientation); - - /// Has BaseOrientation been set? - - bool HasBaseOrientation () const - { - return fHasBaseOrientation; - } - - /// Getter for BaseOrientation. - - const dng_orientation & BaseOrientation () const - { - return fBaseOrientation; - } - - /// Logically rotates the image by changing the orientation values. - /// This will also update the XMP data. - - void ApplyOrientation (const dng_orientation &orientation); - - // API for IPTC metadata: - - void SetIPTC (AutoPtr &block, - uint64 offset); - - void SetIPTC (AutoPtr &block); - - void ClearIPTC (); - - const void * IPTCData () const; - - uint32 IPTCLength () const; - - uint64 IPTCOffset () const; - - dng_fingerprint IPTCDigest (bool includePadding = true) const; - - void RebuildIPTC (dng_memory_allocator &allocator, - bool padForTIFF); - - // API for MakerNote data: - - void SetMakerNoteSafety (bool safe) - { - fIsMakerNoteSafe = safe; - } - - bool IsMakerNoteSafe () const - { - return fIsMakerNoteSafe; - } - - void SetMakerNote (AutoPtr &block) - { - fMakerNote.Reset (block.Release ()); - } - - void ClearMakerNote () - { - fIsMakerNoteSafe = false; - fMakerNote.Reset (); - } - - const void * MakerNoteData () const - { - return fMakerNote.Get () ? fMakerNote->Buffer () - : NULL; - } - - uint32 MakerNoteLength () const - { - return fMakerNote.Get () ? fMakerNote->LogicalSize () - : 0; - } - - // API for EXIF metadata: - - dng_exif * GetExif () - { - return fExif.Get (); - } - - const dng_exif * GetExif () const - { - return fExif.Get (); - } - - template< class E > - E & Exif (); - - template< class E > - const E & Exif () const; - - void ResetExif (dng_exif * newExif); - - dng_memory_block * BuildExifBlock (dng_memory_allocator &allocator, - const dng_resolution *resolution = NULL, - bool includeIPTC = false, - const dng_jpeg_preview *thumbnail = NULL) const; - - // API for original EXIF metadata. - - dng_exif * GetOriginalExif () - { - return fOriginalExif.Get (); - } - - const dng_exif * GetOriginalExif () const - { - return fOriginalExif.Get (); - } - - // API for XMP metadata: - - bool SetXMP (dng_host &host, - const void *buffer, - uint32 count, - bool xmpInSidecar = false, - bool xmpIsNewer = false); - - void SetEmbeddedXMP (dng_host &host, - const void *buffer, - uint32 count); - - dng_xmp * GetXMP () - { - return fXMP.Get (); - } - - const dng_xmp * GetXMP () const - { - return fXMP.Get (); - } - - template< class X > - X & XMP (); - - template< class X > - const X & XMP () const; - - bool XMPinSidecar () const - { - return fXMPinSidecar; - } - - const dng_fingerprint & EmbeddedXMPDigest () const - { - return fEmbeddedXMPDigest; - } - - bool HaveValidEmbeddedXMP () const - { - return fEmbeddedXMPDigest.IsValid (); - } - - void ResetXMP (dng_xmp * newXMP); - - void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer ); - - // Synchronize metadata sources. - - void SynchronizeMetadata (); - - // Routines to update the date/time field in the EXIF and XMP - // metadata. - - void UpdateDateTime (const dng_date_time_info &dt); - - void UpdateDateTimeToNow (); - - void UpdateMetadataDateTimeToNow (); - - // Routines to set and get the source file MIMI type. - - void SetSourceMIMI (const char *s) - { - fSourceMIMI.Set (s); - } - - const dng_string & SourceMIMI () const - { - return fSourceMIMI; - } - - }; - -/*****************************************************************************/ - -template< class E > -E & dng_metadata::Exif () - { - dng_exif * exif = GetExif (); - if (!exif) ThrowProgramError ("EXIF object is NULL."); - return dynamic_cast< E & > (*exif); - } - -/*****************************************************************************/ - -template< class E > -const E & dng_metadata::Exif () const - { - const dng_exif * exif = GetExif (); - if (!exif) ThrowProgramError ("EXIF object is NULL."); - return dynamic_cast< const E & > (*exif); - } - -/*****************************************************************************/ - -template< class X > -X & dng_metadata::XMP () - { - dng_xmp * xmp = GetXMP (); - if (!xmp) ThrowProgramError ("XMP object is NULL."); - return dynamic_cast< X & > (*xmp); - } - -/*****************************************************************************/ - -template< class X > -const X & dng_metadata::XMP () const - { - const dng_xmp * xmp = GetXMP (); - if (!xmp) ThrowProgramError ("XMP object is NULL."); - return dynamic_cast< const X & > (*xmp); - } - -/*****************************************************************************/ - -/// \brief Main class for holding DNG image data and associated metadata. - -class dng_negative - { - - public: - - enum RawImageStageEnum - { - rawImageStagePreOpcode1, - rawImageStagePostOpcode1, - rawImageStagePostOpcode2, - rawImageStagePreOpcode3, - rawImageStagePostOpcode3, - rawImageStageNone - }; - - protected: - - // The negative stores an associated allocator. It does not do - // anything to keep it alive or to release it when the object destructs. - // Hence, clients will need to make sure that the allocator's lifespan - // encompasses that of the dng_factory object which is generally - // directly bound to the dng_negative object. - - dng_memory_allocator &fAllocator; - - // Non-localized ASCII model name. - - dng_string fModelName; - - // Localized UTF-8 model name. - - dng_string fLocalName; - - // The area of raw image that should be included in the final converted - // image. This stems from extra pixels around the edges of the sensor - // including both the black mask and some additional padding. - - // The default crop can be smaller than the "active" area which includes - // the padding but not the black masked pixels. - - dng_urational fDefaultCropSizeH; - dng_urational fDefaultCropSizeV; - - dng_urational fDefaultCropOriginH; - dng_urational fDefaultCropOriginV; - - // Default user crop, in relative coordinates. - - dng_urational fDefaultUserCropT; - dng_urational fDefaultUserCropL; - dng_urational fDefaultUserCropB; - dng_urational fDefaultUserCropR; - - // Default scale factors. Generally, 1.0 for square pixel cameras. They - // can compensate for non-square pixels. The choice of exact values will - // generally depend on what the camera does. These are particularly - // interesting for the Nikon D1X and the Fuji diamond mosaic. - - dng_urational fDefaultScaleH; - dng_urational fDefaultScaleV; - - // Best quality scale factor. Used for the Nikon D1X and Fuji cameras - // to force everything to be a scale up rather than scale down. So, - // generally this is 1.0 / min (fDefaultScaleH, fDefaultScaleV) but - // this isn't used if the scale factors are only slightly different - // from 1.0. - - dng_urational fBestQualityScale; - - // Proxy image support. Remember certain sizes for the original image - // this proxy was derived from. - - dng_point fOriginalDefaultFinalSize; - dng_point fOriginalBestQualityFinalSize; - - dng_urational fOriginalDefaultCropSizeH; - dng_urational fOriginalDefaultCropSizeV; - - // Scale factors used in demosaic algorithm (calculated). - // Maps raw image coordinates to full image coordinates -- i.e., - // original image coordinates on raw sensor data to coordinates - // in fStage3Image which is the output of the interpolation step. - // So, if we downsample when interpolating, these numbers get - // smaller. - - real64 fRawToFullScaleH; - real64 fRawToFullScaleV; - - // Relative amount of noise at ISO 100. This is measured per camera model - // based on looking at flat areas of color. - - dng_urational fBaselineNoise; - - // How much noise reduction has already been applied (0.0 to 1.0) to the - // the raw image data? 0.0 = none, 1.0 = "ideal" amount--i.e. don't apply any - // more by default. 0/0 for unknown. - - dng_urational fNoiseReductionApplied; - - // Amount of noise for this negative (see dng_noise_profile for details). - - dng_noise_profile fNoiseProfile; - - // Zero point for the exposure compensation slider. This reflects how - // the manufacturer sets up the camera and its conversions. - - dng_srational fBaselineExposure; - - // Relative amount of sharpening required. This is chosen per camera - // model based on how strong the anti-alias filter is on the camera - // and the quality of the lenses. This scales the sharpness slider - // value. - - dng_urational fBaselineSharpness; - - // Chroma blur radius (or 0/0 for auto). Set to 0/1 to disable - // chroma blurring. - - dng_urational fChromaBlurRadius; - - // Anti-alias filter strength (0.0 to 1.0). Used as a hint - // to the demosaic algorithms. - - dng_urational fAntiAliasStrength; - - // Linear response limit. The point at which the sensor goes - // non-linear and color information becomes unreliable. Used in - // the highlight-recovery logic. - - dng_urational fLinearResponseLimit; - - // Scale factor for shadows slider. The Fuji HDR cameras, for example, - // need a more sensitive shadow slider. - - dng_urational fShadowScale; - - // Colormetric reference. - - uint32 fColorimetricReference; - - // Number of color channels for this image (e.g. 1, 3, or 4). - - uint32 fColorChannels; - - // Amount by which each channel has already been scaled. Some cameras - // have analog amplifiers on the color channels and these can result - // in different scalings per channel. This provides some level of - // analog white balancing. The Nikon D1 also did digital scaling but - // this caused problems with highlight recovery. - - dng_vector fAnalogBalance; - - // The "As Shot" neutral color coordinates in native camera space. - // This overrides fCameraWhiteXY if both are specified. This - // specifies the values per channel that would result in a neutral - // color for the "As Shot" case. This is generally supplied by - // the camera. - - dng_vector fCameraNeutral; - - // The "As Shot" white balance xy coordinates. Sometimes this is - // supplied by the camera. Sometimes the camera just supplies a name - // for the white balance. - - dng_xy_coord fCameraWhiteXY; - - // Individual camera calibrations. - - // Camera data --> camera calibration --> "inverse" of color matrix - - // This will be a 4x4 matrix for a 4-color camera. The defaults are - // almost always the identity matrix and for the cases where they - // aren't, they are diagonal matrices. - - dng_matrix fCameraCalibration1; - dng_matrix fCameraCalibration2; - - // Signature which allows a profile to announce that it is compatible - // with these calibration matrices. - - dng_string fCameraCalibrationSignature; - - // List of camera profiles. - - std::vector fCameraProfile; - - // "As shot" camera profile name. - - dng_string fAsShotProfileName; - - // Raw image data digests. These are MD5 fingerprints of the raw image data - // in the file, computed using a specific algorithms. They can be used - // verify the raw data has not been corrupted. The new version is faster - // to compute on MP machines, and is used starting with DNG version 1.4. - - mutable dng_fingerprint fRawImageDigest; - - mutable dng_fingerprint fNewRawImageDigest; - - // Raw data unique ID. This is an unique identifer for the actual - // raw image data in the file. It can be used to index into caches - // for this data. - - mutable dng_fingerprint fRawDataUniqueID; - - // Original raw file name. Just the file name, not the full path. - - dng_string fOriginalRawFileName; - - // Is the original raw file data availaible? - - bool fHasOriginalRawFileData; - - // The compressed original raw file data. - - AutoPtr fOriginalRawFileData; - - // MD5 digest of original raw file data block. - - mutable dng_fingerprint fOriginalRawFileDigest; - - // DNG private data block. - - AutoPtr fDNGPrivateData; - - // Metadata information (XMP, IPTC, EXIF, orientation) - - dng_metadata fMetadata; - - // Information required to linearize and range map the raw data. - - AutoPtr fLinearizationInfo; - - // Information required to demoasic the raw data. - - AutoPtr fMosaicInfo; - - // Opcode list 1. (Applied to stored data) - - dng_opcode_list fOpcodeList1; - - // Opcode list 2. (Applied to range mapped data) - - dng_opcode_list fOpcodeList2; - - // Opcode list 3. (Post demosaic) - - dng_opcode_list fOpcodeList3; - - // Stage 1 image, which is image data stored in a DNG file. - - AutoPtr fStage1Image; - - // Stage 2 image, which is the stage 1 image after it has been - // linearized and range mapped. - - AutoPtr fStage2Image; - - // Stage 3 image, which is the stage 2 image after it has been - // demosaiced. - - AutoPtr fStage3Image; - - // Additiona gain applied when building the stage 3 image. - - real64 fStage3Gain; - - // Were any approximations (e.g. downsampling, etc.) applied - // file reading this image? - - bool fIsPreview; - - // Does the file appear to be damaged? - - bool fIsDamaged; - - // At what processing stage did we grab a copy of raw image data? - - RawImageStageEnum fRawImageStage; - - // The raw image data that we grabbed, if any. - - AutoPtr fRawImage; - - // The floating point bit depth of the raw file, if any. - - uint32 fRawFloatBitDepth; - - // The raw image JPEG data that we grabbed, if any. - - AutoPtr fRawJPEGImage; - - // Keep a separate digest for the compressed JPEG data, if any. - - mutable dng_fingerprint fRawJPEGImageDigest; - - // Transparency mask image, if any. - - AutoPtr fTransparencyMask; - - // Grabbed transparency mask, if we are not saving the current mask. - - AutoPtr fRawTransparencyMask; - - // The bit depth for the raw transparancy mask, if known. - - uint32 fRawTransparencyMaskBitDepth; - - // We sometimes need to keep of copy of the stage3 image before - // flattening the transparency. - - AutoPtr fUnflattenedStage3Image; - - public: - - virtual ~dng_negative (); - - static dng_negative * Make (dng_host &host); - - /// Provide access to the memory allocator used for this object. - - dng_memory_allocator & Allocator () const - { - return fAllocator; - } - - /// Getter for ModelName. - - void SetModelName (const char *name) - { - fModelName.Set_ASCII (name); - } - - /// Setter for ModelName. - - const dng_string & ModelName () const - { - return fModelName; - } - - /// Setter for LocalName. - - void SetLocalName (const char *name) - { - fLocalName.Set (name); - } - - /// Getter for LocalName. - - const dng_string & LocalName () const - { - return fLocalName; - } - - /// Getter for metadata - - dng_metadata &Metadata () - { - return fMetadata; - } - - #if qMetadataOnConst - - const dng_metadata &Metadata () const - { - return fMetadata; - } - - #endif // qMetadataOnConst - - /// Make a copy of the internal metadata generally as a basis for further - /// changes. - - dng_metadata * CloneInternalMetadata () const; - - protected: - - /// An accessor for the internal metadata that works even when we - /// have general access turned off. This is needed to provide - /// access to EXIF ISO information. - - const dng_metadata &InternalMetadata () const - { - return fMetadata; - } - - public: - - /// Setter for BaseOrientation. - - void SetBaseOrientation (const dng_orientation &orientation) - { - Metadata ().SetBaseOrientation (orientation); - } - - /// Has BaseOrientation been set? - - bool HasBaseOrientation () METACONST - { - return Metadata ().HasBaseOrientation (); - } - - /// Getter for BaseOrientation. - - const dng_orientation & BaseOrientation () METACONST - { - return Metadata ().BaseOrientation (); - } - - /// Hook to allow SDK host code to add additional rotations. - - virtual dng_orientation ComputeOrientation (const dng_metadata &metadata) const; - - /// For non-const negatives, we simply default to using the metadata attached to the negative. - - dng_orientation Orientation () - { - return ComputeOrientation (Metadata ()); - } - - /// Logically rotates the image by changing the orientation values. - /// This will also update the XMP data. - - void ApplyOrientation (const dng_orientation &orientation) - { - Metadata ().ApplyOrientation (orientation); - } - - /// Setter for DefaultCropSize. - - void SetDefaultCropSize (const dng_urational &sizeH, - const dng_urational &sizeV) - { - fDefaultCropSizeH = sizeH; - fDefaultCropSizeV = sizeV; - } - - /// Setter for DefaultCropSize. - - void SetDefaultCropSize (uint32 sizeH, - uint32 sizeV) - { - SetDefaultCropSize (dng_urational (sizeH, 1), - dng_urational (sizeV, 1)); - } - - /// Getter for DefaultCropSize horizontal. - - const dng_urational & DefaultCropSizeH () const - { - return fDefaultCropSizeH; - } - - /// Getter for DefaultCropSize vertical. - - const dng_urational & DefaultCropSizeV () const - { - return fDefaultCropSizeV; - } - - /// Setter for DefaultCropOrigin. - - void SetDefaultCropOrigin (const dng_urational &originH, - const dng_urational &originV) - { - fDefaultCropOriginH = originH; - fDefaultCropOriginV = originV; - } - - /// Setter for DefaultCropOrigin. - - void SetDefaultCropOrigin (uint32 originH, - uint32 originV) - { - SetDefaultCropOrigin (dng_urational (originH, 1), - dng_urational (originV, 1)); - } - - /// Set default crop around center of image. - - void SetDefaultCropCentered (const dng_point &rawSize) - { - - uint32 sizeH = Round_uint32 (fDefaultCropSizeH.As_real64 ()); - uint32 sizeV = Round_uint32 (fDefaultCropSizeV.As_real64 ()); - - SetDefaultCropOrigin ((rawSize.h - sizeH) >> 1, - (rawSize.v - sizeV) >> 1); - - } - - /// Get default crop origin horizontal value. - - const dng_urational & DefaultCropOriginH () const - { - return fDefaultCropOriginH; - } - - /// Get default crop origin vertical value. - - const dng_urational & DefaultCropOriginV () const - { - return fDefaultCropOriginV; - } - - /// Getter for top coordinate of default user crop. - - const dng_urational & DefaultUserCropT () const - { - return fDefaultUserCropT; - } - - /// Getter for left coordinate of default user crop. - - const dng_urational & DefaultUserCropL () const - { - return fDefaultUserCropL; - } - - /// Getter for bottom coordinate of default user crop. - - const dng_urational & DefaultUserCropB () const - { - return fDefaultUserCropB; - } - - /// Getter for right coordinate of default user crop. - - const dng_urational & DefaultUserCropR () const - { - return fDefaultUserCropR; - } - - /// Reset default user crop to default crop area. - - void ResetDefaultUserCrop () - { - fDefaultUserCropT = dng_urational (0, 1); - fDefaultUserCropL = dng_urational (0, 1); - fDefaultUserCropB = dng_urational (1, 1); - fDefaultUserCropR = dng_urational (1, 1); - } - - /// Setter for all 4 coordinates of default user crop. - - void SetDefaultUserCrop (const dng_urational &t, - const dng_urational &l, - const dng_urational &b, - const dng_urational &r) - { - fDefaultUserCropT = t; - fDefaultUserCropL = l; - fDefaultUserCropB = b; - fDefaultUserCropR = r; - } - - /// Setter for top coordinate of default user crop. - - void SetDefaultUserCropT (const dng_urational &value) - { - fDefaultUserCropT = value; - } - - /// Setter for left coordinate of default user crop. - - void SetDefaultUserCropL (const dng_urational &value) - { - fDefaultUserCropL = value; - } - - /// Setter for bottom coordinate of default user crop. - - void SetDefaultUserCropB (const dng_urational &value) - { - fDefaultUserCropB = value; - } - - /// Setter for right coordinate of default user crop. - - void SetDefaultUserCropR (const dng_urational &value) - { - fDefaultUserCropR = value; - } - - /// Setter for DefaultScale. - - void SetDefaultScale (const dng_urational &scaleH, - const dng_urational &scaleV) - { - fDefaultScaleH = scaleH; - fDefaultScaleV = scaleV; - } - - /// Get default scale horizontal value. - - const dng_urational & DefaultScaleH () const - { - return fDefaultScaleH; - } - - /// Get default scale vertical value. - - const dng_urational & DefaultScaleV () const - { - return fDefaultScaleV; - } - - /// Setter for BestQualityScale. - - void SetBestQualityScale (const dng_urational &scale) - { - fBestQualityScale = scale; - } - - /// Getter for BestQualityScale. - - const dng_urational & BestQualityScale () const - { - return fBestQualityScale; - } - - /// API for raw to full image scaling factors horizontal. - - real64 RawToFullScaleH () const - { - return fRawToFullScaleH; - } - - /// API for raw to full image scaling factors vertical. - - real64 RawToFullScaleV () const - { - return fRawToFullScaleV; - } - - /// Setter for raw to full scales. - - void SetRawToFullScale (real64 scaleH, - real64 scaleV) - { - fRawToFullScaleH = scaleH; - fRawToFullScaleV = scaleV; - } - - /// Get default scale factor. - /// When specifing a single scale factor, we use the horizontal - /// scale factor, and let the vertical scale factor be calculated - /// based on the pixel aspect ratio. - - real64 DefaultScale () const - { - return DefaultScaleH ().As_real64 (); - } - - /// Default cropped image size (at scale == 1.0) width. - - real64 SquareWidth () const - { - return DefaultCropSizeH ().As_real64 (); - } - - /// Default cropped image size (at scale == 1.0) height. - - real64 SquareHeight () const - { - return DefaultCropSizeV ().As_real64 () * - DefaultScaleV ().As_real64 () / - DefaultScaleH ().As_real64 (); - } - - /// Default cropped image aspect ratio. - - real64 AspectRatio () const - { - return SquareWidth () / - SquareHeight (); - } - - /// Pixel aspect ratio of stage 3 image. - - real64 PixelAspectRatio () const - { - return (DefaultScaleH ().As_real64 () / RawToFullScaleH ()) / - (DefaultScaleV ().As_real64 () / RawToFullScaleV ()); - } - - /// Default cropped image size at given scale factor width. - - uint32 FinalWidth (real64 scale) const - { - return Round_uint32 (SquareWidth () * scale); - } - - /// Default cropped image size at given scale factor height. - - uint32 FinalHeight (real64 scale) const - { - return Round_uint32 (SquareHeight () * scale); - } - - /// Default cropped image size at default scale factor width. - - uint32 DefaultFinalWidth () const - { - return FinalWidth (DefaultScale ()); - } - - /// Default cropped image size at default scale factor height. - - uint32 DefaultFinalHeight () const - { - return FinalHeight (DefaultScale ()); - } - - /// Get best quality width. - /// For a naive conversion, one could use either the default size, - /// or the best quality size. - - uint32 BestQualityFinalWidth () const - { - return FinalWidth (DefaultScale () * BestQualityScale ().As_real64 ()); - } - - /// Get best quality height. - /// For a naive conversion, one could use either the default size, - /// or the best quality size. - - uint32 BestQualityFinalHeight () const - { - return FinalHeight (DefaultScale () * BestQualityScale ().As_real64 ()); - } - - /// Default size of original (non-proxy) image. For non-proxy images, this - /// is equal to DefaultFinalWidth/DefaultFinalHight. For proxy images, this - /// is equal to the DefaultFinalWidth/DefaultFinalHeight of the image this - /// proxy was derived from. - - const dng_point & OriginalDefaultFinalSize () const - { - return fOriginalDefaultFinalSize; - } - - /// Setter for OriginalDefaultFinalSize. - - void SetOriginalDefaultFinalSize (const dng_point &size) - { - fOriginalDefaultFinalSize = size; - } - - /// Best quality size of original (non-proxy) image. For non-proxy images, this - /// is equal to BestQualityFinalWidth/BestQualityFinalHeight. For proxy images, this - /// is equal to the BestQualityFinalWidth/BestQualityFinalHeight of the image this - /// proxy was derived from. - - const dng_point & OriginalBestQualityFinalSize () const - { - return fOriginalBestQualityFinalSize; - } - - /// Setter for OriginalBestQualityFinalSize. - - void SetOriginalBestQualityFinalSize (const dng_point &size) - { - fOriginalBestQualityFinalSize = size; - } - - /// DefaultCropSize for original (non-proxy) image. For non-proxy images, - /// this is equal to the DefaultCropSize. for proxy images, this is - /// equal size of the DefaultCropSize of the image this proxy was derived from. - - const dng_urational & OriginalDefaultCropSizeH () const - { - return fOriginalDefaultCropSizeH; - } - - const dng_urational & OriginalDefaultCropSizeV () const - { - return fOriginalDefaultCropSizeV; - } - - /// Setter for OriginalDefaultCropSize. - - void SetOriginalDefaultCropSize (const dng_urational &sizeH, - const dng_urational &sizeV) - { - fOriginalDefaultCropSizeH = sizeH; - fOriginalDefaultCropSizeV = sizeV; - } - - /// If the original size fields are undefined, set them to the - /// current sizes. - - void SetDefaultOriginalSizes (); - - /// The default crop area in the stage 3 image coordinates. - - dng_rect DefaultCropArea () const; - - /// Setter for BaselineNoise. - - void SetBaselineNoise (real64 noise) - { - fBaselineNoise.Set_real64 (noise, 100); - } - - /// Getter for BaselineNoise as dng_urational. - - const dng_urational & BaselineNoiseR () const - { - return fBaselineNoise; - } - - /// Getter for BaselineNoise as real64. - - real64 BaselineNoise () const - { - return fBaselineNoise.As_real64 (); - } - - /// Setter for NoiseReductionApplied. - - void SetNoiseReductionApplied (const dng_urational &value) - { - fNoiseReductionApplied = value; - } - - /// Getter for NoiseReductionApplied. - - const dng_urational & NoiseReductionApplied () const - { - return fNoiseReductionApplied; - } - - /// Setter for noise profile. - - void SetNoiseProfile (const dng_noise_profile &noiseProfile) - { - fNoiseProfile = noiseProfile; - } - - /// Does this negative have a valid noise profile? - - bool HasNoiseProfile () const - { - return fNoiseProfile.IsValidForNegative (*this); - } - - /// Getter for noise profile. - - const dng_noise_profile & NoiseProfile () const - { - return fNoiseProfile; - } - - /// Setter for BaselineExposure. - - void SetBaselineExposure (real64 exposure) - { - fBaselineExposure.Set_real64 (exposure, 100); - } - - /// Getter for BaselineExposure as dng_urational. - - const dng_srational & BaselineExposureR () const - { - return fBaselineExposure; - } - - /// Getter for BaselineExposure as real64. - - real64 BaselineExposure () const - { - return BaselineExposureR ().As_real64 (); - } - - /// Compute total baseline exposure (sum of negative's BaselineExposure and - /// profile's BaselineExposureOffset). - - real64 TotalBaselineExposure (const dng_camera_profile_id &profileID) const; - - /// Setter for BaselineSharpness. - - void SetBaselineSharpness (real64 sharpness) - { - fBaselineSharpness.Set_real64 (sharpness, 100); - } - - /// Getter for BaselineSharpness as dng_urational. - - const dng_urational & BaselineSharpnessR () const - { - return fBaselineSharpness; - } - - /// Getter for BaselineSharpness as real64. - - real64 BaselineSharpness () const - { - return BaselineSharpnessR ().As_real64 (); - } - - /// Setter for ChromaBlurRadius. - - void SetChromaBlurRadius (const dng_urational &radius) - { - fChromaBlurRadius = radius; - } - - /// Getter for ChromaBlurRadius as dng_urational. - - const dng_urational & ChromaBlurRadius () const - { - return fChromaBlurRadius; - } - - /// Setter for AntiAliasStrength. - - void SetAntiAliasStrength (const dng_urational &strength) - { - fAntiAliasStrength = strength; - } - - /// Getter for AntiAliasStrength as dng_urational. - - const dng_urational & AntiAliasStrength () const - { - return fAntiAliasStrength; - } - - /// Setter for LinearResponseLimit. - - void SetLinearResponseLimit (real64 limit) - { - fLinearResponseLimit.Set_real64 (limit, 100); - } - - /// Getter for LinearResponseLimit as dng_urational. - - const dng_urational & LinearResponseLimitR () const - { - return fLinearResponseLimit; - } - - /// Getter for LinearResponseLimit as real64. - - real64 LinearResponseLimit () const - { - return LinearResponseLimitR ().As_real64 (); - } - - /// Setter for ShadowScale. - - void SetShadowScale (const dng_urational &scale); - - /// Getter for ShadowScale as dng_urational. - - const dng_urational & ShadowScaleR () const - { - return fShadowScale; - } - - /// Getter for ShadowScale as real64. - - real64 ShadowScale () const - { - return ShadowScaleR ().As_real64 (); - } - - // API for ColorimetricReference. - - void SetColorimetricReference (uint32 ref) - { - fColorimetricReference = ref; - } - - uint32 ColorimetricReference () const - { - return fColorimetricReference; - } - - /// Setter for ColorChannels. - - void SetColorChannels (uint32 channels) - { - fColorChannels = channels; - } - - /// Getter for ColorChannels. - - uint32 ColorChannels () const - { - return fColorChannels; - } - - /// Setter for Monochrome. - - void SetMonochrome () - { - SetColorChannels (1); - } - - /// Getter for Monochrome. - - bool IsMonochrome () const - { - return ColorChannels () == 1; - } - - /// Setter for AnalogBalance. - - void SetAnalogBalance (const dng_vector &b); - - /// Getter for AnalogBalance as dng_urational. - - dng_urational AnalogBalanceR (uint32 channel) const; - - /// Getter for AnalogBalance as real64. - - real64 AnalogBalance (uint32 channel) const; - - /// Setter for CameraNeutral. - - void SetCameraNeutral (const dng_vector &n); - - /// Clear CameraNeutral. - - void ClearCameraNeutral () - { - fCameraNeutral.Clear (); - } - - /// Determine if CameraNeutral has been set but not cleared. - - bool HasCameraNeutral () const - { - return fCameraNeutral.NotEmpty (); - } - - /// Getter for CameraNeutral. - - const dng_vector & CameraNeutral () const - { - return fCameraNeutral; - } - - dng_urational CameraNeutralR (uint32 channel) const; - - /// Setter for CameraWhiteXY. - - void SetCameraWhiteXY (const dng_xy_coord &coord); - - bool HasCameraWhiteXY () const - { - return fCameraWhiteXY.IsValid (); - } - - const dng_xy_coord & CameraWhiteXY () const; - - void GetCameraWhiteXY (dng_urational &x, - dng_urational &y) const; - - // API for camera calibration: - - /// Setter for first of up to two color matrices used for individual camera calibrations. - /// - /// The sequence of matrix transforms is: - /// Camera data --> camera calibration --> "inverse" of color matrix - /// - /// This will be a 4x4 matrix for a four-color camera. The defaults are - /// almost always the identity matrix, and for the cases where they - /// aren't, they are diagonal matrices. - - void SetCameraCalibration1 (const dng_matrix &m); - - /// Setter for second of up to two color matrices used for individual camera calibrations. - /// - /// The sequence of matrix transforms is: - /// Camera data --> camera calibration --> "inverse" of color matrix - /// - /// This will be a 4x4 matrix for a four-color camera. The defaults are - /// almost always the identity matrix, and for the cases where they - /// aren't, they are diagonal matrices. - - void SetCameraCalibration2 (const dng_matrix &m); - - /// Getter for first of up to two color matrices used for individual camera calibrations. - - const dng_matrix & CameraCalibration1 () const - { - return fCameraCalibration1; - } - - /// Getter for second of up to two color matrices used for individual camera calibrations. - - const dng_matrix & CameraCalibration2 () const - { - return fCameraCalibration2; - } - - void SetCameraCalibrationSignature (const char *signature) - { - fCameraCalibrationSignature.Set (signature); - } - - const dng_string & CameraCalibrationSignature () const - { - return fCameraCalibrationSignature; - } - - // Camera Profile API: - - void AddProfile (AutoPtr &profile); - - void ClearProfiles (); - - void ClearProfiles (bool clearBuiltinMatrixProfiles, - bool clearReadFromDisk); - - uint32 ProfileCount () const; - - const dng_camera_profile & ProfileByIndex (uint32 index) const; - - virtual const dng_camera_profile * ProfileByID (const dng_camera_profile_id &id, - bool useDefaultIfNoMatch = true) const; - - bool HasProfileID (const dng_camera_profile_id &id) const - { - return ProfileByID (id, false) != NULL; - } - - // Returns the camera profile to embed when saving to DNG: - - virtual const dng_camera_profile * ComputeCameraProfileToEmbed - (const dng_metadata &metadata) const; - - // For non-const negatives, we can use the embedded metadata. - - const dng_camera_profile * CameraProfileToEmbed () - { - return ComputeCameraProfileToEmbed (Metadata ()); - } - - // API for AsShotProfileName. - - void SetAsShotProfileName (const char *name) - { - fAsShotProfileName.Set (name); - } - - const dng_string & AsShotProfileName () const - { - return fAsShotProfileName; - } - - // Makes a dng_color_spec object for this negative. - - virtual dng_color_spec * MakeColorSpec (const dng_camera_profile_id &id) const; - - // Compute a MD5 hash on an image, using a fixed algorithm. - // The results must be stable across different hardware, OSes, - // and software versions. - - dng_fingerprint FindImageDigest (dng_host &host, - const dng_image &image) const; - - // API for RawImageDigest and NewRawImageDigest: - - void SetRawImageDigest (const dng_fingerprint &digest) - { - fRawImageDigest = digest; - } - - void SetNewRawImageDigest (const dng_fingerprint &digest) - { - fNewRawImageDigest = digest; - } - - void ClearRawImageDigest () const - { - fRawImageDigest .Clear (); - fNewRawImageDigest.Clear (); - } - - const dng_fingerprint & RawImageDigest () const - { - return fRawImageDigest; - } - - const dng_fingerprint & NewRawImageDigest () const - { - return fNewRawImageDigest; - } - - void FindRawImageDigest (dng_host &host) const; - - void FindNewRawImageDigest (dng_host &host) const; - - void ValidateRawImageDigest (dng_host &host); - - // API for RawDataUniqueID: - - void SetRawDataUniqueID (const dng_fingerprint &id) - { - fRawDataUniqueID = id; - } - - const dng_fingerprint & RawDataUniqueID () const - { - return fRawDataUniqueID; - } - - void FindRawDataUniqueID (dng_host &host) const; - - void RecomputeRawDataUniqueID (dng_host &host); - - // API for original raw file name: - - void SetOriginalRawFileName (const char *name) - { - fOriginalRawFileName.Set (name); - } - - bool HasOriginalRawFileName () const - { - return fOriginalRawFileName.NotEmpty (); - } - - const dng_string & OriginalRawFileName () const - { - return fOriginalRawFileName; - } - - // API for original raw file data: - - void SetHasOriginalRawFileData (bool hasData) - { - fHasOriginalRawFileData = hasData; - } - - bool CanEmbedOriginalRaw () const - { - return fHasOriginalRawFileData && HasOriginalRawFileName (); - } - - void SetOriginalRawFileData (AutoPtr &data) - { - fOriginalRawFileData.Reset (data.Release ()); - } - - const void * OriginalRawFileData () const - { - return fOriginalRawFileData.Get () ? fOriginalRawFileData->Buffer () - : NULL; - } - - uint32 OriginalRawFileDataLength () const - { - return fOriginalRawFileData.Get () ? fOriginalRawFileData->LogicalSize () - : 0; - } - - // API for original raw file data digest. - - void SetOriginalRawFileDigest (const dng_fingerprint &digest) - { - fOriginalRawFileDigest = digest; - } - - const dng_fingerprint & OriginalRawFileDigest () const - { - return fOriginalRawFileDigest; - } - - void FindOriginalRawFileDigest () const; - - void ValidateOriginalRawFileDigest (); - - // API for DNG private data: - - void SetPrivateData (AutoPtr &block) - { - fDNGPrivateData.Reset (block.Release ()); - } - - void ClearPrivateData () - { - fDNGPrivateData.Reset (); - } - - const uint8 * PrivateData () const - { - return fDNGPrivateData.Get () ? fDNGPrivateData->Buffer_uint8 () - : NULL; - } - - uint32 PrivateLength () const - { - return fDNGPrivateData.Get () ? fDNGPrivateData->LogicalSize () - : 0; - } - - // API for MakerNote data: - - void SetMakerNoteSafety (bool safe) - { - Metadata ().SetMakerNoteSafety (safe); - } - - bool IsMakerNoteSafe () METACONST - { - return Metadata ().IsMakerNoteSafe (); - } - - void SetMakerNote (AutoPtr &block) - { - Metadata ().SetMakerNote (block); - } - - void ClearMakerNote () - { - Metadata ().ClearMakerNote (); - } - - const void * MakerNoteData () METACONST - { - return Metadata ().MakerNoteData (); - } - - uint32 MakerNoteLength () METACONST - { - return Metadata ().MakerNoteLength (); - } - - // API for EXIF metadata: - - dng_exif * GetExif () - { - return Metadata ().GetExif (); - } - - #if qMetadataOnConst - - const dng_exif * GetExif () const - { - return Metadata ().GetExif (); - } - - #endif // qMetadataOnConst - - void ResetExif (dng_exif * newExif) - { - Metadata ().ResetExif (newExif); - } - - // API for original EXIF metadata. - - dng_exif * GetOriginalExif () - { - return Metadata ().GetOriginalExif (); - } - - #if qMetadataOnConst - - const dng_exif * GetOriginalExif () const - { - return Metadata ().GetOriginalExif (); - } - - #endif // qMetadataOnConst - - // API for IPTC metadata: - - void SetIPTC (AutoPtr &block, - uint64 offset) - { - Metadata ().SetIPTC (block, offset); - } - - void SetIPTC (AutoPtr &block) - { - Metadata ().SetIPTC (block); - } - - void ClearIPTC () - { - Metadata ().ClearIPTC (); - } - - const void * IPTCData () METACONST - { - return Metadata ().IPTCData (); - } - - uint32 IPTCLength () METACONST - { - return Metadata ().IPTCLength (); - } - - uint64 IPTCOffset () METACONST - { - return Metadata ().IPTCOffset (); - } - - dng_fingerprint IPTCDigest (bool includePadding = true) METACONST - { - return Metadata ().IPTCDigest (includePadding); - } - - void RebuildIPTC (bool padForTIFF) - { - Metadata ().RebuildIPTC (Allocator (), padForTIFF); - } - - // API for XMP metadata: - - bool SetXMP (dng_host &host, - const void *buffer, - uint32 count, - bool xmpInSidecar = false, - bool xmpIsNewer = false) - { - return Metadata ().SetXMP (host, - buffer, - count, - xmpInSidecar, - xmpIsNewer); - } - - dng_xmp * GetXMP () - { - return Metadata ().GetXMP (); - } - - #if qMetadataOnConst - - const dng_xmp * GetXMP () const - { - return Metadata ().GetXMP (); - } - - #endif // qMetadataOnConst - - bool XMPinSidecar () METACONST - { - return Metadata ().XMPinSidecar (); - } - - void ResetXMP (dng_xmp * newXMP) - { - Metadata ().ResetXMP (newXMP); - } - - void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer ) - { - Metadata ().ResetXMPSidecarNewer (newXMP, inSidecar, isNewer); - } - - bool HaveValidEmbeddedXMP () METACONST - { - return Metadata ().HaveValidEmbeddedXMP (); - } - - // API for source MIMI type. - - void SetSourceMIMI (const char *s) - { - Metadata ().SetSourceMIMI (s); - } - - // API for linearization information: - - const dng_linearization_info * GetLinearizationInfo () const - { - return fLinearizationInfo.Get (); - } - - void ClearLinearizationInfo () - { - fLinearizationInfo.Reset (); - } - - // Linearization curve. Usually used to increase compression ratios - // by storing the compressed data in a more visually uniform space. - // This is a 16-bit LUT that maps the stored data back to linear. - - void SetLinearization (AutoPtr &curve); - - // Active area (non-black masked pixels). These pixels are trimmed - // during linearization step. - - void SetActiveArea (const dng_rect &area); - - // Areas that are known to contain black masked pixels that can - // be used to estimate black levels. - - void SetMaskedAreas (uint32 count, - const dng_rect *area); - - void SetMaskedArea (const dng_rect &area) - { - SetMaskedAreas (1, &area); - } - - // Sensor black level information. - - void SetBlackLevel (real64 black, - int32 plane = -1); - - void SetQuadBlacks (real64 black0, - real64 black1, - real64 black2, - real64 black3, - int32 plane = -1); - - void SetRowBlacks (const real64 *blacks, - uint32 count); - - void SetColumnBlacks (const real64 *blacks, - uint32 count); - - // Sensor white level information. - - uint32 WhiteLevel (uint32 plane = 0) const; - - void SetWhiteLevel (uint32 white, - int32 plane = -1); - - // API for mosaic information: - - const dng_mosaic_info * GetMosaicInfo () const - { - return fMosaicInfo.Get (); - } - - void ClearMosaicInfo () - { - fMosaicInfo.Reset (); - } - - // ColorKeys APIs: - - void SetColorKeys (ColorKeyCode color0, - ColorKeyCode color1, - ColorKeyCode color2, - ColorKeyCode color3 = colorKeyMaxEnum); - - void SetRGB () - { - - SetColorChannels (3); - - SetColorKeys (colorKeyRed, - colorKeyGreen, - colorKeyBlue); - - } - - void SetCMY () - { - - SetColorChannels (3); - - SetColorKeys (colorKeyCyan, - colorKeyMagenta, - colorKeyYellow); - - } - - void SetGMCY () - { - - SetColorChannels (4); - - SetColorKeys (colorKeyGreen, - colorKeyMagenta, - colorKeyCyan, - colorKeyYellow); - - } - - // APIs to set mosaic patterns. - - void SetBayerMosaic (uint32 phase); - - void SetFujiMosaic (uint32 phase); - - void SetFujiMosaic6x6 (uint32 phase); - - void SetQuadMosaic (uint32 pattern); - - // BayerGreenSplit. - - void SetGreenSplit (uint32 split); - - // APIs for opcode lists. - - const dng_opcode_list & OpcodeList1 () const - { - return fOpcodeList1; - } - - dng_opcode_list & OpcodeList1 () - { - return fOpcodeList1; - } - - const dng_opcode_list & OpcodeList2 () const - { - return fOpcodeList2; - } - - dng_opcode_list & OpcodeList2 () - { - return fOpcodeList2; - } - - const dng_opcode_list & OpcodeList3 () const - { - return fOpcodeList3; - } - - dng_opcode_list & OpcodeList3 () - { - return fOpcodeList3; - } - - // First part of parsing logic. - - virtual void Parse (dng_host &host, - dng_stream &stream, - dng_info &info); - - // Second part of parsing logic. This is split off from the - // first part because these operations are useful when extending - // this sdk to support non-DNG raw formats. - - virtual void PostParse (dng_host &host, - dng_stream &stream, - dng_info &info); - - // Synchronize metadata sources. - - void SynchronizeMetadata () - { - Metadata ().SynchronizeMetadata (); - } - - // Routines to update the date/time field in the EXIF and XMP - // metadata. - - void UpdateDateTime (const dng_date_time_info &dt) - { - Metadata ().UpdateDateTime (dt); - } - - void UpdateDateTimeToNow () - { - Metadata ().UpdateDateTimeToNow (); - } - - // Developer's utility function to switch to four color Bayer - // interpolation. This is useful for evaluating how much green - // split a Bayer pattern sensor has. - - virtual bool SetFourColorBayer (); - - // Access routines for the image stages. - - const dng_image * Stage1Image () const - { - return fStage1Image.Get (); - } - - const dng_image * Stage2Image () const - { - return fStage2Image.Get (); - } - - const dng_image * Stage3Image () const - { - return fStage3Image.Get (); - } - - // Returns the processing stage of the raw image data. - - RawImageStageEnum RawImageStage () const - { - return fRawImageStage; - } - - // Returns the raw image data. - - const dng_image & RawImage () const; - - // API for raw floating point bit depth. - - uint32 RawFloatBitDepth () const - { - return fRawFloatBitDepth; - } - - void SetRawFloatBitDepth (uint32 bitDepth) - { - fRawFloatBitDepth = bitDepth; - } - - // API for raw jpeg image. - - const dng_jpeg_image * RawJPEGImage () const; - - void SetRawJPEGImage (AutoPtr &jpegImage); - - void ClearRawJPEGImage (); - - // API for RawJPEGImageDigest: - - void SetRawJPEGImageDigest (const dng_fingerprint &digest) - { - fRawJPEGImageDigest = digest; - } - - void ClearRawJPEGImageDigest () const - { - fRawJPEGImageDigest.Clear (); - } - - const dng_fingerprint & RawJPEGImageDigest () const - { - return fRawJPEGImageDigest; - } - - void FindRawJPEGImageDigest (dng_host &host) const; - - // Read the stage 1 image. - - virtual void ReadStage1Image (dng_host &host, - dng_stream &stream, - dng_info &info); - - // Assign the stage 1 image. - - void SetStage1Image (AutoPtr &image); - - // Assign the stage 2 image. - - void SetStage2Image (AutoPtr &image); - - // Assign the stage 3 image. - - void SetStage3Image (AutoPtr &image); - - // Build the stage 2 (linearized and range mapped) image. - - void BuildStage2Image (dng_host &host); - - // Build the stage 3 (demosaiced) image. - - void BuildStage3Image (dng_host &host, - int32 srcPlane = -1); - - // Additional gain applied when building the stage 3 image. - - void SetStage3Gain (real64 gain) - { - fStage3Gain = gain; - } - - real64 Stage3Gain () const - { - return fStage3Gain; - } - - // Adaptively encode a proxy image down to 8-bits/channel. - - dng_image * EncodeRawProxy (dng_host &host, - const dng_image &srcImage, - dng_opcode_list &opcodeList) const; - - // Convert to a proxy negative. - - void ConvertToProxy (dng_host &host, - dng_image_writer &writer, - uint32 proxySize = 0, - uint64 proxyCount = 0); - - // IsPreview API: - - void SetIsPreview (bool preview) - { - fIsPreview = preview; - } - - bool IsPreview () const - { - return fIsPreview; - } - - // IsDamaged API: - - void SetIsDamaged (bool damaged) - { - fIsDamaged = damaged; - } - - bool IsDamaged () const - { - return fIsDamaged; - } - - // Transparancy Mask API: - - void SetTransparencyMask (AutoPtr &image, - uint32 bitDepth = 0); - - const dng_image * TransparencyMask () const; - - const dng_image * RawTransparencyMask () const; - - uint32 RawTransparencyMaskBitDepth () const; - - void ReadTransparencyMask (dng_host &host, - dng_stream &stream, - dng_info &info); - - virtual bool NeedFlattenTransparency (dng_host &host); - - virtual void FlattenTransparency (dng_host &host); - - const dng_image * UnflattenedStage3Image () const; - - protected: - - dng_negative (dng_host &host); - - virtual void Initialize (); - - virtual dng_linearization_info * MakeLinearizationInfo (); - - void NeedLinearizationInfo (); - - virtual dng_mosaic_info * MakeMosaicInfo (); - - void NeedMosaicInfo (); - - virtual void DoBuildStage2 (dng_host &host); - - virtual void DoPostOpcodeList2 (dng_host &host); - - virtual bool NeedDefloatStage2 (dng_host &host); - - virtual void DefloatStage2 (dng_host &host); - - virtual void DoInterpolateStage3 (dng_host &host, - int32 srcPlane); - - virtual void DoMergeStage3 (dng_host &host); - - virtual void DoBuildStage3 (dng_host &host, - int32 srcPlane); - - virtual void AdjustProfileForStage3 (); - - virtual void ResizeTransparencyToMatchStage3 (dng_host &host, - bool convertTo8Bit = false); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_opcode_list.cpp b/third_party/dng_sdk/dng_opcode_list.cpp deleted file mode 100644 index a5af89a..0000000 --- a/third_party/dng_sdk/dng_opcode_list.cpp +++ /dev/null @@ -1,274 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_opcode_list.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_opcode_list.h" - -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_memory_stream.h" -#include "dng_negative.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -#include - -/*****************************************************************************/ - -dng_opcode_list::dng_opcode_list (uint32 stage) - - : fList () - , fAlwaysApply (false) - , fStage (stage) - - { - - } - -/******************************************************************************/ - -dng_opcode_list::~dng_opcode_list () - { - - Clear (); - - } - -/******************************************************************************/ - -void dng_opcode_list::Clear () - { - - for (size_t index = 0; index < fList.size (); index++) - { - - if (fList [index]) - { - - delete fList [index]; - - fList [index] = NULL; - - } - - } - - fList.clear (); - - fAlwaysApply = false; - - } - -/******************************************************************************/ - -void dng_opcode_list::Swap (dng_opcode_list &otherList) - { - - fList.swap (otherList.fList); - - std::swap (fAlwaysApply, otherList.fAlwaysApply); - - std::swap (fStage, otherList.fStage); - - } - -/******************************************************************************/ - -uint32 dng_opcode_list::MinVersion (bool includeOptional) const - { - - uint32 result = dngVersion_None; - - for (size_t index = 0; index < fList.size (); index++) - { - - if (includeOptional || !fList [index]->Optional ()) - { - - result = Max_uint32 (result, fList [index]->MinVersion ()); - - } - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_opcode_list::Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) - { - - for (uint32 index = 0; index < Count (); index++) - { - - dng_opcode &opcode (Entry (index)); - - if (opcode.AboutToApply (host, negative)) - { - - opcode.Apply (host, - negative, - image); - - } - - } - - } - -/*****************************************************************************/ - -void dng_opcode_list::Append (AutoPtr &opcode) - { - - if (opcode->OpcodeID () == dngOpcode_Private) - { - SetAlwaysApply (); - } - - opcode->SetStage (fStage); - - fList.push_back (NULL); - - fList [fList.size () - 1] = opcode.Release (); - - } - -/*****************************************************************************/ - -dng_memory_block * dng_opcode_list::Spool (dng_host &host) const - { - - if (IsEmpty ()) - { - return NULL; - } - - if (AlwaysApply ()) - { - ThrowProgramError (); - } - - dng_memory_stream stream (host.Allocator ()); - - stream.SetBigEndian (); - - stream.Put_uint32 ((uint32) fList.size ()); - - for (size_t index = 0; index < fList.size (); index++) - { - - stream.Put_uint32 (fList [index]->OpcodeID ()); - stream.Put_uint32 (fList [index]->MinVersion ()); - stream.Put_uint32 (fList [index]->Flags ()); - - fList [index]->PutData (stream); - - } - - return stream.AsMemoryBlock (host.Allocator ()); - - } - -/*****************************************************************************/ - -void dng_opcode_list::FingerprintToStream (dng_stream &stream) const - { - - if (IsEmpty ()) - { - return; - } - - stream.Put_uint32 ((uint32) fList.size ()); - - for (size_t index = 0; index < fList.size (); index++) - { - - stream.Put_uint32 (fList [index]->OpcodeID ()); - stream.Put_uint32 (fList [index]->MinVersion ()); - stream.Put_uint32 (fList [index]->Flags ()); - - if (fList [index]->OpcodeID () != dngOpcode_Private) - { - - fList [index]->PutData (stream); - - } - - } - - } - -/*****************************************************************************/ - -void dng_opcode_list::Parse (dng_host &host, - dng_stream &stream, - uint32 byteCount, - uint64 streamOffset) - { - - Clear (); - - TempBigEndian tempBigEndian (stream); - - stream.SetReadPosition (streamOffset); - - uint32 count = stream.Get_uint32 (); - - #if qDNGValidate - - if (gVerbose) - { - - if (count == 1) - { - printf ("1 opcode\n"); - } - - else - { - printf ("%u opcodes\n", (unsigned) count); - } - - } - - #endif - - for (uint32 index = 0; index < count; index++) - { - - uint32 opcodeID = stream.Get_uint32 (); - - AutoPtr opcode (host.Make_dng_opcode (opcodeID, - stream)); - - Append (opcode); - - } - - if (stream.Position () != streamOffset + byteCount) - { - - ThrowBadFormat ("Error parsing opcode list"); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_opcode_list.h b/third_party/dng_sdk/dng_opcode_list.h deleted file mode 100644 index 84813fb..0000000 --- a/third_party/dng_sdk/dng_opcode_list.h +++ /dev/null @@ -1,165 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_opcode_list.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * List of opcodes. - */ - -/*****************************************************************************/ - -#ifndef __dng_opcode_list__ -#define __dng_opcode_list__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_opcodes.h" - -#include - -/*****************************************************************************/ - -/// A list of opcodes. - -class dng_opcode_list - { - - private: - - std::vector fList; - - bool fAlwaysApply; - - uint32 fStage; - - public: - - /// Create an empty opcode list for the specific image stage (1, 2, or 3). - - dng_opcode_list (uint32 stage); - - ~dng_opcode_list (); - - /// Is the opcode list empty? - - bool IsEmpty () const - { - return fList.size () == 0; - } - - /// Does the list contain at least 1 opcode? - - bool NotEmpty () const - { - return !IsEmpty (); - } - - /// Should the opcode list always be applied to the image? - - bool AlwaysApply () const - { - return fAlwaysApply && NotEmpty (); - } - - /// Set internal flag to indicate this opcode list should always be - /// applied. - - void SetAlwaysApply () - { - fAlwaysApply = true; - } - - /// The number of opcodes in this list. - - uint32 Count () const - { - return (uint32) fList.size (); - } - - /// Retrieve read/write opcode by index (must be in the range 0 to Count - /// () - 1). - - dng_opcode & Entry (uint32 index) - { - return *fList [index]; - } - - /// Retrieve read-only opcode by index (must be in the range 0 to Count - /// () - 1). - - const dng_opcode & Entry (uint32 index) const - { - return *fList [index]; - } - - /// Remove all opcodes from the list. - - void Clear (); - - /// Swap two opcode lists. - - void Swap (dng_opcode_list &otherList); - - /// Return minimum DNG version required to support all opcodes in this - /// list. If includeOptional is set to true, then this calculation will - /// include optional opcodes. - - uint32 MinVersion (bool includeOptional) const; - - /// Apply this opcode list to the specified image with corresponding - /// negative. - - void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - /// Append the specified opcode to this list. - - void Append (AutoPtr &opcode); - - /// Serialize this opcode list to a block of memory. The caller is - /// responsible for deleting this block. - - dng_memory_block * Spool (dng_host &host) const; - - /// Write a fingerprint of this opcode list to the specified stream. - - void FingerprintToStream (dng_stream &stream) const; - - /// Read an opcode list from the specified stream, starting at the - /// specified offset (streamOffset, in bytes). byteCount is provided for - /// error checking purposes. A bad format exception - /// will be thrown if the length of the opcode stream does not exactly - /// match byteCount. - - void Parse (dng_host &host, - dng_stream &stream, - uint32 byteCount, - uint64 streamOffset); - - private: - - // Hidden copy constructor and assignment operator. - - dng_opcode_list (const dng_opcode_list &list); - - dng_opcode_list & operator= (const dng_opcode_list &list); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_opcodes.cpp b/third_party/dng_sdk/dng_opcodes.cpp deleted file mode 100644 index dedf097..0000000 --- a/third_party/dng_sdk/dng_opcodes.cpp +++ /dev/null @@ -1,572 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_opcodes.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_opcodes.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_filter_task.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_negative.h" -#include "dng_parse_utils.h" -#include "dng_stream.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -dng_opcode::dng_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags) - - : fOpcodeID (opcodeID) - , fMinVersion (minVersion) - , fFlags (flags) - , fWasReadFromStream (false) - , fStage (0) - - { - - } - -/*****************************************************************************/ - -dng_opcode::dng_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name) - - : fOpcodeID (opcodeID) - , fMinVersion (0) - , fFlags (0) - , fWasReadFromStream (true) - , fStage (0) - - { - - fMinVersion = stream.Get_uint32 (); - fFlags = stream.Get_uint32 (); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("\nOpcode: "); - - if (name) - { - printf ("%s", name); - } - else - { - printf ("Unknown (%u)", (unsigned) opcodeID); - } - - printf (", minVersion = %u.%u.%u.%u", - (unsigned) ((fMinVersion >> 24) & 0x0FF), - (unsigned) ((fMinVersion >> 16) & 0x0FF), - (unsigned) ((fMinVersion >> 8) & 0x0FF), - (unsigned) ((fMinVersion ) & 0x0FF)); - - printf (", flags = %u\n", (unsigned) fFlags); - - } - - #else - - (void) name; - - #endif - - } - -/*****************************************************************************/ - -dng_opcode::~dng_opcode () - { - - } - -/*****************************************************************************/ - -void dng_opcode::PutData (dng_stream &stream) const - { - - // No data by default - - stream.Put_uint32 (0); - - } - -/*****************************************************************************/ - -bool dng_opcode::AboutToApply (dng_host &host, - dng_negative &negative) - { - - if (SkipIfPreview () && host.ForPreview ()) - { - - negative.SetIsPreview (true); - - } - - else if (MinVersion () > dngVersion_Current && - WasReadFromStream ()) - { - - if (!Optional ()) - { - - // Somebody screwed up computing the DNGBackwardVersion... - - ThrowBadFormat (); - - } - - } - - else if (!IsValidForNegative (negative)) - { - - ThrowBadFormat (); - - } - - else if (!IsNOP ()) - { - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -dng_opcode_Unknown::dng_opcode_Unknown (dng_host &host, - uint32 opcodeID, - dng_stream &stream) - - : dng_opcode (opcodeID, - stream, - NULL) - - , fData () - - { - - uint32 size = stream.Get_uint32 (); - - if (size) - { - - fData.Reset (host.Allocate (size)); - - stream.Get (fData->Buffer (), - fData->LogicalSize ()); - - #if qDNGValidate - - if (gVerbose) - { - - DumpHexAscii (fData->Buffer_uint8 (), - fData->LogicalSize ()); - - } - - #endif - - } - - } - -/*****************************************************************************/ - -void dng_opcode_Unknown::PutData (dng_stream &stream) const - { - - if (fData.Get ()) - { - - stream.Put_uint32 (fData->LogicalSize ()); - - stream.Put (fData->Buffer (), - fData->LogicalSize ()); - - } - - else - { - - stream.Put_uint32 (0); - - } - - } - -/*****************************************************************************/ - -void dng_opcode_Unknown::Apply (dng_host & /* host */, - dng_negative & /* negative */, - AutoPtr & /* image */) - { - - // We should never need to apply an unknown opcode. - - if (!Optional ()) - { - - ThrowBadFormat (); - - } - - } - -/*****************************************************************************/ - -class dng_filter_opcode_task: public dng_filter_task - { - - private: - - dng_filter_opcode &fOpcode; - - dng_negative &fNegative; - - public: - - dng_filter_opcode_task (dng_filter_opcode &opcode, - dng_negative &negative, - const dng_image &srcImage, - dng_image &dstImage) - - : dng_filter_task (srcImage, - dstImage) - - , fOpcode (opcode) - , fNegative (negative) - - { - - fSrcPixelType = fOpcode.BufferPixelType (srcImage.PixelType ()); - - fDstPixelType = fSrcPixelType; - - fSrcRepeat = opcode.SrcRepeat (); - - } - - virtual dng_rect SrcArea (const dng_rect &dstArea) - { - - return fOpcode.SrcArea (dstArea, - fDstImage.Bounds ()); - - } - - virtual dng_point SrcTileSize (const dng_point &dstTileSize) - { - - return fOpcode.SrcTileSize (dstTileSize, - fDstImage.Bounds ()); - - } - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - fOpcode.ProcessArea (fNegative, - threadIndex, - srcBuffer, - dstBuffer, - dstBuffer.Area (), - fDstImage.Bounds ()); - - } - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer) - { - - dng_filter_task::Start (threadCount, - tileSize, - allocator, - sniffer); - - fOpcode.Prepare (fNegative, - threadCount, - tileSize, - fDstImage.Bounds (), - fDstImage.Planes (), - fDstPixelType, - *allocator); - - } - - }; - -/*****************************************************************************/ - -dng_filter_opcode::dng_filter_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags) - - : dng_opcode (opcodeID, - minVersion, - flags) - - { - - } - -/*****************************************************************************/ - -dng_filter_opcode::dng_filter_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name) - - : dng_opcode (opcodeID, - stream, - name) - - { - - } - -/*****************************************************************************/ - -void dng_filter_opcode::Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) - { - - dng_rect modifiedBounds = ModifiedBounds (image->Bounds ()); - - if (modifiedBounds.NotEmpty ()) - { - - // Allocate destination image. - - AutoPtr dstImage; - - // If we are processing the entire image, allocate an - // undefined image. - - if (modifiedBounds == image->Bounds ()) - { - - dstImage.Reset (host.Make_dng_image (image->Bounds (), - image->Planes (), - image->PixelType ())); - - } - - // Else start with a clone of the existing image. - - else - { - - dstImage.Reset (image->Clone ()); - - } - - // Filter the image. - - dng_filter_opcode_task task (*this, - negative, - *image, - *dstImage); - - host.PerformAreaTask (task, - modifiedBounds); - - // Return the new image. - - image.Reset (dstImage.Release ()); - - } - - } - -/*****************************************************************************/ - -class dng_inplace_opcode_task: public dng_area_task - { - - private: - - dng_inplace_opcode &fOpcode; - - dng_negative &fNegative; - - dng_image &fImage; - - uint32 fPixelType; - - AutoPtr fBuffer [kMaxMPThreads]; - - public: - - dng_inplace_opcode_task (dng_inplace_opcode &opcode, - dng_negative &negative, - dng_image &image) - - : dng_area_task () - - , fOpcode (opcode) - , fNegative (negative) - , fImage (image) - , fPixelType (opcode.BufferPixelType (image.PixelType ())) - - { - - } - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer * /* sniffer */) - { - - uint32 pixelSize = TagTypeSize (fPixelType); - - uint32 bufferSize = tileSize.v * - RoundUpForPixelSize (tileSize.h, pixelSize) * - pixelSize * - fImage.Planes (); - - for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) - { - - fBuffer [threadIndex] . Reset (allocator->Allocate (bufferSize)); - - } - - fOpcode.Prepare (fNegative, - threadCount, - tileSize, - fImage.Bounds (), - fImage.Planes (), - fPixelType, - *allocator); - - } - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer * /* sniffer */) - { - - // Setup buffer. - - dng_pixel_buffer buffer; - - buffer.fArea = tile; - - buffer.fPlane = 0; - buffer.fPlanes = fImage.Planes (); - - buffer.fPixelType = fPixelType; - buffer.fPixelSize = TagTypeSize (fPixelType); - - buffer.fPlaneStep = RoundUpForPixelSize (tile.W (), - buffer.fPixelSize); - - buffer.fRowStep = buffer.fPlaneStep * - buffer.fPlanes; - - buffer.fData = fBuffer [threadIndex]->Buffer (); - - // Get source pixels. - - fImage.Get (buffer); - - // Process area. - - fOpcode.ProcessArea (fNegative, - threadIndex, - buffer, - tile, - fImage.Bounds ()); - - // Save result pixels. - - fImage.Put (buffer); - - } - - }; - -/*****************************************************************************/ - -dng_inplace_opcode::dng_inplace_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags) - - : dng_opcode (opcodeID, - minVersion, - flags) - - { - - } - -/*****************************************************************************/ - -dng_inplace_opcode::dng_inplace_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name) - - : dng_opcode (opcodeID, - stream, - name) - - { - - } - -/*****************************************************************************/ - -void dng_inplace_opcode::Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) - { - - dng_rect modifiedBounds = ModifiedBounds (image->Bounds ()); - - if (modifiedBounds.NotEmpty ()) - { - - dng_inplace_opcode_task task (*this, - negative, - *image); - - host.PerformAreaTask (task, - modifiedBounds); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_opcodes.h b/third_party/dng_sdk/dng_opcodes.h deleted file mode 100644 index b214540..0000000 --- a/third_party/dng_sdk/dng_opcodes.h +++ /dev/null @@ -1,507 +0,0 @@ -/*****************************************************************************/ -// Copyright 2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_opcodes.h#2 $ */ -/* $DateTime: 2012/08/02 06:09:06 $ */ -/* $Change: 841096 $ */ -/* $Author: erichan $ */ - -/** \file - * Base class and common data structures for opcodes (introduced in DNG 1.3). - */ - -/*****************************************************************************/ - -#ifndef __dng_opcodes__ -#define __dng_opcodes__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_rect.h" -#include "dng_types.h" - -/*****************************************************************************/ - -/// \brief List of supported opcodes (by ID). - -enum dng_opcode_id - { - - // Internal use only opcode. Never written to DNGs. - - dngOpcode_Private = 0, - - // Warp image to correct distortion and lateral chromatic aberration for - // rectilinear lenses. - - dngOpcode_WarpRectilinear = 1, - - // Warp image to correction distortion for fisheye lenses (i.e., map the - // fisheye projection to a perspective projection). - - dngOpcode_WarpFisheye = 2, - - // Radial vignette correction. - - dngOpcode_FixVignetteRadial = 3, - - // Patch bad Bayer pixels which are marked with a special value in the image. - - dngOpcode_FixBadPixelsConstant = 4, - - // Patch bad Bayer pixels/rectangles at a list of specified coordinates. - - dngOpcode_FixBadPixelsList = 5, - - // Trim image to specified bounds. - - dngOpcode_TrimBounds = 6, - - // Map an area through a 16-bit LUT. - - dngOpcode_MapTable = 7, - - // Map an area using a polynomial function. - - dngOpcode_MapPolynomial = 8, - - // Apply a gain map to an area. - - dngOpcode_GainMap = 9, - - // Apply a per-row delta to an area. - - dngOpcode_DeltaPerRow = 10, - - // Apply a per-column delta to an area. - - dngOpcode_DeltaPerColumn = 11, - - // Apply a per-row scale to an area. - - dngOpcode_ScalePerRow = 12, - - // Apply a per-column scale to an area. - - dngOpcode_ScalePerColumn = 13 - - }; - -/*****************************************************************************/ - -/// \brief Virtual base class for opcode. - -class dng_opcode - { - - public: - - /// Opcode flags. - - enum - { - kFlag_None = 0, //!< No flag. - kFlag_Optional = 1, //!< This opcode is optional. - kFlag_SkipIfPreview = 2 //!< May skip opcode for preview images. - }; - - private: - - uint32 fOpcodeID; - - uint32 fMinVersion; - - uint32 fFlags; - - bool fWasReadFromStream; - - uint32 fStage; - - protected: - - dng_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags); - - dng_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name); - - public: - - virtual ~dng_opcode (); - - /// The ID of this opcode. - - uint32 OpcodeID () const - { - return fOpcodeID; - } - - /// The first DNG version that supports this opcode. - - uint32 MinVersion () const - { - return fMinVersion; - } - - /// The flags for this opcode. - - uint32 Flags () const - { - return fFlags; - } - - /// Is this opcode optional? - - bool Optional () const - { - return (Flags () & kFlag_Optional) != 0; - } - - /// Should the opcode be skipped when rendering preview images? - - bool SkipIfPreview () const - { - return (Flags () & kFlag_SkipIfPreview) != 0; - } - - /// Was this opcode read from a data stream? - - bool WasReadFromStream () const - { - return fWasReadFromStream; - } - - /// Which image processing stage (1, 2, 3) is associated with this - /// opcode? - - uint32 Stage () const - { - return fStage; - } - - /// Set the image processing stage (1, 2, 3) for this opcode. Stage 1 is - /// the original image data, including masked areas. Stage 2 is - /// linearized image data and trimmed to the active area. Stage 3 is - /// demosaiced and trimmed to the active area. - - void SetStage (uint32 stage) - { - fStage = stage; - } - - /// Is the opcode a NOP (i.e., does nothing)? An opcode could be a NOP - /// for some specific parameters. - - virtual bool IsNOP () const - { - return false; - } - - /// Is this opcode valid for the specified negative? - - virtual bool IsValidForNegative (const dng_negative & /* negative */) const - { - return true; - } - - /// Write opcode to a stream. - /// \param stream The stream to which to write the opcode data. - - virtual void PutData (dng_stream &stream) const; - - /// Perform error checking prior to applying this opcode to the - /// specified negative. Returns true if this opcode should be applied to - /// the negative, false otherwise. - - bool AboutToApply (dng_host &host, - dng_negative &negative); - - /// Apply this opcode to the specified image with associated negative. - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image) = 0; - - }; - -/*****************************************************************************/ - -/// \brief Class to represent unknown opcodes (e.g, opcodes defined in future -/// DNG versions). - -class dng_opcode_Unknown: public dng_opcode - { - - private: - - AutoPtr fData; - - public: - - dng_opcode_Unknown (dng_host &host, - uint32 opcodeID, - dng_stream &stream); - - virtual void PutData (dng_stream &stream) const; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - }; - -/*****************************************************************************/ - -/// \brief Class to represent a filter opcode, such as a convolution. - -class dng_filter_opcode: public dng_opcode - { - - protected: - - dng_filter_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags); - - dng_filter_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name); - - public: - - /// The pixel data type of this opcode. - - virtual uint32 BufferPixelType (uint32 imagePixelType) - { - return imagePixelType; - } - - /// The adjusted bounds (processing area) of this opcode. It is limited to - /// the intersection of the specified image area and the GainMap area. - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds) - { - return imageBounds; - } - - /// Returns the width and height (in pixels) of the repeating mosaic pattern. - - virtual dng_point SrcRepeat () - { - return dng_point (1, 1); - } - - /// Returns the source pixel area needed to process a destination pixel area - /// that lies within the specified bounds. - /// \param dstArea The destination pixel area to be computed. - /// \param imageBounds The overall image area (dstArea will lie within these - /// bounds). - /// \retval The source pixel area needed to process the specified dstArea. - - virtual dng_rect SrcArea (const dng_rect &dstArea, - const dng_rect & /* imageBounds */) - { - return dstArea; - } - - /// Given a destination tile size, calculate input tile size. Simlar to - /// SrcArea, and should seldom be overridden. - /// - /// \param dstTileSize The destination tile size that is targeted for output. - /// - /// \param imageBounds The image bounds (the destination tile will - /// always lie within these bounds). - /// - /// \retval The source tile size needed to compute a tile of the destination - /// size. - - virtual dng_point SrcTileSize (const dng_point &dstTileSize, - const dng_rect &imageBounds) - { - return SrcArea (dng_rect (dstTileSize), - imageBounds).Size (); - } - - /// Startup method called before any processing is performed on pixel areas. - /// It can be used to allocate (per-thread) memory and setup tasks. - /// - /// \param negative The negative object to be processed. - /// - /// \param threadCount The number of threads to be used to perform the - /// processing. - /// - /// \param threadCount Total number of threads that will be used for - /// processing. Less than or equal to MaxThreads. - /// - /// \param tileSize Size of source tiles which will be processed. (Not all - /// tiles will be this size due to edge conditions.) - /// - /// \param imageBounds Total size of image to be processed. - /// - /// \param imagePlanes Number of planes in the image. Less than or equal to - /// kMaxColorPlanes. - /// - /// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h). - /// - /// \param allocator dng_memory_allocator to use for allocating temporary - /// buffers, etc. - - virtual void Prepare (dng_negative & /* negative */, - uint32 /* threadCount */, - const dng_point & /* tileSize */, - const dng_rect & /* imageBounds */, - uint32 /* imagePlanes */, - uint32 /* bufferPixelType */, - dng_memory_allocator & /* allocator */) - { - } - - /// Implements filtering operation from one buffer to another. Source - /// and destination pixels are set up in member fields of this class. - /// Ideally, no allocation should be done in this routine. - /// - /// \param negative The negative associated with the pixels to be - /// processed. - /// - /// \param threadIndex The thread on which this routine is being called, - /// between 0 and threadCount - 1 for the threadCount passed to Prepare - /// method. - /// - /// \param srcBuffer Input area and source pixels. - /// - /// \param dstBuffer Destination pixels. - /// - /// \param dstArea Destination pixel processing area. - /// - /// \param imageBounds Total image area to be processed; dstArea will - /// always lie within these bounds. - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer, - const dng_rect &dstArea, - const dng_rect &imageBounds) = 0; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - }; - -/*****************************************************************************/ - -/// \brief Class to represent an in-place (i.e., pointwise, per-pixel) opcode, -/// such as a global tone curve. - -class dng_inplace_opcode: public dng_opcode - { - - protected: - - dng_inplace_opcode (uint32 opcodeID, - uint32 minVersion, - uint32 flags); - - dng_inplace_opcode (uint32 opcodeID, - dng_stream &stream, - const char *name); - - public: - - /// The pixel data type of this opcode. - - virtual uint32 BufferPixelType (uint32 imagePixelType) - { - return imagePixelType; - } - - /// The adjusted bounds (processing area) of this opcode. It is limited to - /// the intersection of the specified image area and the GainMap area. - - virtual dng_rect ModifiedBounds (const dng_rect &imageBounds) - { - return imageBounds; - } - - /// Startup method called before any processing is performed on pixel areas. - /// It can be used to allocate (per-thread) memory and setup tasks. - /// - /// \param negative The negative object to be processed. - /// - /// \param threadCount The number of threads to be used to perform the - /// processing. - /// - /// \param threadCount Total number of threads that will be used for - /// processing. Less than or equal to MaxThreads. - /// - /// \param tileSize Size of source tiles which will be processed. (Not all - /// tiles will be this size due to edge conditions.) - /// - /// \param imageBounds Total size of image to be processed. - /// - /// \param imagePlanes Number of planes in the image. Less than or equal to - /// kMaxColorPlanes. - /// - /// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h). - /// - /// \param allocator dng_memory_allocator to use for allocating temporary - /// buffers, etc. - - virtual void Prepare (dng_negative & /* negative */, - uint32 /* threadCount */, - const dng_point & /* tileSize */, - const dng_rect & /* imageBounds */, - uint32 /* imagePlanes */, - uint32 /* bufferPixelType */, - dng_memory_allocator & /* allocator */) - { - } - - /// Implements image processing operation in a single buffer. The source - /// pixels are provided as input to the buffer, and this routine - /// calculates and writes the destination pixels to the same buffer. - /// Ideally, no allocation should be done in this routine. - /// - /// \param negative The negative associated with the pixels to be - /// processed. - /// - /// \param threadIndex The thread on which this routine is being called, - /// between 0 and threadCount - 1 for the threadCount passed to Prepare - /// method. - /// - /// \param srcBuffer Input area and source pixels. - /// - /// \param dstBuffer Destination pixels. - /// - /// \param dstArea Destination pixel processing area. - /// - /// \param imageBounds Total image area to be processed; dstArea will - /// always lie within these bounds. - - virtual void ProcessArea (dng_negative &negative, - uint32 threadIndex, - dng_pixel_buffer &buffer, - const dng_rect &dstArea, - const dng_rect &imageBounds) = 0; - - virtual void Apply (dng_host &host, - dng_negative &negative, - AutoPtr &image); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_orientation.cpp b/third_party/dng_sdk/dng_orientation.cpp deleted file mode 100644 index 820ca34..0000000 --- a/third_party/dng_sdk/dng_orientation.cpp +++ /dev/null @@ -1,233 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_orientation.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -#include "dng_orientation.h" - -/*****************************************************************************/ - -void dng_orientation::SetTIFF (uint32 tiff) - { - - switch (tiff) - { - - case 1: - { - fAdobeOrientation = kNormal; - break; - } - - case 2: - { - fAdobeOrientation = kMirror; - break; - } - - case 3: - { - fAdobeOrientation = kRotate180; - break; - } - - case 4: - { - fAdobeOrientation = kMirror180; - break; - } - - case 5: - { - fAdobeOrientation = kMirror90CCW; - break; - } - - case 6: - { - fAdobeOrientation = kRotate90CW; - break; - } - - case 7: - { - fAdobeOrientation = kMirror90CW; - break; - } - - case 8: - { - fAdobeOrientation = kRotate90CCW; - break; - } - - case 9: - { - fAdobeOrientation = kUnknown; - break; - } - - default: - { - fAdobeOrientation = kNormal; - } - - } - - } - -/*****************************************************************************/ - -uint32 dng_orientation::GetTIFF () const - { - - switch (fAdobeOrientation) - { - - case kNormal: - { - return 1; - } - - case kMirror: - { - return 2; - } - - case kRotate180: - { - return 3; - } - - case kMirror180: - { - return 4; - } - - case kMirror90CCW: - { - return 5; - } - - case kRotate90CW: - { - return 6; - } - - case kMirror90CW: - { - return 7; - } - - case kRotate90CCW: - { - return 8; - } - - case kUnknown: - { - return 9; - } - - default: - break; - - } - - return 1; - - } - -/*****************************************************************************/ - -bool dng_orientation::FlipD () const - { - - return (fAdobeOrientation & 1) != 0; - - } - -/*****************************************************************************/ - -bool dng_orientation::FlipH () const - { - - if (fAdobeOrientation & 4) - return (fAdobeOrientation & 2) == 0; - - else - return (fAdobeOrientation & 2) != 0; - - } - -/*****************************************************************************/ - -bool dng_orientation::FlipV () const - { - - if (fAdobeOrientation & 4) - return FlipD () == FlipH (); - - else - return FlipD () != FlipH (); - - } - -/*****************************************************************************/ - -dng_orientation dng_orientation::operator- () const - { - - uint32 x = GetAdobe (); - - if ((x & 5) == 5) - { - - x ^= 2; - - } - - dng_orientation result; - - result.SetAdobe (((4 - x) & 3) | (x & 4)); - - return result; - - } - -/*****************************************************************************/ - -dng_orientation dng_orientation::operator+ (const dng_orientation &b) const - { - - uint32 x = GetAdobe (); - - uint32 y = b.GetAdobe (); - - if (y & 4) - { - - if (x & 1) - x ^= 6; - else - x ^= 4; - - } - - dng_orientation result; - - result.SetAdobe (((x + y) & 3) | (x & 4)); - - return result; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_orientation.h b/third_party/dng_sdk/dng_orientation.h deleted file mode 100644 index cb23adf..0000000 --- a/third_party/dng_sdk/dng_orientation.h +++ /dev/null @@ -1,189 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_orientation.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/******************************************************************************/ - -#ifndef __dng_orientation__ -#define __dng_orientation__ - -/******************************************************************************/ - -#include "dng_types.h" - -/******************************************************************************/ - -class dng_orientation - { - - private: - - // We internally use an orientation encoding ("Adobe") that is - // different than the TIFF orientation encoding ("TIFF"). - - uint32 fAdobeOrientation; - - public: - enum - { - kNormal = 0, - kRotate90CW = 1, - kRotate180 = 2, - kRotate90CCW = 3, - kMirror = 4, - kMirror90CW = 5, - kMirror180 = 6, - kMirror90CCW = 7, - kUnknown = 8 - }; - - - dng_orientation () - - : fAdobeOrientation (kNormal) - - { - } - - void SetAdobe (uint32 adobe) - { - fAdobeOrientation = adobe; - } - - uint32 GetAdobe () const - { - return fAdobeOrientation; - } - - void SetTIFF (uint32 tiff); - - uint32 GetTIFF () const; - - static dng_orientation AdobeToDNG (uint32 adobe) - { - - dng_orientation result; - - result.SetAdobe (adobe); - - return result; - - } - - static dng_orientation TIFFtoDNG (uint32 tiff) - { - - dng_orientation result; - - result.SetTIFF (tiff); - - return result; - - } - - static dng_orientation Normal () - { - return AdobeToDNG (kNormal); - } - - static dng_orientation Rotate90CW () - { - return AdobeToDNG (kRotate90CW); - } - - static dng_orientation Rotate180 () - { - return AdobeToDNG (kRotate180); - } - - static dng_orientation Rotate90CCW () - { - return AdobeToDNG (kRotate90CCW); - } - - static dng_orientation Mirror () - { - return AdobeToDNG (kMirror); - } - - static dng_orientation Mirror90CW () - { - return AdobeToDNG (kMirror90CW); - } - - static dng_orientation Mirror180 () - { - return AdobeToDNG (kMirror180); - } - - static dng_orientation Mirror90CCW () - { - return AdobeToDNG (kMirror90CCW); - } - - static dng_orientation Unknown () - { - return AdobeToDNG (kUnknown); - } - - bool IsValid () const - { - return fAdobeOrientation < kUnknown; - } - - bool NotValid () const - { - return !IsValid (); - } - - bool FlipD () const; - - bool FlipH () const; - - bool FlipV () const; - - bool operator== (const dng_orientation &b) const - { - return fAdobeOrientation == b.fAdobeOrientation; - } - - bool operator!= (const dng_orientation &b) const - { - return !(*this == b); - } - - dng_orientation operator- () const; - - dng_orientation operator+ (const dng_orientation &b) const; - - dng_orientation operator- (const dng_orientation &b) const - { - return (*this) + (-b); - } - - void operator+= (const dng_orientation &b) - { - *this = *this + b; - } - - void operator-= (const dng_orientation &b) - { - *this = *this - b; - } - - }; - -/******************************************************************************/ - -#endif - -/******************************************************************************/ diff --git a/third_party/dng_sdk/dng_parse_utils.cpp b/third_party/dng_sdk/dng_parse_utils.cpp deleted file mode 100644 index 879efbc..0000000 --- a/third_party/dng_sdk/dng_parse_utils.cpp +++ /dev/null @@ -1,3326 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_parse_utils.cpp#3 $ */ -/* $DateTime: 2012/06/06 12:08:58 $ */ -/* $Change: 833617 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_parse_utils.h" - -#include "dng_date_time.h" -#include "dng_globals.h" -#include "dng_ifd.h" -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_types.h" -#include "dng_stream.h" -#include "dng_exceptions.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -#if qDNGValidate - -/*****************************************************************************/ - -struct dng_name_table - { - uint32 key; - const char *name; - }; - -/*****************************************************************************/ - -static const char * LookupName (uint32 key, - const dng_name_table *table, - uint32 table_entries) - { - - for (uint32 index = 0; index < table_entries; index++) - { - - if (key == table [index] . key) - { - - return table [index] . name; - - } - - } - - return NULL; - - } - -/*****************************************************************************/ - -const char * LookupParentCode (uint32 parentCode) - { - - const dng_name_table kParentCodeNames [] = - { - { 0, "IFD 0" }, - { tcExifIFD, "Exif IFD" }, - { tcGPSInfo, "GPS IFD" }, - { tcInteroperabilityIFD, "Interoperability IFD" }, - { tcKodakDCRPrivateIFD, "Kodak DCR Private IFD" }, - { tcKodakKDCPrivateIFD, "Kodak KDC Private IFD" }, - { tcCanonMakerNote, "Canon MakerNote" }, - { tcEpsonMakerNote, "Epson MakerNote" }, - { tcFujiMakerNote, "Fuji MakerNote" }, - { tcHasselbladMakerNote, "Hasselblad MakerNote" }, - { tcKodakMakerNote, "Kodak MakerNote" }, - { tcKodakMakerNote65280, "Kodak MakerNote 65280" }, - { tcLeicaMakerNote, "Leica MakerNote" }, - { tcMamiyaMakerNote, "Mamiya MakerNote" }, - { tcMinoltaMakerNote, "Minolta MakerNote" }, - { tcNikonMakerNote, "Nikon MakerNote" }, - { tcOlympusMakerNote, "Olympus MakerNote" }, - { tcOlympusMakerNote8208, "Olympus MakerNote 8208" }, - { tcOlympusMakerNote8224, "Olympus MakerNote 8224" }, - { tcOlympusMakerNote8240, "Olympus MakerNote 8240" }, - { tcOlympusMakerNote8256, "Olympus MakerNote 8256" }, - { tcOlympusMakerNote8272, "Olympus MakerNote 8272" }, - { tcOlympusMakerNote12288, "Olympus MakerNote 12288" }, - { tcPanasonicMakerNote, "Panasonic MakerNote" }, - { tcPentaxMakerNote, "Pentax MakerNote" }, - { tcPhaseOneMakerNote, "Phase One MakerNote" }, - { tcRicohMakerNote, "Ricoh MakerNote" }, - { tcRicohMakerNoteCameraInfo, "Ricoh MakerNote Camera Info" }, - { tcSonyMakerNote, "Sony MakerNote" }, - { tcSonyMakerNoteSubInfo, "Sony MakerNote SubInfo" }, - { tcSonyPrivateIFD1, "Sony Private IFD 1" }, - { tcSonyPrivateIFD2, "Sony Private IFD 2" }, - { tcSonyPrivateIFD3A, "Sony Private IFD 3A" }, - { tcSonyPrivateIFD3B, "Sony Private IFD 3B" }, - { tcSonyPrivateIFD3C, "Sony Private IFD 3C" }, - { tcCanonCRW, "Canon CRW" }, - { tcContaxRAW, "Contax RAW" }, - { tcFujiRAF, "Fuji RAF" }, - { tcLeafMOS, "Leaf MOS" }, - { tcMinoltaMRW, "Minolta MRW" }, - { tcPanasonicRAW, "Panasonic RAW" }, - { tcFoveonX3F, "Foveon X3F" }, - { tcJPEG, "JPEG" }, - { tcAdobePSD, "Adobe PSD" } - }; - - const char *name = LookupName (parentCode, - kParentCodeNames, - sizeof (kParentCodeNames ) / - sizeof (kParentCodeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - if (parentCode >= tcFirstSubIFD && - parentCode <= tcLastSubIFD) - { - - sprintf (s, "SubIFD %u", (unsigned) (parentCode - tcFirstSubIFD + 1)); - - } - - else if (parentCode >= tcFirstChainedIFD && - parentCode <= tcLastChainedIFD) - { - - sprintf (s, "Chained IFD %u", (unsigned) (parentCode - tcFirstChainedIFD + 1)); - - } - - else - { - - sprintf (s, "ParentIFD %u", (unsigned) parentCode); - - } - - return s; - - } - -/*****************************************************************************/ - -const char * LookupTagCode (uint32 parentCode, - uint32 tagCode) - { - - const dng_name_table kTagNames [] = - { - { tcNewSubFileType, "NewSubFileType" }, - { tcSubFileType, "SubFileType" }, - { tcImageWidth, "ImageWidth" }, - { tcImageLength, "ImageLength" }, - { tcBitsPerSample, "BitsPerSample" }, - { tcCompression, "Compression" }, - { tcPhotometricInterpretation, "PhotometricInterpretation" }, - { tcThresholding, "Thresholding" }, - { tcCellWidth, "CellWidth" }, - { tcCellLength, "CellLength" }, - { tcFillOrder, "FillOrder" }, - { tcImageDescription, "ImageDescription" }, - { tcMake, "Make" }, - { tcModel, "Model" }, - { tcStripOffsets, "StripOffsets" }, - { tcOrientation, "Orientation" }, - { tcSamplesPerPixel, "SamplesPerPixel" }, - { tcRowsPerStrip, "RowsPerStrip" }, - { tcStripByteCounts, "StripByteCounts" }, - { tcMinSampleValue, "MinSampleValue" }, - { tcMaxSampleValue, "MaxSampleValue" }, - { tcXResolution, "XResolution" }, - { tcYResolution, "YResolution" }, - { tcPlanarConfiguration, "PlanarConfiguration" }, - { tcFreeOffsets, "FreeOffsets" }, - { tcFreeByteCounts, "FreeByteCounts" }, - { tcGrayResponseUnit, "GrayResponseUnit" }, - { tcGrayResponseCurve, "GrayResponseCurve" }, - { tcResolutionUnit, "ResolutionUnit" }, - { tcTransferFunction, "TransferFunction" }, - { tcSoftware, "Software" }, - { tcDateTime, "DateTime" }, - { tcArtist, "Artist" }, - { tcHostComputer, "HostComputer" }, - { tcWhitePoint, "WhitePoint" }, - { tcPrimaryChromaticities, "PrimaryChromaticities" }, - { tcColorMap, "ColorMap" }, - { tcTileWidth, "TileWidth" }, - { tcTileLength, "TileLength" }, - { tcTileOffsets, "TileOffsets" }, - { tcTileByteCounts, "TileByteCounts" }, - { tcSubIFDs, "SubIFDs" }, - { tcExtraSamples, "ExtraSamples" }, - { tcSampleFormat, "SampleFormat" }, - { tcJPEGTables, "JPEGTables" }, - { tcJPEGProc, "JPEGProc" }, - { tcJPEGInterchangeFormat, "JPEGInterchangeFormat" }, - { tcJPEGInterchangeFormatLength, "JPEGInterchangeFormatLength" }, - { tcYCbCrCoefficients, "YCbCrCoefficients" }, - { tcYCbCrSubSampling, "YCbCrSubSampling" }, - { tcYCbCrPositioning, "YCbCrPositioning" }, - { tcReferenceBlackWhite, "ReferenceBlackWhite" }, - { tcXMP, "XMP" }, - { tcKodakCameraSerialNumber, "KodakCameraSerialNumber" }, - { tcCFARepeatPatternDim, "CFARepeatPatternDim" }, - { tcCFAPattern, "CFAPattern" }, - { tcBatteryLevel, "BatteryLevel" }, - { tcKodakDCRPrivateIFD, "KodakDCRPrivateIFD" }, - { tcCopyright, "Copyright" }, - { tcExposureTime, "ExposureTime" }, - { tcFNumber, "FNumber" }, - { tcIPTC_NAA, "IPTC/NAA" }, - { tcLeafPKTS, "LeafPKTS" }, - { tcAdobeData, "AdobeData" }, - { tcExifIFD, "ExifIFD" }, - { tcICCProfile, "ICCProfile" }, - { tcExposureProgram, "ExposureProgram" }, - { tcSpectralSensitivity, "SpectralSensitivity" }, - { tcGPSInfo, "GPSInfo" }, - { tcISOSpeedRatings, "ISOSpeedRatings" }, - { tcOECF, "OECF" }, - { tcInterlace, "Interlace" }, - { tcTimeZoneOffset, "TimeZoneOffset" }, - { tcSelfTimerMode, "SelfTimerMode" }, - { tcSensitivityType, "SensitivityType" }, - { tcStandardOutputSensitivity, "StandardOutputSensitivity" }, - { tcRecommendedExposureIndex, "RecommendedExposureIndex" }, - { tcISOSpeed, "ISOSpeed" }, - { tcISOSpeedLatitudeyyy, "ISOSpeedLatitudeyyy" }, - { tcISOSpeedLatitudezzz, "ISOSpeedLatitudezzz" }, - { tcExifVersion, "ExifVersion" }, - { tcDateTimeOriginal, "DateTimeOriginal" }, - { tcDateTimeDigitized, "DateTimeDigitized" }, - { tcComponentsConfiguration, "ComponentsConfiguration" }, - { tcCompressedBitsPerPixel, "CompressedBitsPerPixel" }, - { tcShutterSpeedValue, "ShutterSpeedValue" }, - { tcApertureValue, "ApertureValue" }, - { tcBrightnessValue, "BrightnessValue" }, - { tcExposureBiasValue, "ExposureBiasValue" }, - { tcMaxApertureValue, "MaxApertureValue" }, - { tcSubjectDistance, "SubjectDistance" }, - { tcMeteringMode, "MeteringMode" }, - { tcLightSource, "LightSource" }, - { tcFlash, "Flash" }, - { tcFocalLength, "FocalLength" }, - { tcFlashEnergy, "FlashEnergy" }, - { tcSpatialFrequencyResponse, "SpatialFrequencyResponse" }, - { tcNoise, "Noise" }, - { tcFocalPlaneXResolution, "FocalPlaneXResolution" }, - { tcFocalPlaneYResolution, "FocalPlaneYResolution" }, - { tcFocalPlaneResolutionUnit, "FocalPlaneResolutionUnit" }, - { tcImageNumber, "ImageNumber" }, - { tcSecurityClassification, "SecurityClassification" }, - { tcImageHistory, "ImageHistory" }, - { tcSubjectArea, "SubjectArea" }, - { tcExposureIndex, "ExposureIndex" }, - { tcTIFF_EP_StandardID, "TIFF/EPStandardID" }, - { tcSensingMethod, "SensingMethod" }, - { tcMakerNote, "MakerNote" }, - { tcUserComment, "UserComment" }, - { tcSubsecTime, "SubsecTime" }, - { tcSubsecTimeOriginal, "SubsecTimeOriginal" }, - { tcSubsecTimeDigitized, "SubsecTimeDigitized" }, - { tcAdobeLayerData, "AdobeLayerData" }, - { tcFlashPixVersion, "FlashPixVersion" }, - { tcColorSpace, "ColorSpace" }, - { tcPixelXDimension, "PixelXDimension" }, - { tcPixelYDimension, "PixelYDimension" }, - { tcRelatedSoundFile, "RelatedSoundFile" }, - { tcInteroperabilityIFD, "InteroperabilityIFD" }, - { tcFlashEnergyExif, "FlashEnergyExif" }, - { tcSpatialFrequencyResponseExif, "SpatialFrequencyResponseExif" }, - { tcFocalPlaneXResolutionExif, "FocalPlaneXResolutionExif" }, - { tcFocalPlaneYResolutionExif, "FocalPlaneYResolutionExif" }, - { tcFocalPlaneResolutionUnitExif, "FocalPlaneResolutionUnitExif" }, - { tcSubjectLocation, "SubjectLocation" }, - { tcExposureIndexExif, "ExposureIndexExif" }, - { tcSensingMethodExif, "SensingMethodExif" }, - { tcFileSource, "FileSource" }, - { tcSceneType, "SceneType" }, - { tcCFAPatternExif, "CFAPatternExif" }, - { tcCustomRendered, "CustomRendered" }, - { tcExposureMode, "ExposureMode" }, - { tcWhiteBalance, "WhiteBalance" }, - { tcDigitalZoomRatio, "DigitalZoomRatio" }, - { tcFocalLengthIn35mmFilm, "FocalLengthIn35mmFilm" }, - { tcSceneCaptureType, "SceneCaptureType" }, - { tcGainControl, "GainControl" }, - { tcContrast, "Contrast" }, - { tcSaturation, "Saturation" }, - { tcSharpness, "Sharpness" }, - { tcDeviceSettingDescription, "DeviceSettingDescription" }, - { tcSubjectDistanceRange, "SubjectDistanceRange" }, - { tcImageUniqueID, "ImageUniqueID" }, - { tcCameraOwnerNameExif, "CameraOwnerNameExif" }, - { tcCameraSerialNumberExif, "CameraSerialNumberExif" }, - { tcLensSpecificationExif, "LensSpecificationExif" }, - { tcLensMakeExif, "LensMakeExif" }, - { tcLensModelExif, "LensModelExif" }, - { tcLensSerialNumberExif, "LensSerialNumberExif" }, - { tcGamma, "Gamma" }, - { tcPrintImageMatchingInfo, "PrintImageMatchingInfo" }, - { tcDNGVersion, "DNGVersion" }, - { tcDNGBackwardVersion, "DNGBackwardVersion" }, - { tcUniqueCameraModel, "UniqueCameraModel" }, - { tcLocalizedCameraModel, "LocalizedCameraModel" }, - { tcCFAPlaneColor, "CFAPlaneColor" }, - { tcCFALayout, "CFALayout" }, - { tcLinearizationTable, "LinearizationTable" }, - { tcBlackLevelRepeatDim, "BlackLevelRepeatDim" }, - { tcBlackLevel, "BlackLevel" }, - { tcBlackLevelDeltaH, "BlackLevelDeltaH" }, - { tcBlackLevelDeltaV, "BlackLevelDeltaV" }, - { tcWhiteLevel, "WhiteLevel" }, - { tcDefaultScale, "DefaultScale" }, - { tcDefaultCropOrigin, "DefaultCropOrigin" }, - { tcDefaultCropSize, "DefaultCropSize" }, - { tcDefaultUserCrop, "DefaultUserCrop" }, - { tcColorMatrix1, "ColorMatrix1" }, - { tcColorMatrix2, "ColorMatrix2" }, - { tcCameraCalibration1, "CameraCalibration1" }, - { tcCameraCalibration2, "CameraCalibration2" }, - { tcReductionMatrix1, "ReductionMatrix1" }, - { tcReductionMatrix2, "ReductionMatrix2" }, - { tcAnalogBalance, "AnalogBalance" }, - { tcAsShotNeutral, "AsShotNeutral" }, - { tcAsShotWhiteXY, "AsShotWhiteXY" }, - { tcBaselineExposure, "BaselineExposure" }, - { tcBaselineNoise, "BaselineNoise" }, - { tcBaselineSharpness, "BaselineSharpness" }, - { tcBayerGreenSplit, "BayerGreenSplit" }, - { tcLinearResponseLimit, "LinearResponseLimit" }, - { tcCameraSerialNumber, "CameraSerialNumber" }, - { tcLensInfo, "LensInfo" }, - { tcChromaBlurRadius, "ChromaBlurRadius" }, - { tcAntiAliasStrength, "AntiAliasStrength" }, - { tcShadowScale, "ShadowScale" }, - { tcDNGPrivateData, "DNGPrivateData" }, - { tcMakerNoteSafety, "MakerNoteSafety" }, - { tcCalibrationIlluminant1, "CalibrationIlluminant1" }, - { tcCalibrationIlluminant2, "CalibrationIlluminant2" }, - { tcBestQualityScale, "BestQualityScale" }, - { tcRawDataUniqueID, "RawDataUniqueID" }, - { tcOriginalRawFileName, "OriginalRawFileName" }, - { tcOriginalRawFileData, "OriginalRawFileData" }, - { tcActiveArea, "ActiveArea" }, - { tcMaskedAreas, "MaskedAreas" }, - { tcAsShotICCProfile, "AsShotICCProfile" }, - { tcAsShotPreProfileMatrix, "AsShotPreProfileMatrix" }, - { tcCurrentICCProfile, "CurrentICCProfile" }, - { tcCurrentPreProfileMatrix, "CurrentPreProfileMatrix" }, - { tcColorimetricReference, "ColorimetricReference" }, - { tcCameraCalibrationSignature, "CameraCalibrationSignature" }, - { tcProfileCalibrationSignature, "ProfileCalibrationSignature" }, - { tcExtraCameraProfiles, "ExtraCameraProfiles" }, - { tcAsShotProfileName, "AsShotProfileName" }, - { tcNoiseReductionApplied, "NoiseReductionApplied" }, - { tcProfileName, "ProfileName" }, - { tcProfileHueSatMapDims, "ProfileHueSatMapDims" }, - { tcProfileHueSatMapData1, "ProfileHueSatMapData1" }, - { tcProfileHueSatMapData2, "ProfileHueSatMapData2" }, - { tcProfileHueSatMapEncoding, "ProfileHueSatMapEncoding" }, - { tcProfileToneCurve, "ProfileToneCurve" }, - { tcProfileEmbedPolicy, "ProfileEmbedPolicy" }, - { tcProfileCopyright, "ProfileCopyright" }, - { tcForwardMatrix1, "ForwardMatrix1" }, - { tcForwardMatrix2, "ForwardMatrix2" }, - { tcPreviewApplicationName, "PreviewApplicationName" }, - { tcPreviewApplicationVersion, "PreviewApplicationVersion" }, - { tcPreviewSettingsName, "PreviewSettingsName" }, - { tcPreviewSettingsDigest, "PreviewSettingsDigest" }, - { tcPreviewColorSpace, "PreviewColorSpace" }, - { tcPreviewDateTime, "PreviewDateTime" }, - { tcRawImageDigest, "RawImageDigest" }, - { tcOriginalRawFileDigest, "OriginalRawFileDigest" }, - { tcSubTileBlockSize, "SubTileBlockSize" }, - { tcRowInterleaveFactor, "RowInterleaveFactor" }, - { tcProfileLookTableDims, "ProfileLookTableDims" }, - { tcProfileLookTableData, "ProfileLookTableData" }, - { tcProfileLookTableEncoding, "ProfileLookTableEncoding" }, - { tcBaselineExposureOffset, "BaselineExposureOffset" }, - { tcDefaultBlackRender, "DefaultBlackRender" }, - { tcOpcodeList1, "OpcodeList1" }, - { tcOpcodeList2, "OpcodeList2" }, - { tcOpcodeList3, "OpcodeList3" }, - { tcNoiseProfile, "NoiseProfile" }, - { tcOriginalDefaultFinalSize, "OriginalDefaultFinalSize" }, - { tcOriginalBestQualityFinalSize, "OriginalBestQualityFinalSize" }, - { tcOriginalDefaultCropSize, "OriginalDefaultCropSize" }, - { tcProfileHueSatMapEncoding, "ProfileHueSatMapEncoding" }, - { tcProfileLookTableEncoding, "ProfileLookTableEncoding" }, - { tcBaselineExposureOffset, "BaselineExposureOffset" }, - { tcDefaultBlackRender, "DefaultBlackRender" }, - { tcNewRawImageDigest, "NewRawImageDigest" }, - { tcRawToPreviewGain, "RawToPreviewGain" }, - { tcCacheBlob, "CacheBlob" }, - { tcKodakKDCPrivateIFD, "KodakKDCPrivateIFD" } - }; - - const dng_name_table kGPSTagNames [] = - { - { tcGPSVersionID, "GPSVersionID" }, - { tcGPSLatitudeRef, "GPSLatitudeRef" }, - { tcGPSLatitude, "GPSLatitude" }, - { tcGPSLongitudeRef, "GPSLongitudeRef" }, - { tcGPSLongitude, "GPSLongitude" }, - { tcGPSAltitudeRef, "GPSAltitudeRef" }, - { tcGPSAltitude, "GPSAltitude" }, - { tcGPSTimeStamp, "GPSTimeStamp" }, - { tcGPSSatellites, "GPSSatellites" }, - { tcGPSStatus, "GPSStatus" }, - { tcGPSMeasureMode, "GPSMeasureMode" }, - { tcGPSDOP, "GPSDOP" }, - { tcGPSSpeedRef, "GPSSpeedRef" }, - { tcGPSSpeed, "GPSSpeed" }, - { tcGPSTrackRef, "GPSTrackRef" }, - { tcGPSTrack, "GPSTrack" }, - { tcGPSImgDirectionRef, "GPSImgDirectionRef" }, - { tcGPSImgDirection, "GPSImgDirection" }, - { tcGPSMapDatum, "GPSMapDatum" }, - { tcGPSDestLatitudeRef, "GPSDestLatitudeRef" }, - { tcGPSDestLatitude, "GPSDestLatitude" }, - { tcGPSDestLongitudeRef, "GPSDestLongitudeRef" }, - { tcGPSDestLongitude, "GPSDestLongitude" }, - { tcGPSDestBearingRef, "GPSDestBearingRef" }, - { tcGPSDestBearing, "GPSDestBearing" }, - { tcGPSDestDistanceRef, "GPSDestDistanceRef" }, - { tcGPSDestDistance, "GPSDestDistance" }, - { tcGPSProcessingMethod, "GPSProcessingMethod" }, - { tcGPSAreaInformation, "GPSAreaInformation" }, - { tcGPSDateStamp, "GPSDateStamp" }, - { tcGPSDifferential, "GPSDifferential" }, - { tcGPSHPositioningError, "GPSHPositioningError" }, - }; - - const dng_name_table kInteroperabilityTagNames [] = - { - { tcInteroperabilityIndex, "InteroperabilityIndex" }, - { tcInteroperabilityVersion, "InteroperabilityVersion" }, - { tcRelatedImageFileFormat, "RelatedImageFileFormat" }, - { tcRelatedImageWidth, "RelatedImageWidth" }, - { tcRelatedImageLength, "RelatedImageLength" } - }; - - const dng_name_table kFujiTagNames [] = - { - { tcFujiHeader, "FujiHeader" }, - { tcFujiRawInfo1, "FujiRawInfo1" }, - { tcFujiRawInfo2, "FujiRawInfo2" } - }; - - const dng_name_table kContaxTagNames [] = - { - { tcContaxHeader, "ContaxHeader" } - }; - - const char *name = NULL; - - if (parentCode == 0 || - parentCode == tcExifIFD || - parentCode == tcLeafMOS || - (parentCode >= tcFirstSubIFD && parentCode <= tcLastSubIFD) || - (parentCode >= tcFirstChainedIFD && parentCode <= tcLastChainedIFD)) - { - - name = LookupName (tagCode, - kTagNames, - sizeof (kTagNames ) / - sizeof (kTagNames [0])); - - } - - else if (parentCode == tcGPSInfo) - { - - name = LookupName (tagCode, - kGPSTagNames, - sizeof (kGPSTagNames ) / - sizeof (kGPSTagNames [0])); - - } - - else if (parentCode == tcInteroperabilityIFD) - { - - name = LookupName (tagCode, - kInteroperabilityTagNames, - sizeof (kInteroperabilityTagNames ) / - sizeof (kInteroperabilityTagNames [0])); - - } - - else if (parentCode == tcFujiRAF) - { - - name = LookupName (tagCode, - kFujiTagNames, - sizeof (kFujiTagNames ) / - sizeof (kFujiTagNames [0])); - - } - - else if (parentCode == tcContaxRAW) - { - - name = LookupName (tagCode, - kContaxTagNames, - sizeof (kContaxTagNames ) / - sizeof (kContaxTagNames [0])); - - } - - if (name) - { - return name; - } - - static char s [32]; - - if (parentCode == tcCanonCRW) - { - sprintf (s, "CRW_%04X", (unsigned) tagCode); - } - - else if (parentCode == tcMinoltaMRW) - { - - char c1 = (char) ((tagCode >> 24) & 0xFF); - char c2 = (char) ((tagCode >> 16) & 0xFF); - char c3 = (char) ((tagCode >> 8) & 0xFF); - char c4 = (char) ((tagCode ) & 0xFF); - - if (c1 < ' ') c1 = '_'; - if (c2 < ' ') c2 = '_'; - if (c3 < ' ') c3 = '_'; - if (c4 < ' ') c4 = '_'; - - sprintf (s, "MRW%c%c%c%c", c1, c2, c3, c4); - - } - - else if (parentCode == tcFujiRawInfo1) - { - sprintf (s, "RAF1_%04X", (unsigned) tagCode); - } - - else if (parentCode == tcFujiRawInfo2) - { - sprintf (s, "RAF2_%04X", (unsigned) tagCode); - } - - else - { - sprintf (s, "Tag%u", (unsigned) tagCode); - } - - return s; - - } - -/*****************************************************************************/ - -const char * LookupTagType (uint32 tagType) - { - - const dng_name_table kTagTypeNames [] = - { - { ttByte, "Byte" }, - { ttAscii, "ASCII" }, - { ttShort, "Short" }, - { ttLong, "Long" }, - { ttRational, "Rational" }, - { ttSByte, "SByte" }, - { ttUndefined, "Undefined" }, - { ttSShort, "SShort" }, - { ttSLong, "SLong" }, - { ttSRational, "SRational" }, - { ttFloat, "Float" }, - { ttDouble, "Double" }, - { ttIFD, "IFD" }, - { ttUnicode, "Unicode" }, - { ttComplex, "Complex" } - }; - - const char *name = LookupName (tagType, - kTagTypeNames, - sizeof (kTagTypeNames ) / - sizeof (kTagTypeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "Type%u", (unsigned) tagType); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupNewSubFileType (uint32 key) - { - - const dng_name_table kNewSubFileTypeNames [] = - { - { sfMainImage , "Main Image" }, - { sfPreviewImage , "Preview Image" }, - { sfTransparencyMask , "Transparency Mask" }, - { sfPreviewMask , "Preview Mask" }, - { sfAltPreviewImage , "Alt Preview Image" } - }; - - const char *name = LookupName (key, - kNewSubFileTypeNames, - sizeof (kNewSubFileTypeNames ) / - sizeof (kNewSubFileTypeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupCompression (uint32 key) - { - - const dng_name_table kCompressionNames [] = - { - { ccUncompressed, "Uncompressed" }, - { ccLZW, "LZW" }, - { ccOldJPEG, "Old JPEG" }, - { ccJPEG, "JPEG" }, - { ccDeflate, "Deflate" }, - { ccPackBits, "PackBits" }, - { ccOldDeflate, "OldDeflate" }, - { ccLossyJPEG, "Lossy JPEG" } - }; - - const char *name = LookupName (key, - kCompressionNames, - sizeof (kCompressionNames ) / - sizeof (kCompressionNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupPredictor (uint32 key) - { - - const dng_name_table kPredictorNames [] = - { - { cpNullPredictor, "NullPredictor" }, - { cpHorizontalDifference, "HorizontalDifference" }, - { cpFloatingPoint, "FloatingPoint" }, - { cpHorizontalDifferenceX2, "HorizontalDifferenceX2" }, - { cpHorizontalDifferenceX4, "HorizontalDifferenceX4" }, - { cpFloatingPointX2, "FloatingPointX2" }, - { cpFloatingPointX4, "FloatingPointX4" } - }; - - const char *name = LookupName (key, - kPredictorNames, - sizeof (kPredictorNames ) / - sizeof (kPredictorNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSampleFormat (uint32 key) - { - - const dng_name_table kSampleFormatNames [] = - { - { sfUnsignedInteger, "UnsignedInteger" }, - { sfSignedInteger, "SignedInteger" }, - { sfFloatingPoint, "FloatingPoint" }, - { sfUndefined, "Undefined" } - }; - - const char *name = LookupName (key, - kSampleFormatNames, - sizeof (kSampleFormatNames ) / - sizeof (kSampleFormatNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupPhotometricInterpretation (uint32 key) - { - - const dng_name_table kPhotometricInterpretationNames [] = - { - { piWhiteIsZero, "WhiteIsZero" }, - { piBlackIsZero, "BlackIsZero" }, - { piRGB, "RGB" }, - { piRGBPalette, "RGBPalette" }, - { piTransparencyMask, "TransparencyMask" }, - { piCMYK, "CMYK" }, - { piYCbCr, "YCbCr" }, - { piCIELab, "CIELab" }, - { piICCLab, "ICCLab" }, - { piCFA, "CFA" }, - { piLinearRaw, "LinearRaw" } - }; - - const char *name = LookupName (key, - kPhotometricInterpretationNames, - sizeof (kPhotometricInterpretationNames ) / - sizeof (kPhotometricInterpretationNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupOrientation (uint32 key) - { - - const dng_name_table kOrientationNames [] = - { - { 1, "1 - 0th row is top, 0th column is left" }, - { 2, "2 - 0th row is top, 0th column is right" }, - { 3, "3 - 0th row is bottom, 0th column is right" }, - { 4, "4 - 0th row is bottom, 0th column is left" }, - { 5, "5 - 0th row is left, 0th column is top" }, - { 6, "6 - 0th row is right, 0th column is top" }, - { 7, "7 - 0th row is right, 0th column is bottom" }, - { 8, "8 - 0th row is left, 0th column is bottom" }, - { 9, "9 - unknown" } - }; - - const char *name = LookupName (key, - kOrientationNames, - sizeof (kOrientationNames ) / - sizeof (kOrientationNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupResolutionUnit (uint32 key) - { - - const dng_name_table kResolutionUnitNames [] = - { - { ruNone, "None" }, - { ruInch, "Inch" }, - { ruCM, "cm" }, - { ruMM, "mm" }, - { ruMicroM, "Micrometer" } - }; - - const char *name = LookupName (key, - kResolutionUnitNames, - sizeof (kResolutionUnitNames ) / - sizeof (kResolutionUnitNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupCFAColor (uint32 key) - { - - const dng_name_table kCFAColorNames [] = - { - { 0, "Red" }, - { 1, "Green" }, - { 2, "Blue" }, - { 3, "Cyan" }, - { 4, "Magenta" }, - { 5, "Yellow" }, - { 6, "White" } - }; - - const char *name = LookupName (key, - kCFAColorNames, - sizeof (kCFAColorNames ) / - sizeof (kCFAColorNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "Color%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSensingMethod (uint32 key) - { - - const dng_name_table kSensingMethodNames [] = - { - { 0, "Undefined" }, - { 1, "MonochromeArea" }, - { 2, "OneChipColorArea" }, - { 3, "TwoChipColorArea" }, - { 4, "ThreeChipColorArea" }, - { 5, "ColorSequentialArea" }, - { 6, "MonochromeLinear" }, - { 7, "TriLinear" }, - { 8, "ColorSequentialLinear" } - }; - - const char *name = LookupName (key, - kSensingMethodNames, - sizeof (kSensingMethodNames ) / - sizeof (kSensingMethodNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupExposureProgram (uint32 key) - { - - const dng_name_table kExposureProgramNames [] = - { - { epUnidentified, "Unidentified" }, - { epManual, "Manual" }, - { epProgramNormal, "Program Normal" }, - { epAperturePriority, "Aperture Priority" }, - { epShutterPriority, "Shutter Priority" }, - { epProgramCreative, "Program Creative" }, - { epProgramAction, "Program Action" }, - { epPortraitMode, "Portrait Mode" }, - { epLandscapeMode, "Landscape Mode" } - }; - - const char *name = LookupName (key, - kExposureProgramNames, - sizeof (kExposureProgramNames ) / - sizeof (kExposureProgramNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupMeteringMode (uint32 key) - { - - const dng_name_table kMeteringModeNames [] = - { - { mmUnidentified, "Unknown" }, - { mmAverage, "Average" }, - { mmCenterWeightedAverage, "CenterWeightedAverage" }, - { mmSpot, "Spot" }, - { mmMultiSpot, "MultiSpot" }, - { mmPattern, "Pattern" }, - { mmPartial, "Partial" }, - { mmOther, "Other" } - }; - - const char *name = LookupName (key, - kMeteringModeNames, - sizeof (kMeteringModeNames ) / - sizeof (kMeteringModeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupLightSource (uint32 key) - { - - const dng_name_table kLightSourceNames [] = - { - { lsUnknown, "Unknown" }, - { lsDaylight, "Daylight" }, - { lsFluorescent, "Fluorescent" }, - { lsTungsten, "Tungsten (incandescent light)" }, - { lsFlash, "Flash" }, - { lsFineWeather, "Fine weather" }, - { lsCloudyWeather, "Cloudy weather" }, - { lsShade, "Shade" }, - { lsDaylightFluorescent, "Daylight fluorescent (D 5700 - 7100K)" }, - { lsDayWhiteFluorescent, "Day white fluorescent (N 4600 - 5500K)" }, - { lsCoolWhiteFluorescent, "Cool white fluorescent (W 3800 - 4500K)" }, - { lsWhiteFluorescent, "White fluorescent (WW 3250 - 3800K)" }, - { lsWarmWhiteFluorescent, "Warm white fluorescent (L 2600 - 3250K)" }, - { lsStandardLightA, "Standard light A" }, - { lsStandardLightB, "Standard light B" }, - { lsStandardLightC, "Standard light C" }, - { lsD55, "D55" }, - { lsD65, "D65" }, - { lsD75, "D75" }, - { lsD50, "D50" }, - { lsISOStudioTungsten, "ISO studio tungsten" }, - { lsOther, "Other" } - }; - - const char *name = LookupName (key, - kLightSourceNames, - sizeof (kLightSourceNames ) / - sizeof (kLightSourceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - if (key & 0x08000) - { - - sprintf (s, "%uK", (unsigned) (key & 0x7FFF)); - - } - - else - { - - sprintf (s, "%u", (unsigned) key); - - } - - return s; - - } - -/*****************************************************************************/ - -const char * LookupColorSpace (uint32 key) - { - - const dng_name_table kColorSpaceNames [] = - { - { 1, "sRGB" }, - { 0xFFFF, "Uncalibrated" } - }; - - const char *name = LookupName (key, - kColorSpaceNames, - sizeof (kColorSpaceNames ) / - sizeof (kColorSpaceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupFileSource (uint32 key) - { - - const dng_name_table kFileSourceNames [] = - { - { 3, "DSC" } - }; - - const char *name = LookupName (key, - kFileSourceNames, - sizeof (kFileSourceNames ) / - sizeof (kFileSourceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSceneType (uint32 key) - { - - const dng_name_table kSceneTypeNames [] = - { - { 1, "A directly photographed image" } - }; - - const char *name = LookupName (key, - kSceneTypeNames, - sizeof (kSceneTypeNames ) / - sizeof (kSceneTypeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupCustomRendered (uint32 key) - { - - const dng_name_table kCustomRenderedNames [] = - { - { 0, "Normal process" }, - { 1, "Custom process" } - }; - - const char *name = LookupName (key, - kCustomRenderedNames, - sizeof (kCustomRenderedNames ) / - sizeof (kCustomRenderedNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupExposureMode (uint32 key) - { - - const dng_name_table kExposureModeNames [] = - { - { 0, "Auto exposure" }, - { 1, "Manual exposure" }, - { 2, "Auto bracket" } - }; - - const char *name = LookupName (key, - kExposureModeNames, - sizeof (kExposureModeNames ) / - sizeof (kExposureModeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupWhiteBalance (uint32 key) - { - - const dng_name_table kWhiteBalanceNames [] = - { - { 0, "Auto white balance" }, - { 1, "Manual white balance" } - }; - - const char *name = LookupName (key, - kWhiteBalanceNames, - sizeof (kWhiteBalanceNames ) / - sizeof (kWhiteBalanceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSceneCaptureType (uint32 key) - { - - const dng_name_table kSceneCaptureTypeNames [] = - { - { 0, "Standard" }, - { 1, "Landscape" }, - { 2, "Portrait" }, - { 3, "Night scene" } - }; - - const char *name = LookupName (key, - kSceneCaptureTypeNames, - sizeof (kSceneCaptureTypeNames ) / - sizeof (kSceneCaptureTypeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupGainControl (uint32 key) - { - - const dng_name_table kGainControlNames [] = - { - { 0, "None" }, - { 1, "Low gain up" }, - { 2, "High gain up" }, - { 3, "Low gain down" }, - { 4, "High gain down" } - }; - - const char *name = LookupName (key, - kGainControlNames, - sizeof (kGainControlNames ) / - sizeof (kGainControlNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupContrast (uint32 key) - { - - const dng_name_table kContrastNames [] = - { - { 0, "Normal" }, - { 1, "Soft" }, - { 2, "Hard" } - }; - - const char *name = LookupName (key, - kContrastNames, - sizeof (kContrastNames ) / - sizeof (kContrastNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSaturation (uint32 key) - { - - const dng_name_table kSaturationNames [] = - { - { 0, "Normal" }, - { 1, "Low saturation" }, - { 2, "High saturation" } - }; - - const char *name = LookupName (key, - kSaturationNames, - sizeof (kSaturationNames ) / - sizeof (kSaturationNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSharpness (uint32 key) - { - - const dng_name_table kSharpnessNames [] = - { - { 0, "Normal" }, - { 1, "Soft" }, - { 2, "Hard" } - }; - - const char *name = LookupName (key, - kSharpnessNames, - sizeof (kSharpnessNames ) / - sizeof (kSharpnessNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSubjectDistanceRange (uint32 key) - { - - const dng_name_table kSubjectDistanceRangeNames [] = - { - { 0, "Unknown" }, - { 1, "Macro" }, - { 2, "Close view" }, - { 3, "Distant view" } - }; - - const char *name = LookupName (key, - kSubjectDistanceRangeNames, - sizeof (kSubjectDistanceRangeNames ) / - sizeof (kSubjectDistanceRangeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupComponent (uint32 key) - { - - const dng_name_table kComponentNames [] = - { - { 0, "-" }, - { 1, "Y" }, - { 2, "Cb" }, - { 3, "Cr" }, - { 4, "R" }, - { 5, "G" }, - { 6, "B" } - }; - - const char *name = LookupName (key, - kComponentNames, - sizeof (kComponentNames ) / - sizeof (kComponentNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupCFALayout (uint32 key) - { - - const dng_name_table kCFALayoutNames [] = - { - { 1, "Rectangular (or square) layout" }, - { 2, "Staggered layout A: even columns are offset down by 1/2 row" }, - { 3, "Staggered layout B: even columns are offset up by 1/2 row" }, - { 4, "Staggered layout C: even rows are offset right by 1/2 column" }, - { 5, "Staggered layout D: even rows are offset left by 1/2 column" }, - { 6, "Staggered layout E: even rows are offset up by 1/2 row, even columns are offset left by 1/2 column" }, - { 7, "Staggered layout F: even rows are offset up by 1/2 row, even columns are offset right by 1/2 column" }, - { 8, "Staggered layout G: even rows are offset down by 1/2 row, even columns are offset left by 1/2 column" }, - { 9, "Staggered layout H: even rows are offset down by 1/2 row, even columns are offset right by 1/2 column" } - }; - - const char *name = LookupName (key, - kCFALayoutNames, - sizeof (kCFALayoutNames ) / - sizeof (kCFALayoutNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupMakerNoteSafety (uint32 key) - { - - const dng_name_table kMakerNoteSafetyNames [] = - { - { 0, "Unsafe" }, - { 1, "Safe" } - }; - - const char *name = LookupName (key, - kMakerNoteSafetyNames, - sizeof (kMakerNoteSafetyNames ) / - sizeof (kMakerNoteSafetyNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupColorimetricReference (uint32 key) - { - - const dng_name_table kColorimetricReferenceNames [] = - { - { crSceneReferred, "Scene Referred" }, - { crICCProfilePCS, "ICC Profile PCS" } - }; - - const char *name = LookupName (key, - kColorimetricReferenceNames, - sizeof (kColorimetricReferenceNames ) / - sizeof (kColorimetricReferenceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupPreviewColorSpace (uint32 key) - { - - const dng_name_table kPreviewColorSpaceNames [] = - { - { previewColorSpace_Unknown , "Unknown" }, - { previewColorSpace_GrayGamma22, "Gray Gamma 2.2" }, - { previewColorSpace_sRGB , "sRGB" }, - { previewColorSpace_AdobeRGB , "Adobe RGB (1998)" }, - { previewColorSpace_ProPhotoRGB, "Pro Photo RGB" } - }; - - const char *name = LookupName (key, - kPreviewColorSpaceNames, - sizeof (kPreviewColorSpaceNames ) / - sizeof (kPreviewColorSpaceNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupJPEGMarker (uint32 key) - { - - const dng_name_table kJPEGMarkerNames [] = - { - { M_TEM, "TEM" }, - { M_SOF0, "SOF0" }, - { M_SOF1, "SOF1" }, - { M_SOF2, "SOF2" }, - { M_SOF3, "SOF3" }, - { M_DHT, "DHT" }, - { M_SOF5, "SOF5" }, - { M_SOF6, "SOF6" }, - { M_SOF7, "SOF7" }, - { M_JPG, "JPG" }, - { M_SOF9, "SOF9" }, - { M_SOF10, "SOF10" }, - { M_SOF11, "SOF11" }, - { M_DAC, "DAC" }, - { M_SOF13, "SOF13" }, - { M_SOF14, "SOF14" }, - { M_SOF15, "SOF15" }, - { M_RST0, "RST0" }, - { M_RST1, "RST1" }, - { M_RST2, "RST2" }, - { M_RST3, "RST3" }, - { M_RST4, "RST4" }, - { M_RST5, "RST5" }, - { M_RST6, "RST6" }, - { M_RST7, "RST7" }, - { M_SOI, "SOI" }, - { M_EOI, "EOI" }, - { M_SOS, "SOS" }, - { M_DQT, "DQT" }, - { M_DNL, "DNL" }, - { M_DRI, "DRI" }, - { M_DHP, "DHP" }, - { M_EXP, "EXP" }, - { M_APP0, "APP0" }, - { M_APP1, "APP1" }, - { M_APP2, "APP2" }, - { M_APP3, "APP3" }, - { M_APP4, "APP4" }, - { M_APP5, "APP5" }, - { M_APP6, "APP6" }, - { M_APP7, "APP7" }, - { M_APP8, "APP8" }, - { M_APP9, "APP9" }, - { M_APP10, "APP10" }, - { M_APP11, "APP11" }, - { M_APP12, "APP12" }, - { M_APP13, "APP13" }, - { M_APP14, "APP14" }, - { M_APP15, "APP15" }, - { M_JPG0, "JPG0" }, - { M_JPG1, "JPG1" }, - { M_JPG2, "JPG2" }, - { M_JPG3, "JPG3" }, - { M_JPG4, "JPG4" }, - { M_JPG5, "JPG5" }, - { M_JPG6, "JPG6" }, - { M_JPG7, "JPG7" }, - { M_JPG8, "JPG8" }, - { M_JPG9, "JPG9" }, - { M_JPG10, "JPG10" }, - { M_JPG11, "JPG11" }, - { M_JPG12, "JPG12" }, - { M_JPG13, "JPG13" }, - { M_COM, "COM" }, - { M_ERROR, "ERROR" } - }; - - const char *name = LookupName (key, - kJPEGMarkerNames, - sizeof (kJPEGMarkerNames ) / - sizeof (kJPEGMarkerNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "0x%02X", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -const char * LookupSensitivityType (uint32 key) - { - - const dng_name_table kSensitivityTypeNames [] = - { - { stUnknown, "Unknown" }, - { stStandardOutputSensitivity, "Standard Output Sensitivity (SOS)" }, - { stRecommendedExposureIndex, "Recommended Exposure Index (REI)" }, - { stISOSpeed, "ISO Speed" }, - { stSOSandREI, "Standard Output Sensitivity (SOS) and Recommended Exposure Index (REI)" }, - { stSOSandISOSpeed, "Standard Output Sensitivity (SOS) and ISO Speed" }, - { stREIandISOSpeed, "Recommended Exposure Index (REI) and ISO Speed" }, - { stSOSandREIandISOSpeed, "Standard Output Sensitivity (SOS) and Recommended Exposure Index (REI) and ISO Speed" }, - }; - - const char *name = LookupName (key, - kSensitivityTypeNames, - sizeof (kSensitivityTypeNames ) / - sizeof (kSensitivityTypeNames [0])); - - if (name) - { - return name; - } - - static char s [32]; - - sprintf (s, "%u", (unsigned) key); - - return s; - - } - -/*****************************************************************************/ - -void DumpHexAscii (dng_stream &stream, - uint32 count) - { - - uint32 rows = (count + 15) >> 4; - - if (rows > gDumpLineLimit) - rows = gDumpLineLimit; - - for (uint32 row = 0; row < rows; row++) - { - - printf (" "); - - uint32 col; - - uint32 cols = count - (row << 4); - - if (cols > 16) - cols = 16; - - uint8 x [16]; - - for (col = 0; col < 16; col++) - { - - x [col] = ' '; - - if (col < cols) - { - - x [col] = stream.Get_uint8 (); - - printf ("%02x ", x [col]); - - } - - else - { - printf (" "); - } - - } - - printf (" "); - - for (col = 0; col < 16; col++) - { - - if (x [col] >= (uint8) ' ' && x [col] <= (uint8) '~') - { - printf ("%c", x [col]); - } - - else - { - printf ("."); - } - - } - - printf ("\n"); - - } - - if (count > rows * 16) - { - printf (" ... %u more bytes\n", (unsigned) (count - rows * 16)); - } - - } - -/*****************************************************************************/ - -void DumpHexAscii (const uint8 *buf, - uint32 count) - { - - uint32 rows = (count + 15) >> 4; - - if (rows > gDumpLineLimit) - rows = gDumpLineLimit; - - for (uint32 row = 0; row < rows; row++) - { - - printf (" "); - - uint32 col; - - uint32 cols = count - (row << 4); - - if (cols > 16) - cols = 16; - - uint8 x [16]; - - for (col = 0; col < 16; col++) - { - - x [col] = ' '; - - if (col < cols) - { - - x [col] = *(buf++); - - printf ("%02x ", x [col]); - - } - - else - { - printf (" "); - } - - } - - printf (" "); - - for (col = 0; col < 16; col++) - { - - if (x [col] >= (uint8) ' ' && x [col] <= (uint8) '~') - { - printf ("%c", x [col]); - } - - else - { - printf ("."); - } - - } - - printf ("\n"); - - } - - if (count > rows * 16) - { - printf (" ... %u more bytes\n", (unsigned) (count - rows * 16)); - } - - } - -/*****************************************************************************/ - -void DumpXMP (dng_stream &stream, - uint32 count) - { - - uint32 lineLength = 0; - - while (count > 0) - { - - uint32 x = stream.Get_uint8 (); - - if (x == 0) break; - - count--; - - if (lineLength == 0) - { - - printf ("XMP: "); - - lineLength = 5; - - } - - if (x == '\n' || - x == '\r') - { - - printf ("\n"); - - lineLength = 0; - - } - - else - { - - if (lineLength >= 128) - { - - printf ("\nXMP: "); - - lineLength = 5; - - } - - if (x >= ' ' && x <= '~') - { - - printf ("%c", (char) x); - - lineLength += 1; - - } - - else - { - - printf ("\\%03o", (unsigned) x); - - lineLength += 4; - - } - - } - - } - - if (lineLength != 0) - { - - printf ("\n"); - - } - - } - -/*****************************************************************************/ - -void DumpString (const dng_string &s) - { - - const uint32 kMaxDumpString = gDumpLineLimit * 64; - - printf ("\""); - - const char *ss = s.Get (); - - uint32 total = 0; - - while (*ss != 0 && total++ < kMaxDumpString) - { - - uint32 c = dng_string::DecodeUTF8 (ss); - - if (c >= ' ' && c <= '~') - { - printf ("%c", (char) c); - } - - else switch (c) - { - - case '\t': - { - printf ("\\t"); - break; - } - - case '\n': - { - printf ("\\n"); - break; - } - - case '\r': - { - printf ("\\r"); - break; - } - - default: - { - printf ("[%X]", (unsigned) c); - } - - } - - } - - uint32 extra = (uint32) strlen (ss); - - if (extra > 0) - { - printf ("...\" (%u more bytes)", (unsigned) extra); - } - - else - { - printf ("\""); - } - - } - -/*****************************************************************************/ - -void DumpTagValues (dng_stream &stream, - const char *entry_name, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - const char *tag_name) - { - - const uint32 kMaxDumpSingleLine = 4; - - const uint32 kMaxDumpArray = Max_uint32 (gDumpLineLimit, kMaxDumpSingleLine); - - printf ("%s:", tag_name ? tag_name - : LookupTagCode (parentCode, tagCode)); - - switch (tagType) - { - - case ttShort: - case ttLong: - case ttIFD: - case ttSByte: - case ttSShort: - case ttSLong: - case ttRational: - case ttSRational: - case ttFloat: - case ttDouble: - { - - if (tagCount > kMaxDumpSingleLine) - { - - printf (" %u entries", (unsigned) tagCount); - - } - - for (uint32 j = 0; j < tagCount && j < kMaxDumpArray; j++) - { - - if (tagCount <= kMaxDumpSingleLine) - { - - if (j == 0) - { - - printf (" %s =", entry_name); - - } - - printf (" "); - - } - - else - { - - printf ("\n %s [%u] = ", entry_name, (unsigned) j); - - } - - switch (tagType) - { - - case ttByte: - case ttShort: - case ttLong: - case ttIFD: - { - - uint32 x = stream.TagValue_uint32 (tagType); - - printf ("%u", (unsigned) x); - - break; - - } - - case ttSByte: - case ttSShort: - case ttSLong: - { - - int32 x = stream.TagValue_int32 (tagType); - - printf ("%d", (int) x); - - break; - - } - - case ttRational: - { - - dng_urational x = stream.TagValue_urational (tagType); - - printf ("%u/%u", (unsigned) x.n, (unsigned) x.d); - - break; - - } - - case ttSRational: - { - - dng_srational x = stream.TagValue_srational (tagType); - - printf ("%d/%d", (int) x.n, (int) x.d); - - break; - - } - - default: - { - - real64 x = stream.TagValue_real64 (tagType); - - printf ("%f", x); - - } - - } - - } - - printf ("\n"); - - if (tagCount > kMaxDumpArray) - { - - printf (" ... %u more entries\n", (unsigned) (tagCount - kMaxDumpArray)); - - } - - break; - - } - - case ttAscii: - { - - dng_string s; - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - s, - false); - - printf (" "); - - DumpString (s); - - printf ("\n"); - - break; - - } - - default: - { - - uint32 tagSize = tagCount * TagTypeSize (tagType); - - if (tagCount == 1 && (tagType == ttByte || - tagType == ttUndefined)) - { - - uint8 x = stream.Get_uint8 (); - - printf (" %s = %u\n", LookupTagType (tagType), x); - - } - - else - { - - printf (" %s, size = %u\n", LookupTagType (tagType), (unsigned) tagSize); - - DumpHexAscii (stream, tagSize); - - } - - } - - } - - } - -/*****************************************************************************/ - -void DumpMatrix (const dng_matrix &m) - { - - for (uint32 row = 0; row < m.Rows (); row++) - { - - for (uint32 col = 0; col < m.Cols (); col++) - { - - if (col == 0) - printf (" "); - else - printf (" "); - - printf ("%8.4f", m [row] [col]); - - } - - printf ("\n"); - - } - - } - -/*****************************************************************************/ - -void DumpVector (const dng_vector &v) - { - - for (uint32 index = 0; index < v.Count (); index++) - { - - printf (" %0.4f", v [index]); - - } - - printf ("\n"); - - } - -/*****************************************************************************/ - -void DumpDateTime (const dng_date_time &dt) - { - - printf ("%04d:%02d:%02d %02d:%02d:%02d", - (int) dt.fYear, - (int) dt.fMonth, - (int) dt.fDay, - (int) dt.fHour, - (int) dt.fMinute, - (int) dt.fSecond); - - } - -/*****************************************************************************/ - -void DumpExposureTime (real64 x) - { - - if (x > 0.0) - { - - if (x >= 0.25) - { - printf ("%0.2f sec", x); - } - - else if (x >= 0.01) - { - printf ("1/%0.1f sec", 1.0 / x); - } - - else - { - printf ("1/%0.0f sec", 1.0 / x); - } - - } - - else - { - - printf (""); - - } - - } - -/*****************************************************************************/ - -void DumpFingerprint (const dng_fingerprint &p) - { - - printf ("<"); - - for (uint32 j = 0; j < 16; j++) - { - printf ("%02x", p.data [j]); - } - - printf (">"); - - } - -/*****************************************************************************/ - -void DumpHueSatMap (dng_stream &stream, - uint32 hues, - uint32 sats, - uint32 vals, - bool skipSat0) - { - - uint32 doneLines = 0; - uint32 skipLines = 0; - - for (uint32 v = 0; v < vals; v++) - { - - for (uint32 h = 0; h < hues; h++) - { - - for (uint32 s = skipSat0 ? 1 : 0; s < sats; s++) - { - - real32 dh = stream.Get_real32 (); - real32 ds = stream.Get_real32 (); - real32 dv = stream.Get_real32 (); - - if (gDumpLineLimit == 0 || - gDumpLineLimit > doneLines) - { - - doneLines++; - - if (vals == 1) - { - - printf (" h [%2u] s [%2u]: h=%8.4f s=%6.4f v=%6.4f\n", - (unsigned) h, - (unsigned) s, - (double) dh, - (double) ds, - (double) dv); - - } - - else - { - - printf (" v [%2u] h [%2u] s [%2u]: h=%8.4f s=%6.4f v=%6.4f\n", - (unsigned) v, - (unsigned) h, - (unsigned) s, - (double) dh, - (double) ds, - (double) dv); - - } - - } - - else - { - - skipLines++; - - } - - } - - } - - } - - if (skipLines > 0) - { - - printf (" ... %u more entries\n", (unsigned) skipLines); - - } - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -bool CheckTagType (uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint16 validType0, - uint16 validType1, - uint16 validType2, - uint16 validType3) - { - - if (tagType != validType0 && - tagType != validType1 && - tagType != validType2 && - tagType != validType3) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s has unexpected type (%s)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - LookupTagType (tagType)); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool CheckTagCount (uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - uint32 minCount, - uint32 maxCount) - { - - if (maxCount < minCount) - maxCount = minCount; - - if (tagCount < minCount || - tagCount > maxCount) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s has unexpected count (%u)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - (unsigned) tagCount); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool CheckColorImage (uint32 parentCode, - uint32 tagCode, - uint32 colorPlanes) - { - - if (colorPlanes == 0) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed with unknown color plane count " - " (missing ColorMatrix1 tag?)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - if (colorPlanes == 1) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed with monochrome images", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool CheckMainIFD (uint32 parentCode, - uint32 tagCode, - uint32 newSubFileType) - { - - if (newSubFileType != sfMainImage) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed IFDs with NewSubFileType != 0", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool CheckRawIFD (uint32 parentCode, - uint32 tagCode, - uint32 photometricInterpretation) - { - - if (photometricInterpretation != piCFA && - photometricInterpretation != piLinearRaw) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed in IFDs with a non-raw PhotometricInterpretation", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -bool CheckCFA (uint32 parentCode, - uint32 tagCode, - uint32 photometricInterpretation) - { - - if (photometricInterpretation != piCFA) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not allowed in IFDs with a non-CFA PhotometricInterpretation", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - return false; - - } - - return true; - - } - -/*****************************************************************************/ - -void ParseStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s, - bool trimBlanks) - { - - if (tagCount == 0 || - tagCount == 0xFFFFFFFF) - { - - s.Clear (); - - return; - - } - - dng_memory_data temp_buffer (tagCount + 1); - - char *buffer = temp_buffer.Buffer_char (); - - stream.Get (buffer, tagCount); - - // Make sure the string is null terminated. - - if (buffer [tagCount - 1] != 0) - { - - buffer [tagCount] = 0; - - #if qDNGValidate - - { - - bool hasNull = false; - - for (uint32 j = 0; j < tagCount; j++) - { - - if (buffer [j] == 0) - { - - hasNull = true; - - break; - - } - - } - - if (!hasNull && parentCode < tcFirstMakerNoteIFD) - { - - char message [256]; - - sprintf (message, - "%s %s is not NULL terminated", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - } - - // Medata working group - Allow UTF-8 - - s.Set_UTF8_or_System (buffer); - - if (trimBlanks) - { - - s.TrimTrailingBlanks (); - - } - - } - -/*****************************************************************************/ - -void ParseDualStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s1, - dng_string &s2) - { - - if (tagCount == 0 || - tagCount == 0xFFFFFFFF) - { - - s1.Clear (); - s2.Clear (); - - return; - - } - - dng_memory_data temp_buffer (tagCount + 1); - - char *buffer = temp_buffer.Buffer_char (); - - stream.Get (buffer, tagCount); - - // Make sure the string is null terminated. - - if (buffer [tagCount - 1] != 0) - { - - buffer [tagCount] = 0; - - #if qDNGValidate - - { - - uint32 nullCount = 0; - - for (uint32 j = 0; j < tagCount; j++) - { - - if (buffer [j] == 0) - { - - nullCount++; - - } - - } - - if (nullCount < 2 && parentCode < tcFirstMakerNoteIFD) - { - - char message [256]; - - sprintf (message, - "%s %s is not NULL terminated", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - } - - // Medata working group - Allow UTF-8 - - s1.Set_UTF8_or_System (buffer); - - s2.Set_ASCII (NULL); - - for (uint32 j = 1; j < tagCount - 1; j++) - { - - if (buffer [j - 1] != 0 && - buffer [j ] == 0) - { - - // Medata working group - Allow UTF-8 - - s2.Set_UTF8_or_System (buffer + j + 1); - - break; - - } - - } - - s1.TrimTrailingBlanks (); - s2.TrimTrailingBlanks (); - - } - -/*****************************************************************************/ - -void ParseEncodedStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s) - { - - if (tagCount < 8) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s has unexpected count (%u)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - (unsigned) tagCount); - - ReportWarning (message); - - } - - #else - - (void) parentCode; // Unused - (void) tagCode; // Unused - - #endif - - s.Clear (); - - return; - - } - - char label [8]; - - stream.Get (label, 8); - - // Sometimes lowercase is used by mistake. Accept this, but issue - // warning. - - { - - bool hadLower = false; - - for (uint32 j = 0; j < 8; j++) - { - - if (label [j] >= 'a' && label [j] <= 'z') - { - - label [j] = 'A' + (label [j] - 'a'); - - hadLower = true; - - } - - } - - #if qDNGValidate - - if (hadLower) - { - - char message [256]; - - sprintf (message, - "%s %s text encoding label not all uppercase", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - } - - if (memcmp (label, "UNICODE\000", 8) == 0) - { - - uint32 uChars = (tagCount - 8) >> 1; - - dng_memory_data temp_buffer ((uChars + 1) * 2); - - uint16 *buffer = temp_buffer.Buffer_uint16 (); - - for (uint32 j = 0; j < uChars; j++) - { - - buffer [j] = stream.Get_uint16 (); - - } - - buffer [uChars] = 0; - - #if qDNGValidate - - { - - // If the writer used UTF-8 rather than UTF-16, and padded - // the string with blanks, then there will be lots of 0x2020 - // (unicode dagger symbol) characters in the string. - - uint32 count2020 = 0; - - for (uint32 k = 0; buffer [k] != 0; k++) - { - - if (buffer [k] == 0x2020) - { - - count2020++; - - } - - } - - if (count2020 > 1) - { - - char message [256]; - - sprintf (message, - "%s %s text appears to be UTF-8 rather than UTF-16", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - } - - #endif - - s.Set_UTF16 (buffer); - - } - - else - { - - uint32 aChars = tagCount - 8; - - dng_memory_data temp_buffer (aChars + 1); - - char *buffer = temp_buffer.Buffer_char (); - - stream.Get (buffer, aChars); - - buffer [aChars] = 0; - - enum dng_encoding - { - dng_encoding_ascii, - dng_encoding_jis_x208_1990, - dng_encoding_unknown - }; - - dng_encoding encoding = dng_encoding_unknown; - - if (memcmp (label, "ASCII\000\000\000", 8) == 0) - { - - encoding = dng_encoding_ascii; - - } - - else if (memcmp (label, "JIS\000\000\000\000\000\000", 8) == 0) - { - - encoding = dng_encoding_jis_x208_1990; - - } - - else - { - - // Some Nikon D1 files have UserComment tags with zero encoding bits and - // garbage text values. So don't try to parse tags with unknown text - // encoding unless all the characters are printing ASCII. - - #if qDNGValidate - - if (memcmp (label, "\000\000\000\000\000\000\000\000\000", 8) == 0) - { - - // Many camera makes store null tags with all zero encoding, so - // don't report a warning message for null strings. - - if (buffer [0] != 0) - { - - char message [256]; - - sprintf (message, - "%s %s has unknown encoding", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - } - - else - { - - char message [256]; - - sprintf (message, - "%s %s has unexpected text encoding", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - } - - // If text encoding was unknown, and the text is anything - // other than pure ASCII, then ignore it. - - if (encoding == dng_encoding_unknown) - { - - encoding = dng_encoding_ascii; - - for (uint32 i = 0; i < aChars && buffer [i] != 0; i++) - { - - if (buffer [i] < ' ' || - buffer [i] > '~') - { - - buffer [0] = 0; - - break; - - } - - } - - } - - switch (encoding) - { - - case dng_encoding_ascii: - { - - // Medata working group - allow UTF-8 for ASCII tags. - - s.Set_UTF8_or_System (buffer); - - break; - - } - - case dng_encoding_jis_x208_1990: - { - s.Set_JIS_X208_1990 (buffer); - break; - } - - case dng_encoding_unknown: - { - s.Set_SystemEncoding (buffer); - break; - } - - default: - break; - - } - - #if qDNGValidate - - { - - if (encoding == dng_encoding_ascii && !s.IsASCII ()) - { - - char message [256]; - - sprintf (message, - "%s %s has non-ASCII characters", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - } - - #endif - - } - - s.TrimTrailingBlanks (); - - } - -/*****************************************************************************/ - -bool ParseMatrixTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint32 rows, - uint32 cols, - dng_matrix &m) - { - - if (CheckTagCount (parentCode, tagCode, tagCount, rows * cols)) - { - - dng_matrix temp (rows, cols); - - for (uint32 row = 0; row < rows; row++) - for (uint32 col = 0; col < cols; col++) - { - - temp [row] [col] = stream.TagValue_real64 (tagType); - - } - - m = temp; - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -bool ParseVectorTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint32 count, - dng_vector &v) - { - - if (CheckTagCount (parentCode, tagCode, tagCount, count)) - { - - dng_vector temp (count); - - for (uint32 index = 0; index < count; index++) - { - - temp [index] = stream.TagValue_real64 (tagType); - - } - - v = temp; - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -bool ParseDateTimeTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - dng_date_time &dt) - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttAscii)) - { - return false; - } - - // Kludge: Some versions of PaintShop Pro write these fields - // with a length of 21 rather than 20. Otherwise they are - // correctly formated. So relax this test and allow these - // these longer than standard tags to be parsed. - - (void) CheckTagCount (parentCode, tagCode, tagCount, 20); - - if (tagCount < 20) - { - return false; - } - - char s [21]; - - stream.Get (s, 20); - - s [20] = 0; - - // See if this is a valid date/time string. - - if (dt.Parse (s)) - { - return true; - } - - // Accept strings that contain only blanks, colons, and zeros as - // valid "null" dates. - - dt = dng_date_time (); - - for (uint32 index = 0; index < 21; index++) - { - - char c = s [index]; - - if (c == 0) - { - return true; - } - - if (c != ' ' && c != ':' && c != '0') - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s is not a valid date/time", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode)); - - ReportWarning (message); - - } - - #endif - - return false; - - } - - } - - return false; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_parse_utils.h b/third_party/dng_sdk/dng_parse_utils.h deleted file mode 100644 index 89a082f..0000000 --- a/third_party/dng_sdk/dng_parse_utils.h +++ /dev/null @@ -1,232 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_parse_utils.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_parse_utils__ -#define __dng_parse_utils__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_flags.h" -#include "dng_types.h" -#include "dng_stream.h" -#include "dng_string.h" -#include "dng_matrix.h" - -/*****************************************************************************/ - -#if qDNGValidate - -/*****************************************************************************/ - -const char * LookupParentCode (uint32 parentCode); - -/*****************************************************************************/ - -const char * LookupTagCode (uint32 parentCode, - uint32 tagCode); - -/*****************************************************************************/ - -const char * LookupTagType (uint32 tagType); - -/*****************************************************************************/ - -const char * LookupNewSubFileType (uint32 key); - -const char * LookupCompression (uint32 key); - -const char * LookupPredictor (uint32 key); - -const char * LookupSampleFormat (uint32 key); - -const char * LookupPhotometricInterpretation (uint32 key); - -const char * LookupOrientation (uint32 key); - -const char * LookupResolutionUnit (uint32 key); - -const char * LookupCFAColor (uint32 key); - -const char * LookupSensingMethod (uint32 key); - -const char * LookupExposureProgram (uint32 key); - -const char * LookupMeteringMode (uint32 key); - -const char * LookupLightSource (uint32 key); - -const char * LookupColorSpace (uint32 key); - -const char * LookupFileSource (uint32 key); - -const char * LookupSceneType (uint32 key); - -const char * LookupCustomRendered (uint32 key); - -const char * LookupExposureMode (uint32 key); - -const char * LookupWhiteBalance (uint32 key); - -const char * LookupSceneCaptureType (uint32 key); - -const char * LookupGainControl (uint32 key); - -const char * LookupContrast (uint32 key); - -const char * LookupSaturation (uint32 key); - -const char * LookupSharpness (uint32 key); - -const char * LookupSubjectDistanceRange (uint32 key); - -const char * LookupComponent (uint32 key); - -const char * LookupCFALayout (uint32 key); - -const char * LookupMakerNoteSafety (uint32 key); - -const char * LookupColorimetricReference (uint32 key); - -const char * LookupPreviewColorSpace (uint32 key); - -const char * LookupJPEGMarker (uint32 key); - -const char * LookupSensitivityType (uint32 key); - -/*****************************************************************************/ - -void DumpHexAscii (dng_stream &stream, - uint32 count); - -void DumpHexAscii (const uint8 *buf, - uint32 count); - -void DumpXMP (dng_stream &stream, - uint32 count); - -void DumpString (const dng_string &s); - -void DumpTagValues (dng_stream &stream, - const char *entry_name, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - const char *tag_name = NULL); - -void DumpMatrix (const dng_matrix &m); - -void DumpVector (const dng_vector &v); - -void DumpDateTime (const dng_date_time &dt); - -void DumpExposureTime (real64 x); - -void DumpFingerprint (const dng_fingerprint &p); - -void DumpHueSatMap (dng_stream &stream, - uint32 hues, - uint32 sats, - uint32 vals, - bool skipSat0); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -bool CheckTagType (uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint16 validType0, - uint16 validType1 = 0, - uint16 validType2 = 0, - uint16 validType3 = 0); - -bool CheckTagCount (uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - uint32 minCount, - uint32 maxCount = 0); - -bool CheckColorImage (uint32 parentCode, - uint32 tagCode, - uint32 colorPlanes); - -bool CheckMainIFD (uint32 parentCode, - uint32 tagCode, - uint32 newSubFileType); - -bool CheckRawIFD (uint32 parentCode, - uint32 tagCode, - uint32 photometricInterpretation); - -bool CheckCFA (uint32 parentCode, - uint32 tagCode, - uint32 photometricInterpretation); - -/*****************************************************************************/ - -void ParseStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s, - bool trimBlanks = true); - -void ParseDualStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s1, - dng_string &s2); - -void ParseEncodedStringTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagCount, - dng_string &s); - -bool ParseMatrixTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint32 rows, - uint32 cols, - dng_matrix &m); - -bool ParseVectorTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint32 count, - dng_vector &v); - -bool ParseDateTimeTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - dng_date_time &dt); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_pixel_buffer.cpp b/third_party/dng_sdk/dng_pixel_buffer.cpp deleted file mode 100644 index 354a774..0000000 --- a/third_party/dng_sdk/dng_pixel_buffer.cpp +++ /dev/null @@ -1,1819 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pixel_buffer.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_pixel_buffer.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_tag_types.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -void OptimizeOrder (const void *&sPtr, - void *&dPtr, - uint32 sPixelSize, - uint32 dPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &sStep0, - int32 &sStep1, - int32 &sStep2, - int32 &dStep0, - int32 &dStep1, - int32 &dStep2) - { - - uint32 step0; - uint32 step1; - uint32 step2; - - // Optimize the order for the data that is most spread out. - - uint32 sRange = Abs_int32 (sStep0) * (count0 - 1) + - Abs_int32 (sStep1) * (count1 - 1) + - Abs_int32 (sStep2) * (count2 - 1); - - uint32 dRange = Abs_int32 (dStep0) * (count0 - 1) + - Abs_int32 (dStep1) * (count1 - 1) + - Abs_int32 (dStep2) * (count2 - 1); - - if (dRange >= sRange) - { - - if (dStep0 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize); - - sStep0 = -sStep0; - dStep0 = -dStep0; - - } - - if (dStep1 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize); - - sStep1 = -sStep1; - dStep1 = -dStep1; - - } - - if (dStep2 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize); - - sStep2 = -sStep2; - dStep2 = -dStep2; - - } - - step0 = (uint32) dStep0; - step1 = (uint32) dStep1; - step2 = (uint32) dStep2; - - } - - else - { - - if (sStep0 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize); - - sStep0 = -sStep0; - dStep0 = -dStep0; - - } - - if (sStep1 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize); - - sStep1 = -sStep1; - dStep1 = -dStep1; - - } - - if (sStep2 < 0) - { - - sPtr = (const void *) - (((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize); - - dPtr = (void *) - (((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize); - - sStep2 = -sStep2; - dStep2 = -dStep2; - - } - - step0 = (uint32) sStep0; - step1 = (uint32) sStep1; - step2 = (uint32) sStep2; - - } - - if (count0 == 1) step0 = 0xFFFFFFFF; - if (count1 == 1) step1 = 0xFFFFFFFF; - if (count2 == 1) step2 = 0xFFFFFFFF; - - uint32 index0; - uint32 index1; - uint32 index2; - - if (step0 >= step1) - { - - if (step1 >= step2) - { - index0 = 0; - index1 = 1; - index2 = 2; - } - - else if (step2 >= step0) - { - index0 = 2; - index1 = 0; - index2 = 1; - } - - else - { - index0 = 0; - index1 = 2; - index2 = 1; - } - - } - - else - { - - if (step0 >= step2) - { - index0 = 1; - index1 = 0; - index2 = 2; - } - - else if (step2 >= step1) - { - index0 = 2; - index1 = 1; - index2 = 0; - } - - else - { - index0 = 1; - index1 = 2; - index2 = 0; - } - - } - - uint32 count [3]; - - count [0] = count0; - count [1] = count1; - count [2] = count2; - - count0 = count [index0]; - count1 = count [index1]; - count2 = count [index2]; - - int32 step [3]; - - step [0] = sStep0; - step [1] = sStep1; - step [2] = sStep2; - - sStep0 = step [index0]; - sStep1 = step [index1]; - sStep2 = step [index2]; - - step [0] = dStep0; - step [1] = dStep1; - step [2] = dStep2; - - dStep0 = step [index0]; - dStep1 = step [index1]; - dStep2 = step [index2]; - - if (sStep0 == ((int32) count1) * sStep1 && - dStep0 == ((int32) count1) * dStep1) - { - count1 *= count0; - count0 = 1; - } - - if (sStep1 == ((int32) count2) * sStep2 && - dStep1 == ((int32) count2) * dStep2) - { - count2 *= count1; - count1 = 1; - } - - } - -/*****************************************************************************/ - -void OptimizeOrder (const void *&sPtr, - uint32 sPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &sStep0, - int32 &sStep1, - int32 &sStep2) - { - - void *dPtr = NULL; - - int32 dStep0 = sStep0; - int32 dStep1 = sStep1; - int32 dStep2 = sStep2; - - OptimizeOrder (sPtr, - dPtr, - sPixelSize, - sPixelSize, - count0, - count1, - count2, - sStep0, - sStep1, - sStep2, - dStep0, - dStep1, - dStep2); - - } - -/*****************************************************************************/ - -void OptimizeOrder (void *&dPtr, - uint32 dPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &dStep0, - int32 &dStep1, - int32 &dStep2) - { - - const void *sPtr = NULL; - - int32 sStep0 = dStep0; - int32 sStep1 = dStep1; - int32 sStep2 = dStep2; - - OptimizeOrder (sPtr, - dPtr, - dPixelSize, - dPixelSize, - count0, - count1, - count2, - sStep0, - sStep1, - sStep2, - dStep0, - dStep1, - dStep2); - - } - -/*****************************************************************************/ - -dng_pixel_buffer::dng_pixel_buffer () - - : fArea () - , fPlane (0) - , fPlanes (1) - , fRowStep (1) - , fColStep (1) - , fPlaneStep (1) - , fPixelType (ttUndefined) - , fPixelSize (0) - , fData (NULL) - , fDirty (true) - - { - - } - -/*****************************************************************************/ - -dng_pixel_buffer::dng_pixel_buffer (const dng_pixel_buffer &buffer) - - : fArea (buffer.fArea) - , fPlane (buffer.fPlane) - , fPlanes (buffer.fPlanes) - , fRowStep (buffer.fRowStep) - , fColStep (buffer.fColStep) - , fPlaneStep (buffer.fPlaneStep) - , fPixelType (buffer.fPixelType) - , fPixelSize (buffer.fPixelSize) - , fData (buffer.fData) - , fDirty (buffer.fDirty) - - { - - } - -/*****************************************************************************/ - -dng_pixel_buffer & dng_pixel_buffer::operator= (const dng_pixel_buffer &buffer) - { - - fArea = buffer.fArea; - fPlane = buffer.fPlane; - fPlanes = buffer.fPlanes; - fRowStep = buffer.fRowStep; - fColStep = buffer.fColStep; - fPlaneStep = buffer.fPlaneStep; - fPixelType = buffer.fPixelType; - fPixelSize = buffer.fPixelSize; - fPixelType = buffer.fPixelType; - fData = buffer.fData; - fDirty = buffer.fDirty; - - return *this; - - } - -/*****************************************************************************/ - -dng_pixel_buffer::~dng_pixel_buffer () - { - - } - -/*****************************************************************************/ - -#if qDebugPixelType - -void dng_pixel_buffer::CheckPixelType (uint32 pixelType) const - { - - if (fPixelType != pixelType) - { - - DNG_REPORT ("Pixel type access mismatch"); - - } - - } - -#endif - -/*****************************************************************************/ - -uint32 dng_pixel_buffer::PixelRange () const - { - - switch (fPixelType) - { - - case ttByte: - case ttSByte: - { - return 0x0FF; - } - - case ttShort: - case ttSShort: - { - return 0x0FFFF; - } - - case ttLong: - case ttSLong: - { - return 0xFFFFFFFF; - } - - default: - break; - - } - - return 0; - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::SetConstant (const dng_rect &area, - uint32 plane, - uint32 planes, - uint32 value) - { - - uint32 rows = area.H (); - uint32 cols = area.W (); - - void *dPtr = DirtyPixel (area.t, - area.l, - plane); - - int32 dRowStep = fRowStep; - int32 dColStep = fColStep; - int32 dPlaneStep = fPlaneStep; - - OptimizeOrder (dPtr, - fPixelSize, - rows, - cols, - planes, - dRowStep, - dColStep, - dPlaneStep); - - switch (fPixelSize) - { - - case 1: - { - - if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0) - { - - DoZeroBytes (dPtr, planes); - - } - - else - { - - DoSetArea8 ((uint8 *) dPtr, - (uint8) value, - rows, - cols, - planes, - dRowStep, - dColStep, - dPlaneStep); - - } - - break; - - } - - case 2: - { - - if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0) - { - - DoZeroBytes (dPtr, planes << 1); - - } - - else - { - - DoSetArea16 ((uint16 *) dPtr, - (uint16) value, - rows, - cols, - planes, - dRowStep, - dColStep, - dPlaneStep); - - } - - break; - - } - - case 4: - { - - if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0) - { - - DoZeroBytes (dPtr, planes << 2); - - } - - else - { - - DoSetArea32 ((uint32 *) dPtr, - value, - rows, - cols, - planes, - dRowStep, - dColStep, - dPlaneStep); - - } - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::SetZero (const dng_rect &area, - uint32 plane, - uint32 planes) - { - - uint32 value = 0; - - switch (fPixelType) - { - - case ttByte: - case ttShort: - case ttLong: - case ttFloat: - { - break; - } - - case ttSShort: - { - value = 0x8000; - break; - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - SetConstant (area, - plane, - planes, - value); - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::CopyArea (const dng_pixel_buffer &src, - const dng_rect &area, - uint32 srcPlane, - uint32 dstPlane, - uint32 planes) - { - - uint32 rows = area.H (); - uint32 cols = area.W (); - - const void *sPtr = src.ConstPixel (area.t, - area.l, - srcPlane); - - void *dPtr = DirtyPixel (area.t, - area.l, - dstPlane); - - int32 sRowStep = src.fRowStep; - int32 sColStep = src.fColStep; - int32 sPlaneStep = src.fPlaneStep; - - int32 dRowStep = fRowStep; - int32 dColStep = fColStep; - int32 dPlaneStep = fPlaneStep; - - OptimizeOrder (sPtr, - dPtr, - src.fPixelSize, - fPixelSize, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - if (fPixelType == src.fPixelType) - { - - if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1) - { - - DoCopyBytes (sPtr, - dPtr, - planes * fPixelSize); - - } - - else switch (fPixelSize) - { - - case 1: - { - - DoCopyArea8 ((const uint8 *) sPtr, - (uint8 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case 2: - { - - DoCopyArea16 ((const uint16 *) sPtr, - (uint16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case 4: - { - - DoCopyArea32 ((const uint32 *) sPtr, - (uint32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else if (src.fPixelType == ttByte) - { - - switch (fPixelType) - { - - case ttShort: - { - - DoCopyArea8_16 ((const uint8 *) sPtr, - (uint16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttSShort: - { - - DoCopyArea8_S16 ((const uint8 *) sPtr, - (int16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttLong: - { - - DoCopyArea8_32 ((const uint8 *) sPtr, - (uint32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttFloat: - { - - DoCopyArea8_R32 ((const uint8 *) sPtr, - (real32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - src.PixelRange ()); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else if (src.fPixelType == ttShort) - { - - switch (fPixelType) - { - - case ttByte: - { - - DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0), - (uint8 *) dPtr, - rows, - cols, - planes, - sRowStep << 1, - sColStep << 1, - sPlaneStep << 1, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttSShort: - { - - DoCopyArea16_S16 ((const uint16 *) sPtr, - (int16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttLong: - { - - DoCopyArea16_32 ((const uint16 *) sPtr, - (uint32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttFloat: - { - - DoCopyArea16_R32 ((const uint16 *) sPtr, - (real32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - src.PixelRange ()); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else if (src.fPixelType == ttSShort) - { - - switch (fPixelType) - { - - case ttByte: - { - - DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0), - (uint8 *) dPtr, - rows, - cols, - planes, - sRowStep << 1, - sColStep << 1, - sPlaneStep << 1, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttShort: - { - - // Moving between signed 16 bit values and unsigned 16 - // bit values just requires toggling the sign bit. So - // we can use the "backwards" bottleneck. - - DoCopyArea16_S16 ((const uint16 *) sPtr, - (int16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttFloat: - { - - DoCopyAreaS16_R32 ((const int16 *) sPtr, - (real32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - src.PixelRange ()); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else if (src.fPixelType == ttLong) - { - - switch (fPixelType) - { - - case ttByte: - { - - DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 3 : 0), - (uint8 *) dPtr, - rows, - cols, - planes, - sRowStep << 2, - sColStep << 2, - sPlaneStep << 2, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case ttShort: - { - - DoCopyArea16 (((const uint16 *) sPtr) + (qDNGBigEndian ? 1 : 0), - (uint16 *) dPtr, - rows, - cols, - planes, - sRowStep << 1, - sColStep << 1, - sPlaneStep << 1, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else if (src.fPixelType == ttFloat) - { - - switch (fPixelType) - { - - case ttByte: - { - - DoCopyAreaR32_8 ((const real32 *) sPtr, - (uint8 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - PixelRange ()); - - break; - - } - - case ttShort: - { - - DoCopyAreaR32_16 ((const real32 *) sPtr, - (uint16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - PixelRange ()); - - break; - - } - - case ttSShort: - { - - DoCopyAreaR32_S16 ((const real32 *) sPtr, - (int16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep, - PixelRange ()); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - - else - { - - ThrowNotYetImplemented (); - - } - - } - -/*****************************************************************************/ - -dng_point dng_pixel_buffer::RepeatPhase (const dng_rect &srcArea, - const dng_rect &dstArea) - { - - int32 repeatV = srcArea.H (); - int32 repeatH = srcArea.W (); - - int32 phaseV; - int32 phaseH; - - if (srcArea.t >= dstArea.t) - { - phaseV = (repeatV - ((srcArea.t - dstArea.t) % repeatV)) % repeatV; - } - else - { - phaseV = (dstArea.t - srcArea.t) % repeatV; - } - - if (srcArea.l >= dstArea.l) - { - phaseH = (repeatH - ((srcArea.l - dstArea.l) % repeatH)) % repeatH; - } - else - { - phaseH = (dstArea.l - srcArea.l) % repeatH; - } - - return dng_point (phaseV, phaseH); - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::RepeatArea (const dng_rect &srcArea, - const dng_rect &dstArea) - { - - dng_point repeat = srcArea.Size (); - - dng_point phase = RepeatPhase (srcArea, - dstArea); - - const void *sPtr = ConstPixel (srcArea.t, - srcArea.l, - fPlane); - - void *dPtr = DirtyPixel (dstArea.t, - dstArea.l, - fPlane); - - uint32 rows = dstArea.H (); - uint32 cols = dstArea.W (); - - switch (fPixelSize) - { - - case 1: - { - - DoRepeatArea8 ((const uint8 *) sPtr, - (uint8 *) dPtr, - rows, - cols, - fPlanes, - fRowStep, - fColStep, - fPlaneStep, - repeat.v, - repeat.h, - phase.v, - phase.h); - - break; - - } - - case 2: - { - - DoRepeatArea16 ((const uint16 *) sPtr, - (uint16 *) dPtr, - rows, - cols, - fPlanes, - fRowStep, - fColStep, - fPlaneStep, - repeat.v, - repeat.h, - phase.v, - phase.h); - - break; - - } - - case 4: - { - - DoRepeatArea32 ((const uint32 *) sPtr, - (uint32 *) dPtr, - rows, - cols, - fPlanes, - fRowStep, - fColStep, - fPlaneStep, - repeat.v, - repeat.h, - phase.v, - phase.h); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - } - - } - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::RepeatSubArea (const dng_rect subArea, - uint32 repeatV, - uint32 repeatH) - { - - if (fArea.t < subArea.t) - { - - RepeatArea (dng_rect (subArea.t , fArea.l, - subArea.t + repeatV, fArea.r), - dng_rect (fArea.t , fArea.l, - subArea.t , fArea.r)); - - } - - if (fArea.b > subArea.b) - { - - RepeatArea (dng_rect (subArea.b - repeatV, fArea.l, - subArea.b , fArea.r), - dng_rect (subArea.b , fArea.l, - fArea.b , fArea.r)); - - } - - if (fArea.l < subArea.l) - { - - RepeatArea (dng_rect (fArea.t, subArea.l , - fArea.b, subArea.l + repeatH), - dng_rect (fArea.t, fArea.l , - fArea.b, subArea.l )); - - } - - if (fArea.r > subArea.r) - { - - RepeatArea (dng_rect (fArea.t, subArea.r - repeatH, - fArea.b, subArea.r ), - dng_rect (fArea.t, subArea.r , - fArea.b, fArea.r )); - - } - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::ShiftRight (uint32 shift) - { - - if (fPixelType != ttShort) - { - - ThrowNotYetImplemented (); - - } - - uint32 rows = fArea.H (); - uint32 cols = fArea.W (); - - uint32 planes = fPlanes; - - void *dPtr = DirtyPixel (fArea.t, - fArea.l, - fPlane); - - const void *sPtr = dPtr; - - int32 sRowStep = fRowStep; - int32 sColStep = fColStep; - int32 sPlaneStep = fPlaneStep; - - int32 dRowStep = fRowStep; - int32 dColStep = fColStep; - int32 dPlaneStep = fPlaneStep; - - OptimizeOrder (sPtr, - dPtr, - fPixelSize, - fPixelSize, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - DoShiftRight16 ((uint16 *) dPtr, - rows, - cols, - planes, - dRowStep, - dColStep, - dPlaneStep, - shift); - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::FlipH () - { - - fData = InternalPixel (fArea.t, fArea.r - 1); - - fColStep = -fColStep; - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::FlipV () - { - - fData = InternalPixel (fArea.b - 1, fArea.l); - - fRowStep = -fRowStep; - - } - -/*****************************************************************************/ - -void dng_pixel_buffer::FlipZ () - { - - fData = InternalPixel (fArea.t, fArea.l, fPlanes - 1); - - fPlaneStep = -fPlaneStep; - - } - -/*****************************************************************************/ - -bool dng_pixel_buffer::EqualArea (const dng_pixel_buffer &src, - const dng_rect &area, - uint32 plane, - uint32 planes) const - { - - uint32 rows = area.H (); - uint32 cols = area.W (); - - const void *sPtr = src.ConstPixel (area.t, - area.l, - plane); - - const void *dPtr = ConstPixel (area.t, - area.l, - plane); - - int32 sRowStep = src.fRowStep; - int32 sColStep = src.fColStep; - int32 sPlaneStep = src.fPlaneStep; - - int32 dRowStep = fRowStep; - int32 dColStep = fColStep; - int32 dPlaneStep = fPlaneStep; - - if (fPixelType == src.fPixelType) - { - - if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1) - { - - return DoEqualBytes (sPtr, - dPtr, - planes * fPixelSize); - - } - - else switch (fPixelSize) - { - - case 1: - { - - return DoEqualArea8 ((const uint8 *) sPtr, - (const uint8 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case 2: - { - - return DoEqualArea16 ((const uint16 *) sPtr, - (const uint16 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - case 4: - { - - return DoEqualArea32 ((const uint32 *) sPtr, - (const uint32 *) dPtr, - rows, - cols, - planes, - sRowStep, - sColStep, - sPlaneStep, - dRowStep, - dColStep, - dPlaneStep); - - break; - - } - - default: - { - - ThrowNotYetImplemented (); - - return false; - - } - - } - - } - - else - return false; - - } - -/*****************************************************************************/ - -namespace - { - - template - real64 MaxDiff (const T *src1, - int32 s1RowStep, - int32 s1PlaneStep, - const T *src2, - int32 s2RowStep, - int32 s2PlaneStep, - uint32 rows, - uint32 cols, - uint32 planes) - { - - real64 result = 0.0; - - for (uint32 plane = 0; plane < planes; plane++) - { - - const T *src1Save = src1; - const T *src2Save = src2; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - real64 diff = fabs ((real64)src1 [col] - src2 [col]); - - if (diff > result) - result = diff; - - } - - src1 += s1RowStep; - src2 += s2RowStep; - - } - - src1 = src1Save + s1PlaneStep; - src2 = src2Save + s2PlaneStep; - - } - - return result; - - } - - template - real64 MaxDiff (const T *src1, - int32 s1ColStep, - int32 s1RowStep, - int32 s1PlaneStep, - const T *src2, - int32 s2ColStep, - int32 s2RowStep, - int32 s2PlaneStep, - uint32 rows, - uint32 cols, - uint32 planes) - { - - if (s1ColStep == s2ColStep && - s1ColStep == 1) - return MaxDiff (src1, - s1RowStep, - s1PlaneStep, - src2, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - real64 result = 0.0; - - for (uint32 plane = 0; plane < planes; plane++) - { - - const T *src1Save = src1; - const T *src2Save = src2; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - real64 diff = fabs ((real64)src1 [col * s1ColStep] - src2 [col * s2ColStep]); - - if (diff > result) - result = diff; - - } - - src1 += s1RowStep; - src2 += s2RowStep; - - } - - src1 = src1Save + s1PlaneStep; - src2 = src2Save + s2PlaneStep; - - } - - - return result; - - } - } - -real64 dng_pixel_buffer::MaximumDifference (const dng_pixel_buffer &rhs, - const dng_rect &area, - uint32 plane, - uint32 planes) const - { - - uint32 rows = area.H (); - uint32 cols = area.W (); - - const void *s1Ptr = rhs.ConstPixel (area.t, - area.l, - plane); - - const void *s2Ptr = ConstPixel (area.t, - area.l, - plane); - - int32 s1RowStep = rhs.fRowStep; - int32 s1ColStep = rhs.fColStep; - int32 s1PlaneStep = rhs.fPlaneStep; - - int32 s2RowStep = fRowStep; - int32 s2ColStep = fColStep; - int32 s2PlaneStep = fPlaneStep; - - if (fPixelType == rhs.fPixelType) - { - - switch (fPixelType) - { - - case ttByte: - return MaxDiff ((const uint8 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const uint8 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttShort: - return MaxDiff ((const uint16 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const uint16 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttLong: - return MaxDiff ((const uint32 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const uint32 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttSByte: - return MaxDiff ((const int8 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const int8 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttSShort: - return MaxDiff ((const int16 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const int16 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttSLong: - return MaxDiff ((const int32 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const int32 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttFloat: - return MaxDiff ((const real32 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const real32 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - case ttDouble: - return MaxDiff ((const real64 *)s1Ptr, - s1ColStep, - s1RowStep, - s1PlaneStep, - (const real64 *)s2Ptr, - s2ColStep, - s2RowStep, - s2PlaneStep, - rows, - cols, - planes); - - break; - - - default: - { - - ThrowNotYetImplemented (); - - return 0.0; - - } - - } - - } - - else - ThrowProgramError ("attempt to difference pixel buffers of different formats."); - - return 0.0; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_pixel_buffer.h b/third_party/dng_sdk/dng_pixel_buffer.h deleted file mode 100644 index 346d5be..0000000 --- a/third_party/dng_sdk/dng_pixel_buffer.h +++ /dev/null @@ -1,680 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pixel_buffer.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for holding buffers of sample data. - */ - -/*****************************************************************************/ - -#ifndef __dng_pixel_buffer__ -#define __dng_pixel_buffer__ - -/*****************************************************************************/ - -#include "dng_assertions.h" -#include "dng_rect.h" -#include "dng_tag_types.h" - -/*****************************************************************************/ - -/// Compute best set of step values for a given source and destination area and stride. - -void OptimizeOrder (const void *&sPtr, - void *&dPtr, - uint32 sPixelSize, - uint32 dPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &sStep0, - int32 &sStep1, - int32 &sStep2, - int32 &dStep0, - int32 &dStep1, - int32 &dStep2); - -void OptimizeOrder (const void *&sPtr, - uint32 sPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &sStep0, - int32 &sStep1, - int32 &sStep2); - -void OptimizeOrder (void *&dPtr, - uint32 dPixelSize, - uint32 &count0, - uint32 &count1, - uint32 &count2, - int32 &dStep0, - int32 &dStep1, - int32 &dStep2); - -/*****************************************************************************/ - -#define qDebugPixelType 0 - -#if qDebugPixelType - -#define ASSERT_PIXEL_TYPE(typeVal) CheckPixelType (typeVal) - -#else - -#define ASSERT_PIXEL_TYPE(typeVal) DNG_ASSERT (fPixelType == typeVal, "Pixel type access mismatch") - -#endif - -/*****************************************************************************/ - -/// \brief Holds a buffer of pixel data with "pixel geometry" metadata. -/// -/// The pixel geometry describes the layout in terms of how many planes, rows and columns -/// plus the steps (in bytes) between each column, row and plane. - -class dng_pixel_buffer - { - - public: - - // Area this buffer holds. - - dng_rect fArea; - - // Range of planes this buffer holds. - - uint32 fPlane; - uint32 fPlanes; - - // Steps between pixels. - - int32 fRowStep; - int32 fColStep; - int32 fPlaneStep; - - // Basic pixel type (TIFF tag type code). - - uint32 fPixelType; - - // Size of pixel type in bytes. - - uint32 fPixelSize; - - // Pointer to buffer's data. - - void *fData; - - // Do we have write-access to this data? - - bool fDirty; - - private: - - void * InternalPixel (int32 row, - int32 col, - uint32 plane = 0) const - { - - return (void *) - (((uint8 *) fData) + (int32)fPixelSize * - (fRowStep * (row - fArea.t) + - fColStep * (col - fArea.l) + - fPlaneStep * (int32)(plane - fPlane ))); - - } - - #if qDebugPixelType - - void CheckPixelType (uint32 pixelType) const; - - #endif - - public: - - dng_pixel_buffer (); - - dng_pixel_buffer (const dng_pixel_buffer &buffer); - - dng_pixel_buffer & operator= (const dng_pixel_buffer &buffer); - - virtual ~dng_pixel_buffer (); - - /// Get the range of pixel values. - /// \retval Range of value a pixel can take. (Meaning [0, max] for unsigned case. Signed case is biased so [-32768, max - 32768].) - - uint32 PixelRange () const; - - /// Get extent of pixels in buffer - /// \retval Rectangle giving valid extent of buffer. - - const dng_rect & Area () const - { - return fArea; - } - - /// Number of planes of image data. - /// \retval Number of planes held in buffer. - - uint32 Planes () const - { - return fPlanes; - } - - /// Step, in pixels not bytes, between rows of data in buffer. - /// \retval row step in pixels. May be negative. - - int32 RowStep () const - { - return fRowStep; - } - - /// Step, in pixels not bytes, between planes of data in buffer. - /// \retval plane step in pixels. May be negative. - - int32 PlaneStep () const - { - return fPlaneStep; - } - - /// Get read-only untyped (void *) pointer to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as void *. - - const void * ConstPixel (int32 row, - int32 col, - uint32 plane = 0) const - { - - return InternalPixel (row, col, plane); - - } - - /// Get a writable untyped (void *) pointer to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as void *. - - void * DirtyPixel (int32 row, - int32 col, - uint32 plane = 0) - { - - DNG_ASSERT (fDirty, "Dirty access to const pixel buffer"); - - return InternalPixel (row, col, plane); - - } - - /// Get read-only uint8 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint8 *. - - const uint8 * ConstPixel_uint8 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttByte); - - return (const uint8 *) ConstPixel (row, col, plane); - - } - - /// Get a writable uint8 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint8 *. - - uint8 * DirtyPixel_uint8 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttByte); - - return (uint8 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only int8 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int8 *. - - const int8 * ConstPixel_int8 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttSByte); - - return (const int8 *) ConstPixel (row, col, plane); - - } - - /// Get a writable int8 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int8 *. - - int8 * DirtyPixel_int8 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttSByte); - - return (int8 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only uint16 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint16 *. - - const uint16 * ConstPixel_uint16 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttShort); - - return (const uint16 *) ConstPixel (row, col, plane); - - } - - /// Get a writable uint16 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint16 *. - - uint16 * DirtyPixel_uint16 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttShort); - - return (uint16 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only int16 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int16 *. - - const int16 * ConstPixel_int16 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttSShort); - - return (const int16 *) ConstPixel (row, col, plane); - - } - - /// Get a writable int16 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int16 *. - - int16 * DirtyPixel_int16 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttSShort); - - return (int16 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only uint32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint32 *. - - const uint32 * ConstPixel_uint32 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttLong); - - return (const uint32 *) ConstPixel (row, col, plane); - - } - - /// Get a writable uint32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as uint32 *. - - uint32 * DirtyPixel_uint32 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttLong); - - return (uint32 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only int32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int32 *. - - const int32 * ConstPixel_int32 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttSLong); - - return (const int32 *) ConstPixel (row, col, plane); - - } - - /// Get a writable int32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as int32 *. - - int32 * DirtyPixel_int32 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttSLong); - - return (int32 *) DirtyPixel (row, col, plane); - - } - - /// Get read-only real32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as real32 *. - - const real32 * ConstPixel_real32 (int32 row, - int32 col, - uint32 plane = 0) const - { - - ASSERT_PIXEL_TYPE (ttFloat); - - return (const real32 *) ConstPixel (row, col, plane); - - } - - /// Get a writable real32 * to pixel data starting at a specific pixel in the buffer. - /// \param row Start row for buffer pointer. - /// \param col Start column for buffer pointer. - /// \param plane Start plane for buffer pointer. - /// \retval Pointer to pixel data as real32 *. - - real32 * DirtyPixel_real32 (int32 row, - int32 col, - uint32 plane = 0) - { - - ASSERT_PIXEL_TYPE (ttFloat); - - return (real32 *) DirtyPixel (row, col, plane); - - } - - /// Initialize a rectangular area of pixel buffer to a constant. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant value to set pixels to. - - void SetConstant (const dng_rect &area, - uint32 plane, - uint32 planes, - uint32 value); - - /// Initialize a rectangular area of pixel buffer to a constant unsigned 8-bit value. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant uint8 value to set pixels to. - - void SetConstant_uint8 (const dng_rect &area, - uint32 plane, - uint32 planes, - uint8 value) - { - - DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type"); - - SetConstant (area, plane, planes, (uint32) value); - - } - - /// Initialize a rectangular area of pixel buffer to a constant unsigned 16-bit value. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant uint16 value to set pixels to. - - void SetConstant_uint16 (const dng_rect &area, - uint32 plane, - uint32 planes, - uint16 value) - { - - DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type"); - - SetConstant (area, plane, planes, (uint32) value); - - } - - /// Initialize a rectangular area of pixel buffer to a constant signed 16-bit value. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant int16 value to set pixels to. - - void SetConstant_int16 (const dng_rect &area, - uint32 plane, - uint32 planes, - int16 value) - { - - DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type"); - - SetConstant (area, plane, planes, (uint32) (uint16) value); - - } - - /// Initialize a rectangular area of pixel buffer to a constant unsigned 32-bit value. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant uint32 value to set pixels to. - - void SetConstant_uint32 (const dng_rect &area, - uint32 plane, - uint32 planes, - uint32 value) - { - - DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type"); - - SetConstant (area, plane, planes, value); - - } - - /// Initialize a rectangular area of pixel buffer to a constant real 32-bit value. - /// \param area Rectangle of pixel buffer to set. - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - /// \param value Constant real32 value to set pixels to. - - void SetConstant_real32 (const dng_rect &area, - uint32 plane, - uint32 planes, - real32 value) - { - - DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type"); - - union - { - uint32 i; - real32 f; - } x; - - x.f = value; - - SetConstant (area, plane, planes, x.i); - - } - - /// Initialize a rectangular area of pixel buffer to zeros. - /// \param area Rectangle of pixel buffer to zero. - /// \param area Area to zero - /// \param plane Plane to start filling on. - /// \param planes Number of planes to fill. - - void SetZero (const dng_rect &area, - uint32 plane, - uint32 planes); - - /// Copy image data from an area of one pixel buffer to same area of another. - /// \param src Buffer to copy from. - /// \param area Rectangle of pixel buffer to copy. - /// \param srcPlane Plane to start copy in src. - /// \param dstPlane Plane to start copy in dst. - /// \param planes Number of planes to copy. - - void CopyArea (const dng_pixel_buffer &src, - const dng_rect &area, - uint32 srcPlane, - uint32 dstPlane, - uint32 planes); - - /// Copy image data from an area of one pixel buffer to same area of another. - /// \param src Buffer to copy from. - /// \param area Rectangle of pixel buffer to copy. - /// \param plane Plane to start copy in src and this. - /// \param planes Number of planes to copy. - - void CopyArea (const dng_pixel_buffer &src, - const dng_rect &area, - uint32 plane, - uint32 planes) - { - - CopyArea (src, area, plane, plane, planes); - - } - - /// Calculate the offset phase of destination rectangle relative to source rectangle. - /// Phase is based on a 0,0 origin and the notion of repeating srcArea across dstArea. - /// It is the number of pixels into srcArea to start repeating from when tiling dstArea. - /// \retval dng_point containing horizontal and vertical phase. - - static dng_point RepeatPhase (const dng_rect &srcArea, - const dng_rect &dstArea); - - /// Repeat the image data in srcArea across dstArea. - /// (Generally used for padding operations.) - /// \param srcArea Area to repeat from. - /// \param dstArea Area to fill with data from srcArea. - - void RepeatArea (const dng_rect &srcArea, - const dng_rect &dstArea); - - /// Replicates a sub-area of a buffer to fill the entire buffer. - - void RepeatSubArea (const dng_rect subArea, - uint32 repeatV = 1, - uint32 repeatH = 1); - - /// Apply a right shift (C++ oerpator >>) to all pixel values. Only implemented for 16-bit (signed or unsigned) pixel buffers. - /// \param shift Number of bits by which to right shift each pixel value. - - void ShiftRight (uint32 shift); - - /// Change metadata so pixels are iterated in opposite horizontal order. - /// This operation does not require movement of actual pixel data. - - void FlipH (); - - /// Change metadata so pixels are iterated in opposite vertical order. - /// This operation does not require movement of actual pixel data. - - void FlipV (); - - /// Change metadata so pixels are iterated in opposite plane order. - /// This operation does not require movement of actual pixel data. - - void FlipZ (); // Flip planes - - /// Return true if the contents of an area of the pixel buffer area are the same as those of another. - /// \param rhs Buffer to compare against. - /// \param area Rectangle of pixel buffer to test. - /// \param plane Plane to start comparing. - /// \param planes Number of planes to compare. - /// \retval bool true if areas are equal, false otherwise. - - bool EqualArea (const dng_pixel_buffer &rhs, - const dng_rect &area, - uint32 plane, - uint32 planes) const; - - /// Return the absolute value of the maximum difference between two pixel buffers. Used for comparison testing with tolerance - /// \param rhs Buffer to compare against. - /// \param area Rectangle of pixel buffer to test. - /// \param plane Plane to start comparing. - /// \param planes Number of planes to compare. - /// \retval larges absolute value difference between the corresponding pixels each buffer across area. - - real64 MaximumDifference (const dng_pixel_buffer &rhs, - const dng_rect &area, - uint32 plane, - uint32 planes) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_point.cpp b/third_party/dng_sdk/dng_point.cpp deleted file mode 100644 index abfd7dd..0000000 --- a/third_party/dng_sdk/dng_point.cpp +++ /dev/null @@ -1,22 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_point.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_point.h" - -/*****************************************************************************/ - -// Currently all inlined. - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_point.h b/third_party/dng_sdk/dng_point.h deleted file mode 100644 index 476a71d..0000000 --- a/third_party/dng_sdk/dng_point.h +++ /dev/null @@ -1,198 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_point.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_point__ -#define __dng_point__ - -/*****************************************************************************/ - -#include "dng_types.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -class dng_point - { - - public: - - int32 v; - int32 h; - - public: - - dng_point () - : v (0) - , h (0) - { - } - - dng_point (int32 vv, int32 hh) - : v (vv) - , h (hh) - { - } - - bool operator== (const dng_point &pt) const - { - return (v == pt.v) && - (h == pt.h); - } - - bool operator!= (const dng_point &pt) const - { - return !(*this == pt); - } - - }; - -/*****************************************************************************/ - -class dng_point_real64 - { - - public: - - real64 v; - real64 h; - - public: - - dng_point_real64 () - : v (0.0) - , h (0.0) - { - } - - dng_point_real64 (real64 vv, real64 hh) - : v (vv) - , h (hh) - { - } - - dng_point_real64 (const dng_point &pt) - : v ((real64) pt.v) - , h ((real64) pt.h) - { - } - - bool operator== (const dng_point_real64 &pt) const - { - return (v == pt.v) && - (h == pt.h); - } - - bool operator!= (const dng_point_real64 &pt) const - { - return !(*this == pt); - } - - dng_point Round () const - { - return dng_point (Round_int32 (v), - Round_int32 (h)); - } - - }; - -/*****************************************************************************/ - -inline dng_point operator+ (const dng_point &a, - const dng_point &b) - - - { - - return dng_point (a.v + b.v, - a.h + b.h); - - } - -/*****************************************************************************/ - -inline dng_point_real64 operator+ (const dng_point_real64 &a, - const dng_point_real64 &b) - - - { - - return dng_point_real64 (a.v + b.v, - a.h + b.h); - - } - -/*****************************************************************************/ - -inline dng_point operator- (const dng_point &a, - const dng_point &b) - - - { - - return dng_point (a.v - b.v, - a.h - b.h); - - } - -/*****************************************************************************/ - -inline dng_point_real64 operator- (const dng_point_real64 &a, - const dng_point_real64 &b) - - - { - - return dng_point_real64 (a.v - b.v, - a.h - b.h); - - } - -/*****************************************************************************/ - -inline real64 DistanceSquared (const dng_point_real64 &a, - const dng_point_real64 &b) - - - { - - dng_point_real64 diff = a - b; - - return (diff.v * diff.v) + (diff.h * diff.h); - - } - -/*****************************************************************************/ - -inline dng_point Transpose (const dng_point &a) - { - - return dng_point (a.h, a.v); - - } - -/*****************************************************************************/ - -inline dng_point_real64 Transpose (const dng_point_real64 &a) - { - - return dng_point_real64 (a.h, a.v); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_preview.cpp b/third_party/dng_sdk/dng_preview.cpp deleted file mode 100644 index 1a65cb0..0000000 --- a/third_party/dng_sdk/dng_preview.cpp +++ /dev/null @@ -1,709 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_preview.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_preview.h" - -#include "dng_assertions.h" -#include "dng_image.h" -#include "dng_image_writer.h" -#include "dng_memory.h" -#include "dng_stream.h" -#include "dng_tag_codes.h" -#include "dng_tag_values.h" - -/*****************************************************************************/ - -class dng_preview_tag_set: public dng_basic_tag_set - { - - private: - - tag_string fApplicationNameTag; - - tag_string fApplicationVersionTag; - - tag_string fSettingsNameTag; - - dng_fingerprint fSettingsDigest; - - tag_uint8_ptr fSettingsDigestTag; - - tag_uint32 fColorSpaceTag; - - tag_string fDateTimeTag; - - tag_real64 fRawToPreviewGainTag; - - tag_uint32 fCacheVersionTag; - - public: - - dng_preview_tag_set (dng_tiff_directory &directory, - const dng_preview &preview, - const dng_ifd &ifd); - - virtual ~dng_preview_tag_set (); - - }; - -/*****************************************************************************/ - -dng_preview_tag_set::dng_preview_tag_set (dng_tiff_directory &directory, - const dng_preview &preview, - const dng_ifd &ifd) - - : dng_basic_tag_set (directory, ifd) - - , fApplicationNameTag (tcPreviewApplicationName, - preview.fInfo.fApplicationName, - false) - - , fApplicationVersionTag (tcPreviewApplicationVersion, - preview.fInfo.fApplicationVersion, - false) - - , fSettingsNameTag (tcPreviewSettingsName, - preview.fInfo.fSettingsName, - false) - - , fSettingsDigest (preview.fInfo.fSettingsDigest) - - , fSettingsDigestTag (tcPreviewSettingsDigest, - fSettingsDigest.data, - 16) - - , fColorSpaceTag (tcPreviewColorSpace, - preview.fInfo.fColorSpace) - - , fDateTimeTag (tcPreviewDateTime, - preview.fInfo.fDateTime, - true) - - , fRawToPreviewGainTag (tcRawToPreviewGain, - preview.fInfo.fRawToPreviewGain) - - , fCacheVersionTag (tcCacheVersion, - preview.fInfo.fCacheVersion) - - { - - if (preview.fInfo.fApplicationName.NotEmpty ()) - { - - directory.Add (&fApplicationNameTag); - - } - - if (preview.fInfo.fApplicationVersion.NotEmpty ()) - { - - directory.Add (&fApplicationVersionTag); - - } - - if (preview.fInfo.fSettingsName.NotEmpty ()) - { - - directory.Add (&fSettingsNameTag); - - } - - if (preview.fInfo.fSettingsDigest.IsValid ()) - { - - directory.Add (&fSettingsDigestTag); - - } - - if (preview.fInfo.fColorSpace != previewColorSpace_MaxEnum) - { - - directory.Add (&fColorSpaceTag); - - } - - if (preview.fInfo.fDateTime.NotEmpty ()) - { - - directory.Add (&fDateTimeTag); - - } - - if (preview.fInfo.fRawToPreviewGain != 1.0) - { - - directory.Add (&fRawToPreviewGainTag); - - } - - if (preview.fInfo.fCacheVersion != 0) - { - - directory.Add (&fCacheVersionTag); - - } - - } - -/*****************************************************************************/ - -dng_preview_tag_set::~dng_preview_tag_set () - { - - } - -/*****************************************************************************/ - -dng_preview::dng_preview () - - : fInfo () - - { - - } - -/*****************************************************************************/ - -dng_preview::~dng_preview () - { - - } - -/*****************************************************************************/ - -dng_image_preview::dng_image_preview () - - : fImage () - , fIFD () - - { - - } - -/*****************************************************************************/ - -dng_image_preview::~dng_image_preview () - { - - } - -/*****************************************************************************/ - -dng_basic_tag_set * dng_image_preview::AddTagSet (dng_tiff_directory &directory) const - { - - fIFD.fNewSubFileType = fInfo.fIsPrimary ? sfPreviewImage - : sfAltPreviewImage; - - fIFD.fImageWidth = fImage->Width (); - fIFD.fImageLength = fImage->Height (); - - fIFD.fSamplesPerPixel = fImage->Planes (); - - fIFD.fPhotometricInterpretation = fIFD.fSamplesPerPixel == 1 ? piBlackIsZero - : piRGB; - - fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8; - - for (uint32 j = 1; j < fIFD.fSamplesPerPixel; j++) - { - fIFD.fBitsPerSample [j] = fIFD.fBitsPerSample [0]; - } - - fIFD.SetSingleStrip (); - - return new dng_preview_tag_set (directory, *this, fIFD); - - } - -/*****************************************************************************/ - -void dng_image_preview::WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const - { - - writer.WriteImage (host, - fIFD, - basic, - stream, - *fImage.Get ()); - - } - -/*****************************************************************************/ - -class dng_jpeg_preview_tag_set: public dng_preview_tag_set - { - - private: - - dng_urational fCoefficientsData [3]; - - tag_urational_ptr fCoefficientsTag; - - uint16 fSubSamplingData [2]; - - tag_uint16_ptr fSubSamplingTag; - - tag_uint16 fPositioningTag; - - dng_urational fReferenceData [6]; - - tag_urational_ptr fReferenceTag; - - public: - - dng_jpeg_preview_tag_set (dng_tiff_directory &directory, - const dng_jpeg_preview &preview, - const dng_ifd &ifd); - - virtual ~dng_jpeg_preview_tag_set (); - - }; - -/******************************************************************************/ - -dng_jpeg_preview_tag_set::dng_jpeg_preview_tag_set (dng_tiff_directory &directory, - const dng_jpeg_preview &preview, - const dng_ifd &ifd) - - : dng_preview_tag_set (directory, preview, ifd) - - , fCoefficientsTag (tcYCbCrCoefficients, fCoefficientsData, 3) - - , fSubSamplingTag (tcYCbCrSubSampling, fSubSamplingData, 2) - - , fPositioningTag (tcYCbCrPositioning, preview.fYCbCrPositioning) - - , fReferenceTag (tcReferenceBlackWhite, fReferenceData, 6) - - { - - if (preview.fPhotometricInterpretation == piYCbCr) - { - - fCoefficientsData [0] = dng_urational (299, 1000); - fCoefficientsData [1] = dng_urational (587, 1000); - fCoefficientsData [2] = dng_urational (114, 1000); - - directory.Add (&fCoefficientsTag); - - fSubSamplingData [0] = (uint16) preview.fYCbCrSubSampling.h; - fSubSamplingData [1] = (uint16) preview.fYCbCrSubSampling.v; - - directory.Add (&fSubSamplingTag); - - directory.Add (&fPositioningTag); - - fReferenceData [0] = dng_urational ( 0, 1); - fReferenceData [1] = dng_urational (255, 1); - fReferenceData [2] = dng_urational (128, 1); - fReferenceData [3] = dng_urational (255, 1); - fReferenceData [4] = dng_urational (128, 1); - fReferenceData [5] = dng_urational (255, 1); - - directory.Add (&fReferenceTag); - - } - - } - -/*****************************************************************************/ - -dng_jpeg_preview_tag_set::~dng_jpeg_preview_tag_set () - { - - } - -/*****************************************************************************/ - -dng_jpeg_preview::dng_jpeg_preview () - - : fPreviewSize () - , fPhotometricInterpretation (piYCbCr) - , fYCbCrSubSampling (1, 1) - , fYCbCrPositioning (2) - , fCompressedData () - - { - - } - -/*****************************************************************************/ - -dng_jpeg_preview::~dng_jpeg_preview () - { - - } - -/*****************************************************************************/ - -dng_basic_tag_set * dng_jpeg_preview::AddTagSet (dng_tiff_directory &directory) const - { - - dng_ifd ifd; - - ifd.fNewSubFileType = fInfo.fIsPrimary ? sfPreviewImage - : sfAltPreviewImage; - - ifd.fImageWidth = fPreviewSize.h; - ifd.fImageLength = fPreviewSize.v; - - ifd.fPhotometricInterpretation = fPhotometricInterpretation; - - ifd.fBitsPerSample [0] = 8; - ifd.fBitsPerSample [1] = 8; - ifd.fBitsPerSample [2] = 8; - - ifd.fSamplesPerPixel = (fPhotometricInterpretation == piBlackIsZero ? 1 : 3); - - ifd.fCompression = ccJPEG; - ifd.fPredictor = cpNullPredictor; - - ifd.SetSingleStrip (); - - return new dng_jpeg_preview_tag_set (directory, *this, ifd); - - } - -/*****************************************************************************/ - -void dng_jpeg_preview::WriteData (dng_host & /* host */, - dng_image_writer & /* writer */, - dng_basic_tag_set &basic, - dng_stream &stream) const - { - - basic.SetTileOffset (0, (uint32) stream.Position ()); - - basic.SetTileByteCount (0, fCompressedData->LogicalSize ()); - - stream.Put (fCompressedData->Buffer (), - fCompressedData->LogicalSize ()); - - if (fCompressedData->LogicalSize () & 1) - { - stream.Put_uint8 (0); - } - - } - -/*****************************************************************************/ - -void dng_jpeg_preview::SpoolAdobeThumbnail (dng_stream &stream) const - { - - DNG_ASSERT (fCompressedData.Get (), - "SpoolAdobeThumbnail: no data"); - - DNG_ASSERT (fPhotometricInterpretation == piYCbCr, - "SpoolAdobeThumbnail: Non-YCbCr"); - - uint32 compressedSize = fCompressedData->LogicalSize (); - - stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M')); - stream.Put_uint16 (1036); - stream.Put_uint16 (0); - - stream.Put_uint32 (compressedSize + 28); - - uint32 widthBytes = (fPreviewSize.h * 24 + 31) / 32 * 4; - - stream.Put_uint32 (1); - stream.Put_uint32 (fPreviewSize.h); - stream.Put_uint32 (fPreviewSize.v); - stream.Put_uint32 (widthBytes); - stream.Put_uint32 (widthBytes * fPreviewSize.v); - stream.Put_uint32 (compressedSize); - stream.Put_uint16 (24); - stream.Put_uint16 (1); - - stream.Put (fCompressedData->Buffer (), - compressedSize); - - if (compressedSize & 1) - { - stream.Put_uint8 (0); - } - - } - -/*****************************************************************************/ - -class dng_raw_preview_tag_set: public dng_preview_tag_set - { - - private: - - tag_data_ptr fOpcodeList2Tag; - - tag_uint32_ptr fWhiteLevelTag; - - uint32 fWhiteLevelData [kMaxColorPlanes]; - - public: - - dng_raw_preview_tag_set (dng_tiff_directory &directory, - const dng_raw_preview &preview, - const dng_ifd &ifd); - - virtual ~dng_raw_preview_tag_set (); - - }; - -/*****************************************************************************/ - -dng_raw_preview_tag_set::dng_raw_preview_tag_set (dng_tiff_directory &directory, - const dng_raw_preview &preview, - const dng_ifd &ifd) - - : dng_preview_tag_set (directory, preview, ifd) - - , fOpcodeList2Tag (tcOpcodeList2, - ttUndefined, - 0, - NULL) - - , fWhiteLevelTag (tcWhiteLevel, - fWhiteLevelData, - preview.fImage->Planes ()) - - { - - if (preview.fOpcodeList2Data.Get ()) - { - - fOpcodeList2Tag.SetData (preview.fOpcodeList2Data->Buffer ()); - fOpcodeList2Tag.SetCount (preview.fOpcodeList2Data->LogicalSize ()); - - directory.Add (&fOpcodeList2Tag); - - } - - if (preview.fImage->PixelType () == ttFloat) - { - - for (uint32 j = 0; j < kMaxColorPlanes; j++) - { - fWhiteLevelData [j] = 32768; - } - - directory.Add (&fWhiteLevelTag); - - } - - } - -/*****************************************************************************/ - -dng_raw_preview_tag_set::~dng_raw_preview_tag_set () - { - - } - -/*****************************************************************************/ - -dng_raw_preview::dng_raw_preview () - - : fImage () - , fOpcodeList2Data () - , fCompressionQuality (-1) - , fIFD () - - { - - } - -/*****************************************************************************/ - -dng_raw_preview::~dng_raw_preview () - { - - } - -/*****************************************************************************/ - -dng_basic_tag_set * dng_raw_preview::AddTagSet (dng_tiff_directory &directory) const - { - - fIFD.fNewSubFileType = sfPreviewImage; - - fIFD.fImageWidth = fImage->Width (); - fIFD.fImageLength = fImage->Height (); - - fIFD.fSamplesPerPixel = fImage->Planes (); - - fIFD.fPhotometricInterpretation = piLinearRaw; - - if (fImage->PixelType () == ttFloat) - { - - fIFD.fCompression = ccDeflate; - - fIFD.fCompressionQuality = fCompressionQuality; - - fIFD.fPredictor = cpFloatingPoint; - - for (uint32 j = 0; j < fIFD.fSamplesPerPixel; j++) - { - fIFD.fBitsPerSample [j] = 16; - fIFD.fSampleFormat [j] = sfFloatingPoint; - } - - fIFD.FindTileSize (512 * 1024); - - } - - else - { - - fIFD.fCompression = ccLossyJPEG; - - fIFD.fCompressionQuality = fCompressionQuality; - - fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8; - - for (uint32 j = 1; j < fIFD.fSamplesPerPixel; j++) - { - fIFD.fBitsPerSample [j] = fIFD.fBitsPerSample [0]; - } - - fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel); - - } - - return new dng_raw_preview_tag_set (directory, *this, fIFD); - - } - -/*****************************************************************************/ - -void dng_raw_preview::WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const - { - - writer.WriteImage (host, - fIFD, - basic, - stream, - *fImage.Get ()); - - } - -/*****************************************************************************/ - -dng_mask_preview::dng_mask_preview () - - : fImage () - , fCompressionQuality (-1) - , fIFD () - - { - - } - -/*****************************************************************************/ - -dng_mask_preview::~dng_mask_preview () - { - - } - -/*****************************************************************************/ - -dng_basic_tag_set * dng_mask_preview::AddTagSet (dng_tiff_directory &directory) const - { - - fIFD.fNewSubFileType = sfPreviewMask; - - fIFD.fImageWidth = fImage->Width (); - fIFD.fImageLength = fImage->Height (); - - fIFD.fSamplesPerPixel = 1; - - fIFD.fPhotometricInterpretation = piTransparencyMask; - - fIFD.fCompression = ccDeflate; - fIFD.fPredictor = cpHorizontalDifference; - - fIFD.fCompressionQuality = fCompressionQuality; - - fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8; - - fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel); - - return new dng_basic_tag_set (directory, fIFD); - - } - -/*****************************************************************************/ - -void dng_mask_preview::WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const - { - - writer.WriteImage (host, - fIFD, - basic, - stream, - *fImage.Get ()); - - } - -/*****************************************************************************/ - -dng_preview_list::dng_preview_list () - - : fCount (0) - - { - - } - -/*****************************************************************************/ - -dng_preview_list::~dng_preview_list () - { - - } - -/*****************************************************************************/ - -void dng_preview_list::Append (AutoPtr &preview) - { - - if (preview.Get ()) - { - - DNG_ASSERT (fCount < kMaxDNGPreviews, "DNG preview list overflow"); - - if (fCount < kMaxDNGPreviews) - { - - fPreview [fCount++] . Reset (preview.Release ()); - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_preview.h b/third_party/dng_sdk/dng_preview.h deleted file mode 100644 index 2b616e3..0000000 --- a/third_party/dng_sdk/dng_preview.h +++ /dev/null @@ -1,245 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_preview.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_preview__ -#define __dng_preview__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_ifd.h" -#include "dng_opcode_list.h" -#include "dng_point.h" -#include "dng_sdk_limits.h" - -/*****************************************************************************/ - -class dng_preview - { - - public: - - dng_preview_info fInfo; - - protected: - - dng_preview (); - - public: - - virtual ~dng_preview (); - - virtual dng_basic_tag_set * AddTagSet (dng_tiff_directory &directory) const = 0; - - virtual void WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const = 0; - - }; - -/*****************************************************************************/ - -class dng_image_preview: public dng_preview - { - - public: - - AutoPtr fImage; - - private: - - mutable dng_ifd fIFD; - - public: - - dng_image_preview (); - - virtual ~dng_image_preview (); - - virtual dng_basic_tag_set * AddTagSet (dng_tiff_directory &directory) const; - - virtual void WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - dng_image_preview (const dng_image_preview &preview); - - dng_image_preview & operator= (const dng_image_preview &preview); - - }; - -/*****************************************************************************/ - -class dng_jpeg_preview: public dng_preview - { - - public: - - dng_point fPreviewSize; - - uint16 fPhotometricInterpretation; - - dng_point fYCbCrSubSampling; - - uint16 fYCbCrPositioning; - - AutoPtr fCompressedData; - - public: - - dng_jpeg_preview (); - - virtual ~dng_jpeg_preview (); - - virtual dng_basic_tag_set * AddTagSet (dng_tiff_directory &directory) const; - - virtual void WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const; - - void SpoolAdobeThumbnail (dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - dng_jpeg_preview (const dng_jpeg_preview &preview); - - dng_jpeg_preview & operator= (const dng_jpeg_preview &preview); - - }; - -/*****************************************************************************/ - -class dng_raw_preview: public dng_preview - { - - public: - - AutoPtr fImage; - - AutoPtr fOpcodeList2Data; - - int32 fCompressionQuality; - - private: - - mutable dng_ifd fIFD; - - public: - - dng_raw_preview (); - - virtual ~dng_raw_preview (); - - virtual dng_basic_tag_set * AddTagSet (dng_tiff_directory &directory) const; - - virtual void WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - dng_raw_preview (const dng_raw_preview &preview); - - dng_raw_preview & operator= (const dng_raw_preview &preview); - - }; - -/*****************************************************************************/ - -class dng_mask_preview: public dng_preview - { - - public: - - AutoPtr fImage; - - int32 fCompressionQuality; - - private: - - mutable dng_ifd fIFD; - - public: - - dng_mask_preview (); - - virtual ~dng_mask_preview (); - - virtual dng_basic_tag_set * AddTagSet (dng_tiff_directory &directory) const; - - virtual void WriteData (dng_host &host, - dng_image_writer &writer, - dng_basic_tag_set &basic, - dng_stream &stream) const; - - private: - - // Hidden copy constructor and assignment operator. - - dng_mask_preview (const dng_mask_preview &preview); - - dng_mask_preview & operator= (const dng_mask_preview &preview); - - }; - -/*****************************************************************************/ - -class dng_preview_list - { - - private: - - uint32 fCount; - - AutoPtr fPreview [kMaxDNGPreviews]; - - public: - - dng_preview_list (); - - ~dng_preview_list (); - - uint32 Count () const - { - return fCount; - } - - const dng_preview & Preview (uint32 index) const - { - return *(fPreview [index]); - } - - void Append (AutoPtr &preview); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_pthread.cpp b/third_party/dng_sdk/dng_pthread.cpp deleted file mode 100644 index 2fffa07..0000000 --- a/third_party/dng_sdk/dng_pthread.cpp +++ /dev/null @@ -1,1141 +0,0 @@ -/*****************************************************************************/ -// Copyright 2002-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pthread.cpp#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -#include "dng_pthread.h" - -/*****************************************************************************/ - -#if qDNGThreadSafe - -/*****************************************************************************/ - -#include "dng_assertions.h" - -/*****************************************************************************/ - -#if qWinOS - -#pragma warning(disable : 4786) - -// Nothing in this file requires Unicode, -// However, CreateSemaphore has a path parameter -// (which is NULL always in this code) and thus -// does not work on Win98 if UNICODE is defined. -// So we force it off here. - -#undef UNICODE -#undef _UNICODE - -#include -#include -#include -#include -#include -#include - -#else - -#include - -#endif - -/*****************************************************************************/ - -#if qWinOS - -/*****************************************************************************/ - -namespace { - struct waiter { - struct waiter *prev; - struct waiter *next; - HANDLE semaphore; - bool chosen_by_signal; - }; -} - -/*****************************************************************************/ - -struct dng_pthread_mutex_impl -{ - CRITICAL_SECTION lock; - - dng_pthread_mutex_impl() { ::InitializeCriticalSection(&lock); } - ~dng_pthread_mutex_impl() { ::DeleteCriticalSection(&lock); } - void Lock() { ::EnterCriticalSection(&lock); } - void Unlock() { ::LeaveCriticalSection(&lock); } -private: - dng_pthread_mutex_impl &operator=(const dng_pthread_mutex_impl &) { } - dng_pthread_mutex_impl(const dng_pthread_mutex_impl &) { } -}; - -/*****************************************************************************/ - -struct dng_pthread_cond_impl -{ - dng_pthread_mutex_impl lock; // Mutual exclusion on next two variables - waiter *head_waiter; // List of threads waiting on this condition - waiter *tail_waiter; // Used to get FIFO, rather than LIFO, behavior for pthread_cond_signal - unsigned int broadcast_generation; // Used as sort of a separator on broadcasts - // saves having to walk the waiters list setting - // each one's "chosen_by_signal" flag while the condition is locked - - dng_pthread_cond_impl() : head_waiter(NULL), tail_waiter(NULL), broadcast_generation(0) { } - ~dng_pthread_cond_impl() { } ; - -// Non copyable -private: - dng_pthread_cond_impl &operator=(const dng_pthread_cond_impl &) { } - dng_pthread_cond_impl(const dng_pthread_cond_impl &) { } - -}; - -/*****************************************************************************/ - -namespace -{ - - struct ScopedLock - { - dng_pthread_mutex_impl *mutex; - - ScopedLock(dng_pthread_mutex_impl *arg) : mutex(arg) - { - mutex->Lock(); - } - ScopedLock(dng_pthread_mutex_impl &arg) : mutex(&arg) - { - mutex->Lock(); - } - ~ScopedLock() - { - mutex->Unlock(); - } - private: - ScopedLock &operator=(const ScopedLock &) { } - ScopedLock(const ScopedLock &) { } - }; - - dng_pthread_mutex_impl validationLock; - - void ValidateMutex(dng_pthread_mutex_t *mutex) - { - if (*mutex != DNG_PTHREAD_MUTEX_INITIALIZER) - return; - - ScopedLock lock(validationLock); - - if (*mutex == DNG_PTHREAD_MUTEX_INITIALIZER) - dng_pthread_mutex_init(mutex, NULL); - } - - void ValidateCond(dng_pthread_cond_t *cond) - { - if (*cond != DNG_PTHREAD_COND_INITIALIZER) - return; - - ScopedLock lock(validationLock); - - if (*cond == DNG_PTHREAD_COND_INITIALIZER) - dng_pthread_cond_init(cond, NULL); - } - - DWORD thread_wait_sema_TLS_index; - bool thread_wait_sema_inited = false; - dng_pthread_once_t once_thread_TLS = DNG_PTHREAD_ONCE_INIT; - - void init_thread_TLS() - { - thread_wait_sema_TLS_index = ::TlsAlloc(); - thread_wait_sema_inited = true; - } - - void finalize_thread_TLS() - { - if (thread_wait_sema_inited) - { - ::TlsFree(thread_wait_sema_TLS_index); - thread_wait_sema_inited = false; - } - } - - dng_pthread_mutex_impl primaryHandleMapLock; - - typedef std::map > ThreadMapType; - - // A map to make sure handles are freed and to allow returning a pointer sized result - // even on 64-bit Windows. - ThreadMapType primaryHandleMap; - - HANDLE GetThreadSemaphore() - { - dng_pthread_once(&once_thread_TLS, init_thread_TLS); - - HANDLE semaphore = ::TlsGetValue(thread_wait_sema_TLS_index); - if (semaphore == NULL) - { - semaphore = ::CreateSemaphore(NULL, 0, 1, NULL); - ::TlsSetValue(thread_wait_sema_TLS_index, semaphore); - } - - return semaphore; - } - - void FreeThreadSemaphore() - { - if (thread_wait_sema_inited) - { - HANDLE semaphore = (HANDLE)::TlsGetValue(thread_wait_sema_TLS_index); - - if (semaphore != NULL) - { - ::TlsSetValue(thread_wait_sema_TLS_index, NULL); - ::CloseHandle(semaphore); - } - } - } - - struct trampoline_args - { - void *(*func)(void *); - void *arg; - }; - - // This trampoline takes care of the return type being different - // between pthreads thread funcs and Windows C lib thread funcs - unsigned __stdcall trampoline(void *arg_arg) - { - trampoline_args *args_ptr = (trampoline_args *)arg_arg; - trampoline_args args = *args_ptr; - - delete args_ptr; - - GetThreadSemaphore(); - - void *result = args.func(args.arg); - - { - ScopedLock lockMap(primaryHandleMapLock); - - ThreadMapType::iterator iter = primaryHandleMap.find(pthread_self()); - if (iter != primaryHandleMap.end()) - *iter->second.second = result; - } - - FreeThreadSemaphore(); - - return S_OK; - } - -} - -/*****************************************************************************/ - -extern "C" { - -/*****************************************************************************/ - -struct dng_pthread_attr_impl - { - size_t stacksize; - }; - -/*****************************************************************************/ - -int dng_pthread_attr_init(pthread_attr_t *attr) - { - dng_pthread_attr_impl *newAttrs; - - newAttrs = new (std::nothrow) dng_pthread_attr_impl; - if (newAttrs == NULL) - return -1; // ENOMEM; - - newAttrs->stacksize = 0; - - *attr = newAttrs; - - return 0; - } - -/*****************************************************************************/ - -int dng_pthread_attr_destroy(pthread_attr_t *attr) - { - if (*attr == NULL) - return -1; // EINVAL - - delete *attr; - - *attr = NULL; - - return 0; - } - -/*****************************************************************************/ - -int dng_pthread_attr_setstacksize(dng_pthread_attr_t *attr, size_t stacksize) - { - if (attr == NULL || (*attr) == NULL) - return -1; // EINVAL - - (*attr)->stacksize = stacksize; - - return 0; - } - -/*****************************************************************************/ - -int dng_pthread_attr_getstacksize(const dng_pthread_attr_t *attr, size_t *stacksize) - { - if (attr == NULL || (*attr) == NULL || stacksize == NULL) - return -1; // EINVAL - - *stacksize = (*attr)->stacksize; - - return 0; - } - -/*****************************************************************************/ - -int dng_pthread_create(dng_pthread_t *thread, const pthread_attr_t *attrs, void * (*func)(void *), void *arg) -{ - try - { - uintptr_t result; - unsigned threadID; - std::auto_ptr args(new (std::nothrow) trampoline_args); - std::auto_ptr resultHolder(new (std::nothrow) (void *)); - - if (args.get() == NULL || resultHolder.get () == NULL) - return -1; // ENOMEM - - args->func = func; - args->arg = arg; - - size_t stacksize = 0; - - if (attrs != NULL) - dng_pthread_attr_getstacksize (attrs, &stacksize); - - { - ScopedLock lockMap(primaryHandleMapLock); - - result = _beginthreadex(NULL, (unsigned)stacksize, trampoline, args.get(), 0, &threadID); - if (result == NULL) - return -1; // ENOMEM - args.release(); - - std::pair > newMapEntry(threadID, - std::pair((HANDLE)result, resultHolder.get ())); - std::pair insertion = primaryHandleMap.insert(newMapEntry); - - // If there is a handle open on the thread, its ID should not be reused so assert that an insertion was made. - DNG_ASSERT(insertion.second, "pthread emulation logic error"); - } - - - resultHolder.release (); - - *thread = (dng_pthread_t)threadID; - return 0; - } - catch (const std::bad_alloc &) - { - return -1; - } -} - -/*****************************************************************************/ - -int dng_pthread_detach(dng_pthread_t thread) -{ - HANDLE primaryHandle; - void **resultHolder = NULL; - - { - ScopedLock lockMap(primaryHandleMapLock); - - ThreadMapType::iterator iter = primaryHandleMap.find(thread); - if (iter == primaryHandleMap.end()) - return -1; - - primaryHandle = iter->second.first; - - // A join is waiting on the thread. - if (primaryHandle == NULL) - return -1; - - resultHolder = iter->second.second; - - primaryHandleMap.erase(iter); - } - - delete resultHolder; - - if (!::CloseHandle(primaryHandle)) - return -1; - - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_join(dng_pthread_t thread, void **result) -{ - bool found = false; - HANDLE primaryHandle = NULL; - void **resultHolder = NULL; - - ThreadMapType::iterator iter; - - { - ScopedLock lockMap(primaryHandleMapLock); - - iter = primaryHandleMap.find(thread); - found = iter != primaryHandleMap.end(); - if (found) - { - primaryHandle = iter->second.first; - resultHolder = iter->second.second; - - // Set HANDLE to NULL to force any later join or detach to fail. - iter->second.first = NULL; - } - } - - // This case can happens when joining a thread not created with pthread_create, - // which is a bad idea, but it gets mapped to doing the join, but always returns NULL. - if (!found) - primaryHandle = ::OpenThread(SYNCHRONIZE|THREAD_QUERY_INFORMATION, FALSE, thread); - - if (primaryHandle == NULL) - return -1; - - DWORD err; - if (::WaitForSingleObject(primaryHandle, INFINITE) != WAIT_OBJECT_0) - { - err = ::GetLastError(); - return -1; - } - - { - ScopedLock lockMap(primaryHandleMapLock); - - if (iter != primaryHandleMap.end()) - primaryHandleMap.erase(iter); - } - - ::CloseHandle(primaryHandle); - if (result != NULL && resultHolder != NULL) - *result = *resultHolder; - - delete resultHolder; - - return 0; -} - -/*****************************************************************************/ - -dng_pthread_t dng_pthread_self() -{ - return (dng_pthread_t)::GetCurrentThreadId(); -} - -/*****************************************************************************/ - -void dng_pthread_exit(void *result) -{ - { - ScopedLock lockMap(primaryHandleMapLock); - - ThreadMapType::iterator iter = primaryHandleMap.find(pthread_self()); - if (iter != primaryHandleMap.end()) - *iter->second.second = result; - } - - FreeThreadSemaphore(); - - _endthreadex(S_OK); -} - -/*****************************************************************************/ - -int dng_pthread_mutex_init(dng_pthread_mutex_t *mutex, void * /* attrs */) -{ - dng_pthread_mutex_t result; - try { - result = new(dng_pthread_mutex_impl); - } catch (const std::bad_alloc &) - { - return -1; - } - - if (result == NULL) - return -1; - *mutex = result; - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_mutex_destroy(dng_pthread_mutex_t *mutex) -{ - if (*mutex == DNG_PTHREAD_MUTEX_INITIALIZER) - { - *mutex = NULL; - return 0; - } - - delete *mutex; - *mutex = NULL; - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_cond_init(dng_pthread_cond_t *cond, void * /* attrs */) -{ - dng_pthread_cond_t result; - try { - result = new(dng_pthread_cond_impl); - } catch (const std::bad_alloc &) - { - return -1; - } - - if (result == NULL) - return -1; - *cond = result; - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_cond_destroy(dng_pthread_cond_t *cond) -{ - if (*cond == DNG_PTHREAD_COND_INITIALIZER) - { - *cond = NULL; - return 0; - } - - delete *cond; - *cond = NULL; - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_mutexattr_init(dng_pthread_mutexattr_t* mutexattr) -{ - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_mutexattr_settype(dng_pthread_mutexattr_t* mutexattr, int type) -{ - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_mutex_lock(dng_pthread_mutex_t *mutex) -{ - ValidateMutex(mutex); - (*mutex)->Lock(); - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_mutex_unlock(dng_pthread_mutex_t *mutex) -{ - ValidateMutex(mutex); - (*mutex)->Unlock(); - return 0; -} - -/*****************************************************************************/ - -static int cond_wait_internal(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex, int timeout_milliseconds) -{ - dng_pthread_cond_impl &real_cond = **cond; - dng_pthread_mutex_impl &real_mutex = **mutex; - - waiter this_wait; - HANDLE semaphore = GetThreadSemaphore(); - int my_generation; // The broadcast generation this waiter is in - - { - this_wait.next = NULL; - this_wait.semaphore = semaphore; - this_wait.chosen_by_signal = 0; - - ScopedLock lock1(real_cond.lock); - - // Add this waiter to the end of the list. - this_wait.prev = real_cond.tail_waiter; - if (real_cond.tail_waiter != NULL) - real_cond.tail_waiter->next = &this_wait; - real_cond.tail_waiter = &this_wait; - - // If the list was empty, set the head of the list to this waiter. - if (real_cond.head_waiter == NULL) - real_cond.head_waiter = &this_wait; - - // Note which broadcast generation this waiter belongs to. - my_generation = real_cond.broadcast_generation; - } - - real_mutex.Unlock(); - - DWORD result = ::WaitForSingleObject(semaphore, timeout_milliseconds); - - if (result == WAIT_TIMEOUT) - { - // If the wait timed out, this thread is likely still on the waiters list - // of the condition. However, there is a race in that the thread may have been - // signaled or broadcast between when WaitForSingleObject decided - // we had timed out and this code running. - - bool mustConsumeSemaphore = false; - { - ScopedLock lock2(real_cond.lock); - - bool chosen_by_signal = this_wait.chosen_by_signal; - bool chosen_by_broadcast = my_generation != real_cond.broadcast_generation; - - if (chosen_by_signal || chosen_by_broadcast) - mustConsumeSemaphore = true; - else - { - // Still on waiters list. Remove this waiter from list. - if (this_wait.next != NULL) - this_wait.next->prev = this_wait.prev; - else - real_cond.tail_waiter = this_wait.prev; - - if (this_wait.prev != NULL) - this_wait.prev->next = this_wait.next; - else - real_cond.head_waiter = this_wait.next; - } - } - - if (mustConsumeSemaphore) - { - ::WaitForSingleObject(semaphore, INFINITE); - result = WAIT_OBJECT_0; - } - } - else - DNG_ASSERT (result == WAIT_OBJECT_0, "pthread emulation logic error"); - - // reacquire the mutex - real_mutex.Lock(); - - return (result == WAIT_TIMEOUT) ? DNG_ETIMEDOUT : 0; -} - -/*****************************************************************************/ - -int dng_pthread_cond_wait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex) -{ - ValidateCond(cond); - - return cond_wait_internal(cond, mutex, INFINITE); -} - -/*****************************************************************************/ - -int dng_pthread_cond_timedwait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex, struct dng_timespec *latest_time) -{ - ValidateCond(cond); - - struct dng_timespec sys_timespec; - - dng_pthread_now (&sys_timespec); - - __int64 sys_time = (__int64)sys_timespec.tv_sec * 1000000000 + sys_timespec.tv_nsec; - __int64 lock_time = (__int64)latest_time->tv_sec * 1000000000 + latest_time->tv_nsec; - - int wait_millisecs = (int)((lock_time - sys_time + 500000) / 1000000); - - if (wait_millisecs < 0) - wait_millisecs = 0; - - return cond_wait_internal(cond, mutex, wait_millisecs); -} - -/*****************************************************************************/ - -int dng_pthread_cond_signal(dng_pthread_cond_t *cond) -{ - ValidateCond(cond); - - waiter *first; - dng_pthread_cond_impl &real_cond = **cond; - - { - ScopedLock lock(real_cond.lock); - - first = real_cond.head_waiter; - if (first != NULL) - { - if (first->next != NULL) - first->next->prev = NULL; - else - real_cond.tail_waiter = NULL; // Or first->prev, which is always NULL in this case - - first->chosen_by_signal = true; - - real_cond.head_waiter = first->next; - } - } - - if (first != NULL) - ::ReleaseSemaphore(first->semaphore, 1, NULL); - - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_cond_broadcast(dng_pthread_cond_t *cond) -{ - ValidateCond(cond); - - waiter *first; - dng_pthread_cond_impl &real_cond = **cond; - - { - ScopedLock lock(real_cond.lock); - - first = real_cond.head_waiter; - real_cond.head_waiter = NULL; - real_cond.tail_waiter = NULL; - - real_cond.broadcast_generation++; - } - - while (first != NULL) - { - waiter *next = first->next; - ::ReleaseSemaphore(first->semaphore, 1, NULL); - first = next; - } - - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_once(dng_pthread_once_t *once, void (*init_func)()) -{ - if (once == NULL || init_func == NULL) - return EINVAL; - - if (once->inited) - return 0; - - if (::InterlockedIncrement(&once->semaphore) == 0) - { - init_func(); - once->inited = 1; - } - else - { - while (!once->inited) - Sleep(0); - } - - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_key_create(dng_pthread_key_t * key, void (*destructor) (void *)) -{ - if (destructor != NULL) - return -1; - - DWORD result = ::TlsAlloc(); - if (result == TLS_OUT_OF_INDEXES) - return -1; - *key = (unsigned long)result; - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_key_delete(dng_pthread_key_t key) -{ - if (::TlsFree((DWORD)key)) - return 0; - return -1; -} - -/*****************************************************************************/ - -int dng_pthread_setspecific(dng_pthread_key_t key, const void *value) -{ - if (::TlsSetValue((DWORD)key, const_cast(value))) - return 0; - return -1; -} - -/*****************************************************************************/ - -void *dng_pthread_getspecific(dng_pthread_key_t key) -{ - return ::TlsGetValue((DWORD)key); -} - -/*****************************************************************************/ - -namespace { - struct rw_waiter { - struct rw_waiter *prev; - struct rw_waiter *next; - HANDLE semaphore; - bool is_writer; - }; -} - -struct dng_pthread_rwlock_impl -{ - dng_pthread_mutex_impl mutex; - - rw_waiter *head_waiter; - rw_waiter *tail_waiter; - - unsigned long readers_active; - unsigned long writers_waiting; - bool writer_active; - - dng_pthread_cond_impl read_wait; - dng_pthread_cond_impl write_wait; - - dng_pthread_rwlock_impl () - : mutex () - , head_waiter (NULL) - , tail_waiter (NULL) - , readers_active (0) - , writers_waiting (0) - , read_wait () - , write_wait () - , writer_active (false) - { - } - - ~dng_pthread_rwlock_impl () - { - } - - void WakeHeadWaiter () - { - HANDLE semaphore = head_waiter->semaphore; - - head_waiter = head_waiter->next; - if (head_waiter == NULL) - tail_waiter = NULL; - - ::ReleaseSemaphore(semaphore, 1, NULL); - } - -}; - -/*****************************************************************************/ - -int dng_pthread_rwlock_init(dng_pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attrs) -{ - dng_pthread_rwlock_impl *newRWLock; - - newRWLock = new (std::nothrow) dng_pthread_rwlock_impl; - if (newRWLock == NULL) - return -1; // ENOMEM; - - *rwlock = newRWLock; - - return 0; -} - -/*****************************************************************************/ - -int dng_pthread_rwlock_destroy(dng_pthread_rwlock_t *rwlock) -{ - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - { - ScopedLock lock (real_rwlock.mutex); - - if (real_rwlock.head_waiter != NULL || - real_rwlock.readers_active != 0 || - real_rwlock.writers_waiting != 0 || - real_rwlock.writer_active) - return -1; // EBUSY - } - - delete *rwlock; - *rwlock = NULL; - return 0; -} - -/*****************************************************************************/ - -#define CHECK_RWLOCK_STATE(real_rwlock) \ - DNG_ASSERT (!real_rwlock.writer_active || real_rwlock.readers_active == 0, "dng_pthread_rwlock_t logic error") - -/*****************************************************************************/ - -int dng_pthread_rwlock_rdlock(dng_pthread_rwlock_t *rwlock) -{ - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - struct rw_waiter this_wait; - bool doWait = false;; - int result = 0; - HANDLE semaphore=NULL; - - { - - ScopedLock lock (real_rwlock.mutex); - - CHECK_RWLOCK_STATE (real_rwlock); - - if (real_rwlock.writers_waiting > 0 || real_rwlock.writer_active) - { - semaphore = GetThreadSemaphore(); - - this_wait.next = NULL; - this_wait.semaphore = semaphore; - this_wait.is_writer = false; - - // Add this waiter to the end of the list. - this_wait.prev = real_rwlock.tail_waiter; - if (real_rwlock.tail_waiter != NULL) - real_rwlock.tail_waiter->next = &this_wait; - real_rwlock.tail_waiter = &this_wait; - - // If the list was empty, set the head of the list to this waiter. - if (real_rwlock.head_waiter == NULL) - real_rwlock.head_waiter = &this_wait; - - doWait = true; - } - else - real_rwlock.readers_active++; - } - - if (result == 0 && doWait) - result = (WaitForSingleObject(semaphore, INFINITE) == WAIT_OBJECT_0) ? 0 : -1; - - return result; -} - -/*****************************************************************************/ - -int dng_pthread_rwlock_tryrdlock(dng_pthread_rwlock_t *rwlock) -{ - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - ScopedLock lock (real_rwlock.mutex); - - CHECK_RWLOCK_STATE (real_rwlock); - - if (real_rwlock.writers_waiting == 0 && !real_rwlock.writer_active) - { - real_rwlock.readers_active++; - return 0; - } - - return -1; -} - -/*****************************************************************************/ - -int dng_pthread_rwlock_trywrlock(dng_pthread_rwlock_t *rwlock) -{ - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - ScopedLock lock (real_rwlock.mutex); - - CHECK_RWLOCK_STATE (real_rwlock); - - if (real_rwlock.readers_active == 0 && - real_rwlock.writers_waiting == 0 && - !real_rwlock.writer_active) - { - real_rwlock.writer_active = true; - return 0; - } - - return -1; -} - -/*****************************************************************************/ - -int dng_pthread_rwlock_unlock(dng_pthread_rwlock_t *rwlock) - { - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - int result = 0; - - ScopedLock lock (real_rwlock.mutex); - - CHECK_RWLOCK_STATE (real_rwlock); - - if (real_rwlock.readers_active > 0) - --real_rwlock.readers_active; - else - real_rwlock.writer_active = false; - - while (real_rwlock.head_waiter != NULL) - { - if (real_rwlock.head_waiter->is_writer) - { - if (real_rwlock.readers_active == 0) - { - real_rwlock.writers_waiting--; - real_rwlock.writer_active = true; - real_rwlock.WakeHeadWaiter (); - } - - break; - } - else - { - ++real_rwlock.readers_active; - real_rwlock.WakeHeadWaiter (); - } - } - - return result; - } - -/*****************************************************************************/ - -int dng_pthread_rwlock_wrlock(dng_pthread_rwlock_t *rwlock) - { - dng_pthread_rwlock_impl &real_rwlock = **rwlock; - - int result = 0; - struct rw_waiter this_wait; - HANDLE semaphore=NULL; - bool doWait = false; - - { - ScopedLock lock (real_rwlock.mutex); - - CHECK_RWLOCK_STATE (real_rwlock); - - if (real_rwlock.readers_active || - real_rwlock.writers_waiting || - real_rwlock.writer_active) - { - semaphore = GetThreadSemaphore(); - - this_wait.next = NULL; - this_wait.semaphore = semaphore; - this_wait.is_writer = true; - - // Add this waiter to the end of the list. - this_wait.prev = real_rwlock.tail_waiter; - if (real_rwlock.tail_waiter != NULL) - real_rwlock.tail_waiter->next = &this_wait; - real_rwlock.tail_waiter = &this_wait; - - // If the list was empty, set the head of the list to this waiter. - if (real_rwlock.head_waiter == NULL) - real_rwlock.head_waiter = &this_wait; - - real_rwlock.writers_waiting++; - - doWait = true; - } - else - real_rwlock.writer_active = true; - } - - if (result == 0 && doWait) - result = (WaitForSingleObject(semaphore, INFINITE) == WAIT_OBJECT_0) ? 0 : -1; - - return result; - } - -/*****************************************************************************/ - -void dng_pthread_disassociate() -{ - FreeThreadSemaphore(); -} - -void dng_pthread_terminate() - { - finalize_thread_TLS(); - } - -/*****************************************************************************/ - -} // extern "C" - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -int dng_pthread_now (struct timespec *now) - { - - if (now == NULL) - return -1; // EINVAL - - #if qWinOS - - FILETIME ft; - ::GetSystemTimeAsFileTime(&ft); - - __int64 sys_time = ((__int64)ft.dwHighDateTime << 32) + ft.dwLowDateTime; - - #define SecsFrom1601To1970 11644473600 - - sys_time -= SecsFrom1601To1970 * 10000000LL; - - sys_time *= 100; // Convert from 100ns to 1ns units - - now->tv_sec = (long)(sys_time / 1000000000); - now->tv_nsec = (long)(sys_time % 1000000000); - - #else - - struct timeval tv; - - if (gettimeofday (&tv, NULL) != 0) - return errno; - - now->tv_sec = tv.tv_sec; - now->tv_nsec = tv.tv_usec * 1000; - - #endif - - return 0; - - } - -/*****************************************************************************/ - -#endif // qDNGThreadSafe - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_pthread.h b/third_party/dng_sdk/dng_pthread.h deleted file mode 100644 index 7ff34f7..0000000 --- a/third_party/dng_sdk/dng_pthread.h +++ /dev/null @@ -1,266 +0,0 @@ -/*****************************************************************************/ -// Copyright 2002-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pthread.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_pthread__ -#define __dng_pthread__ - -/*****************************************************************************/ - -#include "dng_flags.h" - -/*****************************************************************************/ - -#if qDNGThreadSafe - -/*****************************************************************************/ - -#if !qWinOS - -/*****************************************************************************/ - -/* Try generic POSIX compile */ - -#include -#include - -#define dng_pthread_disassociate() -#define dng_pthread_terminate() - -/*****************************************************************************/ - -#else - -/*****************************************************************************/ - -#include - -#if _MSC_VER >= 1600 - -// Get this included so ETIMEDOUT is predefined. -#include - -#endif - -#ifdef __cplusplus -extern "C" -{ -#endif - -/*****************************************************************************/ - -#define DNG_ETIMEDOUT 60 /* Operation timed out */ - -struct dng_timespec { - long tv_sec; - long tv_nsec; -}; - - -typedef unsigned long dng_pthread_t; - -typedef struct dng_pthread_mutex_impl *dng_pthread_mutex_t; -typedef struct dng_pthread_cond_impl *dng_pthread_cond_t; -typedef unsigned long dng_pthread_key_t; - - -#define DNG_PTHREAD_MUTEX_INITIALIZER ((struct dng_pthread_mutex_impl *)-1) -#define DNG_PTHREAD_COND_INITIALIZER ((struct dng_pthread_cond_impl *)-1) - -struct _dng_pthread_once_t { - int inited; - long semaphore; -}; - -typedef struct _dng_pthread_once_t dng_pthread_once_t; -#define DNG_PTHREAD_ONCE_INIT { 0, -1 } - -#define dng_pthread_equal(t1, t2) ((t1) == (t2)) - -typedef struct dng_pthread_attr_impl *dng_pthread_attr_t; - -int dng_pthread_attr_init(dng_pthread_attr_t *attr); -int dng_pthread_attr_destroy(dng_pthread_attr_t *attr); - -int dng_pthread_attr_setstacksize(dng_pthread_attr_t *attr, size_t stacksize); -int dng_pthread_attr_getstacksize(const dng_pthread_attr_t *attr, size_t *stacksize); - -int dng_pthread_create(dng_pthread_t *thread, const dng_pthread_attr_t * /* attrs */, void * (*func)(void *), void *arg); -int dng_pthread_detach(dng_pthread_t thread); -int dng_pthread_join(dng_pthread_t thread, void **result); -dng_pthread_t dng_pthread_self(); -void dng_pthread_exit(void *result); - -#define DNG_PTHREAD_MUTEX_RECURSIVE 0 -typedef unsigned long dng_pthread_mutexattr_t; - -int dng_pthread_mutexattr_init(dng_pthread_mutexattr_t *mutexattr); -int dng_pthread_mutexattr_settype(dng_pthread_mutexattr_t *mutexattr, int /*the options*/); - -int dng_pthread_mutex_init(dng_pthread_mutex_t *mutex, void * /* attrs */); -int dng_pthread_mutex_destroy(dng_pthread_mutex_t *mutex); -int dng_pthread_mutex_lock(dng_pthread_mutex_t *mutex); -int dng_pthread_mutex_unlock(dng_pthread_mutex_t *mutex); - -int dng_pthread_cond_init(dng_pthread_cond_t *cond, void * /* attrs */); -int dng_pthread_cond_destroy(dng_pthread_cond_t *cond); -int dng_pthread_cond_wait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex); -int dng_pthread_cond_timedwait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex, struct dng_timespec *latest_time); -int dng_pthread_cond_signal(dng_pthread_cond_t *cond); -int dng_pthread_cond_broadcast(dng_pthread_cond_t *cond); - -int dng_pthread_once(dng_pthread_once_t *once, void (*init_func)()); - -int dng_pthread_key_create(dng_pthread_key_t * key, void (*destructor) (void *)); -int dng_pthread_key_delete(dng_pthread_key_t key); -int dng_pthread_setspecific(dng_pthread_key_t key, const void *value); -void *dng_pthread_getspecific(dng_pthread_key_t key); - -typedef struct dng_pthread_rwlock_impl *dng_pthread_rwlock_t; -typedef void *pthread_rwlockattr_t; - -int dng_pthread_rwlock_destroy(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_init(dng_pthread_rwlock_t * rwlock, const pthread_rwlockattr_t * attrs); -int dng_pthread_rwlock_rdlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_tryrdlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_trywrlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_unlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_wrlock(dng_pthread_rwlock_t * rwlock); - -typedef struct dng_pthread_rwlock_impl *dng_pthread_rwlock_t; -typedef void *pthread_rwlockattr_t; - -int dng_pthread_rwlock_destroy(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_init(dng_pthread_rwlock_t * rwlock, const pthread_rwlockattr_t * attrs); -int dng_pthread_rwlock_rdlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_tryrdlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_trywrlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_unlock(dng_pthread_rwlock_t * rwlock); -int dng_pthread_rwlock_wrlock(dng_pthread_rwlock_t * rwlock); - -// dng_pthread may maintain per-thread global state. This routine frees that global state. -// there is no need to call this for threads created by dng_pthread and one can call -// dng_pthread routines of a thread after dng_pthread_disassociate as the global state will -// be recreated as necessary. However dng_pthread_disassociate will need to be called again -// and there is a slight performance cost. Do not call this routine while holding a mutex, etc. -void dng_pthread_disassociate(); - -void dng_pthread_terminate(); - -/*****************************************************************************/ - -// Map symbols back to plain pthread names. This whole mechanism is so the DNG pthreads library -// symbols do not collide with another pthread emulation library -// that may be in use in the same linked entity. However if that is the case, it would be far better -// to have the DNG code use the same pthread library as the rest of the code. - -#define pthread_t dng_pthread_t -#define pthread_mutex_t dng_pthread_mutex_t -#define pthread_cond_t dng_pthread_cond_t -#define pthread_once_t dng_pthread_once_t -#define pthread_key_t dng_pthread_key_t - -#undef PTHREAD_MUTEX_INITIALIZER -#define PTHREAD_MUTEX_INITIALIZER DNG_PTHREAD_MUTEX_INITIALIZER -#undef PTHREAD_COND_INITIALIZER -#define PTHREAD_COND_INITIALIZER DNG_PTHREAD_COND_INITIALIZER - -#undef PTHREAD_ONCE_INIT -#define PTHREAD_ONCE_INIT DNG_PTHREAD_ONCE_INIT - -#define timespec dng_timespec - -/* If it is defined on Windows, it probably has the wrong value... */ -#if defined(WIN32) || !defined(ETIMEDOUT) -#undef ETIMEDOUT -#define ETIMEDOUT DNG_ETIMEDOUT -#endif - -#define pthread_equal dng_pthread_equal - -#define pthread_attr_t dng_pthread_attr_t - -#define pthread_attr_init dng_pthread_attr_init -#define pthread_attr_destroy dng_pthread_attr_destroy - -#define pthread_attr_setstacksize dng_pthread_attr_setstacksize -#define pthread_attr_getstacksize dng_pthread_attr_getstacksize - -#define pthread_create dng_pthread_create -#define pthread_detach dng_pthread_detach -#define pthread_join dng_pthread_join -#define pthread_self dng_pthread_self -#define pthread_exit dng_pthread_exit - -#define pthread_mutex_init dng_pthread_mutex_init -#define pthread_mutex_destroy dng_pthread_mutex_destroy -#define pthread_mutex_lock dng_pthread_mutex_lock -#define pthread_mutex_unlock dng_pthread_mutex_unlock - -#define pthread_cond_init dng_pthread_cond_init -#define pthread_cond_destroy dng_pthread_cond_destroy -#define pthread_cond_wait dng_pthread_cond_wait -#define pthread_cond_timedwait dng_pthread_cond_timedwait -#define pthread_cond_signal dng_pthread_cond_signal -#define pthread_cond_broadcast dng_pthread_cond_broadcast - -#define pthread_once dng_pthread_once - -#define pthread_key_create dng_pthread_key_create -#define pthread_key_delete dng_pthread_key_delete -#define pthread_setspecific dng_pthread_setspecific -#define pthread_getspecific dng_pthread_getspecific - -#define pthread_rwlock_t dng_pthread_rwlock_t - -#define pthread_rwlock_destroy dng_pthread_rwlock_destroy -#define pthread_rwlock_init dng_pthread_rwlock_init -#define pthread_rwlock_rdlock dng_pthread_rwlock_rdlock -#define pthread_rwlock_tryrdlock dng_pthread_rwlock_tryrdlock -#define pthread_rwlock_trywrlock dng_pthread_rwlock_trywrlock -#define pthread_rwlock_unlock dng_pthread_rwlock_unlock -#define pthread_rwlock_wrlock dng_pthread_rwlock_wrlock - -/*****************************************************************************/ - -#ifdef __cplusplus -} -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -#ifdef __cplusplus -extern "C" -{ -#endif - -int dng_pthread_now (struct timespec *now); - -#ifdef __cplusplus -} -#endif - -/*****************************************************************************/ - -#endif // qDNGThreadSafe - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_rational.cpp b/third_party/dng_sdk/dng_rational.cpp deleted file mode 100644 index c366b46..0000000 --- a/third_party/dng_sdk/dng_rational.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_rational.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_rational.h" - -#include "dng_utils.h" - -/*****************************************************************************/ - -real64 dng_srational::As_real64 () const - { - - if (d) - return (real64) n / (real64) d; - - else - return 0.0; - - } - -/*****************************************************************************/ - -void dng_srational::Set_real64 (real64 x, int32 dd) - { - - if (x == 0.0) - { - - *this = dng_srational (0, 1); - - } - - if (dd == 0) - { - - real64 y = Abs_real64 (x); - - if (y >= 32768.0) - { - dd = 1; - } - - else if (y >= 1.0) - { - dd = 32768; - } - - else - { - dd = 32768 * 32768; - } - - } - - *this = dng_srational (Round_int32 (x * dd), dd); - - } - -/*****************************************************************************/ - -void dng_srational::ReduceByFactor (int32 factor) - { - - while (n % factor == 0 && - d % factor == 0 && - d >= factor) - { - n /= factor; - d /= factor; - } - - } - -/*****************************************************************************/ - -real64 dng_urational::As_real64 () const - { - - if (d) - return (real64) n / (real64) d; - - else - return 0.0; - - } - -/*****************************************************************************/ - -void dng_urational::Set_real64 (real64 x, uint32 dd) - { - - if (x <= 0.0) - { - - *this = dng_urational (0, 1); - - } - - if (dd == 0) - { - - if (x >= 32768.0) - { - dd = 1; - } - - else if (x >= 1.0) - { - dd = 32768; - } - - else - { - dd = 32768 * 32768; - } - - } - - *this = dng_urational (Round_uint32 (x * dd), dd); - - } - -/*****************************************************************************/ - -void dng_urational::ReduceByFactor (uint32 factor) - { - - while (n % factor == 0 && - d % factor == 0 && - d >= factor) - { - n /= factor; - d /= factor; - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_rational.h b/third_party/dng_sdk/dng_rational.h deleted file mode 100644 index 9080a63..0000000 --- a/third_party/dng_sdk/dng_rational.h +++ /dev/null @@ -1,149 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_rational.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Signed and unsigned rational data types. - */ - -/*****************************************************************************/ - -#ifndef __dng_rational__ -#define __dng_rational__ - -/*****************************************************************************/ - -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_srational - { - - public: - - int32 n; // Numerator - int32 d; // Denominator - - public: - - dng_srational () - : n (0) - , d (0) - { - } - - dng_srational (int32 nn, int32 dd) - : n (nn) - , d (dd) - { - } - - void Clear () - { - n = 0; - d = 0; - } - - bool IsValid () const - { - return d != 0; - } - - bool NotValid () const - { - return !IsValid (); - } - - bool operator== (const dng_srational &r) const - { - return (n == r.n) && - (d == r.d); - } - - bool operator!= (const dng_srational &r) const - { - return !(*this == r); - } - - real64 As_real64 () const; - - void Set_real64 (real64 x, int32 dd = 0); - - void ReduceByFactor (int32 factor); - - }; - -/*****************************************************************************/ - -class dng_urational - { - - public: - - uint32 n; // Numerator - uint32 d; // Denominator - - public: - - dng_urational () - : n (0) - , d (0) - { - } - - dng_urational (uint32 nn, uint32 dd) - : n (nn) - , d (dd) - { - } - - void Clear () - { - n = 0; - d = 0; - } - - bool IsValid () const - { - return d != 0; - } - - bool NotValid () const - { - return !IsValid (); - } - - bool operator== (const dng_urational &r) const - { - return (n == r.n) && - (d == r.d); - } - - bool operator!= (const dng_urational &r) const - { - return !(*this == r); - } - - real64 As_real64 () const; - - void Set_real64 (real64 x, uint32 dd = 0); - - void ReduceByFactor (uint32 factor); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_read_image.cpp b/third_party/dng_sdk/dng_read_image.cpp deleted file mode 100644 index 49df907..0000000 --- a/third_party/dng_sdk/dng_read_image.cpp +++ /dev/null @@ -1,3394 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_read_image.cpp#7 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_read_image.h" - -#include "dng_abort_sniffer.h" -#include "dng_area_task.h" -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_ifd.h" -#include "dng_jpeg_image.h" -#include "dng_lossless_jpeg.h" -#include "dng_mutex.h" -#include "dng_memory.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -#include "zlib.h" - -#if qDNGUseLibJPEG -#include "jpeglib.h" -#include "jerror.h" -#endif - -/******************************************************************************/ - -static void DecodeDelta8 (uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 1; col < cols; col++) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/******************************************************************************/ - -static void DecodeDelta16 (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 1; col < cols; col++) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/******************************************************************************/ - -static void DecodeDelta32 (uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 channels) - { - - const uint32 dRowStep = cols * channels; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 1; col < cols; col++) - { - - for (uint32 channel = 0; channel < channels; channel++) - { - - dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel]; - - } - - } - - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -inline void DecodeDeltaBytes (uint8 *bytePtr, int32 cols, int32 channels) - { - - if (channels == 1) - { - - uint8 b0 = bytePtr [0]; - - bytePtr += 1; - - for (int32 col = 1; col < cols; ++col) - { - - b0 += bytePtr [0]; - - bytePtr [0] = b0; - - bytePtr += 1; - - } - - } - - else if (channels == 3) - { - - uint8 b0 = bytePtr [0]; - uint8 b1 = bytePtr [1]; - uint8 b2 = bytePtr [2]; - - bytePtr += 3; - - for (int32 col = 1; col < cols; ++col) - { - - b0 += bytePtr [0]; - b1 += bytePtr [1]; - b2 += bytePtr [2]; - - bytePtr [0] = b0; - bytePtr [1] = b1; - bytePtr [2] = b2; - - bytePtr += 3; - - } - - } - - else if (channels == 4) - { - - uint8 b0 = bytePtr [0]; - uint8 b1 = bytePtr [1]; - uint8 b2 = bytePtr [2]; - uint8 b3 = bytePtr [3]; - - bytePtr += 4; - - for (int32 col = 1; col < cols; ++col) - { - - b0 += bytePtr [0]; - b1 += bytePtr [1]; - b2 += bytePtr [2]; - b3 += bytePtr [3]; - - bytePtr [0] = b0; - bytePtr [1] = b1; - bytePtr [2] = b2; - bytePtr [3] = b3; - - bytePtr += 4; - - } - - } - - else - { - - for (int32 col = 1; col < cols; ++col) - { - - for (int32 chan = 0; chan < channels; ++chan) - { - - bytePtr [chan + channels] += bytePtr [chan]; - - } - - bytePtr += channels; - - } - - } - - } - -/*****************************************************************************/ - -static void DecodeFPDelta (uint8 *input, - uint8 *output, - int32 cols, - int32 channels, - int32 bytesPerSample) - { - - DecodeDeltaBytes (input, cols * bytesPerSample, channels); - - int32 rowIncrement = cols * channels; - - if (bytesPerSample == 2) - { - - #if qDNGBigEndian - const uint8 *input0 = input; - const uint8 *input1 = input + rowIncrement; - #else - const uint8 *input1 = input; - const uint8 *input0 = input + rowIncrement; - #endif - - for (int32 col = 0; col < rowIncrement; ++col) - { - - output [0] = input0 [col]; - output [1] = input1 [col]; - - output += 2; - - } - - } - - else if (bytesPerSample == 3) - { - - const uint8 *input0 = input; - const uint8 *input1 = input + rowIncrement; - const uint8 *input2 = input + rowIncrement * 2; - - for (int32 col = 0; col < rowIncrement; ++col) - { - - output [0] = input0 [col]; - output [1] = input1 [col]; - output [2] = input2 [col]; - - output += 3; - - } - - } - - else - { - - #if qDNGBigEndian - const uint8 *input0 = input; - const uint8 *input1 = input + rowIncrement; - const uint8 *input2 = input + rowIncrement * 2; - const uint8 *input3 = input + rowIncrement * 3; - #else - const uint8 *input3 = input; - const uint8 *input2 = input + rowIncrement; - const uint8 *input1 = input + rowIncrement * 2; - const uint8 *input0 = input + rowIncrement * 3; - #endif - - for (int32 col = 0; col < rowIncrement; ++col) - { - - output [0] = input0 [col]; - output [1] = input1 [col]; - output [2] = input2 [col]; - output [3] = input3 [col]; - - output += 4; - - } - - } - - } - -/*****************************************************************************/ - -bool DecodePackBits (dng_stream &stream, - uint8 *dPtr, - int32 dstCount) - { - - while (dstCount > 0) - { - - int32 runCount = (int8) stream.Get_uint8 (); - - if (runCount >= 0) - { - - ++runCount; - - dstCount -= runCount; - - if (dstCount < 0) - return false; - - stream.Get (dPtr, runCount); - - dPtr += runCount; - - } - - else - { - - runCount = -runCount + 1; - - dstCount -= runCount; - - if (dstCount < 0) - return false; - - uint8 x = stream.Get_uint8 (); - - while (runCount--) - { - - *(dPtr++) = x; - - } - - } - - } - - return true; - - } - -/******************************************************************************/ - -class dng_lzw_expander - { - - private: - - enum - { - kResetCode = 256, - kEndCode = 257, - kTableSize = 4096 - }; - - struct LZWExpanderNode - { - int16 prefix; - int16 final; - int16 depth; - int16 fake_for_padding; - }; - - dng_memory_data fBuffer; - - LZWExpanderNode *fTable; - - const uint8 *fSrcPtr; - - int32 fSrcCount; - - int32 fByteOffset; - - uint32 fBitBuffer; - int32 fBitBufferCount; - - int32 fNextCode; - - int32 fCodeSize; - - public: - - dng_lzw_expander (); - - bool Expand (const uint8 *sPtr, - uint8 *dPtr, - int32 sCount, - int32 dCount); - - private: - - void InitTable (); - - void AddTable (int32 w, int32 k); - - bool GetCodeWord (int32 &code); - - // Hidden copy constructor and assignment operator. - - dng_lzw_expander (const dng_lzw_expander &expander); - - dng_lzw_expander & operator= (const dng_lzw_expander &expander); - - }; - -/******************************************************************************/ - -dng_lzw_expander::dng_lzw_expander () - - : fBuffer () - , fTable (NULL) - , fSrcPtr (NULL) - , fSrcCount (0) - , fByteOffset (0) - , fBitBuffer (0) - , fBitBufferCount (0) - , fNextCode (0) - , fCodeSize (0) - - { - - fBuffer.Allocate (kTableSize * sizeof (LZWExpanderNode)); - - fTable = (LZWExpanderNode *) fBuffer.Buffer (); - - } - -/******************************************************************************/ - -void dng_lzw_expander::InitTable () - { - - fCodeSize = 9; - - fNextCode = 258; - - LZWExpanderNode *node = &fTable [0]; - - for (int32 code = 0; code < 256; code++) - { - - node->prefix = -1; - node->final = (int16) code; - node->depth = 1; - - node++; - - } - - } - -/******************************************************************************/ - -void dng_lzw_expander::AddTable (int32 w, int32 k) - { - - DNG_ASSERT ((w >= 0) && (w <= kTableSize), - "bad w value in dng_lzw_expander::AddTable"); - - LZWExpanderNode *parentNode = &fTable [w]; - - int32 nextCode = fNextCode; - - fNextCode++; - - DNG_ASSERT ((nextCode >= 0) && (nextCode <= kTableSize), - "bad fNextCode value in dng_lzw_expander::AddTable"); - - LZWExpanderNode *node = &fTable [nextCode]; - - node->prefix = (int16) w; - node->final = (int16) k; - node->depth = 1 + parentNode->depth; - - if (nextCode + 1 == (1 << fCodeSize) - 1) - { - if (fCodeSize != 12) - fCodeSize++; - } - - } - -/******************************************************************************/ - -bool dng_lzw_expander::GetCodeWord (int32 &code) - { - - // The bit buffer has the current code in the most significant bits, - // so shift off the low orders. - - int32 codeSize = fCodeSize; - - code = fBitBuffer >> (32 - codeSize); - - if (fBitBufferCount >= codeSize) - { - - // Typical case; get the code from the bit buffer. - - fBitBuffer <<= codeSize; - fBitBufferCount -= codeSize; - - } - - else - { - - // The buffer needs to be refreshed. - - const int32 bitsSoFar = fBitBufferCount; - - if (fByteOffset >= fSrcCount) - return false; - - // Buffer a long word - - const uint8 *ptr = fSrcPtr + fByteOffset; - - #if qDNGBigEndian - - fBitBuffer = *((const uint32 *) ptr); - - #else - - { - - uint32 b0 = ptr [0]; - uint32 b1 = ptr [1]; - uint32 b2 = ptr [2]; - uint32 b3 = ptr [3]; - - fBitBuffer = (((((b0 << 8) | b1) << 8) | b2) << 8) | b3; - - } - - #endif - - fBitBufferCount = 32; - - fByteOffset += 4; - - // Number of additional bits we need - - const int32 bitsUsed = codeSize - bitsSoFar; - - // Number of low order bits in the current buffer we don't care about - - const int32 bitsNotUsed = 32 - bitsUsed; - - code |= fBitBuffer >> bitsNotUsed; - - fBitBuffer <<= bitsUsed; - fBitBufferCount -= bitsUsed; - - } - - return true; - - } - -/******************************************************************************/ - -bool dng_lzw_expander::Expand (const uint8 *sPtr, - uint8 *dPtr, - int32 sCount, - int32 dCount) - { - - void *dStartPtr = dPtr; - - fSrcPtr = sPtr; - - fSrcCount = sCount; - - fByteOffset = 0; - - /* the master decode loop */ - - while (true) - { - - InitTable (); - - int32 code; - - do - { - - if (!GetCodeWord (code)) - return false; - - DNG_ASSERT (code <= fNextCode, - "Unexpected LZW code in dng_lzw_expander::Expand"); - - } - while (code == kResetCode); - - if (code == kEndCode) - return true; - - if (code > kEndCode) - return false; - - int32 oldCode = code; - int32 inChar = code; - - *(dPtr++) = (uint8) code; - - if (--dCount == 0) - return true; - - while (true) - { - - if (!GetCodeWord (code)) - return false; - - if (code == kResetCode) - break; - - if (code == kEndCode) - return true; - - const int32 inCode = code; - - bool repeatLastPixel = false; - - if (code >= fNextCode) - { - - // This is either a bad file or our code table is not big enough; we - // are going to repeat the last code seen and attempt to muddle thru. - - code = oldCode; - - repeatLastPixel = true; - - } - - // this can only happen if we hit 2 bad codes in a row - - if (code > fNextCode) - return false; - - const int32 depth = fTable [code].depth; - - if (depth < dCount) - { - - dCount -= depth; - - dPtr += depth; - - uint8 *ptr = dPtr; - - // give the compiler an extra hint to optimize these as registers - - const LZWExpanderNode *localTable = fTable; - - int32 localCode = code; - - // this is usually the hottest loop in LZW expansion - - while (localCode >= kResetCode) - { - - if (ptr <= dStartPtr) - return false; // about to trash memory - - const LZWExpanderNode &node = localTable [localCode]; - - uint8 tempFinal = (uint8) node.final; - - localCode = node.prefix; - - // Check for bogus table entry - - if (localCode < 0 || localCode > kTableSize) - return false; - - *(--ptr) = tempFinal; - - } - - code = localCode; - - inChar = localCode; - - if (ptr <= dStartPtr) - return false; // about to trash memory - - *(--ptr) = (uint8) inChar; - - } - - else - { - - // There might not be enough room for the full code - // so skip the end of it. - - const int32 skip = depth - dCount; - - for (int32 i = 0; i < skip ; i++) - { - const LZWExpanderNode &node = fTable [code]; - code = node.prefix; - } - - int32 depthUsed = depth - skip; - - dCount -= depthUsed; - - dPtr += depthUsed; - - uint8 *ptr = dPtr; - - while (code >= 0) - { - - if (ptr <= dStartPtr) - return false; // about to trash memory - - const LZWExpanderNode &node = fTable [code]; - - *(--ptr) = (uint8) node.final; - - code = node.prefix; - - // Check for bogus table entry - - if (code > kTableSize) - return false; - - } - - return true; - - } - - if (repeatLastPixel) - { - - *(dPtr++) = (uint8) inChar; - - if (--dCount == 0) - return true; - - } - - if (fNextCode < kTableSize) - { - - AddTable (oldCode, code); - - } - - oldCode = inCode; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -dng_row_interleaved_image::dng_row_interleaved_image (dng_image &image, - uint32 factor) - - : dng_image (image.Bounds (), - image.Planes (), - image.PixelType ()) - - , fImage (image ) - , fFactor (factor) - - { - - } - -/*****************************************************************************/ - -int32 dng_row_interleaved_image::MapRow (int32 row) const - { - - uint32 rows = Height (); - - int32 top = Bounds ().t; - - uint32 fieldRow = row - top; - - for (uint32 field = 0; true; field++) - { - - uint32 fieldRows = (rows - field + fFactor - 1) / fFactor; - - if (fieldRow < fieldRows) - { - - return fieldRow * fFactor + field + top; - - } - - fieldRow -= fieldRows; - - } - - ThrowProgramError (); - - return 0; - - } - -/*****************************************************************************/ - -void dng_row_interleaved_image::DoGet (dng_pixel_buffer &buffer) const - { - - dng_pixel_buffer tempBuffer (buffer); - - for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++) - { - - tempBuffer.fArea.t = MapRow (row); - - tempBuffer.fArea.b = tempBuffer.fArea.t + 1; - - tempBuffer.fData = (void *) buffer.DirtyPixel (row, - buffer.fArea.l, - buffer.fPlane); - - fImage.Get (tempBuffer); - - } - - } - -/*****************************************************************************/ - -void dng_row_interleaved_image::DoPut (const dng_pixel_buffer &buffer) - { - - dng_pixel_buffer tempBuffer (buffer); - - for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++) - { - - tempBuffer.fArea.t = MapRow (row); - - tempBuffer.fArea.b = tempBuffer.fArea.t + 1; - - tempBuffer.fData = (void *) buffer.ConstPixel (row, - buffer.fArea.l, - buffer.fPlane); - - fImage.Put (tempBuffer); - - } - - } - -/*****************************************************************************/ - -static void ReorderSubTileBlocks (dng_host &host, - const dng_ifd &ifd, - dng_pixel_buffer &buffer, - AutoPtr &tempBuffer) - { - - uint32 tempBufferSize = buffer.fArea.W () * - buffer.fArea.H () * - buffer.fPlanes * - buffer.fPixelSize; - - if (!tempBuffer.Get () || tempBuffer->LogicalSize () < tempBufferSize) - { - - tempBuffer.Reset (host.Allocate (tempBufferSize)); - - } - - uint32 blockRows = ifd.fSubTileBlockRows; - uint32 blockCols = ifd.fSubTileBlockCols; - - uint32 rowBlocks = buffer.fArea.H () / blockRows; - uint32 colBlocks = buffer.fArea.W () / blockCols; - - int32 rowStep = buffer.fRowStep * buffer.fPixelSize; - int32 colStep = buffer.fColStep * buffer.fPixelSize; - - int32 rowBlockStep = rowStep * blockRows; - int32 colBlockStep = colStep * blockCols; - - uint32 blockColBytes = blockCols * buffer.fPlanes * buffer.fPixelSize; - - const uint8 *s0 = (const uint8 *) buffer.fData; - uint8 *d0 = tempBuffer->Buffer_uint8 (); - - for (uint32 rowBlock = 0; rowBlock < rowBlocks; rowBlock++) - { - - uint8 *d1 = d0; - - for (uint32 colBlock = 0; colBlock < colBlocks; colBlock++) - { - - uint8 *d2 = d1; - - for (uint32 blockRow = 0; blockRow < blockRows; blockRow++) - { - - for (uint32 j = 0; j < blockColBytes; j++) - { - - d2 [j] = s0 [j]; - - } - - s0 += blockColBytes; - - d2 += rowStep; - - } - - d1 += colBlockStep; - - } - - d0 += rowBlockStep; - - } - - // Copy back reordered pixels. - - DoCopyBytes (tempBuffer->Buffer (), - buffer.fData, - tempBufferSize); - - } - -/*****************************************************************************/ - -class dng_image_spooler: public dng_spooler - { - - private: - - dng_host &fHost; - - const dng_ifd &fIFD; - - dng_image &fImage; - - dng_rect fTileArea; - - uint32 fPlane; - uint32 fPlanes; - - dng_memory_block &fBlock; - - AutoPtr &fSubTileBuffer; - - dng_rect fTileStrip; - - uint8 *fBuffer; - - uint32 fBufferCount; - uint32 fBufferSize; - - public: - - dng_image_spooler (dng_host &host, - const dng_ifd &ifd, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - dng_memory_block &block, - AutoPtr &subTileBuffer); - - virtual ~dng_image_spooler (); - - virtual void Spool (const void *data, - uint32 count); - - private: - - // Hidden copy constructor and assignment operator. - - dng_image_spooler (const dng_image_spooler &spooler); - - dng_image_spooler & operator= (const dng_image_spooler &spooler); - - }; - -/*****************************************************************************/ - -dng_image_spooler::dng_image_spooler (dng_host &host, - const dng_ifd &ifd, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - dng_memory_block &block, - AutoPtr &subTileBuffer) - - : fHost (host) - , fIFD (ifd) - , fImage (image) - , fTileArea (tileArea) - , fPlane (plane) - , fPlanes (planes) - , fBlock (block) - , fSubTileBuffer (subTileBuffer) - - , fTileStrip () - , fBuffer (NULL) - , fBufferCount (0) - , fBufferSize (0) - - { - - uint32 bytesPerRow = fTileArea.W () * fPlanes * (uint32) sizeof (uint16); - - uint32 stripLength = Pin_uint32 (ifd.fSubTileBlockRows, - fBlock.LogicalSize () / bytesPerRow, - fTileArea.H ()); - - stripLength = stripLength / ifd.fSubTileBlockRows - * ifd.fSubTileBlockRows; - - fTileStrip = fTileArea; - fTileStrip.b = fTileArea.t + stripLength; - - fBuffer = (uint8 *) fBlock.Buffer (); - - fBufferCount = 0; - fBufferSize = bytesPerRow * stripLength; - - } - -/*****************************************************************************/ - -dng_image_spooler::~dng_image_spooler () - { - - } - -/*****************************************************************************/ - -void dng_image_spooler::Spool (const void *data, - uint32 count) - { - - while (count) - { - - uint32 block = Min_uint32 (count, fBufferSize - fBufferCount); - - if (block == 0) - { - return; - } - - DoCopyBytes (data, - fBuffer + fBufferCount, - block); - - data = ((const uint8 *) data) + block; - - count -= block; - - fBufferCount += block; - - if (fBufferCount == fBufferSize) - { - - fHost.SniffForAbort (); - - dng_pixel_buffer buffer; - - buffer.fArea = fTileStrip; - - buffer.fPlane = fPlane; - buffer.fPlanes = fPlanes; - - buffer.fRowStep = fPlanes * fTileStrip.W (); - buffer.fColStep = fPlanes; - buffer.fPlaneStep = 1; - - buffer.fData = fBuffer; - - buffer.fPixelType = ttShort; - buffer.fPixelSize = 2; - - if (fIFD.fSubTileBlockRows > 1) - { - - ReorderSubTileBlocks (fHost, - fIFD, - buffer, - fSubTileBuffer); - - } - - fImage.Put (buffer); - - uint32 stripLength = fTileStrip.H (); - - fTileStrip.t = fTileStrip.b; - - fTileStrip.b = Min_int32 (fTileStrip.t + stripLength, - fTileArea.b); - - fBufferCount = 0; - - fBufferSize = fTileStrip.W () * - fTileStrip.H () * - fPlanes * (uint32) sizeof (uint16); - - } - - } - - } - -/*****************************************************************************/ - -dng_read_image::dng_read_image () - - : fJPEGTables () - - { - - } - -/*****************************************************************************/ - -dng_read_image::~dng_read_image () - { - - } - -/*****************************************************************************/ - -bool dng_read_image::ReadUncompressed (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer) - { - - uint32 rows = tileArea.H (); - uint32 samplesPerRow = tileArea.W (); - - if (ifd.fPlanarConfiguration == pcRowInterleaved) - { - rows *= planes; - } - else - { - samplesPerRow *= planes; - } - - uint32 samplesPerTile = samplesPerRow * rows; - - dng_pixel_buffer buffer; - - buffer.fArea = tileArea; - - buffer.fPlane = plane; - buffer.fPlanes = planes; - - buffer.fRowStep = planes * tileArea.W (); - - if (ifd.fPlanarConfiguration == pcRowInterleaved) - { - buffer.fColStep = 1; - buffer.fPlaneStep = tileArea.W (); - } - - else - { - buffer.fColStep = planes; - buffer.fPlaneStep = 1; - } - - if (uncompressedBuffer.Get () == NULL) - { - - #if qDNGValidate - - ReportError ("Fuzz: Missing uncompressed buffer"); - - #endif - - ThrowBadFormat (); - - } - - buffer.fData = uncompressedBuffer->Buffer (); - - uint32 bitDepth = ifd.fBitsPerSample [plane]; - - if (bitDepth == 8) - { - - buffer.fPixelType = ttByte; - buffer.fPixelSize = 1; - - stream.Get (buffer.fData, samplesPerTile); - - } - - else if (bitDepth == 16 && ifd.fSampleFormat [0] == sfFloatingPoint) - { - - buffer.fPixelType = ttFloat; - buffer.fPixelSize = 4; - - uint32 *p_uint32 = (uint32 *) buffer.fData; - - for (uint32 j = 0; j < samplesPerTile; j++) - { - - p_uint32 [j] = DNG_HalfToFloat (stream.Get_uint16 ()); - - } - - } - - else if (bitDepth == 24 && ifd.fSampleFormat [0] == sfFloatingPoint) - { - - buffer.fPixelType = ttFloat; - buffer.fPixelSize = 4; - - uint32 *p_uint32 = (uint32 *) buffer.fData; - - for (uint32 j = 0; j < samplesPerTile; j++) - { - - uint8 input [3]; - - if (stream.LittleEndian ()) - { - input [2] = stream.Get_uint8 (); - input [1] = stream.Get_uint8 (); - input [0] = stream.Get_uint8 (); - } - - else - { - input [0] = stream.Get_uint8 (); - input [1] = stream.Get_uint8 (); - input [2] = stream.Get_uint8 (); - } - - p_uint32 [j] = DNG_FP24ToFloat (input); - - } - - } - - else if (bitDepth == 16) - { - - buffer.fPixelType = ttShort; - buffer.fPixelSize = 2; - - stream.Get (buffer.fData, samplesPerTile * 2); - - if (stream.SwapBytes ()) - { - - DoSwapBytes16 ((uint16 *) buffer.fData, - samplesPerTile); - - } - - } - - else if (bitDepth == 32) - { - - buffer.fPixelType = image.PixelType (); - buffer.fPixelSize = 4; - - stream.Get (buffer.fData, samplesPerTile * 4); - - if (stream.SwapBytes ()) - { - - DoSwapBytes32 ((uint32 *) buffer.fData, - samplesPerTile); - - } - - } - - else if (bitDepth == 12) - { - - buffer.fPixelType = ttShort; - buffer.fPixelSize = 2; - - uint16 *p = (uint16 *) buffer.fData; - - uint32 evenSamples = samplesPerRow >> 1; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 j = 0; j < evenSamples; j++) - { - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - - p [0] = (uint16) ((b0 << 4) | (b1 >> 4)); - p [1] = (uint16) (((b1 << 8) | b2) & 0x0FFF); - - p += 2; - - } - - if (samplesPerRow & 1) - { - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - - p [0] = (uint16) ((b0 << 4) | (b1 >> 4)); - - p += 1; - - } - - } - - } - - else if (bitDepth > 8 && bitDepth < 16) - { - - buffer.fPixelType = ttShort; - buffer.fPixelSize = 2; - - uint16 *p = (uint16 *) buffer.fData; - - uint32 bitMask = (1 << bitDepth) - 1; - - for (uint32 row = 0; row < rows; row++) - { - - uint32 bitBuffer = 0; - uint32 bufferBits = 0; - - for (uint32 j = 0; j < samplesPerRow; j++) - { - - while (bufferBits < bitDepth) - { - - bitBuffer = (bitBuffer << 8) | stream.Get_uint8 (); - - bufferBits += 8; - - } - - p [j] = (uint16) ((bitBuffer >> (bufferBits - bitDepth)) & bitMask); - - bufferBits -= bitDepth; - - } - - p += samplesPerRow; - - } - - } - - else if (bitDepth > 16 && bitDepth < 32) - { - - buffer.fPixelType = ttLong; - buffer.fPixelSize = 4; - - uint32 *p = (uint32 *) buffer.fData; - - uint32 bitMask = (1 << bitDepth) - 1; - - for (uint32 row = 0; row < rows; row++) - { - - uint64 bitBuffer = 0; - uint32 bufferBits = 0; - - for (uint32 j = 0; j < samplesPerRow; j++) - { - - while (bufferBits < bitDepth) - { - - bitBuffer = (bitBuffer << 8) | stream.Get_uint8 (); - - bufferBits += 8; - - } - - p [j] = ((uint32) (bitBuffer >> (bufferBits - bitDepth))) & bitMask; - - bufferBits -= bitDepth; - - } - - p += samplesPerRow; - - } - - } - - else - { - - return false; - - } - - if (ifd.fSampleBitShift) - { - - buffer.ShiftRight (ifd.fSampleBitShift); - - } - - if (ifd.fSubTileBlockRows > 1) - { - - ReorderSubTileBlocks (host, - ifd, - buffer, - subTileBlockBuffer); - - } - - image.Put (buffer); - - return true; - - } - -/*****************************************************************************/ - -#if qDNGUseLibJPEG - -/*****************************************************************************/ - -static void dng_error_exit (j_common_ptr cinfo) - { - - // Output message. - - (*cinfo->err->output_message) (cinfo); - - // Convert to a dng_exception. - - switch (cinfo->err->msg_code) - { - - case JERR_OUT_OF_MEMORY: - { - ThrowMemoryFull (); - break; - } - - default: - { - ThrowBadFormat (); - } - - } - - } - -/*****************************************************************************/ - -static void dng_output_message (j_common_ptr cinfo) - { - - // Format message to string. - - char buffer [JMSG_LENGTH_MAX]; - - (*cinfo->err->format_message) (cinfo, buffer); - - // Report the libjpeg message as a warning. - - ReportWarning ("libjpeg", buffer); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -void dng_read_image::DecodeLossyJPEG (dng_host &host, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 /* photometricInterpretation */, - uint32 jpegDataSize, - uint8 *jpegDataInMemory) - { - - #if qDNGUseLibJPEG - - struct jpeg_decompress_struct cinfo; - - // Setup the error manager. - - struct jpeg_error_mgr jerr; - - cinfo.err = jpeg_std_error (&jerr); - - jerr.error_exit = dng_error_exit; - jerr.output_message = dng_output_message; - - try - { - - // Create the decompression context. - - jpeg_create_decompress (&cinfo); - - // Setup the data source. - - jpeg_mem_src (&cinfo, - jpegDataInMemory, - jpegDataSize); - - // Read the JPEG header. - - jpeg_read_header (&cinfo, TRUE); - - // Check header. - - if ((uint32) cinfo.image_width != tileArea.W () || - (uint32) cinfo.image_height != tileArea.H () || - (uint32) cinfo.num_components != planes ) - { - ThrowBadFormat (); - } - - // Start the compression. - - jpeg_start_decompress (&cinfo); - - // Setup a one-scanline size buffer. - - dng_pixel_buffer buffer; - - buffer.fArea = tileArea; - buffer.fArea.b = tileArea.t + 1; - buffer.fPlane = plane; - buffer.fPlanes = planes; - - buffer.fColStep = planes; - buffer.fRowStep = tileArea.W () * planes; - buffer.fPlaneStep = 1; - - buffer.fPixelType = ttByte; - buffer.fPixelSize = 1; - - buffer.fDirty = true; - - AutoPtr bufferData (host.Allocate (buffer.fRowStep)); - - buffer.fData = bufferData->Buffer (); - - uint8 *sampArray [1]; - - sampArray [0] = bufferData->Buffer_uint8 (); - - // Read each scanline and save to image. - - while (buffer.fArea.t < tileArea.b) - { - - jpeg_read_scanlines (&cinfo, sampArray, 1); - - image.Put (buffer); - - buffer.fArea.t = buffer.fArea.b; - buffer.fArea.b = buffer.fArea.t + 1; - - } - - // Cleanup. - - jpeg_finish_decompress (&cinfo); - - jpeg_destroy_decompress (&cinfo); - - } - - catch (...) - { - - jpeg_destroy_decompress (&cinfo); - - throw; - - } - - #else - - // The dng_sdk does not include a lossy JPEG decoder. Override this - // this method to add lossy JPEG support. - - (void) host; - (void) image; - (void) tileArea; - (void) plane; - (void) planes; - (void) jpegDataSize; - (void) jpegDataInMemory; - - ThrowProgramError ("Missing lossy JPEG decoder"); - - #endif - - } - -/*****************************************************************************/ - -static dng_memory_block * ReadJPEGDataToBlock (dng_host &host, - dng_stream &stream, - dng_memory_block *tablesBlock, - uint64 tileOffset, - uint32 tileByteCount, - bool patchFirstByte) - { - - if (tileByteCount <= 2) - { - ThrowEndOfFile (); - } - - uint32 tablesByteCount = tablesBlock ? tablesBlock->LogicalSize () : 0; - - if (tablesByteCount && tablesByteCount < 4) - { - ThrowEndOfFile (); - } - - // The JPEG tables start with a two byte SOI marker, and - // and end with a two byte EOI marker. The JPEG tile - // data also starts with a two byte SOI marker. We can - // convert this combination a normal JPEG stream removing - // the last two bytes of the JPEG tables and the first two - // bytes of the tile data, and then concatenating them. - - if (tablesByteCount) - { - - tablesByteCount -= 2; - - tileOffset += 2; - tileByteCount -= 2; - - } - - // Allocate buffer. - - AutoPtr buffer (host.Allocate (tablesByteCount + tileByteCount)); - - // Read in table. - - if (tablesByteCount) - { - - DoCopyBytes (tablesBlock->Buffer (), - buffer->Buffer (), - tablesByteCount); - - } - - // Read in tile data. - - stream.SetReadPosition (tileOffset); - - stream.Get (buffer->Buffer_uint8 () + tablesByteCount, tileByteCount); - - // Patch first byte, if required. - - if (patchFirstByte) - { - - buffer->Buffer_uint8 () [0] = 0xFF; - - } - - // Return buffer. - - return buffer.Release (); - - } - -/*****************************************************************************/ - -bool dng_read_image::ReadBaselineJPEG (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - uint8 *jpegDataInMemory) - { - - // Setup the data source. - - if (fJPEGTables.Get () || !jpegDataInMemory) - { - - AutoPtr jpegDataBlock; - - jpegDataBlock.Reset (ReadJPEGDataToBlock (host, - stream, - fJPEGTables.Get (), - stream.Position (), - tileByteCount, - ifd.fPatchFirstJPEGByte)); - - DecodeLossyJPEG (host, - image, - tileArea, - plane, - planes, - ifd.fPhotometricInterpretation, - jpegDataBlock->LogicalSize (), - jpegDataBlock->Buffer_uint8 ()); - - } - - else - { - - if (ifd.fPatchFirstJPEGByte && tileByteCount) - { - jpegDataInMemory [0] = 0xFF; - } - - DecodeLossyJPEG (host, - image, - tileArea, - plane, - planes, - ifd.fPhotometricInterpretation, - tileByteCount, - jpegDataInMemory); - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_read_image::ReadLosslessJPEG (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer) - { - - uint32 bytesPerRow = tileArea.W () * planes * (uint32) sizeof (uint16); - - uint32 rowsPerStrip = Pin_uint32 (ifd.fSubTileBlockRows, - kImageBufferSize / bytesPerRow, - tileArea.H ()); - - rowsPerStrip = rowsPerStrip / ifd.fSubTileBlockRows - * ifd.fSubTileBlockRows; - - uint32 bufferSize = bytesPerRow * rowsPerStrip; - - if (uncompressedBuffer.Get () && - uncompressedBuffer->LogicalSize () < bufferSize) - { - - uncompressedBuffer.Reset (); - - } - - if (uncompressedBuffer.Get () == NULL) - { - - uncompressedBuffer.Reset (host.Allocate (bufferSize)); - - } - - dng_image_spooler spooler (host, - ifd, - image, - tileArea, - plane, - planes, - *uncompressedBuffer.Get (), - subTileBlockBuffer); - - uint32 decodedSize = tileArea.W () * - tileArea.H () * - planes * (uint32) sizeof (uint16); - - bool bug16 = ifd.fLosslessJPEGBug16; - - uint64 tileOffset = stream.Position (); - - DecodeLosslessJPEG (stream, - spooler, - decodedSize, - decodedSize, - bug16); - - if (stream.Position () > tileOffset + tileByteCount) - { - ThrowBadFormat (); - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_read_image::CanReadTile (const dng_ifd &ifd) - { - - if (ifd.fSampleFormat [0] != sfUnsignedInteger && - ifd.fSampleFormat [0] != sfFloatingPoint) - { - return false; - } - - switch (ifd.fCompression) - { - - case ccUncompressed: - { - - if (ifd.fSampleFormat [0] == sfFloatingPoint) - { - - return (ifd.fBitsPerSample [0] == 16 || - ifd.fBitsPerSample [0] == 24 || - ifd.fBitsPerSample [0] == 32); - - } - - return ifd.fBitsPerSample [0] >= 8 && - ifd.fBitsPerSample [0] <= 32; - - } - - case ccJPEG: - { - - if (ifd.fSampleFormat [0] != sfUnsignedInteger) - { - return false; - } - - if (ifd.IsBaselineJPEG ()) - { - - // Baseline JPEG. - - return true; - - } - - else - { - - // Lossless JPEG. - - return ifd.fBitsPerSample [0] >= 8 && - ifd.fBitsPerSample [0] <= 16; - - } - - break; - - } - - case ccLZW: - case ccDeflate: - case ccOldDeflate: - case ccPackBits: - { - - if (ifd.fSampleFormat [0] == sfFloatingPoint) - { - - if (ifd.fCompression == ccPackBits) - { - return false; - } - - if (ifd.fPredictor != cpNullPredictor && - ifd.fPredictor != cpFloatingPoint && - ifd.fPredictor != cpFloatingPointX2 && - ifd.fPredictor != cpFloatingPointX4) - { - return false; - } - - if (ifd.fBitsPerSample [0] != 16 && - ifd.fBitsPerSample [0] != 24 && - ifd.fBitsPerSample [0] != 32) - { - return false; - } - - } - - else - { - - if (ifd.fPredictor != cpNullPredictor && - ifd.fPredictor != cpHorizontalDifference && - ifd.fPredictor != cpHorizontalDifferenceX2 && - ifd.fPredictor != cpHorizontalDifferenceX4) - { - return false; - } - - if (ifd.fBitsPerSample [0] != 8 && - ifd.fBitsPerSample [0] != 16 && - ifd.fBitsPerSample [0] != 32) - { - return false; - } - - } - - return true; - - } - - default: - { - break; - } - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_read_image::NeedsCompressedBuffer (const dng_ifd &ifd) - { - - if (ifd.fCompression == ccLZW || - ifd.fCompression == ccDeflate || - ifd.fCompression == ccOldDeflate || - ifd.fCompression == ccPackBits) - { - return true; - } - - return false; - - } - -/*****************************************************************************/ - -void dng_read_image::ByteSwapBuffer (dng_host & /* host */, - dng_pixel_buffer &buffer) - { - - uint32 pixels = buffer.fRowStep * buffer.fArea.H (); - - switch (buffer.fPixelSize) - { - - case 2: - { - - DoSwapBytes16 ((uint16 *) buffer.fData, - pixels); - - break; - - } - - case 4: - { - - DoSwapBytes32 ((uint32 *) buffer.fData, - pixels); - - break; - - } - - default: - break; - - } - - } - -/*****************************************************************************/ - -void dng_read_image::DecodePredictor (dng_host & /* host */, - const dng_ifd &ifd, - dng_pixel_buffer &buffer) - { - - switch (ifd.fPredictor) - { - - case cpNullPredictor: - { - - return; - - } - - case cpHorizontalDifference: - case cpHorizontalDifferenceX2: - case cpHorizontalDifferenceX4: - { - - int32 xFactor = 1; - - if (ifd.fPredictor == cpHorizontalDifferenceX2) - { - xFactor = 2; - } - - else if (ifd.fPredictor == cpHorizontalDifferenceX4) - { - xFactor = 4; - } - - switch (buffer.fPixelType) - { - - case ttByte: - { - - DecodeDelta8 ((uint8 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - case ttShort: - { - - DecodeDelta16 ((uint16 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - case ttLong: - { - - DecodeDelta32 ((uint32 *) buffer.fData, - buffer.fArea.H (), - buffer.fArea.W () / xFactor, - buffer.fPlanes * xFactor); - - return; - - } - - default: - break; - - } - - break; - - } - - default: - break; - - } - - ThrowBadFormat (); - - } - -/*****************************************************************************/ - -void dng_read_image::ReadTile (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - AutoPtr &compressedBuffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer) - { - - switch (ifd.fCompression) - { - - case ccLZW: - case ccDeflate: - case ccOldDeflate: - case ccPackBits: - { - - // Figure out uncompressed size. - - uint32 bytesPerSample = (ifd.fBitsPerSample [0] >> 3); - - uint32 sampleCount = planes * tileArea.W () * tileArea.H (); - - uint32 uncompressedSize = sampleCount * bytesPerSample; - - // Setup pixel buffer to hold uncompressed data. - - dng_pixel_buffer buffer; - - if (ifd.fSampleFormat [0] == sfFloatingPoint) - { - buffer.fPixelType = ttFloat; - } - - else if (ifd.fBitsPerSample [0] == 8) - { - buffer.fPixelType = ttByte; - } - - else if (ifd.fBitsPerSample [0] == 16) - { - buffer.fPixelType = ttShort; - } - - else if (ifd.fBitsPerSample [0] == 32) - { - buffer.fPixelType = ttLong; - } - - else - { - ThrowBadFormat (); - } - - buffer.fPixelSize = bytesPerSample; - - buffer.fArea = tileArea; - - buffer.fPlane = plane; - buffer.fPlanes = planes; - - buffer.fPlaneStep = 1; - - buffer.fColStep = planes; - buffer.fRowStep = planes * tileArea.W (); - - uint32 bufferSize = uncompressedSize; - - // If we are using the floating point predictor, we need an extra - // buffer row. - - if (ifd.fPredictor == cpFloatingPoint || - ifd.fPredictor == cpFloatingPointX2 || - ifd.fPredictor == cpFloatingPointX4) - { - bufferSize += buffer.fRowStep * buffer.fPixelSize; - } - - // If are processing less than full size floating point data, - // we need space to expand the data to full floating point size. - - if (buffer.fPixelType == ttFloat) - { - bufferSize = Max_uint32 (bufferSize, sampleCount * 4); - } - - // Sometimes with multi-threading and planar image using strips, - // we can process a small tile before a large tile on a thread. - // Simple fix is to just reallocate the buffer if it is too small. - - if (uncompressedBuffer.Get () && - uncompressedBuffer->LogicalSize () < bufferSize) - { - - uncompressedBuffer.Reset (); - - } - - if (uncompressedBuffer.Get () == NULL) - { - - uncompressedBuffer.Reset (host.Allocate (bufferSize)); - - } - - buffer.fData = uncompressedBuffer->Buffer (); - - // If using floating point predictor, move buffer pointer to second row. - - if (ifd.fPredictor == cpFloatingPoint || - ifd.fPredictor == cpFloatingPointX2 || - ifd.fPredictor == cpFloatingPointX4) - { - - buffer.fData = (uint8 *) buffer.fData + - buffer.fRowStep * buffer.fPixelSize; - - } - - // Decompress the data. - - if (ifd.fCompression == ccLZW) - { - - dng_lzw_expander expander; - - if (!expander.Expand (compressedBuffer->Buffer_uint8 (), - (uint8 *) buffer.fData, - tileByteCount, - uncompressedSize)) - { - ThrowBadFormat (); - } - - } - - else if (ifd.fCompression == ccPackBits) - { - - dng_stream subStream (compressedBuffer->Buffer_uint8 (), - tileByteCount); - - if (!DecodePackBits (subStream, - (uint8 *) buffer.fData, - uncompressedSize)) - { - ThrowBadFormat (); - } - - } - - else - { - - uLongf dstLen = uncompressedSize; - - int err = uncompress ((Bytef *) buffer.fData, - &dstLen, - (const Bytef *) compressedBuffer->Buffer (), - tileByteCount); - - if (err != Z_OK) - { - - if (err == Z_MEM_ERROR) - { - ThrowMemoryFull (); - } - - else if (err == Z_DATA_ERROR) - { - // Most other TIFF readers do not fail for this error - // so we should not either, even if it means showing - // a corrupted image to the user. Watson #2530216 - // - tknoll 12/20/11 - } - - else - { - ThrowBadFormat (); - } - - } - - if (dstLen != uncompressedSize) - { - ThrowBadFormat (); - } - - } - - // The floating point predictor is byte order independent. - - if (ifd.fPredictor == cpFloatingPoint || - ifd.fPredictor == cpFloatingPointX2 || - ifd.fPredictor == cpFloatingPointX4) - { - - int32 xFactor = 1; - - if (ifd.fPredictor == cpFloatingPointX2) - { - xFactor = 2; - } - - else if (ifd.fPredictor == cpFloatingPointX4) - { - xFactor = 4; - } - - for (int32 row = tileArea.t; row < tileArea.b; row++) - { - - uint8 *srcPtr = (uint8 *) buffer.DirtyPixel (row , tileArea.l, plane); - uint8 *dstPtr = (uint8 *) buffer.DirtyPixel (row - 1, tileArea.l, plane); - - DecodeFPDelta (srcPtr, - dstPtr, - tileArea.W () / xFactor, - planes * xFactor, - bytesPerSample); - - } - - buffer.fData = (uint8 *) buffer.fData - - buffer.fRowStep * buffer.fPixelSize; - - } - - else - { - - // Both these compression algorithms are byte based. - - if (stream.SwapBytes ()) - { - - ByteSwapBuffer (host, - buffer); - - } - - // Undo the predictor. - - DecodePredictor (host, - ifd, - buffer); - - } - - // Expand floating point data, if needed. - - if (buffer.fPixelType == ttFloat && buffer.fPixelSize == 2) - { - - uint16 *srcPtr = (uint16 *) buffer.fData; - uint32 *dstPtr = (uint32 *) buffer.fData; - - for (int32 index = sampleCount - 1; index >= 0; index--) - { - - dstPtr [index] = DNG_HalfToFloat (srcPtr [index]); - - } - - buffer.fPixelSize = 4; - - } - - else if (buffer.fPixelType == ttFloat && buffer.fPixelSize == 3) - { - - uint8 *srcPtr = ((uint8 *) buffer.fData) + (sampleCount - 1) * 3; - uint32 *dstPtr = ((uint32 *) buffer.fData) + (sampleCount - 1); - - if (stream.BigEndian () || ifd.fPredictor == cpFloatingPoint || - ifd.fPredictor == cpFloatingPointX2 || - ifd.fPredictor == cpFloatingPointX4) - { - - for (uint32 index = 0; index < sampleCount; index++) - { - - *(dstPtr--) = DNG_FP24ToFloat (srcPtr); - - srcPtr -= 3; - - } - - } - - else - { - - for (uint32 index = 0; index < sampleCount; index++) - { - - uint8 input [3]; - - input [2] = srcPtr [0]; - input [1] = srcPtr [1]; - input [0] = srcPtr [2]; - - *(dstPtr--) = DNG_FP24ToFloat (input); - - srcPtr -= 3; - - } - - } - - buffer.fPixelSize = 4; - - } - - // Save the data. - - image.Put (buffer); - - return; - - } - - case ccUncompressed: - { - - if (ReadUncompressed (host, - ifd, - stream, - image, - tileArea, - plane, - planes, - uncompressedBuffer, - subTileBlockBuffer)) - { - - return; - - } - - break; - - } - - case ccJPEG: - { - - if (ifd.IsBaselineJPEG ()) - { - - // Baseline JPEG. - - if (ReadBaselineJPEG (host, - ifd, - stream, - image, - tileArea, - plane, - planes, - tileByteCount, - compressedBuffer.Get () ? compressedBuffer->Buffer_uint8 () : NULL)) - { - - return; - - } - - } - - else - { - - // Otherwise is should be lossless JPEG. - - if (ReadLosslessJPEG (host, - ifd, - stream, - image, - tileArea, - plane, - planes, - tileByteCount, - uncompressedBuffer, - subTileBlockBuffer)) - { - - return; - - } - - } - - break; - - } - - case ccLossyJPEG: - { - - if (ReadBaselineJPEG (host, - ifd, - stream, - image, - tileArea, - plane, - planes, - tileByteCount, - compressedBuffer.Get () ? compressedBuffer->Buffer_uint8 () : NULL)) - { - - return; - - } - - break; - - } - - default: - break; - - } - - ThrowBadFormat (); - - } - -/*****************************************************************************/ - -bool dng_read_image::CanRead (const dng_ifd &ifd) - { - - if (ifd.fImageWidth < 1 || - ifd.fImageLength < 1) - { - return false; - } - - if (ifd.fSamplesPerPixel < 1) - { - return false; - } - - if (ifd.fBitsPerSample [0] < 1) - { - return false; - } - - for (uint32 j = 1; j < Min_uint32 (ifd.fSamplesPerPixel, - kMaxSamplesPerPixel); j++) - { - - if (ifd.fBitsPerSample [j] != - ifd.fBitsPerSample [0]) - { - return false; - } - - if (ifd.fSampleFormat [j] != - ifd.fSampleFormat [0]) - { - return false; - } - - } - - if ((ifd.fPlanarConfiguration != pcInterleaved ) && - (ifd.fPlanarConfiguration != pcPlanar ) && - (ifd.fPlanarConfiguration != pcRowInterleaved)) - { - return false; - } - - if (ifd.fUsesStrips == ifd.fUsesTiles) - { - return false; - } - - uint32 tileCount = ifd.TilesPerImage (); - - if (tileCount < 1) - { - return false; - } - - bool needTileByteCounts = (ifd.TileByteCount (ifd.TileArea (0, 0)) == 0); - - if (tileCount == 1) - { - - if (needTileByteCounts) - { - - if (ifd.fTileByteCount [0] < 1) - { - return false; - } - - } - - } - - else - { - - if (ifd.fTileOffsetsCount != tileCount) - { - return false; - } - - if (needTileByteCounts) - { - - if (ifd.fTileByteCountsCount != tileCount) - { - return false; - } - - } - - } - - if (!CanReadTile (ifd)) - { - return false; - } - - return true; - - } - -/*****************************************************************************/ - -class dng_read_tiles_task : public dng_area_task - { - - private: - - dng_read_image &fReadImage; - - dng_host &fHost; - - const dng_ifd &fIFD; - - dng_stream &fStream; - - dng_image &fImage; - - dng_jpeg_image *fJPEGImage; - - dng_fingerprint *fJPEGTileDigest; - - uint32 fOuterSamples; - - uint32 fInnerSamples; - - uint32 fTilesDown; - - uint32 fTilesAcross; - - uint64 *fTileOffset; - - uint32 *fTileByteCount; - - uint32 fCompressedSize; - - uint32 fUncompressedSize; - - dng_mutex fMutex; - - uint32 fNextTileIndex; - - public: - - dng_read_tiles_task (dng_read_image &readImage, - dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - dng_jpeg_image *jpegImage, - dng_fingerprint *jpegTileDigest, - uint32 outerSamples, - uint32 innerSamples, - uint32 tilesDown, - uint32 tilesAcross, - uint64 *tileOffset, - uint32 *tileByteCount, - uint32 compressedSize, - uint32 uncompressedSize) - - : fReadImage (readImage) - , fHost (host) - , fIFD (ifd) - , fStream (stream) - , fImage (image) - , fJPEGImage (jpegImage) - , fJPEGTileDigest (jpegTileDigest) - , fOuterSamples (outerSamples) - , fInnerSamples (innerSamples) - , fTilesDown (tilesDown) - , fTilesAcross (tilesAcross) - , fTileOffset (tileOffset) - , fTileByteCount (tileByteCount) - , fCompressedSize (compressedSize) - , fUncompressedSize (uncompressedSize) - , fMutex ("dng_read_tiles_task") - , fNextTileIndex (0) - - { - - fMinTaskArea = 16 * 16; - fUnitCell = dng_point (16, 16); - fMaxTileSize = dng_point (16, 16); - - } - - void Process (uint32 /* threadIndex */, - const dng_rect & /* tile */, - dng_abort_sniffer *sniffer) - { - - AutoPtr compressedBuffer; - AutoPtr uncompressedBuffer; - AutoPtr subTileBlockBuffer; - - if (!fJPEGImage) - { - compressedBuffer.Reset (fHost.Allocate (fCompressedSize)); - } - - if (fUncompressedSize) - { - uncompressedBuffer.Reset (fHost.Allocate (fUncompressedSize)); - } - - while (true) - { - - uint32 tileIndex; - uint32 byteCount; - - { - - dng_lock_mutex lock (&fMutex); - - if (fNextTileIndex == fOuterSamples * fTilesDown * fTilesAcross) - { - return; - } - - tileIndex = fNextTileIndex++; - - TempStreamSniffer noSniffer (fStream, NULL); - - fStream.SetReadPosition (fTileOffset [tileIndex]); - - byteCount = fTileByteCount [tileIndex]; - - if (fJPEGImage) - { - - fJPEGImage->fJPEGData [tileIndex] . Reset (fHost.Allocate (byteCount)); - - } - - fStream.Get (fJPEGImage ? fJPEGImage->fJPEGData [tileIndex]->Buffer () - : compressedBuffer->Buffer (), - byteCount); - - } - - dng_abort_sniffer::SniffForAbort (sniffer); - - if (fJPEGTileDigest) - { - - dng_md5_printer printer; - - printer.Process (compressedBuffer->Buffer (), - byteCount); - - fJPEGTileDigest [tileIndex] = printer.Result (); - - } - - dng_stream tileStream (fJPEGImage ? fJPEGImage->fJPEGData [tileIndex]->Buffer () - : compressedBuffer->Buffer (), - byteCount); - - tileStream.SetLittleEndian (fStream.LittleEndian ()); - - uint32 plane = tileIndex / (fTilesDown * fTilesAcross); - - uint32 rowIndex = (tileIndex - plane * fTilesDown * fTilesAcross) / fTilesAcross; - - uint32 colIndex = tileIndex - (plane * fTilesDown + rowIndex) * fTilesAcross; - - dng_rect tileArea = fIFD.TileArea (rowIndex, colIndex); - - dng_host host (&fHost.Allocator (), - sniffer); // Cannot use sniffer attached to main host - - fReadImage.ReadTile (host, - fIFD, - tileStream, - fImage, - tileArea, - plane, - fInnerSamples, - byteCount, - fJPEGImage ? fJPEGImage->fJPEGData [tileIndex] - : compressedBuffer, - uncompressedBuffer, - subTileBlockBuffer); - - } - - } - - private: - - // Hidden copy constructor and assignment operator. - - dng_read_tiles_task (const dng_read_tiles_task &); - - dng_read_tiles_task & operator= (const dng_read_tiles_task &); - - }; - -/*****************************************************************************/ - -void dng_read_image::Read (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - dng_jpeg_image *jpegImage, - dng_fingerprint *jpegDigest) - { - - uint32 tileIndex; - - // Deal with row interleaved images. - - if (ifd.fRowInterleaveFactor > 1 && - ifd.fRowInterleaveFactor < ifd.fImageLength) - { - - dng_ifd tempIFD (ifd); - - tempIFD.fRowInterleaveFactor = 1; - - dng_row_interleaved_image tempImage (image, - ifd.fRowInterleaveFactor); - - Read (host, - tempIFD, - stream, - tempImage, - jpegImage, - jpegDigest); - - return; - - } - - // Figure out inner and outer samples. - - uint32 innerSamples = 1; - uint32 outerSamples = 1; - - if (ifd.fPlanarConfiguration == pcPlanar) - { - outerSamples = ifd.fSamplesPerPixel; - } - else - { - innerSamples = ifd.fSamplesPerPixel; - } - - // Calculate number of tiles to read. - - uint32 tilesAcross = ifd.TilesAcross (); - uint32 tilesDown = ifd.TilesDown (); - - uint32 tileCount = tilesAcross * tilesDown * outerSamples; - - // Find the tile offsets. - - dng_memory_data tileOffsetData (tileCount * (uint32) sizeof (uint64)); - - uint64 *tileOffset = tileOffsetData.Buffer_uint64 (); - - if (tileCount <= dng_ifd::kMaxTileInfo) - { - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - tileOffset [tileIndex] = ifd.fTileOffset [tileIndex]; - - } - - } - - else - { - - stream.SetReadPosition (ifd.fTileOffsetsOffset); - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - tileOffset [tileIndex] = stream.TagValue_uint32 (ifd.fTileOffsetsType); - - } - - } - - // Quick validity check on tile offsets. - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - #if qDNGValidate - - if (tileOffset [tileIndex] < 8) - { - - ReportWarning ("Tile/Strip offset less than 8"); - - } - - #endif - - if (tileOffset [tileIndex] >= stream.Length ()) - { - - ThrowBadFormat (); - - } - - } - - // Buffer to hold the tile byte counts, if needed. - - dng_memory_data tileByteCountData; - - uint32 *tileByteCount = NULL; - - // If we can compute the number of bytes needed to store the - // data, we can split the read for each tile into sub-tiles. - - uint32 uncompressedSize = 0; - - uint32 subTileLength = ifd.fTileLength; - - if (ifd.TileByteCount (ifd.TileArea (0, 0)) != 0) - { - - uint32 bytesPerPixel = TagTypeSize (ifd.PixelType ()); - - uint32 bytesPerRow = ifd.fTileWidth * innerSamples * bytesPerPixel; - - subTileLength = Pin_uint32 (ifd.fSubTileBlockRows, - kImageBufferSize / bytesPerRow, - ifd.fTileLength); - - subTileLength = subTileLength / ifd.fSubTileBlockRows - * ifd.fSubTileBlockRows; - - uncompressedSize = subTileLength * bytesPerRow; - - } - - // Else we need to know the byte counts. - - else - { - - tileByteCountData.Allocate (tileCount * (uint32) sizeof (uint32)); - - tileByteCount = tileByteCountData.Buffer_uint32 (); - - if (tileCount <= dng_ifd::kMaxTileInfo) - { - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - tileByteCount [tileIndex] = ifd.fTileByteCount [tileIndex]; - - } - - } - - else - { - - stream.SetReadPosition (ifd.fTileByteCountsOffset); - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - tileByteCount [tileIndex] = stream.TagValue_uint32 (ifd.fTileByteCountsType); - - } - - } - - // Quick validity check on tile byte counts. - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - if (tileByteCount [tileIndex] < 1 || - tileByteCount [tileIndex] > stream.Length ()) - { - - ThrowBadFormat (); - - } - - } - - } - - // Find maximum tile size, if possible. - - uint32 maxTileByteCount = 0; - - if (tileByteCount) - { - - for (tileIndex = 0; tileIndex < tileCount; tileIndex++) - { - - maxTileByteCount = Max_uint32 (maxTileByteCount, - tileByteCount [tileIndex]); - - } - - } - - // Do we need a compressed data buffer? - - uint32 compressedSize = 0; - - bool needsCompressedBuffer = NeedsCompressedBuffer (ifd); - - if (needsCompressedBuffer) - { - - if (!tileByteCount) - { - ThrowBadFormat (); - } - - compressedSize = maxTileByteCount; - - } - - // Are we keeping the compressed JPEG image data? - - if (jpegImage) - { - - if (ifd.IsBaselineJPEG ()) - { - - jpegImage->fImageSize.h = ifd.fImageWidth; - jpegImage->fImageSize.v = ifd.fImageLength; - - jpegImage->fTileSize.h = ifd.fTileWidth; - jpegImage->fTileSize.v = ifd.fTileLength; - - jpegImage->fUsesStrips = ifd.fUsesStrips; - - jpegImage->fJPEGData.Reset (new dng_jpeg_image_tile_ptr [tileCount]); - - } - - else - { - - jpegImage = NULL; - - } - - } - - // Do we need to read the JPEG tables? - - if (ifd.fJPEGTablesOffset && ifd.fJPEGTablesCount) - { - - if (ifd.IsBaselineJPEG ()) - { - - fJPEGTables.Reset (host.Allocate (ifd.fJPEGTablesCount)); - - stream.SetReadPosition (ifd.fJPEGTablesOffset); - - stream.Get (fJPEGTables->Buffer (), - fJPEGTables->LogicalSize ()); - - } - - } - - AutoArray jpegTileDigest; - - if (jpegDigest) - { - - jpegTileDigest.Reset (new dng_fingerprint [tileCount + (fJPEGTables.Get () ? 1 : 0)]); - - } - - // Don't read planes we are not actually saving. - - outerSamples = Min_uint32 (image.Planes (), outerSamples); - - // See if we can do this read using multiple threads. - - bool useMultipleThreads = (outerSamples * tilesDown * tilesAcross >= 2) && - (host.PerformAreaTaskThreads () > 1) && - (maxTileByteCount > 0 && maxTileByteCount <= 1024 * 1024) && - (subTileLength == ifd.fTileLength) && - (ifd.fCompression != ccUncompressed); - -#if qImagecore - useMultipleThreads = false; -#endif - - if (useMultipleThreads) - { - - uint32 threadCount = Min_uint32 (outerSamples * tilesDown * tilesAcross, - host.PerformAreaTaskThreads ()); - - dng_read_tiles_task task (*this, - host, - ifd, - stream, - image, - jpegImage, - jpegTileDigest.Get (), - outerSamples, - innerSamples, - tilesDown, - tilesAcross, - tileOffset, - tileByteCount, - maxTileByteCount, - uncompressedSize); - - host.PerformAreaTask (task, - dng_rect (0, 0, 16, 16 * threadCount)); - - } - - // Else use a single thread to read all the tiles. - - else - { - - AutoPtr compressedBuffer; - AutoPtr uncompressedBuffer; - AutoPtr subTileBlockBuffer; - - if (uncompressedSize) - { - uncompressedBuffer.Reset (host.Allocate (uncompressedSize)); - } - - if (compressedSize && !jpegImage) - { - compressedBuffer.Reset (host.Allocate (compressedSize)); - } - - else if (jpegDigest) - { - compressedBuffer.Reset (host.Allocate (maxTileByteCount)); - } - - tileIndex = 0; - - for (uint32 plane = 0; plane < outerSamples; plane++) - { - - for (uint32 rowIndex = 0; rowIndex < tilesDown; rowIndex++) - { - - for (uint32 colIndex = 0; colIndex < tilesAcross; colIndex++) - { - - stream.SetReadPosition (tileOffset [tileIndex]); - - dng_rect tileArea = ifd.TileArea (rowIndex, colIndex); - - uint32 subTileCount = (tileArea.H () + subTileLength - 1) / - subTileLength; - - for (uint32 subIndex = 0; subIndex < subTileCount; subIndex++) - { - - host.SniffForAbort (); - - dng_rect subArea (tileArea); - - subArea.t = tileArea.t + subIndex * subTileLength; - - subArea.b = Min_int32 (subArea.t + subTileLength, - tileArea.b); - - uint32 subByteCount; - - if (tileByteCount) - { - subByteCount = tileByteCount [tileIndex]; - } - else - { - subByteCount = ifd.TileByteCount (subArea); - } - - if (jpegImage) - { - - jpegImage->fJPEGData [tileIndex].Reset (host.Allocate (subByteCount)); - - stream.Get (jpegImage->fJPEGData [tileIndex]->Buffer (), subByteCount); - - stream.SetReadPosition (tileOffset [tileIndex]); - - } - - else if ((needsCompressedBuffer || jpegDigest) && subByteCount) - { - - stream.Get (compressedBuffer->Buffer (), subByteCount); - - if (jpegDigest) - { - - dng_md5_printer printer; - - printer.Process (compressedBuffer->Buffer (), - subByteCount); - - jpegTileDigest [tileIndex] = printer.Result (); - - } - - } - - ReadTile (host, - ifd, - stream, - image, - subArea, - plane, - innerSamples, - subByteCount, - jpegImage ? jpegImage->fJPEGData [tileIndex] : compressedBuffer, - uncompressedBuffer, - subTileBlockBuffer); - - } - - tileIndex++; - - } - - } - - } - - } - - // Finish up JPEG digest computation, if needed. - - if (jpegDigest) - { - - if (fJPEGTables.Get ()) - { - - dng_md5_printer printer; - - printer.Process (fJPEGTables->Buffer (), - fJPEGTables->LogicalSize ()); - - jpegTileDigest [tileCount] = printer.Result (); - - } - - dng_md5_printer printer2; - - for (uint32 j = 0; j < tileCount + (fJPEGTables.Get () ? 1 : 0); j++) - { - - printer2.Process (jpegTileDigest [j].data, - dng_fingerprint::kDNGFingerprintSize); - - } - - *jpegDigest = printer2.Result (); - - } - - // Keep the JPEG table in the jpeg image, if any. - - if (jpegImage) - { - - jpegImage->fJPEGTables.Reset (fJPEGTables.Release ()); - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_read_image.h b/third_party/dng_sdk/dng_read_image.h deleted file mode 100644 index bd79e55..0000000 --- a/third_party/dng_sdk/dng_read_image.h +++ /dev/null @@ -1,182 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_read_image.h#2 $ */ -/* $DateTime: 2012/06/05 11:05:39 $ */ -/* $Change: 833352 $ */ -/* $Author: tknoll $ */ - -/** \file - * Support for DNG image reading. - */ - -/*****************************************************************************/ - -#ifndef __dng_read_image__ -#define __dng_read_image__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_image.h" -#include "dng_memory.h" -#include "dng_types.h" - -/******************************************************************************/ - -bool DecodePackBits (dng_stream &stream, - uint8 *dPtr, - int32 dstCount); - -/*****************************************************************************/ - -class dng_row_interleaved_image: public dng_image - { - - private: - - dng_image &fImage; - - uint32 fFactor; - - public: - - dng_row_interleaved_image (dng_image &image, - uint32 factor); - - virtual void DoGet (dng_pixel_buffer &buffer) const; - - virtual void DoPut (const dng_pixel_buffer &buffer); - - private: - - int32 MapRow (int32 row) const; - - }; - -/*****************************************************************************/ - -/// \brief -/// -/// - -class dng_read_image - { - - friend class dng_read_tiles_task; - - protected: - - enum - { - - // Target size for buffer used to copy data to the image. - - kImageBufferSize = 128 * 1024 - - }; - - AutoPtr fJPEGTables; - - public: - - dng_read_image (); - - virtual ~dng_read_image (); - - /// - /// \param - - virtual bool CanRead (const dng_ifd &ifd); - - /// - /// \param host Host used for memory allocation, progress updating, and abort testing. - /// \param ifd - /// \param stream Stream to read image data from. - /// \param image Result image to populate. - - virtual void Read (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - dng_jpeg_image *jpegImage, - dng_fingerprint *jpegDigest); - - protected: - - virtual bool ReadUncompressed (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer); - - virtual void DecodeLossyJPEG (dng_host &host, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 photometricInterpretation, - uint32 jpegDataSize, - uint8 *jpegDataInMemory); - - virtual bool ReadBaselineJPEG (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - uint8 *jpegDataInMemory); - - virtual bool ReadLosslessJPEG (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer); - - virtual bool CanReadTile (const dng_ifd &ifd); - - virtual bool NeedsCompressedBuffer (const dng_ifd &ifd); - - virtual void ByteSwapBuffer (dng_host &host, - dng_pixel_buffer &buffer); - - virtual void DecodePredictor (dng_host &host, - const dng_ifd &ifd, - dng_pixel_buffer &buffer); - - virtual void ReadTile (dng_host &host, - const dng_ifd &ifd, - dng_stream &stream, - dng_image &image, - const dng_rect &tileArea, - uint32 plane, - uint32 planes, - uint32 tileByteCount, - AutoPtr &compressedBuffer, - AutoPtr &uncompressedBuffer, - AutoPtr &subTileBlockBuffer); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_rect.cpp b/third_party/dng_sdk/dng_rect.cpp deleted file mode 100644 index c45e03f..0000000 --- a/third_party/dng_sdk/dng_rect.cpp +++ /dev/null @@ -1,168 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_rect.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_rect.h" - -#include "dng_utils.h" - -/*****************************************************************************/ - -bool dng_rect::operator== (const dng_rect &rect) const - { - - return (rect.t == t) && - (rect.l == l) && - (rect.b == b) && - (rect.r == r); - - } - -/*****************************************************************************/ - -bool dng_rect::IsZero () const - { - - return (t == 0) && (l == 0) && (b == 0) && (r == 0); - - } - -/*****************************************************************************/ - -bool dng_rect_real64::operator== (const dng_rect_real64 &rect) const - { - - return (rect.t == t) && - (rect.l == l) && - (rect.b == b) && - (rect.r == r); - - } - -/*****************************************************************************/ - -bool dng_rect_real64::IsZero () const - { - - return (t == 0.0) && (l == 0.0) && (b == 0.0) && (r == 0.0); - - } - -/*****************************************************************************/ - -dng_rect operator& (const dng_rect &a, - const dng_rect &b) - { - - dng_rect c; - - c.t = Max_int32 (a.t, b.t); - c.l = Max_int32 (a.l, b.l); - - c.b = Min_int32 (a.b, b.b); - c.r = Min_int32 (a.r, b.r); - - if (c.IsEmpty ()) - { - - c = dng_rect (); - - } - - return c; - - } - -/*****************************************************************************/ - -dng_rect operator| (const dng_rect &a, - const dng_rect &b) - { - - if (a.IsEmpty ()) - { - return b; - } - - if (b.IsEmpty ()) - { - return a; - } - - dng_rect c; - - c.t = Min_int32 (a.t, b.t); - c.l = Min_int32 (a.l, b.l); - - c.b = Max_int32 (a.b, b.b); - c.r = Max_int32 (a.r, b.r); - - return c; - - } - -/*****************************************************************************/ - -dng_rect_real64 operator& (const dng_rect_real64 &a, - const dng_rect_real64 &b) - { - - dng_rect_real64 c; - - c.t = Max_real64 (a.t, b.t); - c.l = Max_real64 (a.l, b.l); - - c.b = Min_real64 (a.b, b.b); - c.r = Min_real64 (a.r, b.r); - - if (c.IsEmpty ()) - { - - c = dng_rect_real64 (); - - } - - return c; - - } - -/*****************************************************************************/ - -dng_rect_real64 operator| (const dng_rect_real64 &a, - const dng_rect_real64 &b) - { - - if (a.IsEmpty ()) - { - return b; - } - - if (b.IsEmpty ()) - { - return a; - } - - dng_rect_real64 c; - - c.t = Min_real64 (a.t, b.t); - c.l = Min_real64 (a.l, b.l); - - c.b = Max_real64 (a.b, b.b); - c.r = Max_real64 (a.r, b.r); - - return c; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_rect.h b/third_party/dng_sdk/dng_rect.h deleted file mode 100644 index 16c4b29..0000000 --- a/third_party/dng_sdk/dng_rect.h +++ /dev/null @@ -1,494 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_rect.h#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_rect__ -#define __dng_rect__ - -/*****************************************************************************/ - -#include "dng_types.h" -#include "dng_point.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -class dng_rect - { - - public: - - int32 t; - int32 l; - int32 b; - int32 r; - - public: - - dng_rect () - : t (0) - , l (0) - , b (0) - , r (0) - { - } - - dng_rect (int32 tt, int32 ll, int32 bb, int32 rr) - : t (tt) - , l (ll) - , b (bb) - , r (rr) - { - } - - dng_rect (uint32 h, uint32 w) - : t (0) - , l (0) - , b ((int32) h) - , r ((int32) w) - { - } - - dng_rect (const dng_point &size) - : t (0) - , l (0) - , b (size.v) - , r (size.h) - { - } - - void Clear () - { - *this = dng_rect (); - } - - bool operator== (const dng_rect &rect) const; - - bool operator!= (const dng_rect &rect) const - { - return !(*this == rect); - } - - bool IsZero () const; - - bool NotZero () const - { - return !IsZero (); - } - - bool IsEmpty () const - { - return (t >= b) || (l >= r); - } - - bool NotEmpty () const - { - return !IsEmpty (); - } - - uint32 W () const - { - return (r >= l ? (uint32) (r - l) : 0); - } - - uint32 H () const - { - return (b >= t ? (uint32) (b - t) : 0); - } - - dng_point TL () const - { - return dng_point (t, l); - } - - dng_point TR () const - { - return dng_point (t, r); - } - - dng_point BL () const - { - return dng_point (b, l); - } - - dng_point BR () const - { - return dng_point (b, r); - } - - dng_point Size () const - { - return dng_point ((int32) H (), (int32) W ()); - } - - real64 Diagonal () const - { - return hypot ((real64) W (), - (real64) H ()); - } - - }; - -/*****************************************************************************/ - -class dng_rect_real64 - { - - public: - - real64 t; - real64 l; - real64 b; - real64 r; - - public: - - dng_rect_real64 () - : t (0.0) - , l (0.0) - , b (0.0) - , r (0.0) - { - } - - dng_rect_real64 (real64 tt, real64 ll, real64 bb, real64 rr) - : t (tt) - , l (ll) - , b (bb) - , r (rr) - { - } - - dng_rect_real64 (real64 h, real64 w) - : t (0) - , l (0) - , b (h) - , r (w) - { - } - - dng_rect_real64 (const dng_point_real64 &size) - : t (0) - , l (0) - , b (size.v) - , r (size.h) - { - } - - dng_rect_real64 (const dng_point_real64 &pt1, - const dng_point_real64 &pt2) - : t (Min_real64 (pt1.v, pt2.v)) - , l (Min_real64 (pt1.h, pt2.h)) - , b (Max_real64 (pt1.v, pt2.v)) - , r (Max_real64 (pt1.h, pt2.h)) - { - } - - dng_rect_real64 (const dng_rect &rect) - : t ((real64) rect.t) - , l ((real64) rect.l) - , b ((real64) rect.b) - , r ((real64) rect.r) - { - } - - void Clear () - { - *this = dng_point_real64 (); - } - - bool operator== (const dng_rect_real64 &rect) const; - - bool operator!= (const dng_rect_real64 &rect) const - { - return !(*this == rect); - } - - bool IsZero () const; - - bool NotZero () const - { - return !IsZero (); - } - - bool IsEmpty () const - { - return (t >= b) || (l >= r); - } - - bool NotEmpty () const - { - return !IsEmpty (); - } - - real64 W () const - { - return Max_real64 (r - l, 0.0); - } - - real64 H () const - { - return Max_real64 (b - t, 0.0); - } - - dng_point_real64 TL () const - { - return dng_point_real64 (t, l); - } - - dng_point_real64 TR () const - { - return dng_point_real64 (t, r); - } - - dng_point_real64 BL () const - { - return dng_point_real64 (b, l); - } - - dng_point_real64 BR () const - { - return dng_point_real64 (b, r); - } - - dng_point_real64 Size () const - { - return dng_point_real64 (H (), W ()); - } - - dng_rect Round () const - { - return dng_rect (Round_int32 (t), - Round_int32 (l), - Round_int32 (b), - Round_int32 (r)); - } - - real64 Diagonal () const - { - return hypot (W (), H ()); - } - - }; - -/*****************************************************************************/ - -dng_rect operator& (const dng_rect &a, - const dng_rect &b); - -dng_rect operator| (const dng_rect &a, - const dng_rect &b); - -/*****************************************************************************/ - -dng_rect_real64 operator& (const dng_rect_real64 &a, - const dng_rect_real64 &b); - -dng_rect_real64 operator| (const dng_rect_real64 &a, - const dng_rect_real64 &b); - -/*****************************************************************************/ - -inline dng_rect operator+ (const dng_rect &a, - const dng_point &b) - { - - return dng_rect (a.t + b.v, - a.l + b.h, - a.b + b.v, - a.r + b.h); - - } - -/*****************************************************************************/ - -inline dng_rect_real64 operator+ (const dng_rect_real64 &a, - const dng_point_real64 &b) - { - - return dng_rect_real64 (a.t + b.v, - a.l + b.h, - a.b + b.v, - a.r + b.h); - - } - -/*****************************************************************************/ - -inline dng_rect operator- (const dng_rect &a, - const dng_point &b) - { - - return dng_rect (a.t - b.v, - a.l - b.h, - a.b - b.v, - a.r - b.h); - - } - -/*****************************************************************************/ - -inline dng_rect_real64 operator- (const dng_rect_real64 &a, - const dng_point_real64 &b) - { - - return dng_rect_real64 (a.t - b.v, - a.l - b.h, - a.b - b.v, - a.r - b.h); - - } - -/*****************************************************************************/ - -inline dng_rect Transpose (const dng_rect &a) - { - - return dng_rect (a.l, a.t, a.r, a.b); - - } - -/*****************************************************************************/ - -inline dng_rect_real64 Transpose (const dng_rect_real64 &a) - { - - return dng_rect_real64 (a.l, a.t, a.r, a.b); - - } - -/*****************************************************************************/ - -inline void HalfRect (dng_rect &rect) - { - - rect.r = rect.l + (int32) (rect.W () >> 1); - rect.b = rect.t + (int32) (rect.H () >> 1); - - } - -/*****************************************************************************/ - -inline void DoubleRect (dng_rect &rect) - { - - rect.r = rect.l + (int32) (rect.W () << 1); - rect.b = rect.t + (int32) (rect.H () << 1); - - } - -/*****************************************************************************/ - -inline void InnerPadRect (dng_rect &rect, - int32 pad) - { - - rect.l += pad; - rect.r -= pad; - rect.t += pad; - rect.b -= pad; - - } - -/*****************************************************************************/ - -inline void OuterPadRect (dng_rect &rect, - int32 pad) - { - - InnerPadRect (rect, -pad); - - } - -/*****************************************************************************/ - -inline void InnerPadRectH (dng_rect &rect, - int32 pad) - { - - rect.l += pad; - rect.r -= pad; - - } - -/*****************************************************************************/ - -inline void InnerPadRectV (dng_rect &rect, - int32 pad) - { - - rect.t += pad; - rect.b -= pad; - - } - -/*****************************************************************************/ - -inline dng_rect MakeHalfRect (const dng_rect &rect) - { - - dng_rect out = rect; - - HalfRect (out); - - return out; - - } - -/*****************************************************************************/ - -inline dng_rect MakeDoubleRect (const dng_rect &rect) - { - - dng_rect out = rect; - - DoubleRect (out); - - return out; - - } - -/*****************************************************************************/ - -inline dng_rect MakeInnerPadRect (const dng_rect &rect, - int32 pad) - { - - dng_rect out = rect; - - InnerPadRect (out, pad); - - return out; - - } - -/*****************************************************************************/ - -inline dng_rect MakeOuterPadRect (const dng_rect &rect, - int32 pad) - { - - dng_rect out = rect; - - OuterPadRect (out, pad); - - return out; - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_ref_counted_block.cpp b/third_party/dng_sdk/dng_ref_counted_block.cpp deleted file mode 100644 index d3e027b..0000000 --- a/third_party/dng_sdk/dng_ref_counted_block.cpp +++ /dev/null @@ -1,187 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_ref_counted_block.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include - -#include "dng_ref_counted_block.h" - -#include "dng_exceptions.h" - -/*****************************************************************************/ - -dng_ref_counted_block::dng_ref_counted_block () - - : fBuffer (NULL) - - { - - } - -/*****************************************************************************/ - -dng_ref_counted_block::dng_ref_counted_block (uint32 size) - - : fBuffer (NULL) - - { - - Allocate (size); - - } - -/*****************************************************************************/ - -dng_ref_counted_block::~dng_ref_counted_block () - { - - Clear (); - - } - -/*****************************************************************************/ - -void dng_ref_counted_block::Allocate (uint32 size) - { - - Clear (); - - if (size) - { - - fBuffer = malloc (size + sizeof (header)); - - if (!fBuffer) - { - - ThrowMemoryFull (); - - } - - new (fBuffer) header (size); - - } - - } - -/*****************************************************************************/ - -void dng_ref_counted_block::Clear () - { - - if (fBuffer) - { - - - bool doFree = false; - - header *blockHeader = (struct header *)fBuffer; - - { - - dng_lock_mutex lock (&blockHeader->fMutex); - - if (--blockHeader->fRefCount == 0) - doFree = true; - } - - if (doFree) - { - - blockHeader->~header (); - - free (fBuffer); - - } - - fBuffer = NULL; - - } - - } - -/*****************************************************************************/ - -dng_ref_counted_block::dng_ref_counted_block (const dng_ref_counted_block &data) - : fBuffer (NULL) - { - - header *blockHeader = (struct header *)data.fBuffer; - - dng_lock_mutex lock (&blockHeader->fMutex); - - blockHeader->fRefCount++; - - fBuffer = blockHeader; - - } - -/*****************************************************************************/ - -dng_ref_counted_block & dng_ref_counted_block::operator= (const dng_ref_counted_block &data) - { - - if (this != &data) - { - Clear (); - - header *blockHeader = (struct header *)data.fBuffer; - - dng_lock_mutex lock (&blockHeader->fMutex); - - blockHeader->fRefCount++; - - fBuffer = blockHeader; - - } - - return *this; - - } - -/*****************************************************************************/ - -void dng_ref_counted_block::EnsureWriteable () - { - - if (fBuffer) - { - - header *possiblySharedHeader = (header *)fBuffer; - - { - - dng_lock_mutex lock (&possiblySharedHeader->fMutex); - - if (possiblySharedHeader->fRefCount > 1) - { - - fBuffer = NULL; - - Allocate ((uint32)possiblySharedHeader->fSize); - - memcpy (Buffer (), - ((char *)possiblySharedHeader) + sizeof (struct header), // could just do + 1 w/o cast, but this makes the type mixing more explicit - possiblySharedHeader->fSize); - - possiblySharedHeader->fRefCount--; - - } - - } - - } - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_ref_counted_block.h b/third_party/dng_sdk/dng_ref_counted_block.h deleted file mode 100644 index cdda745..0000000 --- a/third_party/dng_sdk/dng_ref_counted_block.h +++ /dev/null @@ -1,291 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_ref_counted_block.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** Support for a refcounted block, with optional copy-on-write - */ - -/*****************************************************************************/ - -#ifndef __dng_ref_counted_block__ -#define __dng_ref_counted_block__ - -/*****************************************************************************/ - -#include "dng_types.h" -#include "dng_mutex.h" - -/*****************************************************************************/ - -/// \brief Class to provide resource acquisition is instantiation discipline -/// for small memory allocations. -/// -/// This class does not use dng_memory_allocator for memory allocation. - -class dng_ref_counted_block - { - - private: - - struct header - { - - dng_mutex fMutex; - - uint32 fRefCount; - - uint32 fSize; - - header (uint32 size) - : fMutex ("dng_ref_counted_block") - , fRefCount (1) - , fSize (size) - { - } - - ~header () - { - } - - }; - - void *fBuffer; - - public: - - - /// Construct an empty memory buffer using malloc. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - dng_ref_counted_block (); - - /// Construct memory buffer of size bytes using malloc. - /// \param size Number of bytes of memory needed. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - dng_ref_counted_block (uint32 size); - - /// Release memory buffer using free. - - ~dng_ref_counted_block (); - - /// Copy constructore, which takes a reference to data and does not copy the block. - - dng_ref_counted_block (const dng_ref_counted_block &data); - - /// Assignment operatore takes a reference to right hand side and does not copy the data. - - dng_ref_counted_block & operator= (const dng_ref_counted_block &data); - - /// Clear existing memory buffer and allocate new memory of size bytes. - /// \param size Number of bytes of memory needed. - /// \exception dng_memory_full with fErrorCode equal to dng_error_memory. - - void Allocate (uint32 size); - - /// Release any allocated memory using free. Object is still valid and - /// Allocate can be called again. - - void Clear (); - - /// If there is only one reference, do nothing, otherwise copy the data into a new block and return an object with that block as the data. - - void EnsureWriteable (); - - /// Return pointer to allocated memory as a void *.. - /// \retval void * valid for as many bytes as were allocated. - - uint32 LogicalSize () - { - return ((header *)fBuffer)->fSize; - } - - void * Buffer () - { - return (void *)((char *)fBuffer + sizeof (header)); - } - - /// Return pointer to allocated memory as a const void *. - /// \retval const void * valid for as many bytes as were allocated. - - const void * Buffer () const - { - return (const void *)((char *)fBuffer + sizeof (header)); - } - - /// Return pointer to allocated memory as a char *. - /// \retval char * valid for as many bytes as were allocated. - - char * Buffer_char () - { - return (char *) Buffer (); - } - - /// Return pointer to allocated memory as a const char *. - /// \retval const char * valid for as many bytes as were allocated. - - const char * Buffer_char () const - { - return (const char *) Buffer (); - } - - /// Return pointer to allocated memory as a uint8 *. - /// \retval uint8 * valid for as many bytes as were allocated. - - uint8 * Buffer_uint8 () - { - return (uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint8 *. - /// \retval const uint8 * valid for as many bytes as were allocated. - - const uint8 * Buffer_uint8 () const - { - return (const uint8 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint16 *. - /// \retval uint16 * valid for as many bytes as were allocated. - - uint16 * Buffer_uint16 () - { - return (uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const uint16 *. - /// \retval const uint16 * valid for as many bytes as were allocated. - - const uint16 * Buffer_uint16 () const - { - return (const uint16 *) Buffer (); - } - - /// Return pointer to allocated memory as a int16 *. - /// \retval int16 * valid for as many bytes as were allocated. - - int16 * Buffer_int16 () - { - return (int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int16 *. - /// \retval const int16 * valid for as many bytes as were allocated. - - const int16 * Buffer_int16 () const - { - return (const int16 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint32 *. - /// \retval uint32 * valid for as many bytes as were allocated. - - uint32 * Buffer_uint32 () - { - return (uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint32 *. - /// \retval uint32 * valid for as many bytes as were allocated. - - const uint32 * Buffer_uint32 () const - { - return (const uint32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int32 *. - /// \retval const int32 * valid for as many bytes as were allocated. - - int32 * Buffer_int32 () - { - return (int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int32 *. - /// \retval const int32 * valid for as many bytes as were allocated. - - const int32 * Buffer_int32 () const - { - return (const int32 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint64 *. - /// \retval uint64 * valid for as many bytes as were allocated. - - uint64 * Buffer_uint64 () - { - return (uint64 *) Buffer (); - } - - /// Return pointer to allocated memory as a uint64 *. - /// \retval uint64 * valid for as many bytes as were allocated. - - const uint64 * Buffer_uint64 () const - { - return (const uint64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int64 *. - /// \retval const int64 * valid for as many bytes as were allocated. - - int64 * Buffer_int64 () - { - return (int64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const int64 *. - /// \retval const int64 * valid for as many bytes as were allocated. - - const int64 * Buffer_int64 () const - { - return (const int64 *) Buffer (); - } - - /// Return pointer to allocated memory as a real32 *. - /// \retval real32 * valid for as many bytes as were allocated. - - real32 * Buffer_real32 () - { - return (real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real32 *. - /// \retval const real32 * valid for as many bytes as were allocated. - - const real32 * Buffer_real32 () const - { - return (const real32 *) Buffer (); - } - - /// Return pointer to allocated memory as a real64 *. - /// \retval real64 * valid for as many bytes as were allocated. - - real64 * Buffer_real64 () - { - return (real64 *) Buffer (); - } - - /// Return pointer to allocated memory as a const real64 *. - /// \retval const real64 * valid for as many bytes as were allocated. - - const real64 * Buffer_real64 () const - { - return (const real64 *) Buffer (); - } - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_reference.cpp b/third_party/dng_sdk/dng_reference.cpp deleted file mode 100644 index 3feb195..0000000 --- a/third_party/dng_sdk/dng_reference.cpp +++ /dev/null @@ -1,2781 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_reference.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_reference.h" - -#include "dng_1d_table.h" -#include "dng_hue_sat_map.h" -#include "dng_matrix.h" -#include "dng_resample.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -// This module contains routines that should be as fast as possible, even -// at the expense of slight code size increases. - -#include "dng_fast_module.h" - -/*****************************************************************************/ - -void RefZeroBytes (void *dPtr, - uint32 count) - { - - memset (dPtr, 0, count); - - } - -/*****************************************************************************/ - -void RefCopyBytes (const void *sPtr, - void *dPtr, - uint32 count) - { - - memcpy (dPtr, sPtr, count); - - } - -/*****************************************************************************/ - -void RefSwapBytes16 (uint16 *dPtr, - uint32 count) - { - - for (uint32 j = 0; j < count; j++) - { - - dPtr [j] = SwapBytes16 (dPtr [j]); - - } - - } - -/*****************************************************************************/ - -void RefSwapBytes32 (uint32 *dPtr, - uint32 count) - { - - for (uint32 j = 0; j < count; j++) - { - - dPtr [j] = SwapBytes32 (dPtr [j]); - - } - - } - -/*****************************************************************************/ - -void RefSetArea8 (uint8 *dPtr, - uint8 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - uint8 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - uint8 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = value; - - dPtr2 += planeStep; - - } - - dPtr1 += colStep; - - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefSetArea16 (uint16 *dPtr, - uint16 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = value; - - dPtr2 += planeStep; - - } - - dPtr1 += colStep; - - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefSetArea32 (uint32 *dPtr, - uint32 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - uint32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = value; - - dPtr2 += planeStep; - - } - - dPtr1 += colStep; - - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - uint8 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - uint8 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr; - uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint32 *sPtr1 = sPtr; - uint32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint32 *sPtr2 = sPtr1; - uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea8_16 (const uint8 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea8_S16 (const uint8 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - int16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - int16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - int16 x = *sPtr; - - *dPtr2 = x ^ 0x8000; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea8_32 (const uint8 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - uint32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea16_S16 (const uint16 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr; - int16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - int16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2 ^ 0x8000; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea16_32 (const uint16 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr; - uint32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea8_R32 (const uint8 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = 1.0f / (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - real32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - real32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = scale * (real32) *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyArea16_R32 (const uint16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = 1.0f / (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr; - real32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - real32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = scale * (real32) *sPtr2; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyAreaS16_R32 (const int16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = 1.0f / (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const int16 *sPtr1 = sPtr; - real32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const int16 *sPtr2 = sPtr1; - real32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - int32 x = (*sPtr ^ 0x8000); - - *dPtr2 = scale * (real32) x; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyAreaR32_8 (const real32 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const real32 *sPtr1 = sPtr; - uint8 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const real32 *sPtr2 = sPtr1; - uint8 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = (uint8) (Pin_Overrange (*sPtr2) * scale + 0.5f); - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyAreaR32_16 (const real32 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const real32 *sPtr1 = sPtr; - uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const real32 *sPtr2 = sPtr1; - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = (uint16) (Pin_Overrange (*sPtr2) * scale + 0.5f); - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefCopyAreaR32_S16 (const real32 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange) - { - - real32 scale = (real32) pixelRange; - - for (uint32 row = 0; row < rows; row++) - { - - const real32 *sPtr1 = sPtr; - int16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const real32 *sPtr2 = sPtr1; - int16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - int32 x = (int32) (Pin_Overrange (*sPtr2) * scale + 0.5f); - - *dPtr2 = (int16) (x ^ 0x8000); - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - } - -/*****************************************************************************/ - -void RefRepeatArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - const uint8 *sPtr0 = sPtr + phaseV * rowStep + - phaseH * colStep; - - int32 backStepV = (repeatV - 1) * rowStep; - int32 backStepH = (repeatH - 1) * colStep; - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr0; - uint8 *dPtr1 = dPtr; - - uint32 colPhase = phaseH; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - uint8 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += planeStep; - dPtr2 += planeStep; - - } - - if (++colPhase == repeatH) - { - colPhase = 0; - sPtr1 -= backStepH; - } - else - { - sPtr1 += colStep; - } - - dPtr1 += colStep; - - } - - if (++phaseV == repeatV) - { - phaseV = 0; - sPtr0 -= backStepV; - } - else - { - sPtr0 += rowStep; - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefRepeatArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - const uint16 *sPtr0 = sPtr + phaseV * rowStep + - phaseH * colStep; - - int32 backStepV = (repeatV - 1) * rowStep; - int32 backStepH = (repeatH - 1) * colStep; - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr0; - uint16 *dPtr1 = dPtr; - - uint32 colPhase = phaseH; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += planeStep; - dPtr2 += planeStep; - - } - - if (++colPhase == repeatH) - { - colPhase = 0; - sPtr1 -= backStepH; - } - else - { - sPtr1 += colStep; - } - - dPtr1 += colStep; - - } - - if (++phaseV == repeatV) - { - phaseV = 0; - sPtr0 -= backStepV; - } - else - { - sPtr0 += rowStep; - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefRepeatArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH) - { - - const uint32 *sPtr0 = sPtr + phaseV * rowStep + - phaseH * colStep; - - int32 backStepV = (repeatV - 1) * rowStep; - int32 backStepH = (repeatH - 1) * colStep; - - for (uint32 row = 0; row < rows; row++) - { - - const uint32 *sPtr1 = sPtr0; - uint32 *dPtr1 = dPtr; - - uint32 colPhase = phaseH; - - for (uint32 col = 0; col < cols; col++) - { - - const uint32 *sPtr2 = sPtr1; - uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 = *sPtr2; - - sPtr2 += planeStep; - dPtr2 += planeStep; - - } - - if (++colPhase == repeatH) - { - colPhase = 0; - sPtr1 -= backStepH; - } - else - { - sPtr1 += colStep; - } - - dPtr1 += colStep; - - } - - if (++phaseV == repeatV) - { - phaseV = 0; - sPtr0 -= backStepV; - } - else - { - sPtr0 += rowStep; - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefShiftRight16 (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 shift) - { - - for (uint32 row = 0; row < rows; row++) - { - - uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - *dPtr2 >>= shift; - - dPtr2 += planeStep; - - } - - dPtr1 += colStep; - - } - - dPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefBilinearRow16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const uint16 * const * kernWeights, - uint32 sShift) - { - - for (uint32 j = 0; j < cols; j++) - { - - const uint16 *p = sPtr + (j >> sShift); - - uint32 count = kernCounts [patPhase]; - - const int32 *offsets = kernOffsets [patPhase]; - const uint16 *weights = kernWeights [patPhase]; - - if (++patPhase == patCount) - { - patPhase = 0; - } - - uint32 total = 128; - - for (uint32 k = 0; k < count; k++) - { - - int32 offset = offsets [k]; - uint32 weight = weights [k]; - - uint32 pixel = p [offset]; - - total += pixel * weight; - - } - - dPtr [j] = (uint16) (total >> 8); - - } - - } - -/*****************************************************************************/ - -void RefBilinearRow32 (const real32 *sPtr, - real32 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const real32 * const * kernWeights, - uint32 sShift) - { - - for (uint32 j = 0; j < cols; j++) - { - - const real32 *p = sPtr + (j >> sShift); - - uint32 count = kernCounts [patPhase]; - - const int32 *offsets = kernOffsets [patPhase]; - const real32 *weights = kernWeights [patPhase]; - - if (++patPhase == patCount) - { - patPhase = 0; - } - - real32 total = 0.0f; - - for (uint32 k = 0; k < count; k++) - { - - int32 offset = offsets [k]; - real32 weight = weights [k]; - - real32 pixel = p [offset]; - - total += pixel * weight; - - } - - dPtr [j] = total; - - } - - } - -/*****************************************************************************/ - -void RefBaselineABCtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB) - { - - real32 clipA = (real32) cameraWhite [0]; - real32 clipB = (real32) cameraWhite [1]; - real32 clipC = (real32) cameraWhite [2]; - - real32 m00 = (real32) cameraToRGB [0] [0]; - real32 m01 = (real32) cameraToRGB [0] [1]; - real32 m02 = (real32) cameraToRGB [0] [2]; - - real32 m10 = (real32) cameraToRGB [1] [0]; - real32 m11 = (real32) cameraToRGB [1] [1]; - real32 m12 = (real32) cameraToRGB [1] [2]; - - real32 m20 = (real32) cameraToRGB [2] [0]; - real32 m21 = (real32) cameraToRGB [2] [1]; - real32 m22 = (real32) cameraToRGB [2] [2]; - - for (uint32 col = 0; col < count; col++) - { - - real32 A = sPtrA [col]; - real32 B = sPtrB [col]; - real32 C = sPtrC [col]; - - A = Min_real32 (A, clipA); - B = Min_real32 (B, clipB); - C = Min_real32 (C, clipC); - - real32 r = m00 * A + m01 * B + m02 * C; - real32 g = m10 * A + m11 * B + m12 * C; - real32 b = m20 * A + m21 * B + m22 * C; - - r = Pin_real32 (0.0f, r, 1.0f); - g = Pin_real32 (0.0f, g, 1.0f); - b = Pin_real32 (0.0f, b, 1.0f); - - dPtrR [col] = r; - dPtrG [col] = g; - dPtrB [col] = b; - - } - - } - -/*****************************************************************************/ - -void RefBaselineABCDtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - const real32 *sPtrD, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB) - { - - real32 clipA = (real32) cameraWhite [0]; - real32 clipB = (real32) cameraWhite [1]; - real32 clipC = (real32) cameraWhite [2]; - real32 clipD = (real32) cameraWhite [3]; - - real32 m00 = (real32) cameraToRGB [0] [0]; - real32 m01 = (real32) cameraToRGB [0] [1]; - real32 m02 = (real32) cameraToRGB [0] [2]; - real32 m03 = (real32) cameraToRGB [0] [3]; - - real32 m10 = (real32) cameraToRGB [1] [0]; - real32 m11 = (real32) cameraToRGB [1] [1]; - real32 m12 = (real32) cameraToRGB [1] [2]; - real32 m13 = (real32) cameraToRGB [1] [3]; - - real32 m20 = (real32) cameraToRGB [2] [0]; - real32 m21 = (real32) cameraToRGB [2] [1]; - real32 m22 = (real32) cameraToRGB [2] [2]; - real32 m23 = (real32) cameraToRGB [2] [3]; - - for (uint32 col = 0; col < count; col++) - { - - real32 A = sPtrA [col]; - real32 B = sPtrB [col]; - real32 C = sPtrC [col]; - real32 D = sPtrD [col]; - - A = Min_real32 (A, clipA); - B = Min_real32 (B, clipB); - C = Min_real32 (C, clipC); - D = Min_real32 (D, clipD); - - real32 r = m00 * A + m01 * B + m02 * C + m03 * D; - real32 g = m10 * A + m11 * B + m12 * C + m13 * D; - real32 b = m20 * A + m21 * B + m22 * C + m23 * D; - - r = Pin_real32 (0.0f, r, 1.0f); - g = Pin_real32 (0.0f, g, 1.0f); - b = Pin_real32 (0.0f, b, 1.0f); - - dPtrR [col] = r; - dPtrG [col] = g; - dPtrB [col] = b; - - } - - } - -/*****************************************************************************/ - -void RefBaselineHueSatMap (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_hue_sat_map &lut, - const dng_1d_table *encodeTable, - const dng_1d_table *decodeTable) - { - - uint32 hueDivisions; - uint32 satDivisions; - uint32 valDivisions; - - lut.GetDivisions (hueDivisions, - satDivisions, - valDivisions); - - real32 hScale = (hueDivisions < 2) ? 0.0f : (hueDivisions * (1.0f / 6.0f)); - real32 sScale = (real32) (satDivisions - 1); - real32 vScale = (real32) (valDivisions - 1); - - int32 maxHueIndex0 = hueDivisions - 1; - int32 maxSatIndex0 = satDivisions - 2; - int32 maxValIndex0 = valDivisions - 2; - - const bool hasEncodeTable = ((encodeTable != NULL) && (encodeTable->Table () != NULL)); - const bool hasDecodeTable = ((decodeTable != NULL) && (decodeTable->Table () != NULL)); - - const bool hasTable = hasEncodeTable && hasDecodeTable; - - const dng_hue_sat_map::HSBModify *tableBase = lut.GetConstDeltas (); - - int32 hueStep = satDivisions; - int32 valStep = hueDivisions * hueStep; - - #if 0 // Not required with "2.5D" table optimization. - - if (valDivisions < 2) - { - valStep = 0; - maxValIndex0 = 0; - } - - #endif - - for (uint32 j = 0; j < count; j++) - { - - real32 r = sPtrR [j]; - real32 g = sPtrG [j]; - real32 b = sPtrB [j]; - - real32 h, s, v; - - DNG_RGBtoHSV (r, g, b, h, s, v); - - real32 vEncoded = v; - - real32 hueShift; - real32 satScale; - real32 valScale; - - if (valDivisions < 2) // Optimize most common case of "2.5D" table. - { - - real32 hScaled = h * hScale; - real32 sScaled = s * sScale; - - int32 hIndex0 = (int32) hScaled; - int32 sIndex0 = (int32) sScaled; - - sIndex0 = Min_int32 (sIndex0, maxSatIndex0); - - int32 hIndex1 = hIndex0 + 1; - - if (hIndex0 >= maxHueIndex0) - { - hIndex0 = maxHueIndex0; - hIndex1 = 0; - } - - real32 hFract1 = hScaled - (real32) hIndex0; - real32 sFract1 = sScaled - (real32) sIndex0; - - real32 hFract0 = 1.0f - hFract1; - real32 sFract0 = 1.0f - sFract1; - - const dng_hue_sat_map::HSBModify *entry00 = tableBase + hIndex0 * hueStep + - sIndex0; - - const dng_hue_sat_map::HSBModify *entry01 = entry00 + (hIndex1 - hIndex0) * hueStep; - - real32 hueShift0 = hFract0 * entry00->fHueShift + - hFract1 * entry01->fHueShift; - - real32 satScale0 = hFract0 * entry00->fSatScale + - hFract1 * entry01->fSatScale; - - real32 valScale0 = hFract0 * entry00->fValScale + - hFract1 * entry01->fValScale; - - entry00++; - entry01++; - - real32 hueShift1 = hFract0 * entry00->fHueShift + - hFract1 * entry01->fHueShift; - - real32 satScale1 = hFract0 * entry00->fSatScale + - hFract1 * entry01->fSatScale; - - real32 valScale1 = hFract0 * entry00->fValScale + - hFract1 * entry01->fValScale; - - hueShift = sFract0 * hueShift0 + sFract1 * hueShift1; - satScale = sFract0 * satScale0 + sFract1 * satScale1; - valScale = sFract0 * valScale0 + sFract1 * valScale1; - - } - - else - { - - if (hasTable) - { - vEncoded = encodeTable->Interpolate (Pin_real32 (v)); - } - - real32 hScaled = h * hScale; - real32 sScaled = s * sScale; - real32 vScaled = vEncoded * vScale; - - int32 hIndex0 = (int32) hScaled; - int32 sIndex0 = (int32) sScaled; - int32 vIndex0 = (int32) vScaled; - - sIndex0 = Min_int32 (sIndex0, maxSatIndex0); - vIndex0 = Min_int32 (vIndex0, maxValIndex0); - - int32 hIndex1 = hIndex0 + 1; - - if (hIndex0 >= maxHueIndex0) - { - hIndex0 = maxHueIndex0; - hIndex1 = 0; - } - - real32 hFract1 = hScaled - (real32) hIndex0; - real32 sFract1 = sScaled - (real32) sIndex0; - real32 vFract1 = vScaled - (real32) vIndex0; - - real32 hFract0 = 1.0f - hFract1; - real32 sFract0 = 1.0f - sFract1; - real32 vFract0 = 1.0f - vFract1; - - const dng_hue_sat_map::HSBModify *entry00 = tableBase + vIndex0 * valStep + - hIndex0 * hueStep + - sIndex0; - - const dng_hue_sat_map::HSBModify *entry01 = entry00 + (hIndex1 - hIndex0) * hueStep; - - const dng_hue_sat_map::HSBModify *entry10 = entry00 + valStep; - const dng_hue_sat_map::HSBModify *entry11 = entry01 + valStep; - - real32 hueShift0 = vFract0 * (hFract0 * entry00->fHueShift + - hFract1 * entry01->fHueShift) + - vFract1 * (hFract0 * entry10->fHueShift + - hFract1 * entry11->fHueShift); - - real32 satScale0 = vFract0 * (hFract0 * entry00->fSatScale + - hFract1 * entry01->fSatScale) + - vFract1 * (hFract0 * entry10->fSatScale + - hFract1 * entry11->fSatScale); - - real32 valScale0 = vFract0 * (hFract0 * entry00->fValScale + - hFract1 * entry01->fValScale) + - vFract1 * (hFract0 * entry10->fValScale + - hFract1 * entry11->fValScale); - - entry00++; - entry01++; - entry10++; - entry11++; - - real32 hueShift1 = vFract0 * (hFract0 * entry00->fHueShift + - hFract1 * entry01->fHueShift) + - vFract1 * (hFract0 * entry10->fHueShift + - hFract1 * entry11->fHueShift); - - real32 satScale1 = vFract0 * (hFract0 * entry00->fSatScale + - hFract1 * entry01->fSatScale) + - vFract1 * (hFract0 * entry10->fSatScale + - hFract1 * entry11->fSatScale); - - real32 valScale1 = vFract0 * (hFract0 * entry00->fValScale + - hFract1 * entry01->fValScale) + - vFract1 * (hFract0 * entry10->fValScale + - hFract1 * entry11->fValScale); - - hueShift = sFract0 * hueShift0 + sFract1 * hueShift1; - satScale = sFract0 * satScale0 + sFract1 * satScale1; - valScale = sFract0 * valScale0 + sFract1 * valScale1; - - } - - hueShift *= (6.0f / 360.0f); // Convert to internal hue range. - - h += hueShift; - - s = Min_real32 (s * satScale, 1.0f); - - vEncoded = Pin_real32 (vEncoded * valScale); - - v = hasTable ? decodeTable->Interpolate (vEncoded) : vEncoded; - - DNG_HSVtoRGB (h, s, v, r, g, b); - - dPtrR [j] = r; - dPtrG [j] = g; - dPtrB [j] = b; - - } - - } - -/*****************************************************************************/ - -void RefBaselineRGBtoGray (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrG, - uint32 count, - const dng_matrix &matrix) - { - - real32 m00 = (real32) matrix [0] [0]; - real32 m01 = (real32) matrix [0] [1]; - real32 m02 = (real32) matrix [0] [2]; - - for (uint32 col = 0; col < count; col++) - { - - real32 R = sPtrR [col]; - real32 G = sPtrG [col]; - real32 B = sPtrB [col]; - - real32 g = m00 * R + m01 * G + m02 * B; - - g = Pin_real32 (0.0f, g, 1.0f); - - dPtrG [col] = g; - - } - - } - -/*****************************************************************************/ - -void RefBaselineRGBtoRGB (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_matrix &matrix) - { - - real32 m00 = (real32) matrix [0] [0]; - real32 m01 = (real32) matrix [0] [1]; - real32 m02 = (real32) matrix [0] [2]; - - real32 m10 = (real32) matrix [1] [0]; - real32 m11 = (real32) matrix [1] [1]; - real32 m12 = (real32) matrix [1] [2]; - - real32 m20 = (real32) matrix [2] [0]; - real32 m21 = (real32) matrix [2] [1]; - real32 m22 = (real32) matrix [2] [2]; - - for (uint32 col = 0; col < count; col++) - { - - real32 R = sPtrR [col]; - real32 G = sPtrG [col]; - real32 B = sPtrB [col]; - - real32 r = m00 * R + m01 * G + m02 * B; - real32 g = m10 * R + m11 * G + m12 * B; - real32 b = m20 * R + m21 * G + m22 * B; - - r = Pin_real32 (0.0f, r, 1.0f); - g = Pin_real32 (0.0f, g, 1.0f); - b = Pin_real32 (0.0f, b, 1.0f); - - dPtrR [col] = r; - dPtrG [col] = g; - dPtrB [col] = b; - - } - - } - -/*****************************************************************************/ - -void RefBaseline1DTable (const real32 *sPtr, - real32 *dPtr, - uint32 count, - const dng_1d_table &table) - { - - for (uint32 col = 0; col < count; col++) - { - - real32 x = sPtr [col]; - - real32 y = table.Interpolate (x); - - dPtr [col] = y; - - } - - } - -/*****************************************************************************/ - -void RefBaselineRGBTone (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_1d_table &table) - { - - for (uint32 col = 0; col < count; col++) - { - - real32 r = sPtrR [col]; - real32 g = sPtrG [col]; - real32 b = sPtrB [col]; - - real32 rr; - real32 gg; - real32 bb; - - #define RGBTone(r, g, b, rr, gg, bb)\ - {\ - \ - DNG_ASSERT (r >= g && g >= b && r > b, "Logic Error RGBTone");\ - \ - rr = table.Interpolate (r);\ - bb = table.Interpolate (b);\ - \ - gg = bb + ((rr - bb) * (g - b) / (r - b));\ - \ - } - - if (r >= g) - { - - if (g > b) - { - - // Case 1: r >= g > b - - RGBTone (r, g, b, rr, gg, bb); - - } - - else if (b > r) - { - - // Case 2: b > r >= g - - RGBTone (b, r, g, bb, rr, gg); - - } - - else if (b > g) - { - - // Case 3: r >= b > g - - RGBTone (r, b, g, rr, bb, gg); - - } - - else - { - - // Case 4: r >= g == b - - DNG_ASSERT (r >= g && g == b, "Logic Error 2"); - - rr = table.Interpolate (r); - gg = table.Interpolate (g); - bb = gg; - - } - - } - - else - { - - if (r >= b) - { - - // Case 5: g > r >= b - - RGBTone (g, r, b, gg, rr, bb); - - } - - else if (b > g) - { - - // Case 6: b > g > r - - RGBTone (b, g, r, bb, gg, rr); - - } - - else - { - - // Case 7: g >= b > r - - RGBTone (g, b, r, gg, bb, rr); - - } - - } - - #undef RGBTone - - dPtrR [col] = rr; - dPtrG [col] = gg; - dPtrB [col] = bb; - - } - - } - -/*****************************************************************************/ - -void RefResampleDown16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 sCount, - int32 sRowStep, - const int16 *wPtr, - uint32 wCount, - uint32 pixelRange) - { - - for (uint32 j = 0; j < sCount; j++) - { - - int32 total = 8192; - - const uint16 *s = sPtr + j; - - for (uint32 k = 0; k < wCount; k++) - { - - total += wPtr [k] * (int32) s [0]; - - s += sRowStep; - - } - - dPtr [j] = (uint16) Pin_int32 (0, - total >> 14, - pixelRange); - - } - - } - -/*****************************************************************************/ - -void RefResampleDown32 (const real32 *sPtr, - real32 *dPtr, - uint32 sCount, - int32 sRowStep, - const real32 *wPtr, - uint32 wCount) - { - - uint32 col; - - // Process first row. - - real32 w = wPtr [0]; - - for (col = 0; col < sCount; col++) - { - - dPtr [col] = w * sPtr [col]; - - } - - sPtr += sRowStep; - - // Process middle rows. - - for (uint32 j = 1; j < wCount - 1; j++) - { - - w = wPtr [j]; - - for (col = 0; col < sCount; col++) - { - - dPtr [col] += w * sPtr [col]; - - } - - sPtr += sRowStep; - - } - - // Process last row. - - w = wPtr [wCount - 1]; - - for (col = 0; col < sCount; col++) - { - - dPtr [col] = Pin_real32 (0.0f, - dPtr [col] + w * sPtr [col], - 1.0f); - - } - - } - -/******************************************************************************/ - -void RefResampleAcross16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 dCount, - const int32 *coord, - const int16 *wPtr, - uint32 wCount, - uint32 wStep, - uint32 pixelRange) - { - - for (uint32 j = 0; j < dCount; j++) - { - - int32 sCoord = coord [j]; - - int32 sFract = sCoord & kResampleSubsampleMask; - int32 sPixel = sCoord >> kResampleSubsampleBits; - - const int16 *w = wPtr + sFract * wStep; - const uint16 *s = sPtr + sPixel; - - int32 total = w [0] * (int32) s [0]; - - for (uint32 k = 1; k < wCount; k++) - { - - total += w [k] * (int32) s [k]; - - } - - dPtr [j] = (uint16) Pin_int32 (0, - (total + 8192) >> 14, - pixelRange); - - } - - } - -/******************************************************************************/ - -void RefResampleAcross32 (const real32 *sPtr, - real32 *dPtr, - uint32 dCount, - const int32 *coord, - const real32 *wPtr, - uint32 wCount, - uint32 wStep) - { - - for (uint32 j = 0; j < dCount; j++) - { - - int32 sCoord = coord [j]; - - int32 sFract = sCoord & kResampleSubsampleMask; - int32 sPixel = sCoord >> kResampleSubsampleBits; - - const real32 *w = wPtr + sFract * wStep; - const real32 *s = sPtr + sPixel; - - real32 total = w [0] * s [0]; - - for (uint32 k = 1; k < wCount; k++) - { - - total += w [k] * s [k]; - - } - - dPtr [j] = Pin_real32 (0.0f, total, 1.0f); - - } - - } - -/*****************************************************************************/ - -bool RefEqualBytes (const void *sPtr, - const void *dPtr, - uint32 count) - { - - return memcmp (dPtr, sPtr, count) == 0; - - } - -/*****************************************************************************/ - -bool RefEqualArea8 (const uint8 *sPtr, - const uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint8 *sPtr1 = sPtr; - const uint8 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint8 *sPtr2 = sPtr1; - const uint8 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - if (*dPtr2 != *sPtr2) - return false; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - return true; - - } - -/*****************************************************************************/ - -bool RefEqualArea16 (const uint16 *sPtr, - const uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint16 *sPtr1 = sPtr; - const uint16 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint16 *sPtr2 = sPtr1; - const uint16 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - if (*dPtr2 != *sPtr2) - return false; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - return true; - - } - -/*****************************************************************************/ - -bool RefEqualArea32 (const uint32 *sPtr, - const uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep) - { - - for (uint32 row = 0; row < rows; row++) - { - - const uint32 *sPtr1 = sPtr; - const uint32 *dPtr1 = dPtr; - - for (uint32 col = 0; col < cols; col++) - { - - const uint32 *sPtr2 = sPtr1; - const uint32 *dPtr2 = dPtr1; - - for (uint32 plane = 0; plane < planes; plane++) - { - - if (*dPtr2 != *sPtr2) - return false; - - sPtr2 += sPlaneStep; - dPtr2 += dPlaneStep; - - } - - sPtr1 += sColStep; - dPtr1 += dColStep; - - } - - sPtr += sRowStep; - dPtr += dRowStep; - - } - - return true; - - } - -/*****************************************************************************/ - -void RefVignetteMask16 (uint16 *mPtr, - uint32 rows, - uint32 cols, - int32 rowStep, - int64 offsetH, - int64 offsetV, - int64 stepH, - int64 stepV, - uint32 tBits, - const uint16 *table) - { - - uint32 tShift = 32 - tBits; - uint32 tRound = (1 << (tShift - 1)); - uint32 tLimit = 1 << tBits; - - for (uint32 row = 0; row < rows; row++) - { - - int64 baseDelta = (offsetV + 32768) >> 16; - - baseDelta = baseDelta * baseDelta + tRound; - - int64 deltaH = offsetH + 32768; - - for (uint32 col = 0; col < cols; col++) - { - - int64 temp = deltaH >> 16; - - int64 delta = baseDelta + (temp * temp); - - uint32 index = Min_uint32 ((uint32) (delta >> tShift), tLimit); - - mPtr [col] = table [index]; - - deltaH += stepH; - - } - - offsetV += stepV; - - mPtr += rowStep; - - } - - } - -/*****************************************************************************/ - -void RefVignette16 (int16 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits) - { - - const uint32 mRound = 1 << (mBits - 1); - - switch (planes) - { - - case 1: - { - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - uint32 s = sPtr [col] + 32768; - - uint32 m = mPtr [col]; - - s = (s * m + mRound) >> mBits; - - s = Min_uint32 (s, 65535); - - sPtr [col] = (int16) (s - 32768); - - } - - sPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - case 3: - { - - int16 *rPtr = sPtr; - int16 *gPtr = rPtr + sPlaneStep; - int16 *bPtr = gPtr + sPlaneStep; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - uint32 r = rPtr [col] + 32768; - uint32 g = gPtr [col] + 32768; - uint32 b = bPtr [col] + 32768; - - uint32 m = mPtr [col]; - - r = (r * m + mRound) >> mBits; - g = (g * m + mRound) >> mBits; - b = (b * m + mRound) >> mBits; - - r = Min_uint32 (r, 65535); - g = Min_uint32 (g, 65535); - b = Min_uint32 (b, 65535); - - rPtr [col] = (int16) (r - 32768); - gPtr [col] = (int16) (g - 32768); - bPtr [col] = (int16) (b - 32768); - - } - - rPtr += sRowStep; - gPtr += sRowStep; - bPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - case 4: - { - - int16 *aPtr = sPtr; - int16 *bPtr = aPtr + sPlaneStep; - int16 *cPtr = bPtr + sPlaneStep; - int16 *dPtr = cPtr + sPlaneStep; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - uint32 a = aPtr [col] + 32768; - uint32 b = bPtr [col] + 32768; - uint32 c = cPtr [col] + 32768; - uint32 d = dPtr [col] + 32768; - - uint32 m = mPtr [col]; - - a = (a * m + mRound) >> mBits; - b = (b * m + mRound) >> mBits; - c = (c * m + mRound) >> mBits; - d = (d * m + mRound) >> mBits; - - a = Min_uint32 (a, 65535); - b = Min_uint32 (b, 65535); - c = Min_uint32 (c, 65535); - d = Min_uint32 (d, 65535); - - aPtr [col] = (int16) (a - 32768); - bPtr [col] = (int16) (b - 32768); - cPtr [col] = (int16) (c - 32768); - dPtr [col] = (int16) (d - 32768); - - } - - aPtr += sRowStep; - bPtr += sRowStep; - cPtr += sRowStep; - dPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - default: - { - - for (uint32 plane = 0; plane < planes; plane++) - { - - int16 *planePtr = sPtr; - - const uint16 *maskPtr = mPtr; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - uint32 s = planePtr [col] + 32768; - - uint32 m = maskPtr [col]; - - s = (s * m + mRound) >> mBits; - - s = Min_uint32 (s, 65535); - - planePtr [col] = (int16) (s - 32768); - - } - - planePtr += sRowStep; - - maskPtr += mRowStep; - - } - - sPtr += sPlaneStep; - - } - - break; - - } - - } - - } - -/*****************************************************************************/ - -void RefVignette32 (real32 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits) - { - - const real32 kNorm = 1.0f / (1 << mBits); - - switch (planes) - { - - case 1: - { - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - real32 s = sPtr [col]; - - uint16 m = mPtr [col]; - - real32 scale = m * kNorm; - - s = Min_real32 (s * scale, 1.0f); - - sPtr [col] = s; - - } - - sPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - case 3: - { - - real32 *rPtr = sPtr; - real32 *gPtr = rPtr + sPlaneStep; - real32 *bPtr = gPtr + sPlaneStep; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - real32 r = rPtr [col]; - real32 g = gPtr [col]; - real32 b = bPtr [col]; - - uint16 m = mPtr [col]; - - real32 scale = m * kNorm; - - r = Min_real32 (r * scale, 1.0f); - g = Min_real32 (g * scale, 1.0f); - b = Min_real32 (b * scale, 1.0f); - - rPtr [col] = r; - gPtr [col] = g; - bPtr [col] = b; - - } - - rPtr += sRowStep; - gPtr += sRowStep; - bPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - case 4: - { - - real32 *aPtr = sPtr; - real32 *bPtr = aPtr + sPlaneStep; - real32 *cPtr = bPtr + sPlaneStep; - real32 *dPtr = cPtr + sPlaneStep; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - real32 a = aPtr [col]; - real32 b = bPtr [col]; - real32 c = cPtr [col]; - real32 d = dPtr [col]; - - uint16 m = mPtr [col]; - - real32 scale = m * kNorm; - - a = Min_real32 (a * scale, 1.0f); - b = Min_real32 (b * scale, 1.0f); - c = Min_real32 (c * scale, 1.0f); - d = Min_real32 (d * scale, 1.0f); - - aPtr [col] = a; - bPtr [col] = b; - cPtr [col] = c; - dPtr [col] = d; - - } - - aPtr += sRowStep; - bPtr += sRowStep; - cPtr += sRowStep; - dPtr += sRowStep; - - mPtr += mRowStep; - - } - - break; - - } - - default: - { - - for (uint32 plane = 0; plane < planes; plane++) - { - - real32 *planePtr = sPtr; - - const uint16 *maskPtr = mPtr; - - for (uint32 row = 0; row < rows; row++) - { - - for (uint32 col = 0; col < cols; col++) - { - - real32 s = planePtr [col]; - - uint16 m = maskPtr [col]; - - real32 scale = m * kNorm; - - s = Min_real32 (s * scale, 1.0f); - - planePtr [col] = s; - - } - - planePtr += sRowStep; - - maskPtr += mRowStep; - - } - - sPtr += sPlaneStep; - - } - - break; - - } - - } - - } - -/******************************************************************************/ - -void RefMapArea16 (uint16 *dPtr, - uint32 count0, - uint32 count1, - uint32 count2, - int32 step0, - int32 step1, - int32 step2, - const uint16 *map) - { - - if (step2 == 1 && count2 >= 32) - { - - for (uint32 index0 = 0; index0 < count0; index0++) - { - - uint16 *d1 = dPtr; - - for (uint32 index1 = 0; index1 < count1; index1++) - { - - uint16 *d2 = d1; - - uint32 count = count2; - - // Get the data 32-bit aligned if it is not. - - if (!IsAligned32 (dPtr)) - { - - d2 [0] = map [d2 [0]]; - - count--; - - d2++; - - } - - // Use 32-bit reads and writes for bulk processing. - - uint32 *dPtr32 = (uint32 *) d2; - - // Process in blocks of 16 pixels. - - uint32 blocks = count >> 4; - - count -= blocks << 4; - d2 += blocks << 4; - - while (blocks--) - { - - uint32 x0, x1, x2, x3, x4, x5, x6, x7; - uint32 p0, p1, p2, p3, p4, p5, p6, p7; - - // Use 32 bit reads & writes, and pack and unpack the 16-bit values. - // This results in slightly higher performance. - - // Note that this code runs on both little-endian and big-endian systems, - // since the pixels are either never swapped or double swapped. - - x0 = dPtr32 [0]; - x1 = dPtr32 [1]; - x2 = dPtr32 [2]; - x3 = dPtr32 [3]; - - p0 = map [x0 >> 16 ]; - p1 = map [x0 & 0x0FFFF]; - p2 = map [x1 >> 16 ]; - p3 = map [x1 & 0x0FFFF]; - p4 = map [x2 >> 16 ]; - p5 = map [x2 & 0x0FFFF]; - p6 = map [x3 >> 16 ]; - p7 = map [x3 & 0x0FFFF]; - - x0 = (p0 << 16) | p1; - x1 = (p2 << 16) | p3; - x2 = (p4 << 16) | p5; - x3 = (p6 << 16) | p7; - - x4 = dPtr32 [4]; - x5 = dPtr32 [5]; - x6 = dPtr32 [6]; - x7 = dPtr32 [7]; - - dPtr32 [0] = x0; - dPtr32 [1] = x1; - dPtr32 [2] = x2; - dPtr32 [3] = x3; - - p0 = map [x4 >> 16 ]; - p1 = map [x4 & 0x0FFFF]; - p2 = map [x5 >> 16 ]; - p3 = map [x5 & 0x0FFFF]; - p4 = map [x6 >> 16 ]; - p5 = map [x6 & 0x0FFFF]; - p6 = map [x7 >> 16 ]; - p7 = map [x7 & 0x0FFFF]; - - x4 = (p0 << 16) | p1; - x5 = (p2 << 16) | p3; - x6 = (p4 << 16) | p5; - x7 = (p6 << 16) | p7; - - dPtr32 [4] = x4; - dPtr32 [5] = x5; - dPtr32 [6] = x6; - dPtr32 [7] = x7; - - dPtr32 += 8; - - } - - // Process remaining columns. - - for (uint32 j = 0; j < count; j++) - { - - d2 [j] = map [d2 [j]]; - - } - - d1 += step1; - - } - - dPtr += step0; - - } - - } - - else - { - - for (uint32 index0 = 0; index0 < count0; index0++) - { - - uint16 *d1 = dPtr; - - for (uint32 index1 = 0; index1 < count1; index1++) - { - - uint16 *d2 = d1; - - for (uint32 index2 = 0; index2 < count2; index2++) - { - - d2 [0] = map [d2 [0]]; - - d2 += step2; - - } - - d1 += step1; - - } - - dPtr += step0; - - } - - } - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_reference.h b/third_party/dng_sdk/dng_reference.h deleted file mode 100644 index d75dcec..0000000 --- a/third_party/dng_sdk/dng_reference.h +++ /dev/null @@ -1,521 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2009 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_reference.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_reference__ -#define __dng_reference__ - -/*****************************************************************************/ - -#include "dng_bottlenecks.h" - -/*****************************************************************************/ - -void RefZeroBytes (void *dPtr, - uint32 count); - -void RefCopyBytes (const void *sPtr, - void *dPtr, - uint32 count); - -/*****************************************************************************/ - -void RefSwapBytes16 (uint16 *dPtr, - uint32 count); - -void RefSwapBytes32 (uint32 *dPtr, - uint32 count); - -/*****************************************************************************/ - -void RefSetArea8 (uint8 *dPtr, - uint8 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -void RefSetArea16 (uint16 *dPtr, - uint16 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -void RefSetArea32 (uint32 *dPtr, - uint32 value, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep); - -/*****************************************************************************/ - -void RefCopyArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea8_16 (const uint8 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea8_S16 (const uint8 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea8_32 (const uint8 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea16_S16 (const uint16 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea16_32 (const uint16 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -void RefCopyArea8_R32 (const uint8 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -void RefCopyArea16_R32 (const uint16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -void RefCopyAreaS16_R32 (const int16 *sPtr, - real32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -void RefCopyAreaR32_8 (const real32 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -void RefCopyAreaR32_16 (const real32 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -void RefCopyAreaR32_S16 (const real32 *sPtr, - int16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep, - uint32 pixelRange); - -/*****************************************************************************/ - -void RefRepeatArea8 (const uint8 *sPtr, - uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -void RefRepeatArea16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -void RefRepeatArea32 (const uint32 *sPtr, - uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 repeatV, - uint32 repeatH, - uint32 phaseV, - uint32 phaseH); - -/*****************************************************************************/ - -void RefShiftRight16 (uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 rowStep, - int32 colStep, - int32 planeStep, - uint32 shift); - -/*****************************************************************************/ - -void RefBilinearRow16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const uint16 * const * kernWeights, - uint32 sShift); - -void RefBilinearRow32 (const real32 *sPtr, - real32 *dPtr, - uint32 cols, - uint32 patPhase, - uint32 patCount, - const uint32 * kernCounts, - const int32 * const * kernOffsets, - const real32 * const * kernWeights, - uint32 sShift); - -/*****************************************************************************/ - -void RefBaselineABCtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB); - -void RefBaselineABCDtoRGB (const real32 *sPtrA, - const real32 *sPtrB, - const real32 *sPtrC, - const real32 *sPtrD, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_vector &cameraWhite, - const dng_matrix &cameraToRGB); - -/*****************************************************************************/ - -void RefBaselineHueSatMap (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_hue_sat_map &lut, - const dng_1d_table *encodeTable, - const dng_1d_table *decodeTable); - -/*****************************************************************************/ - -void RefBaselineRGBtoGray (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrG, - uint32 count, - const dng_matrix &matrix); - -void RefBaselineRGBtoRGB (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_matrix &matrix); - -/*****************************************************************************/ - -void RefBaseline1DTable (const real32 *sPtr, - real32 *dPtr, - uint32 count, - const dng_1d_table &table); - -/*****************************************************************************/ - -void RefBaselineRGBTone (const real32 *sPtrR, - const real32 *sPtrG, - const real32 *sPtrB, - real32 *dPtrR, - real32 *dPtrG, - real32 *dPtrB, - uint32 count, - const dng_1d_table &table); - -/*****************************************************************************/ - -void RefResampleDown16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 sCount, - int32 sRowStep, - const int16 *wPtr, - uint32 wCount, - uint32 pixelRange); - -void RefResampleDown32 (const real32 *sPtr, - real32 *dPtr, - uint32 sCount, - int32 sRowStep, - const real32 *wPtr, - uint32 wCount); - -/*****************************************************************************/ - -void RefResampleAcross16 (const uint16 *sPtr, - uint16 *dPtr, - uint32 dCount, - const int32 *coord, - const int16 *wPtr, - uint32 wCount, - uint32 wStep, - uint32 pixelRange); - -void RefResampleAcross32 (const real32 *sPtr, - real32 *dPtr, - uint32 dCount, - const int32 *coord, - const real32 *wPtr, - uint32 wCount, - uint32 wStep); - -/*****************************************************************************/ - -bool RefEqualBytes (const void *sPtr, - const void *dPtr, - uint32 count); - -bool RefEqualArea8 (const uint8 *sPtr, - const uint8 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -bool RefEqualArea16 (const uint16 *sPtr, - const uint16 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -bool RefEqualArea32 (const uint32 *sPtr, - const uint32 *dPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sColStep, - int32 sPlaneStep, - int32 dRowStep, - int32 dColStep, - int32 dPlaneStep); - -/*****************************************************************************/ - -void RefVignetteMask16 (uint16 *mPtr, - uint32 rows, - uint32 cols, - int32 rowStep, - int64 offsetH, - int64 offsetV, - int64 stepH, - int64 stepV, - uint32 tBits, - const uint16 *table); - -/*****************************************************************************/ - -void RefVignette16 (int16 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits); - -/*****************************************************************************/ - -void RefVignette32 (real32 *sPtr, - const uint16 *mPtr, - uint32 rows, - uint32 cols, - uint32 planes, - int32 sRowStep, - int32 sPlaneStep, - int32 mRowStep, - uint32 mBits); - -/*****************************************************************************/ - -void RefMapArea16 (uint16 *dPtr, - uint32 count0, - uint32 count1, - uint32 count2, - int32 step0, - int32 step1, - int32 step2, - const uint16 *map); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_render.cpp b/third_party/dng_sdk/dng_render.cpp deleted file mode 100644 index 1751363..0000000 --- a/third_party/dng_sdk/dng_render.cpp +++ /dev/null @@ -1,1328 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_render.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_render.h" - -#include "dng_1d_table.h" -#include "dng_bottlenecks.h" -#include "dng_camera_profile.h" -#include "dng_color_space.h" -#include "dng_color_spec.h" -#include "dng_filter_task.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_negative.h" -#include "dng_resample.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_function_exposure_ramp::dng_function_exposure_ramp (real64 white, - real64 black, - real64 minBlack) - - : fSlope (1.0 / (white - black)) - , fBlack (black) - - , fRadius (0.0) - , fQScale (0.0) - - { - - const real64 kMaxCurveX = 0.5; // Fraction of minBlack. - - const real64 kMaxCurveY = 1.0 / 16.0; // Fraction of white. - - fRadius = Min_real64 (kMaxCurveX * minBlack, - kMaxCurveY / fSlope); - - if (fRadius > 0.0) - fQScale= fSlope / (4.0 * fRadius); - else - fQScale = 0.0; - - } - -/*****************************************************************************/ - -real64 dng_function_exposure_ramp::Evaluate (real64 x) const - { - - if (x <= fBlack - fRadius) - return 0.0; - - if (x >= fBlack + fRadius) - return Min_real64 ((x - fBlack) * fSlope, 1.0); - - real64 y = x - (fBlack - fRadius); - - return fQScale * y * y; - - } - -/*****************************************************************************/ - -dng_function_exposure_tone::dng_function_exposure_tone (real64 exposure) - - : fIsNOP (exposure >= 0.0) - - , fSlope (0.0) - - , a (0.0) - , b (0.0) - , c (0.0) - - { - - if (!fIsNOP) - { - - // Find slope to use for the all except the highest two f-stops. - - fSlope = pow (2.0, exposure); - - // Find quadradic parameters that match this darking at the crossover - // point, yet still map pure white to pure white. - - a = 16.0 / 9.0 * (1.0 - fSlope); - - b = fSlope - 0.5 * a; - - c = 1.0 - a - b; - - } - - } - -/*****************************************************************************/ - -real64 dng_function_exposure_tone::Evaluate (real64 x) const - { - - if (!fIsNOP) - { - - if (x <= 0.25) - x = x * fSlope; - - else - x = (a * x + b) * x + c; - - } - - return x; - - } - -/*****************************************************************************/ - -real64 dng_tone_curve_acr3_default::Evaluate (real64 x) const - { - - static const real32 kTable [] = - { - 0.00000f, 0.00078f, 0.00160f, 0.00242f, - 0.00314f, 0.00385f, 0.00460f, 0.00539f, - 0.00623f, 0.00712f, 0.00806f, 0.00906f, - 0.01012f, 0.01122f, 0.01238f, 0.01359f, - 0.01485f, 0.01616f, 0.01751f, 0.01890f, - 0.02033f, 0.02180f, 0.02331f, 0.02485f, - 0.02643f, 0.02804f, 0.02967f, 0.03134f, - 0.03303f, 0.03475f, 0.03648f, 0.03824f, - 0.04002f, 0.04181f, 0.04362f, 0.04545f, - 0.04730f, 0.04916f, 0.05103f, 0.05292f, - 0.05483f, 0.05675f, 0.05868f, 0.06063f, - 0.06259f, 0.06457f, 0.06655f, 0.06856f, - 0.07057f, 0.07259f, 0.07463f, 0.07668f, - 0.07874f, 0.08081f, 0.08290f, 0.08499f, - 0.08710f, 0.08921f, 0.09134f, 0.09348f, - 0.09563f, 0.09779f, 0.09996f, 0.10214f, - 0.10433f, 0.10652f, 0.10873f, 0.11095f, - 0.11318f, 0.11541f, 0.11766f, 0.11991f, - 0.12218f, 0.12445f, 0.12673f, 0.12902f, - 0.13132f, 0.13363f, 0.13595f, 0.13827f, - 0.14061f, 0.14295f, 0.14530f, 0.14765f, - 0.15002f, 0.15239f, 0.15477f, 0.15716f, - 0.15956f, 0.16197f, 0.16438f, 0.16680f, - 0.16923f, 0.17166f, 0.17410f, 0.17655f, - 0.17901f, 0.18148f, 0.18395f, 0.18643f, - 0.18891f, 0.19141f, 0.19391f, 0.19641f, - 0.19893f, 0.20145f, 0.20398f, 0.20651f, - 0.20905f, 0.21160f, 0.21416f, 0.21672f, - 0.21929f, 0.22185f, 0.22440f, 0.22696f, - 0.22950f, 0.23204f, 0.23458f, 0.23711f, - 0.23963f, 0.24215f, 0.24466f, 0.24717f, - 0.24967f, 0.25216f, 0.25465f, 0.25713f, - 0.25961f, 0.26208f, 0.26454f, 0.26700f, - 0.26945f, 0.27189f, 0.27433f, 0.27676f, - 0.27918f, 0.28160f, 0.28401f, 0.28641f, - 0.28881f, 0.29120f, 0.29358f, 0.29596f, - 0.29833f, 0.30069f, 0.30305f, 0.30540f, - 0.30774f, 0.31008f, 0.31241f, 0.31473f, - 0.31704f, 0.31935f, 0.32165f, 0.32395f, - 0.32623f, 0.32851f, 0.33079f, 0.33305f, - 0.33531f, 0.33756f, 0.33981f, 0.34205f, - 0.34428f, 0.34650f, 0.34872f, 0.35093f, - 0.35313f, 0.35532f, 0.35751f, 0.35969f, - 0.36187f, 0.36404f, 0.36620f, 0.36835f, - 0.37050f, 0.37264f, 0.37477f, 0.37689f, - 0.37901f, 0.38112f, 0.38323f, 0.38533f, - 0.38742f, 0.38950f, 0.39158f, 0.39365f, - 0.39571f, 0.39777f, 0.39982f, 0.40186f, - 0.40389f, 0.40592f, 0.40794f, 0.40996f, - 0.41197f, 0.41397f, 0.41596f, 0.41795f, - 0.41993f, 0.42191f, 0.42388f, 0.42584f, - 0.42779f, 0.42974f, 0.43168f, 0.43362f, - 0.43554f, 0.43747f, 0.43938f, 0.44129f, - 0.44319f, 0.44509f, 0.44698f, 0.44886f, - 0.45073f, 0.45260f, 0.45447f, 0.45632f, - 0.45817f, 0.46002f, 0.46186f, 0.46369f, - 0.46551f, 0.46733f, 0.46914f, 0.47095f, - 0.47275f, 0.47454f, 0.47633f, 0.47811f, - 0.47989f, 0.48166f, 0.48342f, 0.48518f, - 0.48693f, 0.48867f, 0.49041f, 0.49214f, - 0.49387f, 0.49559f, 0.49730f, 0.49901f, - 0.50072f, 0.50241f, 0.50410f, 0.50579f, - 0.50747f, 0.50914f, 0.51081f, 0.51247f, - 0.51413f, 0.51578f, 0.51742f, 0.51906f, - 0.52069f, 0.52232f, 0.52394f, 0.52556f, - 0.52717f, 0.52878f, 0.53038f, 0.53197f, - 0.53356f, 0.53514f, 0.53672f, 0.53829f, - 0.53986f, 0.54142f, 0.54297f, 0.54452f, - 0.54607f, 0.54761f, 0.54914f, 0.55067f, - 0.55220f, 0.55371f, 0.55523f, 0.55673f, - 0.55824f, 0.55973f, 0.56123f, 0.56271f, - 0.56420f, 0.56567f, 0.56715f, 0.56861f, - 0.57007f, 0.57153f, 0.57298f, 0.57443f, - 0.57587f, 0.57731f, 0.57874f, 0.58017f, - 0.58159f, 0.58301f, 0.58443f, 0.58583f, - 0.58724f, 0.58864f, 0.59003f, 0.59142f, - 0.59281f, 0.59419f, 0.59556f, 0.59694f, - 0.59830f, 0.59966f, 0.60102f, 0.60238f, - 0.60373f, 0.60507f, 0.60641f, 0.60775f, - 0.60908f, 0.61040f, 0.61173f, 0.61305f, - 0.61436f, 0.61567f, 0.61698f, 0.61828f, - 0.61957f, 0.62087f, 0.62216f, 0.62344f, - 0.62472f, 0.62600f, 0.62727f, 0.62854f, - 0.62980f, 0.63106f, 0.63232f, 0.63357f, - 0.63482f, 0.63606f, 0.63730f, 0.63854f, - 0.63977f, 0.64100f, 0.64222f, 0.64344f, - 0.64466f, 0.64587f, 0.64708f, 0.64829f, - 0.64949f, 0.65069f, 0.65188f, 0.65307f, - 0.65426f, 0.65544f, 0.65662f, 0.65779f, - 0.65897f, 0.66013f, 0.66130f, 0.66246f, - 0.66362f, 0.66477f, 0.66592f, 0.66707f, - 0.66821f, 0.66935f, 0.67048f, 0.67162f, - 0.67275f, 0.67387f, 0.67499f, 0.67611f, - 0.67723f, 0.67834f, 0.67945f, 0.68055f, - 0.68165f, 0.68275f, 0.68385f, 0.68494f, - 0.68603f, 0.68711f, 0.68819f, 0.68927f, - 0.69035f, 0.69142f, 0.69249f, 0.69355f, - 0.69461f, 0.69567f, 0.69673f, 0.69778f, - 0.69883f, 0.69988f, 0.70092f, 0.70196f, - 0.70300f, 0.70403f, 0.70506f, 0.70609f, - 0.70711f, 0.70813f, 0.70915f, 0.71017f, - 0.71118f, 0.71219f, 0.71319f, 0.71420f, - 0.71520f, 0.71620f, 0.71719f, 0.71818f, - 0.71917f, 0.72016f, 0.72114f, 0.72212f, - 0.72309f, 0.72407f, 0.72504f, 0.72601f, - 0.72697f, 0.72794f, 0.72890f, 0.72985f, - 0.73081f, 0.73176f, 0.73271f, 0.73365f, - 0.73460f, 0.73554f, 0.73647f, 0.73741f, - 0.73834f, 0.73927f, 0.74020f, 0.74112f, - 0.74204f, 0.74296f, 0.74388f, 0.74479f, - 0.74570f, 0.74661f, 0.74751f, 0.74842f, - 0.74932f, 0.75021f, 0.75111f, 0.75200f, - 0.75289f, 0.75378f, 0.75466f, 0.75555f, - 0.75643f, 0.75730f, 0.75818f, 0.75905f, - 0.75992f, 0.76079f, 0.76165f, 0.76251f, - 0.76337f, 0.76423f, 0.76508f, 0.76594f, - 0.76679f, 0.76763f, 0.76848f, 0.76932f, - 0.77016f, 0.77100f, 0.77183f, 0.77267f, - 0.77350f, 0.77432f, 0.77515f, 0.77597f, - 0.77680f, 0.77761f, 0.77843f, 0.77924f, - 0.78006f, 0.78087f, 0.78167f, 0.78248f, - 0.78328f, 0.78408f, 0.78488f, 0.78568f, - 0.78647f, 0.78726f, 0.78805f, 0.78884f, - 0.78962f, 0.79040f, 0.79118f, 0.79196f, - 0.79274f, 0.79351f, 0.79428f, 0.79505f, - 0.79582f, 0.79658f, 0.79735f, 0.79811f, - 0.79887f, 0.79962f, 0.80038f, 0.80113f, - 0.80188f, 0.80263f, 0.80337f, 0.80412f, - 0.80486f, 0.80560f, 0.80634f, 0.80707f, - 0.80780f, 0.80854f, 0.80926f, 0.80999f, - 0.81072f, 0.81144f, 0.81216f, 0.81288f, - 0.81360f, 0.81431f, 0.81503f, 0.81574f, - 0.81645f, 0.81715f, 0.81786f, 0.81856f, - 0.81926f, 0.81996f, 0.82066f, 0.82135f, - 0.82205f, 0.82274f, 0.82343f, 0.82412f, - 0.82480f, 0.82549f, 0.82617f, 0.82685f, - 0.82753f, 0.82820f, 0.82888f, 0.82955f, - 0.83022f, 0.83089f, 0.83155f, 0.83222f, - 0.83288f, 0.83354f, 0.83420f, 0.83486f, - 0.83552f, 0.83617f, 0.83682f, 0.83747f, - 0.83812f, 0.83877f, 0.83941f, 0.84005f, - 0.84069f, 0.84133f, 0.84197f, 0.84261f, - 0.84324f, 0.84387f, 0.84450f, 0.84513f, - 0.84576f, 0.84639f, 0.84701f, 0.84763f, - 0.84825f, 0.84887f, 0.84949f, 0.85010f, - 0.85071f, 0.85132f, 0.85193f, 0.85254f, - 0.85315f, 0.85375f, 0.85436f, 0.85496f, - 0.85556f, 0.85615f, 0.85675f, 0.85735f, - 0.85794f, 0.85853f, 0.85912f, 0.85971f, - 0.86029f, 0.86088f, 0.86146f, 0.86204f, - 0.86262f, 0.86320f, 0.86378f, 0.86435f, - 0.86493f, 0.86550f, 0.86607f, 0.86664f, - 0.86720f, 0.86777f, 0.86833f, 0.86889f, - 0.86945f, 0.87001f, 0.87057f, 0.87113f, - 0.87168f, 0.87223f, 0.87278f, 0.87333f, - 0.87388f, 0.87443f, 0.87497f, 0.87552f, - 0.87606f, 0.87660f, 0.87714f, 0.87768f, - 0.87821f, 0.87875f, 0.87928f, 0.87981f, - 0.88034f, 0.88087f, 0.88140f, 0.88192f, - 0.88244f, 0.88297f, 0.88349f, 0.88401f, - 0.88453f, 0.88504f, 0.88556f, 0.88607f, - 0.88658f, 0.88709f, 0.88760f, 0.88811f, - 0.88862f, 0.88912f, 0.88963f, 0.89013f, - 0.89063f, 0.89113f, 0.89163f, 0.89212f, - 0.89262f, 0.89311f, 0.89360f, 0.89409f, - 0.89458f, 0.89507f, 0.89556f, 0.89604f, - 0.89653f, 0.89701f, 0.89749f, 0.89797f, - 0.89845f, 0.89892f, 0.89940f, 0.89987f, - 0.90035f, 0.90082f, 0.90129f, 0.90176f, - 0.90222f, 0.90269f, 0.90316f, 0.90362f, - 0.90408f, 0.90454f, 0.90500f, 0.90546f, - 0.90592f, 0.90637f, 0.90683f, 0.90728f, - 0.90773f, 0.90818f, 0.90863f, 0.90908f, - 0.90952f, 0.90997f, 0.91041f, 0.91085f, - 0.91130f, 0.91173f, 0.91217f, 0.91261f, - 0.91305f, 0.91348f, 0.91392f, 0.91435f, - 0.91478f, 0.91521f, 0.91564f, 0.91606f, - 0.91649f, 0.91691f, 0.91734f, 0.91776f, - 0.91818f, 0.91860f, 0.91902f, 0.91944f, - 0.91985f, 0.92027f, 0.92068f, 0.92109f, - 0.92150f, 0.92191f, 0.92232f, 0.92273f, - 0.92314f, 0.92354f, 0.92395f, 0.92435f, - 0.92475f, 0.92515f, 0.92555f, 0.92595f, - 0.92634f, 0.92674f, 0.92713f, 0.92753f, - 0.92792f, 0.92831f, 0.92870f, 0.92909f, - 0.92947f, 0.92986f, 0.93025f, 0.93063f, - 0.93101f, 0.93139f, 0.93177f, 0.93215f, - 0.93253f, 0.93291f, 0.93328f, 0.93366f, - 0.93403f, 0.93440f, 0.93478f, 0.93515f, - 0.93551f, 0.93588f, 0.93625f, 0.93661f, - 0.93698f, 0.93734f, 0.93770f, 0.93807f, - 0.93843f, 0.93878f, 0.93914f, 0.93950f, - 0.93986f, 0.94021f, 0.94056f, 0.94092f, - 0.94127f, 0.94162f, 0.94197f, 0.94231f, - 0.94266f, 0.94301f, 0.94335f, 0.94369f, - 0.94404f, 0.94438f, 0.94472f, 0.94506f, - 0.94540f, 0.94573f, 0.94607f, 0.94641f, - 0.94674f, 0.94707f, 0.94740f, 0.94774f, - 0.94807f, 0.94839f, 0.94872f, 0.94905f, - 0.94937f, 0.94970f, 0.95002f, 0.95035f, - 0.95067f, 0.95099f, 0.95131f, 0.95163f, - 0.95194f, 0.95226f, 0.95257f, 0.95289f, - 0.95320f, 0.95351f, 0.95383f, 0.95414f, - 0.95445f, 0.95475f, 0.95506f, 0.95537f, - 0.95567f, 0.95598f, 0.95628f, 0.95658f, - 0.95688f, 0.95718f, 0.95748f, 0.95778f, - 0.95808f, 0.95838f, 0.95867f, 0.95897f, - 0.95926f, 0.95955f, 0.95984f, 0.96013f, - 0.96042f, 0.96071f, 0.96100f, 0.96129f, - 0.96157f, 0.96186f, 0.96214f, 0.96242f, - 0.96271f, 0.96299f, 0.96327f, 0.96355f, - 0.96382f, 0.96410f, 0.96438f, 0.96465f, - 0.96493f, 0.96520f, 0.96547f, 0.96574f, - 0.96602f, 0.96629f, 0.96655f, 0.96682f, - 0.96709f, 0.96735f, 0.96762f, 0.96788f, - 0.96815f, 0.96841f, 0.96867f, 0.96893f, - 0.96919f, 0.96945f, 0.96971f, 0.96996f, - 0.97022f, 0.97047f, 0.97073f, 0.97098f, - 0.97123f, 0.97149f, 0.97174f, 0.97199f, - 0.97223f, 0.97248f, 0.97273f, 0.97297f, - 0.97322f, 0.97346f, 0.97371f, 0.97395f, - 0.97419f, 0.97443f, 0.97467f, 0.97491f, - 0.97515f, 0.97539f, 0.97562f, 0.97586f, - 0.97609f, 0.97633f, 0.97656f, 0.97679f, - 0.97702f, 0.97725f, 0.97748f, 0.97771f, - 0.97794f, 0.97817f, 0.97839f, 0.97862f, - 0.97884f, 0.97907f, 0.97929f, 0.97951f, - 0.97973f, 0.97995f, 0.98017f, 0.98039f, - 0.98061f, 0.98082f, 0.98104f, 0.98125f, - 0.98147f, 0.98168f, 0.98189f, 0.98211f, - 0.98232f, 0.98253f, 0.98274f, 0.98295f, - 0.98315f, 0.98336f, 0.98357f, 0.98377f, - 0.98398f, 0.98418f, 0.98438f, 0.98458f, - 0.98478f, 0.98498f, 0.98518f, 0.98538f, - 0.98558f, 0.98578f, 0.98597f, 0.98617f, - 0.98636f, 0.98656f, 0.98675f, 0.98694f, - 0.98714f, 0.98733f, 0.98752f, 0.98771f, - 0.98789f, 0.98808f, 0.98827f, 0.98845f, - 0.98864f, 0.98882f, 0.98901f, 0.98919f, - 0.98937f, 0.98955f, 0.98973f, 0.98991f, - 0.99009f, 0.99027f, 0.99045f, 0.99063f, - 0.99080f, 0.99098f, 0.99115f, 0.99133f, - 0.99150f, 0.99167f, 0.99184f, 0.99201f, - 0.99218f, 0.99235f, 0.99252f, 0.99269f, - 0.99285f, 0.99302f, 0.99319f, 0.99335f, - 0.99351f, 0.99368f, 0.99384f, 0.99400f, - 0.99416f, 0.99432f, 0.99448f, 0.99464f, - 0.99480f, 0.99495f, 0.99511f, 0.99527f, - 0.99542f, 0.99558f, 0.99573f, 0.99588f, - 0.99603f, 0.99619f, 0.99634f, 0.99649f, - 0.99664f, 0.99678f, 0.99693f, 0.99708f, - 0.99722f, 0.99737f, 0.99751f, 0.99766f, - 0.99780f, 0.99794f, 0.99809f, 0.99823f, - 0.99837f, 0.99851f, 0.99865f, 0.99879f, - 0.99892f, 0.99906f, 0.99920f, 0.99933f, - 0.99947f, 0.99960f, 0.99974f, 0.99987f, - 1.00000f - }; - - const uint32 kTableSize = sizeof (kTable ) / - sizeof (kTable [0]); - - real32 y = (real32) x * (real32) (kTableSize - 1); - - int32 index = Pin_int32 (0, (int32) y, kTableSize - 2); - - real32 fract = y - (real32) index; - - return kTable [index ] * (1.0f - fract) + - kTable [index + 1] * ( fract); - - } - -/*****************************************************************************/ - -real64 dng_tone_curve_acr3_default::EvaluateInverse (real64 x) const - { - - static const real32 kTable [] = - { - 0.00000f, 0.00121f, 0.00237f, 0.00362f, - 0.00496f, 0.00621f, 0.00738f, 0.00848f, - 0.00951f, 0.01048f, 0.01139f, 0.01227f, - 0.01312f, 0.01393f, 0.01471f, 0.01547f, - 0.01620f, 0.01692f, 0.01763f, 0.01831f, - 0.01899f, 0.01965f, 0.02030f, 0.02094f, - 0.02157f, 0.02218f, 0.02280f, 0.02340f, - 0.02399f, 0.02458f, 0.02517f, 0.02574f, - 0.02631f, 0.02688f, 0.02744f, 0.02800f, - 0.02855f, 0.02910f, 0.02965f, 0.03019f, - 0.03072f, 0.03126f, 0.03179f, 0.03232f, - 0.03285f, 0.03338f, 0.03390f, 0.03442f, - 0.03493f, 0.03545f, 0.03596f, 0.03647f, - 0.03698f, 0.03749f, 0.03799f, 0.03849f, - 0.03899f, 0.03949f, 0.03998f, 0.04048f, - 0.04097f, 0.04146f, 0.04195f, 0.04244f, - 0.04292f, 0.04341f, 0.04389f, 0.04437f, - 0.04485f, 0.04533f, 0.04580f, 0.04628f, - 0.04675f, 0.04722f, 0.04769f, 0.04816f, - 0.04863f, 0.04910f, 0.04956f, 0.05003f, - 0.05049f, 0.05095f, 0.05141f, 0.05187f, - 0.05233f, 0.05278f, 0.05324f, 0.05370f, - 0.05415f, 0.05460f, 0.05505f, 0.05551f, - 0.05595f, 0.05640f, 0.05685f, 0.05729f, - 0.05774f, 0.05818f, 0.05863f, 0.05907f, - 0.05951f, 0.05995f, 0.06039f, 0.06083f, - 0.06126f, 0.06170f, 0.06214f, 0.06257f, - 0.06301f, 0.06344f, 0.06388f, 0.06431f, - 0.06474f, 0.06517f, 0.06560f, 0.06602f, - 0.06645f, 0.06688f, 0.06731f, 0.06773f, - 0.06815f, 0.06858f, 0.06900f, 0.06943f, - 0.06985f, 0.07027f, 0.07069f, 0.07111f, - 0.07152f, 0.07194f, 0.07236f, 0.07278f, - 0.07319f, 0.07361f, 0.07402f, 0.07444f, - 0.07485f, 0.07526f, 0.07567f, 0.07608f, - 0.07650f, 0.07691f, 0.07732f, 0.07772f, - 0.07813f, 0.07854f, 0.07895f, 0.07935f, - 0.07976f, 0.08016f, 0.08057f, 0.08098f, - 0.08138f, 0.08178f, 0.08218f, 0.08259f, - 0.08299f, 0.08339f, 0.08379f, 0.08419f, - 0.08459f, 0.08499f, 0.08539f, 0.08578f, - 0.08618f, 0.08657f, 0.08697f, 0.08737f, - 0.08776f, 0.08816f, 0.08855f, 0.08894f, - 0.08934f, 0.08973f, 0.09012f, 0.09051f, - 0.09091f, 0.09130f, 0.09169f, 0.09208f, - 0.09247f, 0.09286f, 0.09324f, 0.09363f, - 0.09402f, 0.09440f, 0.09479f, 0.09518f, - 0.09556f, 0.09595f, 0.09633f, 0.09672f, - 0.09710f, 0.09749f, 0.09787f, 0.09825f, - 0.09863f, 0.09901f, 0.09939f, 0.09978f, - 0.10016f, 0.10054f, 0.10092f, 0.10130f, - 0.10167f, 0.10205f, 0.10243f, 0.10281f, - 0.10319f, 0.10356f, 0.10394f, 0.10432f, - 0.10469f, 0.10507f, 0.10544f, 0.10582f, - 0.10619f, 0.10657f, 0.10694f, 0.10731f, - 0.10768f, 0.10806f, 0.10843f, 0.10880f, - 0.10917f, 0.10954f, 0.10991f, 0.11029f, - 0.11066f, 0.11103f, 0.11141f, 0.11178f, - 0.11215f, 0.11253f, 0.11290f, 0.11328f, - 0.11365f, 0.11403f, 0.11440f, 0.11478f, - 0.11516f, 0.11553f, 0.11591f, 0.11629f, - 0.11666f, 0.11704f, 0.11742f, 0.11780f, - 0.11818f, 0.11856f, 0.11894f, 0.11932f, - 0.11970f, 0.12008f, 0.12046f, 0.12084f, - 0.12122f, 0.12161f, 0.12199f, 0.12237f, - 0.12276f, 0.12314f, 0.12352f, 0.12391f, - 0.12429f, 0.12468f, 0.12506f, 0.12545f, - 0.12583f, 0.12622f, 0.12661f, 0.12700f, - 0.12738f, 0.12777f, 0.12816f, 0.12855f, - 0.12894f, 0.12933f, 0.12972f, 0.13011f, - 0.13050f, 0.13089f, 0.13129f, 0.13168f, - 0.13207f, 0.13247f, 0.13286f, 0.13325f, - 0.13365f, 0.13404f, 0.13444f, 0.13483f, - 0.13523f, 0.13563f, 0.13603f, 0.13642f, - 0.13682f, 0.13722f, 0.13762f, 0.13802f, - 0.13842f, 0.13882f, 0.13922f, 0.13962f, - 0.14003f, 0.14043f, 0.14083f, 0.14124f, - 0.14164f, 0.14204f, 0.14245f, 0.14285f, - 0.14326f, 0.14366f, 0.14407f, 0.14448f, - 0.14489f, 0.14530f, 0.14570f, 0.14611f, - 0.14652f, 0.14693f, 0.14734f, 0.14776f, - 0.14817f, 0.14858f, 0.14900f, 0.14941f, - 0.14982f, 0.15024f, 0.15065f, 0.15107f, - 0.15148f, 0.15190f, 0.15232f, 0.15274f, - 0.15316f, 0.15357f, 0.15399f, 0.15441f, - 0.15483f, 0.15526f, 0.15568f, 0.15610f, - 0.15652f, 0.15695f, 0.15737f, 0.15779f, - 0.15822f, 0.15864f, 0.15907f, 0.15950f, - 0.15992f, 0.16035f, 0.16078f, 0.16121f, - 0.16164f, 0.16207f, 0.16250f, 0.16293f, - 0.16337f, 0.16380f, 0.16423f, 0.16467f, - 0.16511f, 0.16554f, 0.16598f, 0.16641f, - 0.16685f, 0.16729f, 0.16773f, 0.16816f, - 0.16860f, 0.16904f, 0.16949f, 0.16993f, - 0.17037f, 0.17081f, 0.17126f, 0.17170f, - 0.17215f, 0.17259f, 0.17304f, 0.17349f, - 0.17393f, 0.17438f, 0.17483f, 0.17528f, - 0.17573f, 0.17619f, 0.17664f, 0.17709f, - 0.17754f, 0.17799f, 0.17845f, 0.17890f, - 0.17936f, 0.17982f, 0.18028f, 0.18073f, - 0.18119f, 0.18165f, 0.18211f, 0.18257f, - 0.18303f, 0.18350f, 0.18396f, 0.18442f, - 0.18489f, 0.18535f, 0.18582f, 0.18629f, - 0.18676f, 0.18723f, 0.18770f, 0.18817f, - 0.18864f, 0.18911f, 0.18958f, 0.19005f, - 0.19053f, 0.19100f, 0.19147f, 0.19195f, - 0.19243f, 0.19291f, 0.19339f, 0.19387f, - 0.19435f, 0.19483f, 0.19531f, 0.19579f, - 0.19627f, 0.19676f, 0.19724f, 0.19773f, - 0.19821f, 0.19870f, 0.19919f, 0.19968f, - 0.20017f, 0.20066f, 0.20115f, 0.20164f, - 0.20214f, 0.20263f, 0.20313f, 0.20362f, - 0.20412f, 0.20462f, 0.20512f, 0.20561f, - 0.20611f, 0.20662f, 0.20712f, 0.20762f, - 0.20812f, 0.20863f, 0.20913f, 0.20964f, - 0.21015f, 0.21066f, 0.21117f, 0.21168f, - 0.21219f, 0.21270f, 0.21321f, 0.21373f, - 0.21424f, 0.21476f, 0.21527f, 0.21579f, - 0.21631f, 0.21683f, 0.21735f, 0.21787f, - 0.21839f, 0.21892f, 0.21944f, 0.21997f, - 0.22049f, 0.22102f, 0.22155f, 0.22208f, - 0.22261f, 0.22314f, 0.22367f, 0.22420f, - 0.22474f, 0.22527f, 0.22581f, 0.22634f, - 0.22688f, 0.22742f, 0.22796f, 0.22850f, - 0.22905f, 0.22959f, 0.23013f, 0.23068f, - 0.23123f, 0.23178f, 0.23232f, 0.23287f, - 0.23343f, 0.23398f, 0.23453f, 0.23508f, - 0.23564f, 0.23620f, 0.23675f, 0.23731f, - 0.23787f, 0.23843f, 0.23899f, 0.23956f, - 0.24012f, 0.24069f, 0.24125f, 0.24182f, - 0.24239f, 0.24296f, 0.24353f, 0.24410f, - 0.24468f, 0.24525f, 0.24582f, 0.24640f, - 0.24698f, 0.24756f, 0.24814f, 0.24872f, - 0.24931f, 0.24989f, 0.25048f, 0.25106f, - 0.25165f, 0.25224f, 0.25283f, 0.25342f, - 0.25401f, 0.25460f, 0.25520f, 0.25579f, - 0.25639f, 0.25699f, 0.25759f, 0.25820f, - 0.25880f, 0.25940f, 0.26001f, 0.26062f, - 0.26122f, 0.26183f, 0.26244f, 0.26306f, - 0.26367f, 0.26429f, 0.26490f, 0.26552f, - 0.26614f, 0.26676f, 0.26738f, 0.26800f, - 0.26863f, 0.26925f, 0.26988f, 0.27051f, - 0.27114f, 0.27177f, 0.27240f, 0.27303f, - 0.27367f, 0.27431f, 0.27495f, 0.27558f, - 0.27623f, 0.27687f, 0.27751f, 0.27816f, - 0.27881f, 0.27945f, 0.28011f, 0.28076f, - 0.28141f, 0.28207f, 0.28272f, 0.28338f, - 0.28404f, 0.28470f, 0.28536f, 0.28602f, - 0.28669f, 0.28736f, 0.28802f, 0.28869f, - 0.28937f, 0.29004f, 0.29071f, 0.29139f, - 0.29207f, 0.29274f, 0.29342f, 0.29410f, - 0.29479f, 0.29548f, 0.29616f, 0.29685f, - 0.29754f, 0.29823f, 0.29893f, 0.29962f, - 0.30032f, 0.30102f, 0.30172f, 0.30242f, - 0.30312f, 0.30383f, 0.30453f, 0.30524f, - 0.30595f, 0.30667f, 0.30738f, 0.30809f, - 0.30881f, 0.30953f, 0.31025f, 0.31097f, - 0.31170f, 0.31242f, 0.31315f, 0.31388f, - 0.31461f, 0.31534f, 0.31608f, 0.31682f, - 0.31755f, 0.31829f, 0.31904f, 0.31978f, - 0.32053f, 0.32127f, 0.32202f, 0.32277f, - 0.32353f, 0.32428f, 0.32504f, 0.32580f, - 0.32656f, 0.32732f, 0.32808f, 0.32885f, - 0.32962f, 0.33039f, 0.33116f, 0.33193f, - 0.33271f, 0.33349f, 0.33427f, 0.33505f, - 0.33583f, 0.33662f, 0.33741f, 0.33820f, - 0.33899f, 0.33978f, 0.34058f, 0.34138f, - 0.34218f, 0.34298f, 0.34378f, 0.34459f, - 0.34540f, 0.34621f, 0.34702f, 0.34783f, - 0.34865f, 0.34947f, 0.35029f, 0.35111f, - 0.35194f, 0.35277f, 0.35360f, 0.35443f, - 0.35526f, 0.35610f, 0.35694f, 0.35778f, - 0.35862f, 0.35946f, 0.36032f, 0.36117f, - 0.36202f, 0.36287f, 0.36372f, 0.36458f, - 0.36545f, 0.36631f, 0.36718f, 0.36805f, - 0.36891f, 0.36979f, 0.37066f, 0.37154f, - 0.37242f, 0.37331f, 0.37419f, 0.37507f, - 0.37596f, 0.37686f, 0.37775f, 0.37865f, - 0.37955f, 0.38045f, 0.38136f, 0.38227f, - 0.38317f, 0.38409f, 0.38500f, 0.38592f, - 0.38684f, 0.38776f, 0.38869f, 0.38961f, - 0.39055f, 0.39148f, 0.39242f, 0.39335f, - 0.39430f, 0.39524f, 0.39619f, 0.39714f, - 0.39809f, 0.39904f, 0.40000f, 0.40097f, - 0.40193f, 0.40289f, 0.40386f, 0.40483f, - 0.40581f, 0.40679f, 0.40777f, 0.40875f, - 0.40974f, 0.41073f, 0.41172f, 0.41272f, - 0.41372f, 0.41472f, 0.41572f, 0.41673f, - 0.41774f, 0.41875f, 0.41977f, 0.42079f, - 0.42181f, 0.42284f, 0.42386f, 0.42490f, - 0.42594f, 0.42697f, 0.42801f, 0.42906f, - 0.43011f, 0.43116f, 0.43222f, 0.43327f, - 0.43434f, 0.43540f, 0.43647f, 0.43754f, - 0.43862f, 0.43970f, 0.44077f, 0.44186f, - 0.44295f, 0.44404f, 0.44514f, 0.44624f, - 0.44734f, 0.44845f, 0.44956f, 0.45068f, - 0.45179f, 0.45291f, 0.45404f, 0.45516f, - 0.45630f, 0.45744f, 0.45858f, 0.45972f, - 0.46086f, 0.46202f, 0.46318f, 0.46433f, - 0.46550f, 0.46667f, 0.46784f, 0.46901f, - 0.47019f, 0.47137f, 0.47256f, 0.47375f, - 0.47495f, 0.47615f, 0.47735f, 0.47856f, - 0.47977f, 0.48099f, 0.48222f, 0.48344f, - 0.48467f, 0.48590f, 0.48714f, 0.48838f, - 0.48963f, 0.49088f, 0.49213f, 0.49340f, - 0.49466f, 0.49593f, 0.49721f, 0.49849f, - 0.49977f, 0.50106f, 0.50236f, 0.50366f, - 0.50496f, 0.50627f, 0.50758f, 0.50890f, - 0.51023f, 0.51155f, 0.51289f, 0.51422f, - 0.51556f, 0.51692f, 0.51827f, 0.51964f, - 0.52100f, 0.52237f, 0.52374f, 0.52512f, - 0.52651f, 0.52790f, 0.52930f, 0.53070f, - 0.53212f, 0.53353f, 0.53495f, 0.53638f, - 0.53781f, 0.53925f, 0.54070f, 0.54214f, - 0.54360f, 0.54506f, 0.54653f, 0.54800f, - 0.54949f, 0.55098f, 0.55247f, 0.55396f, - 0.55548f, 0.55699f, 0.55851f, 0.56003f, - 0.56156f, 0.56310f, 0.56464f, 0.56621f, - 0.56777f, 0.56933f, 0.57091f, 0.57248f, - 0.57407f, 0.57568f, 0.57727f, 0.57888f, - 0.58050f, 0.58213f, 0.58376f, 0.58541f, - 0.58705f, 0.58871f, 0.59037f, 0.59204f, - 0.59373f, 0.59541f, 0.59712f, 0.59882f, - 0.60052f, 0.60226f, 0.60399f, 0.60572f, - 0.60748f, 0.60922f, 0.61099f, 0.61276f, - 0.61455f, 0.61635f, 0.61814f, 0.61996f, - 0.62178f, 0.62361f, 0.62545f, 0.62730f, - 0.62917f, 0.63104f, 0.63291f, 0.63480f, - 0.63671f, 0.63862f, 0.64054f, 0.64249f, - 0.64443f, 0.64638f, 0.64835f, 0.65033f, - 0.65232f, 0.65433f, 0.65633f, 0.65836f, - 0.66041f, 0.66245f, 0.66452f, 0.66660f, - 0.66868f, 0.67078f, 0.67290f, 0.67503f, - 0.67717f, 0.67932f, 0.68151f, 0.68368f, - 0.68587f, 0.68809f, 0.69033f, 0.69257f, - 0.69482f, 0.69709f, 0.69939f, 0.70169f, - 0.70402f, 0.70634f, 0.70869f, 0.71107f, - 0.71346f, 0.71587f, 0.71829f, 0.72073f, - 0.72320f, 0.72567f, 0.72818f, 0.73069f, - 0.73323f, 0.73579f, 0.73838f, 0.74098f, - 0.74360f, 0.74622f, 0.74890f, 0.75159f, - 0.75429f, 0.75704f, 0.75979f, 0.76257f, - 0.76537f, 0.76821f, 0.77109f, 0.77396f, - 0.77688f, 0.77982f, 0.78278f, 0.78579f, - 0.78883f, 0.79187f, 0.79498f, 0.79809f, - 0.80127f, 0.80445f, 0.80767f, 0.81095f, - 0.81424f, 0.81757f, 0.82094f, 0.82438f, - 0.82782f, 0.83133f, 0.83488f, 0.83847f, - 0.84210f, 0.84577f, 0.84951f, 0.85328f, - 0.85713f, 0.86103f, 0.86499f, 0.86900f, - 0.87306f, 0.87720f, 0.88139f, 0.88566f, - 0.89000f, 0.89442f, 0.89891f, 0.90350f, - 0.90818f, 0.91295f, 0.91780f, 0.92272f, - 0.92780f, 0.93299f, 0.93828f, 0.94369f, - 0.94926f, 0.95493f, 0.96082f, 0.96684f, - 0.97305f, 0.97943f, 0.98605f, 0.99291f, - 1.00000f - }; - - const uint32 kTableSize = sizeof (kTable ) / - sizeof (kTable [0]); - - real32 y = (real32) x * (real32) (kTableSize - 1); - - int32 index = Pin_int32 (0, (int32) y, kTableSize - 2); - - real32 fract = y - (real32) index; - - return kTable [index ] * (1.0f - fract) + - kTable [index + 1] * ( fract); - - } - -/*****************************************************************************/ - -const dng_1d_function & dng_tone_curve_acr3_default::Get () - { - - static dng_tone_curve_acr3_default static_dng_tone_curve_acr3_default; - - return static_dng_tone_curve_acr3_default; - - } - -/*****************************************************************************/ - -class dng_render_task: public dng_filter_task - { - - protected: - - const dng_negative &fNegative; - - const dng_render &fParams; - - dng_point fSrcOffset; - - dng_vector fCameraWhite; - dng_matrix fCameraToRGB; - - AutoPtr fHueSatMap; - - dng_1d_table fExposureRamp; - - AutoPtr fLookTable; - - dng_1d_table fToneCurve; - - dng_matrix fRGBtoFinal; - - dng_1d_table fEncodeGamma; - - AutoPtr fHueSatMapEncode; - AutoPtr fHueSatMapDecode; - - AutoPtr fLookTableEncode; - AutoPtr fLookTableDecode; - - AutoPtr fTempBuffer [kMaxMPThreads]; - - public: - - dng_render_task (const dng_image &srcImage, - dng_image &dstImage, - const dng_negative &negative, - const dng_render ¶ms, - const dng_point &srcOffset); - - virtual dng_rect SrcArea (const dng_rect &dstArea); - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer); - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer); - - }; - -/*****************************************************************************/ - -dng_render_task::dng_render_task (const dng_image &srcImage, - dng_image &dstImage, - const dng_negative &negative, - const dng_render ¶ms, - const dng_point &srcOffset) - - : dng_filter_task (srcImage, - dstImage) - - , fNegative (negative ) - , fParams (params ) - , fSrcOffset (srcOffset) - - , fCameraWhite () - , fCameraToRGB () - - , fHueSatMap () - - , fExposureRamp () - - , fLookTable () - - , fToneCurve () - - , fRGBtoFinal () - - , fEncodeGamma () - - , fHueSatMapEncode () - , fHueSatMapDecode () - - , fLookTableEncode () - , fLookTableDecode () - - { - - fSrcPixelType = ttFloat; - fDstPixelType = ttFloat; - - } - -/*****************************************************************************/ - -dng_rect dng_render_task::SrcArea (const dng_rect &dstArea) - { - - return dstArea + fSrcOffset; - - } - -/*****************************************************************************/ - -void dng_render_task::Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer) - { - - dng_filter_task::Start (threadCount, - tileSize, - allocator, - sniffer); - - // Compute camera space to linear ProPhoto RGB parameters. - - dng_camera_profile_id profileID; // Default profile ID. - - if (!fNegative.IsMonochrome ()) - { - - AutoPtr spec (fNegative.MakeColorSpec (profileID)); - - if (fParams.WhiteXY ().IsValid ()) - { - - spec->SetWhiteXY (fParams.WhiteXY ()); - - } - - else if (fNegative.HasCameraNeutral ()) - { - - spec->SetWhiteXY (spec->NeutralToXY (fNegative.CameraNeutral ())); - - } - - else if (fNegative.HasCameraWhiteXY ()) - { - - spec->SetWhiteXY (fNegative.CameraWhiteXY ()); - - } - - else - { - - spec->SetWhiteXY (D55_xy_coord ()); - - } - - fCameraWhite = spec->CameraWhite (); - - fCameraToRGB = dng_space_ProPhoto::Get ().MatrixFromPCS () * - spec->CameraToPCS (); - - // Find Hue/Sat table, if any. - - const dng_camera_profile *profile = fNegative.ProfileByID (profileID); - - if (profile) - { - - fHueSatMap.Reset (profile->HueSatMapForWhite (spec->WhiteXY ())); - - if (profile->HasLookTable ()) - { - - fLookTable.Reset (new dng_hue_sat_map (profile->LookTable ())); - - } - - if (profile->HueSatMapEncoding () != encoding_Linear) - { - - BuildHueSatMapEncodingTable (*allocator, - profile->HueSatMapEncoding (), - fHueSatMapEncode, - fHueSatMapDecode, - false); - - } - - if (profile->LookTableEncoding () != encoding_Linear) - { - - BuildHueSatMapEncodingTable (*allocator, - profile->LookTableEncoding (), - fLookTableEncode, - fLookTableDecode, - false); - - } - - } - - } - - // Compute exposure/shadows ramp. - - real64 exposure = fParams.Exposure () + - fNegative.TotalBaselineExposure (profileID) - - (log (fNegative.Stage3Gain ()) / log (2.0)); - - { - - real64 white = 1.0 / pow (2.0, Max_real64 (0.0, exposure)); - - real64 black = fParams.Shadows () * - fNegative.ShadowScale () * - fNegative.Stage3Gain () * - 0.001; - - black = Min_real64 (black, 0.99 * white); - - dng_function_exposure_ramp rampFunction (white, - black, - black); - - fExposureRamp.Initialize (*allocator, rampFunction); - - } - - // Compute tone curve. - - { - - // If there is any negative exposure compenation to perform - // (beyond what the camera provides for with its baseline exposure), - // we fake this by darkening the tone curve. - - dng_function_exposure_tone exposureTone (exposure); - - dng_1d_concatenate totalTone (exposureTone, - fParams.ToneCurve ()); - - fToneCurve.Initialize (*allocator, totalTone); - - } - - // Compute linear ProPhoto RGB to final space parameters. - - { - - const dng_color_space &finalSpace = fParams.FinalSpace (); - - fRGBtoFinal = finalSpace.MatrixFromPCS () * - dng_space_ProPhoto::Get ().MatrixToPCS (); - - fEncodeGamma.Initialize (*allocator, finalSpace.GammaFunction ()); - - } - - // Allocate temp buffer to hold one row of RGB data. - - uint32 tempBufferSize = tileSize.h * (uint32) sizeof (real32) * 3; - - for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) - { - - fTempBuffer [threadIndex] . Reset (allocator->Allocate (tempBufferSize)); - - } - - } - -/*****************************************************************************/ - -void dng_render_task::ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - dng_rect srcArea = srcBuffer.fArea; - dng_rect dstArea = dstBuffer.fArea; - - uint32 srcCols = srcArea.W (); - - real32 *tPtrR = fTempBuffer [threadIndex]->Buffer_real32 (); - - real32 *tPtrG = tPtrR + srcCols; - real32 *tPtrB = tPtrG + srcCols; - - for (int32 srcRow = srcArea.t; srcRow < srcArea.b; srcRow++) - { - - // First convert from camera native space to linear PhotoRGB, - // applying the white balance and camera profile. - - { - - const real32 *sPtrA = (const real32 *) - srcBuffer.ConstPixel (srcRow, - srcArea.l, - 0); - - if (fSrcPlanes == 1) - { - - // For monochrome cameras, this just requires copying - // the data into all three color channels. - - DoCopyBytes (sPtrA, tPtrR, srcCols * (uint32) sizeof (real32)); - DoCopyBytes (sPtrA, tPtrG, srcCols * (uint32) sizeof (real32)); - DoCopyBytes (sPtrA, tPtrB, srcCols * (uint32) sizeof (real32)); - - } - - else - { - - const real32 *sPtrB = sPtrA + srcBuffer.fPlaneStep; - const real32 *sPtrC = sPtrB + srcBuffer.fPlaneStep; - - if (fSrcPlanes == 3) - { - - DoBaselineABCtoRGB (sPtrA, - sPtrB, - sPtrC, - tPtrR, - tPtrG, - tPtrB, - srcCols, - fCameraWhite, - fCameraToRGB); - - } - - else - { - - const real32 *sPtrD = sPtrC + srcBuffer.fPlaneStep; - - DoBaselineABCDtoRGB (sPtrA, - sPtrB, - sPtrC, - sPtrD, - tPtrR, - tPtrG, - tPtrB, - srcCols, - fCameraWhite, - fCameraToRGB); - - } - - // Apply Hue/Sat map, if any. - - if (fHueSatMap.Get ()) - { - - DoBaselineHueSatMap (tPtrR, - tPtrG, - tPtrB, - tPtrR, - tPtrG, - tPtrB, - srcCols, - *fHueSatMap.Get (), - fHueSatMapEncode.Get (), - fHueSatMapDecode.Get ()); - - } - - } - - } - - // Apply exposure curve. - - DoBaseline1DTable (tPtrR, - tPtrR, - srcCols, - fExposureRamp); - - DoBaseline1DTable (tPtrG, - tPtrG, - srcCols, - fExposureRamp); - - DoBaseline1DTable (tPtrB, - tPtrB, - srcCols, - fExposureRamp); - - // Apply look table, if any. - - if (fLookTable.Get ()) - { - - DoBaselineHueSatMap (tPtrR, - tPtrG, - tPtrB, - tPtrR, - tPtrG, - tPtrB, - srcCols, - *fLookTable.Get (), - fLookTableEncode.Get (), - fLookTableDecode.Get ()); - - } - - // Apply baseline tone curve. - - DoBaselineRGBTone (tPtrR, - tPtrG, - tPtrB, - tPtrR, - tPtrG, - tPtrB, - srcCols, - fToneCurve); - - // Convert to final color space. - - int32 dstRow = srcRow + (dstArea.t - srcArea.t); - - if (fDstPlanes == 1) - { - - real32 *dPtrG = dstBuffer.DirtyPixel_real32 (dstRow, - dstArea.l, - 0); - - DoBaselineRGBtoGray (tPtrR, - tPtrG, - tPtrB, - dPtrG, - srcCols, - fRGBtoFinal); - - DoBaseline1DTable (dPtrG, - dPtrG, - srcCols, - fEncodeGamma); - - } - - else - { - - real32 *dPtrR = dstBuffer.DirtyPixel_real32 (dstRow, - dstArea.l, - 0); - - real32 *dPtrG = dPtrR + dstBuffer.fPlaneStep; - real32 *dPtrB = dPtrG + dstBuffer.fPlaneStep; - - DoBaselineRGBtoRGB (tPtrR, - tPtrG, - tPtrB, - dPtrR, - dPtrG, - dPtrB, - srcCols, - fRGBtoFinal); - - DoBaseline1DTable (dPtrR, - dPtrR, - srcCols, - fEncodeGamma); - - DoBaseline1DTable (dPtrG, - dPtrG, - srcCols, - fEncodeGamma); - - DoBaseline1DTable (dPtrB, - dPtrB, - srcCols, - fEncodeGamma); - - } - - } - - } - -/*****************************************************************************/ - -dng_render::dng_render (dng_host &host, - const dng_negative &negative) - - : fHost (host) - , fNegative (negative) - - , fWhiteXY () - - , fExposure (0.0) - , fShadows (5.0) - - , fToneCurve (&dng_tone_curve_acr3_default::Get ()) - - , fFinalSpace (&dng_space_sRGB::Get ()) - , fFinalPixelType (ttByte) - - , fMaximumSize (0) - - , fProfileToneCurve () - - { - - // Switch to NOP default parameters for non-scene referred data. - - if (fNegative.ColorimetricReference () != crSceneReferred) - { - - fShadows = 0.0; - - fToneCurve = &dng_1d_identity::Get (); - - } - - // Use default tone curve from profile if any. - - const dng_camera_profile *profile = fNegative.ProfileByID (dng_camera_profile_id ()); - - if (profile && profile->ToneCurve ().IsValid ()) - { - - fProfileToneCurve.Reset (new dng_spline_solver); - - profile->ToneCurve ().Solve (*fProfileToneCurve.Get ()); - - fToneCurve = fProfileToneCurve.Get (); - - } - - // Turn off default shadow mapping if requested by profile. - - if (profile && (profile->DefaultBlackRender () == defaultBlackRender_None)) - { - - fShadows = 0.0; - - } - - } - -/*****************************************************************************/ - -dng_image * dng_render::Render () - { - - const dng_image *srcImage = fNegative.Stage3Image (); - - dng_rect srcBounds = fNegative.DefaultCropArea (); - - dng_point dstSize; - - dstSize.h = fNegative.DefaultFinalWidth (); - dstSize.v = fNegative.DefaultFinalHeight (); - - if (MaximumSize ()) - { - - if (Max_uint32 (dstSize.h, dstSize.v) > MaximumSize ()) - { - - real64 ratio = fNegative.AspectRatio (); - - if (ratio >= 1.0) - { - dstSize.h = MaximumSize (); - dstSize.v = Max_uint32 (1, Round_uint32 (dstSize.h / ratio)); - } - - else - { - dstSize.v = MaximumSize (); - dstSize.h = Max_uint32 (1, Round_uint32 (dstSize.v * ratio)); - } - - } - - } - - AutoPtr tempImage; - - if (srcBounds.Size () != dstSize) - { - - tempImage.Reset (fHost.Make_dng_image (dstSize, - srcImage->Planes (), - srcImage->PixelType ())); - - ResampleImage (fHost, - *srcImage, - *tempImage.Get (), - srcBounds, - tempImage->Bounds (), - dng_resample_bicubic::Get ()); - - srcImage = tempImage.Get (); - - srcBounds = tempImage->Bounds (); - - } - - uint32 dstPlanes = FinalSpace ().IsMonochrome () ? 1 : 3; - - AutoPtr dstImage (fHost.Make_dng_image (srcBounds.Size (), - dstPlanes, - FinalPixelType ())); - - dng_render_task task (*srcImage, - *dstImage.Get (), - fNegative, - *this, - srcBounds.TL ()); - - fHost.PerformAreaTask (task, - dstImage->Bounds ()); - - return dstImage.Release (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_render.h b/third_party/dng_sdk/dng_render.h deleted file mode 100644 index 4c9aec7..0000000 --- a/third_party/dng_sdk/dng_render.h +++ /dev/null @@ -1,312 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_render.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Classes for conversion of RAW data to final image. - */ - -/*****************************************************************************/ - -#ifndef __dng_render__ -#define __dng_render__ - -/*****************************************************************************/ - -#include "dng_1d_function.h" -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_spline.h" -#include "dng_xy_coord.h" - -/******************************************************************************/ - -/// \brief Curve for pre-exposure-compensation adjustment based on noise floor, -/// shadows, and highlight level. - -class dng_function_exposure_ramp: public dng_1d_function - { - - public: - - real64 fSlope; // Slope of straight segment. - - real64 fBlack; // Intercept of straight segment. - - real64 fRadius; // Rounding radius. - - real64 fQScale; // Quadradic scale. - - public: - - dng_function_exposure_ramp (real64 white, - real64 black, - real64 minBlack); - - virtual real64 Evaluate (real64 x) const; - - }; - -/******************************************************************************/ - -/// \brief Exposure compensation curve for a given compensation amount in stops using -/// quadric for roll-off. - -class dng_function_exposure_tone: public dng_1d_function - { - - protected: - - bool fIsNOP; // Is this a NOP function? - - real64 fSlope; // Slope for lower part of curve. - - real64 a; // Quadradic parameters for upper two f-stops. - real64 b; - real64 c; - - public: - - dng_function_exposure_tone (real64 exposure); - - /// Returns output value for a given input tone. - - virtual real64 Evaluate (real64 x) const; - - }; - -/*****************************************************************************/ - -/// Default ACR3 tone curve. - -class dng_tone_curve_acr3_default: public dng_1d_function - { - - public: - - /// Returns output value for a given input tone. - - virtual real64 Evaluate (real64 x) const; - - /// Returns nearest input value for a given output tone. - - virtual real64 EvaluateInverse (real64 x) const; - - static const dng_1d_function & Get (); - - }; - -/*****************************************************************************/ - -/// \brief Encoding gamma curve for a given color space. - -class dng_function_gamma_encode: public dng_1d_function - { - - protected: - - const dng_color_space &fSpace; - - public: - - dng_function_gamma_encode (const dng_color_space &space); - - virtual real64 Evaluate (real64 x) const; - - }; - -/*****************************************************************************/ - -/// \brief Class used to render digital negative to displayable image. - -class dng_render - { - - protected: - - dng_host &fHost; - - const dng_negative &fNegative; - - dng_xy_coord fWhiteXY; - - real64 fExposure; - - real64 fShadows; - - const dng_1d_function *fToneCurve; - - const dng_color_space *fFinalSpace; - - uint32 fFinalPixelType; - - uint32 fMaximumSize; - - private: - - AutoPtr fProfileToneCurve; - - public: - - /// Construct a rendering instance that will be used to convert a given digital negative. - /// \param host The host to use for memory allocation, progress updates, and abort testing. - /// \param negative The digital negative to convert to a displayable image. - - dng_render (dng_host &host, - const dng_negative &negative); - - virtual ~dng_render () - { - } - - /// Set the white point to be used for conversion. - /// \param white White point to use. - - void SetWhiteXY (const dng_xy_coord &white) - { - fWhiteXY = white; - } - - /// Get the white point to be used for conversion. - /// \retval White point to use. - - const dng_xy_coord WhiteXY () const - { - return fWhiteXY; - } - - /// Set exposure compensation. - /// \param exposure Compensation value in stops, positive or negative. - - void SetExposure (real64 exposure) - { - fExposure = exposure; - } - - /// Get exposure compensation. - /// \retval Compensation value in stops, positive or negative. - - real64 Exposure () const - { - return fExposure; - } - - /// Set shadow clip amount. - /// \param shadows Shadow clip amount. - - void SetShadows (real64 shadows) - { - fShadows = shadows; - } - - /// Get shadow clip amount. - /// \retval Shadow clip amount. - - real64 Shadows () const - { - return fShadows; - } - - /// Set custom tone curve for conversion. - /// \param curve 1D function that defines tone mapping to use during conversion. - - void SetToneCurve (const dng_1d_function &curve) - { - fToneCurve = &curve; - } - - /// Get custom tone curve for conversion. - /// \retval 1D function that defines tone mapping to use during conversion. - - const dng_1d_function & ToneCurve () const - { - return *fToneCurve; - } - - /// Set final color space in which resulting image data should be represented. - /// (See dng_color_space.h for possible values.) - /// \param space Color space to use. - - void SetFinalSpace (const dng_color_space &space) - { - fFinalSpace = &space; - } - - /// Get final color space in which resulting image data should be represented. - /// \retval Color space to use. - - const dng_color_space & FinalSpace () const - { - return *fFinalSpace; - } - - /// Set pixel type of final image data. - /// Can be ttByte (default), ttShort, or ttFloat. - /// \param type Pixel type to use. - - void SetFinalPixelType (uint32 type) - { - fFinalPixelType = type; - } - - /// Get pixel type of final image data. - /// Can be ttByte (default), ttShort, or ttFloat. - /// \retval Pixel type to use. - - uint32 FinalPixelType () const - { - return fFinalPixelType; - } - - /// Set maximum dimension, in pixels, of resulting image. - /// If final image would have either dimension larger than maximum, the larger - /// of the two dimensions is set to this maximum size and the smaller dimension - /// is adjusted to preserve aspect ratio. - /// \param size Maximum size to allow. - - void SetMaximumSize (uint32 size) - { - fMaximumSize = size; - } - - /// Get maximum dimension, in pixels, of resulting image. - /// If the final image would have either dimension larger than this maximum, the larger - /// of the two dimensions is set to this maximum size and the smaller dimension - /// is adjusted to preserve the image's aspect ratio. - /// \retval Maximum allowed size. - - uint32 MaximumSize () const - { - return fMaximumSize; - } - - /// Actually render a digital negative to a displayable image. - /// Input digital negative is passed to the constructor of this dng_render class. - /// \retval The final resulting image. - - virtual dng_image * Render (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_render (const dng_render &render); - - dng_render & operator= (const dng_render &render); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_resample.cpp b/third_party/dng_sdk/dng_resample.cpp deleted file mode 100644 index 5a06465..0000000 --- a/third_party/dng_sdk/dng_resample.cpp +++ /dev/null @@ -1,781 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_resample.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_resample.h" - -#include "dng_assertions.h" -#include "dng_bottlenecks.h" -#include "dng_filter_task.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_memory.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_utils.h" - -/******************************************************************************/ - -real64 dng_resample_bicubic::Extent () const - { - - return 2.0; - - } - -/******************************************************************************/ - -real64 dng_resample_bicubic::Evaluate (real64 x) const - { - - const real64 A = -0.75; - - x = Abs_real64 (x); - - if (x >= 2.0) - return 0.0; - - else if (x >= 1.0) - return (((A * x - 5.0 * A) * x + 8.0 * A) * x - 4.0 * A); - - else - return (((A + 2.0) * x - (A + 3.0)) * x * x + 1.0); - - } - -/******************************************************************************/ - -const dng_resample_function & dng_resample_bicubic::Get () - { - - static dng_resample_bicubic static_dng_resample_bicubic; - - return static_dng_resample_bicubic; - - } - -/*****************************************************************************/ - -dng_resample_coords::dng_resample_coords () - - : fOrigin (0) - , fCoords () - - { - - } - -/*****************************************************************************/ - -dng_resample_coords::~dng_resample_coords () - { - - } - -/*****************************************************************************/ - -void dng_resample_coords::Initialize (int32 srcOrigin, - int32 dstOrigin, - uint32 srcCount, - uint32 dstCount, - dng_memory_allocator &allocator) - { - - fOrigin = dstOrigin; - - uint32 dstEntries = RoundUp8 (dstCount); - - fCoords.Reset (allocator.Allocate (dstEntries * (uint32) sizeof (int32))); - - int32 *coords = fCoords->Buffer_int32 (); - - real64 invScale = (real64) srcCount / - (real64) dstCount; - - for (uint32 j = 0; j < dstCount; j++) - { - - real64 x = (real64) j + 0.5; - - real64 y = x * invScale - 0.5 + (real64) srcOrigin; - - coords [j] = Round_int32 (y * (real64) kResampleSubsampleCount); - - } - - // Pad out table by replicating last entry. - - for (uint32 k = dstCount; k < dstEntries; k++) - { - - coords [k] = coords [dstCount - 1]; - - } - - } - -/*****************************************************************************/ - -dng_resample_weights::dng_resample_weights () - - : fRadius (0) - - , fWeightStep (0) - - , fWeights32 () - , fWeights16 () - - { - - } - -/*****************************************************************************/ - -dng_resample_weights::~dng_resample_weights () - { - - } - -/*****************************************************************************/ - -void dng_resample_weights::Initialize (real64 scale, - const dng_resample_function &kernel, - dng_memory_allocator &allocator) - { - - uint32 j; - - // We only adjust the kernel size for scale factors less than 1.0. - - scale = Min_real64 (scale, 1.0); - - // Find radius of this kernel. - - fRadius = (uint32) (kernel.Extent () / scale + 0.9999); - - // Width is twice the radius. - - uint32 width = fRadius * 2; - - // Round to each set to weights to a multiple of 8 entries. - - fWeightStep = RoundUp8 (width); - - // Allocate and zero weight tables. - - fWeights32.Reset (allocator.Allocate (fWeightStep * - kResampleSubsampleCount * - (uint32) sizeof (real32))); - - DoZeroBytes (fWeights32->Buffer (), - fWeights32->LogicalSize ()); - - fWeights16.Reset (allocator.Allocate (fWeightStep * - kResampleSubsampleCount * - (uint32) sizeof (int16))); - - DoZeroBytes (fWeights16->Buffer (), - fWeights16->LogicalSize ()); - - // Compute kernel for each subsample values. - - for (uint32 sample = 0; sample < kResampleSubsampleCount; sample++) - { - - real64 fract = sample * (1.0 / (real64) kResampleSubsampleCount); - - real32 *w32 = fWeights32->Buffer_real32 () + fWeightStep * sample; - - // Evaluate kernel function for 32 bit weights. - - { - - real64 t32 = 0.0; - - for (j = 0; j < width; j++) - { - - int32 k = j - fRadius + 1; - - real64 x = (k - fract) * scale; - - w32 [j] = (real32) kernel.Evaluate (x); - - t32 += w32 [j]; - - } - - // Scale 32 bit weights so total of weights is 1.0. - - real32 s32 = (real32) (1.0 / t32); - - for (j = 0; j < width; j++) - { - - w32 [j] *= s32; - - } - - } - - // Round off 32 bit weights to 16 bit weights. - - { - - int16 *w16 = fWeights16->Buffer_int16 () + fWeightStep * sample; - - int32 t16 = 0; - - for (j = 0; j < width; j++) - { - - w16 [j] = (int16) Round_int32 (w32 [j] * 16384.0); - - t16 += w16 [j]; - - } - - // Adjust center entry for any round off error so total is - // exactly 16384. - - w16 [fRadius - (fract >= 0.5 ? 0 : 1)] += (int16) (16384 - t16); - - } - - } - - } - -/*****************************************************************************/ - -dng_resample_weights_2d::dng_resample_weights_2d () - - : fRadius (0) - - , fRowStep (0) - , fColStep (0) - - , fWeights32 () - , fWeights16 () - - { - - } - -/*****************************************************************************/ - -dng_resample_weights_2d::~dng_resample_weights_2d () - { - - } - -/*****************************************************************************/ - -void dng_resample_weights_2d::Initialize (const dng_resample_function &kernel, - dng_memory_allocator &allocator) - { - - // Find radius of this kernel. Unlike with 1d resample weights (see - // dng_resample_weights), we never scale up the kernel size. - - fRadius = (uint32) (kernel.Extent () + 0.9999); - - // Width is twice the radius. - - const uint32 width = fRadius * 2; - const uint32 widthSqr = width * width; - - const uint32 step = RoundUp8 (width * width); - - fRowStep = step * kResampleSubsampleCount2D; - fColStep = step; - - // Allocate and zero weight tables. - - fWeights32.Reset (allocator.Allocate (step * - kResampleSubsampleCount2D * - kResampleSubsampleCount2D * - (uint32) sizeof (real32))); - - DoZeroBytes (fWeights32->Buffer (), - fWeights32->LogicalSize ()); - - fWeights16.Reset (allocator.Allocate (step * - kResampleSubsampleCount2D * - kResampleSubsampleCount2D * - (uint32) sizeof (int16))); - - DoZeroBytes (fWeights16->Buffer (), - fWeights16->LogicalSize ()); - - // Compute kernel for each subsample values. - - for (uint32 y = 0; y < kResampleSubsampleCount2D; y++) - { - - real64 yFract = y * (1.0 / (real64) kResampleSubsampleCount2D); - - for (uint32 x = 0; x < kResampleSubsampleCount2D; x++) - { - - real64 xFract = x * (1.0 / (real64) kResampleSubsampleCount2D); - - real32 *w32 = (real32 *) Weights32 (dng_point ((int32) y, - (int32) x)); - - // Evaluate kernel function for 32 bit weights. - - { - - real64 t32 = 0.0; - - uint32 index = 0; - - for (uint32 i = 0; i < width; i++) - { - - int32 yInt = ((int32) i) - fRadius + 1; - real64 yPos = yInt - yFract; - - for (uint32 j = 0; j < width; j++) - { - - int32 xInt = ((int32) j) - fRadius + 1; - real64 xPos = xInt - xFract; - - #if 0 - - // Radial. - - real64 dy2 = yPos * yPos; - real64 dx2 = xPos * xPos; - - real64 r = sqrt (dx2 + dy2); - - w32 [index] = (real32) kernel.Evaluate (r); - - #else - - // Separable. - - w32 [index] = (real32) kernel.Evaluate (xPos) * - (real32) kernel.Evaluate (yPos); - - #endif - - t32 += w32 [index]; - - index++; - - } - - } - - // Scale 32 bit weights so total of weights is 1.0. - - const real32 s32 = (real32) (1.0 / t32); - - for (uint32 i = 0; i < widthSqr; i++) - { - - w32 [i] *= s32; - - } - - } - - // Round off 32 bit weights to 16 bit weights. - - { - - int16 *w16 = (int16 *) Weights16 (dng_point ((int32) y, - (int32) x)); - - int32 t16 = 0; - - for (uint32 j = 0; j < widthSqr; j++) - { - - w16 [j] = (int16) Round_int32 (w32 [j] * 16384.0); - - t16 += w16 [j]; - - } - - // Adjust one of the center entries for any round off error so total - // is exactly 16384. - - const uint32 xOffset = fRadius - ((xFract >= 0.5) ? 0 : 1); - const uint32 yOffset = fRadius - ((yFract >= 0.5) ? 0 : 1); - const uint32 centerOffset = width * yOffset + xOffset; - - w16 [centerOffset] += (int16) (16384 - t16); - - } - - } - - } - - } - -/*****************************************************************************/ - -class dng_resample_task: public dng_filter_task - { - - protected: - - dng_rect fSrcBounds; - dng_rect fDstBounds; - - const dng_resample_function &fKernel; - - real64 fRowScale; - real64 fColScale; - - dng_resample_coords fRowCoords; - dng_resample_coords fColCoords; - - dng_resample_weights fWeightsV; - dng_resample_weights fWeightsH; - - dng_point fSrcTileSize; - - AutoPtr fTempBuffer [kMaxMPThreads]; - - public: - - dng_resample_task (const dng_image &srcImage, - dng_image &dstImage, - const dng_rect &srcBounds, - const dng_rect &dstBounds, - const dng_resample_function &kernel); - - virtual dng_rect SrcArea (const dng_rect &dstArea); - - virtual dng_point SrcTileSize (const dng_point &dstTileSize); - - virtual void Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer); - - virtual void ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer); - - }; - -/*****************************************************************************/ - -dng_resample_task::dng_resample_task (const dng_image &srcImage, - dng_image &dstImage, - const dng_rect &srcBounds, - const dng_rect &dstBounds, - const dng_resample_function &kernel) - - : dng_filter_task (srcImage, - dstImage) - - , fSrcBounds (srcBounds) - , fDstBounds (dstBounds) - - , fKernel (kernel) - - , fRowScale (dstBounds.H () / (real64) srcBounds.H ()) - , fColScale (dstBounds.W () / (real64) srcBounds.W ()) - - , fRowCoords () - , fColCoords () - - , fWeightsV () - , fWeightsH () - - , fSrcTileSize () - - { - - if (srcImage.PixelSize () <= 2 && - dstImage.PixelSize () <= 2 && - srcImage.PixelRange () == dstImage.PixelRange ()) - { - fSrcPixelType = ttShort; - fDstPixelType = ttShort; - } - - else - { - fSrcPixelType = ttFloat; - fDstPixelType = ttFloat; - } - - fUnitCell = dng_point (8, 8); - - fMaxTileSize.v = Pin_int32 (fUnitCell.v, - Round_int32 (fMaxTileSize.v * fRowScale), - fMaxTileSize.v); - - fMaxTileSize.h = Pin_int32 (fUnitCell.h, - Round_int32 (fMaxTileSize.h * fColScale), - fMaxTileSize.h); - - } - -/*****************************************************************************/ - -dng_rect dng_resample_task::SrcArea (const dng_rect &dstArea) - { - - int32 offsetV = fWeightsV.Offset (); - int32 offsetH = fWeightsH.Offset (); - - uint32 widthV = fWeightsV.Width (); - uint32 widthH = fWeightsH.Width (); - - dng_rect srcArea; - - srcArea.t = fRowCoords.Pixel (dstArea.t) + offsetV; - srcArea.l = fColCoords.Pixel (dstArea.l) + offsetH; - - srcArea.b = fRowCoords.Pixel (dstArea.b - 1) + offsetV + widthV; - srcArea.r = fColCoords.Pixel (dstArea.r - 1) + offsetH + widthH; - - return srcArea; - - } - -/*****************************************************************************/ - -dng_point dng_resample_task::SrcTileSize (const dng_point & /* dstTileSize */) - { - - return fSrcTileSize; - - } - -/*****************************************************************************/ - -void dng_resample_task::Start (uint32 threadCount, - const dng_point &tileSize, - dng_memory_allocator *allocator, - dng_abort_sniffer *sniffer) - { - - // Compute sub-pixel resolution coordinates in the source image for - // each row and column of the destination area. - - fRowCoords.Initialize (fSrcBounds.t, - fDstBounds.t, - fSrcBounds.H (), - fDstBounds.H (), - *allocator); - - fColCoords.Initialize (fSrcBounds.l, - fDstBounds.l, - fSrcBounds.W (), - fDstBounds.W (), - *allocator); - - // Compute resampling kernels. - - fWeightsV.Initialize (fRowScale, - fKernel, - *allocator); - - fWeightsH.Initialize (fColScale, - fKernel, - *allocator); - - // Find upper bound on source source tile. - - fSrcTileSize.v = Round_int32 (tileSize.v / fRowScale) + fWeightsV.Width () + 2; - fSrcTileSize.h = Round_int32 (tileSize.h / fColScale) + fWeightsH.Width () + 2; - - // Allocate temp buffers. - - uint32 tempBufferSize = RoundUp8 (fSrcTileSize.h) * (uint32) sizeof (real32); - - for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) - { - - fTempBuffer [threadIndex] . Reset (allocator->Allocate (tempBufferSize)); - - } - - // Allocate the pixel buffers. - - dng_filter_task::Start (threadCount, - tileSize, - allocator, - sniffer); - - } - -/*****************************************************************************/ - -void dng_resample_task::ProcessArea (uint32 threadIndex, - dng_pixel_buffer &srcBuffer, - dng_pixel_buffer &dstBuffer) - { - - dng_rect srcArea = srcBuffer.fArea; - dng_rect dstArea = dstBuffer.fArea; - - uint32 srcCols = srcArea.W (); - uint32 dstCols = dstArea.W (); - - uint32 widthV = fWeightsV.Width (); - uint32 widthH = fWeightsH.Width (); - - int32 offsetV = fWeightsV.Offset (); - int32 offsetH = fWeightsH.Offset (); - - uint32 stepH = fWeightsH.Step (); - - const int32 *rowCoords = fRowCoords.Coords (0 ); - const int32 *colCoords = fColCoords.Coords (dstArea.l); - - if (fSrcPixelType == ttFloat) - { - - const real32 *weightsH = fWeightsH.Weights32 (0); - - real32 *tPtr = fTempBuffer [threadIndex]->Buffer_real32 (); - - real32 *ttPtr = tPtr + offsetH - srcArea.l; - - for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) - { - - int32 rowCoord = rowCoords [dstRow]; - - int32 rowFract = rowCoord & kResampleSubsampleMask; - - const real32 *weightsV = fWeightsV.Weights32 (rowFract); - - int32 srcRow = (rowCoord >> kResampleSubsampleBits) + offsetV; - - for (uint32 plane = 0; plane < dstBuffer.fPlanes; plane++) - { - - const real32 *sPtr = srcBuffer.ConstPixel_real32 (srcRow, - srcArea.l, - plane); - - DoResampleDown32 (sPtr, - tPtr, - srcCols, - srcBuffer.fRowStep, - weightsV, - widthV); - - real32 *dPtr = dstBuffer.DirtyPixel_real32 (dstRow, - dstArea.l, - plane); - - DoResampleAcross32 (ttPtr, - dPtr, - dstCols, - colCoords, - weightsH, - widthH, - stepH); - - } - - } - - } - - else - { - - const int16 *weightsH = fWeightsH.Weights16 (0); - - uint16 *tPtr = fTempBuffer [threadIndex]->Buffer_uint16 (); - - uint16 *ttPtr = tPtr + offsetH - srcArea.l; - - uint32 pixelRange = fDstImage.PixelRange (); - - for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) - { - - int32 rowCoord = rowCoords [dstRow]; - - int32 rowFract = rowCoord & kResampleSubsampleMask; - - const int16 *weightsV = fWeightsV.Weights16 (rowFract); - - int32 srcRow = (rowCoord >> kResampleSubsampleBits) + offsetV; - - for (uint32 plane = 0; plane < dstBuffer.fPlanes; plane++) - { - - const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (srcRow, - srcArea.l, - plane); - - DoResampleDown16 (sPtr, - tPtr, - srcCols, - srcBuffer.fRowStep, - weightsV, - widthV, - pixelRange); - - uint16 *dPtr = dstBuffer.DirtyPixel_uint16 (dstRow, - dstArea.l, - plane); - - DoResampleAcross16 (ttPtr, - dPtr, - dstCols, - colCoords, - weightsH, - widthH, - stepH, - pixelRange); - - } - - } - - } - - } - -/*****************************************************************************/ - -void ResampleImage (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - const dng_rect &srcBounds, - const dng_rect &dstBounds, - const dng_resample_function &kernel) - { - - dng_resample_task task (srcImage, - dstImage, - srcBounds, - dstBounds, - kernel); - - host.PerformAreaTask (task, - dstBounds); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_resample.h b/third_party/dng_sdk/dng_resample.h deleted file mode 100644 index 07f42ef..0000000 --- a/third_party/dng_sdk/dng_resample.h +++ /dev/null @@ -1,261 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_resample.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_resample__ -#define __dng_resample__ - -/*****************************************************************************/ - -#include "dng_assertions.h" -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_memory.h" -#include "dng_point.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_resample_function - { - - public: - - dng_resample_function () - { - } - - virtual ~dng_resample_function () - { - } - - virtual real64 Extent () const = 0; - - virtual real64 Evaluate (real64 x) const = 0; - - }; - -/*****************************************************************************/ - -class dng_resample_bicubic: public dng_resample_function - { - - public: - - virtual real64 Extent () const; - - virtual real64 Evaluate (real64 x) const; - - static const dng_resample_function & Get (); - - }; - -/******************************************************************************/ - -const uint32 kResampleSubsampleBits = 7; -const uint32 kResampleSubsampleCount = 1 << kResampleSubsampleBits; -const uint32 kResampleSubsampleMask = kResampleSubsampleCount - 1; - -/*****************************************************************************/ - -class dng_resample_coords - { - - protected: - - int32 fOrigin; - - AutoPtr fCoords; - - public: - - dng_resample_coords (); - - virtual ~dng_resample_coords (); - - void Initialize (int32 srcOrigin, - int32 dstOrigin, - uint32 srcCount, - uint32 dstCount, - dng_memory_allocator &allocator); - - const int32 * Coords (int32 index) const - { - return fCoords->Buffer_int32 () + (index - fOrigin); - } - - const int32 Pixel (int32 index) const - { - return Coords (index) [0] >> kResampleSubsampleBits; - } - - }; - -/*****************************************************************************/ - -class dng_resample_weights - { - - protected: - - uint32 fRadius; - - uint32 fWeightStep; - - AutoPtr fWeights32; - AutoPtr fWeights16; - - public: - - dng_resample_weights (); - - virtual ~dng_resample_weights (); - - void Initialize (real64 scale, - const dng_resample_function &kernel, - dng_memory_allocator &allocator); - - uint32 Radius () const - { - return fRadius; - } - - uint32 Width () const - { - return fRadius * 2; - } - - int32 Offset () const - { - return 1 - (int32) fRadius; - } - - uint32 Step () const - { - return fWeightStep; - } - - const real32 *Weights32 (uint32 fract) const - { - - DNG_ASSERT (fWeights32->Buffer (), "Weights32 is NULL"); - - return fWeights32->Buffer_real32 () + fract * fWeightStep; - - } - - const int16 *Weights16 (uint32 fract) const - { - - DNG_ASSERT (fWeights16->Buffer (), "Weights16 is NULL"); - - return fWeights16->Buffer_int16 () + fract * fWeightStep; - - } - - }; - -/*****************************************************************************/ - -const uint32 kResampleSubsampleBits2D = 5; -const uint32 kResampleSubsampleCount2D = 1 << kResampleSubsampleBits2D; -const uint32 kResampleSubsampleMask2D = kResampleSubsampleCount2D - 1; - -/*****************************************************************************/ - -class dng_resample_weights_2d - { - - protected: - - uint32 fRadius; - - uint32 fRowStep; - uint32 fColStep; - - AutoPtr fWeights32; - AutoPtr fWeights16; - - public: - - dng_resample_weights_2d (); - - virtual ~dng_resample_weights_2d (); - - void Initialize (const dng_resample_function &kernel, - dng_memory_allocator &allocator); - - uint32 Radius () const - { - return fRadius; - } - - uint32 Width () const - { - return fRadius * 2; - } - - int32 Offset () const - { - return 1 - (int32) fRadius; - } - - uint32 RowStep () const - { - return fRowStep; - } - - uint32 ColStep () const - { - return fColStep; - } - - const real32 *Weights32 (dng_point fract) const - { - - DNG_ASSERT (fWeights32->Buffer (), "Weights32 is NULL"); - - const uint32 offset = fract.v * fRowStep + fract.h * fColStep; - - return fWeights32->Buffer_real32 () + offset; - - } - - const int16 *Weights16 (dng_point fract) const - { - - DNG_ASSERT (fWeights16->Buffer (), "Weights16 is NULL"); - - const uint32 offset = fract.v * fRowStep + fract.h * fColStep; - - return fWeights16->Buffer_int16 () + offset; - - } - - }; - -/*****************************************************************************/ - -void ResampleImage (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - const dng_rect &srcBounds, - const dng_rect &dstBounds, - const dng_resample_function &kernel); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_sdk_limits.h b/third_party/dng_sdk/dng_sdk_limits.h deleted file mode 100644 index e4feed7..0000000 --- a/third_party/dng_sdk/dng_sdk_limits.h +++ /dev/null @@ -1,78 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_sdk_limits.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/** \file - * Collection of constants detailing maximum values used in processing in the DNG SDK. - */ - -/*****************************************************************************/ - -#ifndef __dng_sdk_limits__ -#define __dng_sdk_limits__ - -/*****************************************************************************/ - -#include "dng_types.h" - -/*****************************************************************************/ - -/// The maximum number of previews (in addition to the main IFD's thumbnail) -/// that we support embedded in a DNG. - -const uint32 kMaxDNGPreviews = 20; - -/// The maximum number of SubIFDs that will be parsed. - -const uint32 kMaxSubIFDs = kMaxDNGPreviews + 1; - -/// The maximum number of chained IFDs that will be parsed. - -const uint32 kMaxChainedIFDs = 10; - -/// The maximum number of samples per pixel. - -const uint32 kMaxSamplesPerPixel = 4; - -/// Maximum number of color planes. - -const uint32 kMaxColorPlanes = kMaxSamplesPerPixel; - -/// The maximum size of a CFA repeating pattern. - -const uint32 kMaxCFAPattern = 8; - -/// The maximum size of a black level repeating pattern. - -const uint32 kMaxBlackPattern = 8; - -/// The maximum number of masked area rectangles. - -const uint32 kMaxMaskedAreas = 4; - -/// The maximum image size supported (pixels per side). - -const uint32 kMaxImageSide = 65000; - -/// Maximum number of MP threads for dng_area_task operations. - -#if qDNG64Bit -const uint32 kMaxMPThreads = 32; -#else -const uint32 kMaxMPThreads = 8; -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_shared.cpp b/third_party/dng_sdk/dng_shared.cpp deleted file mode 100644 index 8c96c81..0000000 --- a/third_party/dng_sdk/dng_shared.cpp +++ /dev/null @@ -1,3289 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_shared.cpp#2 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_shared.h" - -#include "dng_camera_profile.h" -#include "dng_exceptions.h" -#include "dng_globals.h" -#include "dng_parse_utils.h" -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_camera_profile_info::dng_camera_profile_info () - - : fBigEndian (false) - - , fColorPlanes (0) - - , fCalibrationIlluminant1 (lsUnknown) - , fCalibrationIlluminant2 (lsUnknown) - - , fColorMatrix1 () - , fColorMatrix2 () - - , fForwardMatrix1 () - , fForwardMatrix2 () - - , fReductionMatrix1 () - , fReductionMatrix2 () - - , fProfileCalibrationSignature () - - , fProfileName () - - , fProfileCopyright () - - , fEmbedPolicy (pepAllowCopying) - - , fProfileHues (0) - , fProfileSats (0) - , fProfileVals (0) - - , fHueSatDeltas1Offset (0) - , fHueSatDeltas1Count (0) - - , fHueSatDeltas2Offset (0) - , fHueSatDeltas2Count (0) - - , fHueSatMapEncoding (encoding_Linear) - - , fLookTableHues (0) - , fLookTableSats (0) - , fLookTableVals (0) - - , fLookTableOffset (0) - , fLookTableCount (0) - - , fLookTableEncoding (encoding_Linear) - - , fBaselineExposureOffset (0, 100) - - , fDefaultBlackRender (defaultBlackRender_Auto) - - , fToneCurveOffset (0) - , fToneCurveCount (0) - - , fUniqueCameraModel () - - { - - } - -/*****************************************************************************/ - -dng_camera_profile_info::~dng_camera_profile_info () - { - - } - -/*****************************************************************************/ - -bool dng_camera_profile_info::ParseTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset) - { - - switch (tagCode) - { - - case tcCalibrationIlluminant1: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCalibrationIlluminant1 = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CalibrationIlluminant1: %s\n", - LookupLightSource (fCalibrationIlluminant1)); - - } - - #endif - - break; - - } - - case tcCalibrationIlluminant2: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fCalibrationIlluminant2 = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CalibrationIlluminant2: %s\n", - LookupLightSource (fCalibrationIlluminant2)); - - } - - #endif - - break; - - } - - case tcColorMatrix1: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (fColorPlanes == 0) - { - - fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes); - - } - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fColorPlanes, - 3, - fColorMatrix1)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ColorMatrix1:\n"); - - DumpMatrix (fColorMatrix1); - - } - - #endif - - break; - - } - - case tcColorMatrix2: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - // Kludge - Hasselblad FFF files are very DNG-like, but sometimes - // only have a ColorMatrix2 tag and no ColorMatrix1 tag. - - bool hasselbladHack = (fColorPlanes == 0); - - if (hasselbladHack) - { - - fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes); - - #if qDNGValidate - - ReportWarning ("ColorMatrix2 without ColorMatrix1"); - - #endif - - } - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fColorPlanes, - 3, - fColorMatrix2)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ColorMatrix2:\n"); - - DumpMatrix (fColorMatrix2); - - } - - #endif - - if (hasselbladHack) - { - - fColorMatrix1 = fColorMatrix2; - - fColorMatrix2 = dng_matrix (); - - } - - break; - - } - - case tcForwardMatrix1: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - 3, - fColorPlanes, - fForwardMatrix1)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ForwardMatrix1:\n"); - - DumpMatrix (fForwardMatrix1); - - } - - #endif - - break; - - } - - case tcForwardMatrix2: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - 3, - fColorPlanes, - fForwardMatrix2)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ForwardMatrix2:\n"); - - DumpMatrix (fForwardMatrix2); - - } - - #endif - - break; - - } - - case tcReductionMatrix1: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - 3, - fColorPlanes, - fReductionMatrix1)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ReductionMatrix1:\n"); - - DumpMatrix (fReductionMatrix1); - - } - - #endif - - break; - - } - - case tcReductionMatrix2: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - 3, - fColorPlanes, - fReductionMatrix2)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ReductionMatrix2:\n"); - - DumpMatrix (fReductionMatrix2); - - } - - #endif - - break; - - } - - case tcProfileCalibrationSignature: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fProfileCalibrationSignature, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileCalibrationSignature: "); - - DumpString (fProfileCalibrationSignature); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcProfileName: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fProfileName, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileName: "); - - DumpString (fProfileName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcProfileCopyright: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fProfileCopyright, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileCopyright: "); - - DumpString (fProfileCopyright); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcProfileEmbedPolicy: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fEmbedPolicy = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - const char *policy; - - switch (fEmbedPolicy) - { - - case pepAllowCopying: - policy = "Allow copying"; - break; - - case pepEmbedIfUsed: - policy = "Embed if used"; - break; - - case pepEmbedNever: - policy = "Embed never"; - break; - - case pepNoRestrictions: - policy = "No restrictions"; - break; - - default: - policy = "INVALID VALUE"; - - } - - printf ("ProfileEmbedPolicy: %s\n", policy); - - } - - #endif - - break; - - } - - case tcProfileHueSatMapDims: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 2, 3); - - fProfileHues = stream.TagValue_uint32 (tagType); - fProfileSats = stream.TagValue_uint32 (tagType); - - if (tagCount > 2) - fProfileVals = stream.TagValue_uint32 (tagType); - else - fProfileVals = 1; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileHueSatMapDims: Hues = %u, Sats = %u, Vals = %u\n", - (unsigned) fProfileHues, - (unsigned) fProfileSats, - (unsigned) fProfileVals); - - } - - #endif - - break; - - } - - case tcProfileHueSatMapData1: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttFloat)) - return false; - - bool skipSat0 = (tagCount == fProfileHues * - (fProfileSats - 1) * - fProfileVals * 3); - - if (!skipSat0) - { - - if (!CheckTagCount (parentCode, tagCode, tagCount, fProfileHues * - fProfileSats * - fProfileVals * 3)) - return false; - - } - - fBigEndian = stream.BigEndian (); - - fHueSatDeltas1Offset = tagOffset; - fHueSatDeltas1Count = tagCount; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileHueSatMapData1:\n"); - - DumpHueSatMap (stream, - fProfileHues, - fProfileSats, - fProfileVals, - skipSat0); - - } - - #endif - - break; - - } - - case tcProfileHueSatMapData2: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttFloat)) - return false; - - bool skipSat0 = (tagCount == fProfileHues * - (fProfileSats - 1) * - fProfileVals * 3); - - if (!skipSat0) - { - - if (!CheckTagCount (parentCode, tagCode, tagCount, fProfileHues * - fProfileSats * - fProfileVals * 3)) - return false; - - } - - fBigEndian = stream.BigEndian (); - - fHueSatDeltas2Offset = tagOffset; - fHueSatDeltas2Count = tagCount; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileHueSatMapData2:\n"); - - DumpHueSatMap (stream, - fProfileHues, - fProfileSats, - fProfileVals, - skipSat0); - - } - - #endif - - break; - - } - - case tcProfileHueSatMapEncoding: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fHueSatMapEncoding = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - const char *encoding = NULL; - - switch (fHueSatMapEncoding) - { - - case encoding_Linear: - encoding = "Linear"; - break; - - case encoding_sRGB: - encoding = "sRGB"; - break; - - default: - encoding = "INVALID VALUE"; - - } - - printf ("ProfileHueSatMapEncoding: %s\n", encoding); - - } - - #endif - - break; - - } - - case tcProfileLookTableDims: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 2, 3); - - fLookTableHues = stream.TagValue_uint32 (tagType); - fLookTableSats = stream.TagValue_uint32 (tagType); - - if (tagCount > 2) - fLookTableVals = stream.TagValue_uint32 (tagType); - else - fLookTableVals = 1; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileLookTableDims: Hues = %u, Sats = %u, Vals = %u\n", - (unsigned) fLookTableHues, - (unsigned) fLookTableSats, - (unsigned) fLookTableVals); - - } - - #endif - - break; - - } - - case tcProfileLookTableData: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttFloat)) - return false; - - bool skipSat0 = (tagCount == fLookTableHues * - (fLookTableSats - 1) * - fLookTableVals * 3); - - if (!skipSat0) - { - - if (!CheckTagCount (parentCode, tagCode, tagCount, fLookTableHues * - fLookTableSats * - fLookTableVals * 3)) - return false; - - } - - fBigEndian = stream.BigEndian (); - - fLookTableOffset = tagOffset; - fLookTableCount = tagCount; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ProfileLookTableData:\n"); - - DumpHueSatMap (stream, - fLookTableHues, - fLookTableSats, - fLookTableVals, - skipSat0); - - } - - #endif - - break; - - } - - case tcProfileLookTableEncoding: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fLookTableEncoding = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - const char *encoding = NULL; - - switch (fLookTableEncoding) - { - - case encoding_Linear: - encoding = "Linear"; - break; - - case encoding_sRGB: - encoding = "sRGB"; - break; - - default: - encoding = "INVALID VALUE"; - - } - - printf ("ProfileLookTableEncoding: %s\n", encoding); - - } - - #endif - - break; - - } - - case tcBaselineExposureOffset: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBaselineExposureOffset = stream.TagValue_srational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BaselineExposureOffset: %+0.2f\n", - fBaselineExposureOffset.As_real64 ()); - - } - - #endif - - break; - - } - - case tcDefaultBlackRender: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fDefaultBlackRender = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - const char *setting = NULL; - - switch (fDefaultBlackRender) - { - - case defaultBlackRender_Auto: - setting = "Auto"; - break; - - case defaultBlackRender_None: - setting = "None"; - break; - - default: - setting = "INVALID VALUE"; - - } - - printf ("DefaultBlackRender: %s\n", - setting); - - } - - #endif - - break; - - } - - case tcProfileToneCurve: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttFloat)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 4, tagCount)) - return false; - - if ((tagCount & 1) != 0) - { - - #if qDNGValidate - - { - - char message [256]; - - sprintf (message, - "%s %s has odd count (%u)", - LookupParentCode (parentCode), - LookupTagCode (parentCode, tagCode), - (unsigned) tagCount); - - ReportWarning (message); - - } - - #endif - - return false; - - } - - fBigEndian = stream.BigEndian (); - - fToneCurveOffset = tagOffset; - fToneCurveCount = tagCount; - - #if qDNGValidate - - if (gVerbose) - { - - DumpTagValues (stream, - "Coord", - parentCode, - tagCode, - tagType, - tagCount); - - - } - - #endif - - break; - - } - - case tcUniqueCameraModel: - { - - // Note: This code is only used when parsing stand-alone - // profiles. The embedded profiles are assumed to be restricted - // to the model they are embedded in. - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fUniqueCameraModel, - false); - - bool didTrim = fUniqueCameraModel.TrimTrailingBlanks (); - - #if qDNGValidate - - if (didTrim) - { - - ReportWarning ("UniqueCameraModel string has trailing blanks"); - - } - - if (gVerbose) - { - - printf ("UniqueCameraModel: "); - - DumpString (fUniqueCameraModel); - - printf ("\n"); - - } - - #else - - (void) didTrim; // Unused - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_camera_profile_info::ParseExtended (dng_stream &stream) - { - - try - { - - // Offsets are relative to the start of this structure, not the entire file. - - uint64 startPosition = stream.Position (); - - // Read header. Like a TIFF header, but with different magic number - // Plus all offsets are relative to the start of the IFD, not to the - // stream or file. - - uint16 byteOrder = stream.Get_uint16 (); - - if (byteOrder == byteOrderMM) - fBigEndian = true; - - else if (byteOrder == byteOrderII) - fBigEndian = false; - - else - return false; - - TempBigEndian setEndianness (stream, fBigEndian); - - uint16 magicNumber = stream.Get_uint16 (); - - if (magicNumber != magicExtendedProfile) - { - return false; - } - - uint32 offset = stream.Get_uint32 (); - - stream.Skip (offset - 8); - - // Start on IFD entries. - - uint32 ifdEntries = stream.Get_uint16 (); - - if (ifdEntries < 1) - { - return false; - } - - for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++) - { - - stream.SetReadPosition (startPosition + 8 + 2 + tag_index * 12); - - uint16 tagCode = stream.Get_uint16 (); - uint32 tagType = stream.Get_uint16 (); - uint32 tagCount = stream.Get_uint32 (); - - uint64 tagOffset = stream.Position (); - - if (TagTypeSize (tagType) * tagCount > 4) - { - - tagOffset = startPosition + stream.Get_uint32 (); - - stream.SetReadPosition (tagOffset); - - } - - if (!ParseTag (stream, - 0, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - #if qDNGValidate - - if (gVerbose) - { - - stream.SetReadPosition (tagOffset); - - printf ("*"); - - DumpTagValues (stream, - LookupTagType (tagType), - 0, - tagCode, - tagType, - tagCount); - - } - - #endif - - } - - } - - return true; - - } - - catch (...) - { - - // Eat parsing errors. - - } - - return false; - - } - -/*****************************************************************************/ - -dng_shared::dng_shared () - - : fExifIFD (0) - , fGPSInfo (0) - , fInteroperabilityIFD (0) - , fKodakDCRPrivateIFD (0) - , fKodakKDCPrivateIFD (0) - - , fXMPCount (0) - , fXMPOffset (0) - - , fIPTC_NAA_Count (0) - , fIPTC_NAA_Offset (0) - - , fMakerNoteCount (0) - , fMakerNoteOffset (0) - , fMakerNoteSafety (0) - - , fDNGVersion (0) - , fDNGBackwardVersion (0) - - , fUniqueCameraModel () - , fLocalizedCameraModel () - - , fCameraProfile () - - , fExtraCameraProfiles () - - , fCameraCalibration1 () - , fCameraCalibration2 () - - , fCameraCalibrationSignature () - - , fAnalogBalance () - - , fAsShotNeutral () - - , fAsShotWhiteXY () - - , fBaselineExposure (0, 1) - , fBaselineNoise (1, 1) - , fNoiseReductionApplied (0, 0) - , fBaselineSharpness (1, 1) - , fLinearResponseLimit (1, 1) - , fShadowScale (1, 1) - - , fHasBaselineExposure (false) - , fHasShadowScale (false) - - , fDNGPrivateDataCount (0) - , fDNGPrivateDataOffset (0) - - , fRawImageDigest () - , fNewRawImageDigest () - - , fRawDataUniqueID () - - , fOriginalRawFileName () - - , fOriginalRawFileDataCount (0) - , fOriginalRawFileDataOffset (0) - - , fOriginalRawFileDigest () - - , fAsShotICCProfileCount (0) - , fAsShotICCProfileOffset (0) - - , fAsShotPreProfileMatrix () - - , fCurrentICCProfileCount (0) - , fCurrentICCProfileOffset (0) - - , fCurrentPreProfileMatrix () - - , fColorimetricReference (crSceneReferred) - - , fAsShotProfileName () - - , fNoiseProfile () - - , fOriginalDefaultFinalSize () - , fOriginalBestQualityFinalSize () - - , fOriginalDefaultCropSizeH () - , fOriginalDefaultCropSizeV () - - { - - } - -/*****************************************************************************/ - -dng_shared::~dng_shared () - { - - } - -/*****************************************************************************/ - -bool dng_shared::ParseTag (dng_stream &stream, - dng_exif &exif, - uint32 parentCode, - bool /* isMainIFD */, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset, - int64 /* offsetDelta */) - { - - if (parentCode == 0) - { - - if (Parse_ifd0 (stream, - exif, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - if (parentCode == 0 || - parentCode == tcExifIFD) - { - - if (Parse_ifd0_exif (stream, - exif, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset)) - { - - return true; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFD 0. - -bool dng_shared::Parse_ifd0 (dng_stream &stream, - dng_exif & /* exif */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset) - { - - switch (tagCode) - { - - case tcXMP: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte, ttUndefined); - - fXMPCount = tagCount; - fXMPOffset = fXMPCount ? tagOffset : 0; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("XMP: Count = %u, Offset = %u\n", - (unsigned) fXMPCount, - (unsigned) fXMPOffset); - - if (fXMPCount) - { - - DumpXMP (stream, fXMPCount); - - } - - } - - #endif - - break; - - } - - case tcIPTC_NAA: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttAscii, ttUndefined); - - fIPTC_NAA_Count = tagCount * TagTypeSize (tagType); - fIPTC_NAA_Offset = fIPTC_NAA_Count ? tagOffset : 0; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("IPTC/NAA: Count = %u, Offset = %u\n", - (unsigned) fIPTC_NAA_Count, - (unsigned) fIPTC_NAA_Offset); - - if (fIPTC_NAA_Count) - { - - DumpHexAscii (stream, fIPTC_NAA_Count); - - } - - // Compute and output the digest. - - dng_memory_data buffer (fIPTC_NAA_Count); - - stream.SetReadPosition (fIPTC_NAA_Offset); - - stream.Get (buffer.Buffer (), fIPTC_NAA_Count); - - const uint8 *data = buffer.Buffer_uint8 (); - - uint32 count = fIPTC_NAA_Count; - - // Method 1: Counting all bytes (this is correct). - - { - - dng_md5_printer printer; - - printer.Process (data, count); - - printf ("IPTCDigest: "); - - DumpFingerprint (printer.Result ()); - - printf ("\n"); - - } - - // Method 2: Ignoring zero padding. - - { - - uint32 removed = 0; - - while ((removed < 3) && (count > 0) && (data [count - 1] == 0)) - { - removed++; - count--; - } - - if (removed != 0) - { - - dng_md5_printer printer; - - printer.Process (data, count); - - printf ("IPTCDigest (ignoring zero padding): "); - - DumpFingerprint (printer.Result ()); - - printf ("\n"); - - } - - } - - } - - #endif - - break; - - } - - case tcExifIFD: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fExifIFD = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("ExifIFD: %u\n", (unsigned) fExifIFD); - } - - #endif - - break; - - } - - case tcGPSInfo: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fGPSInfo = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("GPSInfo: %u\n", (unsigned) fGPSInfo); - } - - #endif - - break; - - } - - case tcKodakDCRPrivateIFD: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fKodakDCRPrivateIFD = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("KodakDCRPrivateIFD: %u\n", (unsigned) fKodakDCRPrivateIFD); - } - - #endif - - break; - - } - - case tcKodakKDCPrivateIFD: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fKodakKDCPrivateIFD = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("KodakKDCPrivateIFD: %u\n", (unsigned) fKodakKDCPrivateIFD); - } - - #endif - - break; - - } - - case tcDNGVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fDNGVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - printf ("DNGVersion: %u.%u.%u.%u\n", - (unsigned) b0, - (unsigned) b1, - (unsigned) b2, - (unsigned) b3); - } - - #endif - - break; - - } - - case tcDNGBackwardVersion: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - CheckTagCount (parentCode, tagCode, tagCount, 4); - - uint32 b0 = stream.Get_uint8 (); - uint32 b1 = stream.Get_uint8 (); - uint32 b2 = stream.Get_uint8 (); - uint32 b3 = stream.Get_uint8 (); - - fDNGBackwardVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - - #if qDNGValidate - - if (gVerbose) - { - printf ("DNGBackwardVersion: %u.%u.%u.%u\n", - (unsigned) b0, - (unsigned) b1, - (unsigned) b2, - (unsigned) b3); - } - - #endif - - break; - - } - - case tcUniqueCameraModel: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fUniqueCameraModel, - false); - - bool didTrim = fUniqueCameraModel.TrimTrailingBlanks (); - - #if qDNGValidate - - if (didTrim) - { - - ReportWarning ("UniqueCameraModel string has trailing blanks"); - - } - - if (gVerbose) - { - - printf ("UniqueCameraModel: "); - - DumpString (fUniqueCameraModel); - - printf ("\n"); - - } - - #else - - (void) didTrim; // Unused - - #endif - - break; - - } - - case tcLocalizedCameraModel: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fLocalizedCameraModel, - false); - - bool didTrim = fLocalizedCameraModel.TrimTrailingBlanks (); - - #if qDNGValidate - - if (didTrim) - { - - ReportWarning ("LocalizedCameraModel string has trailing blanks"); - - } - - if (gVerbose) - { - - printf ("LocalizedCameraModel: "); - - DumpString (fLocalizedCameraModel); - - printf ("\n"); - - } - - #else - - (void) didTrim; // Unused - - #endif - - break; - - } - - case tcCameraCalibration1: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fCameraProfile.fColorPlanes, - fCameraProfile.fColorPlanes, - fCameraCalibration1)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CameraCalibration1:\n"); - - DumpMatrix (fCameraCalibration1); - - } - - #endif - - break; - - } - - case tcCameraCalibration2: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fCameraProfile.fColorPlanes, - fCameraProfile.fColorPlanes, - fCameraCalibration2)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CameraCalibration2:\n"); - - DumpMatrix (fCameraCalibration2); - - } - - #endif - - break; - - } - - case tcCameraCalibrationSignature: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fCameraCalibrationSignature, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CameraCalibrationSignature: "); - - DumpString (fCameraCalibrationSignature); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcAnalogBalance: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - // Kludge - Hasselblad FFF files are very DNG-like, but sometimes - // they don't have any ColorMatrix tags. - - bool hasselbladHack = (fDNGVersion == 0 && - fCameraProfile.fColorPlanes == 0); - - if (hasselbladHack) - { - - fCameraProfile.fColorPlanes = Pin_uint32 (0, tagCount, kMaxColorPlanes); - - #if qDNGValidate - - ReportWarning ("AnalogBalance without ColorMatrix1"); - - #endif - - } - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - if (!ParseVectorTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fCameraProfile.fColorPlanes, - fAnalogBalance)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AnalogBalance:"); - - DumpVector (fAnalogBalance); - - } - - #endif - - break; - - } - - case tcAsShotNeutral: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - // Kludge - Hasselblad FFF files are very DNG-like, but sometimes - // they don't have any ColorMatrix tags. - - bool hasselbladHack = (fDNGVersion == 0 && - fCameraProfile.fColorPlanes == 0); - - if (hasselbladHack) - { - - fCameraProfile.fColorPlanes = Pin_uint32 (0, tagCount, kMaxColorPlanes); - - #if qDNGValidate - - ReportWarning ("AsShotNeutral without ColorMatrix1"); - - #endif - - } - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - if (!ParseVectorTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - fCameraProfile.fColorPlanes, - fAsShotNeutral)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AsShotNeutral:"); - - DumpVector (fAsShotNeutral); - - } - - #endif - - break; - - } - - case tcAsShotWhiteXY: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fAsShotWhiteXY.x = stream.TagValue_real64 (tagType); - fAsShotWhiteXY.y = stream.TagValue_real64 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AsShotWhiteXY: %0.4f %0.4f\n", - fAsShotWhiteXY.x, - fAsShotWhiteXY.y); - - } - - #endif - - break; - - } - - case tcBaselineExposure: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBaselineExposure = stream.TagValue_srational (tagType); - - fHasBaselineExposure = true; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BaselineExposure: %+0.2f\n", - fBaselineExposure.As_real64 ()); - - } - - #endif - - break; - - } - - case tcBaselineNoise: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBaselineNoise = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BaselineNoise: %0.2f\n", - fBaselineNoise.As_real64 ()); - - } - - #endif - - break; - - } - - case tcNoiseReductionApplied: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttRational)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) - return false; - - fNoiseReductionApplied = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("NoiseReductionApplied: %u/%u\n", - (unsigned) fNoiseReductionApplied.n, - (unsigned) fNoiseReductionApplied.d); - - } - - #endif - - break; - - } - - case tcNoiseProfile: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttDouble)) - return false; - - // Must be an even, positive number of doubles in a noise profile. - - if (!tagCount || (tagCount & 1)) - return false; - - // Determine number of planes (i.e., half the number of doubles). - - const uint32 numPlanes = Pin_uint32 (0, - tagCount >> 1, - kMaxColorPlanes); - - // Parse the noise function parameters. - - std::vector noiseFunctions; - - for (uint32 i = 0; i < numPlanes; i++) - { - - const real64 scale = stream.TagValue_real64 (tagType); - const real64 offset = stream.TagValue_real64 (tagType); - - noiseFunctions.push_back (dng_noise_function (scale, offset)); - - } - - // Store the noise profile. - - fNoiseProfile = dng_noise_profile (noiseFunctions); - - // Debug. - - #if qDNGValidate - - if (gVerbose) - { - - printf ("NoiseProfile:\n"); - - printf (" Planes: %u\n", (unsigned) numPlanes); - - for (uint32 plane = 0; plane < numPlanes; plane++) - { - - printf (" Noise function for plane %u: scale = %.8lf, offset = %.8lf\n", - (unsigned) plane, - noiseFunctions [plane].Scale (), - noiseFunctions [plane].Offset ()); - - } - - } - - #endif - - break; - - } - - case tcBaselineSharpness: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fBaselineSharpness = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("BaselineSharpness: %0.2f\n", - fBaselineSharpness.As_real64 ()); - - } - - #endif - - break; - - } - - case tcLinearResponseLimit: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fLinearResponseLimit = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("LinearResponseLimit: %0.2f\n", - fLinearResponseLimit.As_real64 ()); - - } - - #endif - - break; - - } - - case tcShadowScale: - { - - CheckTagType (parentCode, tagCode, tagType, ttRational); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fShadowScale = stream.TagValue_urational (tagType); - - fHasShadowScale = true; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ShadowScale: %0.4f\n", - fShadowScale.As_real64 ()); - - } - - #endif - - break; - - } - - case tcDNGPrivateData: - { - - CheckTagType (parentCode, tagCode, tagType, ttByte); - - fDNGPrivateDataCount = tagCount; - fDNGPrivateDataOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("DNGPrivateData: Count = %u, Offset = %u\n", - (unsigned) fDNGPrivateDataCount, - (unsigned) fDNGPrivateDataOffset); - - DumpHexAscii (stream, tagCount); - - } - - #endif - - break; - - } - - case tcMakerNoteSafety: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fMakerNoteSafety = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("MakerNoteSafety: %s\n", - LookupMakerNoteSafety (fMakerNoteSafety)); - - } - - #endif - - break; - - } - - case tcRawImageDigest: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) - return false; - - stream.Get (fRawImageDigest.data, 16); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RawImageDigest: "); - - DumpFingerprint (fRawImageDigest); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcNewRawImageDigest: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) - return false; - - stream.Get (fNewRawImageDigest.data, 16); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("NewRawImageDigest: "); - - DumpFingerprint (fNewRawImageDigest); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcRawDataUniqueID: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) - return false; - - stream.Get (fRawDataUniqueID.data, 16); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("RawDataUniqueID: "); - - DumpFingerprint (fRawDataUniqueID); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcOriginalRawFileName: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fOriginalRawFileName, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalRawFileName: "); - - DumpString (fOriginalRawFileName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcOriginalRawFileData: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fOriginalRawFileDataCount = tagCount; - fOriginalRawFileDataOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalRawFileData: Count = %u, Offset = %u\n", - (unsigned) fOriginalRawFileDataCount, - (unsigned) fOriginalRawFileDataOffset); - - DumpHexAscii (stream, tagCount); - - } - - #endif - - break; - - } - - case tcOriginalRawFileDigest: - { - - if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) - return false; - - if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) - return false; - - stream.Get (fOriginalRawFileDigest.data, 16); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalRawFileDigest: "); - - DumpFingerprint (fOriginalRawFileDigest); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcAsShotICCProfile: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fAsShotICCProfileCount = tagCount; - fAsShotICCProfileOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AsShotICCProfile: Count = %u, Offset = %u\n", - (unsigned) fAsShotICCProfileCount, - (unsigned) fAsShotICCProfileOffset); - - DumpHexAscii (stream, tagCount); - - } - - #endif - - break; - - } - - case tcAsShotPreProfileMatrix: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - uint32 rows = fCameraProfile.fColorPlanes; - - if (tagCount == fCameraProfile.fColorPlanes * 3) - { - rows = 3; - } - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - rows, - fCameraProfile.fColorPlanes, - fAsShotPreProfileMatrix)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AsShotPreProfileMatrix:\n"); - - DumpMatrix (fAsShotPreProfileMatrix); - - } - - #endif - - break; - - } - - case tcCurrentICCProfile: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fCurrentICCProfileCount = tagCount; - fCurrentICCProfileOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CurrentICCProfile: Count = %u, Offset = %u\n", - (unsigned) fCurrentICCProfileCount, - (unsigned) fCurrentICCProfileOffset); - - DumpHexAscii (stream, tagCount); - - } - - #endif - - break; - - } - - case tcCurrentPreProfileMatrix: - { - - CheckTagType (parentCode, tagCode, tagType, ttSRational); - - if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes)) - return false; - - uint32 rows = fCameraProfile.fColorPlanes; - - if (tagCount == fCameraProfile.fColorPlanes * 3) - { - rows = 3; - } - - if (!ParseMatrixTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - rows, - fCameraProfile.fColorPlanes, - fCurrentPreProfileMatrix)) - return false; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("CurrentPreProfileMatrix:\n"); - - DumpMatrix (fCurrentPreProfileMatrix); - - } - - #endif - - break; - - } - - case tcColorimetricReference: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fColorimetricReference = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ColorimetricReference: %s\n", - LookupColorimetricReference (fColorimetricReference)); - - } - - #endif - - break; - - } - - case tcExtraCameraProfiles: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong); - - CheckTagCount (parentCode, tagCode, tagCount, 1, tagCount); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("ExtraCameraProfiles: %u\n", (unsigned) tagCount); - - } - - #endif - - fExtraCameraProfiles.reserve (tagCount); - - for (uint32 index = 0; index < tagCount; index++) - { - - #if qDNGValidate - - if (gVerbose) - { - - printf ("\nExtraCameraProfile [%u]:\n\n", (unsigned) index); - - } - - #endif - - stream.SetReadPosition (tagOffset + index * 4); - - uint32 profileOffset = stream.TagValue_uint32 (tagType); - - dng_camera_profile_info profileInfo; - - stream.SetReadPosition (profileOffset); - - if (profileInfo.ParseExtended (stream)) - { - - fExtraCameraProfiles.push_back (profileInfo); - - } - - else - { - - #if qDNGValidate - - ReportWarning ("Unable to parse extra camera profile"); - - #endif - - } - - } - - #if qDNGValidate - - if (gVerbose) - { - - printf ("\nDone with ExtraCameraProfiles\n\n"); - - } - - #endif - - break; - - } - - case tcAsShotProfileName: - { - - CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); - - ParseStringTag (stream, - parentCode, - tagCode, - tagCount, - fAsShotProfileName, - false); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("AsShotProfileName: "); - - DumpString (fAsShotProfileName); - - printf ("\n"); - - } - - #endif - - break; - - } - - case tcOriginalDefaultFinalSize: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fOriginalDefaultFinalSize.h = stream.TagValue_int32 (tagType); - fOriginalDefaultFinalSize.v = stream.TagValue_int32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalDefaultFinalSize: H = %d V = %d\n", - (int) fOriginalDefaultFinalSize.h, - (int) fOriginalDefaultFinalSize.v); - - } - - #endif - - break; - - } - - case tcOriginalBestQualityFinalSize: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fOriginalBestQualityFinalSize.h = stream.TagValue_int32 (tagType); - fOriginalBestQualityFinalSize.v = stream.TagValue_int32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalBestQualityFinalSize: H = %d V = %d\n", - (int) fOriginalBestQualityFinalSize.h, - (int) fOriginalBestQualityFinalSize.v); - - } - - #endif - - break; - - } - - case tcOriginalDefaultCropSize: - { - - CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); - - if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) - return false; - - fOriginalDefaultCropSizeH = stream.TagValue_urational (tagType); - fOriginalDefaultCropSizeV = stream.TagValue_urational (tagType); - - #if qDNGValidate - - if (gVerbose) - { - - printf ("OriginalDefaultCropSize: H = %0.2f V = %0.2f\n", - fOriginalDefaultCropSizeH.As_real64 (), - fOriginalDefaultCropSizeV.As_real64 ()); - - } - - #endif - - break; - - } - - default: - { - - // The main camera profile tags also appear in IFD 0 - - return fCameraProfile.ParseTag (stream, - parentCode, - tagCode, - tagType, - tagCount, - tagOffset); - - } - - } - - return true; - - } - -/*****************************************************************************/ - -// Parses tags that should only appear in IFD 0 or EXIF IFD. - -bool dng_shared::Parse_ifd0_exif (dng_stream &stream, - dng_exif & /* exif */, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset) - { - - switch (tagCode) - { - - case tcMakerNote: - { - - CheckTagType (parentCode, tagCode, tagType, ttUndefined); - - fMakerNoteCount = tagCount; - fMakerNoteOffset = tagOffset; - - #if qDNGValidate - - if (gVerbose) - { - - printf ("MakerNote: Count = %u, Offset = %u\n", - (unsigned) fMakerNoteCount, - (unsigned) fMakerNoteOffset); - - DumpHexAscii (stream, tagCount); - - } - - #endif - - break; - - } - - case tcInteroperabilityIFD: - { - - CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD); - - CheckTagCount (parentCode, tagCode, tagCount, 1); - - fInteroperabilityIFD = stream.TagValue_uint32 (tagType); - - #if qDNGValidate - - if (gVerbose) - { - printf ("InteroperabilityIFD: %u\n", (unsigned) fInteroperabilityIFD); - } - - #endif - - break; - - } - - default: - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_shared::PostParse (dng_host & /* host */, - dng_exif & /* exif */) - { - - // Fill in default values for DNG images. - - if (fDNGVersion != 0) - { - - // Support for DNG versions before 1.0.0.0. - - if (fDNGVersion < dngVersion_1_0_0_0) - { - - #if qDNGValidate - - ReportWarning ("DNGVersion less than 1.0.0.0"); - - #endif - - // The CalibrationIlluminant tags were added just before - // DNG version 1.0.0.0, and were hardcoded before that. - - fCameraProfile.fCalibrationIlluminant1 = lsStandardLightA; - fCameraProfile.fCalibrationIlluminant2 = lsD65; - - fDNGVersion = dngVersion_1_0_0_0; - - } - - // Default value for DNGBackwardVersion tag. - - if (fDNGBackwardVersion == 0) - { - - fDNGBackwardVersion = fDNGVersion & 0xFFFF0000; - - } - - // Check DNGBackwardVersion value. - - if (fDNGBackwardVersion < dngVersion_1_0_0_0) - { - - #if qDNGValidate - - ReportWarning ("DNGBackwardVersion less than 1.0.0.0"); - - #endif - - fDNGBackwardVersion = dngVersion_1_0_0_0; - - } - - if (fDNGBackwardVersion > fDNGVersion) - { - - #if qDNGValidate - - ReportWarning ("DNGBackwardVersion > DNGVersion"); - - #endif - - fDNGBackwardVersion = fDNGVersion; - - } - - // Check UniqueCameraModel. - - if (fUniqueCameraModel.IsEmpty ()) - { - - #if qDNGValidate - - ReportWarning ("Missing or invalid UniqueCameraModel"); - - #endif - - fUniqueCameraModel.Set ("Digital Negative"); - - } - - // If we don't know the color depth yet, it must be a monochrome DNG. - - if (fCameraProfile.fColorPlanes == 0) - { - - fCameraProfile.fColorPlanes = 1; - - } - - // Check color info. - - if (fCameraProfile.fColorPlanes > 1) - { - - // Check illuminant pair. - - if (fCameraProfile.fColorMatrix2.NotEmpty ()) - { - - if (fCameraProfile.fCalibrationIlluminant1 == lsUnknown || - (fCameraProfile.fCalibrationIlluminant2 == lsUnknown || - (fCameraProfile.fCalibrationIlluminant1 == fCameraProfile.fCalibrationIlluminant2))) - { - - #if qDNGValidate - - ReportWarning ("Invalid CalibrationIlluminant pair"); - - #endif - - fCameraProfile.fColorMatrix2 = dng_matrix (); - - } - - } - - // If the colorimetric reference is the ICC profile PCS, then the - // data must already be white balanced. The "AsShotWhiteXY" is required - // to be the ICC Profile PCS white point. - - if (fColorimetricReference == crICCProfilePCS) - { - - if (fAsShotNeutral.NotEmpty ()) - { - - #if qDNGValidate - - ReportWarning ("AsShotNeutral not allowed for this " - "ColorimetricReference value"); - - #endif - - fAsShotNeutral.Clear (); - - } - - dng_xy_coord pcs = PCStoXY (); - - #if qDNGValidate - - if (fAsShotWhiteXY.IsValid ()) - { - - if (Abs_real64 (fAsShotWhiteXY.x - pcs.x) > 0.01 || - Abs_real64 (fAsShotWhiteXY.y - pcs.y) > 0.01) - { - - ReportWarning ("AsShotWhiteXY does not match the ICC Profile PCS"); - - } - - } - - #endif - - fAsShotWhiteXY = pcs; - - } - - else - { - - // Warn if both AsShotNeutral and AsShotWhiteXY are specified. - - if (fAsShotNeutral.NotEmpty () && fAsShotWhiteXY.IsValid ()) - { - - #if qDNGValidate - - ReportWarning ("Both AsShotNeutral and AsShotWhiteXY included"); - - #endif - - fAsShotWhiteXY = dng_xy_coord (); - - } - - // Warn if neither AsShotNeutral nor AsShotWhiteXY are specified. - - #if qDNGValidate - - if (fAsShotNeutral.IsEmpty () && !fAsShotWhiteXY.IsValid ()) - { - - ReportWarning ("Neither AsShotNeutral nor AsShotWhiteXY included", - "legal but not recommended"); - - } - - #endif - - } - - // Default values of calibration signatures are required for legacy - // compatiblity. - - if (fCameraProfile.fCalibrationIlluminant1 == lsStandardLightA && - fCameraProfile.fCalibrationIlluminant2 == lsD65 && - fCameraCalibration1.Rows () == fCameraProfile.fColorPlanes && - fCameraCalibration1.Cols () == fCameraProfile.fColorPlanes && - fCameraCalibration2.Rows () == fCameraProfile.fColorPlanes && - fCameraCalibration2.Cols () == fCameraProfile.fColorPlanes && - fCameraCalibrationSignature.IsEmpty () && - fCameraProfile.fProfileCalibrationSignature.IsEmpty () ) - { - - fCameraCalibrationSignature.Set (kAdobeCalibrationSignature); - - fCameraProfile.fProfileCalibrationSignature.Set (kAdobeCalibrationSignature); - - } - - } - - // Check BaselineNoise. - - if (fBaselineNoise.As_real64 () <= 0.0) - { - - #if qDNGValidate - - ReportWarning ("Invalid BaselineNoise"); - - #endif - - fBaselineNoise = dng_urational (1, 1); - - } - - // Check BaselineSharpness. - - if (fBaselineSharpness.As_real64 () <= 0.0) - { - - #if qDNGValidate - - ReportWarning ("Invalid BaselineSharpness"); - - #endif - - fBaselineSharpness = dng_urational (1, 1); - - } - - // Check NoiseProfile. - - if (!fNoiseProfile.IsValid () && fNoiseProfile.NumFunctions () != 0) - { - - #if qDNGValidate - - ReportWarning ("Invalid NoiseProfile"); - - #endif - - fNoiseProfile = dng_noise_profile (); - - } - - // Check LinearResponseLimit. - - if (fLinearResponseLimit.As_real64 () < 0.5 || - fLinearResponseLimit.As_real64 () > 1.0) - { - - #if qDNGValidate - - ReportWarning ("Invalid LinearResponseLimit"); - - #endif - - fLinearResponseLimit = dng_urational (1, 1); - - } - - // Check ShadowScale. - - if (fShadowScale.As_real64 () <= 0.0) - { - - #if qDNGValidate - - ReportWarning ("Invalid ShadowScale"); - - #endif - - fShadowScale = dng_urational (1, 1); - - } - - } - - } - -/*****************************************************************************/ - -bool dng_shared::IsValidDNG () - { - - // Check DNGVersion value. - - if (fDNGVersion < dngVersion_1_0_0_0) - { - - #if qDNGValidate - - if (fDNGVersion != dngVersion_None) - { - - ReportError ("Invalid DNGVersion"); - - } - - #if qDNGValidateTarget - - else - { - - ReportError ("Missing DNGVersion"); - - } - - #endif - - #endif - - return false; - - } - - // Check DNGBackwardVersion value. - - if (fDNGBackwardVersion > dngVersion_Current) - { - - #if qDNGValidate - - ReportError ("DNGBackwardVersion (or DNGVersion) is too high"); - - #endif - - ThrowUnsupportedDNG (); - - } - - // Check color transform info. - - if (fCameraProfile.fColorPlanes > 1) - { - - // CameraCalibration1 is optional, but it must be valid if present. - - if (fCameraCalibration1.Cols () != 0 || - fCameraCalibration1.Rows () != 0) - { - - if (fCameraCalibration1.Cols () != fCameraProfile.fColorPlanes || - fCameraCalibration1.Rows () != fCameraProfile.fColorPlanes) - { - - #if qDNGValidate - - ReportError ("CameraCalibration1 is wrong size"); - - #endif - - return false; - - } - - // Make sure it is invertable. - - try - { - - (void) Invert (fCameraCalibration1); - - } - - catch (...) - { - - #if qDNGValidate - - ReportError ("CameraCalibration1 is not invertable"); - - #endif - - return false; - - } - - } - - // CameraCalibration2 is optional, but it must be valid if present. - - if (fCameraCalibration2.Cols () != 0 || - fCameraCalibration2.Rows () != 0) - { - - if (fCameraCalibration2.Cols () != fCameraProfile.fColorPlanes || - fCameraCalibration2.Rows () != fCameraProfile.fColorPlanes) - { - - #if qDNGValidate - - ReportError ("CameraCalibration2 is wrong size"); - - #endif - - return false; - - } - - // Make sure it is invertable. - - try - { - - (void) Invert (fCameraCalibration2); - - } - - catch (...) - { - - #if qDNGValidate - - ReportError ("CameraCalibration2 is not invertable"); - - #endif - - return false; - - } - - } - - // Check analog balance - - dng_matrix analogBalance; - - if (fAnalogBalance.NotEmpty ()) - { - - analogBalance = fAnalogBalance.AsDiagonal (); - - try - { - - (void) Invert (analogBalance); - - } - - catch (...) - { - - #if qDNGValidate - - ReportError ("AnalogBalance is not invertable"); - - #endif - - return false; - - } - - } - - } - - return true; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_shared.h b/third_party/dng_sdk/dng_shared.h deleted file mode 100644 index b67d7a6..0000000 --- a/third_party/dng_sdk/dng_shared.h +++ /dev/null @@ -1,248 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_shared.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_shared__ -#define __dng_shared__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_fingerprint.h" -#include "dng_matrix.h" -#include "dng_negative.h" -#include "dng_rational.h" -#include "dng_string.h" -#include "dng_stream.h" -#include "dng_sdk_limits.h" -#include "dng_types.h" -#include "dng_xy_coord.h" - -#include - -/*****************************************************************************/ - -class dng_camera_profile_info - { - - public: - - bool fBigEndian; - - uint32 fColorPlanes; - - uint32 fCalibrationIlluminant1; - uint32 fCalibrationIlluminant2; - - dng_matrix fColorMatrix1; - dng_matrix fColorMatrix2; - - dng_matrix fForwardMatrix1; - dng_matrix fForwardMatrix2; - - dng_matrix fReductionMatrix1; - dng_matrix fReductionMatrix2; - - dng_string fProfileCalibrationSignature; - - dng_string fProfileName; - - dng_string fProfileCopyright; - - uint32 fEmbedPolicy; - - uint32 fProfileHues; - uint32 fProfileSats; - uint32 fProfileVals; - - uint64 fHueSatDeltas1Offset; - uint32 fHueSatDeltas1Count; - - uint64 fHueSatDeltas2Offset; - uint32 fHueSatDeltas2Count; - - uint32 fHueSatMapEncoding; - - uint32 fLookTableHues; - uint32 fLookTableSats; - uint32 fLookTableVals; - - uint64 fLookTableOffset; - uint32 fLookTableCount; - - uint32 fLookTableEncoding; - - dng_srational fBaselineExposureOffset; - - uint32 fDefaultBlackRender; - - uint64 fToneCurveOffset; - uint32 fToneCurveCount; - - dng_string fUniqueCameraModel; - - public: - - dng_camera_profile_info (); - - ~dng_camera_profile_info (); - - bool ParseTag (dng_stream &stream, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - bool ParseExtended (dng_stream &stream); - - }; - -/*****************************************************************************/ - -class dng_shared - { - - public: - - uint64 fExifIFD; - uint64 fGPSInfo; - uint64 fInteroperabilityIFD; - uint64 fKodakDCRPrivateIFD; - uint64 fKodakKDCPrivateIFD; - - uint32 fXMPCount; - uint64 fXMPOffset; - - uint32 fIPTC_NAA_Count; - uint64 fIPTC_NAA_Offset; - - uint32 fMakerNoteCount; - uint64 fMakerNoteOffset; - uint32 fMakerNoteSafety; - - uint32 fDNGVersion; - uint32 fDNGBackwardVersion; - - dng_string fUniqueCameraModel; - dng_string fLocalizedCameraModel; - - dng_camera_profile_info fCameraProfile; - - std::vector fExtraCameraProfiles; - - dng_matrix fCameraCalibration1; - dng_matrix fCameraCalibration2; - - dng_string fCameraCalibrationSignature; - - dng_vector fAnalogBalance; - - dng_vector fAsShotNeutral; - - dng_xy_coord fAsShotWhiteXY; - - dng_srational fBaselineExposure; - dng_urational fBaselineNoise; - dng_urational fNoiseReductionApplied; - dng_urational fBaselineSharpness; - dng_urational fLinearResponseLimit; - dng_urational fShadowScale; - - bool fHasBaselineExposure; - bool fHasShadowScale; - - uint32 fDNGPrivateDataCount; - uint64 fDNGPrivateDataOffset; - - dng_fingerprint fRawImageDigest; - dng_fingerprint fNewRawImageDigest; - - dng_fingerprint fRawDataUniqueID; - - dng_string fOriginalRawFileName; - - uint32 fOriginalRawFileDataCount; - uint64 fOriginalRawFileDataOffset; - - dng_fingerprint fOriginalRawFileDigest; - - uint32 fAsShotICCProfileCount; - uint64 fAsShotICCProfileOffset; - - dng_matrix fAsShotPreProfileMatrix; - - uint32 fCurrentICCProfileCount; - uint64 fCurrentICCProfileOffset; - - dng_matrix fCurrentPreProfileMatrix; - - uint32 fColorimetricReference; - - dng_string fAsShotProfileName; - - dng_noise_profile fNoiseProfile; - - dng_point fOriginalDefaultFinalSize; - dng_point fOriginalBestQualityFinalSize; - - dng_urational fOriginalDefaultCropSizeH; - dng_urational fOriginalDefaultCropSizeV; - - public: - - dng_shared (); - - virtual ~dng_shared (); - - virtual bool ParseTag (dng_stream &stream, - dng_exif &exif, - uint32 parentCode, - bool isMainIFD, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset, - int64 offsetDelta); - - virtual void PostParse (dng_host &host, - dng_exif &exif); - - virtual bool IsValidDNG (); - - protected: - - virtual bool Parse_ifd0 (dng_stream &stream, - dng_exif &exif, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - virtual bool Parse_ifd0_exif (dng_stream &stream, - dng_exif &exif, - uint32 parentCode, - uint32 tagCode, - uint32 tagType, - uint32 tagCount, - uint64 tagOffset); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_simple_image.cpp b/third_party/dng_sdk/dng_simple_image.cpp deleted file mode 100644 index 03b5b59..0000000 --- a/third_party/dng_sdk/dng_simple_image.cpp +++ /dev/null @@ -1,197 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_simple_image.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_simple_image.h" - -#include "dng_memory.h" -#include "dng_orientation.h" -#include "dng_tag_types.h" - -/*****************************************************************************/ - -dng_simple_image::dng_simple_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType, - dng_memory_allocator &allocator) - - : dng_image (bounds, - planes, - pixelType) - - , fMemory () - , fBuffer () - , fAllocator (allocator) - - { - - uint32 pixelSize = TagTypeSize (pixelType); - - uint32 bytes = bounds.H () * bounds.W () * planes * pixelSize; - - fMemory.Reset (allocator.Allocate (bytes)); - - fBuffer.fArea = bounds; - - fBuffer.fPlane = 0; - fBuffer.fPlanes = planes; - - fBuffer.fRowStep = planes * bounds.W (); - fBuffer.fColStep = planes; - fBuffer.fPlaneStep = 1; - - fBuffer.fPixelType = pixelType; - fBuffer.fPixelSize = pixelSize; - - fBuffer.fData = fMemory->Buffer (); - - } - -/*****************************************************************************/ - -dng_simple_image::~dng_simple_image () - { - - } - -/*****************************************************************************/ - -dng_image * dng_simple_image::Clone () const - { - - AutoPtr result (new dng_simple_image (Bounds (), - Planes (), - PixelType (), - fAllocator)); - - result->fBuffer.CopyArea (fBuffer, - Bounds (), - 0, - Planes ()); - - return result.Release (); - - } - -/*****************************************************************************/ - -void dng_simple_image::SetPixelType (uint32 pixelType) - { - - dng_image::SetPixelType (pixelType); - - fBuffer.fPixelType = pixelType; - - } - -/*****************************************************************************/ - -void dng_simple_image::Trim (const dng_rect &r) - { - - fBounds.t = 0; - fBounds.l = 0; - - fBounds.b = r.H (); - fBounds.r = r.W (); - - fBuffer.fData = fBuffer.DirtyPixel (r.t, r.l); - - fBuffer.fArea = fBounds; - - } - -/*****************************************************************************/ - -void dng_simple_image::Rotate (const dng_orientation &orientation) - { - - int32 originH = fBounds.l; - int32 originV = fBounds.t; - - int32 colStep = fBuffer.fColStep; - int32 rowStep = fBuffer.fRowStep; - - uint32 width = fBounds.W (); - uint32 height = fBounds.H (); - - if (orientation.FlipH ()) - { - - originH += width - 1; - - colStep = -colStep; - - } - - if (orientation.FlipV ()) - { - - originV += height - 1; - - rowStep = -rowStep; - - } - - if (orientation.FlipD ()) - { - - int32 temp = colStep; - - colStep = rowStep; - rowStep = temp; - - width = fBounds.H (); - height = fBounds.W (); - - } - - fBuffer.fData = fBuffer.DirtyPixel (originV, originH); - - fBuffer.fColStep = colStep; - fBuffer.fRowStep = rowStep; - - fBounds.r = fBounds.l + width; - fBounds.b = fBounds.t + height; - - fBuffer.fArea = fBounds; - - } - -/*****************************************************************************/ - -void dng_simple_image::AcquireTileBuffer (dng_tile_buffer &buffer, - const dng_rect &area, - bool dirty) const - { - - buffer.fArea = area; - - buffer.fPlane = fBuffer.fPlane; - buffer.fPlanes = fBuffer.fPlanes; - buffer.fRowStep = fBuffer.fRowStep; - buffer.fColStep = fBuffer.fColStep; - buffer.fPlaneStep = fBuffer.fPlaneStep; - buffer.fPixelType = fBuffer.fPixelType; - buffer.fPixelSize = fBuffer.fPixelSize; - - buffer.fData = (void *) fBuffer.ConstPixel (buffer.fArea.t, - buffer.fArea.l, - buffer.fPlane); - - buffer.fDirty = dirty; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_simple_image.h b/third_party/dng_sdk/dng_simple_image.h deleted file mode 100644 index 006337d..0000000 --- a/third_party/dng_sdk/dng_simple_image.h +++ /dev/null @@ -1,82 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_simple_image.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_simple_image__ -#define __dng_simple_image__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_image.h" -#include "dng_pixel_buffer.h" - -/*****************************************************************************/ - -/// dng_image derived class with simple Trim and Rotate functionality. - -class dng_simple_image : public dng_image - { - - protected: - - dng_pixel_buffer fBuffer; - - AutoPtr fMemory; - - dng_memory_allocator &fAllocator; - - public: - - dng_simple_image (const dng_rect &bounds, - uint32 planes, - uint32 pixelType, - dng_memory_allocator &allocator); - - virtual ~dng_simple_image (); - - virtual dng_image * Clone () const; - - /// Setter for pixel type. - - virtual void SetPixelType (uint32 pixelType); - - /// Trim image data outside of given bounds. Memory is not reallocated or freed. - - virtual void Trim (const dng_rect &r); - - /// Rotate image according to orientation. - - virtual void Rotate (const dng_orientation &orientation); - - /// Get the buffer for direct processing. (Unique to dng_simple_image.) - - void GetPixelBuffer (dng_pixel_buffer &buffer) - { - buffer = fBuffer; - } - - protected: - - virtual void AcquireTileBuffer (dng_tile_buffer &buffer, - const dng_rect &area, - bool dirty) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_spline.cpp b/third_party/dng_sdk/dng_spline.cpp deleted file mode 100644 index cd47532..0000000 --- a/third_party/dng_sdk/dng_spline.cpp +++ /dev/null @@ -1,233 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_spline.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_spline.h" - -#include "dng_assertions.h" -#include "dng_exceptions.h" - -/******************************************************************************/ - -dng_spline_solver::dng_spline_solver () - - : X () - , Y () - , S () - - { - - } - -/******************************************************************************/ - -dng_spline_solver::~dng_spline_solver () - { - - } - -/******************************************************************************/ - -void dng_spline_solver::Reset () - { - - X.clear (); - Y.clear (); - - S.clear (); - - } - -/******************************************************************************/ - -void dng_spline_solver::Add (real64 x, real64 y) - { - - X.push_back (x); - Y.push_back (y); - - } - -/******************************************************************************/ - -void dng_spline_solver::Solve () - { - - // This code computes the unique curve such that: - // It is C0, C1, and C2 continuous - // The second derivative is zero at the end points - - int32 count = (int32) X.size (); - - DNG_ASSERT (count >= 2, "Too few points"); - - int32 start = 0; - int32 end = count; - - real64 A = X [start+1] - X [start]; - real64 B = (Y [start+1] - Y [start]) / A; - - S.resize (count); - - S [start] = B; - - int32 j; - - // Slopes here are a weighted average of the slopes - // to each of the adjcent control points. - - for (j = start + 2; j < end; ++j) - { - - real64 C = X [j] - X [j-1]; - real64 D = (Y [j] - Y [j-1]) / C; - - S [j-1] = (B * C + D * A) / (A + C); - - A = C; - B = D; - - } - - S [end-1] = 2.0 * B - S [end-2]; - S [start] = 2.0 * S [start] - S [start+1]; - - if ((end - start) > 2) - { - - std::vector E; - std::vector F; - std::vector G; - - E.resize (count); - F.resize (count); - G.resize (count); - - F [start] = 0.5; - E [end-1] = 0.5; - G [start] = 0.75 * (S [start] + S [start+1]); - G [end-1] = 0.75 * (S [end-2] + S [end-1]); - - for (j = start+1; j < end - 1; ++j) - { - - A = (X [j+1] - X [j-1]) * 2.0; - - E [j] = (X [j+1] - X [j]) / A; - F [j] = (X [j] - X [j-1]) / A; - G [j] = 1.5 * S [j]; - - } - - for (j = start+1; j < end; ++j) - { - - A = 1.0 - F [j-1] * E [j]; - - if (j != end-1) F [j] /= A; - - G [j] = (G [j] - G [j-1] * E [j]) / A; - - } - - for (j = end - 2; j >= start; --j) - G [j] = G [j] - F [j] * G [j+1]; - - for (j = start; j < end; ++j) - S [j] = G [j]; - - } - - } - -/******************************************************************************/ - -bool dng_spline_solver::IsIdentity () const - { - - int32 count = (int32) X.size (); - - if (count != 2) - return false; - - if (X [0] != 0.0 || X [1] != 1.0 || - Y [0] != 0.0 || Y [1] != 1.0) - return false; - - return true; - - } - -/******************************************************************************/ - -real64 dng_spline_solver::Evaluate (real64 x) const - { - - int32 count = (int32) X.size (); - - // Check for off each end of point list. - - if (x <= X [0]) - return Y [0]; - - if (x >= X [count-1]) - return Y [count-1]; - - // Binary search for the index. - - int32 lower = 1; - int32 upper = count - 1; - - while (upper > lower) - { - - int32 mid = (lower + upper) >> 1; - - if (x == X [mid]) - { - return Y [mid]; - } - - if (x > X [mid]) - lower = mid + 1; - else - upper = mid; - - } - - DNG_ASSERT (upper == lower, "Binary search error in point list"); - - int32 j = lower; - - // X [j - 1] < x <= X [j] - // A is the distance between the X [j] and X [j - 1] - // B and C describe the fractional distance to either side. B + C = 1. - - // We compute a cubic spline between the two points with slopes - // S[j-1] and S[j] at either end. Specifically, we compute the 1-D Bezier - // with control values: - // - // Y[j-1], Y[j-1] + S[j-1]*A, Y[j]-S[j]*A, Y[j] - - return EvaluateSplineSegment (x, - X [j - 1], - Y [j - 1], - S [j - 1], - X [j ], - Y [j ], - S [j ]); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_spline.h b/third_party/dng_sdk/dng_spline.h deleted file mode 100644 index d2ccdf3..0000000 --- a/third_party/dng_sdk/dng_spline.h +++ /dev/null @@ -1,83 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_spline.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_spline__ -#define __dng_spline__ - -/*****************************************************************************/ - -#include "dng_1d_function.h" - -#include - -/*****************************************************************************/ - -inline real64 EvaluateSplineSegment (real64 x, - real64 x0, - real64 y0, - real64 s0, - real64 x1, - real64 y1, - real64 s1) - { - - real64 A = x1 - x0; - - real64 B = (x - x0) / A; - - real64 C = (x1 - x) / A; - - real64 D = ((y0 * (2.0 - C + B) + (s0 * A * B)) * (C * C)) + - ((y1 * (2.0 - B + C) - (s1 * A * C)) * (B * B)); - - return D; - - } - -/*****************************************************************************/ - -class dng_spline_solver: public dng_1d_function - { - - protected: - - std::vector X; - std::vector Y; - - std::vector S; - - public: - - dng_spline_solver (); - - virtual ~dng_spline_solver (); - - void Reset (); - - void Add (real64 x, real64 y); - - virtual void Solve (); - - virtual bool IsIdentity () const; - - virtual real64 Evaluate (real64 x) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_stream.cpp b/third_party/dng_sdk/dng_stream.cpp deleted file mode 100644 index 5071799..0000000 --- a/third_party/dng_sdk/dng_stream.cpp +++ /dev/null @@ -1,1219 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_stream.cpp#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_stream.h" - -#include "dng_abort_sniffer.h" -#include "dng_auto_ptr.h" -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_memory.h" -#include "dng_tag_types.h" - -/*****************************************************************************/ - -dng_stream::dng_stream (dng_abort_sniffer *sniffer, - uint32 bufferSize, - uint64 offsetInOriginalFile) - - : fSwapBytes (false) - , fHaveLength (false) - , fLength (0) - , fOffsetInOriginalFile (offsetInOriginalFile) - , fPosition (0) - , fMemBlock (bufferSize) - , fBuffer (fMemBlock.Buffer_uint8 ()) - , fBufferSize (bufferSize) - , fBufferStart (0) - , fBufferEnd (0) - , fBufferLimit (bufferSize) - , fBufferDirty (false) - , fSniffer (sniffer) - - { - - } - -/*****************************************************************************/ - -dng_stream::dng_stream (const void *data, - uint32 count, - uint64 offsetInOriginalFile) - - : fSwapBytes (false) - , fHaveLength (true) - , fLength (count) - , fOffsetInOriginalFile (offsetInOriginalFile) - , fPosition (0) - , fMemBlock () - , fBuffer ((uint8 *) data) - , fBufferSize (count) - , fBufferStart (0) - , fBufferEnd (count) - , fBufferLimit (count) - , fBufferDirty (false) - , fSniffer (NULL) - - { - - } - -/*****************************************************************************/ - -dng_stream::~dng_stream () - { - - } - -/*****************************************************************************/ - -uint64 dng_stream::DoGetLength () - { - - ThrowProgramError (); - - return 0; - - } - -/*****************************************************************************/ - -void dng_stream::DoRead (void * /* data */, - uint32 /* count */, - uint64 /* offset */) - { - - ThrowProgramError (); - - } - -/*****************************************************************************/ - -void dng_stream::DoSetLength (uint64 /* length */) - { - - ThrowProgramError (); - - } - -/*****************************************************************************/ - -void dng_stream::DoWrite (const void * /* data */, - uint32 /* count */, - uint64 /* offset */) - { - - ThrowProgramError (); - - } - -/*****************************************************************************/ - -bool dng_stream::BigEndian () const - { - - return fSwapBytes != (!!qDNGBigEndian); - - } - -/*****************************************************************************/ - -void dng_stream::SetBigEndian (bool bigEndian) - { - - fSwapBytes = (bigEndian != (!!qDNGBigEndian)); - - } - -/*****************************************************************************/ - -const void * dng_stream::Data () const - { - - if (fBufferStart == 0 && fHaveLength && fBufferEnd == fLength) - { - - return fBuffer; - - } - - return NULL; - - } - -/*****************************************************************************/ - -dng_memory_block * dng_stream::AsMemoryBlock (dng_memory_allocator &allocator) - { - - Flush (); - - uint64 len64 = Length (); - - if (len64 > 0xFFFFFFFF) - { - ThrowProgramError (); - } - - uint32 len = (uint32) len64; - - AutoPtr block (allocator.Allocate (len)); - - if (len) - { - - SetReadPosition (0); - - Get (block->Buffer (), len); - - } - - return block.Release (); - - } - -/*****************************************************************************/ - -void dng_stream::SetReadPosition (uint64 offset) - { - - fPosition = offset; - - if (fPosition > Length ()) - { - - ThrowEndOfFile (); - - } - - } - -/*****************************************************************************/ - -uint64 dng_stream::OffsetInOriginalFile () const - { - - return fOffsetInOriginalFile; - - } - -/*****************************************************************************/ - -uint64 dng_stream::PositionInOriginalFile () const - { - - if (fOffsetInOriginalFile == kDNGStreamInvalidOffset) - return kDNGStreamInvalidOffset; - - return fOffsetInOriginalFile + Position (); - - } - -/*****************************************************************************/ - -void dng_stream::Get (void *data, uint32 count) - { - - while (count) - { - - // See if the request is totally inside buffer. - - if (fPosition >= fBufferStart && fPosition + count <= fBufferEnd) - { - - DoCopyBytes (fBuffer + (uint32) (fPosition - fBufferStart), - data, - count); - - fPosition += count; - - return; - - } - - // See if first part of request is inside buffer. - - if (fPosition >= fBufferStart && fPosition < fBufferEnd) - { - - uint32 block = (uint32) (fBufferEnd - fPosition); - - DoCopyBytes (fBuffer + (fPosition - fBufferStart), - data, - block); - - count -= block; - - data = (void *) (((char *) data) + block); - - fPosition += block; - - } - - // Flush buffer if dirty. - - Flush (); - - // Do large reads unbuffered. - - if (count > fBufferSize) - { - - if (fPosition + count > Length ()) - { - - ThrowEndOfFile (); - - } - - DoRead (data, - count, - fPosition); - - fPosition += count; - - return; - - } - - // Figure out new buffer range. - - fBufferStart = fPosition; - - if (fBufferSize >= 4096) - { - - // Align to a 4K file block. - - fBufferStart &= (uint64) ~((int64) 4095); - - } - - fBufferEnd = Min_uint64 (fBufferStart + fBufferSize, Length ()); - - if (fBufferEnd <= fPosition) - { - - ThrowEndOfFile (); - - } - - // Read data into buffer. - - dng_abort_sniffer::SniffForAbort (fSniffer); - - DoRead (fBuffer, - (uint32) (fBufferEnd - fBufferStart), - fBufferStart); - - } - - } - -/*****************************************************************************/ - -void dng_stream::SetWritePosition (uint64 offset) - { - - fPosition = offset; - - } - -/*****************************************************************************/ - -void dng_stream::Flush () - { - - if (fBufferDirty) - { - - dng_abort_sniffer::SniffForAbort (fSniffer); - - DoWrite (fBuffer, - (uint32) (fBufferEnd - fBufferStart), - fBufferStart); - - fBufferStart = 0; - fBufferEnd = 0; - fBufferLimit = fBufferSize; - - fBufferDirty = false; - - } - - } - -/*****************************************************************************/ - -void dng_stream::SetLength (uint64 length) - { - - Flush (); - - if (Length () != length) - { - - DoSetLength (length); - - fLength = length; - - } - - } - -/*****************************************************************************/ - -void dng_stream::Put (const void *data, - uint32 count) - { - - // See if we can replace or append to the existing buffer. - - uint64 endPosition = fPosition + count; - - if (fBufferDirty && - fPosition >= fBufferStart && - fPosition <= fBufferEnd && - endPosition <= fBufferLimit) - { - - DoCopyBytes (data, - fBuffer + (uint32) (fPosition - fBufferStart), - count); - - if (fBufferEnd < endPosition) - fBufferEnd = endPosition; - - } - - // Else we need to write to the file. - - else - { - - // Write existing buffer. - - Flush (); - - // Write large blocks unbuffered. - - if (count >= fBufferSize) - { - - dng_abort_sniffer::SniffForAbort (fSniffer); - - DoWrite (data, count, fPosition); - - } - - // Start a new buffer with small blocks. - - else - { - - fBufferDirty = true; - - fBufferStart = fPosition; - fBufferEnd = endPosition; - fBufferLimit = fBufferStart + fBufferSize; - - DoCopyBytes (data, - fBuffer, - count); - - } - - } - - fPosition = endPosition; - - fLength = Max_uint64 (Length (), fPosition); - - } - -/*****************************************************************************/ - -uint16 dng_stream::Get_uint16 () - { - - uint16 x; - - Get (&x, 2); - - if (fSwapBytes) - { - - x = SwapBytes16 (x); - - } - - return x; - - } - -/*****************************************************************************/ - -void dng_stream::Put_uint16 (uint16 x) - { - - if (fSwapBytes) - { - - x = SwapBytes16 (x); - - } - - Put (&x, 2); - - } - -/*****************************************************************************/ - -uint32 dng_stream::Get_uint32 () - { - - uint32 x; - - Get (&x, 4); - - if (fSwapBytes) - { - - x = SwapBytes32 (x); - - } - - return x; - - } - -/*****************************************************************************/ - -void dng_stream::Put_uint32 (uint32 x) - { - - if (fSwapBytes) - { - - x = SwapBytes32 (x); - - } - - Put (&x, 4); - - } - -/*****************************************************************************/ - -uint64 dng_stream::Get_uint64 () - { - - if (fSwapBytes) - { - - union - { - uint32 u32 [2]; - uint64 u64; - } u; - - u.u32 [1] = Get_uint32 (); - u.u32 [0] = Get_uint32 (); - - return u.u64; - - } - - uint64 x; - - Get (&x, 8); - - return x; - - } - -/*****************************************************************************/ - -void dng_stream::Put_uint64 (uint64 x) - { - - if (fSwapBytes) - { - - union - { - uint32 u32 [2]; - uint64 u64; - } u; - - u.u64 = x; - - Put_uint32 (u.u32 [1]); - Put_uint32 (u.u32 [0]); - - } - - else - { - - Put (&x, 8); - - } - - } - -/*****************************************************************************/ - -real32 dng_stream::Get_real32 () - { - - union - { - uint32 i; - real32 r; - } u; - - u.i = Get_uint32 (); - - return u.r; - - } - -/*****************************************************************************/ - -void dng_stream::Put_real32 (real32 x) - { - - if (fSwapBytes) - { - - union - { - uint32 i; - real32 r; - } u; - - u.r = x; - - Put_uint32 (u.i); - - } - - else - { - - Put (&x, 4); - - } - - } - -/*****************************************************************************/ - -real64 dng_stream::Get_real64 () - { - - if (fSwapBytes) - { - - union - { - uint32 i [2]; - real64 r; - } u; - - u.i [1] = Get_uint32 (); - u.i [0] = Get_uint32 (); - - return u.r; - - } - - real64 x; - - Get (&x, 8); - - return x; - - } - -/*****************************************************************************/ - -void dng_stream::Put_real64 (real64 x) - { - - if (fSwapBytes) - { - - union - { - uint32 i [2]; - real64 r; - } u; - - u.r = x; - - Put_uint32 (u.i [1]); - Put_uint32 (u.i [0]); - - } - - else - { - - Put (&x, 8); - - } - - } - -/*****************************************************************************/ - -void dng_stream::Get_CString (char *data, uint32 maxLength) - { - - memset (data, 0, maxLength); - - uint32 index = 0; - - while (true) - { - - char c = (char) Get_uint8 (); - - if (index + 1 < maxLength) - data [index++] = c; - - if (c == 0) - break; - - } - - } - -/*****************************************************************************/ - -void dng_stream::Get_UString (char *data, uint32 maxLength) - { - - memset (data, 0, maxLength); - - uint32 index = 0; - - while (true) - { - - char c = (char) Get_uint16 (); - - if (index + 1 < maxLength) - data [index++] = (char) c; - - if (c == 0) - break; - - } - - } - -/*****************************************************************************/ - -void dng_stream::PutZeros (uint64 count) - { - - const uint32 kZeroBufferSize = 4096; - - if (count >= kZeroBufferSize) - { - - dng_memory_data zeroBuffer (kZeroBufferSize); - - DoZeroBytes (zeroBuffer.Buffer (), - kZeroBufferSize); - - while (count) - { - - uint64 blockSize = Min_uint64 (count, kZeroBufferSize); - - Put (zeroBuffer.Buffer (), (uint32) blockSize); - - count -= blockSize; - - } - - } - - else - { - - uint32 count32 = (uint32) count; - - for (uint32 j = 0; j < count32; j++) - { - - Put_uint8 (0); - - } - - } - - } - -/*****************************************************************************/ - -void dng_stream::PadAlign2 () - { - - PutZeros (Position () & 1); - - } - -/*****************************************************************************/ - -void dng_stream::PadAlign4 () - { - - PutZeros ((4 - (Position () & 3)) & 3); - - } - -/*****************************************************************************/ - -uint32 dng_stream::TagValue_uint32 (uint32 tagType) - { - - switch (tagType) - { - - case ttByte: - return (uint32) Get_uint8 (); - - case ttShort: - return (uint32) Get_uint16 (); - - case ttLong: - case ttIFD: - return Get_uint32 (); - - } - - real64 x = TagValue_real64 (tagType); - - if (x < 0.0) - x = 0.0; - - if (x > (real64) 0xFFFFFFFF) - x = (real64) 0xFFFFFFFF; - - return (uint32) (x + 0.5); - - } - -/*****************************************************************************/ - -int32 dng_stream::TagValue_int32 (uint32 tagType) - { - - switch (tagType) - { - - case ttSByte: - return (int32) Get_int8 (); - - case ttSShort: - return (int32) Get_int16 (); - - case ttSLong: - return Get_int32 (); - - } - - real64 x = TagValue_real64 (tagType); - - if (x < 0.0) - { - - if (x < -2147483648.0) - x = -2147483648.0; - - return (int32) (x - 0.5); - - } - - else - { - - if (x > 2147483647.0) - x = 2147483647.0; - - return (int32) (x + 0.5); - - } - - } - -/*****************************************************************************/ - -dng_urational dng_stream::TagValue_urational (uint32 tagType) - { - - dng_urational result; - - result.n = 0; - result.d = 1; - - switch (tagType) - { - - case ttRational: - { - - result.n = Get_uint32 (); - result.d = Get_uint32 (); - - break; - - } - - case ttSRational: - { - - int32 n = Get_int32 (); - int32 d = Get_int32 (); - - if ((n < 0) == (d < 0)) - { - - if (d < 0) - { - n = -n; - d = -d; - } - - result.n = (uint32) n; - result.d = (uint32) d; - - } - - break; - - } - - case ttByte: - case ttShort: - case ttLong: - case ttIFD: - { - - result.n = TagValue_uint32 (tagType); - - break; - - } - - case ttSByte: - case ttSShort: - case ttSLong: - { - - int32 n = TagValue_int32 (tagType); - - if (n > 0) - { - result.n = (uint32) n; - } - - break; - - } - - default: - { - - real64 x = TagValue_real64 (tagType); - - if (x > 0.0) - { - - while (result.d < 10000 && x < 1000000) - { - - result.d *= 10; - - x *= 10.0; - - } - - result.n = (uint32) (x + 0.5); - - } - - } - - } - - return result; - - } - -/*****************************************************************************/ - -dng_srational dng_stream::TagValue_srational (uint32 tagType) - { - - dng_srational result; - - result.n = 0; - result.d = 1; - - switch (tagType) - { - - case ttSRational: - { - - result.n = Get_int32 (); - result.d = Get_int32 (); - - break; - - } - - default: - { - - real64 x = TagValue_real64 (tagType); - - if (x > 0.0) - { - - while (result.d < 10000 && x < 1000000.0) - { - - result.d *= 10; - - x *= 10.0; - - } - - result.n = (int32) (x + 0.5); - - } - - else - { - - while (result.d < 10000 && x > -1000000.0) - { - - result.d *= 10; - - x *= 10.0; - - } - - result.n = (int32) (x - 0.5); - - } - - } - - } - - return result; - - } - -/*****************************************************************************/ - -real64 dng_stream::TagValue_real64 (uint32 tagType) - { - - switch (tagType) - { - - case ttByte: - case ttShort: - case ttLong: - case ttIFD: - return (real64) TagValue_uint32 (tagType); - - case ttSByte: - case ttSShort: - case ttSLong: - return (real64) TagValue_int32 (tagType); - - case ttRational: - { - - uint32 n = Get_uint32 (); - uint32 d = Get_uint32 (); - - if (d == 0) - return 0.0; - else - return (real64) n / (real64) d; - - } - - case ttSRational: - { - - int32 n = Get_int32 (); - int32 d = Get_int32 (); - - if (d == 0) - return 0.0; - else - return (real64) n / (real64) d; - - } - - case ttFloat: - return (real64) Get_real32 (); - - case ttDouble: - return Get_real64 (); - - } - - return 0.0; - - } - -/*****************************************************************************/ - -void dng_stream::CopyToStream (dng_stream &dstStream, - uint64 count) - { - - uint8 smallBuffer [1024]; - - if (count <= sizeof (smallBuffer)) - { - - Get (smallBuffer, (uint32) count); - - dstStream.Put (smallBuffer, (uint32) count); - - } - - else - { - - const uint32 bigBufferSize = (uint32) Min_uint64 (kBigBufferSize, - count); - - dng_memory_data bigBuffer (bigBufferSize); - - while (count) - { - - uint32 blockCount = (uint32) Min_uint64 (bigBufferSize, - count); - - Get (bigBuffer.Buffer (), - blockCount); - - dstStream.Put (bigBuffer.Buffer (), - blockCount); - - count -= blockCount; - - } - - } - - } - -/*****************************************************************************/ - -void dng_stream::DuplicateStream (dng_stream &dstStream) - { - - // Turn off sniffers for this operation. - - TempStreamSniffer noSniffer1 (*this , NULL); - TempStreamSniffer noSniffer2 (dstStream, NULL); - - // First grow the destination stream if required, in an attempt to - // reserve any needed space before overwriting the existing data. - - if (dstStream.Length () < Length ()) - { - dstStream.SetLength (Length ()); - } - - SetReadPosition (0); - - dstStream.SetWritePosition (0); - - CopyToStream (dstStream, Length ()); - - dstStream.Flush (); - - dstStream.SetLength (Length ()); - - } - -/*****************************************************************************/ - -TempBigEndian::TempBigEndian (dng_stream &stream, - bool bigEndian) - - : fStream (stream) - , fOldSwap (stream.SwapBytes ()) - - { - - fStream.SetBigEndian (bigEndian); - - } - -/*****************************************************************************/ - -TempBigEndian::~TempBigEndian () - { - - fStream.SetSwapBytes (fOldSwap); - - } - -/*****************************************************************************/ - -TempStreamSniffer::TempStreamSniffer (dng_stream &stream, - dng_abort_sniffer *sniffer) - - : fStream (stream) - , fOldSniffer (stream.Sniffer ()) - - { - - fStream.SetSniffer (sniffer); - - } - -/*****************************************************************************/ - -TempStreamSniffer::~TempStreamSniffer () - { - - fStream.SetSniffer (fOldSniffer); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_stream.h b/third_party/dng_sdk/dng_stream.h deleted file mode 100644 index df233ae..0000000 --- a/third_party/dng_sdk/dng_stream.h +++ /dev/null @@ -1,698 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_stream.h#2 $ */ -/* $DateTime: 2012/06/01 07:28:57 $ */ -/* $Change: 832715 $ */ -/* $Author: tknoll $ */ - -/** Data stream abstraction for serializing and deserializing sequences of - * basic types and RAW image data. - */ - -/*****************************************************************************/ - -#ifndef __dng_stream__ -#define __dng_stream__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" -#include "dng_memory.h" -#include "dng_rational.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -// Constants for invalid offset in streams. - -const uint64 kDNGStreamInvalidOffset = (uint64) (int64) -1; - -/*****************************************************************************/ - -/// Base stream abstraction. Has support for going between stream and pointer -/// abstraction. - -class dng_stream - { - - public: - - enum - { - - kSmallBufferSize = 4 * 1024, - kBigBufferSize = 64 * 1024, - - kDefaultBufferSize = kSmallBufferSize - - }; - - private: - - bool fSwapBytes; - - bool fHaveLength; - - uint64 fLength; - - const uint64 fOffsetInOriginalFile; - - uint64 fPosition; - - dng_memory_data fMemBlock; - - uint8 *fBuffer; - - uint32 fBufferSize; - - uint64 fBufferStart; - uint64 fBufferEnd; - uint64 fBufferLimit; - - bool fBufferDirty; - - dng_abort_sniffer *fSniffer; - - protected: - - dng_stream (dng_abort_sniffer *sniffer = NULL, - uint32 bufferSize = kDefaultBufferSize, - uint64 offsetInOriginalFile = kDNGStreamInvalidOffset); - - virtual uint64 DoGetLength (); - - virtual void DoRead (void *data, - uint32 count, - uint64 offset); - - virtual void DoSetLength (uint64 length); - - virtual void DoWrite (const void *data, - uint32 count, - uint64 offset); - - public: - - /// Construct a stream with initial data. - /// \param data Pointer to initial contents of stream. - /// \param count Number of bytes data is valid for. - /// \param offsetInOriginalFile If data came from a file originally, - /// offset can be saved here for later use. - - dng_stream (const void *data, - uint32 count, - uint64 offsetInOriginalFile = kDNGStreamInvalidOffset); - - virtual ~dng_stream (); - - /// Getter for whether stream is swapping byte order on input/output. - /// \retval If true, data will be swapped on input/output. - - bool SwapBytes () const - { - return fSwapBytes; - } - - /// Setter for whether stream is swapping byte order on input/output. - /// \param swapBytes If true, stream will swap byte order on input or - /// output for future reads/writes. - - void SetSwapBytes (bool swapBytes) - { - fSwapBytes = swapBytes; - } - - /// Getter for whether data in stream is big endian. - /// \retval If true, data in stream is big endian. - - bool BigEndian () const; - - /// Setter for whether data in stream is big endian. - /// \param bigEndian If true, data in stream is big endian. - - void SetBigEndian (bool bigEndian = true); - - /// Getter for whether data in stream is big endian. - /// \retval If true, data in stream is big endian. - - bool LittleEndian () const - { - return !BigEndian (); - } - - /// Setter for whether data in stream is big endian. - /// \param littleEndian If true, data in stream is big endian. - - void SetLittleEndian (bool littleEndian = true) - { - SetBigEndian (!littleEndian); - } - - /// Returns the size of the buffer used by the stream. - - uint32 BufferSize () const - { - return fBufferSize; - } - - /// Getter for length of data in stream. - /// \retval Length of readable data in stream. - - uint64 Length () - { - - if (!fHaveLength) - { - - fLength = DoGetLength (); - - fHaveLength = true; - - } - - return fLength; - - } - - /// Getter for current offset in stream. - /// \retval current offset from start of stream. - - uint64 Position () const - { - return fPosition; - } - - /// Getter for current position in original file, taking into account - /// OffsetInOriginalFile stream data was taken from. - /// \retval kInvalidOffset if no offset in original file is set, sum - /// of offset in original file and current position otherwise. - - uint64 PositionInOriginalFile () const; - - /// Getter for offset in original file. - /// \retval kInvalidOffset if no offset in original file is set, - /// offset in original file otherwise. - - uint64 OffsetInOriginalFile () const; - - /// Return pointer to stream contents if the stream is entirely - /// available as a single memory block, NULL otherwise. - - const void * Data () const; - - /// Return the entire stream as a single memory block. - /// This works for all streams, but requires copying the data to a new buffer. - /// \param allocator Allocator used to allocate memory. - - dng_memory_block * AsMemoryBlock (dng_memory_allocator &allocator); - - /// Seek to a new position in stream for reading. - - void SetReadPosition (uint64 offset); - - /// Skip forward in stream. - /// \param delta Number of bytes to skip forward. - - void Skip (uint64 delta) - { - SetReadPosition (Position () + delta); - } - - /// Get data from stream. Exception is thrown and no data is read if - /// insufficient data available in stream. - /// \param data Buffer to put data into. Must be valid for count bytes. - /// \param count Bytes of data to read. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - void Get (void *data, uint32 count); - - /// Seek to a new position in stream for writing. - - void SetWritePosition (uint64 offset); - - /// Force any stored data in stream to be written to underlying storage. - - void Flush (); - - /// Set length of available data. - /// \param length Number of bytes of avialble data in stream. - - void SetLength (uint64 length); - - /// Write data to stream. - /// \param data Buffer of data to write to stream. - /// \param count Bytes of in data. - - void Put (const void *data, uint32 count); - - /// Get an unsigned 8-bit integer from stream and advance read position. - /// \retval One unsigned 8-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - uint8 Get_uint8 () - { - - // Fast check to see if in buffer - - if (fPosition >= fBufferStart && fPosition < fBufferEnd) - { - - return fBuffer [fPosition++ - fBufferStart]; - - } - - // Not in buffer, let main routine do the work. - - uint8 x; - - Get (&x, 1); - - return x; - - } - - /// Put an unsigned 8-bit integer to stream and advance write position. - /// \param x One unsigned 8-bit integer. - - void Put_uint8 (uint8 x) - { - - if (fBufferDirty && - fPosition >= fBufferStart && - fPosition <= fBufferEnd && - fPosition < fBufferLimit) - { - - fBuffer [fPosition - fBufferStart] = x; - - fPosition++; - - if (fBufferEnd < fPosition) - fBufferEnd = fPosition; - - fLength = Max_uint64 (Length (), fPosition); - - } - - else - { - - Put (&x, 1); - - } - - } - - /// Get an unsigned 16-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One unsigned 16-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - uint16 Get_uint16 (); - - /// Put an unsigned 16-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One unsigned 16-bit integer. - - void Put_uint16 (uint16 x); - - /// Get an unsigned 32-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One unsigned 32-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - uint32 Get_uint32 (); - - /// Put an unsigned 32-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One unsigned 32-bit integer. - - void Put_uint32 (uint32 x); - - /// Get an unsigned 64-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One unsigned 64-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - uint64 Get_uint64 (); - - /// Put an unsigned 64-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One unsigned 64-bit integer. - - void Put_uint64 (uint64 x); - - /// Get one 8-bit integer from stream and advance read position. - /// \retval One 8-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - int8 Get_int8 () - { - return (int8) Get_uint8 (); - } - - /// Put one 8-bit integer to stream and advance write position. - /// \param x One 8-bit integer. - - void Put_int8 (int8 x) - { - Put_uint8 ((uint8) x); - } - - /// Get one 16-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One 16-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - int16 Get_int16 () - { - return (int16) Get_uint16 (); - } - - /// Put one 16-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One 16-bit integer. - - void Put_int16 (int16 x) - { - Put_uint16 ((uint16) x); - } - - /// Get one 32-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One 32-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - int32 Get_int32 () - { - return (int32) Get_uint32 (); - } - - /// Put one 32-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One 32-bit integer. - - void Put_int32 (int32 x) - { - Put_uint32 ((uint32) x); - } - - /// Get one 64-bit integer from stream and advance read position. - /// Byte swap if byte swapping is turned on. - /// \retval One 64-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - int64 Get_int64 () - { - return (int64) Get_uint64 (); - } - - /// Put one 64-bit integer to stream and advance write position. - /// Byte swap if byte swapping is turned on. - /// \param x One 64-bit integer. - - void Put_int64 (int64 x) - { - Put_uint64 ((uint64) x); - } - - /// Get one 32-bit IEEE floating-point number from stream and advance - /// read position. Byte swap if byte swapping is turned on. - /// \retval One 32-bit IEEE floating-point number. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - real32 Get_real32 (); - - /// Put one 32-bit IEEE floating-point number to stream and advance write - /// position. Byte swap if byte swapping is turned on. - /// \param x One 32-bit IEEE floating-point number. - - void Put_real32 (real32 x); - - /// Get one 64-bit IEEE floating-point number from stream and advance - /// read position. Byte swap if byte swapping is turned on. - /// \retval One 64-bit IEEE floating-point number . - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - real64 Get_real64 (); - - /// Put one 64-bit IEEE floating-point number to stream and advance write - /// position. Byte swap if byte swapping is turned on. - /// \param x One64-bit IEEE floating-point number. - - void Put_real64 (real64 x); - - /// Get an 8-bit character string from stream and advance read position. - /// Routine always reads until a NUL character (8-bits of zero) is read. - /// (That is, only maxLength bytes will be returned in buffer, but the - /// stream is always advanced until a NUL is read or EOF is reached.) - /// \param data Buffer in which string is returned. - /// \param maxLength Maximum number of bytes to place in buffer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if stream runs out before NUL is seen. - - void Get_CString (char *data, - uint32 maxLength); - - /// Get a 16-bit character string from stream and advance read position. - /// 16-bit characters are truncated to 8-bits. - /// Routine always reads until a NUL character (16-bits of zero) is read. - /// (That is, only maxLength bytes will be returned in buffer, but the - /// stream is always advanced until a NUL is read or EOF is reached.) - /// \param data Buffer to place string in. - /// \param maxLength Maximum number of bytes to place in buffer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if stream runs out before NUL is seen. - - void Get_UString (char *data, - uint32 maxLength); - - /// Writes the specified number of zero bytes to stream. - /// \param count Number of zero bytes to write. - - void PutZeros (uint64 count); - - /// Writes zeros to align the stream position to a multiple of 2. - - void PadAlign2 (); - - /// Writes zeros to align the stream position to a multiple of 4. - - void PadAlign4 (); - - /// Get a value of size indicated by tag type from stream and advance - /// read position. Byte swap if byte swapping is turned on and tag type - /// is larger than a byte. Value is returned as an unsigned 32-bit integer. - /// \param tagType Tag type of data stored in stream. - /// \retval One unsigned 32-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - uint32 TagValue_uint32 (uint32 tagType); - - /// Get a value of size indicated by tag type from stream and advance read - /// position. Byte swap if byte swapping is turned on and tag type is larger - /// than a byte. Value is returned as a 32-bit integer. - /// \param tagType Tag type of data stored in stream. - /// \retval One 32-bit integer. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - int32 TagValue_int32 (uint32 tagType); - - /// Get a value of size indicated by tag type from stream and advance read - /// position. Byte swap if byte swapping is turned on and tag type is larger - /// than a byte. Value is returned as a dng_urational. - /// \param tagType Tag type of data stored in stream. - /// \retval One dng_urational. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - dng_urational TagValue_urational (uint32 tagType); - - /// Get a value of size indicated by tag type from stream and advance read - /// position. Byte swap if byte swapping is turned on and tag type is larger - /// than a byte. Value is returned as a dng_srational. - /// \param tagType Tag type of data stored in stream. - /// \retval One dng_srational. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - dng_srational TagValue_srational (uint32 tagType); - - /// Get a value of size indicated by tag type from stream and advance read - /// position. Byte swap if byte swapping is turned on and tag type is larger - /// than a byte. Value is returned as a 64-bit IEEE floating-point number. - /// \param tagType Tag type of data stored in stream. - /// \retval One 64-bit IEEE floating-point number. - /// \exception dng_exception with fErrorCode equal to dng_error_end_of_file - /// if not enough data in stream. - - real64 TagValue_real64 (uint32 tagType); - - /// Getter for sniffer associated with stream. - /// \retval The sniffer for this stream. - - dng_abort_sniffer * Sniffer () const - { - return fSniffer; - } - - /// Putter for sniffer associated with stream. - /// \param sniffer The new sniffer to use (or NULL for none). - - void SetSniffer (dng_abort_sniffer *sniffer) - { - fSniffer = sniffer; - } - - /// Copy a specified number of bytes to a target stream. - /// \param dstStream The target stream. - /// \param count The number of bytes to copy. - - virtual void CopyToStream (dng_stream &dstStream, - uint64 count); - - /// Makes the target stream a copy of this stream. - /// \param dstStream The target stream. - - void DuplicateStream (dng_stream &dstStream); - - private: - - // Hidden copy constructor and assignment operator. - - dng_stream (const dng_stream &stream); - - dng_stream & operator= (const dng_stream &stream); - - }; - -/*****************************************************************************/ - -class TempBigEndian - { - - private: - - dng_stream & fStream; - - bool fOldSwap; - - public: - - TempBigEndian (dng_stream &stream, - bool bigEndian = true); - - virtual ~TempBigEndian (); - - }; - -/*****************************************************************************/ - -class TempLittleEndian: public TempBigEndian - { - - public: - - TempLittleEndian (dng_stream &stream, - bool littleEndian = true) - - : TempBigEndian (stream, !littleEndian) - - { - } - - virtual ~TempLittleEndian () - { - } - - }; - -/*****************************************************************************/ - -class TempStreamSniffer - { - - private: - - dng_stream & fStream; - - dng_abort_sniffer *fOldSniffer; - - public: - - TempStreamSniffer (dng_stream &stream, - dng_abort_sniffer *sniffer); - - virtual ~TempStreamSniffer (); - - private: - - // Hidden copy constructor and assignment operator. - - TempStreamSniffer (const TempStreamSniffer &temp); - - TempStreamSniffer & operator= (const TempStreamSniffer &temp); - - }; - -/*****************************************************************************/ - -class PreserveStreamReadPosition - { - - private: - - dng_stream & fStream; - - uint64 fPosition; - - public: - - PreserveStreamReadPosition (dng_stream &stream) - - : fStream (stream) - , fPosition (stream.Position ()) - - { - } - - ~PreserveStreamReadPosition () - { - fStream.SetReadPosition (fPosition); - } - - private: - - // Hidden copy constructor and assignment operator. - - PreserveStreamReadPosition (const PreserveStreamReadPosition &rhs); - - PreserveStreamReadPosition & operator= (const PreserveStreamReadPosition &rhs); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_string.cpp b/third_party/dng_sdk/dng_string.cpp deleted file mode 100644 index 3596ea3..0000000 --- a/third_party/dng_sdk/dng_string.cpp +++ /dev/null @@ -1,2242 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_string.cpp#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_string.h" - -#include "dng_assertions.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_mutex.h" -#include "dng_utils.h" - -#if qMacOS -#include -#endif - -#if qWinOS -#include -#endif - -#if qiPhone || qAndroid -#include // for isdigit -#endif - -/*****************************************************************************/ - -const uint32 kREPLACEMENT_CHARACTER = 0x0000FFFD; - -/*****************************************************************************/ - -#if qMacOS - -static void Assign_Multibyte (dng_string &dngString, - const char *otherString, - TextEncoding encoding) - { - - uint32 aSize = (uint32) strlen (otherString); - - if (aSize > 0) - { - - uint32 aBufSize = aSize * 6 + 256; - - dng_memory_data aBuf (aBufSize + 1); - - UnicodeMapping aMapping; - - aMapping.unicodeEncoding = ::CreateTextEncoding (kTextEncodingUnicodeV3_0, - kUnicodeNoSubset, - kUnicodeUTF8Format); - - aMapping.otherEncoding = encoding; - aMapping.mappingVersion = kUnicodeUseLatestMapping; - - TextToUnicodeInfo aInfo = NULL; - - if (::CreateTextToUnicodeInfo (&aMapping, &aInfo) == noErr) - { - - ByteCount aInput = 0; - ByteCount aOutput = 0; - - ::ConvertFromTextToUnicode (aInfo, - aSize, - otherString, - kUnicodeUseFallbacksMask | - kUnicodeLooseMappingsMask, - 0, - NULL, - NULL, - NULL, - aBufSize, - &aInput, - &aOutput, - (UniChar *) aBuf.Buffer ()); - - ::DisposeTextToUnicodeInfo (&aInfo); - - if (aOutput > 0 && aOutput <= aBufSize) - { - - char *aBufChar = aBuf.Buffer_char (); - - aBufChar [aOutput] = 0; - - dngString.Set (aBufChar); - - return; - - } - - } - - } - - dngString.Clear (); - - } - -static uint32 Extract_Multibyte (const dng_string &dngString, - dng_memory_data &buffer, - TextEncoding encoding) - { - - uint32 aSize = dngString.Length (); - - if (aSize > 0) - { - - uint32 aBufSize = (aSize * 2) + 256; - - dng_memory_data tempBuffer (aBufSize); - - UnicodeMapping aMapping; - - aMapping.unicodeEncoding = ::CreateTextEncoding (kTextEncodingUnicodeV3_0, - kUnicodeNoSubset, - kUnicodeUTF8Format); - - aMapping.otherEncoding = encoding; - aMapping.mappingVersion = kUnicodeUseLatestMapping; - - UnicodeToTextInfo aInfo = NULL; - - if (::CreateUnicodeToTextInfo (&aMapping, &aInfo) == noErr) - { - - ByteCount aInput = 0; - ByteCount aOutput = 0; - - ::ConvertFromUnicodeToText (aInfo, - aSize, - (const UniChar *) dngString.Get (), - kUnicodeUseFallbacksMask | - kUnicodeLooseMappingsMask | - kUnicodeDefaultDirectionMask, - 0, - NULL, - NULL, - NULL, - aBufSize, - &aInput, - &aOutput, - tempBuffer.Buffer_char ()); - - ::DisposeUnicodeToTextInfo (&aInfo); - - if (aOutput > 0) - { - - buffer.Allocate ((uint32) (aOutput + 1)); - - memcpy (buffer.Buffer (), - tempBuffer.Buffer (), - aOutput); - - buffer.Buffer_char () [aOutput] = 0; - - return (uint32) aOutput; - - } - - } - - } - - buffer.Allocate (1); - - buffer.Buffer_char () [0] = 0; - - return 0; - - } - -static void Assign_SystemEncoding (dng_string &dngString, - const char *otherString) - { - - TextEncoding aEncoding; - - ::UpgradeScriptInfoToTextEncoding (smSystemScript, - kTextLanguageDontCare, - kTextRegionDontCare, - NULL, - &aEncoding); - - Assign_Multibyte (dngString, - otherString, - aEncoding); - - } - -static uint32 Extract_SystemEncoding (const dng_string &dngString, - dng_memory_data &buffer) - { - - TextEncoding aEncoding; - - ::UpgradeScriptInfoToTextEncoding (smSystemScript, - kTextLanguageDontCare, - kTextRegionDontCare, - NULL, - &aEncoding); - - return Extract_Multibyte (dngString, - buffer, - aEncoding); - - } - -static void Assign_JIS_X208_1990 (dng_string &dngString, - const char *otherString) - { - - Assign_Multibyte (dngString, - otherString, - kTextEncodingJIS_X0208_90); - - } - -#endif - -/*****************************************************************************/ - -#if qWinOS - -static void Assign_Multibyte (dng_string &dngString, - const char *otherString, - UINT encoding) - { - - DNG_ASSERT (sizeof (WCHAR) == 2, "WCHAR must be 2 bytes"); - - int aSize = (int) strlen (otherString); - - if (aSize > 0) - { - - int aBufChars = aSize * 3 + 128; - - dng_memory_data aBuf ((aBufChars + 1) << 1); - - int aResult = ::MultiByteToWideChar (encoding, - 0, - otherString, - aSize, - (WCHAR *) aBuf.Buffer (), - aBufChars); - - if (aResult > 0 && aResult <= aBufChars) - { - - uint16 * aUTF16 = aBuf.Buffer_uint16 (); - - aUTF16 [aResult] = 0; - - dngString.Set_UTF16 (aUTF16); - - return; - - } - - } - - dngString.Clear (); - - } - -static uint32 Extract_Multibyte (const dng_string &dngString, - dng_memory_data &buffer, - UINT encoding) - { - - DNG_ASSERT (sizeof (WCHAR) == 2, "WCHAR must be 2 bytes"); - - dng_memory_data sBuffer; - - int aCount = dngString.Get_UTF16 (sBuffer); - - int dBufSize = aCount * 2 + 256; - - dng_memory_data dBuffer (dBufSize); - - int aResult = ::WideCharToMultiByte (encoding, - 0, - (WCHAR *) sBuffer.Buffer (), - aCount, - dBuffer.Buffer_char (), - dBufSize, - NULL, - NULL); - - if (aResult < 0) - aResult = 0; - - buffer.Allocate (aResult + 1); - - memcpy (buffer.Buffer (), - dBuffer.Buffer (), - aResult); - - buffer.Buffer_char () [aResult] = 0; - - return (uint32) aResult; - - } - -static void Assign_SystemEncoding (dng_string &dngString, - const char *otherString) - { - - Assign_Multibyte (dngString, - otherString, - ::GetACP ()); - - } - -static uint32 Extract_SystemEncoding (const dng_string &dngString, - dng_memory_data &buffer) - { - - return Extract_Multibyte (dngString, - buffer, - ::GetACP ()); - - } - -static void Assign_JIS_X208_1990 (dng_string &dngString, - const char *otherString) - { - - // From MSDN documentation: 20932 = JIS X 0208-1990 & 0121-1990 - - const UINT kJIS = 20932; - - Assign_Multibyte (dngString, - otherString, - kJIS); - - } - -#endif - -/*****************************************************************************/ - -static bool IsASCII (const char *s) - { - - if (!s) - { - - return true; - - } - - while (true) - { - - uint8 c = (uint8) *(s++); - - if (c == 0) - { - - break; - - } - - if (c & 0x80) - { - - return false; - - } - - } - - return true; - - } - -/*****************************************************************************/ - -dng_string::dng_string () - - : fData () - - { - - } - -/*****************************************************************************/ - -dng_string::dng_string (const dng_string &s) - - : fData () - - { - - Set (s.Get ()); - - } - -/*****************************************************************************/ - -dng_string & dng_string::operator= (const dng_string &s) - { - - if (this != &s) - { - - Set (s.Get ()); - - } - - return *this; - - } - -/*****************************************************************************/ - -dng_string::~dng_string () - { - - } - -/*****************************************************************************/ - -const char * dng_string::Get () const - { - - if (fData.Buffer ()) - { - - return fData.Buffer_char (); - - } - - return ""; - - } - -/*****************************************************************************/ - -bool dng_string::IsASCII () const - { - - return ::IsASCII (Get ()); - - } - -/*****************************************************************************/ - -void dng_string::Set (const char *s) - { - - // Measure the new length. - - uint32 newLen = (s != NULL ? (uint32) strlen (s) : 0); - - // If it is a NULL string, then clear the buffer. - - if (newLen == 0) - { - - fData.Clear (); - - } - - // Else we need to copy the bytes. - - else - { - - uint32 oldLen = Length (); - - // We might be setting this string to a sub-string of itself, - // so don't reallocate the data unless the string is getting - // longer. - - if (newLen > oldLen) - { - - fData.Clear (); - - fData.Allocate (newLen + 1); - - } - - char *d = fData.Buffer_char (); - - for (uint32 k = 0; k <= newLen; k++) - { - - d [k] = s [k]; - - } - - } - - } - -/*****************************************************************************/ - -void dng_string::Set_ASCII (const char *s) - { - - if (::IsASCII (s)) - { - - Set (s); - - } - - else - { - - Set_SystemEncoding (s); - - } - - } - -/*****************************************************************************/ - -void dng_string::Set_UTF8 (const char *s) - { - - uint32 len = (uint32) strlen (s); - - const char *sEnd = s + len; - - // Worst case expansion is 1-byte characters expanding to - // replacement character, which requires 3 bytes. - - dng_memory_data buffer (len * 3 + 1); - - uint8 *d = buffer.Buffer_uint8 (); - - while (s < sEnd) - { - - uint32 aChar = DecodeUTF8 (s, (uint32) (sEnd - s)); - - if (aChar > 0x7FFFFFFF) - { - aChar = kREPLACEMENT_CHARACTER; - } - - #if qDNGValidate - - if (aChar == kREPLACEMENT_CHARACTER) - { - ReportWarning ("Expected UTF-8 value is not valid UTF-8 (or contains a kREPLACEMENT_CHARACTER)"); - } - - #endif - - if (aChar < 0x00000080) - { - *(d++) = (uint8) aChar; - } - - else if (aChar < 0x00000800) - { - *(d++) = (uint8) ((aChar >> 6) | 0x000000C0); - *(d++) = (uint8) ((aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x00010000) - { - *(d++) = (uint8) ( (aChar >> 12) | 0x000000E0); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x00200000) - { - *(d++) = (uint8) ( (aChar >> 18) | 0x000000F0); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x04000000) - { - *(d++) = (uint8) ( (aChar >> 24) | 0x000000F8); - *(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else - { - *(d++) = (uint8) ( (aChar >> 30) | 0x000000FC); - *(d++) = (uint8) (((aChar >> 24) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - } - - *d = 0; - - Set (buffer.Buffer_char ()); - - } - -/*****************************************************************************/ - -uint32 dng_string::Get_SystemEncoding (dng_memory_data &buffer) const - { - - if (IsASCII ()) - { - - uint32 len = Length (); - - buffer.Allocate (len + 1); - - memcpy (buffer.Buffer (), Get (), len + 1); - - return len; - - } - - else - { - - #if qMacOS || qWinOS - - return Extract_SystemEncoding (*this, buffer); - - #else - - // Fallback logic to force the string to ASCII. - - dng_string temp (*this); - - temp.ForceASCII (); - - return temp.Get_SystemEncoding (buffer); - - #endif - - } - - } - -/*****************************************************************************/ - -void dng_string::Set_SystemEncoding (const char *s) - { - - if (::IsASCII (s)) - { - - Set (s); - - } - - else - { - - #if qMacOS || qWinOS - - Assign_SystemEncoding (*this, s); - - #else - - // Fallback logic that just grabs the ASCII characters and - // ignores the non-ASCII characters. - - uint32 len = (uint32) strlen (s); - - dng_memory_data buffer (len + 1); - - uint8 *d = buffer.Buffer_uint8 (); - - while (*s) - { - - uint8 c = (uint8) *(s++); - - if ((c & 0x80) == 0) - { - - *(d++) = c; - - } - - } - - *d = 0; - - Set (buffer.Buffer_char ()); - - #endif - - } - - } - -/*****************************************************************************/ - -bool dng_string::ValidSystemEncoding () const - { - - if (IsASCII ()) - { - - return true; - - } - - dng_memory_data buffer; - - Get_SystemEncoding (buffer); - - dng_string temp; - - temp.Set_SystemEncoding (buffer.Buffer_char ()); - - return (*this == temp); - - } - -/*****************************************************************************/ - -void dng_string::Set_JIS_X208_1990 (const char *s) - { - - if (::IsASCII (s)) - { - - Set (s); - - } - - else - { - - #if qMacOS || qWinOS - - Assign_JIS_X208_1990 (*this, s); - - #else - - // Fallback to the ASCII extraction logic. - - Set_SystemEncoding (s); - - #endif - - } - - } - -/*****************************************************************************/ - -uint32 dng_string::DecodeUTF8 (const char *&s, - uint32 maxBytes, - bool *isValid) - { - - static const uint8 gUTF8Bytes [256] = - { - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,6,6 - }; - - if (isValid) - { - *isValid = true; - } - - const uint8 *nBuf = (const uint8 *) s; - - uint32 aChar = nBuf [0]; - - uint32 aSize = gUTF8Bytes [aChar]; - - if (aSize > maxBytes) - { - - s += maxBytes; - - if (isValid) - { - *isValid = false; - } - - return kREPLACEMENT_CHARACTER; - - } - - s += aSize; - - for (uint32 extra = 1; extra < aSize; extra++) - { - - if ((nBuf [extra] & 0xC0) != 0x80) - { - - if (isValid) - { - *isValid = false; - } - - return kREPLACEMENT_CHARACTER; - - } - - } - - switch (aSize) - { - - case 0: - { - - s++; // Don't get stuck in infinite loop - - if (isValid) - { - *isValid = false; - } - - return kREPLACEMENT_CHARACTER; - - } - - case 1: - { - - return aChar; - - } - - case 2: - { - - aChar = ((aChar << 6) + nBuf [1]) - (uint32) 0x00003080UL; - - break; - - } - - case 3: - { - - aChar = ((((aChar << 6) + nBuf [1]) - << 6) + nBuf [2]) - (uint32) 0x000E2080UL; - - break; - - } - - case 4: - { - - aChar = ((((((aChar << 6) + nBuf [1]) - << 6) + nBuf [2]) - << 6) + nBuf [3]) - (uint32) 0x03C82080UL; - - break; - - } - - case 5: - { - - aChar = ((((((((aChar << 6) + nBuf [1]) - << 6) + nBuf [2]) - << 6) + nBuf [3]) - << 6) + nBuf [4]) - (uint32) 0xFA082080UL; - - break; - - } - - case 6: - { - - aChar = ((((((((((aChar << 6) + nBuf [1]) - << 6) + nBuf [2]) - << 6) + nBuf [3]) - << 6) + nBuf [4]) - << 6) + nBuf [5]) - (uint32) 0x82082080UL; - - break; - - } - - } - - if (aChar < 0x7F || aChar > 0x0010FFFF) - { - - if (isValid) - { - *isValid = false; - } - - return kREPLACEMENT_CHARACTER; - - } - - return aChar; - - } - -/*****************************************************************************/ - -bool dng_string::IsUTF8 (const char *s) - { - - uint32 len = (uint32) strlen (s); - - const char *sEnd = s + len; - - while (s < sEnd) - { - - bool isValid = true; - - (void) DecodeUTF8 (s, (uint32) (sEnd - s), &isValid); - - if (!isValid) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -void dng_string::Set_UTF8_or_System (const char *s) - { - - if (::IsASCII (s)) - { - - Set (s); - - } - - else if (IsUTF8 (s)) - { - - Set_UTF8 (s); - - } - - else - { - - Set_SystemEncoding (s); - - } - - } - -/*****************************************************************************/ - -uint32 dng_string::Get_UTF16 (dng_memory_data &buffer) const - { - - uint32 count = 0; - - const char *sPtr = Get (); - - while (*sPtr) - { - - uint32 x = DecodeUTF8 (sPtr); - - if (x <= 0x0000FFFF || - x > 0x0010FFFF) - { - - count += 1; - - } - - else - { - - count += 2; - - } - - } - - buffer.Allocate ((count + 1) * (uint32) sizeof (uint16)); - - uint16 *dPtr = buffer.Buffer_uint16 (); - - sPtr = Get (); - - while (*sPtr) - { - - uint32 x = DecodeUTF8 (sPtr); - - if (x <= 0x0000FFFF) - { - - *(dPtr++) = (uint16) x; - - } - - else if (x > 0x0010FFFF) - { - - *(dPtr++) = (uint16) kREPLACEMENT_CHARACTER; - - } - - else - { - - x -= 0x00010000; - - *(dPtr++) = (uint16) ((x >> 10 ) + 0x0000D800); - *(dPtr++) = (uint16) ((x & 0x000003FF) + 0x0000DC00); - - } - - } - - *dPtr = 0; - - return count; - - } - -/*****************************************************************************/ - -void dng_string::Set_UTF16 (const uint16 *s) - { - - if (!s) - { - Clear (); - return; - } - - bool swap = false; - - if (s [0] == 0xFFFE) // Swapped byte order marker - { - swap = true; - s++; - } - - else if (s [0] == 0xFEFF) // Non-swapped byte order marker - { - s++; - } - - uint32 length16 = 0; - - while (s [length16] != 0) - { - length16++; - } - - const uint16 *sEnd = s + length16; - - dng_memory_data buffer (length16 * 6 + 1); - - uint8 *d = buffer.Buffer_uint8 (); - - while (s < sEnd) - { - - uint32 aChar = *s++; - - if (swap) - { - aChar = ((aChar << 8) | (aChar >> 8)) & 0x0000FFFF; - } - - if ((aChar >= 0x0000D800) && (aChar <= 0x0000DBFF) && (s < sEnd)) - { - - uint32 aLow = *s; - - if (swap) - { - aLow = ((aLow << 8) | (aLow >> 8)) & 0x0000FFFF; - } - - if ((aLow >= 0x0000DC00) && (aLow <= 0x0000DFFF)) - { - - aChar = ((aChar - 0x0000D800) << 10) + - (aLow - 0x0000DC00) + - 0x00010000; - - s++; - - } - - } - - if (aChar > 0x7FFFFFFF) - { - aChar = kREPLACEMENT_CHARACTER; - } - - if (aChar < 0x00000080) - { - *(d++) = (uint8) aChar; - } - - else if (aChar < 0x00000800) - { - *(d++) = (uint8) ((aChar >> 6) | 0x000000C0); - *(d++) = (uint8) ((aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x00010000) - { - *(d++) = (uint8) ( (aChar >> 12) | 0x000000E0); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x00200000) - { - *(d++) = (uint8) ( (aChar >> 18) | 0x000000F0); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else if (aChar < 0x04000000) - { - *(d++) = (uint8) ( (aChar >> 24) | 0x000000F8); - *(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - else - { - *(d++) = (uint8) ( (aChar >> 30) | 0x000000FC); - *(d++) = (uint8) (((aChar >> 24) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) (((aChar >> 6) & 0x0000003F) | 0x00000080); - *(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080); - } - - } - - *d = 0; - - Set (buffer.Buffer_char ()); - - } - -/*****************************************************************************/ - -void dng_string::Clear () - { - - Set (NULL); - - } - -/*****************************************************************************/ - -void dng_string::Truncate (uint32 maxBytes) - { - - uint32 len = Length (); - - if (len > maxBytes) - { - - uint8 *s = fData.Buffer_uint8 (); - - // Don't truncate on an extension character. Extensions characters - // in UTF-8 have the 0x80 bit set and the 0x40 bit clear. - - while (maxBytes > 0 && ((s [maxBytes]) & 0xC0) == 0x80) - { - - maxBytes--; - - } - - s [maxBytes] = 0; - - } - - } - -/*****************************************************************************/ - -bool dng_string::TrimTrailingBlanks () - { - - bool didTrim = false; - - if (fData.Buffer ()) - { - - char *s = fData.Buffer_char (); - - uint32 len = (uint32) strlen (s); - - while (len > 0 && s [len - 1] == ' ') - { - len--; - didTrim = true; - } - - s [len] = 0; - - } - - return didTrim; - - } - -/*****************************************************************************/ - -bool dng_string::TrimLeadingBlanks () - { - - bool didTrim = false; - - const char *s = Get (); - - while (*s == ' ') - { - s++; - didTrim = true; - } - - if (didTrim) - { - Set (s); - } - - return didTrim; - - } - -/*****************************************************************************/ - -bool dng_string::IsEmpty () const - { - - const char *s = Get (); - - return *s == 0; - - } - -/*****************************************************************************/ - -uint32 dng_string::Length () const - { - - const char *s = Get (); - - return (uint32) strlen (s); - - } - -/*****************************************************************************/ - -bool dng_string::operator== (const dng_string &s) const - { - - const char *s1 = Get (); - const char *s2 = s.Get (); - - return strcmp (s1, s2) == 0; - - } - -/*****************************************************************************/ - -bool dng_string::Matches (const char *t, - const char *s, - bool case_sensitive) - { - - while (*s != 0) - { - - char c1 = *(s++); - char c2 = *(t++); - - if (!case_sensitive) - { - c1 = ForceUppercase (c1); - c2 = ForceUppercase (c2); - } - - if (c1 != c2) - { - return false; - } - - } - - return (*t == 0); - - } - -/*****************************************************************************/ - -bool dng_string::Matches (const char *s, - bool case_sensitive) const - { - - return dng_string::Matches (Get (), s, case_sensitive); - - } - -/*****************************************************************************/ - -bool dng_string::StartsWith (const char *s, - bool case_sensitive) const - { - - const char *t = Get (); - - while (*s != 0) - { - - char c1 = *(s++); - char c2 = *(t++); - - if (!case_sensitive) - { - c1 = ForceUppercase (c1); - c2 = ForceUppercase (c2); - } - - if (c1 != c2) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_string::EndsWith (const char *s, - bool case_sensitive) const - { - - uint32 len1 = Length (); - - uint32 len2 = (uint32) strlen (s); - - if (len1 < len2) - { - return false; - } - - const char *t = Get () + (len1 - len2); - - while (*s != 0) - { - - char c1 = *(s++); - char c2 = *(t++); - - if (!case_sensitive) - { - c1 = ForceUppercase (c1); - c2 = ForceUppercase (c2); - } - - if (c1 != c2) - { - return false; - } - - } - - return true; - - } - -/*****************************************************************************/ - -bool dng_string::Contains (const char *s, - bool case_sensitive, - int32 *match_offset) const - { - - if (match_offset) - { - *match_offset = -1; - } - - uint32 len1 = Length (); - - uint32 len2 = (uint32) strlen (s); - - if (len1 < len2) - { - return false; - } - - uint32 offsets = len1 - len2; - - for (uint32 offset = 0; offset <= offsets; offset++) - { - - const char *ss = s; - const char *tt = Get () + offset; - - while (*ss != 0) - { - - char c1 = *(ss++); - char c2 = *(tt++); - - if (!case_sensitive) - { - c1 = ForceUppercase (c1); - c2 = ForceUppercase (c2); - } - - if (c1 != c2) - { - goto tryNextOffset; - } - - } - - if (match_offset) - { - *match_offset = offset; - } - - return true; - - tryNextOffset: ; - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_string::Replace (const char *old_string, - const char *new_string, - bool case_sensitive) - { - - int32 match_offset = -1; - - if (Contains (old_string, - case_sensitive, - &match_offset)) - { - - uint32 len1 = Length (); - - uint32 len2 = (uint32) strlen (old_string); - uint32 len3 = (uint32) strlen (new_string); - - if (len2 == len3) - { - - strncpy (fData.Buffer_char () + match_offset, - new_string, - len3); - - } - - else if (len2 > len3) - { - - strncpy (fData.Buffer_char () + match_offset, - new_string, - len3); - - const char *s = fData.Buffer_char () + match_offset + len2; - char *d = fData.Buffer_char () + match_offset + len3; - - uint32 extra = len1 - match_offset - len2 + 1; // + 1 for NULL termination - - for (uint32 j = 0; j < extra; j++) - { - *(d++) = *(s++); - } - - } - - else - { - - dng_memory_data tempBuffer (len1 - len2 + len3 + 1); - - if (match_offset) - { - - strncpy (tempBuffer.Buffer_char (), - fData .Buffer_char (), - match_offset); - - } - - if (len3) - { - - strncpy (tempBuffer.Buffer_char () + match_offset, - new_string, - len3); - - } - - uint32 extra = len1 - match_offset - len2 + 1; // + 1 for NULL termination - - strncpy (tempBuffer.Buffer_char () + match_offset + len3, - fData .Buffer_char () + match_offset + len2, - extra); - - Set (tempBuffer.Buffer_char ()); - - } - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_string::TrimLeading (const char *s, - bool case_sensitive) - { - - if (StartsWith (s, case_sensitive)) - { - - Set (Get () + (uint32) strlen (s)); - - return true; - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_string::Append (const char *s) - { - - uint32 len2 = (uint32) strlen (s); - - if (len2) - { - - uint32 len1 = Length (); - - dng_memory_data temp (len1 + len2 + 1); - - char *buffer = temp.Buffer_char (); - - if (len1) - { - memcpy (buffer, Get (), len1); - } - - memcpy (buffer + len1, s, len2 + 1); - - Set (buffer); - - } - - } - -/*****************************************************************************/ - -void dng_string::SetUppercase () - { - - if (fData.Buffer ()) - { - - uint32 len = Length (); - - char *dPtr = fData.Buffer_char (); - - for (uint32 j = 0; j < len; j++) - { - - char c = dPtr [j]; - - if (c >= 'a' && c <= 'z') - { - - dPtr [j] = c - 'a' + 'A'; - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_string::SetLowercase () - { - - if (fData.Buffer ()) - { - - uint32 len = Length (); - - char *dPtr = fData.Buffer_char (); - - for (uint32 j = 0; j < len; j++) - { - - char c = dPtr [j]; - - if (c >= 'A' && c <= 'Z') - { - - dPtr [j] = c - 'A' + 'a'; - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_string::SetLineEndings (char ending) - { - - if (fData.Buffer ()) - { - - const char *sPtr = fData.Buffer_char (); - char *dPtr = fData.Buffer_char (); - - while (*sPtr) - { - - char c = *(sPtr++); - - char nc = sPtr [0]; - - if ((c == '\r' && nc == '\n') || - (c == '\n' && nc == '\r')) - { - - sPtr++; - - if (ending) - { - *(dPtr++) = ending; - } - - } - - else if (c == '\n' || - c == '\r') - { - - if (ending) - { - *(dPtr++) = ending; - } - - } - - else - { - - *(dPtr++) = c; - - } - - } - - *dPtr = 0; - - } - - } - -/*****************************************************************************/ - -void dng_string::StripLowASCII () - { - - if (fData.Buffer ()) - { - - const char *sPtr = fData.Buffer_char (); - char *dPtr = fData.Buffer_char (); - - while (*sPtr) - { - - char c = *(sPtr++); - - if (c == '\r' || c == '\n' || (uint8) c >= ' ') - { - - *(dPtr++) = c; - - } - - } - - *dPtr = 0; - - } - - } - -/*****************************************************************************/ - -void dng_string::NormalizeAsCommaSeparatedNumbers () - { - - if (fData.Buffer ()) - { - - const char *sPtr = fData.Buffer_char (); - char *dPtr = fData.Buffer_char (); - - bool commaInserted = false; - - while (*sPtr) - { - - uint32 c = DecodeUTF8 (sPtr); - - // Support number formats such as "3", "+3.0", "-3.1416", "314.16e-2", - // "0.31416E1", but no hex/octal number representations. - - if (isdigit ((int) c) || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E') - { - - *(dPtr++) = (char) c; - - if (commaInserted) - { - - commaInserted = false; - - } - - } - - else if (!commaInserted) - { - - *(dPtr++) = ','; - - commaInserted = true; - - } - - } - - *dPtr = 0; - - } - - } - -/******************************************************************************/ - -// Unicode to low-ASCII strings table. - -struct UnicodeToLowASCIIEntry - { - uint32 unicode; - const char *ascii; - }; - -static const UnicodeToLowASCIIEntry kUnicodeToLowASCII [] = - { - { 0x00A0, " " }, - { 0x00A1, "!" }, - { 0x00A9, "(C)" }, - { 0x00AA, "a" }, - { 0x00AB, "<<" }, - { 0x00AC, "!" }, - { 0x00AE, "(R)" }, - { 0x00B0, "dg" }, - { 0x00B1, "+-" }, - { 0x00B7, "." }, - { 0x00BA, "o" }, - { 0x00BB, ">>" }, - { 0x00BF, "?" }, - { 0x00C0, "A" }, - { 0x00C1, "A" }, - { 0x00C2, "A" }, - { 0x00C3, "A" }, - { 0x00C4, "A" }, - { 0x00C5, "A" }, - { 0x00C6, "AE" }, - { 0x00C7, "C" }, - { 0x00C8, "E" }, - { 0x00C9, "E" }, - { 0x00CA, "E" }, - { 0x00CB, "E" }, - { 0x00CC, "I" }, - { 0x00CD, "I" }, - { 0x00CE, "I" }, - { 0x00CF, "I" }, - { 0x00D1, "N" }, - { 0x00D2, "O" }, - { 0x00D3, "O" }, - { 0x00D4, "O" }, - { 0x00D5, "O" }, - { 0x00D6, "O" }, - { 0x00D8, "O" }, - { 0x00D9, "U" }, - { 0x00DA, "U" }, - { 0x00DB, "U" }, - { 0x00DC, "U" }, - { 0x00DD, "Y" }, - { 0x00E0, "a" }, - { 0x00E1, "a" }, - { 0x00E2, "a" }, - { 0x00E3, "a" }, - { 0x00E4, "a" }, - { 0x00E5, "a" }, - { 0x00E6, "ae" }, - { 0x00E7, "c" }, - { 0x00E8, "e" }, - { 0x00E9, "e" }, - { 0x00EA, "e" }, - { 0x00EB, "e" }, - { 0x00EC, "i" }, - { 0x00ED, "i" }, - { 0x00EE, "i" }, - { 0x00EF, "i" }, - { 0x00F1, "n" }, - { 0x00F2, "o" }, - { 0x00F3, "o" }, - { 0x00F4, "o" }, - { 0x00F5, "o" }, - { 0x00F6, "o" }, - { 0x00F7, "/" }, - { 0x00F8, "o" }, - { 0x00F9, "u" }, - { 0x00FA, "u" }, - { 0x00FB, "u" }, - { 0x00FC, "u" }, - { 0x00FD, "y" }, - { 0x00FF, "y" }, - { 0x0131, "i" }, - { 0x0152, "OE" }, - { 0x0153, "oe" }, - { 0x0178, "Y" }, - { 0x2013, "-" }, - { 0x2014, "-" }, - { 0x2018, "'" }, - { 0x2019, "'" }, - { 0x201A, "," }, - { 0x201C, "\"" }, - { 0x201D, "\"" }, - { 0x201E, ",," }, - { 0x2022, "." }, - { 0x2026, "..." }, - { 0x2039, "<" }, - { 0x203A, ">" }, - { 0x2044, "/" }, - { 0x2122, "TM" }, - { 0x2206, "d" }, - { 0x2211, "S" }, - { 0x2260, "!=" }, - { 0x2264, "<=" }, - { 0x2265, ">=" }, - { 0x2318, "#" }, - { 0xFB01, "fi" }, - { 0xFB02, "fl" } - }; - -/******************************************************************************/ - -void dng_string::ForceASCII () - { - - if (!IsASCII ()) - { - - dng_memory_data tempBuffer (Length () * 3 + 1); - - char *dPtr = tempBuffer.Buffer_char (); - - const char *sPtr = Get (); - - while (*sPtr) - { - - uint32 x = DecodeUTF8 (sPtr); - - if (x <= 0x007F) - { - - *(dPtr++) = (char) x; - - } - - else - { - - const char *ascii = NULL; - - const uint32 kTableEntrys = sizeof (kUnicodeToLowASCII ) / - sizeof (kUnicodeToLowASCII [0]); - - for (uint32 entry = 0; entry < kTableEntrys; entry++) - { - - if (kUnicodeToLowASCII [entry] . unicode == x) - { - - ascii = kUnicodeToLowASCII [entry] . ascii; - - break; - - } - - } - - if (ascii) - { - - while (*ascii) - { - - *(dPtr++) = *(ascii++); - - } - - } - - else - { - - *(dPtr++) ='?'; - - } - - } - - } - - *dPtr = 0; - - Set (tempBuffer.Buffer_char ()); - - } - - } - -/******************************************************************************/ - -static dng_mutex gProtectUCCalls ("gProtectUCCalls"); - -/******************************************************************************/ - -int32 dng_string::Compare (const dng_string &s) const - { - - #if qMacOS - - { - - dng_memory_data aStrA; - dng_memory_data aStrB; - - uint32 aLenA = this->Get_UTF16 (aStrA); - uint32 aLenB = s .Get_UTF16 (aStrB); - - if (aLenA > 0) - { - - if (aLenB > 0) - { - - // For some Mac OS versions anyway, UCCompareTextDefault is not - // thread safe. - - dng_lock_mutex lockMutex (&gProtectUCCalls); - - UCCollateOptions aOptions = kUCCollateStandardOptions | - kUCCollatePunctuationSignificantMask; - - SInt32 aOrder = -1; - - Boolean aEqual = false; - - OSStatus searchStatus = ::UCCompareTextDefault (aOptions, - aStrA.Buffer_uint16 (), - aLenA, - aStrB.Buffer_uint16 (), - aLenB, - &aEqual, - &aOrder); - - if (searchStatus == noErr) - { - - if (aEqual || (aOrder == 0)) - { - return 0; - } - - else - { - return (aOrder > 0) ? 1 : -1; - } - - } - - else - { - - DNG_REPORT ("UCCompareTextDefault failed"); - - return -1; - - } - - } - - else - { - return 1; - } - - } - - else - { - - if (aLenB > 0) - { - return -1; - } - - else - { - return 0; - } - - } - - } - - #elif qWinOS - - { - - dng_memory_data aStrA; - dng_memory_data aStrB; - - uint32 aLenA = this->Get_UTF16 (aStrA); - uint32 aLenB = s .Get_UTF16 (aStrB); - - if (aLenA > 0) - { - - if (aLenB > 0) - { - - LCID locale = LOCALE_SYSTEM_DEFAULT; - - DWORD aFlags = NORM_IGNOREWIDTH; - - int aOrder = ::CompareStringW (locale, - aFlags, - (const WCHAR *) aStrA.Buffer_uint16 (), - aLenA, - (const WCHAR *) aStrB.Buffer_uint16 (), - aLenB); - - if (aOrder == CSTR_EQUAL) - { - return 0; - } - - else if (aOrder == CSTR_GREATER_THAN) - { - return 1; - } - - else - { - return -1; - } - - } - - else - { - return 1; - } - - } - - else - { - - if (aLenB > 0) - { - return -1; - } - else - { - return 0; - } - - } - - } - - #else - - // Fallback to a pure Unicode sort order. - - { - - for (uint32 pass = 0; pass < 2; pass++) - { - - const char *aPtr = Get (); - const char *bPtr = s.Get (); - - while (*aPtr || *bPtr) - { - - if (!bPtr) - { - return 1; - } - - else if (!aPtr) - { - return -1; - } - - uint32 a = DecodeUTF8 (aPtr); - uint32 b = DecodeUTF8 (bPtr); - - // Ignore case on first compare pass. - - if (pass == 0) - { - - if (a >= (uint32) 'a' && a <= (uint32) 'z') - { - a = a - (uint32) 'a' + (uint32) 'A'; - } - - if (b >= (uint32) 'a' && b <= (uint32) 'z') - { - b = b - (uint32) 'a' + (uint32) 'A'; - } - - } - - if (b > a) - { - return 1; - } - - else if (a < b) - { - return -1; - } - - } - - } - - } - - #endif - - return 0; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_string.h b/third_party/dng_sdk/dng_string.h deleted file mode 100644 index 41608f1..0000000 --- a/third_party/dng_sdk/dng_string.h +++ /dev/null @@ -1,165 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_string.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Text string representation. - */ - -/*****************************************************************************/ - -#ifndef __dng_string__ -#define __dng_string__ - -/*****************************************************************************/ - -#include "dng_types.h" -#include "dng_memory.h" - -/*****************************************************************************/ - -class dng_string - { - - private: - - // Always stored internally as a UTF-8 encoded string. - - dng_memory_data fData; - - public: - - dng_string (); - - dng_string (const dng_string &s); - - dng_string & operator= (const dng_string &s); - - ~dng_string (); - - const char * Get () const; - - bool IsASCII () const; - - void Set (const char *s); - - void Set_ASCII (const char *s); - - void Set_UTF8 (const char *s); - - uint32 Get_SystemEncoding (dng_memory_data &buffer) const; - - void Set_SystemEncoding (const char *s); - - bool ValidSystemEncoding () const; - - void Set_JIS_X208_1990 (const char *s); - - static uint32 DecodeUTF8 (const char *&s, - uint32 maxBytes = 6, - bool *isValid = NULL); - - static bool IsUTF8 (const char *s); - - void Set_UTF8_or_System (const char *s); - - uint32 Get_UTF16 (dng_memory_data &buffer) const; - - void Set_UTF16 (const uint16 *s); - - void Clear (); - - void Truncate (uint32 maxBytes); - - bool TrimTrailingBlanks (); - - bool TrimLeadingBlanks (); - - bool IsEmpty () const; - - bool NotEmpty () const - { - return !IsEmpty (); - } - - uint32 Length () const; - - bool operator== (const dng_string &s) const; - - bool operator!= (const dng_string &s) const - { - return !(*this == s); - } - - // A utility for doing case insensitive comparisons on strings... - - static bool Matches (const char *t, - const char *s, - bool case_sensitive = false); - - // ...wrapped up for use with dng_string. - - bool Matches (const char *s, - bool case_sensitive = false) const; - - bool StartsWith (const char *s, - bool case_sensitive = false) const; - - bool EndsWith (const char *s, - bool case_sensitive = false) const; - - bool Contains (const char *s, - bool case_sensitive = false, - int32 *match_offset = NULL) const; - - bool Replace (const char *old_string, - const char *new_string, - bool case_sensitive = true); - - bool TrimLeading (const char *s, - bool case_sensitive = false); - - void Append (const char *s); - - void SetUppercase (); - - void SetLowercase (); - - void SetLineEndings (char ending); - - void SetLineEndingsToNewLines () - { - SetLineEndings ('\n'); - } - - void SetLineEndingsToReturns () - { - SetLineEndings ('\r'); - } - - void StripLowASCII (); - - void ForceASCII (); - - int32 Compare (const dng_string &s) const; - - // A utility to convert fields of numbers into comma separated numbers. - - void NormalizeAsCommaSeparatedNumbers (); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_string_list.cpp b/third_party/dng_sdk/dng_string_list.cpp deleted file mode 100644 index 2ae0334..0000000 --- a/third_party/dng_sdk/dng_string_list.cpp +++ /dev/null @@ -1,163 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_string_list.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_string_list.h" - -#include "dng_bottlenecks.h" -#include "dng_exceptions.h" -#include "dng_string.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_string_list::dng_string_list () - - : fCount (0) - , fAllocated (0) - , fList (NULL) - - { - - } - -/*****************************************************************************/ - -dng_string_list::~dng_string_list () - { - - Clear (); - - } - -/*****************************************************************************/ - -void dng_string_list::Allocate (uint32 minSize) - { - - if (fAllocated < minSize) - { - - uint32 newSize = Max_uint32 (minSize, fAllocated * 2); - - dng_string **list = (dng_string **) - malloc (newSize * sizeof (dng_string *)); - - if (!list) - { - - ThrowMemoryFull (); - - } - - if (fCount) - { - - DoCopyBytes (fList, list, fCount * (uint32) sizeof (dng_string *)); - - } - - if (fList) - { - - free (fList); - - } - - fList = list; - - fAllocated = newSize; - - } - - } - -/*****************************************************************************/ - -void dng_string_list::Insert (uint32 index, - const dng_string &s) - { - - Allocate (fCount + 1); - - dng_string *ss = new dng_string (s); - - if (!ss) - { - - ThrowMemoryFull (); - - } - - fCount++; - - for (uint32 j = fCount - 1; j > index; j--) - { - - fList [j] = fList [j - 1]; - - } - - fList [index] = ss; - - } - -/*****************************************************************************/ - -bool dng_string_list::Contains (const dng_string &s) const - { - - for (uint32 j = 0; j < fCount; j++) - { - - if ((*this) [j] == s) - { - - return true; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_string_list::Clear () - { - - if (fList) - { - - for (uint32 index = 0; index < fCount; index++) - { - - delete fList [index]; - - } - - free (fList); - - fList = NULL; - - } - - fCount = 0; - fAllocated = 0; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_string_list.h b/third_party/dng_sdk/dng_string_list.h deleted file mode 100644 index c2e78d8..0000000 --- a/third_party/dng_sdk/dng_string_list.h +++ /dev/null @@ -1,86 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_string_list.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_string_list__ -#define __dng_string_list__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_string_list - { - - private: - - uint32 fCount; - - uint32 fAllocated; - - dng_string **fList; - - public: - - dng_string_list (); - - ~dng_string_list (); - - uint32 Count () const - { - return fCount; - } - - dng_string & operator[] (uint32 index) - { - return *(fList [index]); - } - - const dng_string & operator[] (uint32 index) const - { - return *(fList [index]); - } - - void Allocate (uint32 minSize); - - void Insert (uint32 index, - const dng_string &s); - - void Append (const dng_string &s) - { - Insert (Count (), s); - } - - bool Contains (const dng_string &s) const; - - void Clear (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_string_list (const dng_string_list &list); - - dng_string_list & operator= (const dng_string_list &list); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tag_codes.h b/third_party/dng_sdk/dng_tag_codes.h deleted file mode 100644 index f1332fc..0000000 --- a/third_party/dng_sdk/dng_tag_codes.h +++ /dev/null @@ -1,543 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tag_codes.h#3 $ */ -/* $DateTime: 2012/05/31 13:27:06 $ */ -/* $Change: 832568 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_tag_codes__ -#define __dng_tag_codes__ - -/*****************************************************************************/ - -// TIFF tags 50706 through 50741 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2003-11-04 & 2003-12-02, purpose "Digital Negative". - -// TIFF tags 50778 through 50781 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2004-08-17, purpose "Digital Negative". - -// TIFF tags 50827 through 50834 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2004-12-06, purpose "Digital Negative". - -// TIFF tag number 50879 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2006-03-23, purpose "Digital Negative". - -// TIFF compression numbers 34892 through 34895 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2003-11-04, purpose "Digital Negative". - -// TIFF tags numbers 50931 through 50942 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2007-04-30, purpose "Digital Negative". - -// TIFF tags numbers 50964 through 50975 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2007-12-17, purpose "Digital Negative". - -// TIFF tags numbers 50981 through 50982 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2008-04-01, purpose "Digital Negative". - -// TIFF tags numbers 51008 through 51009 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2008-10-15, purpose "Digital Negative". - -// TIFF tag number 51022 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2008-12-15, purpose "Digital Negative". - -// TIFF tag number 51041 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2009-5-7, purpose "Digital Negative". - -// TIFF tags numbers 51089 through 51091 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2011-07-01, purpose "Digital Negative". - -// TIFF tags numbers 51107 through 51110 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2011-09-22, purpose "Digital Negative". - -// TIFF tag number 51111 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2011-10-07, purpose "Digital Negative". - -// TIFF tags numbers 51112 through 51114 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2011-10-25, purpose "Digital Negative". - -// TIFF tags number 51125 registered at: -// http://partners.adobe.com/asn/tech/tiff/tiffregister.jsp -// on 2012-05-31, purpose "Digital Negative". - -/*****************************************************************************/ - -// TIFF, DNG, TIFF/EP, and Exif tag codes all share the main TIFF tag code -// number space. In cases where TIFF/EP and Exif have different values for -// tags with the same name, "Exif" is appended to the name of the Exif version -// of the tag. - -enum - { - tcNewSubFileType = 254, - tcSubFileType = 255, - tcImageWidth = 256, - tcImageLength = 257, - tcBitsPerSample = 258, - tcCompression = 259, - tcPhotometricInterpretation = 262, - tcThresholding = 263, - tcCellWidth = 264, - tcCellLength = 265, - tcFillOrder = 266, - tcImageDescription = 270, - tcMake = 271, - tcModel = 272, - tcStripOffsets = 273, - tcOrientation = 274, - tcSamplesPerPixel = 277, - tcRowsPerStrip = 278, - tcStripByteCounts = 279, - tcMinSampleValue = 280, - tcMaxSampleValue = 281, - tcXResolution = 282, - tcYResolution = 283, - tcPlanarConfiguration = 284, - tcFreeOffsets = 285, - tcFreeByteCounts = 286, - tcGrayResponseUnit = 290, - tcGrayResponseCurve = 291, - tcResolutionUnit = 296, - tcTransferFunction = 301, - tcSoftware = 305, - tcDateTime = 306, - tcArtist = 315, - tcHostComputer = 316, - tcPredictor = 317, - tcWhitePoint = 318, - tcPrimaryChromaticities = 319, - tcColorMap = 320, - tcTileWidth = 322, - tcTileLength = 323, - tcTileOffsets = 324, - tcTileByteCounts = 325, - tcSubIFDs = 330, - tcExtraSamples = 338, - tcSampleFormat = 339, - tcJPEGTables = 347, - tcJPEGProc = 512, - tcJPEGInterchangeFormat = 513, - tcJPEGInterchangeFormatLength = 514, - tcYCbCrCoefficients = 529, - tcYCbCrSubSampling = 530, - tcYCbCrPositioning = 531, - tcReferenceBlackWhite = 532, - tcXMP = 700, - tcKodakCameraSerialNumber = 33405, - tcCFARepeatPatternDim = 33421, - tcCFAPattern = 33422, - tcBatteryLevel = 33423, - tcKodakDCRPrivateIFD = 33424, - tcCopyright = 33432, - tcExposureTime = 33434, - tcFNumber = 33437, - tcIPTC_NAA = 33723, - tcLeafPKTS = 34310, - tcAdobeData = 34377, - tcExifIFD = 34665, - tcICCProfile = 34675, - tcExposureProgram = 34850, - tcSpectralSensitivity = 34852, - tcGPSInfo = 34853, - tcISOSpeedRatings = 34855, // EXIF 2.3: PhotographicSensitivity. - tcOECF = 34856, - tcInterlace = 34857, - tcTimeZoneOffset = 34858, - tcSelfTimerMode = 34859, - tcSensitivityType = 34864, - tcStandardOutputSensitivity = 34865, - tcRecommendedExposureIndex = 34866, - tcISOSpeed = 34867, - tcISOSpeedLatitudeyyy = 34868, - tcISOSpeedLatitudezzz = 34869, - tcExifVersion = 36864, - tcDateTimeOriginal = 36867, - tcDateTimeDigitized = 36868, - tcComponentsConfiguration = 37121, - tcCompressedBitsPerPixel = 37122, - tcShutterSpeedValue = 37377, - tcApertureValue = 37378, - tcBrightnessValue = 37379, - tcExposureBiasValue = 37380, - tcMaxApertureValue = 37381, - tcSubjectDistance = 37382, - tcMeteringMode = 37383, - tcLightSource = 37384, - tcFlash = 37385, - tcFocalLength = 37386, - tcFlashEnergy = 37387, - tcSpatialFrequencyResponse = 37388, - tcNoise = 37389, - tcFocalPlaneXResolution = 37390, - tcFocalPlaneYResolution = 37391, - tcFocalPlaneResolutionUnit = 37392, - tcImageNumber = 37393, - tcSecurityClassification = 37394, - tcImageHistory = 37395, - tcSubjectArea = 37396, - tcExposureIndex = 37397, - tcTIFF_EP_StandardID = 37398, - tcSensingMethod = 37399, - tcMakerNote = 37500, - tcUserComment = 37510, - tcSubsecTime = 37520, - tcSubsecTimeOriginal = 37521, - tcSubsecTimeDigitized = 37522, - tcAdobeLayerData = 37724, - tcFlashPixVersion = 40960, - tcColorSpace = 40961, - tcPixelXDimension = 40962, - tcPixelYDimension = 40963, - tcRelatedSoundFile = 40964, - tcInteroperabilityIFD = 40965, - tcFlashEnergyExif = 41483, - tcSpatialFrequencyResponseExif = 41484, - tcFocalPlaneXResolutionExif = 41486, - tcFocalPlaneYResolutionExif = 41487, - tcFocalPlaneResolutionUnitExif = 41488, - tcSubjectLocation = 41492, - tcExposureIndexExif = 41493, - tcSensingMethodExif = 41495, - tcFileSource = 41728, - tcSceneType = 41729, - tcCFAPatternExif = 41730, - tcCustomRendered = 41985, - tcExposureMode = 41986, - tcWhiteBalance = 41987, - tcDigitalZoomRatio = 41988, - tcFocalLengthIn35mmFilm = 41989, - tcSceneCaptureType = 41990, - tcGainControl = 41991, - tcContrast = 41992, - tcSaturation = 41993, - tcSharpness = 41994, - tcDeviceSettingDescription = 41995, - tcSubjectDistanceRange = 41996, - tcImageUniqueID = 42016, - tcCameraOwnerNameExif = 42032, - tcCameraSerialNumberExif = 42033, - tcLensSpecificationExif = 42034, - tcLensMakeExif = 42035, - tcLensModelExif = 42036, - tcLensSerialNumberExif = 42037, - tcGamma = 42240, - tcPrintImageMatchingInfo = 50341, - tcDNGVersion = 50706, - tcDNGBackwardVersion = 50707, - tcUniqueCameraModel = 50708, - tcLocalizedCameraModel = 50709, - tcCFAPlaneColor = 50710, - tcCFALayout = 50711, - tcLinearizationTable = 50712, - tcBlackLevelRepeatDim = 50713, - tcBlackLevel = 50714, - tcBlackLevelDeltaH = 50715, - tcBlackLevelDeltaV = 50716, - tcWhiteLevel = 50717, - tcDefaultScale = 50718, - tcDefaultCropOrigin = 50719, - tcDefaultCropSize = 50720, - tcColorMatrix1 = 50721, - tcColorMatrix2 = 50722, - tcCameraCalibration1 = 50723, - tcCameraCalibration2 = 50724, - tcReductionMatrix1 = 50725, - tcReductionMatrix2 = 50726, - tcAnalogBalance = 50727, - tcAsShotNeutral = 50728, - tcAsShotWhiteXY = 50729, - tcBaselineExposure = 50730, - tcBaselineNoise = 50731, - tcBaselineSharpness = 50732, - tcBayerGreenSplit = 50733, - tcLinearResponseLimit = 50734, - tcCameraSerialNumber = 50735, - tcLensInfo = 50736, - tcChromaBlurRadius = 50737, - tcAntiAliasStrength = 50738, - tcShadowScale = 50739, - tcDNGPrivateData = 50740, - tcMakerNoteSafety = 50741, - tcCalibrationIlluminant1 = 50778, - tcCalibrationIlluminant2 = 50779, - tcBestQualityScale = 50780, - tcRawDataUniqueID = 50781, - tcOriginalRawFileName = 50827, - tcOriginalRawFileData = 50828, - tcActiveArea = 50829, - tcMaskedAreas = 50830, - tcAsShotICCProfile = 50831, - tcAsShotPreProfileMatrix = 50832, - tcCurrentICCProfile = 50833, - tcCurrentPreProfileMatrix = 50834, - tcColorimetricReference = 50879, - tcCameraCalibrationSignature = 50931, - tcProfileCalibrationSignature = 50932, - tcExtraCameraProfiles = 50933, - tcAsShotProfileName = 50934, - tcNoiseReductionApplied = 50935, - tcProfileName = 50936, - tcProfileHueSatMapDims = 50937, - tcProfileHueSatMapData1 = 50938, - tcProfileHueSatMapData2 = 50939, - tcProfileToneCurve = 50940, - tcProfileEmbedPolicy = 50941, - tcProfileCopyright = 50942, - tcForwardMatrix1 = 50964, - tcForwardMatrix2 = 50965, - tcPreviewApplicationName = 50966, - tcPreviewApplicationVersion = 50967, - tcPreviewSettingsName = 50968, - tcPreviewSettingsDigest = 50969, - tcPreviewColorSpace = 50970, - tcPreviewDateTime = 50971, - tcRawImageDigest = 50972, - tcOriginalRawFileDigest = 50973, - tcSubTileBlockSize = 50974, - tcRowInterleaveFactor = 50975, - tcProfileLookTableDims = 50981, - tcProfileLookTableData = 50982, - tcOpcodeList1 = 51008, - tcOpcodeList2 = 51009, - tcOpcodeList3 = 51022, - tcNoiseProfile = 51041, - tcOriginalDefaultFinalSize = 51089, - tcOriginalBestQualityFinalSize = 51090, - tcOriginalDefaultCropSize = 51091, - tcProfileHueSatMapEncoding = 51107, - tcProfileLookTableEncoding = 51108, - tcBaselineExposureOffset = 51109, - tcDefaultBlackRender = 51110, - tcNewRawImageDigest = 51111, - tcRawToPreviewGain = 51112, - tcCacheBlob = 51113, - tcCacheVersion = 51114, - tcDefaultUserCrop = 51125, - tcKodakKDCPrivateIFD = 65024 - }; - -/*****************************************************************************/ - -// Additional values that can be passed as IFD parent codes. - -enum - { - - tcFirstSubIFD = 0x10000, - tcLastSubIFD = 0x1FFFF, - - tcFirstChainedIFD = 0x20000, - tcLastChainedIFD = 0x2FFFF, - - tcFirstMakerNoteIFD = 0x30000, - tcLastMakerNoteIFD = 0x3FFFF, - - tcCanonMakerNote = tcFirstMakerNoteIFD, - tcCasioMakerNote, - tcEpsonMakerNote, - tcFujiMakerNote, - tcHasselbladMakerNote, - tcKodakMakerNote, - tcKodakMakerNote65280, - tcLeicaMakerNote, - tcMamiyaMakerNote, - tcMinoltaMakerNote, - tcNikonMakerNote, - tcOlympusMakerNote, - tcOlympusMakerNote8208, - tcOlympusMakerNote8224, - tcOlympusMakerNote8240, - tcOlympusMakerNote8256, - tcOlympusMakerNote8272, - tcOlympusMakerNote12288, - tcPanasonicMakerNote, - tcPentaxMakerNote, - tcPhaseOneMakerNote, - tcRicohMakerNote, - tcRicohMakerNoteCameraInfo, - tcSamsungMakerNote, - tcSonyMakerNote, - tcSonyMakerNoteSubInfo, - tcSonyPrivateIFD1, - tcSonyPrivateIFD2, - tcSonyPrivateIFD3A, - tcSonyPrivateIFD3B, - tcSonyPrivateIFD3C, - - tcCanonCRW = 0x40000, - tcContaxRAW, - tcContaxHeader, - tcFujiRAF, - tcFujiHeader, - tcFujiRawInfo1, - tcFujiRawInfo2, - tcLeafMOS, - tcMinoltaMRW, - tcPanasonicRAW, - tcFoveonX3F, - tcJPEG, - tcAdobePSD - - }; - -/*****************************************************************************/ - -// GPS tag codes are only valid in the GPS IFD. - -enum - { - tcGPSVersionID = 0, - tcGPSLatitudeRef = 1, - tcGPSLatitude = 2, - tcGPSLongitudeRef = 3, - tcGPSLongitude = 4, - tcGPSAltitudeRef = 5, - tcGPSAltitude = 6, - tcGPSTimeStamp = 7, - tcGPSSatellites = 8, - tcGPSStatus = 9, - tcGPSMeasureMode = 10, - tcGPSDOP = 11, - tcGPSSpeedRef = 12, - tcGPSSpeed = 13, - tcGPSTrackRef = 14, - tcGPSTrack = 15, - tcGPSImgDirectionRef = 16, - tcGPSImgDirection = 17, - tcGPSMapDatum = 18, - tcGPSDestLatitudeRef = 19, - tcGPSDestLatitude = 20, - tcGPSDestLongitudeRef = 21, - tcGPSDestLongitude = 22, - tcGPSDestBearingRef = 23, - tcGPSDestBearing = 24, - tcGPSDestDistanceRef = 25, - tcGPSDestDistance = 26, - tcGPSProcessingMethod = 27, - tcGPSAreaInformation = 28, - tcGPSDateStamp = 29, - tcGPSDifferential = 30, - tcGPSHPositioningError = 31 - }; - -/*****************************************************************************/ - -// Tag codes used in the Interoperability IFD. - -enum - { - tcInteroperabilityIndex = 0x0001, - tcInteroperabilityVersion = 0x0002, - tcRelatedImageFileFormat = 0x1000, - tcRelatedImageWidth = 0x1001, - tcRelatedImageLength = 0x1002 - }; - -/*****************************************************************************/ - -// JPEG marker codes. - -enum JpegMarker - { - - M_TEM = 0x01, - - M_SOF0 = 0xc0, - M_SOF1 = 0xc1, - M_SOF2 = 0xc2, - M_SOF3 = 0xc3, - M_DHT = 0xc4, - M_SOF5 = 0xc5, - M_SOF6 = 0xc6, - M_SOF7 = 0xc7, - M_JPG = 0xc8, - M_SOF9 = 0xc9, - M_SOF10 = 0xca, - M_SOF11 = 0xcb, - M_DAC = 0xcc, - M_SOF13 = 0xcd, - M_SOF14 = 0xce, - M_SOF15 = 0xcf, - - M_RST0 = 0xd0, - M_RST1 = 0xd1, - M_RST2 = 0xd2, - M_RST3 = 0xd3, - M_RST4 = 0xd4, - M_RST5 = 0xd5, - M_RST6 = 0xd6, - M_RST7 = 0xd7, - - M_SOI = 0xd8, - M_EOI = 0xd9, - M_SOS = 0xda, - M_DQT = 0xdb, - M_DNL = 0xdc, - M_DRI = 0xdd, - M_DHP = 0xde, - M_EXP = 0xdf, - - M_APP0 = 0xe0, - M_APP1 = 0xe1, - M_APP2 = 0xe2, - M_APP3 = 0xe3, - M_APP4 = 0xe4, - M_APP5 = 0xe5, - M_APP6 = 0xe6, - M_APP7 = 0xe7, - M_APP8 = 0xe8, - M_APP9 = 0xe9, - M_APP10 = 0xea, - M_APP11 = 0xeb, - M_APP12 = 0xec, - M_APP13 = 0xed, - M_APP14 = 0xee, - M_APP15 = 0xef, - - M_JPG0 = 0xf0, - M_JPG1 = 0xf1, - M_JPG2 = 0xf2, - M_JPG3 = 0xf3, - M_JPG4 = 0xf4, - M_JPG5 = 0xf5, - M_JPG6 = 0xf6, - M_JPG7 = 0xf7, - M_JPG8 = 0xf8, - M_JPG9 = 0xf9, - M_JPG10 = 0xfa, - M_JPG11 = 0xfb, - M_JPG12 = 0xfc, - M_JPG13 = 0xfd, - M_COM = 0xfe, - - M_ERROR = 0x100 - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tag_types.cpp b/third_party/dng_sdk/dng_tag_types.cpp deleted file mode 100644 index fcc34e0..0000000 --- a/third_party/dng_sdk/dng_tag_types.cpp +++ /dev/null @@ -1,66 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tag_types.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_tag_types.h" - -/*****************************************************************************/ - -uint32 TagTypeSize (uint32 tagType) - { - - switch (tagType) - { - - case ttByte: - case ttAscii: - case ttSByte: - case ttUndefined: - { - return 1; - } - - case ttShort: - case ttSShort: - case ttUnicode: - { - return 2; - } - - case ttLong: - case ttSLong: - case ttFloat: - case ttIFD: - { - return 4; - } - - case ttRational: - case ttDouble: - case ttSRational: - case ttComplex: - { - return 8; - } - - default: - break; - - } - - return 0; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tag_types.h b/third_party/dng_sdk/dng_tag_types.h deleted file mode 100644 index 46fd6c5..0000000 --- a/third_party/dng_sdk/dng_tag_types.h +++ /dev/null @@ -1,52 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tag_types.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_tag_types__ -#define __dng_tag_types__ - -/*****************************************************************************/ - -#include "dng_types.h" - -/*****************************************************************************/ - -enum - { - ttByte = 1, - ttAscii, - ttShort, - ttLong, - ttRational, - ttSByte, - ttUndefined, - ttSShort, - ttSLong, - ttSRational, - ttFloat, - ttDouble, - ttIFD, - ttUnicode, - ttComplex - }; - -/*****************************************************************************/ - -uint32 TagTypeSize (uint32 tagType); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tag_values.h b/third_party/dng_sdk/dng_tag_values.h deleted file mode 100644 index a0f8c5e..0000000 --- a/third_party/dng_sdk/dng_tag_values.h +++ /dev/null @@ -1,480 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tag_values.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_tag_values__ -#define __dng_tag_values__ - -/*****************************************************************************/ - -#include "dng_flags.h" - -/*****************************************************************************/ - -// Values for NewSubFileType tag. - -enum - { - - // The main image data. - - sfMainImage = 0, - - // Preview image for the primary settings. - - sfPreviewImage = 1, - - // Transparency mask - - sfTransparencyMask = 4, - - // Preview Transparency mask - - sfPreviewMask = sfPreviewImage + sfTransparencyMask, - - // Preview image for non-primary settings. - - sfAltPreviewImage = 0x10001 - - }; - -/******************************************************************************/ - -// Values for PhotometricInterpretation tag. - -enum - { - - piWhiteIsZero = 0, - piBlackIsZero = 1, - piRGB = 2, - piRGBPalette = 3, - piTransparencyMask = 4, - piCMYK = 5, - piYCbCr = 6, - piCIELab = 8, - piICCLab = 9, - - piCFA = 32803, // TIFF-EP spec - - piLinearRaw = 34892 - - }; - -/******************************************************************************/ - -// Values for PlanarConfiguration tag. - -enum - { - - pcInterleaved = 1, - pcPlanar = 2, - - pcRowInterleaved = 100000 // Internal use only - - }; - -/******************************************************************************/ - -// Values for ExtraSamples tag. - -enum - { - - esUnspecified = 0, - esAssociatedAlpha = 1, - esUnassociatedAlpha = 2 - - }; - -/******************************************************************************/ - -// Values for SampleFormat tag. - -enum - { - - sfUnsignedInteger = 1, - sfSignedInteger = 2, - sfFloatingPoint = 3, - sfUndefined = 4 - - }; - -/******************************************************************************/ - -// Values for Compression tag. - -enum - { - - ccUncompressed = 1, - ccLZW = 5, - ccOldJPEG = 6, - ccJPEG = 7, - ccDeflate = 8, - ccPackBits = 32773, - ccOldDeflate = 32946, - - // Used in DNG files in places that allow lossless JPEG. - - ccLossyJPEG = 34892 - - }; - -/******************************************************************************/ - -// Values for Predictor tag. - -enum - { - - cpNullPredictor = 1, - cpHorizontalDifference = 2, - cpFloatingPoint = 3, - - cpHorizontalDifferenceX2 = 34892, - cpHorizontalDifferenceX4 = 34893, - cpFloatingPointX2 = 34894, - cpFloatingPointX4 = 34895 - - }; - -/******************************************************************************/ - -// Values for ResolutionUnit tag. - -enum - { - - ruNone = 1, - ruInch = 2, - ruCM = 3, - ruMM = 4, - ruMicroM = 5 - - }; - -/******************************************************************************/ - -// Values for LightSource tag. - -enum - { - - lsUnknown = 0, - - lsDaylight = 1, - lsFluorescent = 2, - lsTungsten = 3, - lsFlash = 4, - lsFineWeather = 9, - lsCloudyWeather = 10, - lsShade = 11, - lsDaylightFluorescent = 12, // D 5700 - 7100K - lsDayWhiteFluorescent = 13, // N 4600 - 5500K - lsCoolWhiteFluorescent = 14, // W 3800 - 4500K - lsWhiteFluorescent = 15, // WW 3250 - 3800K - lsWarmWhiteFluorescent = 16, // L 2600 - 3250K - lsStandardLightA = 17, - lsStandardLightB = 18, - lsStandardLightC = 19, - lsD55 = 20, - lsD65 = 21, - lsD75 = 22, - lsD50 = 23, - lsISOStudioTungsten = 24, - - lsOther = 255 - - }; - -/******************************************************************************/ - -// Values for ExposureProgram tag. - -enum - { - - epUnidentified = 0, - epManual = 1, - epProgramNormal = 2, - epAperturePriority = 3, - epShutterPriority = 4, - epProgramCreative = 5, - epProgramAction = 6, - epPortraitMode = 7, - epLandscapeMode = 8 - - }; - -/******************************************************************************/ - -// Values for MeteringMode tag. - -enum - { - - mmUnidentified = 0, - mmAverage = 1, - mmCenterWeightedAverage = 2, - mmSpot = 3, - mmMultiSpot = 4, - mmPattern = 5, - mmPartial = 6, - - mmOther = 255 - - }; - -/******************************************************************************/ - -// CFA color codes from the TIFF/EP specification. - -enum ColorKeyCode - { - - colorKeyRed = 0, - colorKeyGreen = 1, - colorKeyBlue = 2, - colorKeyCyan = 3, - colorKeyMagenta = 4, - colorKeyYellow = 5, - colorKeyWhite = 6, - - colorKeyMaxEnum = 0xFF - - }; - -/*****************************************************************************/ - -// Values for the SensitivityType tag. - -enum - { - - stUnknown = 0, - - stStandardOutputSensitivity = 1, - stRecommendedExposureIndex = 2, - stISOSpeed = 3, - stSOSandREI = 4, - stSOSandISOSpeed = 5, - stREIandISOSpeed = 6, - stSOSandREIandISOSpeed = 7 - - }; - -/*****************************************************************************/ - -// Values for the ColorimetricReference tag. It specifies the colorimetric -// reference used for images with PhotometricInterpretation values of CFA -// or LinearRaw. - -enum - { - - // Scene referred (default): - - crSceneReferred = 0, - - // Output referred using the parameters of the ICC profile PCS. - - crICCProfilePCS = 1 - - }; - -/*****************************************************************************/ - -// Values for the ProfileEmbedPolicy tag. - -enum - { - - // Freely embedable and copyable into installations that encounter this - // profile, so long as the profile is only used to process DNG files. - - pepAllowCopying = 0, - - // Can be embeded in a DNG for portable processing, but cannot be used - // to process other files that the profile is not embedded in. - - pepEmbedIfUsed = 1, - - // Can only be used if installed on the machine processing the file. - // Note that this only applies to stand-alone profiles. Profiles that - // are already embedded inside a DNG file allowed to remain embedded - // in that DNG, even if the DNG is resaved. - - pepEmbedNever = 2, - - // No restricts on profile use or embedding. - - pepNoRestrictions = 3 - - }; - -/*****************************************************************************/ - -// Values for the ProfileHueSatMapEncoding and ProfileLookTableEncoding tags. - -enum - { - - // 1. Convert linear ProPhoto RGB values to HSV. - // 2. Use the HSV coordinates to index into the color table. - // 3. Apply color table result to the original HSV values. - // 4. Convert modified HSV values back to linear ProPhoto RGB. - - encoding_Linear = 0, - - // 1. Convert linear ProPhoto RGB values to HSV. - // 2. Encode V coordinate using sRGB encoding curve. - // 3. Use the encoded HSV coordinates to index into the color table. - // 4. Apply color table result to the encoded values from step 2. - // 5. Decode V coordinate using sRGB decoding curve (inverse of step 2). - // 6. Convert HSV values back to linear ProPhoto RGB (inverse of step 1). - - encoding_sRGB = 1 - - }; - -/*****************************************************************************/ - -// Values for the DefaultBlackRender tag. - -enum - { - - // By default, the renderer applies (possibly auto-calculated) black subtraction - // prior to the look table. - - defaultBlackRender_Auto = 0, - - // By default, the renderer does not apply any black subtraction prior to the - // look table. - - defaultBlackRender_None = 1 - - }; - -/*****************************************************************************/ - -// Values for the PreviewColorSpace tag. - -enum PreviewColorSpaceEnum - { - - previewColorSpace_Unknown = 0, - previewColorSpace_GrayGamma22 = 1, - previewColorSpace_sRGB = 2, - previewColorSpace_AdobeRGB = 3, - previewColorSpace_ProPhotoRGB = 4, - - previewColorSpace_LastValid = previewColorSpace_ProPhotoRGB, - - previewColorSpace_MaxEnum = 0xFFFFFFFF - - }; - -/*****************************************************************************/ - -// Values for CacheVersion tag. - -enum - { - - // The low-16 bits are a rendering version number. - - cacheVersionMask = 0x0FFFF, - - // Default cache version. - - cacheVersionDefault = 0x00100, - - // Is this an integer preview of a floating point image? - - cacheVersionDefloated = 0x10000, - - // Is this an flattening preview of an image with tranparency? - - cacheVersionFlattened = 0x20000, - - // Was this preview build using a the default baseline multi-channel - // CFA merge (i.e. only using the first channel)? - - cacheVersionFakeMerge = 0x40000 - - }; - -/*****************************************************************************/ - -// TIFF-style byte order markers. - -enum - { - - byteOrderII = 0x4949, // 'II' - byteOrderMM = 0x4D4D // 'MM' - - }; - -/*****************************************************************************/ - -// "Magic" numbers. - -enum - { - - // DNG related. - - magicTIFF = 42, // TIFF (and DNG) - magicExtendedProfile = 0x4352, // 'CR' - magicRawCache = 1022, // Raw cache (fast load data) - - // Other raw formats - included here so the DNG SDK can parse them. - - magicPanasonic = 85, - magicOlympusA = 0x4F52, - magicOlympusB = 0x5352 - - }; - -/*****************************************************************************/ - -// DNG Version numbers - -enum - { - - dngVersion_None = 0, - - dngVersion_1_0_0_0 = 0x01000000, - dngVersion_1_1_0_0 = 0x01010000, - dngVersion_1_2_0_0 = 0x01020000, - dngVersion_1_3_0_0 = 0x01030000, - dngVersion_1_4_0_0 = 0x01040000, - - dngVersion_Current = dngVersion_1_4_0_0, - - dngVersion_SaveDefault = dngVersion_Current - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_temperature.cpp b/third_party/dng_sdk/dng_temperature.cpp deleted file mode 100644 index 3635d91..0000000 --- a/third_party/dng_sdk/dng_temperature.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_temperature.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -#include "dng_temperature.h" - -#include "dng_xy_coord.h" - -/*****************************************************************************/ - -// Scale factor between distances in uv space to a more user friendly "tint" -// parameter. - -static const real64 kTintScale = -3000.0; - -/*****************************************************************************/ - -// Table from Wyszecki & Stiles, "Color Science", second edition, page 228. - -struct ruvt - { - real64 r; - real64 u; - real64 v; - real64 t; - }; - -static const ruvt kTempTable [] = - { - { 0, 0.18006, 0.26352, -0.24341 }, - { 10, 0.18066, 0.26589, -0.25479 }, - { 20, 0.18133, 0.26846, -0.26876 }, - { 30, 0.18208, 0.27119, -0.28539 }, - { 40, 0.18293, 0.27407, -0.30470 }, - { 50, 0.18388, 0.27709, -0.32675 }, - { 60, 0.18494, 0.28021, -0.35156 }, - { 70, 0.18611, 0.28342, -0.37915 }, - { 80, 0.18740, 0.28668, -0.40955 }, - { 90, 0.18880, 0.28997, -0.44278 }, - { 100, 0.19032, 0.29326, -0.47888 }, - { 125, 0.19462, 0.30141, -0.58204 }, - { 150, 0.19962, 0.30921, -0.70471 }, - { 175, 0.20525, 0.31647, -0.84901 }, - { 200, 0.21142, 0.32312, -1.0182 }, - { 225, 0.21807, 0.32909, -1.2168 }, - { 250, 0.22511, 0.33439, -1.4512 }, - { 275, 0.23247, 0.33904, -1.7298 }, - { 300, 0.24010, 0.34308, -2.0637 }, - { 325, 0.24702, 0.34655, -2.4681 }, - { 350, 0.25591, 0.34951, -2.9641 }, - { 375, 0.26400, 0.35200, -3.5814 }, - { 400, 0.27218, 0.35407, -4.3633 }, - { 425, 0.28039, 0.35577, -5.3762 }, - { 450, 0.28863, 0.35714, -6.7262 }, - { 475, 0.29685, 0.35823, -8.5955 }, - { 500, 0.30505, 0.35907, -11.324 }, - { 525, 0.31320, 0.35968, -15.628 }, - { 550, 0.32129, 0.36011, -23.325 }, - { 575, 0.32931, 0.36038, -40.770 }, - { 600, 0.33724, 0.36051, -116.45 } - }; - -/*****************************************************************************/ - -void dng_temperature::Set_xy_coord (const dng_xy_coord &xy) - { - - // Convert to uv space. - - real64 u = 2.0 * xy.x / (1.5 - xy.x + 6.0 * xy.y); - real64 v = 3.0 * xy.y / (1.5 - xy.x + 6.0 * xy.y); - - // Search for line pair coordinate is between. - - real64 last_dt = 0.0; - - real64 last_dv = 0.0; - real64 last_du = 0.0; - - for (uint32 index = 1; index <= 30; index++) - { - - // Convert slope to delta-u and delta-v, with length 1. - - real64 du = 1.0; - real64 dv = kTempTable [index] . t; - - real64 len = sqrt (1.0 + dv * dv); - - du /= len; - dv /= len; - - // Find delta from black body point to test coordinate. - - real64 uu = u - kTempTable [index] . u; - real64 vv = v - kTempTable [index] . v; - - // Find distance above or below line. - - real64 dt = - uu * dv + vv * du; - - // If below line, we have found line pair. - - if (dt <= 0.0 || index == 30) - { - - // Find fractional weight of two lines. - - if (dt > 0.0) - dt = 0.0; - - dt = -dt; - - real64 f; - - if (index == 1) - { - f = 0.0; - } - else - { - f = dt / (last_dt + dt); - } - - // Interpolate the temperature. - - fTemperature = 1.0E6 / (kTempTable [index - 1] . r * f + - kTempTable [index ] . r * (1.0 - f)); - - // Find delta from black body point to test coordinate. - - uu = u - (kTempTable [index - 1] . u * f + - kTempTable [index ] . u * (1.0 - f)); - - vv = v - (kTempTable [index - 1] . v * f + - kTempTable [index ] . v * (1.0 - f)); - - // Interpolate vectors along slope. - - du = du * (1.0 - f) + last_du * f; - dv = dv * (1.0 - f) + last_dv * f; - - len = sqrt (du * du + dv * dv); - - du /= len; - dv /= len; - - // Find distance along slope. - - fTint = (uu * du + vv * dv) * kTintScale; - - break; - - } - - // Try next line pair. - - last_dt = dt; - - last_du = du; - last_dv = dv; - - } - - } - -/*****************************************************************************/ - -dng_xy_coord dng_temperature::Get_xy_coord () const - { - - dng_xy_coord result; - - // Find inverse temperature to use as index. - - real64 r = 1.0E6 / fTemperature; - - // Convert tint to offset is uv space. - - real64 offset = fTint * (1.0 / kTintScale); - - // Search for line pair containing coordinate. - - for (uint32 index = 0; index <= 29; index++) - { - - if (r < kTempTable [index + 1] . r || index == 29) - { - - // Find relative weight of first line. - - real64 f = (kTempTable [index + 1] . r - r) / - (kTempTable [index + 1] . r - kTempTable [index] . r); - - // Interpolate the black body coordinates. - - real64 u = kTempTable [index ] . u * f + - kTempTable [index + 1] . u * (1.0 - f); - - real64 v = kTempTable [index ] . v * f + - kTempTable [index + 1] . v * (1.0 - f); - - // Find vectors along slope for each line. - - real64 uu1 = 1.0; - real64 vv1 = kTempTable [index] . t; - - real64 uu2 = 1.0; - real64 vv2 = kTempTable [index + 1] . t; - - real64 len1 = sqrt (1.0 + vv1 * vv1); - real64 len2 = sqrt (1.0 + vv2 * vv2); - - uu1 /= len1; - vv1 /= len1; - - uu2 /= len2; - vv2 /= len2; - - // Find vector from black body point. - - real64 uu3 = uu1 * f + uu2 * (1.0 - f); - real64 vv3 = vv1 * f + vv2 * (1.0 - f); - - real64 len3 = sqrt (uu3 * uu3 + vv3 * vv3); - - uu3 /= len3; - vv3 /= len3; - - // Adjust coordinate along this vector. - - u += uu3 * offset; - v += vv3 * offset; - - // Convert to xy coordinates. - - result.x = 1.5 * u / (u - 4.0 * v + 2.0); - result.y = v / (u - 4.0 * v + 2.0); - - break; - - } - - } - - return result; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_temperature.h b/third_party/dng_sdk/dng_temperature.h deleted file mode 100644 index 7d662bd..0000000 --- a/third_party/dng_sdk/dng_temperature.h +++ /dev/null @@ -1,97 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_temperature.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Representation of color temperature and offset (tint) using black body - * radiator definition. - */ - -#ifndef __dng_temperature__ -#define __dng_temperature__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_temperature - { - - private: - - real64 fTemperature; - - real64 fTint; - - public: - - dng_temperature () - - : fTemperature (0.0) - , fTint (0.0) - - { - } - - dng_temperature (real64 temperature, - real64 tint) - - : fTemperature (temperature) - , fTint (tint ) - - { - - } - - dng_temperature (const dng_xy_coord &xy) - - : fTemperature (0.0) - , fTint (0.0) - - { - Set_xy_coord (xy); - } - - void SetTemperature (real64 temperature) - { - fTemperature = temperature; - } - - real64 Temperature () const - { - return fTemperature; - } - - void SetTint (real64 tint) - { - fTint = tint; - } - - real64 Tint () const - { - return fTint; - } - - void Set_xy_coord (const dng_xy_coord &xy); - - dng_xy_coord Get_xy_coord () const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tile_iterator.cpp b/third_party/dng_sdk/dng_tile_iterator.cpp deleted file mode 100644 index b91a9dc..0000000 --- a/third_party/dng_sdk/dng_tile_iterator.cpp +++ /dev/null @@ -1,199 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tile_iterator.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_tile_iterator.h" - -#include "dng_exceptions.h" -#include "dng_image.h" -#include "dng_pixel_buffer.h" -#include "dng_tag_types.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -dng_tile_iterator::dng_tile_iterator (const dng_image &image, - const dng_rect &area) - - : fArea () - , fTileWidth (0) - , fTileHeight (0) - , fTileTop (0) - , fTileLeft (0) - , fRowLeft (0) - , fLeftPage (0) - , fRightPage (0) - , fTopPage (0) - , fBottomPage (0) - , fHorizontalPage (0) - , fVerticalPage (0) - - { - - Initialize (image.RepeatingTile (), - area & image.Bounds ()); - - } - -/*****************************************************************************/ - -dng_tile_iterator::dng_tile_iterator (const dng_point &tileSize, - const dng_rect &area) - - : fArea () - , fTileWidth (0) - , fTileHeight (0) - , fTileTop (0) - , fTileLeft (0) - , fRowLeft (0) - , fLeftPage (0) - , fRightPage (0) - , fTopPage (0) - , fBottomPage (0) - , fHorizontalPage (0) - , fVerticalPage (0) - - { - - dng_rect tile (area); - - tile.b = Min_int32 (tile.b, tile.t + tileSize.v); - tile.r = Min_int32 (tile.r, tile.l + tileSize.h); - - Initialize (tile, - area); - - } - -/*****************************************************************************/ - -dng_tile_iterator::dng_tile_iterator (const dng_rect &tile, - const dng_rect &area) - - : fArea () - , fTileWidth (0) - , fTileHeight (0) - , fTileTop (0) - , fTileLeft (0) - , fRowLeft (0) - , fLeftPage (0) - , fRightPage (0) - , fTopPage (0) - , fBottomPage (0) - , fHorizontalPage (0) - , fVerticalPage (0) - - { - - Initialize (tile, - area); - - } - -/*****************************************************************************/ - -void dng_tile_iterator::Initialize (const dng_rect &tile, - const dng_rect &area) - { - - fArea = area; - - if (area.IsEmpty ()) - { - - fVerticalPage = 0; - fBottomPage = -1; - - return; - - } - - int32 vOffset = tile.t; - int32 hOffset = tile.l; - - int32 tileHeight = tile.b - vOffset; - int32 tileWidth = tile.r - hOffset; - - fTileHeight = tileHeight; - fTileWidth = tileWidth; - - fLeftPage = (fArea.l - hOffset ) / tileWidth; - fRightPage = (fArea.r - hOffset - 1) / tileWidth; - - fHorizontalPage = fLeftPage; - - fTopPage = (fArea.t - vOffset ) / tileHeight; - fBottomPage = (fArea.b - vOffset - 1) / tileHeight; - - fVerticalPage = fTopPage; - - fTileLeft = fHorizontalPage * tileWidth + hOffset; - fTileTop = fVerticalPage * tileHeight + vOffset; - - fRowLeft = fTileLeft; - - } - -/*****************************************************************************/ - -bool dng_tile_iterator::GetOneTile (dng_rect &tile) - { - - if (fVerticalPage > fBottomPage) - { - return false; - } - - if (fVerticalPage > fTopPage) - tile.t = fTileTop; - else - tile.t = fArea.t; - - if (fVerticalPage < fBottomPage) - tile.b = fTileTop + fTileHeight; - else - tile.b = fArea.b; - - if (fHorizontalPage > fLeftPage) - tile.l = fTileLeft; - else - tile.l = fArea.l; - - if (fHorizontalPage < fRightPage) - tile.r = fTileLeft + fTileWidth; - else - tile.r = fArea.r; - - if (fHorizontalPage < fRightPage) - { - fHorizontalPage++; - fTileLeft += fTileWidth; - } - - else - { - - fVerticalPage++; - fTileTop += fTileHeight; - - fHorizontalPage = fLeftPage; - fTileLeft = fRowLeft; - - } - - return true; - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tile_iterator.h b/third_party/dng_sdk/dng_tile_iterator.h deleted file mode 100644 index 98bdb1c..0000000 --- a/third_party/dng_sdk/dng_tile_iterator.h +++ /dev/null @@ -1,76 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tile_iterator.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_tile_iterator__ -#define __dng_tile_iterator__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_point.h" -#include "dng_rect.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_tile_iterator - { - - private: - - dng_rect fArea; - - int32 fTileWidth; - int32 fTileHeight; - - int32 fTileTop; - int32 fTileLeft; - - int32 fRowLeft; - - int32 fLeftPage; - int32 fRightPage; - - int32 fTopPage; - int32 fBottomPage; - - int32 fHorizontalPage; - int32 fVerticalPage; - - public: - - dng_tile_iterator (const dng_image &image, - const dng_rect &area); - - dng_tile_iterator (const dng_point &tileSize, - const dng_rect &area); - - dng_tile_iterator (const dng_rect &tile, - const dng_rect &area); - - bool GetOneTile (dng_rect &tile); - - private: - - void Initialize (const dng_rect &tile, - const dng_rect &area); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tone_curve.cpp b/third_party/dng_sdk/dng_tone_curve.cpp deleted file mode 100644 index 466ca95..0000000 --- a/third_party/dng_sdk/dng_tone_curve.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tone_curve.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_tone_curve.h" - -#include "dng_assertions.h" -#include "dng_spline.h" -#include "dng_utils.h" - -/******************************************************************************/ - -dng_tone_curve::dng_tone_curve () - - : fCoord () - - { - - SetNull (); - - } - -/******************************************************************************/ - -bool dng_tone_curve::operator== (const dng_tone_curve &curve) const - { - - return fCoord == curve.fCoord; - - } - -/******************************************************************************/ - -void dng_tone_curve::SetNull () - { - - fCoord.resize (2); - - fCoord [0].h = 0.0; - fCoord [0].v = 0.0; - - fCoord [1].h = 1.0; - fCoord [1].v = 1.0; - - } - -/******************************************************************************/ - -bool dng_tone_curve::IsNull () const - { - - dng_tone_curve temp; - - return (*this == temp); - - } - -/******************************************************************************/ - -void dng_tone_curve::SetInvalid () - { - - fCoord.clear (); - - } - -/******************************************************************************/ - -bool dng_tone_curve::IsValid () const - { - - if (fCoord.size () < 2) - { - - return false; - - } - - for (uint32 j = 0; j < fCoord.size (); j++) - { - - if (fCoord [j] . h < 0.0 || fCoord [j] . h > 1.0 || - fCoord [j] . v < 0.0 || fCoord [j] . v > 1.0) - { - - return false; - - } - - if (j > 0) - { - - if (fCoord [j] . h <= fCoord [j - 1] . h) - { - - return false; - - } - - } - - } - - return true; - - } - -/******************************************************************************/ - -void dng_tone_curve::Solve (dng_spline_solver &solver) const - { - - solver.Reset (); - - for (uint32 index = 0; index < fCoord.size (); index++) - { - - solver.Add (fCoord [index].h, - fCoord [index].v); - - } - - solver.Solve (); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_tone_curve.h b/third_party/dng_sdk/dng_tone_curve.h deleted file mode 100644 index e85052f..0000000 --- a/third_party/dng_sdk/dng_tone_curve.h +++ /dev/null @@ -1,66 +0,0 @@ -/*****************************************************************************/ -// Copyright 2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_tone_curve.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Representation of 1-dimensional tone curve. - */ - -/*****************************************************************************/ - -#ifndef __dng_tone_curve__ -#define __dng_tone_curve__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_point.h" - -#include - -/*****************************************************************************/ - -class dng_tone_curve - { - - public: - - std::vector fCoord; - - public: - - dng_tone_curve (); - - bool operator== (const dng_tone_curve &curve) const; - - bool operator!= (const dng_tone_curve &curve) const - { - return !(*this == curve); - } - - void SetNull (); - - bool IsNull () const; - - void SetInvalid (); - - bool IsValid () const; - - void Solve (dng_spline_solver &solver) const; - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_types.h b/third_party/dng_sdk/dng_types.h deleted file mode 100644 index 12a9303..0000000 --- a/third_party/dng_sdk/dng_types.h +++ /dev/null @@ -1,115 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_types.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_types__ -#define __dng_types__ - -/*****************************************************************************/ - -#include "dng_flags.h" - -/*****************************************************************************/ - -// Standard integer types. - -#ifdef _MSC_VER -#include -#endif - -#include - -/*****************************************************************************/ - -#if qDNGUseStdInt || 1 - -typedef int8_t int8; -typedef int16_t int16; -typedef int32_t int32; -typedef int64_t int64; - -typedef uint8_t uint8; -typedef uint16_t uint16; -typedef uint32_t uint32; -typedef uint64_t uint64; - -#else - -typedef signed char int8; -typedef signed short int16; -#if __LP64__ -typedef signed int int32; -#else -typedef signed long int32; -#endif -typedef signed long long int64; - -typedef unsigned char uint8; -typedef unsigned short uint16; -/*Some Mac OS X 10.5 SDK headers already define uint32.*/ -#ifndef _UINT32 -#if __LP64__ -typedef unsigned int uint32; -#else -typedef unsigned long uint32; -#endif -#define _UINT32 -#endif -typedef unsigned long long uint64; - -#endif - -typedef uintptr_t uintptr; - -/*****************************************************************************/ - -typedef float real32; -typedef double real64; - -/*****************************************************************************/ - -/// \def Build a Macintosh style four-character constant in a compiler safe way. - -#define DNG_CHAR4(a,b,c,d) ((((uint32) a) << 24) |\ - (((uint32) b) << 16) |\ - (((uint32) c) << 8) |\ - (((uint32) d) )) - -/*****************************************************************************/ - -#include -#include -#include -#include -#include - -/*****************************************************************************/ - -// Visual Studio now prefers _hypot to hypot - -#ifdef _MSC_VER - -#ifdef hypot -#undef hypot -#endif - -#define hypot _hypot - -#endif - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_uncopyable.h b/third_party/dng_sdk/dng_uncopyable.h deleted file mode 100644 index f25745a..0000000 --- a/third_party/dng_sdk/dng_uncopyable.h +++ /dev/null @@ -1,48 +0,0 @@ -/*****************************************************************************/ -// Copyright 2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_uncopyable.h#1 $ */ -/* $DateTime: 2012/09/05 12:31:51 $ */ -/* $Change: 847652 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_uncopyable__ -#define __dng_uncopyable__ - -/*****************************************************************************/ - -// Virtual base class to prevent object copies. - -class dng_uncopyable - { - - protected: - - dng_uncopyable () - { - } - - ~dng_uncopyable () - { - } - - private: - - dng_uncopyable (const dng_uncopyable &); - - dng_uncopyable & operator= (const dng_uncopyable &); - - }; - -/*****************************************************************************/ - -#endif // __dng_uncopyable__ - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_utils.cpp b/third_party/dng_sdk/dng_utils.cpp deleted file mode 100644 index 17dcdd7..0000000 --- a/third_party/dng_sdk/dng_utils.cpp +++ /dev/null @@ -1,704 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_utils.cpp#3 $ */ -/* $DateTime: 2012/08/12 15:38:38 $ */ -/* $Change: 842799 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_utils.h" - -#include "dng_area_task.h" -#include "dng_assertions.h" -#include "dng_bottlenecks.h" -#include "dng_host.h" -#include "dng_image.h" -#include "dng_flags.h" -#include "dng_point.h" -#include "dng_rect.h" -#include "dng_tile_iterator.h" - -#if qMacOS -#include -#endif - -#if qiPhone || qMacOS -// these provide timers -#include -#include -#endif - -#if qWinOS -#include -#else -#include -#include // for va_start/va_end -#endif - -/*****************************************************************************/ - -#if qDNGDebug - -/*****************************************************************************/ - -#if qMacOS - #define DNG_DEBUG_BREAK __asm__ volatile ("int3") -#elif qWinOS - #if qDNG64Bit - // no inline assembly on Win 64-bit, so use DebugBreak - #define DNG_DEBUG_BREAK DebugBreak() - #else - #define DNG_DEBUG_BREAK __asm__ volatile ("int3") - #endif -#elif qiPhone - // simulator is running on Intel - #if qiPhoneSimulator - #define DNG_DEBUG_BREAK __asm__ volatile ("int3") - #else - // The debugger doesn't restore program counter after this is called. - // Caller must move program counter past line to continue. - // As of iOS5/xCode 4.2, recovery may not be possible. - #define DNG_DEBUG_BREAK __asm__ volatile ("bkpt 1") - #endif -#elif qAndroid - #define DNG_DEBUG_BREAK __asm__ volatile ("bkpt 1") -#elif qLinux - #define DNG_DEBUG_BREAK __asm__ volatile ("int3") -#else - #define DNG_DEBUG_BREAK -#endif - -/*****************************************************************************/ - -bool gPrintAsserts = true; -bool gBreakOnAsserts = true; - -/*****************************************************************************/ - -void dng_show_message (const char *s) - { - - #if qDNGPrintMessages - - // display the message - if (gPrintAsserts) - fprintf (stderr, "%s\n", s); - - #elif qiPhone || qAndroid || qLinux - - if (gPrintAsserts) - fprintf (stderr, "%s\n", s); - - // iOS doesn't print a message to the console like DebugStr and MessageBox do, so we have to do both - // You'll have to advance the program counter manually past this statement - if (gBreakOnAsserts) - DNG_DEBUG_BREAK; - - #elif qMacOS - - if (gBreakOnAsserts) - { - // truncate the to 255 chars - char ss [256]; - - uint32 len = strlen (s); - if (len > 255) - len = 255; - strncpy (&(ss [1]), s, len ); - ss [0] = (unsigned char) len; - - DebugStr ((unsigned char *) ss); - } - else if (gPrintAsserts) - { - fprintf (stderr, "%s\n", s); - } - - #elif qWinOS - - // display a dialog - // This is not thread safe. Multiple message boxes can be launched. - // Should also be launched in its own thread so main msg queue isn't thrown off. - if (gBreakOnAsserts) - MessageBoxA (NULL, (LPSTR) s, NULL, MB_OK); - else if (gPrintAsserts) - fprintf (stderr, "%s\n", s); - - #endif - - } - -/*****************************************************************************/ - -void dng_show_message_f (const char *fmt, ... ) - { - - char buffer [1024]; - - va_list ap; - va_start (ap, fmt); - - vsnprintf (buffer, sizeof (buffer), fmt, ap); - - va_end (ap); - - dng_show_message (buffer); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ - -real64 TickTimeInSeconds () - { - - #if qWinOS - - // One might think it prudent to cache the frequency here, however - // low-power CPU modes can, and do, change the value returned. - // Thus the frequencey needs to be retrieved each time. - - // Note that the frequency changing can cause the return - // result to jump backwards, which is why the TickCountInSeconds - // (below) also exists. - - // Just plug in laptop when doing timings to minimize this. - // QPC/QPH is a slow call compared to rtdsc. - - #if qImagecore - - // You should be plugged-in when measuring. - - static real64 freqMultiplier = 0.0; - - if (freqMultiplier == 0.0) - { - - LARGE_INTEGER freq; - - QueryPerformanceFrequency (&freq); - - freqMultiplier = 1.0 / (real64) freq.QuadPart; - - } - - #else - - LARGE_INTEGER freq; - - QueryPerformanceFrequency (&freq); - - real64 freqMultiplier = 1.0 / (real64) freq.QuadPart; - - #endif // qImagecore - - LARGE_INTEGER cycles; - - QueryPerformanceCounter (&cycles); - - return (real64) cycles.QuadPart * freqMultiplier; - - #elif qiPhone || qMacOS - - // this is switching Mac to high performance timer - // and this is also the timer for iPhone - - // assume frequency is unchanging, requesting frequency every time call - // is too slow. multiple cores, different frequency ? - - static real64 freqMultiplier = 0.0; - if (freqMultiplier == 0.0) - { - mach_timebase_info_data_t freq; - mach_timebase_info(&freq); - - // converts from nanos to micros - // numer = 125, denom = 3 * 1000 - freqMultiplier = ((real64)freq.numer / (real64)freq.denom) * 1.0e-9; - } - - return mach_absolute_time() * freqMultiplier; - - #elif qAndroid || qLinux - - //this is a fast timer to nanos - struct timespec now; - clock_gettime(CLOCK_MONOTONIC, &now); - return now.tv_sec + (real64)now.tv_nsec * 1.0e-9; - - #else - - // Perhaps a better call exists. (e.g. avoid adjtime effects) - - struct timeval tv; - - gettimeofday (&tv, NULL); - - return tv.tv_sec + (real64)tv.tv_usec * 1.0e-6; - - #endif - - } - -/*****************************************************************************/ - -real64 TickCountInSeconds () - { - - #if qWinOS - - return GetTickCount () * (1.0 / 1000.0); - - #elif qMacOS - - return TickCount () * (1.0 / 60.0); - - #else - - return TickTimeInSeconds (); - - #endif - - } - -/*****************************************************************************/ - -bool gDNGShowTimers = true; - -dng_timer::dng_timer (const char *message) - - : fMessage (message ) - , fStartTime (TickTimeInSeconds ()) - - { - - } - -/*****************************************************************************/ - -dng_timer::~dng_timer () - { - - if (!gDNGShowTimers) - return; - - real64 totalTime = TickTimeInSeconds () - fStartTime; - - fprintf (stderr, "%s: %0.3f sec\n", fMessage, totalTime); - - } - -/*****************************************************************************/ - -real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point, - const dng_rect_real64 &rect) - { - - real64 distSqr = DistanceSquared (point, - rect.TL ()); - - distSqr = Max_real64 (distSqr, - DistanceSquared (point, - rect.BL ())); - - distSqr = Max_real64 (distSqr, - DistanceSquared (point, - rect.BR ())); - - distSqr = Max_real64 (distSqr, - DistanceSquared (point, - rect.TR ())); - - return distSqr; - - } - -/*****************************************************************************/ - -real64 MaxDistancePointToRect (const dng_point_real64 &point, - const dng_rect_real64 &rect) - { - - return sqrt (MaxSquaredDistancePointToRect (point, - rect)); - - } - -/*****************************************************************************/ - -dng_dither::dng_dither () - - : fNoiseBuffer () - - { - - const uint32 kSeed = 1; - - fNoiseBuffer.Allocate (kRNGSize2D * sizeof (uint16)); - - uint16 *buffer = fNoiseBuffer.Buffer_uint16 (); - - uint32 seed = kSeed; - - for (uint32 i = 0; i < kRNGSize2D; i++) - { - - seed = DNG_Random (seed); - - buffer [i] = (uint16) (seed); - - } - - } - -/******************************************************************************/ - -const dng_dither & dng_dither::Get () - { - - static dng_dither dither; - - return dither; - - } - -/*****************************************************************************/ - -void HistogramArea (dng_host & /* host */, - const dng_image &image, - const dng_rect &area, - uint32 *hist, - uint32 maxValue, - uint32 plane) - { - - DNG_ASSERT (image.PixelType () == ttShort, "Unsupported pixel type"); - - DoZeroBytes (hist, (maxValue + 1) * (uint32) sizeof (uint32)); - - dng_rect tile; - - dng_tile_iterator iter (image, area); - - while (iter.GetOneTile (tile)) - { - - dng_const_tile_buffer buffer (image, tile); - - const void *sPtr = buffer.ConstPixel (tile.t, - tile.l, - plane); - - uint32 count0 = 1; - uint32 count1 = tile.H (); - uint32 count2 = tile.W (); - - int32 step0 = 0; - int32 step1 = buffer.fRowStep; - int32 step2 = buffer.fColStep; - - OptimizeOrder (sPtr, - buffer.fPixelSize, - count0, - count1, - count2, - step0, - step1, - step2); - - DNG_ASSERT (count0 == 1, "OptimizeOrder logic error"); - - const uint16 *s1 = (const uint16 *) sPtr; - - for (uint32 row = 0; row < count1; row++) - { - - if (maxValue == 0x0FFFF && step2 == 1) - { - - for (uint32 col = 0; col < count2; col++) - { - - uint32 x = s1 [col]; - - hist [x] ++; - - } - - } - - else - { - - const uint16 *s2 = s1; - - for (uint32 col = 0; col < count2; col++) - { - - uint32 x = s2 [0]; - - if (x <= maxValue) - { - - hist [x] ++; - - } - - s2 += step2; - - } - - } - - s1 += step1; - - } - - } - - } - -/*****************************************************************************/ - -class dng_limit_float_depth_task: public dng_area_task - { - - private: - - const dng_image &fSrcImage; - - dng_image &fDstImage; - - uint32 fBitDepth; - - real32 fScale; - - public: - - dng_limit_float_depth_task (const dng_image &srcImage, - dng_image &dstImage, - uint32 bitDepth, - real32 scale); - - virtual dng_rect RepeatingTile1 () const - { - return fSrcImage.RepeatingTile (); - } - - virtual dng_rect RepeatingTile2 () const - { - return fDstImage.RepeatingTile (); - } - - virtual void Process (uint32 threadIndex, - const dng_rect &tile, - dng_abort_sniffer *sniffer); - - }; - -/*****************************************************************************/ - -dng_limit_float_depth_task::dng_limit_float_depth_task (const dng_image &srcImage, - dng_image &dstImage, - uint32 bitDepth, - real32 scale) - - : fSrcImage (srcImage) - , fDstImage (dstImage) - , fBitDepth (bitDepth) - , fScale (scale) - - { - - } - -/*****************************************************************************/ - -void dng_limit_float_depth_task::Process (uint32 /* threadIndex */, - const dng_rect &tile, - dng_abort_sniffer * /* sniffer */) - { - - dng_const_tile_buffer srcBuffer (fSrcImage, tile); - dng_dirty_tile_buffer dstBuffer (fDstImage, tile); - - uint32 count0 = tile.H (); - uint32 count1 = tile.W (); - uint32 count2 = fDstImage.Planes (); - - int32 sStep0 = srcBuffer.fRowStep; - int32 sStep1 = srcBuffer.fColStep; - int32 sStep2 = srcBuffer.fPlaneStep; - - int32 dStep0 = dstBuffer.fRowStep; - int32 dStep1 = dstBuffer.fColStep; - int32 dStep2 = dstBuffer.fPlaneStep; - - const void *sPtr = srcBuffer.ConstPixel (tile.t, - tile.l, - 0); - - void *dPtr = dstBuffer.DirtyPixel (tile.t, - tile.l, - 0); - - OptimizeOrder (sPtr, - dPtr, - srcBuffer.fPixelSize, - dstBuffer.fPixelSize, - count0, - count1, - count2, - sStep0, - sStep1, - sStep2, - dStep0, - dStep1, - dStep2); - - const real32 *sPtr0 = (const real32 *) sPtr; - real32 *dPtr0 = ( real32 *) dPtr; - - real32 scale = fScale; - - bool limit16 = (fBitDepth == 16); - bool limit24 = (fBitDepth == 24); - - for (uint32 index0 = 0; index0 < count0; index0++) - { - - const real32 *sPtr1 = sPtr0; - real32 *dPtr1 = dPtr0; - - for (uint32 index1 = 0; index1 < count1; index1++) - { - - // If the scale is a NOP, and the data is packed solid, we can just do memory - // copy. - - if (scale == 1.0f && sStep2 == 1 && dStep2 == 1) - { - - if (dPtr1 != sPtr1) // srcImage != dstImage - { - - memcpy (dPtr1, sPtr1, count2 * (uint32) sizeof (real32)); - - } - - } - - else - { - - const real32 *sPtr2 = sPtr1; - real32 *dPtr2 = dPtr1; - - for (uint32 index2 = 0; index2 < count2; index2++) - { - - real32 x = sPtr2 [0]; - - x *= scale; - - dPtr2 [0] = x; - - sPtr2 += sStep2; - dPtr2 += dStep2; - - } - - } - - // The data is now in the destination buffer. - - if (limit16) - { - - uint32 *dPtr2 = (uint32 *) dPtr1; - - for (uint32 index2 = 0; index2 < count2; index2++) - { - - uint32 x = dPtr2 [0]; - - uint16 y = DNG_FloatToHalf (x); - - x = DNG_HalfToFloat (y); - - dPtr2 [0] = x; - - dPtr2 += dStep2; - - } - - } - - else if (limit24) - { - - uint32 *dPtr2 = (uint32 *) dPtr1; - - for (uint32 index2 = 0; index2 < count2; index2++) - { - - uint32 x = dPtr2 [0]; - - uint8 temp [3]; - - DNG_FloatToFP24 (x, temp); - - x = DNG_FP24ToFloat (temp); - - dPtr2 [0] = x; - - dPtr2 += dStep2; - - } - - } - - sPtr1 += sStep1; - dPtr1 += dStep1; - - } - - sPtr0 += sStep0; - dPtr0 += dStep0; - - } - - } - -/******************************************************************************/ - -void LimitFloatBitDepth (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - uint32 bitDepth, - real32 scale) - { - - DNG_ASSERT (srcImage.PixelType () == ttFloat, "Floating point image expected"); - DNG_ASSERT (dstImage.PixelType () == ttFloat, "Floating point image expected"); - - dng_limit_float_depth_task task (srcImage, - dstImage, - bitDepth, - scale); - - host.PerformAreaTask (task, dstImage.Bounds ()); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_utils.h b/third_party/dng_sdk/dng_utils.h deleted file mode 100644 index 560c37c..0000000 --- a/third_party/dng_sdk/dng_utils.h +++ /dev/null @@ -1,1237 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_utils.h#3 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_utils__ -#define __dng_utils__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_flags.h" -#include "dng_memory.h" -#include "dng_types.h" - -/*****************************************************************************/ - -inline uint32 Abs_int32 (int32 x) - { - - #if 0 - - // Reference version. - - return (uint32) (x < 0 ? -x : x); - - #else - - // Branchless version. - - uint32 mask = (uint32) (x >> 31); - - return (uint32) (((uint32) x + mask) ^ mask); - - #endif - - } - -inline int32 Min_int32 (int32 x, int32 y) - { - - return (x <= y ? x : y); - - } - -inline int32 Max_int32 (int32 x, int32 y) - { - - return (x >= y ? x : y); - - } - -inline int32 Pin_int32 (int32 min, int32 x, int32 max) - { - - return Max_int32 (min, Min_int32 (x, max)); - - } - -inline int32 Pin_int32_between (int32 a, int32 x, int32 b) - { - - int32 min, max; - if (a < b) { min = a; max = b; } - else { min = b; max = a; } - - return Pin_int32 (min, x, max); - - } - -/*****************************************************************************/ - -inline uint16 Min_uint16 (uint16 x, uint16 y) - { - - return (x <= y ? x : y); - - } - -inline uint16 Max_uint16 (uint16 x, uint16 y) - { - - return (x >= y ? x : y); - - } - -inline int16 Pin_int16 (int32 x) - { - - x = Pin_int32 (-32768, x, 32767); - - return (int16) x; - - } - -/*****************************************************************************/ - -inline uint32 Min_uint32 (uint32 x, uint32 y) - { - - return (x <= y ? x : y); - - } - -inline uint32 Min_uint32 (uint32 x, uint32 y, uint32 z) - { - - return Min_uint32 (x, Min_uint32 (y, z)); - - } - -inline uint32 Max_uint32 (uint32 x, uint32 y) - { - - return (x >= y ? x : y); - - } - -inline uint32 Max_uint32 (uint32 x, uint32 y, uint32 z) - { - - return Max_uint32 (x, Max_uint32 (y, z)); - - } - -inline uint32 Pin_uint32 (uint32 min, uint32 x, uint32 max) - { - - return Max_uint32 (min, Min_uint32 (x, max)); - - } - -/*****************************************************************************/ - -inline uint16 Pin_uint16 (int32 x) - { - - #if 0 - - // Reference version. - - x = Pin_int32 (0, x, 0x0FFFF); - - #else - - // Single branch version. - - if (x & ~65535) - { - - x = ~x >> 31; - - } - - #endif - - return (uint16) x; - - } - -/*****************************************************************************/ - -inline uint32 RoundUp2 (uint32 x) - { - - return (x + 1) & (uint32) ~1; - - } - -inline uint32 RoundUp4 (uint32 x) - { - - return (x + 3) & (uint32) ~3; - - } - -inline uint32 RoundUp8 (uint32 x) - { - - return (x + 7) & (uint32) ~7; - - } - -inline uint32 RoundUp16 (uint32 x) - { - - return (x + 15) & (uint32) ~15; - - } - -inline uint32 RoundUp4096 (uint32 x) - { - - return (x + 4095) & (uint32) ~4095; - - } - -/******************************************************************************/ - -inline uint32 RoundDown2 (uint32 x) - { - - return x & (uint32) ~1; - - } - -inline uint32 RoundDown4 (uint32 x) - { - - return x & (uint32) ~3; - - } - -inline uint32 RoundDown8 (uint32 x) - { - - return x & (uint32) ~7; - - } - -inline uint32 RoundDown16 (uint32 x) - { - - return x & (uint32) ~15; - - } - -/******************************************************************************/ - -inline uint32 RoundUpForPixelSize (uint32 x, uint32 pixelSize) - { - - switch (pixelSize) - { - - case 1: - return RoundUp16 (x); - - case 2: - return RoundUp8 (x); - - case 4: - return RoundUp4 (x); - - case 8: - return RoundUp2 (x); - - default: - return RoundUp16 (x); - - } - - } - -/******************************************************************************/ - -inline uint64 Abs_int64 (int64 x) - { - - return (uint64) (x < 0 ? -x : x); - - } - -inline int64 Min_int64 (int64 x, int64 y) - { - - return (x <= y ? x : y); - - } - -inline int64 Max_int64 (int64 x, int64 y) - { - - return (x >= y ? x : y); - - } - -inline int64 Pin_int64 (int64 min, int64 x, int64 max) - { - - return Max_int64 (min, Min_int64 (x, max)); - - } - -/******************************************************************************/ - -inline uint64 Min_uint64 (uint64 x, uint64 y) - { - - return (x <= y ? x : y); - - } - -inline uint64 Max_uint64 (uint64 x, uint64 y) - { - - return (x >= y ? x : y); - - } - -inline uint64 Pin_uint64 (uint64 min, uint64 x, uint64 max) - { - - return Max_uint64 (min, Min_uint64 (x, max)); - - } - -/*****************************************************************************/ - -inline real32 Abs_real32 (real32 x) - { - - return (x < 0.0f ? -x : x); - - } - -inline real32 Min_real32 (real32 x, real32 y) - { - - return (x < y ? x : y); - - } - -inline real32 Max_real32 (real32 x, real32 y) - { - - return (x > y ? x : y); - - } - -inline real32 Pin_real32 (real32 min, real32 x, real32 max) - { - - return Max_real32 (min, Min_real32 (x, max)); - - } - -inline real32 Pin_real32 (real32 x) - { - - return Pin_real32 (0.0f, x, 1.0f); - - } - -inline real32 Pin_real32_Overrange (real32 min, - real32 x, - real32 max) - { - - // Normal numbers in (min,max). No change. - - if (x > min && x < max) - { - return x; - } - - // Map large numbers (including positive infinity) to max. - - else if (x > min) - { - return max; - } - - // Map everything else (including negative infinity and all NaNs) to min. - - return min; - - } - -inline real32 Pin_Overrange (real32 x) - { - - // Normal in-range numbers, except for plus and minus zero. - - if (x > 0.0f && x <= 1.0f) - { - return x; - } - - // Large numbers, including positive infinity. - - else if (x > 0.5f) - { - return 1.0f; - } - - // Plus and minus zero, negative numbers, negative infinity, and all NaNs. - - return 0.0f; - - } - -inline real32 Lerp_real32 (real32 a, real32 b, real32 t) - { - - return a + t * (b - a); - - } - -/*****************************************************************************/ - -inline real64 Abs_real64 (real64 x) - { - - return (x < 0.0 ? -x : x); - - } - -inline real64 Min_real64 (real64 x, real64 y) - { - - return (x < y ? x : y); - - } - -inline real64 Max_real64 (real64 x, real64 y) - { - - return (x > y ? x : y); - - } - -inline real64 Pin_real64 (real64 min, real64 x, real64 max) - { - - return Max_real64 (min, Min_real64 (x, max)); - - } - -inline real64 Pin_real64 (real64 x) - { - - return Pin_real64 (0.0, x, 1.0); - - } - -inline real64 Pin_real64_Overrange (real64 min, - real64 x, - real64 max) - { - - // Normal numbers in (min,max). No change. - - if (x > min && x < max) - { - return x; - } - - // Map large numbers (including positive infinity) to max. - - else if (x > min) - { - return max; - } - - // Map everything else (including negative infinity and all NaNs) to min. - - return min; - - } - -inline real64 Lerp_real64 (real64 a, real64 b, real64 t) - { - - return a + t * (b - a); - - } - -/*****************************************************************************/ - -inline int32 Round_int32 (real32 x) - { - - return (int32) (x > 0.0f ? x + 0.5f : x - 0.5f); - - } - -inline int32 Round_int32 (real64 x) - { - - return (int32) (x > 0.0 ? x + 0.5 : x - 0.5); - - } - -inline uint32 Floor_uint32 (real32 x) - { - - return (uint32) Max_real32 (0.0f, x); - - } - -inline uint32 Floor_uint32 (real64 x) - { - - return (uint32) Max_real64 (0.0, x); - - } - -inline uint32 Round_uint32 (real32 x) - { - - return Floor_uint32 (x + 0.5f); - - } - -inline uint32 Round_uint32 (real64 x) - { - - return Floor_uint32 (x + 0.5); - - } - -/******************************************************************************/ - -inline int64 Round_int64 (real64 x) - { - - return (int64) (x >= 0.0 ? x + 0.5 : x - 0.5); - - } - -/*****************************************************************************/ - -const int64 kFixed64_One = (((int64) 1) << 32); -const int64 kFixed64_Half = (((int64) 1) << 31); - -/******************************************************************************/ - -inline int64 Real64ToFixed64 (real64 x) - { - - return Round_int64 (x * (real64) kFixed64_One); - - } - -/******************************************************************************/ - -inline real64 Fixed64ToReal64 (int64 x) - { - - return x * (1.0 / (real64) kFixed64_One); - - } - -/*****************************************************************************/ - -inline char ForceUppercase (char c) - { - - if (c >= 'a' && c <= 'z') - { - - c -= 'a' - 'A'; - - } - - return c; - - } - -/*****************************************************************************/ - -inline uint16 SwapBytes16 (uint16 x) - { - - return (uint16) ((x << 8) | - (x >> 8)); - - } - -inline uint32 SwapBytes32 (uint32 x) - { - - return (x << 24) + - ((x << 8) & 0x00FF0000) + - ((x >> 8) & 0x0000FF00) + - (x >> 24); - - } - -/*****************************************************************************/ - -inline bool IsAligned16 (const void *p) - { - - return (((uintptr) p) & 1) == 0; - - } - -inline bool IsAligned32 (const void *p) - { - - return (((uintptr) p) & 3) == 0; - - } - -inline bool IsAligned64 (const void *p) - { - - return (((uintptr) p) & 7) == 0; - - } - -inline bool IsAligned128 (const void *p) - { - - return (((uintptr) p) & 15) == 0; - - } - -/******************************************************************************/ - -// Converts from RGB values (range 0.0 to 1.0) to HSV values (range 0.0 to -// 6.0 for hue, and 0.0 to 1.0 for saturation and value). - -inline void DNG_RGBtoHSV (real32 r, - real32 g, - real32 b, - real32 &h, - real32 &s, - real32 &v) - { - - v = Max_real32 (r, Max_real32 (g, b)); - - real32 gap = v - Min_real32 (r, Min_real32 (g, b)); - - if (gap > 0.0f) - { - - if (r == v) - { - - h = (g - b) / gap; - - if (h < 0.0f) - { - h += 6.0f; - } - - } - - else if (g == v) - { - h = 2.0f + (b - r) / gap; - } - - else - { - h = 4.0f + (r - g) / gap; - } - - s = gap / v; - - } - - else - { - h = 0.0f; - s = 0.0f; - } - - } - -/*****************************************************************************/ - -// Converts from HSV values (range 0.0 to 6.0 for hue, and 0.0 to 1.0 for -// saturation and value) to RGB values (range 0.0 to 1.0). - -inline void DNG_HSVtoRGB (real32 h, - real32 s, - real32 v, - real32 &r, - real32 &g, - real32 &b) - { - - if (s > 0.0f) - { - - if (h < 0.0f) - h += 6.0f; - - if (h >= 6.0f) - h -= 6.0f; - - int32 i = (int32) h; - real32 f = h - (real32) i; - - real32 p = v * (1.0f - s); - - #define q (v * (1.0f - s * f)) - #define t (v * (1.0f - s * (1.0f - f))) - - switch (i) - { - case 0: r = v; g = t; b = p; break; - case 1: r = q; g = v; b = p; break; - case 2: r = p; g = v; b = t; break; - case 3: r = p; g = q; b = v; break; - case 4: r = t; g = p; b = v; break; - case 5: r = v; g = p; b = q; break; - } - - #undef q - #undef t - - } - - else - { - r = v; - g = v; - b = v; - } - - } - -/******************************************************************************/ - -// High resolution timer, for code profiling. - -real64 TickTimeInSeconds (); - -// Lower resolution timer, but more stable. - -real64 TickCountInSeconds (); - -/******************************************************************************/ - -class dng_timer - { - - public: - - dng_timer (const char *message); - - ~dng_timer (); - - private: - - // Hidden copy constructor and assignment operator. - - dng_timer (const dng_timer &timer); - - dng_timer & operator= (const dng_timer &timer); - - private: - - const char *fMessage; - - real64 fStartTime; - - }; - -/*****************************************************************************/ - -// Returns the maximum squared Euclidean distance from the specified point to the -// specified rectangle rect. - -real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point, - const dng_rect_real64 &rect); - -/*****************************************************************************/ - -// Returns the maximum Euclidean distance from the specified point to the specified -// rectangle rect. - -real64 MaxDistancePointToRect (const dng_point_real64 &point, - const dng_rect_real64 &rect); - -/*****************************************************************************/ - -inline uint32 DNG_HalfToFloat (uint16 halfValue) - { - - int32 sign = (halfValue >> 15) & 0x00000001; - int32 exponent = (halfValue >> 10) & 0x0000001f; - int32 mantissa = halfValue & 0x000003ff; - - if (exponent == 0) - { - - if (mantissa == 0) - { - - // Plus or minus zero - - return (uint32) (sign << 31); - - } - - else - { - - // Denormalized number -- renormalize it - - while (!(mantissa & 0x00000400)) - { - mantissa <<= 1; - exponent -= 1; - } - - exponent += 1; - mantissa &= ~0x00000400; - - } - - } - - else if (exponent == 31) - { - - if (mantissa == 0) - { - - // Positive or negative infinity, convert to maximum (16 bit) values. - - return (uint32) ((sign << 31) | ((0x1eL + 127 - 15) << 23) | (0x3ffL << 13)); - - } - - else - { - - // Nan -- Just set to zero. - - return 0; - - } - - } - - // Normalized number - - exponent += (127 - 15); - mantissa <<= 13; - - // Assemble sign, exponent and mantissa. - - return (uint32) ((sign << 31) | (exponent << 23) | mantissa); - - } - -/*****************************************************************************/ - -inline uint16 DNG_FloatToHalf (uint32 i) - { - - int32 sign = (i >> 16) & 0x00008000; - int32 exponent = ((i >> 23) & 0x000000ff) - (127 - 15); - int32 mantissa = i & 0x007fffff; - - if (exponent <= 0) - { - - if (exponent < -10) - { - - // Zero or underflow to zero. - - return (uint16)sign; - - } - - // E is between -10 and 0. We convert f to a denormalized half. - - mantissa = (mantissa | 0x00800000) >> (1 - exponent); - - // Round to nearest, round "0.5" up. - // - // Rounding may cause the significand to overflow and make - // our number normalized. Because of the way a half's bits - // are laid out, we don't have to treat this case separately; - // the code below will handle it correctly. - - if (mantissa & 0x00001000) - mantissa += 0x00002000; - - // Assemble the half from sign, exponent (zero) and mantissa. - - return (uint16)(sign | (mantissa >> 13)); - - } - - else if (exponent == 0xff - (127 - 15)) - { - - if (mantissa == 0) - { - - // F is an infinity; convert f to a half - // infinity with the same sign as f. - - return (uint16)(sign | 0x7c00); - - } - - else - { - - // F is a NAN; produce a half NAN that preserves - // the sign bit and the 10 leftmost bits of the - // significand of f. - - return (uint16)(sign | 0x7c00 | (mantissa >> 13)); - - } - - } - - // E is greater than zero. F is a normalized float. - // We try to convert f to a normalized half. - - // Round to nearest, round "0.5" up - - if (mantissa & 0x00001000) - { - - mantissa += 0x00002000; - - if (mantissa & 0x00800000) - { - mantissa = 0; // overflow in significand, - exponent += 1; // adjust exponent - } - - } - - // Handle exponent overflow - - if (exponent > 30) - { - return (uint16)(sign | 0x7c00); // infinity with the same sign as f. - } - - // Assemble the half from sign, exponent and mantissa. - - return (uint16)(sign | (exponent << 10) | (mantissa >> 13)); - - } - -/*****************************************************************************/ - -inline uint32 DNG_FP24ToFloat (const uint8 *input) - { - - int32 sign = (input [0] >> 7) & 0x01; - int32 exponent = (input [0] ) & 0x7F; - int32 mantissa = (((int32) input [1]) << 8) | input[2]; - - if (exponent == 0) - { - - if (mantissa == 0) - { - - // Plus or minus zero - - return (uint32) (sign << 31); - - } - - else - { - - // Denormalized number -- renormalize it - - while (!(mantissa & 0x00010000)) - { - mantissa <<= 1; - exponent -= 1; - } - - exponent += 1; - mantissa &= ~0x00010000; - - } - - } - - else if (exponent == 127) - { - - if (mantissa == 0) - { - - // Positive or negative infinity, convert to maximum (24 bit) values. - - return (uint32) ((sign << 31) | ((0x7eL + 128 - 64) << 23) | (0xffffL << 7)); - - } - - else - { - - // Nan -- Just set to zero. - - return 0; - - } - - } - - // Normalized number - - exponent += (128 - 64); - mantissa <<= 7; - - // Assemble sign, exponent and mantissa. - - return (uint32) ((sign << 31) | (exponent << 23) | mantissa); - - } - -/*****************************************************************************/ - -inline void DNG_FloatToFP24 (uint32 input, uint8 *output) - { - - int32 exponent = (int32) ((input >> 23) & 0xFF) - 128; - int32 mantissa = input & 0x007FFFFF; - - if (exponent == 127) // infinity or NaN - { - - // Will the NaN alais to infinity? - - if (mantissa != 0x007FFFFF && ((mantissa >> 7) == 0xFFFF)) - { - - mantissa &= 0x003FFFFF; // knock out msb to make it a NaN - - } - - } - - else if (exponent > 63) // overflow, map to infinity - { - - exponent = 63; - mantissa = 0x007FFFFF; - - } - - else if (exponent <= -64) - { - - if (exponent >= -79) // encode as denorm - { - mantissa = (mantissa | 0x00800000) >> (-63 - exponent); - } - - else // underflow to zero - { - mantissa = 0; - } - - exponent = -64; - - } - - output [0] = (uint8)(((input >> 24) & 0x80) | (uint32) (exponent + 64)); - - output [1] = (mantissa >> 15) & 0x00FF; - output [2] = (mantissa >> 7) & 0x00FF; - - } - -/******************************************************************************/ - -// The following code was from PSDivide.h in Photoshop. - -// High order 32-bits of an unsigned 32 by 32 multiply. - -#ifndef MULUH - -#if defined(_X86_) && defined(_MSC_VER) - -inline uint32 Muluh86 (uint32 x, uint32 y) - { - uint32 result; - __asm - { - MOV EAX, x - MUL y - MOV result, EDX - } - return (result); - } - -#define MULUH Muluh86 - -#else - -#define MULUH(x,y) ((uint32) (((x) * (uint64) (y)) >> 32)) - -#endif - -#endif - -// High order 32-bits of an signed 32 by 32 multiply. - -#ifndef MULSH - -#if defined(_X86_) && defined(_MSC_VER) - -inline int32 Mulsh86 (int32 x, int32 y) - { - int32 result; - __asm - { - MOV EAX, x - IMUL y - MOV result, EDX - } - return (result); - } - -#define MULSH Mulsh86 - -#else - -#define MULSH(x,y) ((int32) (((x) * (int64) (y)) >> 32)) - -#endif - -#endif - -/******************************************************************************/ - -// Random number generator (identical to Apple's) for portable use. - -// This implements the "minimal standard random number generator" -// as proposed by Park and Miller in CACM October, 1988. -// It has a period of 2147483647 (0x7fffffff) - -// This is the ACM standard 30 bit generator: -// x' = (x * 16807) mod 2^31-1 - -inline uint32 DNG_Random (uint32 seed) - { - - // high = seed / 127773 - - uint32 temp = MULUH (0x069C16BD, seed); - uint32 high = (temp + ((seed - temp) >> 1)) >> 16; - - // low = seed % 127773 - - uint32 low = seed - high * 127773; - - // seed = (seed * 16807) % 2147483647 - - seed = 16807 * low - 2836 * high; - - if (seed & 0x80000000) - seed += 2147483647; - - return seed; - - } - -/*****************************************************************************/ - -class dng_dither - { - - public: - - static const uint32 kRNGBits = 7; - - static const uint32 kRNGSize = 1 << kRNGBits; - - static const uint32 kRNGMask = kRNGSize - 1; - - static const uint32 kRNGSize2D = kRNGSize * kRNGSize; - - private: - - dng_memory_data fNoiseBuffer; - - private: - - dng_dither (); - - // Hidden copy constructor and assignment operator. - - dng_dither (const dng_dither &); - - dng_dither & operator= (const dng_dither &); - - public: - - static const dng_dither & Get (); - - public: - - const uint16 *NoiseBuffer16 () const - { - return fNoiseBuffer.Buffer_uint16 (); - } - - }; - -/*****************************************************************************/ - -void HistogramArea (dng_host &host, - const dng_image &image, - const dng_rect &area, - uint32 *hist, - uint32 histLimit, - uint32 plane = 0); - -/*****************************************************************************/ - -void LimitFloatBitDepth (dng_host &host, - const dng_image &srcImage, - dng_image &dstImage, - uint32 bitDepth, - real32 scale = 1.0f); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_validate.cpp b/third_party/dng_sdk/dng_validate.cpp deleted file mode 100644 index 468968f..0000000 --- a/third_party/dng_sdk/dng_validate.cpp +++ /dev/null @@ -1,879 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_validate.cpp#2 $ */ -/* $DateTime: 2012/06/14 20:24:41 $ */ -/* $Change: 835078 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_color_space.h" -#include "dng_date_time.h" -#include "dng_exceptions.h" -#include "dng_file_stream.h" -#include "dng_globals.h" -#include "dng_host.h" -#include "dng_ifd.h" -#include "dng_image_writer.h" -#include "dng_info.h" -#include "dng_linearization_info.h" -#include "dng_mosaic_info.h" -#include "dng_negative.h" -#include "dng_preview.h" -#include "dng_render.h" -#include "dng_simple_image.h" -#include "dng_tag_codes.h" -#include "dng_tag_types.h" -#include "dng_tag_values.h" -#include "dng_xmp.h" -#include "dng_xmp_sdk.h" - -/*****************************************************************************/ - -#if qDNGValidateTarget - -/*****************************************************************************/ - -#define kDNGValidateVersion "1.4" - -/*****************************************************************************/ - -static bool gFourColorBayer = false; - -static int32 gMosaicPlane = -1; - -static uint32 gPreferredSize = 0; -static uint32 gMinimumSize = 0; -static uint32 gMaximumSize = 0; - -static uint32 gProxyDNGSize = 0; - -static const dng_color_space *gFinalSpace = &dng_space_sRGB::Get (); - -static uint32 gFinalPixelType = ttByte; - -static dng_string gDumpStage1; -static dng_string gDumpStage2; -static dng_string gDumpStage3; -static dng_string gDumpTIF; -static dng_string gDumpDNG; - -/*****************************************************************************/ - -static dng_error_code dng_validate (const char *filename) - { - - printf ("Validating \"%s\"...\n", filename); - - try - { - - dng_file_stream stream (filename); - - dng_host host; - - host.SetPreferredSize (gPreferredSize); - host.SetMinimumSize (gMinimumSize ); - host.SetMaximumSize (gMaximumSize ); - - host.ValidateSizes (); - - if (host.MinimumSize ()) - { - - host.SetForPreview (true); - - gDumpDNG.Clear (); - - } - - if (gDumpDNG.NotEmpty ()) - { - - host.SetSaveDNGVersion (dngVersion_SaveDefault); - - host.SetSaveLinearDNG (false); - - host.SetKeepOriginalFile (false); - - } - - // Read into the negative. - - AutoPtr negative; - - { - - dng_info info; - - info.Parse (host, stream); - - info.PostParse (host); - - if (!info.IsValidDNG ()) - { - return dng_error_bad_format; - } - - negative.Reset (host.Make_dng_negative ()); - - negative->Parse (host, stream, info); - - negative->PostParse (host, stream, info); - - { - - dng_timer timer ("Raw image read time"); - - negative->ReadStage1Image (host, stream, info); - - } - - if (info.fMaskIndex != -1) - { - - dng_timer timer ("Transparency mask read time"); - - negative->ReadTransparencyMask (host, stream, info); - - } - - negative->ValidateRawImageDigest (host); - - } - - // Option to write stage 1 image. - - if (gDumpStage1.NotEmpty ()) - { - - dng_file_stream stream2 (gDumpStage1.Get (), true); - - const dng_image &stage1 = *negative->Stage1Image (); - - dng_image_writer writer; - - writer.WriteTIFF (host, - stream2, - stage1, - stage1.Planes () >= 3 ? piRGB - : piBlackIsZero); - - gDumpStage1.Clear (); - - } - - // Metadata. - - negative->SynchronizeMetadata (); - - // Four color Bayer option. - - if (gFourColorBayer) - { - negative->SetFourColorBayer (); - } - - // Build stage 2 image. - - { - - dng_timer timer ("Linearization time"); - - negative->BuildStage2Image (host); - - } - - if (gDumpStage2.NotEmpty ()) - { - - dng_file_stream stream2 (gDumpStage2.Get (), true); - - const dng_image &stage2 = *negative->Stage2Image (); - - dng_image_writer writer; - - writer.WriteTIFF (host, - stream2, - stage2, - stage2.Planes () >= 3 ? piRGB - : piBlackIsZero); - - gDumpStage2.Clear (); - - } - - // Build stage 3 image. - - { - - dng_timer timer ("Interpolate time"); - - negative->BuildStage3Image (host, - gMosaicPlane); - - } - - // Convert to proxy, if requested. - - if (gProxyDNGSize) - { - - dng_timer timer ("ConvertToProxy time"); - - dng_image_writer writer; - - negative->ConvertToProxy (host, - writer, - gProxyDNGSize); - - } - - // Flatten transparency, if required. - - if (negative->NeedFlattenTransparency (host)) - { - - dng_timer timer ("FlattenTransparency time"); - - negative->FlattenTransparency (host); - - } - - if (gDumpStage3.NotEmpty ()) - { - - dng_file_stream stream2 (gDumpStage3.Get (), true); - - const dng_image &stage3 = *negative->Stage3Image (); - - dng_image_writer writer; - - writer.WriteTIFF (host, - stream2, - stage3, - stage3.Planes () >= 3 ? piRGB - : piBlackIsZero); - - gDumpStage3.Clear (); - - } - - // Output DNG file if requested. - - if (gDumpDNG.NotEmpty ()) - { - - // Build the preview list. - - dng_preview_list previewList; - - dng_date_time_info dateTimeInfo; - - CurrentDateTimeAndZone (dateTimeInfo); - - for (uint32 previewIndex = 0; previewIndex < 2; previewIndex++) - { - - // Skip preview if writing a compresssed main image to save space - // in this example code. - - if (negative->RawJPEGImage () != NULL && previewIndex > 0) - { - break; - } - - // Report timing. - - dng_timer timer (previewIndex == 0 ? "Build thumbnail time" - : "Build preview time"); - - // Render a preview sized image. - - AutoPtr previewImage; - - { - - dng_render render (host, *negative); - - render.SetFinalSpace (negative->IsMonochrome () ? dng_space_GrayGamma22::Get () - : dng_space_sRGB ::Get ()); - - render.SetFinalPixelType (ttByte); - - render.SetMaximumSize (previewIndex == 0 ? 256 : 1024); - - previewImage.Reset (render.Render ()); - - } - - // Don't write the preview if it is same size as thumbnail. - - if (previewIndex > 0 && - Max_uint32 (previewImage->Bounds ().W (), - previewImage->Bounds ().H ()) <= 256) - { - break; - } - - // If we have compressed JPEG data, create a compressed thumbnail. Otherwise - // save a uncompressed thumbnail. - - bool useCompressedPreview = (negative->RawJPEGImage () != NULL) || - (previewIndex > 0); - - AutoPtr preview (useCompressedPreview ? - (dng_preview *) new dng_jpeg_preview : - (dng_preview *) new dng_image_preview); - - // Setup up preview info. - - preview->fInfo.fApplicationName .Set ("dng_validate"); - preview->fInfo.fApplicationVersion.Set (kDNGValidateVersion); - - preview->fInfo.fSettingsName.Set ("Default"); - - preview->fInfo.fColorSpace = previewImage->Planes () == 1 ? - previewColorSpace_GrayGamma22 : - previewColorSpace_sRGB; - - preview->fInfo.fDateTime = dateTimeInfo.Encode_ISO_8601 (); - - if (!useCompressedPreview) - { - - dng_image_preview *imagePreview = dynamic_cast (preview.Get ()); - - imagePreview->fImage.Reset (previewImage.Release ()); - - } - - else - { - - dng_jpeg_preview *jpegPreview = dynamic_cast (preview.Get ()); - - int32 quality = (previewIndex == 0 ? 8 : 5); - - dng_image_writer writer; - - writer.EncodeJPEGPreview (host, - *previewImage, - *jpegPreview, - quality); - - } - - previewList.Append (preview); - - } - - // Write DNG file. - - dng_file_stream stream2 (gDumpDNG.Get (), true); - - { - - dng_timer timer ("Write DNG time"); - - dng_image_writer writer; - - writer.WriteDNG (host, - stream2, - *negative.Get (), - &previewList, - dngVersion_Current, - false); - - } - - gDumpDNG.Clear (); - - } - - // Output TIF file if requested. - - if (gDumpTIF.NotEmpty ()) - { - - // Render final image. - - dng_render render (host, *negative); - - render.SetFinalSpace (*gFinalSpace ); - render.SetFinalPixelType (gFinalPixelType); - - if (host.MinimumSize ()) - { - - dng_point stage3Size = negative->Stage3Image ()->Size (); - - render.SetMaximumSize (Max_uint32 (stage3Size.v, - stage3Size.h)); - - } - - AutoPtr finalImage; - - { - - dng_timer timer ("Render time"); - - finalImage.Reset (render.Render ()); - - } - - finalImage->Rotate (negative->Orientation ()); - - // Now that Camera Raw supports non-raw formats, we should - // not keep any Camera Raw settings in the XMP around when - // writing rendered files. - - if (negative->GetXMP ()) - { - - negative->GetXMP ()->RemoveProperties (XMP_NS_CRS); - negative->GetXMP ()->RemoveProperties (XMP_NS_CRSS); - - } - - // Write TIF file. - - dng_file_stream stream2 (gDumpTIF.Get (), true); - - { - - dng_timer timer ("Write TIFF time"); - - dng_image_writer writer; - - writer.WriteTIFF (host, - stream2, - *finalImage.Get (), - finalImage->Planes () >= 3 ? piRGB - : piBlackIsZero, - ccUncompressed, - negative.Get (), - &render.FinalSpace ()); - - } - - gDumpTIF.Clear (); - - } - - } - - catch (const dng_exception &except) - { - - return except.ErrorCode (); - - } - - catch (...) - { - - return dng_error_unknown; - - } - - printf ("Validation complete\n"); - - return dng_error_none; - - } - -/*****************************************************************************/ - -int main (int argc, char *argv []) - { - - try - { - - if (argc == 1) - { - - fprintf (stderr, - "\n" - "dng_validate, version " kDNGValidateVersion " " - #if qDNG64Bit - "(64-bit)" - #else - "(32-bit)" - #endif - "\n" - "Copyright 2005-2012 Adobe Systems, Inc.\n" - "\n" - "Usage: %s [options] file1 file2 ...\n" - "\n" - "Valid options:\n" - "-v Verbose mode\n" - "-d Dump line limit (implies -v)\n" - "-b4 Use four-color Bayer interpolation\n" - "-s Use this sample of multi-sample CFAs\n" - "-size Preferred preview image size\n" - "-min Minimum preview image size\n" - "-max Maximum preview image size\n" - "-proxy Target size for proxy DNG\n" - "-cs1 Color space: \"sRGB\" (default)\n" - "-cs2 Color space: \"Adobe RGB\"\n" - "-cs3 Color space: \"ProPhoto RGB\"\n" - "-cs4 Color space: \"ColorMatch RGB\"\n" - "-cs5 Color space: \"Gray Gamma 1.8\"\n" - "-cs6 Color space: \"Gray Gamma 2.2\"\n" - "-16 16-bits/channel output\n" - "-1 Write stage 1 image to \".tif\"\n" - "-2 Write stage 2 image to \".tif\"\n" - "-3 Write stage 3 image to \".tif\"\n" - "-tif Write TIF image to \".tif\"\n" - "-dng Write DNG image to \".dng\"\n" - "\n", - argv [0]); - - return 1; - - } - - int index; - - for (index = 1; index < argc && argv [index] [0] == '-'; index++) - { - - dng_string option; - - option.Set (&argv [index] [1]); - - if (option.Matches ("v", true)) - { - gVerbose = true; - } - - else if (option.Matches ("d", true)) - { - - gVerbose = true; - - gDumpLineLimit = 0; - - if (index + 1 < argc) - { - gDumpLineLimit = atoi (argv [++index]); - } - - if (!gDumpLineLimit) - { - fprintf (stderr, "*** Invalid number after -d\n"); - return 1; - } - - } - - else if (option.Matches ("s", true)) - { - - if (index + 1 < argc) - { - gMosaicPlane = atoi (argv [++index]); - } - - else - { - fprintf (stderr, "*** Missing number after -s\n"); - return 1; - } - - } - - else if (option.Matches ("b4", true)) - { - gFourColorBayer = true; - } - - else if (option.Matches ("size", true)) - { - - if (index + 1 < argc) - { - gPreferredSize = (uint32) atoi (argv [++index]); - } - - else - { - fprintf (stderr, "*** Missing number after -size\n"); - return 1; - } - - } - - else if (option.Matches ("min", true)) - { - - if (index + 1 < argc) - { - gMinimumSize = (uint32) atoi (argv [++index]); - } - - else - { - fprintf (stderr, "*** Missing number after -min\n"); - return 1; - } - - } - - else if (option.Matches ("max", true)) - { - - if (index + 1 < argc) - { - gMaximumSize = (uint32) atoi (argv [++index]); - } - - else - { - fprintf (stderr, "*** Missing number after -max\n"); - return 1; - } - - } - - else if (option.Matches ("proxy", true)) - { - - if (index + 1 < argc) - { - gProxyDNGSize = (uint32) atoi (argv [++index]); - } - - else - { - fprintf (stderr, "*** Missing number after -proxy\n"); - return 1; - } - - } - - else if (option.Matches ("cs1", true)) - { - - gFinalSpace = &dng_space_sRGB::Get (); - - } - - else if (option.Matches ("cs2", true)) - { - - gFinalSpace = &dng_space_AdobeRGB::Get (); - - } - - else if (option.Matches ("cs3", true)) - { - - gFinalSpace = &dng_space_ProPhoto::Get (); - - } - - else if (option.Matches ("cs4", true)) - { - - gFinalSpace = &dng_space_ColorMatch::Get (); - - } - - else if (option.Matches ("cs5", true)) - { - - gFinalSpace = &dng_space_GrayGamma18::Get (); - - } - - else if (option.Matches ("cs6", true)) - { - - gFinalSpace = &dng_space_GrayGamma22::Get (); - - } - - else if (option.Matches ("16")) - { - - gFinalPixelType = ttShort; - - } - - else if (option.Matches ("1")) - { - - gDumpStage1.Clear (); - - if (index + 1 < argc) - { - gDumpStage1.Set (argv [++index]); - } - - if (gDumpStage1.IsEmpty () || gDumpStage1.StartsWith ("-")) - { - fprintf (stderr, "*** Missing file name after -1\n"); - return 1; - } - - if (!gDumpStage1.EndsWith (".tif")) - { - gDumpStage1.Append (".tif"); - } - - } - - else if (option.Matches ("2")) - { - - gDumpStage2.Clear (); - - if (index + 1 < argc) - { - gDumpStage2.Set (argv [++index]); - } - - if (gDumpStage2.IsEmpty () || gDumpStage2.StartsWith ("-")) - { - fprintf (stderr, "*** Missing file name after -2\n"); - return 1; - } - - if (!gDumpStage2.EndsWith (".tif")) - { - gDumpStage2.Append (".tif"); - } - - } - - else if (option.Matches ("3")) - { - - gDumpStage3.Clear (); - - if (index + 1 < argc) - { - gDumpStage3.Set (argv [++index]); - } - - if (gDumpStage3.IsEmpty () || gDumpStage3.StartsWith ("-")) - { - fprintf (stderr, "*** Missing file name after -3\n"); - return 1; - } - - if (!gDumpStage3.EndsWith (".tif")) - { - gDumpStage3.Append (".tif"); - } - - } - - else if (option.Matches ("tif", true)) - { - - gDumpTIF.Clear (); - - if (index + 1 < argc) - { - gDumpTIF.Set (argv [++index]); - } - - if (gDumpTIF.IsEmpty () || gDumpTIF.StartsWith ("-")) - { - fprintf (stderr, "*** Missing file name after -tif\n"); - return 1; - } - - if (!gDumpTIF.EndsWith (".tif")) - { - gDumpTIF.Append (".tif"); - } - - } - - else if (option.Matches ("dng", true)) - { - - gDumpDNG.Clear (); - - if (index + 1 < argc) - { - gDumpDNG.Set (argv [++index]); - } - - if (gDumpDNG.IsEmpty () || gDumpDNG.StartsWith ("-")) - { - fprintf (stderr, "*** Missing file name after -dng\n"); - return 1; - } - - if (!gDumpDNG.EndsWith (".dng")) - { - gDumpDNG.Append (".dng"); - } - - } - - else - { - fprintf (stderr, "*** Unknown option \"-%s\"\n", option.Get ()); - return 1; - } - - } - - if (index == argc) - { - fprintf (stderr, "*** No file specified\n"); - return 1; - } - - dng_xmp_sdk::InitializeSDK (); - - int result = 0; - - while (index < argc) - { - - if (dng_validate (argv [index++]) != dng_error_none) - { - - result = 1; - - } - - } - - dng_xmp_sdk::TerminateSDK (); - - return result; - - } - - catch (...) - { - - } - - fprintf (stderr, "*** Exception thrown in main routine\n"); - - return 1; - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xmp.cpp b/third_party/dng_sdk/dng_xmp.cpp deleted file mode 100644 index e761007..0000000 --- a/third_party/dng_sdk/dng_xmp.cpp +++ /dev/null @@ -1,4415 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2008 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xmp.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_xmp.h" - -#include "dng_assertions.h" -#include "dng_date_time.h" -#include "dng_exceptions.h" -#include "dng_exif.h" -#include "dng_image_writer.h" -#include "dng_iptc.h" -#include "dng_negative.h" -#include "dng_string.h" -#include "dng_string_list.h" -#include "dng_utils.h" -#include "dng_xmp_sdk.h" - -/*****************************************************************************/ - -dng_xmp::dng_xmp (dng_memory_allocator &allocator) - - : fAllocator (allocator) - - , fSDK (NULL) - - { - - fSDK = new dng_xmp_sdk (); - - if (!fSDK) - { - ThrowMemoryFull (); - } - - } - -/*****************************************************************************/ - -dng_xmp::dng_xmp (const dng_xmp &xmp) - - : fAllocator (xmp.fAllocator) - - , fSDK (NULL) - - { - - fSDK = new dng_xmp_sdk (*xmp.fSDK); - - if (!fSDK) - { - ThrowMemoryFull (); - } - - } - -/*****************************************************************************/ - -dng_xmp::~dng_xmp () - { - - if (fSDK) - { - - delete fSDK; - - } - - } - -/*****************************************************************************/ - -dng_xmp * dng_xmp::Clone () const - { - - dng_xmp *result = new dng_xmp (*this); - - if (!result) - { - ThrowMemoryFull (); - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp::TrimDecimal (char *s) - { - - uint32 len = (uint32) strlen (s); - - while (len > 0) - { - - if (s [len - 1] == '0') - s [--len] = 0; - - else - break; - - } - - if (len > 0) - { - - if (s [len - 1] == '.') - s [--len] = 0; - - } - - } - -/*****************************************************************************/ - -dng_string dng_xmp::EncodeFingerprint (const dng_fingerprint &f, - bool allowInvalid) - { - - dng_string result; - - if (f.IsValid () || allowInvalid) - { - - char s [dng_fingerprint::kDNGFingerprintSize * 2 + 1]; - - f.ToUtf8HexString (s); - - result.Set (s); - - } - - return result; - - } - -/*****************************************************************************/ - -dng_fingerprint dng_xmp::DecodeFingerprint (const dng_string &s) - { - - dng_fingerprint result; - - if (s.Length () == 32) - result.FromUtf8HexString (s.Get ()); - - return result; - - } - -/*****************************************************************************/ - -dng_string dng_xmp::EncodeGPSVersion (uint32 version) - { - - dng_string result; - - if (version) - { - - uint8 b0 = (uint8) (version >> 24); - uint8 b1 = (uint8) (version >> 16); - uint8 b2 = (uint8) (version >> 8); - uint8 b3 = (uint8) (version ); - - if (b0 <= 9 && b1 <= 9 && b2 <= 9 && b3 <= 9) - { - - char s [32]; - - sprintf (s, - "%u.%u.%u.%u", - (unsigned) b0, - (unsigned) b1, - (unsigned) b2, - (unsigned) b3); - - result.Set (s); - - } - - } - - return result; - - } - -/*****************************************************************************/ - -uint32 dng_xmp::DecodeGPSVersion (const dng_string &s) - { - - uint32 result = 0; - - if (s.Length () == 7) - { - - unsigned b0 = 0; - unsigned b1 = 0; - unsigned b2 = 0; - unsigned b3 = 0; - - if (sscanf (s.Get (), - "%u.%u.%u.%u", - &b0, - &b1, - &b2, - &b3) == 4) - { - - result = (b0 << 24) | - (b1 << 16) | - (b2 << 8) | - (b3 ); - - } - - } - - return result; - - } - -/*****************************************************************************/ - -dng_string dng_xmp::EncodeGPSCoordinate (const dng_string &ref, - const dng_urational *coord) - { - - dng_string result; - - if (ref.Length () == 1 && coord [0].IsValid () && - coord [1].IsValid ()) - { - - char refChar = ForceUppercase (ref.Get () [0]); - - if (refChar == 'N' || - refChar == 'S' || - refChar == 'E' || - refChar == 'W') - { - - char s [256]; - - // Use the seconds case if all three values are - // integers. - - if (coord [0].d == 1 && - coord [1].d == 1 && - coord [2].d == 1) - { - - sprintf (s, - "%u,%u,%u%c", - (unsigned) coord [0].n, - (unsigned) coord [1].n, - (unsigned) coord [2].n, - refChar); - - } - - // Else we need to use the fractional minutes case. - - else - { - - // Find value minutes. - - real64 x = coord [0].As_real64 () * 60.0 + - coord [1].As_real64 () + - coord [2].As_real64 () * (1.0 / 60.0); - - // Round to fractional four decimal places. - - uint32 y = Round_uint32 (x * 10000.0); - - // Split into degrees and minutes. - - uint32 d = y / (60 * 10000); - uint32 m = y % (60 * 10000); - - char min [32]; - - sprintf (min, "%.4f", m * (1.0 / 10000.0)); - - TrimDecimal (min); - - sprintf (s, - "%u,%s%c", - (unsigned) d, - min, - refChar); - - } - - result.Set (s); - - } - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp::DecodeGPSCoordinate (const dng_string &s, - dng_string &ref, - dng_urational *coord) - { - - ref.Clear (); - - coord [0].Clear (); - coord [1].Clear (); - coord [2].Clear (); - - if (s.Length () > 1) - { - - char refChar = ForceUppercase (s.Get () [s.Length () - 1]); - - if (refChar == 'N' || - refChar == 'S' || - refChar == 'E' || - refChar == 'W') - { - - dng_string ss (s); - - ss.Truncate (ss.Length () - 1); - - ss.NormalizeAsCommaSeparatedNumbers(); - - int degrees = 0; - - real64 minutes = 0.0; - real64 seconds = 0.0; - - int count = sscanf (ss.Get (), - "%d,%lf,%lf", - °rees, - &minutes, - &seconds); - - if (count < 1) - { - return; - } - - // The degree, minute, second values should always be positive. - - if (degrees < 0 || minutes < 0 || seconds < 0) - { - return; - } - - coord [0] = dng_urational ((uint32) degrees, 1); - - if (count <= 2) - { - coord [1].Set_real64 (minutes, 10000); - coord [2] = dng_urational (0, 1); - } - else - { - coord [1].Set_real64 (minutes, 1); - coord [2].Set_real64 (seconds, 100); - } - - char r [2]; - - r [0] = refChar; - r [1] = 0; - - ref.Set (r); - - } - - } - - } - -/*****************************************************************************/ - -dng_string dng_xmp::EncodeGPSDateTime (const dng_string &dateStamp, - const dng_urational *timeStamp) - { - - dng_string result; - - if (timeStamp [0].IsValid () && - timeStamp [1].IsValid () && - timeStamp [2].IsValid ()) - { - - char s [256]; - - char sec [32]; - - sprintf (sec, - "%09.6f", - timeStamp [2].As_real64 ()); - - TrimDecimal (sec); - - int year = 0; - int month = 0; - int day = 0; - - if (dateStamp.NotEmpty ()) - { - - sscanf (dateStamp.Get (), - "%d:%d:%d", - &year, - &month, - &day); - - } - - if (year >= 1 && year <= 9999 && - month >= 1 && month <= 12 && - day >= 1 && day <= 31) - { - - sprintf (s, - "%04d-%02d-%02dT%02u:%02u:%sZ", - year, - month, - day, - (unsigned) Round_uint32 (timeStamp [0].As_real64 ()), - (unsigned) Round_uint32 (timeStamp [1].As_real64 ()), - sec); - - } - - else - { - - sprintf (s, - "%02u:%02u:%sZ", - (unsigned) Round_uint32 (timeStamp [0].As_real64 ()), - (unsigned) Round_uint32 (timeStamp [1].As_real64 ()), - sec); - - } - - result.Set (s); - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp::DecodeGPSDateTime (const dng_string &s, - dng_string &dateStamp, - dng_urational *timeStamp) - { - - dateStamp.Clear (); - - timeStamp [0].Clear (); - timeStamp [1].Clear (); - timeStamp [2].Clear (); - - if (s.NotEmpty ()) - { - - unsigned year = 0; - unsigned month = 0; - unsigned day = 0; - unsigned hour = 0; - unsigned minute = 0; - - double second = 0.0; - - if (sscanf (s.Get (), - "%u-%u-%uT%u:%u:%lf", - &year, - &month, - &day, - &hour, - &minute, - &second) == 6) - { - - if (year >= 1 && year <= 9999 && - month >= 1 && month <= 12 && - day >= 1 && day <= 31 ) - { - - char ss [64]; - - sprintf (ss, - "%04u:%02u:%02u", - year, - month, - day); - - dateStamp.Set (ss); - - } - - } - - else if (sscanf (s.Get (), - "%u:%u:%lf", - &hour, - &minute, - &second) != 3) - { - - return; - - } - - timeStamp [0] = dng_urational ((uint32) hour , 1); - timeStamp [1] = dng_urational ((uint32) minute, 1); - - timeStamp [2].Set_real64 (second, 1000); - - } - - } - -/*****************************************************************************/ - -void dng_xmp::Parse (dng_host &host, - const void *buffer, - uint32 count) - { - - fSDK->Parse (host, - (const char *) buffer, - count); - - } - -/*****************************************************************************/ - -dng_memory_block * dng_xmp::Serialize (bool asPacket, - uint32 targetBytes, - uint32 padBytes, - bool forJPEG, - bool compact) const - { - - return fSDK->Serialize (fAllocator, - asPacket, - targetBytes, - padBytes, - forJPEG, - compact); - - } - -/*****************************************************************************/ - -void dng_xmp::PackageForJPEG (AutoPtr &stdBlock, - AutoPtr &extBlock, - dng_string &extDigest) const - { - - fSDK->PackageForJPEG (fAllocator, - stdBlock, - extBlock, - extDigest); - - } - -/*****************************************************************************/ - -void dng_xmp::MergeFromJPEG (const dng_xmp &xmp) - { - - fSDK->MergeFromJPEG (xmp.fSDK); - - } - -/*****************************************************************************/ - -bool dng_xmp::HasMeta () const - { - - return fSDK->HasMeta (); - - } - -/*****************************************************************************/ - -void * dng_xmp::GetPrivateMeta () - { - - return fSDK->GetPrivateMeta (); - - } - -/*****************************************************************************/ - -bool dng_xmp::Exists (const char *ns, - const char *path) const - { - - return fSDK->Exists (ns, path); - - } - -/*****************************************************************************/ - -bool dng_xmp::HasNameSpace (const char *ns) const - { - - return fSDK->HasNameSpace (ns); - - } - -/*****************************************************************************/ - -bool dng_xmp::IteratePaths (IteratePathsCallback *callback, - void *callbackData, - const char *ns, - const char *path) - { - - return fSDK->IteratePaths (callback, callbackData, ns, path); - - } - -/*****************************************************************************/ - -void dng_xmp::Remove (const char *ns, - const char *path) - { - - fSDK->Remove (ns, path); - - } - -/*****************************************************************************/ - -void dng_xmp::RemoveProperties (const char *ns) - { - - fSDK->RemoveProperties (ns); - - } - -/*****************************************************************************/ - -void dng_xmp::RemoveEmptyStringOrArray (const char *ns, - const char *path) - { - - if (path == NULL || path [0] == 0) - { - return; - } - - if (fSDK->IsEmptyString (ns, path) || - fSDK->IsEmptyArray (ns, path)) - { - - Remove (ns, path); - - } - - } - -/*****************************************************************************/ - -static bool RemoveEmptyStringsAndArraysCallback (const char *ns, - const char *path, - void *callbackData) - { - - dng_xmp *xmp = (dng_xmp *) callbackData; - - xmp->RemoveEmptyStringOrArray (ns, path); - - return true; - - } - -/*****************************************************************************/ - -void dng_xmp::RemoveEmptyStringsAndArrays (const char *ns) - { - - IteratePaths (RemoveEmptyStringsAndArraysCallback, - (void *) this, - ns, - NULL); - - } - -/*****************************************************************************/ - -void dng_xmp::Set (const char *ns, - const char *path, - const char *text) - { - - fSDK->Set (ns, path, text); - - } - -/*****************************************************************************/ - -bool dng_xmp::GetString (const char *ns, - const char *path, - dng_string &s) const - { - - return fSDK->GetString (ns, path, s); - - } - -/*****************************************************************************/ - -void dng_xmp::SetString (const char *ns, - const char *path, - const dng_string &s) - { - - fSDK->SetString (ns, path, s); - - } - -/*****************************************************************************/ - -bool dng_xmp::SyncString (const char *ns, - const char *path, - dng_string &s, - uint32 options) - { - - bool isDefault = s.IsEmpty (); - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault || (options & removeXMP)) - { - - Remove (ns, path); - - } - - else - { - - SetString (ns, path, s); - - } - - return false; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else - { - - SetString (ns, path, s); - - } - - return false; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (GetString (ns, path, s)) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - return true; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else if (!isDefault) - { - - SetString (ns, path, s); - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_xmp::GetStringList (const char *ns, - const char *path, - dng_string_list &list) const - { - - return fSDK->GetStringList (ns, path, list); - - } - -/*****************************************************************************/ - -void dng_xmp::SetStringList (const char *ns, - const char *path, - const dng_string_list &list, - bool isBag) - { - - fSDK->SetStringList (ns, path, list, isBag); - - } - -/*****************************************************************************/ - -void dng_xmp::SyncStringList (const char *ns, - const char *path, - dng_string_list &list, - bool isBag, - uint32 options) - { - - bool isDefault = (list.Count () == 0); - - // First make sure the XMP is not badly formatted, since - // this breaks some Photoshop logic. - - ValidateStringList (ns, path); - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault) - { - - Remove (ns, path); - - } - - else - { - - SetStringList (ns, path, list, isBag); - - } - - return; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - SetStringList (ns, path, list, isBag); - - return; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (GetStringList (ns, path, list)) - { - - return; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (!isDefault) - { - - SetStringList (ns, path, list, isBag); - - } - - } - -/*****************************************************************************/ - -void dng_xmp::SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const dng_string &s) - { - - dng_string ss (s); - - ss.SetLineEndings ('\n'); - - ss.StripLowASCII (); - - fSDK->SetStructField (ns, path, fieldNS, fieldName, ss.Get ()); - - } - -/*****************************************************************************/ - -void dng_xmp::SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const char *s) - { - - fSDK->SetStructField (ns, path, fieldNS, fieldName, s); - - } - -/*****************************************************************************/ - -void dng_xmp::DeleteStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName) - { - - fSDK->DeleteStructField (ns, path, fieldNS, fieldName); - - } - -/*****************************************************************************/ - -bool dng_xmp::GetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - dng_string &s) const - { - - return fSDK->GetStructField (ns, path, fieldNS, fieldName, s); - - } - -/*****************************************************************************/ - -void dng_xmp::SetAltLangDefault (const char *ns, - const char *path, - const dng_string &s) - { - - fSDK->SetAltLangDefault (ns, path, s); - - } - -/*****************************************************************************/ - -bool dng_xmp::GetAltLangDefault (const char *ns, - const char *path, - dng_string &s) const - { - - return fSDK->GetAltLangDefault (ns, path, s); - - } - -/*****************************************************************************/ - -bool dng_xmp::SyncAltLangDefault (const char *ns, - const char *path, - dng_string &s, - uint32 options) - { - - bool isDefault = s.IsEmpty (); - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault) - { - - Remove (ns, path); - - } - - else - { - - SetAltLangDefault (ns, path, s); - - } - - return false; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - SetAltLangDefault (ns, path, s); - - return false; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (GetAltLangDefault (ns, path, s)) - { - - return true; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (!isDefault) - { - - SetAltLangDefault (ns, path, s); - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_xmp::GetBoolean (const char *ns, - const char *path, - bool &x) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.Matches ("True")) - { - - x = true; - - return true; - - } - - if (s.Matches ("False")) - { - - x = false; - - return true; - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::SetBoolean (const char *ns, - const char *path, - bool x) - { - - Set (ns, path, x ? "True" : "False"); - - } - -/*****************************************************************************/ - -bool dng_xmp::Get_int32 (const char *ns, - const char *path, - int32 &x) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - int y = 0; - - if (sscanf (s.Get (), "%d", &y) == 1) - { - - x = y; - - return true; - - } - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::Set_int32 (const char *ns, - const char *path, - int32 x, - bool usePlus) - { - - char s [64]; - - if (x > 0 && usePlus) - { - sprintf (s, "+%d", (int) x); - } - else - { - sprintf (s, "%d", (int) x); - } - - Set (ns, path, s); - - } - -/*****************************************************************************/ - -bool dng_xmp::Get_uint32 (const char *ns, - const char *path, - uint32 &x) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - unsigned y = 0; - - if (sscanf (s.Get (), "%u", &y) == 1) - { - - x = y; - - return true; - - } - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::Set_uint32 (const char *ns, - const char *path, - uint32 x) - { - - char s [64]; - - sprintf (s, - "%u", - (unsigned) x); - - Set (ns, path, s); - - } - -/*****************************************************************************/ - -void dng_xmp::Sync_uint32 (const char *ns, - const char *path, - uint32 &x, - bool isDefault, - uint32 options) - { - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault || (options & removeXMP)) - { - - Remove (ns, path); - - } - - else - { - - Set_uint32 (ns, path, x); - - } - - return; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else - { - - Set_uint32 (ns, path, x); - - } - - return; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (Get_uint32 (ns, path, x)) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - return; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else if (!isDefault) - { - - Set_uint32 (ns, path, x); - - } - - } - -/*****************************************************************************/ - -void dng_xmp::Sync_uint32_array (const char *ns, - const char *path, - uint32 *data, - uint32 &count, - uint32 maxCount, - uint32 options) - { - - dng_string_list list; - - for (uint32 j = 0; j < count; j++) - { - - char s [32]; - - sprintf (s, "%u", (unsigned) data [j]); - - dng_string ss; - - ss.Set (s); - - list.Append (ss); - - } - - SyncStringList (ns, - path, - list, - false, - options); - - count = 0; - - for (uint32 k = 0; k < maxCount; k++) - { - - data [k] = 0; - - if (k < list.Count ()) - { - - unsigned x = 0; - - if (sscanf (list [k].Get (), "%u", &x) == 1) - { - - data [count++] = x; - - } - - } - - } - - } - -/*****************************************************************************/ - -bool dng_xmp::Get_real64 (const char *ns, - const char *path, - real64 &x) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - double y = 0; - - if (sscanf (s.Get (), "%lf", &y) == 1) - { - - x = y; - - return true; - - } - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::Set_real64 (const char *ns, - const char *path, - real64 x, - uint32 places, - bool trim, - bool usePlus) - { - - char s [64]; - - if (x > 0.0 && usePlus) - { - sprintf (s, "+%0.*f", (unsigned) places, (double) x); - } - else - { - sprintf (s, "%0.*f", (unsigned) places, (double) x); - } - - if (trim) - { - - while (s [strlen (s) - 1] == '0') - { - s [strlen (s) - 1] = 0; - } - - if (s [strlen (s) - 1] == '.') - { - s [strlen (s) - 1] = 0; - } - - } - - Set (ns, path, s); - - } - -/*****************************************************************************/ - -bool dng_xmp::Get_urational (const char *ns, - const char *path, - dng_urational &r) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - unsigned n = 0; - unsigned d = 0; - - if (sscanf (s.Get (), "%u/%u", &n, &d) == 2) - { - - if (d != 0) - { - - r = dng_urational (n, d); - - return true; - - } - - } - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::Set_urational (const char *ns, - const char *path, - const dng_urational &r) - { - - char s [64]; - - sprintf (s, - "%u/%u", - (unsigned) r.n, - (unsigned) r.d); - - Set (ns, path, s); - - } - -/*****************************************************************************/ - -void dng_xmp::Sync_urational (const char *ns, - const char *path, - dng_urational &r, - uint32 options) - { - - bool isDefault = r.NotValid (); - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault || (options & removeXMP)) - { - - Remove (ns, path); - - } - - else - { - - Set_urational (ns, path, r); - - } - - return; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else - { - - Set_urational (ns, path, r); - - } - - return; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (Get_urational (ns, path, r)) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - return; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else if (!isDefault) - { - - Set_urational (ns, path, r); - - } - - } - -/*****************************************************************************/ - -bool dng_xmp::Get_srational (const char *ns, - const char *path, - dng_srational &r) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - if (s.NotEmpty ()) - { - - int n = 0; - int d = 0; - - if (sscanf (s.Get (), "%d/%d", &n, &d) == 2) - { - - if (d != 0) - { - - r = dng_srational (n, d); - - return true; - - } - - } - - } - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp::Set_srational (const char *ns, - const char *path, - const dng_srational &r) - { - - char s [64]; - - sprintf (s, - "%d/%d", - (int) r.n, - (int) r.d); - - Set (ns, path, s); - - } - -/*****************************************************************************/ - -void dng_xmp::Sync_srational (const char *ns, - const char *path, - dng_srational &r, - uint32 options) - { - - bool isDefault = r.NotValid (); - - // Sync 1: Force XMP to match non-XMP. - - if (options & ignoreXMP) - { - - if (isDefault || (options & removeXMP)) - { - - Remove (ns, path); - - } - - else - { - - Set_srational (ns, path, r); - - } - - return; - - } - - // Sync 2: From non-XMP to XMP if non-XMP is prefered. - - if ((options & preferNonXMP) && !isDefault) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else - { - - Set_srational (ns, path, r); - - } - - return; - - } - - // Sync 3: From XMP to non-XMP if XMP is prefered or default non-XMP. - - if ((options & preferXMP) || isDefault) - { - - if (Get_srational (ns, path, r)) - { - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - return; - - } - - } - - // Sync 4: From non-XMP to XMP. - - if (options & removeXMP) - { - - Remove (ns, path); - - } - - else if (!isDefault) - { - - Set_srational (ns, path, r); - - } - - } - -/*****************************************************************************/ - -bool dng_xmp::GetFingerprint (const char *ns, - const char *path, - dng_fingerprint &print) const - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - dng_fingerprint temp = DecodeFingerprint (s); - - if (temp.IsValid ()) - { - - print = temp; - - return true; - - } - - } - - return false; - - } - -/******************************************************************************/ - -void dng_xmp::SetFingerprint (const char *ns, - const char *tag, - const dng_fingerprint &print, - bool allowInvalid) - { - - dng_string s = EncodeFingerprint (print, allowInvalid); - - if (s.IsEmpty ()) - { - - Remove (ns, tag); - - } - - else - { - - SetString (ns, tag, s); - - } - - } - -/******************************************************************************/ - -void dng_xmp::SetVersion2to4 (const char *ns, - const char *path, - uint32 version) - { - - char buf [32]; - - if (version & 0x000000ff) - { - - // x.x.x.x - - sprintf (buf, - "%u.%u.%u.%u", - (unsigned) ((version >> 24) & 0xff), - (unsigned) ((version >> 16) & 0xff), - (unsigned) ((version >> 8) & 0xff), - (unsigned) ((version ) & 0xff)); - - } - - else if (version & 0x0000ff00) - { - - // x.x.x - - sprintf (buf, - "%u.%u.%u", - (unsigned) ((version >> 24) & 0xff), - (unsigned) ((version >> 16) & 0xff), - (unsigned) ((version >> 8) & 0xff)); - - } - - else - { - - // x.x - - sprintf (buf, - "%u.%u", - (unsigned) ((version >> 24) & 0xff), - (unsigned) ((version >> 16) & 0xff)); - - } - - Set (ns, path, buf); - - } - -/******************************************************************************/ - -dng_fingerprint dng_xmp::GetIPTCDigest () const - { - - dng_fingerprint digest; - - if (GetFingerprint (XMP_NS_PHOTOSHOP, - "LegacyIPTCDigest", - digest)) - { - - return digest; - - } - - return dng_fingerprint (); - - } - -/******************************************************************************/ - -void dng_xmp::SetIPTCDigest (dng_fingerprint &digest) - { - - SetFingerprint (XMP_NS_PHOTOSHOP, - "LegacyIPTCDigest", - digest); - - } - -/******************************************************************************/ - -void dng_xmp::ClearIPTCDigest () - { - - Remove (XMP_NS_PHOTOSHOP, "LegacyIPTCDigest"); - - } - -/*****************************************************************************/ - -void dng_xmp::SyncIPTC (dng_iptc &iptc, - uint32 options) - { - - SyncAltLangDefault (XMP_NS_DC, - "title", - iptc.fTitle, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Category", - iptc.fCategory, - options); - - { - - uint32 x = 0xFFFFFFFF; - - if (iptc.fUrgency >= 0) - { - - x = (uint32) iptc.fUrgency; - - } - - Sync_uint32 (XMP_NS_PHOTOSHOP, - "Urgency", - x, - x == 0xFFFFFFFF, - options); - - if (x <= 9) - { - - iptc.fUrgency = (int32) x; - - } - - } - - SyncStringList (XMP_NS_PHOTOSHOP, - "SupplementalCategories", - iptc.fSupplementalCategories, - true, - options); - - SyncStringList (XMP_NS_PHOTOSHOP, - "Keywords", - iptc.fKeywords, - true, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Instructions", - iptc.fInstructions, - options); - - { - - dng_string s = iptc.fDateTimeCreated.Encode_ISO_8601 (); - - if (SyncString (XMP_NS_PHOTOSHOP, - "DateCreated", - s, - options)) - { - - iptc.fDateTimeCreated.Decode_ISO_8601 (s.Get ()); - - } - - } - - { - - dng_string s = iptc.fDigitalCreationDateTime.Encode_ISO_8601 (); - - if (SyncString (XMP_NS_EXIF, - "DateTimeDigitized", - s, - options)) - { - - iptc.fDigitalCreationDateTime.Decode_ISO_8601 (s.Get ()); - - } - - } - - SyncStringList (XMP_NS_DC, - "creator", - iptc.fAuthors, - false, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "AuthorsPosition", - iptc.fAuthorsPosition, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "City", - iptc.fCity, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "State", - iptc.fState, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Country", - iptc.fCountry, - options); - - SyncString (XMP_NS_IPTC, - "CountryCode", - iptc.fCountryCode, - options); - - SyncString (XMP_NS_IPTC, - "Location", - iptc.fLocation, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "TransmissionReference", - iptc.fTransmissionReference, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Headline", - iptc.fHeadline, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Credit", - iptc.fCredit, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "Source", - iptc.fSource, - options); - - SyncAltLangDefault (XMP_NS_DC, - "rights", - iptc.fCopyrightNotice, - options); - - SyncAltLangDefault (XMP_NS_DC, - "description", - iptc.fDescription, - options); - - SyncString (XMP_NS_PHOTOSHOP, - "CaptionWriter", - iptc.fDescriptionWriter, - options); - - } - -/*****************************************************************************/ - -void dng_xmp::IngestIPTC (dng_metadata &metadata, - bool xmpIsNewer) - { - - if (metadata.IPTCLength ()) - { - - // Parse the IPTC block. - - dng_iptc iptc; - - iptc.Parse (metadata.IPTCData (), - metadata.IPTCLength (), - metadata.IPTCOffset ()); - - // Compute fingerprint of IPTC data both ways, including and - // excluding the padding data. - - dng_fingerprint iptcDigest1 = metadata.IPTCDigest (true ); - dng_fingerprint iptcDigest2 = metadata.IPTCDigest (false); - - // See if there is an IPTC fingerprint stored in the XMP. - - dng_fingerprint xmpDigest = GetIPTCDigest (); - - if (xmpDigest.IsValid ()) - { - - // If they match, the XMP was already synced with this - // IPTC block, and we should not resync since it might - // overwrite changes in the XMP data. - - if (iptcDigest1 == xmpDigest) - { - - return; - - } - - // If it matches the incorrectly computed digest, skip - // the sync, but fix the digest in the XMP. - - if (iptcDigest2 == xmpDigest) - { - - SetIPTCDigest (iptcDigest1); - - return; - - } - - // Else the IPTC has changed, so force an update. - - xmpIsNewer = false; - - } - - else - { - - // There is no IPTC digest. Previously we would - // prefer the IPTC in this case, but the MWG suggests - // that we prefer the XMP in this case. - - xmpIsNewer = true; - - } - - // Remember the fingerprint of the IPTC we are syncing with. - - SetIPTCDigest (iptcDigest1); - - // Find the sync options. - - uint32 options = xmpIsNewer ? preferXMP - : preferNonXMP; - - // Synchronize the fields. - - SyncIPTC (iptc, options); - - } - - // After the IPTC data is moved to XMP, we don't need it anymore. - - metadata.ClearIPTC (); - - } - -/*****************************************************************************/ - -void dng_xmp::RebuildIPTC (dng_metadata &metadata, - dng_memory_allocator &allocator, - bool padForTIFF) - { - - // If there is no XMP, then there is no IPTC. - - if (!fSDK->HasMeta ()) - { - return; - } - - // Extract the legacy IPTC fields from the XMP data. - - dng_iptc iptc; - - SyncIPTC (iptc, preferXMP); - - // Build legacy IPTC record - - if (iptc.NotEmpty ()) - { - - AutoPtr block (iptc.Spool (allocator, - padForTIFF)); - - metadata.SetIPTC (block); - - } - - } - -/*****************************************************************************/ - -void dng_xmp::SyncFlash (uint32 &flashState, - uint32 &flashMask, - uint32 options) - { - - bool isDefault = (flashState == 0xFFFFFFFF); - - if ((options & ignoreXMP) || !isDefault) - { - - Remove (XMP_NS_EXIF, "Flash"); - - } - - if (!isDefault) - { - - fSDK->SetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Fired", - (flashState & 0x1) ? "True" : "False"); - - if (((flashMask >> 1) & 3) == 3) - { - - char s [8]; - - sprintf (s, "%u", (unsigned) ((flashState >> 1) & 3)); - - fSDK->SetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Return", - s); - - } - - if (((flashMask >> 3) & 3) == 3) - { - - char s [8]; - - sprintf (s, "%u", (unsigned) ((flashState >> 3) & 3)); - - fSDK->SetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Mode", - s); - - } - - if ((flashMask & (1 << 5)) != 0) - { - - fSDK->SetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Function", - (flashState & (1 << 5)) ? "True" : "False"); - - } - - if ((flashMask & (1 << 6)) != 0) - { - - fSDK->SetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "RedEyeMode", - (flashState & (1 << 6)) ? "True" : "False"); - - } - - } - - else if (fSDK->Exists (XMP_NS_EXIF, "Flash")) - { - - dng_string s; - - if (fSDK->GetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Fired", - s)) - { - - flashState = 0; - flashMask = 1; - - if (s.Matches ("True")) - { - flashState |= 1; - } - - if (fSDK->GetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Return", - s)) - { - - unsigned x = 0; - - if (sscanf (s.Get (), "%u", &x) == 1 && x <= 3) - { - - flashState |= x << 1; - flashMask |= 3 << 1; - - } - - } - - if (fSDK->GetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Mode", - s)) - { - - unsigned x = 0; - - if (sscanf (s.Get (), "%u", &x) == 1 && x <= 3) - { - - flashState |= x << 3; - flashMask |= 3 << 3; - - } - - } - - if (fSDK->GetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "Function", - s)) - { - - flashMask |= 1 << 5; - - if (s.Matches ("True")) - { - flashState |= 1 << 5; - } - - } - - if (fSDK->GetStructField (XMP_NS_EXIF, - "Flash", - XMP_NS_EXIF, - "RedEyeMode", - s)) - { - - flashMask |= 1 << 6; - - if (s.Matches ("True")) - { - flashState |= 1 << 6; - } - - } - - } - - } - - } - -/*****************************************************************************/ - -void dng_xmp::SyncExif (dng_exif &exif, - const dng_exif *originalExif, - bool doingUpdateFromXMP, - bool removeFromXMP) - { - - DNG_ASSERT (!doingUpdateFromXMP || originalExif, - "Must have original EXIF if doingUpdateFromXMP"); - - // Default synchronization options for the read-only fields. - - uint32 readOnly = doingUpdateFromXMP ? ignoreXMP - : preferNonXMP; - - // Option for removable fields. - - uint32 removable = removeFromXMP ? removeXMP - : 0; - - // Make: - - SyncString (XMP_NS_TIFF, - "Make", - exif.fMake, - readOnly + removable); - - // Model: - - SyncString (XMP_NS_TIFF, - "Model", - exif.fModel, - readOnly + removable); - - // Exif version number: - - { - - dng_string exifVersion; - - if (exif.fExifVersion) - { - - unsigned b0 = ((exif.fExifVersion >> 24) & 0x0FF) - '0'; - unsigned b1 = ((exif.fExifVersion >> 16) & 0x0FF) - '0'; - unsigned b2 = ((exif.fExifVersion >> 8) & 0x0FF) - '0'; - unsigned b3 = ((exif.fExifVersion ) & 0x0FF) - '0'; - - if (b0 <= 9 && b1 <= 9 && b2 <= 9 && b3 <= 9) - { - - char s [5]; - - sprintf (s, - "%1u%1u%1u%1u", - b0, - b1, - b2, - b3); - - exifVersion.Set (s); - - } - - } - - SyncString (XMP_NS_EXIF, - "ExifVersion", - exifVersion, - readOnly); - - if (exifVersion.NotEmpty ()) - { - - unsigned b0; - unsigned b1; - unsigned b2; - unsigned b3; - - if (sscanf (exifVersion.Get (), - "%1u%1u%1u%1u", - &b0, - &b1, - &b2, - &b3) == 4) - { - - if (b0 <= 9 && b1 <= 9 && b2 <= 9 && b3 <= 9) - { - - b0 += '0'; - b1 += '0'; - b2 += '0'; - b3 += '0'; - - exif.fExifVersion = (b0 << 24) | - (b1 << 16) | - (b2 << 8) | - (b3 ); - - } - - } - - } - - // Provide default value for ExifVersion. - - if (!exif.fExifVersion) - { - - exif.fExifVersion = DNG_CHAR4 ('0','2','2','1'); - - Set (XMP_NS_EXIF, - "ExifVersion", - "0221"); - - } - - if (removeFromXMP) - { - - Remove (XMP_NS_EXIF, "ExifVersion"); - - } - - } - - // ExposureTime / ShutterSpeedValue: - - { - - // Process twice in case XMP contains only one of the - // two fields. - - for (uint32 pass = 0; pass < 2; pass++) - { - - dng_urational et = exif.fExposureTime; - - Sync_urational (XMP_NS_EXIF, - "ExposureTime", - et, - readOnly); - - if (et.IsValid ()) - { - - exif.SetExposureTime (et.As_real64 (), false); - - } - - dng_srational ss = exif.fShutterSpeedValue; - - Sync_srational (XMP_NS_EXIF, - "ShutterSpeedValue", - ss, - readOnly); - - if (ss.IsValid ()) - { - - exif.SetShutterSpeedValue (ss.As_real64 ()); - - } - - } - - if (removeFromXMP) - { - - Remove (XMP_NS_EXIF, "ExposureTime"); - - Remove (XMP_NS_EXIF, "ShutterSpeedValue"); - - } - - } - - // FNumber / ApertureValue: - - { - - for (uint32 pass = 0; pass < 2; pass++) - { - - dng_urational fs = exif.fFNumber; - - Sync_urational (XMP_NS_EXIF, - "FNumber", - fs, - readOnly); - - if (fs.IsValid ()) - { - - exif.SetFNumber (fs.As_real64 ()); - - } - - dng_urational av = exif.fApertureValue; - - Sync_urational (XMP_NS_EXIF, - "ApertureValue", - av, - readOnly); - - if (av.IsValid ()) - { - - exif.SetApertureValue (av.As_real64 ()); - - } - - } - - if (removeFromXMP) - { - - Remove (XMP_NS_EXIF, "FNumber"); - - Remove (XMP_NS_EXIF, "ApertureValue"); - - } - - } - - // Exposure program: - - Sync_uint32 (XMP_NS_EXIF, - "ExposureProgram", - exif.fExposureProgram, - exif.fExposureProgram == 0xFFFFFFFF, - readOnly + removable); - - // ISO Speed Ratings: - - { - - uint32 isoSpeedRatingsCount = 0; - - uint32 isoSpeedRatingsOptions = readOnly; - - uint32 oldISOSpeedRatings [3]; - - memcpy (oldISOSpeedRatings, - exif.fISOSpeedRatings, - sizeof (oldISOSpeedRatings)); - - bool checkXMPForHigherISO = false; - - for (uint32 j = 0; j < 3; j++) - { - - // Special case: the EXIF 2.2x standard represents ISO speed ratings with - // 2 bytes, which cannot hold ISO speed ratings above 65535 (e.g., - // 102400). If the EXIF ISO speed rating value is 65535, prefer the XMP - // ISOSpeedRatings tag value. - - if (exif.fISOSpeedRatings [j] == 65535) - { - - isoSpeedRatingsOptions = preferXMP; - - checkXMPForHigherISO = true; - - isoSpeedRatingsCount = 0; - - break; - - } - - else if (exif.fISOSpeedRatings [j] == 0) - { - break; - } - - isoSpeedRatingsCount++; - - } - - Sync_uint32_array (XMP_NS_EXIF, - "ISOSpeedRatings", - exif.fISOSpeedRatings, - isoSpeedRatingsCount, - 3, - isoSpeedRatingsOptions); - - // If the EXIF ISO was 65535 and we failed to find anything meaningful in the - // XMP, then we fall back to the EXIF ISO. - - if (checkXMPForHigherISO && (isoSpeedRatingsCount == 0)) - { - - memcpy (exif.fISOSpeedRatings, - oldISOSpeedRatings, - sizeof (oldISOSpeedRatings)); - - } - - // Only remove the ISO tag if there are not ratings over 65535. - - if (removeFromXMP) - { - - bool hasHighISO = false; - - for (uint32 j = 0; j < 3; j++) - { - - if (exif.fISOSpeedRatings [j] == 0) - { - break; - } - - hasHighISO = hasHighISO || (exif.fISOSpeedRatings [j] > 65535); - - } - - if (!hasHighISO) - { - - Remove (XMP_NS_EXIF, "ISOSpeedRatings"); - - } - - } - - } - - // SensitivityType: - - Sync_uint32 (XMP_NS_EXIF, - "SensitivityType", - exif.fSensitivityType, - exif.fSensitivityType == stUnknown, - readOnly + removable); - - // StandardOutputSensitivity: - - Sync_uint32 (XMP_NS_EXIF, - "StandardOutputSensitivity", - exif.fStandardOutputSensitivity, - exif.fStandardOutputSensitivity == 0, - readOnly + removable); - - // RecommendedExposureIndex: - - Sync_uint32 (XMP_NS_EXIF, - "RecommendedExposureIndex", - exif.fRecommendedExposureIndex, - exif.fRecommendedExposureIndex == 0, - readOnly + removable); - - // ISOSpeed: - - Sync_uint32 (XMP_NS_EXIF, - "ISOSpeed", - exif.fISOSpeed, - exif.fISOSpeed == 0, - readOnly + removable); - - // ISOSpeedLatitudeyyy: - - Sync_uint32 (XMP_NS_EXIF, - "ISOSpeedLatitudeyyy", - exif.fISOSpeedLatitudeyyy, - exif.fISOSpeedLatitudeyyy == 0, - readOnly + removable); - - // ISOSpeedLatitudezzz: - - Sync_uint32 (XMP_NS_EXIF, - "ISOSpeedLatitudezzz", - exif.fISOSpeedLatitudezzz, - exif.fISOSpeedLatitudezzz == 0, - readOnly + removable); - - // ExposureIndex: - - Sync_urational (XMP_NS_EXIF, - "ExposureIndex", - exif.fExposureIndex, - readOnly + removable); - - // Brightness Value: - - Sync_srational (XMP_NS_EXIF, - "BrightnessValue", - exif.fBrightnessValue, - readOnly + removable); - - // Exposure Bias: - - Sync_srational (XMP_NS_EXIF, - "ExposureBiasValue", - exif.fExposureBiasValue, - readOnly + removable); - - // Max Aperture: - - Sync_urational (XMP_NS_EXIF, - "MaxApertureValue", - exif.fMaxApertureValue, - readOnly + removable); - - // Subject Distance: - - Sync_urational (XMP_NS_EXIF, - "SubjectDistance", - exif.fSubjectDistance, - readOnly + removable); - - // Metering Mode: - - Sync_uint32 (XMP_NS_EXIF, - "MeteringMode", - exif.fMeteringMode, - exif.fMeteringMode == 0xFFFFFFFF, - readOnly + removable); - - // Light Source: - - Sync_uint32 (XMP_NS_EXIF, - "LightSource", - exif.fLightSource, - exif.fLightSource > 0x0FFFF, - readOnly + removable); - - // Flash State: - - SyncFlash (exif.fFlash, - exif.fFlashMask, - readOnly); - - if (removeFromXMP) - { - Remove (XMP_NS_EXIF, "Flash"); - } - - // Focal Length: - - Sync_urational (XMP_NS_EXIF, - "FocalLength", - exif.fFocalLength, - readOnly + removable); - - // Sensing Method. - - Sync_uint32 (XMP_NS_EXIF, - "SensingMethod", - exif.fSensingMethod, - exif.fSensingMethod > 0x0FFFF, - readOnly + removable); - - // File Source. - - Sync_uint32 (XMP_NS_EXIF, - "FileSource", - exif.fFileSource, - exif.fFileSource > 0x0FF, - readOnly + removable); - - // Scene Type. - - Sync_uint32 (XMP_NS_EXIF, - "SceneType", - exif.fSceneType, - exif.fSceneType > 0x0FF, - readOnly + removable); - - // Focal Length in 35mm Film: - - Sync_uint32 (XMP_NS_EXIF, - "FocalLengthIn35mmFilm", - exif.fFocalLengthIn35mmFilm, - exif.fFocalLengthIn35mmFilm == 0, - readOnly + removable); - - // Custom Rendered: - - Sync_uint32 (XMP_NS_EXIF, - "CustomRendered", - exif.fCustomRendered, - exif.fCustomRendered > 0x0FFFF, - readOnly + removable); - - // Exposure Mode: - - Sync_uint32 (XMP_NS_EXIF, - "ExposureMode", - exif.fExposureMode, - exif.fExposureMode > 0x0FFFF, - readOnly + removable); - - // White Balance: - - Sync_uint32 (XMP_NS_EXIF, - "WhiteBalance", - exif.fWhiteBalance, - exif.fWhiteBalance > 0x0FFFF, - readOnly + removable); - - // Scene Capture Type: - - Sync_uint32 (XMP_NS_EXIF, - "SceneCaptureType", - exif.fSceneCaptureType, - exif.fSceneCaptureType > 0x0FFFF, - readOnly + removable); - - // Gain Control: - - Sync_uint32 (XMP_NS_EXIF, - "GainControl", - exif.fGainControl, - exif.fGainControl > 0x0FFFF, - readOnly + removable); - - // Contrast: - - Sync_uint32 (XMP_NS_EXIF, - "Contrast", - exif.fContrast, - exif.fContrast > 0x0FFFF, - readOnly + removable); - - // Saturation: - - Sync_uint32 (XMP_NS_EXIF, - "Saturation", - exif.fSaturation, - exif.fSaturation > 0x0FFFF, - readOnly + removable); - - // Sharpness: - - Sync_uint32 (XMP_NS_EXIF, - "Sharpness", - exif.fSharpness, - exif.fSharpness > 0x0FFFF, - readOnly + removable); - - // Subject Distance Range: - - Sync_uint32 (XMP_NS_EXIF, - "SubjectDistanceRange", - exif.fSubjectDistanceRange, - exif.fSubjectDistanceRange > 0x0FFFF, - readOnly + removable); - - // Subject Area: - - Sync_uint32_array (XMP_NS_EXIF, - "SubjectArea", - exif.fSubjectArea, - exif.fSubjectAreaCount, - sizeof (exif.fSubjectArea ) / - sizeof (exif.fSubjectArea [0]), - readOnly); - - if (removeFromXMP) - { - Remove (XMP_NS_EXIF, "SubjectArea"); - } - - // Digital Zoom Ratio: - - Sync_urational (XMP_NS_EXIF, - "DigitalZoomRatio", - exif.fDigitalZoomRatio, - readOnly + removable); - - // Focal Plane Resolution: - - Sync_urational (XMP_NS_EXIF, - "FocalPlaneXResolution", - exif.fFocalPlaneXResolution, - readOnly + removable); - - Sync_urational (XMP_NS_EXIF, - "FocalPlaneYResolution", - exif.fFocalPlaneYResolution, - readOnly + removable); - - Sync_uint32 (XMP_NS_EXIF, - "FocalPlaneResolutionUnit", - exif.fFocalPlaneResolutionUnit, - exif.fFocalPlaneResolutionUnit > 0x0FFFF, - readOnly + removable); - - // ImageDescription: (XMP is is always preferred) - - if (fSDK->GetAltLangDefault (XMP_NS_DC, - "description", - exif.fImageDescription)) - - { - - } - - else if (doingUpdateFromXMP) - { - - exif.fImageDescription.Clear (); - - if (originalExif->fImageDescription.NotEmpty ()) - { - - fSDK->SetAltLangDefault (XMP_NS_DC, - "description", - dng_string ()); - - } - - } - - else if (exif.fImageDescription.NotEmpty ()) - { - - fSDK->SetAltLangDefault (XMP_NS_DC, - "description", - exif.fImageDescription); - - } - - // Artist: (XMP is is always preferred) - - { - - dng_string_list xmpList; - - if (fSDK->GetStringList (XMP_NS_DC, - "creator", - xmpList)) - { - - exif.fArtist.Clear (); - - if (xmpList.Count () > 0) - { - - uint32 j; - - uint32 bufferSize = xmpList.Count () * 4 + 1; - - for (j = 0; j < xmpList.Count (); j++) - { - - bufferSize += xmpList [j].Length () * 2; - - } - - dng_memory_data temp (bufferSize); - - char *t = temp.Buffer_char (); - - for (j = 0; j < xmpList.Count (); j++) - { - - const char *s = xmpList [j].Get (); - - bool needQuotes = xmpList [j].Contains ("; ") || - s [0] == '\"'; - - if (needQuotes) - { - *(t++) = '\"'; - } - - while (s [0] != 0) - { - - if (s [0] == '\"' && needQuotes) - { - *(t++) = '\"'; - } - - *(t++) = *(s++); - - } - - if (needQuotes) - { - *(t++) = '\"'; - } - - if (j != xmpList.Count () - 1) - { - *(t++) = ';'; - *(t++) = ' '; - } - else - { - *t = 0; - } - - } - - exif.fArtist.Set (temp.Buffer_char ()); - - } - - } - - else if (doingUpdateFromXMP) - { - - exif.fArtist.Clear (); - - if (originalExif->fArtist.NotEmpty ()) - { - - dng_string_list fakeList; - - fakeList.Append (dng_string ()); - - SetStringList (XMP_NS_DC, - "creator", - fakeList, - false); - - } - - } - - else if (exif.fArtist.NotEmpty ()) - { - - dng_string_list newList; - - dng_memory_data temp (exif.fArtist.Length () + 1); - - const char *s = exif.fArtist.Get (); - - char *t = temp.Buffer_char (); - - bool first = true; - - bool quoted = false; - - bool valid = true; - - while (s [0] != 0 && valid) - { - - if (first) - { - - if (s [0] == '\"') - { - - quoted = true; - - s++; - - } - - } - - first = false; - - if (quoted) - { - - if (s [0] == '\"' && - s [1] == '\"') - { - - s+= 2; - - *(t++) = '\"'; - - } - - else if (s [0] == '\"') - { - - s++; - - quoted = false; - - valid = valid && ((s [0] == 0) || ((s [0] == ';' && s [1] == ' '))); - - } - - else - { - - *(t++) = *(s++); - - } - - } - - else if (s [0] == ';' && - s [1] == ' ') - { - - s += 2; - - t [0] = 0; - - dng_string ss; - - ss.Set (temp.Buffer_char ()); - - newList.Append (ss); - - t = temp.Buffer_char (); - - first = true; - - } - - else - { - - *(t++) = *(s++); - - } - - } - - if (quoted) - { - - valid = false; - - } - - if (valid) - { - - if (t != temp.Buffer_char ()) - { - - t [0] = 0; - - dng_string ss; - - ss.Set (temp.Buffer_char ()); - - newList.Append (ss); - - } - - } - - else - { - - newList.Clear (); - - newList.Append (exif.fArtist); - - } - - SetStringList (XMP_NS_DC, - "creator", - newList, - false); - - } - - } - - // Software: (XMP is is always preferred) - - if (fSDK->GetString (XMP_NS_XAP, - "CreatorTool", - exif.fSoftware)) - - { - - } - - else if (doingUpdateFromXMP) - { - - exif.fSoftware.Clear (); - - if (originalExif->fSoftware.NotEmpty ()) - { - - fSDK->SetString (XMP_NS_XAP, - "CreatorTool", - dng_string ()); - - } - - } - - else if (exif.fSoftware.NotEmpty ()) - { - - fSDK->SetString (XMP_NS_XAP, - "CreatorTool", - exif.fSoftware); - - } - - // Copyright: (XMP is is always preferred) - - if (fSDK->GetAltLangDefault (XMP_NS_DC, - "rights", - exif.fCopyright)) - - { - - } - - else if (doingUpdateFromXMP) - { - - exif.fCopyright.Clear (); - - if (originalExif->fCopyright.NotEmpty ()) - { - - fSDK->SetAltLangDefault (XMP_NS_DC, - "rights", - dng_string ()); - - } - - } - - else if (exif.fCopyright.NotEmpty ()) - { - - fSDK->SetAltLangDefault (XMP_NS_DC, - "rights", - exif.fCopyright); - - } - - // Camera serial number private tag: - - SyncString (XMP_NS_AUX, - "SerialNumber", - exif.fCameraSerialNumber, - readOnly); - - // Lens Info: - - { - - dng_string s; - - if (exif.fLensInfo [0].IsValid ()) - { - - char ss [256]; - - sprintf (ss, - "%u/%u %u/%u %u/%u %u/%u", - (unsigned) exif.fLensInfo [0].n, - (unsigned) exif.fLensInfo [0].d, - (unsigned) exif.fLensInfo [1].n, - (unsigned) exif.fLensInfo [1].d, - (unsigned) exif.fLensInfo [2].n, - (unsigned) exif.fLensInfo [2].d, - (unsigned) exif.fLensInfo [3].n, - (unsigned) exif.fLensInfo [3].d); - - s.Set (ss); - - } - - SyncString (XMP_NS_AUX, - "LensInfo", - s, - readOnly); - - if (s.NotEmpty ()) - { - - unsigned n [4]; - unsigned d [4]; - - if (sscanf (s.Get (), - "%u/%u %u/%u %u/%u %u/%u", - &n [0], - &d [0], - &n [1], - &d [1], - &n [2], - &d [2], - &n [3], - &d [3]) == 8) - { - - for (uint32 j = 0; j < 4; j++) - { - - exif.fLensInfo [j] = dng_urational (n [j], d [j]); - - } - - } - - - } - - } - - // Lens name: - - { - - // EXIF lens names are sometimes missing or wrong (esp. when non-OEM lenses - // are used). So prefer the value from XMP. - - SyncString (XMP_NS_AUX, - "Lens", - exif.fLensName, - preferXMP); - - // Generate default lens name from lens info if required. - // Ignore names names that end in "f/0.0" due to third party bug. - - if ((exif.fLensName.IsEmpty () || - exif.fLensName.EndsWith ("f/0.0")) && exif.fLensInfo [0].IsValid ()) - { - - char s [256]; - - real64 minFL = exif.fLensInfo [0].As_real64 (); - real64 maxFL = exif.fLensInfo [1].As_real64 (); - - // The f-stop numbers are optional. - - if (exif.fLensInfo [2].IsValid ()) - { - - real64 minFS = exif.fLensInfo [2].As_real64 (); - real64 maxFS = exif.fLensInfo [3].As_real64 (); - - if (minFL == maxFL) - sprintf (s, "%.1f mm f/%.1f", minFL, minFS); - - else if (minFS == maxFS) - sprintf (s, "%.1f-%.1f mm f/%.1f", minFL, maxFL, minFS); - - else - sprintf (s, "%.1f-%.1f mm f/%.1f-%.1f", minFL, maxFL, minFS, maxFS); - - } - - else - { - - if (minFL == maxFL) - sprintf (s, "%.1f mm", minFL); - - else - sprintf (s, "%.1f-%.1f mm", minFL, maxFL); - - } - - exif.fLensName.Set (s); - - SetString (XMP_NS_AUX, - "Lens", - exif.fLensName); - - } - - } - - // Lens ID: - - SyncString (XMP_NS_AUX, - "LensID", - exif.fLensID, - readOnly); - - // Lens Make: - - SyncString (XMP_NS_EXIF, - "LensMake", - exif.fLensMake, - readOnly + removable); - - // Lens Serial Number: - - SyncString (XMP_NS_AUX, - "LensSerialNumber", - exif.fLensSerialNumber, - readOnly); - - // Image Number: - - Sync_uint32 (XMP_NS_AUX, - "ImageNumber", - exif.fImageNumber, - exif.fImageNumber == 0xFFFFFFFF, - readOnly); - - // User Comment: - - if (exif.fUserComment.NotEmpty ()) - { - - fSDK->SetAltLangDefault (XMP_NS_EXIF, - "UserComment", - exif.fUserComment); - - } - - else - { - - (void) fSDK->GetAltLangDefault (XMP_NS_EXIF, - "UserComment", - exif.fUserComment); - - } - - if (removeFromXMP) - { - Remove (XMP_NS_EXIF, "UserComment"); - } - - // Approximate focus distance: - - SyncApproximateFocusDistance (exif, - readOnly); - - // Flash Compensation: - - Sync_srational (XMP_NS_AUX, - "FlashCompensation", - exif.fFlashCompensation, - readOnly); - - // Owner Name: (allow XMP updates) - - SyncString (XMP_NS_AUX, - "OwnerName", - exif.fOwnerName, - preferXMP); - - // Firmware: - - SyncString (XMP_NS_AUX, - "Firmware", - exif.fFirmware, - readOnly); - - // Image Unique ID: - - { - - dng_string s = EncodeFingerprint (exif.fImageUniqueID); - - SyncString (XMP_NS_EXIF, - "ImageUniqueID", - s, - readOnly + removable); - - exif.fImageUniqueID = DecodeFingerprint (s); - - } - - // Allow EXIF GPS to be updated via updates from XMP. - - if (doingUpdateFromXMP) - { - - // Require that at least one basic GPS field exist in the - // XMP before overrriding the EXIF GPS fields. - - if (Exists (XMP_NS_EXIF, "GPSVersionID" ) || - Exists (XMP_NS_EXIF, "GPSLatitude" ) || - Exists (XMP_NS_EXIF, "GPSLongitude" ) || - Exists (XMP_NS_EXIF, "GPSAltitude" ) || - Exists (XMP_NS_EXIF, "GPSTimeStamp" ) || - Exists (XMP_NS_EXIF, "GPSProcessingMethod")) - { - - // Clear out the GPS info from the EXIF so it will - // replaced by the GPS info from the XMP. - - dng_exif blankExif; - - exif.CopyGPSFrom (blankExif); - - } - - } - - // GPS Version ID: - - { - - dng_string s = EncodeGPSVersion (exif.fGPSVersionID); - - if (SyncString (XMP_NS_EXIF, - "GPSVersionID", - s, - preferNonXMP + removable)) - { - - exif.fGPSVersionID = DecodeGPSVersion (s); - - } - - } - - // GPS Latitude: - - { - - dng_string s = EncodeGPSCoordinate (exif.fGPSLatitudeRef, - exif.fGPSLatitude); - - if (SyncString (XMP_NS_EXIF, - "GPSLatitude", - s, - preferNonXMP + removable)) - { - - DecodeGPSCoordinate (s, - exif.fGPSLatitudeRef, - exif.fGPSLatitude); - - } - - } - - // GPS Longitude: - - { - - dng_string s = EncodeGPSCoordinate (exif.fGPSLongitudeRef, - exif.fGPSLongitude); - - if (SyncString (XMP_NS_EXIF, - "GPSLongitude", - s, - preferNonXMP + removable)) - { - - DecodeGPSCoordinate (s, - exif.fGPSLongitudeRef, - exif.fGPSLongitude); - - } - - } - - // Handle simple case of incorrectly written GPS altitude where someone didn't understand the GPSAltitudeRef and assumed the GPSAltitude RATIONAL is signed. - // Only handle this case as we do not want to misinterpret e.g. a fixed point representation of very high GPS altitudes. - - uint32 &altitudeRef = exif.fGPSAltitudeRef; - dng_urational &altitude = exif.fGPSAltitude; - - if (altitude.IsValid () && - (altitudeRef == 0 || altitudeRef == 0xFFFFFFFF)) // If the file contains a "below sea level" altitudeRef, assume the writing software is working according to the spec. - { - - if ((altitude.n & (1U << 31)) && - altitude.d < 7) // As the denominator increases, large numerator values become possibly valid distances. Pick a limit on the conservative side (approx 33e6m) to prevent misinterpretation. - // Noting that the normal case for this mistake has a denominator of 1 - { - - altitude.n = ~altitude.n + 1; - altitudeRef = 1; - - } - - } - - // GPS Altitude Reference: - - Sync_uint32 (XMP_NS_EXIF, - "GPSAltitudeRef", - altitudeRef, - altitudeRef == 0xFFFFFFFF, - preferNonXMP + removable); - - // GPS Altitude: - - Sync_urational (XMP_NS_EXIF, - "GPSAltitude", - altitude, - preferNonXMP + removable); - - // GPS Date/Time: - - { - - dng_string s = EncodeGPSDateTime (exif.fGPSDateStamp, - exif.fGPSTimeStamp); - - if (SyncString (XMP_NS_EXIF, - "GPSTimeStamp", - s, - preferNonXMP + removable)) - { - - DecodeGPSDateTime (s, - exif.fGPSDateStamp, - exif.fGPSTimeStamp); - - } - - } - - // GPS Satellites: - - SyncString (XMP_NS_EXIF, - "GPSSatellites", - exif.fGPSSatellites, - preferNonXMP + removable); - - // GPS Status: - - SyncString (XMP_NS_EXIF, - "GPSStatus", - exif.fGPSStatus, - preferNonXMP + removable); - - // GPS Measure Mode: - - SyncString (XMP_NS_EXIF, - "GPSMeasureMode", - exif.fGPSMeasureMode, - preferNonXMP + removable); - - // GPS DOP: - - Sync_urational (XMP_NS_EXIF, - "GPSDOP", - exif.fGPSDOP, - preferNonXMP + removable); - - // GPS Speed Reference: - - SyncString (XMP_NS_EXIF, - "GPSSpeedRef", - exif.fGPSSpeedRef, - preferNonXMP + removable); - - // GPS Speed: - - Sync_urational (XMP_NS_EXIF, - "GPSSpeed", - exif.fGPSSpeed, - preferNonXMP + removable); - - // GPS Track Reference: - - SyncString (XMP_NS_EXIF, - "GPSTrackRef", - exif.fGPSTrackRef, - preferNonXMP + removable); - - // GPS Track: - - Sync_urational (XMP_NS_EXIF, - "GPSTrack", - exif.fGPSTrack, - preferNonXMP + removable); - - // GPS Image Direction Reference: - - SyncString (XMP_NS_EXIF, - "GPSImgDirectionRef", - exif.fGPSImgDirectionRef, - preferNonXMP + removable); - - // GPS Image Direction: - - Sync_urational (XMP_NS_EXIF, - "GPSImgDirection", - exif.fGPSImgDirection, - preferNonXMP + removable); - - // GPS Map Datum: - - SyncString (XMP_NS_EXIF, - "GPSMapDatum", - exif.fGPSMapDatum, - preferNonXMP + removable); - - // GPS Destination Latitude: - - { - - dng_string s = EncodeGPSCoordinate (exif.fGPSDestLatitudeRef, - exif.fGPSDestLatitude); - - if (SyncString (XMP_NS_EXIF, - "GPSDestLatitude", - s, - preferNonXMP + removable)) - { - - DecodeGPSCoordinate (s, - exif.fGPSDestLatitudeRef, - exif.fGPSDestLatitude); - - } - - } - - // GPS Destination Longitude: - - { - - dng_string s = EncodeGPSCoordinate (exif.fGPSDestLongitudeRef, - exif.fGPSDestLongitude); - - if (SyncString (XMP_NS_EXIF, - "GPSDestLongitude", - s, - preferNonXMP + removable)) - { - - DecodeGPSCoordinate (s, - exif.fGPSDestLongitudeRef, - exif.fGPSDestLongitude); - - } - - } - - // GPS Destination Bearing Reference: - - SyncString (XMP_NS_EXIF, - "GPSDestBearingRef", - exif.fGPSDestBearingRef, - preferNonXMP + removable); - - // GPS Destination Bearing: - - Sync_urational (XMP_NS_EXIF, - "GPSDestBearing", - exif.fGPSDestBearing, - preferNonXMP + removable); - - // GPS Destination Distance Reference: - - SyncString (XMP_NS_EXIF, - "GPSDestDistanceRef", - exif.fGPSDestDistanceRef, - preferNonXMP + removable); - - // GPS Destination Distance: - - Sync_urational (XMP_NS_EXIF, - "GPSDestDistance", - exif.fGPSDestDistance, - preferNonXMP + removable); - - // GPS Processing Method: - - SyncString (XMP_NS_EXIF, - "GPSProcessingMethod", - exif.fGPSProcessingMethod, - preferNonXMP + removable); - - // GPS Area Information: - - SyncString (XMP_NS_EXIF, - "GPSAreaInformation", - exif.fGPSAreaInformation, - preferNonXMP + removable); - - // GPS Differential: - - Sync_uint32 (XMP_NS_EXIF, - "GPSDifferential", - exif.fGPSDifferential, - exif.fGPSDifferential == 0xFFFFFFFF, - preferNonXMP + removable); - - // GPS Horizontal Positioning Error: - - Sync_urational (XMP_NS_EXIF, - "GPSHPositioningError", - exif.fGPSHPositioningError, - preferNonXMP + removable); - - // Sync date/times. - - UpdateExifDates (exif, removeFromXMP); - - // We are syncing EXIF and XMP, but we are not updating the - // NativeDigest tags. It is better to just delete them than leave - // the stale values around. - - Remove (XMP_NS_EXIF, "NativeDigest"); - Remove (XMP_NS_TIFF, "NativeDigest"); - - } - -/*****************************************************************************/ - -void dng_xmp::SyncApproximateFocusDistance (dng_exif &exif, - const uint32 readOnly) - { - - Sync_urational (XMP_NS_AUX, - "ApproximateFocusDistance", - exif.fApproxFocusDistance, - readOnly); - - } - -/******************************************************************************/ - -void dng_xmp::ValidateStringList (const char *ns, - const char *path) - { - - fSDK->ValidateStringList (ns, path); - - } - -/******************************************************************************/ - -void dng_xmp::ValidateMetadata () - { - - // The following values should be arrays, but are not always. So - // fix them up because Photoshop sometimes has problems parsing invalid - // tags. - - ValidateStringList (XMP_NS_DC, "creator"); - - ValidateStringList (XMP_NS_PHOTOSHOP, "Keywords"); - ValidateStringList (XMP_NS_PHOTOSHOP, "SupplementalCategories"); - - } - -/******************************************************************************/ - -bool dng_xmp::DateTimeIsDateOnly (const char *ns, - const char *path) - { - - dng_string s; - - if (GetString (ns, path, s)) - { - - uint32 len = s.Length (); - - if (len) - { - - for (uint32 j = 0; j < len; j++) - { - - if (s.Get () [j] == 'T') - { - - return false; - - } - - } - - return true; - - } - - } - - return false; - - } - -/******************************************************************************/ - -void dng_xmp::UpdateExifDates (dng_exif &exif, - bool removeFromXMP) - { - - // For the following three date/time fields, we always prefer XMP to - // the EXIF values. This is to allow the user to correct the date/times - // via changes in a sidecar XMP file, without modifying the original - // raw file. - - // Kludge: The Nikon D4 is writing date only date/times into XMP, so - // prefer the EXIF values if the XMP only contains a date. - - // Modification Date/Time: - // exif.fDateTime - // kXMP_NS_XMP:"ModifyDate" & kXMP_NS_TIFF:"DateTime" are aliased - - { - - dng_string s = exif.fDateTime.Encode_ISO_8601 (); - - bool dateOnly = DateTimeIsDateOnly (XMP_NS_TIFF, "DateTime"); - - SyncString (XMP_NS_TIFF, - "DateTime", - s, - dateOnly ? preferNonXMP : preferXMP); - - if (s.NotEmpty ()) - { - - exif.fDateTime.Decode_ISO_8601 (s.Get ()); - - // Round trip again in case we need to add a fake time zone. - - s = exif.fDateTime.Encode_ISO_8601 (); - - SetString (XMP_NS_TIFF, - "DateTime", - s); - - } - - } - - // Original Date/Time: - // exif.fDateTimeOriginal - // IPTC: DateCreated - // XMP_NS_EXIF:"DateTimeOriginal" & XMP_NS_PHOTOSHOP:"DateCreated" - // Adobe has decided to keep the two XMP fields separate. - - { - - dng_string s = exif.fDateTimeOriginal.Encode_ISO_8601 (); - - bool dateOnly = DateTimeIsDateOnly (XMP_NS_EXIF, "DateTimeOriginal"); - - SyncString (XMP_NS_EXIF, - "DateTimeOriginal", - s, - dateOnly ? preferNonXMP : preferXMP); - - if (s.NotEmpty ()) - { - - exif.fDateTimeOriginal.Decode_ISO_8601 (s.Get ()); - - // Round trip again in case we need to add a fake time zone. - - s = exif.fDateTimeOriginal.Encode_ISO_8601 (); - - SetString (XMP_NS_EXIF, - "DateTimeOriginal", - s); - - } - - // Sync the IPTC value to the EXIF value if only the EXIF - // value exists. - - if (s.NotEmpty () && !Exists (XMP_NS_PHOTOSHOP, "DateCreated")) - { - - SetString (XMP_NS_PHOTOSHOP, "DateCreated", s); - - } - - if (removeFromXMP) - { - - Remove (XMP_NS_EXIF, "DateTimeOriginal"); - - } - - } - - // Date Time Digitized: - // XMP_NS_EXIF:"DateTimeDigitized" & kXMP_NS_XMP:"CreateDate" are aliased - - { - - dng_string s = exif.fDateTimeDigitized.Encode_ISO_8601 (); - - bool dateOnly = DateTimeIsDateOnly (XMP_NS_EXIF, "DateTimeDigitized"); - - SyncString (XMP_NS_EXIF, - "DateTimeDigitized", - s, - dateOnly ? preferNonXMP : preferXMP); - - if (s.NotEmpty ()) - { - - exif.fDateTimeDigitized.Decode_ISO_8601 (s.Get ()); - - // Round trip again in case we need to add a fake time zone. - - s = exif.fDateTimeDigitized.Encode_ISO_8601 (); - - SetString (XMP_NS_EXIF, - "DateTimeDigitized", - s); - - } - - } - - } - -/******************************************************************************/ - -void dng_xmp::UpdateDateTime (const dng_date_time_info &dt) - { - - dng_string s = dt.Encode_ISO_8601 (); - - SetString (XMP_NS_TIFF, - "DateTime", - s); - - } - -/******************************************************************************/ - -void dng_xmp::UpdateMetadataDate (const dng_date_time_info &dt) - { - - dng_string s = dt.Encode_ISO_8601 (); - - SetString (XMP_NS_XAP, - "MetadataDate", - s); - - } - -/*****************************************************************************/ - -bool dng_xmp::HasOrientation () const - { - - uint32 x = 0; - - if (Get_uint32 (XMP_NS_TIFF, - "Orientation", - x)) - { - - return (x >= 1) && (x <= 8); - - } - - return false; - - } - -/*****************************************************************************/ - -dng_orientation dng_xmp::GetOrientation () const - { - - dng_orientation result; - - uint32 x = 0; - - if (Get_uint32 (XMP_NS_TIFF, - "Orientation", - x)) - { - - if ((x >= 1) && (x <= 8)) - { - - result.SetTIFF (x); - - } - - } - - return result; - - } - -/******************************************************************************/ - -void dng_xmp::ClearOrientation () - { - - fSDK->Remove (XMP_NS_TIFF, "Orientation"); - - } - -/******************************************************************************/ - -void dng_xmp::SetOrientation (const dng_orientation &orientation) - { - - Set_uint32 (XMP_NS_TIFF, - "Orientation", - orientation.GetTIFF ()); - - } - -/*****************************************************************************/ - -void dng_xmp::SyncOrientation (dng_negative &negative, - bool xmpIsMaster) - { - - SyncOrientation (negative.Metadata (), xmpIsMaster); - - } - -/*****************************************************************************/ - -void dng_xmp::SyncOrientation (dng_metadata &metadata, - bool xmpIsMaster) - { - - // See if XMP contains the orientation. - - bool xmpHasOrientation = HasOrientation (); - - // See if XMP is the master value. - - if (xmpHasOrientation && (xmpIsMaster || !metadata.HasBaseOrientation ())) - { - - metadata.SetBaseOrientation (GetOrientation ()); - - } - - else - { - - SetOrientation (metadata.BaseOrientation ()); - - } - - } - -/******************************************************************************/ - -void dng_xmp::ClearImageInfo () - { - - Remove (XMP_NS_TIFF, "ImageWidth" ); - Remove (XMP_NS_TIFF, "ImageLength"); - - Remove (XMP_NS_EXIF, "PixelXDimension"); - Remove (XMP_NS_EXIF, "PixelYDimension"); - - Remove (XMP_NS_TIFF, "BitsPerSample"); - - Remove (XMP_NS_TIFF, "Compression"); - - Remove (XMP_NS_TIFF, "PhotometricInterpretation"); - - // "Orientation" is handled separately. - - Remove (XMP_NS_TIFF, "SamplesPerPixel"); - - Remove (XMP_NS_TIFF, "PlanarConfiguration"); - - Remove (XMP_NS_TIFF, "XResolution"); - Remove (XMP_NS_TIFF, "YResolution"); - - Remove (XMP_NS_TIFF, "ResolutionUnit"); - - Remove (XMP_NS_PHOTOSHOP, "ColorMode" ); - Remove (XMP_NS_PHOTOSHOP, "ICCProfile"); - - } - -/******************************************************************************/ - -void dng_xmp::SetImageSize (const dng_point &size) - { - - Set_uint32 (XMP_NS_TIFF, "ImageWidth" , size.h); - Set_uint32 (XMP_NS_TIFF, "ImageLength", size.v); - - // Mirror these values to the EXIF tags. - - Set_uint32 (XMP_NS_EXIF, "PixelXDimension" , size.h); - Set_uint32 (XMP_NS_EXIF, "PixelYDimension" , size.v); - - } - -/******************************************************************************/ - -void dng_xmp::SetSampleInfo (uint32 samplesPerPixel, - uint32 bitsPerSample) - { - - Set_uint32 (XMP_NS_TIFF, "SamplesPerPixel", samplesPerPixel); - - char s [32]; - - sprintf (s, "%u", (unsigned) bitsPerSample); - - dng_string ss; - - ss.Set (s); - - dng_string_list list; - - for (uint32 j = 0; j < samplesPerPixel; j++) - { - list.Append (ss); - } - - SetStringList (XMP_NS_TIFF, "BitsPerSample", list, false); - - } - -/******************************************************************************/ - -void dng_xmp::SetPhotometricInterpretation (uint32 pi) - { - - Set_uint32 (XMP_NS_TIFF, "PhotometricInterpretation", pi); - - } - -/******************************************************************************/ - -void dng_xmp::SetResolution (const dng_resolution &res) - { - - Set_urational (XMP_NS_TIFF, "XResolution", res.fXResolution); - Set_urational (XMP_NS_TIFF, "YResolution", res.fYResolution); - - Set_uint32 (XMP_NS_TIFF, "ResolutionUnit", res.fResolutionUnit); - - } - -/*****************************************************************************/ - -void dng_xmp::ComposeArrayItemPath (const char *ns, - const char *arrayName, - int32 itemNumber, - dng_string &s) const - { - - fSDK->ComposeArrayItemPath (ns, arrayName, itemNumber, s); - - } - -/*****************************************************************************/ - -void dng_xmp::ComposeStructFieldPath (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName, - dng_string &s) const - { - - fSDK->ComposeStructFieldPath (ns, structName, fieldNS, fieldName, s); - - } - -/*****************************************************************************/ - -int32 dng_xmp::CountArrayItems (const char *ns, - const char *path) const - { - - return fSDK->CountArrayItems (ns, path); - - } - -/*****************************************************************************/ - -void dng_xmp::AppendArrayItem (const char *ns, - const char *arrayName, - const char *itemValue, - bool isBag, - bool propIsStruct) - { - - fSDK->AppendArrayItem (ns, - arrayName, - itemValue, - isBag, - propIsStruct); - } - -/*****************************************************************************/ - -#if qDNGXMPDocOps - -/*****************************************************************************/ - -void dng_xmp::DocOpsOpenXMP (const char *srcMIMI) - { - - fSDK->DocOpsOpenXMP (srcMIMI); - - } - -/*****************************************************************************/ - -void dng_xmp::DocOpsPrepareForSave (const char *srcMIMI, - const char *dstMIMI, - bool newPath) - { - - fSDK->DocOpsPrepareForSave (srcMIMI, - dstMIMI, - newPath); - - } - -/*****************************************************************************/ - -void dng_xmp::DocOpsUpdateMetadata (const char *srcMIMI) - { - - fSDK->DocOpsUpdateMetadata (srcMIMI); - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xmp.h b/third_party/dng_sdk/dng_xmp.h deleted file mode 100644 index 8b8319e..0000000 --- a/third_party/dng_sdk/dng_xmp.h +++ /dev/null @@ -1,405 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2011 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xmp.h#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_xmp__ -#define __dng_xmp__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" -#include "dng_xmp_sdk.h" - -/*****************************************************************************/ - -class dng_xmp - { - - protected: - - // Sync option bits. - - enum - { - ignoreXMP = 1, // Force XMP values to match non-XMP - preferXMP = 2, // Prefer XMP values if conflict - preferNonXMP = 4, // Prefer non-XMP values if conflict - removeXMP = 8 // Remove XMP value after syncing - }; - - dng_memory_allocator &fAllocator; - - dng_xmp_sdk *fSDK; - - public: - - dng_xmp (dng_memory_allocator &allocator); - - dng_xmp (const dng_xmp &xmp); - - virtual ~dng_xmp (); - - virtual dng_xmp * Clone () const; - - void Parse (dng_host &host, - const void *buffer, - uint32 count); - - dng_memory_block * Serialize (bool asPacket = false, - uint32 targetBytes = 0, - uint32 padBytes = 4096, - bool forJPEG = false, - bool compact = true) const; - - // Kludge: Due to a bug in Premere Elements 9, we need to pass non-compact XMP - // to the host, until we drop support for this Premere version. This bug - // is fixed in Premere Elements 10 and later. - - dng_memory_block * SerializeNonCompact () const - { - return Serialize (false, - 0, - 4096, - false, - false); - } - - void PackageForJPEG (AutoPtr &stdBlock, - AutoPtr &extBlock, - dng_string &extDigest) const; - - void MergeFromJPEG (const dng_xmp &xmp); - - bool HasMeta () const; - - void * GetPrivateMeta (); - - bool Exists (const char *ns, - const char *path) const; - - bool HasNameSpace (const char *ns) const; - - bool IteratePaths (IteratePathsCallback *callback, - void *callbackData, - const char *ns = 0, - const char *path = 0); - - void Remove (const char *ns, - const char *path); - - void RemoveProperties (const char *ns); - - void RemoveEmptyStringOrArray (const char *ns, - const char *path); - - void RemoveEmptyStringsAndArrays (const char *ns = 0); - - void Set (const char *ns, - const char *path, - const char *text); - - bool GetString (const char *ns, - const char *path, - dng_string &s) const; - - void SetString (const char *ns, - const char *path, - const dng_string &s); - - bool GetStringList (const char *ns, - const char *path, - dng_string_list &list) const; - - void SetStringList (const char *ns, - const char *path, - const dng_string_list &list, - bool isBag = false); - - void SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const dng_string &s); - - void SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const char *s); - - void DeleteStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName); - - bool GetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - dng_string &s) const; - - void SetAltLangDefault (const char *ns, - const char *path, - const dng_string &s); - - bool GetAltLangDefault (const char *ns, - const char *path, - dng_string &s) const; - - bool GetBoolean (const char *ns, - const char *path, - bool &x) const; - - void SetBoolean (const char *ns, - const char *path, - bool x); - - bool Get_int32 (const char *ns, - const char *path, - int32 &x) const; - - void Set_int32 (const char *ns, - const char *path, - int32 x, - bool usePlus = false); - - bool Get_uint32 (const char *ns, - const char *path, - uint32 &x) const; - - void Set_uint32 (const char *ns, - const char *path, - uint32 x); - - bool Get_real64 (const char *ns, - const char *path, - real64 &x) const; - - void Set_real64 (const char *ns, - const char *path, - real64 x, - uint32 places = 6, - bool trim = true, - bool usePlus = false); - - bool Get_urational (const char *ns, - const char *path, - dng_urational &r) const; - - void Set_urational (const char *ns, - const char *path, - const dng_urational &r); - - bool Get_srational (const char *ns, - const char *path, - dng_srational &r) const; - - void Set_srational (const char *ns, - const char *path, - const dng_srational &r); - - bool GetFingerprint (const char *ns, - const char *path, - dng_fingerprint &print) const; - - void SetFingerprint (const char *ns, - const char *path, - const dng_fingerprint &print, - bool allowInvalid = false); - - void SetVersion2to4 (const char *ns, - const char *path, - uint32 version); - - dng_fingerprint GetIPTCDigest () const; - - void SetIPTCDigest (dng_fingerprint &digest); - - void ClearIPTCDigest (); - - void IngestIPTC (dng_metadata &metadata, - bool xmpIsNewer = false); - - void RebuildIPTC (dng_metadata &metadata, - dng_memory_allocator &allocator, - bool padForTIFF); - - virtual void SyncExif (dng_exif &exif, - const dng_exif *originalExif = NULL, - bool doingUpdateFromXMP = false, - bool removeFromXMP = false); - - void ValidateStringList (const char *ns, - const char *path); - - void ValidateMetadata (); - - void UpdateDateTime (const dng_date_time_info &dt); - - void UpdateMetadataDate (const dng_date_time_info &dt); - - void UpdateExifDates (dng_exif &exif, - bool removeFromXMP = false); - - bool HasOrientation () const; - - dng_orientation GetOrientation () const; - - void ClearOrientation (); - - void SetOrientation (const dng_orientation &orientation); - - void SyncOrientation (dng_negative &negative, - bool xmpIsMaster); - // FIX_ME_API: Backwards compatibility - - void SyncOrientation (dng_metadata &metadata, - bool xmpIsMaster); - - void ClearImageInfo (); - - void SetImageSize (const dng_point &size); - - void SetSampleInfo (uint32 samplesPerPixel, - uint32 bitsPerSample); - - void SetPhotometricInterpretation (uint32 pi); - - void SetResolution (const dng_resolution &res); - - void ComposeArrayItemPath (const char *ns, - const char *arrayName, - int32 itemNumber, - dng_string &s) const; - - void ComposeStructFieldPath (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName, - dng_string &s) const; - - int32 CountArrayItems (const char *ns, - const char *path) const; - - void AppendArrayItem (const char *ns, - const char *arrayName, - const char *itemValue, - bool isBag = true, - bool propIsStruct = false); - - static dng_string EncodeFingerprint (const dng_fingerprint &f, - bool allowInvalid = false); - - static dng_fingerprint DecodeFingerprint (const dng_string &s); - - #if qDNGXMPDocOps - - void DocOpsOpenXMP (const char *srcMIMI); - - void DocOpsPrepareForSave (const char *srcMIMI, - const char *dstMIMI, - bool newPath = true); - - void DocOpsUpdateMetadata (const char *srcMIMI); - - #endif - - protected: - - static void TrimDecimal (char *s); - - static dng_string EncodeGPSVersion (uint32 version); - - static uint32 DecodeGPSVersion (const dng_string &s); - - static dng_string EncodeGPSCoordinate (const dng_string &ref, - const dng_urational *coord); - - static void DecodeGPSCoordinate (const dng_string &s, - dng_string &ref, - dng_urational *coord); - - static dng_string EncodeGPSDateTime (const dng_string &dateStamp, - const dng_urational *timeStamp); - - static void DecodeGPSDateTime (const dng_string &s, - dng_string &dateStamp, - dng_urational *timeStamp); - - bool SyncString (const char *ns, - const char *path, - dng_string &s, - uint32 options = 0); - - void SyncStringList (const char *ns, - const char *path, - dng_string_list &list, - bool isBag = false, - uint32 options = 0); - - bool SyncAltLangDefault (const char *ns, - const char *path, - dng_string &s, - uint32 options = 0); - - void Sync_uint32 (const char *ns, - const char *path, - uint32 &x, - bool isDefault = false, - uint32 options = 0); - - void Sync_uint32_array (const char *ns, - const char *path, - uint32 *data, - uint32 &count, - uint32 maxCount, - uint32 options = 0); - - void Sync_urational (const char *ns, - const char *path, - dng_urational &r, - uint32 options = 0); - - void Sync_srational (const char *ns, - const char *path, - dng_srational &r, - uint32 options = 0); - - void SyncIPTC (dng_iptc &iptc, - uint32 options); - - void SyncFlash (uint32 &flashState, - uint32 &flashMask, - uint32 options); - - bool DateTimeIsDateOnly (const char *ns, - const char *path); - - virtual void SyncApproximateFocusDistance (dng_exif &exif, - const uint32 readOnly); - - private: - - // Hidden assignment operator. - - dng_xmp & operator= (const dng_xmp &xmp); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xmp_sdk.cpp b/third_party/dng_sdk/dng_xmp_sdk.cpp deleted file mode 100644 index d7ef225..0000000 --- a/third_party/dng_sdk/dng_xmp_sdk.cpp +++ /dev/null @@ -1,1679 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xmp_sdk.cpp#4 $ */ -/* $DateTime: 2012/09/05 12:31:51 $ */ -/* $Change: 847652 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_xmp_sdk.h" - -#include "dng_auto_ptr.h" -#include "dng_assertions.h" -#include "dng_exceptions.h" -#include "dng_flags.h" -#include "dng_host.h" -#include "dng_memory.h" -#include "dng_string.h" -#include "dng_string_list.h" -#include "dng_utils.h" - -/*****************************************************************************/ - -#if qMacOS -#ifndef MAC_ENV -#define MAC_ENV 1 -#endif -#endif - -#if qWinOS -#ifndef WIN_ENV -#define WIN_ENV 1 -#endif -#endif - -#include -#include - -#define TXMP_STRING_TYPE std::string - -#define XMP_INCLUDE_XMPFILES qDNGXMPFiles - -#define XMP_StaticBuild 1 - -#include "XMP.incl_cpp" - -/*****************************************************************************/ - -const char *XMP_NS_TIFF = "http://ns.adobe.com/tiff/1.0/"; -const char *XMP_NS_EXIF = "http://ns.adobe.com/exif/1.0/"; -const char *XMP_NS_PHOTOSHOP = "http://ns.adobe.com/photoshop/1.0/"; -const char *XMP_NS_XAP = "http://ns.adobe.com/xap/1.0/"; -const char *XMP_NS_XAP_RIGHTS = "http://ns.adobe.com/xap/1.0/rights/"; -const char *XMP_NS_DC = "http://purl.org/dc/elements/1.1/"; -const char *XMP_NS_XMP_NOTE = "http://ns.adobe.com/xmp/note/"; -const char *XMP_NS_MM = "http://ns.adobe.com/xap/1.0/mm/"; - -const char *XMP_NS_CRS = "http://ns.adobe.com/camera-raw-settings/1.0/"; -const char *XMP_NS_CRSS = "http://ns.adobe.com/camera-raw-saved-settings/1.0/"; -const char *XMP_NS_AUX = "http://ns.adobe.com/exif/1.0/aux/"; - -const char *XMP_NS_LCP = "http://ns.adobe.com/photoshop/1.0/camera-profile"; - -const char *XMP_NS_IPTC = "http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/"; -const char *XMP_NS_IPTC_EXT = "http://iptc.org/std/Iptc4xmpExt/2008-02-29/"; - -const char *XMP_NS_CRX = "http://ns.adobe.com/lightroom-settings-experimental/1.0/"; - -const char *XMP_NS_DNG = "http://ns.adobe.com/dng/1.0/"; - -/******************************************************************************/ - -#define CATCH_XMP(routine, fatal)\ - \ - catch (std::bad_alloc &)\ - {\ - DNG_REPORT ("Info: XMP " routine " threw memory exception");\ - ThrowMemoryFull ();\ - }\ - \ - catch (XMP_Error &error)\ - {\ - const char *errMessage = error.GetErrMsg ();\ - if (errMessage && strlen (errMessage) <= 128)\ - {\ - char errBuffer [256];\ - sprintf (errBuffer, "Info: XMP " routine " threw '%s' exception", errMessage);\ - DNG_REPORT ( errBuffer);\ - }\ - else\ - {\ - DNG_REPORT ("Info: XMP " routine " threw unnamed exception");\ - }\ - if (fatal) ThrowProgramError ();\ - }\ - \ - catch (...)\ - {\ - DNG_REPORT ("Info: XMP " routine " threw unknown exception");\ - if (fatal) ThrowProgramError ();\ - } - -/*****************************************************************************/ - -class dng_xmp_private - { - - public: - - SXMPMeta *fMeta; - - dng_xmp_private () - : fMeta (NULL) - { - } - - dng_xmp_private (const dng_xmp_private &xmp); - - ~dng_xmp_private () - { - if (fMeta) - { - delete fMeta; - } - } - - private: - - // Hidden assignment operator. - - dng_xmp_private & operator= (const dng_xmp_private &xmp); - - }; - -/*****************************************************************************/ - -dng_xmp_private::dng_xmp_private (const dng_xmp_private &xmp) - - : fMeta (NULL) - - { - - if (xmp.fMeta) - { - - fMeta = new SXMPMeta (xmp.fMeta->Clone (0)); - - if (!fMeta) - { - ThrowMemoryFull (); - } - - } - - } - -/*****************************************************************************/ - -dng_xmp_sdk::dng_xmp_sdk () - - : fPrivate (NULL) - - { - - fPrivate = new dng_xmp_private; - - if (!fPrivate) - { - ThrowMemoryFull (); - } - - } - -/*****************************************************************************/ - -dng_xmp_sdk::dng_xmp_sdk (const dng_xmp_sdk &sdk) - - : fPrivate (NULL) - - { - - fPrivate = new dng_xmp_private (*sdk.fPrivate); - - if (!fPrivate) - { - ThrowMemoryFull (); - } - - } - -/*****************************************************************************/ - -dng_xmp_sdk::~dng_xmp_sdk () - { - - if (fPrivate) - { - delete fPrivate; - } - - } - -/*****************************************************************************/ - -static bool gInitializedXMP = false; - -/*****************************************************************************/ - -void dng_xmp_sdk::InitializeSDK (dng_xmp_namespace * extraNamespaces, - const char *software) - { - - if (!gInitializedXMP) - { - - try - { - - if (!SXMPMeta::Initialize ()) - { - ThrowProgramError (); - } - - // Register Lightroom beta settings namespace. - // We no longer read this but I don't want to cut it out this close - // to a release. [bruzenak] - - { - - TXMP_STRING_TYPE ss; - - SXMPMeta::RegisterNamespace (XMP_NS_CRX, - "crx", - &ss); - - } - - // Register CRSS snapshots namespace - - { - - TXMP_STRING_TYPE ss; - - SXMPMeta::RegisterNamespace (XMP_NS_CRSS, - "crss", - &ss); - - } - - // Register LCP (lens correction profiles) namespace - - { - - TXMP_STRING_TYPE ss; - - SXMPMeta::RegisterNamespace (XMP_NS_LCP, - "stCamera", - &ss); - - } - - // Register DNG format metadata namespace - - { - - TXMP_STRING_TYPE ss; - - SXMPMeta::RegisterNamespace (XMP_NS_DNG, - "dng", - &ss); - - } - - // Register extra namespaces. - - if (extraNamespaces != NULL) - { - - for (; extraNamespaces->fullName != NULL; ++extraNamespaces) - { - - TXMP_STRING_TYPE ss; - - SXMPMeta::RegisterNamespace (extraNamespaces->fullName, - extraNamespaces->shortName, - &ss); - - } - - } - - #if qDNGXMPFiles - - #if qLinux - if (!SXMPFiles::Initialize (kXMPFiles_IgnoreLocalText)) - #else - if (!SXMPFiles::Initialize ()) - #endif - { - ThrowProgramError (); - } - - #endif - - #if qDNGXMPDocOps - - if (software) - { - - SXMPDocOps::SetAppName (software); - - } - - #else - - (void) software; - - #endif - - } - - CATCH_XMP ("Initialization", true) - - gInitializedXMP = true; - - } - - } - -/******************************************************************************/ - -void dng_xmp_sdk::TerminateSDK () - { - - if (gInitializedXMP) - { - - try - { - - #if qDNGXMPFiles - - SXMPFiles::Terminate (); - - #endif - - SXMPMeta::Terminate (); - - } - - catch (...) - { - - } - - gInitializedXMP = false; - - } - - } - -/******************************************************************************/ - -bool dng_xmp_sdk::HasMeta () const - { - - if (fPrivate->fMeta) - { - - return true; - - } - - return false; - - } - -/******************************************************************************/ - -void dng_xmp_sdk::ClearMeta () - { - - if (HasMeta ()) - { - - delete fPrivate->fMeta; - - fPrivate->fMeta = NULL; - - } - - } - -/******************************************************************************/ - -void dng_xmp_sdk::MakeMeta () - { - - ClearMeta (); - - InitializeSDK (); - - try - { - - fPrivate->fMeta = new SXMPMeta; - - if (!fPrivate->fMeta) - { - - ThrowMemoryFull (); - - } - - } - - CATCH_XMP ("MakeMeta", true) - - } - -/******************************************************************************/ - -void dng_xmp_sdk::NeedMeta () - { - - if (!HasMeta ()) - { - - MakeMeta (); - - } - - } - -/******************************************************************************/ - -void * dng_xmp_sdk::GetPrivateMeta () - { - - NeedMeta (); - - return (void *) fPrivate->fMeta; - - } - -/******************************************************************************/ - -void dng_xmp_sdk::Parse (dng_host &host, - const char *buffer, - uint32 count) - { - - MakeMeta (); - - try - { - - try - { - - fPrivate->fMeta->ParseFromBuffer (buffer, count); - - } - - CATCH_XMP ("ParseFromBuffer", true) - - } - - catch (dng_exception &except) - { - - ClearMeta (); - - if (host.IsTransientError (except.ErrorCode ())) - { - - throw; - - } - - ThrowBadFormat (); - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::AppendArrayItem (const char *ns, - const char *arrayName, - const char *itemValue, - bool isBag, - bool propIsStruct) - { - - NeedMeta(); - - try - { - - fPrivate->fMeta->AppendArrayItem (ns, - arrayName, - isBag ? kXMP_PropValueIsArray - : kXMP_PropArrayIsOrdered, - itemValue, - propIsStruct ? kXMP_PropValueIsStruct - : 0); - - } - CATCH_XMP ("AppendArrayItem", true ) - - } - -/*****************************************************************************/ - -int32 dng_xmp_sdk::CountArrayItems (const char *ns, - const char *path) const - { - - if (HasMeta ()) - { - - try - { - - return fPrivate->fMeta->CountArrayItems (ns, path); - - } - - CATCH_XMP ("CountArrayItems", false) - - } - - return 0; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::Exists (const char *ns, - const char *path) const - { - - if (HasMeta ()) - { - - try - { - - return fPrivate->fMeta->DoesPropertyExist (ns, path); - - } - - catch (...) - { - - // Does not exist... - - } - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::HasNameSpace (const char *ns) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - SXMPIterator iter (*fPrivate->fMeta, ns); - - TXMP_STRING_TYPE nsTemp; - TXMP_STRING_TYPE prop; - - if (iter.Next (&nsTemp, - &prop, - NULL, - NULL)) - { - - result = true; - - } - - } - - CATCH_XMP ("HasNameSpace", true) - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::Remove (const char *ns, - const char *path) - { - - if (HasMeta ()) - { - - try - { - - fPrivate->fMeta->DeleteProperty (ns, path); - - } - - CATCH_XMP ("DeleteProperty", false) - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::RemoveProperties (const char *ns) - { - - if (HasMeta ()) - { - - try - { - - SXMPUtils::RemoveProperties (fPrivate->fMeta, - ns, - NULL, - kXMPUtil_DoAllProperties); - - } - - catch (...) - { - - } - - } - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::IsEmptyString (const char *ns, - const char *path) - { - - if (HasMeta ()) - { - - try - { - - TXMP_STRING_TYPE ss; - - XMP_OptionBits options = 0; - - if (fPrivate->fMeta->GetProperty (ns, - path, - &ss, - &options)) - { - - // Item must be simple. - - if (XMP_PropIsSimple (options)) - { - - // Check for null strings. - - return (ss.c_str () == 0 || - ss.c_str () [0] == 0); - - } - - } - - } - - CATCH_XMP ("IsEmptyString", false) - - } - - return false; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::IsEmptyArray (const char *ns, - const char *path) - { - - if (HasMeta ()) - { - - try - { - - TXMP_STRING_TYPE ss; - - XMP_OptionBits options = 0; - - if (fPrivate->fMeta->GetProperty (ns, - path, - &ss, - &options)) - { - - if (XMP_PropIsArray (options)) - { - - if (fPrivate->fMeta->GetArrayItem (ns, - path, - 1, - &ss, - &options)) - { - - // If the first item is a null string... - - if (XMP_PropIsSimple (options)) - { - - if ((ss.c_str () == 0 || - ss.c_str () [0] == 0)) - { - - // And there is no second item. - - if (!fPrivate->fMeta->GetArrayItem (ns, - path, - 2, - &ss, - &options)) - { - - // Then we have an empty array. - - return true; - - } - - } - - } - - } - - else - { - - // Unable to get first item, so array is empty. - - return true; - - } - - } - - } - - } - - CATCH_XMP ("IsEmptyArray", false) - - } - - return false; - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::ComposeArrayItemPath (const char *ns, - const char *arrayName, - int32 index, - dng_string &s) const - { - - try - { - - std::string ss; - - SXMPUtils::ComposeArrayItemPath (ns, arrayName, index, &ss); - - s.Set (ss.c_str ()); - - return; - - } - - CATCH_XMP ("ComposeArrayItemPath", true) - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::ComposeStructFieldPath (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName, - dng_string &s) const - { - - try - { - - std::string ss; - - SXMPUtils::ComposeStructFieldPath (ns, - structName, - fieldNS, - fieldName, - &ss); - - s.Set (ss.c_str ()); - - return; - - } - - CATCH_XMP ("ComposeStructFieldPath", true) - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::GetNamespacePrefix (const char *uri, - dng_string &s) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - std::string ss; - - fPrivate->fMeta->GetNamespacePrefix (uri, &ss); - - s.Set (ss.c_str ()); - - result = true; - - } - - CATCH_XMP ("GetNamespacePrefix", false) - - } - - return result; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::GetString (const char *ns, - const char *path, - dng_string &s) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - TXMP_STRING_TYPE ss; - - if (fPrivate->fMeta->GetProperty (ns, path, &ss, NULL)) - { - - s.Set (ss.c_str ()); - - result = true; - - } - - } - - CATCH_XMP ("GetProperty", false) - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::ValidateStringList (const char *ns, - const char *path) - { - - if (Exists (ns, path)) - { - - bool bogus = true; - - try - { - - XMP_Index index = 1; - - TXMP_STRING_TYPE ss; - - while (fPrivate->fMeta->GetArrayItem (ns, - path, - index++, - &ss, - NULL)) - { - - } - - bogus = false; - - } - - CATCH_XMP ("GetArrayItem", false) - - if (bogus) - { - - Remove (ns, path); - - } - - } - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::GetStringList (const char *ns, - const char *path, - dng_string_list &list) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - XMP_Index index = 1; - - TXMP_STRING_TYPE ss; - - while (fPrivate->fMeta->GetArrayItem (ns, - path, - index++, - &ss, - NULL)) - { - - dng_string s; - - s.Set (ss.c_str ()); - - list.Append (s); - - result = true; - - } - - } - - CATCH_XMP ("GetArrayItem", false) - - } - - return result; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::GetAltLangDefault (const char *ns, - const char *path, - dng_string &s) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - TXMP_STRING_TYPE ss; - - if (fPrivate->fMeta->GetLocalizedText (ns, - path, - "x-default", - "x-default", - NULL, - &ss, - NULL)) - { - - s.Set (ss.c_str ()); - - result = true; - - } - // - // Special Case: treat the following two representation equivalently. - // The first is an empty alt lang array; the second is an array with - // an empty item. It seems that xmp lib could be generating both under - // some circumstances! - // - // - // - // - // - // and - // - // - // - // - // - // - // - else if (fPrivate->fMeta->GetProperty (ns, - path, - &ss, - NULL)) - { - - if (ss.empty ()) - { - - s.Clear (); - - result = true; - - } - - } - - } - - CATCH_XMP ("GetLocalizedText", false) - - } - - return result; - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::GetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - dng_string &s) const - { - - bool result = false; - - if (HasMeta ()) - { - - try - { - - TXMP_STRING_TYPE ss; - - if (fPrivate->fMeta->GetStructField (ns, - path, - fieldNS, - fieldName, - &ss, - NULL)) - { - - s.Set (ss.c_str ()); - - result = true; - - } - - } - - CATCH_XMP ("GetStructField", false) - - } - - return result; - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::Set (const char *ns, - const char *path, - const char *text) - { - - NeedMeta (); - - try - { - - fPrivate->fMeta->SetProperty (ns, path, text); - - return; - - } - - catch (...) - { - - // Failed for some reason. - - } - - // Remove existing value and try again. - - Remove (ns, path); - - try - { - - fPrivate->fMeta->SetProperty (ns, path, text); - - } - - CATCH_XMP ("SetProperty", true) - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::SetString (const char *ns, - const char *path, - const dng_string &s) - { - - dng_string ss (s); - - ss.SetLineEndings ('\n'); - - ss.StripLowASCII (); - - Set (ns, path, ss.Get ()); - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::SetStringList (const char *ns, - const char *path, - const dng_string_list &list, - bool isBag) - { - - // Remove any existing structure. - - Remove (ns, path); - - // If list is not empty, add the items. - - if (list.Count ()) - { - - NeedMeta (); - - for (uint32 index = 0; index < list.Count (); index++) - { - - dng_string s (list [index]); - - s.SetLineEndings ('\n'); - - s.StripLowASCII (); - - try - { - - fPrivate->fMeta->AppendArrayItem (ns, - path, - isBag ? kXMP_PropValueIsArray - : kXMP_PropArrayIsOrdered, - s.Get ()); - - } - - CATCH_XMP ("AppendArrayItem", true) - - } - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::SetAltLangDefault (const char *ns, - const char *path, - const dng_string &s) - { - - NeedMeta (); - - Remove (ns, path); - - dng_string ss (s); - - ss.SetLineEndings ('\n'); - - ss.StripLowASCII (); - - try - { - - fPrivate->fMeta->SetLocalizedText (ns, - path, - "x-default", - "x-default", - ss.Get ()); - - } - - CATCH_XMP ("SetLocalizedText", true) - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const char *text) - { - - NeedMeta (); - - try - { - - fPrivate->fMeta->SetStructField (ns, - path, - fieldNS, - fieldName, - text); - - } - - CATCH_XMP ("SetStructField", true) - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::DeleteStructField (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName) - { - - if (HasMeta ()) - { - - try - { - - fPrivate->fMeta->DeleteStructField (ns, structName, fieldNS, fieldName); - - } - - catch (...) - { - - } - - } - - } - -/*****************************************************************************/ - -dng_memory_block * dng_xmp_sdk::Serialize (dng_memory_allocator &allocator, - bool asPacket, - uint32 targetBytes, - uint32 padBytes, - bool forJPEG, - bool compact) const - { - - // The largest XMP packet you can embed in JPEG using normal methods: - - const uint32 kJPEG_XMP_Limit = 65504; - - if (HasMeta ()) - { - - TXMP_STRING_TYPE s; - - bool havePacket = false; - - // Note that the XMP lib is changing its default to compact format - // in the future, so the following line will need to change. - - uint32 formatOption = compact ? kXMP_UseCompactFormat : 0; - - if (asPacket && targetBytes) - { - - try - { - - fPrivate->fMeta->SerializeToBuffer (&s, - formatOption | kXMP_ExactPacketLength, - targetBytes, - "", - " "); - - havePacket = true; - - } - - catch (...) - { - - // Most likely the packet cannot fit in the target - // byte count. So try again without the limit. - - } - - } - - if (!havePacket) - { - - try - { - - fPrivate->fMeta->SerializeToBuffer (&s, - formatOption | - (asPacket ? 0 - : kXMP_OmitPacketWrapper), - (asPacket ? padBytes - : 0), - "", - " "); - - } - - CATCH_XMP ("SerializeToBuffer", true) - - } - - uint32 packetLen = (uint32) s.size (); - - if (forJPEG && asPacket && padBytes > 0 && targetBytes <= kJPEG_XMP_Limit && - packetLen > kJPEG_XMP_Limit) - { - - uint32 overLimitCount = packetLen - kJPEG_XMP_Limit; - - if (overLimitCount > padBytes) - { - padBytes = 0; - } - else - { - padBytes -= overLimitCount; - } - - try - { - - fPrivate->fMeta->SerializeToBuffer (&s, - formatOption, - padBytes, - "", - " "); - - } - - CATCH_XMP ("SerializeToBuffer", true) - - packetLen = (uint32) s.size (); - - } - - if (packetLen) - { - - AutoPtr buffer (allocator.Allocate (packetLen)); - - memcpy (buffer->Buffer (), s.c_str (), packetLen); - - return buffer.Release (); - - } - - } - - return NULL; - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::PackageForJPEG (dng_memory_allocator &allocator, - AutoPtr &stdBlock, - AutoPtr &extBlock, - dng_string &extDigest) const - { - - if (HasMeta ()) - { - - TXMP_STRING_TYPE stdStr; - TXMP_STRING_TYPE extStr; - TXMP_STRING_TYPE digestStr; - - try - { - - SXMPUtils::PackageForJPEG (*fPrivate->fMeta, - &stdStr, - &extStr, - &digestStr); - - } - - CATCH_XMP ("PackageForJPEG", true) - - uint32 stdLen = (uint32) stdStr.size (); - uint32 extLen = (uint32) extStr.size (); - - if (stdLen) - { - - stdBlock.Reset (allocator.Allocate (stdLen)); - - memcpy (stdBlock->Buffer (), stdStr.c_str (), stdLen); - - } - - if (extLen) - { - - extBlock.Reset (allocator.Allocate (extLen)); - - memcpy (extBlock->Buffer (), extStr.c_str (), extLen); - - if (digestStr.size () != 32) - { - ThrowProgramError (); - } - - extDigest.Set (digestStr.c_str ()); - - } - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::MergeFromJPEG (const dng_xmp_sdk *xmp) - { - - if (xmp && xmp->HasMeta ()) - { - - NeedMeta (); - - try - { - - SXMPUtils::MergeFromJPEG (fPrivate->fMeta, - *xmp->fPrivate->fMeta); - - } - - CATCH_XMP ("MergeFromJPEG", true) - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::ReplaceXMP (dng_xmp_sdk *xmp) - { - - ClearMeta (); - - if (xmp && xmp->HasMeta ()) - { - - fPrivate->fMeta = xmp->fPrivate->fMeta; - - xmp->fPrivate->fMeta = NULL; - - } - - } - -/*****************************************************************************/ - -bool dng_xmp_sdk::IteratePaths (IteratePathsCallback *callback, - void *callbackData, - const char* startingNS, - const char* startingPath) - { - - if (HasMeta ()) - { - - try - { - - SXMPIterator iter (*fPrivate->fMeta, startingNS, startingPath); - - TXMP_STRING_TYPE ns; - TXMP_STRING_TYPE prop; - - while (iter.Next (&ns, - &prop, - NULL, - NULL)) - { - - if (!callback (ns .c_str (), - prop.c_str (), - callbackData)) - { - - return false; - - } - - } - - } - - CATCH_XMP ("IteratePaths", true) - - } - - return true; - - } - -/*****************************************************************************/ - -#if qDNGXMPDocOps - -/*****************************************************************************/ - -void dng_xmp_sdk::DocOpsOpenXMP (const char *srcMIMI) - { - - if (srcMIMI [0]) - { - - NeedMeta (); - - try - { - - SXMPDocOps docOps; - - docOps.OpenXMP (fPrivate->fMeta, - srcMIMI); - - } - - CATCH_XMP ("DocOpsOpenXMP", false) - - Set (XMP_NS_DC, - "format", - srcMIMI); - - } - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::DocOpsPrepareForSave (const char *srcMIMI, - const char *dstMIMI, - bool newPath) - { - - NeedMeta (); - - try - { - - SXMPDocOps docOps; - - docOps.OpenXMP (fPrivate->fMeta, - srcMIMI, - "old path"); - - docOps.NoteChange (kXMP_Part_All); - - docOps.PrepareForSave (dstMIMI, - newPath ? "new path" : "old path"); - - } - - CATCH_XMP ("DocOpsPrepareForSave", false) - - Set (XMP_NS_DC, - "format", - dstMIMI); - - } - -/*****************************************************************************/ - -void dng_xmp_sdk::DocOpsUpdateMetadata (const char *srcMIMI) - { - - NeedMeta (); - - try - { - - SXMPDocOps docOps; - - docOps.OpenXMP (fPrivate->fMeta, - srcMIMI); - - docOps.NoteChange (kXMP_Part_Metadata); - - docOps.PrepareForSave (srcMIMI); - - } - - CATCH_XMP ("DocOpsUpdateMetadata", false) - - } - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xmp_sdk.h b/third_party/dng_sdk/dng_xmp_sdk.h deleted file mode 100644 index 7f4332b..0000000 --- a/third_party/dng_sdk/dng_xmp_sdk.h +++ /dev/null @@ -1,238 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2012 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xmp_sdk.h#2 $ */ -/* $DateTime: 2012/05/31 09:29:29 $ */ -/* $Change: 832505 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#ifndef __dng_xmp_sdk__ -#define __dng_xmp_sdk__ - -/*****************************************************************************/ - -#include "dng_auto_ptr.h" -#include "dng_classes.h" -#include "dng_flags.h" -#include "dng_types.h" - -/*****************************************************************************/ - -extern const char *XMP_NS_TIFF; -extern const char *XMP_NS_EXIF; -extern const char *XMP_NS_PHOTOSHOP; -extern const char *XMP_NS_XAP; -extern const char *XMP_NS_XAP_RIGHTS; -extern const char *XMP_NS_DC; -extern const char *XMP_NS_XMP_NOTE; -extern const char *XMP_NS_MM; - -extern const char *XMP_NS_CRS; -extern const char *XMP_NS_CRSS; - -extern const char *XMP_NS_LCP; - -extern const char *XMP_NS_AUX; - -extern const char *XMP_NS_IPTC; -extern const char *XMP_NS_IPTC_EXT; - -extern const char *XMP_NS_CRX; - -extern const char *XMP_NS_DNG; - -/*****************************************************************************/ - -class dng_xmp_private; - -/*****************************************************************************/ - -typedef bool (IteratePathsCallback) (const char *ns, - const char *path, - void *callbackData); - -/*****************************************************************************/ - -struct dng_xmp_namespace - { - const char * fullName; - const char * shortName; - }; - -/*****************************************************************************/ - -class dng_xmp_sdk - { - - private: - - dng_xmp_private *fPrivate; - - public: - - dng_xmp_sdk (); - - dng_xmp_sdk (const dng_xmp_sdk &sdk); - - virtual ~dng_xmp_sdk (); - - static void InitializeSDK (dng_xmp_namespace * extraNamespaces = NULL, - const char *software = NULL); - - static void TerminateSDK (); - - bool HasMeta () const; - - void * GetPrivateMeta (); - - void Parse (dng_host &host, - const char *buffer, - uint32 count); - - bool Exists (const char *ns, - const char *path) const; - - void AppendArrayItem (const char *ns, - const char *arrayName, - const char *itemValue, - bool isBag = true, - bool propIsStruct = false); - - int32 CountArrayItems (const char *ns, - const char *path) const; - - bool HasNameSpace (const char *ns) const; - - void Remove (const char *ns, - const char *path); - - void RemoveProperties (const char *ns); - - bool IsEmptyString (const char *ns, - const char *path); - - bool IsEmptyArray (const char *ns, - const char *path); - - void ComposeArrayItemPath (const char *ns, - const char *arrayName, - int32 itemNumber, - dng_string &s) const; - - void ComposeStructFieldPath (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName, - dng_string &s) const; - - bool GetNamespacePrefix (const char *uri, - dng_string &s) const; - - bool GetString (const char *ns, - const char *path, - dng_string &s) const; - - void ValidateStringList (const char *ns, - const char *path); - - bool GetStringList (const char *ns, - const char *path, - dng_string_list &list) const; - - bool GetAltLangDefault (const char *ns, - const char *path, - dng_string &s) const; - - bool GetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - dng_string &s) const; - - void Set (const char *ns, - const char *path, - const char *text); - - void SetString (const char *ns, - const char *path, - const dng_string &s); - - void SetStringList (const char *ns, - const char *path, - const dng_string_list &list, - bool isBag); - - void SetAltLangDefault (const char *ns, - const char *path, - const dng_string &s); - - void SetStructField (const char *ns, - const char *path, - const char *fieldNS, - const char *fieldName, - const char *text); - - void DeleteStructField (const char *ns, - const char *structName, - const char *fieldNS, - const char *fieldName); - - dng_memory_block * Serialize (dng_memory_allocator &allocator, - bool asPacket, - uint32 targetBytes, - uint32 padBytes, - bool forJPEG, - bool compact) const; - - void PackageForJPEG (dng_memory_allocator &allocator, - AutoPtr &stdBlock, - AutoPtr &extBlock, - dng_string &extDigest) const; - - void MergeFromJPEG (const dng_xmp_sdk *xmp); - - void ReplaceXMP (dng_xmp_sdk *xmp); - - bool IteratePaths (IteratePathsCallback *callback, - void *callbackData = NULL, - const char *startNS = 0, - const char *startingPath = 0); - - #if qDNGXMPDocOps - - void DocOpsOpenXMP (const char *srcMIMI); - - void DocOpsPrepareForSave (const char *srcMIMI, - const char *dstMIMI, - bool newPath = true); - - void DocOpsUpdateMetadata (const char *srcMIMI); - - #endif - - private: - - void ClearMeta (); - - void MakeMeta (); - - void NeedMeta (); - - // Hidden assignment operator. - - dng_xmp_sdk & operator= (const dng_xmp_sdk &sdk); - - }; - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xy_coord.cpp b/third_party/dng_sdk/dng_xy_coord.cpp deleted file mode 100644 index c4fe8f0..0000000 --- a/third_party/dng_sdk/dng_xy_coord.cpp +++ /dev/null @@ -1,89 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006-2007 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xy_coord.cpp#1 $ */ -/* $DateTime: 2012/05/30 13:28:51 $ */ -/* $Change: 832332 $ */ -/* $Author: tknoll $ */ - -/*****************************************************************************/ - -#include "dng_xy_coord.h" - -#include "dng_matrix.h" -#include "dng_utils.h" - -/******************************************************************************/ - -dng_xy_coord XYZtoXY (const dng_vector_3 &coord) - { - - real64 X = coord [0]; - real64 Y = coord [1]; - real64 Z = coord [2]; - - real64 total = X + Y + Z; - - if (total > 0.0) - { - - return dng_xy_coord (X / total, - Y / total); - - } - - return D50_xy_coord (); - - } - -/*****************************************************************************/ - -dng_vector_3 XYtoXYZ (const dng_xy_coord &coord) - { - - dng_xy_coord temp = coord; - - // Restrict xy coord to someplace inside the range of real xy coordinates. - // This prevents math from doing strange things when users specify - // extreme temperature/tint coordinates. - - temp.x = Pin_real64 (0.000001, temp.x, 0.999999); - temp.y = Pin_real64 (0.000001, temp.y, 0.999999); - - if (temp.x + temp.y > 0.999999) - { - real64 scale = 0.999999 / (temp.x + temp.y); - temp.x *= scale; - temp.y *= scale; - } - - return dng_vector_3 (temp.x / temp.y, - 1.0, - (1.0 - temp.x - temp.y) / temp.y); - - } - -/*****************************************************************************/ - -dng_xy_coord PCStoXY () - { - - return D50_xy_coord (); - - } - -/*****************************************************************************/ - -dng_vector_3 PCStoXYZ () - { - - return XYtoXYZ (PCStoXY ()); - - } - -/*****************************************************************************/ diff --git a/third_party/dng_sdk/dng_xy_coord.h b/third_party/dng_sdk/dng_xy_coord.h deleted file mode 100644 index daf2125..0000000 --- a/third_party/dng_sdk/dng_xy_coord.h +++ /dev/null @@ -1,187 +0,0 @@ -/*****************************************************************************/ -// Copyright 2006 Adobe Systems Incorporated -// All Rights Reserved. -// -// NOTICE: Adobe permits you to use, modify, and distribute this file in -// accordance with the terms of the Adobe license agreement accompanying it. -/*****************************************************************************/ - -/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_xy_coord.h#2 $ */ -/* $DateTime: 2012/07/31 22:04:34 $ */ -/* $Change: 840853 $ */ -/* $Author: tknoll $ */ - -/** \file - * Representation of colors in xy and XYZ coordinates. - */ - -/*****************************************************************************/ - -#ifndef __dng_xy_coord__ -#define __dng_xy_coord__ - -/*****************************************************************************/ - -#include "dng_classes.h" -#include "dng_types.h" - -/*****************************************************************************/ - -class dng_xy_coord - { - - public: - - real64 x; - real64 y; - - public: - - dng_xy_coord () - : x (0.0) - , y (0.0) - { - } - - dng_xy_coord (real64 xx, real64 yy) - : x (xx) - , y (yy) - { - } - - void Clear () - { - x = 0.0; - y = 0.0; - } - - bool IsValid () const - { - return x > 0.0 && - y > 0.0; - } - - bool NotValid () const - { - return !IsValid (); - } - - bool operator== (const dng_xy_coord &coord) const - { - return coord.x == x && - coord.y == y; - } - - bool operator!= (const dng_xy_coord &coord) const - { - return !(*this == coord); - } - - }; - -/*****************************************************************************/ - -inline dng_xy_coord operator+ (const dng_xy_coord &A, - const dng_xy_coord &B) - { - - dng_xy_coord C; - - C.x = A.x + B.x; - C.y = A.y + B.y; - - return C; - - } - -/*****************************************************************************/ - -inline dng_xy_coord operator- (const dng_xy_coord &A, - const dng_xy_coord &B) - { - - dng_xy_coord C; - - C.x = A.x - B.x; - C.y = A.y - B.y; - - return C; - - } - -/*****************************************************************************/ - -inline dng_xy_coord operator* (real64 scale, - const dng_xy_coord &A) - { - - dng_xy_coord B; - - B.x = A.x * scale; - B.y = A.y * scale; - - return B; - - } - -/******************************************************************************/ - -inline real64 operator* (const dng_xy_coord &A, - const dng_xy_coord &B) - { - - return A.x * B.x + - A.y * B.y; - - } - -/*****************************************************************************/ - -// Standard xy coordinate constants. - -inline dng_xy_coord StdA_xy_coord () - { - return dng_xy_coord (0.4476, 0.4074); - } - -inline dng_xy_coord D50_xy_coord () - { - return dng_xy_coord (0.3457, 0.3585); - } - -inline dng_xy_coord D55_xy_coord () - { - return dng_xy_coord (0.3324, 0.3474); - } - -inline dng_xy_coord D65_xy_coord () - { - return dng_xy_coord (0.3127, 0.3290); - } - -inline dng_xy_coord D75_xy_coord () - { - return dng_xy_coord (0.2990, 0.3149); - } - -/*****************************************************************************/ - -// Convert between xy coordinates and XYZ coordinates. - -dng_xy_coord XYZtoXY (const dng_vector_3 &coord); - -dng_vector_3 XYtoXYZ (const dng_xy_coord &coord); - -/*****************************************************************************/ - -// Returns the ICC XYZ profile connection space white point. - -dng_xy_coord PCStoXY (); - -dng_vector_3 PCStoXYZ (); - -/*****************************************************************************/ - -#endif - -/*****************************************************************************/ From 322f72c320bf6ae34e805537282b1abf52d5a765 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 12:05:09 +0100 Subject: [PATCH 14/26] Fix highlight clipping in previews --- Renderer.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Renderer.cpp b/Renderer.cpp index 52904a1..9682e7b 100644 --- a/Renderer.cpp +++ b/Renderer.cpp @@ -63,14 +63,14 @@ void Renderer::process() { void Renderer::whiteBalance() { - double dmax = 0; + double dmin = 10000000.0; for (int c = 0; c < 4; ++c) { - if (dmax < md.camMul[c]) - dmax = md.camMul[c]; + if (dmin > md.camMul[c]) + dmin = md.camMul[c]; } float scale_mul[4]; for (int c = 0; c < 4; ++c) { - scale_mul[c] = (md.camMul[c] /= dmax); + scale_mul[c] = (md.camMul[c] /= dmin); } size_t size = height*width; float * dst = image[0]; From 5bff6584b3681c29d5e86e907479b30d66523cce Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 12:56:46 +0100 Subject: [PATCH 15/26] US32: Make DngPropertiesDialog subclass SaveOptions --- DngPropertiesDialog.cpp | 13 +++++++++++-- DngPropertiesDialog.hpp | 17 +++++------------ ImageStack.cpp | 2 +- ImageStack.hpp | 19 +------------------ Launcher.cpp | 2 -- MainWindow.cpp | 12 ++---------- 6 files changed, 20 insertions(+), 45 deletions(-) diff --git a/DngPropertiesDialog.cpp b/DngPropertiesDialog.cpp index 926989c..fe6096c 100644 --- a/DngPropertiesDialog.cpp +++ b/DngPropertiesDialog.cpp @@ -32,7 +32,7 @@ namespace hdrmerge { DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) - : QDialog(parent, f), bps(16), previewSize(0) { + : QDialog(parent, f), SaveOptions() { QVBoxLayout * layout = new QVBoxLayout(this); QWidget * bpsSelector = new QWidget(this); @@ -47,6 +47,7 @@ DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) bpsSelectorLayout->addWidget(button); } connect(bpsGroup, SIGNAL(buttonClicked( int)), this, SLOT(setBps(int))); + bps = 16; QWidget * previewSelector = new QWidget(this); QHBoxLayout * previewSelectorLayout = new QHBoxLayout(previewSelector); @@ -56,10 +57,11 @@ DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) for (int i = 0; i < 3; ++i) { QRadioButton * button = new QRadioButton(tr(previewLabels[i]), this); button->setChecked(i == 0); - previewGroup->addButton(button, i); + previewGroup->addButton(button, 2 - i); previewSelectorLayout->addWidget(button); } connect(previewGroup, SIGNAL(buttonClicked( int)), this, SLOT(setPreviewSize(int))); + previewSize = 2; QCheckBox * saveIndexFile = new QCheckBox(tr("Save"), this); @@ -100,6 +102,13 @@ DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) } +void DngPropertiesDialog::accept() { + maskFileName = indexFileSelector->isEnabled() ? + QDir::toNativeSeparators(indexFileEditor->text()).toUtf8().constData() : ""; + QDialog::accept(); +} + + void DngPropertiesDialog::setBps(int index) { switch (index) { case 0: bps = 16; break; diff --git a/DngPropertiesDialog.hpp b/DngPropertiesDialog.hpp index 6667912..784d027 100644 --- a/DngPropertiesDialog.hpp +++ b/DngPropertiesDialog.hpp @@ -25,29 +25,24 @@ #include #include +#include "LoadSaveOptions.hpp" namespace hdrmerge { -class DngPropertiesDialog : public QDialog { +class DngPropertiesDialog : public QDialog, public SaveOptions { public: DngPropertiesDialog(QWidget * parent = 0, Qt::WindowFlags f = 0); /// Triggered when the dialog is closed void closeEvent(QCloseEvent * event) { accept(); } - int getBps() const { - return bps; - } - int getPreviewSize() const { - return previewSize; - } - QString getIndexFileName() const { - return indexFileSelector->isEnabled() ? indexFileEditor->text() : ""; - } void setIndexFileName(const QString & name) { indexFileEditor->setText(name); } +public slots: + virtual void accept(); + private slots: void setBps(int index); void setPreviewSize(int index); @@ -57,8 +52,6 @@ private slots: private: Q_OBJECT - int bps; - int previewSize; QLineEdit * indexFileEditor; QWidget * indexFileSelector; }; diff --git a/ImageStack.cpp b/ImageStack.cpp index 21f403b..11ee967 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -77,7 +77,7 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) int ImageStack::save(const SaveOptions & options, ProgressIndicator & progress) { DngFloatWriter writer(*this, progress); writer.setBitsPerSample(options.bps); - writer.setPreviewWidth(options.previewSize); + writer.setPreviewWidth((options.previewSize * width) / 2); writer.setIndexFileName(options.maskFileName.c_str()); writer.write(options.fileName); } diff --git a/ImageStack.hpp b/ImageStack.hpp index b70e35e..28b7b8b 100644 --- a/ImageStack.hpp +++ b/ImageStack.hpp @@ -30,27 +30,10 @@ #include "Image.hpp" #include "ProgressIndicator.hpp" #include "MergeMap.hpp" - +#include "LoadSaveOptions.hpp" namespace hdrmerge { - -struct LoadOptions { - std::vector fileNames; - bool align; - LoadOptions() : align(true) {} -}; - - -struct SaveOptions { - int bps; - int previewSize; - std::string fileName; - std::string maskFileName; - SaveOptions() : bps(16), previewSize(0) {} -}; - - class ImageStack { public: ImageStack() : width(0), height(0) { setGamma(2.2f); } diff --git a/Launcher.cpp b/Launcher.cpp index 5e49cfb..8727c77 100644 --- a/Launcher.cpp +++ b/Launcher.cpp @@ -94,8 +94,6 @@ int Launcher::automaticMerge() { wOptions.fileName = stack.buildOutputFileName() + ".dng"; } Log::msg(Log::PROGRESS, tr("Writing result to %1").arg(wOptions.fileName.c_str())); - wOptions.previewSize *= stack.getWidth(); - wOptions.previewSize /= 2; stack.save(wOptions, progress); return 0; } diff --git a/MainWindow.cpp b/MainWindow.cpp index 7fde8a5..85ffaf4 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -360,19 +360,11 @@ void MainWindow::saveResult() { DngPropertiesDialog dpd(this); dpd.setIndexFileName((images->buildOutputFileName() + "_index.png").c_str()); if (dpd.exec()) { + dpd.fileName = fileName; ProgressDialog pd(this); pd.setWindowTitle(tr("Save DNG file")); QFuture result = QtConcurrent::run([&]() { - SaveOptions options; - options.bps = dpd.getBps(); - options.maskFileName = dpd.getIndexFileName().toUtf8().constData(); - options.fileName = fileName; - switch (dpd.getPreviewSize()) { - case 0: options.previewSize = images->getWidth(); break; - case 1: options.previewSize = images->getWidth() / 2; break; - default: options.previewSize = 0; - } - images->save(options, pd); + images->save(dpd, pd); }); while (result.isRunning()) QApplication::instance()->processEvents(QEventLoop::ExcludeUserInputEvents); From f599bc771bfb50d65577b29f33c36b012136b4c2 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 15:36:43 +0100 Subject: [PATCH 16/26] US32: Add a load dialog. - Add LoadOptionsDialog, with a list of files where the user can add and remove images, and a checkbox to align them. - Move all the "open files" functionality from MainWindow to LoadOptionsDialog. --- CMakeLists.txt | 4 +- DngPropertiesDialog.hpp | 2 +- Launcher.cpp | 5 -- LoadOptionsDialog.cpp | 140 ++++++++++++++++++++++++++++++++++++++++ LoadOptionsDialog.hpp | 55 ++++++++++++++++ LoadSaveOptions.hpp | 48 ++++++++++++++ Log.hpp | 7 ++ MainWindow.cpp | 38 ++--------- 8 files changed, 257 insertions(+), 42 deletions(-) create mode 100644 LoadOptionsDialog.cpp create mode 100644 LoadOptionsDialog.hpp create mode 100644 LoadSaveOptions.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 749c352..ffe7c00 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -44,10 +44,10 @@ include_directories("${PROJECT_BINARY_DIR}") # Sources and headers set(hdrmerge_sources - Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp + Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp LoadOptionsDialog.cpp Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngFloatWriter.cpp Renderer.cpp camxyz.cpp TiffDirectory.cpp) -set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp +set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp LoadOptionsDialog.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) set(hdrmerge_translations hdrmerge_es.ts) diff --git a/DngPropertiesDialog.hpp b/DngPropertiesDialog.hpp index 784d027..e84005b 100644 --- a/DngPropertiesDialog.hpp +++ b/DngPropertiesDialog.hpp @@ -34,7 +34,7 @@ class DngPropertiesDialog : public QDialog, public SaveOptions { DngPropertiesDialog(QWidget * parent = 0, Qt::WindowFlags f = 0); /// Triggered when the dialog is closed - void closeEvent(QCloseEvent * event) { accept(); } + void closeEvent(QCloseEvent * event) { reject(); } void setIndexFileName(const QString & name) { indexFileEditor->setText(name); diff --git a/Launcher.cpp b/Launcher.cpp index 8727c77..c3cc08a 100644 --- a/Launcher.cpp +++ b/Launcher.cpp @@ -50,11 +50,6 @@ int Launcher::startGUI() { } -static std::ostream & operator<<(std::ostream & os, const QString & s) { - return os << string(s.toUtf8().constData()); -} - - struct CoutProgressIndicator : public ProgressIndicator { CoutProgressIndicator() : currentPercent(0) {} diff --git a/LoadOptionsDialog.cpp b/LoadOptionsDialog.cpp new file mode 100644 index 0000000..f1895ef --- /dev/null +++ b/LoadOptionsDialog.cpp @@ -0,0 +1,140 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include "LoadOptionsDialog.hpp" + +namespace hdrmerge { + +LoadOptionsDialog::LoadOptionsDialog(QWidget * parent, Qt::WindowFlags f) + : QDialog(parent, f), LoadOptions() { + QVBoxLayout * layout = new QVBoxLayout(this); + + QWidget * fileSelector = new QWidget(this); + QHBoxLayout * fileSelectorLayout = new QHBoxLayout(fileSelector); + fileSelectorLayout->setMargin(0); + fileList = new QListWidget(fileSelector); + fileList->setSelectionMode(QAbstractItemView::ExtendedSelection); + fileSelectorLayout->addWidget(fileList, 1); + + QWidget * addRemoveButtons = new QWidget(this); + QVBoxLayout * addRemoveButtonsLayout = new QVBoxLayout(addRemoveButtons); + addRemoveButtonsLayout->setMargin(0); + QPushButton * addButton = new QPushButton(tr("Add"), addRemoveButtons); + QPushButton * removeButton = new QPushButton(tr("Remove"), addRemoveButtons); + addRemoveButtonsLayout->addWidget(addButton, 0, Qt::AlignTop); + addRemoveButtonsLayout->addWidget(removeButton, 0, Qt::AlignTop); + addRemoveButtonsLayout->addStretch(1); + fileSelectorLayout->addWidget(addRemoveButtons, 0); + layout->addWidget(fileSelector, 1); + connect(addButton, SIGNAL(clicked(bool)), this, SLOT(addFiles())); + connect(removeButton, SIGNAL(clicked(bool)), this, SLOT(removeFiles())); + + alignBox = new QCheckBox(tr("Align source images"), this); + alignBox->setChecked(true); + layout->addWidget(alignBox, 0); + + QWidget * buttons = new QWidget(this); + QHBoxLayout * buttonsLayout = new QHBoxLayout(buttons); + QPushButton * acceptButton = new QPushButton(tr("Accept"), this); + acceptButton->setDefault(true); + connect(acceptButton, SIGNAL(clicked(bool)), this, SLOT(accept())); + QPushButton * cancelButton = new QPushButton(tr("Cancel"), this); + connect(cancelButton, SIGNAL(clicked(bool)), this, SLOT(reject())); + buttonsLayout->addWidget(acceptButton); + buttonsLayout->addWidget(cancelButton); + layout->addWidget(buttons, 0, Qt::AlignHCenter); + + setLayout(layout); + setWindowTitle(tr("Load raw images")); + addFiles(); +} + + +class FileItem : public QListWidgetItem { +public: + FileItem(const QString & filename, QListWidget * parent) : QListWidgetItem(parent, 1000) { + QDir file(filename); + setText(file.path().section('/', -1)); + setData(Qt::UserRole, QVariant(filename)); + setSizeHint(QSize(0, 24)); + } +}; + + +void LoadOptionsDialog::addFiles() { + QSettings settings; + QVariant lastDirSetting = settings.value("lastOpenDirectory"); + QString filter(tr("Raw images (" + "*.3fr " + "*.ari *.arw " + "*.bay " + "*.crw *.cr2 *.cap " + "*.dcs *.dcr *.dng *.drf " + "*.eip *.erf " + "*.fff " + "*.iiq " + "*.k25 *.kdc " + "*.mdc *.mef *.mos *.mrw " + "*.nef *.nrw " + "*.obm *.orf " + "*.pef *.ptx *.pxn " + "*.r3d *.raf *.raw *.rwl *.rw2 *.rwz " + "*.sr2 *.srf *.srw " + "*.x3f" + ")")); + QStringList files = QFileDialog::getOpenFileNames(this, tr("Open raw images"), + lastDirSetting.isNull() ? QDir::currentPath() : QDir(lastDirSetting.toString()).absolutePath(), + filter, NULL, QFileDialog::DontUseNativeDialog); + if (!files.empty()) { + QString lastDir = QDir(files.front()).absolutePath(); + lastDir.truncate(lastDir.lastIndexOf('/')); + settings.setValue("lastOpenDirectory", lastDir); + for (auto & i : files) { + new FileItem(i, fileList); + } + } +} + + +void LoadOptionsDialog::removeFiles() { + QList items = fileList->selectedItems(); + for (auto i : items) { + delete i; + } +} + + +void LoadOptionsDialog::accept() { + align = alignBox->isChecked(); + for (int i = 0; i < fileList->count(); ++i) { + fileNames.push_back(fileList->item(i)->data(Qt::UserRole).toString().toUtf8().constData()); + } + QDialog::accept(); +} + +} // namespace hdrmerge diff --git a/LoadOptionsDialog.hpp b/LoadOptionsDialog.hpp new file mode 100644 index 0000000..b1833b0 --- /dev/null +++ b/LoadOptionsDialog.hpp @@ -0,0 +1,55 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#ifndef _LOADOPTIONSDIALOG_H_ +#define _LOADOPTIONSDIALOG_H_ + +#include +#include +#include +#include "LoadSaveOptions.hpp" + +namespace hdrmerge { + +class LoadOptionsDialog : public QDialog, public LoadOptions { +public: + LoadOptionsDialog(QWidget * parent = 0, Qt::WindowFlags f = 0); + + void closeEvent(QCloseEvent * event) { reject(); } + +public slots: + virtual void accept(); + void addFiles(); + void removeFiles(); + +private slots: + +private: + Q_OBJECT + + QListWidget * fileList; + QCheckBox * alignBox; +}; + +} // namespace hdrmerge + +#endif // _LOADOPTIONSDIALOG_H_ diff --git a/LoadSaveOptions.hpp b/LoadSaveOptions.hpp new file mode 100644 index 0000000..9282635 --- /dev/null +++ b/LoadSaveOptions.hpp @@ -0,0 +1,48 @@ +/* + * HDRMerge - HDR exposure merging software. + * Copyright 2012 Javier Celaya + * jcelaya@gmail.com + * + * This file is part of HDRMerge. + * + * HDRMerge is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * HDRMerge is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HDRMerge. If not, see . + * + */ + +#ifndef _LOADSAVEOPTIONS_H_ +#define _LOADSAVEOPTIONS_H_ + +#include +#include + +namespace hdrmerge { + +struct LoadOptions { + std::vector fileNames; + bool align; + LoadOptions() : align(true) {} +}; + + +struct SaveOptions { + int bps; + int previewSize; + std::string fileName; + std::string maskFileName; + SaveOptions() : bps(16), previewSize(0) {} +}; + +} // namespace hdrmerge + +#endif // _LOADSAVEOPTIONS_H_ diff --git a/Log.hpp b/Log.hpp index 057d20b..38c9be0 100644 --- a/Log.hpp +++ b/Log.hpp @@ -24,6 +24,8 @@ #define _LOG_HPP_ #include +#include +#include namespace hdrmerge { @@ -71,6 +73,11 @@ class Log { } }; + +inline std::ostream & operator<<(std::ostream & os, const QString & s) { + return os << std::string(s.toUtf8().constData()); +} + } // namespace hdrmerge #endif // _LOG_HPP_ diff --git a/MainWindow.cpp b/MainWindow.cpp index 85ffaf4..25262da 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -45,6 +45,7 @@ #include "PreviewWidget.hpp" #include "DraggableScrollArea.hpp" #include "DngPropertiesDialog.hpp" +#include "LoadOptionsDialog.hpp" using namespace std; using namespace hdrmerge; @@ -254,40 +255,9 @@ void MainWindow::showEvent(QShowEvent * event) { void MainWindow::loadImages() { - QSettings settings; - QVariant lastDirSetting = settings.value("lastOpenDirectory"); - QString filter(tr("Raw images (" - "*.3fr " - "*.ari *.arw " - "*.bay " - "*.crw *.cr2 *.cap " - "*.dcs *.dcr *.dng *.drf " - "*.eip *.erf " - "*.fff " - "*.iiq " - "*.k25 *.kdc " - "*.mdc *.mef *.mos *.mrw " - "*.nef *.nrw " - "*.obm *.orf " - "*.pef *.ptx *.pxn " - "*.r3d *.raf *.raw *.rwl *.rw2 *.rwz " - "*.sr2 *.srf *.srw " - "*.x3f" - ")")); - QStringList files = QFileDialog::getOpenFileNames(this, tr("Open raw images"), - lastDirSetting.isNull() ? QDir::currentPath() : QDir(lastDirSetting.toString()).absolutePath(), - filter, NULL, QFileDialog::DontUseNativeDialog); - if (!files.empty()) { - // Save last dir - QString lastDir = QDir(files.front()).absolutePath(); - lastDir.truncate(lastDir.lastIndexOf('/')); - settings.setValue("lastOpenDirectory", lastDir); - LoadOptions options; - unsigned int numImages = files.size(); - for (int i = 0; i < numImages; ++i) { - options.fileNames.push_back(QDir::toNativeSeparators(files[i]).toLocal8Bit().constData()); - } - loadImages(options); + LoadOptionsDialog lod; + if (lod.exec()) { + loadImages(lod); } shiftPressed = controlPressed = false; dragToolAction->trigger(); From 3ba4a4d7a01e545254874c957ab69ab0d7456429 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 15:43:09 +0100 Subject: [PATCH 17/26] US32: Translate texts --- LoadOptionsDialog.cpp | 4 ++-- hdrmerge_es.ts | 39 +++++++++++++++++++++++++++++++-------- 2 files changed, 33 insertions(+), 10 deletions(-) diff --git a/LoadOptionsDialog.cpp b/LoadOptionsDialog.cpp index f1895ef..b9e1302 100644 --- a/LoadOptionsDialog.cpp +++ b/LoadOptionsDialog.cpp @@ -54,7 +54,7 @@ LoadOptionsDialog::LoadOptionsDialog(QWidget * parent, Qt::WindowFlags f) connect(addButton, SIGNAL(clicked(bool)), this, SLOT(addFiles())); connect(removeButton, SIGNAL(clicked(bool)), this, SLOT(removeFiles())); - alignBox = new QCheckBox(tr("Align source images"), this); + alignBox = new QCheckBox(tr("Align source images."), this); alignBox->setChecked(true); layout->addWidget(alignBox, 0); @@ -70,7 +70,7 @@ LoadOptionsDialog::LoadOptionsDialog(QWidget * parent, Qt::WindowFlags f) layout->addWidget(buttons, 0, Qt::AlignHCenter); setLayout(layout); - setWindowTitle(tr("Load raw images")); + setWindowTitle(tr("Open raw images")); addFiles(); } diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index 524a8ed..f59a641 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -122,6 +122,37 @@ Acerca de HDRMerge... + + hdrmerge::LoadOptionsDialog + + Add + Añadir + + + Remove + Borrar + + + Align source images. + Alinear imágenes. + + + Accept + Aceptar + + + Cancel + Cancelar + + + Raw images (*.3fr *.ari *.arw *.bay *.crw *.cr2 *.cap *.dcs *.dcr *.dng *.drf *.eip *.erf *.fff *.iiq *.k25 *.kdc *.mdc *.mef *.mos *.mrw *.nef *.nrw *.obm *.orf *.pef *.ptx *.pxn *.r3d *.raf *.raw *.rwl *.rw2 *.rwz *.sr2 *.srf *.srw *.x3f) + Images raw (*.3fr *.ari *.arw *.bay *.crw *.cr2 *.cap *.dcs *.dcr *.dng *.drf *.eip *.erf *.fff *.iiq *.k25 *.kdc *.mdc *.mef *.mos *.mrw *.nef *.nrw *.obm *.orf *.pef *.ptx *.pxn *.r3d *.raf *.raw *.rwl *.rw2 *.rwz *.sr2 *.srf *.srw *.x3f) + + + Open raw images + Abrir imágenes raw + + hdrmerge::DngPropertiesDialog @@ -235,14 +266,6 @@ &Help Ay&uda - - Raw images (*.3fr *.ari *.arw *.bay *.crw *.cr2 *.cap *.dcs *.dcr *.dng *.drf *.eip *.erf *.fff *.iiq *.k25 *.kdc *.mdc *.mef *.mos *.mrw *.nef *.nrw *.obm *.orf *.pef *.ptx *.pxn *.r3d *.raf *.raw *.rwl *.rw2 *.rwz *.sr2 *.srf *.srw *.x3f) - Images raw (*.3fr *.ari *.arw *.bay *.crw *.cr2 *.cap *.dcs *.dcr *.dng *.drf *.eip *.erf *.fff *.iiq *.k25 *.kdc *.mdc *.mef *.mos *.mrw *.nef *.nrw *.obm *.orf *.pef *.ptx *.pxn *.r3d *.raf *.raw *.rwl *.rw2 *.rwz *.sr2 *.srf *.srw *.x3f) - - - Open raw images - Abrir imágenes raw - Unable to open file %1. No se pudo abrir el fichero %1. From ee4fc9a3d50c05072172064f0700946b43505a61 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Wed, 14 May 2014 20:43:46 +0100 Subject: [PATCH 18/26] US38: Move edit actions to EditableMask. - Renamed MergeMap as EditableMask. Renamed anything called *index* to *mask*. - Move DngFloatWriter::buildIndexImage to EditableMask::writeMaskImage. - Move EditAction, undo and redo from PreviewWidget to EditableMask. - Fix Bitmap::applyRowMask, with a buffer overflow under certain situations. - Fix Image::relativeExposure to use all the common area between two images. - Fix ImageStack::align to align images from least to most exposed. - Renamed ImageStack::findIntersetion as ImageStack::crop, because it crops the image to the optimal size. Otherwise, the active area is the least exposed image. - Add checkbox to LoadOptionsDialog to crop the final image. - Fix Render, to clip negative values. --- Bitmap.cpp | 3 +- CMakeLists.txt | 2 +- DngFloatWriter.cpp | 28 +--- DngFloatWriter.hpp | 6 - DngPropertiesDialog.cpp | 50 +++---- DngPropertiesDialog.hpp | 17 ++- MergeMap.cpp => EditableMask.cpp | 128 +++++++++++++++--- MergeMap.hpp => EditableMask.hpp | 54 ++++++-- Image.cpp | 24 +++- Image.hpp | 2 +- ImageStack.cpp | 28 ++-- ImageStack.hpp | 24 ++-- LoadOptionsDialog.cpp | 12 ++ LoadOptionsDialog.hpp | 6 +- LoadSaveOptions.hpp | 3 +- MainWindow.cpp | 2 +- PreviewWidget.cpp | 72 ++-------- PreviewWidget.hpp | 9 -- Renderer.cpp | 3 +- hdrmerge_es.ts | 4 + test/CMakeLists.txt | 2 +- ...{testMergeMap.cpp => testEditableMask.cpp} | 6 +- 22 files changed, 277 insertions(+), 208 deletions(-) rename MergeMap.cpp => EditableMask.cpp (53%) rename MergeMap.hpp => EditableMask.hpp (55%) rename test/{testMergeMap.cpp => testEditableMask.cpp} (93%) diff --git a/Bitmap.cpp b/Bitmap.cpp index 7bad744..a74b793 100644 --- a/Bitmap.cpp +++ b/Bitmap.cpp @@ -101,7 +101,8 @@ void Bitmap::applyRowMask(int dx) { bits[padiv] &= amask; for (size_t i = padiv + 1; i < pbdiv; ++i) bits[i] &= 0; - bits[pbdiv] &= bmask; + if (pbdiv < size) + bits[pbdiv] &= bmask; } } } diff --git a/CMakeLists.txt b/CMakeLists.txt index ffe7c00..261aec4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,7 +45,7 @@ include_directories("${PROJECT_BINARY_DIR}") # Sources and headers set(hdrmerge_sources Launcher.cpp MainWindow.cpp PreviewWidget.cpp DraggableScrollArea.cpp DngPropertiesDialog.cpp LoadOptionsDialog.cpp - Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp MergeMap.cpp DngFloatWriter.cpp Renderer.cpp + Image.cpp ImageStack.cpp Bitmap.cpp MetaData.cpp EditableMask.cpp DngFloatWriter.cpp Renderer.cpp camxyz.cpp TiffDirectory.cpp) set(hdrmerge_qobject_headers MainWindow.hpp PreviewWidget.hpp LoadOptionsDialog.hpp DraggableScrollArea.hpp AboutDialog.hpp DngPropertiesDialog.hpp) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 6a5f072..5e5a48b 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -121,8 +121,6 @@ void DngFloatWriter::write(const string & filename) { file.seekp(dataOffset); progress.advance(75, "Writing output"); - if (!indexFile.isEmpty()) - buildIndexImage(); writePreviews(); writeRawData(); file.seekp(0); @@ -292,24 +290,6 @@ void DngFloatWriter::createPreviewIFD() { } -void DngFloatWriter::buildIndexImage() { - size_t width = stack.getWidth(), height = stack.getHeight(); - QImage indexImage(width, height, QImage::Format_Indexed8); - int numColors = stack.size() - 1; - for (int c = 0; c < numColors; ++c) { - int gray = (256 * c) / numColors; - indexImage.setColor(c, qRgb(gray, gray, gray)); - } - indexImage.setColor(numColors, qRgb(255, 255, 255)); - for (size_t row = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col) { - indexImage.setPixel(col, row, stack.getImageAt(col, row)); - } - } - indexImage.save(indexFile); -} - - void DngFloatWriter::renderPreviews() { Renderer r(rawData.get(), width, height, stack.getImage(0).getMetaData()); r.process(); @@ -492,14 +472,14 @@ static void compressFloats(Bytef * dst, int tileWidth, int bytesps) { if (bytesps == 2) { uint16_t * dst16 = (uint16_t *) dst; uint32_t * dst32 = (uint32_t *) dst; - for (int index = 0; index < tileWidth; ++index) { - dst16[index] = DNG_FloatToHalf(dst32[index]); + for (int i = 0; i < tileWidth; ++i) { + dst16[i] = DNG_FloatToHalf(dst32[i]); } } else if (bytesps == 3) { uint8_t * dst8 = (uint8_t *) dst; uint32_t * dst32 = (uint32_t *) dst; - for (int index = 0; index < tileWidth; ++index) { - DNG_FloatToFP24(dst32[index], dst8); + for (int i = 0; i < tileWidth; ++i) { + DNG_FloatToFP24(dst32[i], dst8); dst8 += 3; } } diff --git a/DngFloatWriter.hpp b/DngFloatWriter.hpp index 68d6a90..4f43d70 100644 --- a/DngFloatWriter.hpp +++ b/DngFloatWriter.hpp @@ -45,13 +45,9 @@ class DngFloatWriter { void setBitsPerSample(int b) { bps = b; } - void setIndexFileName(const QString & name) { - indexFile = name; - } void write(const std::string & filename); private: - ProgressIndicator & progress; std::ofstream file; const ImageStack & stack; @@ -62,7 +58,6 @@ class DngFloatWriter { std::unique_ptr rawData; uint32_t previewWidth; int bps; - QString indexFile; QImage thumbnail; QImage preview; uint32_t subIFDoffsets[2]; @@ -71,7 +66,6 @@ class DngFloatWriter { void createRawIFD(); void calculateTiles(); void writeRawData(); - void buildIndexImage(); void copyMetadata(const std::string & filename); void renderPreviews(); void writePreviews(); diff --git a/DngPropertiesDialog.cpp b/DngPropertiesDialog.cpp index fe6096c..c0b3959 100644 --- a/DngPropertiesDialog.cpp +++ b/DngPropertiesDialog.cpp @@ -63,26 +63,26 @@ DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) connect(previewGroup, SIGNAL(buttonClicked( int)), this, SLOT(setPreviewSize(int))); previewSize = 2; - QCheckBox * saveIndexFile = new QCheckBox(tr("Save"), this); - - indexFileSelector = new QWidget(this); - QHBoxLayout * indexFileSelectorLayout = new QHBoxLayout(indexFileSelector); - indexFileSelectorLayout->setMargin(0); - indexFileEditor = new QLineEdit(indexFileSelector); - indexFileEditor->setMinimumWidth(200); - QPushButton * showFileDialog = new QPushButton("...", indexFileSelector); - connect(showFileDialog, SIGNAL(clicked(bool)), this, SLOT(setIndexFileName())); - indexFileSelectorLayout->addWidget(indexFileEditor); - indexFileSelectorLayout->addWidget(showFileDialog); - connect(saveIndexFile, SIGNAL(stateChanged(int)), this, SLOT(setIndexFileSelectorEnabled(int))); - indexFileSelector->setEnabled(false); + QCheckBox * saveMaskFile = new QCheckBox(tr("Save"), this); + + maskFileSelector = new QWidget(this); + QHBoxLayout * maskFileSelectorLayout = new QHBoxLayout(maskFileSelector); + maskFileSelectorLayout->setMargin(0); + maskFileEditor = new QLineEdit(maskFileSelector); + maskFileEditor->setMinimumWidth(200); + QPushButton * showFileDialog = new QPushButton("...", maskFileSelector); + connect(showFileDialog, SIGNAL(clicked(bool)), this, SLOT(setMaskFileName())); + maskFileSelectorLayout->addWidget(maskFileEditor); + maskFileSelectorLayout->addWidget(showFileDialog); + connect(saveMaskFile, SIGNAL(stateChanged(int)), this, SLOT(setMaskFileSelectorEnabled(int))); + maskFileSelector->setEnabled(false); QWidget * formWidget = new QWidget(this); QFormLayout * formLayout = new QFormLayout(formWidget); formLayout->addRow(tr("Bits per sample:"), bpsSelector); formLayout->addRow(tr("Preview size:"), previewSelector); - formLayout->addRow(tr("Mask image:"), saveIndexFile); - formLayout->addRow("", indexFileSelector); + formLayout->addRow(tr("Mask image:"), saveMaskFile); + formLayout->addRow("", maskFileSelector); formWidget->setLayout(formLayout); layout->addWidget(formWidget, 1); @@ -103,14 +103,14 @@ DngPropertiesDialog::DngPropertiesDialog(QWidget * parent, Qt::WindowFlags f) void DngPropertiesDialog::accept() { - maskFileName = indexFileSelector->isEnabled() ? - QDir::toNativeSeparators(indexFileEditor->text()).toUtf8().constData() : ""; + maskFileName = maskFileSelector->isEnabled() ? + QDir::toNativeSeparators(maskFileEditor->text()).toUtf8().constData() : ""; QDialog::accept(); } -void DngPropertiesDialog::setBps(int index) { - switch (index) { +void DngPropertiesDialog::setBps(int i) { + switch (i) { case 0: bps = 16; break; case 1: bps = 24; break; case 2: bps = 32; break; @@ -118,20 +118,20 @@ void DngPropertiesDialog::setBps(int index) { } -void DngPropertiesDialog::setPreviewSize(int index) { - previewSize = index; +void DngPropertiesDialog::setPreviewSize(int i) { + previewSize = i; } -void DngPropertiesDialog::setIndexFileName() { +void DngPropertiesDialog::setMaskFileName() { QString file = QFileDialog::getSaveFileName(this, tr("Save DNG file"), "", tr("PNG Images (*.png)"), NULL, QFileDialog::DontUseNativeDialog); - indexFileEditor->setText(file); + maskFileEditor->setText(file); } -void DngPropertiesDialog::setIndexFileSelectorEnabled(int state) { - indexFileSelector->setEnabled(state == 2); +void DngPropertiesDialog::setMaskFileSelectorEnabled(int state) { + maskFileSelector->setEnabled(state == 2); } diff --git a/DngPropertiesDialog.hpp b/DngPropertiesDialog.hpp index e84005b..18f10e1 100644 --- a/DngPropertiesDialog.hpp +++ b/DngPropertiesDialog.hpp @@ -33,27 +33,26 @@ class DngPropertiesDialog : public QDialog, public SaveOptions { public: DngPropertiesDialog(QWidget * parent = 0, Qt::WindowFlags f = 0); - /// Triggered when the dialog is closed void closeEvent(QCloseEvent * event) { reject(); } - void setIndexFileName(const QString & name) { - indexFileEditor->setText(name); + void setMaskFileName(const QString & name) { + maskFileEditor->setText(name); } public slots: virtual void accept(); private slots: - void setBps(int index); - void setPreviewSize(int index); - void setIndexFileName(); - void setIndexFileSelectorEnabled(int state); + void setBps(int i); + void setPreviewSize(int i); + void setMaskFileName(); + void setMaskFileSelectorEnabled(int state); private: Q_OBJECT - QLineEdit * indexFileEditor; - QWidget * indexFileSelector; + QLineEdit * maskFileEditor; + QWidget * maskFileSelector; }; } // namespace hdrmerge diff --git a/MergeMap.cpp b/EditableMask.cpp similarity index 53% rename from MergeMap.cpp rename to EditableMask.cpp index 765b6af..27bb4f0 100644 --- a/MergeMap.cpp +++ b/EditableMask.cpp @@ -22,23 +22,49 @@ #include #include -#include "MergeMap.hpp" +#include +#include "EditableMask.hpp" #include "ImageStack.hpp" +#include "Log.hpp" using namespace hdrmerge; -void MergeMap::generateFrom(const ImageStack & images) { +void EditableMask::writeMaskImage(const std::string & maskFile) { + QImage maskImage(width, height, QImage::Format_Indexed8); + int numColors = numLayers - 1; + for (int c = 0; c < numColors; ++c) { + int gray = (256 * c) / numColors; + maskImage.setColor(c, qRgb(gray, gray, gray)); + } + maskImage.setColor(numColors, qRgb(255, 255, 255)); + for (size_t row = 0, pos = 0; row < height; ++row) { + for (size_t col = 0; col < width; ++col, ++pos) { + maskImage.setPixel(col, row, mask[pos]); + } + } + if (!maskImage.save(QString(maskFile.c_str()))) { + Log::msg(Log::PROGRESS, "Cannot save mask image to ", maskFile); + } +} + + +void EditableMask::generateFrom(const ImageStack & images) { width = images.getWidth(); height = images.getHeight(); + numLayers = images.size(); + editActions.clear(); + nextAction = editActions.end(); size_t size = width*height; - index.reset(new uint8_t[size]); - std::fill_n(index.get(), size, 0); - for (int i = 0; i < images.size() - 1; ++i) { + mask.reset(new uint8_t[size]); + std::unique_ptr tmp(new uint8_t[size]); + std::fill_n(mask.get(), size, 0); + for (int i = 0; i < numLayers - 1; ++i) { + std::copy_n(mask.get(), size, tmp.get()); const Image & img = images.getImage(i); for (size_t row = 0, pos = 0; row < height; ++row) { for (size_t col = 0; col < width; ++col, ++pos) { - if (index[pos] == i && img.isSaturated(col, row)) { - ++index[pos]; + if (tmp[pos] == i && img.isSaturated(col, row)) { + mask[pos] = i + 1; if (isNotSaturatedAround(img, col, row)) { paintPixels(col, row, 6, i, i + 1); } @@ -49,7 +75,7 @@ void MergeMap::generateFrom(const ImageStack & images) { } -bool MergeMap::isNotSaturatedAround(const Image & img, size_t col, size_t row) const { +bool EditableMask::isNotSaturatedAround(const Image & img, size_t col, size_t row) const { if (row > 0) { if ((col > 0 && !img.isSaturated(col - 1, row - 1)) || !img.isSaturated(col, row - 1) || @@ -72,7 +98,35 @@ bool MergeMap::isNotSaturatedAround(const Image & img, size_t col, size_t row) c } -void MergeMap::paintPixels(int x, int y, size_t radius, uint8_t oldLayer, uint8_t newLayer) { +void EditableMask::startAction(bool add, int layer) { + editActions.erase(nextAction, editActions.end()); + editActions.emplace_back(); + nextAction = editActions.end(); + editActions.back().oldLayer = add ? layer + 1 : layer; + editActions.back().newLayer = add ? layer : layer + 1; +} + + +void EditableMask::paintPixels(int x, int y, size_t radius) { + EditAction & e = editActions.back(); + int r2 = radius * radius; + int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; + int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; + for (int row = ymin, rrow = y + row; row < ymax; ++row, ++rrow) { + for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { + if (row*row + col*col <= r2) { + size_t pos = rrow*width + rcol; + if (mask[pos] == e.oldLayer) { + e.points.push_back({x + col, y + row}); + mask[pos] = e.newLayer; + } + } + } + } +} + + +void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer, int newLayer) { int r2 = radius * radius; int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; @@ -80,8 +134,8 @@ void MergeMap::paintPixels(int x, int y, size_t radius, uint8_t oldLayer, uint8_ for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { if (row*row + col*col <= r2) { size_t pos = rrow*width + rcol; - if (index[pos] == oldLayer) { - index[pos] = newLayer; + if (mask[pos] == oldLayer) { + mask[pos] = newLayer; } } } @@ -89,23 +143,61 @@ void MergeMap::paintPixels(int x, int y, size_t radius, uint8_t oldLayer, uint8_ } -std::unique_ptr MergeMap::blur() const { +EditableMask::Area EditableMask::undo() { + Area result; + if (nextAction != editActions.begin()) { + --nextAction; + result = modifyLayer(nextAction->points, nextAction->oldLayer); + } + return result; +} + + +EditableMask::Area EditableMask::redo() { + Area result; + if (nextAction != editActions.end()) { + result = modifyLayer(nextAction->points, nextAction->newLayer); + ++nextAction; + } + return result; +} + + +EditableMask::Area EditableMask::modifyLayer(const std::list & points, int layer) { + Area a; + a.minx = width + 1; + a.miny = height + 1; + a.maxx = -1; + a.maxy = -1; + for (auto p : points) { + int rcol = p.x, rrow = p.y; + mask[p.y * width + p.x] = layer; + if (p.x < a.minx) a.minx = p.x; + if (p.x > a.maxx) a.maxx = p.x; + if (p.y < a.miny) a.miny = p.y; + if (p.y > a.maxy) a.maxy = p.y; + } + return a; +} + + +std::unique_ptr EditableMask::blur() const { return blur(3); } -std::unique_ptr MergeMap::blur(size_t radius) const { +std::unique_ptr EditableMask::blur(size_t radius) const { BoxBlur b(*this, radius); return b.getResult(); } -MergeMap::BoxBlur::BoxBlur(const MergeMap & src, size_t radius) : m(src) { +EditableMask::BoxBlur::BoxBlur(const EditableMask & src, size_t radius) : m(src) { // From http://blog.ivank.net/fastest-gaussian-blur.html map.reset(new float[m.width*m.height]); tmp.reset(new float[m.width*m.height]); for (size_t i = 0; i < m.width*m.height; ++i) { - map[i] = m.index[i]; + map[i] = m.mask[i]; } size_t hr = std::round(radius*0.39); boxBlur_4(hr); @@ -114,7 +206,7 @@ MergeMap::BoxBlur::BoxBlur(const MergeMap & src, size_t radius) : m(src) { } -void MergeMap::BoxBlur::boxBlur_4(size_t radius) { +void EditableMask::BoxBlur::boxBlur_4(size_t radius) { boxBlurH_4(radius); map.swap(tmp); boxBlurT_4(radius); @@ -122,7 +214,7 @@ void MergeMap::BoxBlur::boxBlur_4(size_t radius) { } -void MergeMap::BoxBlur::boxBlurH_4(size_t r) { +void EditableMask::BoxBlur::boxBlurH_4(size_t r) { float iarr = 1.0 / (r+r+1); for (size_t i = 0; i < m.height; ++i) { size_t ti = i * m.width, li = ti, ri = ti + r; @@ -146,7 +238,7 @@ void MergeMap::BoxBlur::boxBlurH_4(size_t r) { } -void MergeMap::BoxBlur::boxBlurT_4(size_t r) { +void EditableMask::BoxBlur::boxBlurT_4(size_t r) { float iarr = 1.0 / (r+r+1); for (size_t i = 0; i < m.width; ++i) { size_t ti = i, li = ti, ri = ti + r*m.width; diff --git a/MergeMap.hpp b/EditableMask.hpp similarity index 55% rename from MergeMap.hpp rename to EditableMask.hpp index af6802e..04dd2e3 100644 --- a/MergeMap.hpp +++ b/EditableMask.hpp @@ -20,42 +20,56 @@ * */ -#ifndef _MERGEMAP_HPP_ -#define _MERGEMAP_HPP_ +#ifndef _EDITABLEMASK_HPP_ +#define _EDITABLEMASK_HPP_ #include #include +#include +#include namespace hdrmerge { class ImageStack; class Image; -class MergeMap { +class EditableMask { public: - MergeMap() {} - MergeMap(size_t w, size_t h) : width(w), height(h), index(new uint8_t[w*h]) {} + EditableMask() : numLayers(1), nextAction(editActions.end()) {} + EditableMask(size_t w, size_t h) : numLayers(1), nextAction(editActions.end()), + width(w), height(h), mask(new uint8_t[w*h]) {} + + struct Area { + int minx, miny, maxx, maxy; + Area() : minx(0), miny(0), maxx(0), maxy(0) {} + }; void generateFrom(const ImageStack & images); - uint8_t operator[](size_t i) const { - return index[i]; + uint8_t getImageAt(size_t col, size_t row) const { + return mask[row*width + col]; } uint8_t & operator[](size_t i) { - return index[i]; + return mask[i]; } + void startAction(bool add, int layer); + void paintPixels(int x, int y, size_t radius); + Area undo(); + Area redo(); std::unique_ptr blur() const; std::unique_ptr blur(size_t radius) const; + void writeMaskImage(const std::string & maskFile); + private: class BoxBlur { public: - BoxBlur(const MergeMap & src, size_t radius); + BoxBlur(const EditableMask & src, size_t radius); std::unique_ptr && getResult() { return std::move(map); } private: - const MergeMap & m; + const EditableMask & m; void boxBlur_4(size_t radius); void boxBlurH_4(size_t radius); void boxBlurT_4(size_t radius); @@ -63,13 +77,25 @@ class MergeMap { }; friend class BoxBlur; - void paintPixels(int x, int y, size_t radius, uint8_t oldLayer, uint8_t newLayer); - bool isNotSaturatedAround(const Image & img, size_t col, size_t row) const; + struct Point { + int x, y; + }; + struct EditAction { + int oldLayer, newLayer; + std::list points; + }; size_t width, height; - std::unique_ptr index; + std::unique_ptr mask; + int numLayers; + std::list editActions; + std::list::iterator nextAction; + + bool isNotSaturatedAround(const Image & img, size_t col, size_t row) const; + Area modifyLayer(const std::list & points, int oldayer); + void paintPixels(int x, int y, size_t radius, int oldLayer, int newLayer); }; } // namespace hdrmerge -#endif // _MERGEMAP_HPP_ +#endif // _EDITABLEMASK_HPP_ diff --git a/Image.cpp b/Image.cpp index 7e82f79..97dd25a 100644 --- a/Image.cpp +++ b/Image.cpp @@ -24,6 +24,7 @@ #include "Image.hpp" #include "Bitmap.hpp" #include "Histogram.hpp" +#include "Log.hpp" using namespace std; using namespace hdrmerge; @@ -103,16 +104,22 @@ bool Image::isSameFormat(const Image & ref) const { } -void Image::relativeExposure(const Image & r, size_t w, size_t h) { +void Image::relativeExposure(const Image & r) { + int reldx = dx - std::max(dx, r.dx); + int relrdx = r.dx - std::max(dx, r.dx); + int w = width + reldx + relrdx; + int reldy = dy - std::max(dy, r.dy); + int relrdy = r.dy - std::max(dy, r.dy); + int h = height + reldy + relrdy; // Minimize square error between images: // min. C(n) = sum(n*f(x) - g(x))^2 -> n = sum(f(x)*g(x)) / sum(f(x)^2) double numerator = 0, denom = 0, threshold = max * 0.9; - for (size_t y = 0; y < h; ++y) { - for (size_t x = 0; x < w; ++x) { - size_t pos = (y - dy) * width - dx + x; + for (int y = 0; y < h; ++y) { + for (int x = 0; x < w; ++x) { + int pos = (y - reldy) * width - reldx + x; double v = rawPixels[pos]; if (v > 0 && v < threshold) { - size_t rpos = (y - r.dy) * width - r.dx + x; + int rpos = (y - relrdy) * width - relrdx + x; double nv = r.rawPixels[rpos]; numerator += v * nv; denom += v * v; @@ -135,8 +142,8 @@ void Image::alignWith(const Image & r) { size_t minError = curWidth*curHeight; Histogram hist1(r.scaled[s].get(), r.scaled[s].get() + curWidth*curHeight); Histogram hist2(scaled[s].get(), scaled[s].get() + curWidth*curHeight); - uint16_t mth1 = hist1.getPercentile(r.halfLightPercent); - uint16_t mth2 = hist2.getPercentile(r.halfLightPercent); + uint16_t mth1 = hist1.getPercentile(halfLightPercent); + uint16_t mth2 = hist2.getPercentile(halfLightPercent); Bitmap mtb1(curWidth, curHeight), mtb2(curWidth, curHeight), excl1(curWidth, curHeight), excl2(curWidth, curHeight); mtb1.mtb(r.scaled[s].get(), mth1); @@ -163,6 +170,9 @@ void Image::alignWith(const Image & r) { dx <<= 1; dy <<= 1; } + dx += r.dx; + dy += r.dy; + Log::msg(Log::DEBUG, "Image ", metaData->fileName, " displaced to (", dx, ", ", dy, ")"); } diff --git a/Image.hpp b/Image.hpp index 61ef0f6..208f283 100644 --- a/Image.hpp +++ b/Image.hpp @@ -75,7 +75,7 @@ class Image { dx += newDx; dy += newDy; } - void relativeExposure(const Image & nextImage, size_t w, size_t h); + void relativeExposure(const Image & nextImage); static bool comparePointers(const std::unique_ptr & l, const std::unique_ptr & r) { return l->brightness > r->brightness; diff --git a/ImageStack.cpp b/ImageStack.cpp index 11ee967..91f0ab3 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -23,6 +23,7 @@ #include #include "ImageStack.hpp" #include "DngFloatWriter.hpp" +#include "Log.hpp" using namespace std; using namespace hdrmerge; @@ -66,9 +67,12 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) if (options.align) { progress.advance(p += step, "Aligning"); align(); + //if (options.crop) { + crop(); + //} } computeRelExposures(); - imageIndex.generateFrom(*this); + mask.generateFrom(*this); progress.advance(100, "Done loading!"); return 0; } @@ -78,28 +82,26 @@ int ImageStack::save(const SaveOptions & options, ProgressIndicator & progress) DngFloatWriter writer(*this, progress); writer.setBitsPerSample(options.bps); writer.setPreviewWidth((options.previewSize * width) / 2); - writer.setIndexFileName(options.maskFileName.c_str()); writer.write(options.fileName); + if (!options.maskFileName.empty()) { + Log::msg(Log::DEBUG, "Saving mask to ", options.maskFileName); + mask.writeMaskImage(options.maskFileName); + } } void ImageStack::align() { if (images.size() > 1) { - int dx = 0, dy = 0; - for (auto cur = images.begin(), prev = cur++; cur != images.end(); prev = cur++) { - dx = (*prev)->getDeltaX(); - dy = (*prev)->getDeltaY(); - (*cur)->alignWith(**prev); - (*cur)->displace(dx, dy); + for (auto cur = images.rbegin(), next = cur++; cur != images.rend(); next = cur++) { + (*cur)->alignWith(**next); } for (auto & i : images) { i->releaseAlignData(); } - findIntersection(); } } -void ImageStack::findIntersection() { +void ImageStack::crop() { int dx = 0, dy = 0; for (auto & i : images) { int newDx = max(dx, i->getDeltaX()); @@ -119,19 +121,19 @@ void ImageStack::findIntersection() { void ImageStack::computeRelExposures() { for (auto cur = images.rbegin(), next = cur++; cur != images.rend(); next = cur++) { - (*cur)->relativeExposure(**next, width, height); + (*cur)->relativeExposure(**next); } } double ImageStack::value(size_t x, size_t y) const { - Image & img = *images[getImageAt(x, y)]; + Image & img = *images[mask.getImageAt(x, y)]; return img.exposureAt(x, y); } void ImageStack::compose(float * dst) const { - unique_ptr map = imageIndex.blur(); + unique_ptr map = mask.blur(); const MetaData & md = images.front()->getMetaData(); int imageMax = images.size() - 1; float max = 0.0; diff --git a/ImageStack.hpp b/ImageStack.hpp index 28b7b8b..be9f3a2 100644 --- a/ImageStack.hpp +++ b/ImageStack.hpp @@ -29,7 +29,7 @@ #include #include "Image.hpp" #include "ProgressIndicator.hpp" -#include "MergeMap.hpp" +#include "EditableMask.hpp" #include "LoadSaveOptions.hpp" namespace hdrmerge { @@ -41,9 +41,10 @@ class ImageStack { int load(const LoadOptions & options, ProgressIndicator & progress); int save(const SaveOptions & options, ProgressIndicator & progress); void align(); + void crop(); void computeRelExposures(); - void generateImageIndex() { - imageIndex.generateFrom(*this); + void generateMask() { + mask.generateFrom(*this); } size_t size() const { return images.size(); } @@ -66,26 +67,21 @@ class ImageStack { bool addImage(std::unique_ptr & i); std::string buildOutputFileName() const; double value(size_t x, size_t y) const; - int getImageAt(size_t x, size_t y) const { - return imageIndex[y*width + x]; - } - void setImageAt(size_t x, size_t y, int i) { - imageIndex[y*width + x] = i; - } void compose(float * dst) const; void setGamma(float g); uint8_t toneMap(double v) { return toneCurve[(int)std::floor(v)]; } + EditableMask & getMask() { + return mask; + } private: std::vector> images; ///< Images, from most to least exposed - MergeMap imageIndex; - size_t width; ///< Size of a row - size_t height; ///< Size of a column + EditableMask mask; + size_t width; + size_t height; uint8_t toneCurve[65536]; - - void findIntersection(); }; } // namespace hdrmerge diff --git a/LoadOptionsDialog.cpp b/LoadOptionsDialog.cpp index b9e1302..c3d5550 100644 --- a/LoadOptionsDialog.cpp +++ b/LoadOptionsDialog.cpp @@ -58,6 +58,10 @@ LoadOptionsDialog::LoadOptionsDialog(QWidget * parent, Qt::WindowFlags f) alignBox->setChecked(true); layout->addWidget(alignBox, 0); + cropBox = new QCheckBox(tr("Crop result image to optimal size."), this); + cropBox->setChecked(true); + layout->addWidget(cropBox, 0); + QWidget * buttons = new QWidget(this); QHBoxLayout * buttonsLayout = new QHBoxLayout(buttons); QPushButton * acceptButton = new QPushButton(tr("Accept"), this); @@ -75,6 +79,13 @@ LoadOptionsDialog::LoadOptionsDialog(QWidget * parent, Qt::WindowFlags f) } +void LoadOptionsDialog::showEvent(QShowEvent * event) { + if (fileList->count() == 0) { + QMetaObject::invokeMethod(this, "reject", Qt::QueuedConnection); + } +} + + class FileItem : public QListWidgetItem { public: FileItem(const QString & filename, QListWidget * parent) : QListWidgetItem(parent, 1000) { @@ -131,6 +142,7 @@ void LoadOptionsDialog::removeFiles() { void LoadOptionsDialog::accept() { align = alignBox->isChecked(); + crop = cropBox->isChecked(); for (int i = 0; i < fileList->count(); ++i) { fileNames.push_back(fileList->item(i)->data(Qt::UserRole).toString().toUtf8().constData()); } diff --git a/LoadOptionsDialog.hpp b/LoadOptionsDialog.hpp index b1833b0..019f083 100644 --- a/LoadOptionsDialog.hpp +++ b/LoadOptionsDialog.hpp @@ -41,13 +41,15 @@ public slots: void addFiles(); void removeFiles(); -private slots: - +protected: + virtual void showEvent(QShowEvent * event); + private: Q_OBJECT QListWidget * fileList; QCheckBox * alignBox; + QCheckBox * cropBox; }; } // namespace hdrmerge diff --git a/LoadSaveOptions.hpp b/LoadSaveOptions.hpp index 9282635..243a4b1 100644 --- a/LoadSaveOptions.hpp +++ b/LoadSaveOptions.hpp @@ -31,7 +31,8 @@ namespace hdrmerge { struct LoadOptions { std::vector fileNames; bool align; - LoadOptions() : align(true) {} + bool crop; + LoadOptions() : align(true), crop(true) {} }; diff --git a/MainWindow.cpp b/MainWindow.cpp index 25262da..4c10941 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -328,7 +328,7 @@ void MainWindow::saveResult() { fileName += ".dng"; } DngPropertiesDialog dpd(this); - dpd.setIndexFileName((images->buildOutputFileName() + "_index.png").c_str()); + dpd.setMaskFileName((images->buildOutputFileName() + "_mask.png").c_str()); if (dpd.exec()) { dpd.fileName = fileName; ProgressDialog pd(this); diff --git a/PreviewWidget.cpp b/PreviewWidget.cpp index 787fb4a..312cc08 100644 --- a/PreviewWidget.cpp +++ b/PreviewWidget.cpp @@ -32,7 +32,7 @@ using namespace hdrmerge; PreviewWidget::PreviewWidget(QWidget * parent) : QWidget(parent), width(0), height(0), flip(0), -addPixels(false), rmPixels(false), layer(0), radius(5), nextAction(editActions.end()) { +addPixels(false), rmPixels(false), layer(0), radius(5) { setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); } @@ -48,8 +48,6 @@ void PreviewWidget::setImageStack(ImageStack * s) { height = stack->getHeight(); } pixmap.reset(); - editActions.clear(); - nextAction = editActions.end(); QtConcurrent::run(this, &PreviewWidget::render, 0, 0, width, height); } @@ -95,7 +93,7 @@ QRgb PreviewWidget::rgb(int col, int row) const { else if (d > 65535) d = 65535; int v = stack->toneMap(d); int v70 = v*7/10; - int color = stack->getImageAt(col, row); + int color = stack->getMask().getImageAt(col, row); QRgb pixel; switch (color) { case 0: @@ -182,73 +180,33 @@ void PreviewWidget::toggleRmPixelsTool(bool toggled) { void PreviewWidget::mousePressEvent(QMouseEvent * event) { if (addPixels || rmPixels) { event->accept(); - editActions.erase(nextAction, editActions.end()); - editActions.emplace_back(); - nextAction = editActions.end(); - editActions.back().oldLayer = addPixels ? layer + 1 : layer; - editActions.back().newLayer = addPixels ? layer : layer + 1; - paintPixels(event->x(), event->y()); + stack->getMask().startAction(addPixels, layer); + int x = event->x(), y = event->y(); + rotate(x, y); + stack->getMask().paintPixels(x, y, radius); + render(x - radius, y - radius, x + radius + 1, y + radius + 1); } else event->ignore(); } void PreviewWidget::mouseMoveEvent(QMouseEvent * event) { if (addPixels || rmPixels) { event->accept(); - paintPixels(event->x(), event->y()); + int x = event->x(), y = event->y(); + rotate(x, y); + stack->getMask().paintPixels(x, y, radius); + render(x - radius, y - radius, x + radius + 1, y + radius + 1); } else event->ignore(); } -void PreviewWidget::paintPixels(int x, int y) { - if (!stack.get()) return; - EditAction & e = editActions.back(); - int r2 = radius * radius; - int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; - int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; - for (int row = ymin; row < ymax; ++row) { - for (int col = xmin; col < xmax; ++col) { - if (row*row + col*col <= r2) { - size_t pos = (y + row)*width + (x + col); - int rcol = x + col, rrow = y + row; - rotate(rcol, rrow); - if (stack->getImageAt(rcol, rrow) == e.oldLayer) { - e.points.push_back(QPoint(x + col, y + row)); - stack->setImageAt(rcol, rrow, e.newLayer); - } - } - } - } - render(x - radius, y - radius, x + radius + 1, y + radius + 1); -} - - -void PreviewWidget::modifyLayer(const std::list & points, int layer) { - int minx = width + 1, miny = height + 1, maxx = -1, maxy = -1; - for (auto p : points) { - int rcol = p.x(), rrow = p.y(); - rotate(rcol, rrow); - stack->setImageAt(rcol, rrow, layer); - if (p.x() < minx) minx = p.x(); - if (p.x() > maxx) maxx = p.x(); - if (p.y() < miny) miny = p.y(); - if (p.y() > maxy) maxy = p.y(); - } - render(minx, miny, maxx + 1, maxy + 1); -} - - void PreviewWidget::undo() { - if (nextAction != editActions.begin()) { - --nextAction; - modifyLayer(nextAction->points, nextAction->oldLayer); - } + EditableMask::Area a = stack->getMask().undo(); + render(a.minx, a.miny, a.maxx + 1, a.maxy + 1); } void PreviewWidget::redo() { - if (nextAction != editActions.end()) { - modifyLayer(nextAction->points, nextAction->newLayer); - ++nextAction; - } + EditableMask::Area a = stack->getMask().redo(); + render(a.minx, a.miny, a.maxx + 1, a.maxy + 1); } diff --git a/PreviewWidget.hpp b/PreviewWidget.hpp index 2625b7d..7f28b89 100644 --- a/PreviewWidget.hpp +++ b/PreviewWidget.hpp @@ -52,16 +52,10 @@ public slots: private slots: void paintImage(int x, int y, const QImage & image); - void paintPixels(int x, int y); private: Q_OBJECT - struct EditAction { - int oldLayer, newLayer; - std::list points; - }; - std::unique_ptr pixmap; std::unique_ptr stack; size_t width, height; @@ -69,14 +63,11 @@ private slots: bool addPixels, rmPixels; int layer; int radius; - std::list editActions; - std::list::iterator nextAction; void render(int minx, int miny, int maxx, int maxy); QRgb rgb(int col, int row) const; QPixmap createCursor(bool plus); void rotate(int & x, int & y) const; - void modifyLayer(const std::list & points, int oldayer); }; } // namespace hdrmerge diff --git a/Renderer.cpp b/Renderer.cpp index 9682e7b..91747a0 100644 --- a/Renderer.cpp +++ b/Renderer.cpp @@ -123,7 +123,8 @@ void Renderer::convertToRgb() { } for(int c = 0; c < 3; ++c) { float v = out[c]; - if (v > 65535.0) v = 65535.0; + if (v > 65535.0f) v = 65535.0f; + else if (v < 0.0f) v = 0.0f; img[c] = v; } } diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index f59a641..6ad1db7 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -136,6 +136,10 @@ Align source images. Alinear imágenes. + + Crop result image to optimal size. + Recortar resultado al tamaño óptimo. + Accept Aceptar diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 807c01d..3413198 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,6 +1,6 @@ include_directories(${Boost_INCLUDE_DIRS}) -set(test_sources testMain.cpp testImageStack.cpp testBitmap.cpp testHistogram.cpp testMergeMap.cpp) +set(test_sources testMain.cpp testImageStack.cpp testBitmap.cpp testHistogram.cpp testEditableMask.cpp) add_executable(hdrmerge-test ${test_sources} $) target_link_libraries(hdrmerge-test ${hdrmerge_libs} ${Boost_LIBRARIES}) diff --git a/test/testMergeMap.cpp b/test/testEditableMask.cpp similarity index 93% rename from test/testMergeMap.cpp rename to test/testEditableMask.cpp index e5d0ebe..da26ef5 100644 --- a/test/testMergeMap.cpp +++ b/test/testEditableMask.cpp @@ -22,19 +22,19 @@ #include #include -#include "../MergeMap.hpp" +#include "../EditableMask.hpp" #include "SampleImage.hpp" #include "time.hpp" #include using namespace hdrmerge; using namespace std; -BOOST_AUTO_TEST_CASE(testMergeMap1) { +BOOST_AUTO_TEST_CASE(testEditableMask) { SampleImage image("test/testMap.png"); size_t size = image.md.width * image.md.height; uint16_t * src = image.pixelData; image.pixelData = new uint16_t[size]; - MergeMap map(image.md.width, image.md.height); + EditableMask map(image.md.width, image.md.height); for (int radius = 1; radius < 25; radius += 3) { for (size_t i = 0; i < size; ++i) { map[i] = src[i]; From dba098107ff9e266dc514b427c36255ffe976f08 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Thu, 15 May 2014 09:22:44 +0100 Subject: [PATCH 19/26] US38: Small optimizations. --- EditableMask.cpp | 8 +++++--- EditableMask.hpp | 2 +- Image.cpp | 14 ++++++++++---- Image.hpp | 8 ++++---- test/time.hpp | 17 ++++++++++++++++- 5 files changed, 36 insertions(+), 13 deletions(-) diff --git a/EditableMask.cpp b/EditableMask.cpp index 27bb4f0..622458b 100644 --- a/EditableMask.cpp +++ b/EditableMask.cpp @@ -26,6 +26,7 @@ #include "EditableMask.hpp" #include "ImageStack.hpp" #include "Log.hpp" +#include "test/time.hpp" using namespace hdrmerge; void EditableMask::writeMaskImage(const std::string & maskFile) { @@ -55,6 +56,7 @@ void EditableMask::generateFrom(const ImageStack & images) { nextAction = editActions.end(); size_t size = width*height; + Timer t("Generate mask"); mask.reset(new uint8_t[size]); std::unique_ptr tmp(new uint8_t[size]); std::fill_n(mask.get(), size, 0); @@ -66,7 +68,7 @@ void EditableMask::generateFrom(const ImageStack & images) { if (tmp[pos] == i && img.isSaturated(col, row)) { mask[pos] = i + 1; if (isNotSaturatedAround(img, col, row)) { - paintPixels(col, row, 6, i, i + 1); + paintPixels(col, row, 6, i); } } } @@ -126,7 +128,7 @@ void EditableMask::paintPixels(int x, int y, size_t radius) { } -void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer, int newLayer) { +void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer) { int r2 = radius * radius; int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; @@ -135,7 +137,7 @@ void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer, int ne if (row*row + col*col <= r2) { size_t pos = rrow*width + rcol; if (mask[pos] == oldLayer) { - mask[pos] = newLayer; + ++mask[pos]; } } } diff --git a/EditableMask.hpp b/EditableMask.hpp index 04dd2e3..8fdc29c 100644 --- a/EditableMask.hpp +++ b/EditableMask.hpp @@ -93,7 +93,7 @@ class EditableMask { bool isNotSaturatedAround(const Image & img, size_t col, size_t row) const; Area modifyLayer(const std::list & points, int oldayer); - void paintPixels(int x, int y, size_t radius, int oldLayer, int newLayer); + void paintPixels(int x, int y, size_t radius, int oldLayer); }; } // namespace hdrmerge diff --git a/Image.cpp b/Image.cpp index 97dd25a..7532da6 100644 --- a/Image.cpp +++ b/Image.cpp @@ -25,6 +25,7 @@ #include "Bitmap.hpp" #include "Histogram.hpp" #include "Log.hpp" +#include "test/time.hpp" using namespace std; using namespace hdrmerge; @@ -42,6 +43,7 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { brightness = 0.0; uint16_t maxPerColor[4] = {0, 0, 0, 0}; rawPixels.reset(new uint16_t[size]); + alignedPixels = rawPixels.get(); for (size_t row = 0, rrow = md->topMargin; row < height; ++row, ++rrow) { for (size_t col = 0, rcol = md->leftMargin; col < width; ++col, ++rcol) { uint16_t v = rawImage[rrow*md->rawWidth + rcol]; @@ -105,22 +107,24 @@ bool Image::isSameFormat(const Image & ref) const { void Image::relativeExposure(const Image & r) { + Timer t("Relative exposure"); int reldx = dx - std::max(dx, r.dx); int relrdx = r.dx - std::max(dx, r.dx); int w = width + reldx + relrdx; int reldy = dy - std::max(dy, r.dy); int relrdy = r.dy - std::max(dy, r.dy); int h = height + reldy + relrdy; + uint16_t * usePixels = &rawPixels[-reldy*width - reldx]; + uint16_t * rusePixels = &r.rawPixels[-relrdy*width - relrdx]; // Minimize square error between images: // min. C(n) = sum(n*f(x) - g(x))^2 -> n = sum(f(x)*g(x)) / sum(f(x)^2) double numerator = 0, denom = 0, threshold = max * 0.9; for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) { - int pos = (y - reldy) * width - reldx + x; - double v = rawPixels[pos]; + int pos = y * width + x; + double v = usePixels[pos]; if (v > 0 && v < threshold) { - int rpos = (y - relrdy) * width - relrdx + x; - double nv = r.rawPixels[rpos]; + double nv = rusePixels[pos]; numerator += v * nv; denom += v * v; } @@ -132,6 +136,7 @@ void Image::relativeExposure(const Image & r) { void Image::alignWith(const Image & r) { + Timer t("Align images"); if (!good() || !r.good()) return; dx = dy = 0; const double tolerance = 1.0/64; @@ -172,6 +177,7 @@ void Image::alignWith(const Image & r) { } dx += r.dx; dy += r.dy; + alignedPixels = &rawPixels[-dy*width - dx]; Log::msg(Log::DEBUG, "Image ", metaData->fileName, " displaced to (", dx, ", ", dy, ")"); } diff --git a/Image.hpp b/Image.hpp index 208f283..8110b2c 100644 --- a/Image.hpp +++ b/Image.hpp @@ -56,12 +56,10 @@ class Image { return dy; } double exposureAt(size_t x, size_t y) const { - x -= dx; y -= dy; - return rawPixels[y*width + x] * relExp; + return alignedPixels[y*width + x] * relExp; } bool isSaturated(size_t x, size_t y) const { - x -= dx; y -= dy; - return rawPixels[y*width + x] >= max; + return alignedPixels[y*width + x] >= max; } double getRelativeExposure() const { return relExp; @@ -74,6 +72,7 @@ class Image { void displace(int newDx, int newDy) { dx += newDx; dy += newDy; + alignedPixels = &rawPixels[-dy*width - dx]; } void relativeExposure(const Image & nextImage); @@ -84,6 +83,7 @@ class Image { private: std::unique_ptr metaData; std::unique_ptr rawPixels; + uint16_t * alignedPixels; size_t width, height; std::unique_ptr[]> scaled; int dx, dy; diff --git a/test/time.hpp b/test/time.hpp index e7349d9..08577ae 100644 --- a/test/time.hpp +++ b/test/time.hpp @@ -21,10 +21,25 @@ */ #include -#include +#include "../Log.hpp" template double measureTime(Func f) { std::clock_t start = std::clock(); f(); return (std::clock() - start) / (double) CLOCKS_PER_SEC; } + +class Timer { +public: + Timer(const char * n) : name(n) { + start = std::clock(); + } + ~Timer() { + double t = (std::clock() - start) / (double) CLOCKS_PER_SEC; + hdrmerge::Log::msg(hdrmerge::Log::DEBUG, name, " = ", t); + } + +private: + std::clock_t start; + const char * name; +}; From d16993f05f75cc64cd6513ab41c95c1e8e58ed4b Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Thu, 15 May 2014 19:43:27 +0100 Subject: [PATCH 20/26] US38: Optimize mask creation. - Optimize the mask creation process to make it faster. - Fix Bitmap::resize to reset the last unused bits. - Add a saturation threshold 1% lower than max value. - Add time measurement methods to Log.hpp - Fix tests that have changed since last commit. --- Bitmap.cpp | 38 +++++++++++++++------------------ Bitmap.hpp | 2 +- EditableMask.cpp | 26 ++++++++++------------ Image.cpp | 2 +- Image.hpp | 3 ++- Log.hpp | 21 ++++++++++++++++++ test/SampleImage.hpp | 17 +++++++++++++-- test/testBitmap.cpp | 1 - test/testEditableMask.cpp | 6 +++--- test/testImageStack.cpp | 26 +++++++++++----------- test/testMain.cpp | 8 +++++++ test/time.hpp | 45 --------------------------------------- 12 files changed, 92 insertions(+), 103 deletions(-) delete mode 100644 test/time.hpp diff --git a/Bitmap.cpp b/Bitmap.cpp index a74b793..646b7be 100644 --- a/Bitmap.cpp +++ b/Bitmap.cpp @@ -56,6 +56,7 @@ void Bitmap::resize(size_t w, size_t h) { size_t extra = numBits & 31 ? 1 : 0; size = (numBits >> 5) + extra; bits.reset(new uint32_t[size]); + bits[size-1] &= allOnes >> (32 - (numBits & 31)); } @@ -76,7 +77,6 @@ void Bitmap::shift(const Bitmap & src, int dx, int dy) { } bits[size-1] &= allOnes >> (32 - (numBits & 31)); applyRowMask(dx); - dumpFile(); } @@ -112,7 +112,6 @@ void Bitmap::bitwiseXor(const Bitmap & r) { for (size_t i = 0; i < size; ++i) { bits[i] ^= r.bits[i]; } - dumpFile(); } @@ -120,7 +119,6 @@ void Bitmap::bitwiseAnd(const Bitmap & r) { for (size_t i = 0; i < size; ++i) { bits[i] &= r.bits[i]; } - dumpFile(); } @@ -130,7 +128,6 @@ void Bitmap::mtb(const uint16_t * pixels, uint16_t mth) { p.set(pixels[i++] > mth); } bits[size-1] &= allOnes >> (32 - (numBits & 31)); - dumpFile(); } @@ -142,7 +139,6 @@ void Bitmap::exclusion(const uint16_t * pixels, uint16_t mth, uint16_t tolerance ++i; } bits[size-1] &= allOnes >> (32 - (numBits & 31)); - dumpFile(); } @@ -160,28 +156,28 @@ size_t Bitmap::count() const { std::string Bitmap::dumpInfo() { std::ostringstream oss; + iterator it = position(0, 0); + int height = numBits / rowWidth; + for (int row = 0; row < height; ++row) { + for (int col = 0; col < rowWidth; ++col, ++it) { + oss << (it.get() ? '1' : '0'); + } + oss << std::endl; + } + return oss.str(); +} + +void Bitmap::dumpFile(const std::string & fileName) { + std::ofstream of(fileName); + of << "P1\n# Foo\n" << rowWidth << " " << (numBits/rowWidth) << "\n"; size_t tb = 0; for (size_t i = 0; i < size; ++i) { uint32_t value = bits[i]; for (int b = 0; tb < numBits && b < 32; ++tb, ++b) { - oss << (value % 2); + of << ' ' << (value % 2); value >>= 1; } + of << "\n"; } - return oss.str(); -} - -void Bitmap::dumpFile() { -// std::ofstream of("bitmap.pbm"); -// of << "P1\n# Foo\n" << rowWidth << " " << (numBits/rowWidth) << "\n"; -// size_t tb = 0; -// for (size_t i = 0; i < size; ++i) { -// uint32_t value = bits[i]; -// for (int b = 0; tb < numBits && b < 32; ++tb, ++b) { -// of << ' ' << (value % 2); -// value >>= 1; -// } -// of << "\n"; -// } } diff --git a/Bitmap.hpp b/Bitmap.hpp index b5a4621..598f182 100644 --- a/Bitmap.hpp +++ b/Bitmap.hpp @@ -108,7 +108,7 @@ class Bitmap { void resize(size_t w, size_t h); std::string dumpInfo(); - void dumpFile(); + void dumpFile(const std::string & fileName); private: static const int ones[256]; diff --git a/EditableMask.cpp b/EditableMask.cpp index 622458b..8bf2689 100644 --- a/EditableMask.cpp +++ b/EditableMask.cpp @@ -26,7 +26,6 @@ #include "EditableMask.hpp" #include "ImageStack.hpp" #include "Log.hpp" -#include "test/time.hpp" using namespace hdrmerge; void EditableMask::writeMaskImage(const std::string & maskFile) { @@ -58,18 +57,15 @@ void EditableMask::generateFrom(const ImageStack & images) { Timer t("Generate mask"); mask.reset(new uint8_t[size]); - std::unique_ptr tmp(new uint8_t[size]); std::fill_n(mask.get(), size, 0); - for (int i = 0; i < numLayers - 1; ++i) { - std::copy_n(mask.get(), size, tmp.get()); - const Image & img = images.getImage(i); - for (size_t row = 0, pos = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col, ++pos) { - if (tmp[pos] == i && img.isSaturated(col, row)) { - mask[pos] = i + 1; - if (isNotSaturatedAround(img, col, row)) { - paintPixels(col, row, 6, i); - } + for (size_t row = 0, pos = 0; row < height; ++row) { + for (size_t col = 0; col < width; ++col, ++pos) { + int i = mask[pos]; + while (i < numLayers - 1 && images.getImage(i).isSaturated(col, row)) ++i; + if (mask[pos] < i) { + mask[pos] = i; + if (isNotSaturatedAround(images.getImage(i - 1), col, row)) { + paintPixels(col, row, 6, i); } } } @@ -128,7 +124,7 @@ void EditableMask::paintPixels(int x, int y, size_t radius) { } -void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer) { +void EditableMask::paintPixels(int x, int y, size_t radius, int l) { int r2 = radius * radius; int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; @@ -136,8 +132,8 @@ void EditableMask::paintPixels(int x, int y, size_t radius, int oldLayer) { for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { if (row*row + col*col <= r2) { size_t pos = rrow*width + rcol; - if (mask[pos] == oldLayer) { - ++mask[pos]; + if (mask[pos] < l) { + mask[pos] = l; } } } diff --git a/Image.cpp b/Image.cpp index 7532da6..a2659d1 100644 --- a/Image.cpp +++ b/Image.cpp @@ -25,7 +25,6 @@ #include "Bitmap.hpp" #include "Histogram.hpp" #include "Log.hpp" -#include "test/time.hpp" using namespace std; using namespace hdrmerge; @@ -64,6 +63,7 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { brightness /= size; subtractBlack(); metaData->max = max; + satThreshold = 0.99*max; preScale(); computeHalfLightPercentile(); metaData->dumpInfo(); diff --git a/Image.hpp b/Image.hpp index 8110b2c..bb865b3 100644 --- a/Image.hpp +++ b/Image.hpp @@ -59,7 +59,7 @@ class Image { return alignedPixels[y*width + x] * relExp; } bool isSaturated(size_t x, size_t y) const { - return alignedPixels[y*width + x] >= max; + return alignedPixels[y*width + x] >= satThreshold; } double getRelativeExposure() const { return relExp; @@ -88,6 +88,7 @@ class Image { std::unique_ptr[]> scaled; int dx, dy; uint16_t max; + uint16_t satThreshold; double brightness; double relExp; ///< Relative exposure, from data double halfLightPercent; diff --git a/Log.hpp b/Log.hpp index 38c9be0..e235516 100644 --- a/Log.hpp +++ b/Log.hpp @@ -26,6 +26,7 @@ #include #include #include +#include namespace hdrmerge { @@ -78,6 +79,26 @@ inline std::ostream & operator<<(std::ostream & os, const QString & s) { return os << std::string(s.toUtf8().constData()); } +class Timer { +public: + Timer(const char * n) : name(n) { + start = std::clock(); + } + ~Timer() { + double t = (std::clock() - start) / (double) CLOCKS_PER_SEC; + Log::msg(Log::DEBUG, name, ": ", t, " seconds"); + } + +private: + std::clock_t start; + const char * name; +}; + +template void measureTime(const char * name, Func f) { + Timer t(name); + f(); +} + } // namespace hdrmerge #endif // _LOG_HPP_ diff --git a/test/SampleImage.hpp b/test/SampleImage.hpp index 24f0333..5318a2e 100644 --- a/test/SampleImage.hpp +++ b/test/SampleImage.hpp @@ -23,22 +23,33 @@ #include #include "../MetaData.hpp" #include +#include "../Log.hpp" + +namespace hdrmerge { struct SampleImage { uint16_t * pixelData; hdrmerge::MetaData md; SampleImage(const std::string & f) : pixelData(nullptr) { QImage image; - if (!image.load(f.c_str())) + if (!image.load(f.c_str())) { + Log::msg(Log::DEBUG, "Imposible to load sample image ", f); return; + } + Log::msg(Log::DEBUG, "Loaded sample image ", f, " with format ", image.format()); md.width = md.rawWidth = image.width(); md.height = image.height(); - md.max = 65535; + md.max = 255; + md.filters = 0x4b4b4b4b; pixelData = new uint16_t[md.width * md.height]; const uchar * data = image.constBits(); + int min = 255, max = 0; for (int i = 0; i < md.width * md.height; ++i) { pixelData[i] = data[i]; + if (min > data[i]) min = data[i]; + if (max < data[i]) max = data[i]; } + Log::msg(Log::DEBUG, "Data in range ", min, " - ", max); } ~SampleImage() { if (pixelData != nullptr) { @@ -56,3 +67,5 @@ struct SampleImage { image.save(f.c_str()); } }; + +} // namespace hdrmerge diff --git a/test/testBitmap.cpp b/test/testBitmap.cpp index ee2e2ef..1946516 100644 --- a/test/testBitmap.cpp +++ b/test/testBitmap.cpp @@ -52,7 +52,6 @@ BOOST_AUTO_TEST_CASE(bitmap_shift) { p.set(); } b.position(49, 49).reset(); b.position(49, 50).reset(); b.position(50, 49).reset(); b.position(50, 50).reset(); - b.dumpFile(); Bitmap s(100, 100); s.shift(b, 35, 35); BOOST_CHECK_MESSAGE(checkZeroArea(s, 0, 35, 0, 100), s.dumpInfo()); diff --git a/test/testEditableMask.cpp b/test/testEditableMask.cpp index da26ef5..f778951 100644 --- a/test/testEditableMask.cpp +++ b/test/testEditableMask.cpp @@ -24,7 +24,7 @@ #include #include "../EditableMask.hpp" #include "SampleImage.hpp" -#include "time.hpp" +#include "../Log.hpp" #include using namespace hdrmerge; using namespace std; @@ -40,8 +40,8 @@ BOOST_AUTO_TEST_CASE(testEditableMask) { map[i] = src[i]; } unique_ptr blurred; - double blurTime = measureTime([&] () {blurred = map.blur(radius);}); - cout << "Image blurred with radius " << radius << " in " << blurTime << " seconds" << endl; + string title = string("Blur with radius ") + to_string(radius); + measureTime(title.c_str(), [&] () {blurred = map.blur(radius);}); for (size_t i = 0; i < size; ++i) { image.pixelData[i] = std::round(blurred[i]); } diff --git a/test/testImageStack.cpp b/test/testImageStack.cpp index 0d253de..4ae325b 100644 --- a/test/testImageStack.cpp +++ b/test/testImageStack.cpp @@ -20,9 +20,10 @@ * */ +#include #include "../ImageStack.hpp" #include "SampleImage.hpp" -#include "time.hpp" +#include "../Log.hpp" #include #include using namespace hdrmerge; @@ -88,12 +89,13 @@ BOOST_AUTO_TEST_CASE(image_align) { BOOST_CHECK_EQUAL(e3.getDeltaY(), 26); BOOST_CHECK_EQUAL(e4.getDeltaX(), 32); BOOST_CHECK_EQUAL(e4.getDeltaY(), -4); + // Align in chain, should remain aligned with e1 e3.alignWith(e2); e4.alignWith(e3); - BOOST_CHECK_EQUAL(e3.getDeltaX(), 18); - BOOST_CHECK_EQUAL(e3.getDeltaY(), -6); - BOOST_CHECK_EQUAL(e4.getDeltaX(), -6); - BOOST_CHECK_EQUAL(e4.getDeltaY(), -30); + BOOST_CHECK_EQUAL(e3.getDeltaX(), 38); + BOOST_CHECK_EQUAL(e3.getDeltaY(), 26); + BOOST_CHECK_EQUAL(e4.getDeltaX(), 32); + BOOST_CHECK_EQUAL(e4.getDeltaY(), -4); } BOOST_AUTO_TEST_CASE(stack_load) { @@ -131,8 +133,8 @@ BOOST_AUTO_TEST_CASE(stack_align) { BOOST_REQUIRE(images.addImage(e2)); BOOST_REQUIRE(images.addImage(e3)); BOOST_REQUIRE(images.addImage(e4)); - double alignTime = measureTime([&] () {images.align();}); - cerr << "Images aligned in " << alignTime << " seconds." << endl; + measureTime("Align images total", [&] () {images.align();}); + images.crop(); BOOST_CHECK_EQUAL(images.getWidth(), 962); BOOST_CHECK_EQUAL(images.getHeight(), 564); BOOST_CHECK_EQUAL(e1ref.getDeltaX(), -38); @@ -149,12 +151,11 @@ BOOST_AUTO_TEST_CASE(stack_align) { BOOST_AUTO_TEST_CASE(auto_exposure) { ImageStack images; unique_ptr e1, e2, e3; - double time = measureTime([&] () { + measureTime("Load images", [&] () { e1.reset(new Image(image1)); e2.reset(new Image(image2)); e3.reset(new Image(image3)); }); - cerr << "Images loaded in " << time << " seconds." << endl; BOOST_REQUIRE(e1->good()); BOOST_REQUIRE(e2->good()); BOOST_REQUIRE(e3->good()); @@ -163,17 +164,16 @@ BOOST_AUTO_TEST_CASE(auto_exposure) { images.addImage(e2); images.addImage(e3); Image & e1ref = images.getImage(0), & e2ref = images.getImage(1), & e3ref = images.getImage(2); - time = measureTime([&] () { + measureTime("Align images", [&] () { images.align(); }); - cerr << "Images aligned in " << time << " seconds." << endl; - time = measureTime([&] () { + measureTime("Compute relative exposures", [&] () { images.computeRelExposures(); }); double metaImmExp = 1.0 / (1 << (int)(e1ref.getMetaData().logExp() - e2ref.getMetaData().logExp())); double dataImmExp = e1ref.getRelativeExposure() / e2ref.getRelativeExposure(); - cerr << "Relative exposure from data: " << dataImmExp << " in " << time << " seconds." << endl; + cerr << "Relative exposure from data: " << dataImmExp << endl; cerr << "Relative exposure from metadata: " << metaImmExp << endl; } diff --git a/test/testMain.cpp b/test/testMain.cpp index da27234..c4cbbf7 100644 --- a/test/testMain.cpp +++ b/test/testMain.cpp @@ -23,3 +23,11 @@ #define BOOST_TEST_MODULE hdrmerge #define BOOST_TEST_DYN_LINK #include +#include "../Log.hpp" +#include + +static int setLog() { + hdrmerge::Log::setOutputStream(std::cout); + hdrmerge::Log::setMinimumPriority(0); +} +static int foo = setLog(); diff --git a/test/time.hpp b/test/time.hpp deleted file mode 100644 index 08577ae..0000000 --- a/test/time.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - * HDRMerge - HDR exposure merging software. - * Copyright 2012 Javier Celaya - * jcelaya@gmail.com - * - * This file is part of HDRMerge. - * - * HDRMerge is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * HDRMerge is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with HDRMerge. If not, see . - * - */ - -#include -#include "../Log.hpp" - -template double measureTime(Func f) { - std::clock_t start = std::clock(); - f(); - return (std::clock() - start) / (double) CLOCKS_PER_SEC; -} - -class Timer { -public: - Timer(const char * n) : name(n) { - start = std::clock(); - } - ~Timer() { - double t = (std::clock() - start) / (double) CLOCKS_PER_SEC; - hdrmerge::Log::msg(hdrmerge::Log::DEBUG, name, " = ", t); - } - -private: - std::clock_t start; - const char * name; -}; From ce3e197ec999c676637b33ef3e1d7732c7c46008 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Thu, 15 May 2014 20:16:25 +0100 Subject: [PATCH 21/26] US38: Fix sporadic unsaturated pixels in mask. --- EditableMask.cpp | 16 +++++++++------- EditableMask.hpp | 2 +- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/EditableMask.cpp b/EditableMask.cpp index 8bf2689..ddfb8b5 100644 --- a/EditableMask.cpp +++ b/EditableMask.cpp @@ -61,10 +61,12 @@ void EditableMask::generateFrom(const ImageStack & images) { for (size_t row = 0, pos = 0; row < height; ++row) { for (size_t col = 0; col < width; ++col, ++pos) { int i = mask[pos]; - while (i < numLayers - 1 && images.getImage(i).isSaturated(col, row)) ++i; + while (i < numLayers - 1 && + (images.getImage(i).isSaturated(col, row) || + isSaturatedAround(images.getImage(i), col, row))) ++i; if (mask[pos] < i) { mask[pos] = i; - if (isNotSaturatedAround(images.getImage(i - 1), col, row)) { + if (!isSaturatedAround(images.getImage(i - 1), col, row)) { paintPixels(col, row, 6, i); } } @@ -73,26 +75,26 @@ void EditableMask::generateFrom(const ImageStack & images) { } -bool EditableMask::isNotSaturatedAround(const Image & img, size_t col, size_t row) const { +bool EditableMask::isSaturatedAround(const Image & img, size_t col, size_t row) const { if (row > 0) { if ((col > 0 && !img.isSaturated(col - 1, row - 1)) || !img.isSaturated(col, row - 1) || (col < width - 1 && !img.isSaturated(col + 1, row - 1))) { - return true; + return false; } } if ((col > 0 && !img.isSaturated(col - 1, row)) || (col < width - 1 && !img.isSaturated(col + 1, row))) { - return true; + return false; } if (row < height - 1) { if ((col > 0 && !img.isSaturated(col - 1, row + 1)) || !img.isSaturated(col, row + 1) || (col < width - 1 && !img.isSaturated(col + 1, row + 1))) { - return true; + return false; } } - return false; + return true; } diff --git a/EditableMask.hpp b/EditableMask.hpp index 8fdc29c..b2694f0 100644 --- a/EditableMask.hpp +++ b/EditableMask.hpp @@ -91,7 +91,7 @@ class EditableMask { std::list editActions; std::list::iterator nextAction; - bool isNotSaturatedAround(const Image & img, size_t col, size_t row) const; + bool isSaturatedAround(const Image & img, size_t col, size_t row) const; Area modifyLayer(const std::list & points, int oldayer); void paintPixels(int x, int y, size_t radius, int oldLayer); }; From 17b4b1110fba449e36073f3806d73a8b8057f61b Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Thu, 15 May 2014 20:50:47 +0100 Subject: [PATCH 22/26] US38: More robust MTB alignment. --- Bitmap.cpp | 2 +- Image.cpp | 18 +++++++----------- Image.hpp | 3 +-- 3 files changed, 9 insertions(+), 14 deletions(-) diff --git a/Bitmap.cpp b/Bitmap.cpp index 646b7be..42143a4 100644 --- a/Bitmap.cpp +++ b/Bitmap.cpp @@ -168,7 +168,7 @@ std::string Bitmap::dumpInfo() { } void Bitmap::dumpFile(const std::string & fileName) { - std::ofstream of(fileName); + std::ofstream of(fileName + ".pbm"); of << "P1\n# Foo\n" << rowWidth << " " << (numBits/rowWidth) << "\n"; size_t tb = 0; for (size_t i = 0; i < size; ++i) { diff --git a/Image.cpp b/Image.cpp index a2659d1..2f87e28 100644 --- a/Image.cpp +++ b/Image.cpp @@ -65,7 +65,6 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { metaData->max = max; satThreshold = 0.99*max; preScale(); - computeHalfLightPercentile(); metaData->dumpInfo(); } @@ -139,8 +138,9 @@ void Image::alignWith(const Image & r) { Timer t("Align images"); if (!good() || !r.good()) return; dx = dy = 0; - const double tolerance = 1.0/64; - uint16_t tolPixels = (uint16_t)std::floor(32768*tolerance); + const double tolerance = 1.0/16; + Histogram histFull(rawPixels.get(), rawPixels.get() + width*height); + double halfLightPercent = histFull.getFraction(max * 0.9) / 2.0; for (int s = scaleSteps - 1; s >= 0; --s) { size_t curWidth = width >> (s + 1); size_t curHeight = height >> (s + 1); @@ -149,12 +149,14 @@ void Image::alignWith(const Image & r) { Histogram hist2(scaled[s].get(), scaled[s].get() + curWidth*curHeight); uint16_t mth1 = hist1.getPercentile(halfLightPercent); uint16_t mth2 = hist2.getPercentile(halfLightPercent); + uint16_t tolPixels1 = (uint16_t)std::floor(mth1*tolerance); + uint16_t tolPixels2 = (uint16_t)std::floor(mth2*tolerance); Bitmap mtb1(curWidth, curHeight), mtb2(curWidth, curHeight), excl1(curWidth, curHeight), excl2(curWidth, curHeight); mtb1.mtb(r.scaled[s].get(), mth1); mtb2.mtb(scaled[s].get(), mth2); - excl1.exclusion(r.scaled[s].get(), mth1, tolPixels); - excl2.exclusion(scaled[s].get(), mth2, tolPixels); + excl1.exclusion(r.scaled[s].get(), mth1, tolPixels1); + excl2.exclusion(scaled[s].get(), mth2, tolPixels2); Bitmap shiftMtb(curWidth, curHeight), shiftExcl(curWidth, curHeight); int curDx = dx, curDy = dy; for (int i = -1; i <= 1; ++i) { @@ -206,9 +208,3 @@ void Image::preScale() { scaled[s].reset(r); } } - - -void Image::computeHalfLightPercentile() { - Histogram histFull(rawPixels.get(), rawPixels.get() + width*height); - halfLightPercent = histFull.getFraction(max * 0.9) / 2.0; -} diff --git a/Image.hpp b/Image.hpp index bb865b3..3f7a04d 100644 --- a/Image.hpp +++ b/Image.hpp @@ -90,13 +90,12 @@ class Image { uint16_t max; uint16_t satThreshold; double brightness; - double relExp; ///< Relative exposure, from data + double relExp; double halfLightPercent; void subtractBlack(); void buildImage(uint16_t * rawImage, MetaData * md); void preScale(); - void computeHalfLightPercentile(); }; } // namespace hdrmerge From cf451f75ed18b4936087821ccb43de46579f6224 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Fri, 16 May 2014 16:11:23 +0100 Subject: [PATCH 23/26] US38: Add support for not cropping the result. - Use Image::contains in EditableMask and ImageStack when the result is not cropped. - Fix order of arguments of serveral methods that take a pair of coordinates. - Fix Image::contains with signed parameters, to correctly compare with dx and dy. - Several refactorings. --- DngFloatWriter.cpp | 2 +- EditableMask.cpp | 88 ++++++++++++---------------------------------- EditableMask.hpp | 16 +++++++-- Image.cpp | 47 ++++++++++++++++++------- Image.hpp | 4 +++ ImageStack.cpp | 42 +++++++++++++--------- ImageStack.hpp | 17 +++++++-- Log.hpp | 4 +-- MetaData.hpp | 12 +++---- PreviewWidget.cpp | 12 +++---- Renderer.cpp | 18 +++++----- 11 files changed, 138 insertions(+), 124 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 5e5a48b..f19996a 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -256,7 +256,7 @@ void DngFloatWriter::createRawIFD() { uint16_t cfaPatternDim[] = { 2, 2 }; rawIFD.addEntry(CFAPATTERNDIM, IFD::SHORT, 2, cfaPatternDim); const MetaData & md = stack.getImage(0).getMetaData(); - uint8_t cfaPattern[] = { md.FC(0, 0), md.FC(0, 1), md.FC(1, 0), md.FC(1, 1) }; + uint8_t cfaPattern[] = { md.FC(0, 0), md.FC(1, 0), md.FC(0, 1), md.FC(1, 1) }; for (uint8_t & i : cfaPattern) { if (i == 3) i = 1; } diff --git a/EditableMask.cpp b/EditableMask.cpp index ddfb8b5..a53c7a1 100644 --- a/EditableMask.cpp +++ b/EditableMask.cpp @@ -36,9 +36,9 @@ void EditableMask::writeMaskImage(const std::string & maskFile) { maskImage.setColor(c, qRgb(gray, gray, gray)); } maskImage.setColor(numColors, qRgb(255, 255, 255)); - for (size_t row = 0, pos = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col, ++pos) { - maskImage.setPixel(col, row, mask[pos]); + for (size_t y = 0, pos = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x, ++pos) { + maskImage.setPixel(x, y, mask[pos]); } } if (!maskImage.save(QString(maskFile.c_str()))) { @@ -58,46 +58,29 @@ void EditableMask::generateFrom(const ImageStack & images) { Timer t("Generate mask"); mask.reset(new uint8_t[size]); std::fill_n(mask.get(), size, 0); - for (size_t row = 0, pos = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col, ++pos) { + for (size_t y = 0, pos = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x, ++pos) { int i = mask[pos]; while (i < numLayers - 1 && - (images.getImage(i).isSaturated(col, row) || - isSaturatedAround(images.getImage(i), col, row))) ++i; + (!images.getImage(i).contains(x, y) || + images.getImage(i).isSaturated(x, y) || + images.getImage(i).isSaturatedAround(x, y))) ++i; if (mask[pos] < i) { mask[pos] = i; - if (!isSaturatedAround(images.getImage(i - 1), col, row)) { - paintPixels(col, row, 6, i); - } + //if (!images.getImage(i - 1).isSaturatedAround(x, y)) { + paintCircle(x, y, 4, [&] (int col, int row) { + size_t pos = row*width + col; + if (mask[pos] < i && images.getImage(i).contains(col, row)) { + mask[pos] = i; + } + }); + //} } } } } -bool EditableMask::isSaturatedAround(const Image & img, size_t col, size_t row) const { - if (row > 0) { - if ((col > 0 && !img.isSaturated(col - 1, row - 1)) || - !img.isSaturated(col, row - 1) || - (col < width - 1 && !img.isSaturated(col + 1, row - 1))) { - return false; - } - } - if ((col > 0 && !img.isSaturated(col - 1, row)) || - (col < width - 1 && !img.isSaturated(col + 1, row))) { - return false; - } - if (row < height - 1) { - if ((col > 0 && !img.isSaturated(col - 1, row + 1)) || - !img.isSaturated(col, row + 1) || - (col < width - 1 && !img.isSaturated(col + 1, row + 1))) { - return false; - } - } - return true; -} - - void EditableMask::startAction(bool add, int layer) { editActions.erase(nextAction, editActions.end()); editActions.emplace_back(); @@ -107,39 +90,15 @@ void EditableMask::startAction(bool add, int layer) { } -void EditableMask::paintPixels(int x, int y, size_t radius) { +void EditableMask::paintPixels(const ImageStack & images, int x, int y, size_t radius) { EditAction & e = editActions.back(); - int r2 = radius * radius; - int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; - int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; - for (int row = ymin, rrow = y + row; row < ymax; ++row, ++rrow) { - for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { - if (row*row + col*col <= r2) { - size_t pos = rrow*width + rcol; - if (mask[pos] == e.oldLayer) { - e.points.push_back({x + col, y + row}); - mask[pos] = e.newLayer; - } - } - } - } -} - - -void EditableMask::paintPixels(int x, int y, size_t radius, int l) { - int r2 = radius * radius; - int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; - int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; - for (int row = ymin, rrow = y + row; row < ymax; ++row, ++rrow) { - for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { - if (row*row + col*col <= r2) { - size_t pos = rrow*width + rcol; - if (mask[pos] < l) { - mask[pos] = l; - } - } + paintCircle(x, y, radius, [&] (int col, int row) { + size_t pos = row*width + col; + if (mask[pos] == e.oldLayer && images.getImage(e.newLayer).contains(col, row)) { + e.points.push_back({col, row}); + mask[pos] = e.newLayer; } - } + }); } @@ -170,7 +129,6 @@ EditableMask::Area EditableMask::modifyLayer(const std::list & points, in a.maxx = -1; a.maxy = -1; for (auto p : points) { - int rcol = p.x, rrow = p.y; mask[p.y * width + p.x] = layer; if (p.x < a.minx) a.minx = p.x; if (p.x > a.maxx) a.maxx = p.x; diff --git a/EditableMask.hpp b/EditableMask.hpp index b2694f0..007bff8 100644 --- a/EditableMask.hpp +++ b/EditableMask.hpp @@ -52,7 +52,7 @@ class EditableMask { return mask[i]; } void startAction(bool add, int layer); - void paintPixels(int x, int y, size_t radius); + void paintPixels(const ImageStack & images, int x, int y, size_t radius); Area undo(); Area redo(); std::unique_ptr blur() const; @@ -91,9 +91,19 @@ class EditableMask { std::list editActions; std::list::iterator nextAction; - bool isSaturatedAround(const Image & img, size_t col, size_t row) const; Area modifyLayer(const std::list & points, int oldayer); - void paintPixels(int x, int y, size_t radius, int oldLayer); + template void paintCircle(int x, int y, size_t radius, T function) { + int r2 = radius * radius; + int ymin = y < radius ? -y : -radius, ymax = y >= height - radius ? height - y : radius + 1; + int xmin = x < radius ? -x : -radius, xmax = x >= width - radius ? width - x : radius + 1; + for (int row = ymin, rrow = y + row; row < ymax; ++row, ++rrow) { + for (int col = xmin, rcol = x + col; col < xmax; ++col, ++rcol) { + if (row*row + col*col <= r2) { + function(rcol, rrow); + } + } + } + } }; } // namespace hdrmerge diff --git a/Image.cpp b/Image.cpp index 2f87e28..ae0bcfd 100644 --- a/Image.cpp +++ b/Image.cpp @@ -43,13 +43,13 @@ void Image::buildImage(uint16_t * rawImage, MetaData * md) { uint16_t maxPerColor[4] = {0, 0, 0, 0}; rawPixels.reset(new uint16_t[size]); alignedPixels = rawPixels.get(); - for (size_t row = 0, rrow = md->topMargin; row < height; ++row, ++rrow) { - for (size_t col = 0, rcol = md->leftMargin; col < width; ++col, ++rcol) { - uint16_t v = rawImage[rrow*md->rawWidth + rcol]; - rawPixels[row*width + col] = v; + for (size_t y = 0, ry = md->topMargin; y < height; ++y, ++ry) { + for (size_t x = 0, rx = md->leftMargin; x < width; ++x, ++rx) { + uint16_t v = rawImage[ry*md->rawWidth + rx]; + rawPixels[y*width + x] = v; brightness += v; - if (v > maxPerColor[md->FC(row, col)]) { - maxPerColor[md->FC(row, col)] = v; + if (v > maxPerColor[md->FC(x, y)]) { + maxPerColor[md->FC(x, y)] = v; } } } @@ -86,12 +86,12 @@ Image::Image(const char * f) : rawPixels(nullptr) { void Image::subtractBlack() { if (metaData->hasBlack()) { - for (size_t row = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col) { - if (rawPixels[row*width + col] > metaData->blackAt(row, col)) { - rawPixels[row*width + col] -= metaData->blackAt(row, col); + for (size_t y = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x) { + if (rawPixels[y*width + x] > metaData->blackAt(x, y)) { + rawPixels[y*width + x] -= metaData->blackAt(x, y); } else { - rawPixels[row*width + col] = 0; + rawPixels[y*width + x] = 0; } } } @@ -106,7 +106,6 @@ bool Image::isSameFormat(const Image & ref) const { void Image::relativeExposure(const Image & r) { - Timer t("Relative exposure"); int reldx = dx - std::max(dx, r.dx); int relrdx = r.dx - std::max(dx, r.dx); int w = width + reldx + relrdx; @@ -135,7 +134,6 @@ void Image::relativeExposure(const Image & r) { void Image::alignWith(const Image & r) { - Timer t("Align images"); if (!good() || !r.good()) return; dx = dy = 0; const double tolerance = 1.0/16; @@ -208,3 +206,26 @@ void Image::preScale() { scaled[s].reset(r); } } + + +bool Image::isSaturatedAround(size_t x, size_t y) const { + if (y > dy) { + if ((x > dx && !isSaturated(x - 1, y - 1)) || + !isSaturated(x, y - 1) || + (x < width + dx - 1 && !isSaturated(x + 1, y - 1))) { + return false; + } + } + if ((x > dx && !isSaturated(x - 1, y)) || + (x < width + dx - 1 && !isSaturated(x + 1, y))) { + return false; + } + if (y < height + dy - 1) { + if ((x > dx && !isSaturated(x - 1, y + 1)) || + !isSaturated(x, y + 1) || + (x < width + dx - 1 && !isSaturated(x + 1, y + 1))) { + return false; + } + } + return true; +} diff --git a/Image.hpp b/Image.hpp index 3f7a04d..d12b487 100644 --- a/Image.hpp +++ b/Image.hpp @@ -61,6 +61,10 @@ class Image { bool isSaturated(size_t x, size_t y) const { return alignedPixels[y*width + x] >= satThreshold; } + bool contains(int x, int y) const { + return x >= dx && x < width + dx && y >= dy && y < height + dy; + } + bool isSaturatedAround(size_t x, size_t y) const; double getRelativeExposure() const { return relExp; } diff --git a/ImageStack.cpp b/ImageStack.cpp index 91f0ab3..324262e 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -56,7 +56,7 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) int p = -step; for (auto & name : options.fileNames) { progress.advance(p += step, "Loading %1", name.c_str()); - std::unique_ptr image(new Image(name.c_str())); + std::unique_ptr image(measureTime("Load raw", [&] () { return new Image(name.c_str()); })); if (image.get() == nullptr || !image->good()) { return 1; } @@ -65,11 +65,12 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) } } if (options.align) { + Timer t("Align"); progress.advance(p += step, "Aligning"); align(); - //if (options.crop) { + if (options.crop) { crop(); - //} + } } computeRelExposures(); mask.generateFrom(*this); @@ -133,27 +134,34 @@ double ImageStack::value(size_t x, size_t y) const { void ImageStack::compose(float * dst) const { - unique_ptr map = mask.blur(); + Timer t("Compose"); + unique_ptr map = measureTime("Blur", [&] () { return mask.blur(); }); const MetaData & md = images.front()->getMetaData(); int imageMax = images.size() - 1; float max = 0.0; - for (size_t row = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col) { - size_t pos = row*width + col; + for (size_t y = 0, pos = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x, ++pos) { int j = map[pos] > imageMax ? imageMax : ceil(map[pos]); - double v = images[j]->exposureAt(col, row); - // Adjust false highlights - if (j < imageMax && images[j]->isSaturated(col, row)) { - v /= md.whiteMultAt(row, col); + double v = 0.0, vv = 0.0, p; + if (images[j]->contains(x, y)) { + v = images[j]->exposureAt(x, y); + // Adjust false highlights + if (j < imageMax && images[j]->isSaturatedAround(x, y)) { + v /= md.whiteMultAt(x, y); + } + p = j - map[pos]; + } else { + p = 1.0; } - if (j > 0) { - double p = j - map[pos]; - double vv = images[j - 1]->exposureAt(col, row); - if (images[j - 1]->isSaturated(col, row)) { - vv /= md.whiteMultAt(row, col); + if (j > 0 && images[j - 1]->contains(x, y)) { + vv = images[j - 1]->exposureAt(x, y); + if (images[j - 1]->isSaturatedAround(x, y)) { + vv /= md.whiteMultAt(x, y); } - v = v*(1.0 - p) + vv*p; + } else { + p = 0.0; } + v = v*(1.0 - p) + vv*p; dst[pos] = v; if (v > max) { max = v; diff --git a/ImageStack.hpp b/ImageStack.hpp index be9f3a2..703fa61 100644 --- a/ImageStack.hpp +++ b/ImageStack.hpp @@ -72,8 +72,21 @@ class ImageStack { uint8_t toneMap(double v) { return toneCurve[(int)std::floor(v)]; } - EditableMask & getMask() { - return mask; + + uint8_t getImageAt(size_t x, size_t y) const { + return mask.getImageAt(x, y); + } + void startEditAction(bool add, int layer) { + mask.startAction(add, layer); + } + void editPixels(size_t x, size_t y, size_t radius) { + mask.paintPixels(*this, x, y, radius); + } + EditableMask::Area undo() { + return mask.undo(); + } + EditableMask::Area redo() { + return mask.redo(); } private: diff --git a/Log.hpp b/Log.hpp index e235516..b62c0a1 100644 --- a/Log.hpp +++ b/Log.hpp @@ -94,9 +94,9 @@ class Timer { const char * name; }; -template void measureTime(const char * name, Func f) { +template auto measureTime(const char * name, Func f) -> decltype(f()) { Timer t(name); - f(); + return f(); } } // namespace hdrmerge diff --git a/MetaData.hpp b/MetaData.hpp index babafb3..aeaba83 100644 --- a/MetaData.hpp +++ b/MetaData.hpp @@ -37,19 +37,19 @@ class MetaData { bool isSameFormat(const MetaData & r) { return width == r.width && height == r.height && filters == r.filters && cdesc == r.cdesc; } - uint8_t FC(int row, int col) const { - return (filters >> (((row << 1 & 14) | (col & 1)) << 1) & 3); + uint8_t FC(int x, int y) const { + return (filters >> (((y << 1 & 14) | (x & 1)) << 1) & 3); } double logExp() const; void dumpInfo() const; - uint16_t blackAt(int row, int col) const { - return cblack[FC(row, col)]; + uint16_t blackAt(int x, int y) const { + return cblack[FC(x, y)]; } bool hasBlack() const { return black || cblack[0] || cblack[1] || cblack[2] || cblack[3]; } - float whiteMultAt(int row, int col) const { - return camMul[FC(row, col)]; + float whiteMultAt(int x, int y) const { + return camMul[FC(x, y)]; } void adjustBlack(); void adjustWhite(); diff --git a/PreviewWidget.cpp b/PreviewWidget.cpp index 312cc08..8233959 100644 --- a/PreviewWidget.cpp +++ b/PreviewWidget.cpp @@ -93,7 +93,7 @@ QRgb PreviewWidget::rgb(int col, int row) const { else if (d > 65535) d = 65535; int v = stack->toneMap(d); int v70 = v*7/10; - int color = stack->getMask().getImageAt(col, row); + int color = stack->getImageAt(col, row); QRgb pixel; switch (color) { case 0: @@ -180,10 +180,10 @@ void PreviewWidget::toggleRmPixelsTool(bool toggled) { void PreviewWidget::mousePressEvent(QMouseEvent * event) { if (addPixels || rmPixels) { event->accept(); - stack->getMask().startAction(addPixels, layer); + stack->startEditAction(addPixels, layer); int x = event->x(), y = event->y(); rotate(x, y); - stack->getMask().paintPixels(x, y, radius); + stack->editPixels(x, y, radius); render(x - radius, y - radius, x + radius + 1, y + radius + 1); } else event->ignore(); @@ -193,7 +193,7 @@ void PreviewWidget::mouseMoveEvent(QMouseEvent * event) { event->accept(); int x = event->x(), y = event->y(); rotate(x, y); - stack->getMask().paintPixels(x, y, radius); + stack->editPixels(x, y, radius); render(x - radius, y - radius, x + radius + 1, y + radius + 1); } else event->ignore(); @@ -201,12 +201,12 @@ void PreviewWidget::mouseMoveEvent(QMouseEvent * event) { void PreviewWidget::undo() { - EditableMask::Area a = stack->getMask().undo(); + EditableMask::Area a = stack->undo(); render(a.minx, a.miny, a.maxx + 1, a.maxy + 1); } void PreviewWidget::redo() { - EditableMask::Area a = stack->getMask().redo(); + EditableMask::Area a = stack->redo(); render(a.minx, a.miny, a.maxx + 1, a.maxy + 1); } diff --git a/Renderer.cpp b/Renderer.cpp index 91747a0..0fe6f58 100644 --- a/Renderer.cpp +++ b/Renderer.cpp @@ -33,15 +33,15 @@ using namespace hdrmerge; Renderer::Renderer(float * rawData, size_t w, size_t h, const MetaData & md) : md(md), width(w/2), height(h/2) { image.reset(new float[width*height][4]); - for (size_t row = 0; row < height; ++row) { - for (size_t col = 0; col < width; ++col) { - size_t posDst = row*width + col; - size_t row2 = row << 1, col2 = col << 1; - size_t posSrc = row2*w + col2; - image[posDst][md.FC(row2, col2)] = rawData[posSrc] * 65535.0; - image[posDst][md.FC(row2, col2 + 1)] = rawData[posSrc + 1] * 65535.0; - image[posDst][md.FC(row2 + 1, col2)] = rawData[posSrc + w] * 65535.0; - image[posDst][md.FC(row2 + 1, col2 + 1)] = rawData[posSrc + w + 1] * 65535.0; + for (size_t y = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x) { + size_t posDst = y*width + x; + size_t y2 = y << 1, x2 = x << 1; + size_t posSrc = y2*w + x2; + image[posDst][md.FC(x2, y2)] = rawData[posSrc] * 65535.0; + image[posDst][md.FC(x2 + 1, y2)] = rawData[posSrc + 1] * 65535.0; + image[posDst][md.FC(x2, y2 + 1)] = rawData[posSrc + w] * 65535.0; + image[posDst][md.FC(x2 + 1, y2 + 1)] = rawData[posSrc + w + 1] * 65535.0; } } } From 56c3278bc5bedf033493367728c50ca0d67e6b24 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sat, 17 May 2014 17:00:00 +0100 Subject: [PATCH 24/26] US38: Add --no-crop switch --- Launcher.cpp | 9 ++++++--- hdrmerge_es.ts | 4 ++++ 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/Launcher.cpp b/Launcher.cpp index c3cc08a..c199403 100644 --- a/Launcher.cpp +++ b/Launcher.cpp @@ -109,8 +109,10 @@ void Launcher::parseCommandLine() { Log::setMinimumPriority(1); } else if (string("-vv") == argv[i]) { Log::setMinimumPriority(0); - } else if (string("-n") == argv[i] || string("--no-align") == argv[i]) { + } else if (string("--no-align") == argv[i]) { options.align = false; + } else if (string("--no-crop") == argv[i]) { + options.crop = false; } else if (string("--help") == argv[i]) { help = true; } else if (string("-b") == argv[i]) { @@ -147,19 +149,20 @@ void Launcher::showHelp() { cout << tr("Usage") << ": HDRMerge [--help] [OPTIONS ...] [RAW_FILES ...]" << endl; cout << tr("Merges RAW_FILES into an HDR DNG raw image.") << endl; cout << tr("If neither -a nor -o options are given, the GUI will be presented.") << endl; + cout << tr("If similar options are specified, only the last one prevails.") << endl; cout << endl; cout << tr("Options:") << endl; cout << " " << "--help " << tr("Shows this message.") << endl; cout << " " << "-a " << tr("Calculates the output file name automatically.") << endl; cout << " " << "-b BPS " << tr("Bits per sample, can be 16, 24 or 32.") << endl; cout << " " << "-m MASK_FILE " << tr("Saves the mask to MASK_FILE as a PNG image.") << endl; - cout << " " << "-n|--no-align " << tr("Do not auto-align source images.") << endl; + cout << " " << "--no-align " << tr("Do not auto-align source images.") << endl; + cout << " " << "--no-crop " << tr("Do not crop the output image to the optimum size.") << endl; cout << " " << "-o OUT_FILE " << tr("Sets OUT_FILE as the output file name.") << endl; cout << " " << "-p full|half|none " << tr("Preview width.") << endl; cout << " " << "-v " << tr("Verbose mode.") << endl; cout << " " << "-vv " << tr("Debug mode.") << endl; cout << " " << "RAW_FILES " << tr("The input raw files.") << endl; - cout << tr("If similar options are specified, only the last one prevails.") << endl; } diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index 6ad1db7..5112466 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -47,6 +47,10 @@ Do not auto-align source images. No auto-alinear las imágenes de origen. + + Do not crop the output image to the optimum size. + No recortar el resultado al tamaño óptimo. + Verbose mode. Mostrar información de progreso. From 2a6facd255c726eeac561d358fd53e37f27a9b84 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sat, 17 May 2014 18:30:54 +0100 Subject: [PATCH 25/26] US38: Small improvement saving the DNG file --- DngFloatWriter.cpp | 11 +++++++---- Log.hpp | 8 +++++--- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index f19996a..38dd2e9 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -121,8 +121,9 @@ void DngFloatWriter::write(const string & filename) { file.seekp(dataOffset); progress.advance(75, "Writing output"); + Timer t("Write output"); writePreviews(); - writeRawData(); + measureTime("Write raw", [&] () { writeRawData(); }); file.seekp(0); TiffHeader().write(file); mainIFD.write(file, false); @@ -490,8 +491,8 @@ void DngFloatWriter::writeRawData() { size_t tileCount = tilesAcross * tilesDown; uint32_t tileOffsets[tileCount]; uint32_t tileBytes[tileCount]; - uLongf dstLen = tileWidth * tileLength * 4; int bytesps = bps >> 3; + uLongf dstLen = tileWidth * tileLength * bytesps; // #pragma omp parallel { @@ -502,9 +503,11 @@ void DngFloatWriter::writeRawData() { for (size_t y = 0; y < height; y += tileLength) { for (size_t x = 0; x < width; x += tileWidth) { size_t t = (y / tileLength) * tilesAcross + (x / tileWidth); - fill_n(uBuffer, dstLen, 0); size_t thisTileLength = y + tileLength > height ? height - y : tileLength; size_t thisTileWidth = x + tileWidth > width ? width - x : tileWidth; + if (thisTileLength != tileLength || thisTileWidth != tileWidth) { + fill_n(uBuffer, dstLen, 0); + } for (size_t row = 0; row < thisTileLength; ++row) { Bytef * dst = uBuffer + row*tileWidth*bytesps; Bytef * src = (Bytef *)&rawData[(y+row)*width + x]; @@ -516,7 +519,7 @@ void DngFloatWriter::writeRawData() { tileBytes[t] = conpressedLength; if (err != Z_OK) { std::cerr << "DNG Deflate: Failed compressing tile " << t << ", with error " << err << std::endl; - } else { // Floating point data + } else { // #pragma omp critical { tileOffsets[t] = file.tellp(); diff --git a/Log.hpp b/Log.hpp index b62c0a1..48b00e9 100644 --- a/Log.hpp +++ b/Log.hpp @@ -82,15 +82,17 @@ inline std::ostream & operator<<(std::ostream & os, const QString & s) { class Timer { public: Timer(const char * n) : name(n) { - start = std::clock(); + clock_gettime(CLOCK_MONOTONIC_COARSE, &start); } ~Timer() { - double t = (std::clock() - start) / (double) CLOCKS_PER_SEC; + timespec end; + clock_gettime(CLOCK_MONOTONIC_COARSE, &end); + double t = end.tv_sec - start.tv_sec + (end.tv_nsec - start.tv_nsec)/1000000000.0; Log::msg(Log::DEBUG, name, ": ", t, " seconds"); } private: - std::clock_t start; + timespec start; const char * name; }; From 5ef6e320c76ae469770be913cf17021069027bb1 Mon Sep 17 00:00:00 2001 From: Javier Celaya Date: Sat, 17 May 2014 19:41:18 +0100 Subject: [PATCH 26/26] Several performance improvements with OpenMP. - Faster image load. - Faster image alignment. - Faster boxblur. - Faster result render. - Faster writing DNG tiles. --- DngFloatWriter.cpp | 6 +++--- EditableMask.cpp | 2 ++ Image.cpp | 4 ---- ImageStack.cpp | 52 +++++++++++++++++++++++++++++++++------------- Launcher.cpp | 15 ++++++++----- MainWindow.cpp | 11 +++++----- PreviewWidget.cpp | 3 +++ hdrmerge_es.ts | 8 +++++-- 8 files changed, 67 insertions(+), 34 deletions(-) diff --git a/DngFloatWriter.cpp b/DngFloatWriter.cpp index 38dd2e9..a960143 100644 --- a/DngFloatWriter.cpp +++ b/DngFloatWriter.cpp @@ -494,12 +494,12 @@ void DngFloatWriter::writeRawData() { int bytesps = bps >> 3; uLongf dstLen = tileWidth * tileLength * bytesps; -// #pragma omp parallel + #pragma omp parallel { Bytef cBuffer[dstLen]; Bytef uBuffer[dstLen]; -// #pragma omp for collapse(2) + #pragma omp for collapse(2) schedule(dynamic) for (size_t y = 0; y < height; y += tileLength) { for (size_t x = 0; x < width; x += tileWidth) { size_t t = (y / tileLength) * tilesAcross + (x / tileWidth); @@ -520,7 +520,7 @@ void DngFloatWriter::writeRawData() { if (err != Z_OK) { std::cerr << "DNG Deflate: Failed compressing tile " << t << ", with error " << err << std::endl; } else { -// #pragma omp critical + #pragma omp critical { tileOffsets[t] = file.tellp(); file.write((const char *)cBuffer, tileBytes[t]); diff --git a/EditableMask.cpp b/EditableMask.cpp index a53c7a1..63ebb3d 100644 --- a/EditableMask.cpp +++ b/EditableMask.cpp @@ -174,6 +174,7 @@ void EditableMask::BoxBlur::boxBlur_4(size_t radius) { void EditableMask::BoxBlur::boxBlurH_4(size_t r) { float iarr = 1.0 / (r+r+1); + #pragma omp parallel for schedule(dynamic) for (size_t i = 0; i < m.height; ++i) { size_t ti = i * m.width, li = ti, ri = ti + r; float val = map[li] * (r + 1); @@ -198,6 +199,7 @@ void EditableMask::BoxBlur::boxBlurH_4(size_t r) { void EditableMask::BoxBlur::boxBlurT_4(size_t r) { float iarr = 1.0 / (r+r+1); + #pragma omp parallel for schedule(dynamic) for (size_t i = 0; i < m.width; ++i) { size_t ti = i, li = ti, ri = ti + r*m.width; float val = map[li] * (r + 1); diff --git a/Image.cpp b/Image.cpp index ae0bcfd..b5672b5 100644 --- a/Image.cpp +++ b/Image.cpp @@ -175,10 +175,6 @@ void Image::alignWith(const Image & r) { dx <<= 1; dy <<= 1; } - dx += r.dx; - dy += r.dy; - alignedPixels = &rawPixels[-dy*width - dx]; - Log::msg(Log::DEBUG, "Image ", metaData->fileName, " displaced to (", dx, ", ", dy, ")"); } diff --git a/ImageStack.cpp b/ImageStack.cpp index 324262e..a020230 100644 --- a/ImageStack.cpp +++ b/ImageStack.cpp @@ -52,18 +52,35 @@ bool ImageStack::addImage(std::unique_ptr & i) { int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) { - int step = 100 / (options.fileNames.size() + 1); + int numImages = options.fileNames.size(); + int step = 100 / (numImages + 1); int p = -step; - for (auto & name : options.fileNames) { - progress.advance(p += step, "Loading %1", name.c_str()); - std::unique_ptr image(measureTime("Load raw", [&] () { return new Image(name.c_str()); })); - if (image.get() == nullptr || !image->good()) { - return 1; - } - if (!addImage(image)) { - return 2; + int error = 0, failedImage = 0; + { + Timer t("Load files"); + #pragma omp parallel for schedule(dynamic) + for (int i = 0; i < numImages; ++i) { + if (!error) { // We cannot break from the for loop if we are using OpenMP + string name = options.fileNames[i]; + #pragma omp critical + progress.advance(p += step, "Loading %1", name.c_str()); + std::unique_ptr image(new Image(name.c_str())); + #pragma omp critical + if (!error) { // Report on the first image that fails, ignore the rest + if (image.get() == nullptr || !image->good()) { + error = 1; + failedImage = i; + } else if (!addImage(image)) { + error = 2; + failedImage = i; + } + } + } } } + if (error) { + return (failedImage << 1) + error - 1; + } if (options.align) { Timer t("Align"); progress.advance(p += step, "Aligning"); @@ -75,7 +92,7 @@ int ImageStack::load(const LoadOptions & options, ProgressIndicator & progress) computeRelExposures(); mask.generateFrom(*this); progress.advance(100, "Done loading!"); - return 0; + return numImages << 1; } @@ -93,8 +110,12 @@ int ImageStack::save(const SaveOptions & options, ProgressIndicator & progress) void ImageStack::align() { if (images.size() > 1) { - for (auto cur = images.rbegin(), next = cur++; cur != images.rend(); next = cur++) { - (*cur)->alignWith(**next); + for (int i = images.size() - 2; i >= 0; --i) { + images[i]->alignWith(*images[i + 1]); + } + for (int i = images.size() - 2; i >= 0; --i) { + images[i]->displace(images[i + 1]->getDeltaX(), images[i + 1]->getDeltaY()); + Log::msg(Log::DEBUG, "Image ", i, " displaced to (", images[i]->getDeltaX(), ", ", images[i]->getDeltaY(), ")"); } for (auto & i : images) { i->releaseAlignData(); @@ -134,13 +155,14 @@ double ImageStack::value(size_t x, size_t y) const { void ImageStack::compose(float * dst) const { - Timer t("Compose"); unique_ptr map = measureTime("Blur", [&] () { return mask.blur(); }); + Timer t("Compose"); const MetaData & md = images.front()->getMetaData(); int imageMax = images.size() - 1; float max = 0.0; - for (size_t y = 0, pos = 0; y < height; ++y) { - for (size_t x = 0; x < width; ++x, ++pos) { + #pragma omp parallel for schedule(dynamic) + for (size_t y = 0; y < height; ++y) { + for (size_t x = 0, pos = y*width; x < width; ++x, ++pos) { int j = map[pos] > imageMax ? imageMax : ceil(map[pos]); double v = 0.0, vv = 0.0, p; if (images[j]->contains(x, y)) { diff --git a/Launcher.cpp b/Launcher.cpp index c199403..e632c09 100644 --- a/Launcher.cpp +++ b/Launcher.cpp @@ -73,12 +73,17 @@ int Launcher::automaticMerge() { auto tr = [&] (const char * text) { return QCoreApplication::translate("LoadSave", text); }; CoutProgressIndicator progress; ImageStack stack; - if (stack.load(options, progress)) { - int i = progress.getPercent() * (options.fileNames.size() + 1) / 100; - if (i) { - cerr << tr("Error loading %1").arg(options.fileNames[i].c_str()) << endl; - return 1; + int numImages = options.fileNames.size(); + int result = stack.load(options, progress); + if (result < numImages * 2) { + int format = result & 1; + int i = result >> 1; + if (format) { + cerr << tr("Error loading %1, it has a different format.").arg(options.fileNames[i].c_str()) << endl; + } else { + cerr << tr("Error loading %1, file not found.").arg(options.fileNames[i].c_str()) << endl; } + return 1; } if (!wOptions.fileName.empty()) { size_t extPos = wOptions.fileName.find_last_of('.'); diff --git a/MainWindow.cpp b/MainWindow.cpp index 4c10941..c940734 100644 --- a/MainWindow.cpp +++ b/MainWindow.cpp @@ -273,11 +273,12 @@ void MainWindow::loadImages(const LoadOptions & options) { QFuture error = QtConcurrent::run([&] () { return newImages->load(options, progress); }); while (error.isRunning()) QApplication::instance()->processEvents(QEventLoop::ExcludeUserInputEvents); - if (error.result()) { - int i = progress.getPercent() * (numImages + 1) / 100; - QString message = error.result() == 1 ? - tr("Unable to open file %1.").arg(options.fileNames[i].c_str()) : - tr("File %1 has not the same format as the previous ones.").arg(options.fileNames[i].c_str()); + int result = error.result(); + if (result < numImages * 2) { + int i = result >> 1; + QString message = result & 1 ? + tr("File %1 has not the same format as the previous ones.").arg(options.fileNames[i].c_str()) : + tr("Unable to open file %1.").arg(options.fileNames[i].c_str()); QMessageBox::warning(this, tr("Error opening file"), message); delete newImages; return; diff --git a/PreviewWidget.cpp b/PreviewWidget.cpp index 8233959..7abb912 100644 --- a/PreviewWidget.cpp +++ b/PreviewWidget.cpp @@ -121,6 +121,7 @@ void PreviewWidget::render(int minx, int miny, int maxx, int maxy) { if (area.isEmpty()) return; area.getCoords(&minx, &miny, &maxx, &maxy); QImage image(area.width() - 1, area.height() - 1, QImage::Format_RGB32); + #pragma omp parallel for schedule(dynamic) for (int row = miny; row < maxy; row++) { QRgb * scanLine = reinterpret_cast(image.scanLine(row - miny)); for (int col = minx; col < maxx; col++) { @@ -188,6 +189,8 @@ void PreviewWidget::mousePressEvent(QMouseEvent * event) { } else event->ignore(); } + + void PreviewWidget::mouseMoveEvent(QMouseEvent * event) { if (addPixels || rmPixels) { event->accept(); diff --git a/hdrmerge_es.ts b/hdrmerge_es.ts index 5112466..4f364a2 100644 --- a/hdrmerge_es.ts +++ b/hdrmerge_es.ts @@ -75,8 +75,12 @@ LoadSave - Error loading %1 - Error cargando %1 + Error loading %1, it has a different format. + Error cargando %1, tiene un formato diferente. + + + Error loading %1, file not found. + Error cargando %1, no se encontró el fichero. Writing result to %1