libopenraw
neffile.cpp
1 /* -*- tab-width:4; c-basic-offset:4 -*- */
2 /*
3  * libopenraw - neffile.cpp
4  *
5  * Copyright (C) 2006-2016 Hubert Figuiere
6  * Copyright (C) 2008 Novell, Inc.
7  *
8  * This library is free software: you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation, either version 3 of
11  * the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library. If not, see
20  * <http://www.gnu.org/licenses/>.
21  */
22 
23 #include <stddef.h>
24 #include <stdio.h>
25 #include <sys/types.h>
26 
27 #include <cstdint>
28 #include <memory>
29 #include <vector>
30 
31 #include <libopenraw/cameraids.h>
32 #include <libopenraw/consts.h>
33 #include <libopenraw/debug.h>
34 
35 #include "cfapattern.hpp"
36 #include "rawdata.hpp"
37 #include "rawfile.hpp"
38 
39 
40 #include "trace.hpp"
41 #include "ifd.hpp"
42 #include "ifdfilecontainer.hpp"
43 #include "ifdentry.hpp"
44 #include "makernotedir.hpp"
45 #include "nefdiffiterator.hpp"
46 #include "nefcfaiterator.hpp"
47 #include "neffile.hpp"
48 #include "rawcontainer.hpp"
49 #include "rawfile_private.hpp"
50 
51 using namespace Debug;
52 
53 namespace OpenRaw {
54 
55 namespace Internals {
56 
57 #define OR_MAKE_NIKON_TYPEID(camid) \
58  OR_MAKE_FILE_TYPEID(OR_TYPEID_VENDOR_NIKON,camid)
59 
60 /* taken from dcraw, by default */
61 static const BuiltinColourMatrix s_matrices[] = {
62  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D1), 0, 0, /* multiplied by 2.218750, 1.0, 1.148438 */
63  { 16772,-4726,-2141,-7611,15713,1972,-2846,3494,9521 } },
64  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D100), 0, 0,
65  { 5902,-933,-782,-8983,16719,2354,-1402,1455,6464 } },
66  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D1X), 0, 0,
67  { 7702,-2245,-975,-9114,17242,1875,-2679,3055,8521 } },
68  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D200), 0, 0xfbc,
69  { 8367,-2248,-763,-8758,16447,2422,-1527,1550,8053 } },
70  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D2H), 0, 0,
71  { 5710,-901,-615,-8594,16617,2024,-2975,4120,6830 } },
72  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D2X), 0, 0,
73  { 10231,-2769,-1255,-8301,15900,2552,-797,680,7148 } },
74 
75  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3), 0, 0,
76  { 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
77  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3S), 0, 0,
78  { 8828,-2406,-694,-4874,12603,2541,-660,1509,7587 } },
79  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3X), 0, 0,
80  { 7171,-1986,-648,-8085,15555,2718,-2170,2512,7457 } },
81  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D300), 0, 0,
82  { 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
83  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D300S), 0, 0,
84  { 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
85  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3000), 0, 0,
86  { 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
87  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3100), 0, 0,
88  { 7911,-2167,-813,-5327,13150,2408,-1288,2483,7968 } },
89  // From DNG Converter 7.1-rc
90  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3200), 0, 0,
91  { 7911, -2167, -813, -5327, 1315, 2408, -1288, 2483, 7968 } },
92  // From DNG Converter 7.1-rc
93  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D4), 0, 0,
94  { 8598, -2848, -857, -5618, 13606, 2195, -1002, 1773, 7137 } },
95  // Identical to D4 according to dcraw.
96  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D4S), 0, 0,
97  { 8598, -2848, -857, -5618, 13606, 2195, -1002, 1773, 7137 } },
98  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D40), 0, 0,
99  { 6992,-1668,-806,-8138,15748,2543,-874,850,7897 } },
100  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D40X), 0, 0,
101  { 8819,-2543,-911,-9025,16928,2151,-1329,1213,8449 } },
102  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D50), 0, 0,
103  { 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
104  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5000), 0, 0xf00,
105  { 7309,-1403,-519,-8474,16008,2622,-2433,2826,8064 } },
106  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5100), 0, 0x3de6,
107  { 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
108  // From DNG Converter 7.4
109  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5200), 0, 0,
110  { 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
111  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D60), 0, 0,
112  { 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
113  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D600), 0, 0,
114  { 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
115  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D610), 0, 0,
116  { 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
117  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D70), 0, 0,
118  { 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
119  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D70S), 0, 0,
120  { 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
121  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D700), 0, 0,
122  { 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
123  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D7000), 0, 0,
124  { 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
125  // From DNG Converter 7.4
126  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D7100), 0, 0,
127  { 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
128  // From DNG Converter 8.7-rc
129  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D750), 0, 0,
130  { 9020, -2890, -715, -4535, 12436, 2348, -934, 1919, 7086 } },
131  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D80), 0, 0,
132  { 8629,-2410,-883,-9055,16940,2171,-1490,1363,8520 } },
133  // From DNG Converter 7.1-rc
134  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D800), 0, 0,
135  { 7866, -2108, -555, -4869, 12483, 2681, -1176, 2069, 7501 } },
136  // From DNG Converter 7.1-rc
137  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D800E), 0, 0,
138  { 7866, -2108, -555, -4869, 12483, 2681, -1176, 2069, 7501 } },
139  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D90), 0, 0xf00,
140  { 7309,-1403,-519,-8474,16008,2622,-2434,2826,8064 } },
141  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_DF), 0, 0,
142  { 8598,-2848,-857,-5618,13606,2195,-1002,1773,7137 } },
143  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E5400), 0, 0,
144  { 9349,-2987,-1001,-7919,15766,2266,-2098,2680,6839 } },
145 
146 // { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E5700), 0, 0,
147 // { -5368,11478,2368,5537,-113,3148,-4969,10021,5782,778,9028,211 } },
148  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E8400), 0, 0,
149  { 7842,-2320,-992,-8154,15718,2599,-1098,1342,7560 } },
150  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P6000), 0, 0,
151  { 9698,-3367,-914,-4706,12584,2368,-837,968,5801 } },
152  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7000), 0, 0,
153  { 11432,-3679,-1111,-3169,11239,2202,-791,1380,4455 } },
154  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7100), 0, 0,
155  { 11053,-4269,-1024,-1976,10182,2088,-526,1263,4469 } },
156  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7700), 0, 0,
157  { 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
158  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J1), 0, 0,
159  { 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
160  // From DNG Converter 7.4
161  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J2), 0, 0,
162  { 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
163  // From DNG Converter 7.4
164  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J3), 0, 0,
165  { 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
166  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_V1), 0, 0,
167  { 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
168  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_V2), 0, 0,
169  { 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
170  // From DNG Converter 7.4
171  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_S1), 0, 0,
172  { 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
173  // From DNG Converter 7.4
174  { OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_A), 0, 0,
175  { 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
176  { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
177 };
178 
179 const IfdFile::camera_ids_t NefFile::s_def[] = {
180  { "NIKON D1 ", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D1) },
181  { "NIKON D100 ", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D100) },
182  { "NIKON D1X", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D1X) },
183  { "NIKON D200", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D200) },
184  { "NIKON D2H", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D2H ) },
185  { "NIKON D2X", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D2X ) },
186  { "NIKON D3", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3) },
187  { "NIKON D3S", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3S) },
188  { "NIKON D3X", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3X) },
189  { "NIKON D300", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D300) },
190  { "NIKON D300S", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D300S) },
191  { "NIKON D3000", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3000) },
192  { "NIKON D3100", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3100) },
193  { "NIKON D3200", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3200) },
194  { "NIKON D3300", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D3300) },
195  { "NIKON D4", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D4) },
196  { "NIKON D4S", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D4S) },
197  { "NIKON D40", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D40) },
198  { "NIKON D40X", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D40X) },
199  { "NIKON D50", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D50) },
200  { "NIKON D5000", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5000) },
201  { "NIKON D5100", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5100) },
202  { "NIKON D5200", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5200) },
203  { "NIKON D5300", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5300) },
204  { "NIKON D5500", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D5500) },
205  { "NIKON D60", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D60) },
206  { "NIKON D600", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D600) },
207  { "NIKON D610", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D610) },
208  { "NIKON D70", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D70) },
209  { "NIKON D70s", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D70S) },
210  { "NIKON D700", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D700) },
211  { "NIKON D7000", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D7000) },
212  { "NIKON D7100", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D7100) },
213  { "NIKON D7200", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D7200) },
214  { "NIKON D750", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D750) },
215  { "NIKON D80", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D80) },
216  { "NIKON D800", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D800) },
217  { "NIKON D800E", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D800E) },
218  { "NIKON D810", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D810) },
219  { "NIKON D90", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_D90) },
220  { "NIKON Df", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_DF) },
221  { "E5400", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E5400) },
222  { "E5700", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E5700) },
223  { "E8400", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_E8400) },
224  { "COOLPIX P6000", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P6000) },
225  { "COOLPIX P7000", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7000) },
226  { "COOLPIX P7100", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7100) },
227  { "COOLPIX P7700", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_P7700) },
228  { "COOLPIX A", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_COOLPIX_A) },
229  { "NIKON 1 J1", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J1) },
230  { "NIKON 1 J2", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J2) },
231  { "NIKON 1 J3", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J3) },
232  { "NIKON 1 J5", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_J5) },
233  { "NIKON 1 V1", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_V1) },
234  { "NIKON 1 V2", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_V2) },
235  { "NIKON 1 V3", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_V3) },
236  { "NIKON 1 S1", OR_MAKE_NIKON_TYPEID(OR_TYPEID_NIKON_1_S1) },
237  { 0, 0 }
238 };
239 
240 RawFile *NefFile::factory(const IO::Stream::Ptr & _filename)
241 {
242  return new NefFile(_filename);
243 }
244 
245 NefFile::NefFile(const IO::Stream::Ptr & _filename)
246  : TiffEpFile(_filename, OR_RAWFILE_TYPE_NEF)
247 {
248  _setIdMap(s_def);
249  _setMatrices(s_matrices);
250 }
251 
252 
253 NefFile::~NefFile()
254 {
255 }
256 
257 bool NefFile::isCompressed(RawContainer & container, uint32_t offset)
258 {
259  int i;
260  uint8_t buf[256];
261  size_t real_size = container.fetchData(buf, offset,
262  256);
263  if(real_size != 256) {
264  return true;
265  }
266  for(i = 15; i < 256; i+= 16) {
267  if(buf[i]) {
268  Trace(DEBUG1) << "isCompressed: true\n";
269  return true;
270  }
271  }
272  Trace(DEBUG1) << "isCompressed: false\n";
273  return false;
274 }
275 
276 ::or_error NefFile::_decompressNikonQuantized(RawData & data)
277 {
279  if (!_getCompressionCurve(data, c)) {
280  Trace(ERROR) << "compression curve not found\n";
281  return OR_ERROR_NOT_FOUND;
282  }
283  const uint32_t rows = data.height();
284  const uint32_t raw_columns = data.width();
285 
286  //FIXME: not always true
287  const uint32_t columns = raw_columns - 1;
288 
290  diffs(c.huffman, static_cast<uint8_t*>(data.data()), data.size());
291  NefCfaIterator iter(diffs, rows, raw_columns, c.vpred);
292 
293  RawData newData;
294  uint16_t *p = (uint16_t *) newData.allocData(rows * columns * 2);
295  newData.setDimensions(columns, rows);
296  newData.setDataType(OR_DATA_TYPE_RAW);
297  uint16_t bpc = data.bpc();
298  newData.setBpc(bpc);
299  newData.setWhiteLevel((1 << bpc) - 1);
300  newData.setCfaPatternType(data.cfaPattern()->patternType());
301 
302  for (unsigned int i = 0; i < rows; i++) {
303  for (unsigned int j = 0; j < raw_columns; j++) {
304  uint16_t t = iter.get();
305  if (j < columns) {
306  unsigned shift = 16 - data.bpc();
307  p[i * columns + j] = c.curve[t & 0x3fff] << shift;
308  }
309  }
310  }
311 
312  data.swap(newData);
313  return OR_ERROR_NONE;
314 }
315 
316 ::or_error NefFile::_decompressIfNeeded(RawData & data,
317  uint32_t options)
318 {
319  uint32_t compression = data.compression();
320  if((options & OR_OPTIONS_DONT_DECOMPRESS) ||
321  compression == IFD::COMPRESS_NONE) {
322  return OR_ERROR_NONE;
323  } else if(compression == IFD::COMPRESS_NIKON_QUANTIZED) {
324  return _decompressNikonQuantized(data);
325  } else {
326  return OR_ERROR_INVALID_FORMAT;
327  }
328 }
329 
330 int NefFile::_getCompressionCurve(RawData & data, NefFile::NEFCompressionInfo& c)
331 {
332  MakerNoteDir::Ref _makerNoteIfd = makerNoteIfd();
333  if(!_makerNoteIfd) {
334  Trace(ERROR) << "makernote not found\n";
335  return 0;
336  }
337  IfdEntry::Ref curveEntry = _makerNoteIfd->getEntry(IFD::MNOTE_NIKON_NEFDECODETABLE2);
338  if(!curveEntry) {
339  Trace(ERROR) << "decode table2 tag not found\n";
340  return 0;
341  }
342 
343  size_t pos = _makerNoteIfd->getMnoteOffset() + curveEntry->offset();
344 
345  auto file = m_container->file();
346  file->seek(pos, SEEK_SET);
347 
348  uint8_t header0, header1;
349  bool read = m_container->readUInt8(file, header0);
350  if(!read) {
351  Trace(ERROR) << "Header not found\n";
352  return 0;
353  }
354  read = m_container->readUInt8(file, header1);
355  if(!read) {
356  Trace(ERROR) << "Header not found\n";
357  return 0;
358  }
359 
360  bool header_ok = false;
361  if (header0 == 0x44) {
362  if (header1 == 0x10) {
363  c.huffman = NefDiffIterator::Lossy12Bit;
364  data.setBpc(12);
365  header_ok = true;
366  } else if (header1 == 0x20) {
367  c.huffman = NefDiffIterator::Lossy14Bit;
368  data.setBpc(14);
369  header_ok = true;
370  }
371  } else if (header0 == 0x46 && header1 == 0x30) {
372  c.huffman = NefDiffIterator::LossLess14Bit;
373  data.setBpc(14);
374  header_ok = true;
375  }
376  if (!header_ok) {
377  Trace(ERROR) << "Wrong header, found " << header0 << "-"
378  << header1 << "\n";
379  return 0;
380  }
381 
382  int16_t aux;
383 
384  for (int i = 0; i < 2; ++i) {
385  for (int j = 0; j < 2; ++j) {
386  read = m_container->readInt16(file, aux);
387  if(!read) {
388  return 0;
389  }
390  c.vpred[i][j] = aux;
391  }
392  }
393 
394  if (header0 == 0x44) {
395  size_t nelems;
396  read = m_container->readInt16(file, aux);
397  nelems = aux;
398 
399  for (size_t i = 0; i < nelems; ++i) {
400  read = m_container->readInt16(file, aux);
401  if (!read)
402  return 0;
403  c.curve.push_back(aux);
404  }
405  } else if (header0 == 0x46 && header1 == 0x30) {
406  for (size_t i = 0; i <= 0x3fff; ++i) {
407  c.curve.push_back(i);
408  }
409  }
410 
411  return 1;
412 }
413 
414 }
415 }
416 
417 /*
418  Local Variables:
419  mode:c++
420  c-file-style:"stroustrup"
421  c-file-offsets:((innamespace . 0))
422  indent-tabs-mode:nil
423  fill-column:80
424  End:
425 */
size_t fetchData(void *buf, off_t offset, size_t buf_size)
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
uint32_t bpc() const
Definition: bitmapdata.cpp:159
size_t size() const
Definition: bitmapdata.cpp:129
void swap(RawData &with)
Definition: rawdata.cpp:245
void setBpc(uint32_t _bpc)
Definition: bitmapdata.cpp:164
std::shared_ptr< IfdEntry > Ref
Definition: ifdentry.hpp:178
Definition: trace.cpp:30
static bool isCompressed(RawContainer &container, uint32_t offset)
Definition: neffile.cpp:257
::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
virtual void setDimensions(uint32_t x, uint32_t y) override
Definition: rawdata.cpp:260