2 * omnplay.c -- GTK+ 2 omnplay
3 * Copyright (C) 2011 Maksym Veremeyenko <verem@m1stereo.tv>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software Foundation,
17 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
32 #include <gdk/gdkkeysyms.h>
40 #include "omplrclnt.h"
42 static gboolean
on_main_window_delete_event( GtkWidget
*widget
, GdkEvent
*event
, gpointer user_data
)
48 omnplay_instance_t
* omnplay_create(int argc
, char** argv
)
51 omnplay_instance_t
* app
;
53 /* prepare application instance */
54 app
= (omnplay_instance_t
*)malloc(sizeof(omnplay_instance_t
));
55 memset(app
, 0, sizeof(omnplay_instance_t
));
57 /* load parameters from command line */
58 if(!omnplay_opt(argc
, argv
, app
) && app
->players
.count
)
59 app
->window
= ui_omnplay(app
);
66 void omnplay_destroy(omnplay_instance_t
* app
)
71 static int find_index_of_playlist_item(omnplay_instance_t
* app
, int start
, int idx
)
75 if(app
->playlist
.item
[start
].omn_idx
== idx
)
78 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_END
)
87 static void omnplay_update_status(omnplay_player_t
* player
, OmPlrStatus
*prev
, OmPlrStatus
*curr
)
90 char tc_cur
[32], tc_rem
[32], state
[32], status
[32];
95 frames2tc(curr
->pos
- curr
->minPos
, 25.0, tc_cur
);
96 frames2tc(curr
->maxPos
- curr
->pos
, 25.0, tc_rem
);
97 strcpy(status
, "ONLINE");
98 clip
= curr
->currClipName
;
102 case omPlrStateStopped
: strcpy(state
, "STOPPED"); break;
103 case omPlrStateCuePlay
: strcpy(state
, "CUE_PLAY"); break;
104 case omPlrStatePlay
: strcpy(state
, "PLAY"); break;
105 case omPlrStateCueRecord
: strcpy(state
, "CUE_RECORD"); break;
106 case omPlrStateRecord
: strcpy(state
, "RECORD"); break;
115 strcpy(status
, "OFFLINE");
118 /* update status in status page */
120 gtk_label_set_text(GTK_LABEL (player
->label_tc_cur
), tc_cur
);
121 gtk_label_set_text(GTK_LABEL (player
->label_tc_rem
), tc_rem
);
122 gtk_label_set_text(GTK_LABEL (player
->label_state
), state
);
123 gtk_label_set_text(GTK_LABEL (player
->label_status
), status
);
124 gtk_label_set_text(GTK_LABEL (player
->label_clip
), clip
);
128 /* update remaining time */
130 pthread_mutex_lock(&player
->app
->playlist
.lock
);
131 pthread_mutex_lock(&player
->app
->players
.lock
);
132 if(curr
->state
== omPlrStatePlay
|| curr
->state
== omPlrStateCuePlay
)
134 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, curr
->currClipNum
);
137 frames2tc(curr
->currClipStartPos
+ curr
->currClipLen
- curr
->pos
, 25.0, tc_rem
);
138 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
140 if(curr
->currClipNum
!= prev
->currClipNum
&& 1 != prev
->numClips
)
143 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, prev
->currClipNum
);
145 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
151 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, curr
->currClipNum
);
153 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
154 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, prev
->currClipNum
);
156 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
158 pthread_mutex_unlock(&player
->app
->players
.lock
);
159 pthread_mutex_unlock(&player
->app
->playlist
.lock
);
164 memcpy(prev
, curr
, sizeof(OmPlrStatus
));
167 static void* omnplay_thread_proc(void* data
)
170 OmPlrStatus st_curr
, st_prev
;
171 omnplay_player_t
* player
= (omnplay_player_t
*)data
;
174 pthread_mutex_lock(&player
->app
->players
.lock
);
175 r
= OmPlrOpen(player
->host
, player
->name
, (OmPlrHandle
*)&player
->handle
);
176 pthread_mutex_unlock(&player
->app
->players
.lock
);
179 fprintf(stderr
, "ERROR: OmPlrOpen(%s, %s) failed with 0x%.8X\n",
180 player
->host
, player
->name
, r
);
185 /* setup to do not reconnect */
186 pthread_mutex_lock(&player
->app
->players
.lock
);
187 OmPlrSetRetryOpen((OmPlrHandle
)player
->handle
, 0);
188 pthread_mutex_unlock(&player
->app
->players
.lock
);
190 /* setup directory */
191 if(player
->app
->players
.path
[0])
193 pthread_mutex_lock(&player
->app
->players
.lock
);
194 r
= OmPlrClipSetDirectory((OmPlrHandle
)player
->handle
, player
->app
->players
.path
);
195 pthread_mutex_unlock(&player
->app
->players
.lock
);
199 fprintf(stderr
, "ERROR: OmPlrClipSetDirectory(%s) failed with 0x%.8X\n",
200 player
->app
->players
.path
, r
);
202 pthread_mutex_lock(&player
->app
->players
.lock
);
203 OmPlrClose((OmPlrHandle
)player
->handle
);
204 pthread_mutex_unlock(&player
->app
->players
.lock
);
211 for(r
= 0 ; !player
->app
->f_exit
&& !r
;)
217 pthread_mutex_lock(&player
->app
->players
.lock
);
218 st_curr
.size
= sizeof(OmPlrStatus
);
219 r
= OmPlrGetPlayerStatus((OmPlrHandle
)player
->handle
, &st_curr
);
220 pthread_mutex_unlock(&player
->app
->players
.lock
);
223 fprintf(stderr
, "ERROR: OmPlrGetPlayerStatus failed with 0x%.8X\n", r
);
225 if(memcmp(&st_curr
, &st_prev
, sizeof(OmPlrStatus
)))
226 omnplay_update_status(player
, &st_prev
, &st_curr
);
229 pthread_mutex_lock(&player
->app
->players
.lock
);
230 OmPlrClose((OmPlrHandle
)player
->handle
);
231 pthread_mutex_unlock(&player
->app
->players
.lock
);
236 void get_selected_items_playlist_proc(GtkTreeModel
*model
, GtkTreePath
*path
, GtkTreeIter
*iter
, gpointer data
)
238 int idx
, *list
= (int*)data
;
239 gtk_tree_model_get(model
, iter
, 7, &idx
, -1);
240 list
[list
[0] + 1] = idx
;
241 list
[0] = list
[0] + 1;
244 static int* get_selected_items_playlist(omnplay_instance_t
* app
)
247 GtkTreeSelection
*selection
;
249 selection
= gtk_tree_view_get_selection(GTK_TREE_VIEW(app
->playlist_grid
));
252 list
= (int*)malloc(sizeof(int) * (MAX_PLAYLIST_ITEMS
+ 1));
253 memset(list
, 0, sizeof(int) * (MAX_PLAYLIST_ITEMS
+ 1));
255 gtk_tree_selection_selected_foreach(
257 get_selected_items_playlist_proc
,
270 static int idx_in_players_range(omnplay_instance_t
* app
, int idx
)
274 for(i
= 0; i
< app
->players
.count
&& !r
; i
++)
278 a
= app
->players
.item
[i
].playlist_start
;
279 b
= app
->players
.item
[i
].playlist_length
;
286 if(idx
>= a
&& idx
<= b
) r
= 1;
292 static int idxs_in_players_range(omnplay_instance_t
* app
, int start
, int stop
)
296 for(i
= 0; i
< app
->players
.count
&& !r
; i
++)
300 a
= app
->players
.item
[i
].playlist_start
;
301 b
= app
->players
.item
[i
].playlist_length
;
308 #define IN_RANGE(A,B,C) (A <= C && C <= B)
309 if( IN_RANGE(a
,b
,start
) ||
310 IN_RANGE(a
,b
,stop
) ||
311 IN_RANGE(start
,stop
,a
) ||
312 IN_RANGE(start
,stop
,b
))
319 static void omnplay_playlist_block(omnplay_instance_t
* app
, control_buttons_t button
)
321 int start
, stop
, r
, i
;
322 int* list
= get_selected_items_playlist(app
);
327 pthread_mutex_lock(&app
->playlist
.lock
);
328 pthread_mutex_lock(&app
->players
.lock
);
331 stop
= list
[list
[0]];
333 if(!idxs_in_players_range(app
, start
, stop
))
335 int loop
= (button
== BUTTON_PLAYLIST_BLOCK_LOOP
)?OMNPLAY_PLAYLIST_BLOCK_LOOP
:0;
337 /* update selected item */
338 for(i
= start
; i
<= stop
; i
++)
340 int t
= OMNPLAY_PLAYLIST_BLOCK_BODY
| loop
;
342 if(i
== start
) t
|= OMNPLAY_PLAYLIST_BLOCK_BEGIN
;
343 if(i
== stop
) t
|= OMNPLAY_PLAYLIST_BLOCK_END
;
345 app
->playlist
.item
[i
].type
= (playlist_item_type_t
)t
;
347 omnplay_playlist_draw_item(app
, i
);
350 /* update border items */
351 if(!start
&& !(app
->playlist
.item
[start
- 1].type
& OMNPLAY_PLAYLIST_BLOCK_END
))
353 app
->playlist
.item
[start
- 1].type
= (playlist_item_type_t
)(OMNPLAY_PLAYLIST_BLOCK_END
354 | app
->playlist
.item
[start
- 1].type
);
355 omnplay_playlist_draw_item(app
, start
- 1);
357 if((stop
+ 1) < app
->playlist
.count
&& !(app
->playlist
.item
[stop
+ 1].type
& OMNPLAY_PLAYLIST_BLOCK_BEGIN
))
359 app
->playlist
.item
[stop
+ 1].type
= (playlist_item_type_t
)(OMNPLAY_PLAYLIST_BLOCK_BEGIN
360 | app
->playlist
.item
[stop
+ 1].type
);
361 omnplay_playlist_draw_item(app
, stop
+ 1);
365 fprintf(stderr
, "omnplay_playlist_block: range [%d %d] do OVERLAP player\n",
368 pthread_mutex_unlock(&app
->players
.lock
);
369 pthread_mutex_unlock(&app
->playlist
.lock
);
374 static int get_first_selected_item_playlist(omnplay_instance_t
* app
)
377 int* list
= get_selected_items_playlist(app
);
384 static int get_playlist_block(omnplay_instance_t
* app
, int idx
, int* start_ptr
, int* stop_ptr
)
388 for(start
= idx
; start
>= 0; start
--)
389 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_BEGIN
)
392 for(stop
= idx
; stop
< app
->playlist
.count
; stop
++)
393 if(app
->playlist
.item
[stop
].type
& OMNPLAY_PLAYLIST_BLOCK_END
)
396 fprintf(stderr
, "get_playlist_block: range %d -> %d\n", start
, stop
);
398 /* check block range */
399 if(start
>= 0 && stop
< app
->playlist
.count
)
403 return (stop
- start
+ 1);
409 static omnplay_player_t
*get_player_at_pos(omnplay_instance_t
* app
, int pos
)
411 /* check player range */
412 if(app
->playlist
.item
[pos
].player
> -1 && app
->playlist
.item
[pos
].player
< app
->players
.count
)
413 return &app
->players
.item
[app
->playlist
.item
[pos
].player
];
418 static void omnplay_ctl(omnplay_instance_t
* app
, control_buttons_t button
)
421 int idx
, start
, stop
;
422 omnplay_player_t
*player
;
424 pthread_mutex_lock(&app
->playlist
.lock
);
426 idx
= get_first_selected_item_playlist(app
);
430 pthread_mutex_unlock(&app
->playlist
.lock
);
434 fprintf(stderr
, "cue: selected item is %d\n", idx
);
436 if(get_playlist_block(app
, idx
, &start
, &stop
) < 0)
438 pthread_mutex_unlock(&app
->playlist
.lock
);
442 fprintf(stderr
, "cue: range %d -> %d\n", start
, stop
);
444 player
= get_player_at_pos(app
, start
);
448 pthread_mutex_unlock(&app
->playlist
.lock
);
452 pthread_mutex_lock(&app
->players
.lock
);
454 if(BUTTON_PLAYER_STOP
== button
|| BUTTON_PLAYER_CUE
== button
)
457 OmPlrStop((OmPlrHandle
)player
->handle
);
459 /* detach previous clips */
460 player
->playlist_length
= -1;
461 OmPlrDetachAllClips((OmPlrHandle
)player
->handle
);
464 if(BUTTON_PLAYER_CUE
== button
)
468 /* Attach clips to timeline */
469 for(i
= start
, c
= 0, o
= 0; i
<= stop
; i
++)
474 clip
.maxMsTracks
= 0;
475 clip
.size
= sizeof(clip
);
476 r
= OmPlrClipGetInfo((OmPlrHandle
)player
->handle
, app
->playlist
.item
[i
].id
, &clip
);
482 fprintf(stderr
, "OmPlrClipGetInfo(%s): firstFrame=%d, lastFrame=%d\n",
483 app
->playlist
.item
[i
].id
, clip
.firstFrame
, clip
.lastFrame
);
485 /* should we fix playlist clip timings */
487 app
->playlist
.item
[i
].in
>= clip
.firstFrame
&&
488 app
->playlist
.item
[i
].in
+ app
->playlist
.item
[i
].dur
<= clip
.lastFrame
) ||
489 !app
->playlist
.item
[i
].dur
)
491 fprintf(stderr
, "cue: item [%s] will be updated [%d;%d]->[%d;%d]\n",
492 app
->playlist
.item
[i
].id
,
493 app
->playlist
.item
[i
].in
, app
->playlist
.item
[i
].dur
,
494 clip
.firstFrame
, clip
.lastFrame
- clip
.firstFrame
);
496 app
->playlist
.item
[i
].in
= clip
.firstFrame
;
497 app
->playlist
.item
[i
].dur
= clip
.lastFrame
- clip
.firstFrame
;
498 omnplay_playlist_draw_item(app
, i
);
501 r
= OmPlrAttach((OmPlrHandle
)player
->handle
,
502 app
->playlist
.item
[i
].id
,
503 app
->playlist
.item
[i
].in
,
504 app
->playlist
.item
[i
].in
+ app
->playlist
.item
[i
].dur
,
505 0, omPlrShiftModeAfter
, &l
);
510 fprintf(stderr
, "cue: failed with %d, %s\n", r
, OmPlrGetErrorString((OmPlrError
)r
));
511 app
->playlist
.item
[i
].omn_idx
= -1;
512 app
->playlist
.item
[i
].omn_offset
= -1;
516 app
->playlist
.item
[i
].omn_idx
= c
;
517 app
->playlist
.item
[i
].omn_offset
= o
;
519 /* save selected item offset */
523 o
+= app
->playlist
.item
[i
].dur
;
531 /* Set timeline min/max */
532 OmPlrSetMinPosMin((OmPlrHandle
)player
->handle
);
533 OmPlrSetMaxPosMax((OmPlrHandle
)player
->handle
);
535 /* Set timeline position */
537 hs
.size
= sizeof(OmPlrStatus
);
538 OmPlrGetPlayerStatus((OmPlrHandle
)player
->handle
, &hs
);
539 OmPlrSetPos((OmPlrHandle
)player
->handle
, hs
.minPos
+ p
);
542 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_LOOP
)
543 OmPlrLoop((OmPlrHandle
)player
->handle
, hs
.minPos
, hs
.maxPos
);
545 player
->playlist_start
= start
;
546 player
->playlist_length
= stop
- start
+ 1;
549 OmPlrCuePlay((OmPlrHandle
)player
->handle
, 0.0);
553 if(BUTTON_PLAYER_PLAY
== button
)
556 OmPlrPlay((OmPlrHandle
)player
->handle
, 1.0);
559 if(BUTTON_PLAYER_PAUSE
== button
)
561 OmPlrPlay((OmPlrHandle
)player
->handle
, 0.0);
563 pthread_mutex_unlock(&app
->players
.lock
);
565 pthread_mutex_unlock(&app
->playlist
.lock
);
568 static gboolean
omnplay_button_click(omnplay_instance_t
* app
, control_buttons_t button
)
572 case BUTTON_PLAYLIST_ITEM_ADD
:
573 case BUTTON_PLAYLIST_ITEM_DEL
:
574 case BUTTON_PLAYLIST_ITEM_EDIT
:
576 case BUTTON_PLAYLIST_LOAD
:
577 omnplay_playlist_load(app
);
579 case BUTTON_PLAYLIST_SAVE
:
580 omnplay_playlist_save(app
);
582 case BUTTON_PLAYLIST_BLOCK_SINGLE
:
583 case BUTTON_PLAYLIST_BLOCK_LOOP
:
584 omnplay_playlist_block(app
, button
);
586 case BUTTON_PLAYLIST_ITEM_UP
:
587 case BUTTON_PLAYLIST_ITEM_DOWN
:
589 case BUTTON_PLAYER_CUE
:
590 case BUTTON_PLAYER_PLAY
:
591 case BUTTON_PLAYER_PAUSE
:
592 case BUTTON_PLAYER_STOP
:
593 omnplay_ctl(app
, button
);
595 case BUTTON_LIBRARY_ADD
:
596 case BUTTON_LIBRARY_REFRESH
:
603 static gboolean
on_button_click(GtkWidget
*button
, gpointer user_data
)
606 omnplay_instance_t
* app
= (omnplay_instance_t
*)user_data
;
608 for(i
= 1; i
< BUTTON_LAST
; i
++)
609 if(app
->buttons
[i
] == button
)
610 return omnplay_button_click(app
, (control_buttons_t
)i
);
615 void omnplay_init(omnplay_instance_t
* app
)
618 pthread_mutexattr_t attr
;
620 pthread_mutexattr_settype(&attr
, PTHREAD_MUTEX_RECURSIVE
);
622 gtk_signal_connect( GTK_OBJECT( app
->window
), "destroy",
623 GTK_SIGNAL_FUNC(on_main_window_delete_event
), app
);
626 pthread_mutex_init(&app
->players
.lock
, &attr
);
628 /* create a omneon status thread */
629 for(i
= 0; i
< app
->players
.count
; i
++)
630 pthread_create(&app
->players
.item
[i
].thread
, NULL
,
631 omnplay_thread_proc
, &app
->players
.item
[i
]);
634 pthread_mutex_init(&app
->playlist
.lock
, &attr
);
636 /* attach buttons click */
637 for(i
= 1; i
< BUTTON_LAST
; i
++)
638 gtk_signal_connect(GTK_OBJECT(app
->buttons
[i
]), "clicked",
639 GTK_SIGNAL_FUNC( on_button_click
), app
);
643 void omnplay_release(omnplay_instance_t
* app
)
650 for(i
= 0; i
< app
->players
.count
; i
++)
651 /* create a omneon status thread */
652 pthread_join(app
->players
.item
[i
].thread
, &r
);
655 pthread_mutex_destroy(&app
->players
.lock
);
658 pthread_mutex_destroy(&app
->playlist
.lock
);