Change a disabled MediaStreamVideoTrack to output black video frames for each incoming frame.

content/renderer/media/media_stream_video_track.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/media_stream_video_track.h"
 
 #include <utility>
 
 #include "base/bind.h"
 
 namespace content {
 
 namespace {
 void ResetCallback(scoped_ptr<VideoCaptureDeliverFrameCB> callback) {
   // |callback| will be deleted when this exits.
 }
 }  // namespace
 
 // MediaStreamVideoTrack::FrameDeliverer is a helper class used for registering
 // VideoCaptureDeliverFrameCB on the main render thread to receive video frames
 // on the IO-thread.
-// Frames are only delivered to the sinks if the track is enabled.
+// Frames are only delivered to the sinks if the track is enabled. If the track
+// is disabled, a black frame is instead forwarded to the sinks.

[tommi (sloooow) - chröme, 2014/08/05 09:50:46]

is fps relevant in this situation?  I.e. if the track was originally opened as
60fps, will it deliver 60 black frames ps when it's disabled?

[perkj_chrome, 2014/08/06 12:32:22]

Yes. That is intentional. To my understanding - the only difference to the sinks
is that a black frame is received instead.

 class MediaStreamVideoTrack::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
   FrameDeliverer(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
       bool enabled);
 
   void SetEnabled(bool enabled);
 
   // Add |callback| to receive video frames on the IO-thread.
@@ skipping 13 matching lines @@
                         const base::TimeTicks& estimated_capture_time);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
   void AddCallbackOnIO(void* id, const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
       void* id, const scoped_refptr<base::MessageLoopProxy>& message_loop);
 
   void SetEnabledOnIO(bool enabled);
+  const scoped_refptr<media::VideoFrame>& GetBlackFrame(

[tommi (sloooow) - chröme, 2014/08/05 09:50:46]

can you document this function?  The use of scoped_refptr, singular "black
frame" and the |original_frame| parameter, raise some questions.

[perkj_chrome, 2014/08/06 12:32:22]

Done.

+      const scoped_refptr<media::VideoFrame>& original_frame);
 
   // Used to DCHECK that AddCallback and RemoveCallback are called on the main
   // render thread.
   base::ThreadChecker thread_checker_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
 
   bool enabled_;
+  scoped_refptr<media::VideoFrame> black_frame_;
 
   typedef std::pair<void*, VideoCaptureDeliverFrameCB> VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 MediaStreamVideoTrack::FrameDeliverer::FrameDeliverer(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop, bool enabled)
     : io_message_loop_(io_message_loop),
@@ skipping 58 matching lines @@
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   enabled_ = enabled;
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
-  if (!enabled_)
-    return;
+  const scoped_refptr<media::VideoFrame>& video_frame =
+      enabled_ ? frame : GetBlackFrame(frame);
+
   for (std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
-    it->second.Run(frame, format, estimated_capture_time);
+    it->second.Run(video_frame, format, estimated_capture_time);
   }
 }
 
+const scoped_refptr<media::VideoFrame>&
+MediaStreamVideoTrack::FrameDeliverer::GetBlackFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {

[tommi (sloooow) - chröme, 2014/08/05 09:50:46]

different parameter name here than from the header... change to original_frame?
(or should it be reference_frame?)

Is there any chance that we could ping pong between resolutions and continually
be recreating black frames?

As an alternate possibility, would it make sense to blacken out the original
frame, or would that affect other tracks that share the same source?

[perkj_chrome, 2014/08/06 12:32:22]

done:
Only if the source do that for some reason- and that sounds like a bug in the
source if it happens frequently. (Changing video resolution should be possible
with applyConstraints one day). 
That is correct. It would affect all tracks that use the same source. So I think
this is the correct place.

+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  if (!black_frame_ || black_frame_->natural_size() != frame->natural_size())
+    black_frame_ = media::VideoFrame::CreateBlackFrame(frame->natural_size());
+
+  black_frame_->set_timestamp(frame->timestamp());
+  return black_frame_;
+}
+
 // static
 blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
     bool enabled) {
   blink::WebMediaStreamTrack track;
   track.initialize(source->owner());
   track.setExtraData(new MediaStreamVideoTrack(source,
                                                constraints,
@@ skipping 84 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   muted_state_ = muted_state;
 }
 
 bool MediaStreamVideoTrack::GetMutedState(void) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return muted_state_;
 }
 
 }  // namespace content