/*
* sq905c.c
*
* Here is the decompression function for the SQ905C cameras. The functions
* used are adapted from the libgphoto2 functions for the same cameras,
* which was
* Copyright (c) 2005 and 2007 Theodore Kilgore <kilgota@auburn.edu>
* This version for libv4lconvert is
* Copyright (c) 2009 Theodore Kilgore <kilgota@auburn.edu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
*/
#include <stdlib.h>
#include "libv4lconvert-priv.h"
#define CLIP(x) ((x) < 0 ? 0 : ((x) > 0xff) ? 0xff : (x))
static int
sq905c_first_decompress(unsigned char *output, const unsigned char *input,
unsigned int outputsize)
{
unsigned char parity = 0;
unsigned char nibble_to_keep[2];
unsigned char temp1 = 0, temp2 = 0;
unsigned char input_byte;
unsigned char lookup = 0;
unsigned int i = 0;
unsigned int bytes_used = 0;
unsigned int bytes_done = 0;
unsigned int bit_counter = 8;
unsigned int cycles = 0;
int table[9] = { -1, 0, 2, 6, 0x0e, 0x0e, 0x0e, 0x0e, 0xfb};
unsigned char lookup_table[16] = {
0, 2, 6, 0x0e, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4,
0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb
};
unsigned char translator[16] = {
8, 7, 9, 6, 10, 11, 12, 13,
14, 15, 5, 4, 3, 2, 1, 0
};
nibble_to_keep[0] = 0;
nibble_to_keep[1] = 0;
while (bytes_done < outputsize) {
while (parity < 2) {
while (lookup > table[cycles]) {
if (bit_counter == 8) {
input_byte = input[bytes_used];
bytes_used++;
temp1 = input_byte;
bit_counter = 0;
}
input_byte = temp1;
temp2 = (temp2 << 1) & 0xFF;
input_byte = input_byte >> 7;
temp2 = temp2 | input_byte;
temp1 = (temp1 << 1) & 0xFF;
bit_counter++;
cycles++;
if (cycles > 8)
return -1;
lookup = temp2 & 0xff;
}
temp2 = 0;
for (i = 0; i < 17; i++) {
if (i == 16)
return -1;
if (lookup == lookup_table[i]) {
nibble_to_keep[parity] = translator[i];
break;
}
}
cycles = 0;
parity++;
}
output[bytes_done] = (nibble_to_keep[0]<<4)|nibble_to_keep[1];
bytes_done++;
parity = 0;
}
return 0;
}
static int
sq905c_second_decompress(unsigned char *uncomp, unsigned char *in,
int width, int height)
{
int diff = 0;
int tempval = 0;
int i, m;
unsigned char delta_left = 0;
unsigned char delta_right = 0;
int input_counter = 0;
int delta_table[] = {
-144, -110, -77, -53, -35, -21, -11, -3,
2, 10, 20, 34, 52, 76, 110, 144
};
unsigned char *templine_red;
unsigned char *templine_green;
unsigned char *templine_blue;
templine_red = malloc(width);
if (!templine_red) {
return -1;
}
for (i = 0; i < width; i++)
templine_red[i] = 0x80;
templine_green = malloc(width);
if (!templine_green) {
free(templine_red);
return -1;
}
for (i = 0; i < width; i++)
templine_green[i] = 0x80;
templine_blue = malloc(width);
if (!templine_blue) {
free(templine_red);
free(templine_green);
return -1;
}
for (i = 0; i < width; i++)
templine_blue[i] = 0x80;
for (m = 0; m < height / 2; m++) {
/* First we do an even-numbered line */
for (i = 0; i < width / 2; i++) {
delta_right = in[input_counter] & 0x0f;
delta_left = (in[input_counter] >> 4) & 0xff;
input_counter++;
/* left pixel (red) */
diff = delta_table[delta_left];
if (!i)
tempval = templine_red[0] + diff;
else
tempval = (templine_red[i] +
uncomp[2 * m * width + 2 * i - 2]) / 2 + diff;
tempval = CLIP(tempval);
uncomp[2 * m * width + 2 * i] = tempval;
templine_red[i] = tempval;
/* right pixel (green) */
diff = delta_table[delta_right];
if (!i)
tempval = templine_green[1] + diff;
else if (2 * i == width - 2)
tempval = (templine_green[i] +
uncomp[2 * m * width + 2 * i - 1]) / 2 + diff;
else
tempval = (templine_green[i + 1] +
uncomp[2 * m * width + 2 * i - 1]) / 2 + diff;
tempval = CLIP(tempval);
uncomp[2 * m * width + 2 * i + 1] = tempval;
templine_green[i] = tempval;
}
/* then an odd-numbered line */
for (i = 0; i < width/2; i++) {
delta_right = in[input_counter] & 0x0f;
delta_left = (in[input_counter] >> 4) & 0xff;
input_counter++;
/* left pixel (green) */
diff = delta_table[delta_left];
if (!i)
tempval = templine_green[0] + diff;
else
tempval = (templine_green[i] +
uncomp[(2 * m + 1) * width + 2 * i - 2]) / 2 + diff;
tempval = CLIP(tempval);
uncomp[(2*m+1)*width+2*i] = tempval;
templine_green[i] = tempval;
/* right pixel (blue) */
diff = delta_table[delta_right];
if (!i)
tempval = templine_blue[0] + diff;
else
tempval = (templine_blue[i] +
uncomp[(2 * m + 1) * width + 2 * i - 1]) / 2 + diff;
tempval = CLIP(tempval);
uncomp[(2 * m + 1) * width + 2 * i + 1] = tempval;
templine_blue[i] = tempval;
}
}
free(templine_green);
free(templine_red);
free(templine_blue);
return 0;
}
void v4lconvert_decode_sq905c(const unsigned char *src, unsigned char *dst,
int width, int height)
{
int size;
unsigned char *temp_data;
const unsigned char *raw;
/* here we get rid of the 0x50 bytes of header in src. */
raw = src + 0x50;
size = width * height / 2;
temp_data = malloc(size);
if (!temp_data)
goto out;
sq905c_first_decompress(temp_data, raw, size);
sq905c_second_decompress(dst, temp_data, width, height);
out:
free(temp_data);
}