static int RSblock_init(RSblock *blocks, int spec[5], unsigned char *data, unsigned char *ecc)
{
int i;
RSblock *block;
unsigned char *dp, *ep;
RS *rs;
int el, dl;
dl = QRspec_rsDataCodes1(spec);
el = QRspec_rsEccCodes1(spec);
rs = init_rs(8, 0x11d, 0, 1, el, 255 - dl - el);
if(rs == NULL) return -1;
block = blocks;
dp = data;
ep = ecc;
for(i=0; i<QRspec_rsBlockNum1(spec); i++) {
RSblock_initBlock(block, dl, dp, el, ep, rs);
dp += dl;
ep += el;
block++;
}
if(QRspec_rsBlockNum2(spec) == 0) return 0;
dl = QRspec_rsDataCodes2(spec);
el = QRspec_rsEccCodes2(spec);
rs = init_rs(8, 0x11d, 0, 1, el, 255 - dl - el);
if(rs == NULL) return -1;
for(i=0; i<QRspec_rsBlockNum2(spec); i++) {
RSblock_initBlock(block, dl, dp, el, ep, rs);
dp += dl;
ep += el;
block++;
}
return 0;
}
static void compareRS(unsigned char data[])
{
int i, j;
RS *rs;
int spec[5];
int dl, el;
unsigned char ecc_expected[256], ecc_rscodec[256];
for(i = 1; i <= QRSPEC_VERSION_MAX; i++) {
for(j = QR_ECLEVEL_L; j <= QR_ECLEVEL_H; j++) {
QRspec_getEccSpec(i, (QRecLevel)j, spec);
dl = QRspec_rsDataCodes1(spec);
el = QRspec_rsEccCodes1(spec);
rs = init_rs(8, 0x11d, 0, 1, el, 255 - dl - el);
RSECC_encode(dl, el, data, ecc_rscodec);
encode_rs_char(rs, data, ecc_expected);
assert_zero(memcmp(ecc_expected, ecc_rscodec, el), "Invalid ECC found: length %d.\n", el);
free_rs_char(rs);
dl = QRspec_rsDataCodes2(spec);
el = QRspec_rsEccCodes2(spec);
if(dl != 0) {
rs = init_rs(8, 0x11d, 0, 1, el, 255 - dl - el);
RSECC_encode(dl, el, data, ecc_rscodec);
encode_rs_char(rs, data, ecc_expected);
assert_zero(memcmp(ecc_expected, ecc_rscodec, el), "Invalid ECC found: length %d.\n", el);
free_rs_char(rs);
}
}
}
}
bool reedSolomonCoder::encode(QByteArray &ba,QString extension,eRSType rsType)
{
int i,j;
unsigned char dataByte;
QByteArray temp;
tr_buf=ba;
fileType=rsType;
rs_bsize=RSBSIZE;
switch (fileType)
{
case RST1: rs_dsize=RSDSIZERS1; break;
case RST2: rs_dsize=RSDSIZERS2; break;
case RST3: rs_dsize=RSDSIZERS3; break;
case RST4: rs_dsize=RSDSIZERS4; break;
case RSTNONE: return FALSE;
}
init_rs(rs_dsize);
got = tr_buf.size();
chunks = (got+7) / rs_dsize ;
if (((got+7) % rs_dsize ) > 0) chunks++ ;
bep_size=chunks;
// ec_buf.resize(bep_size*RSBSIZE);
ec_buf.clear();
bk_buf.resize(bep_size*RSBSIZE);
dataByte = (unsigned char) ( rs_dsize - ( got % rs_dsize)) ; /* surplus in filelength */
ec_buf.append(dataByte);
dataByte = (unsigned char) ( chunks % 256) ;
ec_buf.append(dataByte);
dataByte = (unsigned char) (chunks/256) ;
ec_buf.append(dataByte);
ec_buf.append(extension.toLatin1().at(0));
ec_buf.append(extension.toLatin1().at(1));
ec_buf.append(extension.toLatin1().at(2));
dataByte=0;
ec_buf.append(dataByte);
ec_buf.append(tr_buf.left(rs_dsize-7));
ec_buf.resize(ec_buf.count()+RSBSIZE-rs_dsize);
rse32(((byte *)ec_buf.data()),((byte *)ec_buf.data()+(rs_dsize)));
for (i=1;i<bep_size;i++)
{
temp=tr_buf.mid(i*rs_dsize-7,rs_dsize);
if(temp.count()==0) break;
ec_buf.append(temp);
if(temp.count()<rs_dsize)
{
for(j=0;j<(rs_dsize-temp.count());j++)
{
ec_buf.append((char)0);
}
}
ec_buf.resize(ec_buf.count()+RSBSIZE-rs_dsize);
rse32(((byte *)ec_buf.data()+i*rs_bsize),((byte *)ec_buf.data()+i*rs_bsize+rs_dsize));
}
ba.resize(ec_buf.count());
distribute((byte *)ec_buf.data(),(byte *)ba.data(),bep_size,rs_bsize,ENCODE);
return TRUE;
}
static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
size_t buffer_size)
{
int numerr;
struct persistent_ram_buffer *buffer = prz->buffer;
int ecc_blocks;
if (!prz->ecc)
return 0;
prz->ecc_block_size = 128;
prz->ecc_size = 16;
prz->ecc_symsize = 8;
prz->ecc_poly = 0x11d;
ecc_blocks = DIV_ROUND_UP(prz->buffer_size - prz->ecc_size,
prz->ecc_block_size + prz->ecc_size);
prz->buffer_size -= (ecc_blocks + 1) * prz->ecc_size;
if (prz->buffer_size > buffer_size) {
pr_err("persistent_ram: invalid size %zu, non-ecc datasize %zu\n",
buffer_size, prz->buffer_size);
return -EINVAL;
}
prz->par_buffer = buffer->data + prz->buffer_size;
prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_size;
/*
* first consecutive root is 0
* primitive element to generate roots = 1
*/
prz->rs_decoder = init_rs(prz->ecc_symsize, prz->ecc_poly, 0, 1,
prz->ecc_size);
if (prz->rs_decoder == NULL) {
pr_info("persistent_ram: init_rs failed\n");
return -EINVAL;
}
prz->corrected_bytes = 0;
prz->bad_blocks = 0;
numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
prz->par_header);
if (numerr > 0) {
pr_info("persistent_ram: error in header, %d\n", numerr);
prz->corrected_bytes += numerr;
} else if (numerr < 0) {
pr_info("persistent_ram: uncorrectable error in header\n");
prz->bad_blocks++;
}
return 0;
}
__STATIC MQRRawCode *MQRraw_new(QRinput *input)
{
MQRRawCode *raw;
RS *rs;
raw = (MQRRawCode *)malloc(sizeof(MQRRawCode));
if(raw == NULL) return NULL;
raw->version = input->version;
raw->dataLength = MQRspec_getDataLength(input->version, input->level);
raw->eccLength = MQRspec_getECCLength(input->version, input->level);
raw->oddbits = raw->dataLength * 8 - MQRspec_getDataLengthBit(input->version, input->level);
raw->datacode = QRinput_getByteStream(input);
if(raw->datacode == NULL) {
free(raw);
return NULL;
}
raw->ecccode = (unsigned char *)malloc(raw->eccLength);
if(raw->ecccode == NULL) {
free(raw->datacode);
free(raw);
return NULL;
}
raw->rsblock = (RSblock *)calloc(1, sizeof(RSblock));
if(raw->rsblock == NULL) {
MQRraw_free(raw);
return NULL;
}
rs = init_rs(8, 0x11d, 0, 1, raw->eccLength, 255 - raw->dataLength - raw->eccLength);
if(rs == NULL) {
MQRraw_free(raw);
return NULL;
}
RSblock_initBlock(raw->rsblock, raw->dataLength, raw->datacode, raw->eccLength, raw->ecccode, rs);
raw->count = 0;
return raw;
}
static int __init ram_console_init(struct ram_console_buffer *buffer,
size_t buffer_size, char *old_buf)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
uint8_t *par;
#endif
ram_console_buffer = buffer;
ram_console_buffer_size =
buffer_size - sizeof(struct ram_console_buffer);
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"datasize %zu\n", buffer, buffer_size,
ram_console_buffer_size);
return 0;
}
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"non-ecc datasize %zu\n",
buffer, buffer_size, ram_console_buffer_size);
return 0;
}
ram_console_par_buffer = buffer->data + ram_console_buffer_size;
/* first consecutive root is 0
* primitive element to generate roots = 1
*/
ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
if (ram_console_rs_decoder == NULL) {
printk(KERN_INFO "ram_console: init_rs failed\n");
return 0;
}
ram_console_corrected_bytes = 0;
ram_console_bad_blocks = 0;
par = ram_console_par_buffer +
DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);
if (numerr > 0) {
printk(KERN_INFO "ram_console: error in header, %d\n", numerr);
ram_console_corrected_bytes += numerr;
} else if (numerr < 0) {
printk(KERN_INFO
"ram_console: uncorrectable error in header\n");
ram_console_bad_blocks++;
}
#endif
if (buffer->sig == RAM_CONSOLE_SIG) {
if (buffer->size > ram_console_buffer_size
|| buffer->start > buffer->size)
printk(KERN_INFO "ram_console: found existing invalid "
"buffer, size %d, start %d\n",
buffer->size, buffer->start);
else {
printk(KERN_INFO "ram_console: found existing buffer, "
"size %d, start %d\n",
buffer->size, buffer->start);
ram_console_save_old(buffer, old_buf);
}
} else {
printk(KERN_INFO "ram_console: no valid data in buffer "
"(sig = 0x%08x)\n", buffer->sig);
}
buffer->sig = RAM_CONSOLE_SIG;
buffer->start = 0;
buffer->size = 0;
register_console(&ram_console);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
console_verbose();
#endif
return 0;
}
static int __init ram_console_init(struct ram_console_buffer *buffer,
size_t buffer_size, char *old_buf)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
uint8_t *par;
#endif
ram_console_buffer = buffer;
ram_console_buffer_size =
buffer_size - sizeof(struct ram_console_buffer);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
ram_console_par_buffer = buffer->data + ram_console_buffer_size;
/* Symbolsize is 10 (bits)
* Primitive polynomial is x^10+x^3+1
* first consecutive root is 0
* primitive element to generate roots = 1
* generator polynomial degree (number of roots) = 6
*/
ram_console_rs_decoder = init_rs(10, 0x409, 0, 1, 6);
ram_console_corrected_bytes = 0;
ram_console_bad_blocks = 0;
par = ram_console_par_buffer +
DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
numerr = decode_rs8(ram_console_rs_decoder, (uint8_t *)buffer,
(uint16_t *)par, sizeof(*buffer), NULL, 0, NULL, 0, NULL);
if (numerr > 0) {
printk(KERN_INFO "ram_console: error in header, %d\n", numerr);
ram_console_corrected_bytes += numerr;
} else if (numerr < 0) {
printk(KERN_INFO
"ram_console: uncorrectable error in header\n");
ram_console_bad_blocks++;
}
#endif
if (buffer->sig == RAM_CONSOLE_SIG) {
if (buffer->size > buffer_size || buffer->start >= buffer_size)
printk(KERN_INFO "ram_console: found existing invalid "
"buffer, size %d, start %d\n",
buffer->size, buffer->start);
else {
printk(KERN_INFO "ram_console: found existing buffer, "
"size %d, start %d\n",
buffer->size, buffer->start);
ram_console_save_old(buffer, old_buf);
}
} else {
printk(KERN_INFO "ram_console: no valid data in buffer "
"(sig = 0x%08x)\n", buffer->sig);
}
buffer->sig = RAM_CONSOLE_SIG;
buffer->start = 0;
buffer->size = 0;
register_console(&ram_console);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
console_verbose();
#endif
return 0;
}
bool reedSolomonCoder::decode(QByteArray &ba,QString fn,QString &newFileName,QByteArray &baFile,QString extension,QList<int> &erasuresArray)
{
int i,j;
int startOfSegment,row;
// QByteArray *t;
init();
// qDebug() << "size of ba" << ba.size();
origFileName=fn;
fpin.setFileName(fn);
if(extension=="rs1") fileType=RST1;
else if(extension=="rs2") fileType=RST2;
else if(extension=="rs3") fileType=RST3;
else if(extension=="rs4") fileType=RST4;
else
{
return FALSE;
}
tr_buf=ba;
got=tr_buf.size();
bep_size = got/RSBSIZE;
if (got % RSBSIZE)
{
bep_size++ ;
tr_buf=tr_buf.leftJustified(bep_size*RSBSIZE,'\0');
}
// qDebug() << "got" << got << "bep_size" << bep_size;
int rest=tr_buf.count()%64;
if(rest!=0)
{
tr_buf=tr_buf.leftJustified(bep_size*RSBSIZE+(64-rest),'\0');
// qDebug() << "size of tr_buf extended" << tr_buf.count();
}
ec_buf.resize(bep_size*RSBSIZE);
bk_buf.resize(bep_size*RSBSIZE);
rs_bsize=RSBSIZE;
switch (fileType)
{
case RST1: rs_dsize=RSDSIZERS1; break;
case RST2: rs_dsize=RSDSIZERS2; break;
case RST3: rs_dsize=RSDSIZERS3; break;
case RST4: rs_dsize=RSDSIZERS4; break;
case RSTNONE: return FALSE;
}
init_rs(rs_dsize);
// setup erasure info
numMissing=0;
if(erasuresArray.count()>2) // we have erasure positions
{
totalSegments=erasuresArray.at(0);
segmentLength=erasuresArray.at(1);
numMissing=erasuresArray.count()-2;
// qDebug() << "numMissing" << numMissing;
if(zeroPositions) delete zeroPositions;
if(newZeroPositions) delete newZeroPositions;
zeroPositions=new int[segmentLength*(totalSegments+1)];
newZeroPositions=new int[256*bep_size];
// qDebug() << "newZeroPositions len" << (segmentLength*(totalSegments+1));
for(i=0;i<(segmentLength*totalSegments);i++) zeroPositions[i]=-1;
}
else
{
qDebug() << "no erasure info";
return FALSE;
}
/* now label the erasures positions */
for (i= 0 ; i < numMissing; i++)
{
startOfSegment = erasuresArray.at(i+2)*segmentLength ; // +2 because of header in array
for (j=0; j < segmentLength ; j++)
{
row = (startOfSegment +j ) / bep_size;
/* if ( row < rs_dsize) */
zeroPositions[startOfSegment+j] = row;
}
}
/* distribute version pa0mbo for the indexes */
int *pointzero=newZeroPositions;
for (i=0; i < bep_size ; i++)
{
for (j=0; j < 255 ; j++)
{
*(pointzero++) = *(zeroPositions + j*bep_size + i);
}
}
distribute((byte *)tr_buf.data(),(byte *)ec_buf.data(),bep_size,rs_bsize,DECODE);
if(!decode_and_write())
{
// fpout.close();
return FALSE;
}
// fpin.close();
// fpout.close();
// tr_buf=ec_buf;
if(uncorrectableFailures>0) return FALSE;
// if(fpout.open(QIODevice::ReadOnly)<=0) return FALSE;
// tr_buf=fpout.readAll();
if (bep_size != (((unsigned char) tr_buf[1]) + ((unsigned char) tr_buf[2])*256 ))
{
qDebug()<< "problems with bep_size coded in file";
qDebug() << "bep_size: " << bep_size <<" coded size: " << (((unsigned char) tr_buf[1]) + ((unsigned char) tr_buf[2])*256 ) ;
qDebug() << "bep_sizeaa: " << bep_size <<" coded size: " << (((unsigned char) ba[1]) + ((unsigned char)ba[2])*256 ) ;
return FALSE;
}
coded_file_size = bep_size*rs_dsize - (int)tr_buf[0];
strncpy(coded_file_ext, tr_buf.data()+3,3);
coded_file_ext[3]=0;
QFileInfo fileInfo(origFileName);
QString baseName=rxImagesPath+"/"+fileInfo.completeBaseName();
baseName.append(".");
baseName.append(coded_file_ext);
// qDebug() <<" new filename: " << baseName;
// qDebug() << "tr_buf count before truncation: " << tr_buf.count();
tr_buf=tr_buf.right(tr_buf.count()-7);
tr_buf=tr_buf.left(coded_file_size);
// qDebug() << "coded_file_size: " << coded_file_size << "tr_buf count: " << tr_buf.count();
newFileName=baseName;
// t=&tr_buf;
baFile=tr_buf;
// fpout.close();
if(uncorrectableFailures>0)
{
// qDebug() <<"uncorrectable failures:" << uncorrectableFailures;
return FALSE;
}
return TRUE;
}
static int __init ram_console_init(struct ram_console_buffer *buffer,
size_t buffer_size, const char *bootinfo,
char *old_buf)
{
int i;
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
uint8_t *par;
#endif
ram_console_buffer = buffer;
ram_console_buffer_size =
buffer_size - sizeof(struct ram_console_buffer);
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"datasize %zu\n", buffer, buffer_size,
ram_console_buffer_size);
return 0;
}
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"non-ecc datasize %zu\n",
buffer, buffer_size, ram_console_buffer_size);
return 0;
}
ram_console_par_buffer = buffer->data + ram_console_buffer_size;
/* first consecutive root is 0
* primitive element to generate roots = 1
*/
ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
if (ram_console_rs_decoder == NULL) {
printk(KERN_INFO "ram_console: init_rs failed\n");
return 0;
}
ram_console_corrected_bytes = 0;
ram_console_bad_blocks = 0;
par = ram_console_par_buffer +
DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);
if (numerr > 0) {
printk(KERN_INFO "ram_console: error in header, %d\n", numerr);
ram_console_corrected_bytes += numerr;
} else if (numerr < 0) {
printk(KERN_INFO
"ram_console: uncorrectable error in header\n");
ram_console_bad_blocks++;
}
#endif
if (buffer->sig == RAM_CONSOLE_SIG) {
if (buffer->size > ram_console_buffer_size
|| buffer->start > buffer->size)
printk(KERN_INFO "ram_console: found existing invalid "
"buffer, size %d, start %d\n",
buffer->size, buffer->start);
else {
printk(KERN_INFO "ram_console: found existing buffer, "
"size %d, start %d\n",
buffer->size, buffer->start);
ram_console_save_old(buffer, bootinfo, old_buf);
}
} else {
printk(KERN_INFO "ram_console: no valid data in buffer "
"(sig = 0x%08x)\n", buffer->sig);
}
buffer->sig = RAM_CONSOLE_SIG;
buffer->start = 0;
buffer->size = 0;
buffer->hw_status = 0;
buffer->shutdown_mode = 0;
buffer->jiffies_current = buffer->jiffies_wdk_kick = buffer->jiffies_idle = INITIAL_JIFFIES;
for (i = 0; i < RC_CPU_COUNT; i++) {
buffer->last_irq_enter[i] = 0;
buffer->jiffies_last_irq_enter[i] = 0;
buffer->last_irq_exit[i] = 0;
buffer->jiffies_last_irq_exit[i] = 0;
buffer->jiffies_last_sched[i] = 0;
memset(buffer->last_sched_comm[i], i, TASK_COMM_LEN);
}
register_console(&ram_console);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
//console_verbose();
#endif
return 0;
}
