react-native-webrtc-nitro 1.0.0

package/cpp/Hybrid/HybridRTCRtpTransceiver.cpp

@@ -0,0 +1,253 @@
+#include "HybridRTCRtpTransceiver.hpp"
+
+using namespace margelo::nitro::webrtc;
+
+auto HybridRTCRtpTransceiver::offerMedia (const std::string &mid)
+    -> rtc::Description::Media
+{
+    this->mid = mid;
+    uint32_t ssrc = random () % UINT32_MAX;
+    std::optional<rtc::Description::Media> media = std::nullopt;
+    if (kind == "audio")
+    {
+        rtc::Description::Audio audio (mid, direction);
+        audio.addOpusCodec (111);
+        media = audio;
+    }
+    else if (kind == "video")
+    {
+        rtc::Description::Video video (mid, direction);
+        video.addH265Codec (104, "level-id=93;"
+                                 "profile-id=1;"
+                                 "tier-flag=0;"
+                                 "tx-mode=SRST");
+        video.addH264Codec (96, "profile-level-id=42e01f;"
+                                "packetization-mode=1;"
+                                "level-asymmetry-allowed=1");
+        media = video;
+    }
+    else
+    {
+        throw std::invalid_argument ("Unsupported media type: " + kind);
+    }
+
+    if (sendMsids.empty ())
+    {
+        media->addSSRC (ssrc, std::nullopt);
+    }
+    for (const auto &msid : sendMsids)
+    {
+        std::string trackid
+            = hybridRtcRtpSender->mediaStreamTrack
+                  ? hybridRtcRtpSender->mediaStreamTrack->getId ()
+                  : "";
+        media->addSSRC (ssrc, std::nullopt, msid, trackid);
+    }
+    track = peerConnection->addTrack (media.value ());
+    return media.value ();
+}
+
+auto HybridRTCRtpTransceiver::answerMedia (
+    const rtc::Description::Media &remoteMedia) -> rtc::Description::Media
+{
+    auto mid = remoteMedia.mid ();
+    this->mid = mid;
+    uint32_t ssrc = random () % UINT32_MAX;
+
+    std::optional<rtc::Description::Media> media = std::nullopt;
+    if (kind == "audio")
+    {
+        rtc::Description::Audio audio (mid, direction);
+        media = audio;
+    }
+    else if (kind == "video")
+    {
+        rtc::Description::Video video (mid, direction);
+        media = video;
+    }
+    else
+    {
+        throw std::invalid_argument ("Unsupported media type: " + kind);
+    }
+
+    for (auto pt : remoteMedia.payloadTypes ())
+    {
+        auto rtpMap = remoteMedia.rtpMap (pt);
+        if (rtpMap->format == "H264" || rtpMap->format == "H265"
+            || rtpMap->format == "opus")
+        {
+            media->addRtpMap (*rtpMap);
+            break;
+        }
+    }
+
+    if (sendMsids.empty ())
+    {
+        media->addSSRC (ssrc, std::nullopt);
+    }
+    for (const auto &msid : sendMsids)
+    {
+        std::string trackid
+            = hybridRtcRtpSender->mediaStreamTrack
+                  ? hybridRtcRtpSender->mediaStreamTrack->getId ()
+                  : "";
+        media->addSSRC (ssrc, std::nullopt, msid, trackid);
+    }
+    track = peerConnection->addTrack (media.value ());
+    return media.value ();
+}
+
+void HybridRTCRtpTransceiver::senderOnOpen ()
+{
+    if (hybridRtcRtpSender->mediaStreamTrack == nullptr)
+    {
+        return;
+    }
+
+    const size_t mtu = 1200;
+    auto ssrcs = track->description ().getSSRCs ();
+    if (ssrcs.size () != 1)
+    {
+        throw std::runtime_error ("Expected exactly one SSRC");
+    }
+    rtc::SSRC ssrc = ssrcs[0];
+
+    AVCodecID avCodecId;
+    auto separator = rtc::NalUnit::Separator::StartSequence;
+    if (rtpMap->format == "H265")
+    {
+        auto rtpConfig = std::make_shared<rtc::RtpPacketizationConfig> (
+            ssrc, track->mid (), rtpMap->payloadType,
+            rtc::H265RtpPacketizer::ClockRate);
+        auto packetizer = std::make_shared<rtc::H265RtpPacketizer> (
+            separator, rtpConfig, mtu);
+        track->chainMediaHandler (packetizer);
+        avCodecId = AV_CODEC_ID_H265;
+    }
+    else if (rtpMap->format == "H264")
+    {
+        auto rtpConfig = std::make_shared<rtc::RtpPacketizationConfig> (
+            ssrc, track->mid (), rtpMap->payloadType,
+            rtc::H264RtpPacketizer::ClockRate);
+        auto packetizer = std::make_shared<rtc::H264RtpPacketizer> (
+            separator, rtpConfig, mtu);
+        track->chainMediaHandler (packetizer);
+        avCodecId = AV_CODEC_ID_H264;
+    }
+    else if (rtpMap->format == "opus")
+    {
+        auto rtpConfig = std::make_shared<rtc::RtpPacketizationConfig> (
+            ssrc, track->mid (), rtpMap->payloadType,
+            rtc::OpusRtpPacketizer::DefaultClockRate);
+        auto packetizer = std::make_shared<rtc::OpusRtpPacketizer> (rtpConfig);
+        track->chainMediaHandler (packetizer);
+        avCodecId = AV_CODEC_ID_OPUS;
+    }
+    else
+    {
+        throw std::runtime_error ("Unsupported codec: " + rtpMap->format);
+    }
+
+    std::string pipeId
+        = hybridRtcRtpSender->mediaStreamTrack->get_dstPipeId ();
+    auto encoder = std::make_shared<FFmpeg::Encoder> (avCodecId);
+    int subscriptionId = subscribe (
+        { pipeId },
+        [encoder, this] (const std::string &, int, const FFmpeg::Frame &frame)
+        {
+            encoder->send (frame);
+            auto packets = encoder->receive ();
+            for (auto packet : packets)
+            {
+                if (!track->isOpen ())
+                {
+                    return;
+                }
+                track->sendFrame ((const rtc::byte *)packet->data,
+                                  packet->size, packet->pts);
+            }
+        });
+    track->onClosed ([subscriptionId] () { unsubscribe (subscriptionId); });
+}
+
+void HybridRTCRtpTransceiver::receiverOnOpen ()
+{
+    if (hybridRtcRtpReceiver->mediaStreamTrack == nullptr)
+    {
+        return;
+    }
+
+    AVCodecID avCodecId;
+    auto separator = rtc::NalUnit::Separator::StartSequence;
+    if (rtpMap->format == "H265")
+    {
+        auto depacketizer
+            = std::make_shared<rtc::H265RtpDepacketizer> (separator);
+        track->chainMediaHandler (depacketizer);
+        avCodecId = AV_CODEC_ID_H265;
+    }
+    else if (rtpMap->format == "H264")
+    {
+        auto depacketizer
+            = std::make_shared<rtc::H264RtpDepacketizer> (separator);
+        track->chainMediaHandler (depacketizer);
+        avCodecId = AV_CODEC_ID_H264;
+    }
+    else if (rtpMap->format == "opus")
+    {
+        auto depacketizer = std::make_shared<rtc::OpusRtpDepacketizer> ();
+        track->chainMediaHandler (depacketizer);
+        avCodecId = AV_CODEC_ID_OPUS;
+    }
+    else
+    {
+        throw std::runtime_error ("Unsupported codec: " + rtpMap->format);
+    }
+
+    auto decoder = std::make_shared<FFmpeg::Decoder> (avCodecId);
+    std::string pipeId
+        = hybridRtcRtpReceiver->mediaStreamTrack->get_srcPipeId ();
+    track->onFrame (
+        [decoder, pipeId] (rtc::binary binary, rtc::FrameInfo info)
+        {
+            FFmpeg::Packet packet (binary.size ());
+            memcpy (packet->data,
+                    reinterpret_cast<const void *> (binary.data ()),
+                    binary.size ());
+            packet->pts = info.timestamp;
+            packet->dts = info.timestamp;
+
+            decoder->send (packet);
+            auto frames = decoder->receive ();
+            for (auto &frame : frames)
+            {
+                publish (pipeId, frame);
+            }
+        });
+}
+
+void
+HybridRTCRtpTransceiver::start (const rtc::Description::Media &remoteMedia)
+{
+    auto localMedia = track->description ();
+    for (auto remotePt : remoteMedia.payloadTypes ())
+    {
+        if (localMedia.hasPayloadType (remotePt))
+        {
+            rtpMap = *remoteMedia.rtpMap (remotePt);
+            break;
+        }
+    }
+    if (!rtpMap.has_value ())
+    {
+        return;
+    }
+
+    track->onOpen (
+        [this] ()
+        {
+            senderOnOpen ();
+
+            receiverOnOpen ();
+        });
+}

