Split RTCRtpParameters idl and header file
[WebKit-https.git] / Source / WebCore / Modules / mediastream / libwebrtc / LibWebRTCUtils.cpp
1 /*
2  * Copyright (C) 2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include "config.h"
26 #include "LibWebRTCUtils.h"
27
28 #if USE(LIBWEBRTC)
29
30 #include "LibWebRTCMacros.h"
31 #include "RTCPeerConnection.h"
32 #include "RTCRtpParameters.h"
33 #include <wtf/text/WTFString.h>
34
35 ALLOW_UNUSED_PARAMETERS_BEGIN
36
37 #include <webrtc/api/rtpparameters.h>
38 #include <webrtc/api/rtptransceiverinterface.h>
39
40 ALLOW_UNUSED_PARAMETERS_END
41
42 namespace WebCore {
43
44 static inline RTCRtpEncodingParameters toRTCEncodingParameters(const webrtc::RtpEncodingParameters& rtcParameters)
45 {
46     RTCRtpEncodingParameters parameters;
47
48     if (rtcParameters.ssrc)
49         parameters.ssrc = *rtcParameters.ssrc;
50     if (rtcParameters.rtx && rtcParameters.rtx->ssrc)
51         parameters.rtx.ssrc = *rtcParameters.rtx->ssrc;
52     if (rtcParameters.fec && rtcParameters.fec->ssrc)
53         parameters.fec.ssrc = *rtcParameters.fec->ssrc;
54     if (rtcParameters.dtx) {
55         switch (*rtcParameters.dtx) {
56         case webrtc::DtxStatus::DISABLED:
57             parameters.dtx = RTCDtxStatus::Disabled;
58             break;
59         case webrtc::DtxStatus::ENABLED:
60             parameters.dtx = RTCDtxStatus::Enabled;
61         }
62     }
63     parameters.active = rtcParameters.active;
64     if (rtcParameters.max_bitrate_bps)
65         parameters.maxBitrate = *rtcParameters.max_bitrate_bps;
66     if (rtcParameters.max_framerate)
67         parameters.maxFramerate = *rtcParameters.max_framerate;
68     parameters.rid = fromStdString(rtcParameters.rid);
69     if (rtcParameters.scale_resolution_down_by)
70         parameters.scaleResolutionDownBy = *rtcParameters.scale_resolution_down_by;
71
72     return parameters;
73 }
74
75 static inline webrtc::RtpEncodingParameters fromRTCEncodingParameters(const RTCRtpEncodingParameters& parameters)
76 {
77     webrtc::RtpEncodingParameters rtcParameters;
78
79     if (parameters.dtx) {
80         switch (*parameters.dtx) {
81         case RTCDtxStatus::Disabled:
82             rtcParameters.dtx = webrtc::DtxStatus::DISABLED;
83             break;
84         case RTCDtxStatus::Enabled:
85             rtcParameters.dtx = webrtc::DtxStatus::ENABLED;
86         }
87     }
88     rtcParameters.active = parameters.active;
89     if (parameters.maxBitrate)
90         rtcParameters.max_bitrate_bps = parameters.maxBitrate;
91     if (parameters.maxFramerate)
92         rtcParameters.max_framerate = parameters.maxFramerate;
93     rtcParameters.rid = parameters.rid.utf8().data();
94     if (parameters.scaleResolutionDownBy != 1)
95         rtcParameters.scale_resolution_down_by = parameters.scaleResolutionDownBy;
96
97     return rtcParameters;
98 }
99
100 static inline RTCRtpHeaderExtensionParameters toRTCHeaderExtensionParameters(const webrtc::RtpHeaderExtensionParameters& rtcParameters)
101 {
102     RTCRtpHeaderExtensionParameters parameters;
103
104     parameters.uri = fromStdString(rtcParameters.uri);
105     parameters.id = rtcParameters.id;
106
107     return parameters;
108 }
109
110 static inline webrtc::RtpHeaderExtensionParameters fromRTCHeaderExtensionParameters(const RTCRtpHeaderExtensionParameters& parameters)
111 {
112     webrtc::RtpHeaderExtensionParameters rtcParameters;
113
114     rtcParameters.uri = parameters.uri.utf8().data();
115     rtcParameters.id = parameters.id;
116
117     return rtcParameters;
118 }
119
120 static inline RTCRtpCodecParameters toRTCCodecParameters(const webrtc::RtpCodecParameters& rtcParameters)
121 {
122     RTCRtpCodecParameters parameters;
123
124     parameters.payloadType = rtcParameters.payload_type;
125     parameters.mimeType = fromStdString(rtcParameters.mime_type());
126     if (rtcParameters.clock_rate)
127         parameters.clockRate = *rtcParameters.clock_rate;
128     if (rtcParameters.num_channels)
129         parameters.channels = *rtcParameters.num_channels;
130
131     return parameters;
132 }
133
134 RTCRtpParameters toRTCRtpParameters(const webrtc::RtpParameters& rtcParameters)
135 {
136     RTCRtpParameters parameters;
137
138     parameters.transactionId = fromStdString(rtcParameters.transaction_id);
139     for (auto& rtcEncoding : rtcParameters.encodings)
140         parameters.encodings.append(toRTCEncodingParameters(rtcEncoding));
141     for (auto& extension : rtcParameters.header_extensions)
142         parameters.headerExtensions.append(toRTCHeaderExtensionParameters(extension));
143     for (auto& codec : rtcParameters.codecs)
144         parameters.codecs.append(toRTCCodecParameters(codec));
145
146     switch (rtcParameters.degradation_preference) {
147     // FIXME: Support DegradationPreference::DISABLED.
148     case webrtc::DegradationPreference::DISABLED:
149     case webrtc::DegradationPreference::MAINTAIN_FRAMERATE:
150         parameters.degradationPreference = RTCDegradationPreference::MaintainFramerate;
151         break;
152     case webrtc::DegradationPreference::MAINTAIN_RESOLUTION:
153         parameters.degradationPreference = RTCDegradationPreference::MaintainResolution;
154         break;
155     case webrtc::DegradationPreference::BALANCED:
156         parameters.degradationPreference = RTCDegradationPreference::Balanced;
157         break;
158     };
159     return parameters;
160 }
161
162 webrtc::RtpParameters fromRTCRtpParameters(const RTCRtpParameters& parameters)
163 {
164     webrtc::RtpParameters rtcParameters;
165     rtcParameters.transaction_id = parameters.transactionId.utf8().data();
166
167     for (auto& encoding : parameters.encodings)
168         rtcParameters.encodings.push_back(fromRTCEncodingParameters(encoding));
169     for (auto& extension : parameters.headerExtensions)
170         rtcParameters.header_extensions.push_back(fromRTCHeaderExtensionParameters(extension));
171     // Codecs parameters are readonly
172
173     switch (parameters.degradationPreference) {
174     case RTCDegradationPreference::MaintainFramerate:
175         rtcParameters.degradation_preference = webrtc::DegradationPreference::MAINTAIN_FRAMERATE;
176         break;
177     case RTCDegradationPreference::MaintainResolution:
178         rtcParameters.degradation_preference = webrtc::DegradationPreference::MAINTAIN_RESOLUTION;
179         break;
180     case RTCDegradationPreference::Balanced:
181         rtcParameters.degradation_preference = webrtc::DegradationPreference::BALANCED;
182         break;
183     }
184     return rtcParameters;
185 }
186
187 RTCRtpTransceiverDirection toRTCRtpTransceiverDirection(webrtc::RtpTransceiverDirection rtcDirection)
188 {
189     switch (rtcDirection) {
190     case webrtc::RtpTransceiverDirection::kSendRecv:
191         return RTCRtpTransceiverDirection::Sendrecv;
192     case webrtc::RtpTransceiverDirection::kSendOnly:
193         return RTCRtpTransceiverDirection::Sendonly;
194     case webrtc::RtpTransceiverDirection::kRecvOnly:
195         return RTCRtpTransceiverDirection::Recvonly;
196     case webrtc::RtpTransceiverDirection::kInactive:
197         return RTCRtpTransceiverDirection::Inactive;
198     };
199
200     RELEASE_ASSERT_NOT_REACHED();
201 }
202
203 webrtc::RtpTransceiverDirection fromRTCRtpTransceiverDirection(RTCRtpTransceiverDirection direction)
204 {
205     switch (direction) {
206     case RTCRtpTransceiverDirection::Sendrecv:
207         return webrtc::RtpTransceiverDirection::kSendRecv;
208     case RTCRtpTransceiverDirection::Sendonly:
209         return webrtc::RtpTransceiverDirection::kSendOnly;
210     case RTCRtpTransceiverDirection::Recvonly:
211         return webrtc::RtpTransceiverDirection::kRecvOnly;
212     case RTCRtpTransceiverDirection::Inactive:
213         return webrtc::RtpTransceiverDirection::kInactive;
214     };
215
216     RELEASE_ASSERT_NOT_REACHED();
217 }
218
219 webrtc::RtpTransceiverInit fromRtpTransceiverInit(const RTCRtpTransceiverInit& init)
220 {
221     webrtc::RtpTransceiverInit rtcInit;
222     rtcInit.direction = fromRTCRtpTransceiverDirection(init.direction);
223     return rtcInit;
224 }
225
226 }; // namespace WebCore
227
228 #endif // USE(LIBWEBRTC)