node-datachannel 0.30.0 → 0.31.0

package/dist/types/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel, SctpSettings, Direction, Channel, DescriptionType, LocalDescriptionInit, CertificateFingerprint, DataChannelInitConfig, RTCPeerConnectionState, RTCIceConnectionState, RTCSignalingState, RTCIceGatheringState, SelectedCandidateInfo, RtcConfig, IceUdpMuxRequest, WebSocketServerConfiguration } from './types.js';
+import { LogLevel, SctpSettings, Direction, Channel, DescriptionType, LocalDescriptionInit, CertificateFingerprint, DataChannelInitConfig, RTCPeerConnectionState, RTCIceConnectionState, RTCSignalingState, RTCIceGatheringState, SelectedCandidateInfo, RtcConfig, IceUdpMuxRequest, NalUnitSeparator, ObuPacketization, WebSocketServerConfiguration } from './types.js';
 export { IceServer, ProxyServer, ProxyServerType, RTCIceGathererState, RTCIceTransportState, RTCSdpType, RelayType, TransportPolicy } from './types.js';
 import DataChannelStream$1 from './datachannel-stream.js';
 import { WebSocketServer } from './websocket-server.js';
@@ -37,8 +37,10 @@ declare const Audio: {
 interface Video {
     addVideoCodec(payloadType: number, codec: string, profile?: string): void;
     addH264Codec(payloadType: number, profile?: string): void;
+    addH265Codec(payloadType: number): void;
     addVP8Codec(payloadType: number): void;
     addVP9Codec(payloadType: number): void;
+    addAV1Codec(payloadType: number): void;
     direction(): Direction;
     generateSdp(eol: string, addr: string, port: number): string;
     mid(): string;
@@ -75,7 +77,7 @@ interface Track {
     requestBitrate(bitRate: number): boolean;
     setBufferedAmountLowThreshold(newSize: number): void;
     requestKeyframe(): boolean;
-    setMediaHandler(handler: RtcpReceivingSession): void;
+    setMediaHandler(handler: MediaHandler): void;
     onOpen(cb: () => void): void;
     onClosed(cb: () => void): void;
     onError(cb: (err: string) => void): void;
@@ -153,11 +155,56 @@ interface IceUdpMuxListener {
 declare const IceUdpMuxListener: {
     new (port: number, address?: string): IceUdpMuxListener;
 };
-interface RtcpReceivingSession {
+interface RtpPacketizationConfig {
+    playoutDelayId: number;
+    playoutDelayMin: number;
+    playoutDelayMax: number;
+    timestamp: number;
+    get clockRate(): number;
+}
+declare const RtpPacketizationConfig: {
+    new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig;
+};
+interface MediaHandler {
+    addToChain(handler: MediaHandler): void;
+}
+interface RtcpReceivingSession extends MediaHandler {
 }
 declare const RtcpReceivingSession: {
     new (): RtcpReceivingSession;
 };
+interface RtcpNackResponder extends MediaHandler {
+}
+declare const RtcpNackResponder: {
+    new (maxSize?: number): RtcpNackResponder;
+};
+interface RtcpSrReporter extends MediaHandler {
+    get rtpConfig(): RtpPacketizationConfig;
+}
+declare const RtcpSrReporter: {
+    new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter;
+};
+interface RtpPacketizer extends MediaHandler {
+    get rtpConfig(): RtpPacketizationConfig;
+}
+declare const RtpPacketizer: {
+    new (rtpConfig: RtpPacketizationConfig): RtpPacketizer;
+};
+interface H264RtpPacketizer extends RtpPacketizer {
+}
+declare const H264RtpPacketizer: {
+    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer;
+};
+interface H265RtpPacketizer extends RtpPacketizer {
+}
+declare const H265RtpPacketizer: {
+    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer;
+};
+interface AV1RtpPacketizer extends RtpPacketizer {
+}
+declare const AV1RtpPacketizer: {
+    new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer;
+};
 
 declare const DataChannelStream: typeof DataChannelStream$1;
 declare const _default: {
@@ -167,6 +214,13 @@ declare const _default: {
     setSctpSettings: typeof setSctpSettings;
     getLibraryVersion: typeof getLibraryVersion;
     RtcpReceivingSession: new () => RtcpReceivingSession;
+    RtcpNackResponder: new (maxSize?: number) => RtcpNackResponder;
+    RtcpSrReporter: new (rtpConfig: RtpPacketizationConfig) => RtcpSrReporter;
+    RtpPacketizationConfig: new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number) => RtpPacketizationConfig;
+    RtpPacketizer: new (rtpConfig: RtpPacketizationConfig) => RtpPacketizer;
+    H264RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H264RtpPacketizer;
+    H265RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H265RtpPacketizer;
+    AV1RtpPacketizer: new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => AV1RtpPacketizer;
     Track: new () => Track;
     Video: new (mid: string, dir: Direction) => Video;
     Audio: new (mid: string, dir: Direction) => Audio;
@@ -178,4 +232,4 @@ declare const _default: {
     IceUdpMuxListener: new (port: number, address?: string) => IceUdpMuxListener;
 };
 
-export { Audio, CertificateFingerprint, Channel, DataChannel, DataChannelInitConfig, DataChannelStream, DescriptionType, Direction, IceUdpMuxListener, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, PeerConnection, RTCIceConnectionState, RTCIceGatheringState, RTCPeerConnectionState, RTCSignalingState, RtcConfig, RtcpReceivingSession, SctpSettings, SelectedCandidateInfo, Track, Video, WebSocket, WebSocketServer, WebSocketServerConfiguration, cleanup, _default as default, getLibraryVersion, initLogger, preload, setSctpSettings };
+export { AV1RtpPacketizer, Audio, CertificateFingerprint, Channel, DataChannel, DataChannelInitConfig, DataChannelStream, DescriptionType, Direction, H264RtpPacketizer, H265RtpPacketizer, IceUdpMuxListener, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, type MediaHandler, NalUnitSeparator, ObuPacketization, PeerConnection, RTCIceConnectionState, RTCIceGatheringState, RTCPeerConnectionState, RTCSignalingState, RtcConfig, RtcpNackResponder, RtcpReceivingSession, RtcpSrReporter, RtpPacketizationConfig, RtpPacketizer, SctpSettings, SelectedCandidateInfo, Track, Video, WebSocket, WebSocketServer, WebSocketServerConfiguration, cleanup, _default as default, getLibraryVersion, initLogger, preload, setSctpSettings };

package/dist/types/lib/types.d.ts

@@ -112,5 +112,7 @@ interface IceUdpMuxRequest {
     host: string;
     port: number;
 }
+type NalUnitSeparator = 'Length' | 'ShortStartSequence' | 'LongStartSequence' | 'StartSequence';
+type ObuPacketization = 'Obu' | 'TemporalUnit';
 
-export type { CertificateFingerprint, Channel, DataChannelInitConfig, DescriptionType, Direction, IceServer, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, ProxyServer, ProxyServerType, RTCIceConnectionState, RTCIceGathererState, RTCIceGatheringState, RTCIceTransportState, RTCPeerConnectionState, RTCSdpType, RTCSignalingState, RelayType, RtcConfig, SctpSettings, SelectedCandidateInfo, TransportPolicy, WebSocketServerConfiguration };
+export type { CertificateFingerprint, Channel, DataChannelInitConfig, DescriptionType, Direction, IceServer, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, NalUnitSeparator, ObuPacketization, ProxyServer, ProxyServerType, RTCIceConnectionState, RTCIceGathererState, RTCIceGatheringState, RTCIceTransportState, RTCPeerConnectionState, RTCSdpType, RTCSignalingState, RelayType, RtcConfig, SctpSettings, SelectedCandidateInfo, TransportPolicy, WebSocketServerConfiguration };

package/dist/types/polyfill/RTCPeerConnection.d.ts

@@ -1,6 +1,7 @@
 import { SelectedCandidateInfo } from '../lib/types';
 import { PeerConnection } from '../lib/index';
 import RTCDataChannel from './RTCDataChannel.js';
+import { RTCDataChannelEvent } from './Events.js';
 import RTCCertificate from './RTCCertificate.js';
 
 interface RTCConfiguration extends globalThis.RTCConfiguration {
@@ -11,7 +12,7 @@ declare class RTCPeerConnection extends EventTarget implements globalThis.RTCPee
     #private;
     static generateCertificate(): Promise<RTCCertificate>;
     onconnectionstatechange: globalThis.RTCPeerConnection['onconnectionstatechange'];
-    ondatachannel: ((this: globalThis.RTCPeerConnection, ev: globalThis.RTCDataChannelEvent) => any) | null;
+    ondatachannel: ((this: globalThis.RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
     onicecandidate: globalThis.RTCPeerConnection['onicecandidate'];
     onicecandidateerror: globalThis.RTCPeerConnection['onicecandidateerror'];
     oniceconnectionstatechange: globalThis.RTCPeerConnection['oniceconnectionstatechange'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-datachannel",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "WebRTC For Node.js and Electron. libdatachannel node bindings.",
   "main": "./dist/cjs/lib/index.cjs",
   "module": "./dist/esm/lib/index.mjs",

package/rollup.config.mjs

@@ -10,7 +10,7 @@ const external = (id) => {
 const bundle = (config) => ({
   ...config,
   input: 'src/index.ts',
-  external,
+  external: ['events','stream'] // <-- suppresses the warning for these built-in modules
 });
 
 export default [

package/src/cpp/main.cpp

@@ -5,7 +5,14 @@
 #include "ice-udp-mux-listener-wrapper.h"
 
 #if RTC_ENABLE_MEDIA == 1
+#include "media-av1rtppacketizer-wrapper.h"
+#include "media-h264rtppacketizer-wrapper.h"
+#include "media-h265rtppacketizer-wrapper.h"
+#include "media-rtcpnackresponder-wrapper.h"
 #include "media-rtcpreceivingsession-wrapper.h"
+#include "media-rtcpsrreporter-wrapper.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-rtppacketizer-wrapper.h"
 #include "media-track-wrapper.h"
 #include "media-video-wrapper.h"
 #include "media-audio-wrapper.h"
@@ -21,7 +28,14 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports)
   RtcWrapper::Init(env, exports);
 
 #if RTC_ENABLE_MEDIA == 1
+  AV1RtpPacketizerWrapper::Init(env, exports);
+  H264RtpPacketizerWrapper::Init(env, exports);
+  H265RtpPacketizerWrapper::Init(env, exports);
+  RtcpNackResponderWrapper::Init(env, exports);
   RtcpReceivingSessionWrapper::Init(env, exports);
+  RtcpSrReporterWrapper::Init(env, exports);
+  RtpPacketizationConfigWrapper::Init(env, exports);
+  RtpPacketizerWrapper::Init(env, exports);
   TrackWrapper::Init(env, exports);
   VideoWrapper::Init(env, exports);
   AudioWrapper::Init(env, exports);

package/src/cpp/media-av1packetization.cpp

@@ -0,0 +1,24 @@
+#include "media-av1packetization.h"
+
+using Packetization = rtc::AV1RtpPacketizer::Packetization;
+
+std::optional<Packetization> strToPacketization(const std::string &packAsStr)
+{
+  if (packAsStr == "Obu")
+    return Packetization::Obu;
+  if (packAsStr == "TemporalUnit")
+    return Packetization::TemporalUnit;
+  return {};
+}
+
+std::string packetizationToStr(rtc::AV1RtpPacketizer::Packetization pack)
+{
+  switch (pack)
+  {
+  case Packetization::Obu:
+    return "Obu";
+  case Packetization::TemporalUnit:
+    return "TemporalUnit";
+  }
+  return "Unknown";
+}

package/src/cpp/media-av1packetization.h

@@ -0,0 +1,11 @@
+#ifndef MEDIA_AV1PACKETIZATION_H
+#define MEDIA_AV1PACKETIZATION_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+#include <optional>
+
+std::optional<rtc::AV1RtpPacketizer::Packetization> strToPacketization(const std::string &pktAsStr);
+std::string packetizationToStr(rtc::AV1RtpPacketizer::Packetization pkt);
+
+#endif // MEDIA_AV1PACKETIZATION_H

package/src/cpp/media-av1rtppacketizer-wrapper.cpp

@@ -0,0 +1,126 @@
+#include "media-av1rtppacketizer-wrapper.h"
+#include "media-av1packetization.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference AV1RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object AV1RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<AV1RtpPacketizerWrapper>::DefineClass(env, "AV1RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &AV1RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &AV1RtpPacketizerWrapper::getRtpPacketizationConfig, nullptr),
+    });
+
+  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+  if (constructor.IsEmpty())
+  {
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+  }
+
+  exports.Set("AV1RtpPacketizer", func);
+  return exports;
+}
+
+AV1RtpPacketizerWrapper::AV1RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<AV1RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "packetization must be \"Obu\" or \"TemporalUnit\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto packetizationOpt = strToPacketization(info[0].As<Napi::String>().Utf8Value());
+  if (!packetizationOpt.has_value())
+  {
+    Napi::TypeError::New(env, "packetization must be \"Obu\" or \"TemporalUnit\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto packetization = packetizationOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].As<Napi::Object>();
+  if (!obj.InstanceOf(RtpPacketizationConfigWrapper::constructor.Value()))
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  // store original JS object so we can return it later
+  mRtpConfigObject = Napi::Persistent(obj);
+  mRtpConfigObject.SuppressDestruct();
+  auto rtpConfig = RtpPacketizationConfigWrapper::Unwrap(obj)->getConfigInstance();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::AV1RtpPacketizer>(packetization, rtpConfig, maxFragmentSize);
+}
+
+AV1RtpPacketizerWrapper::~AV1RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::AV1RtpPacketizer> AV1RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void AV1RtpPacketizerWrapper::addToChain(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto mediaHandler = asMediaHandler(info[0].As<Napi::Object>());
+  if (!mediaHandler)
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance. If this error is unexpected, please report a bug!")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  mPacketizerPtr->addToChain(mediaHandler);
+}
+
+Napi::Value AV1RtpPacketizerWrapper::getRtpPacketizationConfig(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  if (!mPacketizerPtr)
+  {
+    Napi::Error::New(env, "getRtpPacketizationConfig() called on destroyed packetizer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (mRtpConfigObject.IsEmpty())
+    return env.Null();
+
+  return mRtpConfigObject.Value();
+}

package/src/cpp/media-av1rtppacketizer-wrapper.h

@@ -0,0 +1,29 @@
+#ifndef MEDIA_AV1RTPPACKETIZER_WRAPPER_H
+#define MEDIA_AV1RTPPACKETIZER_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class AV1RtpPacketizerWrapper : public Napi::ObjectWrap<AV1RtpPacketizerWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  AV1RtpPacketizerWrapper(const Napi::CallbackInfo &info);
+  ~AV1RtpPacketizerWrapper();
+  std::shared_ptr<rtc::AV1RtpPacketizer> getPacketizerInstance();
+
+  // Functions
+  Napi::Value getRtpPacketizationConfig(const Napi::CallbackInfo &info);
+  void addToChain(const Napi::CallbackInfo &info);
+  // Callbacks
+
+private:
+  std::shared_ptr<rtc::AV1RtpPacketizer> mPacketizerPtr = nullptr;
+  Napi::ObjectReference mRtpConfigObject;
+};
+
+#endif // MEDIA_AV1RTPPACKETIZER_WRAPPER_H

package/src/cpp/media-h264rtppacketizer-wrapper.cpp

@@ -0,0 +1,126 @@
+#include "media-h264rtppacketizer-wrapper.h"
+#include "media-h26xseparator.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference H264RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object H264RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<H264RtpPacketizerWrapper>::DefineClass(env, "H264RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &H264RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &H264RtpPacketizerWrapper::getRtpPacketizationConfig, nullptr),
+    });
+
+  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+  if (constructor.IsEmpty())
+  {
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+  }
+
+  exports.Set("H264RtpPacketizer", func);
+  return exports;
+}
+
+H264RtpPacketizerWrapper::H264RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<H264RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separatorOpt = strToSeparator(info[0].As<Napi::String>().Utf8Value());
+  if (!separatorOpt.has_value())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separator = separatorOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].As<Napi::Object>();
+  if (!obj.InstanceOf(RtpPacketizationConfigWrapper::constructor.Value()))
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  // store original JS object so we can return it later
+  mRtpConfigObject = Napi::Persistent(obj);
+  mRtpConfigObject.SuppressDestruct();
+  auto rtpConfig = RtpPacketizationConfigWrapper::Unwrap(obj)->getConfigInstance();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::H264RtpPacketizer>(separator, rtpConfig, maxFragmentSize);
+}
+
+H264RtpPacketizerWrapper::~H264RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::H264RtpPacketizer> H264RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void H264RtpPacketizerWrapper::addToChain(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto mediaHandler = asMediaHandler(info[0].As<Napi::Object>());
+  if (!mediaHandler)
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance. If this error is unexpected, please report a bug!")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+  mPacketizerPtr->addToChain(mediaHandler);
+}
+
+Napi::Value H264RtpPacketizerWrapper::getRtpPacketizationConfig(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  if (!mPacketizerPtr)
+  {
+    Napi::Error::New(env, "getRtpPacketizationConfig() called on destroyed packetizer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (mRtpConfigObject.IsEmpty())
+    return env.Null();
+
+  return mRtpConfigObject.Value();
+}

package/src/cpp/media-h264rtppacketizer-wrapper.h

@@ -0,0 +1,30 @@
+#ifndef MEDIA_H264RTPPACKETIZER_WRAPPER_H
+#define MEDIA_H264RTPPACKETIZER_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class H264RtpPacketizerWrapper : public Napi::ObjectWrap<H264RtpPacketizerWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  H264RtpPacketizerWrapper(const Napi::CallbackInfo &info);
+  ~H264RtpPacketizerWrapper();
+  std::shared_ptr<rtc::H264RtpPacketizer> getPacketizerInstance();
+
+  // Functions
+  Napi::Value getRtpPacketizationConfig(const Napi::CallbackInfo &info);
+  void addToChain(const Napi::CallbackInfo &info);
+
+  // Callbacks
+
+private:
+  std::shared_ptr<rtc::H264RtpPacketizer> mPacketizerPtr = nullptr;
+  Napi::ObjectReference mRtpConfigObject;
+};
+
+#endif // MEDIA_H264RTPPACKETIZER_WRAPPER_H

package/src/cpp/media-h265rtppacketizer-wrapper.cpp

@@ -0,0 +1,126 @@
+#include "media-h265rtppacketizer-wrapper.h"
+#include "media-h26xseparator.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference H265RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object H265RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<H265RtpPacketizerWrapper>::DefineClass(env, "H265RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &H265RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &H265RtpPacketizerWrapper::getRtpPacketizationConfig, nullptr),
+    });
+
+  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+  if (constructor.IsEmpty())
+  {
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+  }
+
+  exports.Set("H265RtpPacketizer", func);
+  return exports;
+}
+
+H265RtpPacketizerWrapper::H265RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<H265RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separatorOpt = strToSeparator(info[0].As<Napi::String>().Utf8Value());
+  if (!separatorOpt.has_value())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separator = separatorOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].As<Napi::Object>();
+  if (!obj.InstanceOf(RtpPacketizationConfigWrapper::constructor.Value()))
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  // store original JS object so we can return it later
+  mRtpConfigObject = Napi::Persistent(obj);
+  mRtpConfigObject.SuppressDestruct();
+  auto rtpConfig = RtpPacketizationConfigWrapper::Unwrap(obj)->getConfigInstance();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::H265RtpPacketizer>(separator, rtpConfig, maxFragmentSize);
+}
+
+H265RtpPacketizerWrapper::~H265RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::H265RtpPacketizer> H265RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void H265RtpPacketizerWrapper::addToChain(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto mediaHandler = asMediaHandler(info[0].As<Napi::Object>());
+  if (!mediaHandler)
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance. If this error is unexpected, please report a bug!")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+  mPacketizerPtr->addToChain(mediaHandler);
+}
+
+Napi::Value H265RtpPacketizerWrapper::getRtpPacketizationConfig(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  if (!mPacketizerPtr)
+  {
+    Napi::Error::New(env, "getRtpPacketizationConfig() called on destroyed packetizer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (mRtpConfigObject.IsEmpty())
+    return env.Null();
+
+  return mRtpConfigObject.Value();
+}