Introduction:

NOTE: We must enter -lwinmm in the linker settings or PlaySound() will not work.

Resource Script:
We will need to use a resource script as mentioned in the previous tutorial. This will define our audio files as the names IDW_SOUND1, IDW_SOUND2, IDW_SOUND3, and IDW_SOUND4. WAVE defines the type of resource then the next portion of syntax is the file path of the resource. The .rc file tells the compiler where to get these resources and where to place them inside the executable at runtime. This should start to make a little more sense when you review the code below.

resource.rc

#include "resource.h"

//Define the files as IDW_SOUND! (resource name) and of type WAVE then filepath
IDW_SOUND1 WAVE "1.wav"
IDW_SOUND2 WAVE "2.wav"
IDW_SOUND3 WAVE "3.wav"
IDW_SOUND4 WAVE "4.wav"

Resource Header:
The purpose of the header file is to teach the compiler how to access the resources we described in the resource script. To do this we define the names IDW_SOUND1, IDW_SOUND2, IDW_SOUND3, and IDW_SOUND4 as resources by associating them with unique IDs 1000, 1001, 1002, and 1003. These numbers are arbitrary thus you could use anything here just don’t duplicate them. Since we will be using the PlaySound() function we need to tell the compiler what to do when the name is called upon using #ifdef RC_INVOKED. This tells the compiler if the name is invoked then use the resources described. This will make sense when you review the code below.

resource.h

//Defines
#define IDW_SOUND1 1000
#define IDW_SOUND2 1001
#define IDW_SOUND3 1002
#define IDW_SOUND4 1003

//If these are invoked as resources load them
#ifdef RC_INVOKED
IDW_SOUND1 WAVE "1.wav"
IDW_SOUND2 WAVE "2.wav"
IDW_SOUND3 WAVE "3.wav"
IDW_SOUND4 WAVE "4.wav"
#endif

Main Program:
This is where all our gui related features come to life using the windows api. We must include the resource.h file to let the compiler know when we are invoking the audio resources. The GetSystemMetrics() function gets the width and height of the users computer screen. We will then take this and put it in the variable screenWidth and screenHeight respectively but applying some logic first screenWidth = (screenWidth / 2) – 115. This will account for the size of the initial window created because GetSystemMetrics(SM_CXSCREEN) and GetSystemMetrics(SM_CYSCREEN) only returns the size of the entire screen. Windows sets position based on the upper left hand corner thus applying this with variables is the best way to approach this issue. The buttons can be found in the function CreateWindow(TEXT(“button”), TEXT(“SFX1″), WS_VISIBLE | WS_CHILD , 20, 50, 80, 25, hwnd, (HMENU) 1, NULL, NULL) the first 20 is the x position the next is the y position and the width and height follow. (HMENU) 1 is the event number in which we will use to trigger the sound. Using if (LOWORD(wParam) == 1) will trigger the event to the PlaySound() function. PlaySound(MAKEINTRESOURCE(IDW_SOUND4), NULL, SND_RESOURCE | SND_ASYNC) will trigger the sound from the resource header. MAKEINTRESOURCE() function retrieves the file from the resources inside the executable so we don’t have to include our resources as separate files thus we have a portable standalone executable. This should make more sense once you review the code below.

main.cpp

#include <iostream>
#include <windows.h> 
#include "resource.h"

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);


