Playing Back Large Amount of Voices

Sample directory

/cri/pc/samples/criatomex/playback_many_voices

Data used in the sample

/cri/common/smpdata/criatomex/

• SampleProject.acf
• AtomCueSheet.acb
• AtomCueSheet.awb
  

Sample description

CRI Atom can play a large number of voices with one player.

The maximum number of voices that can be used is set by the max_virtual_voices member of the CriAtomExConfig structure, which is passed to the library initialization function criAtomEx_Initialize .

Set this member to a large value (100 if you want to play 100 voices).

#define SMP_NUM_VOICE   (100)
 
CriAtomExConfig atomex_config;
CriAtomExAcbHn acb_hn;
CriAtomExAdxVoicePoolConfig adxvp_config;
CriAtomExVoicePoolHn voice_pool;
CriAtomExPlayerHn player;
 
    /* Initialize the library setting with default value */
    criAtomEx_SetDefaultConfig(&atomex_config);
    /* Set the number of virtual voices */
    atomex_config.max_virtual_voices = SMP_NUM_VOICE;
    /* Initialize the library */
    criAtomEx_Initialize(&atomex_config, NULL, 0);
 
    /* Read and register ACF file */
    criAtomEx_RegisterAcfFile(NULL, PATH ACF_FILE, NULL, 0);
    /* Load an ACB file and create an ACB handle */
    acb_hn = criAtomExAcb_LoadAcbFile(NULL, PATH ACB_FILE, NULL, PATH AWB_FILE, NULL, 0);
 
    /* Create an ADX Voice Pool */
    criAtomExVoicePool_SetDefaultConfigForAdxVoicePool(&adxvp_config);
    /* Set the number of Voices */
    adxvp_config.num_voices = SMP_NUM_VOICE;
    /* Create Voice Pool */
    voice_pool = criAtomExVoicePool_AllocateAdxVoicePool(&adxvp_config, NULL, 0);
 
    /* Create a player */
    player = criAtomExPlayer_Create(NULL, NULL, 0);
    /* Set Cue ID */
    criAtomExPlayer_SetCueId(player, acb_hn, CRI_ATOMCUESHEET_THUNDER1);
    /* Start playback */
    criAtomExPlayer_Start(player);

When the criAtomExPlayer_Start function is executed, voices are used one after another to produce sounds. When there are not enough voices, the oldest voices are stopped and reused.

Since there is a fixed voice limit, it is possible to keep the CPU load within a certain range, regardless of how the data is created.