xiliang_pan
xiliang_pan

openal教程

转自： http://blog.csdn.net/zouxy09/article/details/7893162
 
    1. /*************************************************************************** 
    2. openal全教程 
    3. 分类： OpenSceneGraph 2008-12-01 16:22 3015人阅读 评论(1) 收藏 举报 
    4.  openal教程（一） 
    5. 简介L一直在不断 
    6.    欢迎来到OPENAL的世界！OPENA的创新，几乎没有一个API能达到 
    7. 她的全部潜能。一个很大的原因是因为hardware加速建立在特殊的版卡上。然而， 
    8. Creative Labs是APENAL的主要支持者，同时也是最大声卡厂商之一。OPENAL的另 
    9. 一个主要支持者LOKI。 
    10.    OPENAL不是商业产品，那样做限制了她的发展。我只知道再PC游戏中用OPENAL。 
    11. OPENAL有许多的潜能，有许多的声音库工作在最地层的hardware上。但OPENAL的 
    12. 设计者经过无数的测试使她成为一个高级的API。她的风格是自由的，不同的编码 
    13. 风格和hardware部件将充分运用她的功能。有OPENGL编程精练的人将很快掌握OPEN 
    14. AL。OPENAL有建立3D环境音效的能力。 
    15.    OPENAL是very cool,她是一个非常清晰的API并且能熔入你的代码。你将做出 
    16. 很COOL的音效，下面让我们进入COOL COOL的OPENAL世界。 
    17. *******************************************************************************/  
    18.   
    19.    #include <conio.h>  
    20.    #include <stdlib.h>  
    21.    #include <al/al.h>  
    22.    #include <al/alc.h>  
    23.    #include <al/alu.h>  
    24.    #include <al/alut.h>  
    25.      
    26. /* 
    27.   你会发现再OPENAL头和OPENGL头的定义上有许多的相似之处。除了“al.h","al 
    28. u.h","alut.h"与”gl.h","glu.h","glut.h"相似，还增加了一个"alc.h".ALC（ 
    29. AUDIO LIBRARY CONTEXT）处理声音通过不同的平台，她也处理你在几个窗口下共 
    30. 享设备的环境。 
    31. */  
    32.   
    33.   // 存储声音数据  
    34. ALuint Buffer;  
    35.   
    36. // 用于播放声音  
    37. ALuint Source;  
    38.   
    39. /* 
    40.   这是程序处理结构的初始化。在OPENAL中三种不同的结构，所有关于声音播放和 
    41. 声音数据存储在一个内存中，源（source）是指向放声音的空间。明白源是非常 
    42. 的重要。源只播放内存中的背景声音数据。源也给出了特殊的属性如位置和速度。 
    43.   第三个对象是听者，用户就是那唯一的听者。听者属性属于源属性，决定如何 
    44. 听声音。例如，不同位置将决定声音的速度。 
    45. */  
    46.   
    47.   // 源声音的位置  
    48. ALfloat SourcePos[] = { 0.0, 0.0, 0.0 };  
    49.   
    50. // 源声音的速度  
    51. ALfloat SourceVel[] = { 0.0, 0.0, 0.0 };  
    52.   
    53.   
    54. // 听者的位置  
    55. ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 };  
    56.   
    57. // 听者的速度  
    58. ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 };  
    59.   
    60. // 听者的方向 (first 3 elements are "at", second 3 are "up")  
    61. ALfloat ListenerOri[] = { 0.0, 0.0, -1.0,  0.0, 1.0, 0.0 };  
    62.   
    63. /* 
    64.   在上面的代码中，我们定义了源和听者对象的位置和速度。这些数组是基于笛 
    65. 卡儿坐标的矢量。你能很容易用结构或类做相同的事情。 
    66. */  
    67.   
    68.   ALboolean LoadALData()  
    69. {  
    70.     // 载入变量.  
    71.   
    72.     ALenum format;  
    73.     ALsizei size;  
    74.     ALvoid* data;  
    75.     ALsizei freq;  
    76.     ALboolean loop;  
    77.     //在这里我们建立一个函数用于从一个文件中载入声音数据。变量用于存储适合  
    78.     //我们的ALUT信息。  
    79.       
    80.   // 载入WAV数据  
    81.     alGenBuffers(1, &Buffer);  
    82.     if (alGetError() != AL_NO_ERROR)  
    83.         return AL_FALSE;  
    84.   
    85.     alutLoadWAVFile("wavdata/FancyPants.wav", &format, &data, &size, &freq, &loop);  
    86.     alBufferData(Buffer, format, data, size, freq);  
    87.     alutUnloadWAV(format, data, size, freq);  
    88. /* 
    89.   函数alGenBufers用于建立对象内存并把他们存储在我们定义的变量中。然后判断 
    90. 数据是否存储。 
    91.   ALUT库为我们打开文件，提供我们建立内存所需的信息，并且在我们归属所有 
    92. 数据到内存后，她将处理这些数据。 
    93. */  
    94.   // 捆绑源  
    95.     alGenSources(1, &Source);  
    96.   
    97.     if (alGetError() != AL_NO_ERROR)  
    98.         return AL_FALSE;  
    99.   
    100.     alSourcei (Source, AL_BUFFER,   Buffer   );  
    101.     alSourcef (Source, AL_PITCH,    1.0f     );  
    102.     alSourcef (Source, AL_GAIN,     1.0f     );  
    103.     alSourcefv(Source, AL_POSITION, SourcePos);  
    104.     alSourcefv(Source, AL_VELOCITY, SourceVel);  
    105.     alSourcei (Source, AL_LOOPING,  loop     );  
    106. /* 
    107.   我们用建立内存对象的方法建立了源对象。然后，我们定义源属性用于录放。 
    108. 最重要的属性是她用的内存。这告诉源用于录放。因此，我们只有捆绑她。同时， 
    109. 我们也告诉她我们定义的源位置和速度。 
    110. */  
    111.   // 做错误检测并返回  
    112.     if (alGetError() == AL_NO_ERROR)  
    113.         return AL_TRUE;  
    114.   
    115.     return AL_FALSE;  
    116.   //在函数的结尾，我们将做更多的检测，以确定她的正确。  
    117. }  
    118.   void SetListenervalues()  
    119. {  
    120.     alListenerfv(AL_POSITION,    ListenerPos);  
    121.     alListenerfv(AL_VELOCITY,    ListenerVel);  
    122.     alListenerfv(AL_ORIENTATION, ListenerOri);  
    123. }  
    124.     //我们建立一个函数用于更新听者速度。  
    125.   void KillALData()  
    126. {  
    127.     alDeleteBuffers(1, &Buffer);  
    128.     alDeleteSources(1, &Source);  
    129.     alutExit();  
    130. }  
    131.     //这是一个关闭函数，用于释放内存和音频设备。  
    132.  int main(int argc, char *argv[])  
    133. {  
    134.     // 初始OPENAL并清错误字节  
    135.   
    136.     alutInit(&argc, argv);  
    137.     alGetError();  
    138. /* 
    139.   函数alutInit将安装ALC需要的东西。ALUT通过ALC并设置她为当前建立OPENAL 
    140. 环境描述。在WINDOWS平台上初始DIRECTSOUND。然后用‘GLGETERROR’检测错误。 
    141. */  
    142.    // 载入WAV数据  
    143.     if (LoadALData() == AL_FALSE)  
    144.         return -1;  
    145.   
    146.     SetListenervalues();  
    147.   
    148.     // 设置退出函数  
    149.     atexit(KillALData);  
    150.       
    151.   //我们将检测WAV文件是否正确载入。如果没有退出程序。正确后，更新听者参数，最后退出。  
    152.   ALubyte c = ' ';  
    153.   
    154.     while (c != 'q')  
    155.     {  
    156.         c = getche();  
    157.   
    158.         switch (c)  
    159.         {  
    160.             // Pressing 'p' will begin playing the sample.  
    161.             case 'p': alSourcePlay(Source); break;  
    162.   
    163.             // Pressing 's' will stop the sample from playing.  
    164.             case 's': alSourceStop(Source); break;  
    165.   
    166.             // Pressing 'h' will pause (hold) the sample.  
    167.             case 'h': alSourcePause(Source); break;  
    168.         };  
    169.     }  
    170.   
    171.     return 0;  
    172. }  
    173.   
    174. /********************************************************************************* 
    175. This is the interesting part of the tutorial. It's a very basic loop that lets us  
    176. control the playback of the audio sample. Pressing 'p' will replay the sample,  
    177. pressing 's' will stop the sample, and pressing 'h' will pause the sample.  
    178. Pressing 'q' will exit the program. 
    179.  
    180. Well there it is. Your first delve into OpenAL. I hope it was made simple enough  
    181. for you. It may have been a little too simple for the 1337 h4X0r, but we all got to  
    182. start somewhere. Things will get more advanced as we go along. 
    183.  
    184. Download the Dev-C++ source and project file  
    185.  
    186.  
    187. OpenAl教程（二） 
    188.  
    189. 循环和消退 
    190.  
    191. 希望你觉得上一章有用，这一章将更容易。 
    192.  
    193. ************************************************************************************/  
    194. #include   
    195. #include   
    196. #include   
    197. #include   
    198. #include   
    199. #include   
    200. #include  
    201.   
    202. // 存储声音数据.  
    203. ALuint Buffer;  
    204.   
    205. // 用于播放声音.  
    206. ALuint Source;  
    207.   
    208. // 源声音的位置.  
    209. ALfloat SourcePos[] = { 0.0, 0.0, 0.0 };  
    210.   
    211. // 源声音的速度.  
    212. ALfloat SourceVel[] = { 0.0, 0.0, 0.1 };  
    213.   
    214. // 听者的位置.  
    215. ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 };  
    216.   
    217. // 听者的速度  
    218. ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 };  
    219.   
    220. // 听者的方向 (first 3 elements are "at", second 3 are "up")  
    221. ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 };  
    222. //这一章与上一章唯一的不同是源速度的改变，他的‘Z’现在是0.1.  
    223.   
    224. ALboolean LoadALData()  
    225. {  
    226.     // 载入变量  
    227.     ALenum format;  
    228.     ALsizei size;  
    229.     ALvoid* data;  
    230.     ALsizei freq;  
    231.     ALboolean loop;  
    232.   
    233.     // 载入WAV数据.  
    234.   
    235.     alGenBuffers(1, &Buffer);  
    236.   
    237.     if (alGetError() != AL_NO_ERROR)  
    238.         return AL_FALSE;  
    239.   
    240.     alutLoadWAVFile("wavdata/Footsteps.wav", &format, &data, &size, &freq, &loop);  
    241.     alBufferData(Buffer, format, data, size, freq);  
    242.     alutUnloadWAV(format, data, size, freq);  
    243.   
    244.     // 捆绑源  
    245.   
    246.     alGenSources(1, &Source);  
    247.   
    248.     if (alGetError() != AL_NO_ERROR)  
    249.         return AL_FALSE;  
    250.   
    251.     alSourcei (Source, AL_BUFFER, Buffer );  
    252.     alSourcef (Source, AL_PITCH, 1.0f );  
    253.     alSourcef (Source, AL_GAIN, 1.0f );  
    254.     alSourcefv(Source, AL_POSITION, SourcePos);  
    255.     alSourcefv(Source, AL_VELOCITY, SourceVel);  
    256.     alSourcei (Source, AL_LOOPING, AL_TRUE );  
    257.   
    258.     // 做错误检测并返回  
    259.   
    260.     if (alGetError() != AL_NO_ERROR)  
    261.         return AL_FALSE;  
    262.   
    263.     return AL_TRUE;  
    264. }  
    265.   
    266. //在这一节中有两处改变，首先是导入“FOOTSTES。WAV”，设置源‘AL_LOOPING’  
    267. //为‘AL_TRUE’。这意味着源播放直到停止时结束。他将不断的循环播放。  
    268. void SetListenervalues()  
    269. {  
    270.     alListenerfv(AL_POSITION, ListenerPos);  
    271.     alListenerfv(AL_VELOCITY, ListenerVel);  
    272.     alListenerfv(AL_ORIENTATION, ListenerOri);  
    273. }  
    274.   
    275. void KillALData()  
    276. {  
    277.     alDeleteBuffers(1, &Buffer);  
    278.     alDeleteSources(1, &Source);  
    279.     alutExit();  
    280. }  
    281. //这里没有改变。  
    282. int main(int argc, char *argv[])  
    283. {  
    284.     // 初始OPENAL并清错误字节  
    285.     alutInit(NULL,0);  
    286.     alGetError();  
    287.   
    288.     // 载入WAV数据.  
    289.     if (LoadALData() == AL_FALSE)  
    290.         return 0;  
    291.   
    292.     SetListenervalues();  
    293.   
    294.     // 设置退出函数.  
    295.     atexit(KillALData);  
    296.   
    297.     // 开始源的播放.  
    298.     alSourcePlay(Source);  
    299.   
    300.     //循环  
    301.     ALint time = 0;  
    302.     ALint elapse = 0;  
    303.   
    304.     while (!kbhit())  
    305.     {  
    306.         elapse += clock() - time;  
    307.         time += elapse;  
    308.   
    309.         if (elapse > 50)  
    310.         {  
    311.             elapse = 0;  
    312.   
    313.             SourcePos[0] += SourceVel[0];  
    314.             SourcePos[1] += SourceVel[1];  
    315.             SourcePos[2] += SourceVel[2];  
    316.   
    317.             alSourcefv(Source, AL_POSITION, SourcePos);  
    318.         }  
    319.     }  
    320.   
    321.   
    322.     return 0;  
    323. }  
    324.   
    325. //这里唯一的改变是增加了一个循环。他将代替播放和停止按钮。  
    326. We do this by slowly incrementing the position by it's velocity over  
    327. time. The time is sampled by checking the system clock which gives  
    328. us a tick count. It shouldn't be necessary to change this, but if the   
    329. audio clip fades too fast you might want to change 50 to some higher n  
    330. umber. Pressing any key will end the loop  
    331.   
    332. /************************************************************************** 
    333. 多源 
    334.  
    335. 你好，在这一章中，我们将在上一章的例程中加入一些元素，使他能同时播放超过一种的音乐。 
    336. 通常在一个优秀的游戏中有各种不同的音夹（clip),这是怎样实现的呢？ 
    337. 下面将介绍。 
    338. *****************************************************************************/  
    339. #include   
    340. #include   
    341. #include   
    342. #include   
    343. #include   
    344. #include   
    345. #include  
    346.   
    347. // 我们需要的最大的数据缓冲.  
    348. #define NUM_BUFFERS 3  
    349.   
    350. // 我们需要放三种声音.  
    351. #define NUM_SOURCES 3  
    352.   
    353. // 缓冲和源标志.  
    354. #define BATTLE 0  
    355. #define GUN1 1  
    356. #define GUN2 2  
    357.   
    358. // 存储声音数据.  
    359. ALuint Buffers[NUM_BUFFERS];  
    360.   
    361. // 用于播放声音.  
    362. ALuint Sources[NUM_SOURCES];  
    363.   
    364. // 源声音的位置.  
    365. ALfloat SourcesPos[NUM_SOURCES][3];  
    366.   
    367. // 源声音的速度.  
    368. ALfloat SourcesVel[NUM_SOURCES][3];  
    369.   
    370.   
    371. // 听者的位置.  
    372. ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 };  
    373.   
    374. // 听者的速度.  
    375. ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 };  
    376.   
    377. // 听者的方向 (first 3 elements are "at", second 3 are "up")  
    378. ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 };  
    379.   
    380. //在这一章中，唯一的不同是多了3种将导入Openal系统的不同的声音效果 。  
    381.   
    382. ALboolean LoadALData()  
    383. {  
    384.     // 载入变量.  
    385.   
    386.     ALenum format;  
    387.     ALsizei size;  
    388.     ALvoid* data;  
    389.     ALsizei freq;  
    390.     ALboolean loop;  
    391.   
    392.     // 载入WAV数据.  
    393.   
    394.     alGenBuffers(NUM_BUFFERS, Buffers);  
    395.   
    396.     if (alGetError() != AL_NO_ERROR)  
    397.         return AL_FALSE;  
    398.   
    399.     alutLoadWAVFile("wavdata/Battle.wav", &format, &data, &size, &freq, &loop);  
    400.     alBufferData(Buffers[BATTLE], format, data, size, freq);  
    401.     alutUnloadWAV(format, data, size, freq);  
    402.   
    403.     alutLoadWAVFile("wavdata/Gun1.wav", &format, &data, &size, &freq, &loop);  
    404.     alBufferData(Buffers[GUN1], format, data, size, freq);  
    405.     alutUnloadWAV(format, data, size, freq);  
    406.   
    407.     alutLoadWAVFile("wavdata/Gun2.wav", &format, &data, &size, &freq, &loop);  
    408.     alBufferData(Buffers[GUN2], format, data, size, freq);  
    409.     alutUnloadWAV(format, data, size, freq);  
    410.   
    411.     // 捆绑源.  
    412.   
    413.     alGenSources(NUM_SOURCES, Sources);  
    414.   
    415.     if (alGetError() != AL_NO_ERROR)  
    416.         return AL_FALSE;  
    417.   
    418.     alSourcei (Sources[BATTLE], AL_BUFFER, Buffers[BATTLE] );  
    419.     alSourcef (Sources[BATTLE], AL_PITCH, 1.0 );  
    420.     alSourcef (Sources[BATTLE], AL_GAIN, 1.0 );  
    421.     alSourcefv(Sources[BATTLE], AL_POSITION, SourcePos[BATTLE]);  
    422.     alSourcefv(Sources[BATTLE], AL_VELOCITY, SourceVel[BATTLE]);  
    423.     alSourcei (Sources[BATTLE], AL_LOOPING, AL_TRUE );  
    424.   
    425.     alSourcei (Sources[GUN1], AL_BUFFER, Buffers[GUN1] );  
    426.     alSourcef (Sources[GUN1], AL_PITCH, 1.0 );  
    427.     alSourcef (Sources[GUN1], AL_GAIN, 1.0 );  
    428.     alSourcefv(Sources[GUN1], AL_POSITION, SourcePos[GUN1]);  
    429.     alSourcefv(Sources[GUN1], AL_VELOCITY, SourceVel[GUN1]);  
    430.     alSourcei (Sources[GUN1], AL_LOOPING, AL_FALSE );  
    431.   
    432.     alSourcei (Sources[GUN2], AL_BUFFER, Buffers[GUN2] );  
    433.     alSourcef (Sources[GUN2], AL_PITCH, 1.0 );  
    434.     alSourcef (Sources[GUN2], AL_GAIN, 1.0 );  
    435.     alSourcefv(Sources[GUN2], AL_POSITION, SourcePos[GUN2]);  
    436.     alSourcefv(Sources[GUN2], AL_VELOCITY, SourceVel[GUN2]);  
    437.     alSourcei (Sources[GUN2], AL_LOOPING, AL_FALSE );  
    438.   
    439.     // 做错误检测并返回  
    440.   
    441.     if( alGetError() != AL_NO_ERROR)  
    442.         return AL_FALSE;  
    443.   
    444.     return AL_TRUE;  
    445. }  
    446. //首先，我们导入文件数据到3个缓冲区，然后把3个缓冲区和3个源锁在  
    447. //一起。唯一的不同是文件“battle.wav”在不停止时循环。  
    448. void SetListenervalues()  
    449. {  
    450.     alListenerfv(AL_POSITION, ListenerPos);  
    451.     alListenerfv(AL_VELOCITY, ListenerVel);  
    452.     alListenerfv(AL_ORIENTATION, ListenerOri);  
    453. }  
    454.   
    455. void KillALData()  
    456. {  
    457.     alDeleteBuffers(NUM_BUFFERS, &Buffers[0]);  
    458.     alDeleteSources(NUM_SOURCES, &Sources[0]);  
    459.     alutExit();  
    460. }  
    461. //在这段代码中，我们没有改变。  
    462. int main(int argc, char *argv[])  
    463. {  
    464.     // Initialize OpenAL and clear the error bit.  
    465.     alutInit(NULL, 0);  
    466.     alGetError();  
    467.   
    468.     // Load the wav data.  
    469.     if (LoadALData() == AL_FALSE)  
    470.         return 0;  
    471.   
    472.     SetListenervalues();  
    473.   
    474.     // Setup an exit procedure.  
    475.     atexit(KillALData);  
    476.   
    477.     // Begin the battle sample to play.  
    478.     alSourcePlay(Sources[BATTLE]);  
    479.   
    480.     // Go through all the sources and check that they are playing.  
    481.     // Skip the first source because it is looping anyway (will always be playing).  
    482.     ALint play;  
    483.   
    484.     while (!kbhit())  
    485.     {  
    486.         for (int i = 1; i < NUM_SOURCES; i++)  
    487.         {  
    488.             alGetSourcei(Sources[i], AL_SOURCE_STATE, &play);  
    489.   
    490.             if (play != AL_PLAYING)  
    491.             {  
    492.                 // Pick a random position around the listener to play the source.  
    493.   
    494.                 double theta = (double) (rand() % 360) * 3.14 / 180.0;  
    495.   
    496.                 SourcePos[i][0] = -float(cos(theta));  
    497.                 SourcePos[i][1] = -float(rand()%2);  
    498.                 SourcePos[i][2] = -float(sin(theta));  
    499.   
    500.                 alSourcefv(Sources[i], AL_POSITION, SourcePos[i] );  
    501.   
    502.                 alSourcePlay(Sourcev[i]);  
    503.             }  
    504.         }  
    505.     }  
    506.   
    507.     return 0;  
    508. }  
    509.   
    510. /***************************************************************************** 
    511. 这段是这篇文章最有趣的地方。我们在这里将播放。如果他不播放，我们将在3D空间中选 
    512. 一个点播放（点击）。 
    513.  
    514. And bang! We are done. As most of you have probably seen, you don't have to do  
    515. anything special to play more than one source at a time. OpenAL will handle all 
    516.  the mixing features to get the sounds right for their respective distances and  
    517.  velocities. And when it comes right down to it, isn't that the beauty of OpenAL? 
    518.  
    519. You know that was a lot easier than I thought. I don't know why I waited so long  
    520. to write it. Anyway, if anyone reading wants to see something specific in future  
    521. tutorials (not necessarily pertaining to OpenAL, I have quite an extensive  
    522. knowledge base) drop me a line at [email protected] I plan to do tutorials 
    523.  on sharing buffers and the Doppler effect in some later tutorial unless there is  
    524.  request for something else. Have fun with the code! 
    525.  
    526. ALC 
    527.  
    528. Alut一直为我们做着所有神奇的东西。例如处理音频设备。ALUT库为我们提供这些功能，但是 
    529. 一些机灵的程序员想知道他是怎样工作的。 
    530.  
    531. 我们可以这样想，在一些点上直接用ALC。 
    532.  
    533. 在这一章中，我们将讲述ALC层，并看一下他是怎样处理设备的。 
    534. **********************************************************************************/  
    535. ALCdevice* pDevice;  
    536.   
    537. ALCubyte DeviceName[] = "DirectSound3D";  
    538.   
    539. pDevice = alcOpenDevice(DeviceName);  
    540.   
    541. /* 
    542. 当然，ALC设备是什么？可以这样想，在共享整个系统下，OPENAL夺取了设备的句柄。在我们用 
    543. DIRECTSOUND作为音频设备时，设备能完成的很好。 
    544.  
    545. 程序从设备中夺取句柄并为程序准备着。 
    546.  
    547. 传递NULL给‘alcOpenDevice',他将使ALC用默认设备。 
    548. */  
    549.   
    550. ALCcontext* pContext;  
    551.   
    552. pContext = alcCreateContext(pDevice, NULL);  
    553.   
    554. alcMakeContextCurrent(pContext);  
    555.   
    556. /* 
    557. ALC文本描述是什么？ 
    558.  
    559. OPENGL程序员能撤消通过不同窗口的状态管理的控制的精简文本描述。HGLRC能被挑调用建立多次， 
    560. 使多描述窗口成为可能。并且不同的文本描述状态可以实现。ALC文本描述工作在相同的原理下。 
    561. 首先，我们告诉他我们用的设备，然后我们做当前的文本描述。理论上你能为不同的窗口建立多 
    562. 个表达文本描述，并且设置不同的状态变量，以使他们能很好的工作。尽管“表达文本描述”用于 
    563. 可视表达。 
    564.  
    565. 你可能也注意到“alcCreateContext'中的第二个变量是NULL。 
    566.  
    567. OPENAL中 
    568. 下面的变量与他有关。 
    569. ALC_FREQUENCY  
    570. ALC_REFRESH  
    571. ALC_SYNC 
    572.  
    573. 你可以调用’alcMakeContextCurrent'替换你建立的多个文本描述。同样 
    574. 在'alcMakeContextCurrent'中置NULL。他将防止处理其他声音数据。要意 
    575. 识到当你有多个表达文本描述时，你只能在当前用一个。并且当你的程序要 
    576. 交换使用两个描述时，必须确定当前使用的描述是在当前。当你想不通过大的 
    577. 检查，知道用的哪个描述，必须用这些。 
    578. */  
    579.   
    580. ALcontext* pCurContext;  
    581. pCurContext = alcGetCurrentContext();  
    582. //通过文本描述，你能获取设备。  
    583. ALdevice* pCurDevice;  
    584. pCurDevice = alcGetContextsDevice(pCurContext);  
    585.   
    586. //在我们用文本描述时，我们必须收回用的设备。在处理文本描述时，有更COOL的方法。  
    587.   
    588. alcSuspendContext(pContext);  
    589. // 终止pContext.  
    590. alcProcessContext(pContext);  
    591. // 重置pContext.  
    592.   
    593. //当程序停止时，我们必须重置声音数据到文本描述。当程序暂停时，文本描述中的数据不  
    594. //会产生声音。在程序运行期间，源或缓冲区的‘lifetime'的有效是由源或缓冲器ID的合法性决定的。  
    595.   
    596. alcMakeContextCurrent(NULL);  
    597. alcDestroyContext(pContext);  
    598. alcCloseDevice(pDevice);  
    599.   
    600. //最后，怎样清出他呢？当前文本描述被初始化为’NULL‘，描述释放并且设备句柄交还系统。  
    601. //在这里我们只讲了一些ALC的基本功能。  
    602.   
    603. ALenum alcGetError(ALvoid);  
    604.   
    605. ALboolean alcIsExtensionPresent(ALCdevice* device, ALubyte* extName);  
    606.   
    607. ALvoid* alcGetProcAddress(ALCdevice* device, ALubyte* funcName);  
    608.   
    609. ALenum alcGetEnumvalue(ALCdevice* device, ALubyte* enumName);  
    610.   
    611. ALubyte* alcGetString(ALCdevice* device, ALenum token);  
    612.   
    613. ALvoid alcGetIntegerv(ALCdevice* device, ALenum token, ALsizei size, ALint* dest);  
    614.   
    615. /* 
    616. 这些做什么，我们肯定很清楚，首先，我们用'alcGetError' 检测错误。 
    617.  
    618. 下面三个功能是询问ALC的扩展。这在开始就应计划。最后alcGetInteger'将返回ALC的版本 
    619. 'ALC_MAJOR_VERSION'or 'ALC_MINOR_VERSION'。 
    620.  
    621. 函数'alcGetString'返回下面信息： 
    622. ALC_DEFAULT_DEVICE_SPECIFIER  
    623. ALC_DEVICE_SPECIFIER  
    624. ALC_EXTENSIONS 
    625.  
    626. 首先是OPENAL完成的设备的信息。OPENAL 返回"DirectSound3D",  
    627. 第二个返回"DirectSound" ； 
    628.  
    629. 最后一个返回NULL。 
    630.  
    631. Well that's most of Alc for you. I hope it gave you a better understanding of how  
    632. OpenAL interacts with the operation system. You might try writing your own  
    633. initialization routines so you can cast off Alut altogether. Either way have fun with it. 
    634.  
    635. See the Java Bindings for OpenAL page for the Java version of this tutorial - adapted 
    636.  by: Athomas Goldberg 
    637. */  
    638.    
    639. /********************************************************************************* 
    640. 源共享缓冲区 
    641.  
    642. 在这一章中，我们将讲解如何在你的缓冲区中共享多个源。这是个非常合理，自然的步骤，非常的容易。 
    643. 你完全可以跳过这章。但对于愿意读这一章的朋友，你将发现他非常有趣。我们将准备好ALC层以便我 
    644. 们能用第四章的知识。 
    645.  
    646. 让我们开始吧，在这一章中，我们将用的矢量来自标准模板库，因此，确定你是否安装了他，最好还有 
    647. 一些关于他的知识。在这一章中，我不会讲STL。 
    648. **********************************************************************************/  
    649.   
    650. // 表明缓冲区.  
    651. #define THUNDER 0  
    652. #define WATERDROP 1  
    653. #define STREAM 2  
    654. #define RAIN 3  
    655. #define CHIMES 4  
    656. #define OCEAN 5  
    657.   
    658. #define NUM_BUFFERS 6  
    659.   
    660.   
    661. // 存贮声音数据.  
    662. ALuint Buffers[NUM_BUFFERS];  
    663.   
    664. // 播放多个声音的源的矢量表  
    665. vector<ALuint> Sources;  
    666. //首先，我写出了我们用于表明缓冲区数组的一些指令。我们将用几个WAV文件，因此我们  
    667. //需要几个缓冲区。我们将用一个STL矢量代替用于存贮源的一个数组。我们能做这些是因为  
    668. //他让我们能有一个源的动态数。我们能一直添加源到场景，直到OPENAL脱离他们运行。  
    669.   
    670. ALboolean InitOpenAL()  
    671. {  
    672.     ALCdevice* pDevice;  
    673.     ALCcontext* pContext;  
    674.     ALCubyte* deviceSpecifier;  
    675.     ALCubyte deviceName[] = "DirectSound3D";  
    676.   
    677.     // 得到设备句柄   
    678.     pDevice = alcOpenDevice(deviceName);  
    679.   
    680.     // 得到设备说明.  
    681.     deviceSpecifier = alcGetString(pDevice, ALC_DEVICE_SPECIFIER);  
    682.   
    683.     printf("Using device '%s'./n", szDeviceSpecifier);  
    684.   
    685.     // 建立声音文本描述.  
    686.     pContext = alcCreateContext(pDevice, NULL);  
    687.   
    688.     // 设置行为文本描述.  
    689.     alcMakeContextCurrent(pContext);  
    690.   
    691.     // 检查错误.  
    692.     if (alcGetError() != ALC_NO_ERROR)  
    693.         return AL_FALSE;  
    694.   
    695.     return AL_TRUE;  
    696. }  
    697.   
    698. //这是来自上一章的代码。首先，我们得到 "DirectSound3D"设备的句柄，然后获得用  
    699. //于程序的表明文本描述。这个文本描述设置当前，函数将检查在我们返回成功前，是否出错。  
    700.   
    701. void ExitOpenAL()  
    702. {  
    703.     ALCcontext* pCurContext;  
    704.     ALCdevice* pCurDevice;  
    705.   
    706.     // 得到当前文本描述  
    707.     pCurContext = alcGetCurrentContext();  
    708.   
    709.     // 得到用于当前文本描述的设备?  
    710.     pCurDevice = alcGetContextsDevice(pCurContext);  
    711.   
    712.     // 重置当前文本描述为NULL  
    713.     alcMakeContextCurrent(NULL);  
    714.   
    715.     //释放文本描述和设备  
    716.     alcDestroyContext(pCurContext);  
    717.     alcCloseDevice(pCurDevice);  
    718. }  
    719.   
    720. //我们用和释放的文本描述和设备将收回。另外，在OPENAL暂停程序时，设置当前  
    721. //文本描述为NULL。但是这些都不可预料。如果你用了多个文本描述，你也许需要更  
    722. //好的方法来做这些事。我将介绍一些比较好的方法。  
    723.   
    724. ALboolean LoadALData()  
    725. {  
    726.     // 导入的变量  
    727.     ALenum format;  
    728.     ALsizei size;  
    729.     ALvoid* data;  
    730.     ALsizei freq;  
    731.     ALboolean loop;  
    732.   
    733.     // 装载WAV文件到缓冲区  
    734.     alGenBuffers(NUM_BUFFERS, Buffers);  
    735.   
    736.     if(alGetError() != AL_NO_ERROR)  
    737.         return AL_FALSE;  
    738.   
    739.     alutLoadWAVFile("wavdata/thunder.wav", &format, &data, &size, &freq, &loop);  
    740.     alBufferData(Buffers[THUNDER], format, data, size, freq);  
    741.     alutUnloadWAV(format, data, size, freq);  
    742.   
    743.     alutLoadWAVFile("wavdata/waterdrop.wav", &format, &data, &size, &freq, &loop);  
    744.     alBufferData(Buffers[WATERDROP], format, data, size, freq);  
    745.     alutUnloadWAV(format, data, size, freq);  
    746.   
    747.     alutLoadWAVFile("wavdata/stream.wav", &format, &data, &size, &freq, &loop);  
    748.     alBufferData(Buffers[STREAM], format, data, size, freq);  
    749.     alutUnloadWAV(format, data, size, freq);  
    750.   
    751.     alutLoadWAVFile("wavdata/rain.wav", &format, &data, &size, &freq, &loop);  
    752.     alBufferData(Buffers[RAIN], format, data, size, freq);  
    753.     alutUnloadWAV(format, data, size, freq);  
    754.   
    755.     alutLoadWAVFile("wavdata/ocean.wav", &format, &data, &size, &freq, &loop);  
    756.     alBufferData(Buffers[OCEAN], format, data, size, freq);  
    757.     alutUnloadWAV(format, data, size, freq);  
    758.   
    759.     alutLoadWAVFile("wavdata/chimes.wav", &format, &data, &size, &freq, &loop);  
    760.     alBufferData(Buffers[CHIMES], format, data, size, freq);  
    761.     alutUnloadWAV(format, data, size, freq);  
    762.   
    763.     // 错误检测  
    764.     if (alGetError() != AL_NO_ERROR)  
    765.         return AL_FALSE;  
    766.   
    767.     return AL_TRUE;  
    768. }  
    769.   
    770. //在这个函数中，我将移动产生源，这是因为我们将一个一个的初始化。  
    771. void AddSource(ALint type)  
    772. {  
    773.     ALuint source;  
    774.   
    775.     alGenSources(1, &source);  
    776.   
    777.     if (alGetError() != AL_NO_ERROR)  
    778.     {  
    779.         printf("Error generating audio source.");  
    780.         exit(-1);  
    781.     }  
    782.   
    783.     alSourcei (source, AL_BUFFER, Buffers[type]);  
    784.     alSourcef (source, AL_PITCH, 1.0 );  
    785.     alSourcef (source, AL_GAIN, 1.0 );  
    786.     alSourcefv(source, AL_POSITION, SourcePos );  
    787.     alSourcefv(source, AL_VELOCITY, SourceVel );  
    788.     alSourcei (source, AL_LOOPING, AL_TRUE );  
    789.   
    790.     alSourcePlay(source);  
    791.   
    792.     Sources.push_back(source);  
    793. }  
    794.   
    795. //这个函数将产生源，他将为我们载入的缓冲区中的一个产生一个源。用‘TYPE’表示缓冲区，  
    796. //我们文章开始建立的指令将做这些事情。然后做错误检测，确定源能播放。如果源不能将退出。  
    797.   
    798. void KillALData()  
    799. {  
    800.     for (vector<ALuint>::iterator iter = Sources.begin(); iter != Sources.end(); ++iter)  
    801.         alDeleteSources(1, iter);  
    802.     Sources.clear();  
    803.     alDeleteBuffers(NUM_BUFFERS, Buffers);  
    804.     ExitOpenAL();  
    805. }  
    806.   
    807. //这个函数将修改STL表。我们不得不删除每个源并且清除表上的内容。  
    808.   
    809. ALubyte c = ' ';  
    810.   
    811. while (c != 'q')  
    812. {  
    813.     c = getche();  
    814.   
    815.     switch (c)  
    816.     {  
    817.         case 'w': AddSource(WATERDROP); break;  
    818.         case 't': AddSource(THUNDER); break;  
    819.         case 's': AddSource(STREAM); break;  
    820.         case 'r': AddSource(RAIN); break;  
    821.         case 'o': AddSource(OCEAN); break;  
    822.         case 'c': AddSource(CHIMES); break;  
    823.     };  
    824. }  
    825.   
    826. //这是程序的主函数，他等待键盘输入，建立源，播放声音。  
    827. /* 
    828. The program can be expanded for using more wav files, and have the added feature of placing 
    829. the sources around the scene in arbitrary positions. You could even allow for sources to  
    830. play with a given frequency rather than have them loop. However this would require GUI routines 
    831. that go beyond the scope of the tutorial. A full featured "Weathering Engine" would be a nifty  
    832. program to make though. ;) 
    833. */  
    834.    
    835. /***************************************************************************************** 
    836. 高级导入和错误处理 
    837.  
    838. 虽然现在，我们能做出一些漂亮的东西，但是这些都没有要求我们精确的处理他们。原因是 
    839. 我们写的代码是为了便于学习。因此，我们将移进一些高级的东西。最重要的是我们将学习 
    840. 更高级的处理错误的方法。我们也将重新改写载入声音数据的方法。我们首先考虑这些函数 
    841. 将做什么。 
    842. ********************************************************************************/  
    843.   
    844. string GetALErrorString(ALenum err);  
    845. /* 
    846. * 1) 识别错误代码 
    847. * 2)返回错误 
    848. */  
    849.   
    850.   
    851. ALuint LoadALBuffer(string path);  
    852. /* 
    853. * 1) 建立缓冲区 
    854. * 2) 导入WAV文件 
    855. * 3) 返回缓冲区ID 
    856. */  
    857.   
    858. ALuint GetLoadedALBuffer(string path);  
    859. /* 
    860. * 1) 检测文件是否载入 
    861. * 2) 如果载入，返回缓冲区ID 
    862. * 3) 如果失败，重新载入并返回缓冲区ID  
    863. */  
    864.   
    865. ALuint LoadALSample(string path, bool loop);  
    866. /* 
    867. * 1) 建立源 
    868. * 2) 调用‘GtLoadedALBuffer' 中的’PATH‘加载文件? 
    869. * 3)返回源ID 
    870. */  
    871.   
    872. void KillALLoadedData();  
    873. /* 
    874. * 1)释放数据? 
    875. */  
    876.   
    877. bool LoadALData();  
    878. /* 
    879. * 1) 载入所有的源和缓冲区 
    880. */  
    881.   
    882. void KillALData();  
    883. /* 
    884. * 1) 释放所有的缓冲区 
    885. * 2) 释放所有的源 
    886. */  
    887.   
    888. vector<string> LoadedFiles; // 文件路径  
    889. vector<ALuint> Buffers; // 缓冲区.  
    890. vector<ALuint> Sources; // 源.  
    891.   
    892. //看一下这个函数，想一下他做什么。我们试着建立一个关于缓冲区和源的系统。  
    893. //我们能调用来自文件的源并且系统能处理缓冲区的建立，因此，我们不用复制  
    894. //缓冲区。系统将处理缓冲区并且将有效的处理资源。  
    895.   
    896. string GetALErrorString(ALenum err)  
    897. {  
    898.     switch(err)  
    899.     {  
    900.     case AL_NO_ERROR:  
    901.         return string("AL_NO_ERROR");  
    902.         break;  
    903.   
    904.     case AL_INVALID_NAME:  
    905.         return string("AL_INVALID_NAME");  
    906.         break;  
    907.   
    908.     case AL_INVALID_ENUM:  
    909.         return string("AL_INVALID_ENUM");  
    910.         break;  
    911.   
    912.     case AL_INVALID_value:  
    913.         return string("AL_INVALID_value");  
    914.         break;  
    915.   
    916.     case AL_INVALID_OPERATION:  
    917.         return string("AL_INVALID_OPERATION");  
    918.         break;  
    919.   
    920.     case AL_OUT_OF_MEMORY:  
    921.         return string("AL_OUT_OF_MEMORY");  
    922.         break;  
    923.     };  
    924. }  
    925. //函数的功能是转换错误代码为字符。OPENAL SDK说返回'AL_OUT_OF_MEMORY' 是错误的，  
    926. //我们应认真对待所有错误，使我们的代码用最新的版本处理数据。  
    927.   
    928. string GetALCErrorString(ALenum err)  
    929. {  
    930.     switch(err)  
    931.     {  
    932.     case ALC_NO_ERROR:  
    933.         return string("AL_NO_ERROR");  
    934.         break;  
    935.   
    936.     case ALC_INVALID_DEVICE:  
    937.         return string("ALC_INVALID_DEVICE");  
    938.         break;  
    939.   
    940.     case ALC_INVALID_CONTEXT:  
    941.         return string("ALC_INVALID_CONTEXT");  
    942.         break;  
    943.   
    944.     case ALC_INVALID_ENUM:  
    945.         return string("ALC_INVALID_ENUM");  
    946.         break;  
    947.   
    948.     case ALC_INVALID_value:  
    949.         return string("ALC_INVALID_value");  
    950.         break;  
    951.   
    952.     case ALC_OUT_OF_MEMORY:  
    953.         return string("ALC_OUT_OF_MEMORY");  
    954.         break;  
    955.     };  
    956. }  
    957.   
    958. //这个函数的功能是说明ALC错误。OPENAL和ALC共享ID，但是他们在一些功能上不相等。  
    959. //函数 'alGetError'应注意：OPENAL SDK定义一次只能得到一个错误。当函数被调用时，  
    960. //他返回他得到的第一个错误，并且清错误为'AL_NO_ERROR'  
    961.   
    962. ALuint LoadALBuffer(string path)  
    963. {  
    964.     // Variables to store data which defines the buffer.  
    965.     ALenum format;  
    966.     ALsizei size;  
    967.     ALvoid* data;  
    968.     ALsizei freq;  
    969.     ALboolean loop;  
    970.   
    971.     // 缓冲区ID和错误检测变量  
    972.     ALuint buffer;  
    973.     ALenum result;  
    974.   
    975.     // 产生缓冲区，看他是否成功建立.  
    976.     alGenBuffers(1, &buffer);  
    977.   
    978.     if ((result = alGetError()) != AL_NO_ERROR)  
    979.         throw GetALErrorString(result);  
    980.   
    981.     // 读WAV数据，检测是否成功。  
    982.     alutLoadWAVFile(szFilePath, &format, &data, &size, &freq, &loop);  
    983.   
    984.     if ((result = alGetError()) != AL_NO_ERROR)  
    985.         throw GetALErrorString(result);  
    986.   
    987.     // 装载WAV数据，检测是否成功  
    988.     alBufferData(buffer, format, data, size, freq);  
    989.   
    990.     if ((result = alGetError()) != AL_NO_ERROR)  
    991.         throw GetALErrorString(result);  
    992.   
    993.     // 出去临时数据  
    994.     alutUnloadWAV(format, data, size, freq);  
    995.   
    996.     if ((result = alGetError()) != AL_NO_ERROR)  
    997.         throw GetALErrorString(result);  
    998.   
    999.     //返回缓冲区ID  
    1000.     return buffer;  
    1001. }  
    1002.   
    1003. //在导入数据时，我们做了错误检测。没有任何错误将通过。当数据导入时，没有足够  
    1004. //的内存，WAV文件可能不退出，或者OPENAL函数中的错误数据将产生错误。  
    1005.   
    1006. ALuint GetLoadedALBuffer(string path)  
    1007. {  
    1008.     int count = 0; // 'count' 表明缓冲区列表  
    1009.   
    1010.     ALuint buffer; // 用于导入缓冲区的缓冲区ID  
    1011.   
    1012.   
    1013.     // 重复列表中的每个文件  
    1014.     for(vector<string>::iterator iter = LoadedFiles.begin(); iter != LoadedFiles.end(); ++iter, count++)  
    1015.     {  
    1016.         // 如果文件已经导入，返回他的缓冲区ID.  
    1017.         if(*iter == path)  
    1018.             return Buffers[count];  
    1019.     }  
    1020.   
    1021.     // 如果文件是新的，我们将为他建立缓冲区.  
    1022.     buffer = LoadALBuffer(path);  
    1023.   
    1024.     // 添加缓冲区到列表，记录他已添加.  
    1025.     Buffers.push_back(buffer);  
    1026.   
    1027.     LoadedFiles.push_back(path);  
    1028.   
    1029.     return buffer;  
    1030. }  
    1031.   
    1032. //人们的麻烦通常在这里，但他确实不是很复杂。我们通过包含文件路径的列表来检索。  
    1033. //如果其中一个符合要求，我们直接返回他的ID到缓冲区。我们通过这个函数导入我们  
    1034. //的文件，这样就避免了复制时的浪费。每个文件应该保证在自己的列表中。'Buffers'  
    1035. //表类士于'LoadedFiles'表。  
    1036.   
    1037. ALuint LoadALSample(string path, bool loop)  
    1038. {  
    1039.     ALuint source;  
    1040.     ALuint buffer;  
    1041.     ALenum result;  
    1042.   
    1043.     // 得到文件缓冲区ID   
    1044.     buffer = GetLoadedALBuffer(path);  
    1045.   
    1046.     // 产生源.  
    1047.     alGenSources(1 &source);  
    1048.   
    1049.     if ((result = alGetError()) != AL_NO_ERROR)  
    1050.         throw GetALErrorString(result);  
    1051.   
    1052.     // 设置源属性.  
    1053.     alSourcei (source, AL_BUFFER, buffer );  
    1054.     alSourcef (source, AL_PITCH, 1.0 );  
    1055.     alSourcef (source, AL_GAIN, 1.0 );  
    1056.     alSourcefv(source, AL_POSITION, SourcePos);  
    1057.     alSourcefv(source, AL_VELOCITY, SourceVel);  
    1058.     alSourcei (source, AL_LOOPING, loop );  
    1059.   
    1060.     // 保存源ID.  
    1061.     Sources.push_back(source);  
    1062.   
    1063.     // 返回源ID.  
    1064.     return source;  
    1065. }  
    1066.   
    1067. //现在我们已经建立处理缓冲区的系统，我们需要得到源的伸展。在这里，我们得到了  
    1068. //导入文件的缓冲区ID。这个缓冲区是一个新源，我们保存他并返回。  
    1069.   
    1070. void KillALLoadedData()  
    1071. {  
    1072.     LoadedFiles.clear();  
    1073. }  
    1074. //'gLoadedFilesv'存储在导入缓冲区的WAV文件的路径下，我们要处理他。  
    1075. // 源ID's.  
    1076.   
    1077. ALuint phaser1;  
    1078. ALuint phaser2;  
    1079.   
    1080. void LoadALData()  
    1081. {  
    1082.     // 你的应用在这里，不用担心缓冲区。   
    1083.     phaser1 = LoadALSample("wavdata/phaser.wav", false);  
    1084.     phaser2 = LoadALSample("wavdata/phaser.wav", true);  
    1085.   
    1086.     KillLoadedALData();  
    1087. }  
    1088.   
    1089. //他表示用于程序的所有的WAV应用的程序。我们能调用导入相同的WAV文件到不同的源，  
    1090. //'phaser.wav' 的缓冲区建立了一次，'gPhaser1' and 'gPhaser2' 用于背景音乐的缓冲区。  
    1091. //不用处理缓冲区因为系统会自动处理。  
    1092.   
    1093. void KillALData()  
    1094. {  
    1095.     // 释放所有的缓冲区数据.  
    1096.     for (vector<ALuint>::iterator iter = Buffers.begin(); iter != Buffers.end(); ++iter)  
    1097.         alDeleteBuffers(1, iter);  
    1098.   
    1099.     // 释放所有的源数据.  
    1100.     for (vector<ALuint>::iterator iter = Sources.begin(); iter != Sources.end(); ++iter)  
    1101.         alDeleteBuffers(1, iter);  
    1102.   
    1103.     // 清除列表.  
    1104.     Buffers.clear();  
    1105.     Sources.clear();  
    1106. }  
    1107.     //我们已完成了前述的工作。然后就是释放他们。  
    1108. try  
    1109. {  
    1110.     InitOpenAL();  
    1111.   
    1112.     LoadALData();  
    1113. }  
    1114. catch(string err)  
    1115. {  
    1116.     cout << "OpenAL error: " << err.c_str() << endl;  
    1117. }  
    1118. //如果导入源时出错，我们将改正他。这将借助程序返回的报告。  
    1119. /* 
    1120. That's it. A more advanced way of reporting errors, and a more robust way of loading  
    1121. your wav files. We may find we need to do some modifications in the future to allow  
    1122. for more flexibility, but for now we will be using this source for basic file loading  
    1123. in future tutorials. Expect future tutorials to expand on this code. 
    1124.  
    1125. See the Java Bindings for OpenAL page for the Java version of this tutorial (adapted  
    1126. by: Athomas Goldberg) 
    1127. */  

