Wwise SoundBank (*.bnk)

From XentaxWiki
Jump to: navigation, search

On this page you can find a file format specification of the .bnk SoundBank files used by Wwise.

SoundBanks by Wwise can be used to have a great deal of control over the soundtrack of a game, including the sound effects and the score. SoundBanks contain the individual audio files as well as containers to group the files, e.g. a gun shot container that plays a random gun shot sound. Also, SoundBanks contain events which can play or pause containers or audio files. Events are the only type of object that is visible outside the SoundBanks, and developers can access these events from the game code. For example, during a very emotional scene they could call a Play_EmotionalTheme event, which will play an emotional piece, as defined by the sound designer.

Each Wwise project contains an initialization SoundBank, Init.bnk. This SoundBank contains the project settings and is loaded first. The other SoundBanks contain sounds for different parts of the game (e.g. one SoundBank for each area or level). They are loaded into memory whenever the player has reached that part of the game.

The sound files are stored via a custom Wwise encoding and have the file extension .wem (before 2011, the Wwise extension was called .wav). For converting these files to .ogg files, I recommend the command-line utility ww2ogg by Halley's Comet Software (hcs) -- see hcs64.com/vgm_ripping.html. Depending on the game, some files are not embedded in the SoundBanks but are streamed. In this case, look in the game archive for .wem files.

General format

  • FOR EACH (section) {
    • byte[4]: four-letter identifier of the section, e.g. BKHD or DIDX
    • uint32: length of this section in bytes
    • byte[]: section data (see below)
  • } END FOR

-- END OF FILE --

To avoid errors when reading a .bnk file, it is recommended to always seek to the end of a section by using the byte length field. That way, even the program has reached the end of the section, it will automatically skip to the end in case it has left out something.

BKHD section

The BKHD section (Bank Header) contains the version number and the SoundBank id.

  • 42 4B 48 44 -- BKHD
  • uint32: length of section
  • uint32: version number of this SoundBank
  • uint32: id of this SoundBank
  • uint32: always zero
  • uint32: always zero

DIDX section

The DIDX (Data Index) section contains the references to the .wem files embedded in the SoundBank. Each sound file is described with 12 bytes, so you can get the number of embedded files by dividing the section length by 12.

  • 44 49 44 58 -- DIDX
  • uint32: length of section
  • FOR EACH (embedded .wem file) {
    • uint32: .wem file id
    • uint32: offset from start of DATA section
    • uint32: length in bytes of .wem file
  • } END FOR

DATA section

The DATA section contains the .wem files, not encoded, and immediately following each other. It is not recommended to read this section by itself but instead to immediately jump to the correct position based on the offset given in the DIDX or HIRC section.

  • 44 41 54 41 -- DATA
  • uint32: length of section
  • FOR EACH (embedded .wem file) {
    • byte[]: the .wem file with the length as given in the DIDX section, and starting with 52 49 46 46 -- RIFF.
  • } END FOR

ENVS section

The ENVS section (Environments?) section is yet to be analysed.

FXPR section

The FXPR section (Effects production?) section is yet to be analysed.

HIRC section

The HIRC section contains all the Wwise objects, including the events, the containers to group sounds, and the references to the sound files.

Format:

  • 48 49 52 43 -- HIRC
  • uint32: length of section
  • uint32: number of objects
  • FOR EACH (object) {
    • byte: single byte identifying type of object
    • uint32: length of object section (= 4-byte id field and additional bytes)
    • uint32: id of this object
    • byte[]: additional bytes, depending on type of object and section length
  • } END FOR

type #1: Settings

Format:

  • 01 -- identifier for Settings section
  • uint32: length of this section
  • uint32: id of this Settings object
  • byte: number of settings
  • FOR EACH (setting) {
    • byte: type of setting:
      • 00: Voice Volume
      • 03: Voice Low-pass Filter
  • } END FOR
  • FOR EACH (setting) {
    • float: setting value
  • } END FOR

-- END OF SECTION --

