1123 lines
36 KiB
C++
1123 lines
36 KiB
C++
/* -*- C++ -*-
|
|
* File: fujicompressed.cpp
|
|
* Copyright (C) 2016 Alexey Danilchenko
|
|
*
|
|
* Adopted to LibRaw by Alex Tutubalin, lexa@lexa.ru
|
|
* LibRaw Fujifilm/compressed decoder
|
|
|
|
LibRaw is free software; you can redistribute it and/or modify
|
|
it under the terms of the one of three licenses as you choose:
|
|
|
|
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
|
|
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
|
|
|
|
2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
|
|
(See file LICENSE.CDDL provided in LibRaw distribution archive for details).
|
|
|
|
* Adopted to RawTherapee by Ingo Weyrich
|
|
|
|
*/
|
|
|
|
namespace {
|
|
|
|
int bitDiff (int value1, int value2)
|
|
{
|
|
int decBits = 0;
|
|
|
|
if ( value2 < value1 )
|
|
while (decBits <= 12 && (value2 << ++decBits) < value1)
|
|
;
|
|
|
|
return decBits;
|
|
}
|
|
|
|
}
|
|
|
|
void CLASS init_fuji_compr (struct fuji_compressed_params* info)
|
|
{
|
|
int cur_val;
|
|
char *qt;
|
|
|
|
if ((fuji_block_width % 3 && fuji_raw_type == 16) || (fuji_block_width & 1 && fuji_raw_type == 0)) {
|
|
derror();
|
|
}
|
|
|
|
info->q_table = (char *) malloc (32768);
|
|
merror (info->q_table, "init_fuji_compr()");
|
|
|
|
if (fuji_raw_type == 16) {
|
|
info->line_width = (fuji_block_width * 2) / 3;
|
|
} else {
|
|
info->line_width = fuji_block_width >> 1;
|
|
}
|
|
|
|
info->q_point[0] = 0;
|
|
info->q_point[1] = 0x12;
|
|
info->q_point[2] = 0x43;
|
|
info->q_point[3] = 0x114;
|
|
info->q_point[4] = (1 << fuji_bits) - 1;
|
|
info->min_value = 0x40;
|
|
|
|
cur_val = -info->q_point[4];
|
|
|
|
for (qt = info->q_table; cur_val <= info->q_point[4]; ++qt, ++cur_val) {
|
|
if (cur_val <= -info->q_point[3]) {
|
|
*qt = -4;
|
|
} else if (cur_val <= -info->q_point[2]) {
|
|
*qt = -3;
|
|
} else if (cur_val <= -info->q_point[1]) {
|
|
*qt = -2;
|
|
} else if (cur_val < 0) {
|
|
*qt = -1;
|
|
} else if (cur_val == 0) {
|
|
*qt = 0;
|
|
} else if (cur_val < info->q_point[1]) {
|
|
*qt = 1;
|
|
} else if (cur_val < info->q_point[2]) {
|
|
*qt = 2;
|
|
} else if (cur_val < info->q_point[3]) {
|
|
*qt = 3;
|
|
} else {
|
|
*qt = 4;
|
|
}
|
|
}
|
|
|
|
// populting gradients
|
|
if (info->q_point[4] == 0x3FFF) {
|
|
info->total_values = 0x4000;
|
|
info->raw_bits = 14;
|
|
info->max_bits = 56;
|
|
info->maxDiff = 256;
|
|
} else if (info->q_point[4] == 0xFFF) {
|
|
info->total_values = 4096;
|
|
info->raw_bits = 12;
|
|
info->max_bits = 48;
|
|
info->maxDiff = 64;
|
|
} else {
|
|
derror();
|
|
}
|
|
}
|
|
|
|
#define FUJI_BUF_SIZE 0x10000u
|
|
|
|
void CLASS fuji_fill_buffer (struct fuji_compressed_block *info)
|
|
{
|
|
if (info->cur_pos >= info->cur_buf_size) {
|
|
info->cur_pos = 0;
|
|
info->cur_buf_offset += info->cur_buf_size;
|
|
#ifdef MYFILE_MMAP
|
|
info->cur_buf_size = info->max_read_size;
|
|
info->cur_buf = fdata(info->cur_buf_offset, info->input);
|
|
#else
|
|
#ifdef _OPENMP
|
|
#pragma omp critical
|
|
#endif
|
|
{
|
|
fseek (info->input, info->cur_buf_offset, SEEK_SET);
|
|
info->cur_buf_size = fread (info->cur_buf, 1, std::min (info->max_read_size, FUJI_BUF_SIZE), info->input);
|
|
}
|
|
#endif
|
|
if (info->cur_buf_size < 1) { // nothing read
|
|
if (info->fillbytes > 0) {
|
|
int ls = std::max (1, std::min (info->fillbytes, (int)FUJI_BUF_SIZE));
|
|
memset (info->cur_buf, 0, ls);
|
|
info->fillbytes -= ls;
|
|
}
|
|
}
|
|
|
|
info->max_read_size -= info->cur_buf_size;
|
|
}
|
|
}
|
|
|
|
void CLASS init_fuji_block (struct fuji_compressed_block* info, const struct fuji_compressed_params *params, INT64 raw_offset, unsigned dsize)
|
|
{
|
|
info->linealloc = (ushort*)calloc (sizeof (ushort), _ltotal * (params->line_width + 2));
|
|
merror (info->linealloc, "init_fuji_block()");
|
|
|
|
info->input = ifp;
|
|
INT64 fsize = info->input->size;
|
|
info->max_read_size = std::min (unsigned (fsize - raw_offset), dsize + 16); // Data size may be incorrect?
|
|
info->fillbytes = 1;
|
|
|
|
info->linebuf[_R0] = info->linealloc;
|
|
|
|
for (int i = _R1; i <= _B4; i++) {
|
|
info->linebuf[i] = info->linebuf[i - 1] + params->line_width + 2;
|
|
}
|
|
|
|
// init buffer
|
|
#ifndef MYFILE_MMAP
|
|
info->cur_buf = (uchar*)malloc (FUJI_BUF_SIZE);
|
|
merror (info->cur_buf, "init_fuji_block()");
|
|
#endif
|
|
info->cur_bit = 0;
|
|
info->cur_pos = 0;
|
|
info->cur_buf_offset = raw_offset;
|
|
|
|
for (int j = 0; j < 3; j++)
|
|
for (int i = 0; i < 41; i++) {
|
|
info->grad_even[j][i].value1 = params->maxDiff;
|
|
info->grad_even[j][i].value2 = 1;
|
|
info->grad_odd[j][i].value1 = params->maxDiff;
|
|
info->grad_odd[j][i].value2 = 1;
|
|
}
|
|
|
|
info->cur_buf_size = 0;
|
|
fuji_fill_buffer (info);
|
|
}
|
|
|
|
void CLASS copy_line_to_xtrans (struct fuji_compressed_block* info, int cur_line, int cur_block, int cur_block_width)
|
|
{
|
|
ushort *lineBufB[3];
|
|
ushort *lineBufG[6];
|
|
ushort *lineBufR[3];
|
|
ushort* line_buf;
|
|
int index;
|
|
|
|
int offset = fuji_block_width * cur_block + 6 * raw_width * cur_line;
|
|
ushort* raw_block_data = raw_image + offset;
|
|
int row_count = 0;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
lineBufR[i] = info->linebuf[_R2 + i] + 1;
|
|
lineBufB[i] = info->linebuf[_B2 + i] + 1;
|
|
}
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
lineBufG[i] = info->linebuf[_G2 + i] + 1;
|
|
}
|
|
|
|
while (row_count < 6) {
|
|
unsigned pixel_count = 0;
|
|
|
|
while (static_cast<int>(pixel_count) < cur_block_width) {
|
|
switch (xtrans_abs[row_count][ (pixel_count % 6)]) {
|
|
case 1: // green
|
|
line_buf = lineBufG[row_count];
|
|
break;
|
|
|
|
case 0: // red
|
|
line_buf = lineBufR[row_count >> 1];
|
|
break;
|
|
|
|
case 2: // blue
|
|
default:
|
|
line_buf = lineBufB[row_count >> 1];
|
|
break;
|
|
}
|
|
|
|
index = (((pixel_count * 2 / 3) & 0x7FFFFFFE) | ((pixel_count % 3) & 1)) + ((pixel_count % 3) >> 1);
|
|
raw_block_data[pixel_count] = line_buf[index];
|
|
|
|
++pixel_count;
|
|
}
|
|
|
|
++row_count;
|
|
raw_block_data += raw_width;
|
|
}
|
|
}
|
|
|
|
void CLASS copy_line_to_bayer (struct fuji_compressed_block *info, int cur_line, int cur_block, int cur_block_width)
|
|
{
|
|
ushort *lineBufB[3];
|
|
ushort *lineBufG[6];
|
|
ushort *lineBufR[3];
|
|
ushort *line_buf;
|
|
|
|
int fuji_bayer[2][2];
|
|
|
|
for (int r = 0; r < 2; r++)
|
|
for (int c = 0; c < 2; c++) {
|
|
fuji_bayer[r][c] = FC (r, c); // We'll downgrade G2 to G below
|
|
}
|
|
|
|
int offset = fuji_block_width * cur_block + 6 * raw_width * cur_line;
|
|
ushort *raw_block_data = raw_image + offset;
|
|
int row_count = 0;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
lineBufR[i] = info->linebuf[_R2 + i] + 1;
|
|
lineBufB[i] = info->linebuf[_B2 + i] + 1;
|
|
}
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
lineBufG[i] = info->linebuf[_G2 + i] + 1;
|
|
}
|
|
|
|
while (row_count < 6) {
|
|
unsigned pixel_count = 0;
|
|
|
|
while (static_cast<int>(pixel_count) < cur_block_width) {
|
|
switch (fuji_bayer[row_count & 1][pixel_count & 1]) {
|
|
case 0: // red
|
|
line_buf = lineBufR[row_count >> 1];
|
|
break;
|
|
|
|
case 1: // green
|
|
case 3: // second green
|
|
default: // to make static analyzer happy
|
|
line_buf = lineBufG[row_count];
|
|
break;
|
|
|
|
case 2: // blue
|
|
line_buf = lineBufB[row_count >> 1];
|
|
break;
|
|
}
|
|
|
|
raw_block_data[pixel_count] = line_buf[pixel_count >> 1];
|
|
++pixel_count;
|
|
}
|
|
|
|
++row_count;
|
|
raw_block_data += raw_width;
|
|
}
|
|
}
|
|
|
|
|
|
#define fuji_quant_gradient(i,v1,v2) (9*i->q_table[i->q_point[4]+(v1)] + i->q_table[i->q_point[4]+(v2)])
|
|
|
|
inline void CLASS fuji_zerobits (struct fuji_compressed_block* info, int *count)
|
|
{
|
|
uchar zero = 0;
|
|
*count = 0;
|
|
|
|
while (zero == 0) {
|
|
zero = (info->cur_buf[info->cur_pos] >> (7 - info->cur_bit)) & 1;
|
|
info->cur_bit++;
|
|
info->cur_bit &= 7;
|
|
|
|
if (!info->cur_bit) {
|
|
++info->cur_pos;
|
|
#ifndef MYFILE_MMAP
|
|
fuji_fill_buffer (info);
|
|
#endif
|
|
}
|
|
|
|
if (zero) {
|
|
break;
|
|
}
|
|
|
|
++*count;
|
|
}
|
|
}
|
|
|
|
inline void CLASS fuji_read_code (struct fuji_compressed_block* info, int *data, int bits_to_read)
|
|
{
|
|
*data = 0;
|
|
|
|
if (!bits_to_read) {
|
|
return;
|
|
}
|
|
|
|
uchar bits_left = bits_to_read;
|
|
uchar bits_left_in_byte = 8 - (info->cur_bit & 7);
|
|
|
|
if (bits_to_read >= bits_left_in_byte) {
|
|
do {
|
|
*data <<= bits_left_in_byte;
|
|
bits_left -= bits_left_in_byte;
|
|
*data |= info->cur_buf[info->cur_pos] & ((1 << bits_left_in_byte) - 1);
|
|
++info->cur_pos;
|
|
#ifndef MYFILE_MMAP
|
|
fuji_fill_buffer (info);
|
|
#endif
|
|
bits_left_in_byte = 8;
|
|
} while (bits_left >= 8);
|
|
}
|
|
|
|
if (!bits_left) {
|
|
info->cur_bit = (8 - (bits_left_in_byte & 7)) & 7;
|
|
return;
|
|
}
|
|
|
|
*data <<= bits_left;
|
|
bits_left_in_byte -= bits_left;
|
|
*data |= ((1 << bits_left) - 1) & ((unsigned)info->cur_buf[info->cur_pos] >> bits_left_in_byte);
|
|
info->cur_bit = (8 - (bits_left_in_byte & 7)) & 7;
|
|
}
|
|
|
|
int CLASS fuji_decode_sample_even (struct fuji_compressed_block* info, const struct fuji_compressed_params * params, ushort* line_buf, int pos, struct int_pair* grads)
|
|
{
|
|
int interp_val = 0;
|
|
int errcnt = 0;
|
|
|
|
int sample = 0, code = 0;
|
|
ushort* line_buf_cur = line_buf + pos;
|
|
int Rb = line_buf_cur[-2 - params->line_width];
|
|
int Rc = line_buf_cur[-3 - params->line_width];
|
|
int Rd = line_buf_cur[-1 - params->line_width];
|
|
int Rf = line_buf_cur[-4 - 2 * params->line_width];
|
|
|
|
int grad, gradient, diffRcRb, diffRfRb, diffRdRb;
|
|
|
|
grad = fuji_quant_gradient (params, Rb - Rf, Rc - Rb);
|
|
gradient = std::abs (grad);
|
|
diffRcRb = std::abs (Rc - Rb);
|
|
diffRfRb = std::abs (Rf - Rb);
|
|
diffRdRb = std::abs (Rd - Rb);
|
|
|
|
if ( diffRcRb > diffRfRb && diffRcRb > diffRdRb ) {
|
|
interp_val = Rf + Rd + 2 * Rb;
|
|
} else if ( diffRdRb > diffRcRb && diffRdRb > diffRfRb ) {
|
|
interp_val = Rf + Rc + 2 * Rb;
|
|
} else {
|
|
interp_val = Rd + Rc + 2 * Rb;
|
|
}
|
|
|
|
|
|
fuji_zerobits (info, &sample);
|
|
|
|
if (sample < params->max_bits - params->raw_bits - 1) {
|
|
int decBits = bitDiff (grads[gradient].value1, grads[gradient].value2);
|
|
fuji_read_code (info, &code, decBits);
|
|
code += sample << decBits;
|
|
} else {
|
|
fuji_read_code (info, &code, params->raw_bits);
|
|
code++;
|
|
}
|
|
|
|
if (code < 0 || code >= params->total_values) {
|
|
errcnt++;
|
|
}
|
|
|
|
if (code & 1) {
|
|
code = -1 - code / 2;
|
|
} else {
|
|
code /= 2;
|
|
}
|
|
|
|
grads[gradient].value1 += std::abs (code);
|
|
|
|
if (grads[gradient].value2 == params->min_value ) {
|
|
grads[gradient].value1 >>= 1;
|
|
grads[gradient].value2 >>= 1;
|
|
}
|
|
|
|
grads[gradient].value2++;
|
|
|
|
if (grad < 0) {
|
|
interp_val = (interp_val >> 2) - code;
|
|
} else {
|
|
interp_val = (interp_val >> 2) + code;
|
|
}
|
|
|
|
if ( interp_val < 0 ) {
|
|
interp_val += params->total_values;
|
|
} else if (interp_val > params->q_point[4]) {
|
|
interp_val -= params->total_values;
|
|
}
|
|
|
|
if ( interp_val >= 0 ) {
|
|
line_buf_cur[0] = std::min (interp_val, params->q_point[4]);
|
|
} else {
|
|
line_buf_cur[0] = 0;
|
|
}
|
|
|
|
return errcnt;
|
|
}
|
|
|
|
int CLASS fuji_decode_sample_odd (struct fuji_compressed_block* info, const struct fuji_compressed_params * params, ushort* line_buf, int pos, struct int_pair* grads)
|
|
{
|
|
int interp_val = 0;
|
|
int errcnt = 0;
|
|
|
|
int sample = 0, code = 0;
|
|
ushort* line_buf_cur = line_buf + pos;
|
|
int Ra = line_buf_cur[-1];
|
|
int Rb = line_buf_cur[-2 - params->line_width];
|
|
int Rc = line_buf_cur[-3 - params->line_width];
|
|
int Rd = line_buf_cur[-1 - params->line_width];
|
|
int Rg = line_buf_cur[1];
|
|
|
|
int grad, gradient;
|
|
|
|
grad = fuji_quant_gradient (params, Rb - Rc, Rc - Ra);
|
|
gradient = std::abs (grad);
|
|
|
|
if ((Rb > Rc && Rb > Rd) || (Rb < Rc && Rb < Rd)) {
|
|
interp_val = (Rg + Ra + 2 * Rb) >> 2;
|
|
} else {
|
|
interp_val = (Ra + Rg) >> 1;
|
|
}
|
|
|
|
fuji_zerobits (info, &sample);
|
|
|
|
if (sample < params->max_bits - params->raw_bits - 1) {
|
|
int decBits = bitDiff (grads[gradient].value1, grads[gradient].value2);
|
|
fuji_read_code (info, &code, decBits);
|
|
code += sample << decBits;
|
|
} else {
|
|
fuji_read_code (info, &code, params->raw_bits);
|
|
code++;
|
|
}
|
|
|
|
if (code < 0 || code >= params->total_values) {
|
|
errcnt++;
|
|
}
|
|
|
|
if (code & 1) {
|
|
code = -1 - code / 2;
|
|
} else {
|
|
code /= 2;
|
|
}
|
|
|
|
grads[gradient].value1 += std::abs (code);
|
|
|
|
if (grads[gradient].value2 == params->min_value) {
|
|
grads[gradient].value1 >>= 1;
|
|
grads[gradient].value2 >>= 1;
|
|
}
|
|
|
|
grads[gradient].value2++;
|
|
|
|
if (grad < 0) {
|
|
interp_val -= code;
|
|
} else {
|
|
interp_val += code;
|
|
}
|
|
|
|
if ( interp_val < 0 ) {
|
|
interp_val += params->total_values;
|
|
} else if (interp_val > params->q_point[4]) {
|
|
interp_val -= params->total_values;
|
|
}
|
|
|
|
if ( interp_val >= 0 ) {
|
|
line_buf_cur[0] = std::min (interp_val, params->q_point[4]);
|
|
} else {
|
|
line_buf_cur[0] = 0;
|
|
}
|
|
|
|
return errcnt;
|
|
}
|
|
|
|
void CLASS fuji_decode_interpolation_even (int line_width, ushort* line_buf, int pos)
|
|
{
|
|
ushort* line_buf_cur = line_buf + pos;
|
|
int Rb = line_buf_cur[-2 - line_width];
|
|
int Rc = line_buf_cur[-3 - line_width];
|
|
int Rd = line_buf_cur[-1 - line_width];
|
|
int Rf = line_buf_cur[-4 - 2 * line_width];
|
|
int diffRcRb = std::abs (Rc - Rb);
|
|
int diffRfRb = std::abs (Rf - Rb);
|
|
int diffRdRb = std::abs (Rd - Rb);
|
|
|
|
if ( diffRcRb > diffRfRb && diffRcRb > diffRdRb ) {
|
|
*line_buf_cur = (Rf + Rd + 2 * Rb) >> 2;
|
|
} else if ( diffRdRb > diffRcRb && diffRdRb > diffRfRb ) {
|
|
*line_buf_cur = (Rf + Rc + 2 * Rb) >> 2;
|
|
} else {
|
|
*line_buf_cur = (Rd + Rc + 2 * Rb) >> 2;
|
|
}
|
|
}
|
|
|
|
void CLASS fuji_extend_generic (ushort *linebuf[_ltotal], int line_width, int start, int end)
|
|
{
|
|
for (int i = start; i <= end; i++) {
|
|
linebuf[i][0] = linebuf[i - 1][1];
|
|
linebuf[i][line_width + 1] = linebuf[i - 1][line_width];
|
|
}
|
|
}
|
|
|
|
void CLASS fuji_extend_red (ushort *linebuf[_ltotal], int line_width)
|
|
{
|
|
fuji_extend_generic (linebuf, line_width, _R2, _R4);
|
|
}
|
|
|
|
void CLASS fuji_extend_green (ushort *linebuf[_ltotal], int line_width)
|
|
{
|
|
fuji_extend_generic (linebuf, line_width, _G2, _G7);
|
|
}
|
|
|
|
void CLASS fuji_extend_blue (ushort *linebuf[_ltotal], int line_width)
|
|
{
|
|
fuji_extend_generic (linebuf, line_width, _B2, _B4);
|
|
}
|
|
|
|
void CLASS xtrans_decode_block (struct fuji_compressed_block* info, const struct fuji_compressed_params *params)
|
|
{
|
|
int r_even_pos = 0, r_odd_pos = 1;
|
|
int g_even_pos = 0, g_odd_pos = 1;
|
|
int b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
int errcnt = 0;
|
|
|
|
const int line_width = params->line_width;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_R2] + 1, r_even_pos);
|
|
r_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G2] + 1, g_even_pos, info->grad_even[0]);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R2] + 1, r_odd_pos, info->grad_odd[0]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G2] + 1, g_odd_pos, info->grad_odd[0]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G3] + 1, g_even_pos, info->grad_even[1]);
|
|
g_even_pos += 2;
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_B2] + 1, b_even_pos);
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G3] + 1, g_odd_pos, info->grad_odd[1]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B2] + 1, b_odd_pos, info->grad_odd[1]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
r_even_pos = 0, r_odd_pos = 1;
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
if (r_even_pos & 3) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_R3] + 1, r_even_pos, info->grad_even[2]);
|
|
} else {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_R3] + 1, r_even_pos);
|
|
}
|
|
|
|
r_even_pos += 2;
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_G4] + 1, g_even_pos);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R3] + 1, r_odd_pos, info->grad_odd[2]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G4] + 1, g_odd_pos, info->grad_odd[2]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G5] + 1, g_even_pos, info->grad_even[0]);
|
|
g_even_pos += 2;
|
|
|
|
if ((b_even_pos & 3) == 2) {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_B3] + 1, b_even_pos);
|
|
} else {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_B3] + 1, b_even_pos, info->grad_even[0]);
|
|
}
|
|
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G5] + 1, g_odd_pos, info->grad_odd[0]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B3] + 1, b_odd_pos, info->grad_odd[0]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
r_even_pos = 0, r_odd_pos = 1;
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
if ((r_even_pos & 3) == 2) {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_R4] + 1, r_even_pos);
|
|
} else {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_R4] + 1, r_even_pos, info->grad_even[1]);
|
|
}
|
|
|
|
r_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G6] + 1, g_even_pos, info->grad_even[1]);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R4] + 1, r_odd_pos, info->grad_odd[1]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G6] + 1, g_odd_pos, info->grad_odd[1]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_G7] + 1, g_even_pos);
|
|
g_even_pos += 2;
|
|
|
|
if (b_even_pos & 3) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_B4] + 1, b_even_pos, info->grad_even[2]);
|
|
} else {
|
|
fuji_decode_interpolation_even (line_width, info->linebuf[_B4] + 1, b_even_pos);
|
|
}
|
|
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G7] + 1, g_odd_pos, info->grad_odd[2]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B4] + 1, b_odd_pos, info->grad_odd[2]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
if (errcnt) {
|
|
derror();
|
|
}
|
|
}
|
|
|
|
void CLASS fuji_bayer_decode_block (struct fuji_compressed_block *info, const struct fuji_compressed_params *params)
|
|
{
|
|
int r_even_pos = 0, r_odd_pos = 1;
|
|
int g_even_pos = 0, g_odd_pos = 1;
|
|
int b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
int errcnt = 0;
|
|
|
|
const int line_width = params->line_width;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_R2] + 1, r_even_pos, info->grad_even[0]);
|
|
r_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G2] + 1, g_even_pos, info->grad_even[0]);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R2] + 1, r_odd_pos, info->grad_odd[0]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G2] + 1, g_odd_pos, info->grad_odd[0]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G3] + 1, g_even_pos, info->grad_even[1]);
|
|
g_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_B2] + 1, b_even_pos, info->grad_even[1]);
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G3] + 1, g_odd_pos, info->grad_odd[1]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B2] + 1, b_odd_pos, info->grad_odd[1]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
r_even_pos = 0, r_odd_pos = 1;
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_R3] + 1, r_even_pos, info->grad_even[2]);
|
|
r_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G4] + 1, g_even_pos, info->grad_even[2]);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R3] + 1, r_odd_pos, info->grad_odd[2]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G4] + 1, g_odd_pos, info->grad_odd[2]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G5] + 1, g_even_pos, info->grad_even[0]);
|
|
g_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_B3] + 1, b_even_pos, info->grad_even[0]);
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G5] + 1, g_odd_pos, info->grad_odd[0]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B3] + 1, b_odd_pos, info->grad_odd[0]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
r_even_pos = 0, r_odd_pos = 1;
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_R4] + 1, r_even_pos, info->grad_even[1]);
|
|
r_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G6] + 1, g_even_pos, info->grad_even[1]);
|
|
g_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_R4] + 1, r_odd_pos, info->grad_odd[1]);
|
|
r_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G6] + 1, g_odd_pos, info->grad_odd[1]);
|
|
g_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_red (info->linebuf, line_width);
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
|
|
g_even_pos = 0, g_odd_pos = 1;
|
|
b_even_pos = 0, b_odd_pos = 1;
|
|
|
|
while (g_even_pos < line_width || g_odd_pos < line_width) {
|
|
if (g_even_pos < line_width) {
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_G7] + 1, g_even_pos, info->grad_even[2]);
|
|
g_even_pos += 2;
|
|
errcnt += fuji_decode_sample_even (info, params, info->linebuf[_B4] + 1, b_even_pos, info->grad_even[2]);
|
|
b_even_pos += 2;
|
|
}
|
|
|
|
if (g_even_pos > 8) {
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_G7] + 1, g_odd_pos, info->grad_odd[2]);
|
|
g_odd_pos += 2;
|
|
errcnt += fuji_decode_sample_odd (info, params, info->linebuf[_B4] + 1, b_odd_pos, info->grad_odd[2]);
|
|
b_odd_pos += 2;
|
|
}
|
|
}
|
|
|
|
fuji_extend_green (info->linebuf, line_width);
|
|
fuji_extend_blue (info->linebuf, line_width);
|
|
|
|
if (errcnt) {
|
|
derror();
|
|
}
|
|
}
|
|
|
|
void CLASS fuji_decode_strip (const struct fuji_compressed_params* info_common, int cur_block, INT64 raw_offset, unsigned dsize)
|
|
{
|
|
int cur_block_width, cur_line;
|
|
unsigned line_size;
|
|
struct fuji_compressed_block info;
|
|
|
|
init_fuji_block (&info, info_common, raw_offset, dsize);
|
|
line_size = sizeof (ushort) * (info_common->line_width + 2);
|
|
|
|
cur_block_width = fuji_block_width;
|
|
|
|
if (cur_block + 1 == fuji_total_blocks) {
|
|
cur_block_width = raw_width - cur_block * fuji_block_width;
|
|
}
|
|
|
|
struct i_pair {
|
|
int a, b;
|
|
};
|
|
|
|
const i_pair mtable[6] = { {_R0, _R3}, {_R1, _R4}, {_G0, _G6}, {_G1, _G7}, {_B0, _B3}, {_B1, _B4}},
|
|
ztable[3] = {{_R2, 3}, {_G2, 6}, {_B2, 3}};
|
|
|
|
for (cur_line = 0; cur_line < fuji_total_lines; cur_line++) {
|
|
if (fuji_raw_type == 16) {
|
|
xtrans_decode_block (&info, info_common);
|
|
} else {
|
|
fuji_bayer_decode_block (&info, info_common);
|
|
}
|
|
|
|
// copy data from line buffers and advance
|
|
for (int i = 0; i < 6; i++) {
|
|
memcpy (info.linebuf[mtable[i].a], info.linebuf[mtable[i].b], line_size);
|
|
}
|
|
|
|
if (fuji_raw_type == 16) {
|
|
copy_line_to_xtrans (&info, cur_line, cur_block, cur_block_width);
|
|
} else {
|
|
copy_line_to_bayer (&info, cur_line, cur_block, cur_block_width);
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
memset (info.linebuf[ztable[i].a], 0, ztable[i].b * line_size);
|
|
info.linebuf[ztable[i].a][0] = info.linebuf[ztable[i].a - 1][1];
|
|
info.linebuf[ztable[i].a][info_common->line_width + 1] = info.linebuf[ztable[i].a - 1][info_common->line_width];
|
|
}
|
|
}
|
|
|
|
// release data
|
|
free (info.linealloc);
|
|
#ifndef MYFILE_MMAP
|
|
free (info.cur_buf);
|
|
#endif
|
|
}
|
|
|
|
static unsigned sgetn (int n, uchar *s)
|
|
{
|
|
unsigned result = 0;
|
|
|
|
while (n-- > 0) {
|
|
result = (result << 8) | (*s++);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void CLASS fuji_compressed_load_raw()
|
|
{
|
|
struct fuji_compressed_params common_info;
|
|
int cur_block;
|
|
unsigned *block_sizes;
|
|
INT64 raw_offset, *raw_block_offsets;
|
|
//struct fuji_compressed_block info;
|
|
|
|
init_fuji_compr (&common_info);
|
|
|
|
// read block sizes
|
|
block_sizes = (unsigned*) malloc (sizeof (unsigned) * fuji_total_blocks);
|
|
merror (block_sizes, "fuji_compressed_load_raw()");
|
|
raw_block_offsets = (INT64*) malloc (sizeof (INT64) * fuji_total_blocks);
|
|
merror (raw_block_offsets, "fuji_compressed_load_raw()");
|
|
|
|
raw_offset = sizeof (unsigned) * fuji_total_blocks;
|
|
|
|
if (raw_offset & 0xC) {
|
|
raw_offset += 0x10 - (raw_offset & 0xC);
|
|
}
|
|
|
|
raw_offset += data_offset;
|
|
|
|
fseek (ifp, data_offset, SEEK_SET);
|
|
fread (block_sizes, 1, sizeof (unsigned)*fuji_total_blocks, ifp);
|
|
|
|
raw_block_offsets[0] = raw_offset;
|
|
|
|
// calculating raw block offsets
|
|
for (cur_block = 0; cur_block < fuji_total_blocks; cur_block++) {
|
|
unsigned bsize = sgetn (4, (uchar *) (block_sizes + cur_block));
|
|
block_sizes[cur_block] = bsize;
|
|
}
|
|
|
|
for (cur_block = 1; cur_block < fuji_total_blocks; cur_block++) {
|
|
raw_block_offsets[cur_block] = raw_block_offsets[cur_block - 1] + block_sizes[cur_block - 1] ;
|
|
}
|
|
|
|
fuji_decode_loop (&common_info, fuji_total_blocks, raw_block_offsets, block_sizes);
|
|
|
|
free (block_sizes);
|
|
free (raw_block_offsets);
|
|
free (common_info.q_table);
|
|
}
|
|
|
|
void CLASS fuji_decode_loop (const struct fuji_compressed_params* common_info, int count, INT64* raw_block_offsets, unsigned *block_sizes)
|
|
{
|
|
|
|
#ifdef _OPENMP
|
|
#pragma omp parallel for schedule(dynamic,1) // dynamic scheduling is faster if count > number of cores (e.g. count for GFX 50S is 12)
|
|
#endif
|
|
|
|
for (int cur_block = 0; cur_block < count ; cur_block++) {
|
|
fuji_decode_strip (common_info, cur_block, raw_block_offsets[cur_block], block_sizes[cur_block]);
|
|
}
|
|
}
|
|
|
|
|
|
void CLASS parse_fuji_compressed_header()
|
|
{
|
|
|
|
uchar header[16];
|
|
|
|
ushort signature;
|
|
uchar version;
|
|
uchar h_raw_type;
|
|
uchar h_raw_bits;
|
|
ushort h_raw_height;
|
|
ushort h_raw_rounded_width;
|
|
ushort h_raw_width;
|
|
ushort h_block_size;
|
|
uchar h_blocks_in_row;
|
|
ushort h_total_lines;
|
|
|
|
fseek (ifp, data_offset, SEEK_SET);
|
|
fread (header, 1, sizeof (header), ifp);
|
|
|
|
signature = sgetn (2, header);
|
|
version = header[2];
|
|
h_raw_type = header[3];
|
|
h_raw_bits = header[4];
|
|
h_raw_height = sgetn (2, header + 5);
|
|
h_raw_rounded_width = sgetn (2, header + 7);
|
|
h_raw_width = sgetn (2, header + 9);
|
|
h_block_size = sgetn (2, header + 11);
|
|
h_blocks_in_row = header[13];
|
|
h_total_lines = sgetn (2, header + 14);
|
|
|
|
|
|
// general validation
|
|
if (signature != 0x4953
|
|
|| version != 1
|
|
|| h_raw_height > 0x3000
|
|
|| h_raw_height < 6
|
|
|| h_raw_height % 6
|
|
|| h_raw_width > 0x3000
|
|
|| h_raw_width < 0x300
|
|
|| h_raw_width % 24
|
|
|| h_raw_rounded_width > 0x3000
|
|
|| h_block_size != 0x300
|
|
|| h_raw_rounded_width < h_block_size
|
|
|| h_raw_rounded_width % h_block_size
|
|
|| h_raw_rounded_width - h_raw_width >= h_block_size
|
|
|| h_blocks_in_row > 0x10
|
|
|| h_blocks_in_row == 0
|
|
|| h_blocks_in_row != h_raw_rounded_width / h_block_size
|
|
|| h_total_lines > 0x800
|
|
|| h_total_lines == 0
|
|
|| h_total_lines != h_raw_height / 6
|
|
|| (h_raw_bits != 12 && h_raw_bits != 14)
|
|
|| (h_raw_type != 16 && h_raw_type != 0)) {
|
|
xtransCompressed = false;
|
|
return;
|
|
}
|
|
|
|
// modify data
|
|
fuji_total_lines = h_total_lines;
|
|
fuji_total_blocks = h_blocks_in_row;
|
|
fuji_block_width = h_block_size;
|
|
fuji_bits = h_raw_bits;
|
|
fuji_raw_type = h_raw_type;
|
|
raw_width = h_raw_width;
|
|
raw_height = h_raw_height;
|
|
data_offset += 16;
|
|
load_raw = &CLASS fuji_compressed_load_raw;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Fuji 14-bit compressed code taken from LibRaw 0.19
|
|
//
|
|
// Copyright 2008-2018 LibRaw LLC (info@libraw.org)
|
|
|
|
// LibRaw is free software; you can redistribute it and/or modify
|
|
// it under the terms of the one of two licenses as you choose:
|
|
|
|
// 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
|
|
// (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
|
|
|
|
// 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
|
|
// (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
|
|
//-----------------------------------------------------------------------------
|
|
namespace {
|
|
|
|
inline void unpack7bytesto4x16(unsigned char *src, unsigned short *dest)
|
|
{
|
|
dest[0] = (src[0] << 6) | (src[1] >> 2);
|
|
dest[1] = ((src[1] & 0x3) << 12) | (src[2] << 4) | (src[3] >> 4);
|
|
dest[2] = (src[3] & 0xf) << 10 | (src[4] << 2) | (src[5] >> 6);
|
|
dest[3] = ((src[5] & 0x3f) << 8) | src[6];
|
|
}
|
|
|
|
inline void unpack28bytesto16x16ns(unsigned char *src, unsigned short *dest)
|
|
{
|
|
dest[0] = (src[3] << 6) | (src[2] >> 2);
|
|
dest[1] = ((src[2] & 0x3) << 12) | (src[1] << 4) | (src[0] >> 4);
|
|
dest[2] = (src[0] & 0xf) << 10 | (src[7] << 2) | (src[6] >> 6);
|
|
dest[3] = ((src[6] & 0x3f) << 8) | src[5];
|
|
dest[4] = (src[4] << 6) | (src[11] >> 2);
|
|
dest[5] = ((src[11] & 0x3) << 12) | (src[10] << 4) | (src[9] >> 4);
|
|
dest[6] = (src[9] & 0xf) << 10 | (src[8] << 2) | (src[15] >> 6);
|
|
dest[7] = ((src[15] & 0x3f) << 8) | src[14];
|
|
dest[8] = (src[13] << 6) | (src[12] >> 2);
|
|
dest[9] = ((src[12] & 0x3) << 12) | (src[19] << 4) | (src[18] >> 4);
|
|
dest[10] = (src[18] & 0xf) << 10 | (src[17] << 2) | (src[16] >> 6);
|
|
dest[11] = ((src[16] & 0x3f) << 8) | src[23];
|
|
dest[12] = (src[22] << 6) | (src[21] >> 2);
|
|
dest[13] = ((src[21] & 0x3) << 12) | (src[20] << 4) | (src[27] >> 4);
|
|
dest[14] = (src[27] & 0xf) << 10 | (src[26] << 2) | (src[25] >> 6);
|
|
dest[15] = ((src[25] & 0x3f) << 8) | src[24];
|
|
}
|
|
|
|
#define swab32(x) \
|
|
((unsigned int)((((unsigned int)(x) & (unsigned int)0x000000ffUL) << 24) | \
|
|
(((unsigned int)(x) & (unsigned int)0x0000ff00UL) << 8) | \
|
|
(((unsigned int)(x) & (unsigned int)0x00ff0000UL) >> 8) | \
|
|
(((unsigned int)(x) & (unsigned int)0xff000000UL) >> 24)))
|
|
|
|
inline void swab32arr(unsigned *arr, unsigned len)
|
|
{
|
|
for (unsigned i = 0; i < len; i++)
|
|
arr[i] = swab32(arr[i]);
|
|
}
|
|
#undef swab32
|
|
|
|
} // namespace
|
|
|
|
void CLASS fuji_14bit_load_raw()
|
|
{
|
|
const unsigned linelen = raw_width * 7 / 4;
|
|
const unsigned pitch = raw_width;
|
|
unsigned char *buf = (unsigned char *)malloc(linelen);
|
|
merror(buf, "fuji_14bit_load_raw()");
|
|
|
|
for (int row = 0; row < raw_height; row++)
|
|
{
|
|
unsigned bytesread = fread(buf, 1, linelen, ifp);
|
|
unsigned short *dest = &raw_image[pitch * row];
|
|
if (bytesread % 28)
|
|
{
|
|
swab32arr((unsigned *)buf, bytesread / 4);
|
|
for (int sp = 0, dp = 0; dp < pitch - 3 && sp < linelen - 6 && sp < bytesread - 6; sp += 7, dp += 4)
|
|
unpack7bytesto4x16(buf + sp, dest + dp);
|
|
}
|
|
else
|
|
for (int sp = 0, dp = 0; dp < pitch - 15 && sp < linelen - 27 && sp < bytesread - 27; sp += 28, dp += 16)
|
|
unpack28bytesto16x16ns(buf + sp, dest + dp);
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|