diff --git a/lib/include/libv4l2rds.h b/lib/include/libv4l2rds.h
index 37bdd2f..caefc1a 100644
--- a/lib/include/libv4l2rds.h
+++ b/lib/include/libv4l2rds.h
@@ -63,6 +63,9 @@ extern "C" {
 #define V4L2_RDS_AF		0x800	/* AF (alternative freq) available */
 #define V4L2_RDS_ECC		0x1000	/* Extended County Code */
 #define V4L2_RDS_LC		0x2000	/* Language Code */
+#define V4L2_RDS_TMC_SG		0x4000	/* RDS-TMC single group */
+#define V4L2_RDS_TMC_MG		0x8000	/* RDS-TMC multi group */
+#define V4L2_RDS_TMC_SYS	0x10000 /* RDS-TMC system information */
 
 /* Define Constants for the state of the RDS decoding process
  * used to address the relevant bit in the decode_information bitmask */
@@ -76,6 +79,11 @@ extern "C" {
 #define V4L2_RDS_FLAG_COMPRESSED	0x04
 #define V4L2_RDS_FLAG_STATIC_PTY	0x08
 
+/* TMC related codes
+ * used to extract TMC fields from RDS groups */
+#define V4L2_TMC_TUNING_INFO	0x08
+#define V4L2_TMC_SINGLE_GROUP	0x04
+
 /* struct to encapsulate one complete RDS group */
 /* This structure is used internally to store data until a complete RDS
  * group was received and group id dependent decoding can be done.
@@ -137,6 +145,61 @@ struct v4l2_rds_af_set {
 	uint32_t af[MAX_AF_CNT];	/* AFs defined in Hz */
 };
 
+/* struct to encapsulate an additional data field in a TMC message */
+struct v4l2_tmc_additional {
+	uint8_t label;
+	uint16_t data;
+};
+
+/* struct to encapsulate an arbitrary number of additional data fields
+ * belonging to one TMC message */
+struct v4l2_tmc_additional_set {
+	uint8_t size;
+	/* 28 is the maximal possible number of fields. Additional data
+	 * is limited to 112 bit, and the smallest optional tuple has
+	 * a size of 4 bit (4 bit identifier + 0 bits of data) */
+	struct v4l2_tmc_additional fields[28];
+};
+
+/* struct to encapsulate a decoded TMC message with optional additional
+ * data field (in case of a multi-group TMC message) */
+struct v4l2_rds_tmc_msg {
+	uint8_t length;	/* length of multi-group message (0..4) */
+	uint8_t sid;		/* service identifier at time of reception */
+	uint8_t extent;
+	uint8_t dp;		/* duration and persistence */
+	uint16_t event;		/* TMC event code */
+	uint16_t location;	/* TMC event location */
+	bool follow_diversion;	/* indicates if the driver is adviced to
+				 * follow the diversion */
+	bool neg_direction;	/* indicates negative / positive direction */
+
+	/* decoded additional information (only available in multi-group
+	 * messages) */
+	struct v4l2_tmc_additional_set additional;
+};
+
+/* struct to encapsulate all TMC related information, including TMC System
+ * Information, TMC Tuning information and a buffer for the last decoded
+ * TMC messages */
+struct v4l2_rds_tmc {
+	uint8_t ltn;		/* location_table_number */
+	bool afi;		/* alternative frequency indicator */
+	bool enhanced_mode;	/* mode of transmission,
+				 * if false -> basic => gaps between tmc groups
+				 * gap defines timing behavior
+				 * if true -> enhanced => t_a, t_w and t_d
+				 * define timing behavior of tmc groups */
+	uint8_t mgs;		/* message geographical scope */
+	uint8_t sid;		/* service identifier (unique ID on national level) */
+	uint8_t gap;		/* Gap parameters */
+	uint8_t t_a;		/* activity time (only if mode = enhanced) */
+	uint8_t t_w;		/* window time (only if mode = enhanced */
+	uint8_t t_d;		/* delay time (only if mode = enhanced */
+	uint8_t spn[9];		/* service provider name */
+	struct v4l2_rds_tmc_msg tmc_msg;
+};
+
 /* struct to encapsulate state and RDS information for current decoding process */
 /* This is the structure that will be used by external applications, to
  * communicate with the library and get access to RDS data */
@@ -172,6 +235,7 @@ struct v4l2_rds {
 	struct v4l2_rds_statistics rds_statistics;
 	struct v4l2_rds_oda_set rds_oda;	/* Open Data Services */
 	struct v4l2_rds_af_set rds_af; 		/* Alternative Frequencies */
+	struct v4l2_rds_tmc tmc;		/* TMC information */
 };
 
 /* v4l2_rds_init() - initializes a new decoding process
diff --git a/lib/libv4l2rds/libv4l2rds.c b/lib/libv4l2rds/libv4l2rds.c
index 2d6642c..f47adb8 100644
--- a/lib/libv4l2rds/libv4l2rds.c
+++ b/lib/libv4l2rds/libv4l2rds.c
@@ -63,6 +63,22 @@ struct rds_private_state {
 	uint8_t utc_minute;
 	uint8_t utc_offset;
 
+	/* TMC decoding buffers, to store data before it can be verified,
+	 * and before all parts of a multi-group message have been received */
+	uint8_t continuity_id;	/* continuity index of current TMC multigroup */
+	uint8_t grp_seq_id; 	/* group sequence identifier */
+	uint32_t optional_tmc[4];	/* buffer for up to 112 bits of optional
+					 * additional data in multi-group
+					 * messages */
+
+	/* TMC groups are only accepted if the same data was received twice,
+	 * these structs are used as receive buffers to validate TMC groups */
+	struct v4l2_rds_group prev_tmc_group;
+	struct v4l2_rds_group prev_tmc_sys_group;
+	struct v4l2_rds_tmc_msg new_tmc_msg;
+
+	/* buffers for rds data, before group type specific decoding can
+	 * be done */
 	struct v4l2_rds_group rds_group;
 	struct v4l2_rds_data rds_data_raw[4];
 };
