[1.0.21][ut] Add raw media packet push test case

Change-Id: Idc71953bcb337650a1cabc8604fe426c3f564397

diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index c9e9a30..ef17de3 100644 (file)
--- a/packaging/capi-media-transporter.spec
+++ b/packaging/capi-media-transporter.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-transporter
 Summary:    A Media Transporter library in Tizen Native API
-Version:    1.0.20
+Version:    1.0.21
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/unittest/ut_es_reader.hpp b/unittest/ut_es_reader.hpp
index 39a0a93..99de2ff 100644 (file)
--- a/unittest/ut_es_reader.hpp
+++ b/unittest/ut_es_reader.hpp
@@ -44,6 +44,13 @@ typedef enum {
        NAL_PREFIX_SVC = 14
 } nal_unit_type;
 
+typedef enum {
+       MEDIA_TYPE_ENCODED_AUDIO,
+       MEDIA_TYPE_ENCODED_VIDEO,
+       MEDIA_TYPE_RAW_AUDIO,
+       MEDIA_TYPE_RAW_VIDEO,
+} contentsType;
+
 #define ES_DEFAULT_VIDEO_PTS_OFFSET       41667000
 #define ES_DEFAULT_VIDEO_FPS           24
 
@@ -54,7 +61,7 @@ static const std::string tc_root_dir = "/home/owner/";
 class EsStreamReader {
 public:
        explicit EsStreamReader(const std::string dirpath,
-                                                                                                       mtpr_media_type_e type) {
+                                                                                                       contentsType type) {
                _dirPath = tc_root_dir + dirpath;
                _ESDataFile = _dirPath + "MTPR.es";
                _ESInfoFile = _dirPath + "MTPR.info";
@@ -74,27 +81,34 @@ public:
 
        bool makeMediaFormat() {
                media_format_create(&_mediaFormat);
-               if (_type == MTPR_MEDIA_TYPE_AUDIO) {
+               if (_type == MEDIA_TYPE_ENCODED_AUDIO ||
+                               _type == MEDIA_TYPE_RAW_AUDIO) {
                        uint32_t mimeType;
                        uint32_t sampleRate;
                        uint32_t channels;
+                       uint32_t bit;
                        auto formatStream = std::ifstream(_ESInfoFile, std::ifstream::in);
                        if (!formatStream.is_open()) {
                                LOGW("No audio info file: %s", _ESInfoFile.c_str());
                                return false;
                        }
-                       formatStream >> mimeType >> sampleRate >> channels;
-                       LOGD("mime_type: %u, sampleRate: %u, channels: %u",
-                               mimeType, sampleRate, channels);
+                       formatStream >> mimeType >> sampleRate >> channels >> bit;
+                       LOGD("mime_type: %u, sampleRate: %u, channels: %u, bit: %u",
+                               mimeType, sampleRate, channels, bit);
                        formatStream.close();
 
+                       _rawAudioReadSize = channels * bit / 8 * 1024;
+
                        media_format_set_audio_mime(_mediaFormat, static_cast<media_format_mimetype_e>(mimeType));
                        media_format_set_audio_samplerate(_mediaFormat, sampleRate);
                        media_format_set_audio_channel(_mediaFormat, channels);
+                       if (bit)
+                               media_format_set_audio_bit(_mediaFormat, bit);
 
                        return true;
 
-               } else if (_type == MTPR_MEDIA_TYPE_VIDEO) {
+               } else if (_type == MEDIA_TYPE_ENCODED_VIDEO ||
+                               _type == MEDIA_TYPE_RAW_VIDEO) {
                        uint32_t mimeType;
                        uint32_t width;
                        uint32_t height;
@@ -109,6 +123,8 @@ public:
                                mimeType, width, height, frameRate);
                        formatStream.close();
 
+                       _rawVideoReadSize = width * height * 3 / 2;
+
                        media_format_set_video_mime(_mediaFormat, static_cast<media_format_mimetype_e>(mimeType));
                        media_format_set_video_width(_mediaFormat, width);
                        media_format_set_video_height(_mediaFormat, height);
@@ -123,6 +139,8 @@ public:
 
        bool ReadNextPacket(media_packet_h* outPacket) {
                static uint64_t pts = 0L;
+               uint64_t ptsOffset = 0L;
+               int size = 0;
                media_packet_h packet;
 
                if (!_stream.is_open()) {
@@ -142,46 +160,45 @@ public:
 
                char* tmp = new char[1000000];
 
-               if (_type == MTPR_MEDIA_TYPE_VIDEO) {
-                       int size = videobytestream2nalunit(tmp);
-                       if (size <= 0) {
-                               delete[] tmp;
-                               return false;
-                       }
-
-                       void *buffer = nullptr;
-                       media_packet_new_alloc(_mediaFormat, nullptr, nullptr, &packet);
-                       media_packet_set_pts(packet, pts);
-                       media_packet_set_duration(packet, ES_DEFAULT_VIDEO_PTS_OFFSET);
-                       media_packet_set_buffer_size(packet, size);
-                       media_packet_get_buffer_data_ptr(packet, &buffer);
-
-                       memcpy(buffer, tmp, size);
-
-                       pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
-
-                       *outPacket = packet;
+               switch (_type)
+               {
+               case MEDIA_TYPE_ENCODED_VIDEO:
+                       size = videobytestream2nalunit(tmp);
+                       ptsOffset = ES_DEFAULT_VIDEO_PTS_OFFSET;
+                       break;
+               case MEDIA_TYPE_ENCODED_AUDIO:
+                       size = audiobytestream2nalunit(tmp);
+                       ptsOffset = ES_DEFAULT_AUDIO_PTS_OFFSET;
+                       break;
+               case MEDIA_TYPE_RAW_VIDEO:
+                       size = videoRawUnit(tmp);
+                       ptsOffset = ES_DEFAULT_VIDEO_PTS_OFFSET;
+                       break;
+               case MEDIA_TYPE_RAW_AUDIO:
+                       size = audioRawUnit(tmp);
+                       ptsOffset = ES_DEFAULT_AUDIO_PTS_OFFSET;
+                       break;
+               default:
+                       return false;
+               }
 
-               } else if (_type == MTPR_MEDIA_TYPE_AUDIO) {
-                       int size = audiobytestream2nalunit(tmp);
-                       if (size <= 0) {
-                               delete[] tmp;
-                               return false;
-                       }
+               if (size <= 0) {
+                       delete[] tmp;
+                       return false;
+               }
 
-                       void *buffer = nullptr;
-                       media_packet_new_alloc(_mediaFormat, nullptr, nullptr, &packet);
-                       media_packet_set_pts(packet, pts);
-                       media_packet_set_duration(packet, ES_DEFAULT_AUDIO_PTS_OFFSET);
-                       media_packet_set_buffer_size(packet, size);
-                       media_packet_get_buffer_data_ptr(packet, &buffer);
+               void *buffer = nullptr;
+               media_packet_new_alloc(_mediaFormat, nullptr, nullptr, &packet);
+               media_packet_set_pts(packet, pts);
+               media_packet_set_duration(packet, ptsOffset);
+               media_packet_set_buffer_size(packet, size);
+               media_packet_get_buffer_data_ptr(packet, &buffer);
 
-                       memcpy(buffer, tmp, size);
+               memcpy(buffer, tmp, size);
 
-                       pts += ES_DEFAULT_AUDIO_PTS_OFFSET;
+               pts += ptsOffset;
 
-                       *outPacket = packet;
-               }
+               *outPacket = packet;
 
                delete[] tmp;
                return true;
@@ -279,6 +296,36 @@ private:
                return nal_length;
        }
 
+       int audioRawUnit(char *nal)
+       {
+               if (!_rawAudioReadSize) {
+                       LOGE("audio read size is zero");
+                       return -1;
+               }
+
+               if (GetFileLeftSize_() < _rawAudioReadSize)
+                       return -1;
+
+               _stream.read(nal, _rawAudioReadSize);
+
+               return _rawAudioReadSize;
+       }
+
+       int videoRawUnit(char *nal)
+       {
+               if (!_rawVideoReadSize) {
+                       LOGE("video read size is zero");
+                       return -1;
+               }
+
+               if (GetFileLeftSize_() < _rawVideoReadSize)
+                       return -1;
+
+               _stream.read(nal, _rawVideoReadSize);
+
+               return _rawVideoReadSize;
+       }
+
        int GetFileLeftSize_(void) {
                if (!_stream.is_open()) return 0;
                int cur = _stream.tellg();
@@ -293,7 +340,9 @@ private:
        std::string _ESDataFile;
        std::string _ESInfoFile;
        std::ifstream _stream;
-       mtpr_media_type_e _type;
+       contentsType _type;
+       int _rawAudioReadSize = 0;
+       int _rawVideoReadSize = 0;
        media_format_h _mediaFormat = nullptr;
 };
 

diff --git a/unittest/ut_rist_media_packet_sender.cpp b/unittest/ut_rist_media_packet_sender.cpp
index ce2d57e..d10720f 100644 (file)
--- a/unittest/ut_rist_media_packet_sender.cpp
+++ b/unittest/ut_rist_media_packet_sender.cpp
@@ -23,7 +23,8 @@ using namespace std::chrono_literals;
 static const unsigned numberOfVideoFeedingPacket = 100;
 static const unsigned numberOfAudioFeedingPacket = 200;
 
-static void bufferStateCb(unsigned int sourceId, mtpr_media_packet_source_buffer_state_e state, void *user_data) {
+static void bufferStateCb(unsigned int sourceId,
+               mtpr_media_packet_source_buffer_state_e state, void *user_data) {
        LOGD("callback is invoked. sourceId: %d, state: %d", sourceId, state);
 
        static std::once_flag flag;
@@ -86,7 +87,8 @@ public:
                LOGD("Leave");
        }
 
-       std::thread feedingEsPacket(mtpr_h mtpr, const mtpr_media_type_e type, unsigned int source_id, unsigned int feedingPacketCount);
+       std::thread feedingEsPacket(mtpr_h mtpr, const contentsType type,
+                       unsigned int source_id, unsigned int feedingPacketCount);
 
 protected:
        const std::string _receiverPath = "127.0.0.1:5004";
@@ -96,10 +98,12 @@ protected:
        std::thread _videoFeeder;
 };
 
-std::thread MediaTransporterTestRistPacketSender::feedingEsPacket(mtpr_h mtpr, const mtpr_media_type_e type, unsigned int source_id, unsigned int feedingPacketCount)
+std::thread MediaTransporterTestRistPacketSender::feedingEsPacket(mtpr_h mtpr,
+               const contentsType type, unsigned int source_id, unsigned int feedingPacketCount)
 {
        EsStreamReader* reader = nullptr;
-       reader = (type == MTPR_MEDIA_TYPE_VIDEO) ?      _videoEsReader : _audioEsReader;
+       reader = (type == MEDIA_TYPE_ENCODED_VIDEO || type == MEDIA_TYPE_RAW_VIDEO) ?
+                       _videoEsReader : _audioEsReader;
 
        auto feeding_task_fn = [mtpr, source_id, reader, feedingPacketCount]() {
                unsigned int leftFeedingPacket = feedingPacketCount;
@@ -110,6 +114,7 @@ std::thread MediaTransporterTestRistPacketSender::feedingEsPacket(mtpr_h mtpr, c
                                break;
 
                        mtpr_media_packet_source_push_packet(mtpr, source_id, pkt);
+
                        media_packet_unref(pkt);
                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
                }
@@ -143,7 +148,7 @@ TEST_F(MediaTransporterTestRistPacketSender, set_media_format)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(source_id, 0);
 
-       _videoEsReader = new EsStreamReader("video/", MTPR_MEDIA_TYPE_VIDEO);
+       _videoEsReader = new EsStreamReader("video/", MEDIA_TYPE_ENCODED_VIDEO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _videoEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -161,7 +166,7 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_video_packet)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(source_id, 0);
 
-       _videoEsReader = new EsStreamReader("video/", MTPR_MEDIA_TYPE_VIDEO);
+       _videoEsReader = new EsStreamReader("video/", MEDIA_TYPE_ENCODED_VIDEO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _videoEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -169,7 +174,7 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_video_packet)
        ret = mtpr_start(_mtpr);
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
 
-       _videoFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_VIDEO, source_id, numberOfVideoFeedingPacket);
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_VIDEO, source_id, numberOfVideoFeedingPacket);
        if (_videoFeeder.joinable())
                _videoFeeder.join();
 }
@@ -186,7 +191,7 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_audio_packet)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(source_id, 0);
 
-       _audioEsReader = new EsStreamReader("audio/", MTPR_MEDIA_TYPE_AUDIO);
+       _audioEsReader = new EsStreamReader("audio/", MEDIA_TYPE_ENCODED_AUDIO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _audioEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -194,7 +199,8 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_audio_packet)
        ret = mtpr_start(_mtpr);
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
 
-       _audioFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_AUDIO, source_id, numberOfAudioFeedingPacket);
+       _audioFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_AUDIO, source_id, numberOfAudioFeedingPacket);
+       if (_audioFeeder.joinable())
                _audioFeeder.join();
 }
 
