/*
 * Here we implement parsing/decoding of TRAU-AMR-8k frames per 3GPP TS 48.061,
 * striving to decode and display as much as we can.
 */

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "osmo_bits.h"

/*
 * AMR TRAU parity (same as EFR)
 *
 * g(x) = x^3 + x^1 + 1
 */
static const struct osmo_crc8gen_code gsm0860_amr_crc3 = {
	.bits = 3,
	.poly = 0x3,
	.init = 0x0,
	.remainder = 0x7,
};

static int saved_mode, saved_mode_valid;

static char *fclass_names[4] = {
	"No_Speech", "Speech_Bad", "Speech_Degraded", "Speech_Good"
};

static char *nospch_class_names[8] = {
	"No_Data", "invalid", "invalid", "invalid",
	"Sid_Bad", "Sid_Update", "Onset", "Sid_First"
};

static const uint8_t params_lsf_475_515[]  = {8, 8, 7, 0};
static const uint8_t params_lsf_59_67_74[] = {8, 9, 9, 0};

static const uint8_t params_475_sf1[]  = {8, 7, 2, 8, 0};
static const uint8_t params_475_sf3[]  = {4, 7, 2, 8, 0};
static const uint8_t params_475_sf24[] = {4, 7, 2, 0};

static const uint8_t params_515_sf1[]   = {8, 7, 2, 6, 0};
static const uint8_t params_515_sf234[] = {4, 7, 2, 6, 0};

static const uint8_t params_59_sf13[] = {8, 9, 2, 6, 0};
static const uint8_t params_59_sf24[] = {4, 9, 2, 6, 0};

static const uint8_t params_67_sf13[] = {8, 11, 3, 7, 0};
static const uint8_t params_67_sf24[] = {4, 11, 3, 7, 0};

static const uint8_t params_74_sf13[] = {8, 13, 4, 7, 0};
static const uint8_t params_74_sf24[] = {5, 13, 4, 7, 0};

static const uint8_t params_sid[] = {3, 8, 9, 9, 6, 0};

static const ubit_t bit8_0[8] = { 0, };

/*!< check sync pattern for AMR No_Speech + low bit rate */
bool is_amr_low(const ubit_t *bits)
{
	int i;

	/* TS 08.61 Section 6.8.2.1.2 */
	if (memcmp(bits, bit8_0, sizeof(bit8_0)))
		return false;
	if (bits[8] != 1)
		return false;
	if (bits[16] != 1)
		return false;
	if (bits[24] != 0 || bits[25] != 1)
		return false;
	for (i = 32; i < 20 * 8; i += 8) {
		if (bits[i] != 1)
			return false;
	}
	return true;
}

/*!< check sync pattern for AMR 6.7kBit/s */
bool is_amr_67(const ubit_t *bits)
{
	int i;

	/* TS 08.61 Section 6.8.2.1.3 */
	if (memcmp(bits, bit8_0, sizeof(bit8_0)))
		return false;
	if (bits[8] != 1)
		return false;
	if (bits[16] != 1)
		return false;
	if (bits[24] != 1)
		return false;
	if (bits[32] != 1)
		return false;
	if (bits[40] != 0)
		return false;
	for (i = 48; i < 20 * 8; i += 16) {
		if (bits[i] != 1)
			return false;
	}
	return true;
}

/*!< check sync pattern for AMR 7.4kBit/s */
bool is_amr_74(const ubit_t *bits)
{
	if (bits[0] != 0 || bits[1] != 0 || bits[2] != 1)
		return false;
	if (bits[8] != 0)
		return false;
	if (bits[16] != 1)
		return false;
	if (bits[24] != 0)
		return false;

	return true;
}

static unsigned
bits_to_num(bits, nbits)
	ubit_t *bits;
	unsigned nbits;
{
	unsigned accum;
	unsigned n;

	accum = 0;
	for (n = 0; n < nbits; n++) {
		accum <<= 1;
		if (*bits)
			accum |= 1;
		bits++;
	}
	return accum;
}

static void
print_generic_params(bits, ltab)
	ubit_t *bits;
	uint8_t *ltab;
{
	uint8_t *tp;
	unsigned n, p;

	for (tp = ltab; n = *tp; tp++) {
		p = bits_to_num(bits, n);
		bits += n;
		printf(" %u", p);
	}
}

static void
print_speech_params(bits, ltab)
	ubit_t *bits;
	uint8_t *ltab;
{
	fputs("   ", stdout);
	print_generic_params(bits, ltab);
	putchar('\n');
}

