Hook up EncodedVideoSource on the browser side

content/common/media/encoded_video_source_messages.h

+// Copyright (c) 2012 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 "ipc/ipc_message_macros.h"
+#include "media/video/capture/video_capture_types.h"
+#include "media/video/encoded_video_source.h"
+#include "media/video/video_encode_types.h"
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT CONTENT_EXPORT
+#define IPC_MESSAGE_START EncodedVideoSourceMsgStart
+
+#if !defined(OS_ANDROID)
+IPC_ENUM_TRAITS(media::VideoCodec)
+#endif  // !defined(OS_ANDROID)
+
+IPC_STRUCT_TRAITS_BEGIN(media::VideoEncodingConfig)
+  IPC_STRUCT_TRAITS_MEMBER(codec_type)
+  IPC_STRUCT_TRAITS_MEMBER(codec_name)
+  IPC_STRUCT_TRAITS_MEMBER(max_resolution)
+  IPC_STRUCT_TRAITS_MEMBER(max_frames_per_second)
+  IPC_STRUCT_TRAITS_MEMBER(max_bitrate)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(media::RuntimeVideoEncodingParameters)
+  IPC_STRUCT_TRAITS_MEMBER(average_bitrate)
+  IPC_STRUCT_TRAITS_MEMBER(max_bitrate)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(media::VideoEncodingParameters)
+  IPC_STRUCT_TRAITS_MEMBER(codec_name)
+  IPC_STRUCT_TRAITS_MEMBER(resolution)
+  IPC_STRUCT_TRAITS_MEMBER(frames_per_second)
+  IPC_STRUCT_TRAITS_MEMBER(runtime_params)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(media::BufferEncodingMetadata)
+  IPC_STRUCT_TRAITS_MEMBER(timestamp)
+  IPC_STRUCT_TRAITS_MEMBER(key_frame)
+IPC_STRUCT_TRAITS_END()
+
+// Message from Renderer to Browser process to query the encoding capability
+// for the capture session. A successful request results in
+// EncoderVideoSourceMessage_CapabilityAvailable message.
+IPC_MESSAGE_CONTROL1(EncodedVideoSourceHostMsg_GetCapability,
+                     media::VideoCaptureSessionId /* session_id */)
+
+// Message from Renderer to Browser process to create a bitstream with specific
+// parameters. A successful request results in beginning of streaming and
+// EncoderVideoSourceMsg_BitstreamCreated message to Renderer. A failed request
+// triggers EncodedVideoSourceMsg_BitstreamDestroyed message. |session_id| is
+// the capture session id returned by the MediaStreamManager. The renderer is
+// responsible for generating unique |device_id| within its context that will be
+// used to identify bitstreams in IPC.
+IPC_MESSAGE_CONTROL3(EncodedVideoSourceHostMsg_CreateBitstream,
+                     int /* device_id */,
+                     media::VideoCaptureSessionId /* session_id */,
+                     media::VideoEncodingParameters /* params */)
+
+// Message from Renderer to Browser process to stop streaming a bitstream. When
+// Browser has finalized the bitstream it will trigger
+// EncodedVideoSourceMsg_BitstreamDestroyed message back from Browser to
+// Renderer. Renderer must be prepared to receive
+// EncodedVideoSourceMsg_BitstreamReady messages until it has received the
+// EncodedVideoSourceMsg_BitstreamDestroyed message.
+IPC_MESSAGE_CONTROL1(EncodedVideoSourceHostMsg_DestroyBitstream,
+                    int /* device_id */)
+
+// Message from Renderer to Browser process to set a stream's bitstream config.
+// Will always result in EncodedVideoSourceMsg_BitstreamConfigChanged containing
+// currently active parameters, regardless of whether this call succeeded or
+// not.
+IPC_MESSAGE_CONTROL2(EncodedVideoSourceHostMsg_TryConfigureBitstream,
+                    int /* device_id */,
+                    media::RuntimeVideoEncodingParameters /* params */)
+
+// Message from Renderer to Browser process to tell that the data within a
+// buffer has been processed and it can be reused to encode upcoming bitstream.
+IPC_MESSAGE_CONTROL2(EncodedVideoSourceHostMsg_BitstreamBufferConsumed,
+                     int /* device_id */,
+                     int /* buffer_id */)
+
+// Message from Browser to Renderer process to report the encoding capability
+// of the device.
+IPC_MESSAGE_CONTROL2(EncodedVideoSourceMsg_CapabilityAvailable,
+                     media::VideoCaptureSessionId /* session_id */,

[hshi1, 2013/06/12 20:16:32]

You're using session_id instead of device_id here, is the reason so that caps
can be reported prior to starting capture?

I realized that it would be difficult for VCMessageFilter to locate the delegate
(VCImpl) object associated with the session_id, because the session_id <->
VCImpl mapping is held by the VCImplManager. In order to do this I'll have to
add some plumbing for VCMessageFilter to get to the VCImplManager that owns it,
and another method to look up the VCImpl. Furthermore the manager returns a
VCImpl pointer, this would break the VCMessageFilter::Delegate abstraction.

[sheu, 2013/06/12 20:58:08]

I suppose we could respec the IPC to say:

GetCapability: device_id and session_id
CapabilityAvailable: returns device_id

Since the device_ids are assigned on the client side, we'll just have the
CapabilityAvailable return from the browser with the device_id it was given in
GetCapability, without actually (yet) creating the VideoCaptureController yet on
the browser side.

Does this sound good?

+                     media::VideoEncodingCapability /* capability */)
+
+// Message from Browser to Renderer process to acknowledge a request to create
+// an encoded video bitstream. When this message occurs bitstream can be
+// considered to be streaming and Renderer should be ready to start accepting
+// EncodedVideoSourceMsg_BitstreamReady messages and buffers contained within
+// them. Shared memory buffers used to deliver the bitstream are assigned with
+// buffer ids as specified by the buffers parameter.
+IPC_MESSAGE_CONTROL4(EncodedVideoSourceMsg_BitstreamCreated,
+                     int /* device id */,
+                     media::VideoEncodingParameters /* params */,
+                     std::vector<base::SharedMemoryHandle> /* buffers */,
+                     size_t /* buffer_size */)