@@ -179,6 +195,276 @@ static void rds_decode_d(struct rds_private_state *priv_state, struct v4l2_rds_d
 	grp->data_d_lsb = rds_data->lsb;
 }
 
+/* compare two rds-groups for equality */
+/* used for decoding RDS-TMC, which has the requirement that the same group
+ * is at least received twice before it is accepted */
+static bool rds_compare_group(const struct v4l2_rds_group *a,
+				const struct v4l2_rds_group *b)
+{
+	if (a->pi != b->pi)
+		return false;
+	if (a->group_version != b->group_version)
+		return false;
+	if (a->group_id != b->group_id)
+		return false;
+
+	if (a->data_b_lsb != b->data_b_lsb)
+		return false;
+	if (a->data_c_lsb != b->data_c_lsb || a->data_c_msb != b->data_c_msb)
+		return false;
+	if (a->data_d_lsb != b->data_d_lsb || a->data_d_msb != b->data_d_msb)
+		return false;
+	/* all values are equal */
+	return true;
+}
+
+/* return a bitmask with with bit_cnt bits set to 1 (starting from lsb) */
+static uint32_t get_bitmask(uint8_t bit_cnt)
+{
+	return (1 << bit_cnt) - 1;
+}
+
+/* decode additional information of a TMC message into handy representation */
+/* the additional information of TMC messages is submitted in (up to) 4 blocks of
+ * 28 bits each, which are to be treated as a consecutive bit-array. Each additional
+ * information is defined by a 4-bit label, and the length of the following data
+ * is known. If the number of required bits for labels & data fields exeeds 28,
+ * coding continues without interruption in the next block.
+ * The first label starts at Y11 and is followed immediately by the associated data.
+ * The optional bit blocks are represented by an array of 4 uint32_t vars in the
+ * rds_private_state struct. The msb of each variable starts at Y11 (bit 11 of
+ * block 3) and continues down to Z0 (bit 0 of block 4).
+ * The 4 lsb bits are not used (=0) */
+static struct v4l2_tmc_additional_set *rds_tmc_decode_additional
+		(struct rds_private_state *priv_state)
+{
+	struct v4l2_rds_tmc_msg *msg = &priv_state->handle.tmc.tmc_msg;
+	struct v4l2_tmc_additional *fields = &msg->additional.fields[0];
+	uint32_t *optional = priv_state->optional_tmc;
+	const uint8_t data_len = 28;	/* used bits in the fields of the
+					 * uint32_t optional array */
+	const uint8_t label_len = 4;	/* fixed length of a label */
+	uint8_t label;		/* buffer for extracted label */
+	uint16_t data;		/* buffer for extracted data */
+	uint8_t pos = 0;	/* current position in optional block */
+	uint8_t len; 		/* length of next data field to be extracted */
+	uint8_t o_len;		/* lenght of overhang into next block */
+	uint8_t block_idx = 0;	/* index for current optional block */
+	uint8_t *field_idx = &msg->additional.size;	/* index for
+				 * additional field array */
+	/* LUT for the length of additional data blocks as defined in
+	 * ISO 14819-1 sect. 5.5.1 */
+	static const uint8_t additional_lut[16] = {
+		3, 3, 5, 5, 5, 8, 8, 8, 8, 11, 16, 16, 16, 16, 0, 0
+	};
+
+	/* reset the additional information from previous messages */
+	*field_idx = 0;
+	memset(fields, 0, sizeof(*fields));
+
+	/* decode each received optional block */
+	for (int i = 0; i < msg->length; i++) {
+		/* extract the label, handle situation where label is split
+		 * across two adjacent RDS-TMC groups */
+		if (pos + label_len > data_len) {
+			o_len = label_len - (data_len - pos);	/* overhang length */
+			len = data_len - pos;	/* remaining data in current block*/
+			label = optional[block_idx] >> (32 - pos - len + o_len) &
+				get_bitmask(len + o_len);
+			if (++block_idx >= msg->length)
+				break;
+			pos = 0;	/* start at beginning of next block */
+			label |= optional[block_idx] >> (32 - pos - o_len);
+		} else {
+			label = optional[block_idx] >> (32 - pos - label_len) &
+				get_bitmask(label_len);
+			pos += label_len % data_len;
+			/* end of optional block reached? */
+			block_idx = (pos == 0) ? block_idx+1 : block_idx;
+			if (block_idx >= msg->length)
+				break;
+		}
+
+		/* extract the associated data block, handle situation where it
+		 * is split across two adjacent RDS-TMC groups */
+		len = additional_lut[label];	/* length of data block */
+		if (pos + len > data_len) {
+			o_len = len - (data_len - pos);	/* overhang length */
+			len = data_len - pos;	/* remaining data in current block*/
+			data = optional[block_idx] >> (32 - pos - len + o_len) &
+				get_bitmask(len + o_len);
+			if (++block_idx >= msg->length)
+				break;
+			pos = 0;	/* start at beginning of next block */
+			label |= optional[block_idx] >> (32 - pos - o_len);
+		} else {
+			data = optional[block_idx] >> (32 - pos - len) &
+				get_bitmask(len);
+			data += len % data_len;
+			/* end of optional block reached? */
+			block_idx = (pos == 0) ? block_idx+1 : block_idx;
+		}
+
+		/* if  the label is not "reserved for future use", store
+		 * the extracted additional information */
+		if (label == 15) {
+			continue;
+		}
+		fields[*field_idx].label = label;
+		fields[*field_idx].data = data;
+		*field_idx += 1;
+	}
+	return &msg->additional;
+}
+
+/* decode the TMC system information that is contained in type 3A groups
+ * that announce the presence of TMC */
+static uint32_t rds_decode_tmc_system(struct rds_private_state *priv_state)
+{
+	struct v4l2_rds_group *group = &priv_state->rds_group;
+	struct v4l2_rds_tmc *tmc = &priv_state->handle.tmc;
+	uint8_t variant_code;
+
+	/* check if the same group was received twice. If not, store new
+	 * group and return early */
+	if (!rds_compare_group(&priv_state->prev_tmc_sys_group, &priv_state->rds_group)) {
+		priv_state->prev_tmc_sys_group = priv_state->rds_group;
+		return 0x00;
+	}
+	/* bits 14-15 of block 3 contain the variant code */
+	variant_code = priv_state->rds_group.data_c_msb >> 6;
+	switch (variant_code) {
+	case 0x00:
+		/* bits 11-16 of block 3 contain the LTN */
+		tmc->ltn = (((group->data_c_msb & 0x0f) << 2)) |
+			(group->data_c_lsb >> 6);
+		/* bit 5 of block 3 contains the AFI */
+		tmc->afi = group->data_c_lsb & 0x20;
+		/* bit 4 of block 3 contains the Mode */
+		tmc->enhanced_mode = group->data_c_lsb & 0x10;
+		/* bits 0-3 of block 3 contain the MGS */
+		tmc->mgs = group->data_c_lsb & 0x0f;
+		break;
+	case 0x01:
+		/* bits 12-13 of block 3 contain the Gap parameters */
+		tmc->gap = (group->data_c_msb & 0x30) >> 4;
+		/* bits 11-16 of block 3 contain the SID */
+		tmc->sid = (((group->data_c_msb & 0x0f) << 2)) |
+			(group->data_c_lsb >> 6);
+		/* timing information is only valid in enhanced mode */
+		if (!tmc->enhanced_mode)
+			break;
+		/* bits 4-5 of block 3 contain the activity time */
+		tmc->t_a = (group->data_c_lsb & 0x30) >> 4;
+		/* bits 2-3 of block 3 contain the window time */
+		tmc->t_w = (group->data_c_lsb & 0x0c) >> 2;
+		/* bits 0-1 of block 3 contain the delay time */
+		tmc->t_d = group->data_c_lsb & 0x03;
+		break;
+	}
+	return V4L2_RDS_TMC_SYS;
+}
+
+/* decode a single group TMC message */
+static uint32_t rds_decode_tmc_single_group(struct rds_private_state *priv_state)
+{
+	struct v4l2_rds_group *grp = &priv_state->rds_group;
+	struct v4l2_rds_tmc_msg msg;
+
+	/* bits 0-2 of group 2 contain the duration value */
+	msg.dp = grp->data_b_lsb & 0x07;
+	/* bit 15 of block 3 indicates follow diversion advice */
+	msg.follow_diversion = (bool)(grp->data_c_msb & 0x80);
+	/* bit 14 of block 3 indicates the direction */
+	msg.neg_direction = (bool)(grp->data_c_msb & 0x40);
+	/* bits 11-13 of block 3 contain the extend of the event */
+	msg.extent = (grp->data_c_msb & 0x38) >> 3;
+	/* bits 0-10 of block 3 contain the event */
+	msg.event = ((grp->data_c_msb & 0x07) << 8) | grp->data_c_lsb;
+	/* bits 0-15 of block 4 contain the location */
+	msg.location = (grp->data_d_msb << 8) | grp->data_c_lsb;
+
+	/* decoding done, store the new message */
+	priv_state->handle.tmc.tmc_msg = msg;
+	priv_state->handle.valid_fields |= V4L2_RDS_TMC_SG;
+	priv_state->handle.valid_fields &= ~V4L2_RDS_TMC_MG;
+
+	return V4L2_RDS_TMC_SG;
+}
+
+/* decode a multi group TMC message and decode the additional fields once
+ * a complete group was decoded */
+static uint32_t rds_decode_tmc_multi_group(struct rds_private_state *priv_state)
+{
+	struct v4l2_rds_group *grp = &priv_state->rds_group;
+	struct v4l2_rds_tmc_msg *msg = &priv_state->new_tmc_msg;
+	uint32_t *optional = priv_state->optional_tmc;
+	bool message_completed = false;
+	uint8_t grp_seq_id;
+	uint64_t buffer;
+
+	/* bits 12-13 of block 3 contain the group sequence id, for all
+	 * multi groups except the first group */
+	grp_seq_id = (grp->data_c_msb & 0x30) >> 4;
+
+	/* beginning of a new multigroup ? */
+	/* bit 15 of block 3 is the first group indicator */
+	if (grp->data_c_msb & 0x80) {
+		/* begine decoding of new message */
+		memset(msg, 0, sizeof(msg));
+		/* bits 0-3 of block 2 contain continuity index */
+		priv_state->continuity_id = grp->data_b_lsb & 0x07;
+		/* bit 15 of block 3 indicates follow diversion advice */
+		msg->follow_diversion = (bool)(grp->data_c_msb & 0x80);
+		/* bit 14 of block 3 indicates the direction */
+		msg->neg_direction = (bool)(grp->data_c_msb & 0x40);
+		/* bits 11-13 of block 3 contain the extend of the event */
+		msg->extent = (grp->data_c_msb & 0x38) >> 3;
+		/* bits 0-10 of block 3 contain the event */
+		msg->event = ((grp->data_c_msb & 0x07) << 8) | grp->data_c_lsb;
+		/* bits 0-15 of block 4 contain the location */
+		msg->location = (grp->data_d_msb << 8) | grp->data_c_lsb;
+	}
+	/* second group of multigroup ? */
+	/* bit 14 of block 3 ist the second group indicator, and the
+	 * group continuity id has to match */
+	else if (grp->data_c_msb & 0x40 &&
+		(grp->data_b_lsb & 0x07) == priv_state->continuity_id) {
+		priv_state->grp_seq_id = grp_seq_id;
+		/* store group for later decoding */
+		buffer = grp->data_c_msb << 28 | grp->data_c_lsb << 20 |
+			grp->data_d_msb << 12 | grp->data_d_lsb << 4;
+		optional[0] = buffer;
+		msg->length = 1;
+		if (grp_seq_id == 0)
+			message_completed = true;
+	}
+	/* subsequent groups of multigroup ? */
+	/* group continuity id has to match, and group sequence number has
+	 * to be smaller by one than the group sequence id */
+	else if ((grp->data_b_lsb & 0x07) == priv_state->continuity_id &&
+		(grp_seq_id == priv_state->grp_seq_id-1)) {
+		priv_state->grp_seq_id = grp_seq_id;
+		/* store group for later decoding */
+		buffer = grp->data_c_msb << 28 | grp->data_c_lsb << 20 |
+			grp->data_d_msb << 12 | grp->data_d_lsb << 4;
+		optional[msg->length++] = buffer;
+		if (grp_seq_id == 0)
+			message_completed = true;
+	}
+
+	/* complete message received -> decode additional fields and store
+	 * the new message */
+	if (message_completed) {
+		priv_state->handle.tmc.tmc_msg = *msg;
+		rds_tmc_decode_additional(priv_state);
+		priv_state->handle.valid_fields |= V4L2_RDS_TMC_MG;
+		priv_state->handle.valid_fields &= ~V4L2_RDS_TMC_SG;
+	}
+
+	return V4L2_RDS_TMC_MG;
+}
+
 static bool rds_add_oda(struct rds_private_state *priv_state, struct v4l2_rds_oda oda)
 {
 	struct v4l2_rds *handle = &priv_state->handle;
@@ -526,6 +812,12 @@ static uint32_t rds_decode_group3(struct rds_private_state *priv_state)
 		handle->decode_information |= V4L2_RDS_ODA;
 		updated_fields |= V4L2_RDS_ODA;
 	}