static void
check_spare_bits(bits, nbits, desc)
	ubit_t *bits;
	unsigned nbits;
	char *desc;
{
	while (nbits) {
		if (*bits == 0)
			break;
		bits++;
		nbits--;
	}
	if (!nbits)
		return;
	printf("    Extra data in bits %s\n", desc);
}

static void
decode_mode_0(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	ubit_t crc_collect[36];
	int crc1, crc2, crc3, crc4;

	bcopy(c_bits, crc_collect, 5);
	bcopy(d_bits + 3, crc_collect + 5, 16);
	bcopy(d_bits + 20, crc_collect + 21, 2);
	bcopy(d_bits + 23, crc_collect + 23, 9);
	bcopy(d_bits + 47, crc_collect + 32, 4);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 36,
					d_bits + 51);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, d_bits + 54, 7,
					d_bits + 72);
	bcopy(d_bits + 75, crc_collect, 2);
	bcopy(d_bits + 92, crc_collect + 2, 4);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 6,
					d_bits + 96);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, d_bits + 99, 2,
					d_bits + 112);
	printf("    CRC %s %s %s %s\n",
		crc1 ? "bad" : "good", crc2 ? "bad" : "good",
		crc3 ? "bad" : "good", crc4 ? "bad" : "good");
	if (crc1)
		saved_mode_valid = 0;
	print_speech_params(d_bits + 3, params_lsf_475_515);
	print_speech_params(d_bits + 26, params_475_sf1);
	print_speech_params(d_bits + 59, params_475_sf24);
	print_speech_params(d_bits + 75, params_475_sf3);
	print_speech_params(d_bits + 99, params_475_sf24);
	check_spare_bits(d_bits, 3, "D1..D3");
	check_spare_bits(d_bits + 115, 126 - 115, "D116..D126");
}

static void
decode_mode_1(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	ubit_t crc_collect[37];
	int crc1, crc2, crc3, crc4;

	bcopy(c_bits, crc_collect, 5);
	bcopy(d_bits + 5, crc_collect + 5, 16);
	bcopy(d_bits + 23, crc_collect + 21, 11);
	bcopy(d_bits + 46, crc_collect + 32, 5);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 37,
					d_bits + 51);
	bcopy(d_bits + 54, crc_collect, 7);
	bcopy(d_bits + 73, crc_collect + 7, 5);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 12,
					d_bits + 78);
	bcopy(d_bits + 81, crc_collect, 2);
	bcopy(d_bits + 95, crc_collect + 2, 5);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 100);
	bcopy(d_bits + 103, crc_collect, 2);
	bcopy(d_bits + 117, crc_collect + 2, 5);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 122);
	printf("    CRC %s %s %s %s\n",
		crc1 ? "bad" : "good", crc2 ? "bad" : "good",
		crc3 ? "bad" : "good", crc4 ? "bad" : "good");
	if (crc1)
		saved_mode_valid = 0;
	print_speech_params(d_bits + 5, params_lsf_475_515);
	print_speech_params(d_bits + 28, params_515_sf1);
	print_speech_params(d_bits + 59, params_515_sf234);
	print_speech_params(d_bits + 81, params_515_sf234);
	print_speech_params(d_bits + 103, params_515_sf234);
	check_spare_bits(d_bits, 5, "D1..D5");
	if (!d_bits[125])
		puts("    Bit D126 is 0 (expected 1)");
}

static void
decode_mode_2(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	ubit_t crc_collect[34];
	int crc_stat;

	bcopy(c_bits, crc_collect, 5);
	bcopy(d_bits, crc_collect + 5, 17);
	bcopy(d_bits + 26, crc_collect + 22, 8);
	bcopy(d_bits + 47, crc_collect + 30, 4);
	crc_stat = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 34,
					   d_bits + 51);
	printf("    CRC %s\n", crc_stat ? "bad" : "good");
	if (crc_stat)
		saved_mode_valid = 0;
	print_speech_params(d_bits, params_lsf_59_67_74);
	print_speech_params(d_bits + 26, params_59_sf13);
	print_speech_params(d_bits + 59, params_59_sf24);
	print_speech_params(d_bits + 80, params_59_sf13);
	print_speech_params(d_bits + 105, params_59_sf24);
}

static void (*per_mode_decode[3])() = {
	decode_mode_0,
	decode_mode_1,
	decode_mode_2
};