你可能感兴趣的:(openal教程)

  • 基于医疗知识图谱的问答系统 基于知识图谱的多轮问答 附完整代码数据详细教程 计算机毕设论文 深度学习-自然语言处理nlp医疗知识知识图谱Neo4j多轮问答
    这个项目已实现的功能：1.闲聊类的单论对话2.基于知识图谱的多轮问答数据链接：链接：https://pan.baidu.com/s/1oPr1m8aaIeoMu53OIEULPg提取码：fh39一、项目来源由于之前用Rasa构建过对话系统，因此一直想脱离Rasa这个开源框架，从底层开始构建一个可以实现相似功能的对话系统，毕竟框架用的再溜，都不如自己做一遍。恰巧在Rasa群里看到了前辈分享的一个项目
  • Ubuntu 系统 LVM 逻辑卷扩容教程 运维linuxubuntu
    Ubuntu系统LVM逻辑卷扩容教程前言在Linux系统中，LVM（LogicalVolumeManager）是一种逻辑卷管理工具，允许管理员动态调整磁盘空间，而无需重启系统。本文将详细介绍如何使用LVM扩容逻辑卷，以实现灵活的磁盘管理。准备工作备份重要数据任何磁盘操作都有风险，建议提前备份关键数据。确认当前磁盘状态确保已扩展物理磁盘或添加了新磁盘（虚拟机需扩展虚拟磁盘后重启系统）。步骤1：检查当
  • 知识图谱大模型系列之 11什么是 Neo4j LLM 知识图谱构建器？ 知识大胖 NVIDIAGPU和大语言模型开发教程知识图谱neo4j人工智能llm
    简介LLM知识图谱构建器是Neo4j的GraphRAG生态系统工具之一，可让您将非结构化数据转换为动态知识图谱。它与检索增强生成(RAG)聊天机器人集成，可实现自然语言查询和对数据的可解释洞察。推荐文章《使用ChatGPT从视频脚本创建知识图谱，使用GPT-4作为领域专家来帮助您从视频转录中提取知识（教程含完整源码）》权重2，知识图谱类《赋能知识图谱形成：利用BERTopic、DataMapPlo
  • ubuntu安装k8s qq_41369135 ubuntukuberneteslinux
    centos：centos：K8Sv1.28.2集群搭建-docker版-一毛丶丶-博客园centos：Kubernetes详细安装教程_kubernetes安装-CSDN博客准备工作：1、主机名解析：确保每台机器的主机名能够被解析（可以通过/etc/hosts或DNS）。#三台机子分别执行sudohostnamectlset-hostnamek8s-mastersudohostnamectlse
  • Spring Security（六）RBAC 结构实现 是晓周哦 Spring-Securityspringjava后端springboot安全架构springcloud
    博主前言：本以为这个就是代替传统jwt的插件，没想到复杂程度如此之高。SpringSecurity本身是个高度自定义化的组件，必须花时间重点学习一下。以下为个人配置学习的流程，从零到权限管理、redis嵌入等步骤。本文基于尚硅谷的SpringSecurity教程学习，文章与原教程有不小出入，仅供参考。B站视频链接：尚硅谷Java项目SpringSecurity+OAuth2权限管理实战教程RBAC
  • 从Android Studio上传项目到Github的步骤教程 良辰吉日943 androidstudiogithubgithubandroidstudiogit
    AndroidStudio上传项目到Github的步骤教程最近要做Android课设，老师说使用Gitee或GitHub等代码托管平台可以加分。所以本着不要白不要的原则试一试，随便记录一下步骤，方便小白上手。过程很简单，所以就不放图片了。1.在电脑上安装Git软件从官网下载Git，一路默认设置完成安装；打开GITBash命令行，手动输入，引号内改成自己的信息：$gitconfig--globalu
  • 【Python实用技巧】爬取数据保存到Excel中 「已注销」 pythonpython爬虫开发语言
    嗨嗨，大家好~今天来给你们分享一个小技巧如何用python爬取数据保存到Excel中话不多说，马上开始需要源码、教程，或者是自己有关python不懂的问题，都可以来这里哦https://jq.qq.com/?_wv=1027&k=s5bZE0K3这里还有学习资料与免费课程领取开发工具Python版本：3.6相关模块：importrequestsfromlxmlimportetreeimportti
  • C# 教程 目录 .Net学习 C#教程C#教程
    之前有感于VB.Net书籍提供的学习内容要么很低级，要么很高级，缺少中间层级。低级的根本就不能带你进入编程的殿堂，知其然不知其所以然；而高级的你可能看看就倦怠了，因为太高深了，不易看懂。还没有开始就会打退堂鼓，因而制作了VB.Net的教程：《VB.Net循序渐进》（VB.NetStepByStep）。虽然就我个人而言，用惯了VB，但是无可否认的是C#的势头已经超越VB，作为程序员的我们一是需要与时
  • Windows下Kanass简明安装教程(入门级) 烟雨下扬州 jira
    Kanass是一款国产开源免费的项目管理工具，工具简洁易用、开源免费。本文将介绍如何在windows下安装配置kanass。1、安装下载，下载地址:Kanass-下载，下载安装包如tiklab-kanass.1.0.4.exe安装，双击exe文件安装应用启动，双击应用程序或桌面Kanass应用图标，启动应用2、登录应用启动成功控制台会显示应用访问地址，浏览器输入http://ip:9500打开应用
  • 社交媒体文章内容与评论抓取：Python 爬虫实战教程 Python爬虫项目 2025年爬虫实战项目媒体python爬虫
    社交媒体平台是全球信息交流的重要渠道，成千上万的文章、评论和动态每天都在各大平台上发布。这些数据包含了丰富的用户行为、意见和情感分析的潜力，因此抓取社交媒体平台上的文章内容与评论已成为数据分析、市场研究和情感分析等领域的重要任务。本篇教程将为大家详细介绍如何使用Python编写爬虫，抓取社交媒体平台（如微博、Twitter、Facebook等）的文章内容和评论。我们将涵盖如何使用现代爬虫技术，包括
  • 【MySQL】在 Centos7 环境安装 MySQL -- 详细完整教程 m0_74823842 面试学习路线阿里巴巴mysqlwebviewandroid
    说明：安装与卸载中，用户全部切换成为root，一旦安装，普通用户就能使用。一、卸载内置环境1、卸载不要的环境[root@VM-8-5-centos~]$psajx|grepmariadb#先检查是否有mariadb存在13134148441484313134pts/014843S+10050:00grep--color=automariadb19010191871901019010?-1Sl271
  • Spring Boot2.x教程：（八）优雅地在工具类中使用@Autowired注解 欧阳方超 SpringBootSpringCloud开发遇到的小问题springboot后端java
    优雅地在工具类中使用@Autowired注解1、概述2、理解@Autowired基本用法3、静态方法与@Autowired的冲突4、优雅解决方案4.1、使用@PostConstruct4.2、使用构造器注入5、总结大家好，我是欧阳方超，可以扫描下方二维码关注我的公众号“欧阳方超”，后续内容将在公众号首发。1、概述在SpringBoot中，使用@Autowired注解来注入Bean是一个常见的做法。
  • 《深入浅出多模态》 （五）：多模态经典模型ALBEF GoAI 深入浅出多模态多模态大模型LLM深度学习人工智能
    AI学习星球推荐：GoAI的学习社区知识星球是一个致力于提供《机器学习|深度学习|CV|NLP|大模型|多模态|AIGC》各个最新AI方向综述、论文等成体系的学习资料，配有全面而有深度的专栏内容，包括不限于前沿论文解读、资料共享、行业最新动态以、实践教程、求职相关（简历撰写技巧、面经资料与心得）多方面综合学习平台，强烈推荐AI小白及AI爱好者学习，性价比非常高！加入星球➡️点击链接✨专栏介绍：</
  • KTransformers：告别天价显卡！国产框架让单卡24G显存跑DeepSeek-R1 671B大模型：推理速度飙升28倍 蚝油菜花 每日AI项目与应用实例人工智能开源
    ❤️如果你也关注AI的发展现状，且对AI应用开发感兴趣，我会每日分享大模型与AI领域的开源项目和应用，提供运行实例和实用教程，帮助你快速上手AI技术！微信公众号｜搜一搜：蚝油菜花“还在为千亿模型租天价显卡？清华团队用CPU/GPU协同计算，让4090跑起671B参数全量模型！”大家好，我是蚝油菜花。如果你也经历过——看着API调用账单瑟瑟发抖，微调一次模型吃掉半月算力预算️盯着OOM报错抓狂，为了
  • 【vLLM 学习】安装
    vLLM是一款专为大语言模型推理加速而设计的框架，实现了KV缓存内存几乎零浪费，解决了内存管理瓶颈问题。更多vLLM中文文档及教程可访问→https://vllm.hyper.ai/vLLM是一个Python库，包含预编译的C++和CUDA(12.1)二进制文件。依赖环境操作系统：LinuxPython：3.8-3.12GPU：计算能力7.0或更高（例如V100、T4、RTX20xx、A100、L
  • Python 潮流周刊#89：Python 3.14 的新型解释器！（摘要） python
    本周刊由Python猫出品，精心筛选国内外的250+信息源，为你挑选最值得分享的文章、教程、开源项目、软件工具、播客和视频、热门话题等内容。愿景：帮助所有读者精进Python技术，并增长职业和副业的收入。分享了12篇文章，12个开源项目，2则热门讨论以下是本期摘要：文章&教程①Python3.14新特性：一种新型解释器②高效扩展Python：PyO3与Rust实战③使用uv开发和安装PythonC
  • 从0开始的操作系统手搓教程 4：做好准备，跳到加载器（Loader） charlie114514191 从0开始的操作系统教程学习汇编操作系统手搓教程bochs调试MBR
    目录为什么要加载Loader，Loader是干什么的？上菜！NASM的预处理语句%include包含其他文件%define定义一个常量%macro来定义一个代码宏进一步说明常见的NASM的常见的语法和指令进一步理解我们的实模式关于NASM中对于-I指令的使用办法关于bochs的高级调试手段步入正轨：对硬盘进行系统编程系统编程中对硬盘编程的办法对硬盘进行编程最后一瞥添加一个Loader.S作为测试修
  • 从0开始的操作系统手搓教程 附二——调试我们的操作系统（bochs调试小记） charlie114514191 从0开始的操作系统教程操作系统计算机架构bochs调试
    目录我们可以调试OS的什么理解bochs调试的单位内存尺度查看内存内容disasm作为反汇编指令查看我们正在执行的内容打断点showint查看中断info其他指令我们当然要学习如何使用bochs来调试我们的操作系统。毕竟伴随代码量的增大，出错的概率自然也会直线的上升。我们可以调试OS的什么我们可以查看页表，查看GDT,IDT等后面我们编写操作系统会使用到的数据结构可以看到当前线程流的栈的数据可以反
  • python后端调用Deep Seek API YY_oot pythonai语言模型
    python后端调用DeepSeekAPI需要依次下载●Ollama●DeepseekR1LLM模型●嵌入模型nomic-embed-text/bge-m3●AnythingLLM参考教程：DeepseekR1打造本地化RAG知识库:安装部署使用详细教程手把手教你：deepseekR1基于AnythingLLMAPI调用本地知识库python调用anythingllm的APIimportreque
  • python创建sqlite3数据库_SQLite – Python | 菜鸟教程 weixin_39683144
    SQLite-Python安装SQLite3可使用sqlite3模块与Python进行集成。sqlite3模块是由GerhardHaring编写的。它提供了一个与PEP249描述的DB-API2.0规范兼容的SQL接口。您不需要单独安装该模块，因为Python2.5.x以上版本默认自带了该模块。为了使用sqlite3模块，您首先必须创建一个表示数据库的连接对象，然后您可以有选择地创建光标对象，这将
  • deepseek本地部署指南（解决下载速度慢） 灶龙 人工智能deepseek人工智能本地部署
    很多人都照着网上的教程去下载，但是网上的下载Ollama模型都下载不了，所以我打算写一篇不同的deepseek本地部署指南。第一步：下载奇游加速器奇游加速器下载网址下载奇游加速器后进行安装，然后搜索Deepseek点击进去，不要着急充值，点击右上角口令，输入奇游111就可以白嫖三天的有效期。第二步：下载Ollama框架点进Deepseek后，先点击一键加速（中途不要关闭），在点击右边的游戏服务中的
  • Open3D C++系列教程 （七）继承窗口类 吉拉尔 Open3D-GUIc++开发语言guiopen3d
    Open3DC++系列教程（七）继承窗口类前置：Open3DC++系列教程（一）环境搭建Open3DC++系列教程（二）第一个GUI窗口Open3DC++系列教程（三）关于程序异常退出的探讨Open3DC++系列教程（四）动画Tick事件Open3DC++系列教程（五）创建菜单栏Open3DC++系列教程（六）菜单栏-文件拾取在之前的几节中介绍了直接在main中使用gui::Window和gui:
  • 大模型产品Deepseek（七）、可视化本地知识库搭建详细教程（Cherry Studio） 伯牙碎琴 大模型DeepSeekAI大模型知识库
    完整教程：使用CherryStudio配置OllamaAPI并搭建知识库在本节教程中，我们将通过CherryStudio配置OllamaAPI，并安装嵌入模型bge-m3，以实现知识库的搭建与智能问答功能。具体内容包括CherryStudio的安装、嵌入模型配置、OllamaAPI配置、创建知识库及基于该知识库和通用大模型的提问示例。CherryStudio介绍看这篇文章1.准备工作在开始之前，确
  • opencv全面详解教程 听忆. 机器学习深度学习计算机视觉人工智能
    opencv全面详解教程1.OpenCV简介2.安装OpenCV2.1使用pip安装（适用于Python）2.2通过conda安装2.3从源码编译（高级）3.OpenCV基本操作3.1读取和显示图像3.2保存图像3.3视频处理4.图像处理操作4.1调整大小和裁剪4.2颜色空间转换4.3图像平滑（滤波）4.4边缘检测5.形态学操作6.特征检测与匹配6.1角点检测（Harris）6.2SIFT、SUR
  • 记录：Windows找不到文件gpedit.msc教程方案|亲测有效 bug菌¹ 全栈Bug调优(实战版)#CSDN问答解惑(全栈版)windowsgpedit.msc
    ‍作者：bug菌✏️博客：CSDN、掘金、infoQ、51CTO等简介：CSDN博客专家，历届博客之星Top30，掘金年度人气作者No.40，掘金/InfoQ/51CTO等社区优质创作者，全网粉丝合计10w+，对一切技术感兴趣，重心偏Java方向；硬核公众号「猿圈奇妙屋」，欢迎小伙伴们的加入，一起秃头，一起变强。…✍️温馨提醒：本文字数：1699字,阅读完需：约5分钟一、前言组策略是一个非常方便的
  • 一步解决Ubuntu中无法使用git clone的问题 AI_茗 gitgithub服务器
    在网上找了很多教程都无法解决，最后用了一行命令成功解决gitconfig--globalurl."https://github.com".insteadOfgit://github.com输入这行命令，之后就可以使用gitclone了
  • 利用Python pandas 数据清洗详细教程 小白教程 python运维数据库pythonpandas开发语言
    文章目录前言一、环境搭建1.下载Python2.安装Python3使用pip安装Pandas二、使用步骤1.读取数据2.处理缺失值3.处理重复值4.处理异常值5.数据类型转换6.处理不一致的数据前言pandas是Python数据处理与分析的得力工具，功能强大，是数据从业者进行数据清洗的首选。本教程将系统介绍用pandas进行数据清洗，涵盖数据读取、缺失值与重复值处理、异常值修正、数据类型转换等要点
  • 【案例教程】无人机遥感图像拼接及处理 weixin_贾 GIS无人机遥感无人机图像拼接多光谱Photoscan软件
    无人机遥感图像采集流程:无人机遥感监测介绍无人机航线规划设计无人机飞行软件操作无人机航拍一般过程无人机遥感图像拼接软件操作:Photoscan软件介绍软件基本操作与实践遥感图像拼接的一般流程遥感图像分组拼接与点云分类无人机遥感图像拼接典型案例：基于无人机航拍的单体三维建模案例基于普通相机拍摄的单体三维建模案例基于无人机航拍的正射影像制图案例利用批处理实现无人机航拍制图案例利用地面控制点提高制图精度
  • 非标准纸张Word文件无损转换为A4标准纸张的完整教程 huluang 文档优化格式
    在日常办公中，常会遇到需要将非标准纸张大小的Word文档（如A3、B5等）调整为A4标准尺寸的需求。直接修改Word页面设置可能导致排版错乱，而通过AdobeAcrobat的印前检查功能可实现内容格式无损缩放。以下是详细操作流程：一、Word转PDF：保留原始布局保存为PDF格式在Word中打开文档，点击「文件」→「另存为」→选择保存类型为PDF（.pdf）。关键点：确保不调整Word原有页面设置
  • linux mesa 教程,Ubuntu 13.04使用Mesa weixin_39799565 UbuntuOpenGLCMake显卡信息Mesa
    以前写过一些关于如何使用Mesa的文章，如今再试。Ubuntu13.04下有些东西已经变了。首先安装：sudoapt-getinstalllibgl1-mesa-devsudoapt-getinstalllibglu1-mesa-devsudoapt-getinstallfreeglut3-dev现在不用NetBeans了，用CMake创建工程。根目录下的CMakeLists.txt内容：cmak
  • 设计模式介绍 tntxia 设计模式
    设计模式来源于土木工程师 克里斯托弗 亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。 亚历山大与萨拉-石川佳纯和穆雷 西乐弗斯坦合作
  • android高级组件使用(一) 百合不是茶 androidRatingBarSpinner
    1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。 使用AutoCompleteTex
  • [网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
              如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题.....        这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入  &nbs
  • 自写简单Redis内存统计shell 商人shang Linux shell统计Redis内存
    #!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
  • 单例模式(饿汉 vs懒汉) oloz 单例模式
    package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《 懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
  • springMvc json支持 杨白白 json springmvc
    1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
  • android播放，掃描添加本地音頻文件 小桔子
            最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
  • oracle常用命令 aichenglong oracledba常用命令
    1 创建临时表空间 create temporary tablespace user_temp  tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m  autoextend on  next 50m maxsize 20480m  extent management local
  • 25个Eclipse插件 AILIKES eclipse插件
    提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
  • Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
    原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。   1.新建注解：   ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
  • 《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
    “闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》         看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
  • AngularJS Module类的方法 bijian1013 JavaScriptAngularJSModule
            AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。 一.Main方法在哪里         如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
  • [Maven学习笔记七]Maven插件和目标 bit1129 maven插件
    插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标   使用插件和目标使得我们可以干预
  • 【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
    1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度   2. 多用户资源共享的调度
  • Nginx使用Linux内存加速静态文件访问 ronin47
    Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。 先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
  • 关于Unity3D中的Shader的知识 brotherlamp unityunity资料unity教程unity视频unity自学
    首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
  • CopyOnWriteArrayList vs ArrayList bylijinnan java
    package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
  • 内存中栈和堆的区别 chicony 内存
    1、内存分配方面：     堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。     栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
  • 回答一位网友对Scala的提问 chenchao051 scalamap
    本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。 问题 写道 对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢    先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
  • mysql 取每组前几条记录 daizj mysql分组最大值最小值每组三条记录
    一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a  WHERE 3> (SELECT COUNT(*) FROM  tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
  • HTTP深入浅出 http请求 dcj3sjt126com http
      HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
  • 判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
    把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。 　　我这里总结了判断记录是否存在的常用方法： 　　sql语句： select   count ( * )  from  tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
  • 对HTML XML的一点认识 e200702084 htmlxml
    感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。 节点 根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的： 整个文档是一个文档节点 每个 HTML 标签是一个元素节点 包含在 HTML 元素中的文本是文本节点 每一个 HTML 属性是一个属性节点 注释属于注释节点 Node 层次
  • jquery分页插件 genaiwei jqueryWeb前端分页插件
    //jquery页码控件// 创建一个闭包    (function($) {      // 插件的定义      $.fn.pageTool = function(options) {        var totalPa
  • Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatisibatis区别联系
    一、为什么使用IBatis/Mybatis         对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
  • C中怎样合理决定使用那种整数类型？ 秋风扫落叶 c数据类型
    如果需要大数值(大于32767或小于32767), 使用long 型。 否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。 除此之外, 就使用 int 型。 如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。 但是, 要注意在表达式中混用有符号和无符号值的情况。    &nbs
  • maven问题 zhb8015 maven问题
      问题1： Eclipse 中 新建maven项目 无法添加src/main/java 问题    eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。     按照maven目录结构，添加src/main/ja
  • (二)androidpn-server tomcat版源码解析之--push消息处理 spjich javaandrodipn推送
    在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。 先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
  • 用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题 中华好儿孙 JavaScriptAjaxWeb上传文件FormData
    var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
  • mybatis常用jdbcType数据类型 ysj5125094 mybatismapperjdbcType
      MyBatis 通过包含的jdbcType 类型 BIT         FLOAT      CHAR          
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他