libopenraw
orffile.cpp
1 /*
2  * libopenraw - orffile.cpp
3  *
4  * Copyright (C) 2006-2016 Hubert Figuiere
5  *
6  * This library is free software: you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public License
8  * as published by the Free Software Foundation, either version 3 of
9  * the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library. If not, see
18  * <http://www.gnu.org/licenses/>.
19  */
20 
21 #include <algorithm>
22 #include <cstdint>
23 #include <memory>
24 
25 #include <libopenraw/debug.h>
26 #include <libopenraw/cameraids.h>
27 #include <libopenraw/consts.h>
28 
29 #include "cfapattern.hpp"
30 #include "rawdata.hpp"
31 #include "rawfile.hpp"
32 
33 #include "ifdfilecontainer.hpp"
34 #include "makernotedir.hpp"
35 
36 #include "trace.hpp"
37 #include "orffile.hpp"
38 #include "ifd.hpp"
39 #include "ifddir.hpp"
40 #include "ifdentry.hpp"
41 #include "orfcontainer.hpp"
42 #include "olympusdecompressor.hpp"
43 #include "rawfile_private.hpp"
44 #include "io/streamclone.hpp"
45 #include "jfifcontainer.hpp"
46 
47 using namespace Debug;
48 
49 namespace OpenRaw {
50 namespace Internals {
51 
52 #define OR_MAKE_OLYMPUS_TYPEID(camid) \
53  OR_MAKE_FILE_TYPEID(OR_TYPEID_VENDOR_OLYMPUS,camid)
54 
55 /* taken from dcraw, by default */
56 static const BuiltinColourMatrix s_matrices[] = {
57  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E1), 0, 0,
58  { 11846,-4767,-945,-7027,15878,1089,-2699,4122,8311 } },
59  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E10), 0, 0xffc,
60  { 12745,-4500,-1416,-6062,14542,1580,-1934,2256,6603 } },
61  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E3), 0, 0xf99,
62  { 9487,-2875,-1115,-7533,15606,2010,-1618,2100,7389 } },
63  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E5), 0, 0,
64  { 11200,-3783,-1325,-4576,12593,2206,-695,1742,7504 } },
65  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E300), 0, 0,
66  { 7828,-1761,-348,-5788,14071,1830,-2853,4518,6557 } },
67  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E330), 0, 0,
68  { 8961,-2473,-1084,-7979,15990,2067,-2319,3035,8249 } },
69  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E400), 0, 0,
70  { 6169,-1483,-21,-7107,14761,2536,-2904,3580,8568 } },
71  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E410), 0, 0xf6a,
72  { 8856,-2582,-1026,-7761,15766,2082,-2009,2575,7469 } },
73  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E500), 0, 0,
74  { 8136,-1968,-299,-5481,13742,1871,-2556,4205,6630 } },
75  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E510), 0, 0xf6a,
76  { 8785,-2529,-1033,-7639,15624,2112,-1783,2300,7817 } },
77  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E620), 0, 0xfaf,
78  { 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
79  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP350), 0, 0,
80  { 12078,-4836,-1069,-6671,14306,2578,-786,939,7418 } },
81  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP500), 0, 0xfff,
82  { 9493,-3415,-666,-5211,12334,3260,-1548,2262,6482 } },
83  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP510), 0, 0xffe,
84  { 10593,-3607,-1010,-5881,13127,3084,-1200,1805,6721 } },
85  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP550), 0, 0xffe,
86  { 11597,-4006,-1049,-5432,12799,2957,-1029,1750,6516 } },
87  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP1), 0, 0xffd,
88  { 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
89  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP2), 0, 0xffd,
90  { 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
91  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP3), 0, 0,
92  { 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
93  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL1), 0, 0,
94  { 11408,-4289,-1215,-4286,12385,2118,-387,1467,7787 } },
95  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL2), 0, 0,
96  { 15030,-5552,-1806,-3987,12387,1767,-592,1670,7023 } },
97  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL3), 0, 0,
98  { 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
99  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL5), 0, 0xfcb,
100  { 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
101  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL6), 0, 0xfcb,
102  { 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
103  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL7), 0, 0xfcb,
104  { 9197,-3190,-659,-2606,10830,2039,-458,1250,5458 } },
105  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPM1), 0, 0,
106  { 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
107  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPM2), 0, 0,
108  { 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
109  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_XZ1), 0, 0,
110  { 10901,-4095,-1074,-1141,9208,2293,-62,1417,5158 } },
111  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_XZ2), 0, 0,
112  { 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
113  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EM5), 0, 0xfe1,
114  { 8380, -2630, -639, -2887, 725, 2496, -627, 1427, 5438 } },
115  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EM1), 0, 0,
116  { 7687, -1984, -606, -4327, 11928, 2721, -1381, 2339, 6452 } },
117  { OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_STYLUS1), 0, 0,
118  { 8360, -2420, -880, -3928, 12353, 1739, -1381, 2416, 5173 } },
119 
120  { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
121 
122 };
123 
124 const struct IfdFile::camera_ids_t OrfFile::s_def[] = {
125  { "E-1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E1) },
126  { "E-10 " , OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E10) },
127  { "E-3 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E3) },
128  { "E-5 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E5) },
129  { "E-300 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E300) },
130  { "E-330 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E330) },
131  { "E-400 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E400) },
132  { "E-410 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E410) },
133  { "E-500 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E500) },
134  { "E-510 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E510) },
135  { "E-620 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_E620) },
136  { "SP350" , OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP350) },
137  { "SP500UZ" , OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP500) },
138  { "SP510UZ" , OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP510) },
139  { "SP550UZ ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_SP550) },
140  { "E-P1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP1) },
141  { "E-P2 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP2) },
142  { "E-P3 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EP3) },
143  { "E-PL1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL1) },
144  { "E-PL2 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL2) },
145  { "E-PL3 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL3) },
146  { "E-PL5 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL5) },
147  { "E-PL6 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL6) },
148  { "E-PL7 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPL7) },
149  { "E-PM1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPM1) },
150  { "E-PM2 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EPM2) },
151  { "XZ-1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_XZ1) },
152  { "XZ-2 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_XZ2) },
153  { "E-M5 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EM5) },
154  { "E-M5MarkII ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EM5II) },
155  { "E-M1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_EM1) },
156  { "STYLUS1 ", OR_MAKE_OLYMPUS_TYPEID(OR_TYPEID_OLYMPUS_STYLUS1) },
157  { 0, 0 }
158 };
159 
160 RawFile *OrfFile::factory(const IO::Stream::Ptr &s)
161 {
162  return new OrfFile(s);
163 }
164 
165 OrfFile::OrfFile(const IO::Stream::Ptr &s)
166  : IfdFile(s, OR_RAWFILE_TYPE_ORF, false)
167 {
168  _setIdMap(s_def);
169  _setMatrices(s_matrices);
170  m_container = new OrfContainer(m_io, 0);
171 }
172 
173 OrfFile::~OrfFile()
174 {
175 }
176 
177 IfdDir::Ref OrfFile::_locateCfaIfd()
178 {
179  // in ORF the CFA IFD is the main IFD
180  return mainIfd();
181 }
182 
183 
184 IfdDir::Ref OrfFile::_locateMainIfd()
185 {
186  return m_container->setDirectory(0);
187 }
188 
189 ::or_error OrfFile::_enumThumbnailSizes(std::vector<uint32_t> &list)
190 {
191  auto err = OR_ERROR_NOT_FOUND;
192 
193  err = IfdFile::_enumThumbnailSizes(list);
194 
195  auto exif = exifIfd();
196  if (!exif) {
197  return err;
198  }
199 
200  auto ifd = exif->getMakerNoteIfd();
201  if (!ifd) {
202  return err;
203  }
204  auto makerNote = std::dynamic_pointer_cast<MakerNoteDir>(ifd);
205  if (!makerNote) {
206  return err;
207  }
208 
209  auto e = makerNote->getEntry(0x100);
210  if (e) {
211  auto val_offset = e->offset();
212 
213  val_offset += makerNote->getMnoteOffset();
214 
215  Trace(DEBUG1) << "fetching JPEG\n";
216  IO::Stream::Ptr s(
217  std::make_shared<IO::StreamClone>(m_io, val_offset));
218  std::unique_ptr<JfifContainer> jfif(new JfifContainer(s, 0));
219 
220  uint32_t x, y;
221  x = y = 0;
222  jfif->getDimensions(x, y);
223  Trace(DEBUG1) << "JPEG dimensions x=" << x
224  << " y=" << y << "\n";
225 
226  uint32_t dim = std::max(x, y);
227  if (dim) {
228  _addThumbnail(dim, ThumbDesc(x, y, OR_DATA_TYPE_JPEG,
229  val_offset, e->count()));
230  list.push_back(dim);
231  err = OR_ERROR_NONE;
232  }
233  }
234 
235  return err;
236 }
237 
238 ::or_error OrfFile::_getRawData(RawData & data, uint32_t options)
239 {
240  ::or_error err;
241  const IfdDir::Ref & _cfaIfd = cfaIfd();
242  err = _getRawDataFromDir(data, _cfaIfd);
243  if(err == OR_ERROR_NONE) {
244  // ORF files seems to be marked as uncompressed even if they are.
245  uint32_t x = data.width();
246  uint32_t y = data.height();
247  uint32_t compression = 0;
248  if(data.size() < x * y * 2) {
249  compression = ORF_COMPRESSION;
250  data.setCompression(ORF_COMPRESSION);
251  data.setDataType(OR_DATA_TYPE_COMPRESSED_RAW);
252  }
253  else {
254  compression = data.compression();
255  }
256  switch(compression) {
257  case ORF_COMPRESSION:
258  if((options & OR_OPTIONS_DONT_DECOMPRESS) == 0) {
259  OlympusDecompressor decomp((const uint8_t*)data.data(),
260  data.size(), m_container, x, y);
261  RawData *dData = decomp.decompress(nullptr);
262  if (dData) {
263  dData->setCfaPatternType(data.cfaPattern()->patternType());
264  data.swap(*dData);
265  data.setDataType(OR_DATA_TYPE_RAW);
266  data.setDimensions(x, y);
267  delete dData;
268  }
269  }
270  break;
271  default:
272  break;
273  }
274  }
275  return err;
276 }
277 
278 uint32_t OrfFile::_translateCompressionType(IFD::TiffCompress tiffCompression)
279 {
280  if(tiffCompression == IFD::COMPRESS_CUSTOM) {
281  return ORF_COMPRESSION;
282  }
283  return (uint32_t)tiffCompression;
284 }
285 
286 }
287 }
288 /*
289  Local Variables:
290  mode:c++
291  c-file-style:"stroustrup"
292  c-file-offsets:((innamespace . 0))
293  indent-tabs-mode:nil
294  fill-column:80
295  End:
296 */
CIFF is the container for CRW files. It is an attempt from Canon to make this a standard. I guess it failed.
Definition: arwfile.cpp:30
size_t size() const
Definition: bitmapdata.cpp:129
void swap(RawData &with)
Definition: rawdata.cpp:245
Definition: trace.cpp:30
::or_cfa_pattern patternType() const
Definition: cfapattern.cpp:186
const CfaPattern * cfaPattern() const
Definition: rawdata.cpp:287
void setDataType(DataType _type)
Definition: bitmapdata.cpp:100
generic IFD based raw file.
Definition: ifdfile.hpp:48
virtual void setDimensions(uint32_t x, uint32_t y) override
Definition: rawdata.cpp:260