OpenAL播放pcm或wav数据流-windows/ios/android(一)

OpenAL播放pcm或wav数据流-windows/iOS/Android(一)

 

最近在研究渲染问题，本文采用openal做pcm和wav数据流播放，并非本地文件，demo是windows的，ios通用。网上都是ios的，ios需要引用OpenAl.framework框架,

Android平台需要做openal的jni,android的openal库可以参考

http://blog.csdn.NET/matrix_laboratory/article/details/53319735这篇文章,各个平台需要做稍微处理。

下面是代码：

//.h

 

[cpp] view plain copy

 
 

  1. /** Copyright (c/c++) <2016.11.22> <zwg/> 
  2. * Function   
  3. * OpenAL through the buffer queuing mechanism to support the streaming playback of sound. The buffer queue is a buffer associated with a single source contact mechanism. 
  4. * when audio playback, continuous rendering of each buffer, as if the buffer is composed of a continuous sound. This can be controlled by some special functions. 
  5. * flow is generally the source of the work. In a number of audio buffer by alSourceQueueBuffers () function to queue, and then play the sound source, 
  6. * next with property AL_BUFFERS_PROCESSED to query. This property obtains the number of buffers that have been processed, 
  7. * allows applications to use the alSourceUnqueueBuffers () function to delete the buffers that have been processed. 
  8. * alSourceUnqueueBuffers () function will start from the queue header will be processed in order to remove the buffer. Finally, the rest of the buffer queue in gear. 
  9. * Opanal for audio rendering related implementation and definition, etc. 
  10. * OpenAL通过缓冲器排队机制支持声音的流式播放。缓冲器排队是多个缓冲器与单一音源相关联的一种机制。 
  11. * 当音源播放时，连续对各个缓冲器进行渲染，就好象这些缓冲器组成了一个连续的声音。这可以通过一些特殊函数来控制。 
  12. * 流音源的工作一般是这样的。音源里的一批缓冲器通过alSourceQueueBuffers()函数进行排队，然后播放音源， 
  13. * 接下来用属性AL_BUFFERS_PROCESSED来查询。该属性得出已经处理好的缓冲器的数量， 
  14. * 从而允许应用程序使用alSourceUnqueueBuffers()函数删除那些已经处理好的缓冲器。 
  15. * alSourceUnqueueBuffers()函数将从队列头部开始依次将处理好的缓冲器删除。最后，其余的缓冲器在音源上排队。 
  16. * OpanAl 用于音频渲染相关实现及定义，等 
  17. */  
  18.   
  19. #ifndef __LVS_OPENAL_INTERFACE_H__  
  20. #define __LVS_OPENAL_INTERFACE_H__  
  21.   
  22. #include <stdio.h>  
  23. #include <stdlib.h>  
  24. #include <string>  
  25.   
  26. //windows  
  27. #ifdef WIN32  
  28. #include <Windows.h>  
  29. //openAl库  
  30. #include "alut.h"  
  31. #pragma comment(lib,"alut.lib")  
  32. #pragma comment(lib,"OpenAL32.lib")  
  33. //ios  
  34. #elif __APPLE__  
  35. #include "alut.h"  
  36. //ANDROID平台    
  37. #elif __ANDROID__    
  38. #include "alut.h"  
  39. //linux  
  40. #else  
  41. #include "alut.h"  
  42. #endif  
  43.   
  44. //到处宏定义  
  45. //windows  
  46. #ifdef WIN32  
  47. #define LVS_DLLEXPORT __declspec(dllexport)  
  48. //ios  
  49. #elif __APPLE__  
  50. #define LVS_DLLEXPORT  
  51. //linux  
  52. #else  
  53. #define LVS_DLLEXPORT  
  54. #endif  
  55.   
  56. using namespace std;  
  57.   
  58. //接口初始化  
  59. int lvs_openal_interface_init();  
  60. //接口释放  
  61. void lvs_openal_interface_uninit();  
  62. //接口开始播放  
  63. void lvs_openal_interface_playsound();  
  64. //接口停止播放  
  65. void lvs_openal_interface_stopsound();  
  66. //接口设置音量  
  67. void lvs_openal_interface_setvolume(float volume);//volume取值范围(0~1)  
  68. //接口获取音量  
  69. float lvs_openal_interface_getvolume();  
  70. //接口传入pcm数据用于播放  
  71. int lvs_openal_interface_openaudiofromqueue(char* data,int dataSize,int aSampleRate,int aBit ,int aChannel);  
  72. //更新队列数据，删除已经播放的buffer,这个在队列满的时候用  
  73. int lvs_openal_interface_updataQueueBuffer();  
  74. //获取当前时间戳  
  75. long long lvs_openal_interface_getrealpts();  
  76. //获取已经播放了多少个数据块  
  77. long long lvs_openal_interface_getIsplayBufferSize();  
  78. //获取缓存队列长度  
  79. int lvs_openal_getnumqueuedsize();  
  80.   
  81. class cclass_openal_interface;  
  82.   
  83. class cclass_openal_interface  
  84. {  
  85. public:  
  86.     cclass_openal_interface();  
  87.     virtual ~cclass_openal_interface();  
  88.     //开始播放  
  89.     void playSound();  
  90.     //停止播放  
  91.     void stopSound();  
  92.     //设置音量  
  93.     void SetVolume(float volume);//volume取值范围(0~1)  
  94.     //获取音量  
  95.     float GetVolume();  
  96.     //传入pcm数据用于播放  
  97.     int openAudioFromQueue(char* data,int dataSize,int aSampleRate,int aBit ,int aChannel);  
  98.     //更新队列数据，删除已经播放的buffer  
  99.     int updataQueueBuffer();  
  100. private:  
  101.     //初始化openal  
  102.     int initOpenAL();  
  103.     //释放openal  
  104.     void cleanUpOpenAL();  
  105. public:  
  106.     int m_numprocessed;             //队列中已经播放过的数量  
  107.     int m_numqueued;                //队列中缓冲队列数量  
  108.     long long m_IsplayBufferSize;   //已经播放了多少个音频缓存数目  
  109.     double m_oneframeduration;      //一帧音频数据持续时间(ms)  
  110.     float m_volume;                 //当前音量volume取值范围(0~1)  
  111.     int m_samplerate;               //采样率  
  112.     int m_bit;                      //样本值  
  113.     int m_channel;                  //声道数  
  114.     int m_datasize;                 //一帧音频数据量  
  115. private:  
  116.     ALCdevice * m_Devicde;          //device句柄  
  117.     ALCcontext * m_Context;         //device context  
  118.     ALuint m_outSourceId;           //source id 负责播放  
  119. };  
  120.   
  121.   
  122. #endif  

