metaonly interface ti.sdo.ce.ICodec
index URL

Codec Engine algorithm interface

All codecs supported by the codec engine must implement this interface. This interface provides the Codec Engine runtime the following information: [ more ... ]
XDCspec summary sourced in ti/sdo/ce/ICodec.xdc
metaonly interface ICodec {  ...
XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
package ti.sdo.ce;
 
metaonly interface ICodec {
module-wide config parameters
    readonly config String ialgFxns// Name of xDAIS alg function table;
    readonly config String idma3Fxns// Name of xDAIS alg IDMA3 Interface function table;
    readonly config String iresFxns// Name of xDAIS alg IRES Interface function table;
    readonly config Int rpcProtocolVersion// Version of the Protocol used between the stubFxns and the serverFxns;
 
    config String serverFxns// Name of skeleton fxn table;
    config String stubFxns// Name of stubs fxn table;
    config Bool useCache// If set to true, the codec's memory requests will be allocated from cacheable memory. If set to false, the memory will be allocated from non-cached memory. If this is not set, the ti.sdo.ce.alg.Settings.useCache flag will determine whether the codec's memory will be allocated from cached or non-cached memory;
    config Int uuid// Unique algorithm implementation ID;
module-wide functions
    Int getCreationStackSize// Get the maximum required stack size (in octets) for this algorithm during algorithm instance creation( Program.Module prog );
    Int getDaramScratchSize// Get the maximum scratch size (in octets) required for this algorithm from DARAM space( Program.Module prog );
    Int getSaramScratchSize// Get the maximum scratch size (in octets) required for this algorithm from SARAM space( Program.Module prog );
    Int getStackSize// Get the maximum stack size (in octets) required for this algorithm during its execution phase( Program.Module prog );
}
DETAILS
All codecs supported by the codec engine must implement this interface. This interface provides the Codec Engine runtime the following information:
  1. How much stack space is required by the algorithm during instance creation (so the runtime can allocate an appropriate stack).
  2. How much stack space is required by the algorithm during execution (so the runtime can allocate an appropriate stack).
  3. The algorithm's entry points for the IALG interface (so the runtime can lookup the algorithm's functions based on a string name).
  4. The algorithm's entry points for the optional IDMA3 interface (so the runtime can allocate DMA resources for the algorithm at runtime).
  5. The entry points for "stubs" and "skeletons" in the case that the algorithm is to be run on a remote processor.
  6. The size of scratch memory required by the algorithm.
 
config ICodec.ialgFxns  // module-wide
index URL

Name of xDAIS alg function table

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
readonly config String ialgFxns;
 
DETAILS
All xDAIS algorithms must define an IALG_Fxns structure that contains implementations of the IALG methods. This configuration parameter is simply the extern name of this structure.
 
config ICodec.idma3Fxns  // module-wide
index URL

Name of xDAIS alg IDMA3 Interface function table

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
readonly config String idma3Fxns;
 
DETAILS
All xDAIS algorithms that use DMA must define an IDMA3_Fxns structure containing the pointers to functions implementatng the IDMA3 interface. If algorithm does not use DMA this structure does not have to be defined.
This configuration parameter is simply the extern name of this structure when defined, null otherwise.
 
config ICodec.iresFxns  // module-wide
index URL

Name of xDAIS alg IRES Interface function table

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
readonly config String iresFxns;
 
DETAILS
All xDAIS algorithms that use an IRES resource must define an IRES_Fxns structure containing the pointers to functions implementatng the IRES interface. If algorithm does not use an IRES resource this structure does not have to be defined.
This configuration parameter is simply the extern name of this structure when defined, null otherwise.
SEE
ialgFxns, idma3Fxns
 
config ICodec.rpcProtocolVersion  // module-wide
index URL

Version of the Protocol used between the stubFxns and the serverFxns

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
readonly config Int rpcProtocolVersion;
 
