v0.0.34 - Implemented api about codec capability & parameters.

Author: oddengine

api.c

@@ -81,19 +81,22 @@ typedef void (*__rtp_transceiver_release_fptr__)(void *transceiver);
 
 typedef void *(*__rtp_receiver_get_track_fptr__)(void *receiver);
 typedef void (*__rtp_receiver_get_streams_fptr__)(void *receiver, size_t *size, void **array);
-typedef void (*__rtp_receiver_get_parameters_fptr__)(void *receiver, void *parameters);
+typedef void (*__rtp_receiver_get_parameters_fptr__)(void *receiver, raw_rtp_parameters_t *parameters);
 typedef void (*__rtp_receiver_get_stats_fptr__)(void *receiver, void *stats);
 typedef void (*__rtp_receiver_release_fptr__)(void *receiver);
 
 typedef int (*__rtp_sender_set_track_fptr__)(void *sender, void *track);
 typedef void *(*__rtp_sender_get_track_fptr__)(void *sender);
 typedef void (*__rtp_sender_set_streams_fptr__)(void *sender, size_t size, const char **stream_ids);
 typedef void (*__rtp_sender_get_streams_fptr__)(void *sender, size_t *size, void **array);
-typedef void (*__rtp_sender_set_parameters_fptr__)(void *sender, void *parameters);
-typedef void (*__rtp_sender_get_parameters_fptr__)(void *sender, void *parameters);
+typedef void (*__rtp_sender_set_parameters_fptr__)(void *sender, raw_rtp_parameters_t *parameters, raw_rtc_error_t *err);
+typedef void (*__rtp_sender_get_parameters_fptr__)(void *sender, raw_rtp_parameters_t *parameters);
 typedef void (*__rtp_sender_get_stats_fptr__)(void *sender, void *stats);
 typedef void (*__rtp_sender_release_fptr__)(void *sender);
 
+typedef void (*__rtp_codec_capability_release_fptr__)(void *capability);
+typedef void (*__rtp_codec_parameters_release_fptr__)(void *parameters);
+
 __initialize_library_fptr__ __initialize_library__;
 __calloc_fptr__ __calloc__;
 __free_fptr__ __free__;
@@ -172,6 +175,9 @@ __rtp_sender_get_parameters_fptr__ __rtp_sender_get_parameters__;
 __rtp_sender_get_stats_fptr__ __rtp_sender_get_stats__;
 __rtp_sender_release_fptr__ __rtp_sender_release__;
 
+__rtp_codec_capability_release_fptr__ __rtp_codec_capability_release__;
+__rtp_codec_parameters_release_fptr__ __rtp_codec_parameters_release__;
+
 raw_peer_connection_observer_t *__peer_connection_observer__;
 extern void __onsignalingchange__(void *observer, const char *new_state);
 extern void __ondatachannel__(void *observer, void *data_channel);
@@ -285,6 +291,9 @@ int InitializeLibrary(const char *file, raw_rtc_constraints_t constraints)
     __rtp_sender_get_stats__ = (__rtp_sender_get_stats_fptr__)dlsym(handle, "RtpSenderGetStats");
     __rtp_sender_release__ = (__rtp_sender_release_fptr__)dlsym(handle, "RtpSenderRelease");
 
+    __rtp_codec_capability_release__ = (__rtp_codec_capability_release_fptr__)dlsym(handle, "RtpCodecCapabilityRelease");
+    __rtp_codec_parameters_release__ = (__rtp_codec_parameters_release_fptr__)dlsym(handle, "RtpCodecParametersRelease");
+
     __peer_connection_observer__ = malloc(sizeof(raw_peer_connection_observer_t));
     __peer_connection_observer__->onsignalingchange = __onsignalingchange__;
     __peer_connection_observer__->ondatachannel = __ondatachannel__;
@@ -631,7 +640,7 @@ void RtpReceiverGetStreams(void *receiver, size_t *size, void **array)
     __rtp_receiver_get_streams__(receiver, size, array);
 }
 
