Add video streaming capability in system capability

11 files changed, 411 insertions, 2 deletions

diff --git a/src/appMain/hmi_capabilities.json b/src/appMain/hmi_capabilities.json
index f5e88fe370..d3b7090e77 100755
--- a/src/appMain/hmi_capabilities.json
+++ b/src/appMain/hmi_capabilities.json
@@ -300,6 +300,12 @@
             },
             "phoneCapability": {
                 "dialNumberEnabled": true
+            },
+            "videoStreamingCapability": {
+                "supportedFormats": [{
+                    "protocol": "RAW",
+                    "codec": "H264"
+                }]
             }
         }
     },
diff --git a/src/components/application_manager/include/application_manager/hmi_capabilities_impl.h b/src/components/application_manager/include/application_manager/hmi_capabilities_impl.h
index 777c45d0ac..bdc1b0c633 100644
--- a/src/components/application_manager/include/application_manager/hmi_capabilities_impl.h
+++ b/src/components/application_manager/include/application_manager/hmi_capabilities_impl.h
@@ -408,6 +408,20 @@ class HMICapabilitiesImpl : public HMICapabilities {
   bool phone_call_supported() const OVERRIDE;
 
   /*
+   * @brief Interface to store whether HMI supports video streaming
+   *
+   * @param supported Indicates whether video streaming is supported by HMI
+   */
+  void set_video_streaming_supported(const bool supported) OVERRIDE;
+
+  /*
+   * @brief Retrieves whether HMI supports video streaming
+   *
+   * @return TRUE if it supported, otherwise FALSE
+   */
+  bool video_streaming_supported() const OVERRIDE;
+
+  /*
    * @brief Interface used to store information regarding
    * the navigation "System Capability"
    *
@@ -442,6 +456,21 @@ class HMICapabilitiesImpl : public HMICapabilities {
 
   const smart_objects::SmartObject* phone_capability() const OVERRIDE;
 
+  /*
+   * @brief Sets HMI's video streaming related capability information
+   *
+   * @param video_streaming_capability the video streaming related capabilities
+   */
+  void set_video_streaming_capability(
+      const smart_objects::SmartObject& video_streaming_capability) OVERRIDE;
+
+  /*
+   * @brief Retrieves HMI's video streaming related capabilities
+   *
+   * @return HMI's video streaming related capability information
+   */
+  const smart_objects::SmartObject* video_streaming_capability() const OVERRIDE;
+
   void Init(resumption::LastState* last_state) OVERRIDE;
 
   /*
@@ -518,9 +547,11 @@ class HMICapabilitiesImpl : public HMICapabilities {
   smart_objects::SmartObject* prerecorded_speech_;
   bool is_navigation_supported_;
   bool is_phone_call_supported_;
+  bool is_video_streaming_supported_;
   std::string ccpu_version_;
   smart_objects::SmartObject* navigation_capability_;
   smart_objects::SmartObject* phone_capability_;
+  smart_objects::SmartObject* video_streaming_capability_;
 
   ApplicationManager& app_mngr_;
   HMILanguageHandler hmi_language_handler_;
diff --git a/src/components/application_manager/include/application_manager/smart_object_keys.h b/src/components/application_manager/include/application_manager/smart_object_keys.h
index 9b8acd0675..b8a6d3235f 100644
--- a/src/components/application_manager/include/application_manager/smart_object_keys.h
+++ b/src/components/application_manager/include/application_manager/smart_object_keys.h
@@ -172,6 +172,7 @@ extern const char* system_capability_type;
 extern const char* system_capabilities;
 extern const char* navigation_capability;
 extern const char* phone_capability;
+extern const char* video_streaming_capability;
 
 // PutFile
 extern const char* sync_file_name;
@@ -263,6 +264,7 @@ extern const char* supported_diag_modes;
 extern const char* hmi_capabilities;
 extern const char* navigation;
 extern const char* phone_call;
+extern const char* video_streaming;
 extern const char* sdl_version;
 extern const char* system_software_version;
 extern const char* priority;
diff --git a/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc
index 4b31debbdd..3b5aeac639 100644
--- a/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc
+++ b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc
@@ -78,6 +78,12 @@ void UIGetCapabilitiesResponse::Run() {
       hmi_capabilities.set_phone_call_supported(
           msg_params[strings::hmi_capabilities][strings::phone_call].asBool());
     }
+    if (msg_params[strings::hmi_capabilities].keyExists(
+            strings::video_streaming)) {
+      hmi_capabilities.set_video_streaming_supported(
+          msg_params[strings::hmi_capabilities][strings::video_streaming]
+              .asBool());
+    }
   }
 
   if (msg_params.keyExists(strings::system_capabilities)) {
@@ -92,6 +98,12 @@ void UIGetCapabilitiesResponse::Run() {
       hmi_capabilities.set_phone_capability(
           msg_params[strings::system_capabilities][strings::phone_capability]);
     }
+    if (msg_params[strings::system_capabilities].keyExists(
+            strings::video_streaming_capability)) {
+      hmi_capabilities.set_video_streaming_capability(
+          msg_params[strings::system_capabilities]
+                    [strings::video_streaming_capability]);
+    }
   }
 }
 
diff --git a/src/components/application_manager/src/commands/mobile/get_system_capability_request.cc b/src/components/application_manager/src/commands/mobile/get_system_capability_request.cc
index 91fad1b664..ca0fb1b355 100644
--- a/src/components/application_manager/src/commands/mobile/get_system_capability_request.cc
+++ b/src/components/application_manager/src/commands/mobile/get_system_capability_request.cc
@@ -60,8 +60,15 @@ void GetSystemCapabilityRequest::Run() {
       break;
     }
     case mobile_apis::SystemCapabilityType::VIDEO_STREAMING:
-      SendResponse(false, mobile_apis::Result::UNSUPPORTED_RESOURCE);
-      return;
+      if (hmi_capabilities.video_streaming_capability()) {
+        response_params[strings::system_capability]
+                       [strings::video_streaming_capability] =
+                           *hmi_capabilities.video_streaming_capability();
+      } else {
+        SendResponse(false, mobile_apis::Result::DATA_NOT_AVAILABLE);
+        return;
+      }
+      break;
     case mobile_apis::SystemCapabilityType::AUDIO_STREAMING:
       SendResponse(false, mobile_apis::Result::UNSUPPORTED_RESOURCE);
       return;
diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
index 52153647a7..63231438f4 100644
--- a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
@@ -485,6 +485,8 @@ void FillUIRelatedFields(smart_objects::SmartObject& response_params,
       hmi_capabilities.navigation_supported();
   response_params[strings::hmi_capabilities][strings::phone_call] =
       hmi_capabilities.phone_call_supported();
+  response_params[strings::hmi_capabilities][strings::video_streaming] =
+      hmi_capabilities.video_streaming_supported();
 }
 
 void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile() {
diff --git a/src/components/application_manager/src/hmi_capabilities_impl.cc b/src/components/application_manager/src/hmi_capabilities_impl.cc
index 12a64165e8..99a77d5ba7 100644
--- a/src/components/application_manager/src/hmi_capabilities_impl.cc
+++ b/src/components/application_manager/src/hmi_capabilities_impl.cc
@@ -68,6 +68,10 @@ std::map<std::string, hmi_apis::Common_ImageFieldName::eType>
 std::map<std::string, hmi_apis::Common_FileType::eType> file_type_enum;
 std::map<std::string, hmi_apis::Common_DisplayType::eType> display_type_enum;
 std::map<std::string, hmi_apis::Common_CharacterSet::eType> character_set_enum;
+std::map<std::string, hmi_apis::Common_VideoStreamingProtocol::eType>
+    video_streaming_protocol_enum;
+std::map<std::string, hmi_apis::Common_VideoStreamingCodec::eType>
+    video_streaming_codec_enum;
 
 void InitCapabilities() {
   vr_enum_capabilities.insert(std::make_pair(
@@ -333,6 +337,28 @@ void InitCapabilities() {
       std::string("CID1SET"), hmi_apis::Common_CharacterSet::CID1SET));
   character_set_enum.insert(std::make_pair(
       std::string("CID2SET"), hmi_apis::Common_CharacterSet::CID2SET));
+
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RAW"), hmi_apis::Common_VideoStreamingProtocol::RAW));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTP"), hmi_apis::Common_VideoStreamingProtocol::RTP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTSP"), hmi_apis::Common_VideoStreamingProtocol::RTSP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTMP"), hmi_apis::Common_VideoStreamingProtocol::RTMP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("WEBM"), hmi_apis::Common_VideoStreamingProtocol::WEBM));
+
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("H264"), hmi_apis::Common_VideoStreamingCodec::H264));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("H265"), hmi_apis::Common_VideoStreamingCodec::H265));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("Theora"), hmi_apis::Common_VideoStreamingCodec::Theora));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("VP8"), hmi_apis::Common_VideoStreamingCodec::VP8));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("VP9"), hmi_apis::Common_VideoStreamingCodec::VP9));
 }
 
 }  // namespace
@@ -363,8 +389,10 @@ HMICapabilitiesImpl::HMICapabilitiesImpl(ApplicationManager& app_mngr)
     , prerecorded_speech_(NULL)
     , is_navigation_supported_(false)
     , is_phone_call_supported_(false)
+    , is_video_streaming_supported_(false)
     , navigation_capability_(NULL)
     , phone_capability_(NULL)
+    , video_streaming_capability_(NULL)
     , app_mngr_(app_mngr)
     , hmi_language_handler_(app_mngr) {
   InitCapabilities();
@@ -394,6 +422,7 @@ HMICapabilitiesImpl::~HMICapabilitiesImpl() {
   delete prerecorded_speech_;
   delete navigation_capability_;
   delete phone_capability_;
+  delete video_streaming_capability_;
 }
 
 bool HMICapabilitiesImpl::VerifyImageType(const int32_t image_type) const {
@@ -609,6 +638,10 @@ void HMICapabilitiesImpl::set_phone_call_supported(const bool supported) {
   is_phone_call_supported_ = supported;
 }
 
+void HMICapabilitiesImpl::set_video_streaming_supported(const bool supported) {
+  is_video_streaming_supported_ = supported;
+}
+
 void HMICapabilitiesImpl::set_navigation_capability(
     const smart_objects::SmartObject& navigation_capability) {
   if (navigation_capability_) {
@@ -626,6 +659,15 @@ void HMICapabilitiesImpl::set_phone_capability(
   phone_capability_ = new smart_objects::SmartObject(phone_capability);
 }
 
+void HMICapabilitiesImpl::set_video_streaming_capability(
+    const smart_objects::SmartObject& video_streaming_capability) {
+  if (video_streaming_capability_) {
+    delete video_streaming_capability_;
+  }
+  video_streaming_capability_ =
+      new smart_objects::SmartObject(video_streaming_capability);
+}
+
 void HMICapabilitiesImpl::Init(resumption::LastState* last_state) {
   hmi_language_handler_.Init(last_state);
   if (false == load_capabilities_from_file()) {
@@ -737,6 +779,10 @@ bool HMICapabilitiesImpl::phone_call_supported() const {
   return is_phone_call_supported_;
 }
 
+bool HMICapabilitiesImpl::video_streaming_supported() const {
+  return is_video_streaming_supported_;
+}
+
 const smart_objects::SmartObject* HMICapabilitiesImpl::navigation_capability()
     const {
   return navigation_capability_;
@@ -747,6 +793,11 @@ const smart_objects::SmartObject* HMICapabilitiesImpl::phone_capability()
   return phone_capability_;
 }
 
+const smart_objects::SmartObject*
+HMICapabilitiesImpl::video_streaming_capability() const {
+  return video_streaming_capability_;
+}
+
 bool HMICapabilitiesImpl::load_capabilities_from_file() {
   std::string json_string;
   std::string file_name = app_mngr_.get_settings().hmi_capabilities_file_name();
@@ -1011,6 +1062,53 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() {
                                                          phone_capability_so);
           set_phone_capability(phone_capability_so);
         }
+        if (check_existing_json_member(system_capabilities,
+                                       "videoStreamingCapability")) {
+          Json::Value vs_capability =
+              system_capabilities.get("videoStreamingCapability", "");
+          smart_objects::SmartObject vs_capability_so;
+          Formatters::CFormatterJsonBase::jsonValueToObj(vs_capability,
+                                                         vs_capability_so);
+
+          if (vs_capability_so.keyExists("supportedFormats")) {
+            smart_objects::SmartObject& supported_format_array =
+                vs_capability_so["supportedFormats"];
+            smart_objects::SmartObject converted_array(
+                smart_objects::SmartType_Array);
+            for (uint32_t i = 0, j = 0; i < supported_format_array.length();
+                 i++) {
+              if (!supported_format_array[i].keyExists("protocol") ||
+                  !supported_format_array[i].keyExists("codec")) {
+                continue;
+              }
+
+              std::map<std::string,
+                       hmi_apis::Common_VideoStreamingProtocol::eType>::
+                  const_iterator it_protocol =
+                      video_streaming_protocol_enum.find(
+                          supported_format_array[i]["protocol"].asString());
+
+              std::map<std::string,
+                       hmi_apis::Common_VideoStreamingCodec::eType>::
+                  const_iterator it_codec = video_streaming_codec_enum.find(
+                      supported_format_array[i]["codec"].asString());
+
+              // format is valid only if both protocol and codec are converted
+              // to enum values successfully
+              if (it_protocol != video_streaming_protocol_enum.end() &&
+                  it_codec != video_streaming_codec_enum.end()) {
+                smart_objects::SmartObject format_so =
+                    smart_objects::SmartObject(smart_objects::SmartType_Map);
+                format_so["protocol"] = it_protocol->second;
+                format_so["codec"] = it_codec->second;
+                converted_array[j++] = format_so;
+              }
+            }
+            vs_capability_so.erase("supportedFormats");
+            vs_capability_so["supportedFormats"] = converted_array;
+          }
+          set_video_streaming_capability(vs_capability_so);
+        }
       }
     }  // UI end
 
diff --git a/src/components/application_manager/src/smart_object_keys.cc b/src/components/application_manager/src/smart_object_keys.cc
index 7f8fd5d00f..d5324273a7 100644
--- a/src/components/application_manager/src/smart_object_keys.cc
+++ b/src/components/application_manager/src/smart_object_keys.cc
@@ -139,6 +139,7 @@ const char* system_capability_type = "systemCapabilityType";
 const char* system_capabilities = "systemCapabilities";
 const char* navigation_capability = "navigationCapability";
 const char* phone_capability = "phoneCapability";
+const char* video_streaming_capability = "videoStreamingCapability";
 
 // PutFile
 const char* sync_file_name = "syncFileName";
@@ -230,6 +231,7 @@ const char* supported_diag_modes = "supportedDiagModes";
 const char* hmi_capabilities = "hmiCapabilities";
 const char* navigation = "navigation";
 const char* phone_call = "phoneCall";
+const char* video_streaming = "videoStreaming";
 const char* sdl_version = "sdlVersion";
 const char* system_software_version = "systemSoftwareVersion";
 const char* priority = "priority";
diff --git a/src/components/include/application_manager/hmi_capabilities.h b/src/components/include/application_manager/hmi_capabilities.h
index f7107ebeed..03c0fdedb8 100644
--- a/src/components/include/application_manager/hmi_capabilities.h
+++ b/src/components/include/application_manager/hmi_capabilities.h
@@ -410,6 +410,20 @@ class HMICapabilities {
   virtual bool phone_call_supported() const = 0;
 
   /*
+   * @brief Interface to store whether HMI supports video streaming
+   *
+   * @param supported Indicates whether video streaming is supported by HMI
+   */
+  virtual void set_video_streaming_supported(const bool supported) = 0;
+
+  /*
+   * @brief Retrieves whether HMI supports video streaming
+   *
+   * @return TRUE if it supported, otherwise FALSE
+   */
+  virtual bool video_streaming_supported() const = 0;
+
+  /*
    * @brief Interface used to store information regarding
    * the navigation "System Capability"
    *
@@ -443,6 +457,22 @@ class HMICapabilities {
    */
   virtual const smart_objects::SmartObject* phone_capability() const = 0;
 
+  /*
+   * @brief Sets HMI's video streaming related capability information
+   *
+   * @param video_streaming_capability the video streaming related capabilities
+   */
+  virtual void set_video_streaming_capability(
+      const smart_objects::SmartObject& video_streaming_capability) = 0;
+
+  /*
+   * @brief Retrieves HMI's video streaming related capabilities
+   *
+   * @return HMI's video streaming related capability information
+   */
+  virtual const smart_objects::SmartObject* video_streaming_capability()
+      const = 0;
+
   virtual void Init(resumption::LastState* last_state) = 0;
 
   /**
diff --git a/src/components/interfaces/HMI_API.xml b/src/components/interfaces/HMI_API.xml
index 57348e2715..bbc3ea6322 100644
--- a/src/components/interfaces/HMI_API.xml
+++ b/src/components/interfaces/HMI_API.xml
@@ -1208,6 +1208,86 @@
   <element name="QUEUE" />
 </enum>
 
+<enum name="VideoStreamingProtocol">
+  <description>Enum for each type of video streaming protocol type.</description>
+  <element name="RAW">
+    <description>
+      Raw stream bytes that contains no timestamp data and is the lowest supported video streaming
+    </description>
+  </element>
+  <element name="RTP">
+    <description>
+      RTP facilitates the transfer of real-time data. Information provided by this protocol include
+      timestamps (for synchronization), sequence numbers (for packet loss and reordering detection)
+      and the payload format which indicates the encoded format of the data.
+    </description>
+  </element>
+  <element name="RTSP">
+    <description>
+      The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the
+      Real-time Transport Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP)
+      for media stream delivery. However, some vendors implement proprietary transport protocols.
+    </description>
+  </element>
+  <element name="RTMP">
+    <description>
+      Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by
+      Macromedia for streaming audio, video and data over the Internet, between a Flash player
+      and a server. Macromedia is now owned by Adobe, which has released an incomplete version
+      of the specification of the protocol for public use.
+    </description>
+  </element>
+  <element name="WEBM">
+    <description>
+      The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and
+      Vorbis audio streams. In 2013 it was updated to accommodate VP9 video and Opus audio.
+    </description>
+  </element>
+</enum>
+
+<enum name="VideoStreamingCodec">
+  <description>Enum for each type of video streaming codec.</description>
+  <element name="H264">
+    <description>
+      A block-oriented motion-compensation-based video compression standard.
+      As of 2014 it is one of the most commonly used formats for the recording, compression, and
+      distribution of video content.
+    </description>
+  </element>
+  <element name="H265">
+    <description>
+      High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video
+      compression standard, one of several potential successors to the widely used AVC (H.264 or
+      MPEG-4 Part 10). In comparison to AVC, HEVC offers about double the data compression ratio
+      at the same level of video quality, or substantially improved video quality at the same
+      bit rate. It supports resolutions up to 8192x4320, including 8K UHD.
+    </description>
+  </element>
+  <element name="Theora">
+    <description>
+      Theora is derived from the formerly proprietary VP3 codec, released into the public domain
+      by On2 Technologies. It is broadly comparable in design and bitrate efficiency to
+      MPEG-4 Part 2, early versions of Windows Media Video, and RealVideo while lacking some of
+      the features present in some of these other codecs. It is comparable in open standards
+      philosophy to the BBC's Dirac codec.
+    </description>
+  </element>
+  <element name="VP8">
+    <description>
+      VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and
+      Opus audio. The image format WebP is based on VP8's intra-frame coding. VP8's direct
+      successor, VP9, and the emerging royalty-free internet video format AV1 from the Alliance for
+      Open Media (AOMedia) are based on VP8.
+    </description>
+  </element>
+  <element name="VP9">
+    <description>
+      Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video (UHD)
+      and also enables lossless compression.
+    </description>
+  </element>
+</enum>
+
 <!-- Policies -->
   <enum name="UpdateResult">
     <element name="UP_TO_DATE"/>
@@ -1571,6 +1651,16 @@
   </param>
 </struct>
 
+<struct name="VideoStreamingFormat">
+  <description>Video streaming formats and their specifications.</description>
+  <param name="protocol" type="Common.VideoStreamingProtocol" mandatory="true">
+    <description>Protocol type, see VideoStreamingProtocol</description>
+  </param>
+  <param name="codec" type="Common.VideoStreamingCodec" mandatory="true">
+    <description>Codec type, see VideoStreamingCodec</description>
+  </param>
+</struct>
+
 <struct name="DisplayCapabilities">
   <description>Contains information about the display capabilities.</description>
   <param name="displayType" type="Common.DisplayType" mandatory="true">
@@ -2105,11 +2195,30 @@
     </param>
   </struct>
 
+  <struct name="VideoStreamingCapability">
+    <description>Contains information about this system's video streaming capabilities.</description>
+    <param name="preferredResolution" type="Common.ImageResolution" mandatory="false">
+      <description>The preferred resolution of a video stream for decoding and rendering on HMI.</description>
+    </param>
+    <param name="maxBitrate" type="Integer" minvalue="0" maxvalue="2147483647" mandatory="false">
+      <description>The maximum bitrate of video stream that is supported, in kbps.</description>
+    </param>
+    <param name="supportedFormats" type="Common.VideoStreamingFormat" array="true" mandatory="false">
+      <description>
+        Detailed information on each format supported by this system, in its preferred order
+        (i.e. the first element in the array is most preferable to the system).
+        Each object will contain a VideoStreamingFormat that describes what can be expected.
+      </description>
+    </param>
+  </struct>
+
   <struct name="SystemCapabilities">
       <param name="navigationCapability" type="NavigationCapability" mandatory="false">
       </param>
       <param name="phoneCapability" type="PhoneCapability" mandatory="false">
       </param>
+      <param name="videoStreamingCapability" type="VideoStreamingCapability" mandatory="false">
+      </param>
   </struct>
 
 </interface>
diff --git a/src/components/interfaces/MOBILE_API.xml b/src/components/interfaces/MOBILE_API.xml
index a2f8b79658..64427b3781 100644
--- a/src/components/interfaces/MOBILE_API.xml
+++ b/src/components/interfaces/MOBILE_API.xml
@@ -808,6 +808,86 @@
     <element name="QUEUE" />

   </enum>

 

+  <enum name="VideoStreamingProtocol">

+    <description>Enum for each type of video streaming protocol type.</description>

+    <element name="RAW">

+      <description>

+        Raw stream bytes that contains no timestamp data and is the lowest supported video streaming

+      </description>

+    </element>

+    <element name="RTP">

+      <description>

+        RTP facilitates the transfer of real-time data. Information provided by this protocol include

+        timestamps (for synchronization), sequence numbers (for packet loss and reordering detection)

+        and the payload format which indicates the encoded format of the data.

+      </description>

+    </element>

+    <element name="RTSP">

+      <description>

+        The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the

+        Real-time Transport Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP)

+        for media stream delivery. However, some vendors implement proprietary transport protocols.

+      </description>

+    </element>

+    <element name="RTMP">

+      <description>

+        Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by

+        Macromedia for streaming audio, video and data over the Internet, between a Flash player

+        and a server. Macromedia is now owned by Adobe, which has released an incomplete version

+        of the specification of the protocol for public use.

+      </description>

+    </element>

+    <element name="WEBM">

+      <description>

+        The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and

+        Vorbis audio streams. In 2013 it was updated to accommodate VP9 video and Opus audio.

+      </description>

+    </element>

+  </enum>

+

+  <enum name="VideoStreamingCodec">

+    <description>Enum for each type of video streaming codec.</description>

+    <element name="H264">

+      <description>

+        A block-oriented motion-compensation-based video compression standard.

+        As of 2014 it is one of the most commonly used formats for the recording, compression, and

+        distribution of video content.

+      </description>

+    </element>

+    <element name="H265">

+      <description>

+        High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video

+        compression standard, one of several potential successors to the widely used AVC (H.264 or

+        MPEG-4 Part 10). In comparison to AVC, HEVC offers about double the data compression ratio

+        at the same level of video quality, or substantially improved video quality at the same

+        bit rate. It supports resolutions up to 8192x4320, including 8K UHD.

+      </description>

+    </element>

+    <element name="Theora">

+      <description>

+        Theora is derived from the formerly proprietary VP3 codec, released into the public domain

+        by On2 Technologies. It is broadly comparable in design and bitrate efficiency to

+        MPEG-4 Part 2, early versions of Windows Media Video, and RealVideo while lacking some of

+        the features present in some of these other codecs. It is comparable in open standards

+        philosophy to the BBC's Dirac codec.

+      </description>

+    </element>

+    <element name="VP8">

+      <description>

+        VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and

+        Opus audio. The image format WebP is based on VP8's intra-frame coding. VP8's direct

+        successor, VP9, and the emerging royalty-free internet video format AV1 from the Alliance for

+        Open Media (AOMedia) are based on VP8.

+      </description>

+    </element>

+    <element name="VP9">

+      <description>

+        Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video (UHD)

+        and also enables lossless compression.

+      </description>

+    </element>

+  </enum>

+

   <struct name="Image">

     <param name="value" minlength="0" maxlength="65535" type="String" mandatory="true"> 

       <description>Either the static hex icon value or the binary image file name identifier (sent by PutFile).</description>

@@ -1778,6 +1858,16 @@
     <param name="parameterPermissions" type="ParameterPermissions"  mandatory="true"/>

  </struct>

 

+  <struct name="VideoStreamingFormat">

+    <description>Video streaming formats and their specifications.</description>

+    <param name="protocol" type="VideoStreamingProtocol" mandatory="true">

+      <description>Protocol type, see VideoStreamingProtocol</description>

+    </param>

+    <param name="codec" type="VideoStreamingCodec" mandatory="true">

+      <description>Codec type, see VideoStreamingCodec</description>

+    </param>

+  </struct>

+

   <struct name="DisplayCapabilities">

     <description>Contains information about the display capabilities.</description>

     <param name="displayType" type="DisplayType" mandatory="true">

@@ -1874,6 +1964,9 @@
     <param name="phoneCall" type="Boolean" mandatory="false">

       <description>Availability of build in phone. True: Available, False: Not Available </description>

     </param>

+    <param name="videoStreaming" type="Boolean" mandatory="false">

+      <description>Availability of video streaming. True: Available, False: Not Available</description>

+    </param>

   </struct>

 

   <struct name="MenuParams">

@@ -2409,6 +2502,23 @@
     </param>

   </struct>

 

+  <struct name="VideoStreamingCapability">

+    <description>Contains information about this system's video streaming capabilities.</description>

+    <param name="preferredResolution" type="ImageResolution" mandatory="false">

+      <description>The preferred resolution of a video stream for decoding and rendering on HMI.</description>

+    </param>

+    <param name="maxBitrate" type="Integer" minvalue="0" maxvalue="2147483647" mandatory="false">

+      <description>The maximum bitrate of video stream that is supported, in kbps.</description>

+    </param>

+    <param name="supportedFormats" type="VideoStreamingFormat" array="true" mandatory="false">

+      <description>

+        Detailed information on each format supported by this system, in its preferred order

+        (i.e. the first element in the array is most preferable to the system).

+        Each object will contain a VideoStreamingFormat that describes what can be expected.

+      </description>

+    </param>

+  </struct>

+

   <struct name="SystemCapability">

       <description>The systemCapabilityType indicates which type of data should be changed and identifies which data object exists in this struct. For example, if the SystemCapability Type is NAVIGATION then a "navigationCapability" should exist</description>

       <param name="systemCapabilityType" type="SystemCapabilityType" mandatory="true">