react-native-webrtc-nitro 1.0.0

package/cpp/__tests__/FFmpeg/testEncoder.cpp

@@ -0,0 +1,198 @@
+#include "FFmpeg.hpp"
+#include <filesystem>
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int SAMPLE_RATE = 48000;
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+
+TEST (EncoderTest, testOpusOneFrame)
+{
+    constexpr int NB_SAMPLES = 960;
+    Encoder encoder (AV_CODEC_ID_OPUS);
+    Frame inputFrame (AV_SAMPLE_FMT_FLTP, SAMPLE_RATE, 2, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0) << "Opus encoder should produce packets";
+}
+
+TEST (EncoderTest, testOpusMultiFrame)
+{
+    constexpr int NB_SAMPLES = 960;
+    constexpr int NB_FRAMES = 10;
+
+    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);
+    }
+
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0)
+        << "Opus encoder should handle multi-frame input";
+}
+
+TEST (EncoderTest, testOpusBigFrame)
+{
+    constexpr int NB_SAMPLES = 960000;
+    Encoder encoder (AV_CODEC_ID_OPUS);
+    Frame inputFrame (AV_SAMPLE_FMT_FLTP, SAMPLE_RATE, 2, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0)
+        << "Opus encoder should handle large frames";
+}
+
+TEST (EncoderTest, testH264OneFrame)
+{
+    Encoder encoder (AV_CODEC_ID_H264);
+    Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0) << "H264 encoder should produce packets";
+}
+
+TEST (EncoderTest, testH264MultiFrame)
+{
+    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 ();
+
+    ASSERT_GT (packets.size (), 0)
+        << "H264 encoder should handle multi-frame input";
+}
+
+TEST (EncoderTest, testH265OneFrame)
+{
+    Encoder encoder (AV_CODEC_ID_H265);
+    Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0) << "H265 encoder should produce packets";
+}
+
+TEST (EncoderTest, testH265MultiFrame)
+{
+    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 ();
+
+    ASSERT_GT (packets.size (), 0)
+        << "H265 encoder should handle multi-frame input";
+}
+
+TEST (EncoderTest, testAACOneFrame)
+{
+    constexpr int NB_SAMPLES = 1024;
+    Encoder encoder (AV_CODEC_ID_AAC);
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0) << "AAC encoder should produce packets";
+}
+
+TEST (EncoderTest, testAACMultiFrame)
+{
+    constexpr int NB_SAMPLES = 1024;
+    constexpr int NB_FRAMES = 10;
+
+    Encoder encoder (AV_CODEC_ID_AAC);
+
+    for (int i = 0; i < NB_FRAMES; ++i)
+    {
+        Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+        inputFrame.fillNoise ();
+        encoder.send (inputFrame);
+    }
+
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0)
+        << "AAC encoder should handle multi-frame input";
+}
+
+TEST (EncoderTest, testAACBigFrame)
+{
+    constexpr int NB_SAMPLES = 1024000;
+    Encoder encoder (AV_CODEC_ID_AAC);
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    encoder.send (inputFrame);
+    encoder.flush ();
+    std::vector<Packet> packets = encoder.receive ();
+
+    ASSERT_GT (packets.size (), 0) << "AAC encoder should handle large frames";
+}
+
+TEST (EncoderTest, testPng)
+{
+    Encoder encoder (AV_CODEC_ID_PNG);
+    Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    inputFrame.fillNoise ();
+
+    std::string path = testing::TempDir () + "out.png";
+
+    // std::string file = "out.png";
+    FILE *file = fopen (path.c_str (), "wb");
+    encoder.send (inputFrame);
+    encoder.flush ();
+    for (auto &pkt : encoder.receive ())
+    {
+        fwrite (pkt->data, 1, pkt->size, file);
+    }
+    fclose (file);
+
+    ASSERT_TRUE (std::filesystem::exists (path));
+
+    auto fileSize = std::filesystem::file_size (path);
+    ASSERT_GT (fileSize, 0) << "PNG file should not be empty";
+
+    std::filesystem::remove (path);
+}

package/cpp/__tests__/FFmpeg/testFrame.cpp