DETAILS
This is set by a particular implementation of a stub/skeleton RPC pair, and is used at runtime to ensure the protocol matches. This is important, for example, to ensure that the protocol used by skeletons built into a server matches that used by the stubs built into the application. Specifically, this is typically changed when the marshalling/unmarshalling message format changes.
This is generally not configured by application or server config scripts, but rather by developers of VISA-like API class extensions.
This rpcProtocolVersion is built into the local application executable, as well as the remote server's executable.
Developers of class extensions should ensure this config parameter is set appropriately by each release of their stubs/skeletons. If a new protocol is introduced, implying that updating both would result in error, the number should be incremented.
There is no "backward-compatibility" requirement in rpcProtocolVersion. If the version is different, regardless of whether it's larger or smaller, the creation of algorithms of this class will fail.
 
config ICodec.serverFxns  // module-wide
index URL

Name of skeleton fxn table

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
config String serverFxns;
 
DETAILS
All algorithm's that can run on a remote processor must specify a set of "stub" functions that marshall arguments to send to the remote process that runs corresponding "skeletons" to do the actual processing. This configuration parameter defines the entry point for this algorithm's the skeletons (which run on the remote processor).
This is generally not configured by application or server config scripts, but rather by developers of VISA-like API class extensions. However, an application or server integrator could use this config param to configure in custom serverFxns.
SEE
stubFxns
 
config ICodec.stubFxns  // module-wide
index URL

Name of stubs fxn table

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
config String stubFxns;
 
DETAILS
All algorithm's that can run on a remote processor must specify a set of "stub" functions that marshall arguments to send to the remote process that runs corresponding "skeletons" to do the actual processing. This configuration parameter defines the entry point for this algorithm's the stubs (which run on the local processor).
This is generally not configured by application or server config scripts, but rather by developers of VISA-like API class extensions. However, an application or server integrator could use this config param to configure in custom stubFxns.
SEE
serverFxns
 
config ICodec.useCache  // module-wide
index URL

If set to true, the codec's memory requests will be allocated from cacheable memory. If set to false, the memory will be allocated from non-cached memory. If this is not set, the ti.sdo.ce.alg.Settings.useCache flag will determine whether the codec's memory will be allocated from cached or non-cached memory

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
config Bool useCache;
 
 
config ICodec.uuid  // module-wide
index URL

Unique algorithm implementation ID

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
config Int uuid;
 
DETAILS
This integer must be a unique ID for every algorithm in a "system", where the "system" includes all possible DSP Servers.
This id is used by the Codec Engine APIs to identify the algorithm implementation that will create an instance on a DSP Server.
If a codec doesn't explicitly configure this parameter, a "very likely unique" ID will be generated. It is recommended that codecs not explicitly configure this parameter, and leave it to the system.
 
ICodec.getCreationStackSize( )  // module-wide
index URL

Get the maximum required stack size (in octets) for this algorithm during algorithm instance creation

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
Int getCreationStackSize( Program.Module prog );
 
DETAILS
This method is called during DSP Server configuration and is used to ensure that the instance creation thread on the server has sufficient stackspace to instantiate the algorithm. This stack size is typically the greater of the stack sizes required by the algorithm's algNumAlloc(), algAlloc(), or algInit() methods.
 
ICodec.getDaramScratchSize( )  // module-wide
index URL

Get the maximum scratch size (in octets) required for this algorithm from DARAM space

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
Int getDaramScratchSize( Program.Module prog );
 
DETAILS
This method is called during DSP Server configuration and is used to ensure that sufficient scratch space is configured for the specified set of algorithms.
 
ICodec.getSaramScratchSize( )  // module-wide
index URL

Get the maximum scratch size (in octets) required for this algorithm from SARAM space

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
Int getSaramScratchSize( Program.Module prog );
 
DETAILS
This method is called during DSP Server configuration and is used to ensure that sufficient scratch space is configured for the specified set of algorithms.
 
ICodec.getStackSize( )  // module-wide
index URL

Get the maximum stack size (in octets) required for this algorithm during its execution phase

XDCspec declarations sourced in ti/sdo/ce/ICodec.xdc
Int getStackSize( Program.Module prog );
 
DETAILS
This method is called during DSP Server configuration and is used to ensure that threads on the server have sufficient stackspace to run the algorithm.
generated on Thu, 02 Dec 2010 05:35:36 GMT