无码人妻少妇久久中文字幕 ,久久精品国产久精国产思思,久久久久久精品久久久久

ffmpeg av_seek_frame

ccsdu2009 — Thu, 19 Sep 2019 01:51:00 GMT

    int result = av_seek_frame(ffmpeg->formatCtx, -1,
        (ffmpeg->formatCtx->start_time + time) * AV_TIME_BASE,
        AVSEEK_FLAG_BACKWARD);

time单位为秒

ccsdu2009 2019-09-19 09:51 发表评论

ccsdu2009 — Thu, 10 Dec 2015 08:37:00 GMT

更新不多�Q�主要是取消了插接结构，把所有的�~�解码和��x��都合入了��d��
dll合计不超�q?M

支持常见音频格式和音效，使用��方便
下蝲在这�?/Files/gaimor/gaudio-sdk-2.2.1.0.zip

ccsdu2009 2015-12-10 16:37 发表评论

GAudio介绍

ccsdu2009 — Tue, 26 Nov 2013 11:53:00 GMT

gaudio是一个基于C/C++混合�~�程的跨�q�_��音频�?当前支持windows32/64操作�pȝ��和linux32位操作系�l?br />
当前性能:
1.最大支持音源同时播攄��格式-8
2.单音源最大挂载的��x��个数-8
3.全局最大可挂蝲的音效个�?8
4.当前支持语言C/C++/C#
5.当前支持的OS Win32/Win64/Linux32
6. 当前支持的音�?Fade in,Fade Out,Bassboost,Speed Changer,Echo,3D Effect, Doppler, Phaser, Channel Merget, Channel Swap, Fft, Distortion, Foldback Distortion, Modulator, AutoWah �{?br />7.当前支持的解码格�?- WAV, AU, AIFF, OGG, MOD,IT,XM,S3M,WV,MPC,WV,TTA,MP3,MIDI,FLAC
8.支持的编码格�?- WAV,AU,AIFF,OGG,MP2,MP3,FLAC,AAC,WV,VOC,CAF
9.支持的音频加载模�?- 文�g加蝲�Q�内存加载，虚拟文�g加蝲
10.支持PAN,环绕�?全音量，��x��音量讄��

下一步计�?
1.DEPHI�l�定
2.MAC OS支持
3.Flanger,Chorus��x��
4.TAK,AAC格式
5.故障处理

�q�景:
1.支持所有��^台和手持讑֤�
2.支持常见的所有音频格�?br />3.支持常见的所有音�?br />4.提高最易用最方便的API接口

一个��用的��例�?

/*
    GAudio 2.1.0.1, (C)2013 by Eric Du(E)
    This program is a part of the GAudio SDK.
    Use GAudio's echo effect
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include "gaudio.h"

int main(int argc,char* argv[])
{
    printf("echo created by D.Eric\n");

#if(defined(WIN32) || defined(WIN64))
    gaudio_init("addons");
#else
    gaudio_init("/usr/local/lib/gaudio/");
#endif

    const char* filename = "..\\media\\hurnscald.ogg";

    gsource* source = gaudio_source_create_from_file(filename,FALSE);
    if(source == NULL)
    {
        printf("load file:%s error!\n",filename);
        printf("bad source.\nerror code:%d.\n",gaudio_error_get());
        gaudio_deinit();
        return -1;
    }

    gaudio_source_set_int32(source,AUDIO_ENUM_LOOP,FALSE);
    printf("play filename:%s\n",filename);

    geffect* effect = gaudio_effect_create(AUDIO_EFFECT_ECHO,0);
    if(!effect)
    {
        printf("not support echo effect\n");
        gaudio_source_destroy(source);
        gaudio_deinit();
        return -1;
    }

    gaudio_effect_set_float(effect,AUDIO_EFFECT_ECHO_DELAY,1.0f);
    gaudio_effect_set_float(effect,AUDIO_EFFECT_ECHO_DECAY,0.6f);

    gaudio_effect_bind(effect,0);
    gaudio_source_play(source,FALSE);

    printf("\nplaying, press any key to quit.\n");
    getch();

    gaudio_effect_unbind(effect);
    gaudio_effect_destroy(effect);

    gaudio_source_stop(source);
    gaudio_source_destroy(source);

    gaudio_deinit();
    system("PAUSE");
    return EXIT_SUCCESS;
}

�q�个代表了我当前寚w��频这块的了解�E�度
下蝲在这�?download
�Ƣ迎提意见啊.

ccsdu2009 2013-11-26 19:53 发表评论

ccsdu2009 — Sun, 04 Aug 2013 04:12:00 GMT

直接上代�?

#include <stdio.h>
#include <ao/ao.h>
#include "mpg123.h"

int main(int argc, char *argv[])
{
    ao_initialize();

    mpg123_handle *mpg123 ;
    int iMpg123_error;
    if(MPG123_OK != (iMpg123_error = mpg123_init()))
    {
        printf("failed to init mpg123\n");
        return -1;
    }

    mpg123 = mpg123_new(mpg123_decoders()[0], &iMpg123_error);
    if(MPG123_OK != (iMpg123_error = mpg123_open(mpg123,argv[1])))
    {
        fprintf(stderr,"error in open mp3 file\n");
        return -1;
    }

    int rate,channel,encoding;
    mpg123_getformat(mpg123,&rate,&channel,&encoding);

    int default_driver = ao_default_driver_id();
    ao_sample_format format;
    memset(&format,0,sizeof(format));
    format.bits = 16;
    format.channels = channel;
    format.rate = rate;
    format.byte_format = AO_FMT_LITTLE;

    ao_device *device;
    device = ao_open_live(default_driver,&format,NULL);
    if(device == NULL)
    {
        fprintf(stderr,"error opening device.\n");
        return 1;
    }

    short buffer[4096];

    int read = 0;
    while(1)
    {
        mpg123_read(mpg123,buffer,4096,&read);
        if(read == 0)
            break;
        ao_play(device,buffer,read);
    }

    mpg123_close(mpg123);

    ao_close(device);
    ao_shutdown();
    return 0;
}

ccsdu2009 2013-08-04 12:12 发表评论

linux下��用oss播放音乐

ccsdu2009 — Fri, 19 Jul 2013 14:11:00 GMT

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <math.h>
#if defined(__OpenBSD__) || defined(__NetBSD__)
#include <soundcard.h>
#else
#include <sys/soundcard.h>
#endif
#include <sys/ioctl.h>
#include <sndfile.h>

#define BUFFER_LEN 4096

int _open_default_oss_device(char **dev_path,int id,int blocking);

int main(int argc,char *argv[])
{
    if(argc<2)
        return 0;

    SF_INFO info;
    SNDFILE* file = sf_open(argv[1],SFM_READ,&info);
    if(!file)
        return 0;

    printf("samplerate:%d\n",info.samplerate);
    printf("channel:%d\n",info.channels);

    char* dsp = NULL;
    int dp = _open_default_oss_device(&dsp,0,0);
    if(dp < 0)
    {
        printf("dsp:%d\n",dp);
        perror("oss bad:");
        sf_close(file);
      return -1;
    }
    int tmp = info.channels;
    int ret = ioctl(dp,SNDCTL_DSP_CHANNELS,&tmp);
    tmp = info.samplerate;
    ret = ioctl(dp,SNDCTL_DSP_SPEED,&tmp);
    tmp = AFMT_S16_LE;
    ioctl(dp,SNDCTL_DSP_SAMPLESIZE,&tmp);

    long  len = 0;
    short buffer[BUFFER_LEN];
    while((len=sf_read_short(file,buffer,BUFFER_LEN))!=0)
    {
        write(dp,(char*)buffer,len*2);
    }

    close(dp);
    sf_close(file);
    free(dsp);
    return 0;
}

int _open_default_oss_device(char **dev_path,int id,int blocking)
{
    int fd;
    char buf[80];

    if(id>0)
    {
        sprintf(buf,"/dev/sound/dsp%d",id);
        if(!(*dev_path = strdup(buf)))
            return -1;
    }
    else
    {
        if(!(*dev_path = strdup("/dev/sound/dsp")))
            return -1;
    }

#ifdef BROKEN_OSS
    fd = open(*dev_path, O_WRONLY | O_NONBLOCK);
#else
    fd = open(*dev_path, O_WRONLY);
#endif

    if(fd < 0)
    {
        free(*dev_path);
        if(id>0)
        {
            sprintf(buf,"/dev/dsp%d",id);
            if(!(*dev_path = strdup(buf)))
                return -1;
        }
        else
        {
            if(!(*dev_path = strdup("/dev/dsp")))
                return -1;
        }
#ifdef BROKEN_OSS
        fd = open(*dev_path, O_WRONLY | O_NONBLOCK);
#else
        fd = open(*dev_path, O_WRONLY);
#endif
    }

#ifdef BROKEN_OSS
    if(fd >= 0 && blocking)
    {
        if(fcntl(fd, F_SETFL, 0) < 0)
        {
            close(fd);
            fd = -1;
        }
    }
#endif
    if(fd < 0)
    {
        free(*dev_path);
        *dev_path = NULL;
    }
    return fd;
}

只是在的我的ubuntu13.0.4下执行执�?./text music.wav 会提�C�错�?�q�回-1 提示 no such directory
在网上搜有�h说需要加载snd_pcm_oss

modprobe snd_pcm_oss

可我加蝲的时候提�C?br />

FATAL: Module snd_pcm_oss not found.
谁知道这个如何弄�Q?br />
另外查了下可以加载alsa-oss
之后调用aoss ./text music.wav来播��N��?br />可以�q�个不是我要的，非命令行下不能加�q�个前缀

ccsdu2009 2013-07-19 22:11 发表评论

gaudio是一个基于C/C++混合�~�程的音频库~

ccsdu2009 — Thu, 11 Jul 2013 14:49:00 GMT

gaudio是一个基于C/C++混合�~�程的跨�q�_��音频�?当前支持windows32操作�pȝ��和linux32位操作系�l?br />
修改记录
1.2013.04.01
    初次发布
2.2013.04.10
    完成对wav格式采样频率8000-48000,采样格式4,8,16,24,32的支�?
3.2013.05.01
    a.版本提升�?.4.0.8
    b.修改一个退出异�?br />    c.支持二源混音
    d.使用载入插�g的方式提供对wav播放的支�?br />    e.增加对au格式的支�?br />    f.增加echo��x��
    g.增加bassboost��x��
    h.增加函数gaudio_address_get
    i.增加使用例子:echo/mixer/stream/boost
    j.把设�|?获取��x��三维�I�间信息的函数调整�ؓ: gaudio_source_set_float3,gaudio_source_get_float3
    k.修改解码器结构�ؓ回调模式
4.2013.05.10
    a.版本提升�?.6.8.0
    b.优化部分代码
    c.增加speedchanger��x��
    d.增加音频��{(g168)
    e.增加音频声道交换(g168)
    f.增加声道合�ƈ(g168)
    g.增加speedchanger/invert��试用例
    h.增加vc调用静态链接库libgaudio.lib
    i.增加调制��x��和测试例�?br />    j.修改解码器框�?br />    k.修改获取音频采样�~�码格式不正��的问题
    l.解决seek定位不准的问�?br />    m.增加��x��链测试例�?br />    n.增加函数gaudio_set_long,gaudio_get_long
    o.修改stream例子
    p.支持压羃mpc音频格式
    q.支持ogg/vorbis格式
    r.修改获取采样格式错误的bug
    t.增加接口说明文档
5.2013.06.10
    a.版本提升�?.7.2.0
    b.gaudio_source_set_error_callback回调函数增加��x��参数
    c.gaudio_source_set_finish_callback回调函数增加��x��参数
    d.�U�除gaudio_get_version函数
    e.gaudio_effect_setcallback函数调整为gaudio_effect_set_callback
    f.使用插�g式的音频驱动模式 - gwinmm
    g.gaudio代码优化
    h.增加音频源码率的获取
    i.增加feature范例
    j.完善文档
    k.增加对mp3的支�?br />    l.�U�除invert/modulator/bassboost例子
    m.增加balance
6.2013.07.07
    a.版本提升�?.8.0.2
    b.增加对交换文件aiff的支�?br />    c.修改音频驱动插�g实现
    d.增加�Uȝ��器音�?br />    e.修改部分API接口使用的long为int32_t以方便移�?br />    f.增加code::blocks��试工程
    g.增加msvc2008��试工程
    h.增加函数接口gaudio_source_create_from_buffer2以播放raw音频数据
    i.把各个音效参数提到单独文�?br />    j.��化wav解码
    k.修改几处内存泄漏
    l.增加音频回录功能,输出格式MP2,MP3,APE,WV,AAC,WAV,AU,AIFF,VOC,CAF,OGG
   当前录制信息:16位音�?双声�?采样频率44100
    m.增加音频回录的例子recorder
    n.��试例子使用getopt和usage提示
    o.增加对tta格式的支�?nbsp;
7.2013.07.28
    a.版本提升�?.9.8.6
    b.解决了wav,au,aiff播放�q�度不准的故�?
    c.优化wav/au/aiff解码性能
    d.增加distortion��x��
    e.增加foldback distortion��x��
    f.增加distortion��x��使用例子
    g.增加声音�I�K��力
    h.修改�l�构最大支持八声道
    i.增加portaudio插�g驱动(win32&linux)
    j.完成g168,bassbost的liux版本
    k.完成wav,au音频格式的linux版本
    l.代码增加部分注释(未完�?
    m.��试性支持linux操作�pȝ��
    n.支持midi/mid音乐格式
    o.解决了mixer混音退出报错的问题
p.skip id3v2

8.2013.08.16
    a.版本提升�?.0.0.1
    b.变量宏增加AUDIO_ENUM前缀
    c.增加非标准插件gsndfile支持flac/ogg/au/wav/aiff/voc/caf/..��Z��(sndfile)
    d.改用mpg123解码mp3
   e.支持FFT频谱

9.2013.09.08
    a.版本提升�?.0.6.0
    b.修改CROSSFEED宏和相关
   c.引入200��h��件支持s3m/mod/it/xm音频格式
   d.整理��试用例
   e.增加autowah��x��
   f.增加驱动��?br />10.2015.12.10 版本2.2.1.0

支持常见音频格式和音效，使用��方便
下蝲在这�?/Files/gaimor/gaudio-sdk-2.2.1.0.zip

ccsdu2009 2013-07-11 22:49 发表评论

ccsdu2009 — Sun, 09 Jun 2013 13:14:00 GMT

#include <stdio.h>
#include <string.h>
#include <ao/ao.h>
#include <libmad/mad.h>
#include <math.h>
#include <limits.h>

signed short to_short(mad_fixed_t fixed)
{
    if(fixed>=MAD_F_ONE)
        return(SHRT_MAX);
    if(fixed<=-MAD_F_ONE)
        return(-SHRT_MAX);
    fixed=fixed>>(MAD_F_FRACBITS-15);
    return((signed short)fixed);
}

unsigned char inputBuffer[4096 + MAD_BUFFER_GUARD];

class libMP3
{
public:
    libMP3(const char* filename)
    {
        file = fopen(filename,"rb");
        mad_stream_init(&stream);
        mad_frame_init(&frame);
        mad_synth_init(&synth);
        mad_timer_reset(&timer);
    }

    ~libMP3()
    {
        mad_synth_finish(&synth);
        mad_frame_finish(&frame);
        mad_stream_finish(&stream);
        fclose(file);
    }

    int setup()
    {
        size_t    remaining;
        unsigned char* read;

        if(stream.next_frame!=NULL)
        {
           remaining=stream.bufend-stream.next_frame;
           memmove(inputBuffer,stream.next_frame,remaining);
           read = inputBuffer+remaining;
           readsize = 4096-remaining;
        }
        else
           readsize = 4096,
        read = inputBuffer,
        remaining=0;

        readsize = fread(read,1,readsize,file);
        if(readsize<=0)
        {
           return -1;
        }

        mad_stream_buffer(&stream,inputBuffer,readsize+remaining);
        char dest[100];
        mad_timer_string(timer, dest, "%02lu:%02u:%02u", MAD_UNITS_HOURS, MAD_UNITS_MILLISECONDS, 0);
        stream.error=(mad_error)0;
        return 0;
    }
    long readFrame(unsigned char* pcm)
    {
        if(stream.buffer == NULL)
        {
           if(setup() == -1)
               return -1;
        }
    while(mad_frame_decode(&frame,&stream) != 0)
    {
        if(MAD_RECOVERABLE(stream.error))
        {
            if(stream.error!=MAD_ERROR_LOSTSYNC)
            {
            }
            continue;
        }
        else
            if(stream.error==MAD_ERROR_BUFLEN)
            {
                if (setup() == -1) return -1;
                continue;
            }
            else
            {
                return -1;
            }
    }
    mad_synth_frame(&synth,&frame);

    //! 获取频率
    //freq = synth.pcm.samplerate;

    //bitrate = frame.header.bitrate;
    //channels = (frame.header.mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2;

    mad_timer_add(&timer,frame.header.duration);
    int j = 0;

    for(int i=0;i<synth.pcm.length;i++)
    {
        signed short    sample;
        sample=to_short(synth.pcm.samples[0][i]);
        pcm[j++] = sample&0xff;
        pcm[j++] = sample>>8;
        if(MAD_NCHANNELS(&frame.header)==2)
            sample=to_short(synth.pcm.samples[1][i]);
        pcm[j++] = sample&0xff;
        pcm[j++] = sample>>8;
    }

    char dest[120];
    mad_timer_string(timer,dest, "%lu:%02lu.%03u", MAD_UNITS_MINUTES, MAD_UNITS_MILLISECONDS, 0);
    return j;
    }
private:
    struct mad_stream    stream;
    struct mad_frame    frame;
    struct mad_synth    synth;
    struct mad_header   header;
    mad_timer_t            timer;
    FILE* file;
    long readsize;
};

int main(int argc, char **argv)
{
    int rate = 44100;
    int channels = 2;

    unsigned char data[4096];
    ao_device *device;
    ao_sample_format format;
    int default_driver;
    ao_initialize();

    default_driver = ao_default_driver_id();
    memset(&format,0,sizeof(format));
    format.bits = 16;
    format.channels = channels;
    format.rate = rate;
    format.byte_format = AO_FMT_LITTLE;

    libMP3 mp3("我只在乎�?mp3");

    device = ao_open_live(default_driver,&format,NULL);
    if(device == NULL)
    {
        fprintf(stderr,"error opening device.\n");
        return 1;
    }

    long len = 0;
    unsigned char buffer[4096*2];
    while(len = mp3.readFrame(buffer))
    {
        ao_play(device,(char*)buffer,len);
    }

    ao_close(device);
    ao_shutdown();
    return (0);
}

ccsdu2009 2013-06-09 21:14 发表评论

ccsdu2009 — Sun, 02 Jun 2013 04:41:00 GMT

gaudio是一个��用最方便的音频播攑ֺ�

修改记录
1.2013.04.01
    初次发布
2.2013.04.10
    完成对wav格式采样频率8000-48000,采样格式4,8,16,24,32的支�?
3.2013.05.01
    a.版本提升�?.4.0.8
    b.修改一个退出异�?br />    c.支持二源混音
    d.使用载入插�g的方式提供对wav播放的支�?br />    e.增加对au格式的支�?br />    f.增加echo��x��
    g.增加bassboost��x��
    h.增加函数gaudio_address_get
    i.增加使用例子:echo/mixer/stream/boost
   j.把设�|?获取��x��三维�I�间信息的函数调整�ؓ: gaudio_source_set_float3,gaudio_source_get_float3
   k.修改解码器结构�ؓ回调模式
4.2013.05.10
    a.版本提升�?.6.8.0
    b.优化部分代码
    c.增加speedchanger��x��
   d.增加音频��{(g168)
   e.增加音频声道交换(g168)
   f.增加声道合�ƈ(g168)
   g.增加speedchanger/invert��试用例
   h.增加vc调用静态链接库libgaudio.lib
   i.增加调制��x��和测试例�?br />   j.修改解码器框�?br />   k.修改获取音频采样�~�码格式不正��的问题
   l.解决seek定位不准的问�?br />   m.增加��x��链测试例�?br />   n.增加函数gaudio_set_long,gaudio_get_long
   o.修改stream例子
   p.支持压羃mpc音频格式
   q.支持ogg/vorbis格式
    r.修改获取采样格式错误的bug
    t.增加接口说明文档
5.2013.06.01
    a.版本提升�?.7.2.0
    b.gaudio_source_set_error_callback回调函数增加��x��参数
   c.gaudio_source_set_finish_callback回调函数增加��x��参数
   d.�U�除gaudio_get_version函数
   e.gaudio_effect_setcallback函数调整为gaudio_effect_set_callback
   f.使用插�g式的音频驱动模式(gwinmm)以方便支持linux和mac
   g.gaudio代码优化
   h.增加音频源码率的获取
   i.修改gfeature范例
   j.完善文档

readmap
1.格式:对mp3的支�?br />2.��x��:立体声增�?br />3.处理故障/优化代码

target
1.支持常见音频格式
2.支持常见��x��
3.支持3D播放模式
4.最大支�?-8个音源同时播�?br />5.支持音频转换
6.支持录音
7.支持音频��化
8.跨��^�?nbsp;

ccsdu2009 2013-06-02 12:41 发表评论

WAVPACK音频�~�码

ccsdu2009 — Sat, 09 Feb 2013 10:57:00 GMT

To use the library to create WavPack files from raw PCM audio, the user must provide a WavpackBlockOutput function that is used by the library to write finished WavPack blocks to the output. Unlike the read case, there is no facility to write directly to named files. Here is the function required:

typedef int (*WavpackBlockOutput)(void *id, void *data, int32_t bcount);

where the "id" is used to differentiate the regular WavPack data "wv" from the correction data "wvc" (or for the case of multiple streams running at the same time). The return value is simply TRUE for success and FALSE for error. An example of this function can be found in wavpack.c called write_block().

The basic procedure for creating WavPack files is this:

1. get a context and set block output function with WavpackOpenFileOutput()
2. set the data format and specify modes with WavpackSetConfiguration()
3. optionally write a RIFF header with WavpackAddWrapper()
4. allocate buffers and prepare for packing with WavpackPackInit()
5. actually compress audio and write blocks with WavpackPackSamples()
6. flush final samples into blocks with WavpackFlushSamples()
7. optionally write MD5 sum with WavpackStoreMD5Sum()
8. optionally write RIFF trailer with WavpackAddWrapper()
9. if MD5 sum or RIFF trailer written, call WavpackFlushSamples() again
10. optionally append metadata tag with functions in next section
11. optionally update number of samples with WavpackUpdateNumSamples()
12. close the context with WavpackCloseFile()

Note that this does not show opening and closing the output files which is done by the application itself.

WavpackContext *WavpackOpenFileOutput (WavpackBlockOutput blockout,void *wv_id, void *wvc_id);
-----------------------------------------------------------------

Open context for writing WavPack files. The returned context pointer is used in all following calls to the library. The "blockout" function will be used to store the actual completed WavPack blocks and will be called with the id pointers containing user defined data (one for the wv file and one for the wvc file). A return value of NULL indicates that memory could not be allocated for the context.

int WavpackSetConfiguration (WavpackContext *wpc,WavpackConfig *config,uint32_t total_samples);
----------------------------------------------------

Set configuration for writing WavPack files. This must be done before sending any actual samples, however it is okay to send wrapper or other metadata before calling this. The "config" structure contains the following *required* information:

config->bytes_per_sample     see WavpackGetBytesPerSample() for info
config->bits_per_sample      see WavpackGetBitsPerSample() for info
config->channel_mask         Microsoft standard (mono = 4, stereo = 3)
config->num_channels         self evident
config->sample_rate          self evident

Be particularly careful with the "channel_mask" field. If this is not set to the correct value (3 or 4) then everything will still appear to work
correctly, but the resulting WavPack file will have undefined channel assignments. When this file is unpacked back to WAV it will then get a
WAVEFORMATEXTENSIBLE header which some programs refuse to recognize.

Specifying these 5 parameters alone would create a default lossless WavPack file, identical to the one produced by using the command-line program without options. For optional configuration, the following fields and flags may be set:

config->flags:
--------------
o CONFIG_HYBRID_FLAG         select hybrid mode (must set bitrate)
o CONFIG_JOINT_STEREO        select joint stereo (must set override also)
o CONFIG_JOINT_OVERRIDE      override default joint stereo selection
o CONFIG_HYBRID_SHAPE        select hybrid noise shaping (set override & shaping_weight != 0.0)
o CONFIG_SHAPE_OVERRIDE      override default hybrid noise shaping (set CONFIG_HYBRID_SHAPE and shaping_weight)
o CONFIG_DYNAMIC_SHAPING     force dynamic noise shaping even when WavPack
                               would not use it (no need to set any of the
                               other shaping flags when using this one)
o CONFIG_FAST_FLAG           "fast" compression mode (same as -f)
o CONFIG_HIGH_FLAG           "high" compression mode (same as -h)
o CONFIG_VERY_HIGH_FLAG      "very high" compression mode (same as -hh)
o CONFIG_BITRATE_KBPS        hybrid bitrate is kbps, not bits / sample
o CONFIG_CREATE_WVC          create correction file
o CONFIG_OPTIMIZE_WVC        maximize bybrid compression (same as -cc)
o CONFIG_CALC_NOISE          calc noise in hybrid mode
o CONFIG_EXTRA_MODE          extra processing mode (same as -x)
o CONFIG_SKIP_WVX            no wvx stream for floats & large ints (same as -p)
o CONFIG_MD5_CHECKSUM        specify if you plan to store MD5 signature (the sum is calculated by the application, NOT by the library)
o CONFIG_CREATE_EXE          specify if you plan to prepend sfx module
o CONFIG_OPTIMIZE_MONO       detect and optimize for mono files posing as
                               stereo (uses a more recent stream format that
                               is not compatible with decoders < 4.3)

config->bitrate              hybrid bitrate in either bits/sample or kbps
config->shaping_weight       hybrid noise shaping coefficient override
config->block_samples        force samples per WavPack block (0 = use default, else 1-131072)
config->float_norm_exp       select floating-point data (127 for +/-1.0)
config->xmode                extra mode processing value override (1-6)

If the number of samples to be written is known then it should be passed here.
If the duration is not known then pass -1. In the case that the size is not
known (or the writing is terminated early) then it is suggested that the
application retrieve the first block written and let the library update the
total samples indication. A function is provided to do this update and it
should be done to the "correction" file also. If this cannot be done (because
a pipe is being used, for instance) then a valid WavPack will still be created
(assuming the initial duration was set to -1), but when applications want to
access that file they will have to seek all the way to the end to determine the
actual duration (the library takes care of this). Also, if a RIFF header has
been included then it should be updated as well or the WavPack file will not be
directly unpackable to a valid wav file (although it will still be usable by
itself). A return of FALSE indicates an error (use WavpackGetErrorMessage() to
find out what happened).

int WavpackPackInit (WavpackContext *wpc);
-----------------------------------------

Prepare to actually pack samples by determining the size of the WavPack blocks
and allocating sample buffers and initializing each stream. Call after
WavpackSetConfiguration() and before WavpackPackSamples(). A return of FALSE
indicates an error.

int WavpackPackSamples (WavpackContext *wpc,
                          int32_t *sample_buffer,
                          uint32_t sample_count);
----------------------------------------------

Pack the specified samples. Samples must be stored in 32-bit longs in the
native endian format of the executing processor. The number of samples specified
indicates composite samples (sometimes called "frames"). So, the actual number
of data points would be this "sample_count" times the number of channels. Note
that samples are accumulated here until enough exist to create a complete
WavPack block (or several blocks for multichannel audio). If an application
wants to break a block at a specific sample, then it just calls
WavpackFlushSamples() to force an early termination. Completed WavPack blocks
are sent to the function provided in the initial call to
WavpackOpenFileOutput(). A return of FALSE indicates an error (which most likely
indicates the that user-supplied blockout function returned an error).

int WavpackFlushSamples (WavpackContext *wpc);
---------------------------------------------

Flush all accumulated samples into WavPack blocks. This is normally called after
all samples have been sent to WavpackPackSamples(), but can also be called to
terminate a WavPack block at a specific sample (in other words it is possible
to continue after this operation). This also must be called to dump non-audio
blocks like those holding metadata for MD5 sums or RIFF trailers. A return of
FALSE indicates an error.

void WavpackUpdateNumSamples (WavpackContext *wpc, void *first_block);
---------------------------------------------------------------------

Given the pointer to the first block written (to either a .wv or .wvc file),
update the block with the actual number of samples written. If the wav header
was generated by the library, then it is updated also. This should be done if
WavpackSetConfiguration() was called with an incorrect number of samples (or
-1). This should also be done in the case where the application did not provide
the RIFF header but did add some chunks for a RIFF trailer (see the section
on adding RIFF metadata). It is the responsibility of the application to read
and rewrite the block. An example of this can be found in the Audition filter
or in the command-line packer when the -i option is used. ON MACHINES WITH
ALIGNMENT REQUIREMENTS, BE SURE THAT THE PASSED POINTER IS PROPERLY ALIGNED!

int WavpackStoreMD5Sum (WavpackContext *wpc, uchar data [16]);
-------------------------------------------------------------

Store computed MD5 sum in WavPack metadata. Note that the user must compute the
16 byte sum; it is not done here. It is also required that WavpackFlushSamples()
be called after this to make sure the block containing the MD5 sum is actually
written. A return of FALSE indicates an error.

WavpackContext *WavpackCloseFile (WavpackContext *wpc);
------------------------------------------------------

Close the specified WavPack file and release all resources used by it.
Returns NULL.

With respect to the RIFF WAV wrapper that is inormally appended to the WavPack
file, there are three options available for the application to handle this.

The first is the simplest, and that is for the application to simply do
nothing. The library will automatically create a RIFF header appropriate for
the audio data (including WAVEFORMATEXTENSIBLE if needed) and store this
in the WavPack file. If the application does not know the actual number of
samples beforehand and needs to reread the first block and have the library
update it, then the library will handle updating its own RIFF header also.
In this scenario, there will be no trailing RIFF data. For the vast majority
of applications, this will be all that is required.

However, some applications may want to store a custom RIFF header (and trailer)
so that they can store extra RIFF chunks in there or perhaps they want to
create an exact copy of a .wav file (like the WavPack command-line program
does). To accomplish this, functions are provided (see below) to add RIFF
metadata to a WavPack file being written. In this case, the application must
provide a verbatim copy of all the RIFF data from the initial "RIFF" at the
beginning of the file up to (and including) the size field of the "data"
chunk. If any trailing RIFF data is desired, then this is appended after all
samples have been packed and flushed. This wrapper data will be *exactly*
what wvunpack will use to restore an original WAV file. In no circumstances
does the WavPack library parse, verify, or otherwise use this data.

If the RIFF header information needs to be updated after packing (because the
total file size or the data chunk size need to be update) then the first
block must be reread and the function WavpackGetWrapperLocation() must be
called to find the wrapper in the block (it would be possible to find it by
searching for the "RIFF", but using this function is significantly less ugly).
The WavPack library will not touch a wrapper that it did not create when
calling WavpackUpdateNumSamples().

The third option for including RIFF data chunks is a hybrid between these
two methods and is useful if an application wants to add a few specific RIFF
chunks and does not mind if the chunks appear at the end of the WAV file. In
this method, the application does not send any RIFF header before packing the
audio data which forces the library to create and store a standard RIFF header.
However, when all samples have been packed, the application sends the RIFF
chunks that it wants to add at the end of the file (RIFF trailer). Then, after
flushing, it must reread the first block and call WavpackUpdateNumSamples() so
that the library can update the RIFF header to reflect the added chunks (even
if the number of samples was correct). Because the library created the header,
it will update it, and will take into account the RIFF chunks added to the end.

All of this wrapper stuff can be a little confusing. It is a good idea to
test that the final application is working correctly and creating WavPack
files that will unpack to valid WAV files (even if the RIFF info is totally
wrong, the files will still work perfectly well as WavPack files because,
again, the RIFF wrapper is just informational). The first test is to use the
-ss option on WvUnpack to make sure the RIFF wrapper is reported correctly.
Then, unpack the WavPack file into a WAV using WvUnpack and repack it again
with the standard WavPack command-line program (without options). If it
doesn't complain about anything then there is a good chance that all the
wrapper information is valid.

Here are the appropriate functions:

int WavpackAddWrapper (WavpackContext *wpc, void *data, uint32_t bcount);
------------------------------------------------------------------------

Add wrapper (currently RIFF only) to WavPack blocks. This should be called
before sending any audio samples in the case of the RIFF header or after all
samples have been sent (and flushed) for any RIFF trailer. It is also
required that WavpackFlushSamples() be called again after specifying a RIFF
trailer to make sure it is actually written to the file.

If the exact contents of the RIFF header are not known because, for example,
the file duration is uncertain or trailing chunks are possible, simply write
a "dummy" header of the correct length. When all data has been written it
will be possible to read the first block written and update the header
directly. An example of this can be found in the Audition filter. A return of
FALSE indicates an error.

void *WavpackGetWrapperLocation (void *first_block, uint32_t *size);
-------------------------------------------------------------------

Given the pointer to the first block written to a WavPack file, this function
returns the location of the stored RIFF header that was originally written with
WavpackAddWrapper(). This would normally be used to update the wav header to
indicate that a different number of samples was actually written or if
additional RIFF chunks are written at the end of the file. The "size" parameter
can be set to non-NULL to obtain the exact size of the RIFF header, and the
function will return FALSE if the header is not found in the block's metadata
(or it is not a valid WavPack block). Note that the size of the RIFF header
cannot be changed and it is the responsibility of the application to read and
rewrite the block. An example of this can be found in the Audition filter.

******************************************************************************
*************************   5.0 TAGGING FUNCTIONS   **************************
******************************************************************************

The WavPack library contains rudimentary support to read and write metadata tags
on WavPack files. This includes creating new APEv2 tags during WavPack file
creation, reading text fields from both ID3v1 and APEv2 tags on existing
WavPack files, and editing data in APEv2 tags.

Users should be aware of the following limitations of this functionality:

1. ID3v1 tags are read-only, and cannot be accessed if there is an APEv2 tag
   prior to them in the file. ID3v1 tags are lost if the prior APEv2 tag is
   edited.

2. The text items in APEv2 tags are UTF-8 encoded. The functionality of
   converting to/from any local or multi-byte encoding must be handled by the
   calling application.

3. The binary items of APEv2 tags can now (version 4.60+) be read and written.
   To implement this in a backward-compatible way, the existing functions for
   accessing text tag items were simply duplicated as versions handling only
   binary tags items. The versions for text tag items work exactly as before
   (ignoring binary items) and the binary versions ignore text items.

   The convention for binary tag items in APEv2 tags is that the data starts
   with a NULL-terminated string representing a filename. After the terminating
   NULL, the actual binary data starts. In the WavPack code this filename has
   only the extension of the actual file; the name portion is made up of the
   tag item name. NOTE THAT THIS FUNCTIONALITY IS NOT HANDLED IN THE LIBRARY.
   THE LIBRARY ONLY STORES AND RETRIEVES A BINARY IMAGE AND IT IS UP TO THE
   CALLING APPLICATION TO APPEND AND HANDLE THIS FILENAME.

4. When APEv2 tags are edited and the resulting tags are shorter than the
   original tags, the tag is padded with zeros at the front rather than having
   the file shortened, and this padding cannot be reclaimed by future editing.
   The net result of this is that repeated editing of tags will cause the file
   to grow indefinitely (although this will only happen when the tag is
   actually made smaller).

In these descriptions the meaning of the word "tag" refers to the whole bundle
that is appended to the end of the WavPack file. This bundle may contain many
individual items, each consisting of a key/value pair. The key is referred to
here as the "item", meaning the item's name (like "artist"). Some people refer
to the individual items as "tags", but that usage is not used here. Also note
that APEv2 tags store the case of tag item names and values, but are not case
sensitive when locating tag item names (and this is carried here into the
lookup of ID3v1 tag item names).

int WavpackGetNumTagItems (WavpackContext *wpc);
int WavpackGetNumBinaryTagItems (WavpackContext *wpc);
------------------------------------------------------

Count and return the total number of tag items (either text or binary) in the
specified file. This works with either ID3v1 tags or APEv2 tags (although ID3V1
tags do not have binary items).

int WavpackGetTagItem (WavpackContext *wpc,
                         const char *item,
                         char *value,
                         int size);

int WavpackGetBinaryTagItem (WavpackContext *wpc,
                               const char *item,
                               char *value,
                               int size)
------------------------------------------------------------

Attempt to get the specified item from the specified file's ID3v1 or APEv2 tag.
The "size" parameter specifies the amount of space available at "value", if the
desired text item will not fit in this space then ellipses (...) will be
appended and the string terminated (binary tag data is simply truncated). The
actual length of the string (or binary data) is returned (or 0 if no matching
value found). Note that with APEv2 text tags the length might not be the same
as the number of characters because UTF-8 encoding is used. Also, APEv2 text
tags can have multiple (NULL separated) strings for a single value (this is why
the length is returned). If this function is called with a NULL "value" pointer
(or a zero "length") then only the actual length of the value data is returned
(not counting the terminating NULL of text tag items). This can be used to
determine the actual memory to be allocated beforehand.

For ID3v1 tags the only "item" names supported are "title", "artist", "album",
"year", "comment" and "track" (which is converted to numeric text by the
library).

int WavpackGetTagItemIndexed (WavpackContext *wpc,
                                int index,
                                char *item,
                                int size);

int WavpackGetBinaryTagItemIndexed (WavpackContext *wpc,
                                      int index,
                                      char *item,
                                      int size);
-------------------------------------------------

This function looks up the tag item name by index and is used when the
application wants to access all the items in the file's ID3v1 or APEv2 tag.
Note that this function accesses only the item's name; WavpackGetTagItem()
still must be called to get the actual value. The "size" parameter specifies
the amount of space available at "item", if the desired item will not fit in
this space then ellipses (...) will be appended and the string terminated.
The actual length of the string is returned (or 0 if no item exists for index).
If this function is called with a NULL "value" pointer (or a zero "length")
then only the actual length of the item name is returned (not counting the
terminating NULL). This can be used to determine the actual memory to be
allocated beforehand.

int WavpackAppendTagItem (WavpackContext *wpc,
                            const char *item,
                            const char *value,
                            int vsize);

int WavpackAppendBinaryTagItem (WavpackContext *wpc,
                                  const char *item,
                                  const char *value,
                                  int vsize);
---------------------------------------------

This function is used to append (or replace) the specified field to the tag
being created or edited. If no tag has been started, then an empty one will be
allocated first. When finished adding all the items to the tag, use
WavpackWriteTag() to write the completed tag to the file. Note that ID3 tags
are not supported. A size parameter is included so that text values containing
multiple (NULL separated) strings (and binary data) can be written. A FALSE
return indicates an error.

int WavpackDeleteTagItem (WavpackContext *wpc, const char *item);
----------------------------------------------------------------

Delete the specified tag item from the APEv2 tag being created or edited. This
function works with either text or binary fields. Returns TRUE to indicate that
an item was actually deleted from the tag.

int WavpackWriteTag (WavpackContext *wpc);
-----------------------------------------

Once a APEv2 tag has been created (or edited) using WavpackAppendTagItem()
(and WavpackDeleteTagItem()), this function is used to write the completed tag
to the end of the WavPack file. Note that this is NOT done for EACH item in the
tag, but only after ALL items have been added to the tag.

If this function is called when creating a WavPack file, then it uses the same
"blockout" function that is used to write regular WavPack blocks (and should be
called after flushing all the audio data and writing any WavPack metadata like
RIFF trailers and MD5 sums). It may call the blockout function multiple times
to write the tag.

If this function is called when editing an existing APEv2 tag, then it will
seek to the correct position and write the tag using the WavpackStreamReader
function that has been added for this purpose (write_bytes) or using its
own standard I/O functions (if the WavpackStreamReader is not being used).
Because there is not currently a method implemented to truncate an existing
file to a shorter length, this function will pad the file with 0's in front
of a tag that had been edited to a shorter length.

******************************************************************************
**********************   6.0 HANDLING WAVPACK STREAMS   **********************
******************************************************************************

In some applications (for example streaming applications and some filters, or
cases where WavPack data might be embedded into another multimedia container)
it is required for the audio file parsing functions to be separated from the
decoding functions. This is accomplished in two steps with the WavPack library.

First, the parsing functions are implemented outside the WavPack library. It is
very straightforward to parse WavPack files because the WavPack block header is
easy to recognize, and contains easy to parse and interpret information about
the block's contents and its relation to the whole WavPack file (or stream). The
exact file and block formats are described in detail in the file_format.txt
document. The wputils.c module also contains helper functions and a useful
seeking function that may also be useful in creating a WavPack parser.

Next, the individual parsed blocks are decoded to PCM audio by the library. To
accomplish this a "file" is opened with WavpackOpenFileInputEx() where the
specified WavpackStreamReader is a function that will feed the raw WavPack
block's bytes into the library when requested. The flags parameter should have
the OPEN_STREAMING bit set so that the decoder will ignore the position and any
other "whole file" information in the block headers. The decoder will suck up
the first block (through the stream reader) that actually contains audio and
stop, ready to decode. The next step is to call WavpackUnpackSamples() to
unpack the actual number of samples in the block (which should be known by the
parser).

Normally, the entire block would be unpacked and then the decoder would be
ready for the next block. If a single additional sample is requested past the
size of the current block the decoder will attempt to read the next block, so
it is important to request the exact number of samples (unless this behavior is
okay). If it is not desired to finish decoding the block then there are two
options. The easiest would be to simply decode the rest of the block anyway and
discard the results. Another option would be to close the context with the
function WavpackCloseFile() and then open another context when needed.

This procedure will also work fine for multichannel WavPack files. The decoder
will have to suck up all the blocks for the various channels before decoding may
begin.

******************************************************************************
**************************   7.0 ZIP FORMAT USAGE   **************************
******************************************************************************

With version 11.0, WinZip Computing has added WavPack Audio to the official ZIP
file format standard as compression method 97, as described here:

    http://www.winzip.com/ppmd_info.htm

The WavPack library can easily be used to create or decode the WavPack images
stored in the ZIP files. Some issues to keep in mind:

1. Only lossless mode is used. WinZip's implementation uses the "very high"
   mode with no extra processing, although there is no reason that a different
   profile could not be employed as they would still be fully compatible (for
   example, the new "high" mode and/or the new "extra" mode could be used).

2. All bitdepths (including 32-bit floating-point) are supported. However,
   bitdepths that are not multiples of 8 should be rounded up to the next
   multiple of 8 to ensure that all samples (even illegal ones) are encoded
   losslessly (this is described in more detail in the WinZip document).

3. Multichannel data (with or without WAVEFORMATEXTENSIBLE) is fully supported.

4. CONFIG_OPTIMIZE_MONO is not available during decoding and therefore should
   not be used for encoding.

5. The WavPack data must have RIFF headers (to generate .wav files) and may
   optionally have RIFF trailers. It would not be appropriate to have WavPack
   generate the RIFF headers (either during encode or decode) because of the
   obvious danger of generating files that don't match exactly.

6. The WavPack data should probably NOT have metadata tags or MD5 sums added
   to it. This information would be discarded during decoding anyway and could
   possibly trigger an error condition in a decoder.

The easiest way of using the WavPack library to decode the embedded WavPack
data would be to open a WavPack context using WavpackOpenFileInputEx() and
provide a WavpackStreamReader that would read the appropriate part of the
ZIP file by using an offset. If only the standard unpacking operations are
used, then the WavPack library will not attempt to seek during a decode. The
only flag to use for the "open" call would be OPEN_WRAPPER.

The most critical aspect of creating WavPack images to embed in ZIP files is
making sure that the decoded data will exactly match the source. This is in
contrast to the case of WavPack command-line programs where some invalid WAV
files may not encode (or exactly decode) for one reason or another. For this
reason it is important to check the parameters in the WAV header carefully and
allow only a well-defined set of known good combinations. The size of the audio
data should be checked to make sure it contains the correct number of whole
composite samples (or if it doesn't then this is properly handled). Since
WavPack cannot properly decode WavPack files that contain no audio data (i.e.
zero samples), this case should also be avoided. In all situations where some
question exists, the prudent choice would be to default to some other (more
genereralized) data compression method.

ccsdu2009 2013-02-09 18:57 发表评论

正确的ffmpeg链接�ơ序

ccsdu2009 — Sat, 29 Dec 2012 13:33:00 GMT

libavformat
libavcodec
libavutil

ccsdu2009 2012-12-29 21:33 发表评论

FFmpeg windows�q�_��~�译 - 转蝲

ccsdu2009 — Sat, 29 Dec 2012 11:53:00 GMT

FFmpeg是在Linux�q�_��下开发的�Q�但它同样也可以在其它操作系�l�环境中�~�译�q�行�Q�本文介�l�的��是在windowsXP下编译FFmpeg�?/span>
一准备环境�Q?/span>

1 下蝲 mingw �?MSYS

�?http://sourceforge.net/projects/mingw/ 下蝲

A 点击“DownLoad mingw-get-inst-...exe”�Q?/span>

B 切换到页面：download? Check your browser's security bar, or try a direct link, or try another mirror. �Q?/span>

C 点击“direct link”下蝲�c�M��Q�mingw-get-inst-20110802.exe 的文件�?/span>

提示�Q�msys此处��׃��用下载了�Q�mingw-get-inst-20110802.exe 中已�l�包含了msys1.0,后面安装的时候就可以看到该选项�?/span>

2 下蝲 yasm

ffmpeg�~�译里面的汇�~�代码需要yasm.exe

��d��|�：http://yasm.tortall.net/Download.html 下蝲

直接下蝲�Q�Win32 .exe (for general use on 32-bit Windows)

文�g名�ؓ�Q�yasm-1.1.0-win32.exe

3 下蝲 ffmpeg

ffmpeg可以�?http://www.ffmpeg.org/releases/ 下蝲

本�h选择的是最新版本：ffmpeg-0.8.5.tar.gz

文�g名�ؓ�Q�ffmpeg-0.8.5.tar.gz

4 下蝲 SDL

SDL下蝲可以刎ͼ�http://www.libsdl.org/download-1.2.php

选择�Q�SDL-1.2.14.tar.gz - GPG signed

此版本需要自��q��译，后面会解释�ؓ什么下载该版本�Q�而不下蝲�~�译好的SDL-devel-1.2.14-mingw32.tar.gz (Mingw32)

5 下蝲 pthreadGC2.dll
pthreadgc2.dll 是功能强大的处理数字化媄视作品编辑��Y件premiere6�q�行所需的一个DLL文�g。这是一个无威胁文�g。属于Open Source Software community project的文件。直接去baidu.com三搜索下载就可以了�?/span>

�?�~�译步骤

1 安装 mingw �?msys

    执行下蝲文�g�Q�mingw-get-inst-20110802.exe�Q?/span>

    在第3步选择“Download latest repository catalogues”

    选择安装路径�Q�C:\MinGW�Q�我直接采用默认路径�Q�未做修改）

    �?#8220;Select Components”步骤中选择�Q?/span>

    √ C Compiler (默认且一定选择)

    √ C++ Compiler

    √ MSYS Basic System�Q�选择此项��会安装msys�Q�msys则不需要另外安装）

    √ MinGW Developer ToolKit

    �{�待安装完成�Q�（需要等待一定的旉��Q�因为安装过�E�需要下载文�Ӟ��可想而知�Q�网速越快，安装��快�Q?/span>

    安装完成后，在C:\MinGW目录下可以看�?msys 文�g夹，msys也已�l�安装�?/span>

2 配置 msys.bat 批处理文�?/span>

    ��Z��方便VS200X以及VS2010调用ffmpeg的动态库�Q�可以通过配置让ffmpeg�~�译时��生windows下调用dll对应的lib�Q�当�Ӟ��如果你没有这个需要，那么��可以省略以下处理，直接�q�入步骤3�?/span>

    �q�入�Q�C:\MinGW\msys\1.0\文�g夹，使用UltraEdit打开msys.bat文�g�Q�在文�g的最最前面加入如下一行：

    call "D:\Program Files\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat"

    其中“D:\Program Files\Microsoft Visual Studio 10.0”��Z��机器上安装VS200X或VS2010的目录，我的电脑安装的是VS2010�Q��ƈ且安装在了D盘。文件修改后保存卛_��?/span>

3 配置 yasm

    ��Z��减少配置环境变量的麻烦，本处直接�?yasm-1.1.0-win32.exe 文�g名修�Ҏ��Q�yasm.exe�Q��ƈ攑ֈ��pȝ��目录下：C:\WINDOWS\system32�?/span>

4 解压ffmpeg �?SDL

    ffmpeg-0.8.5.tar.gz 的解压目录您可以直接选择�Q�本��压到�Q�D:\ffmpeg中，解压后目录�ؓ�Q�D:\ffmpeg\ffmpeg-0.8.5

    SDL-1.2.14.tar.tar 解压�?D:\ffmpeg\ffmpeg-0.8.5 目录下，解压后的目录�l�构为：D:\ffmpeg\ffmpeg-0.8.5\SDL-1.2.14

5 �~�译SDL

    双击“C:\MinGW\msys\1.0\msys.bat”�Q�启�?#8220;MinGW32”�Q?/span>

    切换到SDL目录�Q�D:\ffmpeg\ffmpeg-0.8.5\SDL-1.2.14�Q�切换方法如下：

    $ cd /d

    $ cd ffmpeg

    $ cd ffmpeg-0.8.5

    $ cd SDL-1.2.14

    再执行以下命令：

    $ ./configure --prefix=/usr 回�R�{�待…

    $ Make 回�R�{�待…

    $ make install 回�R�{�待…

    �~�译完成后，在C:\MinGW\msys\1.0的bin、include和lib文�g夹下可以看到�~�译�l�果�?/span>

    直接�~�译ffmpeg�Ӟ��发现未生成ffplay.exe�Q?/span>

    configure的时候提�C�Z��息如下：

    SDL support no

    所以需要开启SDL�Q�本人头天接触这东西�Q�不知道使用什么方法可以开启，但通过�~�译SDL�?/span>

    SDL support yes

    如果你的 SDL 已经是开启状态，你可以直接��用下载中提到的编译好的压�~�包SDL-devel-1.2.14-mingw32.tar.gz�Q�直接解压，�q�把解压包中�?bin、include和lib文�g夹中的文件复制到D:\ffmpeg\ffmpeg-0.8.5�Q�与步骤六相同，只是不在从C:\MinGW \msys\1.0中复制�?/span>

6 拯��~�译�l�果�Q?/span>

    C:\MinGW\msys\1.0 �?c:/mingw�?覆盖

    bin下的SDL.dll、sdl-config拯��?bin�?/span>

    include下的 SDL文�g�Ҏ��贝到 include�?/span>

    lib下的libSDL.a、libSDL.dll.a、libSDL.la和libSDLmain.a拯��?lib�?/span>

7 修改sdl-config配置文�g

    使用UltraEdit打开D:\ffmpeg\ffmpeg-0.8.5\bin下的 sdl-config文�g

    �?prefix=/usr 该成�Q?prefix=c:/mingw

    其中�Q�c:/mingw �?mingw的安装�\径，��h��据你的安装进行修攏V�?/span>

8 �~�译 ffmpeg

    双击“C:\MinGW\msys\1.0\msys.bat”�Q�启�?#8220;MinGW32”�Q?/span>

    切换到SDL目录�Q�D:\ffmpeg\ffmpeg-0.8.5\SDL-1.2.14�Q?/span>

    切换�Ҏ��如下�Q?/span>

    $ cd /d

    $ cd ffmpeg

    $ cd ffmpeg-0.8.5

    如果你的“MinGW32”没有关闭�Q�可以直接切换�\径到�Q�D:\ffmpeg\ffmpeg-0.8.5�?/span>

    再执行以下命令：

    $ ./configure --enable-shared --disable-static --enable-memalign-hack

误��心�{�待一�D�|��?/p>

$ make

   需要等待很长一�D�|��_��{�待�~�译�l�束�?/p>
    ��Z��汇�ȝ��译结果，��L��l�执行以下命令：

    $ make install

    �{�待完成�Q�在C:\MinGW\msys\1.0\local中将会生�?bin、include、lib�{�文件夹�Q�其中包含了ffmpeg.exe、ffplay.exe、ffprobe.exe、dll、lib和头文�g�{��?/span>

9 �q�行��试

直接双击�q�行”ffplay.exe”�Q�如果提�C�没�?#8220;pthreadGC2.dll”文�g�Q�你可以�?#8220;pthreadGC2.dll”直接拯��到当前目录，也可攑ֈ��pȝ��目录C:\WINDOWS\system32中�?/span>
avcodec.lib avformat.lib swscale.lib avutil.lib

ccsdu2009 2012-12-29 19:53 发表评论

音频混音

ccsdu2009 — Tue, 05 Jun 2012 11:15:00 GMT

�?�U�办�?br />�W�一�U�是
针对输入的数据n bite数据A,B比如short�c�d��

If both A and B are negative Y = A + B - (A * B / (-(2 pow(n-1) -1)))
Else Y = A + B - (A * B / (2 pow(n-1))
另外一�U�办法是采用旉��片交替的方式

ccsdu2009 2012-06-05 19:15 发表评论

ccsdu2009 — Tue, 20 Mar 2012 14:38:00 GMT

��单的例子如下:

#include <stdio.h>
#include <ao/ao.h>
#include <sndfile.h>
#include <math.h>

int main(int argc, char **argv)
{
    SNDFILE*    infile = 0;
    SF_INFO        sfinfo;
    int            readcount;

    int rate = 44100;
    int channels = 2;

    if(!(infile = sf_open("rock.wav",SFM_READ,&sfinfo)))
    {
        return  1 ;
    };

    rate = sfinfo.samplerate;
    printf("rate %d\n",rate);
    channels = sfinfo.channels;
    printf("channels %d\n",channels);
    printf("format %d\n",sfinfo.format);

    short data[4096];
    ao_device *device;
    ao_sample_format format;
    int default_driver;
    int i;

    ao_initialize();

    default_driver = ao_default_driver_id();
    memset(&format, 0, sizeof(format));
    format.bits = 16;
    format.channels = channels;
    format.rate = rate;
    format.byte_format = AO_FMT_LITTLE;

    device = ao_open_live(default_driver,&format, NULL);
    if(device == NULL)
    {
        fprintf(stderr,"error opening device.\n");
        return 1;
    }

    while((readcount = sf_read_short(infile,data,4096)))
    {
        ao_play(device,data,readcount*2);
    };

    sf_close (infile) ;
    ao_close(device);
    ao_shutdown();
    return (0);
}

ccsdu2009 2012-03-20 22:38 发表评论

��x��~�程:Echo��x��

ccsdu2009 — Thu, 12 May 2011 14:18:00 GMT

Echo是声音的反射�Q�是指�h直接听到声音之后�Q�其反射韛_��被听到�?br>一个真正意义上的Echo是单反射的。其旉��间隔��是声音的速率

很显然一般的Echo��h��2个参�?br>一个是延迟�Q�一个是衰减

在某一时刻�Q��h听到的声��x��此时��x��声音和�g�q�前��x��声音的�؜合音�?br>昄��一个简单的表达式是:

data+=data_prev*decay

�q�就是Echo��x��基本的函数表辑ּ�

�q�是�W�四��关于音效处理的文档
其他�c�M��x��不打��再写了

需要说的就�?实际�~�程�q�没有想象中的那么复�?

在音频这块喔已经做完�?br>1.acc格式�~�解�?br>2.wma�~�解�?br>3.fadein,fadeout,echo,reverb�{�音效算�?br>4.音频频谱分析
5.EQ讄��

有空整理下哈

ccsdu2009 2011-05-12 22:18 发表评论

��x��~�程(3)-FadeOut和FadeIn��x��

ccsdu2009 — Tue, 10 May 2011 15:14:00 GMT

�q�是��x��p�d��~�程之三:FadeOut和FadeIn��x��

二者都分别控制音乐的��E出和淡入

解释下��E出效果的含义:��在是音乐播攑֍��结束之前通过一定的手法控制音乐响度-直至�l�束�?br>
很显�Ӟ��使用�U�性关�p�d��本可以达到目�?br>假定数据关系为y = kx + b;
另外需要控制��E出的坡度,或者直接说需要知道从�l�束之前多少个数据开始需要��用FadeOut��x��。所以我们需要一个参数len�?br>假定我们使用下列的一句话��法来说明问�?

for(int i = 0; i != len ;i++)
bufer[i]*= (a-i)*b;

其中a,b为待定参�?br>因�ؓ有一个前�?当i = len-1的时候buffer[len-1] = 0;
所以有a=len-1
另外当fadeout发挥作用之前buffer数据�q�未变化�Q�故�?br>b=(len-1)
故基本的Fadeout核心��法��是一�?

y=y*(1-t/k)

��单吧�?br>理所当然
基本的FadeIn核心��法��是

y*=(t/k-1)

虽然在具体场合，��法有所变�Ş�Q�但是基本的原理��是�q�个样子

PS:基本的函数关�p�虽然简单，但是比较实用

以后有空�q�会讲Echo,Reverb,Treble Booster,Compressor,High Filter�{�音效原�?br>。只是研�I��效的同志们不多。没的讨�?br>

ccsdu2009 2011-05-10 23:14 发表评论

��x��~�程�?Tremolo��x��

ccsdu2009 — Tue, 26 Apr 2011 14:42:00 GMT

接上�?
Tremolo��x��比较��L��x��Q�听上去感觉是��用电子乐器演�C�的�?br>从感官上��Tremolo(颤音)��x��是重��M��个音�W�然后快速提高，减小音量

下面是颤音音效的几个参数:
1.深度控制:用来控制音量增减速度
2.阈值数�?说明控制音量的频率�?br>3.波�Ş

其基本数学表辑ּ��?

data = data * (1.0 + depth * sin(k* rate * index));

��易的c++代码如下:

class Tremolo : public AudioEffect
{
public:
    static double def_depth;
    static double def_rate;
    double depth;
    double rate;
    double k;
    Tremole();
    std::vector<float> Filter(const std::vector<float>& _data)
    {
        data = _data;
        for(int i = 0; i < data.size();i++)
           data[i] *= (1.0 + depth * sin(2.0 * PI * rate * i / k);
        return data;
    }
};

当然有java版本的化应该是如下这个样�?

public class Tremolo extends AudioEffect
{
    private static double final def_depth = ;
    private static double final def_rate = ;
    private double depth = def_depth;
    private double rate = def_rate;
    Tremolo()
    {

    }

    double[] Filter(double[] _data)
    {
        int len = _data.length;
        double[] ret = new double[len];
        for(int i = 0;i<len;i++)
            ret[i] = _data[i]*(1+depth*Math.Sin(2*Math.PI*rate*i/k));
        return ret;
    }
}

基本的源码就�q�个样子
不过有一个问题就是播��N��效有��许杂音-不过不是大问�?

ccsdu2009 2011-04-26 22:42 发表评论

��x��~�程(1)-Distortion��x��

ccsdu2009 — Mon, 25 Apr 2011 14:48:00 GMT

之前做的音频API都是使用的第三方的库或者代�?br>不过�q�段旉��一直比较忙
没什么时间来玩玩音频引擎�?br>
不过��Z��不至于本博客长草
我就整理下以前接触过的音频处理这块吧

首先上一个简单的��x��基类�?/p>

class AudioEffect
{
public:
   virtual ~AudioEffect(){}
   virtual std::vector<float> Filter(const std::vector<float>& data) = 0;
protected:
   std::vector<float> data;
};

通过调用Filter��可以获取给定pcm处理后的��x��数据

然后再谈下什么是Distortion��x��
Distortion主要使用于电吉他�{�电子类乐器�Q?br>
Distortion��x��主要有以下参�?
1.edge 临界�?br>2.gain 增益
3.低通剪切�?当然�q�有其他几个参数,...)

其简易化的音效处理原则就�?br>使用使用�l�定临界值对原有数据做Clamp处理

��单的例子如下:

#define DISTORTION_RATE 100.0
#define DISTORTION_THRESHOLD 0.4

class Distortion : public AudioEffect
{
public:
    Distortion()
    {
        gain = DISTORTION_RATE;
        value = DISTORTION_THRESHOLD;
    }
    std::vector<float> Filter(const std::vector<float>& data_)
    {
       this->data.clear();
       for(int i = 0; i < data_.size(); i++)
       {
           float v = data_[i]*gain;
           if(v > value)
               v = value;
           if(v < - value)
               v = -value;
           data.push_back(v);
       }
       reutrn data;
    }
private:
    float gain;
    float value;
};

看上��M��乎很��?br>
那处理后的音效如�? 试试��q��道了

接下来还有reverb,ring,echo,chorus�{�音效算法和音频傅里叶变换等
�{�弄完了�q�些�Q�音频引擎也��p��升��?我早已构思好了下个版本的音频API功能�?

下篇tremolo��x��

ccsdu2009 2011-04-25 22:48 发表评论