@@ -0,0 +1,95 @@
+#include "FFmpeg.hpp"
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int AUDIO_SAMPLE_RATE = 48000;
+constexpr int NB_SAMPLES = 960;
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+
+TEST (FrameTest, testAudioFrame)
+{
+    const AVRational timebase = { 1, AUDIO_SAMPLE_RATE };
+
+    int64_t ptsStart = currentPts (timebase);
+    Frame frame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 2, NB_SAMPLES);
+    int64_t ptsEnd = currentPts (timebase);
+
+    ASSERT_EQ (frame->format, AV_SAMPLE_FMT_FLT);
+    ASSERT_EQ (frame->sample_rate, AUDIO_SAMPLE_RATE);
+    ASSERT_EQ (frame->ch_layout.nb_channels, 2);
+    ASSERT_EQ (frame->nb_samples, NB_SAMPLES);
+    ASSERT_GE (frame->pts, ptsStart);
+    ASSERT_LE (frame->pts, ptsEnd);
+}
+
+TEST (FrameTest, testVideoFrame)
+{
+    constexpr int VIDEO_SAMPLE_RATE = 90000;
+    const AVRational timebase = { 1, VIDEO_SAMPLE_RATE };
+
+    int64_t ptsStart = currentPts (timebase);
+    Frame frame (AV_PIX_FMT_YUV420P, WIDTH, HEIGHT);
+    int64_t ptsEnd = currentPts (timebase);
+
+    ASSERT_EQ (frame->format, AV_PIX_FMT_YUV420P);
+    ASSERT_EQ (frame->width, WIDTH);
+    ASSERT_EQ (frame->height, HEIGHT);
+    ASSERT_GE (frame->pts, ptsStart);
+    ASSERT_LE (frame->pts, ptsEnd);
+}
+
+TEST (NoiseTest, testAudioS16)
+{
+    Frame frame (AV_SAMPLE_FMT_S16, AUDIO_SAMPLE_RATE, 2, NB_SAMPLES);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testAudioS16P)
+{
+    Frame frame (AV_SAMPLE_FMT_S16P, AUDIO_SAMPLE_RATE, 2, NB_SAMPLES);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testAudioFLT)
+{
+    Frame frame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 2, NB_SAMPLES);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testAudioFLTP)
+{
+    Frame frame (AV_SAMPLE_FMT_FLTP, AUDIO_SAMPLE_RATE, 2, NB_SAMPLES);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testVideoRGB24)
+{
+    Frame frame (AV_PIX_FMT_RGB24, WIDTH, HEIGHT);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testVideoRGBA)
+{
+    Frame frame (AV_PIX_FMT_RGBA, WIDTH, HEIGHT);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testVideoARGB)
+{
+    Frame frame (AV_PIX_FMT_ARGB, WIDTH, HEIGHT);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testVideoNV12)
+{
+    Frame frame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    frame.fillNoise ();
+}
+
+TEST (NoiseTest, testVideoYUV420P)
+{
+    Frame frame (AV_PIX_FMT_YUV420P, WIDTH, HEIGHT);
+    frame.fillNoise ();
+}

package/cpp/__tests__/FFmpeg/testMuxer.cpp

