static gboolean
probe_codec_server_encoders (GstPlugin *TICodecPlugin)
{
GstTIDmaiencData *encoder;
gint numalgo;
gint xdm_ver;
Engine_AlgInfo algoname;
enum dmai_codec_type mediaType;
/* Get the algorithms from Codec Engine */
algoname.algInfoSize = sizeof(Engine_AlgInfo);
Engine_getNumAlgs (ENCODEENGINE, &numalgo);
while (numalgo != 0) {
numalgo--;
/* Get the algo info */
Engine_getAlgInfo (ENCODEENGINE, &algoname, numalgo);
if (g_strstr_len (*algoname.typeTab, 100, "ENC1")) {
xdm_ver = 1;
} else if (g_strstr_len (*algoname.typeTab, 100, "ENC")) {
xdm_ver = 0;
} else {
/* Nothing we handle, maybe an decoder */
continue;
}
encoder = g_malloc0 (sizeof (GstTIDmaiencData));
encoder->codecName = algoname.name;
encoder->engineName = ENCODEENGINE;
if (!strcmp (encoder->codecName, "mpeg4enc")) {
mediaType = VIDEO;
encoder->streamtype = "mpeg4";
encoder->srcCaps = &gstti_mpeg4_src_caps;
encoder->stream_ops = &gstti_mpeg4_stream_enc_ops;
} else if (!strcmp (encoder->codecName, "h264enc")){
mediaType = VIDEO;
encoder->streamtype = "h264";
encoder->srcCaps = &gstti_h264_caps;
encoder->stream_ops = &gstti_h264_stream_enc_ops;
} else if (!strcmp (encoder->codecName, "mpeg2enc")) {
mediaType = VIDEO;
encoder->streamtype = "mpeg2";
encoder->srcCaps = &gstti_mpeg2_caps;
} else if (!strcmp (encoder->codecName, "aacheenc") ||
!strcmp (encoder->codecName, "aaclcenc")) {
mediaType = AUDIO;
encoder->streamtype = "aac";
encoder->srcCaps = &gstti_aac_src_caps;
encoder->stream_ops = &gstti_aac_stream_enc_ops;
} else if (!strcmp (encoder->codecName, "mp3enc")) {
mediaType = AUDIO;
encoder->streamtype = "mp3";
encoder->srcCaps = &gstti_mp3_src_caps;
} else if (!strcmp (encoder->codecName, "wmaenc")) {
mediaType = AUDIO;
encoder->streamtype = "wma";
encoder->srcCaps = &gstti_wma_caps;
#if 0
} else if (!strcmp (encoder->codecName, "g711enc")) {
mediaType = AUDIO;
encoder->streamtype = "g711";
encoder->srcCaps = &gstti_g711_caps;
continue;
#endif
} else if (!strcmp (encoder->codecName, "jpegenc")) {
GstTIDmaiencData *vencoder;
mediaType = IMAGE;
encoder->streamtype = "jpeg";
encoder->srcCaps = &gstti_jpeg_caps;
/* Install mjpeg video encoder */
vencoder = g_malloc0 (sizeof (GstTIDmaiencData));
vencoder->codecName = algoname.name;
vencoder->engineName = ENCODEENGINE;
vencoder->streamtype = "mjpeg";
vencoder->srcCaps = &gstti_jpeg_caps;
#if PLATFORM == dm365
vencoder->sinkCaps = &gstti_uyvy_nv12_caps;
#else
vencoder->sinkCaps = &gstti_uyvy_caps;
#endif
switch (xdm_ver) {
case 0:
vencoder->eops = &gstti_imgenc_ops;
break;
case 1:
vencoder->eops = &gstti_imgenc1_ops;
}
/* Now register the element */
if (!register_dmai_encoder(TICodecPlugin,vencoder)){
g_warning("Failed to register one encoder, aborting");
return FALSE;
}
} else {
GST_WARNING ("Element not provided for codec: %s",
encoder->codecName);
g_free(encoder);
continue;
}
/* Fill based on the xdm version */
switch (mediaType){
case VIDEO:
#if PLATFORM == dm365
encoder->sinkCaps = &gstti_uyvy_nv12_caps;
#else
encoder->sinkCaps = &gstti_uyvy_caps;
#endif
#if PLATFORM == dm365
if (!strcmp (encoder->codecName, "h264enc") || !strcmp (encoder->codecName, "mpeg4enc")) {
encoder->sinkCaps = &gstti_nv12_caps;
}
#endif
switch (xdm_ver) {
case 0:
encoder->eops = &gstti_videnc_ops;
break;
case 1:
encoder->eops = &gstti_videnc1_ops;
}
break;
case IMAGE:
#if PLATFORM == dm365
encoder->sinkCaps = &gstti_uyvy_nv12_caps;
#else
encoder->sinkCaps = &gstti_uyvy_caps;
#endif
switch (xdm_ver) {
case 0:
encoder->eops = &gstti_imgenc_ops;
break;
case 1:
encoder->eops = &gstti_imgenc1_ops;
}
break;
case AUDIO:
encoder->sinkCaps = &gstti_pcm_caps;
switch (xdm_ver) {
case 0:
encoder->eops = &gstti_audenc_ops;
break;
case 1:
encoder->eops = &gstti_audenc1_ops;
}
break;
default:
g_warning("Unkown media type for idx %d",mediaType);
break;
}
/* Now register the element */
if (!register_dmai_encoder(TICodecPlugin,encoder)){
g_warning("Failed to register one encoder, aborting");
return FALSE;
}
}
return TRUE;
}
/*
* ======== TraceUtil_start ========
*/
Int TraceUtil_start(String engineName)
{
String refreshPeriod;
Bool hasServer = FALSE;
Int i;
Int nAlgs;
Engine_AlgInfo algInfo;
Engine_Error status;
if (getenv( "CE_DEBUG" ) != NULL) {
printf( "TraceUtil_start> note: CE_DEBUG env. var is set, so TraceUtil "
"is not active (unset CE_DEBUG if you need TraceUtil)\n" );
return (TRACEUTIL_SUCCESS);
}
/*
* Determine whether or not this engine has a server. If not, do not
* start the trace thread.
*/
algInfo.algInfoSize = sizeof(Engine_AlgInfo);
status = Engine_getNumAlgs(engineName, &nAlgs);
if (status != Engine_EOK) {
ERR("TraceUtil_start((\"%s\"): Failed to get engine information\n",
engineName);
return (TRACEUTIL_FAILURE);
}
for (i = 0; i < nAlgs; i++) {
status = Engine_getAlgInfo(engineName, &algInfo, i);
if (status != Engine_EOK) {
ERR("TraceUtil_start((\"%s\"): Failed to get engine information\n",
engineName);
return (TRACEUTIL_FAILURE);
}
if (algInfo.isLocal == FALSE) {
hasServer = TRUE;
break;
}
}
if (!hasServer) {
WARN("TraceUtil_start(\"%s\"): not starting trace thread since "
"engine has no remote algs\n",
engineName);
/* TODO: Return success or failure in this case? */
return (TRACEUTIL_FAILURE);
}
/* Get the refresh period */
refreshPeriod = getenv("TRACEUTIL_REFRESHPERIOD");
if (refreshPeriod != NULL) {
refresh = atoi(refreshPeriod) * 1000;
}
else {
refresh = TraceUtil_refreshPeriod * 1000;
}
INFO("DSP Trace refresh period: %d ms\n", refresh / 1000);
/* create the collection thread if either the refresh period
* is non-0, or there is a pipe option
*/
if ((refresh != 0) ||
(cmdPipeFile != NULL && cmdPipeFile[0] != '\0') ) {
if (pthread_create(&traceThread, NULL, traceThrFxn,
(void *) engineName)) {
ERR("Failed to create log thread\n");
return (TRACEUTIL_FAILURE);
}
/* make sure this thread runs before we continue */
while (traceThreadCreated == FALSE) {
sched_yield();
if (threadCreateFailed == TRUE) {
ERR("Aborting TraceUtil_start\n");
return (TRACEUTIL_FAILURE);
}
}
}
return (TRACEUTIL_SUCCESS);
}
static gboolean
probe_codec_server_decoders (GstPlugin *TICodecPlugin)
{
GstTIDmaidecData *decoder = NULL;
gint numalgo;
gint xdm_ver;
Engine_AlgInfo algoname;
enum dmai_codec_type mediaType;
/* Get the algorithms from Codec Engine */
algoname.algInfoSize = sizeof(Engine_AlgInfo);
Engine_getNumAlgs (DECODEENGINE, &numalgo);
while (numalgo != 0) {
numalgo--;
/* Get the algo info */
Engine_getAlgInfo (DECODEENGINE, &algoname, numalgo);
if (g_strstr_len (*algoname.typeTab, 100, "DEC2")) {
xdm_ver = 2;
} else if (g_strstr_len (*algoname.typeTab, 100, "DEC1")) {
xdm_ver = 1;
} else if (g_strstr_len (*algoname.typeTab, 100, "DEC")) {
xdm_ver = 0;
} else {
/* Nothing we handle, maybe an encoder */
continue;
}
decoder = g_malloc0 (sizeof (GstTIDmaidecData));
decoder->codecName = algoname.name;
decoder->engineName = DECODEENGINE;
if (!strcmp (decoder->codecName, "mpeg4dec")) {
mediaType = VIDEO;
decoder->streamtype = "mpeg4";
decoder->sinkCaps = &gstti_mpeg4_sink_caps;
decoder->parser = &gstti_mpeg4_parser;
decoder->stream_ops = &gstti_mpeg4_stream_dec_ops;
} else if (!strcmp (decoder->codecName, "h264dec")) {
mediaType = VIDEO;
decoder->streamtype = "h264";
decoder->sinkCaps = &gstti_h264_caps;
decoder->parser = &gstti_h264_parser;
decoder->stream_ops = &gstti_h264_stream_dec_ops;
} else if (!strcmp (decoder->codecName, "mpeg2dec")) {
mediaType = VIDEO;
decoder->streamtype = "mpeg2";
decoder->sinkCaps = &gstti_mpeg2_caps;
decoder->parser = &gstti_mpeg2_parser;
} else if (!strcmp (decoder->codecName, "aachedec") ||
!strcmp (decoder->codecName, "aaclcdec")) {
mediaType = AUDIO;
decoder->streamtype = "aac";
decoder->sinkCaps = &gstti_aac_sink_caps;
decoder->parser = &gstti_aac_parser;
decoder->stream_ops = &gstti_aac_stream_dec_ops;
} else if (!strcmp (decoder->codecName, "mp3dec")) {
mediaType = AUDIO;
decoder->streamtype = "mp3";
decoder->sinkCaps = &gstti_mp3_sink_caps;
decoder->parser = &gstti_generic_parser;
} else if (!strcmp (decoder->codecName, "wmadec")) {
mediaType = AUDIO;
decoder->streamtype = "wma";
decoder->sinkCaps = &gstti_wma_caps;
decoder->parser = &gstti_generic_parser;
} else if (!strcmp (decoder->codecName, "jpegdec")) {
GstTIDmaidecData *vdecoder;
mediaType = IMAGE;
decoder->streamtype = "jpeg";
decoder->sinkCaps = &gstti_jpeg_caps;
decoder->parser = &gstti_jpeg_parser;
/* Install mjpeg video encoder */
vdecoder = g_malloc0 (sizeof (GstTIDmaidecData));
vdecoder->codecName = algoname.name;
vdecoder->engineName = DECODEENGINE;
vdecoder->streamtype = "mjpeg";
vdecoder->parser = &gstti_jpeg_parser;
vdecoder->sinkCaps = &gstti_jpeg_caps;
#if PLATFORM == dm365
vdecoder->srcCaps = &gstti_uyvy_nv12_caps;
#else
vdecoder->srcCaps = &gstti_uyvy_caps;
#endif
switch (xdm_ver) {
case 0:
vdecoder->dops = &gstti_imgdec_ops;
break;
case 1:
vdecoder->dops = &gstti_imgdec1_ops;
}
/* Now register the element */
if (!register_dmai_decoder(TICodecPlugin,vdecoder)){
g_warning("Failed to register one decoder, aborting");
return FALSE;
}
#if 0
} else if (!strcmp (decoder->codecName, "g711dec")) {
decoder->streamtype = "g711";
mediaType = AUDIO;
decoder->sinkCaps = &gstti_g711_caps;
decoder->parser = &gstti_generic_parser;
#endif
} else {
GST_WARNING ("Element not provided for codec: %s",
decoder->codecName);
g_free(decoder);
continue;
}
/* Fill based on the xdm version */
switch (mediaType){
case VIDEO:
#if PLATFORM == dm365
decoder->srcCaps = &gstti_uyvy_nv12_caps;
#else
decoder->srcCaps = &gstti_uyvy_caps;
#endif
switch (xdm_ver) {
case 0:
decoder->dops = &gstti_viddec_ops;
break;
case 2:
decoder->dops = &gstti_viddec2_ops;
}
break;
case AUDIO:
decoder->srcCaps = &gstti_pcm_caps;
switch (xdm_ver) {
case 0:
decoder->dops = &gstti_auddec_ops;
break;
case 1:
decoder->dops = &gstti_auddec1_ops;
}
break;
case IMAGE:
#if PLATFORM == dm365
decoder->srcCaps = &gstti_uyvy_nv12_caps;
#else
decoder->srcCaps = &gstti_uyvy_caps;
#endif
switch (xdm_ver) {
case 0:
decoder->dops = &gstti_imgdec_ops;
break;
case 1:
decoder->dops = &gstti_imgdec1_ops;
}
break;
default:
g_warning("Unkown media type for idx %d",mediaType);
break;
}
/* Now register the element */
if (!register_dmai_decoder(TICodecPlugin,decoder)){
g_warning("Failed to register one decoder, aborting");
return FALSE;
}
}
return TRUE;
}