-void RtpReceiverGetParameters(void *receiver, void *parameters)
+void RtpReceiverGetParameters(void *receiver, raw_rtp_parameters_t *parameters)
 {
     // __debugf__(6, "===> RtpReceiverGetParameters()");
     __rtp_receiver_get_parameters__(receiver, parameters);
@@ -673,13 +682,13 @@ void RtpSenderGetStreams(void *sender, size_t *size, void **array)
     __rtp_sender_get_streams__(sender, size, array);
 }
 
-void RtpSenderSetParameters(void *sender, void *parameters)
+void RtpSenderSetParameters(void *sender, raw_rtp_parameters_t *parameters, raw_rtc_error_t *err)
 {
     // __debugf__(6, "===> RtpSenderSetParameters()");
-    __rtp_sender_set_parameters__(sender, parameters);
+    __rtp_sender_set_parameters__(sender, parameters, err);
 }
 
-void RtpSenderGetParameters(void *sender, void *parameters)
+void RtpSenderGetParameters(void *sender, raw_rtp_parameters_t *parameters)
 {
     // __debugf__(6, "===> RtpSenderGetParameters()");
     __rtp_sender_get_parameters__(sender, parameters);
@@ -696,3 +705,15 @@ void RtpSenderRelease(void *sender)
     // __debugf__(6, "===> RtpSenderRelease()");
     __rtp_sender_release__(sender);
 }
+
+void RtpCodecCapabilityRelease(void *capability)
+{
+    // __debugf__(6, "===> RtpCodecCapabilityRelease()");
+    __rtp_codec_capability_release__(capability);
+}
+
+void RtpCodecParametersRelease(void *parameters)
+{
+    // __debugf__(6, "===> RtpCodecParametersRelease()");
+    __rtp_codec_parameters_release__(parameters);
+}

api.go

@@ -123,16 +123,16 @@ type RtpSenderInterface interface {
 	Track() MediaStreamTrackInterface
 	SetStreams(stream_ids ...string)
 	Streams() []string
-	SetParameters(parameters interface{})
-	GetParameters() interface{}
+	SetParameters(parameters RtpParameters) error
+	GetParameters() RtpParameters
 	GetStats() map[string]interface{}
 	Release()
 }
 
 type RtpReceiverInterface interface {
 	Track() MediaStreamTrackInterface
 	Streams() []MediaStreamInterface
-	GetParameters() interface{}
+	GetParameters() RtpParameters
 	GetStats() map[string]interface{}
 	Release()
 }
@@ -155,9 +155,32 @@ type RtpCapabilities struct {
 type RtpCodecCapability struct {
 	fd unsafe.Pointer
 
-	MimeType  string
-	ClockRate int
-	Channels  int
+	MimeType    string
+	ClockRate   int
+	Channels    int
+	SdpFmtpLine string
+}
+
+func (me *RtpCodecCapability) Release() {
+	C.RtpCodecCapabilityRelease(me.fd)
+}
+
+type RtpParameters struct {
+	Codecs []RtpCodecParameters
+}
+
+type RtpCodecParameters struct {
+	fd unsafe.Pointer
+
+	PayloadType int
+	MimeType    string
+	ClockRate   int
+	Channels    int
+	SdpFmtpLine string
+}
+
+func (me *RtpCodecParameters) Release() {
+	C.RtpCodecParametersRelease(me.fd)
 }
 
 type RtpTransceiverInit struct {
@@ -368,16 +391,12 @@ func __ontrack__(target unsafe.Pointer, transceiver unsafe.Pointer) {
 		}
 	}()
 
-	trans := new(RtpTransceiver).Init()
-	trans.fd = transceiver
-
-	receiver := trans.Receiver()
-	track := receiver.Track()
-	streams := receiver.Streams()
+	t := new(RtpTransceiver).Init()
+	t.fd = transceiver
 
 	pc := (*PeerConnection)(target)
 	if pc != nil {
-		pc.OnTrack(track, streams...)
+		pc.OnTrack(t)
 	}
 }
 

api.h

@@ -75,17 +75,20 @@ void RtpTransceiverRelease(void *transceiver);
 
 void *RtpReceiverGetTrack(void *receiver);
 void RtpReceiverGetStreams(void *receiver, size_t *size, void **array);