@@ -0,0 +1,75 @@
+#include "FFmpeg.hpp"
+#include <filesystem>
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int AUDIO_SAMPLE_RATE = 48000;
+constexpr int AUDIO_NB_SAMPLES = 2048;
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+
+TEST (MuxerTest, testMuxerAAC)
+{
+    std::string file = testing::TempDir () + "/test_file.mp4";
+    Muxer muxer (file, AV_CODEC_ID_AAC, AV_CODEC_ID_NONE);
+
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 1,
+                      AUDIO_NB_SAMPLES);
+    inputFrame.fillNoise ();
+    muxer.writeAudio (inputFrame);
+    muxer.stop ();
+
+    EXPECT_TRUE (std::filesystem::exists (file));
+}
+
+TEST (MuxerTest, testMuxerH264)
+{
+    std::string file = testing::TempDir () + "/test_file.mp4";
+
+    Muxer muxer (file, AV_CODEC_ID_NONE, AV_CODEC_ID_H264);
+    Frame inputFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    inputFrame.fillNoise ();
+    muxer.writeVideo (inputFrame);
+    muxer.stop ();
+
+    EXPECT_TRUE (std::filesystem::exists (file));
+}
+
+TEST (MuxerTest, testMuxerVideo)
+{
+    std::string file = testing::TempDir () + "/test_file.mp4";
+    Muxer muxer (file, AV_CODEC_ID_AAC, AV_CODEC_ID_H264);
+
+    Frame audioFrame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 1,
+                      AUDIO_NB_SAMPLES);
+    Frame videoFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT);
+    audioFrame.fillNoise ();
+    videoFrame.fillNoise ();
+    muxer.writeAudio (audioFrame);
+    muxer.writeVideo (videoFrame);
+
+    muxer.stop ();
+    EXPECT_TRUE (std::filesystem::exists (file));
+}
+
+TEST (MuxerTest, testSaveMp4)
+{
+    std::string file = "output.mp4";
+    Muxer muxer (file, AV_CODEC_ID_AAC, AV_CODEC_ID_H264);
+    constexpr int LOOPS = 1000;
+    constexpr int VIDEO_SAMPLES = 3000;
+
+    for (int i = 0; i < LOOPS; ++i)
+    {
+        Frame audioFrame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 1,
+                          AUDIO_NB_SAMPLES, i * AUDIO_NB_SAMPLES);
+        Frame videoFrame (AV_PIX_FMT_NV12, WIDTH, HEIGHT, i * VIDEO_SAMPLES);
+        audioFrame.fillNoise ();
+        videoFrame.fillNoise ();
+        muxer.writeAudio (audioFrame);
+        muxer.writeVideo (videoFrame);
+    }
+    muxer.stop ();
+    EXPECT_TRUE (std::filesystem::exists (file));
+}

package/cpp/__tests__/FFmpeg/testResampler.cpp

