vcl/source/filter/jpeg/Exif.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "Exif.hxx"
  21 #include <memory>
  22 #include <osl/endian.h>
  23 #include <tools/stream.hxx>
  24
  25 Exif::Exif() :
  26     maOrientation(exif::TOP_LEFT),
  27     mbExifPresent(false)
  28 {}
  29
  30 void Exif::setOrientation(exif::Orientation aOrientation) {
  31     maOrientation = aOrientation;
  32 }
  33
  34 exif::Orientation Exif::convertToOrientation(sal_Int32 value)
  35 {
  36     switch(value) {
  37         case 1: return exif::TOP_LEFT;
  38         case 2: return exif::TOP_RIGHT;
  39         case 3: return exif::BOTTOM_RIGHT;
  40         case 4: return exif::BOTTOM_LEFT;
  41         case 5: return exif::LEFT_TOP;
  42         case 6: return exif::RIGHT_TOP;
  43         case 7: return exif::RIGHT_BOTTOM;
  44         case 8: return exif::LEFT_BOTTOM;
  45     }
  46     return exif::TOP_LEFT;
  47 }
  48
  49 Degree10 Exif::getRotation() const
  50 {
  51     switch(maOrientation) {
  52         case exif::TOP_LEFT:
  53             return 0_deg10;
  54         case exif::BOTTOM_RIGHT:
  55             return 1800_deg10;
  56         case exif::RIGHT_TOP:
  57             return 2700_deg10;
  58         case exif::LEFT_BOTTOM:
  59             return 900_deg10;
  60         default:
  61             break;
  62     }
  63     return 0_deg10;
  64 }
  65
  66 bool Exif::read(SvStream& rStream)
  67 {
  68     sal_uInt64 nStreamPosition = rStream.Tell();
  69     bool result = processJpeg(rStream, false);
  70     rStream.Seek( nStreamPosition );
  71
  72     return result;
  73 }
  74
  75 void Exif::write(SvStream& rStream)
  76 {
  77     sal_uInt64 nStreamPosition = rStream.Tell();
  78     processJpeg(rStream, true);
  79     rStream.Seek( nStreamPosition );
  80 }
  81
  82 bool Exif::processJpeg(SvStream& rStream, bool bSetValue)
  83 {
  84     sal_uInt16  aMagic16;
  85     sal_uInt16  aLength;
  86
  87     sal_uInt64 aSize = rStream.TellEnd();
  88     rStream.Seek(STREAM_SEEK_TO_BEGIN);
  89
  90     rStream.SetEndian( SvStreamEndian::BIG );
  91     rStream.ReadUInt16( aMagic16 );
  92
  93     // Compare JPEG magic bytes
  94     if( 0xFFD8 != aMagic16 )
  95     {
  96         return false;
  97     }
  98
  99     sal_uInt32 aPreviousPosition = STREAM_SEEK_TO_BEGIN;
 100
 101     while(true)
 102     {
 103         sal_uInt8 aMarker = 0xD9;
 104         sal_Int32 aCount;
 105
 106         for (aCount = 0; aCount < 7; aCount++)
 107         {
 108             rStream.ReadUChar( aMarker );
 109             if (aMarker != 0xFF)
 110             {
 111                 break;
 112             }
 113             if (aCount >= 6)
 114             {
 115                 return false;
 116             }
 117         }
 118
 119         rStream.ReadUInt16( aLength );
 120
 121         if (aLength < 8 || aLength > rStream.remainingSize())
 122         {
 123             return false;
 124         }
 125
 126         if (aMarker == 0xE1)
 127         {
 128             return processExif(rStream, aLength, bSetValue);
 129         }
 130         else if (aMarker == 0xD9)
 131         {
 132             return false;
 133         }
 134         else
 135         {
 136             sal_uInt64 aCurrentPosition = rStream.SeekRel(aLength-1);
 137             if (aCurrentPosition == aPreviousPosition || aCurrentPosition > aSize)
 138             {
 139                 return false;
 140             }
 141             aPreviousPosition = aCurrentPosition;
 142         }
 143     }
 144     return false;
 145 }
 146
 147 namespace {
 148
 149 sal_uInt16 read16(sal_uInt8 const (& data)[2], bool littleEndian) {
 150     if (littleEndian) {
 151         return data[0] | (sal_uInt16(data[1]) << 8);
 152     } else {
 153         return data[1] | (sal_uInt16(data[0]) << 8);
 154     }
 155 }
 156
 157 void write16(sal_uInt16 value, sal_uInt8 (& data)[2], bool littleEndian) {
 158     if (littleEndian) {
 159         data[0] = value & 0xFF;
 160         data[1] = value >> 8;
 161     } else {
 162         data[1] = value & 0xFF;
 163         data[0] = value >> 8;
 164     }
 165 }
 166
 167 void write32(sal_uInt32 value, sal_uInt8 (& data)[4], bool littleEndian) {
 168     if (littleEndian) {
 169         data[0] = value & 0xFF;
 170         data[1] = (value >> 8) & 0xFF;
 171         data[2] = (value >> 16) & 0xFF;
 172         data[3] = value >> 24;
 173     } else {
 174         data[3] = value & 0xFF;
 175         data[2] = (value >> 8) & 0xFF;
 176         data[1] = (value >> 16) & 0xFF;
 177         data[0] = value >> 24;
 178     }
 179 }
 180
 181 }
 182
 183 void Exif::processIFD(sal_uInt8* pExifData, sal_uInt16 aLength, sal_uInt16 aOffset, sal_uInt16 aNumberOfTags, bool bSetValue, bool littleEndian)
 184 {
 185     ExifIFD* ifd = nullptr;
 186
 187     while (aOffset <= aLength - 12 && aNumberOfTags > 0)
 188     {
 189         ifd = reinterpret_cast<ExifIFD*>(&pExifData[aOffset]);
 190         sal_uInt16 tag = read16(ifd->tag, littleEndian);
 191
 192         if (tag == ORIENTATION)
 193         {
 194             if(bSetValue)
 195             {
 196                 write16(3, ifd->type, littleEndian);
 197                 write32(1, ifd->count, littleEndian);
 198                 write16(
 199                     maOrientation, reinterpret_cast<sal_uInt8 (&)[2]>(ifd->offset), littleEndian);
 200             }
 201             else
 202             {
 203                 sal_uInt16 nIfdOffset = read16(
 204                     reinterpret_cast<sal_uInt8 (&)[2]>(ifd->offset), littleEndian);
 205                 maOrientation = convertToOrientation(nIfdOffset);
 206             }
 207         }
 208
 209         aNumberOfTags--;
 210         aOffset += 12;
 211     }
 212 }
 213
 214 bool Exif::processExif(SvStream& rStream, sal_uInt16 aSectionLength, bool bSetValue)
 215 {
 216     sal_uInt32  aMagic32;
 217     sal_uInt16  aMagic16;
 218
 219     rStream.ReadUInt32( aMagic32 );
 220     rStream.ReadUInt16( aMagic16 );
 221
 222     // Compare EXIF magic bytes
 223     if( 0x45786966 != aMagic32 || 0x0000 != aMagic16)
 224     {
 225         return false;
 226     }
 227
 228     sal_uInt16 aLength = aSectionLength - 6; // Length = Section - Header
 229
 230     std::unique_ptr<sal_uInt8[]> aExifData(new sal_uInt8[aLength]);
 231     sal_uInt64 aExifDataBeginPosition = rStream.Tell();
 232
 233     rStream.ReadBytes(aExifData.get(), aLength);
 234
 235     // Exif detected
 236     mbExifPresent = true;
 237
 238     TiffHeader* aTiffHeader = reinterpret_cast<TiffHeader*>(&aExifData[0]);
 239
 240     bool bIntel = aTiffHeader->byteOrder == 0x4949;      //little-endian
 241     bool bMotorola = aTiffHeader->byteOrder == 0x4D4D;   //big-endian
 242
 243     if (!bIntel && !bMotorola)
 244     {
 245         return false;
 246     }
 247
 248     bool bSwap = false;
 249
 250 #ifdef OSL_BIGENDIAN
 251     if (bIntel)
 252         bSwap = true;
 253 #else
 254     if (bMotorola)
 255         bSwap = true;
 256 #endif
 257
 258     if (bSwap)
 259     {
 260         aTiffHeader->tagAlign = OSL_SWAPWORD(aTiffHeader->tagAlign);
 261         aTiffHeader->offset = OSL_SWAPDWORD(aTiffHeader->offset);
 262     }
 263
 264     if (aTiffHeader->tagAlign != 0x002A) // TIFF tag
 265     {
 266         return false;
 267     }
 268
 269     sal_uInt16 aOffset = aTiffHeader->offset;
 270
 271     sal_uInt16 aNumberOfTags = aExifData[aOffset];
 272     if (bSwap)
 273     {
 274         aNumberOfTags = ((aExifData[aOffset] << 8) | aExifData[aOffset+1]);
 275     }
 276
 277     processIFD(aExifData.get(), aLength, aOffset+2, aNumberOfTags, bSetValue, bIntel);
 278
 279     if (bSetValue)
 280     {
 281         rStream.Seek(aExifDataBeginPosition);
 282         rStream.WriteBytes(aExifData.get(), aLength);
 283     }
 284
 285     return true;
 286 }
 287
 288 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */