talk/session/phone/mediamessages.cc - vendor/opensource/libjingle - Git at Google

 /*
  * libjingle
  * Copyright 2010, Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 /*
  * Documentation is in mediamessages.h.
  */

 #include "talk/session/phone/mediamessages.h"

 #include "talk/base/stringencode.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/session/phone/mediasessionclient.h"
 #include "talk/xmllite/xmlelement.h"

 namespace cricket {

 namespace {

 bool GetFirstSourceByNick(const NamedSources& sources,
                           const std::string& nick,
                           NamedSource* source_out) {
   for (NamedSources::const_iterator source = sources.begin();
        source != sources.end(); ++source) {
     if (source->nick == nick) {
       *source_out = *source;
       return true;
     }
   }
   return false;
 }

 bool GetSourceBySsrc(const NamedSources& sources, uint32 ssrc,
                      NamedSource* source_out) {
   for (NamedSources::const_iterator source = sources.begin();
        source != sources.end(); ++source) {
     if (source->ssrc == ssrc) {
       *source_out = *source;
       return true;
     }
   }
   return false;
 }

 // NOTE: There is no check here for duplicate sources, so check before
 // adding.
 void AddSource(NamedSources* sources, const NamedSource& source) {
   sources->push_back(source);
 }

 void RemoveSourceBySsrc(uint32 ssrc, NamedSources* sources) {
   for (NamedSources::iterator source = sources->begin();
        source != sources->end(); ) {
     if (source->ssrc == ssrc) {
       source = sources->erase(source);
     } else {
       ++source;
     }
   }
 }

 bool ParseSsrc(const std::string& string, uint32* ssrc) {
   return talk_base::FromString(string, ssrc);
 }

 bool ParseSsrc(const buzz::XmlElement* element, uint32* ssrc) {
   if (element == NULL) {
     return false;
   }
   return ParseSsrc(element->BodyText(), ssrc);
 }

 bool ParseNamedSource(const buzz::XmlElement* source_elem,
                       NamedSource* named_source,
                       ParseError* error) {
   named_source->nick = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NICK);
   if (named_source->nick.empty()) {
     return BadParse("Missing or invalid nick.", error);
   }

   named_source->name = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NAME);
   named_source->usage = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_USAGE);
   named_source->removed =
       STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED ==
       source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_STATE);

   const buzz::XmlElement* ssrc_elem =
       source_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE_SSRC);
   if (ssrc_elem != NULL && !ssrc_elem->BodyText().empty()) {
     uint32 ssrc;
     if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
       return BadParse("Missing or invalid ssrc.", error);
     }
     named_source->SetSsrc(ssrc);
   }

   return true;
 }

 // Builds a <view> element according to the following spec:
 // goto/jinglemuc
 buzz::XmlElement* CreateViewElem(const std::string& name,
                                  const std::string& type) {
   buzz::XmlElement* view_elem =
       new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
   view_elem->AddAttr(QN_JINGLE_DRAFT_CONTENT_NAME, name);
   view_elem->SetAttr(QN_JINGLE_DRAFT_VIEW_TYPE, type);
   return view_elem;
 }

 buzz::XmlElement* CreateVideoViewElem(const std::string& content_name,
                                       const std::string& type) {
   return CreateViewElem(content_name, type);
 }

 buzz::XmlElement* CreateNoneVideoViewElem(const std::string& content_name) {
   return CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_NONE);
 }

 buzz::XmlElement* CreateStaticVideoViewElem(const std::string& content_name,
                                             const StaticVideoView& view) {
   buzz::XmlElement* view_elem =
       CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
   AddXmlAttr(view_elem, QN_JINGLE_DRAFT_VIEW_SSRC, view.ssrc);

   buzz::XmlElement* params_elem = new buzz::XmlElement(
       QN_JINGLE_DRAFT_VIEW_PARAMS);
   AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH, view.width);
   AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT, view.height);
   AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE,
              view.framerate);
   AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE,
              view.preference);
   view_elem->AddElement(params_elem);

   return view_elem;
 }

 }  //  namespace

 bool MediaSources::GetFirstAudioSourceByNick(
     const std::string& nick, NamedSource* source) {
   return GetFirstSourceByNick(audio_, nick, source);
 }

 bool MediaSources::GetFirstVideoSourceByNick(
     const std::string& nick, NamedSource* source) {
   return GetFirstSourceByNick(video_, nick, source);
 }

 void MediaSources::CopyFrom(const MediaSources& sources) {
   audio_ = sources.audio_;
   video_ = sources.video_;
 }

 bool MediaSources::GetAudioSourceBySsrc(uint32 ssrc, NamedSource* source) {
   return GetSourceBySsrc(audio_, ssrc, source);
 }

 bool MediaSources::GetVideoSourceBySsrc(uint32 ssrc, NamedSource* source) {
   return GetSourceBySsrc(video_, ssrc, source);
 }

 void MediaSources::AddAudioSource(const NamedSource& source) {
   AddSource(&audio_, source);
 }

 void MediaSources::AddVideoSource(const NamedSource& source) {
   AddSource(&video_, source);
 }

 void MediaSources::RemoveAudioSourceBySsrc(uint32 ssrc) {
   RemoveSourceBySsrc(ssrc, &audio_);
 }

 void MediaSources::RemoveVideoSourceBySsrc(uint32 ssrc) {
   RemoveSourceBySsrc(ssrc, &video_);
 }

 bool WriteViewRequest(const std::string& content_name,
                       const ViewRequest& request,
                       XmlElements* elems,
                       WriteError* error) {
   if (request.static_video_views.empty()) {
     elems->push_back(CreateNoneVideoViewElem(content_name));
   } else {
     for (StaticVideoViews::const_iterator view =
              request.static_video_views.begin();
          view != request.static_video_views.end(); ++view) {
       elems->push_back(CreateStaticVideoViewElem(content_name, *view));
     }
   }
   return true;
 }

 bool IsSourcesNotify(const buzz::XmlElement* action_elem) {
   return action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY) != NULL;
 }

 bool ParseSourcesNotify(const buzz::XmlElement* action_elem,
                         const SessionDescription* session_description,
                         MediaSources* sources,
                         ParseError* error) {
   for (const buzz::XmlElement* notify_elem =
            action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY);
        notify_elem != NULL;
        notify_elem = notify_elem->NextNamed(QN_JINGLE_DRAFT_NOTIFY)) {
     std::string content_name = notify_elem->Attr(QN_JINGLE_DRAFT_CONTENT_NAME);
     for (const buzz::XmlElement* source_elem =
              notify_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE);
          source_elem != NULL;
          source_elem = source_elem->NextNamed(QN_JINGLE_DRAFT_SOURCE)) {
       NamedSource named_source;
       if (!ParseNamedSource(source_elem, &named_source, error)) {
         return false;
       }

       if (session_description == NULL) {
         return BadParse("Unknown content name: " + content_name, error);
       }
       const ContentInfo* content =
           FindContentInfoByName(session_description->contents(), content_name);
       if (content == NULL) {
         return BadParse("Unknown content name: " + content_name, error);
       }

       if (IsAudioContent(content)) {
         sources->mutable_audio()->push_back(named_source);
       } else if (IsVideoContent(content)) {
         sources->mutable_video()->push_back(named_source);
       }
     }
   }

   return true;
 }

 }  // namespace cricket
	/*
	* libjingle
	* Copyright 2010, Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/*
	* Documentation is in mediamessages.h.
	*/

	#include "talk/session/phone/mediamessages.h"

	#include "talk/base/stringencode.h"
	#include "talk/p2p/base/constants.h"
	#include "talk/session/phone/mediasessionclient.h"
	#include "talk/xmllite/xmlelement.h"

	namespace cricket {

	namespace {

	bool GetFirstSourceByNick(const NamedSources& sources,
	const std::string& nick,
	NamedSource* source_out) {
	for (NamedSources::const_iterator source = sources.begin();
	source != sources.end(); ++source) {
	if (source->nick == nick) {
	source_out = source;
	return true;
	}
	}
	return false;
	}

	bool GetSourceBySsrc(const NamedSources& sources, uint32 ssrc,
	NamedSource* source_out) {
	for (NamedSources::const_iterator source = sources.begin();
	source != sources.end(); ++source) {
	if (source->ssrc == ssrc) {
	source_out = source;
	return true;
	}
	}
	return false;
	}

	// NOTE: There is no check here for duplicate sources, so check before
	// adding.
	void AddSource(NamedSources* sources, const NamedSource& source) {
	sources->push_back(source);
	}

	void RemoveSourceBySsrc(uint32 ssrc, NamedSources* sources) {
	for (NamedSources::iterator source = sources->begin();
	source != sources->end(); ) {
	if (source->ssrc == ssrc) {
	source = sources->erase(source);
	} else {
	++source;
	}
	}
	}

	bool ParseSsrc(const std::string& string, uint32* ssrc) {
	return talk_base::FromString(string, ssrc);
	}

	bool ParseSsrc(const buzz::XmlElement* element, uint32* ssrc) {
	if (element == NULL) {
	return false;
	}
	return ParseSsrc(element->BodyText(), ssrc);
	}

	bool ParseNamedSource(const buzz::XmlElement* source_elem,
	NamedSource* named_source,
	ParseError* error) {
	named_source->nick = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NICK);
	if (named_source->nick.empty()) {
	return BadParse("Missing or invalid nick.", error);
	}

	named_source->name = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NAME);
	named_source->usage = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_USAGE);
	named_source->removed =
	STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED ==
	source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_STATE);

	const buzz::XmlElement* ssrc_elem =
	source_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE_SSRC);
	if (ssrc_elem != NULL && !ssrc_elem->BodyText().empty()) {
	uint32 ssrc;
	if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
	return BadParse("Missing or invalid ssrc.", error);
	}
	named_source->SetSsrc(ssrc);
	}

	return true;
	}

	// Builds a <view> element according to the following spec:
	// goto/jinglemuc
	buzz::XmlElement* CreateViewElem(const std::string& name,
	const std::string& type) {
	buzz::XmlElement* view_elem =
	new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
	view_elem->AddAttr(QN_JINGLE_DRAFT_CONTENT_NAME, name);
	view_elem->SetAttr(QN_JINGLE_DRAFT_VIEW_TYPE, type);
	return view_elem;
	}

	buzz::XmlElement* CreateVideoViewElem(const std::string& content_name,
	const std::string& type) {
	return CreateViewElem(content_name, type);
	}

	buzz::XmlElement* CreateNoneVideoViewElem(const std::string& content_name) {
	return CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_NONE);
	}

	buzz::XmlElement* CreateStaticVideoViewElem(const std::string& content_name,
	const StaticVideoView& view) {
	buzz::XmlElement* view_elem =
	CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
	AddXmlAttr(view_elem, QN_JINGLE_DRAFT_VIEW_SSRC, view.ssrc);

	buzz::XmlElement* params_elem = new buzz::XmlElement(
	QN_JINGLE_DRAFT_VIEW_PARAMS);
	AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH, view.width);
	AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT, view.height);
	AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE,
	view.framerate);
	AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE,
	view.preference);
	view_elem->AddElement(params_elem);

	return view_elem;
	}

	} // namespace

	bool MediaSources::GetFirstAudioSourceByNick(
	const std::string& nick, NamedSource* source) {
	return GetFirstSourceByNick(audio_, nick, source);
	}

	bool MediaSources::GetFirstVideoSourceByNick(
	const std::string& nick, NamedSource* source) {
	return GetFirstSourceByNick(video_, nick, source);
	}

	void MediaSources::CopyFrom(const MediaSources& sources) {
	audio_ = sources.audio_;
	video_ = sources.video_;
	}

	bool MediaSources::GetAudioSourceBySsrc(uint32 ssrc, NamedSource* source) {
	return GetSourceBySsrc(audio_, ssrc, source);
	}

	bool MediaSources::GetVideoSourceBySsrc(uint32 ssrc, NamedSource* source) {
	return GetSourceBySsrc(video_, ssrc, source);
	}

	void MediaSources::AddAudioSource(const NamedSource& source) {
	AddSource(&audio_, source);
	}

	void MediaSources::AddVideoSource(const NamedSource& source) {
	AddSource(&video_, source);
	}

	void MediaSources::RemoveAudioSourceBySsrc(uint32 ssrc) {
	RemoveSourceBySsrc(ssrc, &audio_);
	}

	void MediaSources::RemoveVideoSourceBySsrc(uint32 ssrc) {
	RemoveSourceBySsrc(ssrc, &video_);
	}

	bool WriteViewRequest(const std::string& content_name,
	const ViewRequest& request,
	XmlElements* elems,
	WriteError* error) {
	if (request.static_video_views.empty()) {
	elems->push_back(CreateNoneVideoViewElem(content_name));
	} else {
	for (StaticVideoViews::const_iterator view =
	request.static_video_views.begin();
	view != request.static_video_views.end(); ++view) {
	elems->push_back(CreateStaticVideoViewElem(content_name, *view));
	}
	}
	return true;
	}

	bool IsSourcesNotify(const buzz::XmlElement* action_elem) {
	return action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY) != NULL;
	}

	bool ParseSourcesNotify(const buzz::XmlElement* action_elem,
	const SessionDescription* session_description,
	MediaSources* sources,
	ParseError* error) {
	for (const buzz::XmlElement* notify_elem =
	action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY);
	notify_elem != NULL;
	notify_elem = notify_elem->NextNamed(QN_JINGLE_DRAFT_NOTIFY)) {
	std::string content_name = notify_elem->Attr(QN_JINGLE_DRAFT_CONTENT_NAME);
	for (const buzz::XmlElement* source_elem =
	notify_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE);
	source_elem != NULL;
	source_elem = source_elem->NextNamed(QN_JINGLE_DRAFT_SOURCE)) {
	NamedSource named_source;
	if (!ParseNamedSource(source_elem, &named_source, error)) {
	return false;
	}

	if (session_description == NULL) {
	return BadParse("Unknown content name: " + content_name, error);
	}
	const ContentInfo* content =
	FindContentInfoByName(session_description->contents(), content_name);
	if (content == NULL) {
	return BadParse("Unknown content name: " + content_name, error);
	}

	if (IsAudioContent(content)) {
	sources->mutable_audio()->push_back(named_source);
	} else if (IsVideoContent(content)) {
	sources->mutable_video()->push_back(named_source);
	}
	}
	}

	return true;
	}

	} // namespace cricket