Ticket #4733: eitcrash.diff

libs/libmythtv/eitscanner.h

@@ -2 +2 @@
 #ifndef EITSCANNER_H
 #define EITSCANNER_H
 
-// C includes
-#include <pthread.h>
-
 // Qt includes
 #include <qmutex.h>
 #include <qobject.h>
 #include <qdatetime.h>
 #include <qstringlist.h>
 #include <qwaitcondition.h>
+#include <qthread.h>
 
 class TVRec;
 class ChannelBase;
@@ -27 +25 @@
     virtual void SetEITRate(float rate) = 0;
 };
 
+class EITScanner;
+
+class EITThread : public QThread
+{
+  public:
+    virtual void run();
+    EITScanner   *scanner;
+};
+
 class EITScanner
 {
+  friend class EITThread;
+
   public:
     EITScanner(uint cardnum);
     ~EITScanner() { TeardownAll(); }
@@ -39 +48 @@
     void StartActiveScan(TVRec*, uint max_seconds_per_source,
                          bool ignore_source);
 
-    void StopActiveScan(void);        
+    void StopActiveScan(void);
 
+  protected:
+    void RunEventLoop(void);
+
   private:
     void TeardownAll(void);
-    void RunEventLoop(void);
     static void *SpawnEventLoop(void*);
     static void RescheduleRecordings(void);
 
@@ -52 +63 @@
     EITSource       *eitSource;
 
     EITHelper       *eitHelper;
-    pthread_t        eventThread;
+    EITThread        eventThread;
     bool             exitThread;
     QWaitCondition   exitThreadCond;
 

libs/libmythtv/tv_rec.cpp

@@ -259 +259 @@
     overRecordSecCat  = gContext->GetNumSetting("CategoryOverTime") * 60;
     overRecordCategory= gContext->GetSetting("OverTimeCategory");
 
-    pthread_create(&event_thread, NULL, EventThread, this);
+    tvthread.thetv = this;
+    tvthread.start();
 
     WaitForEventThreadSleep();
 
@@ -288 +289 @@
     if (HasFlags(kFlagRunMainLoop))
     {
         ClearFlags(kFlagRunMainLoop);
-        pthread_join(event_thread, NULL);
+        tvthread.wait();
     }
 
     TeardownSignalMonitor();
@@ -1088 +1089 @@
         gContext->dispatch(me);
 
         recorder->StopRecording();
-        pthread_join(recorder_thread, NULL);
+        recthread.wait();
     }
     ClearFlags(kFlagRecorderRunning);
 
@@ -1239 +1240 @@
 #endif // USING_V4L
 }
 
-/** \fn TVRec::EventThread(void*)
- *  \brief Thunk that allows event pthread to call RunTV().
+/** \fn TVThread::run(void)
+ *  \brief Thunk that allows event Qthread to call RunTV().
  */
-void *TVRec::EventThread(void *param)
+void TVThread::run(void)
 {
-    TVRec *thetv = (TVRec *)param;
     thetv->RunTV();
-    return NULL;
 }
 
-/** \fn TVRec::RecorderThread(void*)
- *  \brief Thunk that allows recorder pthread to
+/** \fn RECThread::run(void)
+ *  \brief Thunk that allows recorder Qthread to
  *         call RecorderBase::StartRecording().
  */
-void *TVRec::RecorderThread(void *param)
+void RECThread::run(void)
 {
-    RecorderBase *recorder = (RecorderBase *)param;
     recorder->StartRecording();
-    return NULL;
 }
 
 bool get_use_eit(uint cardid)
@@ -4003 +4000 @@
     }
 #endif
 
-    pthread_create(&recorder_thread, NULL, TVRec::RecorderThread, recorder);
+    recthread.recorder = recorder;
+    recthread.start();
 
     // Wait for recorder to start.
     stateChangeLock.unlock();

libs/libmythtv/eitscanner.cpp

@@ -36 +36 @@
     QStringList langPref = iso639_get_language_list();
     eitHelper->SetLanguagePreferences(langPref);
 
