← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libhdhomerun/trusty

« back to all changes in this revision

Viewing changes to hdhomerun_channels.c

  • Committer: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2011-03-25 16:30:20 UTC
  • mfrom: (1.1.10 upstream) (0.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110325163020-cz65j0hkmfep1pfi
Tags: 20110323-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
hdhomerun_channels.c
32
32
 
33
33
#include "hdhomerun.h"
34
34
 
35
 
#define FREQUENCY_RESOLUTION 62500
36
 
 
37
35
struct hdhomerun_channel_entry_t {
38
36
        struct hdhomerun_channel_entry_t *next;
39
37
        struct hdhomerun_channel_entry_t *prev;
40
38
        uint32_t frequency;
41
 
        uint8_t channel_number;
 
39
        uint16_t channel_number;
42
40
        char name[16];
43
41
};
44
42
 
48
46
};
49
47
 
50
48
struct hdhomerun_channelmap_range_t {
51
 
        uint8_t channel_range_start;
52
 
        uint8_t channel_range_end;
 
49
        uint16_t channel_range_start;
 
50
        uint16_t channel_range_end;
53
51
        uint32_t frequency;
54
52
        uint32_t spacing;
55
53
};
61
59
        const char *countrycodes;
62
60
};
63
61
 
64
 
/* AU antenna channels. Channels {0, 1, 2, 6, 7, 8, 9, 9A} are numbered {2, 3, 4, 5, 6, 7, 8, 9} by the HDHomeRun. */
 
62
/* AU antenna channels. Channels {6, 7, 8, 9, 9A} are numbered {5, 6, 7, 8, 9} by the HDHomeRun. */
65
63
static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_au_bcast[] = {
66
 
        {  2,   2,  48500000, 7000000},
67
 
        {  3,   4,  59500000, 7000000},
68
64
        {  5,  12, 177500000, 7000000},
69
 
        { 28,  69, 529500000, 7000000},
70
 
        {  0,   0,         0,       0}
71
 
};
72
 
 
73
 
/* AU cable channels. TBD. */
74
 
static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_au_cable[] = {
 
65
        { 21,  69, 480500000, 7000000},
75
66
        {  0,   0,         0,       0}
76
67
};
77
68
 
78
69
/* EU antenna channels. */
79
70
static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_eu_bcast[] = {
80
 
        {  2,   4,  50500000, 7000000},
81
71
        {  5,  12, 177500000, 7000000},
82
72
        { 21,  69, 474000000, 8000000},
83
73
        {  0,   0,         0,       0}
84
74
};
85
75
 
86
 
/* EU cable channels. Channels do not have simple numbers - the HDHomeRun uses its own numbering scheme (subject to change). */
 
76
/* EU cable channels. No common standard - use frequency in MHz for channel number. */
87
77
static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_eu_cable[] = {
88
 
        {  6,   7, 113000000, 8000000},
89
 
        {  9, 100, 138000000, 8000000},
 
78
        { 50, 998,  50000000, 1000000},
90
79
        {  0,   0,         0,       0}
91
80
};
92
81
 
107
96
        { 14,  22, 123000000, 6000000},
108
97
        { 23,  94, 219000000, 6000000},
109
98
        { 95,  99,  93000000, 6000000},
110
 
        {100, 135, 651000000, 6000000},
 
99
        {100, 158, 651000000, 6000000},
111
100
        {  0,   0,         0,       0}
112
101
};
113
102
 
119
108
        { 14,  22, 121756000, 6000300},
120
109
        { 23,  94, 217760800, 6000300},
121
110
        { 95,  99,  91754500, 6000300},
122
 
        {100, 135, 649782400, 6000300},
 
111
        {100, 158, 649782400, 6000300},
123
112
        {  0,   0,         0,       0}
124
113
};
125
114
 
134
123
        { 43,  94, 339012500, 6000000},
135
124
        { 95,  97,  93012500, 6000000},
136
125
        { 98,  99, 111025000, 6000000},
137
 
        {100, 135, 651012500, 6000000},
 
126
        {100, 158, 651012500, 6000000},
138
127
        {  0,   0,         0,       0}
