| /* |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "TiffWriter" |
| |
| #include <img_utils/TiffHelpers.h> |
| #include <img_utils/TiffWriter.h> |
| #include <img_utils/TagDefinitions.h> |
| |
| #include <assert.h> |
| |
| namespace android { |
| namespace img_utils { |
| |
| KeyedVector<uint16_t, const TagDefinition_t*> TiffWriter::buildTagMap( |
| const TagDefinition_t* definitions, size_t length) { |
| KeyedVector<uint16_t, const TagDefinition_t*> map; |
| for(size_t i = 0; i < length; ++i) { |
| map.add(definitions[i].tagId, definitions + i); |
| } |
| return map; |
| } |
| |
| #define COMPARE(op) \ |
| bool Orderable::operator op (const Orderable& orderable) const { \ |
| return getComparableValue() op orderable.getComparableValue(); \ |
| } |
| |
| #define ARRAY_SIZE(array) \ |
| (sizeof(array) / sizeof(array[0])) |
| |
| KeyedVector<uint16_t, const TagDefinition_t*> TiffWriter::sTagMaps[] = { |
| buildTagMap(TIFF_EP_TAG_DEFINITIONS, ARRAY_SIZE(TIFF_EP_TAG_DEFINITIONS)), |
| buildTagMap(DNG_TAG_DEFINITIONS, ARRAY_SIZE(DNG_TAG_DEFINITIONS)), |
| buildTagMap(EXIF_2_3_TAG_DEFINITIONS, ARRAY_SIZE(EXIF_2_3_TAG_DEFINITIONS)), |
| buildTagMap(TIFF_6_TAG_DEFINITIONS, ARRAY_SIZE(TIFF_6_TAG_DEFINITIONS)) |
| }; |
| |
| TiffWriter::TiffWriter() : mTagMaps(sTagMaps), mNumTagMaps(DEFAULT_NUM_TAG_MAPS) {} |
| |
| TiffWriter::TiffWriter(KeyedVector<uint16_t, const TagDefinition_t*>* enabledDefinitions, |
| size_t length) : mTagMaps(enabledDefinitions), mNumTagMaps(length) {} |
| |
| TiffWriter::~TiffWriter() {} |
| |
| status_t TiffWriter::write(Output* out, StripSource** sources, size_t sourcesCount, |
| Endianness end) { |
| status_t ret = OK; |
| EndianOutput endOut(out, end); |
| |
| if (mIfd == NULL) { |
| ALOGE("%s: Tiff header is empty.", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| |
| uint32_t totalSize = getTotalSize(); |
| |
| KeyedVector<uint32_t, uint32_t> offsetVector; |
| |
| for (size_t i = 0; i < mNamedIfds.size(); ++i) { |
| if (mNamedIfds[i]->uninitializedOffsets()) { |
| uint32_t stripSize = mNamedIfds[i]->getStripSize(); |
| if (mNamedIfds[i]->setStripOffset(totalSize) != OK) { |
| ALOGE("%s: Could not set strip offsets.", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| totalSize += stripSize; |
| WORD_ALIGN(totalSize); |
| offsetVector.add(mNamedIfds.keyAt(i), totalSize); |
| } |
| } |
| |
| size_t offVecSize = offsetVector.size(); |
| if (offVecSize != sourcesCount) { |
| ALOGE("%s: Mismatch between number of IFDs with uninitialized strips (%zu) and" |
| " sources (%zu).", __FUNCTION__, offVecSize, sourcesCount); |
| return BAD_VALUE; |
| } |
| |
| BAIL_ON_FAIL(writeFileHeader(endOut), ret); |
| |
| uint32_t offset = FILE_HEADER_SIZE; |
| sp<TiffIfd> ifd = mIfd; |
| while(ifd != NULL) { |
| BAIL_ON_FAIL(ifd->writeData(offset, &endOut), ret); |
| offset += ifd->getSize(); |
| ifd = ifd->getNextIfd(); |
| } |
| |
| if (LOG_NDEBUG == 0) { |
| log(); |
| } |
| |
| for (size_t i = 0; i < offVecSize; ++i) { |
| uint32_t ifdKey = offsetVector.keyAt(i); |
| uint32_t nextOffset = offsetVector[i]; |
| uint32_t sizeToWrite = mNamedIfds[ifdKey]->getStripSize(); |
| bool found = false; |
| for (size_t j = 0; j < sourcesCount; ++j) { |
| if (sources[j]->getIfd() == ifdKey) { |
| if ((ret = sources[i]->writeToStream(endOut, sizeToWrite)) != OK) { |
| ALOGE("%s: Could not write to stream, received %d.", __FUNCTION__, ret); |
| return ret; |
| } |
| ZERO_TILL_WORD(&endOut, sizeToWrite, ret); |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| ALOGE("%s: No stream for byte strips for IFD %u", __FUNCTION__, ifdKey); |
| return BAD_VALUE; |
| } |
| assert(nextOffset == endOut.getCurrentOffset()); |
| } |
| |
| return ret; |
| } |
| |
| status_t TiffWriter::write(Output* out, Endianness end) { |
| status_t ret = OK; |
| EndianOutput endOut(out, end); |
| |
| if (mIfd == NULL) { |
| ALOGE("%s: Tiff header is empty.", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| BAIL_ON_FAIL(writeFileHeader(endOut), ret); |
| |
| uint32_t offset = FILE_HEADER_SIZE; |
| sp<TiffIfd> ifd = mIfd; |
| while(ifd != NULL) { |
| BAIL_ON_FAIL(ifd->writeData(offset, &endOut), ret); |
| offset += ifd->getSize(); |
| ifd = ifd->getNextIfd(); |
| } |
| return ret; |
| } |
| |
| |
| const TagDefinition_t* TiffWriter::lookupDefinition(uint16_t tag) const { |
| const TagDefinition_t* definition = NULL; |
| for (size_t i = 0; i < mNumTagMaps; ++i) { |
| ssize_t index = mTagMaps[i].indexOfKey(tag); |
| if (index >= 0) { |
| definition = mTagMaps[i][index]; |
| break; |
| } |
| } |
| |
| if (definition == NULL) { |
| ALOGE("%s: No definition exists for tag with id %x.", __FUNCTION__, tag); |
| } |
| return definition; |
| } |
| |
| sp<TiffEntry> TiffWriter::getEntry(uint16_t tag, uint32_t ifd) const { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| if (index < 0) { |
| ALOGE("%s: No IFD %d set for this writer.", __FUNCTION__, ifd); |
| return NULL; |
| } |
| return mNamedIfds[index]->getEntry(tag); |
| } |
| |
| void TiffWriter::removeEntry(uint16_t tag, uint32_t ifd) { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| if (index >= 0) { |
| mNamedIfds[index]->removeEntry(tag); |
| } |
| } |
| |
| status_t TiffWriter::addEntry(const sp<TiffEntry>& entry, uint32_t ifd) { |
| uint16_t tag = entry->getTag(); |
| |
| const TagDefinition_t* definition = lookupDefinition(tag); |
| |
| if (definition == NULL) { |
| ALOGE("%s: No definition exists for tag 0x%x.", __FUNCTION__, tag); |
| return BAD_INDEX; |
| } |
| |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| |
| // Add a new IFD if necessary |
| if (index < 0) { |
| ALOGE("%s: No IFD %u exists.", __FUNCTION__, ifd); |
| return NAME_NOT_FOUND; |
| } |
| |
| sp<TiffIfd> selectedIfd = mNamedIfds[index]; |
| return selectedIfd->addEntry(entry); |
| } |
| |
| status_t TiffWriter::addStrip(uint32_t ifd) { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| if (index < 0) { |
| ALOGE("%s: Ifd %u doesn't exist, cannot add strip entries.", __FUNCTION__, ifd); |
| return BAD_VALUE; |
| } |
| sp<TiffIfd> selected = mNamedIfds[index]; |
| return selected->validateAndSetStripTags(); |
| } |
| |
| status_t TiffWriter::addIfd(uint32_t ifd) { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| if (index >= 0) { |
| ALOGE("%s: Ifd with ID 0x%x already exists.", __FUNCTION__, ifd); |
| return BAD_VALUE; |
| } |
| |
| sp<TiffIfd> newIfd = new TiffIfd(ifd); |
| if (mIfd == NULL) { |
| mIfd = newIfd; |
| } else { |
| sp<TiffIfd> last = findLastIfd(); |
| last->setNextIfd(newIfd); |
| } |
| |
| if(mNamedIfds.add(ifd, newIfd) < 0) { |
| ALOGE("%s: Failed to add new IFD 0x%x.", __FUNCTION__, ifd); |
| return BAD_VALUE; |
| } |
| |
| return OK; |
| } |
| |
| status_t TiffWriter::addSubIfd(uint32_t parentIfd, uint32_t ifd, SubIfdType type) { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| if (index >= 0) { |
| ALOGE("%s: Ifd with ID 0x%x already exists.", __FUNCTION__, ifd); |
| return BAD_VALUE; |
| } |
| |
| ssize_t parentIndex = mNamedIfds.indexOfKey(parentIfd); |
| if (parentIndex < 0) { |
| ALOGE("%s: Parent IFD with ID 0x%x does not exist.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| |
| sp<TiffIfd> parent = mNamedIfds[parentIndex]; |
| sp<TiffIfd> newIfd = new TiffIfd(ifd); |
| |
| uint16_t subIfdTag; |
| if (type == SUBIFD) { |
| subIfdTag = TAG_SUBIFDS; |
| } else if (type == GPSINFO) { |
| subIfdTag = TAG_GPSINFO; |
| } else { |
| ALOGE("%s: Unknown SubIFD type %d.", __FUNCTION__, type); |
| return BAD_VALUE; |
| } |
| |
| sp<TiffEntry> subIfds = parent->getEntry(subIfdTag); |
| if (subIfds == NULL) { |
| if (buildEntry(subIfdTag, 1, &newIfd, &subIfds) < 0) { |
| ALOGE("%s: Failed to build SubIfd entry in IFD 0x%x.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| } else { |
| if (type == GPSINFO) { |
| ALOGE("%s: Cannot add GPSInfo SubIFD to IFD %u, one already exists.", __FUNCTION__, |
| ifd); |
| return BAD_VALUE; |
| } |
| |
| Vector<sp<TiffIfd> > subIfdList; |
| const sp<TiffIfd>* oldIfdArray = subIfds->getData<sp<TiffIfd> >(); |
| if (subIfdList.appendArray(oldIfdArray, subIfds->getCount()) < 0) { |
| ALOGE("%s: Failed to build SubIfd entry in IFD 0x%x.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| |
| if (subIfdList.add(newIfd) < 0) { |
| ALOGE("%s: Failed to build SubIfd entry in IFD 0x%x.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| |
| uint32_t count = subIfdList.size(); |
| if (buildEntry(subIfdTag, count, subIfdList.array(), &subIfds) < 0) { |
| ALOGE("%s: Failed to build SubIfd entry in IFD 0x%x.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| } |
| |
| if (parent->addEntry(subIfds) < 0) { |
| ALOGE("%s: Failed to add SubIfd entry in IFD 0x%x.", __FUNCTION__, parentIfd); |
| return BAD_VALUE; |
| } |
| |
| if(mNamedIfds.add(ifd, newIfd) < 0) { |
| ALOGE("%s: Failed to add new IFD 0x%x.", __FUNCTION__, ifd); |
| return BAD_VALUE; |
| } |
| |
| return OK; |
| } |
| |
| TagType TiffWriter::getDefaultType(uint16_t tag) const { |
| const TagDefinition_t* definition = lookupDefinition(tag); |
| if (definition == NULL) { |
| ALOGE("%s: Could not find definition for tag %x", __FUNCTION__, tag); |
| return UNKNOWN_TAGTYPE; |
| } |
| return definition->defaultType; |
| } |
| |
| uint32_t TiffWriter::getDefaultCount(uint16_t tag) const { |
| const TagDefinition_t* definition = lookupDefinition(tag); |
| if (definition == NULL) { |
| ALOGE("%s: Could not find definition for tag %x", __FUNCTION__, tag); |
| return 0; |
| } |
| return definition->fixedCount; |
| } |
| |
| bool TiffWriter::hasIfd(uint32_t ifd) const { |
| ssize_t index = mNamedIfds.indexOfKey(ifd); |
| return index >= 0; |
| } |
| |
| bool TiffWriter::checkIfDefined(uint16_t tag) const { |
| return lookupDefinition(tag) != NULL; |
| } |
| |
| const char* TiffWriter::getTagName(uint16_t tag) const { |
| const TagDefinition_t* definition = lookupDefinition(tag); |
| if (definition == NULL) { |
| return NULL; |
| } |
| return definition->tagName; |
| } |
| |
| sp<TiffIfd> TiffWriter::findLastIfd() { |
| sp<TiffIfd> ifd = mIfd; |
| while(ifd != NULL) { |
| sp<TiffIfd> nextIfd = ifd->getNextIfd(); |
| if (nextIfd == NULL) { |
| break; |
| } |
| ifd = nextIfd; |
| } |
| return ifd; |
| } |
| |
| status_t TiffWriter::writeFileHeader(EndianOutput& out) { |
| status_t ret = OK; |
| uint16_t endMarker = (out.getEndianness() == BIG) ? BIG_ENDIAN_MARKER : LITTLE_ENDIAN_MARKER; |
| BAIL_ON_FAIL(out.write(&endMarker, 0, 1), ret); |
| |
| uint16_t tiffMarker = TIFF_FILE_MARKER; |
| BAIL_ON_FAIL(out.write(&tiffMarker, 0, 1), ret); |
| |
| uint32_t offsetMarker = FILE_HEADER_SIZE; |
| BAIL_ON_FAIL(out.write(&offsetMarker, 0, 1), ret); |
| return ret; |
| } |
| |
| uint32_t TiffWriter::getTotalSize() const { |
| uint32_t totalSize = FILE_HEADER_SIZE; |
| sp<TiffIfd> ifd = mIfd; |
| while(ifd != NULL) { |
| totalSize += ifd->getSize(); |
| ifd = ifd->getNextIfd(); |
| } |
| return totalSize; |
| } |
| |
| void TiffWriter::log() const { |
| ALOGI("%s: TiffWriter:", __FUNCTION__); |
| size_t length = mNamedIfds.size(); |
| for (size_t i = 0; i < length; ++i) { |
| mNamedIfds[i]->log(); |
| } |
| } |
| |
| } /*namespace img_utils*/ |
| } /*namespace android*/ |