int32_t
ppb_video_decoder_decode(PP_Resource video_decoder,
const struct PP_VideoBitstreamBuffer_Dev *bitstream_buffer,
struct PP_CompletionCallback callback)
{
struct pp_video_decoder_s *vd = pp_resource_acquire(video_decoder, PP_RESOURCE_VIDEO_DECODER);
if (!vd) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
if (vd->failed_state) {
trace_warning("%s, there were errors before, giving up\n", __func__);
pp_resource_release(video_decoder);
return PP_ERROR_FAILED;
}
void *rawdata = ppb_buffer_map(bitstream_buffer->data);
if (!rawdata) {
trace_error("%s, bad bitstream buffer\n", __func__);
pp_resource_release(video_decoder);
return PP_ERROR_FAILED;
}
uint8_t *inbuf = rawdata;
size_t inbuf_sz = bitstream_buffer->size;
while (inbuf_sz > 0) {
uint8_t *outbuf = NULL;
int outbuf_sz = 0;
int len = av_parser_parse2(vd->avparser, vd->avctx, &outbuf, &outbuf_sz,
inbuf, inbuf_sz, 0, 0, AV_NOPTS_VALUE);
if (outbuf_sz > 0)
decode_frame(vd, outbuf, outbuf_sz, vd->last_consumed_bitstream_buffer_id);
inbuf += len;
inbuf_sz -= len;
}
vd->last_consumed_bitstream_buffer_id = bitstream_buffer->id;
ppb_buffer_unmap(bitstream_buffer->data);
pp_resource_release(video_decoder);
ppb_core_call_on_main_thread(0, callback, PP_OK);
return PP_OK_COMPLETIONPENDING;
}
int32_t
ppb_video_capture_open(PP_Resource video_capture, PP_Resource device_ref,
const struct PP_VideoCaptureDeviceInfo_Dev *requested_info,
uint32_t buffer_count, struct PP_CompletionCallback callback)
{
int32_t result;
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
const char *capture_device = default_capture_device;
struct PP_Var longname = ppb_device_ref_get_longname(device_ref);
if (longname.type == PP_VARTYPE_STRING)
capture_device = ppb_var_var_to_utf8(longname, NULL);
vc->fd = v4l2_open(capture_device, O_RDWR);
ppb_var_release(longname);
if (vc->fd < 0) {
result = PP_ERROR_NOACCESS;
goto point_1;
}
struct v4l2_capability caps;
if (v4l2_ioctl(vc->fd, VIDIOC_QUERYCAP, &caps) != 0) {
result = PP_ERROR_FAILED;
goto point_2;
}
#ifdef V4L2_CAP_DEVICE_CAPS
const uint32_t device_caps = (caps.capabilities & V4L2_CAP_DEVICE_CAPS) ? caps.device_caps
: caps.capabilities;
#else
const uint32_t device_caps = caps.capabilities;
#endif // V4L2_CAP_DEVICE_CAPS
if (!(device_caps & V4L2_CAP_VIDEO_CAPTURE)) {
trace_error("%s, device can't capture\n", __func__);
result = PP_ERROR_FAILED;
goto point_2;
}
if (!(device_caps & V4L2_CAP_READWRITE)) {
trace_error("%s, device doesn't support read/write interface\n", __func__);
result = PP_ERROR_FAILED;
goto point_2;
}
if (requested_info) {
vc->width = requested_info->width;
vc->height = requested_info->height;
vc->fps = requested_info->frames_per_second;
} else {
vc->width = 640;
vc->height = 480;
vc->fps = 15;
}
struct v4l2_format fmt = {
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.fmt.pix.width = vc->width,
.fmt.pix.height = vc->height,
.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420, // PPAPI hardcodes format to YUV420
.fmt.pix.field = V4L2_FIELD_INTERLACED,
};
if (v4l2_ioctl(vc->fd, VIDIOC_S_FMT, &fmt) != 0) {
trace_error("%s, failed to set resolution\n", __func__);
result = PP_ERROR_FAILED;
goto point_2;
}
vc->width = fmt.fmt.pix.width;
vc->height = fmt.fmt.pix.height;
vc->buffer_size = fmt.fmt.pix.sizeimage; // buffer size in bytes
vc->buffer_count = MAX(buffer_count, 5); // limit lowest number of buffers, just in case
vc->buffers = calloc(sizeof(*vc->buffers), vc->buffer_count);
if (!vc->buffers) {
trace_error("%s, memory allocation failure (1)\n", __func__);
result = PP_ERROR_FAILED;
goto point_2;
}
vc->buffer_is_free = malloc(sizeof(*vc->buffer_is_free) * vc->buffer_count);
if (!vc->buffer_is_free) {
trace_error("%s, memory allocation failure (2)\n", __func__);
result = PP_ERROR_FAILED;
goto point_3;
}
for (unsigned int k = 0; k < vc->buffer_count; k ++) {
vc->buffer_is_free[k] = 1;
vc->buffers[k] = ppb_buffer_create(vc->instance->id, vc->buffer_size);
if (vc->buffers[k] == 0)
goto point_4;
}
struct PP_VideoCaptureDeviceInfo_Dev info = {
.width = vc->width,
.height = vc->height,
.frames_per_second = vc->fps,
};
vc->ppp_video_capture_dev->OnDeviceInfo(vc->instance->id, video_capture, &info,
vc->buffer_count, vc->buffers);
result = PP_OK;
goto point_1;
point_4:
for (unsigned int k = 0; k < vc->buffer_count; k ++)
ppb_core_release_resource(vc->buffers[k]);
free_and_nullify(vc->buffer_is_free);
point_3:
free_and_nullify(vc->buffers);
point_2:
v4l2_close(vc->fd);
vc->fd = -1;
point_1:
pp_resource_release(video_capture);
ppb_core_call_on_main_thread2(0, callback, result, __func__);
return PP_OK_COMPLETIONPENDING;
}
struct on_buffer_ready_param_s {
PP_Instance instance;
PP_Resource video_capture;
uint32_t buf_idx;
const struct PPP_VideoCapture_Dev_0_1 *ppp_video_capture_dev;
};
static
void
on_buffer_ready_comt(void *user_data, int32_t result)
{
struct on_buffer_ready_param_s *p = user_data;
struct pp_instance_s *pp_i = tables_get_pp_instance(p->instance);
if (!pp_i)
return;
p->ppp_video_capture_dev->OnBufferReady(p->instance, p->video_capture, p->buf_idx);
g_slice_free1(sizeof(*p), p);
}
static
void *
video_capture_thread(void *param)
{
struct pp_video_capture_s *vc = param;
PP_Resource video_capture = vc->self_id;
PP_Instance instance = vc->instance->id;
const int fd = vc->fd;
const size_t buffer_size = vc->buffer_size;
vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc)
goto gone;
while (!vc->terminate_thread) {
// find free buffer
uint32_t buf_idx = (uint32_t)-1;
for (uint32_t k = 0; k < vc->buffer_count; k ++) {
if (vc->buffer_is_free[k]) {
buf_idx = k;
vc->buffer_is_free[k] = 0;
break;
}
}
if (buf_idx == (uint32_t)-1) {
// all buffers are busy, wait for some to free, with resource unlocked
pp_resource_release(video_capture);
usleep(10);
vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc)
goto gone;
continue;
}
PP_Resource buffer = vc->buffers[buf_idx];
pp_resource_release(video_capture);
// wait on v4l2_read() with resource unlocked
void *ptr = ppb_buffer_map(buffer);
RETRY_ON_EINTR(v4l2_read(fd, ptr, buffer_size));
ppb_buffer_unmap(buffer);
vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc)
goto gone;
struct on_buffer_ready_param_s *p = g_slice_alloc(sizeof(*p));
p->instance = instance;
p->video_capture = video_capture;
p->buf_idx = buf_idx;
p->ppp_video_capture_dev = vc->ppp_video_capture_dev;
ppb_core_call_on_main_thread2(0, PP_MakeCCB(on_buffer_ready_comt, p), PP_OK, __func__);
}
pp_resource_release(video_capture);
return NULL;
gone:
trace_error("%s, resource gone\n", __func__);
return NULL;
}
int32_t
ppb_video_capture_start_capture(PP_Resource video_capture)
{
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
if (vc->thread_started)
goto done;
if (vc->fd < 0) {
trace_error("%s, device is closed\n", __func__);
pp_resource_release(video_capture);
return PP_ERROR_FAILED;
}
vc->ppp_video_capture_dev->OnStatus(vc->instance->id, video_capture,
PP_VIDEO_CAPTURE_STATUS_STARTING);
pp_resource_ref(video_capture); // prevents freeing while thread is still running
pthread_create(&vc->thread, NULL, video_capture_thread, vc);
vc->thread_started = 1;
vc->ppp_video_capture_dev->OnStatus(vc->instance->id, video_capture,
PP_VIDEO_CAPTURE_STATUS_STARTED);
done:
pp_resource_release(video_capture);
return PP_OK;
}
int32_t
ppb_video_capture_reuse_buffer(PP_Resource video_capture, uint32_t buffer)
{
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
if (buffer < vc->buffer_count)
vc->buffer_is_free[buffer] = 1;
pp_resource_release(video_capture);
return PP_OK;
}
int32_t
ppb_video_capture_stop_capture(PP_Resource video_capture)
{
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
if (!vc->thread_started)
goto done;
vc->ppp_video_capture_dev->OnStatus(vc->instance->id, video_capture,
PP_VIDEO_CAPTURE_STATUS_STOPPING);
vc->terminate_thread = 1;
pthread_t thread = vc->thread;
pp_resource_release(video_capture);
pthread_join(thread, NULL);
vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, resource gone\n", __func__);
return PP_ERROR_BADRESOURCE;
}
vc->thread_started = 0;
vc->terminate_thread = 0;
vc->ppp_video_capture_dev->OnStatus(vc->instance->id, video_capture,
PP_VIDEO_CAPTURE_STATUS_STOPPED);
pp_resource_unref(video_capture); // remove reference made in start_capture()
done:
pp_resource_release(video_capture);
return PP_OK;
}
void
ppb_video_capture_close(PP_Resource video_capture)
{
ppb_video_capture_stop_capture(video_capture);
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return;
}
ppb_video_capture_destroy(vc);
pp_resource_release(video_capture);
return;
}
// trace wrappers
TRACE_WRAPPER
PP_Resource
trace_ppb_video_capture_create(PP_Instance instance)
{
trace_info("[PPB] {full} %s instance=%d\n", __func__+6, instance);
return ppb_video_capture_create(instance);
}