[Cast] VideoFrameFactory interface to vend frames with encoder affinity.

media/cast/sender/video_encoder.h

 // Copyright 2014 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.
 
 #ifndef MEDIA_CAST_SENDER_VIDEO_ENCODER_H_
 #define MEDIA_CAST_SENDER_VIDEO_ENCODER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 
 namespace media {
 namespace cast {
 
+class VideoFrameFactory;
+
 // All these functions are called from the main cast thread.
 class VideoEncoder {
  public:
   typedef base::Callback<void(scoped_ptr<EncodedFrame>)> FrameEncodedCallback;
 
   virtual ~VideoEncoder() {}
 
   // If true is returned, the Encoder has accepted the request and will process
   // it asynchronously, running |frame_encoded_callback| on the MAIN
   // CastEnvironment thread with the result.  If false is returned, nothing
   // happens and the callback will not be run.
   virtual bool EncodeVideoFrame(
       const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& reference_time,
       const FrameEncodedCallback& frame_encoded_callback) = 0;
 
   // Inform the encoder about the new target bit rate.
   virtual void SetBitRate(int new_bit_rate) = 0;
 
   // Inform the encoder to encode the next frame as a key frame.
   virtual void GenerateKeyFrame() = 0;
 
   // Inform the encoder to only reference frames older or equal to frame_id;
   virtual void LatestFrameIdToReference(uint32 frame_id) = 0;
+
+  // Allow the encoder to return a specialized video frame factory. May return
+  // null, in which case a default implementation will be used instead.
+  virtual scoped_refptr<VideoFrameFactory> GetVideoFrameFactory() = 0;

[Alpha Left Google, 2014/11/17 20:23:14]

I don't think the threading model for this method is good.

According to this interface. VideoframeFactory is going to be called on the main
thread, while encoder is running on the encoder thread. Which means
VideoFrameFactory will have to perform cross thread communication with encoder
implementation. It is easy to make mistakes if each encoder & VideoFrameFactory
has to implement this. And it violates the design that VideoEncoder is
sinlge-threaded.

[jfroy, 2014/11/17 21:23:06]

That's not quite the design I had in mind.

The expectation is that GetVideoFrameFactory() will always be called on the main
cast thread, in keeping with the design of VideoEncoder. Its purpose is to
create a or return an existing video frame factory (essentially a specialized
allocator) that is assumed to be usable from any thread (but perhaps not
concurrently; that detail is up to the implementation). This is why the video
frame factory is a thread-safe ref-counted object.

[Alpha Left Google, 2014/11/18 02:57:58]

In this patch VideoFrameFactory is always accessed through VideoFrameInput which
is already a refcounted thread safe. Making VideoFrameFactory doesn't add more
value. Also there's only one owner of VideoFrameFactory in this patch, what
about change this to:
virtual scoped_ptr<VidoeFrameFactory> CreateVideoFrameFactory() = 0;

[jfroy, 2014/11/18 18:03:59]

Sounds good.

 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_SENDER_VIDEO_ENCODER_H_