Enable passing receive stream ID to the decoder factory.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 901 matching lines @@
     LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
                     << "with ssrc " << ssrc << " which doesn't exist.";
     return webrtc::RtpParameters();
   }
 
   // TODO(deadbeef): Return stream-specific parameters.
   webrtc::RtpParameters rtp_params = CreateRtpParametersWithOneEncoding();
   for (const VideoCodec& codec : recv_params_.codecs) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
+  rtp_params.ssrcs = it->second->GetSsrcs();

[pthatcher1, 2016/06/15 19:40:00]

This should be:

if (!it->second-GetSsrcs().empty()) {
  rtp_params.encodings[0] = it->second->GetSsrcs()[0];
}

[perkj_webrtc, 2016/06/15 20:25:52]

Why is this change needed at all ? 

[pthatcher1, 2016/06/15 21:08:17]

Now that you mention it, this part of the change isn't needed at all if sp.id is
used as the received_stream_id, because the app can just the ID passed into the
SessionDescription to correlate the decoder to the receive stream, even without
having the SSRC exposed in the RtpParameters.

So, as much as I like a part of the standard implemented, you are correct that
it's not needed for the purpose of this CL.


As for the purpose: my understanding is that certain applications want to have a
hardward-based VideoSinkInterface<EncodedFrame> for certain payload types but
not others.  We don't have support.  So they are hacking around it by making a
Decoder act like a VideoSinkInterface<EncodedFrame>.  But then they need to
correlate a Decoder to an RtpReceiver/ReceiveStream.  And do that, they
basically need the Decoder to know some ID of the RtpReceiver/ReceiveStream.  

   return rtp_params;
 }
 
 bool WebRtcVideoChannel2::SetRtpReceiveParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpReceiveParameters");
   rtc::CritScope stream_lock(&stream_crit_);
   auto it = receive_streams_.find(ssrc);
   if (it == receive_streams_.end()) {
@@ skipping 1267 matching lines @@
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
     WebRtcVideoDecoderFactory* external_decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     bool red_disabled_by_remote_side)
     : call_(call),
+      receive_stream_id_(sp.id),

[pthatcher1, 2016/06/15 19:40:00]

Interesting.   That's now what I had in mind originally, but that will probably
be easier to use and implement for now, since that comes right from the
SessionDescription passed into SetLocalDescription.

       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       stream_(NULL),
       default_stream_(default_stream),
       config_(std::move(config)),
       red_disabled_by_remote_side_(red_disabled_by_remote_side),
       external_decoder_factory_(external_decoder_factory),
       sink_(NULL),
       last_width_(-1),
       last_height_(-1),
@@ skipping 41 matching lines @@
     if ((*old_decoders)[i].type == type) {
       AllocatedDecoder decoder = (*old_decoders)[i];
       (*old_decoders)[i] = old_decoders->back();
       old_decoders->pop_back();
       return decoder;
     }
   }
 
   if (external_decoder_factory_ != NULL) {
     webrtc::VideoDecoder* decoder =
-        external_decoder_factory_->CreateVideoDecoder(type);
+        external_decoder_factory_->CreateVideoDecoder(type,
+            { receive_stream_id_ });
     if (decoder != NULL) {
       return AllocatedDecoder(decoder, type, true);
     }
   }
 
   if (type == webrtc::kVideoCodecVP8) {
     return AllocatedDecoder(
         webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
   }
 
@@ skipping 332 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket