120 lines
3.5 KiB
C
120 lines
3.5 KiB
C
/* dvdisaster: Additional error correction for optical media.
|
|
* Copyright (C) 2004-2010 Carsten Gnoerlich.
|
|
* Project home page: http://www.dvdisaster.com
|
|
* Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA,
|
|
* or direct your browser at http://www.gnu.org.
|
|
*/
|
|
|
|
#include "dvdisaster.h"
|
|
|
|
/***
|
|
*** Reed-Solomon encoding
|
|
***/
|
|
|
|
/* Portable (non-SSE2) version.
|
|
* Using 32bit operands seems to be a good choice for the lowest
|
|
* common denominator between the non-SSE2 systems.
|
|
*/
|
|
|
|
#ifdef HAVE_BIG_ENDIAN
|
|
#define SHIFT_LEFT <<
|
|
#define SHIFT_RIGHT >>
|
|
#else
|
|
#define SHIFT_LEFT >>
|
|
#define SHIFT_RIGHT <<
|
|
#endif /* HAVE_BIG_ENDIAN */
|
|
|
|
static void encode_next_layer_portable(ReedSolomonTables *rt, unsigned char *data, unsigned char *parity, guint64 layer_size, int shift)
|
|
{ gint32 *gf_index_of = rt->gfTables->indexOf;
|
|
gint32 *enc_alpha_to = rt->gfTables->encAlphaTo;
|
|
gint32 *rs_gpoly = rt->gpoly;
|
|
int nroots = rt->nroots;
|
|
int nroots_aligned = (nroots+15)&~15;
|
|
int nroots_aligned32 = (nroots+3)&~3;
|
|
int nroots_full = nroots_aligned32>>2;
|
|
int i,j;
|
|
|
|
for(i=0; i<layer_size; i++)
|
|
{ int feedback = gf_index_of[data[i] ^ parity[shift]];
|
|
int offset = nroots-shift-1;
|
|
int byte_offset = offset&3;
|
|
|
|
if(feedback != GF_ALPHA0) /* non-zero feedback term */
|
|
{ guint32 *par_idx = (guint32*)parity;
|
|
guint32 *e_lut = ((guint32*)(rt->bLut[feedback]+(offset&~3)));
|
|
|
|
/* Process lut in 32 bit steps */
|
|
|
|
switch(byte_offset)
|
|
{ case 0:
|
|
for(j=nroots_full; j; j--)
|
|
*par_idx++ ^= *e_lut++;
|
|
break;
|
|
|
|
case 1:
|
|
{ for(j=nroots_full; j; j--)
|
|
{ guint32 span = *e_lut SHIFT_LEFT 8;
|
|
e_lut++;
|
|
span |= *e_lut SHIFT_RIGHT 24;
|
|
*par_idx++ ^= span;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{ for(j=nroots_full; j; j--)
|
|
{ guint32 span = *e_lut SHIFT_LEFT 16;
|
|
e_lut++;
|
|
span |= *e_lut SHIFT_RIGHT 16;
|
|
*par_idx++ ^= span;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{ for(j=nroots_full; j; j--)
|
|
{ guint32 span = *e_lut SHIFT_LEFT 24;
|
|
e_lut++;
|
|
span |= *e_lut SHIFT_RIGHT 8;
|
|
*par_idx++ ^= span;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
parity[shift] = enc_alpha_to[feedback + rs_gpoly[0]];
|
|
}
|
|
else /* zero feedback term */
|
|
parity[shift] = 0;
|
|
|
|
parity += nroots_aligned;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Dispatch upon availability of SSE2 intrinsics
|
|
*/
|
|
|
|
void encode_next_layer_sse2(ReedSolomonTables*, unsigned char*, unsigned char*, guint64, int);
|
|
|
|
void EncodeNextLayer(ReedSolomonTables *rt, unsigned char *data, unsigned char *parity, guint64 layer_size, int shift)
|
|
{
|
|
if(Closure->useSSE2)
|
|
encode_next_layer_sse2(rt, data, parity, layer_size, shift);
|
|
else encode_next_layer_portable(rt, data, parity, layer_size, shift);
|
|
}
|