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教程)

  • Ubuntu下编译OpenWrt的详细教程 艾丽丝的爱情 ubuntulinux运维编程
    OpenWrt是一个基于Linux的嵌入式操作系统，常用于路由器等网络设备。本文将为您提供在Ubuntu操作系统下编译OpenWrt的完整教程。步骤1：安装必要的软件包首先，我们需要安装一些必要的软件包来支持OpenWrt的编译过程。在终端中运行以下命令来安装这些软件包：sudoaptupdatesudoaptinstallbuild-essentiallibncurses5-devzlib1g-
  • 学习使用 Git 和 GitHub 开发项目的教程推荐 vortex5 学习gitgithub
    Git和GitHub是现代软件开发中不可或缺的工具，无论你是个人开发者还是团队成员，掌握它们都能极大提升效率。本文精选了一系列优质教程资源，涵盖从基本Git命令到进阶多人协作的内容。这些教程既有文字形式，也有视频或交互式资源，适合不同学习风格的人。一、为何要学习Git和GitHub？Git是一个分布式版本控制系统，让你追踪代码变更、回滚错误并与他人协作；GitHub则将其扩展为一个云端平台，支持代
  • Promise 原理与实战：从基础到高级的完整教程 D.eL 前端工程化从无-通前端javascript
    一、前言：为什么会出现Promise?Promise的重要性我认为没有必要多说，概括起来就是五个字：必！须！得！掌！握！。而且还要掌握透彻，在实际的使用中，有非常多的应用场景我们不能立即知道应该如何继续往下执行。最常见的一个场景就是ajax请求，通俗来说，由于网速的不同，可能你得到返回值的时间也是不同的，这个时候我们就需要等待，结果出来了之后才知道怎么样继续下去。letxhr=newXMLHttp
  • 零基础怎么开始学网络安全（非常详细）零基础入门到精通，收藏这一篇就够了 程序员羊羊 web安全安全网络php学习
    一、学习建议1.了解基础概念：开始之前，了解网络安全的基本概念和术语是很重要的。你可以查找网络安全入门教程或在线课程，了解网络安全领域的基本概念，如黑客、漏洞、攻击类型等。2.网络基础知识：学习计算机网络基础知识，了解网络通信原理，不同网络协议（如TCP/IP）的工作方式，以及网络拓扑结构等。3.操作系统知识：了解常见的操作系统，特别是Windows和Linux。掌握基本的命令行操作和系统管理技能
  • 网络安全入门教程（非常详细）从零基础入门到精通，看完这一篇就够了 白帽黑客坤哥 web安全网络安全pythonwindows
    href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/kdoc_html_views-1a98987dfd.css"rel="stylesheet"/>href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/ck_htmledit_v
  • Deno入门教程：Node.js 的替代品 xiaoweids 编程语言JavaScriptnode.jsjavascript开发语言
    转自：微点阅读https://www.weidianyuedu.com这几天假期，我学习了一下Deno[1]。它是Node.js的替代品。有了它，将来可能就不需要Node.js了。这篇文章就是Deno的一个初步介绍，尝试回答为什么Node.js不能满足需要，以及Deno能够带给我们什么？以下内容主要基于BertBelder[2]和RyanDahl[3]的最新演讲。0、进入主题之前，先说一下Deno
  • ChatGPT、DeepSeek、GIS与Python机器学习强强联合！地质灾害风险评估、易发性分析、信息化建库及灾后重建 WangYan2022 DeepSeekChatGPT地下水地质灾害DeepSeekChatGPTGIS灾后重建
    在地质灾害频繁肆虐的当下，精准开展风险评价刻不容缓。如今，一门极具创新性的教程震撼登场，它将ChatGPT、DeepSeek等前沿技术与GIS、Python以及机器学习深度交融，为学员打造出前所未有的学习体验，助力大家在地质灾害风险评价领域强势突围，一路领先。前沿技术融合，铸就智能学习核心动力教程最闪耀的亮点之一，便是大胆引入了ChatGPT和DeepSeek技术。它们恰似无所不能的“数据魔法师”
  • 推特关键词爬虫Python实现最新版（2025.2.20） 才华是浅浅的耐心 爬虫python开发语言
    引言随着各类自媒体平台的兴起，数据挖掘和分析变得尤为重要。推特作为全球最大的自媒体平台，越来越来越多的人需要通过爬取其内容进行分析。然后自从马斯克接手推特之后，推特api不可再用，推特的反爬力度也在逐渐增强。今天小编就分享一个推特爬虫的教程。描述这篇文章主要通过关键词爬取帖子内容信息以及帖子作者主页相关信息，用户也可根据自己需要的时间段进行筛选。推特可支持筛选多种语言，我这里先展示中文和英文的。字
  • 如何合法抓取TikTok视频信息和评论：完整Python爬虫教程 Python爬虫项目 2025年爬虫实战项目音视频python爬虫开发语言
    一、引言TikTok是全球最受欢迎的短视频平台之一，每天吸引着数百万的用户上传和分享视频内容。作为内容创作者和数据分析师，抓取TikTok上的视频和评论可以帮助你分析社交趋势、受欢迎的内容类型和用户互动。然而，TikTok明确表示其平台的数据抓取行为受到限制，这也意味着我们不能直接通过常规的网络爬虫技术去抓取其数据。本文将介绍如何在合法的前提下进行TikTok数据抓取。我们将探索TikTok的AP
  • C++协程入门教程 ox0080 #北漂+滴滴出行C++协程VIP激励c++开发语言
    一、环境搭建（Docker+双编译系统）1.全能Docker环境配置FROMubuntu:22.04#基础工具链RUNapt-getupdate&&DEBIAN_FRONTEND=noninteractiveapt-getinstall-y\build-essentialcmakebazelgitg++-12libcppcoro-dev\openssh-serverrsyslogcurlgnupg
  • 【AI Agent教程】各种Agent开发框架都是如何实现ReAct思想的？深入源码学习一下 同学小张 大模型人工智能学习笔记经验分享AIGCAIAgentReAct
    大家好，我是同学小张，持续学习C++进阶知识和AI大模型应用实战案例，持续分享，欢迎大家点赞+关注，共同学习和进步。驱动大模型有很多种方式，例如纯Prompt方式、思维链方式、ReAct方式等。ReAct方式是AIAgent最常用的实现思路之一，它强调在执行任务时结合推理（Reasoning）和行动（Acting）两个方面，使得Agent能够在复杂和动态的环境中更有效地工作。本文我们来看看常用的那
  • Python之pip的安装和使用详细教程 叫我技术帝 Pythonpython
    我们都知道python有海量的第三方库或者说模块，这些库针对不同的应用，发挥不同的作用。我们在实际的项目中，或多或少的都要使用到第三方库，那么如何将他人的库加入到自己的项目中内呢？打个电话？大哥你好，想用下你那个库，麻烦给邮箱发个源码呗！显然这是个笑话。Python官方的PyPi仓库为我们提供了一个统一的代码托管仓库，所有的第三方库，甚至你自己写的开源模块，都可以发布到这里，让全世界的人分享下载。
  • opencv + opengl显示摄像头视频流 jbjhzstsl opencv计算机视觉
    完整代码github建议学习LearnOpenGL教程，学到入门的纹理一节1.OpenGL依赖安装1.1.安装GLFWsudoaptinstalllibglfw3libglfw3-devlibglfw3：GLFW运行时库libglfw3-dev：GLFW开发库（用于编译）1.2.安装OpenGL相关依赖sudoaptinstalllibgl1-mesa-devxorg-devlibgl1-mesa
  • vs code配置python_如何在vscode里的python配置好matplotlib？,vscode配置python环境教程 weixin_39564151 vscode配置python
    如何在vscode里的python配置好matplotlib？,vscode配置python环境教程vscode配置python环境教程2020-09-2015:14:33人已围观VScode配置Python环境“配置任务运行程序”遇到问题我建议尝试再把bug写出来，不能因为不一样就不继续首先需要VScodePython插件。打开Python任意脚可以直接拖入。点击左下角的扩展按钮，在弹出界面选择
  • ros smach 教程——（二） 白云千载尽 自动驾驶rospythonsmach状态机
    ROSSMACH中级教程一、SMACH容器1.1状态机容器1.1.1创建状态机容器首先引入状态机容器fromsmachimportStateMachine由于SMACH状态机还提供状态接口，因此必须在构造时指定其结果和用户数据交互。sm=StateMachine(outcomes=['outcome1','outcome2'],input_keys=['input1','input2'],outp
  • TikTokenizer 开源项目教程 邱纳巧Gillian
    TikTokenizer开源项目教程tiktokenizerOnlineplaygroundforOpenAPItokenizers项目地址:https://gitcode.com/gh_mirrors/ti/tiktokenizer项目介绍TikTokenizer是一个基于Python的开源项目，旨在提供一个高效、灵活的文本分词工具。该项目利用先进的算法和数据结构，能够快速准确地对文本进行分词处
  • Telegram bot教程：通过BotFather设置Telegram bot的命令菜单 鲲志说 Web3相关业界资讯telegrambot经验分享笔记twitterTelegramBot
    最近在研究Telegrambot嘛，总有些小细节可以记录了，今天就记录一个通过BotFather设置Telegrambot的命令菜单功能➡️【好看的灵魂千篇一律，有趣的鲲志一百六七！】-欢迎认识我～～作者：鲲志说（公众号、B站同名，视频号：鲲志说996）科技博主：极星会星辉大使后端研发：java、go、python、TS，前电商、现web3主理人：COC杭州开发者社区主理人、周周黑客松杭州主理人、
  • matsim开发教程 若木胡 大数据信息可视化
    以下是基于MATSim的二次开发教程指南，结合交通仿真框架的核心功能和开发实践，提供从环境搭建到高级开发的完整路径：一、MATSim简介MATSim（Multi-AgentTransportSimulation）是一个基于Java的开源交通仿真框架，专注于大规模多智能体（Agent）交通行为模拟，支持动态需求建模、路径规划优化、政策评估等应用场景。二、开发环境搭建1.基础依赖JavaJDK11+：
  • 清晰易懂的Python安装与配置教程 Tee xm python开发语言
    初学者也能看懂的Python安装与配置教程本教程将手把手教你安装Python，并配置国内镜像源和自定义依赖包缓存位置，即使你是零基础小白，也能轻松完成！一、准备工作操作系统：Windows10/11、macOS或Linux。下载工具：浏览器（推荐Chrome或Edge）。存储空间：至少预留500MB可用空间。二、安装Python1.下载Python访问Python官网下载页面：https://ww
  • ESP8266 与 ARM7 接口-LPC2148 创建 Web 服务器以控制 LED David WangYang ESP8266项目服务器运维
    ESP8266与ARM7接口-LPC2148创建Web服务器以控制LEDESP8266Wi-Fi收发器提供了一种将微控制器连接到网络的方法。它被广泛用于物联网项目，因为它便宜、体积小且易于使用。在本教程中，我们将ESP8266Wi-Fi模块与ARM7-LPC2148微控制器连接，并创建一个Web服务器来控制连接到LPC2148的LED。工作流程将如下所示：从LPC2148向ESP8266发送AT命
  • 信息系统运行管理员教程4--信息系统软件运维 LRX_198927 信息系统运行管理运维数据库
    第四章信息系统软件运维信息系统软件是信息系统运行的核心，其运维的目的是保证信息系统软件能正常而可靠地运行，并能使系统不断得到改善和提高，以充分发挥作用。第1节信息系统软件运维概述1.信息系统软件运维的概念信息系统软件运维是指信息系统软件在开发完后投入使用后，对信息系统软件进行的改正性维护、适应性维护、完善性维护、预防性维护等软件工程活动。2.信息系统软件的可维护性及维护类型软件可维护性的度量可以从
  • SvelteKit 最新中文文档教程（6）—— 状态管理
    前言Svelte，一个语法简洁、入门容易，面向未来的前端框架。从Svelte诞生之初，就备受开发者的喜爱，根据统计，从2019年到2024年，连续6年一直是开发者最感兴趣的前端框架No.1：Svelte以其独特的编译时优化机制著称，具有轻量级、高性能、易上手等特性，非常适合构建轻量级Web项目。为了帮助大家学习Svelte，我同时搭建了Svelte最新的中文文档站点。如果需要进阶学习，也可以入手我
  • 单片机中断系统设计教程 kkchenjj STM32编程等单片机编程单片机嵌入式硬件
    单片机中断系统设计教程单片机中断系统概述中断的基本概念中断（Interrupt）是计算机系统中一种重要的机制，它允许外部设备或内部硬件在CPU执行程序的任意时刻请求CPU暂停当前任务，转而处理紧急或高优先级的任务。在单片机中，中断机制使得单片机能够及时响应外部事件，如按键按下、传感器数据变化等，从而提高系统的实时性和效率。工作原理中断系统通常包括中断源、中断请求、中断响应和中断服务程序。当中断源产
  • 清晰易懂的Java8安装教程 Tee xm windowsjava
    小白也能看懂的Java8安装教程（JDK和JRE分目录安装）本教程将手把手教你如何在Windows系统上安装Java8（JDK1.8），并将JDK和JRE安装到不同的目录中，同时提供国内Java8下载源和方法。即使你是编程小白，也能轻松学会！一、准备工作操作系统：Windows10或更高版本。下载工具：一个浏览器（如Chrome、Edge）。存储空间：确保你的电脑有至少500MB的可用空间。二、下
  • DeepSeek私有化部署搭建、本地知识库、可联网查询RAG检索增强生成 TonyH2002 DeepSeek本地部署私有化搭建联网查询
    一、如何私有化部署DeepSeek如何部署DeepSeek，具体可参考以下内容：喂饭式教程-腾讯云轻量服务器部署DeepSeek：https://cloud.tencent.com/developer/article/2494571喂饭式教程-腾讯云HAI服务部署DeepSeek：https://cloud.tencent.com/developer/article/2495288喂饭式教程-腾讯
  • 【FPGA教程案例31】通信案例1——基于FPGA的ASK调制信号产生 fpga和matlab ★教程2:fpga入门100例fpga开发FPGA教程ASK调制verilog
    FPGA教程目录MATLAB教程目录---------------------------------------------------------------------------------------目录1.软件版本2.ASK调制原理3.ASK调制过程的FPGA实现4.操作步骤与仿真结论5.参考文献1.软件版本vivado2019.22.ASK调制原理幅度键控（Amplitude-Shi
  • 从零实现B站视频下载器：Python自动化实战教程 木觞清 #编程语言自动化运维
    一、项目背景与实现原理1.1B站视频分发机制Bilibili的视频采用音视频分离技术，通过以下方式提升用户体验：动态码率适配（1080P/4K/HDR）分段加载技术（基于M4S格式）内容保护机制（防盗链/签名验证）1.2技术实现路线graphTDA[模拟浏览器请求]-->B[获取加密播放信息]B-->C[解析音视频地址]C-->D[多线程下载]D-->E[FFmpeg合并]二、代码逐层解析2.1请
  • Java开发者必看！零成本集成DeepSeek-R1打造AI办公神器，源码级实战教程让你效率翻倍！ Leaton Lee java人工智能开发语言
    目录开篇互动一、为什么是DeepSeek-R1？它凭什么碾压传统AI工具？二、手把手部署DeepSeek-R1本地环境（附避坑指南）步骤1：Docker一键部署步骤2：下载模型步骤3：验证部署三、Java整合DeepSeek-R1：从理论到实战1.添加HTTP客户端依赖（以SpringBoot为例）2.封装AI工具类（核心代码解析）3.实战场景1：自动生成周报（附Prompt技巧）四、高阶玩法：A
  • 【css酷炫效果】实现鱼群游动动态效果 冰夏之夜影 web前端css前端
    【css酷炫效果】实现小鱼游动动态效果缘创作背景css代码创建div容器引入jquery引入鱼群js完整代码效果图成品资源下载链接：点击下载缘在开发系统功能的时候，无意间看到了小鱼游动特效，感觉很有意思，就在网上找了相关教程，分享给大家。创作背景刚看到csdn出活动了，赶时间，直接上代码。css代码.container{background-color:transparent;position:f
  • openai 标准化协议 Structured Outputs 具体示例教程 weixin_40941102 语言模型
    StructuredOutputs具体示例教程场景：个人财务管理助手假设我们要构建一个AI助手，帮助用户记录和管理个人财务支出。用户可以输入自然语言描述（如“昨天我花了50元买了午餐”），助手将提取关键信息并以结构化JSON格式返回，包括日期、金额、类别和备注。示例1：使用StructuredOutputs提取财务记录步骤1：定义JSONSchema我们需要一个清晰的Schema来描述财务记录：{
  • 设计模式介绍 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其他