139
128
};
140
129
 
141
130
static const struct hdhomerun_channelmap_record_t hdhomerun_channelmap_table[] = {
142
131
        {"au-bcast", hdhomerun_channelmap_range_au_bcast, "au-bcast",               "AU"},
143
 
        {"au-cable", hdhomerun_channelmap_range_au_cable, "au-cable",               "AU"},
 
132
        {"au-cable", hdhomerun_channelmap_range_eu_cable, "au-cable",               "AU"},
144
133
        {"eu-bcast", hdhomerun_channelmap_range_eu_bcast, "eu-bcast",               "EU PA"},
145
134
        {"eu-cable", hdhomerun_channelmap_range_eu_cable, "eu-cable",               "EU"},
146
135
        {"tw-bcast", hdhomerun_channelmap_range_us_bcast, "tw-bcast",               "TW"},
193
182
        return NULL;
194
183
}
195
184
 
196
 
uint8_t hdhomerun_channel_entry_channel_number(struct hdhomerun_channel_entry_t *entry)
 
185
uint16_t hdhomerun_channel_entry_channel_number(struct hdhomerun_channel_entry_t *entry)
197
186
{
198
187
        return entry->channel_number;
199
188
}
259
248
        return count;
260
249
}
261
250
 
262
 
uint32_t hdhomerun_channel_frequency_truncate(uint32_t frequency)
263
 
{
264
 
        return (frequency / FREQUENCY_RESOLUTION) * FREQUENCY_RESOLUTION;
265
 
}
266
 
 
267
 
uint32_t hdhomerun_channel_number_to_frequency(struct hdhomerun_channel_list_t *channel_list, uint8_t channel_number)
 
251
uint32_t hdhomerun_channel_frequency_round(uint32_t frequency, uint32_t resolution)
 
252
{
 
253
        frequency += resolution / 2;
 
254
        return (frequency / resolution) * resolution;
 
255
}
 
256
 
 
257
uint32_t hdhomerun_channel_frequency_round_normal(uint32_t frequency)
 
258
{
 
259
        return hdhomerun_channel_frequency_round(frequency, 125000);
 
260
}
 
261
 
 
262
uint32_t hdhomerun_channel_number_to_frequency(struct hdhomerun_channel_list_t *channel_list, uint16_t channel_number)
268
263
{
269
264
        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
270
265
        while (entry) {
278
273
        return 0;
279
274
}
280
275
 
281
 
uint8_t hdhomerun_channel_frequency_to_number(struct hdhomerun_channel_list_t *channel_list, uint32_t frequency)
 
276
uint16_t hdhomerun_channel_frequency_to_number(struct hdhomerun_channel_list_t *channel_list, uint32_t frequency)
282
277
{
283
 
        frequency = hdhomerun_channel_frequency_truncate(frequency);
 
278
        frequency = hdhomerun_channel_frequency_round_normal(frequency);
284
279
 
285
280
        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
286
281
        while (entry) {
329
324
 
330
325
static void hdhomerun_channel_list_build_range(struct hdhomerun_channel_list_t *channel_list, const char *channelmap, const struct hdhomerun_channelmap_range_t *range)
331
326
{
332
 
        uint8_t channel_number;
 
327
        uint16_t channel_number;
333
328
        for (channel_number = range->channel_range_start; channel_number <= range->channel_range_end; channel_number++) {
334
329
                struct hdhomerun_channel_entry_t *entry = (struct hdhomerun_channel_entry_t *)calloc(1, sizeof(struct hdhomerun_channel_entry_t));
335
330
                if (!entry) {
338
333
 
339
334
                entry->channel_number = channel_number;
340
335
                entry->frequency = range->frequency + ((uint32_t)(channel_number - range->channel_range_start) * range->spacing);
341
 
                entry->frequency = hdhomerun_channel_frequency_truncate(entry->frequency);
 
336
                entry->frequency = hdhomerun_channel_frequency_round_normal(entry->frequency);
342
337
                sprintf(entry->name, "%s:%u", channelmap, entry->channel_number);
343
338
 
344
339
                hdhomerun_channel_list_build_insert(channel_list, entry);