static void
decode_speech_frame(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	unsigned c1_3 = bits_to_num(c_bits, 3);
	unsigned rif = (c1_3 >= 3);
	unsigned c4_5 = bits_to_num(c_bits + 3, 2);
	unsigned mode;

	printf("  Speech: RIF=%u FC=%s\n", rif, fclass_names[c4_5]);
	if (rif) {
		printf("  CMR=%u\n", c1_3 - 3);
		if (!saved_mode_valid) {
			puts("  Mode unknown, cannot decode");
			return;
		}
		mode = saved_mode;
		saved_mode_valid = 0;
	} else {
		mode = c1_3;
		saved_mode = mode;
		saved_mode_valid = 1;
	}
	printf("  Decoding per speech mode %u\n", mode);
	per_mode_decode[mode](c_bits, d_bits);
}

static void
decode_nospeech_frame(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	ubit_t crc_collect[5 + 51];
	unsigned cmi, cmr;
	int crc_stat;

	printf("  No_Speech: RIF=%u TA=%u UFE/DFE=%u\n", c_bits[2],
		bits_to_num(d_bits, 6), d_bits[6]);
	cmi = bits_to_num(d_bits + 10, 3);
	cmr = bits_to_num(d_bits + 13, 3);
	printf("  No_Spch_Class=%u%u%u (%s) CMI=%u CMR=%u\n",
		d_bits[7], d_bits[8], d_bits[9],
		nospch_class_names[bits_to_num(d_bits + 7, 3)], cmi, cmr);
	if (cmi <= 2) {
		saved_mode = cmi;
		saved_mode_valid = 1;
	} else {
		saved_mode_valid = 0;
	}
	bcopy(c_bits, crc_collect, 5);
	bcopy(d_bits, crc_collect + 5, 51);
	crc_stat = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect,
					   5 + 51, d_bits + 51);
	printf("  CRC %s\n", crc_stat ? "bad" : "good");
	fputs("    SID", stdout);
	print_generic_params(d_bits + 16, params_sid);
	putchar('\n');
	printf("  PAB=%u TAE=%u%u DTXd=%u TFOE=%u\n", d_bits[59], d_bits[60],
		d_bits[61], d_bits[62], d_bits[63]);
	check_spare_bits(d_bits + 64, 61, "D65..D125");
}

static int
handle_amr8_low(frame_bits)
	ubit_t *frame_bits;
{
	ubit_t *c_bits = frame_bits + 17;
	ubit_t d_bits[126];

	bcopy(frame_bits + 9, d_bits, 7);
	bcopy(frame_bits + 22, d_bits + 7, 2);
	bcopy(frame_bits + 26, d_bits + 9, 6);
	bcopy(frame_bits + 33, d_bits + 15, 7);
	bcopy(frame_bits + 41, d_bits + 22, 7);
	bcopy(frame_bits + 49, d_bits + 29, 7);
	bcopy(frame_bits + 57, d_bits + 36, 7);
	bcopy(frame_bits + 65, d_bits + 43, 7);
	bcopy(frame_bits + 73, d_bits + 50, 7);
	bcopy(frame_bits + 81, d_bits + 57, 7);
	bcopy(frame_bits + 89, d_bits + 64, 7);
	bcopy(frame_bits + 97, d_bits + 71, 7);
	bcopy(frame_bits + 105, d_bits + 78, 7);
	bcopy(frame_bits + 113, d_bits + 85, 7);
	bcopy(frame_bits + 121, d_bits + 92, 7);
	bcopy(frame_bits + 129, d_bits + 99, 7);
	bcopy(frame_bits + 137, d_bits + 106, 7);
	bcopy(frame_bits + 145, d_bits + 113, 7);
	bcopy(frame_bits + 153, d_bits + 120, 6);

	printf("  AMR C1-C5: %u%u%u %u%u\n", c_bits[0], c_bits[1], c_bits[2],
		c_bits[3], c_bits[4]);
	printf("  Config_Prot=%u%u%u Msg_No=%u%u\n", d_bits[54], d_bits[55],
		d_bits[56], d_bits[57], d_bits[58]);
	if (c_bits[3] || c_bits[4]) {
		decode_speech_frame(c_bits, d_bits);
		printf("  T=%u\n", frame_bits[159]);
		return 1;
	} else {
		decode_nospeech_frame(c_bits, d_bits);
		printf("  D126=%u T=%u\n", frame_bits[158], frame_bits[159]);
		return 2;
	}
}