+
+	/* if it's a TMC announcement decode the contained information */
+	if (new_oda.aid == 0xcd46 || new_oda.aid == 0xcd47) {
+		rds_decode_tmc_system(priv_state);
+	}
+
 	return updated_fields;
 }
 
@@ -623,6 +915,50 @@ static uint32_t rds_decode_group4(struct rds_private_state *priv_state)
 	return updated_fields;
 }
 
+/* group 8A: TMC */
+static uint32_t rds_decode_group8(struct rds_private_state *priv_state)
+{
+	struct v4l2_rds_group *grp = &priv_state->rds_group;
+	uint8_t tuning_variant = 0x00;
+
+	/* TMC uses version A exclusively */
+	if (grp->group_version != 'A')
+		return 0x00;
+
+	/* check if the same group was received twice, store new rds group
+	 * and return early if the old group doesn't match the new one */
+	if (!rds_compare_group(&priv_state->prev_tmc_group, &priv_state->rds_group)) {
+		priv_state->prev_tmc_group = priv_state->rds_group;
+		return 0x00;
+	}
+	/* modify the old group, to prevent that the same TMC message is decoded
+	 * again in the next iteration (the default number of repetitions for
+	 * RDS-TMC groups is 3) */
+	priv_state->prev_tmc_group.group_version = 0x00;
+
+	/* handle the new TMC data depending on the message type */
+	/* -> single group message */
+	if ((grp->data_b_lsb & V4L2_TMC_SINGLE_GROUP) &&
+		!(grp->data_b_lsb & V4L2_TMC_TUNING_INFO)) {
+		return rds_decode_tmc_single_group(priv_state);
+	}
+	/* -> multi group message */
+	if (!(grp->data_b_lsb & V4L2_TMC_SINGLE_GROUP) &&
+		!(grp->data_b_lsb & V4L2_TMC_TUNING_INFO)) {
+		return rds_decode_tmc_multi_group(priv_state);
+	}
+	/* -> tuning information message, defined for variants 4..9, submitted
+	 * in bits 0-3 of block 2 */
+	tuning_variant = grp->data_b_lsb & 0x0f;
+	if ((grp->data_b_lsb & V4L2_TMC_TUNING_INFO) && tuning_variant >= 4 &&
+		tuning_variant <= 9) {
+		/* TODO: Implement tuning information decoding */
+		return 0x00;
+	}
+
+	return 0x00;
+}
+
 /* group 10: Program Type Name */
 static uint32_t rds_decode_group10(struct rds_private_state *priv_state)
 {
@@ -685,6 +1021,7 @@ static const decode_group_func decode_group[16] = {
 	[2] = rds_decode_group2,
 	[3] = rds_decode_group3,
 	[4] = rds_decode_group4,
+	[8] = rds_decode_group8,
 	[10] = rds_decode_group10,
 };
 
@@ -956,8 +1293,7 @@ const char *v4l2_rds_get_coverage_str(const struct v4l2_rds *handle)
 	return coverage_lut[coverage];
 }
 
