/******************************************************************************
* Buffer_setUserPtr
******************************************************************************/
Int Buffer_setUserPtr(Buffer_Handle hBuf, Int8 *ptr)
{
assert(hBuf);
if (!hBuf->reference) {
return Dmai_EINVAL;
}
hBuf->userPtr = ptr;
if (ptr) {
hBuf->physPtr = Memory_getBufferPhysicalAddress(hBuf->userPtr, 4, NULL);
}
else {
hBuf->physPtr = 0;
}
Dmai_dbg2("Set user pointer 0x%x (physical 0x%x)\n",
(Uns) hBuf->userPtr, (Uns) hBuf->physPtr);
return Dmai_EOK;
}
/******************************************************************************
* Framecopy_accel_execute
******************************************************************************/
Int Framecopy_accel_config(Framecopy_Handle hFc,
Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf)
{
vdce_params_t params;
BufferGfx_Dimensions srcDim;
BufferGfx_Dimensions dstDim;
Int width, height;
/* Buffer needs to be graphics buffers */
if (Buffer_getType(hSrcBuf) != Buffer_Type_GRAPHICS ||
Buffer_getType(hDstBuf) != Buffer_Type_GRAPHICS) {
Dmai_err0("Src and dst buffers need to be graphics buffers\n");
return Dmai_EINVAL;
}
/* Sanity check buffer color space */
if (BufferGfx_getColorSpace(hSrcBuf) !=
BufferGfx_getColorSpace(hDstBuf)) {
Dmai_err0("Src and dst buffers need to have same colorspace\n");
return Dmai_EINVAL;
}
BufferGfx_getDimensions(hSrcBuf, &srcDim);
BufferGfx_getDimensions(hDstBuf, &dstDim);
/* Source and destination width must be even */
if (dstDim.width % 2 || srcDim.width % 2) {
Dmai_err2("Output (%d) and input width (%d) must be even\n",
dstDim.width, srcDim.width);
return Dmai_EINVAL;
}
/* Pitches must be a multiple of 8 */
if (dstDim.lineLength % 8 || srcDim.lineLength % 8) {
Dmai_err2("Dst (%ld) and src (%ld) pitch must be a multiple of 8\n",
dstDim.lineLength, srcDim.lineLength);
return Dmai_EINVAL;
}
/* Select the smallest resolution */
width = srcDim.width < dstDim.width ? srcDim.width : dstDim.width;
height = srcDim.height < dstDim.height ? srcDim.height : dstDim.height;
Dmai_dbg2("Configuring resizer to copy image resolution %dx%d\n",
width, height);
params.vdce_mode = VDCE_OPERATION_RESIZING;
if (ioctl(hFc->fd, VDCE_GET_DEFAULT, ¶ms) < 0) {
Dmai_err0("default params failed error.\n");
return Dmai_EFAIL;
}
switch (BufferGfx_getColorSpace(hSrcBuf)) {
case ColorSpace_YUV422PSEMI:
params.vdce_mode_params.rsz_params.rsz_mode = VDCE_MODE_422;
/* Speed up the conversion, note that this value hangs the resizer
* for 420P color format
*/
params.common_params.prcs_unit_value = 256;
break;
case ColorSpace_YUV420PSEMI:
params.vdce_mode_params.rsz_params.rsz_mode = VDCE_MODE_420;
break;
default:
Dmai_err0("Colorspace format not supported\n");
return Dmai_ENOTIMPL;
}
params.common_params.src_hsz_luminance = width;
params.common_params.src_vsz_luminance = height;
params.common_params.dst_hsz_luminance = width;
params.common_params.dst_vsz_luminance = height;
params.common_params.src_processing_mode = VDCE_PROGRESSIVE;
params.common_params.src_mode = VDCE_FRAME_MODE;
params.common_params.res_mode = VDCE_FRAME_MODE;
/* call ioctl to set parameters */
if (ioctl(hFc->fd, VDCE_SET_PARAMS, ¶ms) < 0) {
Dmai_err0("VDCE_SET_PARAMS failed \n");
return Dmai_EFAIL;
}
return Dmai_EOK;
}
/******************************************************************************
* Sdec_create
******************************************************************************/
Sdec_Handle Sdec_create(Engine_Handle hEngine, Char *codecName,
SPHDEC_Params *params, SPHDEC_DynamicParams *dynParams)
{
Sdec_Handle hSd;
SPHDEC_Handle hDecode;
SPHDEC_Status decStatus;
XDAS_Int32 status;
if (hEngine == NULL || codecName == NULL ||
params == NULL || dynParams == NULL) {
Dmai_err0("Cannot pass null for engine, codec name, params or "
"dynamic params\n");
return NULL;
}
/* Allocate space for the object */
hSd = (Sdec_Handle)calloc(1, sizeof(Sdec_Object));
if (hSd == NULL) {
Dmai_err0("Failed to allocate space for Sdec Object\n");
return NULL;
}
/* Create speech decoder */
hDecode = SPHDEC_create(hEngine, codecName, params);
if (hDecode == NULL) {
Dmai_err0("Failed to create speech decoder\n");
cleanup(hSd);
return NULL;
}
Dmai_dbg1("Speech decoder instance of %s created\n", codecName);
/* Set dynamic parameters */
decStatus.size = sizeof(SPHDEC_Status);
status = SPHDEC_control(hDecode, XDM_SETPARAMS, dynParams, &decStatus);
if (status != SPHDEC_EOK) {
Dmai_err1("XDM_SETPARAMS failed, status=%d\n", status);
SPHDEC_delete(hDecode);
cleanup(hSd);
return NULL;
}
/* Get buffer information from video decoder */
status = SPHDEC_control(hDecode, XDM_GETBUFINFO, dynParams,
&decStatus);
if (status != SPHDEC_EOK) {
Dmai_err0("XDM_GETBUFINFO control failed\n");
SPHDEC_delete(hDecode);
cleanup(hSd);
return NULL;
}
Dmai_dbg2("Speech decoder requires buffer sizes in %u and out %u\n",
(Uns) decStatus.bufInfo.minInBufSize[0],
(Uns) decStatus.bufInfo.minInBufSize[1]);
memcpy(hSd->minInBufSize,
decStatus.bufInfo.minInBufSize, sizeof(hSd->minInBufSize));
hSd->minNumInBufs = decStatus.bufInfo.minNumInBufs;
memcpy(hSd->minOutBufSize,
decStatus.bufInfo.minOutBufSize, sizeof(hSd->minOutBufSize));
hSd->minNumOutBufs = decStatus.bufInfo.minNumOutBufs;
hSd->hDecode = hDecode;
return hSd;
}
/******************************************************************************
* Capture_detectVideoStd
******************************************************************************/
Int Capture_detectVideoStd(Capture_Handle hCapture, VideoStd_Type *videoStdPtr,
Capture_Attrs *attrs)
{
v4l2_std_id id;
struct v4l2_input input;
Int index;
Int fd;
struct v4l2_standard std;
assert(videoStdPtr);
assert(attrs);
if (attrs->videoStd < 0 || attrs->videoStd > VideoStd_COUNT) {
Dmai_err1("Invalid capture standard given (%d)\n", attrs->videoStd);
return Dmai_EINVAL;
}
if (hCapture) {
fd = hCapture->fd;
}
else {
fd = open(attrs->captureDevice, O_RDWR, 0);
if (fd == -1) {
Dmai_err2("Cannot open %s (%s)\n", attrs->captureDevice,
strerror(errno));
return Dmai_EFAIL;
}
}
/* Get any active input */
if (ioctl(fd, VIDIOC_G_INPUT, &index) < 0) {
Dmai_err0("VIDIOC_G_INPUT");
return Dmai_EFAIL;
}
/* Display available video input */
Dmai_dbg0("Available video input:\n");
for (index=0;; index++) {
input.index = index;
if (ioctl(fd, VIDIOC_ENUMINPUT, &input) < 0) {
if (errno == EINVAL || errno == ENOTTY)
break;
}
Dmai_dbg1(" name=%s\n", input.name);
}
/* Set video input */
switch (attrs->videoInput) {
case Capture_Input_SVIDEO:
Dmai_dbg0("Setting video input to SVIDEO\n");
index = 1;
break;
case Capture_Input_COMPOSITE:
Dmai_dbg0("Setting video input to COMPOSITE\n");
index = 0;
break;
default:
Dmai_err0("Unknown video input\n");
return Dmai_EFAIL;
break;
}
if (ioctl(fd, VIDIOC_S_INPUT, &index) < 0) {
Dmai_err2("Failed VIDIOC_S_INPUT to index %d (%s)\n",
index, strerror(errno));
return Dmai_EFAIL;
}
/* Display available video standards */
Dmai_dbg0("Available video standard:\n");
for (index=0;; index++) {
std.frameperiod.numerator = 1;
std.frameperiod.denominator = 0;
std.index = index;
if (ioctl(fd, VIDIOC_ENUMSTD, &std) < 0) {
if (errno == EINVAL || errno == ENOTTY)
break;
}
Dmai_dbg3(" name=%s, fps=%d/%d\n", std.name,
std.frameperiod.denominator, std.frameperiod.numerator);
}
/* Detect the standard in the input detected */
if (ioctl(fd, VIDIOC_QUERYSTD, &id) < 0) {
Dmai_err0("VIDIOC_QUERYSTD");
return Dmai_EFAIL;
}
/* Get current video standard */
if (ioctl(fd, VIDIOC_G_STD, &id) < 0) {
Dmai_err0("Failed VIDIOC_G_STD\n");
return Dmai_EFAIL;
}
if (!hCapture) {
close(fd);
}
if (id & V4L2_STD_NTSC) {
*videoStdPtr = VideoStd_D1_NTSC;
Dmai_dbg0("Found NTSC std input\n");
}
else if (id & V4L2_STD_PAL) {
*videoStdPtr = VideoStd_D1_PAL;
Dmai_dbg0("Found PAL std input\n");
}
else if (id & V4L2_STD_525_60) {
*videoStdPtr = VideoStd_480P;
Dmai_dbg0("Found 525_60 std input\n");
}
else if (id & V4L2_STD_625_50) {
*videoStdPtr = VideoStd_576P;
Dmai_dbg0("Found 625_50 std input\n");
}
else {
Dmai_err1("Unknown video standard on capture device %s\n",
attrs->captureDevice);
return Dmai_EFAIL;
}
attrs->videoStd = *videoStdPtr;
Dmai_dbg2("Capture input set to %s. Standard: %d\n",
captureInputString[attrs->videoInput], *videoStdPtr);
return Dmai_EOK;
}
/******************************************************************************
* Framecopy_resizer_accel_config
******************************************************************************/
Int Framecopy_resizer_accel_config(Framecopy_Handle hFc,
Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf)
{
#if defined(CONFIG_VIDEO_OMAP34XX_ISP_RESIZER)
struct v4l2_requestbuffers reqbuf;
Int rszRate;
BufferGfx_Dimensions srcDim, dstDim;
struct rsz_params params = {
0, /* in_hsize (set at run time) */
0, /* in_vsize (set at run time) */
0, /* in_pitch (set at run time) */
RSZ_INTYPE_YCBCR422_16BIT, /* inptyp */
0, /* vert_starting_pixel */
0, /* horz_starting_pixel */
0, /* cbilin */
RSZ_PIX_FMT_UYVY, /* pix_fmt */
0, /* out_hsize (set at run time) */
0, /* out_vsize (set at run time) */
0, /* out_pitch (set at run time) */
0, /* hstph */
0, /* vstph */
{ /* hfilt_coeffs */
256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0,
256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0
},
{ /* vfilt_coeffs */
256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0,
256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0
},
{ /* yenh_params */
0, /* type */
0, /* gain */
0, /* slop */
0 /* core */
}
};
/* Pointers must be a multiple of 4096 bytes */
assert((Buffer_getPhysicalPtr(hDstBuf) & 0xFFF) == 0);
assert((Buffer_getPhysicalPtr(hSrcBuf) & 0xFFF) == 0);
BufferGfx_getDimensions(hSrcBuf, &srcDim);
BufferGfx_getDimensions(hDstBuf, &dstDim);
Dmai_dbg2("Configuring resizer to copy image of resolution %dx%d\n",
srcDim.width, srcDim.height);
/* Source and destination pitch must be 32 bytes aligned */
if (srcDim.lineLength % 32 || dstDim.lineLength % 32) {
Dmai_err2("Src (%ld) and dst (%ld) must be aligned on 32 bytes\n",
srcDim.lineLength, dstDim.lineLength);
return Dmai_EINVAL;
}
/* Set up the copy job */
params.in_hsize = srcDim.width;
params.in_vsize = srcDim.height;
params.in_pitch = srcDim.lineLength;
params.out_hsize = dstDim.width;
params.out_vsize = dstDim.height;
params.out_pitch = dstDim.lineLength;
params.cbilin = 0;
params.pix_fmt = RSZ_PIX_FMT_UYVY;
params.vert_starting_pixel = 0;
params.horz_starting_pixel = 0;
params.inptyp = RSZ_INTYPE_YCBCR422_16BIT;
params.hstph = 0;
params.vstph = 0;
params.yenh_params.type = 0;
params.yenh_params.gain = 0;
params.yenh_params.slop = 0;
params.yenh_params.core = 0;
hFc->inSize = srcDim.lineLength * params.in_vsize;
hFc->outSize = dstDim.lineLength * params.out_vsize;
if (ioctl(hFc->fd, RSZ_S_PARAM, ¶ms) == -1) {
Dmai_err0("Framecopy setting parameters failed.\n");
return Dmai_EFAIL;
}
rszRate = 0x0;
if (ioctl(hFc->fd, RSZ_S_EXP, &rszRate) == -1) {
Dmai_err0("Framecopy setting read cycle failed.\n");
return Dmai_EFAIL;
}
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_USERPTR;
reqbuf.count = 2;
if (ioctl(hFc->fd, RSZ_REQBUF, &reqbuf) == -1) {
Dmai_err0("Request buffer failed.\n");
return Dmai_EFAIL;
}
return Dmai_EOK;
#else
Dmai_err0("not implemented\n");
return Dmai_ENOTIMPL;
#endif /* end CONFIG_VIDEO_OMAP34XX_ISP_RESIZER */
}
