diff -Naur libmythtv/eithelper.cpp libmythtvclone/eithelper.cpp
old
|
new
|
|
78 | 78 | for (uint i = 0; (i < kChunkSize) && (db_events.size() > 0); i++) |
79 | 79 | { |
80 | 80 | DBEventEIT *event = db_events.dequeue(); |
81 | | eitList_lock.unlock(); |
| 81 | // eitList_lock.unlock(); |
82 | 82 | |
83 | 83 | eitfixup->Fix(*event); |
84 | 84 | |
| 85 | LOG(VB_EIT, LOG_INFO, LOC + |
| 86 | QString("\n%1 CHANID::%1<-\n%1 STARTTIME::%2<-\n%1 TITLE::%3<-\n%1 SUBTITLE::%4<-\n%1 DESCRIPTION::%5<-") |
| 87 | .arg(event->chanid).arg(event->starttime.toString()) |
| 88 | .arg(event->title).arg(event->subtitle) |
| 89 | .arg(event->description)); |
| 90 | |
85 | 91 | insertCount += event->UpdateDB(query, 1000); |
86 | 92 | maxStarttime = max (maxStarttime, event->starttime); |
87 | 93 | |
88 | 94 | delete event; |
89 | | eitList_lock.lock(); |
| 95 | // eitList_lock.lock(); |
90 | 96 | } |
91 | 97 | |
92 | 98 | if (!insertCount) |
… |
… |
|
205 | 211 | } |
206 | 212 | |
207 | 213 | // Couldn't find matching EIT. If not yet in unmatched ETT map, insert it. |
208 | | EventIDToETT &elist = unmatched_etts[atsc_key]; |
209 | | if (elist.find(ett->EventID()) == elist.end()) |
210 | | { |
211 | | elist[ett->EventID()] = ett->ExtendedTextMessage() |
212 | | .GetBestMatch(languagePreferences); |
213 | | } |
| 214 | // EventIDToETT &elist = unmatched_etts[atsc_key]; |
| 215 | // if (elist.find(ett->EventID()) == elist.end()) |
| 216 | // { |
| 217 | // elist[ett->EventID()] = ett->ExtendedTextMessage() |
| 218 | // .GetBestMatch(languagePreferences); |
| 219 | // } |
214 | 220 | } |
215 | 221 | |
216 | 222 | static void parse_dvb_event_descriptors(desc_list_t list, uint fix, |
diff -Naur libmythtv/eitscanner.cpp libmythtvclone/eitscanner.cpp
old
|
new
|
|
45 | 45 | |
46 | 46 | void EITScanner::TeardownAll(void) |
47 | 47 | { |
| 48 | QMutexLocker locker(&mutex); |
| 49 | LOG(VB_EIT, LOG_INFO, |
| 50 | LOC_ID + QString("EITScanner::TeardownAll")); |
48 | 51 | StopActiveScan(); |
49 | 52 | if (!exitThread) |
50 | 53 | { |
51 | | lock.lock(); |
| 54 | // lock.lock(); |
52 | 55 | exitThread = true; |
53 | 56 | exitThreadCond.wakeAll(); |
54 | | lock.unlock(); |
| 57 | // lock.unlock(); |
55 | 58 | } |
56 | 59 | eventThread->wait(); |
57 | 60 | delete eventThread; |
… |
… |
|
69 | 72 | */ |
70 | 73 | void EITScanner::run(void) |
71 | 74 | { |
| 75 | QMutexLocker locker(&mutex); |
| 76 | |
72 | 77 | static const uint sz[] = { 2000, 1800, 1600, 1400, 1200, }; |
73 | 78 | static const float rt[] = { 0.0f, 0.2f, 0.4f, 0.6f, 0.8f, }; |
74 | 79 | |
75 | | lock.lock(); |
| 80 | // lock.lock(); |
76 | 81 | |
77 | 82 | MythTimer t; |
78 | 83 | uint eitCount = 0; |
79 | 84 | |
80 | 85 | while (!exitThread) |
81 | 86 | { |
82 | | lock.unlock(); |
| 87 | // lock.unlock(); |
83 | 88 | uint list_size = eitHelper->GetListSize(); |
84 | 89 | |
85 | 90 | float rate = 1.0f; |
… |
… |
|
92 | 97 | } |
93 | 98 | } |
94 | 99 | |
95 | | lock.lock(); |
| 100 | // lock.lock(); |
96 | 101 | if (eitSource) |
97 | 102 | eitSource->SetEITRate(rate); |
98 | | lock.unlock(); |
| 103 | // lock.unlock(); |
99 | 104 | |
100 | 105 | if (list_size) |
101 | 106 | { |
| 107 | LOG(VB_EIT, LOG_INFO, |
| 108 | LOC_ID + QString("BEGIN eitHelper->ProcessEvents")); |
102 | 109 | eitCount += eitHelper->ProcessEvents(); |
103 | 110 | t.start(); |
| 111 | LOG(VB_EIT, LOG_INFO, |
| 112 | LOC_ID + QString("END eitHelper->ProcessEvents")); |
| 113 | t.start(); |
104 | 114 | } |
105 | 115 | |
106 | 116 | // Tell the scheduler to run if |
… |
… |
|
118 | 128 | // Is it time to move to the next transport in active scan? |
119 | 129 | if (activeScan && (MythDate::current() > activeScanNextTrig)) |
120 | 130 | { |
121 | | // if there have been any new events, tell scheduler to run. |
| 131 | LOG(VB_EIT, LOG_INFO, |
| 132 | LOC_ID + QString("activeScan and time to move to the next channel")); |
| 133 | // if there have been any new events, tell scheduler to run. |
122 | 134 | if (eitCount) |
123 | 135 | { |
124 | 136 | LOG(VB_EIT, LOG_INFO, |
… |
… |
|
150 | 162 | |
151 | 163 | // 24 hours ago |
152 | 164 | eitHelper->PruneEITCache(activeScanNextTrig.toTime_t() - 86400); |
| 165 | LOG(VB_EIT, LOG_INFO, |
| 166 | LOC_ID + QString("PruneEITCache DONE ")); |
| 167 | if (activeScanNextChan == activeScanChannels.end()) |
| 168 | { |
| 169 | activeScanNextChan = activeScanChannels.begin(); |
| 170 | activeScanStopped = true; |
| 171 | activeScanCond.wakeAll(); |
| 172 | } |
| 173 | |
153 | 174 | } |
154 | 175 | |
155 | | lock.lock(); |
| 176 | // lock.lock(); |
156 | 177 | if ((activeScan || activeScanStopped) && !exitThread) |
157 | | exitThreadCond.wait(&lock, 400); // sleep up to 400 ms. |
| 178 | exitThreadCond.wait(&mutex, 400); // sleep up to 400 ms. |
158 | 179 | |
159 | 180 | if (!activeScan && !activeScanStopped) |
160 | 181 | { |
| 182 | LOG(VB_EIT, LOG_INFO, |
| 183 | LOC_ID + QString("Not activeScan and not activeScanStopped ")); |
161 | 184 | activeScanStopped = true; |
162 | 185 | activeScanCond.wakeAll(); |
163 | 186 | } |
164 | | } |
| 187 | } // End while |
| 188 | LOG(VB_EIT, LOG_INFO, LOC_ID + |
| 189 | QString("Exiting while not exitThread loop - channel %1" |
| 190 | " activeScanNextTrig 2").arg(*activeScanNextChan)); |
165 | 191 | |
166 | 192 | if (eitCount) /* some events have been handled since the last schedule request */ |
167 | 193 | { |
… |
… |
|
171 | 197 | |
172 | 198 | activeScanStopped = true; |
173 | 199 | activeScanCond.wakeAll(); |
174 | | lock.unlock(); |
| 200 | // lock.unlock(); |
175 | 201 | } |
176 | 202 | |
177 | 203 | /** \fn EITScanner::RescheduleRecordings(void) |
… |
… |
|
192 | 218 | void EITScanner::StartPassiveScan(ChannelBase *_channel, |
193 | 219 | EITSource *_eitSource) |
194 | 220 | { |
195 | | QMutexLocker locker(&lock); |
| 221 | QMutexLocker locker(&mutex); |
196 | 222 | |
197 | 223 | eitSource = _eitSource; |
198 | 224 | channel = _channel; |
… |
… |
|
210 | 236 | */ |
211 | 237 | void EITScanner::StopPassiveScan(void) |
212 | 238 | { |
213 | | QMutexLocker locker(&lock); |
| 239 | QMutexLocker locker(&mutex); |
214 | 240 | |
215 | 241 | if (eitSource) |
216 | 242 | { |
… |
… |
|
227 | 253 | void EITScanner::StartActiveScan(TVRec *_rec, uint max_seconds_per_source) |
228 | 254 | { |
229 | 255 | rec = _rec; |
| 256 | uint i, randomStart; |
230 | 257 | |
231 | 258 | if (activeScanChannels.isEmpty()) |
232 | 259 | { |
233 | 260 | // TODO get input name and use it in crawl. |
| 261 | // Place channels with earliest "latest starttime" first in list |
234 | 262 | MSqlQuery query(MSqlQuery::InitCon()); |
235 | 263 | query.prepare( |
236 | | "SELECT channum, MIN(chanid) " |
237 | | "FROM channel, cardinput, capturecard, videosource " |
| 264 | "SELECT channum, channel.chanid " |
| 265 | "FROM cardinput, capturecard, videosource, channel LEFT JOIN program " |
| 266 | "ON channel.chanid = program.chanid " |
238 | 267 | "WHERE cardinput.sourceid = channel.sourceid AND " |
239 | 268 | " videosource.sourceid = channel.sourceid AND " |
240 | 269 | " capturecard.cardid = cardinput.cardid AND " |
… |
… |
|
244 | 273 | " channum != '' AND " |
245 | 274 | " cardinput.cardid = :CARDID " |
246 | 275 | "GROUP BY mplexid " |
247 | | "ORDER BY cardinput.sourceid, mplexid, " |
248 | | " atsc_major_chan, atsc_minor_chan "); |
| 276 | "ORDER BY MAX(starttime) "); |
| 277 | |
249 | 278 | query.bindValue(":CARDID", rec->GetCaptureCardNum()); |
250 | 279 | |
251 | 280 | if (!query.exec() || !query.isActive()) |
… |
… |
|
261 | 290 | } |
262 | 291 | |
263 | 292 | LOG(VB_EIT, LOG_INFO, LOC_ID + |
264 | | QString("StartActiveScan called with %1 multiplexes") |
265 | | .arg(activeScanChannels.size())); |
| 293 | QString("StartActiveScan called with %1 multiplexes %2") |
| 294 | .arg(activeScanChannels.size()).arg(activeScanChannels.join(","))); |
266 | 295 | |
267 | 296 | // Start at a random channel. This is so that multiple cards with |
268 | 297 | // the same source don't all scan the same channels in the same |
269 | 298 | // order when the backend is first started up. |
270 | 299 | if (activeScanChannels.size()) |
271 | 300 | { |
272 | | uint randomStart = random() % activeScanChannels.size(); |
273 | | activeScanNextChan = activeScanChannels.begin()+randomStart; |
| 301 | srandom(time(0)); |
| 302 | // If more than 5 channels, only randomize the first five |
| 303 | if (activeScanChannels.size() > 4){ |
| 304 | // randomstart one more than number in "if" |
| 305 | randomStart = 5; |
| 306 | } |
| 307 | else{ |
| 308 | randomStart = activeScanChannels.size(); |
| 309 | } |
| 310 | for (i=0;i<randomStart;i++) |
| 311 | { |
| 312 | activeScanChannels.swap(i,random() % randomStart); |
| 313 | LOG(VB_EIT, LOG_DEBUG, LOC_ID + |
| 314 | QString("StartActiveScan swap with %1 multiplexes %2") |
| 315 | .arg(activeScanChannels.size()) |
| 316 | .arg(activeScanChannels.join(","))); |
| 317 | } |
| 318 | activeScanChannels.swap(activeScanChannels.size() -1 - random() % randomStart, activeScanChannels.size() - 1); |
| 319 | activeScanNextChan = activeScanChannels.begin(); |
274 | 320 | |
275 | 321 | activeScanNextTrig = MythDate::current(); |
276 | 322 | activeScanTrigTime = max_seconds_per_source; |
… |
… |
|
280 | 326 | activeScanStopped = false; |
281 | 327 | activeScan = true; |
282 | 328 | } |
| 329 | LOG(VB_EIT, LOG_INFO, LOC_ID + |
| 330 | QString("StartActiveScan random with %1 multiplexes %2") |
| 331 | .arg(activeScanChannels.size()).arg(activeScanChannels.join(","))); |
283 | 332 | } |
284 | 333 | |
285 | 334 | void EITScanner::StopActiveScan(void) |
286 | 335 | { |
287 | | QMutexLocker locker(&lock); |
| 336 | LOG(VB_EIT, LOG_INFO, LOC_ID + |
| 337 | QString("EITScanner::StopActiveScan")); |
| 338 | QMutexLocker locker(&mutex); |
288 | 339 | |
289 | 340 | activeScanStopped = false; |
290 | 341 | activeScan = false; |
… |
… |
|
295 | 346 | locker.relock(); |
296 | 347 | |
297 | 348 | while (!activeScan && !activeScanStopped) |
298 | | activeScanCond.wait(&lock, 100); |
| 349 | activeScanCond.wait(&mutex, 100); |
299 | 350 | |
300 | 351 | rec = NULL; |
301 | 352 | } |
diff -Naur libmythtv/eitscanner.h libmythtvclone/eitscanner.h
old
|
new
|
|
7 | 7 | #include <QStringList> |
8 | 8 | #include <QDateTime> |
9 | 9 | #include <QRunnable> |
10 | | #include <QMutex> |
| 10 | // #include <QMutex> |
| 11 | #include <QMutexLocker> |
11 | 12 | |
12 | 13 | class TVRec; |
13 | 14 | class MThread; |
… |
… |
|
48 | 49 | static void *SpawnEventLoop(void*); |
49 | 50 | void RescheduleRecordings(void); |
50 | 51 | |
51 | | QMutex lock; |
| 52 | // QMutex lock; |
| 53 | mutable QMutex mutex; |
52 | 54 | ChannelBase *channel; |
53 | 55 | EITSource *eitSource; |
54 | 56 | |
diff -Naur libmythtv/mpeg/atscstreamdata.cpp libmythtvclone/mpeg/atscstreamdata.cpp
old
|
new
|
|
305 | 305 | } |
306 | 306 | case TableID::ETT: |
307 | 307 | { |
| 308 | QMutexLocker locker(&_listener_lock); |
308 | 309 | ExtendedTextTable ett(psip); |
309 | 310 | |
310 | | QMutexLocker locker(&_listener_lock); |
311 | 311 | for (uint i = 0; i < _atsc_eit_listeners.size(); i++) |
312 | 312 | _atsc_eit_listeners[i]->HandleETT(pid, &ett); |
313 | 313 | |
diff -Naur libmythtv/programdata.cpp libmythtvclone/programdata.cpp
old
|
new
|
|
218 | 218 | int i = -1; |
219 | 219 | |
220 | 220 | if (!count) |
| 221 | { |
| 222 | LOG(VB_EIT, LOG_DEBUG,QString("GetOverlappingPrograms returned zero.")); |
221 | 223 | return InsertDB(query, chanid); |
222 | | |
| 224 | } |
223 | 225 | // move overlapping programs out of the way and update existing if possible |
224 | 226 | match = GetMatch(programs, i); |
225 | 227 | |
… |
… |
|
489 | 491 | if (match.subtitle.length() >= lsubtitle.length()) |
490 | 492 | lsubtitle = match.subtitle; |
491 | 493 | |
492 | | if (match.description.length() >= ldesc.length()) |
493 | | ldesc = match.description; |
| 494 | // if (match.description.length() >= ldesc.length()) |
| 495 | // if (match.description.length() >= 2) |
| 496 | // ldesc = match.description; |
494 | 497 | |
495 | 498 | if (lcategory.isEmpty() && !match.category.isEmpty()) |
496 | 499 | lcategory = match.category; |
… |
… |
|
534 | 537 | query.prepare( |
535 | 538 | "UPDATE program " |
536 | 539 | "SET title = :TITLE, subtitle = :SUBTITLE, " |
537 | | " description = :DESC, " |
| 540 | " description = :DESCR, " |
538 | 541 | " category = :CATEGORY, category_type = :CATTYPE, " |
539 | 542 | " starttime = :STARTTIME, endtime = :ENDTIME, " |
540 | 543 | " closecaptioned = :CC, subtitled = :HASSUBTITLES, " |
… |
… |
|
554 | 557 | query.bindValue(":OLDSTART", match.starttime); |
555 | 558 | query.bindValue(":TITLE", denullify(ltitle)); |
556 | 559 | query.bindValue(":SUBTITLE", denullify(lsubtitle)); |
557 | | query.bindValue(":DESC", denullify(ldesc)); |
| 560 | query.bindValue(":DESCR", denullify(ldesc)); |
558 | 561 | query.bindValue(":CATEGORY", denullify(lcategory)); |
559 | 562 | query.bindValue(":CATTYPE", lcattype); |
560 | 563 | query.bindValue(":STARTTIME", starttime); |
… |
… |
|
1235 | 1238 | " endtime = :END AND " |
1236 | 1239 | " title = :TITLE AND " |
1237 | 1240 | " subtitle = :SUBTITLE AND " |
1238 | | " description = :DESC AND " |
| 1241 | " description = :DESCR AND " |
1239 | 1242 | " category = :CATEGORY AND " |
1240 | 1243 | " category_type = :CATEGORY_TYPE AND " |
1241 | 1244 | " airdate = :AIRDATE AND " |
… |
… |
|
1261 | 1264 | query.bindValue(":END", pi.endtime); |
1262 | 1265 | query.bindValue(":TITLE", denullify(pi.title)); |
1263 | 1266 | query.bindValue(":SUBTITLE", denullify(pi.subtitle)); |
1264 | | query.bindValue(":DESC", denullify(pi.description)); |
| 1267 | query.bindValue(":DESCR", denullify(pi.description)); |
1265 | 1268 | query.bindValue(":CATEGORY", denullify(pi.category)); |
1266 | 1269 | query.bindValue(":CATEGORY_TYPE", cattype); |
1267 | 1270 | query.bindValue(":AIRDATE", pi.airdate); |
diff -Naur libmythtv/tv_rec.cpp libmythtvclone/tv_rec.cpp
old
|
new
|
|
1267 | 1267 | scanner = new EITScanner(cardid); |
1268 | 1268 | eitScanStartTime = eitScanStartTime.addSecs( |
1269 | 1269 | eitCrawlIdleStart + eit_start_rand(cardid, eitTransportTimeout)); |
| 1270 | LOG(VB_GENERAL, LOG_INFO, LOC + "Adjusted Scan start " + eitScanStartTime.toString()); |
1270 | 1271 | } |
1271 | 1272 | else |
| 1273 | { |
1272 | 1274 | eitScanStartTime = eitScanStartTime.addYears(1); |
| 1275 | LOG(VB_GENERAL, LOG_INFO, LOC + "EIT scan DISABLED " + eitScanStartTime.toString()); |
| 1276 | } |
1273 | 1277 | |
1274 | 1278 | while (HasFlags(kFlagRunMainLoop)) |
1275 | 1279 | { |
… |
… |
|
1416 | 1420 | } |
1417 | 1421 | else |
1418 | 1422 | { |
| 1423 | LOG(VB_GENERAL, LOG_INFO, LOC + QString("StartActiveScan eitTransportTimeout is %1 ") |
| 1424 | .arg(eitTransportTimeout)); |
1419 | 1425 | scanner->StartActiveScan(this, eitTransportTimeout); |
1420 | 1426 | SetFlags(kFlagEITScannerRunning); |
1421 | | eitScanStartTime = MythDate::current().addYears(1); |
| 1427 | eitScanStartTime = MythDate::current().addSecs(8192); |
| 1428 | //eitScanStartTime = MythDate::current().addYears(1); |
1422 | 1429 | } |
1423 | 1430 | } |
1424 | 1431 | |
… |
… |
|
3932 | 3939 | ClearFlags(kFlagNeedToStartRecorder); |
3933 | 3940 | newRecStatus = rsFailed; |
3934 | 3941 | |
3935 | | if (scanner && HasFlags(kFlagEITScannerRunning)) |
3936 | | { |
3937 | | scanner->StopActiveScan(); |
3938 | | ClearFlags(kFlagEITScannerRunning); |
3939 | | eitScanStartTime = MythDate::current(); |
3940 | | eitScanStartTime = eitScanStartTime.addSecs(eitCrawlIdleStart + |
3941 | | eit_start_rand(cardid, eitTransportTimeout)); |
3942 | | } |
| 3942 | return NULL; |
| 3943 | // if (scanner && HasFlags(kFlagEITScannerRunning)) |
| 3944 | // { |
| 3945 | // scanner->StopActiveScan(); |
| 3946 | // ClearFlags(kFlagEITScannerRunning); |
| 3947 | // eitScanStartTime = MythDate::current(); |
| 3948 | // eitScanStartTime = eitScanStartTime.addSecs(eitCrawlIdleStart + |
| 3949 | // eit_start_rand(cardid, eitTransportTimeout)); |
| 3950 | // } |
3943 | 3951 | } |
3944 | 3952 | else |
3945 | 3953 | { |