[PATCH 2/2] Add convolutional code for TCH/AFS

From: Max &lt;msuraev(a)sysmocom.de&gt; Replace implementation in tests with added code. --- include/osmocom/gsm/gsm0503.h | 32 +++++ src/gsm/Makefile.am | 4 + src/gsm/conv_tch_afs_10_2_gen.c | 284 ++++++++++++++++++++++++++++++++++++++++ src/gsm/conv_tch_afs_12_2_gen.c | 150 +++++++++++++++++++++ src/gsm/conv_tch_afs_4_75_gen.c | 275 ++++++++++++++++++++++++++++++++++++++ src/gsm/conv_tch_afs_5_15_gen.c | 209 +++++++++++++++++++++++++++++ src/gsm/conv_tch_afs_5_9_gen.c | 260 ++++++++++++++++++++++++++++++++++++ src/gsm/conv_tch_afs_6_7_gen.c | 219 +++++++++++++++++++++++++++++++ src/gsm/conv_tch_afs_7_4_gen.c | 116 ++++++++++++++++ src/gsm/conv_tch_afs_7_95_gen.c | 251 +++++++++++++++++++++++++++++++++++ tests/conv/conv_test.c | 78 +---------- 11 files changed, 1801 insertions(+), 77 deletions(-) create mode 100644 src/gsm/conv_tch_afs_10_2_gen.c create mode 100644 src/gsm/conv_tch_afs_12_2_gen.c create mode 100644 src/gsm/conv_tch_afs_4_75_gen.c create mode 100644 src/gsm/conv_tch_afs_5_15_gen.c create mode 100644 src/gsm/conv_tch_afs_5_9_gen.c create mode 100644 src/gsm/conv_tch_afs_6_7_gen.c create mode 100644 src/gsm/conv_tch_afs_7_4_gen.c create mode 100644 src/gsm/conv_tch_afs_7_95_gen.c diff --git a/include/osmocom/gsm/gsm0503.h b/include/osmocom/gsm/gsm0503.h index 764e2d1..4722e7e 100644 --- a/include/osmocom/gsm/gsm0503.h +++ b/include/osmocom/gsm/gsm0503.h @@ -40,3 +40,35 @@ extern const struct osmo_conv_code osmo_conv_gsm0503_xcch; */ extern const struct osmo_conv_code osmo_conv_gsm0503_cs2; extern const struct osmo_conv_code osmo_conv_gsm0503_cs3; + +/*! \brief structure describing convolutional code TCH/AFS 12.2 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_12_2; + +/*! \brief structure describing convolutional code TCH/AFS 10.2 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_10_2; + +/*! \brief structure describing convolutional code TCH/AFS 7.95 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_7_95; + +/*! \brief structure describing convolutional code TCH/AFS 7.4 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_7_4; + +/*! \brief structure describing convolutional code TCH/AFS 6.7 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_6_7; + +/*! \brief structure describing convolutional code TCH/AFS 5.9 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_5_9; + +/*! \brief structure describing convolutional code TCH/AFS 5.15 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_5_15; + +/*! \brief structure describing convolutional code TCH/AFS 4.75 + */ +extern const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_4_75; diff --git a/src/gsm/Makefile.am b/src/gsm/Makefile.am index 53d16b3..101b532 100644 --- a/src/gsm/Makefile.am +++ b/src/gsm/Makefile.am @@ -19,6 +19,10 @@ libgsmint_la_SOURCES = a5.c rxlev_stat.c tlv_parser.c comp128.c comp128v23.c \ gsm0411_utils.c gsm0411_smc.c gsm0411_smr.c \ lapd_core.c lapdm.c kasumi.c conv_xcch_gen.c \ conv_cs2_gen.c conv_cs3_gen.c \ + conv_tch_afs_12_2_gen.c conv_tch_afs_10_2_gen.c \ + conv_tch_afs_7_95_gen.c conv_tch_afs_7_4_gen.c \ + conv_tch_afs_6_7_gen.c conv_tch_afs_5_9_gen.c \ + conv_tch_afs_5_15_gen.c conv_tch_afs_4_75_gen.c \ auth_core.c auth_comp128v1.c auth_comp128v23.c \ auth_milenage.c milenage/aes-encblock.c \ milenage/aes-internal.c milenage/aes-internal-enc.c \ diff --git a/src/gsm/conv_tch_afs_10_2_gen.c b/src/gsm/conv_tch_afs_10_2_gen.c new file mode 100644 index 0000000..d67b455 --- /dev/null +++ b/src/gsm/conv_tch_afs_10_2_gen.c @@ -0,0 +1,284 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_10_2_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_10_2_output[][2] = { + { 0, 7 }, + { 2, 5 }, + { 4, 3 }, + { 6, 1 }, + { 2, 5 }, + { 0, 7 }, + { 6, 1 }, + { 4, 3 }, + { 0, 7 }, + { 2, 5 }, + { 4, 3 }, + { 6, 1 }, + { 2, 5 }, + { 0, 7 }, + { 6, 1 }, + { 4, 3 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_10_2_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_10_2_term_output[] = { + 0, 5, 3, 6, 5, 0, 6, 3, 7, 2, 4, 1, 2, 7, 1, 4, +}; + +static const int osmo_conv_gsm0503_tch_afs_10_2_puncture[] = { + 1, + 4, + 7, + 10, + 16, + 19, + 22, + 28, + 31, + 34, + 40, + 43, + 46, + 52, + 55, + 58, + 64, + 67, + 70, + 76, + 79, + 82, + 88, + 91, + 94, + 100, + 103, + 106, + 112, + 115, + 118, + 124, + 127, + 130, + 136, + 139, + 142, + 148, + 151, + 154, + 160, + 163, + 166, + 172, + 175, + 178, + 184, + 187, + 190, + 196, + 199, + 202, + 208, + 211, + 214, + 220, + 223, + 226, + 232, + 235, + 238, + 244, + 247, + 250, + 256, + 259, + 262, + 268, + 271, + 274, + 280, + 283, + 286, + 292, + 295, + 298, + 304, + 307, + 310, + 316, + 319, + 322, + 325, + 328, + 331, + 334, + 337, + 340, + 343, + 346, + 349, + 352, + 355, + 358, + 361, + 364, + 367, + 370, + 373, + 376, + 379, + 382, + 385, + 388, + 391, + 394, + 397, + 400, + 403, + 406, + 409, + 412, + 415, + 418, + 421, + 424, + 427, + 430, + 433, + 436, + 439, + 442, + 445, + 448, + 451, + 454, + 457, + 460, + 463, + 466, + 469, + 472, + 475, + 478, + 481, + 484, + 487, + 490, + 493, + 496, + 499, + 502, + 505, + 508, + 511, + 514, + 517, + 520, + 523, + 526, + 529, + 532, + 535, + 538, + 541, + 544, + 547, + 550, + 553, + 556, + 559, + 562, + 565, + 568, + 571, + 574, + 577, + 580, + 583, + 586, + 589, + 592, + 595, + 598, + 601, + 604, + 607, + 609, + 610, + 613, + 616, + 619, + 621, + 622, + 625, + 627, + 628, + 631, + 633, + 634, + 636, + 637, + 639, + 640, + -1, +}; + +/* TCH/AFS 10.2 kbits convolutional code: + G1/G3 = 1 + D + D3 + D4 / 1 + D + D2 + D3 + D4 + G2/G3 = 1 + D2 + D4 / 1 + D + D2 + D3 + D4 + G3/G3 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_10_2 = { + .N = 3, + .K = 5, + .len = 210, + .next_output = osmo_conv_gsm0503_tch_afs_10_2_output, + .next_state = osmo_conv_gsm0503_tch_afs_10_2_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_10_2_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_10_2_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_10_2_puncture, +}; diff --git a/src/gsm/conv_tch_afs_12_2_gen.c b/src/gsm/conv_tch_afs_12_2_gen.c new file mode 100644 index 0000000..b09ea93 --- /dev/null +++ b/src/gsm/conv_tch_afs_12_2_gen.c @@ -0,0 +1,150 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_12_2_state[][2] = { + { 0, 1 }, + { 2, 3 }, + { 4, 5 }, + { 6, 7 }, + { 9, 8 }, + { 11, 10 }, + { 13, 12 }, + { 15, 14 }, + { 1, 0 }, + { 3, 2 }, + { 5, 4 }, + { 7, 6 }, + { 8, 9 }, + { 10, 11 }, + { 12, 13 }, + { 14, 15 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_12_2_output[][2] = { + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, + { 0, 3 }, + { 1, 2 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_12_2_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_12_2_term_output[] = { + 0, 1, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 0, 1, 0, 1, +}; + +static const int osmo_conv_gsm0503_tch_afs_12_2_puncture[] = { + 321, + 325, + 329, + 333, + 337, + 341, + 345, + 349, + 353, + 357, + 361, + 363, + 365, + 369, + 373, + 377, + 379, + 381, + 385, + 389, + 393, + 395, + 397, + 401, + 405, + 409, + 411, + 413, + 417, + 421, + 425, + 427, + 429, + 433, + 437, + 441, + 443, + 445, + 449, + 453, + 457, + 459, + 461, + 465, + 469, + 473, + 475, + 477, + 481, + 485, + 489, + 491, + 493, + 495, + 497, + 499, + 501, + 503, + 505, + 507, + -1, +}; + +/* TCH/AFS 12.2 convolutional code: + 250 bits block, rate 1/2, punctured + G0/G0 = 1 + G1/G0 = 1 + D + D3 + D4 / 1 + D3 + D4 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_12_2 = { + .N = 2, + .K = 5, + .len = 250, + .next_output = osmo_conv_gsm0503_tch_afs_12_2_output, + .next_state = osmo_conv_gsm0503_tch_afs_12_2_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_12_2_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_12_2_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_12_2_puncture, +}; diff --git a/src/gsm/conv_tch_afs_4_75_gen.c b/src/gsm/conv_tch_afs_4_75_gen.c new file mode 100644 index 0000000..bbd35dd --- /dev/null +++ b/src/gsm/conv_tch_afs_4_75_gen.c @@ -0,0 +1,275 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_4_75_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 17, 16 }, + { 18, 19 }, + { 20, 21 }, + { 23, 22 }, + { 24, 25 }, + { 27, 26 }, + { 29, 28 }, + { 30, 31 }, + { 32, 33 }, + { 35, 34 }, + { 37, 36 }, + { 38, 39 }, + { 41, 40 }, + { 42, 43 }, + { 44, 45 }, + { 47, 46 }, + { 49, 48 }, + { 50, 51 }, + { 52, 53 }, + { 55, 54 }, + { 56, 57 }, + { 59, 58 }, + { 61, 60 }, + { 62, 63 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, + { 16, 17 }, + { 19, 18 }, + { 21, 20 }, + { 22, 23 }, + { 25, 24 }, + { 26, 27 }, + { 28, 29 }, + { 31, 30 }, + { 33, 32 }, + { 34, 35 }, + { 36, 37 }, + { 39, 38 }, + { 40, 41 }, + { 43, 42 }, + { 45, 44 }, + { 46, 47 }, + { 48, 49 }, + { 51, 50 }, + { 53, 52 }, + { 54, 55 }, + { 57, 56 }, + { 58, 59 }, + { 60, 61 }, + { 63, 62 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_4_75_output[][2] = { + { 0, 31 }, + { 24, 7 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 0, 31 }, + { 24, 7 }, + { 24, 7 }, + { 0, 31 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 24, 7 }, + { 0, 31 }, + { 24, 7 }, + { 0, 31 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 24, 7 }, + { 0, 31 }, + { 0, 31 }, + { 24, 7 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 0, 31 }, + { 24, 7 }, + { 0, 31 }, + { 24, 7 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 0, 31 }, + { 24, 7 }, + { 24, 7 }, + { 0, 31 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 24, 7 }, + { 0, 31 }, + { 24, 7 }, + { 0, 31 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 24, 7 }, + { 0, 31 }, + { 0, 31 }, + { 24, 7 }, + { 4, 27 }, + { 28, 3 }, + { 4, 27 }, + { 28, 3 }, + { 0, 31 }, + { 24, 7 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_4_75_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_4_75_term_output[] = { + 0, 7, 27, 28, 27, 28, 0, 7, 7, 0, 28, 27, 28, 27, 7, 0, 24, 31, 3, 4, 3, 4, 24, 31, 31, 24, 4, 3, 4, 3, 31, 24, 31, 24, 4, 3, 4, 3, 31, 24, 24, 31, 3, 4, 3, 4, 24, 31, 7, 0, 28, 27, 28, 27, 7, 0, 0, 7, 27, 28, 27, 28, 0, 7, +}; + +static const int osmo_conv_gsm0503_tch_afs_4_75_puncture[] = { + 0, + 1, + 2, + 4, + 5, + 7, + 9, + 15, + 25, + 35, + 45, + 55, + 65, + 75, + 85, + 95, + 105, + 115, + 125, + 135, + 145, + 155, + 165, + 175, + 185, + 195, + 205, + 215, + 225, + 235, + 245, + 255, + 265, + 275, + 285, + 295, + 305, + 315, + 325, + 335, + 345, + 355, + 365, + 375, + 385, + 395, + 400, + 405, + 410, + 415, + 420, + 425, + 430, + 435, + 440, + 445, + 450, + 455, + 459, + 460, + 465, + 470, + 475, + 479, + 480, + 485, + 490, + 495, + 499, + 500, + 505, + 509, + 510, + 515, + 517, + 519, + 520, + 522, + 524, + 525, + 526, + 527, + 529, + 530, + 531, + 532, + 534, + -1, +}; + +/* TCH/AFS 4.75 kbits convolutional code: + G4/G6 = 1 + D2 + D3 + D5 + D6 / 1 + D + D2 + D3 + D4 + D6 + G4/G6 = 1 + D2 + D3 + D5 + D6 / 1 + D + D2 + D3 + D4 + D6 + G5/G6 = 1 + D + D4 + D6 / 1 + D + D2 + D3 + D4 + D6 + G6/G6 = 1 + G6/G6 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_4_75 = { + .N = 5, + .K = 7, + .len = 101, + .next_output = osmo_conv_gsm0503_tch_afs_4_75_output, + .next_state = osmo_conv_gsm0503_tch_afs_4_75_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_4_75_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_4_75_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_4_75_puncture, +}; diff --git a/src/gsm/conv_tch_afs_5_15_gen.c b/src/gsm/conv_tch_afs_5_15_gen.c new file mode 100644 index 0000000..d00dd5c --- /dev/null +++ b/src/gsm/conv_tch_afs_5_15_gen.c @@ -0,0 +1,209 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_15_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_15_output[][2] = { + { 0, 31 }, + { 4, 27 }, + { 24, 7 }, + { 28, 3 }, + { 4, 27 }, + { 0, 31 }, + { 28, 3 }, + { 24, 7 }, + { 0, 31 }, + { 4, 27 }, + { 24, 7 }, + { 28, 3 }, + { 4, 27 }, + { 0, 31 }, + { 28, 3 }, + { 24, 7 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_15_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_15_term_output[] = { + 0, 27, 7, 28, 27, 0, 28, 7, 31, 4, 24, 3, 4, 31, 3, 24, +}; + +static const int osmo_conv_gsm0503_tch_afs_5_15_puncture[] = { + 0, + 4, + 5, + 9, + 10, + 14, + 15, + 20, + 25, + 30, + 35, + 40, + 50, + 60, + 70, + 80, + 90, + 100, + 110, + 120, + 130, + 140, + 150, + 160, + 170, + 180, + 190, + 200, + 210, + 220, + 230, + 240, + 250, + 260, + 270, + 280, + 290, + 300, + 310, + 315, + 320, + 325, + 330, + 334, + 335, + 340, + 344, + 345, + 350, + 354, + 355, + 360, + 364, + 365, + 370, + 374, + 375, + 380, + 384, + 385, + 390, + 394, + 395, + 400, + 404, + 405, + 410, + 414, + 415, + 420, + 424, + 425, + 430, + 434, + 435, + 440, + 444, + 445, + 450, + 454, + 455, + 460, + 464, + 465, + 470, + 474, + 475, + 480, + 484, + 485, + 490, + 494, + 495, + 500, + 504, + 505, + 510, + 514, + 515, + 520, + 524, + 525, + 529, + 530, + 534, + 535, + 539, + 540, + 544, + 545, + 549, + 550, + 554, + 555, + 559, + 560, + 564, + -1, +}; + +/* TCH/AFS 5.15 kbits convolutional code: + G1/G3 = 1 + D + D3 + D4 / 1 + D + D2 + D3 + D4 + G1/G3 = 1 + D + D3 + D4 / 1 + D + D2 + D3 + D4 + G2/G3 = 1 + D2 + D4 / 1 + D + D2 + D3 + D4 + G3/G3 = 1 + G3/G3 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_5_15 = { + .N = 5, + .K = 5, + .len = 109, + .next_output = osmo_conv_gsm0503_tch_afs_5_15_output, + .next_state = osmo_conv_gsm0503_tch_afs_5_15_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_5_15_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_5_15_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_5_15_puncture, +}; diff --git a/src/gsm/conv_tch_afs_5_9_gen.c b/src/gsm/conv_tch_afs_5_9_gen.c new file mode 100644 index 0000000..d182adb --- /dev/null +++ b/src/gsm/conv_tch_afs_5_9_gen.c @@ -0,0 +1,260 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_9_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 17, 16 }, + { 18, 19 }, + { 20, 21 }, + { 23, 22 }, + { 24, 25 }, + { 27, 26 }, + { 29, 28 }, + { 30, 31 }, + { 32, 33 }, + { 35, 34 }, + { 37, 36 }, + { 38, 39 }, + { 41, 40 }, + { 42, 43 }, + { 44, 45 }, + { 47, 46 }, + { 49, 48 }, + { 50, 51 }, + { 52, 53 }, + { 55, 54 }, + { 56, 57 }, + { 59, 58 }, + { 61, 60 }, + { 62, 63 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, + { 16, 17 }, + { 19, 18 }, + { 21, 20 }, + { 22, 23 }, + { 25, 24 }, + { 26, 27 }, + { 28, 29 }, + { 31, 30 }, + { 33, 32 }, + { 34, 35 }, + { 36, 37 }, + { 39, 38 }, + { 40, 41 }, + { 43, 42 }, + { 45, 44 }, + { 46, 47 }, + { 48, 49 }, + { 51, 50 }, + { 53, 52 }, + { 54, 55 }, + { 57, 56 }, + { 58, 59 }, + { 60, 61 }, + { 63, 62 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_9_output[][2] = { + { 0, 15 }, + { 8, 7 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 0, 15 }, + { 8, 7 }, + { 8, 7 }, + { 0, 15 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 8, 7 }, + { 0, 15 }, + { 8, 7 }, + { 0, 15 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 8, 7 }, + { 0, 15 }, + { 0, 15 }, + { 8, 7 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 0, 15 }, + { 8, 7 }, + { 0, 15 }, + { 8, 7 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 0, 15 }, + { 8, 7 }, + { 8, 7 }, + { 0, 15 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 8, 7 }, + { 0, 15 }, + { 8, 7 }, + { 0, 15 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 8, 7 }, + { 0, 15 }, + { 0, 15 }, + { 8, 7 }, + { 4, 11 }, + { 12, 3 }, + { 4, 11 }, + { 12, 3 }, + { 0, 15 }, + { 8, 7 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_9_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_5_9_term_output[] = { + 0, 7, 11, 12, 11, 12, 0, 7, 7, 0, 12, 11, 12, 11, 7, 0, 8, 15, 3, 4, 3, 4, 8, 15, 15, 8, 4, 3, 4, 3, 15, 8, 15, 8, 4, 3, 4, 3, 15, 8, 8, 15, 3, 4, 3, 4, 8, 15, 7, 0, 12, 11, 12, 11, 7, 0, 0, 7, 11, 12, 11, 12, 0, 7, +}; + +static const int osmo_conv_gsm0503_tch_afs_5_9_puncture[] = { + 0, + 1, + 3, + 5, + 7, + 11, + 15, + 31, + 47, + 63, + 79, + 95, + 111, + 127, + 143, + 159, + 175, + 191, + 207, + 223, + 239, + 255, + 271, + 287, + 303, + 319, + 327, + 331, + 335, + 343, + 347, + 351, + 359, + 363, + 367, + 375, + 379, + 383, + 391, + 395, + 399, + 407, + 411, + 415, + 423, + 427, + 431, + 439, + 443, + 447, + 455, + 459, + 463, + 467, + 471, + 475, + 479, + 483, + 487, + 491, + 495, + 499, + 503, + 507, + 509, + 511, + 512, + 513, + 515, + 516, + 517, + 519, + -1, +}; + +/* TCH/AFS 5.9 kbits convolutional code: + 124 bits + G4/G6 = 1 + D2 + D3 + D5 + D6 / 1 + D + D2 + D3 + D4 + D6 + G5/G6 = 1 + D + D4 + D6 / 1 + D + D2 + D3 + D4 + D6 + G6/G6 = 1 + G6/G6 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_5_9 = { + .N = 4, + .K = 7, + .len = 124, + .next_output = osmo_conv_gsm0503_tch_afs_5_9_output, + .next_state = osmo_conv_gsm0503_tch_afs_5_9_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_5_9_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_5_9_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_5_9_puncture, +}; diff --git a/src/gsm/conv_tch_afs_6_7_gen.c b/src/gsm/conv_tch_afs_6_7_gen.c new file mode 100644 index 0000000..8baedaa --- /dev/null +++ b/src/gsm/conv_tch_afs_6_7_gen.c @@ -0,0 +1,219 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_6_7_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_6_7_output[][2] = { + { 0, 15 }, + { 4, 11 }, + { 8, 7 }, + { 12, 3 }, + { 4, 11 }, + { 0, 15 }, + { 12, 3 }, + { 8, 7 }, + { 0, 15 }, + { 4, 11 }, + { 8, 7 }, + { 12, 3 }, + { 4, 11 }, + { 0, 15 }, + { 12, 3 }, + { 8, 7 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_6_7_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_6_7_term_output[] = { + 0, 11, 7, 12, 11, 0, 12, 7, 15, 4, 8, 3, 4, 15, 3, 8, +}; + +static const int osmo_conv_gsm0503_tch_afs_6_7_puncture[] = { + 1, + 3, + 7, + 11, + 15, + 27, + 39, + 55, + 67, + 79, + 95, + 107, + 119, + 135, + 147, + 159, + 175, + 187, + 199, + 215, + 227, + 239, + 255, + 267, + 279, + 287, + 291, + 295, + 299, + 303, + 307, + 311, + 315, + 319, + 323, + 327, + 331, + 335, + 339, + 343, + 347, + 351, + 355, + 359, + 363, + 367, + 369, + 371, + 375, + 377, + 379, + 383, + 385, + 387, + 391, + 393, + 395, + 399, + 401, + 403, + 407, + 409, + 411, + 415, + 417, + 419, + 423, + 425, + 427, + 431, + 433, + 435, + 439, + 441, + 443, + 447, + 449, + 451, + 455, + 457, + 459, + 463, + 465, + 467, + 471, + 473, + 475, + 479, + 481, + 483, + 487, + 489, + 491, + 495, + 497, + 499, + 503, + 505, + 507, + 511, + 513, + 515, + 519, + 521, + 523, + 527, + 529, + 531, + 535, + 537, + 539, + 543, + 545, + 547, + 549, + 551, + 553, + 555, + 557, + 559, + 561, + 563, + 565, + 567, + 569, + 571, + 573, + 575, + -1, +}; + +/* TCH/AFS 6.7 kbits convolutional code: + G1/G3 = 1 + D + D3 + D4 / 1 + D + D2 + D3 + D4 + G2/G3 = 1 + D2 + D4 / 1 + D + D2 + D3 + D4 + G3/G3 = 1 + G3/G3 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_6_7 = { + .N = 4, + .K = 5, + .len = 140, + .next_output = osmo_conv_gsm0503_tch_afs_6_7_output, + .next_state = osmo_conv_gsm0503_tch_afs_6_7_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_6_7_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_6_7_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_6_7_puncture, +}; diff --git a/src/gsm/conv_tch_afs_7_4_gen.c b/src/gsm/conv_tch_afs_7_4_gen.c new file mode 100644 index 0000000..924776b --- /dev/null +++ b/src/gsm/conv_tch_afs_7_4_gen.c @@ -0,0 +1,116 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_4_state[][2] = { + { 0, 1 }, + { 3, 2 }, + { 5, 4 }, + { 6, 7 }, + { 9, 8 }, + { 10, 11 }, + { 12, 13 }, + { 15, 14 }, + { 1, 0 }, + { 2, 3 }, + { 4, 5 }, + { 7, 6 }, + { 8, 9 }, + { 11, 10 }, + { 13, 12 }, + { 14, 15 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_4_output[][2] = { + { 0, 7 }, + { 2, 5 }, + { 4, 3 }, + { 6, 1 }, + { 2, 5 }, + { 0, 7 }, + { 6, 1 }, + { 4, 3 }, + { 0, 7 }, + { 2, 5 }, + { 4, 3 }, + { 6, 1 }, + { 2, 5 }, + { 0, 7 }, + { 6, 1 }, + { 4, 3 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_4_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_4_term_output[] = { + 0, 5, 3, 6, 5, 0, 6, 3, 7, 2, 4, 1, 2, 7, 1, 4, +}; + +static const int osmo_conv_gsm0503_tch_afs_7_4_puncture[] = { + 0, + 355, + 361, + 367, + 373, + 379, + 385, + 391, + 397, + 403, + 409, + 415, + 421, + 427, + 433, + 439, + 445, + 451, + 457, + 460, + 463, + 466, + 468, + 469, + 471, + 472, + -1, +}; + +/* TCH/AFS 7.4 kbits convolutional code: + G1/G3 = 1 + D + D3 + D4 / 1 + D + D2 + D3 + D4 + G2/G3 = 1 + D2 + D4 / 1 + D + D2 + D3 + D4 + G3/G3 = 1 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_7_4 = { + .N = 3, + .K = 5, + .len = 154, + .next_output = osmo_conv_gsm0503_tch_afs_7_4_output, + .next_state = osmo_conv_gsm0503_tch_afs_7_4_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_7_4_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_7_4_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_7_4_puncture, +}; diff --git a/src/gsm/conv_tch_afs_7_95_gen.c b/src/gsm/conv_tch_afs_7_95_gen.c new file mode 100644 index 0000000..737a7aa --- /dev/null +++ b/src/gsm/conv_tch_afs_7_95_gen.c @@ -0,0 +1,251 @@ + +/* + * Copyright (C) 2011-2016 Sylvain Munaut &lt;tnt(a)246tNt.com&gt; + * Copyright (C) 2016 sysmocom s.f.m.c. GmbH + * + * All Rights Reserved + * + * 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 3 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., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdint.h> +#include <osmocom/core/conv.h> + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_95_state[][2] = { + { 0, 1 }, + { 2, 3 }, + { 5, 4 }, + { 7, 6 }, + { 9, 8 }, + { 11, 10 }, + { 12, 13 }, + { 14, 15 }, + { 16, 17 }, + { 18, 19 }, + { 21, 20 }, + { 23, 22 }, + { 25, 24 }, + { 27, 26 }, + { 28, 29 }, + { 30, 31 }, + { 33, 32 }, + { 35, 34 }, + { 36, 37 }, + { 38, 39 }, + { 40, 41 }, + { 42, 43 }, + { 45, 44 }, + { 47, 46 }, + { 49, 48 }, + { 51, 50 }, + { 52, 53 }, + { 54, 55 }, + { 56, 57 }, + { 58, 59 }, + { 61, 60 }, + { 63, 62 }, + { 1, 0 }, + { 3, 2 }, + { 4, 5 }, + { 6, 7 }, + { 8, 9 }, + { 10, 11 }, + { 13, 12 }, + { 15, 14 }, + { 17, 16 }, + { 19, 18 }, + { 20, 21 }, + { 22, 23 }, + { 24, 25 }, + { 26, 27 }, + { 29, 28 }, + { 31, 30 }, + { 32, 33 }, + { 34, 35 }, + { 37, 36 }, + { 39, 38 }, + { 41, 40 }, + { 43, 42 }, + { 44, 45 }, + { 46, 47 }, + { 48, 49 }, + { 50, 51 }, + { 53, 52 }, + { 55, 54 }, + { 57, 56 }, + { 59, 58 }, + { 60, 61 }, + { 62, 63 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_95_output[][2] = { + { 0, 7 }, + { 3, 4 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 0, 7 }, + { 3, 4 }, + { 3, 4 }, + { 0, 7 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 3, 4 }, + { 0, 7 }, + { 3, 4 }, + { 0, 7 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 3, 4 }, + { 0, 7 }, + { 0, 7 }, + { 3, 4 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 0, 7 }, + { 3, 4 }, + { 0, 7 }, + { 3, 4 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 0, 7 }, + { 3, 4 }, + { 3, 4 }, + { 0, 7 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 3, 4 }, + { 0, 7 }, + { 3, 4 }, + { 0, 7 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 3, 4 }, + { 0, 7 }, + { 0, 7 }, + { 3, 4 }, + { 2, 5 }, + { 1, 6 }, + { 2, 5 }, + { 1, 6 }, + { 0, 7 }, + { 3, 4 }, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_95_term_state[] = { + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, +}; + +static const uint8_t osmo_conv_gsm0503_tch_afs_7_95_term_output[] = { + 0, 3, 5, 6, 5, 6, 0, 3, 3, 0, 6, 5, 6, 5, 3, 0, 4, 7, 1, 2, 1, 2, 4, 7, 7, 4, 2, 1, 2, 1, 7, 4, 7, 4, 2, 1, 2, 1, 7, 4, 4, 7, 1, 2, 1, 2, 4, 7, 3, 0, 6, 5, 6, 5, 3, 0, 0, 3, 5, 6, 5, 6, 0, 3, +}; + +static const int osmo_conv_gsm0503_tch_afs_7_95_puncture[] = { + 1, + 2, + 4, + 5, + 8, + 22, + 70, + 118, + 166, + 214, + 262, + 310, + 317, + 319, + 325, + 332, + 334, + 341, + 343, + 349, + 356, + 358, + 365, + 367, + 373, + 380, + 382, + 385, + 389, + 391, + 397, + 404, + 406, + 409, + 413, + 415, + 421, + 428, + 430, + 433, + 437, + 439, + 445, + 452, + 454, + 457, + 461, + 463, + 469, + 476, + 478, + 481, + 485, + 487, + 490, + 493, + 500, + 502, + 503, + 505, + 506, + 508, + 509, + 511, + 512, + -1, +}; + +/* TCH/AFS 7.95 kbits convolutional code: + G4/G4 = 1 + G5/G4 = 1 + D + D4 + D6 / 1 + D2 + D3 + D5 + D6 + G6/G4 = 1 + D + D2 + D3 + D4 + D6 / 1 + D2 + D3 + D5 + D6 + */ +const struct osmo_conv_code osmo_conv_gsm0503_tch_afs_7_95 = { + .N = 3, + .K = 7, + .len = 165, + .next_output = osmo_conv_gsm0503_tch_afs_7_95_output, + .next_state = osmo_conv_gsm0503_tch_afs_7_95_state, + .next_term_output = osmo_conv_gsm0503_tch_afs_7_95_term_output, + .next_term_state = osmo_conv_gsm0503_tch_afs_7_95_term_state, + .puncture = osmo_conv_gsm0503_tch_afs_7_95_puncture, +}; diff --git a/tests/conv/conv_test.c b/tests/conv/conv_test.c index d8779db..980bbc3 100644 --- a/tests/conv/conv_test.c +++ b/tests/conv/conv_test.c @@ -16,82 +16,6 @@ /* Test codes */ /* ------------------------------------------------------------------------ */ -/* GSM TCH/AFS 7.95 -> Recursive code, flushed, with puncturing */ -static const uint8_t conv_gsm_tch_afs_7_95_next_output[][2] = { - { 0, 7 }, { 3, 4 }, { 2, 5 }, { 1, 6 }, - { 2, 5 }, { 1, 6 }, { 0, 7 }, { 3, 4 }, - { 3, 4 }, { 0, 7 }, { 1, 6 }, { 2, 5 }, - { 1, 6 }, { 2, 5 }, { 3, 4 }, { 0, 7 }, - { 3, 4 }, { 0, 7 }, { 1, 6 }, { 2, 5 }, - { 1, 6 }, { 2, 5 }, { 3, 4 }, { 0, 7 }, - { 0, 7 }, { 3, 4 }, { 2, 5 }, { 1, 6 }, - { 2, 5 }, { 1, 6 }, { 0, 7 }, { 3, 4 }, - { 0, 7 }, { 3, 4 }, { 2, 5 }, { 1, 6 }, - { 2, 5 }, { 1, 6 }, { 0, 7 }, { 3, 4 }, - { 3, 4 }, { 0, 7 }, { 1, 6 }, { 2, 5 }, - { 1, 6 }, { 2, 5 }, { 3, 4 }, { 0, 7 }, - { 3, 4 }, { 0, 7 }, { 1, 6 }, { 2, 5 }, - { 1, 6 }, { 2, 5 }, { 3, 4 }, { 0, 7 }, - { 0, 7 }, { 3, 4 }, { 2, 5 }, { 1, 6 }, - { 2, 5 }, { 1, 6 }, { 0, 7 }, { 3, 4 }, -}; - -static const uint8_t conv_gsm_tch_afs_7_95_next_state[][2] = { - { 0, 1 }, { 2, 3 }, { 5, 4 }, { 7, 6 }, - { 9, 8 }, { 11, 10 }, { 12, 13 }, { 14, 15 }, - { 16, 17 }, { 18, 19 }, { 21, 20 }, { 23, 22 }, - { 25, 24 }, { 27, 26 }, { 28, 29 }, { 30, 31 }, - { 33, 32 }, { 35, 34 }, { 36, 37 }, { 38, 39 }, - { 40, 41 }, { 42, 43 }, { 45, 44 }, { 47, 46 }, - { 49, 48 }, { 51, 50 }, { 52, 53 }, { 54, 55 }, - { 56, 57 }, { 58, 59 }, { 61, 60 }, { 63, 62 }, - { 1, 0 }, { 3, 2 }, { 4, 5 }, { 6, 7 }, - { 8, 9 }, { 10, 11 }, { 13, 12 }, { 15, 14 }, - { 17, 16 }, { 19, 18 }, { 20, 21 }, { 22, 23 }, - { 24, 25 }, { 26, 27 }, { 29, 28 }, { 31, 30 }, - { 32, 33 }, { 34, 35 }, { 37, 36 }, { 39, 38 }, - { 41, 40 }, { 43, 42 }, { 44, 45 }, { 46, 47 }, - { 48, 49 }, { 50, 51 }, { 53, 52 }, { 55, 54 }, - { 57, 56 }, { 59, 58 }, { 60, 61 }, { 62, 63 }, -}; - -static const uint8_t conv_gsm_tch_afs_7_95_next_term_output[] = { - 0, 3, 5, 6, 5, 6, 0, 3, 3, 0, 6, 5, 6, 5, 3, 0, - 4, 7, 1, 2, 1, 2, 4, 7, 7, 4, 2, 1, 2, 1, 7, 4, - 7, 4, 2, 1, 2, 1, 7, 4, 4, 7, 1, 2, 1, 2, 4, 7, - 3, 0, 6, 5, 6, 5, 3, 0, 0, 3, 5, 6, 5, 6, 0, 3, -}; - -static const uint8_t conv_gsm_tch_afs_7_95_next_term_state[] = { - 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, - 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, - 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, - 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, -}; - -static int conv_gsm_tch_afs_7_95_puncture[] = { - 1, 2, 4, 5, 8, 22, 70, 118, 166, 214, 262, 310, - 317, 319, 325, 332, 334, 341, 343, 349, 356, 358, 365, 367, - 373, 380, 382, 385, 389, 391, 397, 404, 406, 409, 413, 415, - 421, 428, 430, 433, 437, 439, 445, 452, 454, 457, 461, 463, - 469, 476, 478, 481, 485, 487, 490, 493, 500, 502, 503, 505, - 506, 508, 509, 511, 512, - -1, /* end */ -}; - -static const struct osmo_conv_code conv_gsm_tch_afs_7_95 = { - .N = 3, - .K = 7, - .len = 165, - .term = CONV_TERM_FLUSH, - .next_output = conv_gsm_tch_afs_7_95_next_output, - .next_state = conv_gsm_tch_afs_7_95_next_state, - .next_term_output = conv_gsm_tch_afs_7_95_next_term_output, - .next_term_state = conv_gsm_tch_afs_7_95_next_term_state, - .puncture = conv_gsm_tch_afs_7_95_puncture, -}; - - /* GMR-1 TCH3 Speech -> Non recursive code, tail-biting, punctured */ static const uint8_t conv_gmr1_tch3_speech_next_output[][2] = { { 0, 3 }, { 1, 2 }, { 3, 0 }, { 2, 1 }, @@ -260,7 +184,7 @@ int main(int argc, char *argv[]) }, { .name = "GSM TCH/AFS 7.95 (recursive, flushed, punctured)", - .code = &conv_gsm_tch_afs_7_95, + .code = &osmo_conv_gsm0503_tch_afs_7_95, .in_len = 165, .out_len = 448, .has_vec = 1, -- 2.5.0