-void RtpReceiverGetParameters(void *receiver, void *parameters);
+void RtpReceiverGetParameters(void *receiver, raw_rtp_parameters_t *parameters);
 void RtpReceiverGetStats(void *receiver, void *stats);
 void RtpReceiverRelease(void *receiver);
 
 int RtpSenderSetTrack(void *sender, void *track);
 void *RtpSenderGetTrack(void *sender);
 void RtpSenderSetStreams(void *sender, size_t size, const char **stream_ids);
 void RtpSenderGetStreams(void *sender, size_t *size, void **array);
-void RtpSenderSetParameters(void *sender, void *parameters);
-void RtpSenderGetParameters(void *sender, void *parameters);
+void RtpSenderSetParameters(void *sender, raw_rtp_parameters_t *parameters, raw_rtc_error_t *err);
+void RtpSenderGetParameters(void *sender, raw_rtp_parameters_t *parameters);
 void RtpSenderGetStats(void *sender, void *stats);
 void RtpSenderRelease(void *sender);
 
+void RtpCodecCapabilityRelease(void *capability);
+void RtpCodecParametersRelease(void *parameters);
+
 #endif // RAWRTC_API_H_

include/rtp_parameters.h

@@ -8,11 +8,26 @@ typedef struct {
   char* mime_type;
   int clock_rate;
   int channels;
+  char* sdp_fmtp_line;
 } raw_rtp_codec_capability_t;
 
 typedef struct {
   raw_rtp_codec_capability_t* codecs;
   size_t size;
 } raw_rtp_capabilities_t;
 
+typedef struct {
+  void* fd;
+  int payload_type;
+  char* mime_type;
+  int clock_rate;
+  int channels;
+  char* sdp_fmtp_line;
+} raw_rtp_codec_parameters_t;
+
+typedef struct {
+  raw_rtp_codec_parameters_t* codecs;
+  size_t size;
+} raw_rtp_parameters_t;
+
 #endif  // EXAMPLES_RAWRTC_RTP_PARAMETERS_H_

peerconnection.go

@@ -72,7 +72,7 @@ type PeerConnection struct {
 	OnIceGatheringChange  func(new_state string)
 	OnIceCandidate        func(candidate *IceCandidate)
 	OnIceCandidateError   func(address string, port int, url string, error_code int, error_text string)
-	OnTrack               func(track *MediaStreamTrack, streams ...*MediaStream)
+	OnTrack               func(transceiver *RtpTransceiver)
 }
 
 func (me *PeerConnection) Init(config RTCConfiguration) *PeerConnection {

peerconnectionfactory.go

@@ -53,6 +53,35 @@ func (me *PeerConnectionFactory) GetRtpSenderCapabilities(kind string) RtpCapabi
 		capabilities RtpCapabilities
 	)
 
+	k := C.CString(kind)
+	defer func() {
+		C.free((unsafe.Pointer(k)))
+	}()
+
+	rtp_capabilities := C.GetRtpSenderCapabilities(me.fd, k)
+	size := int(rtp_capabilities.size)
+	if size > 0 {
+		defer func() {
+			C.Free(unsafe.Pointer(rtp_capabilities.codecs))
+		}()
+	}
+
+	for i := 0; i < size; i++ {
+		arr := (*[1024]C.raw_rtp_codec_capability_t)(unsafe.Pointer(rtp_capabilities.codecs))[:size:size]
+		src := arr[i]
+		defer (func(src C.raw_rtp_codec_capability_t) {
+			C.Free(unsafe.Pointer(src.mime_type))
+			C.Free(unsafe.Pointer(src.sdp_fmtp_line))
+		})(src)
+
+		dst := new(RtpCodecCapability)
+		dst.fd = src.fd
+		dst.MimeType = C.GoString(src.mime_type)
+		dst.ClockRate = int(src.clock_rate)
+		dst.Channels = int(src.channels)
+		dst.SdpFmtpLine = C.GoString(src.sdp_fmtp_line)
+		capabilities.Codecs = append(capabilities.Codecs, *dst)
+	}
 	return capabilities
 }
 