package/cpp/Hybrid/HybridRTCRtpTransceiver.hpp

@@ -0,0 +1,101 @@
+#pragma once
+#include "HybridRTCRtpReceiver.hpp"
+#include "HybridRTCRtpSender.hpp"
+#include "HybridRTCRtpTransceiverSpec.hpp"
+#include <rtc/rtc.hpp>
+
+namespace margelo::nitro::webrtc
+{
+    class HybridRTCRtpTransceiver : public HybridRTCRtpTransceiverSpec
+    {
+      private:
+        std::optional<rtc::Description::Media::RtpMap> rtpMap;
+        const std::vector<std::string> sendMsids;
+        std::shared_ptr<rtc::Track> track;
+        const std::shared_ptr<rtc::PeerConnection> peerConnection;
+
+      public:
+        std::optional<std::string> mid = std::nullopt;
+        const std::string kind;
+        const rtc::Description::Direction direction;
+
+        const std::shared_ptr<HybridRTCRtpSender> hybridRtcRtpSender;
+        const std::shared_ptr<HybridRTCRtpReceiver> hybridRtcRtpReceiver;
+
+        HybridRTCRtpTransceiver ()
+            : HybridObject (TAG), HybridRTCRtpTransceiverSpec (),
+              peerConnection (nullptr), kind (""),
+              direction (rtc::Description::Direction::Inactive)
+
+        {
+            throw std::runtime_error (
+                "Uncaught TypeError: Illegal constructor");
+        }
+
+        HybridRTCRtpTransceiver (
+            const std::shared_ptr<rtc::PeerConnection> &peerConnection,
+            const std::shared_ptr<HybridMediaStreamTrack> &mediaStreamTrack,
+            rtc::Description::Direction direction,
+            const std::vector<std::string> &msids)
+            : HybridObject (TAG), HybridRTCRtpTransceiverSpec (),
+              sendMsids (msids), peerConnection (peerConnection),
+              kind (mediaStreamTrack->getKind ()), direction (direction),
+              hybridRtcRtpSender (std::make_shared<HybridRTCRtpSender> ()),
+              hybridRtcRtpReceiver (std::make_shared<HybridRTCRtpReceiver> ())
+        {
+            if (direction == rtc::Description::Direction::SendOnly
+                || direction == rtc::Description::Direction::SendRecv)
+            {
+                hybridRtcRtpSender->mediaStreamTrack = mediaStreamTrack;
+            }
+        }
+
+        auto offerMedia (const std::string &mid) -> rtc::Description::Media;
+        auto answerMedia (const rtc::Description::Media &remoteMedia)
+            -> rtc::Description::Media;
+
+        void senderOnOpen ();
+        void receiverOnOpen ();
+        void start (const rtc::Description::Media &remoteMedia);
+
+        auto getMid () -> std::variant<nitro::NullType, std::string> override
+        {
+            if (mid.has_value ())
+            {
+                return mid.value ();
+            }
+            else
+            {
+                return nitro::null;
+            }
+        };
+
+        auto getSender () -> std::shared_ptr<HybridRTCRtpSenderSpec> override
+        {
+            return hybridRtcRtpSender;
+        };
+
+        auto getReceiver ()
+            -> std::shared_ptr<HybridRTCRtpReceiverSpec> override
+        {
+            return hybridRtcRtpReceiver;
+        };
+
+        auto getDirection () -> RTCRtpTransceiverDirection override
+        {
+            switch (direction)
+            {
+            case rtc::Description::Direction::SendOnly:
+                return RTCRtpTransceiverDirection::SENDONLY;
+            case rtc::Description::Direction::RecvOnly:
+                return RTCRtpTransceiverDirection::RECVONLY;
+            case rtc::Description::Direction::SendRecv:
+                return RTCRtpTransceiverDirection::SENDRECV;
+            case rtc::Description::Direction::Inactive:
+                return RTCRtpTransceiverDirection::INACTIVE;
+            default:
+                throw std::runtime_error ("Unknown direction");
+            }
+        };
+    };
+} // namespace margelo::nitro::webrtc