@@ -0,0 +1,164 @@
+#include "FFmpeg.hpp"
+#include <gtest/gtest.h>
+#include <thread>
+
+using namespace FFmpeg;
+
+constexpr int SAMPLE_RATE = 48000;
+constexpr int NB_SAMPLES = 960;
+
+auto resampleAndFlush (Frame &inputFrame, AVSampleFormat outFormat,
+                       int outSampleRate, int outChannels) -> Frame
+{
+    Resampler resampler;
+    AudioFifo fifo;
+
+    Frame frame1 = resampler.resample (inputFrame, outFormat, outSampleRate,
+                                       outChannels);
+    fifo.write (frame1);
+
+    Frame frame2 = resampler.flush ();
+    fifo.write (frame2);
+
+    auto outFrame = fifo.read (-1);
+    if (!outFrame.has_value ())
+    {
+        throw std::runtime_error ("No output frame from resampler");
+    }
+    return outFrame.value ();
+}
+
+TEST (ResamplerTest, testResampleFormat)
+{
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    Frame outFrame
+        = resampleAndFlush (inputFrame, AV_SAMPLE_FMT_S16, SAMPLE_RATE, 1);
+
+    ASSERT_EQ (outFrame->format, AV_SAMPLE_FMT_S16);
+    ASSERT_EQ (outFrame->nb_samples, NB_SAMPLES);
+
+    auto *inData = (float *)inputFrame->data[0];
+    auto *outData = (int16_t *)outFrame->data[0];
+    for (int i = 0; i < NB_SAMPLES; ++i)
+    {
+        EXPECT_NEAR (outData[i] / 32767.0, inData[i], 0.01);
+    }
+}
+
+TEST (ResamplerTest, testResamplePlanar)
+{
+    Frame inputFrame (AV_SAMPLE_FMT_FLTP, SAMPLE_RATE, 2, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    Frame outFrame
+        = resampleAndFlush (inputFrame, AV_SAMPLE_FMT_S16P, SAMPLE_RATE, 2);
+    ASSERT_EQ (outFrame->format, AV_SAMPLE_FMT_S16P);
+    ASSERT_EQ (outFrame->nb_samples, NB_SAMPLES);
+
+    auto *leftData = (float *)inputFrame->data[0];
+    auto *rightData = (float *)inputFrame->data[1];
+    auto *outLeft = (int16_t *)outFrame->data[0];
+    auto *outRight = (int16_t *)outFrame->data[1];
+    for (int i = 0; i < NB_SAMPLES; ++i)
+    {
+        EXPECT_NEAR (outLeft[i] / 32767.0, leftData[i], 0.01);
+        EXPECT_NEAR (outRight[i] / 32767.0, rightData[i], 0.01);
+    }
+}
+
+TEST (ResamplerTest, testResampleChannels12)
+{
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, NB_SAMPLES);
+    inputFrame.fillNoise ();
+
+    Frame outFrame
+        = resampleAndFlush (inputFrame, AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 2);
+    ASSERT_EQ (outFrame->format, AV_SAMPLE_FMT_FLT);
+    ASSERT_EQ (outFrame->nb_samples, NB_SAMPLES);
+
+    auto *inData = (float *)inputFrame->data[0];
+    auto *outData = (float *)outFrame->data[0];
+    for (int i = 0; i < NB_SAMPLES; ++i)
+    {
+        EXPECT_NEAR (outData[i * 2], inData[i] * 0.7071, 0.001);
+        EXPECT_NEAR (outData[i * 2 + 1], inData[i] * 0.7071, 0.001);
+    }
+}
+
+TEST (ResamplerTest, testResampleRate)
+{
+    constexpr int NB_SAMPLES_IN = 320;
+    constexpr int NB_SAMPLES_OUT = 960;
+    constexpr int SAMPLE_RATE_IN = 16000;
+    constexpr int SAMPLE_RATE_OUT = 48000;
+
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE_IN, 1, NB_SAMPLES_IN);
+    inputFrame.fillNoise ();
+    auto *inData = (float *)inputFrame->data[0];
+
+    Frame outFrame
+        = resampleAndFlush (inputFrame, AV_SAMPLE_FMT_FLT, SAMPLE_RATE_OUT, 1);
+
+    ASSERT_EQ (outFrame->nb_samples, NB_SAMPLES_OUT);
+    ASSERT_EQ (outFrame->ch_layout.nb_channels, 1);
+    ASSERT_EQ (outFrame->format, AV_SAMPLE_FMT_FLT);
+    ASSERT_EQ (outFrame->sample_rate, SAMPLE_RATE_OUT);
+
+    auto *outData = (float *)outFrame->data[0];
+    for (int i = 0; i < inputFrame->nb_samples; i++)
+    {
+        float outSample = outData[i * 3];
+        float inSample = inData[i];
+        EXPECT_NEAR (outSample, inSample, 0.01);
+    }
+}
+
+TEST (ResamplerTest, testPts)
+{
+    constexpr int NB_SAMPLES = 320;
+    constexpr int SAMPLE_RATE_IN = 16000;
+    constexpr int SAMPLE_RATE_OUT = 48000;
+
+    Frame in1 (AV_SAMPLE_FMT_FLT, SAMPLE_RATE_IN, 1, NB_SAMPLES, 1);
+    Frame in2 (AV_SAMPLE_FMT_FLT, SAMPLE_RATE_IN, 1, NB_SAMPLES,
+               NB_SAMPLES + 1);
+    in1.fillNoise ();
+    in1.fillNoise ();
+
+    Resampler resampler;
+    std::optional<Frame> out1
+        = resampler.resample (in1, AV_SAMPLE_FMT_FLT, SAMPLE_RATE_OUT, 1);
+    std::optional<Frame> out2
+        = resampler.resample (in2, AV_SAMPLE_FMT_FLT, SAMPLE_RATE_OUT, 1);
+    ASSERT_EQ (out1.value ()->pts, 1);
+    ASSERT_EQ (out2.value ()->pts, out1.value ()->nb_samples + 1);
+}
+
+TEST (ResamplerTest, testEmpty)
+{
+    constexpr int SAMPLE_RATE = 48000;
+    Resampler resampler;
+    Frame inputFrame (AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1, 0, 1);
+    resampler.resample (inputFrame, AV_SAMPLE_FMT_FLT, SAMPLE_RATE, 1);
+    resampler.flush ();
+}
+
+TEST (ResamplerTest, testContinue)
+{
+    constexpr int AUDIO_SAMPLE_RATE = 48000;
+    constexpr int NB_SAMPLES = 48000;
+    constexpr int DELAY_MS = 1000;
+
+    Resampler resampler;
+    for (int i = 0; i < 10; ++i)
+    {
+
+        FFmpeg::Frame frame (AV_SAMPLE_FMT_FLT, AUDIO_SAMPLE_RATE, 2,
+                             NB_SAMPLES);
+        frame.fillNoise ();
+        resampler.resample (frame, AV_SAMPLE_FMT_S16, AUDIO_SAMPLE_RATE, 2);
+        std::this_thread::sleep_for (std::chrono::milliseconds (DELAY_MS));
+    }
+}

