CMakeLists.txt

@@ -99,7 +99,7 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/common.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/global.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/message.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/mediasample.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/frameinfo.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/peerconnection.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/reliability.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtc.h

include/rtc/mediasample.hpp → include/rtc/frameinfo.hpp

@@ -13,11 +13,8 @@
 
 namespace rtc {
 
-struct RTC_CPP_EXPORT MediaSample : binary {
-	MediaSample(uint32_t timestamp) : timestamp(timestamp){};
-	MediaSample(binary &&data, uint32_t timestamp)
-	    : binary(std::move(data)), timestamp(timestamp){};
-
+struct RTC_CPP_EXPORT FrameInfo {
+	FrameInfo(uint32_t timestamp) : timestamp(timestamp){};
 	uint32_t timestamp = 0; // RTP Timestamp
 };
 

include/rtc/message.hpp

@@ -10,7 +10,7 @@
 #define RTC_MESSAGE_H
 
 #include "common.hpp"
-#include "mediasample.hpp"
+#include "frameinfo.hpp"
 #include "reliability.hpp"
 
 #include <functional>
@@ -33,7 +33,7 @@ struct RTC_CPP_EXPORT Message : binary {
 	unsigned int stream = 0; // Stream id (SCTP stream or SSRC)
 	unsigned int dscp = 0;   // Differentiated Services Code Point
 	shared_ptr<Reliability> reliability;
-	shared_ptr<MediaSample> media_sample;
+	shared_ptr<FrameInfo> frame_info;
 };
 
 using message_ptr = shared_ptr<Message>;
@@ -47,11 +47,11 @@ inline size_t message_size_func(const message_ptr &m) {
 template <typename Iterator>
 message_ptr make_message(Iterator begin, Iterator end, Message::Type type = Message::Binary,
                          unsigned int stream = 0, shared_ptr<Reliability> reliability = nullptr,
-                         shared_ptr<MediaSample> media_sample = nullptr) {
+                         shared_ptr<FrameInfo> frame_info = nullptr) {
 	auto message = std::make_shared<Message>(begin, end, type);
 	message->stream = stream;
 	message->reliability = reliability;
-	message->media_sample = media_sample;
+	message->frame_info = frame_info;
 	return message;
 }
 
@@ -62,7 +62,7 @@ RTC_CPP_EXPORT message_ptr make_message(size_t size, Message::Type type = Messag
 RTC_CPP_EXPORT message_ptr make_message(binary &&data, Message::Type type = Message::Binary,
                                         unsigned int stream = 0,
                                         shared_ptr<Reliability> reliability = nullptr,
-                                        shared_ptr<MediaSample> media_sample = nullptr);
+                                        shared_ptr<FrameInfo> frame_info = nullptr);
 
 RTC_CPP_EXPORT message_ptr make_message(size_t size, message_ptr orig);
 

include/rtc/track.hpp

@@ -41,7 +41,7 @@ class RTC_CPP_EXPORT Track final : private CheshireCat<impl::Track>, public Chan
 	bool isClosed(void) const override;
 	size_t maxMessageSize() const override;
 
-	void onMediaSample(std::function<void(MediaSample data)> callback);
+	void onFrame(std::function<void(binary data, FrameInfo frame)> callback);
 
 	bool requestKeyframe();
 	bool requestBitrate(unsigned int bitrate);

src/h264rtpdepacketizer.cpp

@@ -35,7 +35,7 @@ message_vector H264RtpDepacketizer::buildFrames(message_vector::iterator begin,
                                                 message_vector::iterator end, uint32_t timestamp) {
 	message_vector out = {};
 	auto fua_buffer = std::vector<std::byte>{};
-	auto media_sample = std::make_shared<MediaSample>(timestamp);
+	auto frame_info = std::make_shared<FrameInfo>(timestamp);
 
 	for (auto it = begin; it != end; it++) {
 		auto pkt = it->get();
@@ -60,12 +60,12 @@ message_vector H264RtpDepacketizer::buildFrames(message_vector::iterator begin,
 				    std::byte(nalUnitHeader.idc() | nalUnitFragmentHeader.unitType());
 
 				out.push_back(
-				    make_message(std::move(fua_buffer), Message::Binary, 0, nullptr, media_sample));
+				    make_message(std::move(fua_buffer), Message::Binary, 0, nullptr, frame_info));
 				fua_buffer.clear();
 			}
 		} else if (nalUnitHeader.unitType() > 0 && nalUnitHeader.unitType() < 24) {
 			out.push_back(make_message(pkt->begin() + headerSize, pkt->end(), Message::Binary, 0,
-			                           nullptr, media_sample));
+			                           nullptr, frame_info));
 		} else if (nalUnitHeader.unitType() == naluTypeSTAPA) {
 			auto currOffset = stapaHeaderSize + headerSize;
 
@@ -81,7 +81,7 @@ message_vector H264RtpDepacketizer::buildFrames(message_vector::iterator begin,
 
 				out.push_back(make_message(pkt->begin() + currOffset,
 				                           pkt->begin() + currOffset + naluSize, Message::Binary, 0,
-				                           nullptr, media_sample));
+				                           nullptr, frame_info));
 				currOffset += naluSize;
 			}
 		} else {

src/impl/track.cpp

@@ -216,7 +216,7 @@ void Track::setMediaHandler(shared_ptr<MediaHandler> handler) {
 		mMediaHandler = handler;
 	}
 
-	if(handler)
+	if (handler)
 		handler->media(description());
 }
 
