1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/* 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.
*/
/* From dev/ppb_video_capture_dev.idl modified Thu Dec 12 15:36:11 2013. */
#ifndef PPAPI_C_DEV_PPB_VIDEO_CAPTURE_DEV_H_
#define PPAPI_C_DEV_PPB_VIDEO_CAPTURE_DEV_H_
#include "ppapi/c/dev/pp_video_capture_dev.h"
#include "ppapi/c/dev/ppb_device_ref_dev.h"
#include "ppapi/c/pp_array_output.h"
#include "ppapi/c/pp_bool.h"
#include "ppapi/c/pp_completion_callback.h"
#include "ppapi/c/pp_instance.h"
#include "ppapi/c/pp_macros.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/c/pp_stdint.h"
#define PPB_VIDEOCAPTURE_DEV_INTERFACE_0_3 "PPB_VideoCapture(Dev);0.3"
#define PPB_VIDEOCAPTURE_DEV_INTERFACE PPB_VIDEOCAPTURE_DEV_INTERFACE_0_3
/**
* @file
* This file defines the <code>PPB_VideoCapture_Dev</code> interface.
*/
/**
* @addtogroup Interfaces
* @{
*/
/**
* Video capture interface. It goes hand-in-hand with PPP_VideoCapture_Dev.
*
* Theory of operation:
* 1- Create a VideoCapture resource using Create.
* 2- Find available video capture devices using EnumerateDevices.
* 3- Open a video capture device. In addition to a device reference (0 can be
* used to indicate the default device), you pass in the requested info
* (resolution, frame rate), as well as suggest a number of buffers you will
* need.
* 4- Start the capture using StartCapture.
* 5- Receive the OnDeviceInfo callback, in PPP_VideoCapture_Dev, which will
* give you the actual capture info (the requested one is not guaranteed), as
* well as an array of buffers allocated by the browser.
* 6- On every frame captured by the browser, OnBufferReady (in
* PPP_VideoCapture_Dev) is called with the index of the buffer from the array
* containing the new frame. The buffer is now "owned" by the plugin, and the
* browser won't reuse it until ReuseBuffer is called.
* 7- When the plugin is done with the buffer, call ReuseBuffer.
* 8- Stop the capture using StopCapture.
* 9- Close the device.
*
* The browser may change the resolution based on the constraints of the system,
* in which case OnDeviceInfo will be called again, with new buffers.
*
* The buffers contain the pixel data for a frame. The format is planar YUV
* 4:2:0, one byte per pixel, tightly packed (width x height Y values, then
* width/2 x height/2 U values, then width/2 x height/2 V values).
*/
struct PPB_VideoCapture_Dev_0_3 {
/**
* Creates a new VideoCapture.
*/
PP_Resource (*Create)(PP_Instance instance);
/**
* Returns PP_TRUE if the given resource is a VideoCapture.
*/
PP_Bool (*IsVideoCapture)(PP_Resource video_capture);
/**
* Enumerates video capture devices.
*
* @param[in] video_capture A <code>PP_Resource</code> corresponding to a
* video capture resource.
* @param[in] output An output array which will receive
* <code>PPB_DeviceRef_Dev</code> resources on success. Please note that the
* ref count of those resources has already been increased by 1 for the
* caller.
* @param[in] callback A <code>PP_CompletionCallback</code> to run on
* completion.
*
* @return An error code from <code>pp_errors.h</code>.
*/
int32_t (*EnumerateDevices)(PP_Resource video_capture,
struct PP_ArrayOutput output,
struct PP_CompletionCallback callback);
/**
* Requests device change notifications.
*
* @param[in] video_capture A <code>PP_Resource</code> corresponding to a
* video capture resource.
* @param[in] callback The callback to receive notifications. If not NULL, it
* will be called once for the currently available devices, and then every
* time the list of available devices changes. All calls will happen on the
* same thread as the one on which MonitorDeviceChange() is called. It will
* receive notifications until <code>video_capture</code> is destroyed or
* <code>MonitorDeviceChange()</code> is called to set a new callback for
* <code>video_capture</code>. You can pass NULL to cancel sending
* notifications.
* @param[inout] user_data An opaque pointer that will be passed to
* <code>callback</code>.
*
* @return An error code from <code>pp_errors.h</code>.
*/
int32_t (*MonitorDeviceChange)(PP_Resource video_capture,
PP_MonitorDeviceChangeCallback callback,
void* user_data);
/**
* Opens a video capture device. |device_ref| identifies a video capture
* device. It could be one of the resource in the array returned by
* |EnumerateDevices()|, or 0 which means the default device.
* |requested_info| is a pointer to a structure containing the requested
* resolution and frame rate. |buffer_count| is the number of buffers
* requested by the plugin. Note: it is only used as advisory, the browser may
* allocate more or fewer based on available resources. How many buffers
* depends on usage. At least 2 to make sure latency doesn't cause lost
* frames. If the plugin expects to hold on to more than one buffer at a time
* (e.g. to do multi-frame processing, like video encoding), it should request
* that many more.
*/
int32_t (*Open)(PP_Resource video_capture,
PP_Resource device_ref,
const struct PP_VideoCaptureDeviceInfo_Dev* requested_info,
uint32_t buffer_count,
struct PP_CompletionCallback callback);
/**
* Starts the capture.
*
* Returns PP_ERROR_FAILED if called when the capture was already started, or
* PP_OK on success.
*/
int32_t (*StartCapture)(PP_Resource video_capture);
/**
* Allows the browser to reuse a buffer that was previously sent by
* PPP_VideoCapture_Dev.OnBufferReady. |buffer| is the index of the buffer in
* the array returned by PPP_VideoCapture_Dev.OnDeviceInfo.
*
* Returns PP_ERROR_BADARGUMENT if buffer is out of range (greater than the
* number of buffers returned by PPP_VideoCapture_Dev.OnDeviceInfo), or if it
* is not currently owned by the plugin. Returns PP_OK otherwise.
*/
int32_t (*ReuseBuffer)(PP_Resource video_capture, uint32_t buffer);
/**
* Stops the capture.
*
* Returns PP_ERROR_FAILED if the capture wasn't already started, or PP_OK on
* success.
*/
int32_t (*StopCapture)(PP_Resource video_capture);
/**
* Closes the video capture device, and stops capturing if necessary. It is
* not valid to call |Open()| again after a call to this method.
* If a video capture resource is destroyed while a device is still open, then
* it will be implicitly closed, so you are not required to call this method.
*/
void (*Close)(PP_Resource video_capture);
};
typedef struct PPB_VideoCapture_Dev_0_3 PPB_VideoCapture_Dev;
/**
* @}
*/
#endif /* PPAPI_C_DEV_PPB_VIDEO_CAPTURE_DEV_H_ */
|
