/* -*- c++ -*- */
/*
* Copyright 2015-2017,2019 Free Software Foundation, Inc.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "dvbt2_framemapper_cc_impl.h"
#include <gnuradio/io_signature.h>
#include <algorithm>
namespace gr {
namespace dtv {
dvbt2_framemapper_cc::sptr
dvbt2_framemapper_cc::make(dvb_framesize_t framesize,
dvb_code_rate_t rate,
dvb_constellation_t constellation,
dvbt2_rotation_t rotation,
int fecblocks,
int tiblocks,
dvbt2_extended_carrier_t carriermode,
dvbt2_fftsize_t fftsize,
dvb_guardinterval_t guardinterval,
dvbt2_l1constellation_t l1constellation,
dvbt2_pilotpattern_t pilotpattern,
int t2frames,
int numdatasyms,
dvbt2_papr_t paprmode,
dvbt2_version_t version,
dvbt2_preamble_t preamble,
dvbt2_inputmode_t inputmode,
dvbt2_reservedbiasbits_t reservedbiasbits,
dvbt2_l1scrambled_t l1scrambled,
dvbt2_inband_t inband)
{
return gnuradio::make_block_sptr<dvbt2_framemapper_cc_impl>(framesize,
rate,
constellation,
rotation,
fecblocks,
tiblocks,
carriermode,
fftsize,
guardinterval,
l1constellation,
pilotpattern,
t2frames,
numdatasyms,
paprmode,
version,
preamble,
inputmode,
reservedbiasbits,
l1scrambled,
inband);
}
/*
* The private constructor
*/
dvbt2_framemapper_cc_impl::dvbt2_framemapper_cc_impl(
dvb_framesize_t framesize,
dvb_code_rate_t rate,
dvb_constellation_t constellation,
dvbt2_rotation_t rotation,
int fecblocks,
int tiblocks,
dvbt2_extended_carrier_t carriermode,
dvbt2_fftsize_t fftsize,
dvb_guardinterval_t guardinterval,
dvbt2_l1constellation_t l1constellation,
dvbt2_pilotpattern_t pilotpattern,
int t2frames,
int numdatasyms,
dvbt2_papr_t paprmode,
dvbt2_version_t version,
dvbt2_preamble_t preamble,
dvbt2_inputmode_t inputmode,
dvbt2_reservedbiasbits_t reservedbiasbits,
dvbt2_l1scrambled_t l1scrambled,
dvbt2_inband_t inband)
: gr::block("dvbt2_framemapper_cc",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(gr_complex)))
{
L1Pre* l1preinit = &L1_Signalling[0].l1pre_data;
L1Post* l1postinit = &L1_Signalling[0].l1post_data;
double normalization;
double m_16qam_lookup[4] = { 3.0, 1.0, -3.0, -1.0 };
double m_64qam_lookup[8] = { 7.0, 5.0, 1.0, 3.0, -7.0, -5.0, -1.0, -3.0 };
int real_index, imag_index;
int N_punc_temp, N_post_temp;
if (framesize == FECFRAME_NORMAL) {
switch (constellation) {
case MOD_QPSK:
cell_size = 32400;
break;
case MOD_16QAM:
cell_size = 16200;
break;
case MOD_64QAM:
cell_size = 10800;
break;
case MOD_256QAM:
cell_size = 8100;
break;
default:
cell_size = 0;
break;
}
} else {
switch (constellation) {
case MOD_QPSK:
cell_size = 8100;
break;
case MOD_16QAM:
cell_size = 4050;
break;
case MOD_64QAM:
cell_size = 2700;
break;
case MOD_256QAM:
cell_size = 2025;
break;
default:
cell_size = 0;
break;
}
}
l1preinit->type = STREAMTYPE_TS;
l1preinit->bwt_ext = carriermode;
fft_size = fftsize;
l1preinit->s1 = preamble;
l1preinit->s2 = fft_size & 0x7;
l1preinit->l1_repetition_flag = FALSE;
l1preinit->guard_interval = guardinterval;
l1preinit->papr = paprmode;
l1preinit->l1_mod = l1constellation;
l1preinit->l1_cod = 0;
l1preinit->l1_fec_type = 0;
l1preinit->l1_post_info_size = KSIG_POST - 32;
l1preinit->pilot_pattern = pilotpattern;
l1preinit->tx_id_availability = 0;
l1preinit->cell_id = 0;
l1preinit->network_id = 0x3085;
l1preinit->t2_system_id = 0x8001;
l1preinit->num_t2_frames = t2frames;
l1preinit->num_data_symbols = numdatasyms;
l1preinit->regen_flag = FALSE;
l1preinit->l1_post_extension = FALSE;
l1preinit->num_rf = 1;
l1preinit->current_rf_index = 0;
l1preinit->t2_version = version;
if (version == VERSION_131) {
l1preinit->l1_post_scrambled = l1scrambled;
} else {
l1preinit->l1_post_scrambled = FALSE;
}
l1preinit->t2_base_lite = FALSE;
if (reservedbiasbits == RESERVED_ON && version == VERSION_131) {
l1preinit->reserved = 0xf;
} else {
l1preinit->reserved = 0x0;
}
l1postinit->sub_slices_per_frame = 1;
l1postinit->num_plp = 1;
l1postinit->num_aux = 0;
l1postinit->aux_config_rfu = 0;
l1postinit->rf_idx = 0;
l1postinit->frequency = 729833333;
l1postinit->plp_id = 0;
l1postinit->plp_type = 1;
l1postinit->plp_payload_type = 3;
l1postinit->ff_flag = 0;
l1postinit->first_rf_idx = 0;
l1postinit->first_frame_idx = 0;
l1postinit->plp_group_id = 1;
switch (rate) {
case C1_3:
l1postinit->plp_cod = 6;
break;
case C2_5:
l1postinit->plp_cod = 7;
break;
case C1_2:
l1postinit->plp_cod = 0;
break;
case C3_5:
l1postinit->plp_cod = 1;
break;
case C2_3:
l1postinit->plp_cod = 2;
break;
case C3_4:
l1postinit->plp_cod = 3;
break;
case C4_5:
l1postinit->plp_cod = 4;
break;
case C5_6:
l1postinit->plp_cod = 5;
break;
default:
l1postinit->plp_cod = 0;
break;
}
l1postinit->plp_mod = constellation;
l1postinit->plp_rotation = rotation;
l1postinit->plp_fec_type = framesize;
l1postinit->plp_num_blocks_max = fecblocks;
l1postinit->frame_interval = 1;
l1postinit->time_il_length = tiblocks;
l1postinit->time_il_type = 0;
l1postinit->in_band_a_flag = 0;
if (inband == INBAND_ON && version == VERSION_131) {
l1postinit->in_band_b_flag = 1;
} else {
l1postinit->in_band_b_flag = 0;
}
if (reservedbiasbits == RESERVED_ON && version == VERSION_131) {
l1postinit->reserved_1 = 0x7ff;
} else {
l1postinit->reserved_1 = 0x0;
}
if (version == VERSION_111) {
l1postinit->plp_mode = 0;
} else {
l1postinit->plp_mode = inputmode + 1;
}
l1postinit->static_flag = 0;
l1postinit->static_padding_flag = 0;
l1postinit->fef_length_msb = 0;
if (reservedbiasbits == RESERVED_ON && version == VERSION_131) {
l1postinit->reserved_2 = 0x3fffffff;
} else {
l1postinit->reserved_2 = 0;
}
l1postinit->frame_idx = 0;
l1postinit->sub_slice_interval = 0;
l1postinit->type_2_start = 0;
l1postinit->l1_change_counter = 0;
l1postinit->start_rf_idx = 0;
if (reservedbiasbits == RESERVED_ON && version == VERSION_131) {
l1postinit->reserved_3 = 0xff;
} else {
l1postinit->reserved_3 = 0;
}
l1postinit->plp_id = 0;
l1postinit->plp_start = 0;
l1postinit->plp_num_blocks = fecblocks;
if (reservedbiasbits == RESERVED_ON && version == VERSION_131) {
l1postinit->reserved_4 = 0xff;
l1postinit->reserved_5 = 0xff;
} else {
l1postinit->reserved_4 = 0;
l1postinit->reserved_5 = 0;
}
bch_poly_build_tables();
l1pre_ldpc_lookup_generate();
m_bpsk[0] = gr_complex(1.0, 0.0);
m_bpsk[1] = gr_complex(-1.0, 0.0);
unmodulated = gr_complex(0.0, 0.0);
l1post_ldpc_lookup_generate();
switch (l1constellation) {
case L1_MOD_BPSK:
eta_mod = 1;
break;
case L1_MOD_QPSK:
normalization = sqrt(2);
m_qpsk[0] = gr_complex(1.0 / normalization, 1.0 / normalization);
m_qpsk[1] = gr_complex(1.0 / normalization, -1.0 / normalization);
m_qpsk[2] = gr_complex(-1.0 / normalization, 1.0 / normalization);
m_qpsk[3] = gr_complex(-1.0 / normalization, -1.0 / normalization);
eta_mod = 2;
break;
case L1_MOD_16QAM:
normalization = sqrt(10);
for (int i = 0; i < 16; i++) {
real_index = ((i & 0x8) >> 2) | ((i & 0x2) >> 1);
imag_index = ((i & 0x4) >> 1) | ((i & 0x1) >> 0);
m_16qam[i] = gr_complex(m_16qam_lookup[real_index] / normalization,
m_16qam_lookup[imag_index] / normalization);
}
eta_mod = 4;
break;
case L1_MOD_64QAM:
normalization = sqrt(42);
for (int i = 0; i < 64; i++) {
real_index = ((i & 0x20) >> 3) | ((i & 0x8) >> 2) | ((i & 0x2) >> 1);
imag_index = ((i & 0x10) >> 2) | ((i & 0x4) >> 1) | ((i & 0x1) >> 0);
m_64qam[i] = gr_complex(m_64qam_lookup[real_index] / normalization,
m_64qam_lookup[imag_index] / normalization);
}
eta_mod = 6;
break;
}
N_P2 = 1;
C_P2 = 0;
N_FC = 0;
C_FC = 0;
C_DATA = 0;
if ((preamble == PREAMBLE_T2_SISO) || (preamble == PREAMBLE_T2_LITE_SISO)) {
switch (fft_size) {
case FFTSIZE_1K:
N_P2 = 16;
C_P2 = 558;
break;
case FFTSIZE_2K:
N_P2 = 8;
C_P2 = 1118;
break;
case FFTSIZE_4K:
N_P2 = 4;
C_P2 = 2236;
break;
case FFTSIZE_8K:
case FFTSIZE_8K_T2GI:
N_P2 = 2;
C_P2 = 4472;
break;
case FFTSIZE_16K:
case FFTSIZE_16K_T2GI:
N_P2 = 1;
C_P2 = 8944;
break;
case FFTSIZE_32K:
case FFTSIZE_32K_T2GI:
N_P2 = 1;
C_P2 = 22432;
break;
}
} else {
switch (fft_size) {
case FFTSIZE_1K:
N_P2 = 16;
C_P2 = 546;
break;
case FFTSIZE_2K:
N_P2 = 8;
C_P2 = 1098;
break;
case FFTSIZE_4K:
N_P2 = 4;
C_P2 = 2198;
break;
case FFTSIZE_8K:
case FFTSIZE_8K_T2GI:
N_P2 = 2;
C_P2 = 4398;
break;
case FFTSIZE_16K:
case FFTSIZE_16K_T2GI:
N_P2 = 1;
C_P2 = 8814;
break;
case FFTSIZE_32K:
case FFTSIZE_32K_T2GI:
N_P2 = 1;
C_P2 = 17612;
break;
}
}
switch (fft_size) {
case FFTSIZE_1K:
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 764;
N_FC = 568;
C_FC = 402;
break;
case PILOT_PP2:
C_DATA = 768;
N_FC = 710;
C_FC = 654;
break;
case PILOT_PP3:
C_DATA = 798;
N_FC = 710;
C_FC = 490;
break;
case PILOT_PP4:
C_DATA = 804;
N_FC = 780;
C_FC = 707;
break;
case PILOT_PP5:
C_DATA = 818;
N_FC = 780;
C_FC = 544;
break;
case PILOT_PP6:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP7:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP8:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 10;
}
if (N_FC != 0) {
N_FC -= 10;
}
if (C_FC != 0) {
C_FC -= 10;
}
}
break;
case FFTSIZE_2K:
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 1522;
N_FC = 1136;
C_FC = 804;
break;
case PILOT_PP2:
C_DATA = 1532;
N_FC = 1420;
C_FC = 1309;
break;
case PILOT_PP3:
C_DATA = 1596;
N_FC = 1420;
C_FC = 980;
break;
case PILOT_PP4:
C_DATA = 1602;
N_FC = 1562;
C_FC = 1415;
break;
case PILOT_PP5:
C_DATA = 1632;
N_FC = 1562;
C_FC = 1088;
break;
case PILOT_PP6:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP7:
C_DATA = 1646;
N_FC = 1632;
C_FC = 1396;
break;
case PILOT_PP8:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 18;
}
if (N_FC != 0) {
N_FC -= 18;
}
if (C_FC != 0) {
C_FC -= 18;
}
}
break;
case FFTSIZE_4K:
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 3084;
N_FC = 2272;
C_FC = 1609;
break;
case PILOT_PP2:
C_DATA = 3092;
N_FC = 2840;
C_FC = 2619;
break;
case PILOT_PP3:
C_DATA = 3228;
N_FC = 2840;
C_FC = 1961;
break;
case PILOT_PP4:
C_DATA = 3234;
N_FC = 3124;
C_FC = 2831;
break;
case PILOT_PP5:
C_DATA = 3298;
N_FC = 3124;
C_FC = 2177;
break;
case PILOT_PP6:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP7:
C_DATA = 3328;
N_FC = 3266;
C_FC = 2792;
break;
case PILOT_PP8:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 36;
}
if (N_FC != 0) {
N_FC -= 36;
}
if (C_FC != 0) {
C_FC -= 36;
}
}
break;
case FFTSIZE_8K:
case FFTSIZE_8K_T2GI:
if (carriermode == CARRIERS_NORMAL) {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 6208;
N_FC = 4544;
C_FC = 3218;
break;
case PILOT_PP2:
C_DATA = 6214;
N_FC = 5680;
C_FC = 5238;
break;
case PILOT_PP3:
C_DATA = 6494;
N_FC = 5680;
C_FC = 3922;
break;
case PILOT_PP4:
C_DATA = 6498;
N_FC = 6248;
C_FC = 5662;
break;
case PILOT_PP5:
C_DATA = 6634;
N_FC = 6248;
C_FC = 4354;
break;
case PILOT_PP6:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP7:
C_DATA = 6698;
N_FC = 6532;
C_FC = 5585;
break;
case PILOT_PP8:
C_DATA = 6698;
N_FC = 0;
C_FC = 0;
break;
}
} else {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 6296;
N_FC = 4608;
C_FC = 3264;
break;
case PILOT_PP2:
C_DATA = 6298;
N_FC = 5760;
C_FC = 5312;
break;
case PILOT_PP3:
C_DATA = 6584;
N_FC = 5760;
C_FC = 3978;
break;
case PILOT_PP4:
C_DATA = 6588;
N_FC = 6336;
C_FC = 5742;
break;
case PILOT_PP5:
C_DATA = 6728;
N_FC = 6336;
C_FC = 4416;
break;
case PILOT_PP6:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP7:
C_DATA = 6788;
N_FC = 6624;
C_FC = 5664;
break;
case PILOT_PP8:
C_DATA = 6788;
N_FC = 0;
C_FC = 0;
break;
}
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 72;
}
if (N_FC != 0) {
N_FC -= 72;
}
if (C_FC != 0) {
C_FC -= 72;
}
}
break;
case FFTSIZE_16K:
case FFTSIZE_16K_T2GI:
if (carriermode == CARRIERS_NORMAL) {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 12418;
N_FC = 9088;
C_FC = 6437;
break;
case PILOT_PP2:
C_DATA = 12436;
N_FC = 11360;
C_FC = 10476;
break;
case PILOT_PP3:
C_DATA = 12988;
N_FC = 11360;
C_FC = 7845;
break;
case PILOT_PP4:
C_DATA = 13002;
N_FC = 12496;
C_FC = 11324;
break;
case PILOT_PP5:
C_DATA = 13272;
N_FC = 12496;
C_FC = 8709;
break;
case PILOT_PP6:
C_DATA = 13288;
N_FC = 13064;
C_FC = 11801;
break;
case PILOT_PP7:
C_DATA = 13416;
N_FC = 13064;
C_FC = 11170;
break;
case PILOT_PP8:
C_DATA = 13406;
N_FC = 0;
C_FC = 0;
break;
}
} else {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 12678;
N_FC = 9280;
C_FC = 6573;
break;
case PILOT_PP2:
C_DATA = 12698;
N_FC = 11600;
C_FC = 10697;
break;
case PILOT_PP3:
C_DATA = 13262;
N_FC = 11600;
C_FC = 8011;
break;
case PILOT_PP4:
C_DATA = 13276;
N_FC = 12760;
C_FC = 11563;
break;
case PILOT_PP5:
C_DATA = 13552;
N_FC = 12760;
C_FC = 8893;
break;
case PILOT_PP6:
C_DATA = 13568;
N_FC = 13340;
C_FC = 12051;
break;
case PILOT_PP7:
C_DATA = 13698;
N_FC = 13340;
C_FC = 11406;
break;
case PILOT_PP8:
C_DATA = 13688;
N_FC = 0;
C_FC = 0;
break;
}
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 144;
}
if (N_FC != 0) {
N_FC -= 144;
}
if (C_FC != 0) {
C_FC -= 144;
}
}
break;
case FFTSIZE_32K:
case FFTSIZE_32K_T2GI:
if (carriermode == CARRIERS_NORMAL) {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP2:
C_DATA = 24886;
N_FC = 22720;
C_FC = 20952;
break;
case PILOT_PP3:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP4:
C_DATA = 26022;
N_FC = 24992;
C_FC = 22649;
break;
case PILOT_PP5:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP6:
C_DATA = 26592;
N_FC = 26128;
C_FC = 23603;
break;
case PILOT_PP7:
C_DATA = 26836;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP8:
C_DATA = 26812;
N_FC = 0;
C_FC = 0;
break;
}
} else {
switch (pilotpattern) {
case PILOT_PP1:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP2:
C_DATA = 25412;
N_FC = 23200;
C_FC = 21395;
break;
case PILOT_PP3:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP4:
C_DATA = 26572;
N_FC = 25520;
C_FC = 23127;
break;
case PILOT_PP5:
C_DATA = 0;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP6:
C_DATA = 27152;
N_FC = 26680;
C_FC = 24102;
break;
case PILOT_PP7:
C_DATA = 27404;
N_FC = 0;
C_FC = 0;
break;
case PILOT_PP8:
C_DATA = 27376;
N_FC = 0;
C_FC = 0;
break;
}
}
if (paprmode == PAPR_TR || paprmode == PAPR_BOTH) {
if (C_DATA != 0) {
C_DATA -= 288;
}
if (N_FC != 0) {
N_FC -= 288;
}
if (C_FC != 0) {
C_FC -= 288;
}
}
break;
}
if ((preamble == PREAMBLE_T2_SISO) || (preamble == PREAMBLE_T2_LITE_SISO)) {
if (guardinterval == GI_1_128 && pilotpattern == PILOT_PP7) {
N_FC = 0;
C_FC = 0;
}
if (guardinterval == GI_1_32 && pilotpattern == PILOT_PP4) {
N_FC = 0;
C_FC = 0;
}
if (guardinterval == GI_1_16 && pilotpattern == PILOT_PP2) {
N_FC = 0;
C_FC = 0;
}
if (guardinterval == GI_19_256 && pilotpattern == PILOT_PP2) {
N_FC = 0;
C_FC = 0;
}
}
N_punc_temp = (6 * (KBCH_1_2 - KSIG_POST)) / 5;
N_post_temp = KSIG_POST + NBCH_PARITY + 9000 - N_punc_temp;
if (N_P2 == 1) {
N_post = ceil((float)N_post_temp / (2 * (float)eta_mod)) * 2 * eta_mod;
} else {
N_post =
ceil((float)N_post_temp / ((float)eta_mod * (float)N_P2)) * eta_mod * N_P2;
}
N_punc = N_punc_temp - (N_post - N_post_temp);
l1preinit->l1_post_size = N_post / eta_mod;
add_l1pre(&l1pre_cache[0]);
l1_constellation = l1constellation;
t2_frames = t2frames;
t2_frame_num = 0;
if (version == VERSION_131) {
l1_scrambled = l1scrambled;
} else {
l1_scrambled = FALSE;
}
stream_items = cell_size * fecblocks;
if (N_FC == 0) {
set_output_multiple((N_P2 * C_P2) + (numdatasyms * C_DATA));
mapped_items = (N_P2 * C_P2) + (numdatasyms * C_DATA);
if (mapped_items < (stream_items + 1840 + (N_post / eta_mod) + (N_FC - C_FC))) {
GR_LOG_WARN(d_logger, "Frame Mapper, too many FEC blocks in T2 frame.");
mapped_items = stream_items + 1840 + (N_post / eta_mod) +
(N_FC - C_FC); /* avoid segfault */
}
zigzag_interleave = (gr_complex*)malloc(sizeof(gr_complex) * mapped_items);
if (zigzag_interleave == NULL) {
GR_LOG_FATAL(d_logger,
"Frame Mapper, cannot allocate memory for zigzag_interleave.");
throw std::bad_alloc();
}
} else {
set_output_multiple((N_P2 * C_P2) + ((numdatasyms - 1) * C_DATA) + N_FC);
mapped_items = (N_P2 * C_P2) + ((numdatasyms - 1) * C_DATA) + N_FC;
if (mapped_items < (stream_items + 1840 + (N_post / eta_mod) + (N_FC - C_FC))) {
GR_LOG_WARN(d_logger, "Frame Mapper, too many FEC blocks in T2 frame.");
mapped_items = stream_items + 1840 + (N_post / eta_mod) +
(N_FC - C_FC); /* avoid segfault */
}
zigzag_interleave = (gr_complex*)malloc(sizeof(gr_complex) * mapped_items);
if (zigzag_interleave == NULL) {
GR_LOG_FATAL(d_logger,
"Frame Mapper, cannot allocate memory for zigzag_interleave.");
throw std::bad_alloc();
}
}
dummy_randomize =
(gr_complex*)malloc(sizeof(gr_complex) * mapped_items - stream_items - 1840 -
(N_post / eta_mod) - (N_FC - C_FC));
if (dummy_randomize == NULL) {
free(zigzag_interleave);
GR_LOG_FATAL(d_logger,
"Frame Mapper, cannot allocate memory for dummy_randomize.");
throw std::bad_alloc();
}
init_dummy_randomizer();
init_l1_randomizer();
}
/*
* Our virtual destructor.
*/
dvbt2_framemapper_cc_impl::~dvbt2_framemapper_cc_impl()
{
free(dummy_randomize);
free(zigzag_interleave);
}
void dvbt2_framemapper_cc_impl::forecast(int noutput_items,
gr_vector_int& ninput_items_required)
{
ninput_items_required[0] = stream_items * (noutput_items / mapped_items);
}
#define CRC_POLY 0x04C11DB7
int dvbt2_framemapper_cc_impl::add_crc32_bits(unsigned char* in, int length)
{
int crc = 0xffffffff;
int b;
int i = 0;
for (int n = 0; n < length; n++) {
b = in[i++] ^ ((crc >> 31) & 0x01);
crc <<= 1;
if (b) {
crc ^= CRC_POLY;
}
}
for (int n = 31; n >= 0; n--) {
in[i++] = (crc & (1 << n)) ? 1 : 0;
}
return 32;
}
int dvbt2_framemapper_cc_impl::poly_mult(
const int* ina, int lena, const int* inb, int lenb, int* out)
{
memset(out, 0, sizeof(int) * (lena + lenb));
for (int i = 0; i < lena; i++) {
for (int j = 0; j < lenb; j++) {
if (ina[i] * inb[j] > 0) {
out[i + j]++; // count number of terms for this pwr of x
}
}
}
int max = 0;
for (int i = 0; i < lena + lenb; i++) {
out[i] = out[i] & 1; // If even ignore the term
if (out[i])
max = i;
}
// return the size of array to house the result.
return max + 1;
}
void dvbt2_framemapper_cc_impl::poly_pack(const int* pin, unsigned int* pout, int len)
{
int lw = len / 32;
int ptr = 0;
unsigned int temp;
if (len % 32) {
lw++;
}
for (int i = 0; i < lw; i++) {
temp = 0x80000000;
pout[i] = 0;
for (int j = 0; j < 32; j++) {
if (pin[ptr++]) {
pout[i] |= temp;
}
temp >>= 1;
}
}
}
void dvbt2_framemapper_cc_impl::bch_poly_build_tables(void)
{
// Short polynomials
const int polys01[] = { 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
const int polys02[] = { 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1 };
const int polys03[] = { 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1 };
const int polys04[] = { 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1 };
const int polys05[] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1 };
const int polys06[] = { 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1 };
const int polys07[] = { 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1 };
const int polys08[] = { 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1 };
const int polys09[] = { 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1 };
const int polys10[] = { 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1 };
const int polys11[] = { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1 };
const int polys12[] = { 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1 };
int len;
int polyout[2][200];
len = poly_mult(polys01, 15, polys02, 15, polyout[0]);
len = poly_mult(polys03, 15, polyout[0], len, polyout[1]);
len = poly_mult(polys04, 15, polyout[1], len, polyout[0]);
len = poly_mult(polys05, 15, polyout[0], len, polyout[1]);
len = poly_mult(polys06, 15, polyout[1], len, polyout[0]);
len = poly_mult(polys07, 15, polyout[0], len, polyout[1]);
len = poly_mult(polys08, 15, polyout[1], len, polyout[0]);
len = poly_mult(polys09, 15, polyout[0], len, polyout[1]);
len = poly_mult(polys10, 15, polyout[1], len, polyout[0]);
len = poly_mult(polys11, 15, polyout[0], len, polyout[1]);
len = poly_mult(polys12, 15, polyout[1], len, polyout[0]);
poly_pack(polyout[0], m_poly_s_12, 168);
}
inline void dvbt2_framemapper_cc_impl::reg_6_shift(unsigned int* sr)
{
sr[5] = (sr[5] >> 1) | (sr[4] << 31);
sr[4] = (sr[4] >> 1) | (sr[3] << 31);
sr[3] = (sr[3] >> 1) | (sr[2] << 31);
sr[2] = (sr[2] >> 1) | (sr[1] << 31);
sr[1] = (sr[1] >> 1) | (sr[0] << 31);
sr[0] = (sr[0] >> 1);
}
void dvbt2_framemapper_cc_impl::l1pre_ldpc_lookup_generate(void)
{
int im;
int index;
int pbits;
int q;
index = 0;
im = 0;
pbits = FRAME_SIZE_SHORT - NBCH_1_4; // number of parity bits
q = 36;
for (int row = 0; row < 9; row++) {
for (int n = 0; n < 360; n++) {
for (int col = 1; col <= ldpc_tab_1_4S[row][0]; col++) {
l1pre_ldpc_encode.p[index] = (ldpc_tab_1_4S[row][col] + (n * q)) % pbits;
l1pre_ldpc_encode.d[index] = im;
index++;
}
im++;
}
}
l1pre_ldpc_encode.table_length = index;
}
void dvbt2_framemapper_cc_impl::l1post_ldpc_lookup_generate(void)
{
int im;
int index;
int pbits;
int q;
index = 0;
im = 0;
pbits = FRAME_SIZE_SHORT - NBCH_1_2; // number of parity bits
q = 25;
for (int row = 0; row < 20; row++) {
for (int n = 0; n < 360; n++) {
for (int col = 1; col <= ldpc_tab_1_2S[row][0]; col++) {
l1post_ldpc_encode.p[index] = (ldpc_tab_1_2S[row][col] + (n * q)) % pbits;
l1post_ldpc_encode.d[index] = im;
index++;
}
im++;
}
}
l1post_ldpc_encode.table_length = index;
}
void dvbt2_framemapper_cc_impl::add_l1pre(gr_complex* out)
{
int temp, offset_bits = 0;
unsigned char b, value;
unsigned int shift[6];
int plen = FRAME_SIZE_SHORT - NBCH_1_4;
const unsigned char* d;
unsigned char* p;
unsigned char* l1pre = l1_temp;
L1Pre* l1preinit = &L1_Signalling[0].l1pre_data;
int g, o, index;
temp = l1preinit->type;
for (int n = 7; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1pre[offset_bits++] = l1preinit->bwt_ext;
temp = l1preinit->s1;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->s2;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1pre[offset_bits++] = 0;
l1pre[offset_bits++] = l1preinit->l1_repetition_flag;
temp = l1preinit->guard_interval;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->papr;
for (int n = 3; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->l1_mod;
for (int n = 3; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->l1_cod;
for (int n = 1; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->l1_fec_type;
for (int n = 1; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->l1_post_size;
for (int n = 17; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->l1_post_info_size;
for (int n = 17; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->pilot_pattern;
for (int n = 3; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->tx_id_availability;
for (int n = 7; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->cell_id;
for (int n = 15; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->network_id;
for (int n = 15; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->t2_system_id;
for (int n = 15; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->num_t2_frames;
for (int n = 7; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->num_data_symbols;
for (int n = 11; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->regen_flag;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1pre[offset_bits++] = l1preinit->l1_post_extension;
temp = l1preinit->num_rf;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->current_rf_index;
for (int n = 2; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1preinit->t2_version;
for (int n = 3; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1pre[offset_bits++] = l1preinit->l1_post_scrambled;
l1pre[offset_bits++] = l1preinit->t2_base_lite;
temp = l1preinit->reserved;
for (int n = 3; n >= 0; n--) {
l1pre[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
offset_bits += add_crc32_bits(l1pre, offset_bits);
/* Padding */
for (int n = KBCH_1_4 - offset_bits - 1; n >= 0; n--) {
l1pre[offset_bits++] = 0;
}
/* BCH */
offset_bits = 0;
memset(shift, 0, sizeof(unsigned int) * 6);
for (int j = 0; j < KBCH_1_4; j++) {
value = l1pre[offset_bits++];
b = (value ^ ((shift[5] & 0x01000000) ? 1 : 0));
reg_6_shift(shift);
if (b) {
shift[0] ^= m_poly_s_12[0];
shift[1] ^= m_poly_s_12[1];
shift[2] ^= m_poly_s_12[2];
shift[3] ^= m_poly_s_12[3];
shift[4] ^= m_poly_s_12[4];
shift[5] ^= m_poly_s_12[5];
}
}
for (int n = 0; n < NBCH_PARITY; n++) {
l1pre[offset_bits++] = (shift[5] & 0x01000000) ? 1 : 0;
reg_6_shift(shift);
}
/* LDPC */
d = l1_temp;
p = &l1_temp[NBCH_1_4];
memset(p, 0, sizeof(unsigned char) * plen);
for (int j = 0; j < l1pre_ldpc_encode.table_length; j++) {
p[l1pre_ldpc_encode.p[j]] ^= d[l1pre_ldpc_encode.d[j]];
}
for (int j = 1; j < plen; j++) {
p[j] ^= p[j - 1];
}
/* Puncturing */
for (int c = 0; c < 31; c++) {
g = pre_puncture[c];
for (int c2 = 0; c2 < 360; c2++) {
o = (c2 * 36) + g + NBCH_1_4;
l1_temp[o] = 0x55;
}
}
g = pre_puncture[31];
for (int c2 = 0; c2 < 328; c2++) {
o = (c2 * 36) + g + NBCH_1_4;
l1_temp[o] = 0x55;
}
/* remove padding and punctured bits, BPSK modulate */
index = 0;
for (int w = 0; w < KSIG_PRE; w++) {
out[index++] = m_bpsk[l1_temp[w]];
}
for (int w = 0; w < NBCH_PARITY; w++) {
out[index++] = m_bpsk[l1_temp[w + KBCH_1_4]];
}
for (int w = 0; w < FRAME_SIZE_SHORT - NBCH_1_4; w++) {
if (l1_temp[w + NBCH_1_4] != 0x55) {
out[index++] = m_bpsk[l1_temp[w + NBCH_1_4]];
}
}
}
void dvbt2_framemapper_cc_impl::add_l1post(gr_complex* out, int t2_frame_num)
{
int temp, offset_bits = 0;
unsigned char b, value;
unsigned int shift[6];
int plen = FRAME_SIZE_SHORT - NBCH_1_2;
const unsigned char* d;
unsigned char* p;
unsigned char* l1post = l1_interleave;
L1Post* l1postinit = &L1_Signalling[0].l1post_data;
int m, g, o, last, index;
const int* post_padding;
const int* post_puncture;
int rows, numCols, mod, offset, pack, produced;
unsigned char* cols[12];
temp = l1postinit->sub_slices_per_frame;
for (int n = 14; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->num_plp;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->num_aux;
for (int n = 3; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->aux_config_rfu;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->rf_idx;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->frequency;
for (int n = 31; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_id;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_type;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_payload_type;
for (int n = 4; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1post[offset_bits++] = l1postinit->ff_flag;
temp = l1postinit->first_rf_idx;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->first_frame_idx;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_group_id;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_cod;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_mod;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1post[offset_bits++] = l1postinit->plp_rotation;
temp = l1postinit->plp_fec_type;
for (int n = 1; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_num_blocks_max;
for (int n = 9; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->frame_interval;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->time_il_length;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1post[offset_bits++] = l1postinit->time_il_type;
l1post[offset_bits++] = l1postinit->in_band_a_flag;
l1post[offset_bits++] = l1postinit->in_band_b_flag;
temp = l1postinit->reserved_1;
for (int n = 10; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_mode;
for (int n = 1; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
l1post[offset_bits++] = l1postinit->static_flag;
l1post[offset_bits++] = l1postinit->static_padding_flag;
temp = l1postinit->fef_length_msb;
for (int n = 1; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->reserved_2;
for (int n = 29; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = t2_frame_num;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->sub_slice_interval;
for (int n = 21; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->type_2_start;
for (int n = 21; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->l1_change_counter;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->start_rf_idx;
for (int n = 2; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->reserved_3;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_id_dynamic;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_start;
for (int n = 21; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->plp_num_blocks;
for (int n = 9; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->reserved_4;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
temp = l1postinit->reserved_5;
for (int n = 7; n >= 0; n--) {
l1post[offset_bits++] = temp & (1 << n) ? 1 : 0;
}
offset_bits += add_crc32_bits(l1post, offset_bits);
if (l1_scrambled == TRUE) {
for (int n = 0; n < offset_bits; n++) {
l1post[n] = l1post[n] ^ l1_randomize[n];
}
}
/* Padding */
switch (l1_constellation) {
case L1_MOD_BPSK:
post_padding = post_padding_bqpsk;
break;
case L1_MOD_QPSK:
post_padding = post_padding_bqpsk;
break;
case L1_MOD_16QAM:
post_padding = post_padding_16qam;
break;
case L1_MOD_64QAM:
post_padding = post_padding_64qam;
break;
default:
post_padding = post_padding_bqpsk;
break;
}
memset(l1_map, 0, KBCH_1_2);
if (offset_bits <= 360) {
m = 20 - 1;
last = 360 - offset_bits;
} else {
m = (KBCH_1_2 - offset_bits) / 360;
last = KBCH_1_2 - offset_bits - (360 * m);
}
for (int n = 0; n < m; n++) {
index = post_padding[n] * 360;
if (post_padding[n] == 19) {
for (int w = 0; w < 192; w++) {
l1_map[index++] = 0x7;
}
} else {
for (int w = 0; w < 360; w++) {
l1_map[index++] = 0x7;
}
}
}
if (post_padding[m] == 19) {
index = (post_padding[m] * 360) + 192 - last;
} else {
index = (post_padding[m] * 360) + 360 - last;
}
for (int w = 0; w < last; w++) {
l1_map[index++] = 0x7;
}
index = 0;
l1post = l1_temp;
for (int n = 0; n < KBCH_1_2; n++) {
if (l1_map[n] != 0x7) {
l1post[n] = l1_interleave[index++];
} else {
l1post[n] = 0;
}
}
/* BCH */
offset_bits = 0;
memset(shift, 0, sizeof(unsigned int) * 6);
for (int j = 0; j < KBCH_1_2; j++) {
value = l1post[offset_bits++];
b = (value ^ ((shift[5] & 0x01000000) ? 1 : 0));
reg_6_shift(shift);
if (b) {
shift[0] ^= m_poly_s_12[0];
shift[1] ^= m_poly_s_12[1];
shift[2] ^= m_poly_s_12[2];
shift[3] ^= m_poly_s_12[3];
shift[4] ^= m_poly_s_12[4];
shift[5] ^= m_poly_s_12[5];
}
}
for (int n = 0; n < NBCH_PARITY; n++) {
l1post[offset_bits++] = (shift[5] & 0x01000000) ? 1 : 0;
reg_6_shift(shift);
}
/* LDPC */
d = l1_temp;
p = &l1_temp[NBCH_1_2];
memset(p, 0, sizeof(unsigned char) * plen);
for (int j = 0; j < l1post_ldpc_encode.table_length; j++) {
p[l1post_ldpc_encode.p[j]] ^= d[l1post_ldpc_encode.d[j]];
}
for (int j = 1; j < plen; j++) {
p[j] ^= p[j - 1];
}
/* Puncturing */
switch (l1_constellation) {
case L1_MOD_BPSK:
post_puncture = post_puncture_bqpsk;
break;
case L1_MOD_QPSK:
post_puncture = post_puncture_bqpsk;
break;
case L1_MOD_16QAM:
post_puncture = post_puncture_16qam;
break;
case L1_MOD_64QAM:
post_puncture = post_puncture_64qam;
break;
default:
post_puncture = post_puncture_bqpsk;
break;
}
for (int c = 0; c < (N_punc / 360); c++) {
g = post_puncture[c];
for (int c2 = 0; c2 < 360; c2++) {
o = (c2 * 25) + g + NBCH_1_2;
l1_temp[o] = 0x55;
}
}
g = post_puncture[(N_punc / 360)];
for (int c2 = 0; c2 < (N_punc - ((N_punc / 360) * 360)); c2++) {
o = (c2 * 25) + g + NBCH_1_2;
l1_temp[o] = 0x55;
}
/* remove padding and punctured bits */
index = 0;
for (int w = 0; w < KBCH_1_2; w++) {
if (l1_map[w] != 0x7) {
l1_interleave[index++] = l1_temp[w];
}
}
for (int w = 0; w < NBCH_PARITY; w++) {
l1_interleave[index++] = l1_temp[w + KBCH_1_2];
}
for (int w = 0; w < FRAME_SIZE_SHORT - NBCH_1_2; w++) {
if (l1_temp[w + NBCH_1_2] != 0x55) {
l1_interleave[index++] = l1_temp[w + NBCH_1_2];
}
}
/* Bit interleave for 16QAM and 64QAM */
if (l1_constellation == L1_MOD_16QAM || l1_constellation == L1_MOD_64QAM) {
if (l1_constellation == L1_MOD_16QAM) {
numCols = 8;
rows = N_post / 8;
} else {
numCols = 12;
rows = N_post / 12;
}
for (int j = 0; j < numCols; j++) {
cols[j] = &l1_interleave[rows * j];
}
index = 0;
for (int k = 0; k < rows; k++) {
for (int w = 0; w < numCols; w++) {
*l1post++ = *(cols[w] + index);
}
index++;
}
}
switch (l1_constellation) {
case L1_MOD_BPSK:
index = 0;
produced = 0;
for (int d = 0; d < N_post; d++) {
out[produced++] = m_bpsk[l1_interleave[index++]];
}
break;
case L1_MOD_QPSK:
mod = 2;
index = 0;
produced = 0;
for (int d = 0; d < N_post / mod; d++) {
pack = 0;
for (int e = 0; e < mod; e++) {
pack |= l1_interleave[index++];
pack <<= 1;
}
pack >>= 1;
out[produced++] = m_qpsk[pack];
}
break;
case L1_MOD_16QAM:
mod = 4;
index = 0;
produced = 0;
for (int d = 0; d < N_post / (mod * 2); d++) {
pack = 0;
for (int e = 0; e < (mod * 2); e++) {
offset = mux16[e];
pack |= l1_temp[index + offset];
pack <<= 1;
}
pack >>= 1;
out[produced++] = m_16qam[pack >> 4];
out[produced++] = m_16qam[pack & 0xf];
index += (mod * 2);
}
break;
case L1_MOD_64QAM:
mod = 6;
index = 0;
produced = 0;
for (int d = 0; d < N_post / (mod * 2); d++) {
pack = 0;
for (int e = 0; e < (mod * 2); e++) {
offset = mux64[e];
pack |= l1_temp[index + offset];
pack <<= 1;
}
pack >>= 1;
out[produced++] = m_64qam[pack >> 6];
out[produced++] = m_64qam[pack & 0x3f];
index += (mod * 2);
}
break;
}
}
void dvbt2_framemapper_cc_impl::init_dummy_randomizer(void)
{
int sr = 0x4A80;
int num = mapped_items - stream_items - 1840 - (N_post / eta_mod) - (N_FC - C_FC);
std::fill_n(&dummy_randomize[0], num, 0);
for (int i = 0; i < num; i++) {
int b = ((sr) ^ (sr >> 1)) & 1;
dummy_randomize[i] = (b ? -1.0 : 1.0);
sr >>= 1;
if (b) {
sr |= 0x4000;
}
}
}
void dvbt2_framemapper_cc_impl::init_l1_randomizer(void)
{
int sr = 0x4A80;
for (int i = 0; i < KBCH_1_2; i++) {
int b = ((sr) ^ (sr >> 1)) & 1;
l1_randomize[i] = b;
sr >>= 1;
if (b) {
sr |= 0x4000;
}
}
}
int dvbt2_framemapper_cc_impl::general_work(int noutput_items,
gr_vector_int& ninput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
const gr_complex* in = (const gr_complex*)input_items[0];
gr_complex* out = (gr_complex*)output_items[0];
int index = 0;
int read, save, count = 0;
gr_complex* interleave = zigzag_interleave;
for (int i = 0; i < noutput_items; i += mapped_items) {
if (N_P2 == 1) {
for (int j = 0; j < 1840; j++) {
*out++ = l1pre_cache[index++];
}
add_l1post(out, t2_frame_num);
t2_frame_num = (t2_frame_num + 1) % t2_frames;
out += N_post / eta_mod;
for (int j = 0; j < stream_items; j++) {
*out++ = *in++;
}
index = 0;
for (int j = 0; j < mapped_items - stream_items - 1840 - (N_post / eta_mod) -
(N_FC - C_FC);
j++) {
*out++ = dummy_randomize[index++];
}
for (int j = 0; j < N_FC - C_FC; j++) {
*out++ = unmodulated;
}
} else {
for (int j = 0; j < 1840; j++) {
*interleave++ = l1pre_cache[index++];
}
add_l1post(interleave, t2_frame_num);
t2_frame_num = (t2_frame_num + 1) % t2_frames;
interleave += N_post / eta_mod;
for (int j = 0; j < stream_items; j++) {
*interleave++ = *in++;
}
index = 0;
for (int j = 0; j < mapped_items - stream_items - 1840 - (N_post / eta_mod) -
(N_FC - C_FC);
j++) {
*interleave++ = dummy_randomize[index++];
}
for (int j = 0; j < N_FC - C_FC; j++) {
*interleave++ = unmodulated;
}
interleave = zigzag_interleave;
read = 0;
index = 0;
for (int n = 0; n < N_P2; n++) {
save = read;
for (int j = 0; j < 1840 / N_P2; j++) {
out[index++] = interleave[read];
count++;
read += N_P2;
}
read = save + 1;
index += C_P2 - (1840 / N_P2);
}
read = 1840;
index = 1840 / N_P2;
for (int n = 0; n < N_P2; n++) {
save = read;
for (int j = 0; j < (N_post / eta_mod) / N_P2; j++) {
out[index++] = interleave[read];
count++;
read += N_P2;
}
read = save + 1;
index += C_P2 - ((N_post / eta_mod) / N_P2);
}
read = 1840 + (N_post / eta_mod);
index = (1840 / N_P2) + ((N_post / eta_mod) / N_P2);
for (int n = 0; n < N_P2; n++) {
for (int j = 0; j < C_P2 - (1840 / N_P2) - ((N_post / eta_mod) / N_P2);
j++) {
out[index++] = interleave[read++];
count++;
}
index += C_P2 - (C_P2 - (1840 / N_P2) - ((N_post / eta_mod) / N_P2));
}
index -= C_P2 - (C_P2 - (1840 / N_P2) - ((N_post / eta_mod) / N_P2));
for (int j = 0; j < mapped_items - count; j++) {
out[index++] = interleave[read++];
}
out += mapped_items;
}
}
// Tell runtime system how many input items we consumed on
// each input stream.
consume_each(stream_items);
// Tell runtime system how many output items we produced.
return noutput_items;
}
const int dvbt2_framemapper_cc_impl::ldpc_tab_1_4S[9][13] = {
{ 12, 6295, 9626, 304, 7695, 4839, 4936, 1660, 144, 11203, 5567, 6347, 12557 },
{ 12, 10691, 4988, 3859, 3734, 3071, 3494, 7687, 10313, 5964, 8069, 8296, 11090 },
{ 12, 10774, 3613, 5208, 11177, 7676, 3549, 8746, 6583, 7239, 12265, 2674, 4292 },
{ 12, 11869, 3708, 5981, 8718, 4908, 10650, 6805, 3334, 2627, 10461, 9285, 11120 },
{ 3, 7844, 3079, 10773, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 3, 3385, 10854, 5747, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 3, 1360, 12010, 12202, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 3, 6189, 4241, 2343, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 3, 9840, 12726, 4977, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
const int dvbt2_framemapper_cc_impl::ldpc_tab_1_2S[20][9] = {
{ 8, 20, 712, 2386, 6354, 4061, 1062, 5045, 5158 },
{ 8, 21, 2543, 5748, 4822, 2348, 3089, 6328, 5876 },
{ 8, 22, 926, 5701, 269, 3693, 2438, 3190, 3507 },
{ 8, 23, 2802, 4520, 3577, 5324, 1091, 4667, 4449 },
{ 8, 24, 5140, 2003, 1263, 4742, 6497, 1185, 6202 },
{ 3, 0, 4046, 6934, 0, 0, 0, 0, 0 },
{ 3, 1, 2855, 66, 0, 0, 0, 0, 0 },
{ 3, 2, 6694, 212, 0, 0, 0, 0, 0 },
{ 3, 3, 3439, 1158, 0, 0, 0, 0, 0 },
{ 3, 4, 3850, 4422, 0, 0, 0, 0, 0 },
{ 3, 5, 5924, 290, 0, 0, 0, 0, 0 },
{ 3, 6, 1467, 4049, 0, 0, 0, 0, 0 },
{ 3, 7, 7820, 2242, 0, 0, 0, 0, 0 },
{ 3, 8, 4606, 3080, 0, 0, 0, 0, 0 },
{ 3, 9, 4633, 7877, 0, 0, 0, 0, 0 },
{ 3, 10, 3884, 6868, 0, 0, 0, 0, 0 },
{ 3, 11, 8935, 4996, 0, 0, 0, 0, 0 },
{ 3, 12, 3028, 764, 0, 0, 0, 0, 0 },
{ 3, 13, 5988, 1057, 0, 0, 0, 0, 0 },
{ 3, 14, 7411, 3450, 0, 0, 0, 0, 0 }
};
const int dvbt2_framemapper_cc_impl::pre_puncture[36] = {
27, 13, 29, 32, 5, 0, 11, 21, 33, 20, 25, 28, 18, 35, 8, 3, 9, 31,
22, 24, 7, 14, 17, 4, 2, 26, 16, 34, 19, 10, 12, 23, 1, 6, 30, 15
};
const int dvbt2_framemapper_cc_impl::post_padding_bqpsk[20] = {
18, 17, 16, 15, 14, 13, 12, 11, 4, 10, 9, 8, 3, 2, 7, 6, 5, 1, 19, 0
};
const int dvbt2_framemapper_cc_impl::post_padding_16qam[20] = {
18, 17, 16, 15, 14, 13, 12, 11, 4, 10, 9, 8, 7, 3, 2, 1, 6, 5, 19, 0
};
const int dvbt2_framemapper_cc_impl::post_padding_64qam[20] = {
18, 17, 16, 4, 15, 14, 13, 12, 3, 11, 10, 9, 2, 8, 7, 1, 6, 5, 19, 0
};
const int dvbt2_framemapper_cc_impl::post_puncture_bqpsk[25] = {
6, 4, 18, 9, 13, 8, 15, 20, 5, 17, 2, 24, 10,
22, 12, 3, 16, 23, 1, 14, 0, 21, 19, 7, 11
};
const int dvbt2_framemapper_cc_impl::post_puncture_16qam[25] = {
6, 4, 13, 9, 18, 8, 15, 20, 5, 17, 2, 22, 24,
7, 12, 1, 16, 23, 14, 0, 21, 10, 19, 11, 3
};
const int dvbt2_framemapper_cc_impl::post_puncture_64qam[25] = {
6, 15, 13, 10, 3, 17, 21, 8, 5, 19, 2, 23, 16,
24, 7, 18, 1, 12, 20, 0, 4, 14, 9, 11, 22
};
const int dvbt2_framemapper_cc_impl::mux16[8] = { 7, 1, 3, 5, 2, 4, 6, 0 };
const int dvbt2_framemapper_cc_impl::mux64[12] = { 11, 8, 5, 2, 10, 7, 4, 1, 9, 6, 3, 0 };
} /* namespace dtv */
} /* namespace gr */