package/cpp/MockCamera.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include "FramePipe.hpp"
+#include <thread>
+
+class MockCamera
+{
+  private:
+    std::thread mockThread;
+    std::atomic<bool> running = true;
+
+  public:
+    MockCamera (const std::string &srcPipeId)
+    {
+        mockThread = std::thread (
+            [this, srcPipeId] ()
+            {
+                constexpr int WIDTH = 640;
+                constexpr int HEIGHT = 480;
+                while (running.load ())
+                {
+                    FFmpeg::Frame frame (AV_PIX_FMT_RGB24, WIDTH, HEIGHT);
+                    frame.fillNoise ();
+                    publish (srcPipeId, frame);
+                    std::this_thread::sleep_for (
+                        std::chrono::milliseconds (33));
+                }
+            });
+    }
+
+    void dispose ()
+    {
+        running.store (false);
+        if (mockThread.joinable ())
+        {
+            mockThread.join ();
+        }
+    }
+
+    ~MockCamera () { dispose (); }
+};

package/cpp/MockMicrophone.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include "FramePipe.hpp"
+#include <thread>
+
+class MockMicrophone
+{
+  private:
+    std::thread mockThread;
+    std::atomic<bool> running = true;
+
+  public:
+    MockMicrophone (const std::string &srcPipeId)
+    {
+        mockThread = std::thread (
+            [this, srcPipeId] ()
+            {
+                constexpr int AUDIO_SAMPLE_RATE = 48000;
+                constexpr int NB_SAMPLES = 960;
+                constexpr int DELAY_MS = 20;
+                while (running.load ())
+                {
+                    FFmpeg::Frame frame (AV_SAMPLE_FMT_S16, AUDIO_SAMPLE_RATE,
+                                         2, NB_SAMPLES);
+                    frame.fillNoise ();
+                    publish (srcPipeId, frame);
+                    std::this_thread::sleep_for (
+                        std::chrono::milliseconds (DELAY_MS));
+                }
+            });
+    }
+
+    void dispose ()
+    {
+        running.store (false);
+        if (mockThread.joinable ())
+        {
+            mockThread.join ();
+        }
+    }
+
+    ~MockMicrophone () { dispose (); }
+};