@@ -215,8 +221,8 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_av_packet)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(videoSourceID, 0);
 
-       _audioEsReader = new EsStreamReader("audio/", MTPR_MEDIA_TYPE_AUDIO);
-       _videoEsReader = new EsStreamReader("video/", MTPR_MEDIA_TYPE_VIDEO);
+       _audioEsReader = new EsStreamReader("audio/", MEDIA_TYPE_ENCODED_AUDIO);
+       _videoEsReader = new EsStreamReader("video/", MEDIA_TYPE_ENCODED_VIDEO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, audioSourceID, _audioEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -227,8 +233,8 @@ TEST_F(MediaTransporterTestRistPacketSender, push_media_av_packet)
        ret = mtpr_start(_mtpr);
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
 
-       _audioFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_AUDIO, audioSourceID, numberOfAudioFeedingPacket);
-       _videoFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_VIDEO, videoSourceID, numberOfVideoFeedingPacket);
+       _audioFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_AUDIO, audioSourceID, numberOfAudioFeedingPacket);
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_VIDEO, videoSourceID, numberOfVideoFeedingPacket);
 
        if (_audioFeeder.joinable())
                _audioFeeder.join();
@@ -249,7 +255,7 @@ TEST_F(MediaTransporterTestRistPacketSender, set_buffer_state_callback)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(source_id, 0);
 