//.cpp

 

[cpp] view plain copy

 

 

  1. #include "Lvs_OpenAl_Interface.h"  
  2.   
  3. static cclass_openal_interface * copenal_interface = NULL;  
  4.   
  5. int lvs_openal_interface_init()   
  6. {  
  7.     int ret = 0;  
  8.     printf("Device : lvs_openal_interface_init\n");  
  9.     if(copenal_interface == NULL)  
  10.     {  
  11.         copenal_interface = new cclass_openal_interface();  
  12.     }  
  13.     return ret;  
  14. }  
  15.   
  16. void lvs_openal_interface_uninit()  
  17. {  
  18.     printf("Device : lvs_openal_interface_uninit\n");  
  19.   
  20.     if(copenal_interface)  
  21.     {  
  22.         delete copenal_interface;  
  23.         copenal_interface = NULL;  
  24.     }  
  25.     return ;  
  26. }  
  27.   
  28. void lvs_openal_interface_playsound()  
  29. {  
  30.     copenal_interface->playSound();  
  31. }  
  32.   
  33. void lvs_openal_interface_stopsound()  
  34. {  
  35.     copenal_interface->stopSound();  
  36. }  
  37.   
  38. void lvs_openal_interface_setvolume(float volume)//volume取值范围(0~1)  
  39. {  
  40.     copenal_interface->SetVolume(volume);  
  41. }  
  42.   
  43. float lvs_openal_interface_getvolume()  
  44. {  
  45.     return copenal_interface->GetVolume();  
  46. }  
  47.   
  48. int lvs_openal_interface_openaudiofromqueue(char* data,int dataSize,int aSampleRate,int aBit ,int aChannel)  
  49. {  
  50.     return copenal_interface->openAudioFromQueue(data,dataSize,aSampleRate,aBit,aChannel);  
  51. }  
  52.   
  53. long long lvs_openal_interface_getrealpts()  
  54. {  
  55.     long long time = (long long )((copenal_interface->m_IsplayBufferSize * copenal_interface->m_oneframeduration) + 0.5);  
  56.     printf("*****m_IsplayBufferSize : %ld",copenal_interface->m_IsplayBufferSize);  
  57.     printf("****************time : %lld(ms)\n",time);  
  58.     return time;  
  59. }  
  60.   
  61. long long lvs_openal_interface_getIsplayBufferSize()  
  62. {  
  63.     return copenal_interface->m_IsplayBufferSize;  
  64. }  
  65.   
  66. int lvs_openal_getnumqueuedsize()  
  67. {  
  68.     return copenal_interface->m_numqueued;  
  69. }  
  70.   
  71. int lvs_openal_interface_updataQueueBuffer()  
  72. {  
  73.     return copenal_interface->updataQueueBuffer();  
  74. }  
  75.   
  76. cclass_openal_interface::cclass_openal_interface()  
  77. {  
  78.     m_Devicde = NULL;    
  79.     m_Context = NULL;        
  80.     m_outSourceId = 0;        
  81.     m_numprocessed = 0;            
  82.     m_numqueued = 0;  
  83.     m_IsplayBufferSize = 0;  
  84.     m_oneframeduration = 0.0;  
  85.     m_volume = 1.0;  
  86.     m_samplerate = 0;  
  87.     m_bit = 0;  
  88.     m_channel = 0;  
  89.     m_datasize = 0;  
  90.   
  91.     //init  
  92.     initOpenAL();  
  93. }  
  94.   
  95. cclass_openal_interface::~cclass_openal_interface()  
  96. {  
  97.     cleanUpOpenAL();  
  98.   
  99.     m_Devicde = NULL;    
  100.     m_Context = NULL;        
  101.     m_outSourceId = 0;        
  102.     m_numprocessed = 0;            
  103.     m_numqueued = 0;  
  104.     m_IsplayBufferSize = 0;  
  105.     m_oneframeduration = 0.0;  
  106.     m_volume = 1.0;  
  107.     m_samplerate = 0;  
  108.     m_bit = 0;  
  109.     m_channel = 0;  
  110.     m_datasize = 0;  
  111. }  
  112.   
  113. int cclass_openal_interface::initOpenAL()  
  114. {  
  115.     int ret = 0;  
  116.   
  117.     printf("=======initOpenAl===\n");  
  118.   
  119. #ifdef WIN32  
  120.     //初始化 ALUT openal函数库  
  121.     int zwg_argc=1;  
  122.     //添加函数库名称  
  123.     char* zwg_argv[]={"ZWG_ALUT"};    
  124.     ret= alutInit(&zwg_argc, zwg_argv);   
  125. #else  
  126.   
  127. #endif  
  128.   
  129.     //打开device  
  130.     m_Devicde = alcOpenDevice(NULL);  
  131.     if (m_Devicde)  
  132.     {  
  133. #ifdef WIN32  
  134.         //windows 用这个context 声音不正常，以后处理  
  135. #else  
  136.         //建立声音文本描述  
  137.         m_Context = alcCreateContext(m_Devicde, NULL);  
  138.   
  139.         //设置行为文本描述  
  140.         alcMakeContextCurrent(m_Context);  
  141. #endif  
  142.     }  
  143.   
  144.     //创建一个source并设置一些属性  
  145.     alGenSources(1, &m_outSourceId);  
  146.     alSpeedOfSound(1.0);  
  147.     alDopplerVelocity(1.0);  
  148.     alDopplerFactor(1.0);  
  149.     alSourcef(m_outSourceId, AL_PITCH, 1.0f);  
  150.     alSourcef(m_outSourceId, AL_GAIN, 1.0f);  
  151.     alSourcei(m_outSourceId, AL_LOOPING, AL_FALSE);  
  152.     alSourcef(m_outSourceId, AL_SOURCE_TYPE, AL_STREAMING);  
  153.   
  154.     return ret;  
  155. }  
  156.   
  157. void cclass_openal_interface::cleanUpOpenAL()  
  158. {  
  159.     printf("=======cleanUpOpenAL===\n");  
  160.   
  161.     alDeleteSources(1, &m_outSourceId);  
  162.   
  163. #ifdef WIN32  
  164.     alcCloseDevice(m_Devicde);  
  165.     m_Devicde = NULL;  
  166.     alutExit();  
  167. #else  
  168.     ALCcontext * Context = alcGetCurrentContext();  
  169.     ALCdevice * Devicde = alcGetContextsDevice(Context);  
  170.   
  171.     if (Context)  
  172.     {  
  173.         alcMakeContextCurrent(NULL);  
  174.         alcDestroyContext(Context);  
  175.         m_Context = NULL;  
  176.     }  
  177.     alcCloseDevice(m_Devicde);  
  178.     m_Devicde = NULL;  
  179. #endif  
  180. }  
  181.   
  182. void cclass_openal_interface::playSound()  
  183. {  
  184.     int ret = 0;  
  185.     alSourcePlay(m_outSourceId);  
  186.     if((ret = alGetError()) != AL_NO_ERROR)  
  187.     {  
  188.         printf("error alcMakeContextCurrent %x : %s\n", ret,alutGetErrorString (ret));  
  189.     }  
  190. }  
  191.   
  192. void cclass_openal_interface::stopSound()  
  193. {  
  194.     alSourceStop(m_outSourceId);  
  195. }  
  196.   
  197. void cclass_openal_interface::SetVolume(float volume)//volume取值范围(0~1)  
  198. {  
  199.     m_volume = volume;  
  200.     alSourcef(m_outSourceId,AL_GAIN,volume);  
  201. }  
  202.   
  203. float cclass_openal_interface::GetVolume()  
  204. {  
  205.     return m_volume;  
  206. }  
  207.   
  208. int cclass_openal_interface::updataQueueBuffer()  
  209. {  
  210.     //播放状态字段  
  211.     ALint stateVaue = 0;  
  212.   
  213.     //获取处理队列，得出已经播放过的缓冲器的数量  
  214.     alGetSourcei(m_outSourceId, AL_BUFFERS_PROCESSED, &m_numprocessed);  
  215.     //获取缓存队列，缓存的队列数量  
  216.     alGetSourcei(m_outSourceId, AL_BUFFERS_QUEUED, &m_numqueued);  
  217.   
  218.     //获取播放状态，是不是正在播放  
  219.     alGetSourcei(m_outSourceId, AL_SOURCE_STATE, &stateVaue);  
  220.   
  221.     //printf("===statevaue ========================%x\n",stateVaue);  
  222.   
  223.     if (stateVaue == AL_STOPPED ||  
  224.         stateVaue == AL_PAUSED ||   
  225.         stateVaue == AL_INITIAL)   
  226.     {  
  227.         //如果没有数据,或数据播放完了  
  228.         if (m_numqueued < m_numprocessed || m_numqueued == 0 ||(m_numqueued == 1 && m_numprocessed ==1))  
  229.         {  
  230.             //停止播放  
  231.             printf("...Audio Stop\n");  
  232.             stopSound();  
  233.             cleanUpOpenAL();  
  234.             return 0;  
  235.         }  
  236.   
  237.         if (stateVaue != AL_PLAYING)  
  238.         {  
  239.             playSound();  
  240.         }  
  241.     }  
  242.   
  243.     //将已经播放过的的数据删除掉  
  244.     while(m_numprocessed --)  
  245.     {  
  246.         ALuint buff;  
  247.         //更新缓存buffer中的数据到source中  
  248.         alSourceUnqueueBuffers(m_outSourceId, 1, &buff);  
  249.         //删除缓存buff中的数据  
  250.         alDeleteBuffers(1, &buff);  
  251.   
  252.         //得到已经播放的音频队列多少块  
  253.         m_IsplayBufferSize ++;  
  254.     }  
  255.     long long time = (long long )((m_IsplayBufferSize * m_oneframeduration) + 0.5);  
  256.     //printf("*****m_IsplayBufferSize : %ld",m_IsplayBufferSize);  
  257.     //printf("****************time : %ld(ms)\n",time);  
  258.     return 1;  
  259. }  
  260.   
  261. int cclass_openal_interface::openAudioFromQueue(char* data,int dataSize,int aSampleRate,int aBit ,int aChannel)  
  262. {  
  263.     int ret = 0;  
  264.     //样本数openal的表示方法  
  265.     ALenum format = 0;  
  266.     //buffer id 负责缓存,要用局部变量每次数据都是新的地址  
  267.     ALuint bufferID = 0;  
  268.   
  269.     if (m_datasize == 0 &&  
  270.         m_samplerate == 0 &&  
  271.         m_bit == 0 &&  
  272.         m_channel == 0)  
  273.     {  
  274.         if (dataSize != 0 &&  
  275.             aSampleRate != 0 &&  
  276.             aBit != 0 &&  
  277.             aChannel != 0)  
  278.         {  
  279.             m_datasize = dataSize;  
  280.             m_samplerate = aSampleRate;  
  281.             m_bit = aBit;  
  282.             m_channel = aChannel;  
  283.             m_oneframeduration = m_datasize * 1.0 /(m_bit/8) /m_channel /m_samplerate * 1000 ;   //计算一帧数据持续时间  
  284.         }  
  285.     }  
  286.   
  287.     //创建一个buffer  
  288.     alGenBuffers(1, &bufferID);  
  289.     if((ret = alGetError()) != AL_NO_ERROR)  
  290.     {  
  291.         printf("error alGenBuffers %x : %s\n", ret,alutGetErrorString (ret));  
  292.         //AL_ILLEGAL_ENUM   
  293.         //AL_INVALID_VALUE  
  294.         //#define AL_ILLEGAL_COMMAND                        0xA004  
  295.         //#define AL_INVALID_OPERATION                      0xA004  
  296.     }  
  297.   
  298.     if (aBit == 8)   
  299.     {  
  300.         if (aChannel == 1)   
  301.         {  
  302.             format = AL_FORMAT_MONO8;  
  303.         }  
  304.         else if(aChannel == 2)  
  305.         {  
  306.             format = AL_FORMAT_STEREO8;  
  307.         }  
  308.     }  
  309.   
  310.     if( aBit == 16 )  
  311.     {  
  312.         if( aChannel == 1 )   
  313.         {   
  314.             format = AL_FORMAT_MONO16;  
  315.         }  
  316.         if( aChannel == 2 )   
  317.         {  
  318.             format = AL_FORMAT_STEREO16;  
  319.         }  
  320.     }  
  321.     //指定要将数据复制到缓冲区中的数据  
  322.     alBufferData(bufferID, format, data, dataSize,aSampleRate);  
  323.     if((ret = alGetError()) != AL_NO_ERROR)  
  324.     {  
  325.         printf("error alBufferData %x : %s\n", ret,alutGetErrorString (ret));  
  326.         //AL_ILLEGAL_ENUM   
  327.         //AL_INVALID_VALUE  
  328.         //#define AL_ILLEGAL_COMMAND                        0xA004  
  329.         //#define AL_INVALID_OPERATION                      0xA004  
  330.     }  
  331.     //附加一个或一组buffer到一个source上  
  332.     alSourceQueueBuffers(m_outSourceId, 1, &bufferID);  
  333.     if((ret = alGetError()) != AL_NO_ERROR)  
  334.     {  
  335.         printf("error alSourceQueueBuffers %x : %s\n", ret,alutGetErrorString (ret));  
  336.     }  
  337.   
  338.     //更新队列数据  
  339.     ret = updataQueueBuffer();  
  340.   
  341.     //删除一个缓冲 这里不应该删除缓冲，在source里面播放完毕删除  
  342.     //alDeleteBuffers(1, &bufferID);  
  343.     bufferID = 0;  
  344.   
  345.     return 1;  
  346. }  

 

