调用CImg库显示WAV格式音频波形

最近在做傅里叶变换和小波变换时经常要通过显示波形来检验算法，但通过visual studio之类显示波形又显得麻烦，而且不能跨平台。

CImg是一个跨平台的C++的图像处理库，提供的图像处理等功能十分强大，而且加入项目中十分轻便，只需将头文件包含在项目中即可，十分轻便。

可自行到http://www.cimg.eu/下载

利用它来在linux、Mac OS X中显示波形，再合适不过了，下面是音频波形显示的代码。

主函数

main.cpp

#include <iostream>
#include "wavfile.h"
#include "CImg.h"

using namespace std;
using namespace cimg_library;
using namespace AudioUtils;

int main(void)
{
    WaveFile *wf=new WaveFile();
    /*
    读取本目录里的audio.wav文件，并生成波形
    */
    wf->readwav("audio.wav");

    int datalength=wf->size()/wf->bit();

    wf->output_WAVfile_info();

    int *data=(int*)malloc(sizeof(int)*datalength);
    for(int i=0;i<datalength;i++)
    {
        data[i]=(float)(wf->data[i]/100);
    }
    /*
    调用CImg显示波形
    */
    const unsigned char red[] = { 255, 0, 0 }, yellow[] = { 255, 255, 0 },
    green[] = { 0, 255, 0 };
    /*
    一维信号
    */
    int num=wf->size()/(8*(wf->bit()));
    CImg<float> signal_wav(num,1, 1, 1, 0);
    for(int i=0;i<num;i++)
    {
        signal_wav[i]=(data[i*8])*100;
    }

    CImg<unsigned char> signal_visu( 1200, 400, 1, 3, 0 );
   /*
   画格子
   */
    signal_visu.draw_grid( 50, 50, 0, 0, 0, 0, yellow, 0.5 );

    signal_visu.draw_graph(signal_wav,red,1,3,0,35000,-35000,0);
    /*
    画波形
    */
    CImgDisplay main_disp_wav (signal_visu,  "signal" );

    getchar();

    return 0;
} 

wavfile.h

读取WAV格式文件

#ifndef WAVFILE_H
#define WAVFILE_H
#include <iostream>
#include <fstream>
using namespace std;

/*
BYTE=unsigned char(完全等同)         WORD=unsigned short(完全等同)         DWORD=unsigned long(完全等同)

unsigned char是无符号字节型
*/
namespace AudioUtils
{
    /*
    RIFF WAVE Chunk
    ==================================
    |       |所占字节数|  具体内容   |
    ==================================
    | ID    |  4 Bytes |   'RIFF'    |
    ----------------------------------
    | Size  |  4 Bytes |             |
    ----------------------------------
    | Type  |  4 Bytes |   'WAVE'    |
    ----------------------------------
    

    */
    class RiffBlock
    {
    public:
        void ReadRiff(ifstream &infile)
        {
            int i=0;
            for(i=0;i<4;i++)
            {
                infile.read((char*)&m_RiffID[i],1);
            }
            infile.read((char*)&m_RiffSize,4);
            for(i=0;i<4;i++)
            {
                infile.read((char*)&Format[i],1);
            }
        }

        /*
        此处应当声明为pravte 用函数return, 不安全代码，暂简略处理
        */
        unsigned char m_RiffID[4];
        unsigned long m_RiffSize;
        unsigned char Format[4];
    };
    /*
    ====================================================================
    |               |   字节数  |              具体内容                |
    ====================================================================
    | ID            |  4 Bytes  |   'fmt '                             |
    --------------------------------------------------------------------
    | Size          |  4 Bytes  | 数值为16或18，18则最后又附加信息     |
    --------------------------------------------------------------------  ----
    | FormatTag     |  2 Bytes  | 编码方式，一般为0x0001               |     |
    --------------------------------------------------------------------     |
    | Channels      |  2 Bytes  | 声道数目，1--单声道；2--双声道       |     |
    --------------------------------------------------------------------     |
    | SamplesPerSec |  4 Bytes  | 采样频率                             |     |
    --------------------------------------------------------------------     |
    | AvgBytesPerSec|  4 Bytes  | 每秒所需字节数                       |     |===> WAVE_FORMAT
    --------------------------------------------------------------------     |
    | BlockAlign    |  2 Bytes  | 数据块对齐单位(每个采样需要的字节数) |     |
    --------------------------------------------------------------------     |
    | BitsPerSample |  2 Bytes  | 每个采样需要的bit数                  |     |
    --------------------------------------------------------------------     |
    |               |  2 Bytes  | 附加信息（可选，通过Size来判断有无） |     |
    --------------------------------------------------------------------  ----

    */
    class FmtBlock
    {
    public:
        //seekg()移动文件指针
        void ReadFmt(ifstream &infile)
        {
            int i=0;
            for(i=0;i<4;i++)
            {
                infile.read((char*)&m_FmtID[i],1);
            }
            infile.read((char*)&m_FmtSize,4);
            int size=m_FmtSize;
            infile.read((char*)&m_FmtTag,2);
            infile.read((char*)&m_Channels,2);
            infile.read((char*)&m_SamplesPerSec,4);
            infile.read((char*)&m_AverageBytesPerSec,4);
            infile.read((char*)&m_BlockAlign,2);
            infile.read((char*)&m_BitsPerSample,2);
            if(size==18)
            {
                infile.read((char*)&m_OtherMeg,2);
            }
        }
        
        int BitsPerSample()
        {
            return (m_BitsPerSample/8);
        }
    
        unsigned char m_FmtID[4];
        unsigned long m_FmtSize;
        unsigned short m_FmtTag;
        unsigned short m_Channels;
        unsigned long m_SamplesPerSec;
        unsigned long m_AverageBytesPerSec;
        unsigned short m_BlockAlign;
        unsigned short m_BitsPerSample;
        unsigned short m_OtherMeg;
    };

