Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/talk/session/media/mediamessages.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 13.3 KB
Line 
1/*
2 * libjingle
3 * Copyright 2010 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28/*
29 * Documentation is in mediamessages.h.
30 */
31
32#include "talk/session/media/mediamessages.h"
33
34#include "talk/base/logging.h"
35#include "talk/base/stringencode.h"
36#include "talk/p2p/base/constants.h"
37#include "talk/p2p/base/parsing.h"
38#include "talk/session/media/mediasessionclient.h"
39#include "talk/xmllite/xmlelement.h"
40
41namespace cricket {
42
43namespace {
44
45// NOTE: There is no check here for duplicate streams, so check before
46// adding.
47void AddStream(std::vector<StreamParams>* streams, const StreamParams& stream) {
48  streams->push_back(stream);
49}
50
51bool ParseSsrc(const std::string& string, uint32* ssrc) {
52  return talk_base::FromString(string, ssrc);
53}
54
55bool ParseSsrc(const buzz::XmlElement* element, uint32* ssrc) {
56  if (element == NULL) {
57    return false;
58  }
59  return ParseSsrc(element->BodyText(), ssrc);
60}
61
62// Builds a <view> element according to the following spec:
63// goto/jinglemuc
64buzz::XmlElement* CreateViewElem(const std::string& name,
65                                 const std::string& type) {
66  buzz::XmlElement* view_elem =
67      new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
68  view_elem->AddAttr(QN_NAME, name);
69  view_elem->SetAttr(QN_TYPE, type);
70  return view_elem;
71}
72
73buzz::XmlElement* CreateVideoViewElem(const std::string& content_name,
74                                      const std::string& type) {
75  return CreateViewElem(content_name, type);
76}
77
78buzz::XmlElement* CreateNoneVideoViewElem(const std::string& content_name) {
79  return CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_NONE);
80}
81
82buzz::XmlElement* CreateStaticVideoViewElem(const std::string& content_name,
83                                            const StaticVideoView& view) {
84  buzz::XmlElement* view_elem =
85      CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
86  AddXmlAttr(view_elem, QN_SSRC, view.selector.ssrc);
87
88  buzz::XmlElement* params_elem = new buzz::XmlElement(QN_JINGLE_DRAFT_PARAMS);
89  AddXmlAttr(params_elem, QN_WIDTH, view.width);
90  AddXmlAttr(params_elem, QN_HEIGHT, view.height);
91  AddXmlAttr(params_elem, QN_FRAMERATE, view.framerate);
92  AddXmlAttr(params_elem, QN_PREFERENCE, view.preference);
93  view_elem->AddElement(params_elem);
94
95  return view_elem;
96}
97
98}  //  namespace
99
100bool MediaStreams::GetAudioStream(
101    const StreamSelector& selector, StreamParams* stream) {
102  return GetStream(audio_, selector, stream);
103}
104
105bool MediaStreams::GetVideoStream(
106    const StreamSelector& selector, StreamParams* stream) {
107  return GetStream(video_, selector, stream);
108}
109
110bool MediaStreams::GetDataStream(
111    const StreamSelector& selector, StreamParams* stream) {
112  return GetStream(data_, selector, stream);
113}
114
115void MediaStreams::CopyFrom(const MediaStreams& streams) {
116  audio_ = streams.audio_;
117  video_ = streams.video_;
118  data_ = streams.data_;
119}
120
121void MediaStreams::AddAudioStream(const StreamParams& stream) {
122  AddStream(&audio_, stream);
123}
124
125void MediaStreams::AddVideoStream(const StreamParams& stream) {
126  AddStream(&video_, stream);
127}
128
129void MediaStreams::AddDataStream(const StreamParams& stream) {
130  AddStream(&data_, stream);
131}
132
133bool MediaStreams::RemoveAudioStream(
134    const StreamSelector& selector) {
135  return RemoveStream(&audio_, selector);
136}
137
138bool MediaStreams::RemoveVideoStream(
139    const StreamSelector& selector) {
140  return RemoveStream(&video_, selector);
141}
142
143bool MediaStreams::RemoveDataStream(
144    const StreamSelector& selector) {
145  return RemoveStream(&data_, selector);
146}
147
148bool IsJingleViewRequest(const buzz::XmlElement* action_elem) {
149  return action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW) != NULL;
150}
151
152bool ParseStaticVideoView(const buzz::XmlElement* view_elem,
153                          StaticVideoView* view,
154                          ParseError* error) {
155  uint32 ssrc;
156  if (!ParseSsrc(view_elem->Attr(QN_SSRC), &ssrc)) {
157    return BadParse("Invalid or missing view ssrc.", error);
158  }
159  view->selector = StreamSelector(ssrc);
160
161  const buzz::XmlElement* params_elem =
162      view_elem->FirstNamed(QN_JINGLE_DRAFT_PARAMS);
163  if (params_elem) {
164    view->width = GetXmlAttr(params_elem, QN_WIDTH, 0);
165    view->height = GetXmlAttr(params_elem, QN_HEIGHT, 0);
166    view->framerate = GetXmlAttr(params_elem, QN_FRAMERATE, 0);
167    view->preference = GetXmlAttr(params_elem, QN_PREFERENCE, 0);
168  } else {
169    return BadParse("Missing view params.", error);
170  }
171
172  return true;
173}
174
175bool ParseJingleViewRequest(const buzz::XmlElement* action_elem,
176                            ViewRequest* view_request,
177                            ParseError* error) {
178  for (const buzz::XmlElement* view_elem =
179           action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW);
180       view_elem != NULL;
181       view_elem = view_elem->NextNamed(QN_JINGLE_DRAFT_VIEW)) {
182    std::string type = view_elem->Attr(QN_TYPE);
183    if (STR_JINGLE_DRAFT_VIEW_TYPE_NONE == type) {
184      view_request->static_video_views.clear();
185      return true;
186    } else if (STR_JINGLE_DRAFT_VIEW_TYPE_STATIC == type) {
187      StaticVideoView static_video_view(StreamSelector(0), 0, 0, 0);
188      if (!ParseStaticVideoView(view_elem, &static_video_view, error)) {
189        return false;
190      }
191      view_request->static_video_views.push_back(static_video_view);
192    } else {
193      LOG(LS_INFO) << "Ingnoring unknown view type: " << type;
194    }
195  }
196  return true;
197}
198
199bool WriteJingleViewRequest(const std::string& content_name,
200                            const ViewRequest& request,
201                            XmlElements* elems,
202                            WriteError* error) {
203  if (request.static_video_views.empty()) {
204    elems->push_back(CreateNoneVideoViewElem(content_name));
205  } else {
206    for (StaticVideoViews::const_iterator view =
207             request.static_video_views.begin();
208         view != request.static_video_views.end(); ++view) {
209      elems->push_back(CreateStaticVideoViewElem(content_name, *view));
210    }
211  }
212  return true;
213}
214
215bool ParseSsrcAsLegacyStream(const buzz::XmlElement* desc_elem,
216                             std::vector<StreamParams>* streams,
217                             ParseError* error) {
218  const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
219  if (!ssrc_str.empty()) {
220    uint32 ssrc;
221    if (!ParseSsrc(ssrc_str, &ssrc)) {
222      return BadParse("Missing or invalid ssrc.", error);
223    }
224
225    streams->push_back(StreamParams::CreateLegacy(ssrc));
226  }
227  return true;
228}
229
230bool ParseSsrcs(const buzz::XmlElement* parent_elem,
231                std::vector<uint32>* ssrcs,
232                ParseError* error) {
233  for (const buzz::XmlElement* ssrc_elem =
234           parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
235       ssrc_elem != NULL;
236       ssrc_elem = ssrc_elem->NextNamed(QN_JINGLE_DRAFT_SSRC)) {
237    uint32 ssrc;
238    if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
239      return BadParse("Missing or invalid ssrc.", error);
240    }
241
242    ssrcs->push_back(ssrc);
243  }
244  return true;
245}
246
247bool ParseSsrcGroups(const buzz::XmlElement* parent_elem,
248                     std::vector<SsrcGroup>* ssrc_groups,
249                     ParseError* error) {
250  for (const buzz::XmlElement* group_elem =
251           parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC_GROUP);
252       group_elem != NULL;
253       group_elem = group_elem->NextNamed(QN_JINGLE_DRAFT_SSRC_GROUP)) {
254    std::string semantics = group_elem->Attr(QN_SEMANTICS);
255    std::vector<uint32> ssrcs;
256    if (!ParseSsrcs(group_elem, &ssrcs, error)) {
257      return false;
258    }
259    ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
260  }
261  return true;
262}
263
264bool ParseJingleStream(const buzz::XmlElement* stream_elem,
265                       std::vector<StreamParams>* streams,
266                       ParseError* error) {
267  StreamParams stream;
268  // We treat the nick as a stream groupid.
269  stream.groupid = stream_elem->Attr(QN_NICK);
270  stream.id = stream_elem->Attr(QN_NAME);
271  stream.type = stream_elem->Attr(QN_TYPE);
272  stream.display = stream_elem->Attr(QN_DISPLAY);
273  stream.cname = stream_elem->Attr(QN_CNAME);
274  if (!ParseSsrcs(stream_elem, &(stream.ssrcs), error)) {
275    return false;
276  }
277  std::vector<SsrcGroup> ssrc_groups;
278  if (!ParseSsrcGroups(stream_elem, &(stream.ssrc_groups), error)) {
279    return false;
280  }
281  streams->push_back(stream);
282  return true;
283}
284
285bool ParseJingleRtpHeaderExtensions(const buzz::XmlElement* parent_elem,
286                                    std::vector<RtpHeaderExtension>* hdrexts,
287                                    ParseError* error) {
288  for (const buzz::XmlElement* hdrext_elem =
289           parent_elem->FirstNamed(QN_JINGLE_RTP_HDREXT);
290       hdrext_elem != NULL;
291       hdrext_elem = hdrext_elem->NextNamed(QN_JINGLE_RTP_HDREXT)) {
292    std::string uri = hdrext_elem->Attr(QN_URI);
293    int id = GetXmlAttr(hdrext_elem, QN_ID, 0);
294    if (id <= 0) {
295      return BadParse("Invalid RTP header extension id.", error);
296    }
297    hdrexts->push_back(RtpHeaderExtension(uri, id));
298  }
299  return true;
300}
301
302bool HasJingleStreams(const buzz::XmlElement* desc_elem) {
303  const buzz::XmlElement* streams_elem =
304      desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
305  return (streams_elem != NULL);
306}
307
308bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
309                        std::vector<StreamParams>* streams,
310                        ParseError* error) {
311  const buzz::XmlElement* streams_elem =
312      desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
313  if (streams_elem == NULL) {
314    return BadParse("Missing streams element.", error);
315  }
316  for (const buzz::XmlElement* stream_elem =
317           streams_elem->FirstNamed(QN_JINGLE_DRAFT_STREAM);
318       stream_elem != NULL;
319       stream_elem = stream_elem->NextNamed(QN_JINGLE_DRAFT_STREAM)) {
320    if (!ParseJingleStream(stream_elem, streams, error)) {
321      return false;
322    }
323  }
324  return true;
325}
326
327void WriteSsrcs(const std::vector<uint32>& ssrcs,
328                buzz::XmlElement* parent_elem) {
329  for (std::vector<uint32>::const_iterator ssrc = ssrcs.begin();
330       ssrc != ssrcs.end(); ++ssrc) {
331    buzz::XmlElement* ssrc_elem =
332        new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC, false);
333    SetXmlBody(ssrc_elem, *ssrc);
334
335    parent_elem->AddElement(ssrc_elem);
336  }
337}
338
339void WriteSsrcGroups(const std::vector<SsrcGroup>& groups,
340                     buzz::XmlElement* parent_elem) {
341  for (std::vector<SsrcGroup>::const_iterator group = groups.begin();
342       group != groups.end(); ++group) {
343    buzz::XmlElement* group_elem =
344        new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC_GROUP, false);
345    AddXmlAttrIfNonEmpty(group_elem, QN_SEMANTICS, group->semantics);
346    WriteSsrcs(group->ssrcs, group_elem);
347
348    parent_elem->AddElement(group_elem);
349  }
350}
351
352void WriteJingleStream(const StreamParams& stream,
353                       buzz::XmlElement* parent_elem) {
354  buzz::XmlElement* stream_elem =
355      new buzz::XmlElement(QN_JINGLE_DRAFT_STREAM, false);
356  // We treat the nick as a stream groupid.
357  AddXmlAttrIfNonEmpty(stream_elem, QN_NICK, stream.groupid);
358  AddXmlAttrIfNonEmpty(stream_elem, QN_NAME, stream.id);
359  AddXmlAttrIfNonEmpty(stream_elem, QN_TYPE, stream.type);
360  AddXmlAttrIfNonEmpty(stream_elem, QN_DISPLAY, stream.display);
361  AddXmlAttrIfNonEmpty(stream_elem, QN_CNAME, stream.cname);
362  WriteSsrcs(stream.ssrcs, stream_elem);
363  WriteSsrcGroups(stream.ssrc_groups, stream_elem);
364
365  parent_elem->AddElement(stream_elem);
366}
367
368void WriteJingleStreams(const std::vector<StreamParams>& streams,
369                        buzz::XmlElement* parent_elem) {
370  buzz::XmlElement* streams_elem =
371      new buzz::XmlElement(QN_JINGLE_DRAFT_STREAMS, true);
372  for (std::vector<StreamParams>::const_iterator stream = streams.begin();
373       stream != streams.end(); ++stream) {
374    WriteJingleStream(*stream, streams_elem);
375  }
376
377  parent_elem->AddElement(streams_elem);
378}
379
380void WriteJingleRtpHeaderExtensions(
381    const std::vector<RtpHeaderExtension>& hdrexts,
382    buzz::XmlElement* parent_elem) {
383  for (std::vector<RtpHeaderExtension>::const_iterator hdrext = hdrexts.begin();
384       hdrext != hdrexts.end(); ++hdrext) {
385    buzz::XmlElement* hdrext_elem =
386      new buzz::XmlElement(QN_JINGLE_RTP_HDREXT, false);
387    AddXmlAttr(hdrext_elem, QN_URI, hdrext->uri);
388    AddXmlAttr(hdrext_elem, QN_ID, hdrext->id);
389    parent_elem->AddElement(hdrext_elem);
390  }
391}
392
393
394}  // namespace cricket
Note: See TracBrowser for help on using the repository browser.