[hshi1, 2013/06/12 18:30:45]

What does |buffer_size| represent? I guess it is the size of a single buffer? So
we assume that all buffers in std::vector<base::SharedMemoryHandle> buffers have
the same size?

[sheu, 2013/06/12 19:51:18]

Right.  The assumption is that they all share the same size.

+
+// Message from Browser to Renderer process to acknowledge a request to destroy
+// an encoded video bitstream.
+IPC_MESSAGE_CONTROL1(EncodedVideoSourceMsg_BitstreamDestroyed,
+                     int /* device id */)
+
+// Message from Browser to Renderer process to inform the clients of the current
+// encoding parameters, regardless of whether the previous request to change
+// them has been successful or not. This is called usually as a response to
+// EncodedVideoSourceHostMsg_TryConfigureBitstream during runtime, but can occur
+// also as a result of config change initiated by encoder or other clients in
+// the system. E.g. if there are multiple clients and bitstream config change is
+// requested from one client, all clients should be prepared to handle the
+// configuration change.
+IPC_MESSAGE_CONTROL2(EncodedVideoSourceMsg_BitstreamConfigChanged,
+                     int /* device id */,
+                     media::RuntimeVideoEncodingParameters /* current_params */)
+
+// Message from Browser to Renderer process indicating that a bitstream buffer
+// is available for the stream. The value of |size| indicates the amount of
+// valid bitstream data (in bytes).
+IPC_MESSAGE_CONTROL4(EncodedVideoSourceMsg_BitstreamReady,
+                     int /* device id */,
+                     int /* buffer_id */,
+                     size_t /* size */,
+                     media::BufferEncodingMetadata /* metadata */)