/*
|
* xcam_handle.cpp - xcam handle implementation
|
*
|
* Copyright (c) 2017 Intel Corporation
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
* Author: Wind Yuan <feng.yuan@intel.com>
|
*/
|
|
#include <xcam_utils.h>
|
#include <xcam_handle.h>
|
#include <dma_video_buffer.h>
|
#include "context_priv.h"
|
#include <stdarg.h>
|
#if HAVE_LIBDRM
|
#include <drm_bo_buffer.h>
|
#endif
|
|
using namespace XCam;
|
|
XCamHandle *
|
xcam_create_handle (const char *name)
|
{
|
ContextBase *context = NULL;
|
|
if (handle_name_equal (name, HandleType3DNR)) {
|
context = new NR3DContext;
|
} else if (handle_name_equal (name, HandleTypeWaveletNR)) {
|
context = new NRWaveletContext;
|
} else if (handle_name_equal (name, HandleTypeFisheye)) {
|
context = new FisheyeContext;
|
} else if (handle_name_equal (name, HandleTypeDefog)) {
|
context = new DefogContext;
|
} else if (handle_name_equal (name, HandleTypeDVS)) {
|
context = new DVSContext;
|
} else if (handle_name_equal (name, HandleTypeStitch)) {
|
context = new StitchContext;
|
} else {
|
XCAM_LOG_ERROR ("create handle failed with unsupported type:%s", name);
|
return NULL;
|
}
|
|
return HANDLE_CAST (context);
|
}
|
|
void
|
xcam_destroy_handle (XCamHandle *handle)
|
{
|
if (handle)
|
delete CONTEXT_BASE_CAST (handle);
|
}
|
|
XCamReturn
|
xcam_handle_init (XCamHandle *handle)
|
{
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
SmartPtr<CLImageHandler> handler_ptr;
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
XCAM_FAIL_RETURN (
|
ERROR, context, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handler_init failed, handle can NOT be NULL, did you have xcam_create_handler first?");
|
|
ret = context->init_handler ();
|
XCAM_FAIL_RETURN (
|
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
|
"xcam_handler_init, create handle ptr(%s) failed", context->get_type_name ());
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
xcam_handle_uinit (XCamHandle *handle)
|
{
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
|
XCAM_FAIL_RETURN (
|
ERROR, context, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handler_uinit failed, handle can NOT be NULL");
|
|
return context->uinit_handler ();
|
}
|
|
XCamReturn
|
xcam_handle_get_usage (XCamHandle *handle, char *usage_buf, int *usage_len)
|
{
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
XCAM_FAIL_RETURN (
|
ERROR, context, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handle_get_usage failed, handle can NOT be NULL");
|
|
const char *usage = context->get_usage ();
|
int len = strlen (usage) + 1;
|
if (len < *usage_len)
|
len = *usage_len;
|
strncpy (usage_buf, usage, len - 1);
|
*usage_len = len;
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
xcam_handle_set_parameters (
|
XCamHandle *handle, const char *field, ...)
|
{
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
ContextParams params;
|
|
XCAM_FAIL_RETURN (
|
ERROR, context, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handle_set_parameters failed, handle can NOT be NULL");
|
|
const char *vfield, *vvalue;
|
vfield = field;
|
va_list args;
|
va_start (args, field);
|
while (vfield) {
|
vvalue = va_arg (args, const char *);
|
XCAM_FAIL_RETURN (
|
ERROR, vvalue, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handle(%s) set_parameters failed, param(field:%s) value should never be NULL",
|
context->get_type_name (), vfield);
|
|
params[vfield] = vvalue;
|
vfield = va_arg (args, const char *);
|
}
|
va_end (args);
|
|
return context->set_parameters (params);
|
}
|
|
SmartPtr<VideoBuffer>
|
external_buf_to_drm_buf (XCamVideoBuffer *buf)
|
{
|
#if HAVE_LIBDRM
|
SmartPtr<DrmDisplay> display = DrmDisplay::instance ();
|
SmartPtr<DmaVideoBuffer> dma_buf;
|
SmartPtr<VideoBuffer> drm_buf;
|
SmartPtr<VideoBuffer> video_buf;
|
|
dma_buf = external_buf_to_dma_buf (buf);
|
|
XCAM_FAIL_RETURN (
|
ERROR, dma_buf.ptr (), NULL,
|
"external_buf_to_drm_buf failed");
|
|
video_buf = dma_buf;
|
XCAM_ASSERT (display.ptr ());
|
drm_buf = display->convert_to_drm_bo_buf (display, video_buf);
|
return drm_buf;
|
#else
|
XCAM_LOG_ERROR ("VideoBuffer doesn't support drm buf");
|
|
XCAM_UNUSED (buf);
|
return NULL;
|
#endif
|
}
|
|
SmartPtr<VideoBuffer>
|
copy_external_buf_to_drm_buf (XCamHandle *handle, XCamVideoBuffer *buf)
|
{
|
if (!handle || !buf) {
|
XCAM_LOG_WARNING ("xcam handle can NOT be NULL");
|
return NULL;
|
}
|
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
if (!context) {
|
XCAM_LOG_WARNING ("xcam handle context can NOT be NULL");
|
return NULL;
|
}
|
|
const XCamVideoBufferInfo src_info = buf->info;
|
uint8_t* src = buf->map (buf);
|
uint8_t* p_src = src;
|
if (!src) {
|
XCAM_LOG_WARNING ("xcam handle map buffer failed");
|
return NULL;
|
}
|
uint32_t height = src_info.height;
|
|
SmartPtr<BufferPool> buf_pool = context->get_input_buffer_pool();
|
XCAM_ASSERT (buf_pool.ptr ());
|
SmartPtr<VideoBuffer> video_buf = buf_pool->get_buffer (buf_pool);
|
XCAM_ASSERT (video_buf.ptr ());
|
const XCamVideoBufferInfo dest_info = video_buf->get_video_info ();
|
|
uint8_t* dest = video_buf->map ();
|
uint8_t* p_dest = dest;
|
|
for (uint32_t index = 0; index < src_info.components; index++) {
|
src += (int32_t)src_info.offsets[index];
|
p_src = src;
|
|
dest += dest_info.offsets[index];
|
p_dest = dest;
|
if (src_info.format == V4L2_PIX_FMT_NV12) {
|
height = height >> index;
|
}
|
for (uint32_t i = 0; i < height; i++) {
|
memcpy (p_dest, p_src, src_info.strides[index]);
|
p_src += src_info.strides[index];
|
p_dest += dest_info.strides[index];
|
}
|
}
|
|
buf->unmap (buf);
|
video_buf->unmap ();
|
|
return video_buf;
|
}
|
|
XCamReturn
|
xcam_handle_execute (XCamHandle *handle, XCamVideoBuffer *buf_in, XCamVideoBuffer **buf_out)
|
{
|
ContextBase *context = CONTEXT_BASE_CAST (handle);
|
SmartPtr<VideoBuffer> input, output;
|
|
XCAM_FAIL_RETURN (
|
ERROR, context && buf_in && buf_out, XCAM_RETURN_ERROR_PARAM,
|
"xcam_handle_execute failed, either of handle/buf_in/buf_out can NOT be NULL");
|
|
XCAM_FAIL_RETURN (
|
ERROR, context->get_handler().ptr (), XCAM_RETURN_ERROR_PARAM,
|
"context (%s) failed, handler was not initialized", context->get_type_name ());
|
|
if (buf_in->mem_type == XCAM_MEM_TYPE_GPU) {
|
input = external_buf_to_drm_buf (buf_in);
|
} else {
|
input = copy_external_buf_to_drm_buf (handle, buf_in);
|
}
|
XCAM_FAIL_RETURN (
|
ERROR, input.ptr (), XCAM_RETURN_ERROR_MEM,
|
"xcam_handle(%s) execute failed, buf_in convert to DRM buffer failed.",
|
context->get_type_name ());
|
|
if (*buf_out) {
|
output = external_buf_to_drm_buf (*buf_out);
|
XCAM_FAIL_RETURN (
|
ERROR, output.ptr (), XCAM_RETURN_ERROR_MEM,
|
"xcam_handle(%s) execute failed, buf_out set but convert to DRM buffer failed.",
|
context->get_type_name ());
|
}
|
|
XCamReturn ret = context->execute (input, output);
|
|
XCAM_FAIL_RETURN (
|
ERROR, ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS,
|
ret,
|
"context (%s) failed, handler execute failed", context->get_type_name ());
|
|
if (*buf_out == NULL && output.ptr ()) {
|
XCamVideoBuffer *new_buf = convert_to_external_buffer (output);
|
XCAM_FAIL_RETURN (
|
ERROR, new_buf, XCAM_RETURN_ERROR_MEM,
|
"xcam_handle(%s) execute failed, out buffer can't convert to external buffer.",
|
context->get_type_name ());
|
*buf_out = new_buf;
|
}
|
return ret;
|
}
|
