FreeCalypso > hg > gsm-net-reveng

view trau-decode/parse-amr.c @ 92:761650771e51

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
trau-parse AMR: print SID parameters
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 05 Mar 2025 02:26:11 +0000
parents bbb28d5447f9
children fa80ce9b076c
line wrap: on
line source

/*
 * Here we implement parsing/decoding of AMR frames as in 3GPP TS 48.060
 * section 5.5.1.2, striving to decode and display as much as we can.
 */

#include <stdio.h>
#include <stdint.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_102[] = {8, 9, 9, 0};
static const uint8_t params_lsf_795[] = {9, 9, 9, 0};
static const uint8_t params_lsf_122[] = {7, 8, 9, 8, 6, 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_795_sf13[] = {8, 13, 4, 4, 5, 0};
static const uint8_t params_795_sf24[] = {6, 13, 4, 4, 5, 0};

static const uint8_t params_102_sf13[] = {8, 1, 1, 1, 1, 10, 10, 7, 7, 0};
static const uint8_t params_102_sf24[] = {5, 1, 1, 1, 1, 10, 10, 7, 7, 0};

static const uint8_t params_122_sf13[] =
	{9, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 5, 0};
static const uint8_t params_122_sf24[] =
	{6, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 5, 0};

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

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
decode_mode_0(c_bits, d_bits)
	ubit_t *c_bits, *d_bits;
{
	ubit_t crc_collect[56];
	int crc1, crc2, crc3, crc4;

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 44, crc_collect + 25, 16);
	bcopy(d_bits + 61, crc_collect + 41, 2);
	bcopy(d_bits + 64, crc_collect + 43, 9);
	bcopy(d_bits + 88, crc_collect + 52, 4);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 56,
					d_bits + 92);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, d_bits + 95, 2,
					d_bits + 108);
	bcopy(d_bits + 111, crc_collect, 2);
	bcopy(d_bits + 128, crc_collect + 2, 4);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 6,
					d_bits + 132);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, d_bits + 135, 2,
					d_bits + 148);
	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 + 44, params_lsf_475_515);
	print_speech_params(d_bits + 67, params_475_sf1);
	print_speech_params(d_bits + 95, params_475_sf24);
	print_speech_params(d_bits + 111, params_475_sf3);
	print_speech_params(d_bits + 135, params_475_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 46, crc_collect + 25, 16);
	bcopy(d_bits + 64, crc_collect + 41, 11);
	bcopy(d_bits + 87, crc_collect + 52, 5);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 57,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 2);
	bcopy(d_bits + 109, crc_collect + 2, 5);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 114);
	bcopy(d_bits + 117, crc_collect, 2);
	bcopy(d_bits + 131, crc_collect + 2, 5);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 136);
	bcopy(d_bits + 139, crc_collect, 2);
	bcopy(d_bits + 153, crc_collect + 2, 5);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 158);
	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 + 46, params_lsf_475_515);
	print_speech_params(d_bits + 69, params_515_sf1);
	print_speech_params(d_bits + 95, params_515_sf234);
	print_speech_params(d_bits + 117, params_515_sf234);
	print_speech_params(d_bits + 139, params_515_sf234);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 41, crc_collect + 25, 17);
	bcopy(d_bits + 67, crc_collect + 42, 8);
	bcopy(d_bits + 88, crc_collect + 50, 4);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 54,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 3);
	bcopy(d_bits + 112, crc_collect + 3, 4);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 116);
	bcopy(d_bits + 119, crc_collect, 8);
	bcopy(d_bits + 140, crc_collect + 8, 4);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 12,
					d_bits + 144);
	bcopy(d_bits + 147, crc_collect, 3);
	bcopy(d_bits + 164, crc_collect + 3, 4);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 168);
	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 + 41, params_lsf_59_67_74_102);
	print_speech_params(d_bits + 67, params_59_sf13);
	print_speech_params(d_bits + 95, params_59_sf24);
	print_speech_params(d_bits + 119, params_59_sf13);
	print_speech_params(d_bits + 147, params_59_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 37, crc_collect + 25, 17);
	crc_collect[42] = d_bits[56];
	crc_collect[43] = d_bits[60];
	bcopy(d_bits + 63, crc_collect + 44, 8);
	bcopy(d_bits + 85, crc_collect + 52, 5);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 57,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 4);
	bcopy(d_bits + 113, crc_collect + 4, 5);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 9,
					d_bits + 120);
	bcopy(d_bits + 123, crc_collect, 8);
	bcopy(d_bits + 145, crc_collect + 8, 5);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 13,
					d_bits + 152);
	bcopy(d_bits + 155, crc_collect, 4);
	bcopy(d_bits + 173, crc_collect + 4, 5);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 9,
					d_bits + 180);
	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 + 37, params_lsf_59_67_74_102);
	print_speech_params(d_bits + 63, params_67_sf13);
	print_speech_params(d_bits + 95, params_67_sf24);
	print_speech_params(d_bits + 123, params_67_sf13);
	print_speech_params(d_bits + 155, params_67_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 34, crc_collect + 25, 20);
	bcopy(d_bits + 55, crc_collect + 45, 3);
	bcopy(d_bits + 60, crc_collect + 48, 6);
	bcopy(d_bits + 85, crc_collect + 54, 2);
	bcopy(d_bits + 88, crc_collect + 56, 3);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 59,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 3);
	bcopy(d_bits + 117, crc_collect + 3, 2);
	bcopy(d_bits + 120, crc_collect + 5, 3);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 8,
					d_bits + 124);
	bcopy(d_bits + 127, crc_collect, 6);
	bcopy(d_bits + 152, crc_collect + 6, 2);
	bcopy(d_bits + 155, crc_collect + 8, 3);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 11,
					d_bits + 159);
	bcopy(d_bits + 162, crc_collect, 3);
	bcopy(d_bits + 184, crc_collect + 3, 2);
	bcopy(d_bits + 187, crc_collect + 5, 2);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 7,
					d_bits + 191);
	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 + 34, params_lsf_59_67_74_102);
	print_speech_params(d_bits + 60, params_74_sf13);
	print_speech_params(d_bits + 95, params_74_sf24);
	print_speech_params(d_bits + 127, params_74_sf13);
	print_speech_params(d_bits + 162, params_74_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 31, crc_collect + 25, 35);
	bcopy(d_bits + 83, crc_collect + 60, 2);
	crc_collect[62] = d_bits[87];
	crc_collect[63] = d_bits[90];
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 64,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 4);
	bcopy(d_bits + 118, crc_collect + 4, 2);
	bcopy(d_bits + 122, crc_collect + 6, 4);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 10,
					d_bits + 127);
	bcopy(d_bits + 130, crc_collect, 8);
	bcopy(d_bits + 155, crc_collect + 8, 2);
	bcopy(d_bits + 159, crc_collect + 10, 4);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 14,
					d_bits + 164);
	bcopy(d_bits + 167, crc_collect, 4);
	bcopy(d_bits + 190, crc_collect + 4, 2);
	bcopy(d_bits + 194, crc_collect + 6, 4);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 10,
					d_bits + 199);
	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 + 31, params_lsf_795);
	print_speech_params(d_bits + 58, params_795_sf13);
	print_speech_params(d_bits + 95, params_795_sf24);
	print_speech_params(d_bits + 130, params_795_sf13);
	print_speech_params(d_bits + 167, params_795_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits, crc_collect + 25, 45);
	bcopy(d_bits + 46, crc_collect + 70, 8);
	bcopy(d_bits + 85, crc_collect + 78, 2);
	bcopy(d_bits + 88, crc_collect + 80, 2);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 82,
					d_bits + 92);
	bcopy(d_bits + 95, crc_collect, 4);
	bcopy(d_bits + 131, crc_collect + 4, 2);
	bcopy(d_bits + 134, crc_collect + 6, 2);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 8,
					d_bits + 138);
	bcopy(d_bits + 141, crc_collect, 8);
	bcopy(d_bits + 180, crc_collect + 8, 2);
	bcopy(d_bits + 183, crc_collect + 10, 2);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 12,
					d_bits + 187);
	bcopy(d_bits + 190, crc_collect, 4);
	bcopy(d_bits + 226, crc_collect + 4, 2);
	bcopy(d_bits + 229, crc_collect + 6, 2);
	bcopy(d_bits + 233, crc_collect + 8, 20);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 28,
					d_bits + 253);
	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 + 20, params_lsf_59_67_74_102);
	print_speech_params(d_bits + 46, params_102_sf13);
	print_speech_params(d_bits + 95, params_102_sf24);
	print_speech_params(d_bits + 141, params_102_sf13);
	print_speech_params(d_bits + 190, params_102_sf24);
}

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

	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits, crc_collect + 25, 29);
	bcopy(d_bits + 38, crc_collect + 54, 12);
	bcopy(d_bits + 86, crc_collect + 66, 3);
	crc1 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 69,
					d_bits + 91);
	bcopy(d_bits + 94, crc_collect, 9);
	bcopy(d_bits + 139, crc_collect + 9, 3);
	crc2 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 12,
					d_bits + 144);
	bcopy(d_bits + 147, crc_collect, 12);
	bcopy(d_bits + 195, crc_collect + 12, 3);
	crc3 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 15,
					d_bits + 200);
	bcopy(d_bits + 203, crc_collect, 5);
	bcopy(d_bits + 209, crc_collect + 5, 3);
	bcopy(d_bits + 248, crc_collect + 8, 3);
	crc4 = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect, 11,
					d_bits + 253);
	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, params_lsf_122);
	print_speech_params(d_bits + 38, params_122_sf13);
	print_speech_params(d_bits + 94, params_122_sf24);
	print_speech_params(d_bits + 147, params_122_sf13);
	print_speech_params(d_bits + 203, params_122_sf24);
}

