rawdata.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <assert.h>
00023
00024 #include <libopenraw++/rawdata.h>
00025 #include <libopenraw++/rawfile.h>
00026
00027 namespace OpenRaw {
00028
00029 class RawData::Private {
00030 public:
00031 RawData *self;
00032 uint16_t min, max;
00033 CfaPattern cfa_pattern;
00034 uint32_t compression;
00035 uint8_t *pos;
00036 size_t offset;
00037 size_t row_offset;
00038 uint8_t slice;
00039 uint32_t sliceWidth;
00040 uint32_t sliceOffset;
00042 std::vector<uint16_t> slices;
00044 Private(RawData *_self)
00045 : self(_self),
00046 min(0), max(0),
00047 cfa_pattern(OR_CFA_PATTERN_NONE),
00048 compression(0),
00049 pos(NULL), offset(0),
00050 row_offset(0),
00051 slice(0), sliceWidth(0),
00052 sliceOffset(0), slices()
00053 {
00054 }
00055 void advance(size_t s);
00056 void nextSlice();
00057 void nextRow();
00058 private:
00059 Private(const Private &);
00060 Private & operator=(const Private &);
00061 };
00062
00063
00064 RawData *
00065 RawData::getAndExtractRawData(const char* filename, uint32_t options,
00066 or_error & err)
00067 {
00068 err = OR_ERROR_NONE;
00069 RawData *rawdata = NULL;
00070
00071 RawFile *file = RawFile::newRawFile(filename);
00072 if (file) {
00073 rawdata = new RawData();
00074 err = file->getRawData(*rawdata, options);
00075 delete file;
00076 }
00077 else {
00078 err = OR_ERROR_CANT_OPEN;
00079 }
00080 return rawdata;
00081 }
00082
00083
00084 RawData::RawData()
00085 : BitmapData(),
00086 d(new RawData::Private(this))
00087 {
00088
00089 }
00090
00091
00092 RawData::~RawData()
00093 {
00094 delete d;
00095 }
00096
00097 uint16_t RawData::min()
00098 {
00099 return d->min;
00100 }
00101
00102 uint16_t RawData::max()
00103 {
00104 return d->max;
00105 }
00106
00107 void RawData::setMin(uint16_t m)
00108 {
00109 d->min = m;
00110 }
00111
00112 void RawData::setMax(uint16_t m)
00113 {
00114 d->max = m;
00115 }
00116
00117 void RawData::swap(RawData & with)
00118 {
00119 BitmapData::swap(with);
00120 std::swap(this->d, with.d);
00121 }
00122
00123 void * RawData::allocData(const size_t s)
00124 {
00125 void * p = BitmapData::allocData(s);
00126 d->pos = (uint8_t*)p;
00127 d->offset = 0;
00128 return p;
00129 }
00130
00131
00132 void RawData::setDimensions(uint32_t _x, uint32_t _y)
00133 {
00134 BitmapData::setDimensions(_x, _y);
00135 if(d->slices.size()) {
00136 d->sliceWidth = d->slices[0];
00137 }
00138 else {
00139 d->sliceWidth = _x;
00140 }
00141 }
00142
00143 void RawData::setSlices(const std::vector<uint16_t> & slices)
00144 {
00145 d->slices = slices;
00146 if(slices.size()) {
00147 d->sliceWidth = slices[0];
00148 }
00149 else {
00150 d->sliceWidth = x();
00151 }
00152 }
00153
00154 void RawData::setCfaPattern(or_cfa_pattern t)
00155 {
00156 d->cfa_pattern = t;
00157 }
00158
00159 or_cfa_pattern RawData::cfaPattern()
00160 {
00161 return d->cfa_pattern;
00162 }
00163
00164 void RawData::setCompression(uint32_t t)
00165 {
00166 d->compression = t;
00167 }
00168
00169 uint32_t RawData::compression()
00170 {
00171 return d->compression;
00172 }
00173
00174 #if 0
00175 RawData &RawData::append(uint8_t c)
00176 {
00177 assert(d->pos);
00178 assert(d->offset < d->data_size);
00179 *(d->pos) = c;
00180 advance(sizeof(c));
00181 return *this;
00182 }
00183 #endif
00184
00185 RawData &RawData::append(uint16_t c)
00186 {
00187 assert(d->pos);
00188 assert(d->offset < size());
00189 *(d->pos) = c & 0xff;
00190 *(d->pos + 1) = (c >> 8) & 0xff;
00191 d->advance(sizeof(c));
00192 return *this;
00193 }
00194
00195
00196 void RawData::nextRow()
00197 {
00198 d->nextRow();
00199 }
00200
00201
00202 void RawData::Private::nextRow()
00203 {
00204 uint32_t w = self->x() * 2;
00205 uint32_t row = offset / w;
00206 row++;
00207 if(row == self->y())
00208 {
00209
00210 nextSlice();
00211 row = 0;
00212 }
00213 offset = row * w + sliceOffset * 2;
00214 pos = (uint8_t*)(self->data()) + offset;
00215 row_offset = offset;
00216 }
00217
00218 void RawData::Private::nextSlice()
00219 {
00220 if(slices.size()) {
00221 sliceOffset += slices[slice];
00222 slice++;
00223 if(slices.size() > slice) {
00224 sliceWidth = slices[slice];
00225 }
00226 else {
00227 sliceWidth = 0;
00228 }
00229 }
00230 }
00231
00232 void RawData::Private::advance(size_t s)
00233 {
00234 if(offset + s - row_offset >= sliceWidth * 2) {
00235 nextRow();
00236 }
00237 else {
00238 pos += s;
00239 offset += s;
00240 }
00241 }
00242
00243 }
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253