void TurboCodeWithZP::Decoder_term(const itpp::cvec& in1,
const itpp::cvec& in2,
double n0, int iterations) const
{
// std::cout << "## zeroPadding_ = " << zeroPadding_.PadPositions() << std::endl;
int memory = rsc1_.Constraint() - 1;
static itpp::vec llrZeros(0);
if (llrZeros.size() != memory){
llrZeros.set_size(memory);
llrZeros.zeros();
} // if
for (int ite = 0; ite < iterations; ++ite){
itpp::vec llrToRsc1_mod = zeroPadding_.ModifyLLR(llrToRsc1_);
itpp::vec llrFromRsc1;
rsc1_.Decode(in1, llrToRsc1_mod, &llrFromRsc1, n0);
itpp::vec llrFromRsc1_mod = zeroPadding_.ModifyLLR(llrFromRsc1);
itpp::vec llrToRsc2 = Interleave(llrFromRsc1_mod.left(interleaver_.size()), interleaver_);
llrToRsc2 = itpp::concat(llrToRsc2, llrZeros);
itpp::vec llrFromRsc2;
rsc2_.Decode(in2, llrToRsc2, &llrFromRsc2, n0);
llrToRsc1_ = Deinterleave(llrFromRsc2.left(interleaver_.size()), interleaver_);
llrToRsc1_ = itpp::concat(llrToRsc1_, llrZeros);
} // for ite
}
void TurboCode::Decoder_term(const itpp::cvec &in1,
const itpp::cvec &in2,
double n0, int iteration) const
{
int memory = rsc1_.Constraint() - 1;
static itpp::vec llrZeros(0);
if (llrZeros.size() != memory){
llrZeros.set_size(memory);
llrZeros.zeros();
} // if
for (int ite = 0; ite < iteration; ++ite){
itpp::vec llrFromRsc1;
rsc1_.Decode(in1, llrToRsc1_, &llrFromRsc1, n0);
itpp::vec llrToRsc2 = Interleave(llrFromRsc1.left(interleaver_.size()), interleaver_);
llrToRsc2 = itpp::concat(llrToRsc2, llrZeros);
itpp::vec llrFromRsc2;
rsc2_.Decode(in2, llrToRsc2, &llrFromRsc2, n0);
llrToRsc1_ = Deinterleave(llrFromRsc2.left(interleaver_.size()), interleaver_);
llrToRsc1_ = itpp::concat(llrToRsc1_, llrZeros);
} // for ite
}
void TurboCode::doDecode(const itpp::cvec &receivedSignal, itpp::bvec *output, double n0) const
{
assert(receivedSignal.size() % codeRate_.denominator() == 0);
itpp::cvec in1, in2;
SeparateReceivedSignal(receivedSignal, &in1, &in2);
Decoder(in1, in2, n0, iteration_);
itpp::bvec interleaved_output = rsc2_.HardDecision();
(*output) = Deinterleave(interleaved_output, interleaver_);
}
void TurboCode::Decoder(const itpp::cvec &in1,
const itpp::cvec &in2, double n0, int iteration) const
{
for (int ite = 0; ite < iteration; ++ite){
itpp::vec llrFromRsc1;
rsc1_.Decode(in1, llrToRsc1_, &llrFromRsc1, n0);
itpp::vec llrToRsc2 = Interleave(llrFromRsc1, interleaver_);
itpp::vec llrFromRsc2;
rsc2_.Decode(in2, llrToRsc2, &llrFromRsc2, n0);
llrToRsc1_ = Deinterleave(llrFromRsc2, interleaver_);
} // for ite
}
void TurboCode::doDecode_term(const itpp::cvec& receivedSignal, itpp::bvec* output,
double n0) const
{
int memory = rsc1_.Constraint() - 1;
itpp::cvec in1, in2;
SeparateReceivedSignal(receivedSignal, &in1, &in2);
itpp::cvec tail1 = receivedSignal.mid(3*interleaver_.size(), 2*memory);
itpp::cvec tail2 = receivedSignal.right(2*memory);
in1 = itpp::concat(in1, tail1);
in2 = itpp::concat(in2, tail2);
Decoder_term(in1, in2, n0, iteration_);
itpp::bvec interleaved_output = rsc2_.HardDecision();
(*output) = Deinterleave(interleaved_output.left(interleaver_.size()), interleaver_);
}
/************************************************************************************
* TurboCodeWithZP
*
* Implementation of Turbo Code with Zero Padding
************************************************************************************/
void TurboCodeWithZP::Decoder(const itpp::cvec &in1,
const itpp::cvec &in2, double n0, int iterations) const
{
for (int ite = 0; ite < iterations; ++ite){
itpp::vec llrToRsc1_mod = zeroPadding_.ModifyLLR(llrToRsc1_);
itpp::vec llrFromRsc1;
rsc1_.Decode(in1, llrToRsc1_mod, &llrFromRsc1, n0);
itpp::vec llrFromRsc1_mod = zeroPadding_.ModifyLLR(llrFromRsc1);
itpp::vec llrToRsc2 = Interleave(llrFromRsc1_mod.left(interleaver_.size()), interleaver_);
itpp::vec llrFromRsc2;
rsc2_.Decode(in2, llrToRsc2, &llrFromRsc2, n0);
llrToRsc1_ = Deinterleave(llrFromRsc2.left(interleaver_.size()), interleaver_);
} // for ite
}
template <> SIMD_INLINE uint16x8_t ReduceColTail<false>(const uint8_t *src)
{
const uint8x8x2_t t01 = vld2_u8(src - 1);
const uint8x8x2_t t23 = Deinterleave(LoadAfterLast<1>(LoadAfterLast<1>(vld1q_u8(src - 1))));
return vaddq_u16(vaddl_u8(t01.val[0], t23.val[1]), vmulq_u16(vaddl_u8(t01.val[1], t23.val[0]), K16_0003));
}
SIMD_INLINE uint16x8_t ReduceColNose(const uint8_t * src)
{
const uint8x8x2_t t01 = Deinterleave(LoadBeforeFirst<1>(vld1q_u8(src)));
const uint8x8x2_t t23 = vld2_u8(src + 1);
return vaddq_u16(vaddl_u8(t01.val[0], t23.val[1]), vmulq_u16(vaddl_u8(t01.val[1], t23.val[0]), K16_0003));
}
__regargs BitmapT *LoadILBM(const char *filename, BOOL interleaved) {
BitmapT *bitmap = NULL;
PaletteT *palette = NULL;
IffFileT iff;
if (OpenIff(&iff, filename)) {
if (iff.header.type == ID_ILBM) {
BOOL compression = FALSE;
while (ParseChunk(&iff)) {
BitmapHeaderT bmhd;
switch (iff.chunk.type) {
case ID_BMHD:
ReadChunk(&iff, &bmhd);
bitmap = NewBitmap(bmhd.w, bmhd.h, bmhd.nPlanes, interleaved);
compression = bmhd.compression;
break;
case ID_CMAP:
palette = NewPalette(iff.chunk.length / sizeof(ColorT));
ReadChunk(&iff, palette->colors);
break;
case ID_BODY:
{
BYTE *data = MemAlloc(iff.chunk.length, MEMF_PUBLIC);
LONG size = iff.chunk.length;
ReadChunk(&iff, data);
if (compression) {
LONG newSize = bitmap->bplSize * bitmap->depth;
BYTE *uncompressed = MemAlloc(newSize, MEMF_PUBLIC);
UnRLE(data, size, uncompressed);
MemFree(data, size);
data = uncompressed;
size = newSize;
}
if (!interleaved)
Deinterleave(data, bitmap);
else
memcpy(bitmap->planes[0], data, bitmap->bplSize * bitmap->depth);
MemFree(data, size);
}
break;
default:
SkipChunk(&iff);
break;
}
}
if (bitmap)
bitmap->palette = palette;
}
CloseIff(&iff);
} else {
Log("File '%s' missing.\n", filename);
}
return bitmap;
}