-    pthread_create(&eventThread, NULL, SpawnEventLoop, this);
+    // Start scanner with Idle scheduling priority, to avoid problems with recordings.
+    eventThread.scanner = this;
+    eventThread.start(QThread::IdlePriority);
 }
 
 void EITScanner::TeardownAll(void)
@@ -46 +48 @@
     {
         exitThread = true;
         exitThreadCond.wakeAll();
-        pthread_join(eventThread, NULL);
+        eventThread.wait();
     }
 
     if (eitHelper)
@@ -56 +58 @@
     }
 }
 
-/** \fn EITScanner::SpawnEventLoop(void*)
- *  \brief Thunk that allows scanner_thread pthread to
+/** \fn EITThread::run(void)
+ *  \brief Thunk that allows scanner Qthread to
  *         call EITScanner::RunScanner().
  */
-void *EITScanner::SpawnEventLoop(void *param)
+void EITThread::run(void)
 {
-    // Lower scheduling priority, to avoid problems with recordings.
-    if (setpriority(PRIO_PROCESS, 0, 19))
-        VERBOSE(VB_IMPORTANT, LOC + "Setting priority failed." + ENO);
-    EITScanner *scanner = (EITScanner*) param;
     scanner->RunEventLoop();
-    return NULL;
 }
 
 /** \fn EITScanner::RunEventLoop()

libs/libmythtv/tv_rec.h

@@ -2 +2 @@
 #define TVREC_H
 
 #include <qstring.h>
-#include <pthread.h>
+#include <qthread.h>
 #include <qdatetime.h>
 #include <qvaluelist.h>
 #include <qptrlist.h>
@@ -149 +149 @@
 };
 typedef QMap<uint,PendingInfo> PendingMap;
 
+class RECThread : public QThread
+{
+  public:
+    virtual void run();
+    RecorderBase *recorder;
+};
+
+class MPUBLIC TVRec;
+
+class TVThread : public QThread
+{
+  public:
+    virtual void run();
+    TVRec        *thetv;
+};
+
 class MPUBLIC TVRec : public QObject
 {
     friend class TuningRequest;
+    friend class TVThread;
     Q_OBJECT
   public:
     TVRec(int capturecardnum);
@@ -332 +349 @@
     SignalMonitor    *signalMonitor;
     EITScanner       *scanner;
 
-    // Various threads
-    /// Event processing thread, runs RunTV().
-    pthread_t event_thread;
-    /// Recorder thread, runs RecorderBase::StartRecording()
-    pthread_t recorder_thread;
-
     // Configuration variables from database
     bool    eitIgnoresSource;
     bool    transcodeFirst;
@@ -400 +411 @@
     static QMutex            cardsLock;
     static QMap<uint,TVRec*> cards;
 
+    // Various threads
+    /// Recorder thread, runs RecorderBase::StartRecording()
+    RECThread    recthread;
+
+    /// Event processing thread, runs RunTV().
+    TVThread     tvthread;
+
   public:
     static const uint kSignalMonitoringRate;
 

libs/libmythtv/mpeg/pespacket.cpp

@@ -48 +48 @@
 
     if (ccExp == cc)
     {
-        if (_pesdataSize + payloadSize >= _allocSize)
+        uint sz = _allocSize;
+
+        while (_pesdataSize + payloadSize >= sz)
         {
-            uint sz = (((_allocSize * 2) + 4095) / 4096) * 4096;
+            if (sz > 0)
+            {
+                sz = (((sz * 2) + 4095) / 4096) * 4096;
+            }
+            else
+            {
+                sz = 4096;
+            }
+        }
+
+        if (sz != _allocSize)
+        {
             unsigned char *nbuf = pes_alloc(sz);
+
+            if (!nbuf)
+            {
+                return true;
+            }
+
             memcpy(nbuf, _fullbuffer, _pesdataSize);
             pes_free(_fullbuffer);
             _fullbuffer = nbuf;