-       _videoEsReader = new EsStreamReader("video/", MTPR_MEDIA_TYPE_VIDEO);
+       _videoEsReader = new EsStreamReader("video/", MEDIA_TYPE_ENCODED_VIDEO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _videoEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -262,7 +268,7 @@ TEST_F(MediaTransporterTestRistPacketSender, set_buffer_state_callback)
        ret = mtpr_start(_mtpr);
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
 
-       _videoFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_VIDEO, source_id, numberOfVideoFeedingPacket);
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_VIDEO, source_id, numberOfVideoFeedingPacket);
 
        ASSERT_TRUE(waitBufferStateCallback(f));
 
@@ -282,7 +288,7 @@ TEST_F(MediaTransporterTestRistPacketSender, unset_buffer_state_callback)
        ASSERT_EQ(ret, MTPR_ERROR_NONE);
        ASSERT_GE(source_id, 0);
 
-       _videoEsReader = new EsStreamReader("video/", MTPR_MEDIA_TYPE_VIDEO);
+       _videoEsReader = new EsStreamReader("video/", MEDIA_TYPE_ENCODED_VIDEO);
 
        ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _videoEsReader->getMediaFormat());
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
@@ -296,7 +302,96 @@ TEST_F(MediaTransporterTestRistPacketSender, unset_buffer_state_callback)
        ret = mtpr_start(_mtpr);
        EXPECT_EQ(ret, MTPR_ERROR_NONE);
 
