/******************************************************************************
* Dmai_setLogLevel
******************************************************************************/
Int Dmai_setLogLevel(Dmai_LogLevel logLevel)
{
/* Set the log level if global variable is not set */
if (Dmai_debugLogLevel == Dmai_LogLevel_Notset) {
switch (logLevel) {
case 0:
GT_set("ti.sdo.dmai=");
break;
case 1:
GT_set("ti.sdo.dmai=67");
break;
case 2:
GT_set("ti.sdo.dmai=01234567");
break;
default:
/* Invalid level. */
return Dmai_EINVAL;
}
Dmai_dbg1("Log level set to %d.\n", logLevel);
}
else {
Dmai_dbg0("Using log level set by DMAI_DEBUG.\n");
}
return Dmai_EOK;
}
/******************************************************************************
* Dmai_init
******************************************************************************/
Void Dmai_init()
{
if (ti_sdo_dmai_GTMask.modName == NULL) {
GT_init();
Global_init();
Memory_init();
Sem_init();
GT_create(&ti_sdo_dmai_GTMask, Dmai_gtname);
if (Dmai_debugLogLevel != Dmai_LogLevel_Notset) {
switch (Dmai_debugLogLevel) {
case 0:
GT_set("ti.sdo.dmai=");
break;
case 1:
GT_set("ti.sdo.dmai=67");
break;
case 2:
GT_set("ti.sdo.dmai=01234567");
break;
default:
/* Invalid parameter. Do nothing. */
break;
}
Dmai_dbg1("Dmai log level set to %d.\n", Dmai_debugLogLevel);
}
}
return;
}
/******************************************************************************
* validateKey
******************************************************************************/
static Int validateKey(Int val)
{
if (val != Ir_Key_POWER && val != Ir_Key_CHANINC &&
val != Ir_Key_CHANDEC && val != Ir_Key_VOLINC &&
val != Ir_Key_VOLDEC && val != Ir_Key_OK &&
val != Ir_Key_MUTE && val != Ir_Key_MENUDONE &&
val != Ir_Key_INFOSELECT && val != Ir_Key_SLEEP &&
val != Ir_Key_SUBTITLE && val != Ir_Key_REPEAT &&
val != Ir_Key_1 && val != Ir_Key_2 &&
val != Ir_Key_3 && val != Ir_Key_4 &&
val != Ir_Key_5 && val != Ir_Key_6 &&
val != Ir_Key_7 && val != Ir_Key_8 &&
val != Ir_Key_9 && val != Ir_Key_0 &&
val != Ir_Key_ENTER && val != Ir_Key_INPUT &&
val != Ir_Key_REWIND && val != Ir_Key_PLAY &&
val != Ir_Key_FASTFORWARD && val != Ir_Key_RECORD &&
val != Ir_Key_UP && val != Ir_Key_DOWN &&
val != Ir_Key_LEFT && val != Ir_Key_RIGHT &&
val != Ir_Key_STOP && val != Ir_Key_PAUSE) {
Dmai_dbg1("Ir key %d not valid\n", val);
return 0;
}
return 1;
}
/******************************************************************************
* Idec1_process
******************************************************************************/
Int Idec1_process(Idec1_Handle hId, Buffer_Handle hInBuf,
Buffer_Handle hOutBuf)
{
BufferGfx_Dimensions dim;
IMGDEC1_DynamicParams dynParams;
IMGDEC1_InArgs inArgs;
IMGDEC1_OutArgs outArgs;
IMGDEC1_Status decStatus;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc outBufDesc;
XDAS_Int32 status;
XDAS_Int8 * inPtr;
XDAS_Int8 * outPtr;
UInt32 offset = 0;
UInt32 i;
assert(hId);
assert(hInBuf);
assert(hOutBuf);
assert(Buffer_getSize(hInBuf));
assert(Buffer_getUserPtr(hInBuf));
assert(Buffer_getUserPtr(hOutBuf));
assert(Buffer_getNumBytesUsed(hInBuf));
assert(Buffer_getSize(hOutBuf));
assert(Buffer_getType(hOutBuf) == Buffer_Type_GRAPHICS);
BufferGfx_getDimensions(hOutBuf, &dim);
inPtr = Buffer_getUserPtr(hInBuf);
outPtr = Buffer_getUserPtr(hOutBuf);
inArgs.size = sizeof(IMGDEC1_InArgs);
inArgs.numBytes = Buffer_getNumBytesUsed(hInBuf);
outArgs.size = sizeof(IMGDEC1_OutArgs);
inBufDesc.numBufs = 1;
outBufDesc.numBufs = hId->minNumOutBufs;
inBufDesc.descs[0].buf = inPtr;
inBufDesc.descs[0].bufSize = Buffer_getSize(hInBuf);
for(i = 0; i < hId->minNumOutBufs; i++)
{
outBufDesc.descs[i].buf = (XDAS_Int8 *)((unsigned int)outPtr + offset);
offset += hId->minOutBufSize[i];
outBufDesc.descs[i].bufSize = hId->minOutBufSize[i];
}
/* Decode image buffer */
status = IMGDEC1_process(hId->hDecode, &inBufDesc, &outBufDesc, &inArgs,
&outArgs);
Buffer_setNumBytesUsed(hInBuf, outArgs.bytesConsumed);
if (status != IMGDEC1_EOK) {
if (XDM_ISFATALERROR(outArgs.extendedError)) {
Dmai_err2("IMGDEC1_process() failed with error (%d ext: 0x%x)\n",
(Int)status, (Uns) outArgs.extendedError);
return Dmai_EFAIL;
}
else {
Dmai_dbg1("IMGDEC1_process() non-fatal error 0x%x\n",
(Uns) outArgs.extendedError);
return Dmai_EBITERROR;
}
}
/* Get the dynamic codec status */
decStatus.data.buf = NULL;
decStatus.size = sizeof(IMGDEC1_Status);
dynParams.size = sizeof(IMGDEC1_DynamicParams);
status = IMGDEC1_control(hId->hDecode, XDM_GETSTATUS, &dynParams,
&decStatus);
if (status != IMGDEC1_EOK) {
Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status);
return Dmai_EFAIL;
}
/* Set output Color Format */
switch (decStatus.outputChromaFormat) {
case XDM_YUV_422ILE:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_UYVY);
break;
case XDM_YUV_420P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV420P);
break;
case XDM_YUV_422P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV422P);
break;
case XDM_YUV_444P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV444P);
break;
case XDM_GRAY:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_GRAY);
break;
default:
printf("Unsupported output color space.\n");
return Dmai_EFAIL;
}
dim.x = dim.y = 0;
dim.width = decStatus.outputWidth;
dim.height = decStatus.outputHeight;
dim.lineLength = decStatus.outputWidth *
ColorSpace_getBpp(BufferGfx_getColorSpace(hOutBuf)) / 8;
if (BufferGfx_setDimensions(hOutBuf, &dim) < 0) {
Dmai_err0("Frame does not fit in allocated buffer\n");
return Dmai_EFAIL;
}
return Dmai_EOK;
}
/******************************************************************************
* Idec1_create
******************************************************************************/
Idec1_Handle Idec1_create(Engine_Handle hEngine, Char *codecName,
IMGDEC1_Params *params,
IMGDEC1_DynamicParams *dynParams)
{
Idec1_Handle hId;
IMGDEC1_Handle hDecode;
IMGDEC1_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 */
hId = (Idec1_Handle)calloc(1, sizeof(Idec1_Object));
if (hId == NULL) {
Dmai_err0("Failed to allocate space for Idec1 Object\n");
return NULL;
}
/* Create image decoder instance */
hDecode = IMGDEC1_create(hEngine, codecName, params);
if (hDecode == NULL) {
Dmai_err0("Failed to open image decode algorithm\n");
free(hId);
return NULL;
}
Dmai_dbg0("Image decoder instance created\n");
/* Set image decoder dynamic params */
decStatus.data.buf = NULL;
decStatus.size = sizeof(IMGDEC1_Status);
status = IMGDEC1_control(hDecode, XDM_SETPARAMS, dynParams,
&decStatus);
if (status != IMGDEC1_EOK) {
Dmai_err0("XDM_SETPARAMS control failed\n");
IMGDEC1_delete(hDecode);
free(hId);
return NULL;
}
/* Get buffer information from image decoder */
status = IMGDEC1_control(hDecode, XDM_GETBUFINFO, dynParams,
&decStatus);
if (status != IMGDEC1_EOK) {
Dmai_err0("XDM_GETBUFINFO control failed\n");
IMGDEC1_delete(hDecode);
free(hId);
return NULL;
}
Dmai_dbg1("Buffer size %u obtained from XDM_GETBUFINFO control call\n",
(UInt) decStatus.bufInfo.minInBufSize[0]);
hId->hDecode = hDecode;
memcpy(hId->minInBufSize,
decStatus.bufInfo.minInBufSize, sizeof(hId->minInBufSize));
hId->minNumInBufs = decStatus.bufInfo.minNumInBufs;
memcpy(hId->minOutBufSize,
decStatus.bufInfo.minOutBufSize, sizeof(hId->minOutBufSize));
hId->minNumOutBufs = decStatus.bufInfo.minNumOutBufs;
return hId;
}
/******************************************************************************
* 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;
}
/******************************************************************************
* Initialize & configure previewer in on-the-fly (continous) mode
******************************************************************************/
Int Previewer_continuous_config(Bool setRgbColorPallet)
{
#ifdef CONFIG_DM365_IPIPE
Int preview_fd;
unsigned int oper_mode, user_mode;
struct prev_channel_config prev_chan_config;
struct prev_continuous_config prev_cont_config;
struct prev_cap cap;
struct prev_module_param mod_param;
user_mode = IMP_MODE_CONTINUOUS;
preview_fd = open((const char *)PREVIEWER_DEVICE, O_RDWR);
if(preview_fd <= 0) {
Dmai_err0("Cannot open previewer device \n");
return NULL;
}
if (ioctl(preview_fd,PREV_S_OPER_MODE, &user_mode) < 0) {
Dmai_err1("Can't set operation mode in previewer (%s)\n", strerror(errno));
close(preview_fd);
return Dmai_EFAIL;
}
if (ioctl(preview_fd,PREV_G_OPER_MODE, &oper_mode) < 0) {
Dmai_err1("Can't get operation mode from previewer (%s)\n", strerror(errno));
close(preview_fd);
return Dmai_EFAIL;
}
if (oper_mode == user_mode) {
Dmai_dbg0("Operating mode changed successfully to continuous in previewer\n");
} else {
Dmai_err0("failed to set mode to continuous in previewer\n");
close(preview_fd);
return Dmai_EFAIL;
}
prev_chan_config.oper_mode = oper_mode;
prev_chan_config.len = 0;
prev_chan_config.config = NULL; /* to set defaults in driver */
if (ioctl(preview_fd, PREV_S_CONFIG, &prev_chan_config) < 0) {
Dmai_err1("Error in setting default previewer configuration (%s)\n",
strerror(errno));
close(preview_fd);
return Dmai_EFAIL;
}
if (setRgbColorPallet) {
Dmai_dbg0("Setting RGB color pallet\n");
prev_chan_config.oper_mode = oper_mode;
prev_chan_config.len = sizeof(struct prev_continuous_config);
prev_chan_config.config = &prev_cont_config; /* to set defaults in driver */
if (ioctl(preview_fd, PREV_G_CONFIG, &prev_chan_config) < 0) {
Dmai_err1("Error in setting default previewer configuration (%s)\n",
strerror(errno));
close(preview_fd);
return Dmai_EFAIL;
}
prev_chan_config.oper_mode = oper_mode;
prev_chan_config.len = sizeof(struct prev_continuous_config);
prev_chan_config.config = &prev_cont_config; /* to set defaults in driver */
prev_cont_config.input.colp_elep= IPIPE_BLUE;
prev_cont_config.input.colp_elop= IPIPE_GREEN_BLUE;
prev_cont_config.input.colp_olep= IPIPE_GREEN_RED;
prev_cont_config.input.colp_olop= IPIPE_RED;
if (ioctl(preview_fd, PREV_S_CONFIG, &prev_chan_config) < 0) {
Dmai_err1("Error in setting default previewer configuration (%s)\n",
strerror(errno));
close(preview_fd);
return Dmai_EFAIL;
}
cap.index=0;
while (1) {
if (ioctl(preview_fd , PREV_ENUM_CAP, &cap) < 0) {
break;
}
strcpy(mod_param.version,cap.version);
mod_param.module_id = cap.module_id;
// using defaults
Dmai_dbg1("Setting default for %s\n", cap.module_name);
mod_param.param = NULL;
if (ioctl(preview_fd, PREV_S_PARAM, &mod_param) < 0) {
Dmai_err1("Error in Setting %s params from driver\n", cap.module_name);
close(preview_fd);
return Dmai_EFAIL;
}
cap.index++;
}
}
Dmai_dbg0("Previewer initialized\n");
return preview_fd;
#else
Dmai_err0("not implemented\n");
return Dmai_ENOTIMPL;
#endif
}
/******************************************************************************
* Sdec_process
******************************************************************************/
Int Sdec_process(Sdec_Handle hSd, Buffer_Handle hInBuf, Buffer_Handle hOutBuf)
{
SPHDEC_DynamicParams dynamicParams;
SPHDEC_Status decStatus;
XDM_BufDesc inBufDesc;
XDM_BufDesc outBufDesc;
XDAS_Int32 inBufSizeArray[1];
XDAS_Int32 outBufSizeArray[1];
XDAS_Int32 status;
SPHDEC_InArgs inArgs;
SPHDEC_OutArgs outArgs;
XDAS_Int8 *inPtr;
XDAS_Int8 *outPtr;
assert(hSd);
assert(hInBuf);
assert(hOutBuf);
assert(Buffer_getUserPtr(hInBuf));
assert(Buffer_getUserPtr(hOutBuf));
assert(Buffer_getNumBytesUsed(hInBuf));
assert(Buffer_getSize(hOutBuf));
inPtr = Buffer_getUserPtr(hInBuf);
outPtr = Buffer_getUserPtr(hOutBuf);
inBufSizeArray[0] = Buffer_getNumBytesUsed(hInBuf);
outBufSizeArray[0] = Buffer_getSize(hOutBuf);
inBufDesc.bufSizes = inBufSizeArray;
inBufDesc.bufs = &inPtr;
inBufDesc.numBufs = 1;
outBufDesc.bufSizes = outBufSizeArray;
outBufDesc.bufs = &outPtr;
outBufDesc.numBufs = 1;
inArgs.size = sizeof(SPHDEC_InArgs);
inArgs.inBufferSize = Buffer_getNumBytesUsed(hInBuf);
outArgs.size = sizeof(SPHDEC_OutArgs);
/* Decode the speech buffer */
status = SPHDEC_process(hSd->hDecode, &inBufDesc, &outBufDesc, &inArgs,
&outArgs);
if (status != SPHDEC_EOK) {
decStatus.size = sizeof(SPHDEC_Status);
dynamicParams.size = sizeof(SPHDEC_DynamicParams);
status = SPHDEC_control(hSd->hDecode, XDM_GETSTATUS, &dynamicParams,
&decStatus);
if (status != SPHDEC_EOK) {
Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status);
return Dmai_EFAIL;
}
if (status == SPHDEC_ERUNTIME ||
XDM_ISFATALERROR(decStatus.extendedError)) {
Dmai_err2("SPHDEC_process() failed with error (%d ext: 0x%x)\n",
(Int)status, (Uns) decStatus.extendedError);
return Dmai_EFAIL;
}
else {
Dmai_dbg1("SPHDEC_process() non-fatal error 0x%x\n",
(Uns) decStatus.extendedError);
return Dmai_EBITERROR;
}
}
/* A fixed x2 decompression ratio, only works for g711 */
Buffer_setNumBytesUsed(hOutBuf, Buffer_getNumBytesUsed(hInBuf) * 2);
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;
}
