On Tue May 7 2013 18:24:22 Konke Radlow wrote:
> Signed-off-by: Konke Radlow <koradlow@xxxxxxxxx>
> ---
> lib/include/libv4l2rds.h | 39 +++++++++++
> lib/libv4l2rds/libv4l2rds.c | 159 +++++++++++++++++++++++++++++++++++++++++--
> 2 files changed, 194 insertions(+), 4 deletions(-)
>
> diff --git a/lib/include/libv4l2rds.h b/lib/include/libv4l2rds.h
> index 62b28bc..45dc2d1 100644
> --- a/lib/include/libv4l2rds.h
> +++ b/lib/include/libv4l2rds.h
> @@ -50,6 +50,10 @@ extern "C" {
> * 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) */
> +#define MAX_TMC_ALT_STATIONS 32 /* defined by ISO 14819-1:2003, 7.5.3.3 */
> +#define MAX_TMC_AF_CNT 4 /* limit for the numbers of AFs stored per alternative TMC
> + * station. This value is not defined by the standard, but based on observation
> + * of real-world RDS-TMC streams */
Could you clarify this a bit more? E.g. what is the maximum number of AFs you
have seen in practice?
> #define MAX_EON_CNT 20 /* Maximal number of entries in the EON table (for storing
> * information about other radio stations, broadcasted
> * by the current station) */
> @@ -75,6 +79,7 @@ extern "C" {
> #define V4L2_RDS_TMC_SYS 0x10000 /* RDS-TMC system information */
> #define V4L2_RDS_EON 0x20000 /* Enhanced Other Network Info */
> #define V4L2_RDS_LSF 0x40000 /* Linkage information */
> +#define V4L2_RDS_TMC_TUNING 0x80000 /* RDS-TMC tuning information */
>
> /* Define Constants for the state of the RDS decoding process
> * used to address the relevant bit in the decode_information bitmask */
> @@ -175,6 +180,37 @@ struct v4l2_rds_eon_set {
> * radio channels */
> };
>
> +/* struct to encapsulate alternative frequencies (AFs) for RDS-TMC stations.
> + * AFs listed in af[] can be used unconditionally.
> + * AFs listed in mapped_af[n] should only be used if the current
> + * tuner frequency matches the value in mapped_af_tuning[n] */
> +struct v4l2_tmc_alt_freq {
> + uint8_t af_size; /* number of known AFs */
> + uint8_t af_index;
> + uint8_t mapped_af_size; /* number of mapped AFs */
> + uint8_t mapped_af_index;
> + uint32_t af[MAX_TMC_AF_CNT]; /* AFs defined in Hz */
> + uint32_t mapped_af[MAX_TMC_AF_CNT]; /* mapped AFs defined in Hz */
> + uint32_t mapped_af_tuning[MAX_TMC_AF_CNT]; /* mapped AFs defined in Hz */
> +};
> +
> +/* struct to encapsulate information about stations carrying RDS-TMC services */
> +struct v4l2_tmc_station {
> + uint16_t pi;
> + uint8_t ltn; /* database-ID of ON */
> + uint8_t msg; /* msg parameters of ON */
> + uint8_t sid; /* service-ID of ON */
> + struct v4l2_tmc_alt_freq afi;
> +};
> +
> +/* struct to encapsulate tuning information for TMC */
> +struct v4l2_tmc_tuning {
> + uint8_t station_cnt; /* number of announced alternative stations */
> + uint8_t index;
> + struct v4l2_tmc_station station[MAX_TMC_ALT_STATIONS]; /* information
> + * about other stations carrying the same RDS-TMC service */
> +};
> +
> /* struct to encapsulate an additional data field in a TMC message */
> struct v4l2_tmc_additional {
> uint8_t label;
> @@ -225,6 +261,9 @@ struct v4l2_rds_tmc {
> uint8_t t_d; /* delay time (only if mode = enhanced */
> uint8_t spn[9]; /* service provider name */
> struct v4l2_rds_tmc_msg tmc_msg;
> +
> + /* tuning information for alternative service providers */
> + struct v4l2_tmc_tuning tuning;
> };
>
> /* struct to encapsulate state and RDS information for current decoding process */
> diff --git a/lib/libv4l2rds/libv4l2rds.c b/lib/libv4l2rds/libv4l2rds.c
> index 3a90a3b..3995c3d 100644
> --- a/lib/libv4l2rds/libv4l2rds.c
> +++ b/lib/libv4l2rds/libv4l2rds.c
> @@ -93,7 +93,9 @@ enum rds_state {
> };
>
> /* function declarations to prevent the need to move large code blocks */
> +static int rds_add_tmc_station(struct rds_private_state *priv_state, uint16_t pi);
> static uint32_t rds_decode_af(uint8_t af, bool is_vhf);
> +static bool rds_add_tmc_af(struct rds_private_state *priv_state);
Same comment as previously: just have a separate patch that moves code around.
>
> static inline uint8_t set_bit(uint8_t input, uint8_t bitmask, bool bitvalue)
> {
> @@ -437,6 +439,59 @@ static uint32_t rds_decode_tmc_multi_group(struct rds_private_state *priv_state)
> return V4L2_RDS_TMC_MG;
> }
>
> +/* decode the RDS-TMC tuning information that is contained in type 8A groups
> + * (variants 4 to 9) that announce the presence alternative transmitters
> + * providing the same RDS-TMC service */
> +static uint32_t rds_decode_tmc_tuning(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 = group->data_b_lsb & 0x0f;
> + uint16_t pi_on = (group->data_d_msb << 8) | group->data_d_lsb;
> + uint8_t index;
> +
> + /* variants 4 and 5 carry the service provider name */
> + if (variant_code >= 4 && variant_code <= 5) {
> + int offset = 4 * (variant_code - 4);
> + tmc->spn[0 + offset] = group->data_c_msb;
> + tmc->spn[1 + offset] = group->data_c_lsb;
> + tmc->spn[2 + offset] = group->data_d_msb;
> + tmc->spn[3 + offset] = group->data_d_lsb;
> +
> + /* variant 6 provides specific frequencies for the same RDS-TMC service
> + * on a network with a different PI code */
> + /* variant 7 provides mapped frequency pair information which should only
> + * be used if the terminal is tuned to the tuning frequency */
> + } else if (variant_code == 6 || variant_code == 7) {
> + rds_add_tmc_af(priv_state);
> +
> + /* variant 8 indicates up to 2 PI codes of adjacent networks carrying
> + * the same RDS-TMC service on all transmitters of the network */
> + } else if (variant_code == 8) {
> + uint16_t pi_on_2 = (group->data_c_msb << 8) | group->data_c_lsb;
> +
> + /* try to add both transmitted PI codes to the table */
> + rds_add_tmc_station(priv_state, pi_on);
> + /* PI = 0 is used as a filler code */
> + if (pi_on_2 != 0) rds_add_tmc_station(priv_state, pi_on_2);
Newline before rds_add_tmc_station().
> +
> + /* variant 9 provides PI codes of other networks with different system
> + * parameters */
> + } else if (variant_code == 9) {
> + index = rds_add_tmc_station(priv_state, pi_on);
> +
> + /* bits 0 - 5 contain the service-ID of the ON */
> + tmc->tuning.station[index].sid = group->data_c_lsb & 0x3F;
> + /* bits 6-10 contain the msg parameters of the ON */
> + tmc->tuning.station[index].msg = (group->data_c_msb & 0x03) << 2;
> + tmc->tuning.station[index].msg |= (group->data_c_lsb >> 6) & 0x03;
> + /* bits 11-15 contain the database-ID of the ON */
> + tmc->tuning.station[index].ltn = group->data_c_msb >> 2;
> + }
> +
> + return V4L2_RDS_TMC_TUNING;
> +}
> +
> static bool rds_add_oda(struct rds_private_state *priv_state, struct v4l2_rds_oda oda)
> {
> struct v4l2_rds *handle = &priv_state->handle;
> @@ -516,6 +571,103 @@ static bool rds_add_af(struct rds_private_state *priv_state)
> return updated_af;
> }
>
> +/* checks if an entry for the given PI already exists and returns the index
> + * of that entry if so. Else it adds a new entry to the TMC-Tuning table and returns
> + * the index of the new field */
> +static int rds_add_tmc_station(struct rds_private_state *priv_state, uint16_t pi)
> +{
> + struct v4l2_tmc_tuning *tuning = &priv_state->handle.tmc.tuning;
> + uint8_t index = tuning->index;
> + uint8_t size = tuning->station_cnt;
> +
> + /* check if there's an entry for the given PI key */
> + for (int i = 0; i < tuning->station_cnt; i++) {
> + if (tuning->station[i].pi == pi) {
> + return i;
> + }
> + }
> + /* if the the maximum table size is reached, overwrite old
> + * entries, starting at the oldest one = 0 */
> + tuning->station[index].pi = pi;
> + tuning->index = (index+1 < MAX_TMC_ALT_STATIONS)? (index+1) : 0;
Space before '?'
> + tuning->station_cnt = (size+1 <= MAX_TMC_ALT_STATIONS)? (size+1) : MAX_TMC_ALT_STATIONS;
Ditto. You do this elsewhere as well, please check :-)
> + return index;
> +}
> +
> +/* tries to add new AFs to the relevant entry in the list of RDS-TMC providers */
> +static bool rds_add_tmc_af(struct rds_private_state *priv_state)
> +{
> + struct v4l2_rds_group *grp = &priv_state->rds_group;
> + struct v4l2_tmc_alt_freq *afi;
> + uint16_t pi_on = grp->data_d_msb << 8 | grp->data_d_lsb;
> + uint8_t variant = grp->data_b_lsb & 0x0f;
> + uint8_t station_index = rds_add_tmc_station(priv_state, pi_on);
> + uint8_t af_index;
> + uint8_t mapped_af_index;
> + uint32_t freq_a = rds_decode_af(grp->data_c_msb, true);
> + uint32_t freq_b = rds_decode_af(grp->data_c_lsb, true);
> +
> + afi = &priv_state->handle.tmc.tuning.station[station_index].afi;
> + af_index = afi->af_index;
> + mapped_af_index = afi->mapped_af_index;
> +
> + /* specific frequencies */
> + if (variant == 6) {
> + /* compare the new AFs to the stored ones, reset them to 0 if the AFs are
> + * already known */
> + for (int i = 0; i < afi->af_size; i++) {
> + freq_a = (freq_a == afi->af[i])? 0 : freq_a;
> + freq_b = (freq_b == afi->af[i])? 0 : freq_b;
> + }
> + /* return early if there is nothing to do */
> + if (freq_a == 0 && freq_b == 0)
> + return false;
> +
> + /* add the new AFs if they were previously unknown */
> + if (freq_a != 0) {
> + afi->af[af_index] = freq_a;
> + af_index = (af_index+1 < MAX_TMC_AF_CNT)? af_index+1 : 0;
> + afi->af_size++;
> + }
> + if (freq_b != 0) {
> + afi->af[af_index] = freq_b;
> + af_index = (af_index+1 < MAX_TMC_AF_CNT)? af_index+1 : 0;
> + afi->af_size++;
> + }
> + /* update the information in the handle */
> + afi->af_index = af_index;
> + if (afi->af_size >= MAX_TMC_AF_CNT)
> + afi->af_size = MAX_TMC_AF_CNT;
> +
> + return true;
> + }
> +
> + /* mapped frequency pair */
> + else if (variant == 7) {
> + /* check the if there's already a frequency mapped to the new tuning
> + * frequency, update the mapped frequency in this case */
> + for (int i = 0; i < afi->mapped_af_size; i++) {
> + if (freq_a == afi->mapped_af_tuning[i])
> + afi->mapped_af[i] = freq_b;
> + return true;
> + }
> + /* new pair is unknown, add it to the list */
> + if (freq_a != 0 && freq_b != 0) {
> + mapped_af_index = (mapped_af_index+1 >= MAX_TMC_AF_CNT)? 0 : mapped_af_index + 1;
> + afi->mapped_af[mapped_af_index] = freq_b;
> + afi->mapped_af_tuning[mapped_af_index] = freq_a;
> + afi->mapped_af_size++;
> + }
> + /* update the information in the handle */
> + afi->mapped_af_index = mapped_af_index;
> + if (afi->mapped_af_size >= MAX_TMC_AF_CNT)
> + afi->mapped_af_size = MAX_TMC_AF_CNT;
> +
> + return true;
> + }
> + return false;
> +}
> +
> /* adds one char of the ps name to temporal storage, the value is validated
> * if it is received twice in a row
> * @pos: position of the char within the PS name (0..7)
> @@ -968,13 +1120,12 @@ static uint32_t rds_decode_group8(struct rds_private_state *priv_state)
> !(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 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 0;
> + return rds_decode_tmc_tuning(priv_state);
> }
>
> return 0;
>
I suggest that we update V4L2_RDS_VERSION to 2.
Unless I am mistaken we are now complete with regards to the RDS/TMC
functionality and we can release the library officially.
It would still be nice if rds-ctl could decode the TMC messages to human
readable text, though...
Regards,
Hans
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
