/*{{{ TransformerTerminate*/ static int TransformerTerminate(struct MMEContext_s *Context) { MME_ERROR MMEStatus; if (Context->TransformerInitialized) { Context->TransformerInitialized = false; MMEStatus = MME_TermTransformer(Context->MMEHandle); if (MMEStatus != MME_SUCCESS) { MONITOR_ERROR("%s: Failed to terminate mme transformer - Error 0x%08x.\n", Context->TransformerName, MMEStatus); return -EFAULT; } } return 0; }
/* MME_TermTransformer() * Terminate a transformer instance */ MME_ERROR acc_MME_TermTransformer(MME_TransformerHandle_t handle) { MME_ERROR mme_status; int hdl_idx = handles_search(handle); if (log_enable == ACC_TRUE) { FILE *fcmd = cmd_log_lock(); FWRITE(cmd_str[CMD_TERM], strlen(cmd_str[CMD_TERM]) + 1, 1, fcmd); FWRITE(&hdl_idx, sizeof(int), 1, fcmd); cmd_log_release(fcmd); } mme_status = MME_TermTransformer(handle); if (log_enable == ACC_TRUE) { if (mme_status == MME_SUCCESS) handles[hdl_idx] = 0; } return mme_status; }
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; }