Define EncodedVideoSource and RtcCapturedEncodingVideoCapturer.

media/video/encoded_video_source.h

Index: media/video/encoded_video_source.h
diff --git a/media/video/encoded_video_source.h b/media/video/encoded_video_source.h
new file mode 100644
index 0000000000000000000000000000000000000000..c545cb0e4959157fb943c4ece4ced2637d6a2339
--- /dev/null
+++ b/media/video/encoded_video_source.h
@@ -0,0 +1,76 @@
+// Copyright (c) 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.
+
+#ifndef MEDIA_VIDEO_ENCODED_VIDEO_SOURCE_H_
+#define MEDIA_VIDEO_ENCODED_VIDEO_SOURCE_H_
+
+#include "base/memory/ref_counted.h"
+#include "media/base/encoded_bitstream_buffer.h"
+#include "media/video/video_encode_types.h"
+
+namespace media {
+
+// Class to represent any encoded video source. Anything that provides encoded
+// video can be an EncodedVideoSource. Notable examples of this can be video
+// encoder and webcam that has encoding capabilities.
+// TODO(hshi): merge this with VEA interface. http://crbug.com/248334.
+class MEDIA_EXPORT EncodedVideoSource {
+ public:
+  class MEDIA_EXPORT Client {
+   public:
+    // Notifies client that bitstream is opened successfully. The |params|
+    // contains the actual encoding parameters chosen by the browser process.
+    // It may be different from the params requested in OpenBitstream().
+    virtual void OnOpened(const VideoEncodingParameters& params) = 0;
+
+    // Notifies client that bitstream is closed. After this call it is
+    // guaranteed that client will not receive further calls.
+    virtual void OnClosed() = 0;
+
+    // Delivers an encoded bitstream buffer to the client.
+    virtual void OnBufferReady(
+        scoped_refptr<const EncodedBitstreamBuffer> buffer) = 0;
+
+    // Notifies client that encoding parameters has changed. The |params|
+    // contains the current encoding parameters chosen by the browser process.
+    // It may be different from the params requested in TrySetBitstreamConfig().
+    virtual void OnConfigChanged(
+        const RuntimeVideoEncodingParameters& params) = 0;
+  };
+
+  // Callback is invoked once RequestCapabilities() is complete.
+  typedef base::Callback<void(const VideoEncodingCapabilities& capabilities)>
+      RequestCapabilitiesCallback;
+
+  // RequestCapabilities initiates an asynchronous query for the types of
+  // encoded bitstream supported by the encoder. This call should be invoked
+  // only once. EncodedVideoSource will invoke |callback| when capabilities

[Ami GONE FROM CHROMIUM, 2013/06/13 22:56:58]

Given this should be called only once, would it make more sense to always return
Capabilities unconditionally in Client::OnOpened?

[hshi1, 2013/06/13 23:33:40]

Unfortunately Client::OnOpened is too late for passing capabilities. The caps
needs to be sent to the factory very early (before any encoded bitstream is
opened), because factory reports its supported codecs list to libjingle based on
the caps, and the that codec list determines the list of SendCodecs that is
signalled in the SDP header. No caps, no send codecs, and we won't have a
generic codec listed in the offer sent to the receiver end.

+  // become available.
+  virtual void RequestCapabilities(
+      const RequestCapabilitiesCallback& callback) = 0;
+
+  // OpenBitstream opens the bitstream on the encoded video source. Only one
+  // bitstream can be opened for an encoded video source.
+  virtual void OpenBitstream(Client* client,

[Ami GONE FROM CHROMIUM, 2013/06/13 22:56:58]

doco lifetime of |client|
(probably the answer is that it must outlive the call to OnClosed()).

[hshi1, 2013/06/13 23:33:40]

Well the answer is more complicated. The lifetime of |client| is limited to the
owner, encoding capturer factory (due to the scoped_ptr) but it may be released
earlier. In the current design, it may or may not outlive the call to
OnClosed().

Case (1): bitstream is closed upon request of libjingle (coming from
WebRtcVideoEncoder::Release): this invokes the dtor of client, which calls
EVS->CloseBitstream(). Note that EVS->CloseBitstream() immedialy sets its
client_ pointer to NULL, so when the IPC roundtrip comes back, client_ will not
be notified of OnClosed().

Case (2): bitstream is closed by the browser process (may be due to an error for
example). In this case, renderer process never requested CloseBitstream, but got
an OnBitstreamClosed message. This will cause EVS to call EVSClient::OnClosed
(where we set finished_ to true), and then EVS will set its client_ to NULL.

+                             const VideoEncodingParameters& params) = 0;
+
+  // CloseBitstream closes the bitstream.
+  virtual void CloseBitstream() = 0;
+
+  // ReturnBitstreamBuffer notifies that the data within the buffer has been
+  // processed and it can be reused to encode upcoming bitstream.
+  virtual void ReturnBitstreamBuffer(
+      scoped_refptr<const media::EncodedBitstreamBuffer> buffer) = 0;
+
+  // TrySetBitstreamConfig requests to change encoding parameters. Old config
+  // must be considered valid until OnConfigChanged is invoked on the client
+  // signaling successful change.
+  virtual void TrySetBitstreamConfig(
+      const RuntimeVideoEncodingParameters& params) = 0;
+};
+
+}  // namespace media
+
+#endif  // MEDIA_VIDEO_ENCODED_VIDEO_SOURCE_H_
+