-const struct v4l2_rds_group *v4l2_rds_get_group
-	(const struct v4l2_rds *handle)
+const struct v4l2_rds_group *v4l2_rds_get_group(const struct v4l2_rds *handle)
 {
 	struct rds_private_state *priv_state = (struct rds_private_state *) handle;
 	return &priv_state->rds_group;
diff --git a/utils/rds-ctl/rds-ctl.cpp b/utils/rds-ctl/rds-ctl.cpp
index 262773c..a91e4fa 100644
--- a/utils/rds-ctl/rds-ctl.cpp
+++ b/utils/rds-ctl/rds-ctl.cpp
@@ -76,6 +76,7 @@ enum Option {
 	OptOpenFile,
 	OptPrintBlock,
 	OptSilent,
+	OptTMC,
 	OptTunerIndex,
 	OptVerbose,
 	OptWaitLimit,
@@ -110,6 +111,7 @@ static struct option long_options[] = {
 	{"print-block", no_argument, 0, OptPrintBlock},
 	{"read-rds", no_argument, 0, OptReadRds},
 	{"set-freq", required_argument, 0, OptSetFreq},
+	{"tmc", no_argument, 0, OptTMC},
 	{"tuner-index", required_argument, 0, OptTunerIndex},
 	{"verbose", no_argument, 0, OptVerbose},
 	{"wait-limit", required_argument, 0, OptWaitLimit},
@@ -170,6 +172,8 @@ static void usage_rds(void)
 	       "  --print-block\n"
 	       "                     prints all valid RDS fields, whenever a value is updated\n"
 	       "                     instead of printing only updated values\n"
+	       "  --tmc\n"
+	       "                     enables decoding of TMC (Traffic Message Channel) data\n"
 	       "  --verbose\n"
 	       "                     turn on verbose mode - every received RDS group\n"
 	       "                     will be printed\n"
@@ -491,7 +495,30 @@ static void print_decoder_info(uint8_t di)
 		printf("Not Compressed");
 }
 
-static void print_rds_statistics(struct v4l2_rds_statistics *statistics)
+static void print_rds_tmc(const struct v4l2_rds *handle, uint32_t updated_fields)
+{
+	const struct v4l2_rds_tmc_msg *msg = &handle->tmc.tmc_msg;
+	const struct v4l2_tmc_additional_set *set = &msg->additional;
+
+	if (updated_fields & V4L2_RDS_TMC_SG) {
+		printf("\nTMC Single-grp: location: %04x, event: %04x, extent: %02x "
+			"duration: %02x", msg->location, msg->event,
+			msg->extent, msg->dp);
+		return;
+	}
+	if (updated_fields & V4L2_RDS_TMC_MG) {
+		printf("\nTMC Multi-grp: length: %02d, location: %04x, event: %04x,\n"
+		"               extent: %02x duration: %02x", msg->length, msg->location, msg->event,
+			msg->extent, msg->dp);
+		for (int i = 0; i < set->size; i++) {
+			printf("\n               additional[%02d]: label: %02d, value: %04x",
+			i, set->fields[i].label, set->fields[i].data);
+		}
+		return;
+	}
+}
+
+static void print_rds_statistics(const struct v4l2_rds_statistics *statistics)
 {
 	printf("\n\nRDS Statistics: \n");
 	printf("received blocks / received groups: %u / %u\n",
@@ -583,6 +610,8 @@ static void print_rds_data(const struct v4l2_rds *handle, uint32_t updated_field
 		print_rds_af(&handle->rds_af);
 	if (params.options[OptPrintBlock])
 		printf("\n");
+	if (params.options[OptTMC])
+		print_rds_tmc(handle, updated_fields);
 }
 
 static void read_rds(struct v4l2_rds *handle, const int fd, const int wait_limit)