//main.cpp

 

 

[cpp] view plain copy

 

 

  1. #include "Lvs_OpenAl_Interface.h"  
  2.   
  3. //要显示的pcm/wav文件路径及名称  
  4. #define PCM_STREAM_PATH_NAME  "../pcm_stream/44100_2_16.pcm"  
  5.   
  6. int main()  
  7. {  
  8.     int ret = 0;  
  9.     int nSampleRate = 44100;                   //采样率  
  10.     int nBit = 16;                             //样本数  
  11.     int nChannel = 2;                          //声道  
  12.     int ndatasize = 1024 * (nBit/8) *nChannel; //每次读取的数据大小   
  13.     char ndata[4096 + 1] = {0};                //读取的数据           
  14.     FILE * pFile_pcm = NULL;                   //读取pcm数据的文件句柄    
  15.   
  16.     //打开pcm文件  
  17.     if((pFile_pcm = fopen(PCM_STREAM_PATH_NAME, "rb")) == NULL)  
  18.     {  
  19.         printf("filed open file : %s\n",PCM_STREAM_PATH_NAME);  
  20.         return getchar();  
  21.     }  
  22.     else  
  23.     {  
  24.         printf("success open file : %s\n",PCM_STREAM_PATH_NAME);  
  25.     }  
  26.   
  27.     //init  
  28.     lvs_openal_interface_init();  
  29.   
  30.     //设置音量volume取值范围(0~1)  
  31.     lvs_openal_interface_setvolume(1.0);  
  32.   
  33.     for(;;)  
  34.     {  
  35.         Sleep(23);  
  36.         //循环读取文件  
  37.         ret = fread(ndata, 1,ndatasize, pFile_pcm);  
  38.         if (ret != ndatasize)  
  39.         {  
  40.             //seek到文件开头  
  41.             fseek(pFile_pcm, 0, SEEK_SET);  
  42.             fread(ndata, 1,ndatasize, pFile_pcm);  
  43.         }  
  44.         //具体的处理在这里  
  45.         ret = lvs_openal_interface_openaudiofromqueue((char *)ndata,ndatasize,nSampleRate,nBit,nChannel);  
  46.   
  47.         long long time = lvs_openal_interface_getrealpts();  
  48.     }  
  49.   
  50.     //uinit  
  51.     lvs_openal_interface_uninit();  
  52.   
  53.     //关闭pcm文件  
  54.     if (pFile_pcm != NULL)  
  55.     {  
  56.         fclose(pFile_pcm);  
  57.         pFile_pcm = NULL;  
  58.     }  
  59.   
  60.     return 1;  
  61. }  

 

 

 