package/cpp/__tests__/FFmpeg/testScaler.cpp

@@ -0,0 +1,35 @@
+#include "FFmpeg.hpp"
+#include <gtest/gtest.h>
+
+using namespace FFmpeg;
+
+constexpr int WIDTH_IN = 640;
+constexpr int HEIGHT_IN = 480;
+constexpr int WIDTH_OUT = 320;
+constexpr int HEIGHT_OUT = 240;
+
+TEST (ScalerTest, test_RGB24_to_NV12)
+{
+    Scaler scaler;
+    Frame inputFrame (AV_PIX_FMT_RGB24, WIDTH_IN, HEIGHT_IN);
+    Frame outFrame
+        = scaler.scale (inputFrame, AV_PIX_FMT_NV12, WIDTH_OUT, HEIGHT_OUT);
+
+    ASSERT_EQ (outFrame->format, AV_PIX_FMT_NV12);
+    ASSERT_EQ (outFrame->width, WIDTH_OUT);
+    ASSERT_EQ (outFrame->height, HEIGHT_OUT);
+    ASSERT_EQ (outFrame->pts, inputFrame->pts);
+}
+
+TEST (ScalerTest, test_NV12_to_RGB24)
+{
+    Scaler scaler;
+    Frame inputFrame (AV_PIX_FMT_NV12, WIDTH_IN, HEIGHT_IN);
+    Frame outFrame
+        = scaler.scale (inputFrame, AV_PIX_FMT_RGB24, WIDTH_OUT, HEIGHT_OUT);
+
+    ASSERT_EQ (outFrame->format, AV_PIX_FMT_RGB24);
+    ASSERT_EQ (outFrame->width, WIDTH_OUT);
+    ASSERT_EQ (outFrame->height, HEIGHT_OUT);
+    ASSERT_EQ (outFrame->pts, inputFrame->pts);
+}

package/cpp/__tests__/main.cpp

@@ -0,0 +1,7 @@
+#include <gtest/gtest.h>
+
+auto main (int argc, char **argv) -> int
+{
+    ::testing::InitGoogleTest (&argc, argv);
+    return RUN_ALL_TESTS ();
+}

package/cpp/__tests__/testFramePipe.cpp