@@ -225,26 +225,25 @@ shared_ptr<MediaHandler> Track::getMediaHandler() {
 	return mMediaHandler;
 }
 
-void Track::onMediaSample(std::function<void(MediaSample data)> callback) {
-	mediaSampleCallback = callback;
+void Track::onFrame(std::function<void(binary data, FrameInfo frame)> callback) {
+	frameCallback = callback;
 	flushPendingMessages();
 }
 
 void Track::flushPendingMessages() {
 	if (!mOpenTriggered)
 		return;
 
-	while (messageCallback || mediaSampleCallback) {
+	while (messageCallback || frameCallback) {
 		auto next = mRecvQueue.pop();
 		if (!next)
 			break;
 
 		auto message = next.value();
 		try {
-			if (message->media_sample != nullptr && mediaSampleCallback) {
-				mediaSampleCallback(
-				    MediaSample(std::move(*message), message->media_sample->timestamp));
-			} else if (message->media_sample == nullptr && messageCallback) {
+			if (message->frame_info != nullptr && frameCallback) {
+				frameCallback(std::move(*message), std::move(*message->frame_info));
+			} else if (message->frame_info == nullptr && messageCallback) {
 				messageCallback(trackMessageToVariant(message));
 			}
 		} catch (const std::exception &e) {

src/impl/track.hpp

@@ -41,7 +41,7 @@ class Track final : public std::enable_shared_from_this<Track>, public Channel {
 	void flushPendingMessages() override;
 	message_variant trackMessageToVariant(message_ptr message);
 
-	void onMediaSample(std::function<void(MediaSample data)> callback);
+	void onFrame(std::function<void(binary data, FrameInfo frame)> callback);
 
 	bool isOpen() const;
 	bool isClosed() const;
@@ -76,7 +76,7 @@ class Track final : public std::enable_shared_from_this<Track>, public Channel {
 
 	Queue<message_ptr> mRecvQueue;
 
-	synchronized_callback<MediaSample> mediaSampleCallback;
+	synchronized_callback<binary, FrameInfo> frameCallback;
 };
 
 } // namespace rtc::impl

src/message.cpp

@@ -19,17 +19,16 @@ message_ptr make_message(size_t size, Message::Type type, unsigned int stream,
 }
 
 message_ptr make_message(binary &&data, Message::Type type, unsigned int stream,
-                         shared_ptr<Reliability> reliability,
-                         shared_ptr<MediaSample> media_sample) {
+                         shared_ptr<Reliability> reliability, shared_ptr<FrameInfo> frame_info) {
 	auto message = std::make_shared<Message>(std::move(data), type);
 	message->stream = stream;
 	message->reliability = reliability;
-	message->media_sample = media_sample;
+	message->frame_info = frame_info;
 	return message;
 }
 
 message_ptr make_message(size_t size, message_ptr orig) {
-	if(!orig)
+	if (!orig)
 		return nullptr;
 
 	auto message = std::make_shared<Message>(size, orig->type);

src/track.cpp

@@ -70,8 +70,8 @@ bool Track::requestBitrate(unsigned int bitrate) {
 
 shared_ptr<MediaHandler> Track::getMediaHandler() { return impl()->getMediaHandler(); }
 
-void Track::onMediaSample(std::function<void(MediaSample data)> callback) {
-	impl()->onMediaSample(callback);
+void Track::onFrame(std::function<void(binary data, FrameInfo frame)> callback) {
+	impl()->onFrame(callback);
 }
 
 } // namespace rtc