package/cpp/__tests__/CMakeLists.txt

@@ -0,0 +1,60 @@
+cmake_minimum_required(VERSION 3.14)
+project(testcpp)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+get_filename_component(TOP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../.. ABSOLUTE)
+set(LIBDATACHANNEL_PATH ${TOP_PATH}/3rdparty/output/unittest/libdatachannel)
+set(FFMPEG_PATH ${TOP_PATH}/3rdparty/output/unittest/ffmpeg)
+set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
+
+enable_testing()
+find_package(GTest REQUIRED)
+
+file(GLOB CPP_SOURCES
+    ${TOP_PATH}/cpp/*.cpp
+    ${TOP_PATH}/cpp/FFmpeg/*.cpp
+    ${TOP_PATH}/cpp/__tests__/*.cpp
+    ${TOP_PATH}/cpp/__tests__/FFmpeg/*.cpp
+)
+
+add_executable(
+    testcpp
+    ${CPP_SOURCES}
+)
+
+target_include_directories(
+    testcpp
+    PUBLIC
+    ${TOP_PATH}/cpp/
+    ${TOP_PATH}/cpp/FFmpeg/
+    SYSTEM
+    ${LIBDATACHANNEL_PATH}/include
+    ${FFMPEG_PATH}/include
+)
+
+target_link_libraries(
+    testcpp
+    PRIVATE
+    ${LIBDATACHANNEL_PATH}/lib/libdatachannel.a
+    ${LIBDATACHANNEL_PATH}/lib/libjuice.a
+    ${LIBDATACHANNEL_PATH}/lib/libsrtp2.a
+    ${LIBDATACHANNEL_PATH}/lib/libusrsctp.a
+    ${LIBDATACHANNEL_PATH}/lib/libmbedtls.a
+    ${LIBDATACHANNEL_PATH}/lib/libmbedx509.a
+    ${LIBDATACHANNEL_PATH}/lib/libmbedcrypto.a
+    ${FFMPEG_PATH}/lib/libavformat.a
+    ${FFMPEG_PATH}/lib/libavcodec.a
+    ${FFMPEG_PATH}/lib/libswscale.a
+    ${FFMPEG_PATH}/lib/libswresample.a
+    ${FFMPEG_PATH}/lib/libavutil.a
+    opus
+    x264
+    x265
+    z
+    GTest::gtest
+    GTest::gtest_main
+)

package/cpp/__tests__/FFmpeg/testAudioFifo.cpp

@@ -0,0 +1,79 @@
+#include "FFmpeg.hpp"
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int SAMPLE_RATE = 48000;
+constexpr int NB_SAMPLES = 960;
+
+TEST (AudioFifoTest, testNormal)
+{
+    AudioFifo fifo;
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    fifo.write (inputFrame);
+    std::optional<Frame> outFrame = fifo.read (NB_SAMPLES);
+
+    ASSERT_TRUE (outFrame.has_value ()) << "Expected to read frame from FIFO";
+    ASSERT_EQ (outFrame.value ()->nb_samples, NB_SAMPLES);
+    ASSERT_EQ (outFrame.value ()->format, AV_SAMPLE_FMT_FLT);
+    ASSERT_EQ (outFrame.value ()->sample_rate, SAMPLE_RATE);
+    ASSERT_EQ (outFrame.value ()->ch_layout.nb_channels, 1);
+}
+
+TEST (AudioFifoTest, testPts)
+{
+    AudioFifo fifo;
+    Frame in1 (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES, 1);
+    Frame in2 (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES, NB_SAMPLES + 1);
+
+    fifo.write (in1);
+    fifo.write (in2);
+
+    std::optional<Frame> out1 = fifo.read (NB_SAMPLES);
+    ASSERT_TRUE (out1.has_value ()) << "Expected first frame";
+    ASSERT_EQ (out1.value ()->pts, 1);
+
+    auto out2 = fifo.read (NB_SAMPLES);
+    ASSERT_TRUE (out2.has_value ()) << "Expected second frame";
+    ASSERT_EQ (out2.value ()->pts, 961);
+}
+
+TEST (AudioFifoTest, testEmpty)
+{
+    AudioFifo fifo;
+    std::optional<Frame> outFrame = fifo.read (NB_SAMPLES);
+    ASSERT_FALSE (outFrame.has_value ()) << "Should not read from empty FIFO";
+}
+
+TEST (AudioFifoTest, testPartialRead)
+{
+    AudioFifo fifo;
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    fifo.write (inputFrame);
+    std::optional<Frame> outFrame = fifo.read (NB_SAMPLES / 2); // read half
+    ASSERT_TRUE (outFrame.has_value ());
+    ASSERT_EQ (outFrame.value ()->nb_samples, NB_SAMPLES / 2);
+}
+
+TEST (AudioFifoTest, testMultipleWrites)
+{
+    AudioFifo fifo;
+    constexpr int FRAME_NUMBERS = 5;
+
+    for (int i = 0; i < FRAME_NUMBERS; i++)
+    {
+        Frame frame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+        frame.fillNoise ();
+        fifo.write (frame);
+    }
+
+    for (int i = 0; i < FRAME_NUMBERS; i++)
+    {
+        std::optional<Frame> outFrame = fifo.read (NB_SAMPLES);
+        ASSERT_TRUE (outFrame.has_value ()) << "Failed at iteration " << i;
+    }
+}

package/cpp/__tests__/FFmpeg/testCommon.cpp

@@ -0,0 +1,44 @@
+#include "FFmpeg.hpp"
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int AUDIO_SAMPLE_RATE = 48000;
+constexpr int VIDEO_SAMPLE_RATE = 90000;
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+constexpr int TIME_MS = 1000;
+
+void sleep_ms (int time_ms)
+{
+    using namespace std::chrono;
+
+    auto start = high_resolution_clock::now ();
+    auto end = start + milliseconds (time_ms);
+
+    while (high_resolution_clock::now () < end)
+    {
+    }
+}
+
+TEST (currentPtsTest, test90k)
+{
+    const AVRational timebase = { 1, VIDEO_SAMPLE_RATE };
+
+    int64_t pts1 = currentPts (timebase);
+    sleep_ms (TIME_MS);
+    int64_t pts2 = currentPts (timebase);
+
+    ASSERT_NEAR (pts2 - pts1, VIDEO_SAMPLE_RATE, 90);
+}
+
+TEST (currentPtsTest, test48K)
+{
+    const AVRational timebase = { 1, AUDIO_SAMPLE_RATE };
+
+    auto pts1 = currentPts (timebase);
+    sleep_ms (TIME_MS);
+    auto pts2 = currentPts (timebase);
+
+    ASSERT_NEAR (pts2 - pts1, AUDIO_SAMPLE_RATE, 48);
+}

package/cpp/__tests__/FFmpeg/testDecoder.cpp

@@ -0,0 +1,84 @@
+#include "FFmpeg.hpp"
+#include <filesystem>
+#include <gtest/gtest.h>
+#include <thread>
+
+using namespace FFmpeg;
+
+constexpr int SAMPLE_RATE = 48000;
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+
+TEST (DecoderTest, testOpus)
+{
+    constexpr int NB_SAMPLES = 960;
+    constexpr int NB_FRAMES = 10;
+    constexpr int TIME_DELAY_MS = 20;
+
+    Encoder encoder (AV_CODEC_ID_OPUS);
+    for (int i = 0; i < NB_FRAMES; ++i)
+    {
+        Frame inputFrame (AV_SAMPLE_FMT_FLTP, SAMPLE_RATE, 2, NB_SAMPLES);
+        inputFrame.fillNoise ();
+        encoder.send (inputFrame);
+        std::this_thread::sleep_for (
+            std::chrono::milliseconds (TIME_DELAY_MS));
+    }
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    Decoder decoder (AV_CODEC_ID_OPUS);
+    for (const auto &packet : packets)
+    {
+        decoder.send (packet);
+    }
+    decoder.flush ();
+    std::vector<Frame> frames = decoder.receive ();
+    ASSERT_GT (frames.size (), 0);
+}
+
+TEST (EncoderTest, testH264)
+{
+    constexpr int NB_FRAMES = 10;
+    Encoder encoder (AV_CODEC_ID_H264);
+    for (int i = 0; i < NB_FRAMES; ++i)
+    {
+        Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+        inputFrame.fillNoise ();
+        encoder.send (inputFrame);
+    }
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    Decoder decoder (AV_CODEC_ID_H264);
+    for (const auto &packet : packets)
+    {
+        decoder.send (packet);
+    }
+    decoder.flush ();
+    std::vector<Frame> frames = decoder.receive ();
+    ASSERT_GT (frames.size (), 0);
+}
+
+TEST (EncoderTest, testH265)
+{
+    constexpr int NB_FRAMES = 10;
+    Encoder encoder (AV_CODEC_ID_H265);
+    for (int i = 0; i < NB_FRAMES; ++i)
+    {
+        Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+        inputFrame.fillNoise ();
+        encoder.send (inputFrame);
+    }
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    Decoder decoder (AV_CODEC_ID_H265);
+    for (const auto &packet : packets)
+    {
+        decoder.send (packet);
+    }
+    decoder.flush ();
+    std::vector<Frame> frames = decoder.receive ();
+    ASSERT_GT (frames.size (), 0);
+}