type #2: Sound SFX/Sound Voice

Format:

-- BEGINNING OF SECTION --

  • 02 -- identifier for Sound SFX section
  • uint32: length of this section
  • uint32: id of this Sound SFX object
  • byte[4]: four unknown bytes
  • uint32: whether the sound is included in the SoundBank or streamed:
    • 00: embedded in the SoundBank, not streamed
    • 01: is streamed
    • 02: is streamed, with Zero Latency (that is, the sound data is prefetched)
  • uint32: id of the audio file
  • uint32: id of the source:
    • If this file is embedded, this will contain the SoundBank id as given in the STID section.
    • If the file is being streamed, this number will be identical to the audio file id and can be used to find the .wem file to stream.

IF (file is embedded in a SoundBank) {

  • uint32: offset to the position where the .wem sound file can be found in the SoundBank
  • uint32: length in bytes of the .wem sound file in the SoundBank

} END IF

  • byte: type of Sound object:
    • 00: Sound SFX
    • 01: Sound Voice
  • byte[]: see section Sound structure

-- END OF SECTION --

type #3: Event Action

Format:

  • 03 -- identifier for Event Action section
  • uint32: length of this section
  • uint32: id of this Event Action object
  • byte: The Scope of this Event Action:
    • 01: Game object: Switch or Trigger
    • 02: Global
    • 03: Game object: see referenced object id
    • 04: Game object: State
    • 05: All
    • 09: All Except see referenced object id
  • byte: Action Type:
    • 01: Stop
    • 02: Pause
    • 03: Resume
    • 04: Play
    • 05: Trigger
    • 06: Mute
    • 07: UnMute
    • 08: Set Voice Pitch
    • 09: Reset Voice Pitch
    • 0A: Set Voice Volume
    • 0B: Reset Voice Volume
    • 0C: Set Bus Volume
    • 0D: Reset Bus Volume
    • 0E: Set Voice Low-pass Filter
    • 0F: Reset Voice Low-pass Filter
    • 10: Enable State
    • 11: Disable State
    • 12: Set State
    • 13: Set Game Parameter
    • 14: Reset Game Parameter
    • 19: Set Switch
    • 1A: Enable Bypass or Disable Bypass
    • 1B: Reset Bypass Effect
    • 1C: Break
    • 1E: Seek
  • uint32: id of the game object that is referenced by this Event Action, or zero if there is no game object
  • byte: always 00
  • byte: number of additional parameters
  • FOR EACH (parameter) {
    • byte: parameter type:
      • 0E: Delay, given as uint32 in milliseconds
      • 0F: Play: Fade in time, given as uint32 in milliseconds
      • 10: Probability, given as float
  • } END FOR
  • FOR EACH (parameter) {
    • byte[]: parameter value, format depending on parameter type (see above)
  • } END FOR
  • byte: always 00
  • IF (Action Type == "Set State", 0x12) {
    • uint32: State Group id
    • uint32: State id
  • ELSE IF (Action Type == "Set Switch", 0x19) {
    • uint32: Switch Group id
    • uint32: Switch id
  • } END IF

-- END OF SECTION --

More information will follow.

type #4: Event

Format:

-- BEGINNING OF SECTION --

  • 04 -- identifier for Event section
  • uint32: length of this section
  • uint32: id of this Event object
  • uint32: the number of Event Actions this Event has
  • FOR EACH (event action) {
    • uint32: id of the Event Action
  • } END FOR

-- END OF SECTION --

type #5: Random Container or Sequence Container

More information will follow.

type #6: Switch Container

More information will follow.

type #7: Actor-Mixer

More information will follow.

type #8: Audio Bus

-- BEGINNING OF SECTION --

  • 08 -- identifier for Audio Bus section
  • uint32: length of this section
  • uint32: id of this Audio Bus object
  • uint32: id of the parent Audio Bus object, or zero if it is the root (Master Audio Bus)
  • byte: the number of additional parameters
  • FOR EACH (additional parameter) {
    • byte: parameter type:
      • 00 = Voice: Volume
      • 02 = Voice: Pitch
      • 03 = Voice: Low-pass filter
      • 04 = Bus: Volume
  • } END FOR
  • FOR EACH (additional parameter) {
    • float: parameter value
  • } END FOR
  • byte: What to do when priority is equal:
    • 00 = Discard oldest instance
    • 01 = Discard newest instance
  • byte: What to do when limit is reached:
    • 00 = Kill voice
    • 01 = Use virtual voice settings
  • uint16: Limit sound instances to ...
  • boolean: whether to override parent settings for Playback Limit
  • uint32: unknown, always 3F 00 00 00 (= 63)
  • uint32: Auto-ducking: Recover time (ms)
  • float: Auto-ducking: Maximum ducking volume
  • uint32: Auto-ducking: Number of ducked busses
  • FOR EACH (ducked bus) {
    • uint32: id of ducked Audio Bus object
    • float: Volume of ducked bus
    • uint32: Fade Out (ms) of ducked bus
    • uint32: Fade In (ms) of ducked bus
    • byte: shape of curve:
        • 00 = Logarithmic (Base 3)
        • 01 = Sine (Constant Power Fade In)
        • 02 = Logarithmic (Base 1.41)
        • 03 = Inverted S-Curve
        • 04 = Linear
        • 05 = S-Curve
        • 06 = Exponential (Base 1.41)
        • 07 = Sine (Constant Power Fade Out)
        • 08 = Exponential (Base 3)
    • byte: Target:
      • 00: Voice Volume
      • 04: Bus Volume
  • } END FOR
  • byte: number of effects
  • IF (number of effects > 0) {
    • byte: bit mask specifying which effects should be bypassed:
      • 0000 0001 = Bypass Effect 0
      • 0000 0010 = Bypass Effect 1
      • 0000 0100 = Bypass Effect 2
      • 0000 1000 = Bypass Effect 3
      • 0001 0000 = Bypass All
    • FOR EACH (effect) {
      • byte: effect index (00 to 03)
      • uint32: id of Effect object
      • byte[2]: two zero bytes
    • } END FOR
  • } END IF
  • uint16: number of RTPCs
  • FOR EACH (RTPC) {
    • uint32: id of Game Parameter on x-axis
    • uint32: y-axis type:
      • 00 = Voice Volume
      • 03 = Voice Low-Pass Filter
      • 08 = Priority
      • 09 = Sound Instance Limit
      • 0F = User-Defined Auxiliary Sends Volume 0
      • 10 = User-Defined Auxiliary Sends Volume 1
      • 11 = User-Defined Auxiliary Sends Volume 2
      • 12 = User-Defined Auxiliary Sends Volume 3
      • 13 = Game-Defined Auxiliary Sends Volume
      • 16 = Output Bus Volume
      • 17 = Output Bus Low-pass Filter
      • 18 = Bypass Effect 0
      • 19 = Bypass Effect 1
      • 1A = Bypass Effect 2
      • 1B = Bypass Effect 3
      • 1C = Bypass All Effects
      • 1D = Motion Volume Offset
      • 1E = Motion Low Pass
    • uint32: unknown id
    • byte: unknown
    • byte: number of points
    • byte: unknown
    • FOR EACH (point) {
      • float: x-coordinate of point
      • float: y-coordinate of point
      • uint32: shape of curve following this point:
        • 00 = Logarithmic (Base 3)
        • 01 = Sine (Constant Power Fade In)
        • 02 = Logarithmic (Base 1.41)
        • 03 = Inverted S-Curve
        • 04 = Linear
        • 05 = S-Curve
        • 06 = Exponential (Base 1.41)
        • 07 = Sine (Constant Power Fade Out)
        • 08 = Exponential (Base 3)
        • 09 = Constant
    • } END FOR
  • } END FOR
  • uint32: number of State Groups
  • FOR EACH (State Group) {
    • uint32: id of State Group object
    • byte: change occurs at: (only if it is Interactive Music, otherwise this is always zero)
      • 00 = Immediate
      • 01 = Next Grid
      • 02 = Next Bar
      • 03 = Next Beat
      • 04 = Next Cue
      • 05 = Custom Cue
      • 06 = Entry Cue
      • 07 = Exit Cue
    • uint16: number of States where settings are different from default settings
    • FOR EACH (State with custom settings) {
      • uint32: id of State object
      • uint32: id of object that contains the settings (see section type #1: Settings)
    • } END FOR
  • } END FOR

-- END OF SECTION --

type #9: Blend Container

More information will follow.

type #10: Music Segment

A Music Segment is similar to a Music Track, it contains exactly one song. However, unlike the Music Tracks, a Music Segment can contain multiple audio files, for example one file for each instrument. In this case, all files are played simultaneously, but it is possible to for example mute a certain instrument in the middle of the song, or to otherwise control the volume of individual files.

  • 0A -- identifier for Music Segment section
  • uint32: length of this section
  • uint32: id of this Music Segment object
  • byte[]: see section Sound structure
  • uint32: number of child objects
  • FOR EACH (child object) {
    • uint32: id of child object
  • } END FOR
  • byte[]: unknown bytes

More information will follow.

type #11: Music Track

A Music Track is the most basic Music object. For each audio file that you import, a Music Track is created. It contains information on where the track is stored.

Each Music Track is contained inside one Music Segment, so when working with Containers, you can only use Segments as children, not Tracks.

More information will follow.

type #12: Music Switch Container

A Music Switch Container uses Switches or States to determine which music should be played. For example, a Switch Group could be activity, with possible states ranging from combat, stealth, exploration, rest, etc. The game could change the current value via a Set State or Set Switch Event. Depening on the currently set state, the game would either play the music container specified for combat, the container for stealth, and so on.

  • 0C -- identifier for Music Switch Container section
  • uint32: length of this section
  • uint32: id of this Music Switch Container object
  • byte[]: see section Sound structure
  • uint32: number of children (Switch/Playlist Containers and Segments) that are part of this Switch container
  • FOR EACH (child) {
    • uint32: id of child object
  • } END FOR
  • byte[4]: four zero bytes
  • float: unknown float
  • byte[8]: eight zero bytes
  • float: tempo (usually 120)
  • byte: time signature, part 1
  • byte: time signature, part 2 (usually 4/4)
  • byte: always 01
  • byte[4]: four zero bytes
  • uint32: number of Transitions (from Source to Destination)
  • FOR EACH (Transition) {
    • uint32: id of Source object, or FF FF FF FF if Any, or 00 00 00 00 if Nothing
    • uint32: id of Destination object, or FF FF FF FF if Any, or 00 00 00 00 if Nothing
    • int32: Source Fade-out Time (ms)
    • uint32: shape of Source Fade-out curve
    • int32: Source Fade-out Offset (ms)
    • uint32: Exit source at:
      • 00: Immediate
      • 01: Next Grid
      • 02: Next Bar
      • 03: Next Beat
      • 04: Next Cue
      • 05: New Custom Cue (see Match)
      • 07: Exit Cue
    • note: Newer Wwise versions (2012.1+?) may include an additional uint32 field here: id of Match for "Next Custom Cue"
    • byte: 00 = Nothing, FF = Play post-exit section of Source object
    • int32: Destination Fade-in Time (ms)
    • uint32: shape of Destination Fade-in curve
    • int32: Destination Fade-in Offset (ms)
    • uint32: id of Match for Custom Cue Filter, 00=Any
    • uint32: if destination is a Playlist Container, this contains the id of the Playlist item to jump to, otherwise zero
    • uint16: Sync to:
      • 00: Entry Cue
      • 01: Same Time as Playing Segment
      • 02: Random Cue
      • 03: Random Custom Cue (see Custom Cue Filter)
    • byte: 00 = Nothing, FF = Play pre-entry section of Destination object
    • note: Newer Wwise versions (2012.1+?) may include an additional byte here for Custom Cue Filter: 01=Match source cue name, 00=Match ... (see above)
    • boolean: whether the Transition has a Transition object specified
    • uint32: id of the Transition object, or zero if no Transition object
    • int32: Transition Fade-in Time (ms)
    • uint32: shape of Transition Fade-in curve
    • int32: Transition Fade-in Offset (ms)
    • int32: Transition Fade-out Time (ms)
    • uint32: shape of Transition Fade-out curve
    • int32: Transition Fade-out Offset (ms)
    • byte: 00 = Nothing, FF = Play pre-entry section of Transition object
    • byte: 00 = Nothing, FF = Play post-exit section of Transition object
  • } END FOR
  • uint32: Switch Type:
    • 00 00 00 00: The current switch of a Switch Group determines which music to play
    • 01 00 00 00: The current state of a State Group determines which music to play
  • uint32: id of the Switch Group or State Group object
  • uint32: id of the default Switch/State, or 00 00 00 00 if None
  • boolean: whether to Continue to play on Switch change
  • uint32: number of Switches/States
  • FOR EACH (Switch or State) {
    • uint32: id of the Switch/State
    • uint32: id of the music object that should be played when this Switch/State is set
  • } END FOR

-- END OF SEGMENT --

type #13: Music Playlist Container

The Playlist Container allows you to select a number of segments that should be played during a certain point in the game. Unlike the Music Segment which only contains one track, Playlists can contain multiple Segments that are played one after another.

You can control in what order the segments are played. For example, you could choose that one of three segments from the A part should be played first, then a random track from the B part, and then to start over from the beginning.

However, all the transitions from one music to the other have to be coded beforehand and it is not possible to change them during game. Instead, use a Switch container to for example stop playing all the peaceful music from the Playlist Container and start playing the combat music Playlist Container.

  • 0D -- identifier for Music Playlist section
  • uint32: length of this section
  • uint32: id of this Music Segment object
  • byte[]: see section Sound structure
  • uint32: number of Music Segments that are part of this playlist
  • FOR EACH (Music Segment) {
    • uint32: Music Segment id
  • } END FOR
  • byte[4]: four zero bytes
  • float: unknown float
  • byte[8]: eight zero bytes
  • float: tempo (usually 120)
  • byte: time signature, part 1
  • byte: time signature, part 2 (usually 4/4)
  • byte: always 01
  • byte[4]: four zero bytes
  • uint32: number of Transitions (from Source to Destination)
  • FOR EACH (Transition) {
    • uint32: id of Source Music Segment, or FF FF FF FF if Any, or 00 00 00 00 if Nothing
    • uint32: id of Destination Music Segment, or FF FF FF FF if Any, or 00 00 00 00 if Nothing
    • int32: Source Fade-out Time (ms)
    • uint32: shape of Source Fade-out curve
    • int32: Source Fade-out Offset (ms)
    • int32: unknown, always 7
    • note: Newer Wwise versions (2012.1+?) may include an additional unknown int32 field here.
    • byte: 00 = Nothing, FF = Play post-exit section of Source segment
    • int32: Destination Fade-in Time (ms)
    • uint32: shape of Destination Fade-in curve
    • int32: Destination Fade-in Offset (ms)
    • int32: unknown
    • int32: unknown
    • int16: unknown
    • byte: 00 = Nothing, FF = Play pre-entry section of Destination segment
    • note: Newer Wwise versions (2012.1+?) may include an additional unknown 00 zero byte here.
    • boolean: whether the Transition has a Transition segment specified
    • uint32: id of the Transition segment, or zero if no Transition segment
    • int32: Transition Fade-in Time (ms)
    • uint32: shape of Transition Fade-in curve
    • int32: Transition Fade-in Offset (ms)
    • int32: Transition Fade-out Time (ms)
    • uint32: shape of Transition Fade-out curve
    • int32: Transition Fade-out Offset (ms)
    • byte: 00 = Nothing, FF = Play pre-entry section of Transition segment
    • byte: 00 = Nothing, FF = Play post-exit section of Transition segment
  • } END FOR
  • uint32: number of Playlist elements (either Groups or Music Segments)
  • FOR EACH (Playlist elements) {
    • uint32: id of the Music Segment, or zero if it is a Group
    • uint32: id of this element, mostly used by the Wwise sound engine and not that important to know
    • uint32: if it is a Group, this contains the number of child elements, otherwise it is zero
    • int32: if it is a Group, this contains the playlist type:
      • 00 00 00 00: Sequence Continuous (play all the child elements, one after another)
      • 01 00 00 00: Sequence Step (play one of the child elements)
      • 02 00 00 00: Random Continuous (play all the child elements, in random order)
      • 03 00 00 00: Random Step (play one random child element)
      • FF FF FF FF: this element is a Segment, not a Group
    • uint16: Loop Count (usually 01 00)
    • uint32: Weight * 1000, only needed for children of Random Groups (e.g., a weight of 50 would be encoded as 50,000)
    • uint16: only for Random Groups: Avoid repeating a child track ... times in row
    • byte: always 01
    • byte: only for Random Groups: Random Type: 00 = Standard, 01 = Shuffle
  • } END FOR

-- END OF SECTION --

Note: The playlist elements themselves do not contain a field that tells you which element is the parent or which elements are children. Instead, after each Group element, the children are encoded in the file. When writing a file reader, I recommend a recursive programming style like the following:

function readElement(index, parent) {
  index++
  if (Element is a Group) {
    parent.add(playlist type, number of children)
    for each (child) {
      readElement(index++, this)
    }
  } else (Element is a Segment) {
    parent.add(segment id)
  }
}
readElement(0, root)

type #14: Attenuation

More information will follow.

type #15: Dialogue Event

More information will follow.

type #16: Motion Bus

Only included if a Motion Device is activated under project settings. More information will follow.

type #17: Motion FX

More information will follow.

type #18: Effect

More information will follow.

type #20: Auxiliary Bus

More information will follow.

Sound structure

This sound structure is used in a number of objects, which is why I put it in this separate section.

  • boolean: whether to override parent settings for Effects section
  • byte: number of effects
  • IF (number of effects > 0) {
    • byte: bit mask specifying which effects should be bypassed:
      • 0000 0001 = Bypass Effect 0
      • 0000 0010 = Bypass Effect 1
      • 0000 0100 = Bypass Effect 2
      • 0000 1000 = Bypass Effect 3
      • 0001 0000 = Bypass All
    • FOR EACH (effect) {
      • byte: effect index (00 to 03)
      • uint32: id of Effect object
      • byte[2]: two zero bytes
    • } END FOR
  • } END IF
  • uint32: id of Output Bus, or 00 if Output Bus of parent object should be used
  • uint32: id of parent object
  • boolean: whether to override parent settings for Playback Priority section
  • boolean: whether the "Offset priority by ... at max distance" setting is activated
  • byte: number of additional parameters; they are only included if they are different from their default values
  • FOR EACH (additional parameter) {
    • byte: type of parameter:
      • 00 = General Settings: Voice: Volume, float
      • 02 = General Settings: Voice: Pitch, float
      • 03 = General Settings: Voice: Low-pass filter, float
      • 05 = Advanced Settings: Playback Priority: Priority, float
      • 06 = Advanced Settings: Playback Priority: Offset priority by ... at max distance, float
      • 07: whether to Loop, given as uint32 = number of loops, or infinite if the value is 0
      • 08 = Motion: Audio to Motion Settings: Motion Volume Offset, float
      • 0B = Positioning: 2D: Panner X-coordinate, float
      • 0C = Positioning: 2D: Panner X-coordinate, float
      • 0D = Positioning: Center %, float
      • 12 = General Settings: User-Defined Auxiliary Sends: Bus #0 Volume, float
      • 13 = General Settings: User-Defined Auxiliary Sends: Bus #1 Volume, float
      • 14 = General Settings: User-Defined Auxiliary Sends: Bus #2 Volume, float
      • 15 = General Settings: User-Defined Auxiliary Sends: Bus #3 Volume, float
      • 16 = General Settings: Game-Defined Auxiliary Sends: Volume, float
      • 17 = General Settings: Output Bus: Volume, float
      • 18 = General Settings: Output Bus: Low-pass filter, float
  • } END FOR
  • FOR EACH (additional parameter) {
    • byte[]: value of additional parameter, decoded based on the property type, see above
  • } END FOR
  • byte: unknown 00 zero byte
  • boolean: whether a Positioning section is included (01, if object overrides parent or it has no parent)
  • IF (Positioning section is included) {
    • byte: 00 = 2D, 01 = 3D
    • IF (Positioning = 2D) {
      • boolean: whether to Enable Panner
    • } ELSE IF (Positioning = 3D) {
      • uint32: type of Position Source:
        • 02 = User-defined
        • 03 = Game-defined
      • uint32: id of Attenuation object, if it exists, otherwise zero
      • boolean: whether to Enable Spatialization
      • IF (Position Source = User-defined, 0x02) {
        • uint32: Play Type:
          • 00 = Sequence Step
          • 01 = Random Step
          • 02 = Sequence Continuous
          • 03 = Random Continuous
          • 04 = Sequence Step, Pick new path when sound starts
          • 05 = Random Step, Pick new path when sound starts
        • boolean: whether to Loop (only when Play Type is Continuous, otherwise ignore value of this field)
        • uint32: Transition time (ms) (only when Play Type is Continuous, otherwise ignore value of this field)
        • boolean: whether to Follow Listener Orientation
      • } ELSE IF (Position Source = Game-defined, 0x03) {
        • boolean: whether to Update at each frame
      • } END IF
    • } END IF
  • } END IF
  • boolean: whether to override parent settings for Game-Defined Auxiliary Sends
  • boolean: whether to Use Game-Defined Auxiliary Sends
  • boolean: whether to override parent settings for User-Defined Auxiliary Sends
  • boolean: whether User-Defined Auxiliary Sends exist
  • IF (User-Defined Auxiliary Sends exist) {
    • uint32: id of Auxiliary Bus 0
    • uint32: id of Auxiliary Bus 1
    • uint32: id of Auxiliary Bus 2
    • uint32: id of Auxiliary Bus 3
  • } END IF
  • boolean: unknown parameter for Playback Limit section (note: this value may be bugged)
  • IF (unknown parameter) {
    • byte: What to do when priority is equal:
      • 00 = Discard oldest instance
      • 01 = Discard newest instance
    • byte: What to do when limit is reached:
      • 00 = Kill voice
      • 01 = Use virtual voice settings
    • uint16: Limit sound instances to ...
  • } END IF
  • byte: How to limit sound instances:
    • 00 = Per game object
    • 01 = Globally
  • byte: Virtual voice behavior:
    • 00 = Continue to play
    • 01 = Kill voice
    • 02 = Send to virtual voice
  • boolean: whether to override parent settings for Playback Limit section
  • boolean: whether to override parent settings for Virtual Voice section
  • uint32: number of State Groups
  • FOR EACH (State Group) {
    • uint32: id of State Group object
    • byte: change occurs at: (only if it is Interactive Music, otherwise this is always zero)
      • 00 = Immediate
      • 01 = Next Grid
      • 02 = Next Bar
      • 03 = Next Beat
      • 04 = Next Cue
      • 05 = Custom Cue
      • 06 = Entry Cue
      • 07 = Exit Cue
    • uint16: number of States where settings are different from default settings
    • FOR EACH (State with custom settings) {
      • uint32: id of State object
      • uint32: id of object that contains the settings (see section type #1: Settings)
    • } END FOR
  • } END FOR
  • uint16: number of RTPCs (Real-time Parameter Controls)
  • FOR EACH (RTPC) {
    • uint32: id of Game Parameter on x-axis
    • uint32: y-axis type:
      • 00 = Voice Volume
      • 03 = Voice Low-Pass Filter
      • 08 = Priority
      • 09 = Sound Instance Limit
      • 0F = User-Defined Auxiliary Sends Volume 0
      • 10 = User-Defined Auxiliary Sends Volume 1
      • 11 = User-Defined Auxiliary Sends Volume 2
      • 12 = User-Defined Auxiliary Sends Volume 3
      • 13 = Game-Defined Auxiliary Sends Volume
      • 16 = Output Bus Volume
      • 17 = Output Bus Low-pass Filter
      • 18 = Bypass Effect 0
      • 19 = Bypass Effect 1
      • 1A = Bypass Effect 2
      • 1B = Bypass Effect 3
      • 1C = Bypass All Effects
      • 1D = Motion Volume Offset
      • 1E = Motion Low Pass
    • uint32: unknown id
    • byte: unknown
    • byte: number of points
    • byte: unknown
    • FOR EACH (point) {
      • float: x-coordinate of point
      • float: y-coordinate of point
      • uint32: shape of curve following this point:
        • 00 = Logarithmic (Base 3)
        • 01 = Sine (Constant Power Fade In)
        • 02 = Logarithmic (Base 1.41)
        • 03 = Inverted S-Curve
        • 04 = Linear
        • 05 = S-Curve
        • 06 = Exponential (Base 1.41)
        • 07 = Sine (Constant Power Fade Out)
        • 08 = Exponential (Base 3)
        • 09 = Constant
    • } END FOR
  • } END FOR

STID section

The STID section (Sound Type ID?) section contains a list of all the SoundBanks referenced in the HIRC section (including the current SoundBank). In the HIRC section, only the SoundBank ids are given, so this section can be used to match an id with a SoundBank file name.

  • 53 54 49 44 -- STID
  • uint32: length of section
  • uint32: unknown integer, always 01 00 00 00
  • uint32: number of SoundBanks
  • FOR EACH (SoundBank) {
    • uint32: SoundBank id
    • byte: length of SoundBank name
    • char[]: String with given length, e.g. "music". Can be used to find the SoundBank file name: "music.bnk".
  • } END FOR

STMG section

The STMG section section can only be found in the Init.bnk SoundBank. It contains the project settings as well as the Switch Groups, State Groups and Game Parameters.

  • 53 54 4D 47 -- STMG
  • uint32: length of section
  • float: Volume Threshold
  • uint16: Max Voice Instances
  • uint32: number of State Groups
  • FOR EACH (State Group) {
    • uint32: id of State Group
    • uint32: default transition time (ms)
    • uint32: number of Custom Transition Times
    • FOR EACH (Custom Transition Time) {
      • uint32: id of "from" State
      • uint32: id of "to" State
      • uint32: transition time (ms)
    • } END FOR
  • } END FOR
  • uint32: number of Switch Groups that set the current Switch based on a Game Parameter
  • FOR EACH (Switch Group) {
    • uint32: id of Switch Group
    • uint32: id of Game Parameter that determines currently set Switch
    • uint32: number of points
    • FOR EACH (point) {
      • float: value of Game Parameter
      • uint32: id of Switch that is set when Game Parameter >= given value
      • uint32: shape of curve, always 09 = Constant
  • } END FOR
  • uint32: number of Game Parameters
  • FOR EACH (Game Parameter) {
    • uint32: id of Game Parameter
    • float: default value of Game Parameter
  • } END FOR

-- END OF SECTION --

Further information

You can get Wwise, free for personal use, at Audiokinetic.com, to generate custom SoundBank files and train your converter/reader. Also, I recommend watching the video tutorials at www.audiokinetic.com/en/resources/videos, specifically:

  • Using the interface
  • Importing Audio Files
  • Building Sound Hierarchies
  • Creating Events
  • Building SoundBanks
  • Relation between Sound, Source and Audio File