@@ -0,0 +1,107 @@
+#include "FFmpeg.hpp"
+#include "FramePipe.hpp"
+#include <gtest/gtest.h>
+
+constexpr int SAMPLE_RATE = 48000;
+constexpr int NB_SAMPLES = 960;
+constexpr int CHANNELS = 2;
+
+TEST (FramePipeTest, testCallback)
+{
+    bool called = false;
+    int subscriptionIdSet = -1;
+    FrameCallback callback
+        = [&called, &subscriptionIdSet] (const std::string &pipeId,
+                                         int subscriptionId,
+                                         const FFmpeg::Frame &)
+    {
+        ASSERT_EQ (pipeId, std::string ("test_pipe"));
+        subscriptionIdSet = subscriptionId;
+        called = true;
+    };
+    int subscriptionId = subscribe ({ "test_pipe" }, callback);
+
+    FFmpeg::Frame frame (AV_SAMPLE_FMT_S16, SAMPLE_RATE, CHANNELS, NB_SAMPLES);
+
+    ASSERT_FALSE (called);
+    publish ("test_pipe", frame);
+    ASSERT_TRUE (called);
+    ASSERT_EQ (subscriptionIdSet, subscriptionId);
+
+    unsubscribe (subscriptionId);
+}
+
+TEST (FramePipeTest, testCallbackNotMatch)
+{
+    bool called = false;
+    FrameCallback callback
+        = [&called] (const std::string &, int, const FFmpeg::Frame &)
+    { called = true; };
+    int subscriptionId = subscribe ({ "test_pipe" }, callback);
+
+    FFmpeg::Frame frame (AV_SAMPLE_FMT_S16, SAMPLE_RATE, CHANNELS, NB_SAMPLES);
+
+    ASSERT_FALSE (called);
+    publish ("test_pipe2", frame);
+    ASSERT_FALSE (called);
+
+    unsubscribe (subscriptionId);
+}
+
+TEST (FramePipeTest, testCleanup)
+{
+    bool cleanedUp = false;
+    int subscriptionIdSet = -1;
+    FrameCallback callback
+        = [] (const std::string &, int, const FFmpeg::Frame &frame) {};
+    CleanupCallback cleanup
+        = [&cleanedUp, &subscriptionIdSet] (int subscriptionId)
+    {
+        cleanedUp = true;
+        subscriptionIdSet = subscriptionId;
+    };
+    int subscriptionId = subscribe ({ "test_pipe" }, callback, cleanup);
+
+    ASSERT_FALSE (cleanedUp);
+    unsubscribe (subscriptionId);
+    ASSERT_TRUE (cleanedUp);
+    ASSERT_EQ (subscriptionIdSet, subscriptionId);
+}
+
+TEST (FramePipeTest, testUnsubscribe)
+{
+    int count = 0;
+    FrameCallback callback = [&count] (const std::string &pipeId, int subId,
+                                       const FFmpeg::Frame &) { count += 1; };
+
+    int subscriptionId = subscribe ({ "test_pipe" }, callback);
+
+    FFmpeg::Frame frame (AV_SAMPLE_FMT_S16, SAMPLE_RATE, CHANNELS, NB_SAMPLES);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    unsubscribe (subscriptionId);
+    ASSERT_EQ (count, 4);
+}
+
+TEST (FramePipeTest, testUnsubscribeInCallback)
+{
+    int count = 0;
+    FrameCallback callback =
+        [&count] (const std::string &pipeId, int subId, const FFmpeg::Frame &)
+    {
+        count += 1;
+        unsubscribe (subId);
+    };
+
+    int subscriptionId = subscribe ({ "test_pipe" }, callback);
+
+    FFmpeg::Frame frame (AV_SAMPLE_FMT_S16, SAMPLE_RATE, CHANNELS, NB_SAMPLES);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    publish ("test_pipe", frame);
+    unsubscribe (subscriptionId);
+    ASSERT_EQ (count, 1);
+}

package/ios/FramePipeWrapper.h

@@ -0,0 +1,26 @@
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FramePipeWrapper : NSObject
+
++ (void)cameraPublishVideo:(CMSampleBufferRef)sampleBuffer
+                   pipeIds:(NSArray<NSString *> *)pipeIds;
+
++ (void)microphonePublishAudio:(CMSampleBufferRef)sampleBuffer
+                       pipeIds:(NSArray<NSString *> *)pipeIds;
+
++ (int)viewSubscribeVideo:(AVSampleBufferDisplayLayer *)displayLayer
+                   pipeId:(NSString *)pipeId;
+
++ (int)speakerSubscribeAudio:(AVAudioPlayerNode *)audioPlayer
+                      pipeId:(NSString *)pipeId
+                       queue:(dispatch_queue_t)queue;
+
++ (void)unsubscribe:(int)subscriptionId;
+
+@end
+
+NS_ASSUME_NONNULL_END