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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

gui_main.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. /*
  24.  * gui_main.cpp - Contains the gtk based gui 
  25.  */
  26. #define __STDC_LIMIT_MACROS
  27. #include "mp4live.h"
  28. #include "mp4live_gui.h"
  29. #include "gdk/gdkx.h"
  31. CLiveConfig* MyConfig;
  32. CAVMediaFlow* AVFlow;
  34. /* Local variables */
  35. static bool started = false;
  37. static GtkWidget *main_window;
  38. static GtkWidget *main_hbox;
  39. static GtkWidget *main_vbox1;
  40. static GtkWidget *main_vbox2;
  41. static GtkWidget *video_preview;
  43. static GtkWidget *video_enabled_button;
  44. static GSList  *video_preview_radio_group;
  45. static GtkWidget *video_none_preview_button;
  46. static GtkWidget *video_raw_preview_button;
  47. static GtkWidget *video_encoded_preview_button;
  48. static GtkWidget *video_settings_label1;
  49. static GtkWidget *video_settings_label2;
  50. static GtkWidget *video_settings_label3;
  51. static GtkWidget *video_settings_button;
  53. static GtkWidget *audio_enabled_button;
  54. static GtkWidget *audio_mute_button;
  55. static GtkWidget *audio_settings_label1;
  56. static GtkWidget *audio_settings_label2;
  57. static GtkWidget *audio_settings_label3;
  58. static GtkWidget *audio_settings_button;
  60. static GtkWidget *record_enabled_button;
  61. static GtkWidget *record_settings_label;
  62. static GtkWidget *record_settings_button;
  64. static GtkWidget *transmit_enabled_button;
  65. static GtkWidget *transmit_settings_label;
  66. static GtkWidget *transmit_settings_button;
  68. static GtkWidget *start_button;
  69. static GtkWidget *start_button_label;
  70. static GtkWidget *duration_spinner;
  71. static GtkWidget *duration_units_menu;
  73. static GtkWidget *config_file_entry;
  74. static GtkWidget *load_config_button;
  75. static GtkWidget *save_config_button;
  77. static u_int16_t durationUnitsValues[] = {
  78. 1, 60, 3600
  79. };
  80. static char* durationUnitsNames[] = {
  81. "Seconds", "Minutes", "Hours"
  82. };
  83. static u_int8_t durationUnitsIndex = 1;
  85. static GtkWidget *media_source_label;
  86. static GtkWidget *media_source;
  88. static GtkWidget *start_time_label;
  89. static GtkWidget *start_time;
  90. static GtkWidget *start_time_units;
  92. static GtkWidget *duration_label;
  93. static GtkWidget *duration;
  94. static GtkWidget *duration_units;
  96. static GtkWidget *current_time_label;
  97. static GtkWidget *current_time;
  98. static GtkWidget *current_time_units;
  100. static GtkWidget *finish_time_label;
  101. static GtkWidget *finish_time;
  102. static GtkWidget *finish_time_units;
  104. static GtkWidget *current_size_label;
  105. static GtkWidget *current_size;
  106. static GtkWidget *current_size_units;
  108. static GtkWidget *final_size_label;
  109. static GtkWidget *final_size;
  110. static GtkWidget *final_size_units;
  112. static GtkWidget *actual_fps_label;
  113. static GtkWidget *actual_fps;
  114. static GtkWidget *actual_fps_units;
  116. static Timestamp StartTime;
  117. static Timestamp StopTime;
  118. static Duration FlowDuration;
  119. static u_int32_t StartEncodedFrameNumber;
  120. static u_int64_t StartFileSize;
  121. static u_int64_t StopFileSize;
  123. /*
  124.  * delete_event - called when window closed
  125.  */
  126. static void delete_event (GtkWidget *widget, gpointer *data)
  127. {
  128. gtk_main_quit();
  129. }
  131. void NewVideoWindow()
  132. {
  133. // We use the Gtk Preview widget to get the right type of window created
  134. // and then hand it over to SDL to actually do the blitting
  136. if (video_preview != NULL) {
  137. gtk_container_remove(GTK_CONTAINER(main_vbox1), 
  138. GTK_WIDGET(video_preview));
  139. video_preview = NULL;
  140. }
  142. video_preview = gtk_preview_new(GTK_PREVIEW_COLOR);
  144. gtk_preview_size(GTK_PREVIEW(video_preview), 
  145. MyConfig->m_videoWidth, MyConfig->m_videoHeight);
  147. gtk_widget_show(video_preview);
  149. gtk_box_pack_start(GTK_BOX(main_vbox1), video_preview, FALSE, FALSE, 5);
  151. // Let video source know which window to draw into
  152. gtk_widget_realize(video_preview); // so XCreateWindow() is called
  154. if (video_preview->window) {
  155. MyConfig->m_videoPreviewWindowId = 
  156. GDK_WINDOW_XWINDOW(video_preview->window);
  157. }
  158. }
  160. void DisplayVideoSettings(void)
  161. {
  162. char buffer[256];
  164. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(video_enabled_button),
  165. MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE));
  166.   
  167. gtk_toggle_button_set_active(
  168. GTK_TOGGLE_BUTTON(video_none_preview_button), 
  169. !MyConfig->GetBoolValue(CONFIG_VIDEO_PREVIEW));
  171. gtk_toggle_button_set_active(
  172. GTK_TOGGLE_BUTTON(video_raw_preview_button), 
  173. MyConfig->GetBoolValue(CONFIG_VIDEO_PREVIEW)
  174. && MyConfig->GetBoolValue(CONFIG_VIDEO_RAW_PREVIEW));
  176. gtk_toggle_button_set_active(
  177. GTK_TOGGLE_BUTTON(video_encoded_preview_button), 
  178. MyConfig->GetBoolValue(CONFIG_VIDEO_PREVIEW)
  179. && MyConfig->GetBoolValue(CONFIG_VIDEO_ENCODED_PREVIEW));
  181. snprintf(buffer, sizeof(buffer), " MPEG-4 at %u kbps",
  182. MyConfig->GetIntegerValue(CONFIG_VIDEO_BIT_RATE));
  183. gtk_label_set_text(GTK_LABEL(video_settings_label1), buffer);
  184. gtk_widget_show(video_settings_label1);
  186. snprintf(buffer, sizeof(buffer), " %u x %u @ %.2f fps", 
  187. MyConfig->m_videoWidth,
  188. MyConfig->m_videoHeight,
  189. MyConfig->GetFloatValue(CONFIG_VIDEO_FRAME_RATE));
  190. gtk_label_set_text(GTK_LABEL(video_settings_label2), buffer);
  191. gtk_widget_show(video_settings_label2);
  192. }
  194. void DisplayAudioSettings(void)
  195. {
  196. char buffer[256];
  197.  
  198. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(audio_enabled_button),
  199. MyConfig->GetBoolValue(CONFIG_AUDIO_ENABLE));
  200.   
  201. char* encoding;
  202. if (!strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  203.   AUDIO_ENCODING_AAC)) {
  204. encoding = "AAC";
  205. } else {
  206. encoding = "MP3";
  207. }
  209. snprintf(buffer, sizeof(buffer), " %s at %u kbps",
  210. encoding,
  211. MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE));
  212. gtk_label_set_text(GTK_LABEL(audio_settings_label1), buffer);
  213. gtk_widget_show(audio_settings_label1);
  215. snprintf(buffer, sizeof(buffer), " %s @ %u Hz",
  216. (MyConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS) == 2
  217. ? "Stereo" : "Mono"),
  218. MyConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE));
  219. gtk_label_set_text(GTK_LABEL(audio_settings_label2), buffer);
  220. gtk_widget_show(audio_settings_label2);
  221. }
  223. void DisplayTransmitSettings (void)
  224. {
  225. char buffer[256];
  226. const char *addr = MyConfig->GetStringValue(CONFIG_RTP_DEST_ADDRESS);
  228. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(transmit_enabled_button),
  229. MyConfig->GetBoolValue(CONFIG_RTP_ENABLE));
  230.   
  231. if (addr == NULL) {
  232. gtk_label_set_text(GTK_LABEL(transmit_settings_label), 
  233. "RTP/UDP to <Automatic Multicast>");
  234. } else {
  235. snprintf(buffer, sizeof(buffer), " RTP/UDP to %s", addr); 
  236. gtk_label_set_text(GTK_LABEL(transmit_settings_label), buffer);
  237. }
  238. gtk_widget_show(transmit_settings_label);
  239. }
  241. void DisplayRecordingSettings(void)
  242. {
  243. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(record_enabled_button),
  244. MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE));
  246. char* fileName = strrchr(
  247. MyConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME), '/');
  248. if (!fileName) {
  249. fileName = MyConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME);
  250. } else {
  251. fileName++;
  252. }
  254. char buffer[256];
  255.     snprintf(buffer, sizeof(buffer), " %s", fileName);
  256. gtk_label_set_text(GTK_LABEL(record_settings_label), buffer);
  257. gtk_widget_show(record_settings_label);
  258. }
  260. void DisplayControlSettings(void)
  261. {
  262. // duration
  263. gtk_spin_button_set_value(
  264. GTK_SPIN_BUTTON(duration_spinner),
  265. (gfloat)MyConfig->GetIntegerValue(CONFIG_APP_DURATION));
  267. // duration units
  268. for (u_int8_t i = 0; 
  269.   i < sizeof(durationUnitsValues) / sizeof(u_int16_t); i++) {
  270. if (MyConfig->GetIntegerValue(CONFIG_APP_DURATION_UNITS) 
  271.   == durationUnitsValues[i]) {
  272. durationUnitsIndex = i;
  273. break;
  274. }
  275. }
  276. gtk_option_menu_set_history(
  277. GTK_OPTION_MENU(duration_units_menu), 
  278. durationUnitsIndex);
  279. gtk_widget_show(duration_units_menu);
  280. }
  282. void DisplayStatusSettings(void)
  283. {
  284. // media source
  285. char buffer[128];
  287. buffer[0] = '';
  289. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)
  290.   && MyConfig->GetBoolValue(CONFIG_AUDIO_ENABLE)
  291.   && strcmp(MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME),
  292. MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME))) {
  294. snprintf(buffer, sizeof(buffer), "%s & %s",
  295. MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME),
  296. MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME));
  297. gtk_label_set_text(GTK_LABEL(media_source), buffer);
  299. } else if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  300. gtk_label_set_text(GTK_LABEL(media_source),
  301. MyConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME));
  303. } else if (MyConfig->GetBoolValue(CONFIG_AUDIO_ENABLE)) {
  304. gtk_label_set_text(GTK_LABEL(media_source),
  305. MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME));
  306. }
  307. }
  309. void DisplayAllSettings()
  310. {
  311. DisplayVideoSettings();
  312. DisplayAudioSettings();
  313. DisplayRecordingSettings();
  314. DisplayTransmitSettings();
  315. DisplayControlSettings();
  316. DisplayStatusSettings();
  317. }
  319. void DisplayFinishTime(Timestamp t)
  320. {
  321. time_t secs;
  322. const struct tm *local;
  323. char buffer[128];
  325. secs = (time_t)GetSecsFromTimestamp(t);
  326. local = localtime(&secs);
  327. strftime(buffer, sizeof(buffer), "%l:%M:%S", local);
  328. gtk_label_set_text(GTK_LABEL(finish_time), buffer);
  329. gtk_widget_show(finish_time);
  331. strftime(buffer, sizeof(buffer), "%p", local);
  332. gtk_label_set_text(GTK_LABEL(finish_time_units), buffer);
  333. gtk_widget_show(finish_time_units);
  334. }
  336. static void on_video_enabled_button (GtkWidget *widget, gpointer *data)
  337. {
  338. MyConfig->SetBoolValue(CONFIG_VIDEO_ENABLE,
  339. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  341. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  342. AVFlow->StartVideoPreview();
  343. } else {
  344. AVFlow->StopVideoPreview();
  345. }
  346. }
  348. static void on_video_preview_button (GtkWidget *widget, gpointer *data)
  349. {
  350. MyConfig->SetBoolValue(CONFIG_VIDEO_PREVIEW,
  351. !gtk_toggle_button_get_active(
  352. GTK_TOGGLE_BUTTON(video_none_preview_button)));
  354. MyConfig->SetBoolValue(CONFIG_VIDEO_RAW_PREVIEW,
  355. gtk_toggle_button_get_active(
  356. GTK_TOGGLE_BUTTON(video_raw_preview_button)));
  358. MyConfig->SetBoolValue(CONFIG_VIDEO_ENCODED_PREVIEW,
  359. gtk_toggle_button_get_active(
  360. GTK_TOGGLE_BUTTON(video_encoded_preview_button)));
  362. MyConfig->UpdateVideo();
  363. }
  365. static void on_video_settings_button (GtkWidget *widget, gpointer *data)
  366. {
  367. CreateVideoDialog();
  368. }
  370. static void on_audio_enabled_button (GtkWidget *widget, gpointer *data)
  371. {
  372. MyConfig->SetBoolValue(CONFIG_AUDIO_ENABLE,
  373. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  374. }
  376. static void on_audio_mute_button (GtkWidget *widget, gpointer *data)
  377. {
  378. AVFlow->SetAudioOutput(
  379. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  380. }
  382. static void on_audio_settings_button (GtkWidget *widget, gpointer *data)
  383. {
  384. CreateAudioDialog();
  385. }
  387. static void on_record_enabled_button (GtkWidget *widget, gpointer *data)
  388. {
  389. MyConfig->SetBoolValue(CONFIG_RECORD_ENABLE,
  390. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  391. }
  393. static void on_record_settings_button (GtkWidget *widget, gpointer *data)
  394. {
  395. CreateRecordingDialog();
  396. }
  398. static void on_transmit_enabled_button (GtkWidget *widget, gpointer *data)
  399. {
  400. MyConfig->SetBoolValue(CONFIG_RTP_ENABLE, 
  401. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  402. }
  404. static void on_transmit_settings_button (GtkWidget *widget, gpointer *data)
  405. {
  406. CreateTransmitDialog();
  407. }
  409. static void LockoutChanges(bool lockout)
  410. {
  411. gtk_widget_set_sensitive(GTK_WIDGET(video_enabled_button), !lockout);
  412. gtk_widget_set_sensitive(GTK_WIDGET(video_settings_button), !lockout);
  413. gtk_widget_set_sensitive(GTK_WIDGET(audio_enabled_button), !lockout);
  414. gtk_widget_set_sensitive(GTK_WIDGET(audio_settings_button), !lockout);
  415. gtk_widget_set_sensitive(GTK_WIDGET(record_enabled_button), !lockout);
  416. gtk_widget_set_sensitive(GTK_WIDGET(record_settings_button), !lockout);
  417. gtk_widget_set_sensitive(GTK_WIDGET(transmit_enabled_button), !lockout);
  418. gtk_widget_set_sensitive(GTK_WIDGET(transmit_settings_button), !lockout);
  419. gtk_widget_set_sensitive(GTK_WIDGET(duration_spinner), !lockout);
  420. gtk_widget_set_sensitive(GTK_WIDGET(duration_units_menu), !lockout);
  421. gtk_widget_set_sensitive(GTK_WIDGET(config_file_entry), !lockout);
  422. gtk_widget_set_sensitive(GTK_WIDGET(load_config_button), !lockout);
  423. gtk_widget_set_sensitive(GTK_WIDGET(save_config_button), !lockout);
  424. }
  426. static guint status_timer_id;
  428. // forward declaration
  429. static void on_start_button (GtkWidget *widget, gpointer *data);
  431. static void status_start()
  432. {
  433. time_t secs;
  434. const struct tm *local;
  435. char buffer[128];
  437. // start time
  438. secs = (time_t)GetSecsFromTimestamp(StartTime);
  439. local = localtime(&secs);
  440. strftime(buffer, sizeof(buffer), "%l:%M:%S", local);
  441. gtk_label_set_text(GTK_LABEL(start_time), buffer);
  442. gtk_widget_show(start_time);
  444. strftime(buffer, sizeof(buffer), "%p", local);
  445. gtk_label_set_text(GTK_LABEL(start_time_units), buffer);
  446. gtk_widget_show(start_time_units);
  448. // finish time
  449. if (StopTime) {
  450. DisplayFinishTime(StopTime);
  451. }
  453. // file size
  454. StartFileSize = 0;
  455. StopFileSize = 0;
  457. if (MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE)) {
  458. if (!MyConfig->GetBoolValue(CONFIG_RECORD_MP4_OVERWRITE)) {
  459. struct stat stats;
  460. stat(MyConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME), &stats);
  461. StartFileSize = stats.st_size;
  462. }
  464. snprintf(buffer, sizeof(buffer), " %llu",
  465. StartFileSize / 1000000);
  466. gtk_label_set_text(GTK_LABEL(current_size), buffer);
  467. gtk_widget_show(current_size);
  469. gtk_label_set_text(GTK_LABEL(current_size_units), "MB");
  470. gtk_widget_show(current_size_units);
  472. StopFileSize = MyConfig->m_recordEstFileSize;
  473. snprintf(buffer, sizeof(buffer), " %llu",
  474. StopFileSize / 1000000);
  475. gtk_label_set_text(GTK_LABEL(final_size), buffer);
  476. gtk_widget_show(final_size);
  478. gtk_label_set_text(GTK_LABEL(final_size_units), "MB");
  479. gtk_widget_show(final_size_units);
  480. }
  481. }
  483. /*
  484.  * Status timer routine
  485.  */
  486. static gint status_timer (gpointer raw)
  487. {
  488. time_t secs;
  489. const struct tm *local;
  490. char buffer[80];
  492. Timestamp now = GetTimestamp();
  493. secs = (time_t)GetSecsFromTimestamp(now);
  494. local = localtime(&secs);
  495. strftime(buffer, sizeof(buffer), "%l:%M:%S", local);
  496. gtk_label_set_text(GTK_LABEL(current_time), buffer);
  497. gtk_widget_show(current_time);
  499. strftime(buffer, sizeof(buffer), "%p", local);
  500. gtk_label_set_text(GTK_LABEL(current_time_units), buffer);
  501. gtk_widget_show(current_time);
  503. time_t duration_secs = (time_t)GetSecsFromTimestamp(now - StartTime);
  505. snprintf(buffer, sizeof(buffer), "%lu:%02lu:%02lu", 
  506. duration_secs / 3600, (duration_secs % 3600) / 60, duration_secs % 60);
  507. gtk_label_set_text(GTK_LABEL(duration), buffer);
  508. gtk_widget_show(duration);
  510. if (MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE)) {
  511. struct stat stats;
  512. stat(MyConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME), &stats);
  513. snprintf(buffer, sizeof(buffer), " %lu", stats.st_size / 1000000);
  514. gtk_label_set_text(GTK_LABEL(current_size), buffer);
  515. gtk_widget_show(current_size);
  516. }
  518. if (!StopTime) {
  519. float progress;
  520. AVFlow->GetStatus(FLOW_STATUS_PROGRESS, &progress);
  522. if (progress > 0.0) {
  523. u_int32_t estDuration = (u_int32_t)(duration_secs / progress);
  524. DisplayFinishTime(StartTime + (estDuration * TimestampTicks));
  525. }
  526. }
  528. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  529. u_int32_t encodedFrames;
  530. AVFlow->GetStatus(FLOW_STATUS_VIDEO_ENCODED_FRAMES, &encodedFrames);
  531. u_int32_t totalFrames = encodedFrames - StartEncodedFrameNumber;
  533. snprintf(buffer, sizeof(buffer), " %.2f", 
  534. ((float)totalFrames / (float)(now - StartTime)) * TimestampTicks);
  535. gtk_label_set_text(GTK_LABEL(actual_fps), buffer);
  536. gtk_widget_show(actual_fps);
  538. gtk_label_set_text(GTK_LABEL(actual_fps_units), "fps");
  539. gtk_widget_show(actual_fps_units);
  540. }
  542. bool stop = false;
  544. if (StopTime) {
  545. stop = (now >= StopTime);
  546. } 
  548. if (!stop && duration_secs > 10) {
  549. AVFlow->GetStatus(FLOW_STATUS_DONE, &stop);
  550. }
  551. if (!stop) {
  552. Duration elapsedDuration;
  553. if (AVFlow->GetStatus(FLOW_STATUS_DURATION, &elapsedDuration)) {
  554. if (elapsedDuration >= FlowDuration) {
  555. stop = true;
  556. }
  557. }
  558. }
  560. if (stop) {
  561. // automatically "press" stop button
  562. DoStop();
  564. if (MyConfig->m_appAutomatic) {
  565. // In automatic mode, time to exit app
  566. gtk_main_quit();
  567. } else {
  568. // Make sure user knows that were done
  569. char *notice;
  571. if (MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE)
  572.   && MyConfig->GetBoolValue(CONFIG_RTP_ENABLE)) {
  573. notice = "Recording and transmission completed";
  574. } else if (MyConfig->GetBoolValue(CONFIG_RTP_ENABLE)) {
  575. notice = "Transmission completed";
  576. } else {
  577. notice = "Recording completed";
  578. }
  579. ShowMessage("Completed", notice);
  580. }
  582. return (FALSE);
  583. }
  585. return (TRUE);  // keep timer going
  586. }
  588. void DoStart()
  589. {
  590. if (!MyConfig->GetBoolValue(CONFIG_AUDIO_ENABLE)
  591.   && !MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  592. ShowMessage("No Media", "Neither audio nor video are enabled");
  593. return;
  594. }
  596. // lock out change to settings while media is running
  597. LockoutChanges(true);
  599. AVFlow->Start();
  601. StartTime = GetTimestamp(); 
  603. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  604. if (MyConfig->IsCaptureVideoSource()) {
  605. AVFlow->GetStatus(FLOW_STATUS_VIDEO_ENCODED_FRAMES, 
  606. &StartEncodedFrameNumber);
  607. } else {
  608. StartEncodedFrameNumber = 0;
  609. }
  610. }
  612. FlowDuration =
  613. gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(duration_spinner))
  614. * durationUnitsValues[durationUnitsIndex] * TimestampTicks;
  616. if (!MyConfig->IsCaptureVideoSource() && !MyConfig->IsCaptureAudioSource()
  617.   && !MyConfig->GetBoolValue(CONFIG_RTP_ENABLE)) {
  618. // no real time constraints
  619. StopTime = 0;
  620. } else {
  621. StopTime = StartTime + FlowDuration;
  622. }
  624. status_start();
  626. gtk_label_set_text(GTK_LABEL(start_button_label), "  Stop  ");
  628. status_timer_id = gtk_timeout_add(1000, status_timer, main_window);
  630. started = true;
  631. }
  633. void DoStop()
  634. {
  635. gtk_timeout_remove(status_timer_id);
  637. if (MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE)) {
  638. char* notice = "CLOSING";
  640. if (MyConfig->GetBoolValue(CONFIG_RECORD_MP4_HINT_TRACKS)) {
  641. notice = "HINTING";
  642. }
  644. // borrow finish time field
  645. gtk_label_set_text(GTK_LABEL(finish_time), notice);
  646. gtk_widget_show_now(finish_time);
  648. gtk_label_set_text(GTK_LABEL(finish_time_units), "");
  649. gtk_widget_show_now(finish_time_units);
  650. }
  652. AVFlow->Stop();
  654. if (MyConfig->GetBoolValue(CONFIG_RECORD_ENABLE)) {
  655. DisplayFinishTime(GetTimestamp());
  656. }
  658. // unlock changes to settings
  659. LockoutChanges(false);
  661. gtk_label_set_text(GTK_LABEL(start_button_label), "  Start  ");
  663. started = false;
  664. }
  666. static void on_start_button (GtkWidget *widget, gpointer *data)
  667. {
  668. if (!started) {
  669. DoStart();
  670. } else {
  671. DoStop();
  672. }
  673. }
  675. static void on_duration_changed(GtkWidget* widget, gpointer* data)
  676. {
  677. MyConfig->SetIntegerValue(CONFIG_APP_DURATION,
  678. gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(duration_spinner)));
  679. MyConfig->UpdateRecord();
  680. }
  682. static void on_duration_units_menu_activate(GtkWidget *widget, gpointer data)
  683. {
  684. durationUnitsIndex = (unsigned int)data & 0xFF;;
  685. MyConfig->SetIntegerValue(CONFIG_APP_DURATION_UNITS,
  686. durationUnitsValues[durationUnitsIndex]);
  687. MyConfig->UpdateRecord();
  688. }
  690. static void LoadConfig()
  691. {
  692. AVFlow->StopVideoPreview();
  694. char* configFileName =
  695. gtk_entry_get_text(GTK_ENTRY(config_file_entry));
  697. MyConfig->ReadFromFile(configFileName);
  699. MyConfig->Update();
  701. DisplayAllSettings();
  703. NewVideoWindow();
  705. // restart video source
  706. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  707. AVFlow->StartVideoPreview();
  708. }
  709. }
  711. static void on_load_config_button (GtkWidget *widget, gpointer *data)
  712. {
  713. FileBrowser(config_file_entry, GTK_SIGNAL_FUNC(LoadConfig));
  714. }
  716. static void on_save_config_button (GtkWidget *widget, gpointer *data)
  717. {
  718. char* configFileName =
  719. gtk_entry_get_text(GTK_ENTRY(config_file_entry));
  721. MyConfig->WriteToFile(configFileName);
  723. char notice[512];
  724. sprintf(notice,
  725. "Current configuration saved to %s", configFileName);
  727. ShowMessage("Configuration Saved", notice);
  728. }
  730. static gfloat frameLabelAlignment = 0.025;
  732. static void LayoutVideoFrame(GtkWidget* box)
  733. {
  734. GtkWidget *frame;
  735. GtkWidget *vbox, *hbox, *vbox1, *vbox2;
  736. GtkWidget *label;
  738. frame = gtk_frame_new("Video");
  739. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  740. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  741. gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 5);
  743. vbox = gtk_vbox_new(FALSE, 1);
  744. gtk_widget_show(vbox);
  746. // create first row
  747. hbox = gtk_hbox_new(FALSE, 1);
  748. gtk_widget_show(hbox);
  749. gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
  750.   
  751. // enabled button
  752. video_enabled_button = gtk_check_button_new_with_label("Enabled");
  753. gtk_box_pack_start(GTK_BOX(hbox), video_enabled_button, TRUE, TRUE, 5);
  754. gtk_signal_connect(GTK_OBJECT(video_enabled_button), 
  755. "toggled",
  756. GTK_SIGNAL_FUNC(on_video_enabled_button),
  757. NULL);
  758. gtk_widget_show(video_enabled_button);
  760. // create second row
  761. hbox = gtk_hbox_new(FALSE, 1);
  762. gtk_widget_show(hbox);
  763. gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
  765. // preview label
  766. label = gtk_label_new(" Preview:");
  767. gtk_widget_show(label);
  768. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  769. gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
  771. // none preview radio button
  772. video_none_preview_button = gtk_radio_button_new_with_label(NULL, "None");
  773. gtk_widget_show(video_none_preview_button);
  774. gtk_box_pack_start(GTK_BOX(hbox), video_none_preview_button,
  775. FALSE, FALSE, 0);
  777. // raw preview radio button
  778. video_preview_radio_group = 
  779. gtk_radio_button_group(GTK_RADIO_BUTTON(video_none_preview_button));
  780. video_raw_preview_button = 
  781. gtk_radio_button_new_with_label(video_preview_radio_group, "Raw");
  782. gtk_widget_show(video_raw_preview_button);
  783. gtk_box_pack_start(GTK_BOX(hbox), video_raw_preview_button,
  784. FALSE, FALSE, 0);
  786. // encoded preview radio button
  787. video_preview_radio_group = 
  788. gtk_radio_button_group(GTK_RADIO_BUTTON(video_none_preview_button));
  789. video_encoded_preview_button = 
  790. gtk_radio_button_new_with_label(video_preview_radio_group, "Encoded");
  791. gtk_widget_show(video_encoded_preview_button);
  792. gtk_box_pack_start(GTK_BOX(hbox), video_encoded_preview_button,
  793. FALSE, FALSE, 0);
  795. gtk_signal_connect(GTK_OBJECT(video_none_preview_button), 
  796. "toggled",
  797.  GTK_SIGNAL_FUNC(on_video_preview_button),
  798.  NULL);
  799. gtk_signal_connect(GTK_OBJECT(video_raw_preview_button), 
  800. "toggled",
  801.  GTK_SIGNAL_FUNC(on_video_preview_button),
  802.  NULL);
  803. gtk_signal_connect(GTK_OBJECT(video_encoded_preview_button), 
  804. "toggled",
  805.  GTK_SIGNAL_FUNC(on_video_preview_button),
  806.  NULL);
  808. // create third row
  809. hbox = gtk_hbox_new(FALSE, 1);
  810. gtk_widget_show(hbox);
  811. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  813. // secondary vbox for two labels
  814. vbox1 = gtk_vbox_new(FALSE, 1);
  815. gtk_widget_show(vbox1);
  816. gtk_box_pack_start(GTK_BOX(hbox), vbox1, TRUE, TRUE, 5);
  818. video_settings_label1 = gtk_label_new("");
  819. gtk_misc_set_alignment(GTK_MISC(video_settings_label1), 0.0, 0.5);
  820. gtk_box_pack_start(GTK_BOX(vbox1), video_settings_label1, TRUE, TRUE, 0);
  822. video_settings_label2 = gtk_label_new("");
  823. gtk_misc_set_alignment(GTK_MISC(video_settings_label2), 0.0, 0.5);
  824. gtk_box_pack_start(GTK_BOX(vbox1), video_settings_label2, TRUE, TRUE, 0);
  826. // secondary vbox to match stacked labels
  827. vbox2 = gtk_vbox_new(FALSE, 1);
  828. gtk_widget_show(vbox2);
  829. gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 5);
  831. // settings button
  832. video_settings_button = gtk_button_new_with_label(" Settings... ");
  833. gtk_box_pack_start(GTK_BOX(vbox2), video_settings_button, FALSE, FALSE, 5);
  834. gtk_signal_connect(GTK_OBJECT(video_settings_button), 
  835. "clicked",
  836. GTK_SIGNAL_FUNC(on_video_settings_button),
  837. NULL);
  838. gtk_widget_show(video_settings_button);
  840. // empty label to get sizing correct
  841. video_settings_label3 = gtk_label_new("");
  842. gtk_box_pack_start(GTK_BOX(vbox2), video_settings_label3, TRUE, TRUE, 0);
  844. gtk_container_add(GTK_CONTAINER(frame), vbox);
  845. gtk_widget_show(frame);
  846. }
  848. static void LayoutAudioFrame(GtkWidget* box)
  849. {
  850. GtkWidget *frame;
  851. GtkWidget *vbox, *hbox, *vbox1, *vbox2;
  853. frame = gtk_frame_new("Audio");
  854. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  855. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  856. gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 5);
  858. vbox = gtk_vbox_new(FALSE, 1);
  859. gtk_widget_show(vbox);
  861. // create first row, homogenous
  862. hbox = gtk_hbox_new(TRUE, 1);
  863. gtk_widget_show(hbox);
  864. gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
  865.   
  866. // enabled button
  867. audio_enabled_button = gtk_check_button_new_with_label("Enabled");
  868. gtk_box_pack_start(GTK_BOX(hbox), audio_enabled_button, TRUE, TRUE, 5);
  869. gtk_signal_connect(GTK_OBJECT(audio_enabled_button), 
  870. "toggled",
  871. GTK_SIGNAL_FUNC(on_audio_enabled_button),
  872. NULL);
  873. gtk_widget_show(audio_enabled_button);
  875. // mute button
  876. audio_mute_button = gtk_check_button_new_with_label("Mute");
  877. gtk_box_pack_start(GTK_BOX(hbox), audio_mute_button, TRUE, TRUE, 5);
  878. gtk_signal_connect(GTK_OBJECT(audio_mute_button), 
  879. "toggled",
  880. GTK_SIGNAL_FUNC(on_audio_mute_button),
  881. NULL);
  882. gtk_widget_show(audio_mute_button);
  884. // create second row
  885. hbox = gtk_hbox_new(FALSE, 1);
  886. gtk_widget_show(hbox);
  887. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  889. // settings summary
  891. // secondary vbox for two labels
  892. vbox1 = gtk_vbox_new(FALSE, 1);
  893. gtk_widget_show(vbox1);
  894. gtk_box_pack_start(GTK_BOX(hbox), vbox1, TRUE, TRUE, 5);
  896. audio_settings_label1 = gtk_label_new("");
  897. gtk_misc_set_alignment(GTK_MISC(audio_settings_label1), 0.0, 0.5);
  898. gtk_widget_show(audio_settings_label1);
  899. gtk_box_pack_start(GTK_BOX(vbox1), audio_settings_label1, TRUE, TRUE, 0);
  901. audio_settings_label2 = gtk_label_new("");
  902. gtk_misc_set_alignment(GTK_MISC(audio_settings_label2), 0.0, 0.5);
  903. gtk_widget_show(audio_settings_label2);
  904. gtk_box_pack_start(GTK_BOX(vbox1), audio_settings_label2, TRUE, TRUE, 0);
  906. // secondary vbox to match stacked labels
  907. vbox2 = gtk_vbox_new(FALSE, 1);
  908. gtk_widget_show(vbox2);
  909. gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 5);
  911. // settings button
  912. audio_settings_button = gtk_button_new_with_label(" Settings... ");
  913. gtk_box_pack_start(GTK_BOX(vbox2), audio_settings_button, FALSE, FALSE, 5);
  914. gtk_signal_connect(GTK_OBJECT(audio_settings_button), 
  915. "clicked",
  916. GTK_SIGNAL_FUNC(on_audio_settings_button),
  917. NULL);
  918. gtk_widget_show(audio_settings_button);
  920. // empty label to get sizing correct
  921. audio_settings_label3 = gtk_label_new("");
  922. gtk_box_pack_start(GTK_BOX(vbox2), audio_settings_label3, TRUE, TRUE, 0);
  924. // finalize
  925. gtk_container_add(GTK_CONTAINER(frame), vbox);
  926. gtk_widget_show(frame);
  927. }
  929. static void LayoutRecordingFrame(GtkWidget* box)
  930. {
  931. GtkWidget *frame;
  932. GtkWidget *vbox, *hbox;
  934. frame = gtk_frame_new("Recording");
  935. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  936. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  937. gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 5);
  939. vbox = gtk_vbox_new(FALSE, 1);
  940. gtk_widget_show(vbox);
  942. // create first row, homogenous
  943. hbox = gtk_hbox_new(TRUE, 1);
  944. gtk_widget_show(hbox);
  945. gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
  946.   
  947. // enabled button
  948. record_enabled_button = gtk_check_button_new_with_label("Enabled");
  949. gtk_box_pack_start(GTK_BOX(hbox), record_enabled_button, TRUE, TRUE, 5);
  950. gtk_signal_connect(GTK_OBJECT(record_enabled_button), 
  951. "toggled",
  952. GTK_SIGNAL_FUNC(on_record_enabled_button),
  953. NULL);
  954. gtk_widget_show(record_enabled_button);
  956. // create second row
  957. hbox = gtk_hbox_new(FALSE, 1);
  958. gtk_widget_show(hbox);
  959. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  961. // settings summary
  962. record_settings_label = gtk_label_new("");
  963. gtk_misc_set_alignment(GTK_MISC(record_settings_label), 0.0, 0.5);
  964. gtk_widget_show(record_settings_label);
  965. gtk_box_pack_start(GTK_BOX(hbox), record_settings_label, TRUE, TRUE, 0);
  967. // settings button
  968. record_settings_button = gtk_button_new_with_label(" Settings... ");
  969. gtk_box_pack_start(GTK_BOX(hbox), record_settings_button, FALSE, FALSE, 5);
  970. gtk_signal_connect(GTK_OBJECT(record_settings_button), 
  971. "clicked",
  972. GTK_SIGNAL_FUNC(on_record_settings_button),
  973. NULL);
  974. gtk_widget_show(record_settings_button);
  976. // finalize
  977. gtk_container_add(GTK_CONTAINER(frame), vbox);
  978. gtk_widget_show(frame);
  979. }
  981. static void LayoutTransmitFrame(GtkWidget* box)
  982. {
  983. GtkWidget *frame;
  984. GtkWidget *vbox, *hbox;
  986. frame = gtk_frame_new("Transmission");
  987. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  988. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  989. gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 5);
  991. vbox = gtk_vbox_new(FALSE, 1);
  992. gtk_widget_show(vbox);
  994. // create first row, homogenous
  995. hbox = gtk_hbox_new(TRUE, 1);
  996. gtk_widget_show(hbox);
  997. gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
  998.   
  999. // enabled button
  1000. transmit_enabled_button = gtk_check_button_new_with_label("Enabled");
  1001. gtk_box_pack_start(GTK_BOX(hbox), transmit_enabled_button, TRUE, TRUE, 5);
  1002. gtk_signal_connect(GTK_OBJECT(transmit_enabled_button), 
  1003. "toggled",
  1004. GTK_SIGNAL_FUNC(on_transmit_enabled_button),
  1005. NULL);
  1006. gtk_widget_show(transmit_enabled_button);
  1008. // create second row
  1009. hbox = gtk_hbox_new(FALSE, 1);
  1010. gtk_widget_show(hbox);
  1011. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  1013. // settings summary
  1014. transmit_settings_label = gtk_label_new("");
  1015. gtk_misc_set_alignment(GTK_MISC(transmit_settings_label), 0.0, 0.5);
  1016. gtk_widget_show(transmit_settings_label);
  1017. gtk_box_pack_start(GTK_BOX(hbox), transmit_settings_label, TRUE, TRUE, 0);
  1019. // settings button
  1020. transmit_settings_button = gtk_button_new_with_label(" Settings... ");
  1021. gtk_box_pack_start(GTK_BOX(hbox), 
  1022. transmit_settings_button, FALSE, FALSE, 5);
  1023. gtk_signal_connect(GTK_OBJECT(transmit_settings_button), 
  1024. "clicked",
  1025. GTK_SIGNAL_FUNC(on_transmit_settings_button),
  1026. NULL);
  1027. gtk_widget_show(transmit_settings_button);
  1029. // finalize
  1030. gtk_container_add(GTK_CONTAINER(frame), vbox);
  1031. gtk_widget_show(frame);
  1032. }
  1034. // Control frame
  1035. void LayoutControlFrame(GtkWidget* box)
  1036. {
  1037. GtkWidget *frame;
  1038. GtkWidget *vbox;
  1039. GtkWidget *hbox;
  1040. GtkWidget *label;
  1041. GtkWidget *separator;
  1042. GtkObject* adjustment;
  1044. frame = gtk_frame_new("Control");
  1045. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  1046. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1047. gtk_box_pack_end(GTK_BOX(box), frame, FALSE, FALSE, 5);
  1049. vbox = gtk_vbox_new(FALSE, 1);
  1050. gtk_widget_show(vbox);
  1051. gtk_container_add(GTK_CONTAINER(frame), vbox);
  1053. hbox = gtk_hbox_new(FALSE, 1);
  1054. gtk_widget_show(hbox);
  1055. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  1057. label = gtk_label_new(" Duration:");
  1058. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  1059. gtk_widget_show(label);
  1060. gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
  1062. adjustment = gtk_adjustment_new(
  1063. MyConfig->GetIntegerValue(CONFIG_APP_DURATION),
  1064. 1, 24 * 60 * 60, 1, 0, 0);
  1065. duration_spinner = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
  1066. gtk_signal_connect(GTK_OBJECT(duration_spinner),
  1067. "changed",
  1068. GTK_SIGNAL_FUNC(on_duration_changed),
  1069. GTK_OBJECT(duration_spinner));
  1070. gtk_widget_show(duration_spinner);
  1071. gtk_box_pack_start(GTK_BOX(hbox), duration_spinner, FALSE, FALSE, 5);
  1073. durationUnitsIndex = 0; // temporary
  1074. duration_units_menu = CreateOptionMenu(NULL,
  1075. durationUnitsNames, 
  1076. sizeof(durationUnitsNames) / sizeof(char*),
  1077. durationUnitsIndex,
  1078. GTK_SIGNAL_FUNC(on_duration_units_menu_activate));
  1079. gtk_box_pack_start(GTK_BOX(hbox), duration_units_menu, FALSE, FALSE, 5);
  1081. // vertical separator
  1082. separator = gtk_vseparator_new();
  1083. gtk_widget_show(separator);
  1084. gtk_box_pack_start(GTK_BOX(hbox), separator, FALSE, FALSE, 0);
  1086. start_button = gtk_button_new();
  1087. start_button_label = gtk_label_new("  Start  ");
  1088. gtk_misc_set_alignment(GTK_MISC(start_button_label), 0.5, 0.5);
  1089. gtk_container_add(GTK_CONTAINER(start_button), start_button_label);
  1090. gtk_widget_show(start_button_label);
  1091. gtk_box_pack_start(GTK_BOX(hbox), start_button, TRUE, TRUE, 5);
  1092. gtk_signal_connect(GTK_OBJECT(start_button), 
  1093. "clicked",
  1094. GTK_SIGNAL_FUNC(on_start_button),
  1095. NULL);
  1096. gtk_widget_show(start_button);
  1098. // separator
  1099. separator = gtk_hseparator_new();
  1100. gtk_widget_show(separator);
  1101. gtk_box_pack_start(GTK_BOX(vbox), separator, TRUE, TRUE, 0);
  1103. // second row
  1104. hbox = gtk_hbox_new(FALSE, 1);
  1105. gtk_widget_show(hbox);
  1106. gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
  1108. label = gtk_label_new(" Configuration File:");
  1109. gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  1110. gtk_widget_show(label);
  1111. gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
  1113. config_file_entry = gtk_entry_new_with_max_length(256);
  1114. gtk_entry_set_text(GTK_ENTRY(config_file_entry), 
  1115. MyConfig->GetFileName());
  1116. gtk_widget_show(config_file_entry);
  1117. gtk_box_pack_start(GTK_BOX(hbox), config_file_entry, TRUE, TRUE, 5);
  1119. // config file load button
  1120. load_config_button = gtk_button_new_with_label(" Load... ");
  1121. gtk_signal_connect(GTK_OBJECT(load_config_button),
  1122.  "clicked",
  1123.  GTK_SIGNAL_FUNC(on_load_config_button),
  1124.  NULL);
  1125. gtk_widget_show(load_config_button);
  1126. gtk_box_pack_start(GTK_BOX(hbox), load_config_button, FALSE, FALSE, 5);
  1128. // config file save button
  1129. save_config_button = gtk_button_new_with_label(" Save ");
  1130. gtk_signal_connect(GTK_OBJECT(save_config_button),
  1131.  "clicked",
  1132.  GTK_SIGNAL_FUNC(on_save_config_button),
  1133.  NULL);
  1134. gtk_widget_show(save_config_button);
  1135. gtk_box_pack_start(GTK_BOX(hbox), save_config_button, FALSE, FALSE, 5);
  1137. gtk_widget_show(frame); // show control frame
  1138. }
  1140. // Status frame
  1141. void LayoutStatusFrame(GtkWidget* box)
  1142. {
  1143. GtkWidget *frame;
  1144. GtkWidget *frame_vbox;
  1145. GtkWidget *vbox, *hbox;
  1146. GtkWidget *separator;
  1148. frame = gtk_frame_new("Status");
  1149. gtk_frame_set_label_align(GTK_FRAME(frame), frameLabelAlignment, 0);
  1150. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1151. gtk_box_pack_end(GTK_BOX(box), frame, FALSE, FALSE, 5);
  1153. // frame vbox
  1154. frame_vbox = gtk_vbox_new(FALSE, 1);
  1155. gtk_widget_show(frame_vbox);
  1156. gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
  1158. // first row
  1159. hbox = gtk_hbox_new(FALSE, 1);
  1160. gtk_widget_show(hbox);
  1161. gtk_box_pack_start(GTK_BOX(frame_vbox), hbox, FALSE, FALSE, 2);
  1163. media_source_label = gtk_label_new(" Source:");
  1164. gtk_misc_set_alignment(GTK_MISC(media_source_label), 0.0, 0.5);
  1165. gtk_widget_show(media_source_label);
  1166. gtk_box_pack_start(GTK_BOX(hbox), media_source_label, TRUE, TRUE, 5);
  1168. media_source = gtk_label_new("");
  1169. gtk_misc_set_alignment(GTK_MISC(media_source), 1.0, 0.5);
  1170. gtk_widget_show(media_source);
  1171. gtk_box_pack_start(GTK_BOX(hbox), media_source, TRUE, TRUE, 5);
  1173. // separator
  1174. separator = gtk_hseparator_new();
  1175. gtk_widget_show(separator);
  1176. gtk_box_pack_start(GTK_BOX(frame_vbox), separator, TRUE, TRUE, 0);
  1178. // second row
  1180. hbox = gtk_hbox_new(FALSE, 1);
  1181. gtk_widget_show(hbox);
  1182. gtk_box_pack_start(GTK_BOX(frame_vbox), hbox, FALSE, FALSE, 2);
  1184. // vbox for time labels
  1185. vbox = gtk_vbox_new(FALSE, 1);
  1186. gtk_widget_show(vbox);
  1187. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  1189. start_time_label = gtk_label_new(" Start Time:");
  1190. gtk_misc_set_alignment(GTK_MISC(start_time_label), 0.0, 0.5);
  1191. gtk_widget_show(start_time_label);
  1192. gtk_box_pack_start(GTK_BOX(vbox), start_time_label, TRUE, TRUE, 0);
  1194. duration_label = gtk_label_new(" Current Duration:");
  1195. gtk_misc_set_alignment(GTK_MISC(duration_label), 0.0, 0.5);
  1196. gtk_widget_show(duration_label);
  1197. gtk_box_pack_start(GTK_BOX(vbox), duration_label, TRUE, TRUE, 0);
  1199. current_time_label = gtk_label_new(" Current Time:");
  1200. gtk_misc_set_alignment(GTK_MISC(current_time_label), 0.0, 0.5);
  1201. gtk_widget_show(current_time_label);
  1202. gtk_box_pack_start(GTK_BOX(vbox), current_time_label, TRUE, TRUE, 0);
  1204. finish_time_label = gtk_label_new(" Finish Time:");
  1205. gtk_misc_set_alignment(GTK_MISC(finish_time_label), 0.0, 0.5);
  1206. gtk_widget_show(finish_time_label);
  1207. gtk_box_pack_start(GTK_BOX(vbox), finish_time_label, TRUE, TRUE, 0);
  1209. // vbox for time values
  1210. vbox = gtk_vbox_new(FALSE, 1);
  1211. gtk_widget_show(vbox);
  1212. gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
  1214. start_time = gtk_label_new("");
  1215. gtk_misc_set_alignment(GTK_MISC(start_time), 1.0, 0.5);
  1216. gtk_widget_show(start_time);
  1217. gtk_box_pack_start(GTK_BOX(vbox), start_time, TRUE, TRUE, 0);
  1219. duration = gtk_label_new("");
  1220. gtk_misc_set_alignment(GTK_MISC(duration), 1.0, 0.5);
  1221. gtk_widget_show(duration);
  1222. gtk_box_pack_start(GTK_BOX(vbox), duration, TRUE, TRUE, 0);
  1224. current_time = gtk_label_new("                 ");
  1225. gtk_misc_set_alignment(GTK_MISC(current_time), 1.0, 0.5);
  1226. gtk_widget_show(current_time);
  1227. gtk_box_pack_start(GTK_BOX(vbox), current_time, TRUE, TRUE, 0);
  1229. finish_time = gtk_label_new("");
  1230. gtk_misc_set_alignment(GTK_MISC(finish_time), 1.0, 0.5);
  1231. gtk_widget_show(finish_time);
  1232. gtk_box_pack_start(GTK_BOX(vbox), finish_time, TRUE, TRUE, 0);
  1234. // vbox for time units
  1235. vbox = gtk_vbox_new(FALSE, 1);
  1236. gtk_widget_show(vbox);
  1237. gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 5);
  1239. start_time_units = gtk_label_new("");
  1240. gtk_misc_set_alignment(GTK_MISC(start_time_units), 1.0, 0.5);
  1241. gtk_widget_show(start_time_units);
  1242. gtk_box_pack_start(GTK_BOX(vbox), start_time_units, TRUE, TRUE, 0);
  1244. duration_units = gtk_label_new("");
  1245. gtk_misc_set_alignment(GTK_MISC(duration_units), 1.0, 0.5);
  1246. gtk_widget_show(duration_units);
  1247. gtk_box_pack_start(GTK_BOX(vbox), duration_units, TRUE, TRUE, 0);
  1249. current_time_units = gtk_label_new("");
  1250. gtk_misc_set_alignment(GTK_MISC(current_time_units), 1.0, 0.5);
  1251. gtk_widget_show(current_time_units);
  1252. gtk_box_pack_start(GTK_BOX(vbox), current_time_units, TRUE, TRUE, 0);
  1254. finish_time_units = gtk_label_new("");
  1255. gtk_misc_set_alignment(GTK_MISC(finish_time_units), 1.0, 0.5);
  1256. gtk_widget_show(finish_time_units);
  1257. gtk_box_pack_start(GTK_BOX(vbox), finish_time_units, TRUE, TRUE, 0);
  1259. // separator
  1260. separator = gtk_hseparator_new();
  1261. gtk_widget_show(separator);
  1262. gtk_box_pack_start(GTK_BOX(frame_vbox), separator, TRUE, TRUE, 0);
  1264. // third row
  1266. hbox = gtk_hbox_new(FALSE, 1);
  1267. gtk_widget_show(hbox);
  1268. gtk_box_pack_start(GTK_BOX(frame_vbox), hbox, FALSE, FALSE, 2);
  1270. // vbox for size labels
  1271. vbox = gtk_vbox_new(FALSE, 1);
  1272. gtk_widget_show(vbox);
  1273. gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
  1275. current_size_label = gtk_label_new(" Current Size:");
  1276. gtk_misc_set_alignment(GTK_MISC(current_size_label), 0.0, 0.5);
  1277. gtk_widget_show(current_size_label);
  1278. gtk_box_pack_start(GTK_BOX(vbox), current_size_label, TRUE, TRUE, 0);
  1280. final_size_label = gtk_label_new(" Estimated Final Size:");
  1281. gtk_misc_set_alignment(GTK_MISC(final_size_label), 0.0, 0.5);
  1282. gtk_widget_show(final_size_label);
  1283. gtk_box_pack_start(GTK_BOX(vbox), final_size_label, TRUE, TRUE, 0);
  1285. // vbox for size values
  1286. vbox = gtk_vbox_new(FALSE, 1);
  1287. gtk_widget_show(vbox);
  1288. gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
  1290. current_size = gtk_label_new("");
  1291. gtk_misc_set_alignment(GTK_MISC(current_size), 1.0, 0.5);
  1292. gtk_widget_show(current_size);
  1293. gtk_box_pack_start(GTK_BOX(vbox), current_size, TRUE, TRUE, 0);
  1295. final_size = gtk_label_new("");
  1296. gtk_misc_set_alignment(GTK_MISC(final_size), 1.0, 0.5);
  1297. gtk_widget_show(final_size);
  1298. gtk_box_pack_start(GTK_BOX(vbox), final_size, TRUE, TRUE, 0);
  1300. // vbox for size units
  1301. vbox = gtk_vbox_new(FALSE, 1);
  1302. gtk_widget_show(vbox);
  1303. gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 5);
  1305. current_size_units = gtk_label_new("");
  1306. gtk_misc_set_alignment(GTK_MISC(current_size_units), 1.0, 0.5);
  1307. gtk_widget_show(current_size_units);
  1308. gtk_box_pack_start(GTK_BOX(vbox), current_size_units, TRUE, TRUE, 0);
  1310. final_size_units = gtk_label_new("");
  1311. gtk_misc_set_alignment(GTK_MISC(final_size_units), 1.0, 0.5);
  1312. gtk_widget_show(final_size_units);
  1313. gtk_box_pack_start(GTK_BOX(vbox), final_size_units, TRUE, TRUE, 0);
  1315. // separator
  1316. separator = gtk_hseparator_new();
  1317. gtk_widget_show(separator);
  1318. gtk_box_pack_start(GTK_BOX(frame_vbox), separator, TRUE, TRUE, 0);
  1320. // fourth row
  1322. hbox = gtk_hbox_new(FALSE, 1);
  1323. gtk_widget_show(hbox);
  1324. gtk_box_pack_start(GTK_BOX(frame_vbox), hbox, FALSE, FALSE, 2);
  1326. actual_fps_label = gtk_label_new(" Video Frame Rate:");
  1327. gtk_misc_set_alignment(GTK_MISC(actual_fps_label), 0.0, 0.5);
  1328. gtk_widget_show(actual_fps_label);
  1329. gtk_box_pack_start(GTK_BOX(hbox), actual_fps_label, TRUE, TRUE, 5);
  1331. actual_fps = gtk_label_new("");
  1332. gtk_misc_set_alignment(GTK_MISC(actual_fps), 1.0, 0.5);
  1333. gtk_widget_show(actual_fps);
  1334. gtk_box_pack_start(GTK_BOX(hbox), actual_fps, FALSE, FALSE, 0);
  1336. actual_fps_units = gtk_label_new("");
  1337. gtk_misc_set_alignment(GTK_MISC(actual_fps_units), 1.0, 0.5);
  1338. gtk_widget_show(actual_fps_units);
  1339. gtk_box_pack_start(GTK_BOX(hbox), actual_fps_units, FALSE, FALSE, 5);
  1341. gtk_widget_show(frame); // show control frame
  1342. }
  1344. /*
  1345.  * Main routine - set up window
  1346.  */
  1347. int gui_main(int argc, char **argv, CLiveConfig* pConfig)
  1348. {
  1349. MyConfig = pConfig;
  1351. AVFlow = new CAVMediaFlow(pConfig);
  1353. gtk_init(&argc, &argv);
  1355. // Setup main window
  1356. main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1357. gtk_window_set_policy(GTK_WINDOW(main_window), FALSE, FALSE, TRUE);
  1359. char buffer[80];
  1360. snprintf(buffer, sizeof(buffer), "cisco mp4live %s", VERSION);
  1361. gtk_window_set_title(GTK_WINDOW(main_window), buffer);
  1362. gtk_signal_connect(GTK_OBJECT(main_window),
  1363. "delete_event",
  1364. GTK_SIGNAL_FUNC(delete_event),
  1365. NULL);
  1367. // main boxes
  1368. main_hbox = gtk_hbox_new(FALSE, 1);
  1369. gtk_container_set_border_width(GTK_CONTAINER(main_hbox), 4);
  1370. gtk_widget_show(main_hbox);
  1371. gtk_container_add(GTK_CONTAINER(main_window), main_hbox);
  1373. main_vbox1 = gtk_vbox_new(FALSE, 1);
  1374. gtk_container_set_border_width(GTK_CONTAINER(main_vbox1), 4);
  1375. gtk_widget_show(main_vbox1);
  1376. gtk_box_pack_start(GTK_BOX(main_hbox), main_vbox1, FALSE, FALSE, 5);
  1378. main_vbox2 = gtk_vbox_new(FALSE, 1);
  1379. gtk_container_set_border_width(GTK_CONTAINER(main_vbox2), 4);
  1380. gtk_widget_show(main_vbox2);
  1381. gtk_box_pack_start(GTK_BOX(main_hbox), main_vbox2, FALSE, FALSE, 5);
  1383. // Video Preview
  1384. NewVideoWindow();
  1386. // Video Frame
  1387. LayoutVideoFrame(main_vbox2);
  1389. // Audio Frame
  1390. LayoutAudioFrame(main_vbox2);
  1392. // Recording Frame
  1393. LayoutRecordingFrame(main_vbox2);
  1395. // Transmission Frame
  1396. LayoutTransmitFrame(main_vbox2);
  1398. // Status frame
  1399. LayoutStatusFrame(main_vbox1);
  1401. // Control frame
  1402. LayoutControlFrame(main_vbox1);
  1404. DisplayAllSettings();
  1406. gtk_widget_show(main_window);
  1408. if (MyConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  1409. AVFlow->StartVideoPreview();
  1410. }
  1412. // "press" start button
  1413. if (MyConfig->m_appAutomatic) {
  1414. on_start_button(start_button, NULL);
  1415. }
  1417. gtk_main();
  1419. delete AVFlow;
  1421. return 0;
  1422. }
  1424. /* end gui_main.cpp */