    /*
    Data Chunk
    ==================================
    |       |所占字节数|  具体内容   |
    ==================================
    | ID    |  4 Bytes |   'data'    |
    ----------------------------------
    | Size  |  4 Bytes |             |
    ----------------------------------
    | data  |          |             |
    ----------------------------------

    1Bytes
    ---------------------------------------------------------------------
    |   单声道    |    取样1    |    取样2    |    取样3    |    取样4    |
    |                   |  --------------------------------------------------------
    |  8bit量化 |    声道0    |    声道0    |    声道0    |    声道0    |
    ---------------------------------------------------------------------
    |   双声道    |          取样1                      |           取样2                      |
    |                   |--------------------------------------------------------
    |  8bit量化 |  声道0(左)  |  声道1(右)  |  声道0(左)  |  声道1(右)  |
   1WORD
   ---------------------------------------------------------------------
    |                    |          取样1                        |           取样2                       |
    |   单声道     |--------------------------------------------------------
    | 16bit量化 |    声道0       |  声道0          |    声道0       |  声道0          |
    |                    | (低位字节)  | (高位字节)  | (低位字节)  | (高位字节)   |
    ---------------------------------------------------------------------
    |                    |                         取样1                                                       |
    |   双声道     |--------------------------------------------------------
    | 16bit量化 |  声道0(左)    |  声道0(左)  |  声道1(右)   |  声道1(右)   |
    |                     | (低位字节)  | (高位字节)  | (低位字节)  | (高位字节)  |
    ---------------------------------------------------------------------

    */
    class DataBlock
    {
    public:
        void ReadData(ifstream &infile,int BitsPerSample)//BitsPerSample:1 8bit;2 16bit
        {
            int i=0;

            bool un_find_data=true;
            while(un_find_data)
            {
                infile.read((char*)&temp,1);
                if(temp=='d')
                {
                    infile.read((char*)&temp,1);
                    if(temp=='a')
                    {
                        infile.read((char*)&temp,1);
                        if(temp=='t')
                        {
                            infile.read((char*)&temp,1);
                            if(temp=='a')
                            {
                                un_find_data=false;
                            }
                        }
                    }

                }
            }

            infile.read((char*)&m_DataSize,4);
            m_NumSamples=m_DataSize/BitsPerSample;
            if(BitsPerSample==1)
            {
              m_Data8=new char[m_NumSamples];
              for(i=0;i<m_NumSamples;i++)
              {
                infile.read((char*)&m_Data8[i],BitsPerSample);
              }
            }
            else if(BitsPerSample==2)
            {
              m_Data16=new short[m_NumSamples];
              for(i=0;i<m_NumSamples;i++)
              {
                infile.read((char*)&m_Data16[i],BitsPerSample);
              }
            }
            
            
        }
        
        short *m_Data16;
        char *m_Data8;

        unsigned char temp;
        unsigned char m_DataID[4];
        unsigned long m_DataSize;
        
        
        int    m_NumSamples;//样本数量
    };
    class WaveFile
    {
    public:
        void readwav(char *path)
        {
            ifstream infile(path,ios::binary);
            m_Riff = new RiffBlock();
            m_Fmt = new FmtBlock();
            m_Data = new DataBlock();

            m_Riff->ReadRiff(infile);
            m_Fmt->ReadFmt(infile);
            m_Data->ReadData(infile,m_Fmt->BitsPerSample());
            int i=0;
            data=new int[m_Data->m_DataSize/m_Fmt->BitsPerSample()];
            for(i=0;i<(m_Data->m_DataSize)/(m_Fmt->BitsPerSample());i++)
            {
                
                if(m_Fmt->BitsPerSample()==1)
                {
                   data[i]=(int)m_Data->m_Data8[i];
                }
                else if(m_Fmt->BitsPerSample()==2)
                {
                   data[i]=(int)m_Data->m_Data16[i];
                }
            }
            
        }
        
        
        void output_WAVfile_info(void)//test
        {
            cout<<"Audio Msg:"<<endl;
            /*
            RIFF WAVE Chunk Message
            */
            cout<<m_Riff->m_RiffID<<endl;
            cout<<m_Riff->m_RiffSize<<endl;
            cout<<m_Riff->Format<<endl;

            /*
            Fmt Message
            */
            cout<<m_Fmt->m_FmtID<<endl;
            cout<<m_Fmt->m_FmtSize<<endl;
            cout<<m_Fmt->m_FmtTag<<endl;
            cout<<m_Fmt->m_Channels<<endl;
            cout<<m_Fmt->m_SamplesPerSec<<endl;
            cout<<m_Fmt->m_AverageBytesPerSec<<endl;
            cout<<m_Fmt->m_BlockAlign<<endl;
            cout<<m_Fmt->m_BitsPerSample<<endl;
            cout<<m_Fmt->m_OtherMeg<<endl;
            /*
            Data Chunk Message
            */
            cout<<m_Data->temp<<endl;
            cout<<m_Data->m_DataID<<endl;
            cout<<m_Data->m_DataSize<<endl;

        }
        int size(void)//音频长度
        {
            return m_Data->m_DataSize;
        }
        int channels(void)
        {
            return m_Fmt->m_Channels;
        }
        int bit(void)
        {
            return m_Fmt->BitsPerSample();
        }
        int *data;
    private: 
         RiffBlock            *m_Riff;
         FmtBlock            *m_Fmt;
         DataBlock            *m_Data;
    };
}

#endif

编译时运行如下命令：

g++ -o out main.cpp -O2 -lm -lpthread -L/usr/X11R6/lib -lm -lpthread -lX11

结果：