void huffman_decoder::decode_file(std::istream & ins, std::ostream & outs) {
inbs = new ibstream(ins);
chars_count = (((size_t)ins.get()) << 8) | ((size_t)ins.get());
if (chars_count == 0) {
return;
}
read_tree(ins);
decode_and_write(outs);
free_resources();
}
static void
test_repair(struct s_sndfile *sf_out,
codec_id_t cid,
repair_id_t repair_type,
struct s_sndfile *sf_in)
{
codec_state *encoder;
struct s_codec_state_store *decoder_states;
media_data *md_prev, *md_cur;
coded_unit *cu;
int32_t consec_lost = 0, total_lost, total_done;
const codec_format_t *cf;
uint16_t i;
repair_id_t repair_none;
for (i = 0; i < repair_get_count(); i++) {
const repair_details_t *rd;
rd = repair_get_details(i);
if (strcasecmp(rd->name, "none") == 0) {
repair_none = rd->id;
break;
}
}
codec_encoder_create(cid, &encoder);
codec_state_store_create(&decoder_states, DECODER);
cf = codec_get_format(cid);
/* Read and write one unit to kick off with */
media_data_create(&md_cur, 1);
read_and_encode(md_cur->rep[0], encoder, sf_in);
decode_and_write(sf_out, decoder_states, md_cur);
/* Initialize next reading cycle */
md_prev = md_cur;
md_cur = NULL;
media_data_create(&md_cur, 1);
total_lost = total_done = 0;
while(read_and_encode(md_cur->rep[0], encoder, sf_in)) {
total_done++;
if (do_drop()) {
total_lost++;
media_data_destroy(&md_cur, sizeof(media_data));
media_data_create(&md_cur, 0);
cu = (coded_unit*)block_alloc(sizeof(coded_unit));
assert(cu != NULL);
memset(cu, 0, sizeof(coded_unit));
/* Loss happens - invoke repair */
if (repair_type != repair_none) {
cu->id = cid;
repair(repair_type,
consec_lost,
decoder_states,
md_prev,
cu);
} else {
/* Create a silent unit */
cu->id = codec_get_native_coding((uint16_t)cf->format.sample_rate,
(uint16_t)cf->format.channels);
cu->state = NULL;
cu->state_len = 0;
cu->data = (u_char*)block_alloc(cf->format.bytes_per_block);
cu->data_len = cf->format.bytes_per_block;
memset(cu->data, 0, cu->data_len);
}
/* Add repaired audio to frame */
md_cur->rep[md_cur->nrep] = cu;
md_cur->nrep++;
consec_lost++;
} else {
consec_lost = 0;
}
decode_and_write(sf_out, decoder_states, md_cur);
media_data_destroy(&md_prev, sizeof(media_data));
md_prev = md_cur;
md_cur = NULL;
media_data_create(&md_cur, 1);
}
printf("# Dropped %d frames out of %d (%f loss %%)\n", total_lost, total_done, 100.0 * total_lost / (double)total_done);
media_data_destroy(&md_cur, sizeof(media_data));
media_data_destroy(&md_prev, sizeof(media_data));
codec_encoder_destroy(&encoder);
codec_state_store_destroy(&decoder_states);
}
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;
}
