extern gboolean button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
struct view_s* v = data;
int y = event->y;
int x = event->x;
int x2 = x / v->xzoom;
int y2 = y / v->yzoom;
if (event->button == GDK_BUTTON_SECONDARY) {
v->pos[v->xdim] = x2;
v->pos[v->ydim] = y2;
gtk_adjustment_set_value(v->gtk_posall[v->xdim], x2);
gtk_adjustment_set_value(v->gtk_posall[v->ydim], y2);
update_status_bar(v, x2, y2);
for (struct view_s* v2 = v->next; v2 != v; v2 = v2->next) {
if (v->sync && v2->sync) {
gtk_adjustment_set_value(v2->gtk_posall[v->xdim], x2);
gtk_adjustment_set_value(v2->gtk_posall[v->ydim], y2);
update_status_bar(v2, x2, y2);
}
}
}
return FALSE;
}
// this thread works in a fire-and-forget fashion, it's started and then just runs
static DWORD WINAPI read_named_pipe(void *opaque) {
const char *pipe_name = "\\\\.\\pipe\\tinkerforge-brick-daemon-debug-log";
HANDLE hpipe;
DWORD mode = PIPE_READMODE_MESSAGE;
LogPipeMessage pipe_message;
DWORD bytes_read;
(void)opaque;
append_debug_meta_message("Connecting to Brick Daemon...");
for (;;) {
_debug_connected = 0;
update_status_bar();
for (;;) {
hpipe = CreateFile(pipe_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hpipe != INVALID_HANDLE_VALUE) {
break;
}
Sleep(250);
}
if (!SetNamedPipeHandleState(hpipe, &mode, NULL, NULL)) {
CloseHandle(hpipe);
continue;
}
_debug_connected = 1;
update_status_bar();
append_debug_meta_message("Connected to Brick Daemon");
for (;;) {
if (!ReadFile(hpipe, &pipe_message, sizeof(pipe_message), &bytes_read, NULL)) {
append_debug_meta_message("Disconnected from Brick Daemon, reconnecting...");
CloseHandle(hpipe);
break;
}
if (bytes_read == sizeof(pipe_message) && pipe_message.length == sizeof(pipe_message)) {
// enforce that strings are NUL-terminated
pipe_message.file[sizeof(pipe_message.file) - 1] = '\0';
pipe_message.function[sizeof(pipe_message.function) - 1] = '\0';
pipe_message.message[sizeof(pipe_message.message) - 1] = '\0';
append_debug_pipe_message(&pipe_message);
}
}
}
return 0;
}
/**
* @brief Creates a status bar in the map view.
*
* The status bar is not made with Qt designer because
* one cannot create QStatusBar widgets with Qt designer.
*/
void MapEditor::build_status_bar() {
status_bar = new QStatusBar();
ui.entity_creation_layout->addWidget(status_bar);
connect(ui.map_view, SIGNAL(mouse_map_coordinates_changed(QPoint)),
this, SLOT(update_status_bar()));
connect(ui.map_view, SIGNAL(mouse_left()),
this, SLOT(update_status_bar()));
}
void GUI_NextFrame(uint32_t frameCount)
{
// uint8_t *ptr;
uint32_t flags;
if (playing)
return;
if( avifileinfo && curframe + frameCount >= avifileinfo->nb_frames )
return;
if (avifileinfo)
{
uint32_t newframe = curframe + frameCount;
if( !GUI_getFrame(newframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode next frame."));
}
else
{
curframe = newframe;
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
}
//_____________________________________________________________
int GUI_GoToFrame(uint32_t frame)
{
uint32_t flags;
if (playing)
return 0;
if (!avifileinfo)
return 0;
if(frame>=avifileinfo->nb_frames) return 0;
if( !GUI_getFrame(frame ,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode the frame."));
return 0;
}
curframe = frame;
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
return 1;
}
static gboolean
on_scroll_notify (GtkWidget *widget, GdkEventScroll *event, void *user_data)
{
Viewer *self = (Viewer*) user_data;
gtku_gl_drawing_area_set_context (self->gl_area);
double ray_start[3];
double ray_dir[3];
_window_coord_to_ray (event->x, widget->allocation.height - event->y, ray_start, ray_dir);
// give picking handler first dibs
int consumed = 0;
if (self->picking_handler && !self->picking_handler->picking)
self->picking_handler = NULL;
if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->mouse_scroll) {
consumed = self->picking_handler->mouse_scroll(self, self->picking_handler, ray_start, ray_dir, event);
update_status_bar(self);
}
// try all the other handlers in order of priority
for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) {
EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx);
if (handler != self->picking_handler && handler->enabled && handler->mouse_scroll)
if (handler->mouse_scroll(self, handler, ray_start, ray_dir, event))
break;
}
return TRUE;
}
void GUI_PreviousKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getPKFrame(&f)&&curframe)
{
return;
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode keyframe."));
}
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
};
//_____________________________________________________________
void GUI_NextKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getNKFrame(&f))
//if( !GUI_getFrameNKF(&f ,rdr_decomp_buffer))
{
// GUI_Error_HIG("Decompressing error", NULL);
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode keyframe."));
}
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
}
void GUI_NextFrame(void)
{
// uint8_t *ptr;
uint32_t flags;
if (playing)
return;
if( avifileinfo && curframe + 1 == avifileinfo->nb_frames )
return;
if (avifileinfo)
{
if( !GUI_getFrame(curframe + 1,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error NF");
}
else
{
curframe++;
if(mode_preview)
editorUpdatePreview( curframe) ;
renderUpdateImage(rdr_decomp_buffer->data);
update_status_bar(rdr_decomp_buffer);
UI_purge();
}
}
}
static gint
on_main_window_key_press_event (GtkWidget *widget, GdkEventKey *event,
void *user)
{
Viewer *self = (Viewer*) user;
// give picking handler first dibs
int consumed = 0;
if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->picking &&
self->picking_handler->key_press) {
consumed = self->picking_handler->key_press(self, self->picking_handler, event);
update_status_bar(self);
}
// try all the other handlers in order of priority
for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) {
EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx);
if (handler != self->picking_handler && handler->enabled && handler->key_press) {
consumed = handler->key_press(self, handler, event);
if (consumed)
break;
}
}
return consumed;
}
//_____________________________________________________________
int GUI_GoToFrame(uint32_t frame)
{
uint32_t flags;
if (playing)
return 0;
if (!avifileinfo)
return 0;
if( !GUI_getFrame(frame ,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error GF");
return 0;
}
curframe = frame;
renderUpdateImage(rdr_decomp_buffer->data);
if(mode_preview)
editorUpdatePreview( curframe);
update_status_bar(rdr_decomp_buffer);
UI_purge();
return 1;
}
void GUI_NextPrevBlackFrame(int dir)
{
uint32_t f;
uint32_t flags;
uint16_t reresh_count=0;
if (playing)
return;
if (! avifileinfo)
return;
const int darkness=40;
DIA_working *work=new DIA_working("Seeking");
while(1)
{
f=curframe+dir;
if(work->update(1)) break;
if((f==0 && dir==-1)|| (f==avifileinfo->nb_frames-1&&dir==1)) break;
if( !video_body->getUncompressedFrame(f ,rdr_decomp_buffer,&flags))
{
curframe=0;
video_body->getUncompressedFrame(0 ,rdr_decomp_buffer);
break;
}
curframe=f;
if(!fastIsNotBlack(darkness)) break;
reresh_count++;
if(reresh_count>100)
{
update_status_bar(rdr_decomp_buffer);
reresh_count=0;
}
}
delete work;
renderUpdateImage(rdr_decomp_buffer->data);
if(mode_preview)
editorUpdatePreview( curframe) ;
update_status_bar(rdr_decomp_buffer);
return ;
}
gboolean restore_status_bar(gpointer data)
{
struct con_win *cwin = data;
update_status_bar(cwin);
return FALSE;
}
static gboolean
on_motion_notify (GtkWidget *widget, GdkEventMotion *event, void *user_data)
{
Viewer *self = (Viewer*) user_data;
gtku_gl_drawing_area_set_context (self->gl_area);
double ray_start[3];
double ray_dir[3];
_window_coord_to_ray (event->x, widget->allocation.height - event->y, ray_start, ray_dir);
// is anyone hovering?
if (self->picking_handler == NULL || !self->picking_handler->picking) {
// find a new hover?
double best_distance = HUGE;
EventHandler *best_handler = NULL;
for (unsigned int eidx = 0; eidx < g_ptr_array_size(self->event_handlers); eidx++) {
EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx);
handler->hovering = 0;
if (handler->enabled && handler->hover_query) {
double this_distance = handler->hover_query(self, handler, ray_start, ray_dir);
if (this_distance < best_distance && this_distance >= 0) {
best_distance = this_distance;
best_handler = handler;
}
}
}
// notify the new handler
if (best_handler)
best_handler->hovering = 1;
viewer_request_redraw(self);
}
// give picking handler first dibs
int consumed = 0;
if (self->picking_handler && !self->picking_handler->picking)
self->picking_handler = NULL;
if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->mouse_motion) {
consumed = self->picking_handler->mouse_motion(self, self->picking_handler, ray_start, ray_dir, event);
update_status_bar(self);
}
// try all the other handlers in order of priority
for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) {
EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx);
if (handler != self->picking_handler && handler->enabled && handler->mouse_motion)
if (handler->mouse_motion(self, handler, ray_start, ray_dir, event))
break;
}
return TRUE;
}
void on_ui_chmfile_html_link_message_notify(ChmSee* self, GParamSpec* pspec, ChmseeUiChmfile* ui_chmfile) {
gchar* link_message;
g_object_get(ui_chmfile,
"link-message", &link_message,
NULL);
update_status_bar(self, link_message);
g_free(link_message);
}
static gboolean
on_gl_configure (GtkWidget *widget, GdkEventConfigure *event, void* user_data)
{
Viewer * self = (Viewer *) user_data;
update_status_bar(self); // redraw our window size
viewer_request_redraw (self);
return TRUE;
}
void
cur_proj_set (GttProject *proj)
{
/* Due to the way the widget callbacks work,
* we may be called recursively ... */
if (cur_proj == proj) return;
log_proj(NULL);
gtt_project_timer_stop (cur_proj);
gtt_status_icon_stop_timer (proj);
run_shell_command (cur_proj, FALSE);
GttProject *old_prj = cur_proj;
if (proj)
{
if (timer_is_running ())
{
stop_main_timer ();
}
cur_proj = proj;
gtt_project_timer_start (proj);
gtt_status_icon_start_timer (proj);
run_shell_command (cur_proj, TRUE);
start_idle_timer ();
start_main_timer ();
}
else
{
if (timer_is_running ())
{
stop_main_timer ();
}
cur_proj = NULL;
start_no_project_timer ();
}
log_proj(proj);
if (old_prj)
{
gtt_projects_tree_update_project_data (projects_tree, old_prj);
}
if (cur_proj)
{
gtt_projects_tree_update_project_data (projects_tree, cur_proj);
}
/* update GUI elements */
menu_set_states();
toolbar_set_states();
if (proj)
{
prop_dialog_set_project(proj);
notes_area_set_project (global_na, proj);
}
update_status_bar();
}
int viewer_request_pick(Viewer *viewer, EventHandler *ehandler)
{
if (viewer_picking(viewer) && viewer->picking_handler != ehandler)
return -1;
ehandler->picking = 1;
viewer->picking_handler = ehandler;
update_status_bar(viewer);
return 0;
}
void viewer_set_status_bar_message (Viewer *viewer, const char *fmt, ...)
{
char buf[1024];
va_list ap;
va_start (ap, fmt);
vsnprintf (buf, sizeof (buf), fmt, ap);
va_end (ap);
if (viewer->status_bar_message)
free(viewer->status_bar_message);
viewer->status_bar_message = strdup(buf);
update_status_bar(viewer);
}
static void set_current_list_view(HWND list_view) {
if (_current_list_view != NULL) {
ShowWindow(_current_list_view, SW_HIDE);
}
_current_list_view = list_view;
set_view_menu_item_state(ID_VIEW_EVENT, list_view == _event_list_view ? MFS_CHECKED : MFS_UNCHECKED);
set_view_menu_item_state(ID_VIEW_DEBUG, list_view == _debug_list_view ? MFS_CHECKED : MFS_UNCHECKED);
ShowWindow(_current_list_view, SW_SHOW);
SetFocus(_current_list_view);
UpdateWindow(_current_list_view);
update_status_bar();
}
static gint
main_timer_func(gpointer data)
{
/* Wake up the notes area GUI, if needed. */
gtt_notes_timer_callback (global_na);
gtt_diary_timer_callback (NULL);
if (!cur_proj)
{
main_timer = 0;
return 0;
}
/* Update the data in the data engine. */
gtt_project_timer_update (cur_proj);
gtt_projects_tree_update_project_data (projects_tree, cur_proj);
update_status_bar ();
return 1;
}
// force_map_redraw: Forces the map area to be redrawn
// ------------------------------------------------ >>
void force_map_redraw(bool map, bool grid)
{
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(map_area);
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
return;
if (grid)
update_grid();
if (map)
update_map();
gdk_gl_drawable_gl_end(gldrawable);
gdk_window_invalidate_rect(map_area->window, &map_area->allocation, false);
update_status_bar();
//render_map();
}
void clock_speed_cb(GtkWidget *item, GtkWindow *window)
{
GtkWidget *dialog;
GtkWidget *spin_button;
int result;
dialog = gtk_dialog_new_with_buttons("Clock Speed", window,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
spin_button = create_clock_speed_dialog(dialog);
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT)
clock_speed = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin_button));
update_status_bar();
gtk_widget_destroy(dialog);
}
//_____________________________________________________________
void GUI_NextKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getNKFrame(&f))
//if( !GUI_getFrameNKF(&f ,rdr_decomp_buffer))
{
// GUI_Alert("Decompressing Error");
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error NKF");
}
renderUpdateImage(rdr_decomp_buffer->data);
if(mode_preview)
editorUpdatePreview( curframe) ;
update_status_bar(rdr_decomp_buffer);
UI_purge();
}
}
}
static void
populate_window(ChmSee *self)
{
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GladeXML *glade;
glade = glade_xml_new(get_resource_path(GLADE_FILE), "main_vbox", NULL);
if (glade == NULL) {
g_error("Cannot find glade file!");
exit(1);
}
g_object_set_data(G_OBJECT (self), "glade", glade);
GtkWidget *main_vbox;
main_vbox = get_widget(self, "main_vbox");
gtk_container_add(GTK_CONTAINER (self), vbox);
GtkActionGroup* action_group = gtk_action_group_new ("MenuActions");
selfp->action_group = action_group;
gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), self);
gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), self);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "NewTab"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "CloseTab"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Home"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Back"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Forward"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "SidePane"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomIn"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomOut"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomReset"), FALSE);
GtkUIManager* ui_manager = gtk_ui_manager_new ();
selfp->ui_manager = ui_manager;
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
GtkAccelGroup* accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (self), accel_group);
GError* error = NULL;
if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, &error))
{
g_message ("building menus failed: %s", error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
GtkWidget* menubar = gtk_handle_box_new();
selfp->menubar = menubar;
gtk_container_add(GTK_CONTAINER(menubar), gtk_ui_manager_get_widget (ui_manager, "/MainMenu"));
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
GtkWidget* toolbar = gtk_handle_box_new();
selfp->toolbar = toolbar;
gtk_container_add(GTK_CONTAINER(toolbar), gtk_ui_manager_get_widget(ui_manager, "/toolbar"));
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
GtkWidget* ui_chmfile = chmsee_ui_chmfile_new();
selfp->ui_chmfile = ui_chmfile;
gtk_box_pack_start(GTK_BOX(vbox), ui_chmfile, TRUE, TRUE, 0);
gtk_container_set_focus_child(GTK_CONTAINER(vbox), ui_chmfile);
g_signal_connect_swapped(ui_chmfile,
"model_changed",
G_CALLBACK(on_ui_chmfile_model_changed),
self);
g_signal_connect_swapped(ui_chmfile,
"html_changed",
G_CALLBACK(on_ui_chmfile_html_changed),
self);
g_signal_connect_swapped(ui_chmfile,
"notify::link-message",
G_CALLBACK(on_ui_chmfile_html_link_message_notify),
self);
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(gtk_ui_manager_get_widget(ui_manager, "/toolbar/sidepane")),
gtk_image_new_from_file(get_resource_path("show-pane.png")));
gtk_box_pack_start (GTK_BOX (vbox), main_vbox, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
accel_group = g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW (self), accel_group);
/* status bar */
selfp->statusbar = glade_xml_get_widget(glade, "statusbar");
selfp->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (selfp->statusbar),
"default");
update_status_bar(self, _("Ready!"));
}
uint8_t A_ListAllBlackFrames(char *name)
{
// Print a list of all black frames
//_____________________________________________________________
uint32_t f;
uint32_t flags;
uint32_t startframe;
uint16_t mm,hh,ss,ms;
uint16_t reresh_count=0;
char *outfile;
FILE *fd;
outfile=name;
if ( playing )
return 0;
if ( !avifileinfo )
return 0;
if ( !outfile )
return 0;
fd=fopen(outfile, "wb");
if ( fd == NULL )
{
fprintf(stderr, "cannot create output file for list of black frames\n");
return 0;
}
const int darkness=40;
startframe=curframe;
DIA_working *work=new DIA_working("Finding black frames");
printf("\n** Listing all black frames **\n");
for (f=0; f<avifileinfo->nb_frames; f++) {
if( work->update( 100 * f / avifileinfo->nb_frames ) )
break;
if ( !video_body->getUncompressedFrame(f,rdr_decomp_buffer,&flags) ) {
curframe=0;
video_body->getUncompressedFrame(0,rdr_decomp_buffer);
break;
}
curframe=f;
if ( !fastIsNotBlack(darkness) ) {
frame2time(curframe,avifileinfo->fps1000,&hh,&mm,&ss,&ms);
printf("\tBlack frame: frame %d time %02d:%02d:%02d.%03d\n", curframe, hh, mm, ss, ms);
fprintf(fd, "\tBlack frame: frame %d time %02d:%02d:%02d.%03d\n", curframe, hh, mm, ss, ms);
}
reresh_count++;
if(reresh_count>100)
{
update_status_bar(rdr_decomp_buffer);
reresh_count=0;
}
}
printf("** done **\n\n");
fclose(fd);
delete work;
curframe=startframe;
if ( !video_body->getUncompressedFrame(curframe,rdr_decomp_buffer,&flags) ) {
curframe=0;
video_body->getUncompressedFrame(0,rdr_decomp_buffer);
}
renderUpdateImage(rdr_decomp_buffer->data);
if ( mode_preview )
editorUpdatePreview( curframe );
update_status_bar(rdr_decomp_buffer);
return 1;
}
// this thread works in a fire-and-forget fashion, it's started and then just runs
static DWORD WINAPI read_named_pipe(void *opaque) {
const char *pipe_name = "\\\\.\\pipe\\tinkerforge-brick-daemon-debug-log";
HANDLE hpipe;
DWORD current_error;
DWORD last_error;
LogPipeMessage pipe_message;
DWORD bytes_read;
char buffer[256];
(void)opaque;
append_debug_meta_message("Connecting to Brick Daemon...");
for (;;) {
_debug_connected = 0;
last_error = ERROR_SUCCESS;
update_status_bar();
for (;;) {
hpipe = CreateFile(pipe_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hpipe != INVALID_HANDLE_VALUE) {
break;
}
current_error = GetLastError();
if (current_error != last_error && current_error != ERROR_FILE_NOT_FOUND) {
_snprintf(buffer, sizeof(buffer), "Error while connecting to Brick Daemon, trying again: %s (%d)",
get_error_name(current_error), current_error);
append_debug_meta_message(buffer);
}
last_error = current_error;
Sleep(1000);
}
_debug_connected = 1;
update_status_bar();
append_debug_meta_message("Connected to Brick Daemon");
for (;;) {
if (!ReadFile(hpipe, &pipe_message, sizeof(pipe_message), &bytes_read, NULL)) {
append_debug_meta_message("Disconnected from Brick Daemon, reconnecting...");
CloseHandle(hpipe);
break;
}
if (bytes_read == sizeof(pipe_message) &&
pipe_message.length == sizeof(pipe_message)) {
// enforce that strings are NUL-terminated
pipe_message.source[sizeof(pipe_message.source) - 1] = '\0';
pipe_message.message[sizeof(pipe_message.message) - 1] = '\0';
append_debug_pipe_message(&pipe_message);
}
}
}
}
//static uint8_t Vbuffer[7.0*5.6*3];
//AVDMGenericVideoStream *getFirstVideoFilter( void)
//
//_____________________________________________________________
void GUI_PlayAvi(bool forceStop)
{
uint32_t time_e, time_a = 0;
uint32_t err = 0, acc = 0;
uint32_t max;
uint32_t framelen,flags;
AVDMGenericVideoStream *filter;
vids = 0, auds = 0, dauds = 0;
// check we got everything...
if (!avifileinfo)
return;
if((curframe+1)>= avifileinfo->nb_frames-1)
{
printf("No frame left\n");
return;
}
if (avifileinfo->fps1000 == 0)
return;
if (playing || forceStop)
{
stop_req = 1;
return;
}
uint32_t priorityLevel;
originalPriority = getpriority(PRIO_PROCESS, 0);
prefs->get(PRIORITY_PLAYBACK,&priorityLevel);
setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel));
uint32_t played_frame=0;
uint32_t remaining=avifileinfo->nb_frames-curframe;
if(getPreviewMode()==ADM_PREVIEW_OUTPUT)
{
filter=getLastVideoFilter(curframe,remaining);
}
else
{
filter=getFirstVideoFilter(curframe,remaining );
}
max=filter->getInfo()->nb_frames;
// compute how much a frame lasts in ms
one_frame = (uint32_t) floor(1000.*1000.*10. / filter->getInfo()->fps1000);
err = one_frame % 10;
one_frame /= 10; // Duration of a frame in ms, err =leftover in 1/10 ms
// go to RealTime...
printf("One frame : %lu, err=%lu ms\n", one_frame, err);
// prepare 1st frame
stop_req = 0;
playing = 1;
#ifdef HAVE_AUDIO
ComputePreload();
#endif
//renderStartPlaying();
// reset timer reference
resetTime();
admPreview::deferDisplay(1,curframe);
admPreview::update(played_frame);
do
{
vids++;
admPreview::displayNow(played_frame);;
update_status_bar();
if (time_a == 0)
time_a = getTime(0);
// mark !
//printf("\n Rendering %lu frame\n",curframe);
// read frame in chunk
if((played_frame)>=(max-1))
{
printf("\nEnd met (%lu / %lu )\n",played_frame,max);
goto abort_play;
}
admPreview::update(played_frame+1);;
curframe++;
played_frame++;
#ifdef HAVE_AUDIO
FillAudio();
#endif
time_e = getTime(1);
acc += err;
if (acc > 10)
{
acc -= 10;
time_a++;
}
time_a += one_frame;
// delta a is next frame time
// time is is current time
delta = time_a - time_e;
if (delta <= 0)
{
//if(delta<-19) // allow 19 ms late without warning...
// tick seems to be ~ 18 ms
//printf("\n Late ....,due : %lu ms / found : %lu \n",
// time_a,time_e);
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
} else
{
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
if (delta > 10)
GUI_Sleep(delta - 10);
}
//
UI_purge();
if(getPreviewMode()==ADM_PREVIEW_SEPARATE )
{
UI_purge();
UI_purge();
}
}
while (!stop_req);
abort_play:
// ___________________________________
// Flush buffer
// go back to normal display mode
//____________________________________
playing = 0;
getFirstVideoFilter( );
admPreview::deferDisplay(0,0);
UI_purge();
// Updated by expose ?
admPreview::update(curframe);
UI_purge();
update_status_bar();
#ifdef HAVE_AUDIO
if (currentaudiostream)
{
if (wavbuf)
ADM_dealloc(wavbuf);
deleteAudioFilter(NULL);
currentaudiostream->endDecompress();
AVDM_AudioClose();
}
#endif
// done.
setpriority(PRIO_PROCESS, 0, originalPriority);
};
void GUI_NextPrevBlackFrame(int dir)
{
uint32_t f;
uint32_t flags;
uint16_t reresh_count=0;
uint32_t orgFrame;
uint32_t r=1;
if (playing)
return;
if (! avifileinfo)
return;
ADMImage *buffer=admPreview::getBuffer();
if(!buffer) return;
const int darkness=40;
DIA_working *work=new DIA_working(QT_TR_NOOP("Seeking"));
orgFrame=curframe;
int total;
// Avoid it being 0
if(dir==1) total=avifileinfo->nb_frames-curframe+1;
else total=curframe+1;
while(1)
{
int current=abs(curframe-orgFrame);
f=curframe+dir;
if(work->update(current,total)) break;
if((f==0 && dir==-1)|| (f==avifileinfo->nb_frames-1&&dir==1)) break;
if( !video_body->getUncompressedFrame(f ,buffer,&flags))
{
r=0;
break;
}
if(!work->isAlive())
{
r=0;
break;
}
curframe=f;
if(!fastIsNotBlack(darkness,buffer)) break;
reresh_count++;
if(reresh_count>100)
{
update_status_bar();
reresh_count=0;
}
}
delete work;
if(!r)
{
curframe=orgFrame;
}
admPreview::update( curframe) ;
update_status_bar();
return ;
}
/**
\fn A_ListAllBlackFrames
\brief Scan for all black frames and output that in a separate (text) file
*/
uint8_t A_ListAllBlackFrames(char *name)
{
uint32_t f;
uint32_t flags;
uint32_t startframe;
uint16_t mm,hh,ss,ms;
uint16_t reresh_count=0;
char *outfile;
FILE *fd;
outfile=name;
if ( playing )
return 0;
if ( !avifileinfo )
return 0;
ADMImage *buffer=admPreview::getBuffer();
if(!buffer) return 0;
if ( !outfile )
return 0;
fd=fopen(outfile, "wb");
if ( fd == NULL )
{
fprintf(stderr, "cannot create output file for list of black frames\n");
return 0;
}
const int darkness=40;
startframe=curframe;
DIA_working *work=new DIA_working(QT_TR_NOOP("Finding black frames"));
printf("\n** Listing all black frames **\n");
for (f=0; f<avifileinfo->nb_frames; f++) {
if( work->update( 100 * f / avifileinfo->nb_frames ) )
break;
if ( !video_body->getUncompressedFrame(f,buffer,&flags) )
{
break;
}
curframe=f;
if ( !fastIsNotBlack(darkness,buffer) )
{
frame2time(curframe,avifileinfo->fps1000,&hh,&mm,&ss,&ms);
printf("\tBlack frame: frame %d time %02d:%02d:%02d.%03d\n", curframe, hh, mm, ss, ms);
fprintf(fd, "\tBlack frame: frame %d time %02d:%02d:%02d.%03d\n", curframe, hh, mm, ss, ms);
}
reresh_count++;
if(reresh_count>100)
{
update_status_bar();
reresh_count=0;
}
}
printf("** done **\n\n");
fclose(fd);
delete work;
GUI_GoToFrame(startframe);
return 1;
}
