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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

video_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 "video_v4l_source.h"
  28. static GtkWidget *dialog;
  30. static char* source_type;
  31. static char* source_name;
  32. static GtkWidget *source_combo;
  33. static GtkWidget *source_entry;
  34. static GtkWidget *source_list;
  35. static GtkWidget *browse_button;
  36. static bool source_modified;
  37. static bool default_file_audio_dialog = false;
  38. static int32_t default_file_audio_source = -1;
  39. static GtkWidget *input_label;
  40. static GtkWidget *input_menu;
  41. static GtkWidget *signal_label;
  42. static GtkWidget *signal_menu;
  43. static GSList* signal_menu_items;
  44. static GtkWidget *channel_list_label;
  45. static GtkWidget *channel_list_menu;
  46. static GtkWidget *channel_label;
  47. static GtkWidget *channel_combo;
  48. static GtkWidget *track_label;
  49. static GtkWidget *track_menu;
  50. static GtkWidget *size_menu;
  51. static GtkWidget *aspect_menu;
  52. static GtkObject *frame_rate_ntsc_adjustment;
  53. static GtkObject *frame_rate_pal_adjustment;
  54. static GtkWidget *frame_rate_spinner;
  55. static GtkWidget *bit_rate_spinner;
  57. static CVideoCapabilities* pVideoCaps;
  59. static char** inputNames = NULL;
  60. static u_int8_t inputIndex = 0;
  61. static u_int8_t inputNumber = 0; // how many inputs total
  63. static char* signalNames[] = {
  64. "PAL", "NTSC", "SECAM"
  65. };
  66. static u_int8_t signalIndex;
  68. static u_int8_t channelListIndex;
  70. static u_int8_t channelIndex;
  72. static u_int32_t trackIndex;
  73. static u_int32_t trackNumber; // how many tracks total
  74. static u_int32_t* trackValues = NULL;
  76. static u_int16_t sizeWidthValues[] = {
  77. 128, 176, 320, 352, 352,
  78. 640, 704, 704, 720, 720, 768
  79. };
  80. static u_int16_t sizeHeightValues[] = {
  81. 96, 144, 240, 288, 480,
  82. 480, 480, 576, 480, 576, 576
  83. };
  84. static char* sizeNames[] = {
  85. "128 x 96 SQCIF", 
  86. "176 x 144 QCIF",
  87. "320 x 240 SIF",
  88. "352 x 288 CIF",
  89. "352 x 480 Half D1",
  90. "640 x 480 4SIF",
  91. "704 x 480 D1",
  92. "704 x 576 4CIF",
  93. "720 x 480 NTSC CCIR601",
  94. "720 x 576 PAL CCIR601",
  95. "768 x 576 PAL SQ Pixel"
  96. };
  97. static u_int8_t sizeIndex;
  98. static u_int8_t sizeMaxIndex;
  100. static float aspectValues[] = {
  101. VIDEO_STD_ASPECT_RATIO, VIDEO_LB1_ASPECT_RATIO, 
  102. VIDEO_LB2_ASPECT_RATIO, VIDEO_LB3_ASPECT_RATIO
  103. }; 
  104. static char* aspectNames[] = {
  105. "Standard 4:3", "Letterbox 2.35", "Letterbox 1.85", "HDTV 16:9"
  106. };
  107. static u_int8_t aspectIndex;
  109. // forward declarations
  110. static void SetAvailableSignals(void);
  112. static void on_destroy_dialog (GtkWidget *widget, gpointer *data)
  113. {
  114. gtk_grab_remove(dialog);
  115. gtk_widget_destroy(dialog);
  116. dialog = NULL;
  117. } 
  119. static bool SourceIsDevice()
  120. {
  121. return IsDevice(gtk_entry_get_text(GTK_ENTRY(source_entry)));
  122. }
  124. static void ShowSourceSpecificSettings()
  125. {
  126. if (SourceIsDevice()) {
  127. gtk_widget_show(input_label);
  128. gtk_widget_show(input_menu);
  129. gtk_widget_show(signal_label);
  130. gtk_widget_show(signal_menu);
  131. gtk_widget_show(channel_list_label);
  132. gtk_widget_show(channel_list_menu);
  133. gtk_widget_show(channel_label);
  134. gtk_widget_show(channel_combo);
  136. gtk_widget_hide(track_label);
  137. gtk_widget_hide(track_menu);
  138. } else {
  139. gtk_widget_hide(input_label);
  140. gtk_widget_hide(input_menu);
  141. gtk_widget_hide(signal_label);
  142. gtk_widget_hide(signal_menu);
  143. gtk_widget_hide(channel_list_label);
  144. gtk_widget_hide(channel_list_menu);
  145. gtk_widget_hide(channel_label);
  146. gtk_widget_hide(channel_combo);
  148. gtk_widget_show(track_label);
  149. gtk_widget_show(track_menu);
  150. }
  151. }
  153. static void EnableChannels()
  154. {
  155. bool hasTuner = false;
  157. if (pVideoCaps && pVideoCaps->m_inputHasTuners[inputIndex]) {
  158. hasTuner = true;
  159. }
  161. gtk_widget_set_sensitive(GTK_WIDGET(channel_list_menu), hasTuner);
  162. gtk_widget_set_sensitive(GTK_WIDGET(channel_combo), hasTuner);
  163. }
  165. static void ChangeInput(u_int8_t newIndex)
  166. {
  167. inputIndex = newIndex;
  168. SetAvailableSignals();
  169. EnableChannels();
  170. }
  172. static void on_input_menu_activate(GtkWidget *widget, gpointer data)
  173. {
  174. ChangeInput(((unsigned int)data) & 0xFF);
  175. }
  177. void CreateInputMenu(CVideoCapabilities* pNewVideoCaps)
  178. {
  179. u_int8_t newInputNumber;
  180. if (pNewVideoCaps) {
  181. newInputNumber = pNewVideoCaps->m_numInputs;
  182. } else {
  183. newInputNumber = 0;
  184. }
  186. if (inputIndex >= newInputNumber) {
  187. inputIndex = 0; 
  188. }
  190. // create new menu item names
  191. char** newInputNames = (char**)malloc(sizeof(char*) * newInputNumber);
  193. for (u_int8_t i = 0; i < newInputNumber; i++) {
  194. char buf[64];
  195. snprintf(buf, sizeof(buf), "%u - %s",
  196. i, pNewVideoCaps->m_inputNames[i]);
  197. newInputNames[i] = stralloc(buf);
  198. }
  200. // (re)create the menu
  201. input_menu = CreateOptionMenu(
  202. input_menu,
  203. newInputNames, 
  204. newInputNumber,
  205. inputIndex,
  206. GTK_SIGNAL_FUNC(on_input_menu_activate));
  208. // free up old names
  209. for (u_int8_t i = 0; i < inputNumber; i++) {
  210. free(inputNames[i]);
  211. }
  212. free(inputNames);
  213. inputNames = newInputNames;
  214. inputNumber = newInputNumber;
  215. }
  217. static void SourceV4LDevice()
  218. {
  219. char *newSourceName =
  220. gtk_entry_get_text(GTK_ENTRY(source_entry));
  222. // don't probe the already open device!
  223. if (!strcmp(newSourceName, 
  224.   MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME))) {
  225. return;
  226. }
  228. // probe new source device
  229. CVideoCapabilities* pNewVideoCaps = 
  230. new CVideoCapabilities(newSourceName);
  232. // check for errors
  233. if (!pNewVideoCaps->IsValid()) {
  234. if (!pNewVideoCaps->m_canOpen) {
  235. ShowMessage("Change Video Source",
  236. "Specified video source can't be opened, check name");
  237. } else {
  238. ShowMessage("Change Video Source",
  239. "Specified video source doesn't support capture");
  240. }
  241. delete pNewVideoCaps;
  242. return;
  243. }
  245. // change inputs menu
  246. CreateInputMenu(pNewVideoCaps);
  248. if (pVideoCaps != MyConfig->m_videoCapabilities) {
  249. delete pVideoCaps;
  250. }
  251. pVideoCaps = pNewVideoCaps;
  253. ChangeInput(inputIndex);
  254. }
  256. static void on_yes_default_file_audio_source (GtkWidget *widget, gpointer *data)
  257. {
  258. default_file_audio_source = 
  259. FileDefaultAudio(gtk_entry_get_text(GTK_ENTRY(source_entry)));
  261. default_file_audio_dialog = false;
  262. }
  264. static void on_no_default_file_audio_source (GtkWidget *widget, gpointer *data)
  265. {
  266. default_file_audio_dialog = false;
  267. }
  269. static void ChangeSource()
  270. {
  271. char* new_source_name =
  272. gtk_entry_get_text(GTK_ENTRY(source_entry));
  274. if (!strcmp(new_source_name, source_name)) {
  275. source_modified = false;
  276. return;
  277. }
  279. free(source_name);
  280. source_name = stralloc(new_source_name);
  282. default_file_audio_source = -1;
  284. // decide what type of source we have
  285. if (SourceIsDevice()) {
  286. source_type = VIDEO_SOURCE_V4L;
  288. SourceV4LDevice();
  289. } else {
  290. if (pVideoCaps != MyConfig->m_videoCapabilities) {
  291. delete pVideoCaps;
  292. }
  293. pVideoCaps = NULL;
  295. if (IsUrl(source_name)) {
  296. source_type = URL_SOURCE;
  297. } else {
  298. if (access(source_name, R_OK) != 0) {
  299. ShowMessage("Change Video Source",
  300. "Specified video source can't be opened, check name");
  301. }
  302. source_type = FILE_SOURCE;
  303. }
  305. if (!default_file_audio_dialog
  306.   && FileDefaultAudio(source_name) >= 0) {
  307. YesOrNo(
  308. "Change Video Source",
  309. "Do you want to use this for the audio source also?",
  310. true,
  311. GTK_SIGNAL_FUNC(on_yes_default_file_audio_source),
  312. GTK_SIGNAL_FUNC(on_no_default_file_audio_source));
  313. }
  314. }
  316. track_menu = CreateTrackMenu(
  317. track_menu,
  318. 'V',
  319. source_name,
  320. &trackIndex,
  321. &trackNumber,
  322. &trackValues);
  324. ShowSourceSpecificSettings();
  326. source_modified = false;
  327. }
  329. static void on_source_browse_button (GtkWidget *widget, gpointer *data)
  330. {
  331. FileBrowser(source_entry, GTK_SIGNAL_FUNC(ChangeSource));
  332. }
  334. static void on_source_entry_changed(GtkWidget *widget, gpointer *data)
  335. {
  336. if (widget == source_entry) {
  337. source_modified = true;
  338. }
  339. }
  341. static void on_source_leave(GtkWidget *widget, gpointer *data)
  342. {
  343. if (source_modified) {
  344. ChangeSource();
  345. }
  346. }
  348. static void on_source_list_changed(GtkWidget *widget, gpointer *data)
  349. {
  350. if (widget == source_list) {
  351. ChangeSource();
  352. }
  353. }
  356. char* GetChannelName(size_t index, void* pUserData)
  357. {
  358. return ((struct CHANNEL*)pUserData)[index].name;
  359. }
  361. static void CreateChannelCombo()
  362. {
  363. struct CHANNEL_LIST* pChannelList =
  364. ListOfChannelLists[signalIndex];
  366. GList* list = NULL;
  367. for (int i = 0; i < pChannelList[channelListIndex].count; i++) {
  368. list = g_list_append(list, 
  369. pChannelList[channelListIndex].list[i].name);
  370. }
  372. channel_combo = gtk_combo_new();
  373. gtk_combo_set_popdown_strings(GTK_COMBO(channel_combo), list);
  374. // although we do want to limit the combo choices to the ones we provide
  375. // this call results is some odd UI behaviors
  376. // gtk_combo_set_value_in_list(GTK_COMBO(channel_combo), 1, 0);
  377. gtk_combo_set_use_arrows_always(GTK_COMBO(channel_combo), 1);
  379. GtkWidget* entry = GTK_COMBO(channel_combo)->entry;
  380. gtk_entry_set_text(GTK_ENTRY(entry), 
  381. pChannelList[channelListIndex].list[channelIndex].name);
  383. gtk_widget_show(channel_combo);
  384. }
  386. void ChangeChannelList(u_int8_t newIndex)
  387. {
  388. channelListIndex = newIndex;
  390. // change channel index to zero
  391. channelIndex = 0;
  393. // recreate channel menu
  394. CreateChannelCombo();
  395. }
  397. static void on_channel_list_menu_activate(GtkWidget *widget, gpointer data)
  398. {
  399. ChangeChannelList((unsigned int)data & 0xFF);
  400. }
  402. char* GetChannelListName(size_t index, void* pUserData)
  403. {
  404. return ((struct CHANNEL_LIST*)pUserData)[index].name;
  405. }
  407. static void CreateChannelListMenu()
  408. {
  409. struct CHANNEL_LIST* pChannelList =
  410. ListOfChannelLists[signalIndex];
  412. channel_list_menu = CreateOptionMenu(
  413. channel_list_menu,
  414. GetChannelListName,
  415. pChannelList,
  416. 0xFF,
  417. channelListIndex,
  418. GTK_SIGNAL_FUNC(on_channel_list_menu_activate));
  419. }
  421. static void on_size_menu_activate(GtkWidget *widget, gpointer data)
  422. {
  423. sizeIndex = ((unsigned int)data) & 0xFF;
  424. }
  426. static void CreateSizeMenu()
  427. {
  428. sizeMaxIndex = sizeof(sizeNames) / sizeof(char*);
  429. if (signalIndex == 1) {
  430. // NTSC can't support the two largest sizes
  431. sizeMaxIndex -= 2;
  432. }
  434. if (sizeIndex >= sizeMaxIndex) {
  435. sizeIndex = sizeMaxIndex - 1;
  436. }
  438. size_menu = CreateOptionMenu(
  439. size_menu,
  440. sizeNames, 
  441. sizeMaxIndex,
  442. sizeIndex,
  443. GTK_SIGNAL_FUNC(on_size_menu_activate));
  444. }
  446. void ChangeSignal(u_int8_t newIndex)
  447. {
  448. signalIndex = newIndex;
  450. CreateChannelListMenu();
  451. ChangeChannelList(0);
  453. CreateSizeMenu();
  455. // change max frame rate spinner
  456. if (signalIndex == 1) {
  457. // NTSC 
  458. gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(frame_rate_spinner),
  459. GTK_ADJUSTMENT(frame_rate_ntsc_adjustment));
  460. } else {
  461. // PAL or SECAM
  462. float frameRate = gtk_spin_button_get_value_as_float(
  463. GTK_SPIN_BUTTON(frame_rate_spinner));
  465. if (frameRate > VIDEO_PAL_FRAME_RATE) {
  466. gtk_spin_button_set_value(GTK_SPIN_BUTTON(frame_rate_spinner),
  467. VIDEO_PAL_FRAME_RATE);
  468. }
  469. gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(frame_rate_spinner),
  470. GTK_ADJUSTMENT(frame_rate_pal_adjustment));
  471. }
  472. }
  474. static void on_signal_menu_activate(GtkWidget *widget, gpointer data)
  475. {
  476. ChangeSignal(((unsigned int)data) & 0xFF);
  477. }
  479. static void SetAvailableSignals(void)
  480. {
  481. GSList* item = signal_menu_items;
  482. u_int8_t i = 0;
  483. u_int8_t validSignalIndex = 0xFF;
  485. // for all menu items in the signal menu
  486. while (item != NULL) {
  487. // all signals are enabled
  488. bool enabled = true;
  490. // unless input is a tuner
  491. if (pVideoCaps != NULL
  492.   && pVideoCaps->m_inputHasTuners[inputIndex]) {
  494. // this signal type is valid for this tuner
  495.    if (pVideoCaps->m_inputTunerSignalTypes[inputIndex] & (1 << i)) {
  497. // remember first valid signal type for this tuner
  498. if (validSignalIndex == 0xFF) {
  499. validSignalIndex = i;
  500. }
  502. } else { // this signal type is invalid for this tuner
  504. // so disable this menu item
  505. enabled = false;
  507. // check if our current signal type is invalid for this tuner
  508. if (signalIndex == i) {
  509. signalIndex = 0xFF;
  510. }
  511. }
  512. }
  514. gtk_widget_set_sensitive(GTK_WIDGET(item->data), enabled);
  516. item = item->next;
  517. i++;
  518. }
  520. // try to choose a valid signal type if we don't have one
  521. if (signalIndex == 0xFF) {
  522. if (validSignalIndex == 0xFF) {
  523. // we're in trouble
  524. debug_message("SetAvailableSignals: no valid signal type!");
  525. signalIndex = 0;
  526. } else {
  527. signalIndex = validSignalIndex;
  528. }
  530. // cause the displayed value to be updated
  531. gtk_option_menu_set_history(GTK_OPTION_MENU(signal_menu), signalIndex);
  532. // TBD check that signal activate is called here
  533. }
  534. }
  536. static void on_aspect_menu_activate(GtkWidget *widget, gpointer data)
  537. {
  538. aspectIndex = ((unsigned int)data) & 0xFF;
  539. }
  541. static bool ValidateAndSave(void)
  542. {
  543. // if source has been modified
  544. if (source_modified) {
  545. // validate it
  546. ChangeSource();
  548. // can't validate
  549. if (source_modified) {
  550. return false;
  551. }
  552. }
  554. // if previewing, stop video source
  555. AVFlow->StopVideoPreview();
  557. // copy new values to config
  559. MyConfig->SetStringValue(CONFIG_VIDEO_SOURCE_TYPE,
  560. source_type);
  562. MyConfig->SetStringValue(CONFIG_VIDEO_SOURCE_NAME,
  563. gtk_entry_get_text(GTK_ENTRY(source_entry)));
  565. MyConfig->UpdateFileHistory(
  566. gtk_entry_get_text(GTK_ENTRY(source_entry)));
  568. if (MyConfig->m_videoCapabilities != pVideoCaps) {
  569. delete MyConfig->m_videoCapabilities;
  570. MyConfig->m_videoCapabilities = pVideoCaps;
  571. pVideoCaps = NULL;
  572. }
  574. if (strcasecmp(source_type, VIDEO_SOURCE_V4L) 
  575.   && default_file_audio_source >= 0) {
  576. MyConfig->SetStringValue(CONFIG_AUDIO_SOURCE_TYPE,
  577. source_type);
  578. MyConfig->SetStringValue(CONFIG_AUDIO_SOURCE_NAME,
  579. gtk_entry_get_text(GTK_ENTRY(source_entry)));
  580. MyConfig->SetIntegerValue(CONFIG_AUDIO_SOURCE_TRACK,
  581. default_file_audio_source);
  582. }
  584. MyConfig->SetIntegerValue(CONFIG_VIDEO_INPUT,
  585. inputIndex);
  587. MyConfig->SetIntegerValue(CONFIG_VIDEO_SIGNAL,
  588. signalIndex);
  590. MyConfig->SetIntegerValue(CONFIG_VIDEO_CHANNEL_LIST_INDEX,
  591. channelListIndex);
  593. // extract channel index out of combo (not so simple)
  594. GtkWidget* entry = GTK_COMBO(channel_combo)->entry;
  595. char* channelName = gtk_entry_get_text(GTK_ENTRY(entry));
  596. struct CHANNEL_LIST* pChannelList =
  597. ListOfChannelLists[signalIndex];
  598. for (int i = 0; i < pChannelList[channelListIndex].count; i++) {
  599. if (!strcmp(channelName, 
  600.   pChannelList[channelListIndex].list[i].name)) {
  601. channelIndex = i;
  602. break;
  603. }
  604. }
  605. MyConfig->SetIntegerValue(CONFIG_VIDEO_CHANNEL_INDEX,
  606. channelIndex);
  608. MyConfig->SetIntegerValue(CONFIG_VIDEO_SOURCE_TRACK,
  609. trackValues ? trackValues[trackIndex] : 0);
  611. MyConfig->SetIntegerValue(CONFIG_VIDEO_RAW_WIDTH,
  612. sizeWidthValues[sizeIndex]);
  614. MyConfig->SetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT,
  615. sizeHeightValues[sizeIndex]);
  617. MyConfig->SetFloatValue(CONFIG_VIDEO_ASPECT_RATIO,
  618. aspectValues[aspectIndex]);
  620. MyConfig->SetFloatValue(CONFIG_VIDEO_FRAME_RATE,
  621. gtk_spin_button_get_value_as_float(
  622. GTK_SPIN_BUTTON(frame_rate_spinner)));
  624. MyConfig->SetIntegerValue(CONFIG_VIDEO_BIT_RATE,
  625. gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(bit_rate_spinner)));
  628. // now put the new configuration into effect
  630. MyConfig->Update();
  632. NewVideoWindow();
  634. // restart video source
  635. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  636. AVFlow->StartVideoPreview();
  637. }
  639. // refresh display of settings in main window
  640. DisplayVideoSettings();  
  641. DisplayStatusSettings();  
  643. return true;
  644. }
  646. static void on_ok_button (GtkWidget *widget, gpointer *data)
  647. {
  648. // check and save values
  649. if (!ValidateAndSave()) {
  650. return;
  651. }
  652.     on_destroy_dialog(NULL, NULL);
  653. }
  655. static void on_cancel_button (GtkWidget *widget, gpointer *data)
  656. {
  657. on_destroy_dialog(NULL, NULL);
  658. }
  660. void CreateVideoDialog (void) 
  661. {
  662. GtkWidget* hbox;
  663. GtkWidget* vbox;
  664. GtkWidget* hbox2;
  665. GtkWidget* label;
  666. GtkWidget* button;
  667. GtkObject* adjustment;
  669. pVideoCaps = MyConfig->m_videoCapabilities;
  670. default_file_audio_source = -1;
  672. dialog = gtk_dialog_new();
  673. gtk_signal_connect(GTK_OBJECT(dialog),
  674. "destroy",
  675. GTK_SIGNAL_FUNC(on_destroy_dialog),
  676. &dialog);
  678. gtk_window_set_title(GTK_WINDOW(dialog), "Video Settings");
  679. gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  680. gtk_container_set_resize_mode(GTK_CONTAINER(dialog), GTK_RESIZE_IMMEDIATE);
  682. hbox = gtk_hbox_new(FALSE, 1);
  683. gtk_widget_show(hbox);
  684. gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
  685. FALSE, FALSE, 5);
  687. vbox = gtk_vbox_new(TRUE, 1);
  688. gtk_widget_show(vbox);
  689. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  691. label = gtk_label_new(" Source:");
  692. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  693. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  694. gtk_widget_show(label);
  696. input_label = gtk_label_new("   Port:");
  697. gtk_misc_set_alignment(GTK_MISC(input_label), 0.0, 0.5);
  698. gtk_box_pack_start(GTK_BOX(vbox), input_label, FALSE, FALSE, 0);
  700. signal_label = gtk_label_new("   Signal:");
  701. gtk_misc_set_alignment(GTK_MISC(signal_label), 0.0, 0.5);
  702. gtk_box_pack_start(GTK_BOX(vbox), signal_label, FALSE, FALSE, 0);
  704. channel_list_label = gtk_label_new("   Channel List:");
  705. gtk_misc_set_alignment(GTK_MISC(channel_list_label), 0.0, 0.5);
  706. gtk_box_pack_start(GTK_BOX(vbox), channel_list_label, FALSE, FALSE, 0);
  708. channel_label = gtk_label_new("   Channel:");
  709. gtk_misc_set_alignment(GTK_MISC(channel_label), 0.0, 0.5);
  710. gtk_box_pack_start(GTK_BOX(vbox), channel_label, FALSE, FALSE, 0);
  712. track_label = gtk_label_new("   Track:");
  713. gtk_misc_set_alignment(GTK_MISC(track_label), 0.0, 0.5);
  714. gtk_box_pack_start(GTK_BOX(vbox), track_label, FALSE, FALSE, 0);
  716. label = gtk_label_new(" Output:");
  717. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  718. gtk_widget_show(label);
  719. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  721. label = gtk_label_new("   Size:");
  722. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  723. gtk_widget_show(label);
  724. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  726. label = gtk_label_new("   Aspect Ratio:");
  727. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  728. gtk_widget_show(label);
  729. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  731. label = gtk_label_new("   Frame Rate (fps):");
  732. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  733. gtk_widget_show(label);
  734. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  736. label = gtk_label_new("   Bit Rate (kbps):");
  737. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  738. gtk_widget_show(label);
  739. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  742. vbox = gtk_vbox_new(TRUE, 1);
  743. gtk_widget_show(vbox);
  744. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  746. hbox2 = gtk_hbox_new(FALSE, 1);
  747. gtk_widget_show(hbox2);
  748. gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
  750. source_type = MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_TYPE);
  752. // source entry
  753. free(source_name);
  754. source_name = 
  755. stralloc(MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME));
  757. source_modified = false;
  759. source_combo = CreateFileCombo(source_name);
  761. source_entry = GTK_COMBO(source_combo)->entry;
  763. source_list = GTK_COMBO(source_combo)->list;
  764. gtk_signal_connect(GTK_OBJECT(source_list), "select_child",
  765. GTK_SIGNAL_FUNC(on_source_list_changed), NULL);
  767. SetEntryValidator(GTK_OBJECT(source_entry),
  768. GTK_SIGNAL_FUNC(on_source_entry_changed), 
  769. GTK_SIGNAL_FUNC(on_source_leave));
  771. gtk_widget_show(source_combo);
  772. gtk_box_pack_start(GTK_BOX(hbox2), source_combo, TRUE, TRUE, 0);
  774. // browse button
  775. browse_button = gtk_button_new_with_label(" Browse... ");
  776. gtk_signal_connect(GTK_OBJECT(browse_button),
  777.  "clicked",
  778.  GTK_SIGNAL_FUNC(on_source_browse_button),
  779.  NULL);
  780. gtk_widget_show(browse_button);
  781. gtk_box_pack_start(GTK_BOX(hbox2), browse_button, FALSE, FALSE, 5);
  783. // N.B. because of the dependencies of 
  784. // input, signal, channel list, channel, and sizes
  785. // order of operations is important here
  787. channelIndex = 
  788. MyConfig->GetIntegerValue(CONFIG_VIDEO_CHANNEL_INDEX);
  789. channelListIndex = 
  790. MyConfig->GetIntegerValue(CONFIG_VIDEO_CHANNEL_LIST_INDEX);
  791. signalIndex = 
  792. MyConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL); 
  793. inputIndex = 
  794. MyConfig->GetIntegerValue(CONFIG_VIDEO_INPUT);
  796. channel_combo = NULL;
  797. CreateChannelCombo();
  799. channel_list_menu = NULL;
  800. CreateChannelListMenu();
  802. track_menu = NULL;
  803. track_menu = CreateTrackMenu(
  804. track_menu,
  805. 'V',
  806. gtk_entry_get_text(GTK_ENTRY(source_entry)),
  807. &trackIndex,
  808. &trackNumber,
  809. &trackValues);
  811. trackIndex = 0; 
  812. for (u_int8_t i = 0; i < trackNumber; i++) {
  813. if (MyConfig->GetIntegerValue(CONFIG_VIDEO_SOURCE_TRACK)
  814.    == trackValues[i]) {
  815. trackIndex = i;
  816. break;
  817. }
  818. }
  820. sizeIndex = 0; 
  821. for (u_int8_t i = 0; i < sizeof(sizeWidthValues) / sizeof(u_int16_t); i++) {
  822. if (MyConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH)
  823.     == sizeWidthValues[i]
  824.   && MyConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT)
  825.     == sizeHeightValues[i]) {
  826. sizeIndex = i;
  827. break;
  828. }
  829. }
  831. size_menu = NULL;
  832. CreateSizeMenu();
  834. signal_menu = CreateOptionMenu(
  835. NULL,
  836. signalNames, 
  837. sizeof(signalNames) / sizeof(char*),
  838. signalIndex,
  839. GTK_SIGNAL_FUNC(on_signal_menu_activate),
  840. &signal_menu_items);
  842. input_menu = NULL;
  843. CreateInputMenu(pVideoCaps);
  844. ChangeInput(inputIndex);
  846. gtk_box_pack_start(GTK_BOX(vbox), input_menu, FALSE, FALSE, 0);
  848. gtk_box_pack_start(GTK_BOX(vbox), signal_menu, FALSE, FALSE, 0);
  850. gtk_box_pack_start(GTK_BOX(vbox), channel_list_menu, FALSE, FALSE, 0);
  852. gtk_box_pack_start(GTK_BOX(vbox), channel_combo, FALSE, FALSE, 0);
  854. gtk_box_pack_start(GTK_BOX(vbox), track_menu, FALSE, FALSE, 0);
  856. // spacer
  857. label = gtk_label_new(" ");
  858. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  859. gtk_widget_show(label);
  860. gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  862. gtk_box_pack_start(GTK_BOX(vbox), size_menu, FALSE, FALSE, 0);
  864. aspectIndex = 0; 
  865. for (u_int8_t i = 0; i < sizeof(aspectValues) / sizeof(float); i++) {
  866. if (MyConfig->GetFloatValue(CONFIG_VIDEO_ASPECT_RATIO)
  867.   == aspectValues[i]) {
  868. aspectIndex = i;
  869. break;
  870. }
  871. }
  872. aspect_menu = CreateOptionMenu(
  873. NULL,
  874. aspectNames, 
  875. sizeof(aspectNames) / sizeof(char*),
  876. aspectIndex,
  877. GTK_SIGNAL_FUNC(on_aspect_menu_activate));
  878. gtk_box_pack_start(GTK_BOX(vbox), aspect_menu, FALSE, FALSE, 0);
  880. frame_rate_pal_adjustment = gtk_adjustment_new(
  881. MyConfig->GetFloatValue(CONFIG_VIDEO_FRAME_RATE),
  882. 1, VIDEO_PAL_FRAME_RATE, 1, 0, 0);
  883. gtk_object_ref(frame_rate_pal_adjustment);
  885. frame_rate_ntsc_adjustment = gtk_adjustment_new(
  886. MyConfig->GetFloatValue(CONFIG_VIDEO_FRAME_RATE),
  887. 1, VIDEO_NTSC_FRAME_RATE, 1, 0, 0);
  888. gtk_object_ref(frame_rate_ntsc_adjustment);
  890. if (signalIndex == 1) {
  891. frame_rate_spinner = gtk_spin_button_new(
  892. GTK_ADJUSTMENT(frame_rate_ntsc_adjustment), 1, 2);
  893. } else {
  894. frame_rate_spinner = gtk_spin_button_new(
  895. GTK_ADJUSTMENT(frame_rate_pal_adjustment), 1, 2);
  896. }
  897. gtk_widget_show(frame_rate_spinner);
  898. gtk_box_pack_start(GTK_BOX(vbox), frame_rate_spinner, FALSE, FALSE, 0);
  900. adjustment = gtk_adjustment_new(
  901. MyConfig->GetIntegerValue(CONFIG_VIDEO_BIT_RATE),
  902. 25, 4000, 50, 0, 0);
  903. bit_rate_spinner = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 50, 0);
  904. gtk_widget_show(bit_rate_spinner);
  905. gtk_box_pack_start(GTK_BOX(vbox), bit_rate_spinner, FALSE, FALSE, 0);
  907. // Add standard buttons at bottom
  908. button = AddButtonToDialog(dialog,
  909. " OK ", 
  910. GTK_SIGNAL_FUNC(on_ok_button));
  911. GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  913. AddButtonToDialog(dialog,
  914. " Cancel ", 
  915. GTK_SIGNAL_FUNC(on_cancel_button));
  917. ShowSourceSpecificSettings();
  919. gtk_widget_show(dialog);
  920. }
  922. /* end video_dialog.cpp */