程序运行效果并能听到声音：

 

本demo还需完善。

 

from:http://blog.csdn.net/zhuweigangzwg/article/details/53286945

时间： 2024-10-28 18:51:27

OpenAL播放pcm或wav数据流-windows/ios/android(一)的相关文章

按钮-客户端如何播放服务器端的WAV录音文件

问题描述 客户端如何播放服务器端的WAV录音文件 我的程序B/S的 现在我的数据库中存有客服的WAV录音文件的路径,同时录音文件是在服务器上保存的. 我使用repeater控件绑定数据库后,用lable读取路径,传到一个"播放"按钮的点击事件里. 现在问题来了:当我点击这个播放按钮的时候,可以播放录音,但是只限在服务器上面,在其他客户端无法播放 所以我想请问各位大大: 有什么办法可以在客户端点击"播放"按钮播放服务器端的WAV录音文件(客户端直接能在本机听到声音 求

最简单的视音频播放示例9：SDL2播放PCM

本文记录SDL播放音频的技术.在这里使用的版本是SDL2.实际上SDL本身并不提供视音频播放的功能,它只是封装了视音频播放的底层API.在Windows平台下,SDL封装了Direct3D这类的API用于播放视频:封装了DirectSound这类的API用于播放音频.因为SDL的编写目的就是简化视音频播放的开发难度,所以使用SDL播放视频(YUV/RGB)和音频(PCM)数据非常的容易. SDL简介 SDL(Simple DirectMedia Layer)是一套开放源代码的跨平台多媒体开发库,

最简单的视音频播放示例8：DirectSound播放PCM

本文记录DirectSound播放音频的技术.DirectSound是Windows下最常见的音频播放技术.目前大部分的音频播放应用都是通过DirectSound来播放的.本文记录一个使用DirectSound播放PCM的例子.注:一位仁兄已经提醒我DirectSound已经计划被XAudio2取代了.后来考证了一下发现确有此事.因此在下次更新中考虑加入XAudio2播放PCM的例子.本文仍然记录一下DirectSound这位"元老".   DirectSound简介 DirectSo

与众不同 windows phone (14) - Media（媒体）之音频播放器, 视频播放器, 与 Windows Phone 的音乐和视频中心集成

原文:与众不同 windows phone (14) - Media(媒体)之音频播放器, 视频播放器, 与 Windows Phone 的音乐和视频中心集成 [索引页][源码下载] 与众不同 windows phone (14) - Media(媒体)之音频播放器, 视频播放器, 与 Windows Phone 的音乐和视频中心集成 作者:webabcd 介绍与众不同 windows phone 7.5 (sdk 7.1) 之媒体 音频播放器 视频播放器 与 Windows Phone 的音乐

linux alsa下实现同时录制、播放pcm？？？

问题描述 linux alsa下实现同时录制.播放pcm??? 大神们: 目的:在linux平台上实现同时录制.播放声音,要求播放的声音和录制的声音之间的延时小于5ms. 要实现这个要求的话,硬件上需要声卡支持全双工吗?软件上有无设计建议?linux系统延时能达到上述要求吗? 谢谢! 平台:linux 音频结构:alsa 解决方案 linux alsa pcm 播放声音基于alsa驱动架构的pcm播放

使用WindowsAPI实现播放PCM音频的方法_C 语言

本文介绍了使用WindowsAPI实现播放PCM音频的方法,同前面一篇使用WindowsAPI获取录音音频的方法原理具有相似之处,这里就不再详细介绍具体的函数与结构体的参数,相同的部分加以省略,只介绍主要的功能部分代码.如下所示: 1. waveOutGetNumDevs 2. waveOutGetDevCaps 3. waveOutOpen 回调函数: void CALLBACK PlayCallback(HWAVEOUT hwaveout, UINT uMsg, DWORD dwInstan

使用WindowsAPI实现播放PCM音频的方法

这篇文章主要介绍了使用WindowsAPI实现播放PCM音频的方法,很实用的一个功能,需要的朋友可以参考下 本文介绍了使用WindowsAPI实现播放PCM音频的方法,同前面一篇使用WindowsAPI获取录音音频的方法原理具有相似之处,这里就不再详细介绍具体的函数与结构体的参数,相同的部分加以省略,只介绍主要的功能部分代码.如下所示: 1. waveOutGetNumDevs 2. waveOutGetDevCaps 3. waveOutOpen 回调函数: ? 1 void CALLBACK

foobar2000 正式登陆 iOS/Android

在登陆Windows 10移动平台之后, 被很多音乐爱好者.发烧友所推崇的播放器foobar2000终于来到了iOS.Android平台上,全面支持iPhone.iPad.Android 手机.Android平板.foobar2000 mobile移动版继承了PC桌面版的强大功能,界面依然朴素简洁,是专心听音乐的不二之选. AZhCConuceO1Y7NorcTqi4-ivYgeP8fKsKHTaadnxgGFKaOXCHGi9zeTNzpTEo5b8Q=h310.png DotYvoF1wiL

【原】常见CSS3属性对ios&amp;android&amp;winphone的支持

那么,除了ios和android系统之外,还有哪个移动设备的操作系统是我们需要考虑进来的呢?可能大家会在猜是winphone,没错!就是微软发布的一款手机操作系统Windows Phone,虽然用户不算太多,但是这部分用户也是我们需要考虑到的,至少要保证网页在winphone的展现是正常的.目前winphone有几个版本,主要是Windows Phone 7 和Windows Phone 8,其对应的浏览器分别是IE9和IE10.那么,webapp开发中除了兼容ios3.0~7.0,androi