[8976] | 1 | #ifndef EPGSCAN_H |
---|
| 2 | #define EPGSCAN_H |
---|
| 3 | |
---|
[8981] | 4 | struct epgscanlist* getepgscanlistbytransponder(int transponderid) |
---|
| 5 | { |
---|
| 6 | //debug(1000, "in"); |
---|
| 7 | struct epgscanlist *node = epgscanlist; |
---|
| 8 | |
---|
| 9 | while(node != NULL) |
---|
| 10 | { |
---|
| 11 | if(node->transponderid == transponderid) |
---|
| 12 | { |
---|
| 13 | //debug(1000, "out"); |
---|
| 14 | return node; |
---|
| 15 | } |
---|
| 16 | |
---|
| 17 | node = node->next; |
---|
| 18 | } |
---|
| 19 | debug(100, "epgscanlist not found (transponderid=%d)", transponderid); |
---|
| 20 | return NULL; |
---|
| 21 | } |
---|
| 22 | |
---|
[8976] | 23 | void epgscanlistthread(struct stimerthread* self) |
---|
| 24 | { |
---|
[8981] | 25 | struct epgscanlist* node = epgscanlist, *tmpepgscannode = NULL; |
---|
[8976] | 26 | struct dvbdev* fenode = NULL; |
---|
| 27 | struct channel* chnode = NULL; |
---|
[10803] | 28 | |
---|
| 29 | debug(400, "epgscan thread start"); |
---|
[8976] | 30 | |
---|
[9005] | 31 | if(status.standby == 0) |
---|
| 32 | { |
---|
| 33 | if(status.epglistmode == 0 || status.epglistmode == 2) |
---|
[9754] | 34 | goto end; |
---|
[9005] | 35 | } |
---|
| 36 | else if(getconfig("epg_refreshtime", NULL) == NULL) |
---|
[9754] | 37 | goto end; |
---|
[8976] | 38 | |
---|
| 39 | //wait for right time |
---|
| 40 | while(self->aktion != STOP && time(NULL) < 1072224000) // 01.01.2004 |
---|
| 41 | usleep(1 * 1000000); |
---|
| 42 | |
---|
| 43 | while(node != NULL) |
---|
| 44 | { |
---|
| 45 | chnode = getchannel(node->serviceid, node->transponderid); |
---|
| 46 | if(chnode == NULL || chnode == status.aktservice->channel) |
---|
| 47 | { |
---|
| 48 | node = node->next; |
---|
| 49 | debug(400, "epgscan channel not found"); |
---|
| 50 | continue; |
---|
| 51 | } |
---|
| 52 | |
---|
[8981] | 53 | tmpepgscannode = getepgscanlistbytransponder(node->transponderid); |
---|
| 54 | if(tmpepgscannode != NULL && tmpepgscannode->scantime != 0) |
---|
| 55 | { |
---|
| 56 | node = node->next; |
---|
| 57 | debug(400, "epgscan transponer already scanned"); |
---|
| 58 | continue; |
---|
| 59 | } |
---|
| 60 | |
---|
[9005] | 61 | if(status.standby > 0) |
---|
[10261] | 62 | fenode = fegetfree(chnode->transponder, 0, NULL); |
---|
[9005] | 63 | else |
---|
[10261] | 64 | fenode = fegetfree(chnode->transponder, 2, NULL); |
---|
[9005] | 65 | if(fenode == NULL || (status.standby == 0 && fenode == status.aktservice->fedev)) |
---|
[8976] | 66 | { |
---|
| 67 | node = node->next; |
---|
| 68 | debug(400, "epgscan no free frontend found"); |
---|
| 69 | continue; |
---|
| 70 | } |
---|
| 71 | |
---|
| 72 | if(fenode->felock == 0) |
---|
| 73 | { |
---|
| 74 | //frontend tune |
---|
| 75 | if(fenode->feinfo->type == FE_QPSK) |
---|
| 76 | { |
---|
| 77 | feset(fenode, chnode->transponder); |
---|
| 78 | fetunedvbs(fenode, chnode->transponder); |
---|
| 79 | } |
---|
| 80 | else if(fenode->feinfo->type == FE_QAM) |
---|
| 81 | fetunedvbc(fenode, chnode->transponder); |
---|
| 82 | else if(fenode->feinfo->type == FE_OFDM) |
---|
| 83 | fetunedvbt(fenode, chnode->transponder); |
---|
| 84 | else |
---|
| 85 | { |
---|
| 86 | node = node->next; |
---|
| 87 | continue; |
---|
| 88 | } |
---|
| 89 | |
---|
| 90 | int festatus = fewait(fenode); |
---|
| 91 | if(festatus != 0) |
---|
| 92 | { |
---|
| 93 | node = node->next; |
---|
| 94 | debug(400, "epgscan frontend tune failed"); |
---|
| 95 | continue; |
---|
| 96 | } |
---|
| 97 | |
---|
| 98 | if(chnode->name != NULL) |
---|
| 99 | debug(400, "epgscan scanning channel=%s, frontend=%s", chnode->name, fenode->feshortname); |
---|
| 100 | readeit(self, chnode, fenode, 1); |
---|
[8981] | 101 | node->scantime = time(NULL); |
---|
[8976] | 102 | } |
---|
| 103 | |
---|
| 104 | node = node->next; |
---|
| 105 | } |
---|
[9754] | 106 | |
---|
| 107 | end: |
---|
| 108 | status.epgscanlistthread = NULL; |
---|
[8976] | 109 | debug(400, "epgscan thread end"); |
---|
| 110 | } |
---|
| 111 | |
---|
| 112 | struct epgscanlist* addepgscanlist(char *line, int count, struct epgscanlist* last) |
---|
| 113 | { |
---|
| 114 | //debug(1000, "in"); |
---|
| 115 | struct epgscanlist *newnode = NULL, *prev = NULL, *node = epgscanlist; |
---|
| 116 | int ret = 0; |
---|
| 117 | |
---|
| 118 | newnode = (struct epgscanlist*)malloc(sizeof(struct epgscanlist)); |
---|
| 119 | if(newnode == NULL) |
---|
| 120 | { |
---|
| 121 | err("no memory"); |
---|
| 122 | return NULL; |
---|
| 123 | } |
---|
| 124 | |
---|
| 125 | memset(newnode, 0, sizeof(struct epgscanlist)); |
---|
| 126 | status.writeepgscanlist = 1; |
---|
| 127 | |
---|
| 128 | ret = sscanf(line, "%d#%ld", &newnode->serviceid, &newnode->transponderid); |
---|
| 129 | if(ret != 2) |
---|
| 130 | { |
---|
| 131 | if(count > 0) |
---|
| 132 | { |
---|
| 133 | err("epgscanlist line %d not ok", count); |
---|
| 134 | } |
---|
| 135 | else |
---|
| 136 | { |
---|
| 137 | err("add epgscanlist"); |
---|
| 138 | } |
---|
| 139 | free(newnode); |
---|
| 140 | return NULL; |
---|
| 141 | } |
---|
| 142 | |
---|
| 143 | if(getchannel(newnode->serviceid, newnode->transponderid) == NULL) |
---|
| 144 | { |
---|
| 145 | err("epgscanlist line %d not ok (channel not found)", count); |
---|
| 146 | free(newnode); |
---|
| 147 | return NULL; |
---|
| 148 | } |
---|
| 149 | |
---|
| 150 | if(last == NULL) |
---|
| 151 | { |
---|
| 152 | while(node != NULL) |
---|
| 153 | { |
---|
| 154 | prev = node; |
---|
| 155 | node = node->next; |
---|
| 156 | } |
---|
| 157 | } |
---|
| 158 | else |
---|
| 159 | { |
---|
| 160 | prev = last; |
---|
| 161 | node = last->next; |
---|
| 162 | } |
---|
| 163 | |
---|
| 164 | if(prev == NULL) |
---|
| 165 | epgscanlist = newnode; |
---|
| 166 | else |
---|
| 167 | { |
---|
| 168 | prev->next = newnode; |
---|
| 169 | newnode->prev = prev; |
---|
| 170 | } |
---|
| 171 | newnode->next = node; |
---|
[9750] | 172 | if(node != NULL) node->prev = newnode; |
---|
[8976] | 173 | |
---|
| 174 | //debug(1000, "out"); |
---|
| 175 | return newnode; |
---|
| 176 | } |
---|
| 177 | |
---|
| 178 | int readepgscanlist(const char* filename) |
---|
| 179 | { |
---|
| 180 | debug(1000, "in"); |
---|
| 181 | FILE *fd = NULL; |
---|
| 182 | char *fileline = NULL; |
---|
| 183 | int linecount = 0; |
---|
[10174] | 184 | struct epgscanlist* last = NULL, *tmplast = NULL; |
---|
[8976] | 185 | |
---|
| 186 | fileline = malloc(MINMALLOC); |
---|
| 187 | if(fileline == NULL) |
---|
| 188 | { |
---|
| 189 | err("no memory"); |
---|
| 190 | return 1; |
---|
| 191 | } |
---|
| 192 | |
---|
| 193 | fd = fopen(filename, "r"); |
---|
| 194 | if(fd == NULL) |
---|
| 195 | { |
---|
| 196 | perr("can't open %s", filename); |
---|
| 197 | free(fileline); |
---|
| 198 | return 1; |
---|
| 199 | } |
---|
| 200 | |
---|
| 201 | while(fgets(fileline, MINMALLOC, fd) != NULL) |
---|
| 202 | { |
---|
| 203 | if(fileline[0] == '#' || fileline[0] == '\n') |
---|
| 204 | continue; |
---|
| 205 | if(fileline[strlen(fileline) - 1] == '\n') |
---|
| 206 | fileline[strlen(fileline) - 1] = '\0'; |
---|
| 207 | if(fileline[strlen(fileline) - 1] == '\r') |
---|
| 208 | fileline[strlen(fileline) - 1] = '\0'; |
---|
| 209 | |
---|
| 210 | linecount++; |
---|
| 211 | |
---|
[10174] | 212 | if(last == NULL) last = tmplast; |
---|
[8976] | 213 | last = addepgscanlist(fileline, linecount, last); |
---|
[10174] | 214 | if(last != NULL) tmplast = last; |
---|
[8976] | 215 | } |
---|
| 216 | |
---|
| 217 | status.writeepgscanlist = 0; |
---|
| 218 | free(fileline); |
---|
| 219 | fclose(fd); |
---|
| 220 | return 0; |
---|
| 221 | } |
---|
| 222 | |
---|
| 223 | void delepgscanlist(int serviceid, int transponderid) |
---|
| 224 | { |
---|
| 225 | debug(1000, "in"); |
---|
| 226 | struct epgscanlist *node = epgscanlist, *prev = epgscanlist; |
---|
| 227 | |
---|
| 228 | while(node != NULL) |
---|
| 229 | { |
---|
| 230 | if(node->serviceid == serviceid && node->transponderid == transponderid) |
---|
| 231 | { |
---|
| 232 | status.writeepgscanlist = 1; |
---|
| 233 | if(node == epgscanlist) |
---|
| 234 | { |
---|
| 235 | epgscanlist = node->next; |
---|
| 236 | if(epgscanlist != NULL) |
---|
| 237 | epgscanlist->prev = NULL; |
---|
| 238 | } |
---|
| 239 | else |
---|
| 240 | { |
---|
| 241 | prev->next = node->next; |
---|
| 242 | if(node->next != NULL) |
---|
| 243 | node->next->prev = prev; |
---|
| 244 | } |
---|
| 245 | |
---|
| 246 | free(node); |
---|
| 247 | node = NULL; |
---|
| 248 | break; |
---|
| 249 | } |
---|
| 250 | |
---|
| 251 | prev = node; |
---|
| 252 | node = node->next; |
---|
| 253 | } |
---|
| 254 | debug(1000, "out"); |
---|
| 255 | } |
---|
| 256 | |
---|
| 257 | struct epgscanlist* getepgscanlist(int serviceid, int transponderid) |
---|
| 258 | { |
---|
| 259 | //debug(1000, "in"); |
---|
| 260 | struct epgscanlist *node = epgscanlist; |
---|
| 261 | |
---|
| 262 | while(node != NULL) |
---|
| 263 | { |
---|
| 264 | if(node->serviceid == serviceid && node->transponderid == transponderid) |
---|
| 265 | { |
---|
| 266 | //debug(1000, "out"); |
---|
| 267 | return node; |
---|
| 268 | } |
---|
| 269 | |
---|
| 270 | node = node->next; |
---|
| 271 | } |
---|
| 272 | debug(100, "epgscanlist not found (serviceid=%d, transponderid=%d)", serviceid, transponderid); |
---|
| 273 | return NULL; |
---|
| 274 | } |
---|
| 275 | |
---|
| 276 | void freeepgscanlist() |
---|
| 277 | { |
---|
| 278 | debug(1000, "in"); |
---|
| 279 | struct epgscanlist *node = epgscanlist, *prev = epgscanlist; |
---|
| 280 | |
---|
| 281 | while(node != NULL) |
---|
| 282 | { |
---|
| 283 | prev = node; |
---|
| 284 | node = node->next; |
---|
| 285 | if(prev != NULL) |
---|
| 286 | delepgscanlist(prev->serviceid, prev->transponderid); |
---|
| 287 | } |
---|
| 288 | debug(1000, "out"); |
---|
| 289 | } |
---|
| 290 | |
---|
| 291 | int writeepgscanlist(const char *filename) |
---|
| 292 | { |
---|
| 293 | debug(1000, "in"); |
---|
| 294 | FILE *fd = NULL; |
---|
| 295 | struct epgscanlist *node = epgscanlist; |
---|
[10183] | 296 | int ret = 0; |
---|
[8976] | 297 | |
---|
| 298 | fd = fopen(filename, "w"); |
---|
| 299 | if(fd == NULL) |
---|
| 300 | { |
---|
| 301 | perr("can't open %s", filename); |
---|
| 302 | return 1; |
---|
| 303 | } |
---|
| 304 | |
---|
| 305 | while(node != NULL) |
---|
| 306 | { |
---|
[10183] | 307 | ret = fprintf(fd, "%d#%lu\n", node->serviceid, node->transponderid); |
---|
| 308 | if(ret < 0) |
---|
[8976] | 309 | { |
---|
| 310 | perr("writting file %s", filename); |
---|
| 311 | } |
---|
| 312 | node = node->next; |
---|
| 313 | } |
---|
| 314 | |
---|
| 315 | fclose(fd); |
---|
| 316 | debug(1000, "out"); |
---|
| 317 | return 0; |
---|
| 318 | } |
---|
| 319 | |
---|
| 320 | #endif |
---|