[EXPERIMENTAL] Generic stereo codec with index header sending single frames

modules/video_coding/video_codec_initializer.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 21 matching lines @@
 }
 }  // namespace
 
 bool VideoCodecInitializer::SetupCodec(
     const VideoEncoderConfig& config,
     const VideoSendStream::Config::EncoderSettings settings,
     const std::vector<VideoStream>& streams,
     bool nack_enabled,
     VideoCodec* codec,
     std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
-  *codec =
-      VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
-                                     settings.payload_type, nack_enabled);
+  *codec = VideoEncoderConfigToVideoCodec(
+      config, streams, settings.payload_name, settings.payload_type,
+      settings.stereo_associated_payload_name, nack_enabled);
 
   std::unique_ptr<TemporalLayersFactory> tl_factory;
   switch (codec->codecType) {
     case kVideoCodecVP8: {
       if (!codec->VP8()->tl_factory) {
         if (codec->mode == kScreensharing &&
             (codec->numberOfSimulcastStreams > 1 ||
              (codec->numberOfSimulcastStreams == 1 &&
               codec->VP8()->numberOfTemporalLayers == 2))) {
           // Conference mode temporal layering for screen content.
@@ skipping 35 matching lines @@
 
   return rate_allocator;
 }
 
 // TODO(sprang): Split this up and separate the codec specific parts.
 VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
     const VideoEncoderConfig& config,
     const std::vector<VideoStream>& streams,
     const std::string& payload_name,
     int payload_type,
+    const std::string& stereo_associated_payload_name,
     bool nack_enabled) {
   static const int kEncoderMinBitrateKbps = 30;
   RTC_DCHECK(!streams.empty());
   RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
   video_codec.codecType = PayloadStringToCodecType(payload_name);
 
+  const bool is_stereo_codec = video_codec.codecType == kVideoCodecStereo;
+  if (is_stereo_codec) {
+    video_codec.codecType =
+        PayloadStringToCodecType(stereo_associated_payload_name);
+  }
+
   switch (config.content_type) {
     case VideoEncoderConfig::ContentType::kRealtimeVideo:
       video_codec.mode = kRealtimeVideo;
       break;
     case VideoEncoderConfig::ContentType::kScreen:
       video_codec.mode = kScreensharing;
       if (!streams.empty() &&
           streams[0].temporal_layer_thresholds_bps.size() == 1) {
         video_codec.targetBitrate =
             streams[0].temporal_layer_thresholds_bps[0] / 1000;
@@ skipping 112 matching lines @@
     // Unset max bitrate -> cap to one bit per pixel.
     video_codec.maxBitrate =
         (video_codec.width * video_codec.height * video_codec.maxFramerate) /
         1000;
   }
   if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
     video_codec.maxBitrate = kEncoderMinBitrateKbps;
 
   RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
+
+  if (is_stereo_codec)
+    video_codec.codecType = kVideoCodecStereo;
+
   return video_codec;
 }
 
 }  // namespace webrtc