-       _videoFeeder = feedingEsPacket(_mtpr, MTPR_MEDIA_TYPE_VIDEO, source_id, numberOfVideoFeedingPacket);
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_ENCODED_VIDEO, source_id, numberOfVideoFeedingPacket);
+
+       if (_videoFeeder.joinable())
+               _videoFeeder.join();
+}
+
+TEST_F(MediaTransporterTestRistPacketSender, push_media_raw_video_packet)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int source_id = 0;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_MEDIAPACKET, &source_id);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_GE(source_id, 0);
+
+       _videoEsReader = new EsStreamReader("raw_video/", MEDIA_TYPE_RAW_VIDEO);
+
+       ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _videoEsReader->getMediaFormat());
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_RAW_VIDEO, source_id, numberOfVideoFeedingPacket);
+       if (_videoFeeder.joinable())
+               _videoFeeder.join();
+}
+
+TEST_F(MediaTransporterTestRistPacketSender, push_media_raw_audio_packet)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int source_id = 0;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_MEDIAPACKET, &source_id);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_GE(source_id, 0);
+
+       _audioEsReader = new EsStreamReader("raw_audio/", MEDIA_TYPE_RAW_AUDIO);
+
+       ret = mtpr_media_packet_source_set_format(_mtpr, source_id, _audioEsReader->getMediaFormat());
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       _audioFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_RAW_AUDIO, source_id, numberOfAudioFeedingPacket);
+       if (_audioFeeder.joinable())
+               _audioFeeder.join();
+}
+
+TEST_F(MediaTransporterTestRistPacketSender, push_media_raw_av_packet)
+{
+       int ret = MTPR_ERROR_NONE;
+       unsigned int audioSourceID = 0;
+       unsigned int videoSourceID = 0;
+
+       ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_MEDIAPACKET, &audioSourceID);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_GE(audioSourceID, 0);
+
+       ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_MEDIAPACKET, &videoSourceID);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_GE(videoSourceID, 0);
+
+       _audioEsReader = new EsStreamReader("raw_audio/", MEDIA_TYPE_RAW_AUDIO);
+       _videoEsReader = new EsStreamReader("raw_video/", MEDIA_TYPE_RAW_VIDEO);
+
+       ret = mtpr_media_packet_source_set_format(_mtpr, audioSourceID, _audioEsReader->getMediaFormat());
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_media_packet_source_set_format(_mtpr, videoSourceID, _videoEsReader->getMediaFormat());
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_start(_mtpr);
+       EXPECT_EQ(ret, MTPR_ERROR_NONE);
+
+       _audioFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_RAW_AUDIO, audioSourceID, numberOfAudioFeedingPacket);
+       _videoFeeder = feedingEsPacket(_mtpr, MEDIA_TYPE_RAW_VIDEO, videoSourceID, numberOfVideoFeedingPacket);
+
+       if (_audioFeeder.joinable())
+               _audioFeeder.join();
 
        if (_videoFeeder.joinable())
                _videoFeeder.join();