29#include <libopenraw/consts.h>
30#include <libopenraw/debug.h>
32#include "bitmapdata.hpp"
34#include "cfapattern.hpp"
36#include "render/bimedian_demosaic.hpp"
37#include "render/grayscale.hpp"
42static const int MAX_MATRIX_SIZE = 12;
47 uint16_t blackLevel, whiteLevel;
48 ExifPhotometricInterpretation photometricInterpretation;
58 std::vector<uint16_t> slices;
61 uint32_t colourMatrixCount;
62 double colourMatrix2[MAX_MATRIX_SIZE];
63 uint32_t colourMatrix2Count;
67 blackLevel(0), whiteLevel(0),
68 photometricInterpretation(EV_PI_CFA),
69 cfa_pattern(
CfaPattern::twoByTwoPattern(OR_CFA_PATTERN_NONE)),
79 memset(colourMatrix2, 0,
sizeof(colourMatrix2));
81 void advance(
size_t s);
91RawData::getAndExtractRawData(
const char* filename, uint32_t options,
104 err = OR_ERROR_CANT_OPEN;
112 d(new RawData::Private(this))
127 uint32_t _x, _y, out_x, out_y;
130 if(
dataType() != OR_DATA_TYPE_RAW) {
131 LOGDBG1(
"wrong data type\n");
132 return OR_ERROR_INVALID_FORMAT;
134 if(d->photometricInterpretation != EV_PI_CFA &&
135 d->photometricInterpretation != EV_PI_LINEAR_RAW) {
136 LOGDBG1(
"only CFA or LinearRaw are supported.\n");
137 return OR_ERROR_INVALID_FORMAT;
140 or_cfa_pattern pattern;
151 src = (uint16_t*)data();
153 or_error err = OR_ERROR_NONE;
155 if (d->photometricInterpretation == EV_PI_CFA) {
159 uint8_t *dst = (uint8_t *)bitmapdata.allocData(
sizeof(uint8_t) * 3 * _x * _y);
160 err = bimedian_demosaic(src, _x, _y, pattern, dst, out_x, out_y);
168 uint16_t *dst = (uint16_t *)bitmapdata.allocData(
sizeof(uint16_t)
171 err = grayscale_to_rgb(src, _x, _y, dst);
180uint16_t RawData::blackLevel()
const
182 return d->blackLevel;
185uint16_t RawData::whiteLevel()
const
187 return d->whiteLevel;
190void RawData::setBlackLevel(uint16_t m)
195void RawData::setWhiteLevel(uint16_t m)
200void RawData::setPhotometricInterpretation(ExifPhotometricInterpretation pi)
202 d->photometricInterpretation = pi;
205ExifPhotometricInterpretation RawData::getPhotometricInterpretation()
const
207 return d->photometricInterpretation;
213 matrixSize = d->colourMatrixCount;
217void RawData::setColourMatrix1(
const double* matrix, uint32_t matrixSize)
219 if(matrixSize > MAX_MATRIX_SIZE) {
220 matrixSize = MAX_MATRIX_SIZE;
222 for(uint32_t i = 0; i < matrixSize; i++) {
225 d->colourMatrixCount = matrixSize;
230 matrixSize = d->colourMatrix2Count;
231 return d->colourMatrix2;
234void RawData::setColourMatrix2(
const double* matrix, uint32_t matrixSize)
236 if(matrixSize > MAX_MATRIX_SIZE) {
237 matrixSize = MAX_MATRIX_SIZE;
239 for(uint32_t i = 0; i < matrixSize; i++) {
240 d->colourMatrix2[i] = matrix[i];
242 d->colourMatrix2Count = matrixSize;
248 std::swap(this->d, with.d);
251void * RawData::allocData(
const size_t s)
253 void * p = BitmapData::allocData(s);
254 d->pos = (uint8_t*)p;
263 if(d->slices.size()) {
271void RawData::setSlices(
const std::vector<uint16_t> & slices)
282void RawData::setCfaPatternType(or_cfa_pattern t)
289 return d->cfa_pattern;
292void RawData::setCfaPattern(
const CfaPattern* pattern)
294 d->cfa_pattern = pattern;
297void RawData::setCompression(uint32_t t)
302uint32_t RawData::compression()
const
304 return d->compression;
311 assert(d->offset < d->data_size);
321 assert(d->offset <
size());
322 *(d->pos) = c & 0xff;
323 *(d->pos + 1) = (c >> 8) & 0xff;
324 d->advance(
sizeof(c));
333void RawData::Private::nextRow()
335 uint32_t w = self->width() * 2;
336 uint32_t row = offset / w;
338 if(row == self->height())
344 offset = row * w + sliceOffset * 2;
345 pos = (uint8_t*)(self->data()) + offset;
349void RawData::Private::nextSlice()
351 if(slices.size() > slice) {
352 sliceOffset += slices[slice];
355 if(slices.size() > slice) {
356 sliceWidth = slices[slice];
363void RawData::Private::advance(
size_t s)
365 if(offset + s - row_offset >= sliceWidth * 2) {
void setDataType(DataType _type)
void swap(BitmapData &with)
virtual void setDimensions(uint32_t x, uint32_t y)
DataType dataType() const
static const CfaPattern * twoByTwoPattern(::or_cfa_pattern)
::or_cfa_pattern patternType() const
double colourMatrix[MAX_MATRIX_SIZE]
const double * getColourMatrix1(uint32_t &size) const
RawData & append(uint16_t c)
::or_error getRenderedImage(BitmapData &bitmapdata, uint32_t options)
const CfaPattern * cfaPattern() const
const double * getColourMatrix2(uint32_t &size) const
virtual void setDimensions(uint32_t x, uint32_t y) override
::or_error getRawData(RawData &rawdata, uint32_t options)
static RawFile * newRawFile(const char *_filename, Type _typeHint=OR_RAWFILE_TYPE_UNKNOWN)
CIFF is the container for CRW files. It is an attempt from Canon to make this a standard....