@@ -68,15 +97,26 @@ func (me *PeerConnectionFactory) GetRtpReceiverCapabilities(kind string) RtpCapa
 
 	rtp_capabilities := C.GetRtpReceiverCapabilities(me.fd, k)
 	size := int(rtp_capabilities.size)
+	if size > 0 {
+		defer func() {
+			C.Free(unsafe.Pointer(rtp_capabilities.codecs))
+		}()
+	}
 
 	for i := 0; i < size; i++ {
 		arr := (*[1024]C.raw_rtp_codec_capability_t)(unsafe.Pointer(rtp_capabilities.codecs))[:size:size]
 		src := arr[i]
+		defer (func(src C.raw_rtp_codec_capability_t) {
+			C.Free(unsafe.Pointer(src.mime_type))
+			C.Free(unsafe.Pointer(src.sdp_fmtp_line))
+		})(src)
+
 		dst := new(RtpCodecCapability)
 		dst.fd = src.fd
 		dst.MimeType = C.GoString(src.mime_type)
 		dst.ClockRate = int(src.clock_rate)
 		dst.Channels = int(src.channels)
+		dst.SdpFmtpLine = C.GoString(src.sdp_fmtp_line)
 		capabilities.Codecs = append(capabilities.Codecs, *dst)
 	}
 	return capabilities

rtpreceiver.go

@@ -46,8 +46,37 @@ func (me *RtpReceiver) Streams() []*MediaStream {
 	return streams
 }
 
-func (me *RtpReceiver) GetParameters() interface{} {
-	return nil
+func (me *RtpReceiver) GetParameters() RtpParameters {
+	var (
+		parameters RtpParameters
+		dst        C.raw_rtp_parameters_t
+	)
+
+	C.RtpReceiverGetParameters(me.fd, &dst)
+	size := int(dst.size)
+	if size > 0 {
+		defer func() {
+			C.Free(unsafe.Pointer(dst.codecs))
+		}()
+	}
+
+	for i := 0; i < size; i++ {
+		arr := (*[1024]C.raw_rtp_codec_parameters_t)(unsafe.Pointer(dst.codecs))[:size:size]
+		src := arr[i]
+		defer (func(src C.raw_rtp_codec_parameters_t) {
+			C.free(unsafe.Pointer(src.fd))
+			C.Free(unsafe.Pointer(src.mime_type))
+		})(src)
+
+		dst := new(RtpCodecParameters)
+		dst.fd = src.fd
+		dst.PayloadType = int(src.payload_type)
+		dst.MimeType = C.GoString(src.mime_type)
+		dst.ClockRate = int(src.clock_rate)
+		dst.Channels = int(src.channels)
+		parameters.Codecs = append(parameters.Codecs, *dst)
+	}
+	return parameters
 }
 
 func (me *RtpReceiver) GetStats() map[string]interface{} {

rtpsender.go

@@ -67,12 +67,12 @@ func (me *RtpSender) Streams() []string {
 	return stream_ids
 }
 
-func (me *RtpSender) SetParameters(parameters interface{}) {
-
+func (me *RtpSender) SetParameters(parameters RtpParameters) error {
+	return nil
 }
 
-func (me *RtpSender) GetParameters() interface{} {
-	return nil
+func (me *RtpSender) GetParameters() RtpParameters {
+	return RtpParameters{}
 }
 
 func (me *RtpSender) GetStats() map[string]interface{} {

rtptransceiver.go

@@ -62,7 +62,9 @@ func (me *RtpTransceiver) SetCodecPreferences(codecs []RtpCodecCapability) {
 	for i, codec := range codecs {
 		array[i] = codec.fd
 	}
-	C.RtpTransceiverSetCodecPreferences(me.fd, (*unsafe.Pointer)(&array[0]), C.size_t(size))
+	if len(codecs) > 0 {
+		C.RtpTransceiverSetCodecPreferences(me.fd, (*unsafe.Pointer)(&array[0]), C.size_t(size))
+	}
 }
 
 func (me *RtpTransceiver) SetDirection(new_direction string) error {