Refactor the findings to hide the list and merge on timestamp

Realigned results to video frames

Author: Beirdo

mythtv/programs/mythgpucommflag/audioconsumer.cpp

@@ -27,6 +27,13 @@ AudioConsumer::AudioConsumer(PacketQueue *inQ, ResultsMap *outMap,
 
     m_context = avcodec_alloc_context();
 }
+    
+AudioConsumer::~AudioConsumer()
+{
+    av_free(m_audioSamples);
+    if (m_dev)
+        delete m_dev;
+};
 
 void AudioConsumer::ProcessPacket(Packet *packet)
 {
@@ -137,19 +144,19 @@ void AudioConsumer::ProcessFrame(int16_t *samples, int size, int frames,
         AudioProcessor *proc = *it;
 
         // Run the routine in GPU/CPU & pull results
-        FlagResults *result = proc->m_func(m_dev, samples, size, frames, pts,
-                                           rate);
+        FlagFindings *findings = proc->m_func(m_dev, samples, size, frames, pts,
+                                              rate);
 
         // Toss the results onto the results list
-        if (result)
+        if (findings)
         {
             static const AVRational realTimeBase = { 1, 1000 };
             LOG(VB_GENERAL, LOG_INFO, "Audio Finding found");
             pts = av_rescale_q(pts, realTimeBase, m_timebase);
-            result->m_timestamp = NormalizeTimecode(pts);;
-            result->m_duration = duration;
-            LOG(VB_GENERAL, LOG_INFO, result->toString());
-            m_outMap->insertMulti(result->m_timestamp, result);
+            int64_t timestamp = NormalizeTimecode(pts);
+            FlagResults *result = FlagResults::Create(m_outMap, timestamp);
+            findings->SetTiming(timestamp, duration, duration, 0);
+            result->append(findings);
         }
     }
 

mythtv/programs/mythgpucommflag/audioconsumer.h

@@ -12,7 +12,7 @@ class AudioConsumer : public QueueConsumer
 {
   public:
     AudioConsumer(PacketQueue *inQ, ResultsMap *outMap, OpenCLDevice *dev);
-    ~AudioConsumer() { av_free(m_audioSamples); };
+    ~AudioConsumer();
     bool Initialize(void) { return true; };
     void ProcessPacket(Packet *packet);
     void ProcessFrame(int16_t *samples, int size, int frames, int64_t pts,

mythtv/programs/mythgpucommflag/audioprocessor.h

@@ -7,8 +7,8 @@
 #include "openclinterface.h"
 #include "flagresults.h"
 
-typedef FlagResults *(*AudioProcessorFunc)(OpenCLDevice *, int16_t *, int, int,
-                                           int64_t, int);
+typedef FlagFindings *(*AudioProcessorFunc)(OpenCLDevice *, int16_t *, int, int,
+                                            int64_t, int);
 
 typedef struct {
     QString name;

mythtv/programs/mythgpucommflag/flagresults.cpp

@@ -5,6 +5,10 @@
 #include "flagresults.h"
 #include "mythlogging.h"
 
+#ifndef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
+
 FlagFindingsMap findingsMap;
 
 void findingsAdd(int value, QString description);
@@ -29,40 +33,77 @@ QString FlagFindings::toString(void)
     if (findingsMap.contains((int)m_type))
         finding = findingsMap.value((int)m_type);
 
-    QString str = QString("%1: %2").arg(finding).arg(m_value);
+    QString str =
+        QString("Findings: Frame: %1, Offset: %2.%3, Duration: %4.%5\n")
+        .arg(m_timestamp)
+        .arg(m_offset / 1000000)
+        .arg((int)(m_offset % 1000000), 6, 10, QChar('0'))
+        .arg(m_duration / 1000000)
+        .arg((int)(m_duration % 1000000), 6, 10, QChar('0'));
+
+    str += QString("    %1: %2").arg(finding).arg(m_value);
     return str;
 }
 
-QString FlagResults::toString(void)
+QString FlagFindings::toGnuplot(void)
 {
-    FlagFindingsList::iterator it;
+    int64_t timestamp = m_timestamp * m_frameDuration + m_offset;
+    QString str = QString("%1 %2 %3") .arg((double)(timestamp) / 1000000.0)
+            .arg((double)(timestamp + m_duration - 1) / 1000000.0)
+            .arg(m_type + 1);
+    return str;
+}
 
-    QString str = QString("Findings at PTS: %1, Duration: %2\n")
-        .arg(m_timestamp) .arg(m_duration);
+void FlagFindings::SetTiming(int64_t timestamp, int duration, int frameDuration,
+                             int offset)
+{
+    m_timestamp = timestamp;
+    m_duration = duration;
+    m_frameDuration = frameDuration;
+    m_offset = offset;
+}
 
-    for (it = m_findings->begin(); it != m_findings->end(); ++it)
+QString FlagResults::toString(void)
+{
+    FlagResults::iterator it;
+    QString str("");
+
+    for (it = begin(); it != end(); ++it)
     {
         FlagFindings *finding = *it;
-        str += QString("    %1\n").arg(finding->toString());
+        str += QString("%1\n").arg(finding->toString());
     }
     str += QString("\n");
     return str;
 }
 
 QString FlagResults::toGnuplot(void)
 {
-    FlagFindingsList::iterator it;
+    FlagResults::iterator it;
     QString str("");
 
-    for (it = m_findings->begin(); it != m_findings->end(); ++it)
+    for (it = begin(); it != end(); ++it)
     {
         FlagFindings *finding = *it;
-        str += QString("%1 %2 %3\n") .arg(m_timestamp)
-            .arg(m_timestamp + m_duration - 1) .arg(finding->m_type + 1);
+        str += QString("%1\n") .arg(finding->toGnuplot());
     }
     return str;
 }
 
+FlagResults *FlagResults::Create(ResultsMap *map, int64_t timestamp)
+{
+    FlagResults *results;
+    if (map->contains(timestamp))
+        results = map->value(timestamp);
+    else
+    {
+        results = new FlagResults;
+        map->insertMulti(timestamp, results);
+    }
+
+    return results;
+}
+
 QString ResultsMap::toString(QString title)
 {
     ResultsMap::iterator it;
@@ -88,6 +129,63 @@ QString ResultsMap::toGnuplot(void)
     }
     return str;
 }
+
+ResultsMap *ResultsMap::Compress(int frameDuration)
+{
+    if (frameDuration == 0)
+        return NULL;
+
+    ResultsMap *newMap = new ResultsMap;
+    ResultsMap::iterator it;
+    for (it = begin(); it != end(); ++it)
+    {
+        FlagResults *oldResults = it.value();
+        FlagResults::iterator it2 = oldResults->begin();
+        if (it2 == oldResults->end())
+            continue;
+
+        FlagFindings *oldFinding = *it2;
+
+        int remainDuration = oldFinding->m_duration;
+        int64_t timestamp = oldFinding->m_timestamp / frameDuration;
+        int offset = oldFinding->m_timestamp - (timestamp * frameDuration);
+        int duration = MIN(remainDuration, frameDuration - offset);
+
+        do {
+            for (it2 = oldResults->begin(); it2 != oldResults->end(); ++it2)
+            {
+                FlagResults *results = FlagResults::Create(newMap, timestamp);
+                oldFinding = *it2;
+
+                FlagFindings *finding = new FlagFindings(oldFinding);
+                finding->SetTiming(timestamp, duration, frameDuration, offset);
+                results->append(finding);
+            }
+
+            remainDuration -= duration;
+            duration = MIN(frameDuration, remainDuration);
+            offset = 0;
+            timestamp++;
+        } while (remainDuration);
+    }
+    return newMap;
+}
+
+int64_t ResultsMap::GetDuration(void)
+{
+    ResultsMap::iterator it = begin();
+    if (it == end())
+        return 0;
+
+    FlagResults *results = it.value();
+    FlagResults::iterator it2 = results->begin();
+    if (it2 == results->end())
+        return 0;
+
+    FlagFindings *finding = *it2;
+    return finding->m_frameDuration;
+}
+
 /*
  * vim:ts=4:sw=4:ai:et:si:sts=4
  */

mythtv/programs/mythgpucommflag/flagresults.h

@@ -14,40 +14,43 @@ class FlagFindings
 {
   public:
     FlagFindings(int type, int64_t value) : m_type(type), m_value(value) {};
+    FlagFindings(FlagFindings *other) : m_type(other->m_type),
+        m_value(other->m_value), m_offset(other->m_offset) {};
     ~FlagFindings() {};
     QString toString(void);
+    QString toGnuplot(void);
+    void SetTiming(int64_t timestamp, int duration, int frameDuration,
+                   int offset = 0);
 
-    int m_type;
+    int     m_type;
     int64_t m_value;
-};
 
-typedef QList<FlagFindings *> FlagFindingsList;
+    int64_t m_timestamp;
+    int     m_duration;
+    int     m_frameDuration;
+    int     m_offset;       // Offset within video frame
+};
 
-class FlagResults
+class ResultsMap;
+class FlagResults : public QList<FlagFindings *>
 {
   public:
-    FlagResults(AVPacket *pkt, FlagFindingsList *list) : m_findings(list)
-    {
-        m_valid = (pkt != NULL);
-    }
+    FlagResults() {};
+    ~FlagResults() {};
+
+    static FlagResults *Create(ResultsMap *map, int64_t timestamp);
 
-    FlagResults(FlagFindingsList *list) : m_findings(list) {};
-    ~FlagResults() { delete m_findings; };
     QString toString(void);
     QString toGnuplot(void);
-
-    bool    m_valid;
-    int64_t m_timestamp;
-    int     m_duration;
-
-    FlagFindingsList *m_findings;
 };
 
 class ResultsMap : public QMap<int64_t, FlagResults *>
 {
   public:
     QString toString(QString title);
     QString toGnuplot(void);
+    ResultsMap *Compress(int frameDuration);
+    int64_t GetDuration(void);
 };
 
 typedef QMap<int, QString> FlagFindingsMap;

mythtv/programs/mythgpucommflag/main.cpp

@@ -114,10 +114,6 @@ static bool DoesFileExist(ProgramInfo *program_info)
 
 int main(int argc, char **argv)
 {
-#if 0
-    setenv("__GL_NO_DSO_FINALIZER", "1", true);
-#endif
-
     // Parse commandline
     if (!cmdline.Parse(argc, argv))
     {
@@ -345,21 +341,20 @@ int main(int argc, char **argv)
     delete ctx;
     delete audioThread;
     delete videoThread;
-    delete devices[0];
-    delete devices[1];
 
     LOG(VB_GENERAL, LOG_INFO, QString("audioMarks: %1, videoMarks: %2")
         .arg(audioMarks.size()) .arg(videoMarks.size()));
 
     // Combine results maps into one map
-    ResultsMap findings(audioMarks);
-    findings.unite(videoMarks);
+    ResultsMap mergedMarks(audioMarks);
+    mergedMarks.unite(videoMarks);
+    ResultsMap *findings = mergedMarks.Compress(videoMarks.GetDuration());
 
     // Dump results to an output file
     QString audioDump = audioMarks.toString("Audio markings");
     QString videoDump = videoMarks.toString("Video markings");
-    QString mergedDump = findings.toString("Merged markings");
-    QString mergedPlot = findings.toGnuplot();
+    QString mergedDump = findings->toString("Merged markings");
+    QString mergedPlot = findings->toGnuplot();
 
     QFile dump("out/results");
     dump.open(QIODevice::WriteOnly);
@@ -383,9 +378,7 @@ int main(int argc, char **argv)
 
     // Send map to the db
 
-#if 0
-    unsetenv("__GL_NO_DSO_FINALIZER");
-#endif
+    delete findings;
     return(GENERIC_EXIT_OK);
 }
 

mythtv/programs/mythgpucommflag/openclaudioprocessor.cpp

@@ -13,8 +13,8 @@
 
 // Prototypes
 void OpenCLVolumeLevelCleanup(cl_mem **bufs);
-FlagResults *OpenCLVolumeLevel(OpenCLDevice *dev, int16_t *samples, int size,
-                               int count, int64_t pts, int rate);
+FlagFindings *OpenCLVolumeLevel(OpenCLDevice *dev, int16_t *samples, int size,
+                                int count, int64_t pts, int rate);
 
 AudioProcessorList *openCLAudioProcessorList;
 
@@ -32,8 +32,8 @@ void InitOpenCLAudioProcessors(void)
 
 #define KERNEL_VOLUME_CL "audioVolumeLevel.cl"
 #define KERNEL_VOLUME_64_CL "audioVolumeLevel64.cl"
-FlagResults *OpenCLVolumeLevel(OpenCLDevice *dev, int16_t *samples, int size,
-                               int count, int64_t pts, int rate)
+FlagFindings *OpenCLVolumeLevel(OpenCLDevice *dev, int16_t *samples, int size,
+                                int count, int64_t pts, int rate)
 {
     LOG(VB_GPUAUDIO, LOG_INFO, "OpenCL Volume Level");
 
@@ -306,21 +306,14 @@ FlagResults *OpenCLVolumeLevel(OpenCLDevice *dev, int16_t *samples, int size,
         .arg(intStats[2]) .arg(intStats[3]));
 #endif
 
-    FlagFindings *finding = NULL;
+    FlagFindings *findings = NULL;
 
     if (deltaRMSdB >= 6.0)
-        finding = new FlagFindings(kFindingAudioHigh, true);
+        findings = new FlagFindings(kFindingAudioHigh, true);
     else if (deltaRMSdB <= -12.0)
-        finding = new FlagFindings(kFindingAudioLow, true);
+        findings = new FlagFindings(kFindingAudioLow, true);
 
-    if (!finding)
-        return NULL;
-
-    FlagFindingsList *findings = new FlagFindingsList();
-    findings->append(finding);
-    FlagResults *results = new FlagResults(findings);
-
-    return results;
+    return findings;
 }