TEST(Gzip, gzencode_gzdecode) {
auto str = td::rand_string(0, 127, 1000);
encode_decode(str);
str = td::rand_string('a', 'z', 1000000);
encode_decode(str);
str = td::string(1000000, 'a');
encode_decode(str);
}
uint32_t sd_ble_gatts_service_add(adapter_t *adapter, uint8_t type, ble_uuid_t const *p_uuid, uint16_t *p_handle)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_service_add_req_enc(type, p_uuid, p_handle, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_service_add_rsp_dec(buffer, length, p_handle, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_attr_get(adapter_t *adapter, uint16_t handle, ble_uuid_t * p_uuid, ble_gatts_attr_md_t * p_md)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_attr_get_req_enc(handle, p_uuid, p_md, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_attr_get_rsp_dec(buffer, length, &p_uuid, &p_md, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_initial_user_handle_get(adapter_t *adapter, uint16_t *p_handle)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_initial_user_handle_get_req_enc(p_handle, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_initial_user_handle_get_rsp_dec(buffer, length, &p_handle, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_sys_attr_get(adapter_t *adapter, uint16_t conn_handle, uint8_t *p_sys_attr_data, uint16_t *p_len, uint32_t flags)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_sys_attr_get_req_enc(conn_handle, p_sys_attr_data, p_len, flags, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_sys_attr_get_rsp_dec(buffer, length, p_sys_attr_data, p_len, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_rw_authorize_reply(adapter_t *adapter, uint16_t conn_handle, ble_gatts_rw_authorize_reply_params_t const *p_rw_authorize_reply_params)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_rw_authorize_reply_req_enc(conn_handle, p_rw_authorize_reply_params, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_rw_authorize_reply_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_service_changed(adapter_t *adapter, uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_service_changed_req_enc(conn_handle, start_handle, end_handle, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_service_changed_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_include_add(adapter_t *adapter, uint16_t service_handle, uint16_t inc_srvc_handle, uint16_t *p_include_handle)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_include_add_req_enc(service_handle, inc_srvc_handle, p_include_handle, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_include_add_rsp_dec(buffer, length, p_include_handle, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_descriptor_add(adapter_t *adapter, uint16_t char_handle, ble_gatts_attr_t const *p_attr, uint16_t *p_handle)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_descriptor_add_req_enc(char_handle, p_attr, p_handle, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_descriptor_add_rsp_dec(buffer, length, p_handle, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_descriptors_discover(adapter_t *adapter, uint16_t conn_handle, ble_gattc_handle_range_t const *p_handle_range)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_descriptors_discover_req_enc(conn_handle, p_handle_range, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_descriptors_discover_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_hv_confirm(adapter_t *adapter, uint16_t conn_handle, uint16_t handle)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_hv_confirm_req_enc(conn_handle, handle, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_hv_confirm_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_primary_services_discover(adapter_t *adapter, uint16_t conn_handle, uint16_t start_handle, ble_uuid_t const *p_srvc_uuid)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_primary_services_discover_req_enc(conn_handle, start_handle, p_srvc_uuid, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_primary_services_discover_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_char_values_read(adapter_t *adapter, uint16_t conn_handle, uint16_t const *p_handles, uint16_t handle_count)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_char_values_read_req_enc(conn_handle, p_handles, handle_count, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_char_values_read_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_write(adapter_t *adapter, uint16_t conn_handle, ble_gattc_write_params_t const *p_write_params)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_write_req_enc(conn_handle, p_write_params, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_write_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_value_get(adapter_t *adapter, uint16_t conn_handle, uint16_t handle, ble_gatts_value_t *p_value)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_value_get_req_enc(conn_handle, handle, p_value, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
return ble_gatts_value_get_rsp_dec(buffer, length, p_value, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gattc_char_value_by_uuid_read(adapter_t *adapter, uint16_t conn_handle, ble_uuid_t const *p_uuid, ble_gattc_handle_range_t const *p_handle_range)
{
const encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gattc_char_value_by_uuid_read_req_enc(conn_handle, p_uuid, p_handle_range, buffer, length);
};
const decode_function_t decode_function = [&] (uint8_t *buffer, const uint32_t length, uint32_t *result) -> uint32_t {
return ble_gattc_char_value_by_uuid_read_rsp_dec(buffer, length, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
static uint32_t gap_encode_decode(adapter_t *adapter, const encode_function_t &encode_function,
const decode_function_t &decode_function)
{
const auto adapterLayer = static_cast<AdapterInternal *>(adapter->internal);
if (adapterLayer == nullptr)
{
return NRF_ERROR_INVALID_PARAM;
}
RequestReplyCodecContext context(adapterLayer->transport);
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_hvx(adapter_t *adapter, uint16_t conn_handle, ble_gatts_hvx_params_t const *p_hvx_params)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_hvx_req_enc(conn_handle, p_hvx_params, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
uint16_t *out_length = p_hvx_params->p_len;
return ble_gatts_hvx_rsp_dec(buffer, length, result, &out_length);
};
return encode_decode(adapter, encode_function, decode_function);
}
uint32_t sd_ble_gatts_characteristic_add(adapter_t *adapter, uint16_t service_handle, ble_gatts_char_md_t const *p_char_md, ble_gatts_attr_t const *p_attr_char_value, ble_gatts_char_handles_t *p_handles)
{
encode_function_t encode_function = [&] (uint8_t *buffer, uint32_t *length) -> uint32_t {
return ble_gatts_characteristic_add_req_enc(service_handle, p_char_md, p_attr_char_value, p_handles, buffer, length);
};
decode_function_t decode_function = [&] (uint8_t *buffer, uint32_t length, uint32_t *result) -> uint32_t {
uint16_t * handles = &p_handles->value_handle;
return ble_gatts_characteristic_add_rsp_dec(buffer, length, &handles, result);
};
return encode_decode(adapter, encode_function, decode_function);
}
/*
* ======== smain ========
*/
Int smain(Int argc, String argv[])
{
Engine_Handle ce = NULL;
SPHDEC1_Handle dec = NULL;
SPHENC1_Handle enc = NULL;
SPHDEC1_Params decParams;
SPHENC1_Params encParams;
FILE *in = NULL;
FILE *out = NULL;
String inFile, outFile;
if (argc <= 1) {
inFile = "../in.dat";
outFile = "../out.dat";
}
else if (argc == 3) {
progName = argv[0];
inFile = argv[1];
outFile = argv[2];
}
else {
fprintf(stderr, usage, argv[0]);
exit(1);
}
GT_0trace(curMask, GT_1CLASS, "App-> Application started.\n");
/* allocate input, encoded, and output buffers */
inBuf = (XDAS_Int8 *)Memory_contigAlloc(IFRAMESIZE, BUFALIGN);
encodedBuf = (XDAS_Int8 *)Memory_contigAlloc(EFRAMESIZE, BUFALIGN);
outBuf = (XDAS_Int8 *)Memory_contigAlloc(OFRAMESIZE, BUFALIGN);
versionBuf = (XDAS_Int8 *)Memory_contigAlloc(MAXVERSIONSIZE, BUFALIGN);
if ((inBuf == NULL) || (encodedBuf == NULL) || (outBuf == NULL) ||
(versionBuf == NULL)) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, NULL, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize decoder in the engine */
decParams.size = sizeof(decParams);
decParams.compandingLaw = ISPEECH1_PCM_COMPAND_ULAW;
/* no other create params are meaningful for PCM decoders */
dec = SPHDEC1_create(ce, decoderName, &decParams);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize encoder in the engine */
encParams.size = sizeof(encParams);
encParams.frameSize = IFRAMESIZE;
encParams.compandingLaw = ISPEECH1_PCM_COMPAND_ULAW;
/* no other create params are meaningful for PCM encoders */
enc = SPHENC1_create(ce, encoderName, &encParams);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
/* teardown the codecs */
if (enc) {
SPHENC1_delete(enc);
}
if (dec) {
SPHDEC1_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
if (inBuf) {
Memory_contigFree(inBuf, IFRAMESIZE);
}
if (encodedBuf) {
Memory_contigFree(encodedBuf, EFRAMESIZE);
}
if (outBuf) {
Memory_contigFree(outBuf, OFRAMESIZE);
}
if (versionBuf) {
Memory_contigFree(versionBuf, MAXVERSIONSIZE);
}
GT_0trace(curMask, GT_1CLASS, "app done.\n");
return (0);
}
/*
* ======== smain ========
*/
Int smain(Int argc, String argv[])
{
Engine_Handle ce = NULL;
IMGDEC1_Handle dec = NULL;
IMGENC1_Handle enc = NULL;
FILE *in = NULL;
FILE *out = NULL;
String inFile, outFile;
Memory_AllocParams allocParams;
if (argc <= 1) {
inFile = "./in.dat";
outFile = "./out.dat";
createInFileIfMissing(inFile);
}
else if (argc >= 3) {
progName = argv[0];
inFile = argv[1];
outFile = argv[2];
}
else {
fprintf(stderr, usage, argv[0]);
exit(1);
}
if ((argc == 4) && (argv[3][0] == '1')) {
appPause = 1;
}
GT_0trace(curMask, GT_1CLASS, "App-> Application started.\n");
/* allocate buffers */
allocParams.type = Memory_CONTIGPOOL;
allocParams.flags = Memory_NONCACHED;
allocParams.align = BUFALIGN;
allocParams.seg = 0;
inBuf = (XDAS_Int8 *)Memory_alloc(IFRAMESIZE, &allocParams);
encodedBuf = (XDAS_Int8 *)Memory_alloc(EFRAMESIZE, &allocParams);
outBuf = (XDAS_Int8 *)Memory_alloc(OFRAMESIZE, &allocParams);
versionBuf = (XDAS_Int8 *)Memory_alloc(MAXVERSIONSIZE, &allocParams);
if ((inBuf == NULL) || (encodedBuf == NULL) || (outBuf == NULL) ||
(versionBuf == NULL)) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, NULL, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize video decoder on the engine */
dec = IMGDEC1_create(ce, decoderName, NULL);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize video encoder on the engine */
enc = IMGENC1_create(ce, encoderName, NULL);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
#ifdef USE_POWER_MANAGEMENT
/* open local power manager */
if (Global_usePowerManagement) {
LPM_Status lpmStat = LPM_SOK;
lpmStat = LPM_open("/dev/lpm0", &lpmHandle);
if (lpmStat != LPM_SOK) {
fprintf(stderr, "%s: error: LPM_open() failed\n", progName);
goto end;
}
}
#endif
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
#ifdef USE_POWER_MANAGEMENT
/* close local power manager */
if (lpmHandle != NULL) {
LPM_close(lpmHandle);
}
#endif
/* teardown the codecs */
if (enc) {
IMGENC1_delete(enc);
}
if (dec) {
IMGDEC1_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
if (inBuf) {
Memory_free(inBuf, IFRAMESIZE, &allocParams);
}
if (encodedBuf) {
Memory_free(encodedBuf, EFRAMESIZE, &allocParams);
}
if (outBuf) {
Memory_free(outBuf, OFRAMESIZE, &allocParams);
}
if (versionBuf) {
Memory_free(versionBuf, MAXVERSIONSIZE, &allocParams);
}
GT_0trace(curMask, GT_1CLASS, "app done.\n");
return (0);
}
/*
* ======== smain ========
*/
Int smain(String progName, String procId, String engineName,
String inFile, String outFile)
{
Engine_Handle ce = NULL;
Engine_Attrs attrs;
VIDDEC2_Handle dec = NULL;
VIDENC1_Handle enc = NULL;
FILE *in = NULL;
FILE *out = NULL;
Memory_AllocParams allocParams;
createInFileIfMissing(inFile);
Log_print4(Diags_USER1, "[+1] App-> Application started, procId %s "
"engineName %s input-file %s output-file %s.",
(IArg)procId, (IArg)engineName, (IArg)inFile, (IArg)outFile);
/* allocate input, encoded, and output buffers */
allocParams.type = Memory_CONTIGPOOL;
allocParams.flags = Memory_NONCACHED;
allocParams.align = BUFALIGN;
allocParams.seg = 0;
inBuf = (XDAS_Int8 *)Memory_alloc(IFRAMESIZE, &allocParams);
encodedBuf = (XDAS_Int8 *)Memory_alloc(EFRAMESIZE, &allocParams);
outBuf = (XDAS_Int8 *)Memory_alloc(OFRAMESIZE, &allocParams);
versionBuf = (XDAS_Int8 *)Memory_alloc(MAXVERSIONSIZE, &allocParams);
if ((inBuf == NULL) || (encodedBuf == NULL) || (outBuf == NULL) ||
(versionBuf == NULL)) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* Initialize attrs fields to default values, and set the procId */
Engine_initAttrs(&attrs);
attrs.procId = procId;
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, &attrs, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize video decoder on the engine */
dec = VIDDEC2_create(ce, decoderName, NULL);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize video encoder on the engine */
enc = VIDENC1_create(ce, encoderName, NULL);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
/* teardown the codecs */
if (enc) {
VIDENC1_delete(enc);
}
if (dec) {
VIDDEC2_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
if (inBuf) {
Memory_free(inBuf, IFRAMESIZE, &allocParams);
}
if (encodedBuf) {
Memory_free(encodedBuf, EFRAMESIZE, &allocParams);
}
if (outBuf) {
Memory_free(outBuf, OFRAMESIZE, &allocParams);
}
if (versionBuf) {
Memory_free(versionBuf, MAXVERSIONSIZE, &allocParams);
}
Log_print0(Diags_USER1, "[+1] app done.");
return (0);
}
/*
* ======== smain ========
*/
Int smain(Int argc, String argv[])
{
Engine_Handle ce = NULL;
AUDDEC1_Handle dec = NULL;
AUDENC1_Handle enc = NULL;
FILE *in = NULL;
FILE *out = NULL;
String inFile, outFile;
Memory_AllocParams allocParams;
if (argc <= 1) {
inFile = "./in.dat";
outFile = "./out.dat";
createInFileIfMissing(inFile);
}
else if (argc == 3) {
progName = argv[0];
inFile = argv[1];
outFile = argv[2];
}
else {
fprintf(stderr, usage, argv[0]);
exit(1);
}
GT_0trace(curMask, GT_1CLASS, "App-> Application started.\n");
/* allocate buffers */
allocParams.type = Memory_CONTIGPOOL;
allocParams.flags = Memory_NONCACHED;
allocParams.align = BUFALIGN;
allocParams.seg = 0;
inBuf = (XDAS_Int8 *)Memory_alloc(IFRAMESIZE, &allocParams);
encodedBuf = (XDAS_Int8 *)Memory_alloc(EFRAMESIZE, &allocParams);
outBuf = (XDAS_Int8 *)Memory_alloc(OFRAMESIZE, &allocParams);
versionBuf = (XDAS_Int8 *)Memory_alloc(MAXVERSIONSIZE, &allocParams);
#if USE_ANCDATA
ancBuf = (XDAS_Int8 *)Memory_alloc(ENCANCBUFSIZE, &allocParams);
if (ancBuf == NULL) {
goto end;
}
#endif
if ((inBuf == NULL) || (encodedBuf == NULL) || (outBuf == NULL) ||
(versionBuf == NULL)) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, NULL, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize video decoder on the engine */
dec = AUDDEC1_create(ce, decoderName, NULL);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize video encoder on the engine */
enc = AUDENC1_create(ce, encoderName, NULL);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
/* teardown the codecs */
if (enc) {
AUDENC1_delete(enc);
}
if (dec) {
AUDDEC1_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
if (inBuf) {
Memory_free(inBuf, IFRAMESIZE, &allocParams);
}
if (encodedBuf) {
Memory_free(encodedBuf, EFRAMESIZE, &allocParams);
}
if (outBuf) {
Memory_free(outBuf, OFRAMESIZE, &allocParams);
}
if (versionBuf) {
Memory_free(versionBuf, MAXVERSIONSIZE, &allocParams);
}
#if USE_ANCDATA
if (ancBuf) {
Memory_free(ancBuf, ENCANCBUFSIZE, &allocParams);
}
#endif
GT_0trace(curMask, GT_1CLASS, "app done.\n");
return (0);
}
/*
* ======== smain ========
*/
Int smain(Int argc, String argv[])
{
Engine_Handle ce = NULL;
AUDDEC1_Handle dec = NULL;
AUDENC1_Handle enc = NULL;
FILE *in = NULL;
FILE *out = NULL;
String inFile, outFile;
Int i;
if (argc <= 1) {
inFile = "../in.dat";
outFile = "../out.dat";
}
else if (argc == 3) {
progName = argv[0];
inFile = argv[1];
outFile = argv[2];
}
else {
fprintf(stderr, usage, argv[0]);
exit(1);
}
GT_0trace(curMask, GT_1CLASS, "App-> Application started.\n");
/* allocate input, encoded, output, and version buffers */
for (i = 0; i < NBUFFERS; i++) {
inBuf[i] = (XDAS_Int8 *)Memory_contigAlloc(IFRAMESIZE, BUFALIGN);
encodedBuf[i] = (XDAS_Int8 *)Memory_contigAlloc(EFRAMESIZE, BUFALIGN);
outBuf[i] = (XDAS_Int8 *)Memory_contigAlloc(OFRAMESIZE, BUFALIGN);
#if USE_ANCDATA
ancBuf[i] = (XDAS_Int8 *)Memory_contigAlloc(ENCANCBUFSIZE, BUFALIGN);
if (ancBuf[i] == NULL) {
goto end;
}
#endif
if ((inBuf[i] == NULL) || (encodedBuf[i] == NULL) ||
(outBuf[i] == NULL)) {
goto end;
}
}
/* we need one more encoded buffer than the others */
encodedBuf[NBUFFERS] = (XDAS_Int8 *)Memory_contigAlloc(EFRAMESIZE,
BUFALIGN);
if (encodedBuf[NBUFFERS] == NULL) {
goto end;
}
versionBuf = (XDAS_Int8 *)Memory_contigAlloc(MAXVERSIONSIZE, BUFALIGN);
if (versionBuf == NULL) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, NULL, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize video decoder on the engine */
dec = AUDDEC1_create(ce, decoderName, NULL);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize video encoder on the engine */
enc = AUDENC1_create(ce, encoderName, NULL);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
/* teardown the codecs */
if (enc) {
AUDENC1_delete(enc);
}
if (dec) {
AUDDEC1_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
for (i = 0; i < NBUFFERS; i++) {
if (inBuf[i]) {
Memory_contigFree(inBuf[i], IFRAMESIZE);
}
if (encodedBuf[i]) {
Memory_contigFree(encodedBuf[i], EFRAMESIZE);
}
if (outBuf[i]) {
Memory_contigFree(outBuf[i], OFRAMESIZE);
}
#if USE_ANCDATA
if (ancBuf[i]) {
Memory_contigFree(ancBuf[i], ENCANCBUFSIZE);
}
#endif
}
if (encodedBuf[NBUFFERS]) {
Memory_contigFree(encodedBuf[NBUFFERS], EFRAMESIZE);
}
if (versionBuf) {
Memory_contigFree(versionBuf, MAXVERSIONSIZE);
}
GT_0trace(curMask, GT_1CLASS, "app done.\n");
return (0);
}