mp4demux count function ref fixed

Signed-off-by: ryadav698 <[email protected]>

Author: rajat698

test/gstTestHarness/rialto-api-test.cpp

@@ -5,6 +5,9 @@
 #include <cstring>
 #include <memory>
 #include <vector>
+#include <mutex>
+#include <queue>
+#include <condition_variable>
 #include "mp4demux.hpp"
 #include "rialto-gst-pipeline.h"
 
@@ -20,6 +23,21 @@ static int32_t sourceIdVideo;
 
 using namespace firebolt::rialto; 
 
+uint32_t WaitForNeedDataRequest(int32_t sourceId, int timeoutMs = 5000)
+{
+    std::unique_lock<std::mutex> lock(g_needDataMutex);
+    if (!g_needDataCv.wait_for(lock, std::chrono::milliseconds(timeoutMs), [sourceId]{
+        return !g_needDataQueue.empty() && g_needDataQueue.front().sourceId == sourceId;
+    }))
+    {
+        return UINT32_MAX;
+    }
+
+    uint32_t requestId = g_needDataQueue.front().requestId;
+    g_needDataQueue.pop();
+    return requestId;
+}
+
 void LoadAndDemuxSegment(Mp4Demux &mp4Demux, const char *path)
 {
     char fullpath[512];
@@ -86,15 +104,13 @@ void ConfigureAudio()
     // const char *codec_ptr = trackAudio.codec_data.c_str();
     // codecData.data = std::vector<uint8_t>( codec_ptr, &codec_ptr[trackAudio.codec_data.size()] );
 
-    std::unique_ptr<IMediaPipeline::MediaSourceAudio> sourceAudio =
-    std::make_unique<IMediaPipeline::MediaSourceAudio>(
-                        mimeType,
-                        hasDrm,
-                        alignment,
-                        streamFormat,
-                        trackAudio.audio.rate, 
-                        trackAudio.audio.channels,
-                        std::make_shared<CodecData>(codecData) );
+   std::unique_ptr<IMediaPipeline::MediaSourceAudio> sourceAudio = std::make_unique<IMediaPipeline::MediaSourceAudio>(
+																					   mimeType,
+																					   hasDrm,
+																					   audioConfig,
+																					   SegmentAlignment::UNDEFINED,
+																					   streamFormat,
+																					   nullptr /* codecData*/ );
 
     gstMediaPipeline->attachSource( std::move(sourceAudio), sourceIdAudio );
 }
@@ -146,12 +162,13 @@ void ConfigureComplete()
     gstMediaPipeline->allSourcesAttached();
 }
 
-void InjectAudio()
+void InjectAudio(int32_t needDataId)
 {
     LoadAndDemuxSegment(trackAudio, "audio/chunk-stream0-00001.m4s");
     std::cout << "loading rialtotest /tmp/data/bipbop-gen/audio/chunk-stream0-00001.m4s" << std::endl;
 
-    size_t segmentCount = trackAudio.getNbSegments(); // Corrected function name
+    // size_t segmentCount = trackAudio.getNbSegments();
+    size_t segmentCount = trackAudio.count();
     printf("adding %zu audio frames\n", segmentCount); 
 
     for (size_t i = 0; i < segmentCount; ++i)
@@ -170,17 +187,18 @@ void InjectAudio()
         std::memcpy(data, trackAudio.getPtr(i), len);
         audioSegment->setData((uint32_t)len, data);
 
-        AddSegmentStatus status = gstMediaPipeline->addSegment(0, audioSegment);
+        AddSegmentStatus status = gstMediaPipeline->addSegment(needDataId, audioSegment);
         assert(status == AddSegmentStatus::OK);
     }
 }
 
-void InjectVideo()
+void InjectVideo(int32_t needDataId)
 {
     LoadAndDemuxSegment(trackVideo, "video/chunk-stream0-00001.m4s");
     std::cout << "loading rialtotest /tmp/data/bipbop-gen/video/chunk-stream0-00001.m4s" << std::endl;
 
-    size_t segmentCount = trackVideo.getNbSegments(); // Corrected function name
+    // size_t segmentCount = trackVideo.getNbSegments();
+    size_t segmentCount = trackVideo.count();
     printf("adding %zu video frames\n", segmentCount);
 
     for (size_t i = 0; i < segmentCount; ++i)
@@ -201,7 +219,7 @@ void InjectVideo()
         std::memcpy(data, trackVideo.getPtr(i), len);
         videoSegment->setData((uint32_t)len, data);
 
-        AddSegmentStatus status = gstMediaPipeline->addSegment(0, videoSegment);
+        AddSegmentStatus status = gstMediaPipeline->addSegment(needDataId, videoSegment);
         assert(status == AddSegmentStatus::OK);
     }
 }