static void (*per_mode_decode[8])() = {
	decode_mode_0,
	decode_mode_1,
	decode_mode_2,
	decode_mode_3,
	decode_mode_4,
	decode_mode_5,
	decode_mode_6,
	decode_mode_7
};

static void
decode_speech_frame(c_bits, d_bits, cm_hdr)
	ubit_t *c_bits, *d_bits;
	unsigned cm_hdr;
{
	unsigned mode;

	if (c_bits[11]) {
		if (!saved_mode_valid) {
			printf("  Mode unknown, cannot decode\n");
			return;
		}
		mode = saved_mode;
		saved_mode_valid = 0;
	} else {
		mode = cm_hdr;
		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[25 + 61];
	int crc_stat;

	printf("  No_Spch_Class=%u%u%u (%s) CMI=%u CMR=%u\n",
		d_bits[31], d_bits[32], d_bits[33],
		nospch_class_names[bits_to_num(d_bits + 31, 3)],
		bits_to_num(d_bits + 34, 3), bits_to_num(d_bits + 37, 3));
	printf("  PAB=%u TAE=%u%u\n", d_bits[40], d_bits[41], d_bits[42]);
	bcopy(c_bits, crc_collect, 25);
	bcopy(d_bits + 31, crc_collect + 25, 61);
	crc_stat = osmo_crc8gen_check_bits(&gsm0860_amr_crc3, crc_collect,
					   25 + 61, d_bits + 92);
	printf("  CRC %s\n", crc_stat ? "bad" : "good");
	if (crc_stat) {
		saved_mode_valid = 0;
	} else {
		saved_mode = bits_to_num(d_bits + 34, 3);
		saved_mode_valid = 1;
	}
	fputs("    SID", stdout);
	print_generic_params(d_bits + 57, params_sid);
	putchar('\n');
}

void
print_amr_frame(frame_bits)
	uint8_t *frame_bits;
{
	ubit_t c_bits[25], d_bits[256];
	uint8_t fclass, cm_hdr;

	bcopy(frame_bits + 17, c_bits, 15);
	bcopy(frame_bits + 33, c_bits + 15, 10);
	bcopy(frame_bits + 43, d_bits, 5);
	bcopy(frame_bits + 49, d_bits + 5, 15);
	bcopy(frame_bits + 65, d_bits + 20, 15);
	bcopy(frame_bits + 81, d_bits + 35, 15);
	bcopy(frame_bits + 97, d_bits + 50, 15);
	bcopy(frame_bits + 113, d_bits + 65, 15);
	bcopy(frame_bits + 129, d_bits + 80, 15);
	bcopy(frame_bits + 145, d_bits + 95, 15);
	bcopy(frame_bits + 161, d_bits + 110, 15);
	bcopy(frame_bits + 177, d_bits + 125, 15);
	bcopy(frame_bits + 193, d_bits + 140, 15);
	bcopy(frame_bits + 209, d_bits + 155, 15);
	bcopy(frame_bits + 225, d_bits + 170, 15);
	bcopy(frame_bits + 241, d_bits + 185, 15);
	bcopy(frame_bits + 257, d_bits + 200, 15);
	bcopy(frame_bits + 273, d_bits + 215, 15);
	bcopy(frame_bits + 289, d_bits + 230, 15);
	bcopy(frame_bits + 305, d_bits + 245, 11);

	printf("  C6-C11: %u\n", bits_to_num(c_bits + 5, 6));
	printf("  RIF=%u UFE=%u Config_Prot=%u%u%u Msg_No=%u%u\n",
		c_bits[11], c_bits[12], c_bits[13], c_bits[14], c_bits[15],
		c_bits[16], c_bits[17]);
	fclass = bits_to_num(c_bits + 20, 2);
	cm_hdr = bits_to_num(c_bits + 22, 3);
	printf("  DTXd=%u TFOE=%u FClass=%u%u (%s) %s=%u\n",
		c_bits[18], c_bits[19], c_bits[20], c_bits[21],
		fclass_names[fclass], c_bits[11] ? "CMR" : "CMI", cm_hdr);
	if (fclass)
		decode_speech_frame(c_bits, d_bits, cm_hdr);
	else
		decode_nospeech_frame(c_bits, d_bits);
	printf("  T1=%u T2=%u T3=%u T4=%u\n", frame_bits[316],
		frame_bits[317], frame_bits[318], frame_bits[319]);
}