int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
					LPSTR lpCmdLine, int nCmdShow )
{
  MSG  msg ;    
  WNDCLASS wc = {0};
  wc.lpszClassName = TEXT( "Buttons" );
  wc.hInstance     = hInstance ;
  wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
  wc.lpfnWndProc   = WndProc ;
  wc.hCursor       = LoadCursor(0, IDC_ARROW);
  int screenWidth = GetSystemMetrics(SM_CXSCREEN);
  int screenHeight = GetSystemMetrics(SM_CYSCREEN);
  screenWidth = (screenWidth / 2) - 115;
  screenHeight = (screenHeight / 2) - 90;

  
  RegisterClass(&wc);
  CreateWindow( wc.lpszClassName, TEXT("SoundBoard Tutorial"),
                WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                screenWidth, screenHeight, 230, 180, 0, 0, hInstance, 0);  

  while( GetMessage(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return (int) msg.wParam;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{

    
  switch(msg)  
  {
	case WM_CREATE:
	{
        CreateWindow(TEXT("button"), TEXT("SFX1"),    
		             WS_VISIBLE | WS_CHILD ,
		             20, 50, 80, 25,        
		             hwnd, (HMENU) 1, NULL, NULL);
		             
        CreateWindow(TEXT("button"), TEXT("SFX2"),    
		             WS_VISIBLE | WS_CHILD ,
		             20, 80, 80, 25,        
		             hwnd, (HMENU) 2, NULL, NULL);
                      
        CreateWindow(TEXT("button"), TEXT("SFX3"),    
		             WS_VISIBLE | WS_CHILD ,
		             120, 50, 80, 25,        
		             hwnd, (HMENU) 3, NULL, NULL); 
        CreateWindow(TEXT("button"), TEXT("SFX4"),    
		             WS_VISIBLE | WS_CHILD ,
		             120, 80, 80, 25,        
		             hwnd, (HMENU) 4, NULL, NULL); 
		             
        CreateWindow(TEXT("button"), TEXT("ABOUT"),    
		             WS_VISIBLE | WS_CHILD ,
		             20, 110, 80, 25,        
		             hwnd, (HMENU) 5, NULL, NULL);

	    CreateWindow(TEXT("button"), TEXT("QUIT"),    
		             WS_VISIBLE | WS_CHILD ,
		             120, 110, 80, 25,        
		             hwnd, (HMENU) 6, NULL, NULL);    
	    break;
	}

    case WM_COMMAND:
    {
    if (LOWORD(wParam) == 1){
	    PlaySound(MAKEINTRESOURCE(IDW_SOUND1), NULL, SND_RESOURCE | SND_ASYNC);
        }
        
    if (LOWORD(wParam) == 2){
	    PlaySound(MAKEINTRESOURCE(IDW_SOUND2), NULL, SND_RESOURCE | SND_ASYNC);
        }
        
    if (LOWORD(wParam) == 3){
	    PlaySound(MAKEINTRESOURCE(IDW_SOUND3), NULL, SND_RESOURCE | SND_ASYNC);
        }
        
    if (LOWORD(wParam) == 4){
	    PlaySound(MAKEINTRESOURCE(IDW_SOUND4), NULL, SND_RESOURCE | SND_ASYNC);
        }
        
    if (LOWORD(wParam) == 5){
    MessageBox(NULL, "This tutorial was created by www.lukechalaudio.com", "About", MB_OK);
    }

	   if (LOWORD(wParam) == 6) {
              PostQuitMessage(0);
	   }

	   break;
       }

      case WM_DESTROY:
      {
         PostQuitMessage(0);
         break;
      }
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}

Final Remarks:
With a little basic knowledge it starts becomes easy to trigger audio events from code. Since you have read the post you can now have the source code and files.
Download Source
I hope this helps with your current projects.

In order to start defining the resources to be included in the executable we must first start with the resource.h header. The purpose of this file is to define the resources as IDs and names. #define will help us with that. However in order to access these assets we must also add #ifdef RC_INVOAKED as well. This will allow the compiler to know where to find this information when it’s called upon. The source is provided below of resource.h.

resource.h

//Defines
#define IDW_SOUND1 1000
#define IDW_SOUND2 1001
#define IDW_SOUND3 1002
#define IDW_SOUND4 1003

//If these are invoked as resources load them
#ifdef RC_INVOKED
IDW_SOUND1 WAVE "sound1.wav"
IDW_SOUND2 WAVE "sound2.wav"
IDW_SOUND3 WAVE "sound3.wav"
IDW_SOUND4 WAVE "sound4.wav"
#endif

The next file we will need is the .rc file. These files are also known as resource scripts. This file gives the resource.h header the correct file path of the resources to be compiled into the final executable. Take note of the following code.

resource.rc

#include "resource.h"

//Define the files as IDW_SOUND! (resource name) and of type WAVE then filepath
IDW_SOUND1 WAVE "sound1.wav"
IDW_SOUND2 WAVE "sound2.wav"
IDW_SOUND3 WAVE "sound3.wav"
IDW_SOUND4 WAVE "sound4.wav"

This brings us to the main event or code I should say. The switch function will allow us to create specific events for each number from 1 to 5. The if statement which uses != (not equal to) and || (or) takes every other entry as invalid. The else statement at this point is for fun thus the sarcasm. The exit(0) function will allow us to exit the program when we wish.

main.cpp

#include <iostream>
#include <windows.h> 
#include "resource.h"

using namespace std;

int main(int argc, char *argv[])
{
    //Ask for input from 1 to 4 or 5 to exit and store in input var
    int input;
    cout << "Choose a sound from 1 to 4 or 5 to exit:";
    cin >> input;

    //If the input is 1 2 3 or 5...
    //This switch will execute the valid arguments in series
    switch (input)
    {
         //We will use the PlaySound function from windows.h and the linker must contain -lwinmm in DevC++
         case 1: PlaySound(MAKEINTRESOURCE(IDW_SOUND1), NULL, SND_RESOURCE | SND_ASYNC);
         cout << "Playing sound 1..." << endl;
         cout << "Press any key to exit" << endl;
         system("PAUSE>nul");
         exit(0);
         break;
         case 2: PlaySound(MAKEINTRESOURCE(IDW_SOUND2), NULL, SND_RESOURCE | SND_ASYNC);
         cout << "Playing sound 2..." << endl;
         cout << "Press any key to exit" << endl;
         system("PAUSE>nul");
         exit(0);
         break;
         case 3: PlaySound(MAKEINTRESOURCE(IDW_SOUND3), NULL, SND_RESOURCE | SND_ASYNC);
         cout << "Playing sound 3..." << endl;
         cout << "Press any key to exit" << endl;
         system("PAUSE>nul");
         exit(0);
         break;
         case 4: PlaySound(MAKEINTRESOURCE(IDW_SOUND4), NULL, SND_RESOURCE | SND_ASYNC);
         cout << "Playing sound 4..." << endl;
         cout << "Press any key to exit" << endl;
         system("PAUSE>nul");
         exit(0);
         break;
         case 5: exit(0);
         break;
    }
    if (input != (1 || 2 || 3 || 4 || 5))
    {
        cout << "You entered an invalid choice you know how to count from 1 to 5 right?" << endl;
        system("PAUSE>nul");
    }
    else
    {
        cout << "I don't know how you did it but you really screwed this one up!" << endl;
    }
    return 0;
}

IMPORTANT NOTE:
You MUST put -lwinmm (library for playsound) in the project settings -> paramaters / linker or DevC++ will think your a complete loser.

After you understand these concepts then you may download the source.
Download Source

Final Remarks:
I hope this helps you in your own projects. Some more programs to look into are resedit for generating the .h and .res file automatically for you and resource hacker for checking your work on the compiled executable. Hopefully soon I will be going over how to use this with an external API like irrKlang or the famous FMOD.

Tools of the trade:
Hex Converter (more advanced one)
Road Map (see part 1)
Hex Editor (see part 1)

Chunk Size:
This describes the size of whole file in bytes. Although you must subtract 8 bytes because ChunkID and Chunk Size are not included.
This chunk is 4 bytes in size and is read backwards. Thus if you have 24:08 you must put 08:24 in the hex converter returning 2084 bytes as the decimal value.

SubChunk1Size:
This is the size in bytes of the rest of the fmt subchunk in bytes excluding the 4 bytes the SubChunk1Size uses to describe this. Usually in a 16bit wav file this value will be 16 bytes.
Unlike Chunk Size this usually reads forwards.

Audio Format:
List of Compression Codes in mmreg.h
This is where the compression code for the audio file is decided. Use the list from the link above to get the value of the compression code you are looking for. Once you find the correct code then you must read on how to interpret the samples for the data chunk.
Remember to put this in your text editor.

Sample Rate:
The rate in hz in which samples are read. Usually CD quality will be 44:AC:00:00. Thus convert AC:44 to decimal and it returns 44.1Khz. This chunk uses 4 bytes.

Byte Rate:
This is just a calculated value done using the Sample Rate times the Number of Channels times Bits per Sample divided by 8. This is how many bytes per second.

Block Align:
The number of bytes for one sample but including all channels.
This chunk is 2 bytes in size.

SubChunk2Size:
This is the total number of bytes of the data chunk (the samples).
This is read just like SubChunk1Size.

Samples:
In a 16bit mono wav file it’s 2byes per sample and they are signed decimal values. There is an excellent converter for this on-line if you click the hex converter link from “Tools of the trade”. Once you arrive at the website click on the signed short 16bit converter button. Here you can now enter your hex values to return the sample value. So lets say for example you have a sample of 2bytes as 1E:F3 this is equal to 7923. Where -7923 is E1:0D in hex. In order to know the range of the samples you must figure out the sample range. This is determined by 2^n where n is the bit depth. This means 2 to the power of 16 bits equals 65536 increments of quantization. Since this is signed samples it will range from decimal values of −32768 to 32767 because we are starting from zero. The same method of mathematics can be applied to 24bit and 32bit as well except for 8bit audio files in which case are always unsigned only having 256 increments of quantization. This makes 16bit look like a huge technological improvement. Below is an image of what audio quantization looks like. This will show you what the analog signal looks like in comparison to the quantized digital portion.

Digital Audio Quantization (bit depth)

I could go into ideal sample rates based on the nyquist frequency principal but this I’ll leave for another post.

Final Remarks:
After looking at these principals step by step it becomes easy to identify how computers read every byte of wav file data. I hope that this will be useful to you now and in the future.

Hex editing is not as daunting as one may expect. It’s actually very logical the first thing you will need is a road map, hex editor, and of course the file that you are editing. When I refer to “road map” this is actually a list of address and what they mean. Kind of like “33 Wonder St., 5th floor”. In this example the street name is the filename, the street number 33 is the hex offset and the value is the 5 (the fifth floor level). The 33 Wonder St., 5th floor example may strike you as elementary but it will help later on.

The WAV filetype is a standard for storing audio data in chunks and subchunks using the RIFF (Resource Interchange File Format) format. The most common type of WAV file in audio is PCM (Pulse Code Modulation) and this is the type of file we will be editing today. If you don’t understand some of this terminology it’s okay this is more about doing then knowing really.. just trust me okay!

The Road Map:
HEX |DESCRIPTION
0000 |RIFF (in plain ASCII text)
0004 |Length of the entire file as a 32-bit unsigned integer
0008 |WAVE (in plain ASCII text)
000C |fmt[] (fmt[] in ASCII text denotes subchunk)
0010 |subchunk1size as a 32-bit unsigned integer
0032 |audio format 1=PCM
0016 |# of channels 1=1 2=2 (you can figure that out right?!)
0018 |Sample Rate!
001C |Byte Rate
0020 |Block Align
0022 |Bits/Sample
0024 |data (in plain ASCII text start of data subchunk)
0028 |Subchunk2Size
002C |First Sample (Left if 0016 = 2)
002E |Second Sample (Right if 0016 = 2)
REST OF DATA

Tools of the Trade:
Now that we have the road map we will need a few other tools to get us started please download and install the following:
Download Frhed
Download Audacity
Download testhex.wav

Step 1:
Open up testhex.wav with Frhed hex editor
 Notice how I have marked all these addresses out for you in RED!

Step 2:
Change the value of the first sample in the mono file to [6A 06]

Then save as testhex2.wav. In theory we have made the first sample equal to the second lets prove this now.

Step 3:
Open up Audacity and compare your testhex.wav to testhex2.wav and notice the following differences.
This should be a simple proof of concept that the theory presented to you in the beginning of this tutorial is correct.

Final Remarks:
To finally answer the question as posed in the first paragraph this will be useful for writing your own audio programs to edit waveforms but for the average audio geek this is great knowledge to help recover corrupt header files. If a header file is corrupt the audio program will not know how to read the data chunks and subchunks of the WAV file. With all this new knowledge you now have it’s possible to write the data in manually to fix corruptions (this can take days even months but I didn’t say it would be easy). I will be highlighting the different aspects of WAV headers and their functions in a future post.

Download MP3

Here is another massive vst pre-set you can download. This particular example uses an envelope to create a pitch slide on the oscillators. The choice of settings is closely related to the previous blog post called Dirty Dubstep Bass Massive VST Pre-set Download. I hope you will find this useful in your own mixes.

Pre-set Download

This particular example makes use “Modern Talking”, “Deep Throat”, and “Screamer” oscillator pre-sets. These all being oscillators 1, 2, and 3 respectively. This choice of oscillators was selected to get a vocal sound out of the synth. The resonant wt-positions were set so the sound hit different natural harmonics giving it a throat singing feel. In routing I changed the way in which the feedback loop is set up because I found the default settings to be a bit too aggressive not allowing for harmonics to show. The audio does max-out causing the tops of the waves to look like a square-waves but it clips rather nicely. All the other settings are self-explanatory once the pre-set is downloaded.

Hope you can enjoy some of this in your own mix!

You can download the patch and files here.

If you wish to record the audio created use the writesf~ object by clicking on “open temp.wav”  then “start”. To stop the recording to disc click “stop”.

I will have the podcast up and running soon. If you wish to test the podcast click on the podcast image in the side bar to bring up the feed page.