MME_ERROR acc_MME_InitTransformer(const char *Name,
MME_TransformerInitParams_t * Params_p,
MME_TransformerHandle_t * Handle_p)
{
MME_ERROR mme_status;
FILE * fcmd = cmd_log_lock();
if (log_enable == ACC_TRUE)
{
FWRITE(cmd_str[CMD_INIT], strlen(cmd_str[CMD_INIT]) + 1, 1, fcmd);
FWRITE((char *)Name, strlen(Name) + 1, 1, fcmd);
FWRITE(Params_p, sizeof(MME_TransformerInitParams_t), 1, fcmd);
FWRITE(Params_p->TransformerInitParams_p, Params_p->TransformerInitParamsSize, 1, fcmd);
}
cmd_log_release(fcmd);
mme_status = MME_InitTransformer(Name, Params_p, Handle_p);
if (log_enable)
{
if (mme_status == MME_SUCCESS) handles[handles_new()] = (int) *Handle_p;
}
return mme_status;
}
/*{{{ TransformerInitialize*/
static int TransformerInitialize(struct MMEContext_s *Context)
{
EVENT_LOG_InitTransformerParam_t EventLogInitParams = {0};
MME_TransformerInitParams_t MMEInitParams = {0};
MME_ERROR MMEStatus;
int Status;
Status = VerifyCapabilities(Context);
if (Status != 0)
return Status;
EventLogInitParams.StructSize = sizeof(EVENT_LOG_InitTransformerParam_t);
EventLogInitParams.TimeCodeMemoryAddress = Context->ClockAddress;
MMEInitParams.Priority = MME_PRIORITY_LOWEST;
MMEInitParams.StructSize = sizeof(MME_TransformerInitParams_t);
MMEInitParams.Callback = &TransformerCallback;
MMEInitParams.CallbackUserData = Context;
MMEInitParams.TransformerInitParamsSize = sizeof(EVENT_LOG_InitTransformerParam_t);
MMEInitParams.TransformerInitParams_p = (MME_GenericParams_t)(&EventLogInitParams);
MMEStatus = MME_InitTransformer(Context->TransformerName, &MMEInitParams, &Context->MMEHandle);
if (MMEStatus != MME_SUCCESS)
{
MONITOR_ERROR("%s: Failed to initialize transformer - Error 0x%08x.\n", Context->TransformerName, MMEStatus);
return -EFAULT;
}
Context->TransformerInitialized = true;
return 0;
}
//}}}
//{{{ SendMMEStreamParameters
CodecStatus_t Codec_MmeVideoTheora_c::SendMMEStreamParameters (void)
{
CodecStatus_t CodecStatus = CodecNoError;
unsigned int MMEStatus = MME_SUCCESS;
CODEC_TRACE("%s\n", __FUNCTION__);
// There are no set stream parameters for Rmv decoder so the transformer is
// terminated and restarted when required (i.e. if width or height change).
if (RestartTransformer)
{
TerminateMMETransformer();
memset (&MMEInitializationParameters, 0x00, sizeof(MME_TransformerInitParams_t));
MMEInitializationParameters.Priority = MME_PRIORITY_NORMAL;
MMEInitializationParameters.StructSize = sizeof(MME_TransformerInitParams_t);
MMEInitializationParameters.Callback = &MMECallbackStub;
MMEInitializationParameters.CallbackUserData = this;
FillOutTransformerInitializationParameters ();
CODEC_TRACE("%s: Initilising Theora transformer %s\n",__FUNCTION__, Configuration.TransformName[SelectedTransformer]);
MMEStatus = MME_InitTransformer (Configuration.TransformName[SelectedTransformer],
&MMEInitializationParameters, &MMEHandle);
if (MMEStatus == MME_SUCCESS)
{
CodecStatus = CodecNoError;
RestartTransformer = false;
ParsedFrameParameters->NewStreamParameters = false;
MMEInitialized = true;
}
}
//
// The base class has very helpfully acquired a stream
// parameters context for us which we must release.
// But only if everything went well, otherwise the callers
// will helpfully release it as well (Nick).
//
if (CodecStatus == CodecNoError)
StreamParameterContextBuffer->DecrementReferenceCount ();
//
return CodecStatus;
}
//}}}
//{{{ FillOutSetStreamParametersCommand
////////////////////////////////////////////////////////////////////////////
///
/// Populate the AUDIO_DECODER's MME_SET_GLOBAL_TRANSFORMER_PARAMS parameters for PCM audio.
///
CodecStatus_t Codec_MmeAudioPcm_c::FillOutSetStreamParametersCommand( void )
{
CodecStatus_t Status;
PcmAudioCodecStreamParameterContext_t* Context = (PcmAudioCodecStreamParameterContext_t *)StreamParameterContext;
CODEC_TRACE("\n");
// Fill out the structure
#if 0
// There are no set stream parameters for Vp6 decoder so the transformer is
// terminated and restarted when required (i.e. if width or height change).
if (RestartTransformer)
{
TerminateMMETransformer();
memset (&MMEInitializationParameters, 0x00, sizeof(MME_TransformerInitParams_t));
MMEInitializationParameters.Priority = MME_PRIORITY_NORMAL;
MMEInitializationParameters.StructSize = sizeof(MME_TransformerInitParams_t);
MMEInitializationParameters.Callback = &MMECallbackStub;
MMEInitializationParameters.CallbackUserData = this;
FillOutTransformerInitializationParameters ();
MMEStatus = MME_InitTransformer (Configuration.TransformName[SelectedTransformer],
&MMEInitializationParameters, &MMEHandle);
if (MMEStatus == MME_SUCCESS)
{
CODEC_DEBUG ("New Stream Params %dx%d\n", DecodingWidth, DecodingHeight);
CodecStatus = CodecNoError;
RestartTransformer = eAccFalse;
ParsedFrameParameters->NewStreamParameters = false;
MMEInitialized = true;
}
}
#endif
memset (&(Context->StreamParameters), 0, sizeof(Context->StreamParameters));
Status = FillOutTransformerGlobalParameters (&(Context->StreamParameters));
if (Status != CodecNoError)
return Status;
// Fillout the actual command
Context->BaseContext.MMECommand.CmdStatus.AdditionalInfoSize = 0;
Context->BaseContext.MMECommand.CmdStatus.AdditionalInfo_p = NULL;
Context->BaseContext.MMECommand.ParamSize = sizeof(Context->StreamParameters);
Context->BaseContext.MMECommand.Param_p = (MME_GenericParams_t)(&Context->StreamParameters);
return CodecNoError;
}
/* TODO:
* Multiple companion CPU tests
*/
int main(void)
{
MME_TransformerInitParams_t initParams = {
sizeof(MME_TransformerInitParams_t),
MME_PRIORITY_NORMAL,
TransformerCallback,
USERDATA,
0,
NULL,
};
MME_TransformerHandle_t transformerHandle;
MME_TransformerHandle_t transformerHandle2;
MME_ERROR error;
/* bring up the API */
harness_boot();
MME(Init());
#ifndef USERMODE
assert(MME_DeregisterTransport(TRANSPORT_NAME)==MME_INVALID_ARGUMENT);
MME(RegisterTransport(TRANSPORT_NAME));
#endif
#if 0
/* Currently a bug in EMBX prevents a transport from being
closed and reopened
*/
printf("Calling MME_DeregisterTransport\n");
error = MME_DeregisterTransport(TRANSPORT_NAME);
printf("MME_DeregisterTransport err %d\n", error);
VERBOSE(printf(MACHINE "MME_InitTransformer(com.st.mcdt.mme.test)"));
/* this should fail - no transports yet */
error = MME_InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle);
assert(error == MME_UNKNOWN_TRANSFORMER);
MME(RegisterTransport(TRANSPORT_NAME));
#endif
/* this should fail - not a valid xformer */
error = MME_InitTransformer("com.st.mcdt.mme.testX", &initParams, &transformerHandle);
assert(error == MME_UNKNOWN_TRANSFORMER);
do {
VERBOSE(printf("Attempting MME_InitTransformer(com.st.mcdt.mme.test)\n"));
/* loop till registered on companion */
error = MME_InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle);
harness_sleep(1);
} while (error == MME_UNKNOWN_TRANSFORMER);
/* And again - two instantiations on the same CPU */
MME(InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle2));
/* tidy up */
MME(TermTransformer(transformerHandle));
error = MME_Term();
assert(error == MME_HANDLES_STILL_OPEN);
MME(TermTransformer(transformerHandle2));
MME(Term());
harness_shutdown();
return 0;
}
int main(void)
{
MME_TransformerInitParams_t initParams = { sizeof(MME_TransformerInitParams_t) };
MixerParamsInit_t mixerInit;
MME_TransformerHandle_t localHdl, remoteHdl;
MME_ERROR err;
/* initialize the underlying EMBX transport */
embxRuntimeInit();
/* initialize the MME API */
err = MME_Init();
if (MME_SUCCESS != err) {
printf("ERROR: cannot initialize the MME API (%d)\n", err);
}
/* other misc. initialization */
OS_SIGNAL_INIT(&callbackSignal);
/* pre-construct the data structure to be passed at transformer
* initialization time
*/
initParams.Priority = MME_PRIORITY_NORMAL;
initParams.Callback = mixerCallback;
initParams.TransformerInitParamsSize = sizeof(MixerParamsInit_t);
initParams.TransformerInitParams_p = &mixerInit;
MME_INDEXED_PARAM(mixerInit, MixerParamsInit_volume, 0) = 1.0;
MME_INDEXED_PARAM(mixerInit, MixerParamsInit_volume, 1) = 4.0/3.0;
/* display the waveforms that will be mixed */
printf("ORIGINAL WAVEFORMS\n"
"------------------\n\n");
printTwinSignal(sample1, sample2, sizeof(sample1));
printf("\nSIMPLE MIXING USING A LOCALLY REGISTERED TRANSFORMER\n"
"----------------------------------------------------\n\n");
/* register a local transformer */
err = Mixer_RegisterTransformer("local.8bit_mixer");
if (MME_SUCCESS != err) {
printf("ERROR: cannot register local.8bit_mixer (%d)\n", err);
}
/* initialize the local transformer */
err = MME_InitTransformer("local.8bit_mixer", &initParams, &localHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot instanciate local.8bit_mixer (%d)\n", err);
}
/* perform a simple mix using the local transformer */
err = simpleMix(localHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot perform mixer transformer on mme.8bit_mixer (%d)\n", err);
}
printf("\nSIMPLE MIXING USING A REMOTELY REGISTERED TRANSFORMER\n"
"-----------------------------------------------------\n\n");
#if !(defined(__LINUX__) && !defined(__KERNEL__))
/* register the transport for the remote transformer (at this point we will
* block until the remote processor initializes itself)
*/
err = MME_RegisterTransport("shm");
if (MME_SUCCESS != err) {
printf("ERROR: cannot register transport to external processors (%d)\n", err);
}
#endif
/* repeatly attempt to connect to the remote transformer until it is registered or
* a serious error occurs.
*/
do {
err = MME_InitTransformer("mme.8bit_mixer", &initParams, &remoteHdl);
} while (err == MME_UNKNOWN_TRANSFORMER);
if (MME_SUCCESS != err) {
printf("ERROR: cannot instanciate mme.8bit_mixer (%d)\n", err);
}
/* perform the same mix as above using a remotely registered transformer. the
* results should be identical assuming both processors implement IEEE single
* precision floating point maths.
*/
err = simpleMix(remoteHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot perform mixer transformer on mme.8bit_mixer (%d)\n", err);
}
/* clean up prior to shutting down */
err = MME_TermTransformer(remoteHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate mme.8bit_mixer (%d)\n", err);
}
err = MME_TermTransformer(localHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate local.8bit_mixer (%d)\n", err);
}
err = MME_Term();
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate the MME API (%d)\n", err);
}
#ifndef __LINUX__
(void) EMBX_Deinit();
#endif
return 0;
}
int main(void)
{
MME_TransformerInitParams_t initParams[2] = {{ sizeof(MME_TransformerInitParams_t) },
{ sizeof(MME_TransformerInitParams_t) }};
MixerParamsInit_t mixerInit[2];
MME_TransformerHandle_t remoteHdl[2];
MME_ERROR err;
/* initialize the underlying EMBX transport */
setupEMBXAndOS();
/* initialize the MME API */
err = MME_Init();
if (MME_SUCCESS != err) {
printf("ERROR: cannot initialize the MME API (%d)\n", err);
}
/* other misc. initialization */
OS_SIGNAL_INIT(&callbackSignal);
/* pre-construct the data structure to be passed at transformer
* initialization time
*/
initParams[0].Priority = MME_PRIORITY_NORMAL;
initParams[0].Callback = mixerCallback;
initParams[0].TransformerInitParamsSize = sizeof(MixerParamsInit_t);
initParams[0].TransformerInitParams_p = &mixerInit[0];
MME_INDEXED_PARAM(mixerInit[0], MixerParamsInit_volume, 0) = 1.0;
MME_INDEXED_PARAM(mixerInit[0], MixerParamsInit_volume, 1) = 4.0/3.0;
initParams[1].Priority = MME_PRIORITY_NORMAL;
initParams[1].Callback = mixerCallback;
initParams[1].TransformerInitParamsSize = sizeof(MixerParamsInit_t);
initParams[1].TransformerInitParams_p = &mixerInit[1];
MME_INDEXED_PARAM(mixerInit[1], MixerParamsInit_volume, 0) = 0.4;
MME_INDEXED_PARAM(mixerInit[1], MixerParamsInit_volume, 1) = 0.7;
#if !(defined(__LINUX__) && !defined(__KERNEL__))
/* register the transport for the remote transformer (at this point we will
* block until the remote processor initializes itself)
*/
printf("Trying to register transport shm\n");
err = MME_RegisterTransport("shm");
if (MME_SUCCESS != err) {
printf("ERROR: cannot register transport to external processors (%d)\n", err);
}
#endif
/* repeatly attempt to connect to the remote transformer until it is registered or
* a serious error occurs.
*/
do {
task_delay(time_ticks_per_sec() * 2);
printf("Trying to init mme.8bit_mix_1\n");
err = MME_InitTransformer("mme.8bit_mixer_1", &initParams[0], &remoteHdl[0]);
} while (err == MME_UNKNOWN_TRANSFORMER);
if (MME_SUCCESS != err) {
printf("ERROR: cannot instantiate mme.8bit_mixer_1 (%d)\n", err);
}
do {
task_delay(time_ticks_per_sec() * 2);
printf("Trying to init mme.8bit_mix_2\n");
err = MME_InitTransformer("mme.8bit_mixer_2", &initParams[1], &remoteHdl[1]);
} while (err == MME_UNKNOWN_TRANSFORMER);
if (MME_SUCCESS != err) {
printf("ERROR: cannot instantiate mme.8bit_mixer_2 (%d)\n", err);
}
/* display the waveforms that will be mixed */
printf("ORIGINAL WAVEFORMS\n"
"------------------\n\n");
printTwinSignal(sample1, sample2, sizeof(sample1));
printf("\nSIMPLE MIXING USING TWO REMOTELY REGISTERED TRANSFORMERS\n"
"--------------------------------------------------------\n\n");
/* perform the mix as above using remotely registered transformer. the
* results should be identical assuming both processors implement IEEE single
* precision floating point maths.
*/
err = simpleMix(remoteHdl);
if (MME_SUCCESS != err) {
printf("ERROR: cannot perform mixer transformer on mme.8bit_mixer (%d)\n", err);
}
/* clean up prior to shutting down */
err = MME_TermTransformer(remoteHdl[0]);
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate mme.8bit_mixer (%d)\n", err);
}
err = MME_TermTransformer(remoteHdl[1]);
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate mme.8bit_mixer (%d)\n", err);
}
err = MME_Term();
if (MME_SUCCESS != err) {
printf("ERROR: cannot terminate the MME API (%d)\n", err);
}
(void) EMBX_Deinit();
return 0;
}