static void
decode_6k7_7k4_common(c_bits, d_bits, mode, cmr_offset)
	ubit_t *c_bits, *d_bits;
	char *mode;
{
	unsigned c1_3 = bits_to_num(c_bits, 3);
	unsigned rif, fc, cmr_code;

	printf("  %s speech, C1-C3: %u%u%u\n", mode, c_bits[0], c_bits[1],
		c_bits[2]);
	switch (c1_3) {
	case 0:
		rif = 0;
		fc = 1;
		break;
	case 1:
		rif = 0;
		fc = 3;
		break;
	case 2:
		rif = 1;
		fc = 1;
		cmr_code = bits_to_num(d_bits + cmr_offset, 3);
		break;
	default:
		rif = 1;
		fc = 3;
		cmr_code = c1_3;
	}
	printf("  RIF=%u FC=%s\n", rif, fclass_names[fc]);
	if (rif) {
		if (cmr_code >= 3)
			printf("  CMR=%u\n", cmr_code - 3);
		else
			puts("  CMR code in data bits is invalid");
	}
}

static int
handle_amr8_6k7(frame_bits)
	ubit_t *frame_bits;
{
	ubit_t *c_bits = frame_bits + 17;
	ubit_t d_bits[137], crc_collect[35];
	int crc_stat;

	bcopy(frame_bits + 9, d_bits, 7);
	bcopy(frame_bits + 20, d_bits + 7, 4);
	bcopy(frame_bits + 25, d_bits + 11, 7);
	bcopy(frame_bits + 33, d_bits + 18, 7);
	bcopy(frame_bits + 41, d_bits + 25, 7);
	bcopy(frame_bits + 49, d_bits + 32, 15);
	bcopy(frame_bits + 65, d_bits + 47, 15);
	bcopy(frame_bits + 81, d_bits + 62, 15);
	bcopy(frame_bits + 97, d_bits + 77, 15);
	bcopy(frame_bits + 113, d_bits + 92, 15);
	bcopy(frame_bits + 129, d_bits + 107, 15);
	bcopy(frame_bits + 145, d_bits + 122, 15);

	decode_6k7_7k4_common(c_bits, d_bits, "MR67", 0);
	bcopy(c_bits, crc_collect, 3);
	bcopy(d_bits, crc_collect + 3, 17);
	crc_collect[20] = d_bits[19];
	crc_collect[21] = d_bits[23];
	bcopy(d_bits + 26, crc_collect + 22, 8);
	bcopy(d_bits + 48, crc_collect + 30, 5);
	crc_stat = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 35,
					   d_bits + 55);
	printf("  CRC %s\n", crc_stat ? "bad" : "good");
	print_speech_params(d_bits, params_lsf_59_67_74);
	print_speech_params(d_bits + 26, params_67_sf13);
	print_speech_params(d_bits + 58, params_67_sf24);
	print_speech_params(d_bits + 83, params_67_sf13);
	print_speech_params(d_bits + 112, params_67_sf24);

	saved_mode_valid = 0;
	return 0;
}

static int
handle_amr8_7k4(frame_bits)
	ubit_t *frame_bits;
{
	ubit_t *c_bits = frame_bits + 17;
	ubit_t d_bits[151], crc_collect[37];
	int crc_stat;

	bcopy(frame_bits + 3, d_bits, 5);
	bcopy(frame_bits + 9, d_bits + 5, 7);
	bcopy(frame_bits + 20, d_bits + 12, 4);
	bcopy(frame_bits + 25, d_bits + 16, 135);

	decode_6k7_7k4_common(c_bits, d_bits, "MR74", 5);
	bcopy(c_bits, crc_collect, 3);
	bcopy(d_bits, crc_collect + 3, 20);
	bcopy(d_bits + 21, crc_collect + 23, 3);
	bcopy(d_bits + 26, crc_collect + 26, 6);
	bcopy(d_bits + 51, crc_collect + 32, 2);
	bcopy(d_bits + 54, crc_collect + 34, 3);
	crc_stat = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 37,
					   d_bits + 58);
	printf("  CRC %s\n", crc_stat ? "bad" : "good");
	print_speech_params(d_bits, params_lsf_59_67_74);
	print_speech_params(d_bits + 26, params_74_sf13);
	print_speech_params(d_bits + 61, params_74_sf24);
	print_speech_params(d_bits + 90, params_74_sf13);
	print_speech_params(d_bits + 122, params_74_sf24);

	saved_mode_valid = 0;
	return 0;
}

print_amr8_frame(frame_bits)
	ubit_t *frame_bits;
{
	if (is_amr_low(frame_bits))
		return handle_amr8_low(frame_bits);
	if (is_amr_67(frame_bits))
		return handle_amr8_6k7(frame_bits);
	if (is_amr_74(frame_bits))
		return handle_amr8_7k4(frame_bits);
	puts("  Unrecognized format by sync pattern");
	return 0;
}