int AP_Win32App::WinMain(const char * szAppName, HINSTANCE hInstance,
HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
if (!g_thread_supported ())
g_thread_init (NULL);
bool bShowApp = true;
BOOL bInitialized = FALSE;
// this is a static function and doesn't have a 'this' pointer.
MSG msg;
#ifdef _MSC_VER
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG );
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_WNDW);
#endif
// HACK: load least-common-denominator Rich Edit control
// TODO: fix Spell dlg so we don't rely on this
// ALT: make it a Preview widget instead
HINSTANCE hinstRich = LoadLibraryW(L"riched32.dll");
if (!hinstRich)
hinstRich = LoadLibraryW(L"riched20.dll");
UT_return_val_if_fail (hinstRich, 1);
AP_Win32App * pMyWin32App;
// OLE Stuff
if (SUCCEEDED(OleInitialize(NULL)))
bInitialized = TRUE;
// We put this in a block to force the destruction of Args in the stack
{
UT_Win32LocaleString scnv;
UT_UTF8String sUTFCmdLine;
// Load the command line into an XAP_Args class
scnv.fromLocale(GetCommandLineW());
sUTFCmdLine=scnv.utf8_str();
XAP_Args XArgs = XAP_Args(sUTFCmdLine.utf8_str());
// Step 1: Initialize our application.
pMyWin32App = new AP_Win32App(hInstance, szAppName);
AP_Args Args = AP_Args(&XArgs, szAppName, pMyWin32App);
Args.parseOptions();
pMyWin32App->initialize();
// Step 2: Handle all non-window args.
// process args (calls common arg handler, which then calls platform specific)
// As best I understand, it returns true to continue and show window, or
// false if no window should be shown (and thus we should simply exit).
bool windowlessArgsWereSuccessful = true;
if (!Args.doWindowlessArgs(windowlessArgsWereSuccessful))
{
pMyWin32App->shutdown(); // properly shutdown the app 1st
delete pMyWin32App;
return (windowlessArgsWereSuccessful ? 0 : -1);
}
// Step 3: Create windows as appropriate.
// if some args are botched, it returns false and we should
// continue out the door.
// We used to check for bShowApp here. It shouldn't be needed
// anymore, because doWindowlessArgs was supposed to bail already. -PL
if (!pMyWin32App->openCmdLineFiles(&Args))
{
pMyWin32App->shutdown(); // properly shutdown the app 1st
delete pMyWin32App;
return 0;
}
}
//
// This block is controlled by the Structured Exception Handle
// if any crash happens here we will recover it and save the file (cross fingers)
//
try
{
UT_uint32 iHeight = 0, iWidth = 0, t_flag =0;
UT_sint32 iPosX = 0, iPosY = 0;
if (!((XAP_App::getApp()->getGeometry(&iPosX,&iPosY,&iWidth,&iHeight,&t_flag)) &&
((iWidth > 0) && (iHeight > 0))) )
XAP_App::getApp()->getDefaultGeometry(iWidth,iHeight,t_flag);
if ((t_flag & PREF_FLAG_GEOMETRY_MAXIMIZED)==PREF_FLAG_GEOMETRY_MAXIMIZED)
iCmdShow = SW_SHOWMAXIMIZED;
if (bShowApp)
{
// display the windows
for(UT_sint32 i = 0; i < pMyWin32App->m_vecFrames.getItemCount(); i++)
{
AP_Win32Frame * curFrame = (AP_Win32Frame*)pMyWin32App->m_vecFrames[i];
UT_continue_if_fail(curFrame);
HWND hwnd = curFrame->getTopLevelWindow();
ShowWindow(hwnd, iCmdShow);
UpdateWindow(hwnd);
}
// do dispatch loop
while(UT_GetMessage(&msg, NULL, 0, 0))
{
// TranslateMessage is not called because AbiWord
// has its own way of decoding keyboard accelerators
if (pMyWin32App->handleModelessDialogMessage(&msg))
continue;
TranslateMessage(&msg);
UT_DispatchMessage(&msg);
// Check for idle condition
while( !UT_Win32Idle::_isEmpty() &&
!PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE) )
{
// Fire idle functions when no pending messages
UT_Win32Idle::_fireall();
}
}
}
// Un-init OLE
if (bInitialized)
OleUninitialize();
FreeLibrary(hinstRich);
// unload all loaded plugins (remove some of the memory leaks shown at shutdown :-)
XAP_ModuleManager::instance().unloadAllPlugins();
// Step 4: Destroy the App. It should take care of deleting all frames.
pMyWin32App->shutdown();
delete pMyWin32App;
}// end of thes block is controlled by the Exception Handler
//
// If an exception happens, with "catch" the block
// and then the save it into disk
//
catch (...)
{
#ifdef DEBUG
throw;
#endif
AP_Win32App *pApp = (AP_Win32App *) XAP_App::getApp();
UT_return_val_if_fail (pApp,1);
// first of all, try to save the current prefs (so that any log entries are dumped
// onto disk -- this allows us to save useful info for dbg purposes) we will enclose
// this inside of a try/catch block, so that in the (unlikely) case something goes
// badly wrong when writing the prefs file, we still get chance to save the open
// documents
try
{
if(pApp->getPrefs())
{
pApp->getPrefs()->savePrefsFile();
}
}
catch(...)
{
// do nothing
}
IEFileType abiType = IE_Imp::fileTypeForSuffix(".abw");
for (UT_sint32 i = 0; i < pApp->m_vecFrames.getItemCount(); i++)
{
AP_Win32Frame * curFrame = (AP_Win32Frame*)pApp->m_vecFrames[i];
UT_continue_if_fail(curFrame);
// again, we want to catch any exception thrown while saving individual documents,
// in order to run through the whole loop
try
{
if (NULL == curFrame->getFilename())
curFrame->backup(".abw.saved", abiType);
else
curFrame->backup(".saved", abiType);
}
catch(...)
{
// do nothing
}
}
// Tell the user was has just happened
AP_Win32Frame * curFrame = (AP_Win32Frame*)pApp->m_vecFrames[0];
if (curFrame)
{
curFrame->showMessageBox(AP_STRING_ID_MSG_Exception,XAP_Dialog_MessageBox::b_O, XAP_Dialog_MessageBox::a_OK);
}
}// end of except
SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF );
return msg.wParam;
}
int main(int argc, char *argv[])
{
struct stat buf = { 0 };
struct mntent *mnt = NULL;
FILE *fp = NULL;
gchar *uri;
gint fileindex = 1;
GError *error = NULL;
GOptionContext *context;
gint i;
gdouble volume = 100.0;
gchar *accelerator_keys;
gchar **parse;
#ifdef GTK3_ENABLED
GtkSettings *gtk_settings;
#endif
int stat_result;
#ifndef OS_WIN32
struct sigaction sa;
#endif
gboolean playiter = FALSE;
#ifdef GIO_ENABLED
GFile *file;
#endif
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
playlist = 0;
embed_window = 0;
control_id = 0;
window_x = 0;
window_y = 0;
last_window_width = 0;
last_window_height = 0;
showcontrols = 1;
showsubtitles = TRUE;
autostart = 1;
videopresent = 0;
disable_context_menu = FALSE;
dontplaynext = FALSE;
idledata = (IdleData *) g_new0(IdleData, 1);
idledata->videopresent = FALSE;
idledata->length = 0.0;
idledata->device = NULL;
idledata->cachepercent = -1.0;
selection = NULL;
path = NULL;
js_state = STATE_UNDEFINED;
control_instance = TRUE;
playlistname = NULL;
rpconsole = NULL;
subtitle = NULL;
tv_device = NULL;
tv_driver = NULL;
tv_width = 0;
tv_height = 0;
tv_fps = 0;
ok_to_play = TRUE;
alang = NULL;
slang = NULL;
metadata_codepage = NULL;
playlistname = NULL;
window_width = -1;
window_height = -1;
stored_window_width = -1;
stored_window_height = -1;
cache_size = 0;
forcecache = FALSE;
use_volume_option = FALSE;
vertical_layout = FALSE;
playlist_visible = FALSE;
disable_fullscreen = FALSE;
disable_framedrop = FALSE;
softvol = FALSE;
remember_softvol = FALSE;
volume_softvol = -1;
volume_gain = 0;
subtitlefont = NULL;
subtitle_codepage = NULL;
subtitle_color = NULL;
subtitle_outline = FALSE;
subtitle_shadow = FALSE;
subtitle_fuzziness = 0;
disable_embeddedfonts = FALSE;
quit_on_complete = FALSE;
verbose = 0;
reallyverbose = 0;
embedding_disabled = FALSE;
disable_pause_on_click = FALSE;
disable_animation = FALSE;
auto_hide_timeout = 3;
mouse_over_controls = FALSE;
use_mediakeys = TRUE;
use_defaultpl = FALSE;
mplayer_bin = NULL;
mplayer_dvd_device = NULL;
single_instance = FALSE;
disable_deinterlace = TRUE;
details_visible = FALSE;
replace_and_play = FALSE;
bring_to_front = FALSE;
keep_on_top = FALSE;
resize_on_new_media = FALSE;
use_pausing_keep_force = FALSE;
show_notification = TRUE;
show_status_icon = TRUE;
lang_group = NULL;
audio_group = NULL;
gpod_mount_point = NULL;
load_tracks_from_gpod = FALSE;
disable_cover_art_fetch = FALSE;
fullscreen = 0;
vo = NULL;
data = NULL;
max_data = NULL;
details_table = NULL;
large_buttons = FALSE;
button_size = GTK_ICON_SIZE_BUTTON;
lastguistate = -1;
non_fs_height = 0;
non_fs_width = 0;
use_hw_audio = FALSE;
start_second = 0;
play_length = 0;
save_loc = TRUE;
use_xscrnsaver = FALSE;
screensaver_disabled = FALSE;
update_control_flag = FALSE;
gchar *filename;
skip_fixed_allocation_on_show = FALSE;
skip_fixed_allocation_on_hide = FALSE;
pref_volume = -1;
use_mplayer2 = FALSE;
enable_global_menu = FALSE;
#ifndef OS_WIN32
sa.sa_handler = hup_handler;
sigemptyset(&sa.sa_mask);
#ifdef SA_RESTART
sa.sa_flags = SA_RESTART; /* Restart functions if
interrupted by handler */
#endif
#ifdef SIGINT
if (sigaction(SIGINT, &sa, NULL) == -1)
printf("SIGINT signal handler not installed\n");
#endif
#ifdef SIGHUP
if (sigaction(SIGHUP, &sa, NULL) == -1)
printf("SIGHUP signal handler not installed\n");
#endif
#ifdef SIGTERM
if (sigaction(SIGTERM, &sa, NULL) == -1)
printf("SIGTERM signal handler not installed\n");
#endif
#endif
// call g_type_init or otherwise we can crash
gtk_init(&argc, &argv);
if (!g_thread_supported())
g_thread_init(NULL);
uri = g_strdup_printf("%s/gnome-mplayer/cover_art", g_get_user_config_dir());
if (!g_file_test(uri, G_FILE_TEST_IS_DIR)) {
g_mkdir_with_parents(uri, 0775);
}
g_free(uri);
uri = g_strdup_printf("%s/gnome-mplayer/plugin", g_get_user_config_dir());
if (!g_file_test(uri, G_FILE_TEST_IS_DIR)) {
g_mkdir_with_parents(uri, 0775);
}
g_free(uri);
uri = NULL;
default_playlist = g_strdup_printf("file://%s/gnome-mplayer/default.pls", g_get_user_config_dir());
safe_to_save_default_playlist = TRUE;
gm_store = gm_pref_store_new("gnome-mplayer");
gmp_store = gm_pref_store_new("gecko-mediaplayer");
vo = gm_pref_store_get_string(gm_store, VO);
audio_device.alsa_mixer = gm_pref_store_get_string(gm_store, ALSA_MIXER);
use_hardware_codecs = gm_pref_store_get_boolean(gm_store, USE_HARDWARE_CODECS);
use_crystalhd_codecs = gm_pref_store_get_boolean(gm_store, USE_CRYSTALHD_CODECS);
osdlevel = gm_pref_store_get_int(gm_store, OSDLEVEL);
pplevel = gm_pref_store_get_int(gm_store, PPLEVEL);
#ifndef HAVE_ASOUNDLIB
volume = gm_pref_store_get_int(gm_store, VOLUME);
#endif
audio_channels = gm_pref_store_get_int(gm_store, AUDIO_CHANNELS);
use_hw_audio = gm_pref_store_get_boolean(gm_store, USE_HW_AUDIO);
fullscreen = gm_pref_store_get_boolean(gm_store, FULLSCREEN);
softvol = gm_pref_store_get_boolean(gm_store, SOFTVOL);
remember_softvol = gm_pref_store_get_boolean(gm_store, REMEMBER_SOFTVOL);
volume_softvol = gm_pref_store_get_float(gm_store, VOLUME_SOFTVOL);
volume_gain = gm_pref_store_get_int(gm_store, VOLUME_GAIN);
forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE);
vertical_layout = gm_pref_store_get_boolean(gm_store, VERTICAL);
playlist_visible = gm_pref_store_get_boolean(gm_store, SHOWPLAYLIST);
details_visible = gm_pref_store_get_boolean(gm_store, SHOWDETAILS);
show_notification = gm_pref_store_get_boolean(gm_store, SHOW_NOTIFICATION);
show_status_icon = gm_pref_store_get_boolean(gm_store, SHOW_STATUS_ICON);
showcontrols = gm_pref_store_get_boolean_with_default(gm_store, SHOW_CONTROLS, showcontrols);
restore_controls = showcontrols;
disable_deinterlace = gm_pref_store_get_boolean(gm_store, DISABLEDEINTERLACE);
disable_framedrop = gm_pref_store_get_boolean(gm_store, DISABLEFRAMEDROP);
disable_fullscreen = gm_pref_store_get_boolean(gm_store, DISABLEFULLSCREEN);
disable_context_menu = gm_pref_store_get_boolean(gm_store, DISABLECONTEXTMENU);
disable_ass = gm_pref_store_get_boolean(gm_store, DISABLEASS);
disable_embeddedfonts = gm_pref_store_get_boolean(gm_store, DISABLEEMBEDDEDFONTS);
disable_pause_on_click = gm_pref_store_get_boolean(gm_store, DISABLEPAUSEONCLICK);
disable_animation = gm_pref_store_get_boolean(gm_store, DISABLEANIMATION);
auto_hide_timeout = gm_pref_store_get_int_with_default(gm_store, AUTOHIDETIMEOUT, auto_hide_timeout);
disable_cover_art_fetch = gm_pref_store_get_boolean(gm_store, DISABLE_COVER_ART_FETCH);
use_mediakeys = gm_pref_store_get_boolean_with_default(gm_store, USE_MEDIAKEYS, use_mediakeys);
use_defaultpl = gm_pref_store_get_boolean_with_default(gm_store, USE_DEFAULTPL, use_defaultpl);
metadata_codepage = gm_pref_store_get_string(gm_store, METADATACODEPAGE);
alang = gm_pref_store_get_string(gm_store, AUDIO_LANG);
slang = gm_pref_store_get_string(gm_store, SUBTITLE_LANG);
subtitlefont = gm_pref_store_get_string(gm_store, SUBTITLEFONT);
subtitle_scale = gm_pref_store_get_float(gm_store, SUBTITLESCALE);
if (subtitle_scale < 0.25) {
subtitle_scale = 1.0;
}
subtitle_codepage = gm_pref_store_get_string(gm_store, SUBTITLECODEPAGE);
subtitle_color = gm_pref_store_get_string(gm_store, SUBTITLECOLOR);
subtitle_outline = gm_pref_store_get_boolean(gm_store, SUBTITLEOUTLINE);
subtitle_shadow = gm_pref_store_get_boolean(gm_store, SUBTITLESHADOW);
subtitle_margin = gm_pref_store_get_int(gm_store, SUBTITLE_MARGIN);
subtitle_fuzziness = gm_pref_store_get_int(gm_store, SUBTITLE_FUZZINESS);
showsubtitles = gm_pref_store_get_boolean_with_default(gm_store, SHOW_SUBTITLES, TRUE);
qt_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_QT);
real_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_REAL);
wmp_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_WMP);
dvx_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_DVX);
midi_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_MIDI);
embedding_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_EMBEDDING);
disable_embedded_scaling = gm_pref_store_get_boolean(gmp_store, DISABLE_EMBEDDED_SCALING);
if (embed_window == 0) {
single_instance = gm_pref_store_get_boolean(gm_store, SINGLE_INSTANCE);
if (single_instance) {
replace_and_play = gm_pref_store_get_boolean(gm_store, REPLACE_AND_PLAY);
bring_to_front = gm_pref_store_get_boolean(gm_store, BRING_TO_FRONT);
}
}
enable_global_menu = gm_pref_store_get_boolean(gm_store, ENABLE_GLOBAL_MENU);
if (!enable_global_menu) {
enable_global_menu = (g_getenv("UBUNTU_MENUPROXY") == NULL ? FALSE : TRUE);
}
enable_nautilus_plugin = gm_pref_store_get_boolean_with_default(gm_store, ENABLE_NAUTILUS_PLUGIN, TRUE);
mplayer_bin = gm_pref_store_get_string(gm_store, MPLAYER_BIN);
if (mplayer_bin != NULL && !g_file_test(mplayer_bin, G_FILE_TEST_EXISTS)) {
g_free(mplayer_bin);
mplayer_bin = NULL;
}
mplayer_dvd_device = gm_pref_store_get_string(gm_store, MPLAYER_DVD_DEVICE);
extraopts = gm_pref_store_get_string(gm_store, EXTRAOPTS);
use_xscrnsaver = gm_pref_store_get_boolean_with_default(gm_store, USE_XSCRNSAVER, use_xscrnsaver);
accelerator_keys = gm_pref_store_get_string(gm_store, ACCELERATOR_KEYS);
accel_keys = g_strv_new(KEY_COUNT);
accel_keys_description = g_strv_new(KEY_COUNT);
if (accelerator_keys != NULL) {
parse = g_strsplit(accelerator_keys, " ", KEY_COUNT);
for (i = 0; i < g_strv_length(parse); i++) {
accel_keys[i] = g_strdup(parse[i]);
}
g_free(accelerator_keys);
g_strfreev(parse);
}
assign_default_keys();
accel_keys_description[FILE_OPEN_LOCATION] = g_strdup(_("Open Location"));
accel_keys_description[EDIT_SCREENSHOT] = g_strdup(_("Take Screenshot"));
accel_keys_description[EDIT_PREFERENCES] = g_strdup(_("Preferences"));
accel_keys_description[VIEW_PLAYLIST] = g_strdup(_("Playlist"));
accel_keys_description[VIEW_INFO] = g_strdup(_("Media Info"));
accel_keys_description[VIEW_DETAILS] = g_strdup(_("Details"));
accel_keys_description[VIEW_METER] = g_strdup(_("Audio Meter"));
accel_keys_description[VIEW_FULLSCREEN] = g_strdup(_("Full Screen"));
accel_keys_description[VIEW_ASPECT] = g_strdup(_("Aspect"));
accel_keys_description[VIEW_SUBTITLES] = g_strdup(_("Subtitles"));
accel_keys_description[VIEW_DECREASE_SIZE] = g_strdup(_("Decrease Subtitle Size"));
accel_keys_description[VIEW_INCREASE_SIZE] = g_strdup(_("Increase Subtitle Size"));
accel_keys_description[VIEW_ANGLE] = g_strdup(_("Switch Angle"));
accel_keys_description[VIEW_CONTROLS] = g_strdup(_("Controls"));
remember_loc = gm_pref_store_get_boolean(gm_store, REMEMBER_LOC);
loc_window_x = gm_pref_store_get_int(gm_store, WINDOW_X);
loc_window_y = gm_pref_store_get_int(gm_store, WINDOW_Y);
loc_window_height = gm_pref_store_get_int(gm_store, WINDOW_HEIGHT);
loc_window_width = gm_pref_store_get_int(gm_store, WINDOW_WIDTH);
loc_panel_position = gm_pref_store_get_int(gm_store, PANEL_POSITION);
keep_on_top = gm_pref_store_get_boolean(gm_store, KEEP_ON_TOP);
resize_on_new_media = gm_pref_store_get_boolean(gm_store, RESIZE_ON_NEW_MEDIA);
mouse_wheel_changes_volume = gm_pref_store_get_boolean_with_default(gm_store, MOUSE_WHEEL_CHANGES_VOLUME, FALSE);
audio_device_name = gm_pref_store_get_string(gm_store, AUDIO_DEVICE_NAME);
audio_device.description = g_strdup(audio_device_name);
context = g_option_context_new(_("[FILES...] - GNOME Media player based on MPlayer"));
#ifdef GTK2_12_ENABLED
g_option_context_set_translation_domain(context, "UTF-8");
g_option_context_set_translate_func(context, (GTranslateFunc) gettext, NULL, NULL);
#endif
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_parse(context, &argc, &argv, &error);
g_option_context_free(context);
if (new_instance)
single_instance = FALSE;
if (verbose == 0)
verbose = gm_pref_store_get_int(gm_store, VERBOSE);
if (reallyverbose)
verbose = 2;
if (verbose) {
printf(_("GNOME MPlayer v%s\n"), VERSION);
printf(_("gmtk v%s\n"), gmtk_version());
}
if (cache_size == 0)
cache_size = gm_pref_store_get_int(gm_store, CACHE_SIZE);
if (cache_size == 0)
cache_size = 2000;
plugin_audio_cache_size = gm_pref_store_get_int(gm_store, PLUGIN_AUDIO_CACHE_SIZE);
if (plugin_audio_cache_size == 0)
plugin_audio_cache_size = 2000;
plugin_video_cache_size = gm_pref_store_get_int(gm_store, PLUGIN_VIDEO_CACHE_SIZE);
if (plugin_video_cache_size == 0)
plugin_video_cache_size = 2000;
if (control_id != 0)
cache_size = plugin_video_cache_size;
gm_pref_store_free(gm_store);
gm_pref_store_free(gmp_store);
if (verbose && embed_window) {
printf("embedded in window id 0x%x\n", embed_window);
}
if (verbose && single_instance) {
printf("Running in single instance mode\n");
}
#ifdef GIO_ENABLED
if (verbose) {
printf("Running with GIO support\n");
}
#endif
#ifdef ENABLE_PANSCAN
if (verbose) {
printf("Running with panscan enabled (mplayer svn r29565 or higher required)\n");
}
#endif
if (verbose) {
printf("Using audio device: %s\n", audio_device_name);
}
if (softvol) {
if (verbose)
printf("Using MPlayer Software Volume control\n");
if (remember_softvol && volume_softvol != -1) {
if (verbose)
printf("Using last volume of %f%%\n", volume_softvol * 100.0);
volume = (gdouble) volume_softvol *100.0;
} else {
volume = 100.0;
}
}
if (large_buttons)
button_size = GTK_ICON_SIZE_DIALOG;
if (playlist_visible && control_id != 0)
playlist_visible = FALSE;
if (error != NULL) {
printf("%s\n", error->message);
printf(_("Run 'gnome-mplayer --help' to see a full list of available command line options.\n"));
return 1;
}
// if (verbose)
// printf("Threading support enabled = %i\n",g_thread_supported());
if (rpconsole == NULL)
rpconsole = g_strdup("NONE");
// setup playliststore
playliststore =
gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,
G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_BOOLEAN);
// only use dark theme if not embedded, otherwise use the default theme
#ifdef GTK3_ENABLED
if (embed_window <= 0) {
gtk_settings = gtk_settings_get_default();
g_object_set(G_OBJECT(gtk_settings), "gtk-application-prefer-dark-theme", TRUE, NULL);
}
#endif
create_window(embed_window);
autopause = FALSE;
#ifdef GIO_ENABLED
idledata->caching = g_mutex_new();
idledata->caching_complete = g_cond_new();
#endif
retrieve_metadata_pool = g_thread_pool_new(retrieve_metadata, NULL, 10, TRUE, NULL);
if (argv[fileindex] != NULL) {
#ifdef GIO_ENABLED
file = g_file_new_for_commandline_arg(argv[fileindex]);
stat_result = -1;
if (file != NULL) {
GError *error = NULL;
GFileInfo *file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_UNIX_MODE, 0, NULL, &error);
if (file_info != NULL) {
buf.st_mode = g_file_info_get_attribute_uint32(file_info, G_FILE_ATTRIBUTE_UNIX_MODE);
stat_result = 0;
g_object_unref(file_info);
}
if (error != NULL) {
if (verbose)
printf("failed to get mode: %s\n", error->message);
g_error_free(error);
}
g_object_unref(file);
}
#else
stat_result = g_stat(argv[fileindex], &buf);
#endif
if (verbose) {
printf("opening %s\n", argv[fileindex]);
printf("stat_result = %i\n", stat_result);
printf("is block %i\n", S_ISBLK(buf.st_mode));
printf("is character %i\n", S_ISCHR(buf.st_mode));
printf("is reg %i\n", S_ISREG(buf.st_mode));
printf("is dir %i\n", S_ISDIR(buf.st_mode));
printf("playlist %i\n", playlist);
printf("embedded in window id 0x%x\n", embed_window);
}
if (stat_result == 0 && S_ISBLK(buf.st_mode)) {
// might have a block device, so could be a DVD
#ifdef HAVE_SYS_MOUNT_H
fp = setmntent("/etc/mtab", "r");
do {
mnt = getmntent(fp);
if (mnt)
printf("%s is at %s\n", mnt->mnt_fsname, mnt->mnt_dir);
if (argv[fileindex] != NULL && mnt && mnt->mnt_fsname != NULL) {
if (strcmp(argv[fileindex], mnt->mnt_fsname) == 0)
break;
}
}
while (mnt);
endmntent(fp);
#endif
if (mnt && mnt->mnt_dir) {
printf("%s is mounted on %s\n", argv[fileindex], mnt->mnt_dir);
uri = g_strdup_printf("%s/VIDEO_TS", mnt->mnt_dir);
stat(uri, &buf);
g_free(uri);
if (S_ISDIR(buf.st_mode)) {
add_item_to_playlist("dvdnav://", 0);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
//play_iter(&iter, 0);
playiter = TRUE;
} else {
uri = g_strdup_printf("file://%s", mnt->mnt_dir);
create_folder_progress_window();
add_folder_to_playlist_callback(uri, NULL);
g_free(uri);
destroy_folder_progress_window();
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
} else {
parse_cdda("cdda://");
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
//play_file("cdda://", playlist);
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
} else if (stat_result == 0 && S_ISDIR(buf.st_mode)) {
uri = g_strdup_printf("%s/VIDEO_TS", argv[fileindex]);
stat_result = g_stat(uri, &buf);
g_free(uri);
if (stat_result == 0 && S_ISDIR(buf.st_mode)) {
add_item_to_playlist("dvdnav://", 0);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
//play_iter(&iter, 0);
playiter = TRUE;
} else {
create_folder_progress_window();
uri = NULL;
#ifdef GIO_ENABLED
file = g_file_new_for_commandline_arg(argv[fileindex]);
if (file != NULL) {
uri = g_file_get_uri(file);
g_object_unref(file);
}
#else
uri = g_filename_to_uri(argv[fileindex], NULL, NULL);
#endif
add_folder_to_playlist_callback(uri, NULL);
g_free(uri);
destroy_folder_progress_window();
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
//play_iter(&iter, 0);
playiter = TRUE;
}
}
} else {
// local file
// detect if playlist here, so even if not specified it can be picked up
i = fileindex;
while (argv[i] != NULL) {
if (verbose > 1)
printf("Argument %i is %s\n", i, argv[i]);
#ifdef GIO_ENABLED
if (!device_name(argv[i])) {
file = g_file_new_for_commandline_arg(argv[i]);
if (file != NULL) {
uri = g_file_get_uri(file);
g_object_unref(file);
} else {
uri = g_strdup(argv[i]);
}
} else {
uri = g_strdup(argv[i]);
}
#else
uri = g_filename_to_uri(argv[i], NULL, NULL);
#endif
if (uri != NULL) {
if (playlist == 0)
playlist = detect_playlist(uri);
if (!playlist) {
add_item_to_playlist(uri, playlist);
} else {
if (!parse_playlist(uri)) {
add_item_to_playlist(uri, playlist);
}
}
g_free(uri);
}
i++;
}
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
}
#ifdef HAVE_GPOD
if (load_tracks_from_gpod) {
gpod_mount_point = find_gpod_mount_point();
printf("mount point is %s\n", gpod_mount_point);
if (gpod_mount_point != NULL) {
gpod_load_tracks(gpod_mount_point);
} else {
printf("Unable to find gpod mount point\n");
}
}
#endif
gm_audio_update_device(&audio_device);
gm_audio_get_volume(&audio_device);
gm_audio_set_server_volume_update_callback(&audio_device, set_volume);
set_media_player_attributes(media);
if (!softvol) {
if (pref_volume != -1) {
audio_device.volume = (gdouble) pref_volume / 100.0;
}
if (verbose)
printf("The volume on '%s' is %f\n", audio_device.description, audio_device.volume);
volume = audio_device.volume * 100;
} else {
audio_device.volume = volume / 100.0;
}
#ifdef GTK2_12_ENABLED
gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol_slider), audio_device.volume);
#else
gtk_range_set_value(GTK_RANGE(vol_slider), audio_device.volume);
#endif
use_volume_option = detect_volume_option();
dbus_hookup(embed_window, control_id);
show_window(embed_window);
if (playiter)
play_iter(&iter, 0);
if (argv[fileindex] == NULL && embed_window == 0) {
// When running as apple.com external player, don't load the default playlist
if (control_id == 0) {
use_remember_loc = remember_loc;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_playlist), playlist_visible);
} else {
remember_loc = FALSE;
use_remember_loc = FALSE;
// prevents saving of a playlist with one item on it
use_defaultpl = FALSE;
// don't save the loc when launched with a single file
save_loc = FALSE;
}
} else {
// prevents saving of a playlist with one item on it
use_defaultpl = FALSE;
// don't save the loc when launched with a single file
save_loc = FALSE;
}
if (single_instance && embed_window == 0) {
if (control_id == 0) {
use_remember_loc = remember_loc;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_playlist), playlist_visible);
}
}
if (embed_window == 0) {
if (remember_loc) {
gtk_window_move(GTK_WINDOW(window), loc_window_x, loc_window_y);
g_idle_add(set_pane_position, NULL);
}
}
safe_to_save_default_playlist = FALSE;
if (use_defaultpl) {
create_folder_progress_window();
parse_playlist(default_playlist);
destroy_folder_progress_window();
}
safe_to_save_default_playlist = TRUE;
gtk_main();
return 0;
}
int
main (int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
#ifdef G_OS_WIN32
if (fileno (stdout) != -1 &&
_get_osfhandle (fileno (stdout)) != -1)
{
/* stdout is fine, presumably redirected to a file or pipe */
}
else
{
typedef BOOL (* WINAPI AttachConsole_t) (DWORD);
AttachConsole_t p_AttachConsole =
(AttachConsole_t) GetProcAddress (GetModuleHandle ("kernel32.dll"), "AttachConsole");
if (p_AttachConsole != NULL && p_AttachConsole (ATTACH_PARENT_PROCESS))
{
freopen ("CONOUT$", "w", stdout);
dup2 (fileno (stdout), 1);
freopen ("CONOUT$", "w", stderr);
dup2 (fileno (stderr), 2);
}
}
#endif
#if (!GLIB_CHECK_VERSION(2,31,0))
/* Remove this once we bump dependencies to glib >= 2.31.0 */
/* Init glib threads asap */
if (!g_thread_supported ())
g_thread_init (NULL);
#endif
#ifdef ENABLE_NLS
/* Initialize the i18n stuff */
bindtextdomain (GETTEXT_PACKAGE, ev_get_locale_dir());
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
context = g_option_context_new (N_("GNOME Document Viewer"));
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, goption_options, GETTEXT_PACKAGE);
#ifdef WITH_SMCLIENT
g_option_context_add_group (context, egg_sm_client_get_option_group ());
#endif
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_printerr ("Cannot parse arguments: %s\n", error->message);
g_error_free (error);
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
if (preview_mode) {
gboolean retval;
retval = launch_previewer ();
return retval ? 0 : 1;
}
if (!ev_init ())
return 1;
ev_stock_icons_init ();
#if defined(WITH_SMCLIENT) && defined(GDK_WINDOWING_X11)
egg_set_desktop_file (GNOMEDATADIR "/applications/evince.desktop");
#else
/* Manually set name and icon */
g_set_application_name (_("Document Viewer"));
gtk_window_set_default_icon_name ("evince");
#endif /* WITH_SMCLIENT && GDK_WINDOWING_X11 */
ev_application_load_session (EV_APP);
load_files (file_arguments);
/* Change directory so we don't prevent unmounting in case the initial cwd
* is on an external device (see bug #575436)
*/
g_chdir (g_get_home_dir ());
gtk_main ();
ev_shutdown ();
ev_stock_icons_shutdown ();
return 0;
}
static int MicrocodeDialog()
{
GtkWidget *infoLabel;
GtkWidget *infoFrame, *infoTable;
GtkWidget *crcInfoLabel, *crcDataInfoLabel, *textInfoLabel;
GtkWidget *crcLabel = NULL, *crcDataLabel = NULL, *textLabel = NULL;
GtkWidget *selectUcodeLabel;
//GtkWidget *microcodeLabel;
GtkWidget *okButton, *stopButton;
GList *ucodeList = 0;
char buf[1024];
if (!g_thread_supported())
g_thread_init( NULL );
gdk_threads_enter();
// create dialog
if (microcodeWindow == 0)
{
microcodeWindow = gtk_dialog_new();
gtk_signal_connect( GTK_OBJECT(microcodeWindow), "delete_event",
GTK_SIGNAL_FUNC(delete_question_event), (gpointer)NULL );
sprintf( buf, "%s - unknown microcode", pluginName );
gtk_window_set_title( GTK_WINDOW(microcodeWindow), buf );
gtk_container_set_border_width( GTK_CONTAINER(GTK_DIALOG(microcodeWindow)->vbox), 11 );
// ok button
okButton = gtk_button_new_with_label( "Ok" );
gtk_signal_connect_object( GTK_OBJECT(okButton), "clicked",
GTK_SIGNAL_FUNC(okButton_clicked), NULL );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(microcodeWindow)->action_area), okButton );
// stop button
stopButton = gtk_button_new_with_label( "Stop" );
gtk_signal_connect_object( GTK_OBJECT(stopButton), "clicked",
GTK_SIGNAL_FUNC(stopButton_clicked), NULL );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(microcodeWindow)->action_area), stopButton );
// info label
infoLabel = gtk_label_new( "Unknown microcode. Please notify Orkin, including the following information:" );
gtk_box_pack_start_defaults( GTK_BOX(GTK_DIALOG(microcodeWindow)->vbox), infoLabel );
// info frame
infoFrame = gtk_frame_new( "Microcode info" );
gtk_container_set_border_width( GTK_CONTAINER(infoFrame), 7 );
gtk_box_pack_start_defaults( GTK_BOX(GTK_DIALOG(microcodeWindow)->vbox), infoFrame );
infoTable = gtk_table_new( 3, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER(infoTable), 7 );
gtk_table_set_col_spacings( GTK_TABLE(infoTable), 3 );
gtk_table_set_row_spacings( GTK_TABLE(infoTable), 3 );
gtk_container_add( GTK_CONTAINER(infoFrame), infoTable );
crcInfoLabel = gtk_label_new( "Microcode CRC:" );
crcDataInfoLabel = gtk_label_new( "Microcode Data CRC:" );
textInfoLabel = gtk_label_new( "Microcode Text:" );
crcLabel = gtk_label_new( "" );
crcDataLabel = gtk_label_new( "" );
textLabel = gtk_label_new( "" );
gtk_table_attach_defaults( GTK_TABLE(infoTable), crcInfoLabel, 0, 1, 0, 1 );
gtk_table_attach_defaults( GTK_TABLE(infoTable), crcLabel, 1, 2, 0, 1 );
gtk_table_attach_defaults( GTK_TABLE(infoTable), crcDataInfoLabel, 0, 1, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(infoTable), crcDataLabel, 1, 2, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(infoTable), textInfoLabel, 0, 1, 2, 3 );
gtk_table_attach_defaults( GTK_TABLE(infoTable), textLabel, 1, 2, 2, 3 );
selectUcodeLabel = gtk_label_new( "You can manually select the closest matching microcode." );
for (int i = 0; i < numMicrocodeTypes; i++)
ucodeList = g_list_append( ucodeList, gtk_list_item_new_with_label( MicrocodeTypes[i] ) );
microcodeList = gtk_list_new();
gtk_list_set_selection_mode( GTK_LIST(microcodeList), GTK_SELECTION_SINGLE );
gtk_list_append_items( GTK_LIST(microcodeList), ucodeList );
gtk_box_pack_start_defaults( GTK_BOX(GTK_DIALOG(microcodeWindow)->vbox), selectUcodeLabel );
gtk_box_pack_start_defaults( GTK_BOX(GTK_DIALOG(microcodeWindow)->vbox), microcodeList );
}
snprintf( buf, 1024, "0x%8.8X", (unsigned int)uc_crc );
if(crcLabel) gtk_label_set_text( GTK_LABEL(crcLabel), buf );
snprintf( buf, 1024, "0x%8.8X", (unsigned int)uc_dcrc );
if(crcDataLabel) gtk_label_set_text( GTK_LABEL(crcDataLabel), buf );
if(textLabel) gtk_label_set_text( GTK_LABEL(textLabel), uc_str );
selectedMicrocode = -1;
gtk_widget_show_all( microcodeWindow );
while (selectedMicrocode == -1)
{
// if( gtk_main_iteration() )
// break;
usleep( 10000 );
}
gdk_threads_leave();
return selectedMicrocode;
}
/**
* Main entry point for sleepd - runs the initialization hooks installed at program load time
*
* A bit counter-intuitively, this is not the first part of this program which
* is run.
*
* First, everything which uses the {@link INIT_FUNC} macro in init.h are run,
* which registers a bunch of hooks with the initialization system so that
* individual modules can be registered without touching the main sleepd
* initialization code. Then, once all of those hooks are installed, execution
* proceeds to this function which actually runs those hooks.
*
* - Initializes sleepd.
* - Attaches as a Luna service under com.palm.sleep.
* - Attaches to Nyx.
* - Subscribes to events related to the charger being plugged and unplugged from the com.palm.power service.
* - Calls {@link TheOneInit()} to finish initialization of the service.
* - Issues a request to the com.palm.power service to check on the plugged/unplugged status of the charger.
*
* @param argc Number of command-line arguments.
* @param argv List of command-line arguments.
*
* @todo Move the logging initialization functionality into {@link TheOneInit()}.
*/
int
main(int argc, char **argv)
{
bool retVal;
/*
* Register a function to be able to gracefully handle termination signals
* from the OS or other processes.
*/
signal(SIGTERM, term_handler);
signal(SIGINT, term_handler);
#if !GLIB_CHECK_VERSION(2,32,0)
if (!g_thread_supported())
{
g_thread_init(NULL);
}
#endif
mainloop = g_main_loop_new(NULL, FALSE);
/*
* initialize the lunaservice and we want it before all the init
* stuff happening.
*/
LSError lserror;
LSErrorInit(&lserror);
/*
* Register ourselves as the com.palm.sleep service.
*/
retVal = LSRegisterPalmService("com.palm.sleep", &psh, &lserror);
if (retVal)
{
/*
* Attach our main loop to the service so we can process IPC messages addressed to us.
*/
retVal = LSGmainAttachPalmService(psh, mainloop, &lserror);
if (retVal)
{
/*
* Get our private bus for our service so we can pass a message to com.palm.power.
*/
private_sh = LSPalmServiceGetPrivateConnection(psh);
/*
* Register with com.palm.power for events regarding changes in status
* to the plug/unplug state of any chargers which may be attached to our
* device.
*/
retVal = LSCall(private_sh, "luna://com.palm.lunabus/signal/addmatch",
"{\"category\":\"/com/palm/power\","
"\"method\":\"USBDockStatus\"}", ChargerStatus, NULL, NULL, &lserror);
if (retVal)
{
/*
* Connect to Nyx so we can use it later.
*/
int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem);
if (ret != NYX_ERROR_NONE)
{
SLEEPDLOG_CRITICAL(MSGID_NYX_DEVICE_OPEN_FAIL, 1,
PMLOGKS(CAUSE, "Unable to open the nyx device system"), "");
abort();
}
/*
* Call our main initialization function - this is the function which
* is supposed to handle initializing pretty much everything for us.
*/
TheOneInit();
/*
* Now that we've got something listening for charger status changes,
* request the current state of the charger from com.palm.power.
*/
LSCall(private_sh, "luna://com.palm.power/com/palm/power/chargerStatusQuery",
"{}", ChargerStatus, NULL, NULL, &lserror);
SLEEPDLOG_DEBUG("Sleepd daemon started");
g_main_loop_run(mainloop);
}
}
}
else
{
SLEEPDLOG_CRITICAL(MSGID_SRVC_REGISTER_FAIL, 1, PMLOGKS(ERRTEXT,
lserror.message), "Could not initialize sleepd");
LSErrorFree(&lserror);
}
g_main_loop_unref(mainloop);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *err = NULL;
DBusConnection *conn;
DBusError error;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
return 1;
}
g_printerr("An unknown error occurred\n");
return 1;
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
event_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
signal = setup_signalfd();
__ofono_log_init(argv[0], option_debug, option_detach);
dbus_error_init(&error);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, OFONO_SERVICE, &error);
if (conn == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
ofono_error("Unable to hop onto D-Bus: %s",
error.message);
dbus_error_free(&error);
} else {
ofono_error("Unable to hop onto D-Bus");
}
goto cleanup;
}
g_dbus_set_disconnect_function(conn, system_bus_disconnected,
NULL, NULL);
__ofono_dbus_init(conn);
__ofono_modemwatch_init();
__ofono_manager_init();
__ofono_plugin_init(option_plugin, option_noplugin);
g_free(option_plugin);
g_free(option_noplugin);
g_main_loop_run(event_loop);
__ofono_plugin_cleanup();
__ofono_manager_cleanup();
__ofono_modemwatch_cleanup();
__ofono_dbus_cleanup();
dbus_connection_unref(conn);
cleanup:
g_source_remove(signal);
g_main_loop_unref(event_loop);
__ofono_log_cleanup();
g_free(option_debug);
return 0;
}
static void
g_cancellable_class_init (GCancellableClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GCancellablePrivate));
if (cancellable_cond == NULL && g_thread_supported ())
cancellable_cond = g_cond_new ();
gobject_class->finalize = g_cancellable_finalize;
/**
* GCancellable::cancelled:
* @cancellable: a #GCancellable.
*
* Emitted when the operation has been cancelled.
*
* Can be used by implementations of cancellable operations. If the
* operation is cancelled from another thread, the signal will be
* emitted in the thread that cancelled the operation, not the
* thread that is running the operation.
*
* Note that disconnecting from this signal (or any signal) in a
* multi-threaded program is prone to race conditions. For instance
* it is possible that a signal handler may be invoked even
* <emphasis>after</emphasis> a call to
* g_signal_handler_disconnect() for that handler has already
* returned.
*
* There is also a problem when cancellation happen
* right before connecting to the signal. If this happens the
* signal will unexpectedly not be emitted, and checking before
* connecting to the signal leaves a race condition where this is
* still happening.
*
* In order to make it safe and easy to connect handlers there
* are two helper functions: g_cancellable_connect() and
* g_cancellable_disconnect() which protect against problems
* like this.
*
* An example of how to us this:
* |[
* /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/
* if (g_cancellable_set_error_if_cancelled (cancellable))
* return;
*
* /<!-- -->* Set up all the data needed to be able to
* * handle cancellation of the operation *<!-- -->/
* my_data = my_data_new (...);
*
* id = 0;
* if (cancellable)
* id = g_cancellable_connect (cancellable,
* G_CALLBACK (cancelled_handler)
* data, NULL);
*
* /<!-- -->* cancellable operation here... *<!-- -->/
*
* g_cancellable_disconnect (cancellable, id);
*
* /<!-- -->* cancelled_handler is never called after this, it
* * is now safe to free the data *<!-- -->/
* my_data_free (my_data);
* ]|
*
* Note that the cancelled signal is emitted in the thread that
* the user cancelled from, which may be the main thread. So, the
* cancellable signal should not do something that can block.
*/
signals[CANCELLED] =
g_signal_new (I_("cancelled"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GCancellableClass, cancelled),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
int
main (int argc, char **argv)
{
static const GOptionEntry test_goptions[] = {
{ "videosink", '\0', 0, G_OPTION_ARG_STRING, &opt_videosink_str,
"videosink to use (default: " DEFAULT_VIDEOSINK ")", NULL
},
{ "caps", '\0', 0, G_OPTION_ARG_STRING, &opt_filtercaps_str,
"filter caps to narrow down formats to test", NULL
},
{ "with-ffmpegcolorspace", '\0', 0, G_OPTION_ARG_NONE,
&opt_with_ffmpegcolorspace,
"whether to add an ffmpegcolorspace element in front of the sink",
NULL
},
{NULL, '\0', 0, 0, NULL, NULL, NULL}
};
GOptionContext *ctx;
GError *opt_err = NULL;
GstElement *pipeline, *src, *filter1, *crop, *scale, *filter2, *csp, *sink;
GMainLoop *loop;
GstCaps *filter_caps = NULL;
GList *caps_list, *l;
if (!g_thread_supported ())
g_thread_init (NULL);
/* command line option parsing */
ctx = g_option_context_new ("");
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_add_main_entries (ctx, test_goptions, NULL);
if (!g_option_context_parse (ctx, &argc, &argv, &opt_err)) {
g_error ("Error parsing command line options: %s", opt_err->message);
return -1;
}
GST_DEBUG_CATEGORY_INIT (videocrop_test_debug, "videocroptest", 0, "vctest");
loop = g_main_loop_new (NULL, FALSE);
pipeline = gst_pipeline_new ("pipeline");
src = gst_element_factory_make ("videotestsrc", "videotestsrc");
g_assert (src != NULL);
filter1 = gst_element_factory_make ("capsfilter", "capsfilter1");
g_assert (filter1 != NULL);
crop = gst_element_factory_make ("videocrop", "videocrop");
g_assert (crop != NULL);
scale = gst_element_factory_make ("videoscale", "videoscale");
g_assert (scale != NULL);
filter2 = gst_element_factory_make ("capsfilter", "capsfilter2");
g_assert (filter2 != NULL);
if (opt_with_ffmpegcolorspace) {
g_print ("Adding ffmpegcolorspace\n");
csp = gst_element_factory_make ("ffmpegcolorspace", "colorspace");
} else {
csp = gst_element_factory_make ("identity", "colorspace");
}
g_assert (csp != NULL);
if (opt_filtercaps_str) {
filter_caps = gst_caps_from_string (opt_filtercaps_str);
if (filter_caps == NULL) {
g_error ("Invalid filter caps string '%s'", opt_filtercaps_str);
} else {
g_print ("Using filter caps '%s'\n", opt_filtercaps_str);
}
}
if (opt_videosink_str) {
g_print ("Trying videosink '%s' ...", opt_videosink_str);
sink = gst_element_factory_make (opt_videosink_str, "sink");
g_print ("%s\n", (sink) ? "ok" : "element couldn't be created");
} else {
sink = NULL;
}
if (sink == NULL) {
g_print ("Trying videosink '%s' ...", DEFAULT_VIDEOSINK);
sink = gst_element_factory_make (DEFAULT_VIDEOSINK, "sink");
g_print ("%s\n", (sink) ? "ok" : "element couldn't be created");
}
if (sink == NULL) {
g_print ("Trying videosink '%s' ...", "xvimagesink");
sink = gst_element_factory_make ("xvimagesink", "sink");
g_print ("%s\n", (sink) ? "ok" : "element couldn't be created");
}
if (sink == NULL) {
g_print ("Trying videosink '%s' ...", "ximagesink");
sink = gst_element_factory_make ("ximagesink", "sink");
g_print ("%s\n", (sink) ? "ok" : "element couldn't be created");
}
g_assert (sink != NULL);
gst_bin_add_many (GST_BIN (pipeline), src, filter1, crop, scale, filter2,
csp, sink, NULL);
if (!gst_element_link (src, filter1))
g_error ("Failed to link videotestsrc to capsfilter1");
if (!gst_element_link (filter1, crop))
g_error ("Failed to link capsfilter1 to videocrop");
if (!gst_element_link (crop, scale))
g_error ("Failed to link videocrop to videoscale");
if (!gst_element_link (scale, filter2))
g_error ("Failed to link videoscale to capsfilter2");
if (!gst_element_link (filter2, csp))
g_error ("Failed to link capsfilter2 to ffmpegcolorspace");
if (!gst_element_link (csp, sink))
g_error ("Failed to link ffmpegcolorspace to video sink");
caps_list = video_crop_get_test_caps (crop);
for (l = caps_list; l != NULL; l = l->next) {
GstStateChangeReturn ret;
GstCaps *caps, *out_caps;
gboolean skip = FALSE;
gchar *s;
if (filter_caps) {
GstCaps *icaps;
icaps = gst_caps_intersect (filter_caps, GST_CAPS (l->data));
skip = gst_caps_is_empty (icaps);
gst_caps_unref (icaps);
}
/* this is the size of our window (stays fixed) */
out_caps = gst_caps_copy (GST_CAPS (l->data));
gst_structure_set (gst_caps_get_structure (out_caps, 0), "width",
G_TYPE_INT, OUT_WIDTH, "height", G_TYPE_INT, OUT_HEIGHT, NULL);
g_object_set (filter2, "caps", out_caps, NULL);
/* filter1 gets these too to prevent videotestsrc from renegotiating */
g_object_set (filter1, "caps", out_caps, NULL);
gst_caps_unref (out_caps);
caps = gst_caps_copy (GST_CAPS (l->data));
GST_INFO ("testing format: %" GST_PTR_FORMAT, caps);
s = gst_caps_to_string (caps);
if (skip) {
g_print ("Skipping format: %s\n", s);
g_free (s);
continue;
}
g_print ("Format: %s\n", s);
caps = gst_caps_make_writable (caps);
/* FIXME: check return values */
ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
if (ret != GST_STATE_CHANGE_FAILURE) {
ret = gst_element_get_state (pipeline, NULL, NULL, -1);
if (ret != GST_STATE_CHANGE_FAILURE) {
test_with_caps (src, crop, caps);
} else {
g_print ("Format: %s not supported (failed to go to PLAYING)\n", s);
}
} else {
g_print ("Format: %s not supported\n", s);
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_caps_unref (caps);
g_free (s);
}
g_list_foreach (caps_list, (GFunc) gst_caps_unref, NULL);
g_list_free (caps_list);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return 0;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status;
//gint32 image_ID;
gint32 drawable_ID;
FblurParam *fblur_param;
/* Get the specified values */
run_mode = param[0].data.d_int32;
//image_ID = param[1].data.d_image;
drawable_ID = param[2].data.d_drawable;
#ifdef ENABLE_MP
if (! g_thread_supported ())
g_thread_init (NULL);
#endif
INIT_I18N ();
/* Check image type */
if (! gimp_drawable_is_rgb (drawable_ID) &&
! gimp_drawable_is_gray (drawable_ID))
{
status = GIMP_PDB_EXECUTION_ERROR;
goto focusblur_exit;
}
/* Initialize parameters */
fblur_param = focusblur_param_new (drawable_ID);
if (! fblur_param)
{
status = GIMP_PDB_EXECUTION_ERROR;
goto focusblur_exit;
}
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
focusblur_param_restore (fblur_param);
/* Get information from the dialog */
if (! focusblur_dialog (fblur_param))
{
status = GIMP_PDB_SUCCESS;
goto focusblur_exit;
}
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (! focusblur_param_set (fblur_param, nparams, param))
{
status = GIMP_PDB_CALLING_ERROR;
goto focusblur_exit;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
if (! focusblur_param_restore (fblur_param))
{
status = GIMP_PDB_CALLING_ERROR;
goto focusblur_exit;
}
break;
}
if (focusblur_execute (fblur_param, NULL))
status = GIMP_PDB_SUCCESS;
else
status = GIMP_PDB_EXECUTION_ERROR;
/* If run mode is interactive, flush displays */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
focusblur_param_store (fblur_param);
focusblur_exit:
if (run_mode == GIMP_RUN_INTERACTIVE)
focusblur_rc_save_preferences (&(fblur_param->pref));
focusblur_param_destroy (&fblur_param);
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = G_N_ELEMENTS (values);
*return_vals = values;
}
bool wxApp::Initialize(int& argc, wxChar **argv)
{
bool init_result;
#if wxUSE_THREADS
if (!g_thread_supported())
g_thread_init(NULL);
wxgs_poll_func = g_main_context_get_poll_func(NULL);
g_main_context_set_poll_func(NULL, wxapp_poll_func);
#endif // wxUSE_THREADS
gtk_set_locale();
// We should have the wxUSE_WCHAR_T test on the _outside_
#if wxUSE_WCHAR_T
// gtk+ 2.0 supports Unicode through UTF-8 strings
wxConvCurrent = &wxConvUTF8;
#else // !wxUSE_WCHAR_T
if (!wxOKlibc())
wxConvCurrent = (wxMBConv*) NULL;
#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
// decide which conversion to use for the file names
// (1) this variable exists for the sole purpose of specifying the encoding
// of the filenames for GTK+ programs, so use it if it is set
wxString encName(wxGetenv(_T("G_FILENAME_ENCODING")));
encName = encName.BeforeFirst(_T(','));
if (encName.CmpNoCase(_T("@locale")) == 0)
encName.clear();
encName.MakeUpper();
#if wxUSE_INTL
if (encName.empty())
{
// (2) if a non default locale is set, assume that the user wants his
// filenames in this locale too
encName = wxLocale::GetSystemEncodingName().Upper();
// (3) finally use UTF-8 by default
if (encName.empty() || encName == _T("US-ASCII"))
encName = _T("UTF-8");
wxSetEnv(_T("G_FILENAME_ENCODING"), encName);
}
#else
if (encName.empty())
encName = _T("UTF-8");
#endif // wxUSE_INTL
#if wxUSE_WCHAR_T
static wxConvBrokenFileNames fileconv(encName);
wxConvFileName = &fileconv;
#endif // wxUSE_WCHAR_T
#if wxUSE_UNICODE
// gtk_init() wants UTF-8, not wchar_t, so convert
int i;
char **argvGTK = new char *[argc + 1];
for ( i = 0; i < argc; i++ )
{
argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv[i]));
}
argvGTK[argc] = NULL;
int argcGTK = argc;
#ifdef __WXGPE__
init_result = true; // is there a _check() version of this?
gpe_application_init( &argcGTK, &argvGTK );
#else
init_result = gtk_init_check( &argcGTK, &argvGTK );
#endif
if ( argcGTK != argc )
{
// we have to drop the parameters which were consumed by GTK+
for ( i = 0; i < argcGTK; i++ )
{
while ( strcmp(wxConvUTF8.cWX2MB(argv[i]), argvGTK[i]) != 0 )
{
memmove(argv + i, argv + i + 1, (argc - i)*sizeof(*argv));
}
}
argc = argcGTK;
}
//else: gtk_init() didn't modify our parameters
// free our copy
for ( i = 0; i < argcGTK; i++ )
{
free(argvGTK[i]);
}
delete [] argvGTK;
#else // !wxUSE_UNICODE
// gtk_init() shouldn't actually change argv itself (just its contents) so
// it's ok to pass pointer to it
init_result = gtk_init_check( &argc, &argv );
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
if (!init_result) {
wxLogError(wxT("Unable to initialize gtk, is DISPLAY set properly?"));
return false;
}
// update internal arg[cv] as GTK+ may have removed processed options:
this->argc = argc;
this->argv = argv;
// we can not enter threads before gtk_init is done
gdk_threads_enter();
if ( !wxAppBase::Initialize(argc, argv) )
{
gdk_threads_leave();
return false;
}
wxSetDetectableAutoRepeat( true );
#if wxUSE_INTL
wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif
return true;
}
int main (int argc, char *argv[])
{
int i;
char *pluginname = NULL;
char *plugindir = NULL;
char *configfile = NULL;
char *objtype = NULL;
OSyncError *error = NULL;
if (argc < 2)
usage (argv[0], 1);
pluginname = argv[1];
for (i = 2; i < argc; i++) {
char *arg = argv[i];
if (!strcmp (arg, "--config")) {
configfile = argv[i + 1];
i++;
if (!configfile)
usage (argv[0], 1);
} else if (!strcmp (arg, "--type")) {
objtype = argv[i + 1];
i++;
if (!objtype)
usage (argv[0], 1);
} else if (!strcmp (arg, "--plugindir")) {
printf("plugindir %s\n", argv[i + 1]);
plugindir = argv[i + 1];
i++;
if (!plugindir)
usage (argv[0], 1);
} else if (!strcmp (arg, "--random")) {
only_random = TRUE;
} else if (!strcmp (arg, "--help")) {
usage (argv[0], 0);
} else {
usage (argv[0], 1);
}
}
OSyncEnv *env = osync_env_new(NULL);
osync_env_set_option(env, "LOAD_GROUPS", "FALSE");
if (plugindir)
osync_env_set_option(env, "PLUGINS_DIRECTORY", plugindir);
if (!osync_env_initialize(env, &error)) {
printf("Unable to initialize environment: %s\n", osync_error_print(&error));
osync_error_unref(&error);
return 1;
}
char *testdir = g_strdup_printf("%s/plgtest.XXXXXX", g_get_tmp_dir());
char *result = mkdtemp(testdir);
if (result == NULL)
{
osync_trace(TRACE_EXIT_ERROR, "unable to create temporary dir: %s", g_strerror(errno));
return 1;
}
OSyncGroup *group = osync_group_new(env);
osync_group_set_name(group, osync_rand_str(8));
osync_group_set_configdir(group, testdir);
OSyncMember *member = osync_member_new(group);
char *config = NULL;
int size = 0;
if (configfile) {
if (!osync_file_read(configfile, &config, &size, &error)) {
fprintf(stderr, "Unable to read config: %s\n", osync_error_print(&error));
osync_error_unref(&error);
return 1;
}
osync_member_set_config(member, config, size);
}
osync_member_set_pluginname(member, pluginname);
OSyncMember *file = osync_member_new(group);
localdir = g_strdup_printf("%s/plgtest.XXXXXX", g_get_tmp_dir());
result = mkdtemp(localdir);
if (result == NULL)
{
osync_trace(TRACE_EXIT_ERROR, "unable to create temporary dir: %s", g_strerror(errno));
return 1;
}
config = g_strdup_printf("<config><path>%s</path><recursive>0</recursive></config>", localdir);
osync_member_set_config(file, config, strlen(config) + 1);
osync_member_set_pluginname(file, "file-sync");
if (!osync_group_save(group, &error)) {
printf("Error while creating syncengine: %s\n", osync_error_print(&error));
osync_error_unref(&error);
goto error_free_env;
}
if (!g_thread_supported ()) g_thread_init (NULL);
OSyncEngine *engine = osengine_new(group, &error);
if (!engine) {
printf("Error while creating syncengine: %s\n", osync_error_print(&error));
osync_error_unref(&error);
goto error_free_env;
}
if (!osengine_init(engine, &error)) {
printf("Error while initializing syncengine: %s\n", osync_error_print(&error));
osync_error_unref(&error);
goto error_free_engine;
}
int count = 0;
if (only_random) {
do {
count++;
printf("++++++++++++++++++++++++++++++\n");
printf("Initializing new round #%i!\n", count);
if (g_random_int_range(0, 5) == 0) {
int i;
OSyncFormatEnv *env = osync_group_get_format_env(group);
for (i = 0; i < osync_conv_num_objtypes(env); i++) {
if (g_random_int_range(0, 5) == 0) {
OSyncObjType *type = osync_conv_nth_objtype(env, i);
osync_group_set_slow_sync(group, osync_objtype_get_name(type), TRUE);
printf("Requesting slow-sync for: %s\n", osync_objtype_get_name(type));
}
}
osync_conv_env_free(env);
}
change_content();
check_sync(engine, "Random", 1);
} while (g_random_int_range(0, 3) != 0);
printf("Finalizing engine\n");
osengine_finalize(engine);
osengine_free(engine);
engine = osengine_new(group, &error);
if (!engine) {
printf("Error while creating syncengine: %s\n", osync_error_print(&error));
osync_error_unref(&error);
goto error_free_env;
}
if (!osengine_init(engine, &error)) {
printf("Error while initializing syncengine: %s\n", osync_error_print(&error));
osync_error_unref(&error);
goto error_free_engine;
}
} else {
register_tests();
run_all_tests(engine, file, member, objtype);
}
printf("\nCompleted successfully\n");
return 0;
error_free_engine:
osengine_free(engine);
error_free_env:
osync_group_free(group);
osync_env_free(env);
return 1;
}
int
main (int argc, char *argv[])
{
signal_user_data_t *ud;
GValue *preset;
GError *error = NULL;
GOptionContext *context;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!g_thread_supported())
g_thread_init(NULL);
context = g_option_context_new ("- Transcode media formats");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group (context, gst_init_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free(context);
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init (&argc, &argv);
gtk_rc_parse_string(hud_rcstyle);
g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON));
g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_register_transforms();
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->settings = ghb_settings_new();
ud->builder = create_builder_or_die (BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes (ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
GtkWidget *widget;
#if defined(_NO_UPDATE_CHECK)
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
widget = GHB_WIDGET(ud->builder, "preview_hud");
gtk_widget_set_name(widget, "preview_hud");
widget = GHB_WIDGET(ud->builder, "preview_window");
gtk_widget_set_name(widget, "preview_window");
// Set up the "hud" control overlay for the preview window
GtkWidget *draw, *hud, *blender, *align;
align = GHB_WIDGET(ud->builder, "preview_window_alignment");
draw = GHB_WIDGET(ud->builder, "preview_image_align");
hud = GHB_WIDGET(ud->builder, "preview_hud");
// Set up compositing for hud
blender = ghb_compositor_new();
gtk_container_add(GTK_CONTAINER(align), blender);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85);
gtk_widget_show(blender);
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer (textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full (ud->builder, MyConnect, ud);
// Load all internal settings
ghb_settings_init(ud);
// Load the presets files
ghb_presets_load(ud);
ghb_prefs_load(ud);
ghb_prefs_to_ui(ud);
gint logLevel;
logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel");
ghb_backend_init(logLevel);
if (ghb_settings_get_boolean(ud->settings, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
gchar *source = ghb_settings_get_string(ud->settings, "default_source");
ghb_dvd_set_current(source, ud);
g_free(source);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_parse_options(ud, "");
// Populate the presets tree view
ghb_presets_list_init(ud, NULL, 0);
// Get the first preset name
if (arg_preset != NULL)
{
preset = ghb_parse_preset_path(arg_preset);
if (preset)
{
ghb_select_preset(ud->builder, preset);
ghb_value_free(preset);
}
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies (ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_settings_set_string(ud->settings, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add (500, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
#if defined(_USE_APP_IND)
GtkUIManager * uim = GTK_UI_MANAGER(GHB_OBJECT(ud->builder, "uimanager1"));
GtkMenu *ai_menu = GTK_MENU(gtk_ui_manager_get_widget(uim, "/ui/tray_menu"));
ud->ai = app_indicator_new("HandBrake", "hb-icon", APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_menu( ud->ai, ai_menu );
app_indicator_set_label( ud->ai, "", "99.99%");
if (ghb_settings_get_boolean(ud->settings, "show_status"))
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_ACTIVE );
}
else
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_PASSIVE );
}
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si, FALSE );
#else
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si,
ghb_settings_get_boolean(ud->settings, "show_status"));
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_status_icon_set_has_tooltip(si, TRUE);
g_signal_connect(si, "query-tooltip",
status_icon_query_tooltip_cb, ud);
#else
gtk_status_icon_set_tooltip(si, "HandBrake");
#endif
#endif
// Ugly hack to keep subtitle table from bouncing around as I change
// which set of controls are visible
GtkRequisition req;
gint width, height;
widget = GHB_WIDGET(ud->builder, "SrtCodeset");
gtk_widget_size_request( widget, &req );
height = req.height;
widget = GHB_WIDGET(ud->builder, "srt_code_label");
gtk_widget_size_request( widget, &req );
height += req.height;
widget = GHB_WIDGET(ud->builder, "subtitle_table");
gtk_widget_set_size_request(widget, -1, height);
widget = GHB_WIDGET (ud->builder, "hb_window");
GdkGeometry geo = {
-1, -1, 1024, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask);
width = ghb_settings_get_int(ud->settings, "window_width");
height = ghb_settings_get_int(ud->settings, "window_height");
gtk_window_resize(GTK_WINDOW(widget), width, height);
gtk_widget_show(widget);
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, "All");
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, "Video");
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string ("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view"));
gtk_widget_modify_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free (font_desc);
// Everything should be go-to-go. Lets rock!
gtk_main ();
gtk_status_icon_set_visible(si, FALSE);
ghb_backend_close();
if (ud->queue)
ghb_value_free(ud->queue);
ghb_value_free(ud->settings);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
#if !defined(_WIN32)
notify_uninit();
#endif
g_free(ud);
return 0;
}
/*
static void tvsub(struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
{
tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
while (tdiff->tv_usec < 0)
tdiff->tv_sec--, tdiff->tv_usec += 1000000;
}
static int Nread(GstElement * dccpclientsrc)
{
sock=socket (AF_INET, SOCK_DCCP, IPPROTO_DCCP);
g_object_get(G_OBJECT(dccpclientsrc), "sockfd", &sock, NULL);
struct tfrc_rx_info tfrc;
socklen_t len = sizeof(tfrc);
struct timeval now, onow;
getsockopt(sock, SOL_DCCP, DCCP_SOCKOPT_CCID_RX_INFO,(char*)&tfrc, &len);
gettimeofday(&now, NULL);
tvsub(&onow, &now, &time0);
printf("%ld.%06ld %u %u %u\n",
onow.tv_sec, onow.tv_usec,
tfrc.tfrcrx_x_recv,
tfrc.tfrcrx_rtt,
tfrc.tfrcrx_p);
//if (tfrc.tfrcrx_p>0)
//tfrc.tfrcrx_p=0;
//setsockopt(sock, SOL_DCCP, DCCP_SOCKOPT_CCID_TX_INFO,&tfrc, sizeof(tfrc));
return 1;
}
*/
int main (int argc, char *argv[]){
GMainLoop *loop;
GstBus *bus;
GstElement *pipeline, *ffmpegcolorspace, *ximagesink, *h264parse, *ffdec_h264, *dccpclientsrc;
gchar *host="127.0.0.1";
gint port = 4000;
gint ccid = 3;
GOptionContext *context = NULL;
GError *err;
/* Option Entry */
GOptionEntry entries[] =
{
{"Port", 'p', 0, G_OPTION_ARG_INT, &port, "The port to receive packets from (default: 4000)", NULL},
{"Host", 'i', 0, G_OPTION_ARG_STRING, &host, "The host IP address to receive packets from (default: localhost)", NULL},
{"ccid", 'c', 0, G_OPTION_ARG_INT, &ccid, "The Congestion Control IDentified to be used (default: 3)", NULL},
{NULL}
};
if (!g_thread_supported())
g_thread_init (NULL);
context = g_option_context_new("- TFRC over DCCP");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_add_group(context, gst_init_get_option_group());
if (!g_option_context_parse(context, &argc, &argv, &err)) {
g_error("%s\n", err->message);
return FALSE;
}
/* initialize GStreamer */
gst_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
/* create elements */
pipeline = gst_pipeline_new ("video-sender");
ximagesink = gst_element_factory_make ("ximagesink", "ximagesink");
ffmpegcolorspace = gst_element_factory_make ("ffmpegcolorspace", "ffmpegcolorspace");
h264parse = gst_element_factory_make ("h264parse", "h264parse");
ffdec_h264 = gst_element_factory_make ("ffdec_h264", "ffdec_h264");
dccpclientsrc = gst_element_factory_make ("dccpclientsrc", "client-source");
if (!pipeline || !ximagesink || !ffmpegcolorspace || !h264parse || !ffdec_h264 || !dccpclientsrc) {
g_print ("One element could not be created\n");
return -1;
}
g_object_set (G_OBJECT (dccpclientsrc), "host", host, NULL);
g_object_set (G_OBJECT (dccpclientsrc), "port", port, NULL);
g_object_set (G_OBJECT (dccpclientsrc), "ccid", ccid, NULL);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_watch (bus, bus_call, loop);
gst_object_unref (bus);
/* put all elements in a bin */
gst_bin_add_many (GST_BIN (pipeline), dccpclientsrc, h264parse, ffdec_h264,ffmpegcolorspace, ximagesink, NULL);
gst_element_link_many (dccpclientsrc, h264parse, ffdec_h264,ffmpegcolorspace, ximagesink, NULL);
/* Now set to playing and iterate. */
g_print ("Setting to PLAYING\n");
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_print ("Running\n");
//g_timeout_add(1000,(GSourceFunc)Nread, dccpclientsrc);
g_main_loop_run (loop);
/* clean up nicely */
g_print ("Returned, stopping playback\n");
gst_element_set_state (pipeline, GST_STATE_NULL);
g_print ("Deleting pipeline\n");
gst_object_unref (GST_OBJECT (pipeline));
return 0;
}
int main(void){
GThread *theThread;
GtkWidget *window;
GtkWidget *save;
GtkWidget *hbox;
GtkWidget *theTable;
GtkWidget *eBox, *eBox2;
GtkWidget *lsh,*lsl,*lvh,*lvl;
gtk_init(0,NULL);
loadVars("segVals.dat",theVars);
//int index=getIndex();
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
hbox=gtk_hbox_new(FALSE,2);
image=gtk_image_new();
gseg=gtk_image_new();
eBox=gtk_event_box_new();
eBox2=gtk_event_box_new();
theTable=gtk_table_new(5,2,TRUE);
save = gtk_button_new_with_label("Save!");
spinvh=gtk_spin_button_new_with_range(0,255,1);
spinvl=gtk_spin_button_new_with_range(0,255,1);
spinsh=gtk_spin_button_new_with_range(0,255,1);
spinsl=gtk_spin_button_new_with_range(0,255,1);
lsh=gtk_label_new_with_mnemonic("sh");
lsl=gtk_label_new_with_mnemonic("sl");
lvh=gtk_label_new_with_mnemonic("vh");
lvl=gtk_label_new_with_mnemonic("vl");
hval=gtk_label_new_with_mnemonic("Hue=0");
gtk_window_set_title(GTK_WINDOW(window),"gtk application");
g_signal_connect(window,"delete_event",G_CALLBACK(kill_window),NULL);
g_signal_connect(eBox,"button_press_event",G_CALLBACK(pressed),image);
g_signal_connect(eBox2,"button_press_event",G_CALLBACK(pressed),image);
g_signal_connect(save,"button_press_event",G_CALLBACK(theSaver),NULL);
g_signal_connect(spinsh,"changed",G_CALLBACK(updateValue), (gpointer)1);
g_signal_connect(spinsl,"changed",G_CALLBACK(updateValue),(gpointer)2);
g_signal_connect(spinvh,"changed",G_CALLBACK(updateValue),(gpointer)3);
g_signal_connect(spinvl,"changed",G_CALLBACK(updateValue),(gpointer)4);//*/
gtk_table_attach_defaults(GTK_TABLE(theTable),spinsh,0,1,0,1);
gtk_table_attach_defaults(GTK_TABLE(theTable),spinsl,0,1,1,2);
gtk_table_attach_defaults(GTK_TABLE(theTable),spinvh,0,1,2,3);
gtk_table_attach_defaults(GTK_TABLE(theTable),spinvl,0,1,3,4);
gtk_table_attach_defaults(GTK_TABLE(theTable),lsh,1,2,0,1);
gtk_table_attach_defaults(GTK_TABLE(theTable),lsl,1,2,1,2);
gtk_table_attach_defaults(GTK_TABLE(theTable),lvh,1,2,2,3);
gtk_table_attach_defaults(GTK_TABLE(theTable),lvl,1,2,3,4);
gtk_table_attach_defaults(GTK_TABLE(theTable),hval,0,2,4,5);
updateLimits();
/*gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinsh),theVars[7+theIndex*2].theInt);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinsl),theVars[6+theIndex*2].theInt);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinvh),theVars[13+theIndex*2].theInt);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinvl),theVars[12+theIndex*2].theInt);//*/
gtk_container_add(GTK_CONTAINER(eBox),image);
gtk_container_add(GTK_CONTAINER(eBox2),gseg);
//gtk_box_pack_start(GTK_BOX(hbox),gseg,FALSE,FALSE,2);
gtk_box_pack_start(GTK_BOX(hbox),eBox2,FALSE,FALSE,2);
gtk_box_pack_start(GTK_BOX(hbox),eBox,FALSE,FALSE,2);
gtk_box_pack_start(GTK_BOX(hbox),theTable,FALSE,FALSE,2);
gtk_box_pack_start(GTK_BOX(hbox),save,TRUE,TRUE,2);
//gtk_box_pack_start(GTK_BOX(hbox),save,FALSE,FALSE,2);
gtk_container_add(GTK_CONTAINER(window),hbox);
if( g_thread_supported() )
{
g_thread_init(NULL);
gdk_threads_init(); // Called to initialize internal mutex "gdk_threads_mutex".
printf("g_thread supported\n");
}
else
{
printf("g_thread NOT supported\n");
exit(0);
}
theThread = g_thread_create((GThreadFunc)ocvThread, NULL, TRUE, NULL);
assert(theThread!=NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
/**
* CGstMediaManager::Init().
*
* @param data user-defined data. Pointer to this.
* @return Java long reference to the media.
*/
uint32_t CGstMediaManager::Init()
{
GError* pError = NULL;
uint32_t uRetCode = ERROR_NONE;
#if ENABLE_LOWLEVELPERF && TARGET_OS_MAC
g_mem_set_vtable (glib_mem_profiler_table);
#endif
#if ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION && TARGET_OS_WIN32
_CrtSetDbgFlag ( 0 );
#endif // ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION
//***** Try to initialize the GStreamer system
if (!g_thread_supported())
g_thread_init (NULL);
LOWLEVELPERF_EXECTIMESTART("gst_init_check()");
// disable installing SIGSEGV signal handling as it interferes with Java's signal handling
gst_segtrap_set_enabled(false);
if (!gst_init_check(NULL, NULL, NULL))
{
LOGGER_LOGMSG(LOGGER_DEBUG, "Could not init GStreamer!\n");
return ERROR_MANAGER_ENGINEINIT_FAIL;
}
LOWLEVELPERF_EXECTIMESTOP("gst_init_check()");
#if ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION && TARGET_OS_WIN32
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif // ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION
//***** Create mutex and condition variable
m_pRunloopCond = g_cond_new();
m_pRunloopMutex = g_mutex_new();
#if ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION && TARGET_OS_WIN32
_CrtSetDbgFlag(0);
#endif // ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION
//***** Create the primary run loop
m_pMainLoopThread = g_thread_create((GThreadFunc)run_loop, this, FALSE, &pError);
if (m_pMainLoopThread == NULL)
{
LOGGER_LOGMSG(LOGGER_DEBUG, "Could not create main GThread!!\n");
LOGGER_LOGMSG(LOGGER_DEBUG, pError->message);
return ERROR_MANAGER_RUNLOOP_FAIL;
}
#if ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION && TARGET_OS_WIN32
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif // ENABLE_VISUAL_STUDIO_MEMORY_LEAKS_DETECTION
//***** Wait till the run loop has fully initialized. Bad things happen if we do not do this, including crashers.
g_mutex_lock(m_pRunloopMutex);
while (NULL == m_pMainLoop)
g_cond_wait(m_pRunloopCond, m_pRunloopMutex);
g_mutex_unlock(m_pRunloopMutex);
if (m_bMainLoopCreateFailed)
uRetCode = ERROR_GSTREAMER_MAIN_LOOP_CREATE;
// Free no longer needed GCond.
if (NULL != m_pRunloopCond)
{
g_cond_free(m_pRunloopCond);
m_pRunloopCond = NULL;
}
// Free no longer needed GMutex.
if (NULL != m_pRunloopMutex)
{
g_mutex_free(m_pRunloopMutex);
m_pRunloopMutex = NULL;
}
// Set the default Glib log handler.
g_log_set_default_handler (GlibLogFunc, this);
return uRetCode;
}
//static
bool
MediaPluginGStreamer010::startup()
{
// first - check if GStreamer is explicitly disabled
if (NULL != getenv("LL_DISABLE_GSTREAMER"))
return false;
// only do global GStreamer initialization once.
if (!mDoneInit)
{
#if !GLIB_CHECK_VERSION(2, 36, 0)
#if !GLIB_CHECK_VERSION(2, 32, 0)
if (!g_thread_supported()) g_thread_init(NULL);
#endif
// Init the glib type system - we need it.
g_type_init();
#endif
set_gst_plugin_path();
/*
// Get symbols!
#if LL_DARWIN
if (! grab_gst_syms("libgstreamer-0.10.dylib",
"libgstvideo-0.10.dylib") )
#elseif LL_WINDOWS
if (! grab_gst_syms("libgstreamer-0.10.dll",
"libgstvideo-0.10.dll") )
#else // linux or other ELFy unixoid
if (! grab_gst_syms("libgstreamer-0.10.so.0",
"libgstvideo-0.10.so.0") )
#endif
{
WARNMSG("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled.");
return false;
}
*/
// if (gst_segtrap_set_enabled)
// {
gst_segtrap_set_enabled(FALSE);
// }
// else
// {
// WARNMSG("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught.");
// }
/*
#if LL_LINUX
// Gstreamer tries a fork during init, waitpid-ing on it,
// which conflicts with any installed SIGCHLD handler...
struct sigaction tmpact, oldact;
if (gst_registry_fork_set_enabled) {
// if we can disable SIGCHLD-using forking behaviour,
// do it.
gst_registry_fork_set_enabled(false);
}
else {
// else temporarily install default SIGCHLD handler
// while GStreamer initialises
tmpact.sa_handler = SIG_DFL;
sigemptyset( &tmpact.sa_mask );
tmpact.sa_flags = SA_SIGINFO;
sigaction(SIGCHLD, &tmpact, &oldact);
}
#endif // LL_LINUX
*/
// Protect against GStreamer resetting the locale, yuck.
static std::string saved_locale;
saved_locale = setlocale(LC_ALL, NULL);
// finally, try to initialize GStreamer!
GError *err = NULL;
gboolean init_gst_success = gst_init_check(NULL, NULL, &err);
// restore old locale
setlocale(LC_ALL, saved_locale.c_str() );
/*
#if LL_LINUX
// restore old SIGCHLD handler
if (!gst_registry_fork_set_enabled)
sigaction(SIGCHLD, &oldact, NULL);
#endif // LL_LINUX
*/
if (!init_gst_success) // fail
{
if (err)
{
WARNMSG("GST init failed: %s", err->message);
g_error_free(err);
}
else
{
WARNMSG("GST init failed for unspecified reason.");
}
return false;
}
// Set up logging facilities
gst_debug_remove_log_function( gst_debug_log_default );
// gst_debug_add_log_function( gstreamer_log, NULL );
// Init our custom plugins - only really need do this once.
gst_slvideo_init_class();
/*
// List the plugins GStreamer can find
LL_DEBUGS("MediaImpl") << "Found GStreamer plugins:" << LL_ENDL;
GList *list;
GstRegistry *registry = gst_registry_get_default();
std::string loaded = "";
for (list = gst_registry_get_plugin_list(registry);
list != NULL;
list = g_list_next(list))
{
GstPlugin *list_plugin = (GstPlugin *)list->data;
(bool)gst_plugin_is_loaded(list_plugin) ? loaded = "Yes" : loaded = "No";
LL_DEBUGS("MediaImpl") << gst_plugin_get_name(list_plugin) << ", loaded? " << loaded << LL_ENDL;
}
gst_plugin_list_free(list);
*/
mDoneInit = true;
}
return true;
}
int
main (int argc, char **argv)
{
GError *err = NULL;
GstDiscoverer *dc;
gint timeout = 10;
GOptionEntry options[] = {
{"async", 'a', 0, G_OPTION_ARG_NONE, &async,
"Run asynchronously", NULL},
{"silent", 's', 0, G_OPTION_ARG_NONE, &silent,
"Don't output the information structure", NULL},
{"timeout", 't', 0, G_OPTION_ARG_INT, &timeout,
"Specify timeout (in seconds, default 10)", "T"},
/* {"elem", 'e', 0, G_OPTION_ARG_NONE, &elem_seek, */
/* "Seek on elements instead of pads", NULL}, */
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Verbose properties", NULL},
{NULL}
};
GOptionContext *ctx;
#if !GLIB_CHECK_VERSION (2, 31, 0)
if (!g_thread_supported ())
g_thread_init (NULL);
#endif
ctx =
g_option_context_new
("- discover files synchronously with GstDiscoverer");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
g_option_context_free (ctx);
if (argc < 2) {
g_print ("usage: %s <uris>\n", argv[0]);
exit (-1);
}
dc = gst_discoverer_new (timeout * GST_SECOND, &err);
if (G_UNLIKELY (dc == NULL)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
if (async == FALSE) {
gint i;
for (i = 1; i < argc; i++)
process_file (dc, argv[i]);
} else {
PrivStruct *ps = g_new0 (PrivStruct, 1);
GMainLoop *ml = g_main_loop_new (NULL, FALSE);
ps->dc = dc;
ps->argc = argc;
ps->argv = argv;
/* adding uris will be started when the mainloop runs */
g_idle_add ((GSourceFunc) _run_async, ps);
/* connect signals */
g_signal_connect (dc, "discovered", G_CALLBACK (_new_discovered_uri), NULL);
g_signal_connect (dc, "finished", G_CALLBACK (_discoverer_finished), ml);
gst_discoverer_start (dc);
/* run mainloop */
g_main_loop_run (ml);
gst_discoverer_stop (dc);
g_free (ps);
g_main_loop_unref (ml);
}
g_object_unref (dc);
return 0;
}
/* Rather than inline this one, we just declare it as a function, to prevent
* GCC warning about inline failure. */
fluid_cond_t *
new_fluid_cond (void)
{
if (!g_thread_supported ()) g_thread_init (NULL);
return g_cond_new ();
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GOptionContext *context;
const gchar *filename;
EvDocumentModel *model;
GError *error = NULL;
#ifdef G_OS_WIN32
if (fileno (stdout) != -1 &&
_get_osfhandle (fileno (stdout)) != -1)
{
/* stdout is fine, presumably redirected to a file or pipe */
}
else
{
typedef BOOL (* WINAPI AttachConsole_t) (DWORD);
AttachConsole_t p_AttachConsole =
(AttachConsole_t) GetProcAddress (GetModuleHandle ("kernel32.dll"), "AttachConsole");
if (p_AttachConsole != NULL && p_AttachConsole (ATTACH_PARENT_PROCESS))
{
freopen ("CONOUT$", "w", stdout);
dup2 (fileno (stdout), 1);
freopen ("CONOUT$", "w", stderr);
dup2 (fileno (stderr), 2);
}
}
#endif
/* Init glib threads asap */
if (!g_thread_supported ())
g_thread_init (NULL);
#ifdef ENABLE_NLS
/* Initialize the i18n stuff */
bindtextdomain (GETTEXT_PACKAGE, ev_get_locale_dir());
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
context = g_option_context_new (_("MATE Document Previewer"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, goption_options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("Error parsing command line arguments: %s", error->message);
g_error_free (error);
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
if (!filenames) {
g_warning ("File argument is required");
return 1;
}
filename = filenames[0];
if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)) {
g_warning ("Filename \"%s\" does not exist or is not a regular file", filename);
return 1;
}
if (!ev_init ())
return 1;
ev_stock_icons_init ();
g_set_application_name (_("MATE Document Previewer"));
gtk_window_set_default_icon_name ("atril");
model = ev_document_model_new ();
window = ev_previewer_window_new (model);
ev_previewer_window_set_source_file (EV_PREVIEWER_WINDOW (window), filename);
ev_previewer_window_set_print_settings (EV_PREVIEWER_WINDOW (window), print_settings);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (window);
ev_previewer_load_document (filename, model);
gtk_main ();
if (unlink_temp_file)
ev_previewer_unlink_tempfile (filename);
if (print_settings)
ev_previewer_unlink_tempfile (print_settings);
ev_shutdown ();
ev_stock_icons_shutdown ();
g_object_unref (model);
return 0;
}
/* This function recieves the START_TAPER command from driver, and
returns the attached timestamp. */
static gboolean find_first_tape(taper_state_t * state) {
struct cmdargs *cmdargs;
tape_search_request_t search_request;
GThread * tape_search = NULL;
gboolean use_threads;
/* We save the value here in case it changes while we're running. */
use_threads = g_thread_supported();
search_request.state = state;
search_request.prolong = TRUE;
search_request.errmsg = NULL;
if (use_threads) {
tape_search = g_thread_create(tape_search_thread,
&search_request, TRUE, NULL);
}
cmdargs = getcmd();
switch (cmdargs->cmd) {
case START_TAPER: {
gboolean search_result;
state->driver_start_time = strdup(cmdargs->argv[1]);
if (use_threads) {
search_result = GPOINTER_TO_INT(g_thread_join(tape_search));
} else {
search_result =
GPOINTER_TO_INT(tape_search_thread(&search_request));
}
if (search_result) {
putresult(TAPER_OK, "\n");
} else {
char *msg = quote_string(_("Could not find a tape to use"));
putresult(TAPE_ERROR, "99-99999 %s\n", msg);
log_add(L_ERROR, "no-tape [%s]", "Could not find a tape to use");
if (search_request.errmsg != NULL) {
char *c, *c1;
c = c1 = search_request.errmsg;
while (*c != '\0') {
if (*c == '\n') {
*c = '\0';
log_add(L_WARNING,"%s", c1);
c1 = c+1;
}
c++;
}
if (strlen(c1) > 1 )
log_add(L_WARNING,"%s", c1);
}
}
amfree(search_request.errmsg);
free_cmdargs(cmdargs);
return TRUE;
}
case QUIT:
search_request.prolong = FALSE;
if (use_threads) {
g_thread_join(tape_search);
}
free_cmdargs(cmdargs);
return send_quitting(state);
default:
error("error [file_reader_side cmd %d argc %d]", cmdargs->cmd, cmdargs->argc);
}
g_assert_not_reached();
}
// use unusual names for the parameters to avoid conflict with wxApp::arg[cv]
bool wxApp::Initialize(int& argc_, wxChar **argv_)
{
if ( !wxAppBase::Initialize(argc_, argv_) )
return false;
#if wxUSE_THREADS
if (!g_thread_supported())
{
g_thread_init(NULL);
gdk_threads_init();
}
#endif // wxUSE_THREADS
// gtk+ 2.0 supports Unicode through UTF-8 strings
wxConvCurrent = &wxConvUTF8;
// decide which conversion to use for the file names
// (1) this variable exists for the sole purpose of specifying the encoding
// of the filenames for GTK+ programs, so use it if it is set
wxString encName(wxGetenv(wxT("G_FILENAME_ENCODING")));
encName = encName.BeforeFirst(wxT(','));
if (encName.CmpNoCase(wxT("@locale")) == 0)
encName.clear();
encName.MakeUpper();
#if wxUSE_INTL
if (encName.empty())
{
// (2) if a non default locale is set, assume that the user wants his
// filenames in this locale too
encName = wxLocale::GetSystemEncodingName().Upper();
// (3) finally use UTF-8 by default
if (encName.empty() || encName == wxT("US-ASCII"))
encName = wxT("UTF-8");
wxSetEnv(wxT("G_FILENAME_ENCODING"), encName);
}
#else
if (encName.empty())
encName = wxT("UTF-8");
// if wxUSE_INTL==0 it probably indicates that only "C" locale is supported
// by the program anyhow so prevent GTK+ from calling setlocale(LC_ALL, "")
// from gtk_init_check() as it does by default
gtk_disable_setlocale();
#endif // wxUSE_INTL
static wxConvBrokenFileNames fileconv(encName);
wxConvFileName = &fileconv;
bool init_result;
int i;
#if wxUSE_UNICODE
// gtk_init() wants UTF-8, not wchar_t, so convert
char **argvGTK = new char *[argc_ + 1];
for ( i = 0; i < argc_; i++ )
{
argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv_[i]));
}
argvGTK[argc_] = NULL;
int argcGTK = argc_;
#ifdef __WXGPE__
init_result = true; // is there a _check() version of this?
gpe_application_init( &argcGTK, &argvGTK );
#else
init_result = gtk_init_check( &argcGTK, &argvGTK );
#endif
wxUpdateLocaleIsUtf8();
if ( argcGTK != argc_ )
{
// we have to drop the parameters which were consumed by GTK+
for ( i = 0; i < argcGTK; i++ )
{
while ( strcmp(wxConvUTF8.cWX2MB(argv_[i]), argvGTK[i]) != 0 )
{
memmove(argv_ + i, argv_ + i + 1, (argc_ - i)*sizeof(*argv_));
}
}
argc_ = argcGTK;
argv_[argc_] = NULL;
}
//else: gtk_init() didn't modify our parameters
// free our copy
for ( i = 0; i < argcGTK; i++ )
{
free(argvGTK[i]);
}
delete [] argvGTK;
#else // !wxUSE_UNICODE
// gtk_init() shouldn't actually change argv_ itself (just its contents) so
// it's ok to pass pointer to it
init_result = gtk_init_check( &argc_, &argv_ );
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
// update internal arg[cv] as GTK+ may have removed processed options:
this->argc = argc_;
this->argv = argv_;
if ( m_traits )
{
// if there are still GTK+ standard options unparsed in the command
// line, it means that they were not syntactically correct and GTK+
// already printed a warning on the command line and we should now
// exit:
wxArrayString opt, desc;
m_traits->GetStandardCmdLineOptions(opt, desc);
for ( i = 0; i < argc_; i++ )
{
// leave just the names of the options with values
const wxString str = wxString(argv_[i]).BeforeFirst('=');
for ( size_t j = 0; j < opt.size(); j++ )
{
// remove the leading spaces from the option string as it does
// have them
if ( opt[j].Trim(false).BeforeFirst('=') == str )
{
// a GTK+ option can be left on the command line only if
// there was an error in (or before, in another standard
// options) it, so abort, just as we do if incorrect
// program option is given
wxLogError(_("Invalid GTK+ command line option, use \"%s --help\""),
argv_[0]);
return false;
}
}
}
}
if ( !init_result )
{
wxLogError(_("Unable to initialize GTK+, is DISPLAY set properly?"));
return false;
}
// we can not enter threads before gtk_init is done
gdk_threads_enter();
#if wxUSE_INTL
wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif
// make sure GtkWidget type is loaded, idle hooks need it
g_type_class_ref(GTK_TYPE_WIDGET);
WakeUpIdle();
return true;
}
/* If handle is NULL, then this function assumes that we are in startup mode.
* In that case it will wait for a command from driver. If handle is not NULL,
* this this function will ask for permission with REQUEST-NEW-TAPE. */
static gboolean find_new_tape(taper_state_t * state, dump_info_t * dump) {
GThread * tape_search = NULL;
tape_search_request_t search_request;
gboolean use_threads;
struct cmdargs *cmdargs;
cmd_t cmd;
if (state->device != NULL) {
return TRUE;
}
/* We save the value here in case it changes while we're running. */
use_threads = g_thread_supported();
search_request.state = state;
search_request.prolong = TRUE;
search_request.errmsg = NULL;
if (use_threads) {
tape_search = g_thread_create(tape_search_thread,
&search_request, TRUE, NULL);
}
putresult(REQUEST_NEW_TAPE, "%s\n", dump->handle);
cmdargs = getcmd();
cmd = cmdargs->cmd;
switch (cmd) {
default:
g_fprintf(stderr, "taper: Got odd message from driver, expected NEW-TAPE or NO-NEW-TAPE.\n");
/* FALLTHROUGH. */
case NEW_TAPE: {
gboolean search_result;
if (use_threads) {
search_result = GPOINTER_TO_INT(g_thread_join(tape_search));
} else {
search_result =
GPOINTER_TO_INT(tape_search_thread(&search_request));
}
if (search_result) {
/* We don't say NEW_TAPE until we actually write the label. */
amfree(search_request.errmsg);
free_cmdargs(cmdargs);
return TRUE;
} else {
putresult(NO_NEW_TAPE, "%s\n", dump->handle);
log_taper_scan_errmsg(search_request.errmsg);
log_add(L_ERROR, "no-tape [%s]", "No more writable valid tape found");
free_cmdargs(cmdargs);
return FALSE;
}
}
case NO_NEW_TAPE:
search_request.prolong = FALSE;
if (use_threads) {
g_thread_join(tape_search);
}
log_add(L_ERROR, "no-tape [%s]", cmdargs->argv[1]);
state->last_errmsg = stralloc(cmdargs->argv[1]);
free_cmdargs(cmdargs);
return FALSE;
}
/* NOTREACHED */
}
/**********
* Name: create_browser
* Input: 'type' - either controller or url rendering tab
* 'tab_index' - which index
* 'create_new_tab_cb' - the call back function to create a new tab
* 'uri_entered_cb' - the call back function to help make a persistent window when you hit enter
* 'b_window' - double pointer to a browser_window type to get initialized
* 'comm_channel' - the channel of a particular tab to chatter on; full of FD's.
* Output: error description
* Function: Sets up the location of the browser window,
* allocates space for data etc., (building it if it's a CONTROLLER_TAB
* or making it the empty boring window for tabs), labels window pieces,
* and shows the end window result.
*/
int create_browser(tab_type t_type,
int tab_index,
void (*create_new_tab_cb)(void),
void (*uri_entered_cb)(void),
browser_window **b_window,
comm_channel comm_channel)
{
GtkWidget *window;
GtkWidget *table;
gtk_init(NULL, NULL);
if (!g_thread_supported ())
g_thread_init (NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
if(t_type == CONTROLLER_TAB)
table = gtk_table_new(2,4,FALSE);
else
table = gtk_table_new(2,1,FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
gtk_table_set_row_spacing(GTK_TABLE(table), 0, 20);
// Allocate space for browser-window to be passed to various callbacks.
*b_window = calloc(1, sizeof(browser_window));
(*b_window)->web_view = NULL;
(*b_window)->notebook = gtk_notebook_new ();
(*b_window)->tab_index = tab_index;
sprintf((*b_window)->tab_label, "Tab %d", tab_index);
memcpy((*b_window)->channel.parent_to_child_fd,
comm_channel.parent_to_child_fd,
2*sizeof(int));
memcpy((*b_window)->channel.child_to_parent_fd,
comm_channel.child_to_parent_fd,
2*sizeof(int));
gtk_notebook_set_tab_pos (GTK_NOTEBOOK ((*b_window)->notebook), GTK_POS_TOP);
gtk_table_attach_defaults (GTK_TABLE (table), (*b_window)->notebook, 0, 6, 1, 2);
gtk_widget_show ((*b_window)->notebook);
if(t_type == CONTROLLER_TAB)
{
gtk_window_set_title(GTK_WINDOW(window), "CONTROLLER-TAB");
GtkWidget* url_label = gtk_label_new("URL");
gtk_table_attach_defaults(GTK_TABLE(table), url_label, 0,1,0,1);
gtk_widget_show(url_label);
GtkWidget* uri_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table), uri_entry, 1, 2, 0, 1);
gtk_widget_show(uri_entry);
g_signal_connect (G_OBJECT (uri_entry), "activate", uri_entered_cb, *b_window);
(*b_window)->uri_entry = uri_entry;
GtkWidget* tab_label = gtk_label_new("Tab Number");
gtk_table_attach_defaults(GTK_TABLE(table), tab_label, 2,3,0,1);
gtk_widget_show(tab_label);
GtkWidget* tab_selector = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table), tab_selector, 3, 4, 0, 1);
gtk_widget_show(tab_selector);
//g_signal_connect (G_OBJECT (uri_entry), "activate", uri_entered_cb, *b_window);
(*b_window)->tab_selector = tab_selector;
}
else
{
gtk_window_set_title(GTK_WINDOW(window),"URL-RENDERING TAB");
(*b_window)->tab_selector = NULL;
(*b_window)->uri_entry = NULL;
}
if(t_type == CONTROLLER_TAB)
{
// Create "+" and "-" buttons (for adding and deleting new tabs)
// in CONTROLLER tab
create_add_remove_tab_button("+", G_CALLBACK(create_new_tab_cb), *b_window);
//create_add_remove_tab_button("-", G_CALLBACK(delete_tab_clicked_cb), *b_window);
}
else
{
// Create rendering window for ORDINARY tab
create_labeled_tab(*b_window);
}
g_signal_connect(G_OBJECT (window), "destroy",
G_CALLBACK(delete_window_cb), *b_window);
gtk_widget_show(table);
gtk_widget_show_all(window);
return 0;
}
int
main (int argc, char *argv[])
{
gchar *target_times = NULL;
gchar *ev_option = NULL;
gchar *fn_option = NULL;
GOptionEntry options[] = {
{"ev-compensation", '\0', 0, G_OPTION_ARG_STRING, &ev_option,
"EV compensation for source element GstPhotography interface", NULL},
{"aperture", '\0', 0, G_OPTION_ARG_INT, &aperture,
"Aperture (size of lens opening) for source element GstPhotography interface",
NULL},
{"flash-mode", '\0', 0, G_OPTION_ARG_INT,
&flash_mode,
"Flash mode for source element GstPhotography interface", NULL},
{"scene-mode", '\0', 0, G_OPTION_ARG_INT,
&scene_mode,
"Scene mode for source element GstPhotography interface", NULL},
{"exposure", '\0', 0, G_OPTION_ARG_INT64,
&exposure,
"Exposure time (in ms) for source element GstPhotography interface",
NULL},
{"iso-speed", '\0', 0, G_OPTION_ARG_INT,
&iso_speed,
"ISO speed for source element GstPhotography interface", NULL},
{"white-balance-mode", '\0', 0, G_OPTION_ARG_INT,
&wb_mode,
"White balance mode for source element GstPhotography interface", NULL},
{"colour-tone-mode", '\0', 0, G_OPTION_ARG_INT,
&color_mode,
"Colour tone mode for source element GstPhotography interface", NULL},
{"directory", '\0', 0, G_OPTION_ARG_STRING, &fn_option,
"Directory for capture file(s) (default is current directory)", NULL},
{"mode", '\0', 0, G_OPTION_ARG_INT, &mode,
"Capture mode (default = 1 (image), 2 = video)", NULL},
{"capture-time", '\0', 0, G_OPTION_ARG_INT,
&capture_time,
"Time to capture video in seconds (default = 10)", NULL},
{"capture-total", '\0', 0, G_OPTION_ARG_INT, &capture_total,
"Total number of captures to be done (default = 1)", NULL},
{"zoom", '\0', 0, G_OPTION_ARG_INT, &zoom,
"Zoom (100 = 1x (default), 200 = 2x etc.)", NULL},
{"wrapper-source", '\0', 0, G_OPTION_ARG_STRING, &wrappersrc_name,
"Camera source wrapper used for setting the video source (default is wrappercamerabinsrc)",
NULL},
{"video-source", '\0', 0, G_OPTION_ARG_STRING, &videosrc_name,
"Video source used in still capture and video recording", NULL},
{"video-device", '\0', 0, G_OPTION_ARG_STRING, &videodevice_name,
"Video device to be set on the video source", NULL},
{"audio-source", '\0', 0, G_OPTION_ARG_STRING, &audiosrc_name,
"Audio source used in video recording", NULL},
{"image-pp", '\0', 0, G_OPTION_ARG_STRING, &imagepp_name,
"List of image post-processing elements separated with comma", NULL},
{"viewfinder-sink", '\0', 0, G_OPTION_ARG_STRING, &vfsink_name,
"Viewfinder sink (default = fakesink)", NULL},
{"image-width", '\0', 0, G_OPTION_ARG_INT, &image_width,
"Width for image capture", NULL},
{"image-height", '\0', 0, G_OPTION_ARG_INT, &image_height,
"Height for image capture", NULL},
{"view-framerate-num", '\0', 0, G_OPTION_ARG_INT, &view_framerate_num,
"Framerate numerator for viewfinder", NULL},
{"view-framerate-den", '\0', 0, G_OPTION_ARG_INT, &view_framerate_den,
"Framerate denominator for viewfinder", NULL},
{"preview-caps", '\0', 0, G_OPTION_ARG_STRING, &preview_caps_name,
"Preview caps (e.g. video/x-raw-rgb,width=320,height=240)", NULL},
{"viewfinder-filter", '\0', 0, G_OPTION_ARG_STRING, &viewfinder_filter,
"Filter to process all frames going to viewfinder sink", NULL},
{"x-width", '\0', 0, G_OPTION_ARG_INT, &x_width,
"X window width (default = 320)", NULL},
{"x-height", '\0', 0, G_OPTION_ARG_INT, &x_height,
"X window height (default = 240)", NULL},
{"no-xwindow", '\0', 0, G_OPTION_ARG_NONE, &no_xwindow,
"Do not create XWindow", NULL},
{"encoding-target", '\0', 0, G_OPTION_ARG_STRING, &gep_targetname,
"Video encoding target name", NULL},
{"encoding-profile", '\0', 0, G_OPTION_ARG_STRING, &gep_profilename,
"Video encoding profile name", NULL},
{"encoding-profile-filename", '\0', 0, G_OPTION_ARG_STRING, &gep_filename,
"Video encoding profile filename", NULL},
{"image-capture-caps", '\0', 0,
G_OPTION_ARG_STRING, &image_capture_caps_str,
"Image capture caps (e.g. video/x-raw-rgb,width=640,height=480)", NULL},
{"viewfinder-caps", '\0', 0, G_OPTION_ARG_STRING,
&viewfinder_caps_str,
"Viewfinder caps (e.g. video/x-raw-rgb,width=640,height=480)", NULL},
{"video-capture-caps", '\0', 0,
G_OPTION_ARG_STRING, &video_capture_caps_str,
"Video capture caps (e.g. video/x-raw-rgb,width=640,height=480)", NULL},
{NULL}
};
GOptionContext *ctx;
GError *err = NULL;
if (!g_thread_supported ())
g_thread_init (NULL);
ctx = g_option_context_new ("\n\ncamerabin command line test application.");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
g_option_context_free (ctx);
GST_DEBUG_CATEGORY_INIT (camerabin_test, "camerabin-test", 0,
"camerabin test");
/* if we fail to create xwindow should we care? */
if (!no_xwindow)
create_host_window ();
/* FIXME: error handling */
if (ev_option != NULL)
ev_compensation = strtod (ev_option, (char **) NULL);
if (vfsink_name == NULL)
vfsink_name = g_strdup ("fakesink");
filename = g_string_new (fn_option);
if (filename->len == 0)
filename = g_string_append (filename, ".");
timer = g_timer_new ();
/* init */
if (setup_pipeline ()) {
loop = g_main_loop_new (NULL, FALSE);
g_idle_add ((GSourceFunc) run_pipeline, NULL);
g_main_loop_run (loop);
cleanup_pipeline ();
g_main_loop_unref (loop);
}
/* free */
g_string_free (filename, TRUE);
g_free (ev_option);
g_free (wrappersrc_name);
g_free (videosrc_name);
g_free (videodevice_name);
g_free (audiosrc_name);
g_free (imagepp_name);
g_free (vfsink_name);
g_free (target_times);
g_free (gep_targetname);
g_free (gep_profilename);
g_free (gep_filename);
g_timer_destroy (timer);
if (window)
XDestroyWindow (display, window);
if (display)
XCloseDisplay (display);
return 0;
}
int
main (int argc, char **argv)
{
GPtrArray *files;
gchar **args = NULL;
guint num, i;
GError *err = NULL;
GOptionContext *ctx;
GOptionEntry options[] = {
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &args, NULL},
{NULL}
};
GTimer *timer;
if (!g_thread_supported ())
g_thread_init (NULL);
ctx = g_option_context_new ("FILES OR DIRECTORIES WITH AUDIO FILES");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
exit (1);
}
g_option_context_free (ctx);
if (args == NULL || *args == NULL) {
g_print ("Please provide one or more directories with audio files\n\n");
return 1;
}
files = g_ptr_array_new ();
num = g_strv_length (args);
for (i = 0; i < num; ++i) {
if (g_path_is_absolute (args[i])) {
check_arg (files, args[i]);
} else {
g_warning ("Argument '%s' is not an absolute file path", args[i]);
}
}
if (files->len == 0) {
g_print ("Did not find any files\n\n");
return 1;
}
timer = g_timer_new ();
while (g_timer_elapsed (timer, NULL) < TEST_RUNTIME) {
gint32 idx;
idx = g_random_int_range (0, files->len);
play_file ((const gchar *) g_ptr_array_index (files, idx));
}
g_strfreev (args);
g_timer_destroy (timer);
return 0;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
if (mkdir(STATEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create state directory");
}
if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create storage directory");
}
umask(0077);
main_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
signal = setup_signalfd();
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, CONNMAN_SERVICE, &err);
if (conn == NULL) {
if (dbus_error_is_set(&err) == TRUE) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
__connman_log_init(argv[0], option_debug, option_detach,
option_backtrace, "Connection Manager", VERSION);
__connman_dbus_init(conn);
if (option_config == NULL)
config_init(CONFIGMAINFILE);
else
config_init(option_config);
__connman_inotify_init();
__connman_technology_init();
__connman_notifier_init();
__connman_agent_init();
__connman_service_init();
__connman_provider_init();
__connman_network_init();
__connman_device_init(option_device, option_nodevice);
__connman_ippool_init();
__connman_iptables_init();
__connman_firewall_init();
__connman_nat_init();
__connman_tethering_init();
__connman_counter_init();
__connman_manager_init();
__connman_config_init();
__connman_stats_init();
__connman_clock_init();
__connman_resolver_init(option_dnsproxy);
__connman_ipconfig_init();
__connman_rtnl_init();
__connman_task_init();
__connman_proxy_init();
__connman_detect_init();
__connman_session_init();
__connman_timeserver_init();
__connman_connection_init();
__connman_plugin_init(option_plugin, option_noplugin);
__connman_rtnl_start();
__connman_dhcp_init();
__connman_dhcpv6_init();
__connman_wpad_init();
__connman_wispr_init();
__connman_rfkill_init();
g_free(option_config);
g_free(option_device);
g_free(option_plugin);
g_free(option_nodevice);
g_free(option_noplugin);
#ifdef SYSTEMD
/* Tell systemd that we have started up */
if( option_systemd )
sd_notify(0, "READY=1");
#endif
g_main_loop_run(main_loop);
g_source_remove(signal);
__connman_rfkill_cleanup();
__connman_wispr_cleanup();
__connman_wpad_cleanup();
__connman_dhcpv6_cleanup();
__connman_dhcp_cleanup();
__connman_session_cleanup();
__connman_plugin_cleanup();
__connman_provider_cleanup();
__connman_connection_cleanup();
__connman_timeserver_cleanup();
__connman_detect_cleanup();
__connman_proxy_cleanup();
__connman_task_cleanup();
__connman_rtnl_cleanup();
__connman_resolver_cleanup();
__connman_clock_cleanup();
__connman_stats_cleanup();
__connman_config_cleanup();
__connman_manager_cleanup();
__connman_counter_cleanup();
__connman_tethering_cleanup();
__connman_nat_cleanup();
__connman_firewall_cleanup();
__connman_iptables_cleanup();
__connman_ippool_cleanup();
__connman_device_cleanup();
__connman_network_cleanup();
__connman_service_cleanup();
__connman_agent_cleanup();
__connman_ipconfig_cleanup();
__connman_notifier_cleanup();
__connman_technology_cleanup();
__connman_inotify_cleanup();
__connman_dbus_cleanup();
__connman_log_cleanup(option_backtrace);
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
if (connman_settings.pref_timeservers != NULL)
g_strfreev(connman_settings.pref_timeservers);
g_free(connman_settings.auto_connect);
g_free(connman_settings.preferred_techs);
g_strfreev(connman_settings.fallback_nameservers);
g_strfreev(connman_settings.blacklisted_interfaces);
g_strfreev(connman_settings.tethering_technologies);
g_free(option_debug);
return 0;
}
int AP_UnixApp::main(const char * szAppName, int argc, char ** argv)
{
// This is a static function.
if (!g_thread_supported ())
g_thread_init (NULL);
// initialize our application.
int exit_status = 0;
AP_UnixApp * pMyUnixApp = new AP_UnixApp(szAppName);
#ifdef WITH_CHAMPLAIN
gtk_clutter_init (&argc, &argv);
#endif
/* this brace is here to ensure that our local variables on the stack
* do not outlive the application object by giving them a lower scope
*/
{
XAP_Args XArgs = XAP_Args(argc, argv);
AP_Args Args = AP_Args(&XArgs, szAppName, pMyUnixApp);
#ifdef LOGFILE
UT_String sLogFile = pMyUnixApp->getUserPrivateDirectory();
sLogFile += "abiLogFile";
logfile = fopen(sLogFile.c_str(),"a+");
fprintf(logfile,"About to do gtk_set_locale \n");
fprintf(logfile,"New logfile \n");
#endif
// Step 1: Initialize GTK and create the APP.
// hack needed to intialize gtk before ::initialize
setlocale(LC_ALL, "");
gboolean have_display = gtk_init_check(&argc, &argv);
#ifdef LOGFILE
fprintf(logfile,"Got display %d \n",have_display);
fprintf(logfile,"Really display %d \n",have_display);
#endif
if (have_display > 0) {
Args.addOptions(gtk_get_option_group(TRUE));
Args.parseOptions();
}
else {
// no display, but we still need to at least parse our own arguments, damnit, for --to, --to-png, and --print
Args.addOptions(gtk_get_option_group(FALSE));
Args.parseOptions();
}
// if the initialize fails, we don't have icons, fonts, etc.
if (!pMyUnixApp->initialize(have_display))
{
delete pMyUnixApp;
return -1; // make this something standard?
}
// Setup signal handlers, primarily for segfault
// If we segfaulted before here, we *really* blew it
struct sigaction sa;
sa.sa_handler = signalWrapper;
sigfillset(&sa.sa_mask); // We don't want to hear about other signals
sigdelset(&sa.sa_mask, SIGABRT); // But we will call abort(), so we can't ignore that
#if defined (SA_NODEFER) && defined (SA_RESETHAND)
sa.sa_flags = SA_NODEFER | SA_RESETHAND; // Don't handle nested signals
#else
sa.sa_flags = 0;
#endif
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
sigaction(SIGILL, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGFPE, &sa, NULL);
// TODO: handle SIGABRT
// Step 2: Handle all non-window args.
bool windowlessArgsWereSuccessful = true;
if (!Args.doWindowlessArgs(windowlessArgsWereSuccessful )) {
delete pMyUnixApp;
return (windowlessArgsWereSuccessful ? 0 : -1);
}
if (have_display) {
// Step 3: Create windows as appropriate.
// if some args are botched, it returns false and we should
// continue out the door.
// We used to check for bShowApp here. It shouldn't be needed
// anymore, because doWindowlessArgs was supposed to bail already. -PL
if (pMyUnixApp->openCmdLineFiles(&Args))
{
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
s_bInitDone = true;
pMyUnixApp->processStartupQueue();
#endif
// turn over control to gtk
gtk_main();
}
else
{
UT_DEBUGMSG(("DOM: not parsing command line or showing app\n"));
}
}
else {
fprintf(stderr, "No DISPLAY: this may not be what you want.\n");
exit_status = 1;
}
// unload all loaded plugins (remove some of the memory leaks shown at shutdown :-)
XAP_ModuleManager::instance().unloadAllPlugins();
// Step 4: Destroy the App. It should take care of deleting all frames.
pMyUnixApp->shutdown();
}
delete pMyUnixApp;
return exit_status;
}
int
main (int argc, char* argv[]) {
gtk_init (&argc, &argv);
if (!g_thread_supported ())
g_thread_init (NULL);
printf("Uzbl start location: %s\n", argv[0]);
strcpy(executable_path,argv[0]);
strcat ((char *) XDG_CONFIG_HOME_default, getenv ("HOME"));
strcat ((char *) XDG_CONFIG_HOME_default, "/.config");
GError *error = NULL;
GOptionContext* context = g_option_context_new ("- some stuff here maybe someday");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, &error);
/* initialize hash table */
bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free_action);
soup_session = webkit_get_default_session();
keycmd = g_string_new("");
settings_init ();
commands_hash ();
if (always_insert_mode)
insert_mode = TRUE;
GtkWidget* vbox = gtk_vbox_new (FALSE, 0);
if (status_top)
gtk_box_pack_start (GTK_BOX (vbox), create_mainbar (), FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), create_browser (), TRUE, TRUE, 0);
if (!status_top)
gtk_box_pack_start (GTK_BOX (vbox), create_mainbar (), FALSE, TRUE, 0);
main_window = create_window ();
gtk_container_add (GTK_CONTAINER (main_window), vbox);
load_uri (web_view, uri);
gtk_widget_grab_focus (GTK_WIDGET (web_view));
gtk_widget_show_all (main_window);
xwin = GDK_WINDOW_XID (GTK_WIDGET (main_window)->window);
printf("window_id %i\n",(int) xwin);
printf("pid %i\n", getpid ());
printf("name: %s\n", instance_name);
scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL);
bar_v = gtk_range_get_adjustment((GtkRange*) scbar_v);
scbar_h = (GtkScrollbar*) gtk_hscrollbar_new (NULL);
bar_h = gtk_range_get_adjustment((GtkRange*) scbar_h);
gtk_widget_set_scroll_adjustments ((GtkWidget*) web_view, bar_h, bar_v);
if (!show_status)
gtk_widget_hide(mainbar);
if (fifo_dir)
create_fifo ();
if (socket_dir)
create_socket();
gtk_main ();
g_string_free(keycmd, TRUE);
if (fifo_dir)
unlink (fifo_path);
if (socket_dir)
unlink (socket_path);
g_hash_table_destroy(bindings);
g_hash_table_destroy(commands);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
guint watch;
struct sigaction sa;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
main_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
if (conn == NULL) {
if (dbus_error_is_set(&err) == TRUE) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sig_term;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
ofono_connect, ofono_disconnect, NULL, NULL);
g_main_loop_run(main_loop);
g_dbus_remove_watch(conn, watch);
if (ofono_running == TRUE)
ofono_disconnect(conn, NULL);
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
return 0;
}
int main(int argc, char **argv)
{
if (initDecoderWithFile(filename))
return -1;
init_queue(&video_pkt_queue); //初始化视频数据包队列
init_queue(&video_pic_queue); //初始化视频图像队列
init_queue(&audio_pkt_queue);
init_queue(&audio_sam_queue);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//设置线程分离属性
//文件处理线程
if (0 != pthread_create(&file_tid, &attr, demux, (void*)filename))
printf("create file handler thread failed!\n");
//视频解码线程
if (0 != pthread_create(&dec_tid, &attr, video_decoder, NULL))
printf("create decode thread failed!\n");
if (0 != pthread_create(&audio_dec_tid, &attr, audio_decoder, NULL))
printf("create audio decode thread failed!\n");
if (0 != pthread_create(&audio_render_tid, &attr, audio_player, NULL))
printf("create audio render thread failed!\n");
/*以下是Gtk界面相关代码*/
if (!g_thread_supported())
g_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
GtkWidget *main_win;//主窗口
//GtkWidget *drawable;//图像绘制区域
gtk_init(&argc, &argv);
char win_title[100];
sprintf(win_title, "AniPlayer--by Excalibur : %s", filename);
main_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_win), win_title);
GtkWidget *drawable = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(main_win), drawable);
g_signal_connect(G_OBJECT(main_win), "delete-event", G_CALLBACK(exit_clean), NULL);
//gtk_signal_connect(GTK_OBJECT(drawable), "expose-event", G_CALLBACK(on_darea_expose), NULL);
gtk_widget_show_all(main_win);
gtk_widget_set_size_request(drawable, g_player_ctx->width, g_player_ctx->height);
//关闭自动刷新和双缓冲
gtk_widget_set_app_paintable(drawable, TRUE);
gtk_widget_set_double_buffered(drawable, FALSE);//此乃大坑，之前没disable掉一直刷白屏
time_out = gtk_timeout_add(40, GSourceFunc(on_timer), drawable);
gtk_main();
gdk_threads_leave();
_CrtDumpMemoryLeaks();
//getchar();
return 0;
}
