开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
audio_dialog.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：19k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

audio_dialog.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  * Bill May  wmay@cisco.com
  21.  */
  23. #define __STDC_LIMIT_MACROS
  24. #include "mp4live.h"
  25. #include "mp4live_gui.h"
  26. #include "audio_oss_source.h"
  27. #include "audio_lame.h"
  29. static GtkWidget *dialog;
  31. static char* source_type;
  32. static char* source_name;
  33. static GtkWidget *source_combo;
  34. static GtkWidget *source_entry;
  35. static GtkWidget *source_list;
  36. static bool source_modified;
  37. static GtkWidget *browse_button;
  38. static GtkWidget *input_label;
  39. static GtkWidget *input_menu;
  40. static GtkWidget *track_label;
  41. static GtkWidget *track_menu;
  42. static GtkWidget *channel_menu;
  43. static GtkWidget *encoding_menu;
  44. static GtkWidget *sampling_rate_menu;
  45. static GtkWidget *bit_rate_menu;
  47. static CAudioCapabilities* pAudioCaps;
  49. static char* inputValues[] = {
  50. "cd", "line", "mic", "mix"
  51. };
  52. static char* inputNames[] = {
  53. "CD", "Line In", "Microphone", "Via Mixer"
  54. };
  55. static u_int8_t inputIndex;
  57. static u_int32_t trackIndex;
  58. static u_int32_t trackNumber; // how many tracks total
  59. static u_int32_t* trackValues = NULL;
  61. static u_int8_t channelValues[] = {
  62. 1, 2
  63. };
  64. static char* channelNames[] = {
  65. "1 - Mono", "2 - Stereo"
  66. };
  67. static u_int8_t channelIndex;
  69. static char* encodingNames[] = {
  70. "MP3", "AAC"
  71. };
  72. static u_int8_t encodingIndex;
  74. static char** samplingRateNames = NULL;
  75. static u_int32_t* samplingRateValues = NULL;
  76. static u_int8_t samplingRateIndex;
  77. static u_int8_t samplingRateNumber = 0; // how many sampling rates
  79. // union of valid sampling rates for MP3 and AAC
  80. static const u_int32_t samplingRateAllValues[] = {
  81. 7350, 8000, 11025, 12000, 16000, 22050, 
  82. 24000, 32000, 44100, 48000, 64000, 88200, 96000
  83. };
  85. // union of valid bit rates for MP3 and AAC
  86. static const u_int16_t bitRateAllValues[] = {
  87. 8, 16, 24, 32, 40, 48, 
  88. 56, 64, 80, 96, 112, 128, 
  89. 144, 160, 192, 224, 256, 320
  90. };
  91. static const u_int8_t bitRateAllNumber =
  92. sizeof(bitRateAllValues) / sizeof(u_int16_t);
  94. static u_int16_t bitRateValues[bitRateAllNumber];
  95. static char* bitRateNames[bitRateAllNumber];
  96. static u_int8_t bitRateIndex;
  97. static u_int8_t bitRateNumber = 0; // how many bit rates
  99. // forward function declarations
  100. static void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps);
  101. static void CreateBitRateMenu();
  102. static void SetSamplingRate(u_int32_t samplingRate);
  105. static void on_destroy_dialog (GtkWidget *widget, gpointer *data)
  106. {
  107. gtk_grab_remove(dialog);
  108. gtk_widget_destroy(dialog);
  109. dialog = NULL;
  110. } 
  112. static bool SourceIsDevice()
  113. {
  114. const char* source_name =
  115. gtk_entry_get_text(GTK_ENTRY(source_entry));
  116. return !strncmp(source_name, "/dev/", 5);
  117. }
  119. static void ShowSourceSpecificSettings()
  120. {
  121. if (SourceIsDevice()) {
  122. gtk_widget_show(input_label);
  123. gtk_widget_show(input_menu);
  125. gtk_widget_hide(track_label);
  126. gtk_widget_hide(track_menu);
  127. } else {
  128. gtk_widget_hide(input_label);
  129. gtk_widget_hide(input_menu);
  131. gtk_widget_show(track_label);
  132. gtk_widget_show(track_menu);
  133. }
  134. }
  136. static void SourceOssDevice()
  137. {
  138. char *newSourceName =
  139. gtk_entry_get_text(GTK_ENTRY(source_entry));
  141. // don't probe the already open device!
  142. if (!strcmp(newSourceName, 
  143.   MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME))) {
  144. return;
  145. }
  147. // probe new device
  148. CAudioCapabilities* pNewAudioCaps = 
  149. new CAudioCapabilities(newSourceName);
  151. // check for errors
  152. if (!pNewAudioCaps->IsValid()) {
  153. ShowMessage("Change Audio Source",
  154. "Specified audio source can't be opened, check name");
  155. delete pNewAudioCaps;
  156. return;
  157. }
  159. if (pAudioCaps != MyConfig->m_audioCapabilities) {
  160. delete pAudioCaps;
  161. }
  162. pAudioCaps = pNewAudioCaps;
  164. // change sampling rate menu
  165. CreateSamplingRateMenu(pNewAudioCaps);
  167. // change bit rate menu
  168. CreateBitRateMenu();
  169. }
  171. static void ChangeSource()
  172. {
  173. char* new_source_name =
  174. gtk_entry_get_text(GTK_ENTRY(source_entry));
  176. if (!strcmp(new_source_name, source_name)) {
  177. source_modified = false;
  178. return;
  179. }
  181. free(source_name);
  182. source_name = stralloc(new_source_name);
  184. if (SourceIsDevice()) {
  185. source_type = AUDIO_SOURCE_OSS;
  187. SourceOssDevice();
  189. } else {
  190. if (pAudioCaps != MyConfig->m_audioCapabilities) {
  191. delete pAudioCaps;
  192. }
  193. pAudioCaps = NULL;
  195. if (IsUrl(source_name)) {
  196. source_type = URL_SOURCE;
  197. } else {
  198. if (access(source_name, R_OK) != 0) {
  199. ShowMessage("Change Audio Source",
  200. "Specified audio source can't be opened, check name");
  201. }
  202. source_type = FILE_SOURCE;
  203. }
  204. }
  206. track_menu = CreateTrackMenu(
  207. track_menu,
  208. 'A',
  209. gtk_entry_get_text(GTK_ENTRY(source_entry)),
  210. &trackIndex,
  211. &trackNumber,
  212. &trackValues);
  214. ShowSourceSpecificSettings();
  216. source_modified = false;
  217. }
  219. static void on_source_browse_button (GtkWidget *widget, gpointer *data)
  220. {
  221. FileBrowser(source_entry, GTK_SIGNAL_FUNC(ChangeSource));
  222. }
  224. static void on_source_entry_changed(GtkWidget *widget, gpointer *data)
  225. {
  226. if (widget == source_entry) {
  227. source_modified = true;
  228. }
  229. }
  231. static void on_source_leave(GtkWidget *widget, gpointer *data)
  232. {
  233. if (source_modified) {
  234. ChangeSource();
  235. }
  236. }
  238. static void on_source_list_changed(GtkWidget *widget, gpointer *data)
  239. {
  240. if (widget == source_list) {
  241. ChangeSource();
  242. }
  243. }
  245. static void on_input_menu_activate (GtkWidget *widget, gpointer data)
  246. {
  247. inputIndex = (unsigned int)data & 0xFF;
  248. }
  250. static void on_channel_menu_activate (GtkWidget *widget, gpointer data)
  251. {
  252. channelIndex = (unsigned int)data & 0xFF;
  253. }
  255. static void on_encoding_menu_activate (GtkWidget *widget, gpointer data)
  256. {
  257. encodingIndex = (unsigned int)data & 0xFF;
  259. CreateSamplingRateMenu(pAudioCaps);
  260. CreateBitRateMenu();
  261. }
  263. static void on_sampling_rate_menu_activate (GtkWidget *widget, gpointer data)
  264. {
  265. samplingRateIndex = (unsigned int)data & 0xFF;
  267. CreateBitRateMenu();
  268. }
  270. static void on_bit_rate_menu_activate (GtkWidget *widget, gpointer data)
  271. {
  272. bitRateIndex = (unsigned int)data & 0xFF;
  273. }
  275. void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps)
  276. {
  277. // remember current sampling rate
  278. u_int32_t oldSamplingRate = 0;
  279. if (samplingRateValues) {
  280. oldSamplingRate = samplingRateValues[samplingRateIndex];
  281. }
  283. // invalidate index, will fix up below
  284. samplingRateIndex = 255;
  286. u_int8_t maxSamplingRateNumber;
  287. const u_int32_t* samplingRates = NULL;
  289. if (pNewAudioCaps) {
  290. maxSamplingRateNumber = pNewAudioCaps->m_numSamplingRates;
  291. samplingRates = &pNewAudioCaps->m_samplingRates[0];
  292. } else {
  293. maxSamplingRateNumber = 
  294. sizeof(samplingRateAllValues) / sizeof(u_int32_t);
  295. samplingRates = &samplingRateAllValues[0];
  296. }
  298. // create new menu item names and values
  299. char** newSamplingRateNames = 
  300. (char**)malloc(sizeof(char*) * maxSamplingRateNumber);
  301. u_int32_t* newSamplingRateValues =
  302. (u_int32_t*)malloc(sizeof(u_int32_t) * maxSamplingRateNumber);
  304. u_int8_t i;
  305. u_int8_t newSamplingRateNumber = 0;
  307. for (i = 0; i < maxSamplingRateNumber; i++) {
  309. // MP3 can't use all the possible sampling rates
  310. if (encodingIndex == 0) {
  311. // skip the ones it can't handle
  312. // MP3 can't handle anything less than 8000
  313. // LAME MP3 encoder has additional lower bound at 16000
  314. if (samplingRates[i] < 16000 || samplingRates[i] > 48000) {
  315. continue;
  316. }
  317. }
  319. char buf[64];
  320. snprintf(buf, sizeof(buf), "%u", samplingRates[i]);
  321. newSamplingRateNames[newSamplingRateNumber] = 
  322. stralloc(buf);
  324. newSamplingRateValues[newSamplingRateNumber] = 
  325. samplingRates[i];
  327. if (oldSamplingRate == newSamplingRateValues[newSamplingRateNumber]) {
  328. samplingRateIndex = newSamplingRateNumber;
  329. }
  331. newSamplingRateNumber++;
  332. }
  334. if (samplingRateIndex >= newSamplingRateNumber) {
  335. samplingRateIndex = newSamplingRateNumber - 1; 
  336. }
  338. // (re)create the menu
  339. sampling_rate_menu = CreateOptionMenu(
  340. sampling_rate_menu,
  341. newSamplingRateNames, 
  342. newSamplingRateNumber,
  343. samplingRateIndex,
  344. GTK_SIGNAL_FUNC(on_sampling_rate_menu_activate));
  346. // free up old names
  347. for (i = 0; i < samplingRateNumber; i++) {
  348. free(samplingRateNames[i]);
  349. }
  350. free(samplingRateNames);
  351. samplingRateNames = newSamplingRateNames;
  352. samplingRateValues = newSamplingRateValues;
  353. samplingRateNumber = newSamplingRateNumber;
  354. }
  356. static void SetSamplingRate(u_int32_t samplingRate)
  357. {
  358. u_int8_t i;
  359. for (i = 0; i < samplingRateNumber; i++) {
  360. if (samplingRate == samplingRateValues[i]) {
  361. samplingRateIndex = i;
  362. break;
  363. }
  364. }
  365. if (i == samplingRateNumber) {
  366. debug_message("invalid sampling rate %un", samplingRate);
  367. }
  369. gtk_option_menu_set_history(
  370. GTK_OPTION_MENU(sampling_rate_menu), samplingRateIndex);
  371. }
  373. void CreateBitRateMenu()
  374. {
  375. u_int8_t i;
  376. u_int16_t oldBitRate = bitRateValues[bitRateIndex];
  377. u_int32_t samplingRate = samplingRateValues[samplingRateIndex];
  379. // free up old names
  380. for (i = 0; i < bitRateNumber; i++) {
  381. free(bitRateNames[i]);
  382. bitRateNames[i] = NULL;
  383. }
  384. bitRateNumber = 0;
  386. // make current bitrate index invalid, will fixup below
  387. bitRateIndex = 255;
  389. // for all possible bitrates
  390. for (i = 0; i < bitRateAllNumber; i++) {
  392. // MP3 can't use all the possible bit rates
  393. // LAME imposes additional constraints
  394. if (encodingIndex == 0) {
  395. if (samplingRate >= 32000) {
  396. // MPEG-1
  398. if (bitRateAllValues[i] < 40
  399.   || bitRateAllValues[i] == 144) {
  400. continue;
  401. }
  402. if (samplingRate >= 44100 && bitRateAllValues[i] < 56) {
  403. continue;
  404. }
  405. if (samplingRate >= 48000 && bitRateAllValues[i] < 64) {
  406. continue;
  407. }
  409. } else {
  410. // MPEG-2 or MPEG-2.5
  412. if (samplingRate > 16000) {
  413. if (bitRateAllValues[i] < 32) {
  414. continue;
  415. }
  416. }
  418. if (bitRateAllValues[i] > 160) {
  419. continue;
  420. }
  421. }
  422. }
  424. char buf[64];
  425. snprintf(buf, sizeof(buf), "%u",
  426. bitRateAllValues[i]);
  427. bitRateNames[bitRateNumber] = stralloc(buf);
  429. bitRateValues[bitRateNumber] = bitRateAllValues[i];
  431. // preserve user's current choice if we can
  432. if (oldBitRate == bitRateValues[bitRateNumber]) {
  433. bitRateIndex = bitRateNumber;
  434. }
  436. bitRateNumber++;
  437. }
  439. if (bitRateIndex >= bitRateNumber) {
  440. bitRateIndex = bitRateNumber - 1; 
  441. }
  443. // (re)create the menu
  444. bit_rate_menu = CreateOptionMenu(
  445. bit_rate_menu,
  446. bitRateNames, 
  447. bitRateNumber,
  448. bitRateIndex,
  449. GTK_SIGNAL_FUNC(on_bit_rate_menu_activate));
  450. }
  452. static bool ValidateAndSave(void)
  453. {
  454. // if source has been modified
  455. if (source_modified) {
  456. // validate it
  457. ChangeSource();
  459. // can't validate
  460. if (source_modified) {
  461. return false;
  462. }
  463. }
  465. // copy new values to config
  467. MyConfig->SetStringValue(CONFIG_AUDIO_SOURCE_TYPE,
  468. source_type);
  470. MyConfig->SetStringValue(CONFIG_AUDIO_SOURCE_NAME,
  471. gtk_entry_get_text(GTK_ENTRY(source_entry)));
  473. MyConfig->UpdateFileHistory(
  474. gtk_entry_get_text(GTK_ENTRY(source_entry)));
  476. if (MyConfig->m_audioCapabilities != pAudioCaps) {
  477. delete MyConfig->m_audioCapabilities;
  478. MyConfig->m_audioCapabilities = pAudioCaps;
  479. }
  481. MyConfig->SetStringValue(CONFIG_AUDIO_INPUT_NAME,
  482. inputValues[inputIndex]);
  484. MyConfig->SetIntegerValue(CONFIG_AUDIO_SOURCE_TRACK,
  485. trackValues ? trackValues[trackIndex] : 0);
  487. MyConfig->SetIntegerValue(CONFIG_AUDIO_CHANNELS, 
  488. channelValues[channelIndex]);
  490. if (encodingIndex == 1) {
  491. MyConfig->SetStringValue(CONFIG_AUDIO_ENCODING, AUDIO_ENCODING_AAC);
  492. MyConfig->SetStringValue(CONFIG_AUDIO_ENCODER, AUDIO_ENCODER_FAAC);
  493. } else {
  494. MyConfig->SetStringValue(CONFIG_AUDIO_ENCODING, AUDIO_ENCODING_MP3);
  495. MyConfig->SetStringValue(CONFIG_AUDIO_ENCODER, AUDIO_ENCODER_LAME);
  496. }
  498. MyConfig->SetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE, 
  499. samplingRateValues[samplingRateIndex]);
  501. MyConfig->SetIntegerValue(CONFIG_AUDIO_BIT_RATE,
  502. bitRateValues[bitRateIndex]);
  504. MyConfig->Update();
  506. DisplayAudioSettings();  // display settings in main window
  507. DisplayStatusSettings();  
  509. return true;
  510. }
  512. static void on_ok_button (GtkWidget *widget, gpointer *data)
  513. {
  514. // check and save values
  515. if (!ValidateAndSave()) {
  516. return;
  517. }
  518.     on_destroy_dialog(NULL, NULL);
  519. }
  521. static void on_cancel_button (GtkWidget *widget, gpointer *data)
  522. {
  523. on_destroy_dialog(NULL, NULL);
  524. }
  526. void CreateAudioDialog (void) 
  527. {
  528. GtkWidget* hbox;
  529. GtkWidget* vbox;
  530. GtkWidget* hbox2;
  531. GtkWidget* label;
  532. GtkWidget* button;
  534. pAudioCaps = MyConfig->m_audioCapabilities;
  536. dialog = gtk_dialog_new();
  537. gtk_signal_connect(GTK_OBJECT(dialog),
  538. "destroy",
  539. GTK_SIGNAL_FUNC(on_destroy_dialog),
  540. &dialog);
  542. gtk_window_set_title(GTK_WINDOW(dialog), "Audio Settings");
  544. hbox = gtk_hbox_new(FALSE, 1);
  545. gtk_widget_show(hbox);
  546. gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
  547. FALSE, FALSE, 5);
  549. vbox = gtk_vbox_new(TRUE, 1);
  550. gtk_widget_show(vbox);
  551. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  553. label = gtk_label_new(" Source:");
  554. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  555. gtk_widget_show(label);
  556. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  558. input_label = gtk_label_new("   Input Port:");
  559. gtk_misc_set_alignment(GTK_MISC(input_label), 0.0, 0.5);
  560. gtk_box_pack_start(GTK_BOX(vbox), input_label, FALSE, FALSE, 0);
  562. track_label = gtk_label_new("   Track:");
  563. gtk_misc_set_alignment(GTK_MISC(track_label), 0.0, 0.5);
  564. gtk_box_pack_start(GTK_BOX(vbox), track_label, FALSE, FALSE, 0);
  566. label = gtk_label_new(" Output:");
  567. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  568. gtk_widget_show(label);
  569. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  571. label = gtk_label_new("   Encoding :");
  572. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  573. gtk_widget_show(label);
  574. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  576. label = gtk_label_new("   Channels:");
  577. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  578. gtk_widget_show(label);
  579. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  581. label = gtk_label_new("   Sampling Rate (Hz):");
  582. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  583. gtk_widget_show(label);
  584. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  586. label = gtk_label_new("   Bit Rate (kbps):");
  587. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  588. gtk_widget_show(label);
  589. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  592. vbox = gtk_vbox_new(TRUE, 1);
  593. gtk_widget_show(vbox);
  594. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  596. hbox2 = gtk_hbox_new(FALSE, 1);
  597. gtk_widget_show(hbox2);
  598. gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
  600. source_type = MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_TYPE);
  602. // source entry
  603. free(source_name);
  604. source_name =
  605. stralloc(MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME));
  607. source_modified = false;
  609. source_combo = CreateFileCombo(source_name);
  611. source_entry = GTK_COMBO(source_combo)->entry;
  613. SetEntryValidator(GTK_OBJECT(source_entry),
  614. GTK_SIGNAL_FUNC(on_source_entry_changed),
  615. GTK_SIGNAL_FUNC(on_source_leave));
  617. source_list = GTK_COMBO(source_combo)->list;
  618. gtk_signal_connect(GTK_OBJECT(source_list), "select_child",
  619. GTK_SIGNAL_FUNC(on_source_list_changed), NULL);
  621. gtk_widget_show(source_combo);
  622. gtk_box_pack_start(GTK_BOX(hbox2), source_combo, TRUE, TRUE, 0);
  624. // browse button
  625. browse_button = gtk_button_new_with_label(" Browse... ");
  626. gtk_signal_connect(GTK_OBJECT(browse_button),
  627.  "clicked",
  628.  GTK_SIGNAL_FUNC(on_source_browse_button),
  629.  NULL);
  630. gtk_widget_show(browse_button);
  631. gtk_box_pack_start(GTK_BOX(hbox2), browse_button, FALSE, FALSE, 5);
  633. // input menu
  634. inputIndex = 0;
  635. for (u_int8_t i = 0; i < sizeof(inputValues) / sizeof(u_int8_t); i++) {
  636. if (!strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_INPUT_NAME),
  637.   inputValues[i])) {
  638. inputIndex = i;
  639. break;
  640. }
  641. }
  642. input_menu = CreateOptionMenu (NULL,
  643. inputNames, 
  644. sizeof(inputNames) / sizeof(char*),
  645. inputIndex,
  646. GTK_SIGNAL_FUNC(on_input_menu_activate));
  647. gtk_box_pack_start(GTK_BOX(vbox), input_menu, TRUE, TRUE, 0);
  649. // track menu
  650. track_menu = NULL;
  651. track_menu = CreateTrackMenu(
  652. track_menu,
  653. 'A',
  654. gtk_entry_get_text(GTK_ENTRY(source_entry)),
  655. &trackIndex,
  656. &trackNumber,
  657. &trackValues);
  659. trackIndex = 0; 
  660. for (u_int8_t i = 0; i < trackNumber; i++) {
  661. if (MyConfig->GetIntegerValue(CONFIG_AUDIO_SOURCE_TRACK)
  662.    == trackValues[i]) {
  663. trackIndex = i;
  664. break;
  665. }
  666. }
  667. gtk_box_pack_start(GTK_BOX(vbox), track_menu, FALSE, FALSE, 0);
  669. // spacer
  670. label = gtk_label_new(" ");
  671. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  672. gtk_widget_show(label);
  673. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  675. if (!strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  676.   AUDIO_ENCODING_AAC)) {
  677. encodingIndex = 1;
  678. } else {
  679. encodingIndex = 0;
  680. }
  681. encoding_menu = CreateOptionMenu (NULL,
  682. encodingNames, 
  683. sizeof(encodingNames) / sizeof(char*),
  684. encodingIndex,
  685. GTK_SIGNAL_FUNC(on_encoding_menu_activate));
  686. gtk_box_pack_start(GTK_BOX(vbox), encoding_menu, TRUE, TRUE, 0);
  688. // channel menu
  689. channelIndex = 0;
  690. for (u_int8_t i = 0; i < sizeof(channelValues) / sizeof(u_int8_t); i++) {
  691. if (MyConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS)
  692.   == channelValues[i]) {
  693. channelIndex = i;
  694. break;
  695. }
  696. }
  697. channel_menu = CreateOptionMenu (NULL,
  698. channelNames, 
  699. sizeof(channelNames) / sizeof(char*),
  700. channelIndex,
  701. GTK_SIGNAL_FUNC(on_channel_menu_activate));
  702. gtk_box_pack_start(GTK_BOX(vbox), channel_menu, TRUE, TRUE, 0);
  704. sampling_rate_menu = NULL;
  705. CreateSamplingRateMenu(pAudioCaps);
  706. gtk_box_pack_start(GTK_BOX(vbox), sampling_rate_menu, TRUE, TRUE, 0);
  708. // set sampling rate value based on MyConfig
  709. SetSamplingRate(MyConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE));
  711. bit_rate_menu = NULL;
  712. CreateBitRateMenu();
  713. gtk_box_pack_start(GTK_BOX(vbox), bit_rate_menu, TRUE, TRUE, 0);
  715. // set bit rate value based on MyConfig
  716. for (u_int8_t i = 0; i < bitRateNumber; i++) {
  717. if (MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE)
  718.   == bitRateValues[i]) {
  719. bitRateIndex = i;
  720. break;
  721. }
  722. }
  723. gtk_option_menu_set_history(
  724. GTK_OPTION_MENU(bit_rate_menu), bitRateIndex);
  726. // Add standard buttons at bottom
  727. button = AddButtonToDialog(dialog,
  728. " OK ", 
  729. GTK_SIGNAL_FUNC(on_ok_button));
  730. GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  732. AddButtonToDialog(dialog,
  733. " Cancel ", 
  734. GTK_SIGNAL_FUNC(on_cancel_button));
  736. ShowSourceSpecificSettings();
  738. gtk_widget_show(dialog);
  739. }
  741. /* end audio_dialog.cpp */