@@ -222,23 +240,33 @@ int my_main(int argc, char **argv)
         return -1;
     }
 
-    if (!gstMediaPipeline->setVideoWindow(0, 0, 1920, 1080))
-    {
-        fprintf(stderr, "Warning: Failed to set video window. Video may not appear.\n");
-    }
+    // if (!gstMediaPipeline->setVideoWindow(0, 0, 1920, 1080))
+    // {
+    //     fprintf(stderr, "Warning: Failed to set video window. Video may not appear.\n");
+    // }
 
-    gstMediaPipeline->play();
+    // MUST happen before any attachSource() to create a Rialto Gstreamer player
+    gstMediaPipeline->load(MediaType::MSE, "video/fmp4", "test://local"); // Dummy values
 
     ConfigureAudio();
     ConfigureVideo();
     ConfigureComplete();
 
-    InjectAudio();
-    InjectVideo();
+    gstMediaPipeline->play();
+
+    uint32_t audioReqId = WaitForNeedDataRequest(sourceIdAudio);
+    uint32_t videoReqId = WaitForNeedDataRequest(sourceIdVideo);
+
+    if (audioReqId != UINT32_MAX)
+        InjectAudio(audioReqId);
+
+    if (videoReqId != UINT32_MAX)
+        InjectVideo(videoReqId);
+
 
-    std::this_thread::sleep_for(std::chrono::seconds(5)); 
+    // std::this_thread::sleep_for(std::chrono::seconds(5)); 
 
-    gstMediaPipeline->stop();
+    // gstMediaPipeline->stop();
 
     return 0;
 }

test/gstTestHarness/rialto-gst-pipeline.cpp

@@ -3,6 +3,13 @@
 #include <vector>
 #include <cassert>
 #include <cstring>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+
+std::mutex g_needDataMutex;
+std::condition_variable g_needDataCv;
+std::queue<NeedDataRequestEvent> g_needDataQueue;
 
 using namespace firebolt::rialto;
 
@@ -106,9 +113,16 @@ void GstMediaPipeline::notifyNetworkState(NetworkState state) {}
 void GstMediaPipeline::notifyQos(int32_t sourceId, const QosInfo &qosInfo) {}
 void GstMediaPipeline::notifyBufferUnderflow(int32_t sourceId) {}
 void GstMediaPipeline::notifySourceFlushed(int32_t sourceId) {}
+
 void GstMediaPipeline::notifyNeedMediaData(int32_t sourceId, size_t frameCount, 
-                             uint32_t needDataRequestId, 
-                             const std::shared_ptr<MediaPlayerShmInfo> &mediaPlayerShmInfo) {}
+                                           uint32_t needDataRequestId, 
+                                           const std::shared_ptr<MediaPlayerShmInfo> &mediaPlayerShmInfo)
+{
+    std::lock_guard<std::mutex> lock(g_needDataMutex);
+    g_needDataQueue.push({sourceId, needDataRequestId});
+    g_needDataCv.notify_one();
+}
+
 void GstMediaPipeline::notifyDuration(int64_t duration) {}
 void GstMediaPipeline::notifyNativeSize(uint32_t width, uint32_t height, double aspect) {}
 void GstMediaPipeline::notifyVideoData(bool hasData) {}

test/gstTestHarness/rialto-gst-pipeline.h

@@ -6,6 +6,20 @@
 #include <iostream>
 #include <vector>
 
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+
+struct NeedDataRequestEvent
+{
+    int32_t sourceId;
+    uint32_t requestId;
+};
+
+extern std::mutex g_needDataMutex;
+extern std::condition_variable g_needDataCv;
+extern std::queue<NeedDataRequestEvent> g_needDataQueue;
+
 using namespace firebolt::rialto;
 
 class GstMediaPipeline : public IMediaPipeline,