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 int omnplay_get_content(omnplay_instance_t
* app
, playlist_item_t
*items
, int limit
,
43 omnplay_get_content_cb_proc proc
, void* data
)
46 OmPlrClipInfo clip_info
;
47 char clip_name
[omPlrMaxClipDirLen
];
49 pthread_mutex_lock(&app
->players
.lock
);
51 r
= OmPlrClipGetFirst((OmPlrHandle
)app
->players
.item
[0].handle
, clip_name
, sizeof(clip_name
));
52 for(; c
< limit
&& !r
;)
55 clip_info
.maxMsTracks
= 0;
56 clip_info
.size
= sizeof(clip_info
);
58 r
= OmPlrClipGetInfo((OmPlrHandle
)app
->players
.item
[0].handle
, clip_name
, &clip_info
);
63 strncpy(items
[c
].id
, clip_name
, PATH_MAX
);
64 items
[c
].in
= clip_info
.firstFrame
;
65 items
[c
].dur
= clip_info
.lastFrame
- clip_info
.firstFrame
;
68 pthread_mutex_unlock(&app
->players
.lock
);
70 proc(app
, &items
[c
], data
);
71 pthread_mutex_lock(&app
->players
.lock
);
76 r
= OmPlrClipGetNext((OmPlrHandle
)app
->players
.item
[0].handle
, clip_name
, sizeof(clip_name
));
79 pthread_mutex_unlock(&app
->players
.lock
);
85 static gboolean
on_main_window_delete_event( GtkWidget
*widget
, GdkEvent
*event
, gpointer user_data
)
87 g_print ("delete event occurred [start]\n");
89 omnplay_release((omnplay_instance_t
*)user_data
);
91 g_print ("delete event occurred [finish]\n");
96 static void on_main_window_destroy( GtkWidget
*widget
, gpointer user_data
)
98 g_print ("destroy occurred\n");
102 omnplay_instance_t
* omnplay_create(int argc
, char** argv
)
105 omnplay_instance_t
* app
;
107 /* prepare application instance */
108 app
= (omnplay_instance_t
*)malloc(sizeof(omnplay_instance_t
));
109 memset(app
, 0, sizeof(omnplay_instance_t
));
111 /* load parameters from command line */
112 if(!omnplay_opt(argc
, argv
, app
) && app
->players
.count
)
113 app
->window
= ui_omnplay(app
);
120 void omnplay_destroy(omnplay_instance_t
* app
)
125 static int find_index_of_playlist_item(omnplay_instance_t
* app
, int start
, int idx
)
127 if(start
< 0 || start
>= app
->playlist
.count
)
132 if(app
->playlist
.item
[start
].omn_idx
== idx
)
135 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_END
)
144 static void omnplay_update_status(omnplay_player_t
* player
, OmPlrStatus
*prev
, OmPlrStatus
*curr
)
147 char tc_cur
[32], tc_rem
[32], state
[32], status
[32];
152 frames2tc(curr
->pos
- curr
->minPos
, 25.0, tc_cur
);
153 frames2tc(curr
->maxPos
- curr
->pos
, 25.0, tc_rem
);
154 strcpy(status
, "ONLINE");
155 clip
= curr
->currClipName
;
159 case omPlrStateStopped
: strcpy(state
, "STOPPED"); break;
160 case omPlrStateCuePlay
: strcpy(state
, "CUE_PLAY"); break;
161 case omPlrStatePlay
: strcpy(state
, "PLAY"); break;
162 case omPlrStateCueRecord
: strcpy(state
, "CUE_RECORD"); break;
163 case omPlrStateRecord
: strcpy(state
, "RECORD"); break;
172 strcpy(status
, "OFFLINE");
175 /* update status in status page */
177 gtk_label_set_text(GTK_LABEL (player
->label_tc_cur
), tc_cur
);
178 gtk_label_set_text(GTK_LABEL (player
->label_tc_rem
), tc_rem
);
179 gtk_label_set_text(GTK_LABEL (player
->label_state
), state
);
180 gtk_label_set_text(GTK_LABEL (player
->label_status
), status
);
181 gtk_label_set_text(GTK_LABEL (player
->label_clip
), clip
);
185 /* update remaining time */
187 pthread_mutex_lock(&player
->app
->playlist
.lock
);
188 pthread_mutex_lock(&player
->app
->players
.lock
);
189 if(curr
->state
== omPlrStatePlay
|| curr
->state
== omPlrStateCuePlay
)
191 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, curr
->currClipNum
);
194 frames2tc(curr
->currClipStartPos
+ curr
->currClipLen
- curr
->pos
, 25.0, tc_rem
);
195 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
197 if(curr
->currClipNum
!= prev
->currClipNum
&& 1 != prev
->numClips
)
200 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, prev
->currClipNum
);
202 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
208 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, curr
->currClipNum
);
210 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
211 idx
= find_index_of_playlist_item(player
->app
, player
->playlist_start
, prev
->currClipNum
);
213 omnplay_playlist_draw_item_rem(player
->app
, idx
, tc_rem
);
215 pthread_mutex_unlock(&player
->app
->players
.lock
);
216 pthread_mutex_unlock(&player
->app
->playlist
.lock
);
221 memcpy(prev
, curr
, sizeof(OmPlrStatus
));
224 static void* omnplay_thread_proc(void* data
)
227 OmPlrStatus st_curr
, st_prev
;
228 omnplay_player_t
* player
= (omnplay_player_t
*)data
;
230 g_warning("omnplay_thread_proc\n");
232 memset(&st_curr
, 0, sizeof(OmPlrStatus
));
233 memset(&st_prev
, 0, sizeof(OmPlrStatus
));
236 pthread_mutex_lock(&player
->app
->players
.lock
);
237 r
= OmPlrOpen(player
->host
, player
->name
, (OmPlrHandle
*)&player
->handle
);
238 pthread_mutex_unlock(&player
->app
->players
.lock
);
241 g_warning("ERROR: OmPlrOpen(%s, %s) failed with 0x%.8X\n",
242 player
->host
, player
->name
, r
);
247 /* setup to do not reconnect */
248 pthread_mutex_lock(&player
->app
->players
.lock
);
249 OmPlrSetRetryOpen((OmPlrHandle
)player
->handle
, 0);
250 pthread_mutex_unlock(&player
->app
->players
.lock
);
252 /* setup directory */
253 if(player
->app
->players
.path
[0])
255 pthread_mutex_lock(&player
->app
->players
.lock
);
256 r
= OmPlrClipSetDirectory((OmPlrHandle
)player
->handle
, player
->app
->players
.path
);
257 pthread_mutex_unlock(&player
->app
->players
.lock
);
261 g_warning("ERROR: OmPlrClipSetDirectory(%s) failed with 0x%.8X\n",
262 player
->app
->players
.path
, r
);
264 pthread_mutex_lock(&player
->app
->players
.lock
);
265 OmPlrClose((OmPlrHandle
)player
->handle
);
266 pthread_mutex_unlock(&player
->app
->players
.lock
);
273 for(r
= 0 ; !player
->app
->f_exit
&& !r
;)
283 pthread_mutex_lock(&player
->app
->players
.lock
);
284 st_curr
.size
= sizeof(OmPlrStatus
);
285 r
= OmPlrGetPlayerStatus((OmPlrHandle
)player
->handle
, &st_curr
);
286 pthread_mutex_unlock(&player
->app
->players
.lock
);
289 g_warning("ERROR: OmPlrGetPlayerStatus failed with 0x%.8X\n", r
);
291 if(memcmp(&st_curr
, &st_prev
, sizeof(OmPlrStatus
)))
292 omnplay_update_status(player
, &st_prev
, &st_curr
);
295 pthread_mutex_lock(&player
->app
->players
.lock
);
296 OmPlrClose((OmPlrHandle
)player
->handle
);
297 pthread_mutex_unlock(&player
->app
->players
.lock
);
302 void get_selected_items_playlist_proc(GtkTreeModel
*model
, GtkTreePath
*path
, GtkTreeIter
*iter
, gpointer data
)
304 int idx
, *list
= (int*)data
;
305 gtk_tree_model_get(model
, iter
, 7, &idx
, -1);
306 list
[list
[0] + 1] = idx
;
307 list
[0] = list
[0] + 1;
310 static int* get_selected_items_playlist(omnplay_instance_t
* app
)
313 GtkTreeSelection
*selection
;
315 selection
= gtk_tree_view_get_selection(GTK_TREE_VIEW(app
->playlist_grid
));
318 list
= (int*)malloc(sizeof(int) * (MAX_PLAYLIST_ITEMS
+ 1));
319 memset(list
, 0, sizeof(int) * (MAX_PLAYLIST_ITEMS
+ 1));
321 gtk_tree_selection_selected_foreach(
323 get_selected_items_playlist_proc
,
336 static int idx_in_players_range(omnplay_instance_t
* app
, int idx
)
340 for(i
= 0; i
< app
->players
.count
&& !r
; i
++)
344 a
= app
->players
.item
[i
].playlist_start
;
345 b
= app
->players
.item
[i
].playlist_length
;
352 if(idx
>= a
&& idx
<= b
) r
= 1;
358 static int idxs_in_players_range(omnplay_instance_t
* app
, int start
, int stop
)
362 for(i
= 0; i
< app
->players
.count
&& !r
; i
++)
366 a
= app
->players
.item
[i
].playlist_start
;
367 b
= app
->players
.item
[i
].playlist_length
;
374 #define IN_RANGE(A,B,C) (A <= C && C <= B)
375 if( IN_RANGE(a
,b
,start
) ||
376 IN_RANGE(a
,b
,stop
) ||
377 IN_RANGE(start
,stop
,a
) ||
378 IN_RANGE(start
,stop
,b
))
385 static void omnplay_playlist_block(omnplay_instance_t
* app
, control_buttons_t button
)
387 int start
, stop
, r
, i
;
388 int* list
= get_selected_items_playlist(app
);
393 pthread_mutex_lock(&app
->playlist
.lock
);
394 pthread_mutex_lock(&app
->players
.lock
);
397 stop
= list
[list
[0]];
399 if(!idxs_in_players_range(app
, start
, stop
))
401 int loop
= (button
== BUTTON_PLAYLIST_BLOCK_LOOP
)?OMNPLAY_PLAYLIST_BLOCK_LOOP
:0;
403 /* update selected item */
404 for(i
= start
; i
<= stop
; i
++)
406 int t
= OMNPLAY_PLAYLIST_BLOCK_BODY
| loop
;
408 if(i
== start
) t
|= OMNPLAY_PLAYLIST_BLOCK_BEGIN
;
409 if(i
== stop
) t
|= OMNPLAY_PLAYLIST_BLOCK_END
;
411 app
->playlist
.item
[i
].type
= (playlist_item_type_t
)t
;
413 omnplay_playlist_draw_item(app
, i
);
416 /* update border items */
417 if(start
&& !(app
->playlist
.item
[start
- 1].type
& OMNPLAY_PLAYLIST_BLOCK_END
))
419 app
->playlist
.item
[start
- 1].type
= (playlist_item_type_t
)(OMNPLAY_PLAYLIST_BLOCK_END
420 | app
->playlist
.item
[start
- 1].type
);
421 omnplay_playlist_draw_item(app
, start
- 1);
423 if((stop
+ 1) < app
->playlist
.count
&& !(app
->playlist
.item
[stop
+ 1].type
& OMNPLAY_PLAYLIST_BLOCK_BEGIN
))
425 app
->playlist
.item
[stop
+ 1].type
= (playlist_item_type_t
)(OMNPLAY_PLAYLIST_BLOCK_BEGIN
426 | app
->playlist
.item
[stop
+ 1].type
);
427 omnplay_playlist_draw_item(app
, stop
+ 1);
431 g_warning("omnplay_playlist_block: range [%d %d] do OVERLAP player\n",
434 pthread_mutex_unlock(&app
->players
.lock
);
435 pthread_mutex_unlock(&app
->playlist
.lock
);
440 static int get_first_selected_item_playlist(omnplay_instance_t
* app
)
443 int* list
= get_selected_items_playlist(app
);
450 static int get_playlist_block(omnplay_instance_t
* app
, int idx
, int* start_ptr
, int* stop_ptr
)
454 for(start
= idx
; start
>= 0; start
--)
455 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_BEGIN
)
458 for(stop
= idx
; stop
< app
->playlist
.count
; stop
++)
459 if(app
->playlist
.item
[stop
].type
& OMNPLAY_PLAYLIST_BLOCK_END
)
462 g_warning("get_playlist_block: range %d -> %d\n", start
, stop
);
464 /* check block range */
465 if(start
>= 0 && stop
< app
->playlist
.count
)
469 return (stop
- start
+ 1);
475 static omnplay_player_t
*get_player_at_pos(omnplay_instance_t
* app
, int pos
)
477 /* check player range */
478 if(app
->playlist
.item
[pos
].player
> -1 && app
->playlist
.item
[pos
].player
< app
->players
.count
)
479 return &app
->players
.item
[app
->playlist
.item
[pos
].player
];
484 static void omnplay_playlist_delete_items(omnplay_instance_t
* app
, int* idxs
, int count
)
489 pthread_mutex_lock(&app
->playlist
.lock
);
490 pthread_mutex_lock(&app
->players
.lock
);
492 for(j
= 0; j
< count
; j
++)
496 /* fix block types */
497 if( app
->playlist
.item
[idx
].type
!= OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY
&&
498 app
->playlist
.item
[idx
].type
!= OMNPLAY_PLAYLIST_ITEM_LOOP_BODY
)
501 app
->playlist
.item
[idx
- 1].type
= (playlist_item_type_t
)(app
->playlist
.item
[idx
- 1].type
|
502 OMNPLAY_PLAYLIST_BLOCK_END
);
503 if(idx
+ 1 < app
->playlist
.count
)
504 app
->playlist
.item
[idx
+ 1].type
= (playlist_item_type_t
)(app
->playlist
.item
[idx
+ 1].type
|
505 OMNPLAY_PLAYLIST_BLOCK_BEGIN
);
508 /* shift playlist items */
511 &app
->playlist
.item
[idx
],
512 &app
->playlist
.item
[idx
+ 1],
513 (app
->playlist
.count
- idx
- 1) * sizeof(playlist_item_t
)
516 /* decrement items count */
517 app
->playlist
.count
--;
519 /* increment servers indexes */
520 for(i
= 0; i
< app
->players
.count
; i
++)
521 if(app
->players
.item
[i
].playlist_start
>= idx
)
522 app
->players
.item
[i
].playlist_start
--;
527 /* redraw playlist */
528 omnplay_playlist_draw(app
);
531 path
= gtk_tree_path_new_from_indices(idxs
[0], -1);
532 gtk_tree_selection_select_path(gtk_tree_view_get_selection(GTK_TREE_VIEW(app
->playlist_grid
)), path
);
533 gtk_tree_view_set_cursor(GTK_TREE_VIEW(app
->playlist_grid
), path
, NULL
, FALSE
);
534 gtk_tree_path_free(path
);
537 pthread_mutex_unlock(&app
->players
.lock
);
538 pthread_mutex_unlock(&app
->playlist
.lock
);
541 static void omnplay_playlist_item_del(omnplay_instance_t
* app
)
546 list
= get_selected_items_playlist(app
);
549 list2
= (int*)malloc(sizeof(int) * list
[0]);
551 for(i
= 0, c
= 0; i
< list
[0]; i
++)
553 /* check for playing block */
554 if(idx_in_players_range(app
, list
[i
+ 1]))
558 list2
[c
++] = list
[i
+ 1];
562 omnplay_playlist_delete_items(app
, list2
, c
);
568 static int omnplay_playlist_insert_check(omnplay_instance_t
* app
, int idx
, playlist_item_type_t
* t
)
570 *t
= OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE
;
572 /* before or after playlist */
573 if(!idx
|| idx
== app
->playlist
.count
)
576 /* check for block borders */
577 if( app
->playlist
.item
[idx
- 1].type
& OMNPLAY_PLAYLIST_BLOCK_END
&&
578 app
->playlist
.item
[idx
+ 0].type
& OMNPLAY_PLAYLIST_BLOCK_BEGIN
)
581 /* check for playing block */
582 if(idx_in_players_range(app
, idx
))
585 if(app
->playlist
.item
[idx
].type
& OMNPLAY_PLAYLIST_BLOCK_LOOP
)
586 *t
= OMNPLAY_PLAYLIST_ITEM_LOOP_BODY
;
588 *t
= OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY
;
593 static void omnplay_playlist_insert_items(omnplay_instance_t
* app
, int idx
,
594 playlist_item_t
* items
, int count
)
599 pthread_mutex_lock(&app
->playlist
.lock
);
600 pthread_mutex_lock(&app
->players
.lock
);
602 /* shift playlist items */
605 &app
->playlist
.item
[idx
+ count
],
606 &app
->playlist
.item
[idx
],
607 (app
->playlist
.count
- idx
) * sizeof(playlist_item_t
)
613 &app
->playlist
.item
[idx
],
615 count
* sizeof(playlist_item_t
)
618 /* increment servers indexes */
619 for(i
= 0; i
< app
->players
.count
; i
++)
620 if(app
->players
.item
[i
].playlist_start
>= idx
)
621 app
->players
.item
[i
].playlist_start
+= idx
;
623 /* increment items count */
624 app
->playlist
.count
+= count
;
626 /* redraw playlist */
627 omnplay_playlist_draw(app
);
630 path
= gtk_tree_path_new_from_indices(idx
+ count
, -1);
631 gtk_tree_selection_select_path(gtk_tree_view_get_selection(GTK_TREE_VIEW(app
->playlist_grid
)), path
);
632 gtk_tree_view_set_cursor(GTK_TREE_VIEW(app
->playlist_grid
), path
, NULL
, FALSE
);
633 gtk_tree_path_free(path
);
635 pthread_mutex_unlock(&app
->players
.lock
);
636 pthread_mutex_unlock(&app
->playlist
.lock
);
639 static void omnplay_playlist_item_add(omnplay_instance_t
* app
, int after
)
642 playlist_item_t item
;
643 playlist_item_type_t t
;
645 /* find insert position */
646 idx
= get_first_selected_item_playlist(app
);
652 if(!omnplay_playlist_insert_check(app
, idx
, &t
))
655 g_warning("allowed insert into idx=%d\n", idx
);
658 memset(&item
, 0, sizeof(playlist_item_t
));
659 if(ui_playlist_item_dialog(app
, &item
))
661 omnplay_library_normalize_item(app
, &item
);
663 omnplay_playlist_insert_items(app
, idx
, &item
, 1);
667 static void omnplay_playlist_item_edit(omnplay_instance_t
* app
)
670 playlist_item_t item
;
672 /* find insert position */
673 idx
= get_first_selected_item_playlist(app
);
678 /* check for playing block */
679 if(idx_in_players_range(app
, idx
))
682 item
= app
->playlist
.item
[idx
];
684 if(ui_playlist_item_dialog(app
, &item
))
686 omnplay_library_normalize_item(app
, &item
);
687 app
->playlist
.item
[idx
] = item
;
688 omnplay_playlist_draw_item(app
, idx
);
692 static void omnplay_ctl(omnplay_instance_t
* app
, control_buttons_t button
)
695 int idx
, start
, stop
;
696 omnplay_player_t
*player
;
698 pthread_mutex_lock(&app
->playlist
.lock
);
700 idx
= get_first_selected_item_playlist(app
);
704 pthread_mutex_unlock(&app
->playlist
.lock
);
708 g_warning("cue: selected item is %d\n", idx
);
710 if(get_playlist_block(app
, idx
, &start
, &stop
) < 0)
712 pthread_mutex_unlock(&app
->playlist
.lock
);
716 g_warning("cue: range %d -> %d\n", start
, stop
);
718 player
= get_player_at_pos(app
, start
);
722 pthread_mutex_unlock(&app
->playlist
.lock
);
726 pthread_mutex_lock(&app
->players
.lock
);
728 if(BUTTON_PLAYER_STOP
== button
|| BUTTON_PLAYER_CUE
== button
)
731 OmPlrStop((OmPlrHandle
)player
->handle
);
733 /* detach previous clips */
734 player
->playlist_length
= -1;
735 OmPlrDetachAllClips((OmPlrHandle
)player
->handle
);
738 if(BUTTON_PLAYER_CUE
== button
)
742 /* Attach clips to timeline */
743 for(i
= start
, c
= 0, o
= 0; i
<= stop
; i
++)
748 clip
.maxMsTracks
= 0;
749 clip
.size
= sizeof(clip
);
750 r
= OmPlrClipGetInfo((OmPlrHandle
)player
->handle
, app
->playlist
.item
[i
].id
, &clip
);
756 g_warning("OmPlrClipGetInfo(%s): firstFrame=%d, lastFrame=%d\n",
757 app
->playlist
.item
[i
].id
, clip
.firstFrame
, clip
.lastFrame
);
759 /* should we fix playlist clip timings */
761 app
->playlist
.item
[i
].in
>= clip
.firstFrame
&&
762 app
->playlist
.item
[i
].in
+ app
->playlist
.item
[i
].dur
<= clip
.lastFrame
) ||
763 !app
->playlist
.item
[i
].dur
)
765 g_warning("cue: item [%s] will be updated [%d;%d]->[%d;%d]\n",
766 app
->playlist
.item
[i
].id
,
767 app
->playlist
.item
[i
].in
, app
->playlist
.item
[i
].dur
,
768 clip
.firstFrame
, clip
.lastFrame
- clip
.firstFrame
);
770 app
->playlist
.item
[i
].in
= clip
.firstFrame
;
771 app
->playlist
.item
[i
].dur
= clip
.lastFrame
- clip
.firstFrame
;
772 omnplay_playlist_draw_item(app
, i
);
775 r
= OmPlrAttach((OmPlrHandle
)player
->handle
,
776 app
->playlist
.item
[i
].id
,
777 app
->playlist
.item
[i
].in
,
778 app
->playlist
.item
[i
].in
+ app
->playlist
.item
[i
].dur
,
779 0, omPlrShiftModeAfter
, &l
);
784 g_warning("cue: failed with %d, %s\n", r
, OmPlrGetErrorString((OmPlrError
)r
));
785 app
->playlist
.item
[i
].omn_idx
= -1;
786 app
->playlist
.item
[i
].omn_offset
= -1;
787 app
->playlist
.item
[i
].error
|= PLAYLIST_ITEM_ERROR_CUE
;
791 app
->playlist
.item
[i
].omn_idx
= c
;
792 app
->playlist
.item
[i
].omn_offset
= o
;
793 app
->playlist
.item
[i
].error
&= 0xF ^ PLAYLIST_ITEM_ERROR_CUE
;
795 /* save selected item offset */
799 o
+= app
->playlist
.item
[i
].dur
;
807 /* Set timeline min/max */
808 OmPlrSetMinPosMin((OmPlrHandle
)player
->handle
);
809 OmPlrSetMaxPosMax((OmPlrHandle
)player
->handle
);
811 /* Set timeline position */
813 hs
.size
= sizeof(OmPlrStatus
);
814 OmPlrGetPlayerStatus((OmPlrHandle
)player
->handle
, &hs
);
815 OmPlrSetPos((OmPlrHandle
)player
->handle
, hs
.minPos
+ p
);
818 if(app
->playlist
.item
[start
].type
& OMNPLAY_PLAYLIST_BLOCK_LOOP
)
819 OmPlrLoop((OmPlrHandle
)player
->handle
, hs
.minPos
, hs
.maxPos
);
821 OmPlrLoop((OmPlrHandle
)player
->handle
, hs
.minPos
, hs
.minPos
);
823 player
->playlist_start
= start
;
824 player
->playlist_length
= stop
- start
+ 1;
827 OmPlrCuePlay((OmPlrHandle
)player
->handle
, 0.0);
831 if(BUTTON_PLAYER_PLAY
== button
)
834 OmPlrPlay((OmPlrHandle
)player
->handle
, 1.0);
837 if(BUTTON_PLAYER_PAUSE
== button
)
839 OmPlrPlay((OmPlrHandle
)player
->handle
, 0.0);
841 pthread_mutex_unlock(&app
->players
.lock
);
843 pthread_mutex_unlock(&app
->playlist
.lock
);
846 static void omnplay_playlist_item_swap(omnplay_instance_t
* app
, int dir
)
848 int sel
, a
, b
, e
= 1;
850 playlist_item_t item
;
852 /* find insert position */
853 sel
= get_first_selected_item_playlist(app
);
870 /* check for playing block */
871 if(idx_in_players_range(app
, a
) || idx_in_players_range(app
, b
))
874 pthread_mutex_lock(&app
->playlist
.lock
);
875 pthread_mutex_lock(&app
->players
.lock
);
878 item
= app
->playlist
.item
[a
];
879 app
->playlist
.item
[a
] = app
->playlist
.item
[b
];
880 app
->playlist
.item
[b
] = item
;
883 if(app
->playlist
.item
[a
].type
!= app
->playlist
.item
[b
].type
)
886 app
->playlist
.item
[a
].type
= OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE
;
887 app
->playlist
.item
[b
].type
= OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE
;
890 /* redraw main items */
891 omnplay_playlist_draw_item(app
, a
);
892 omnplay_playlist_draw_item(app
, b
);
894 /* fix block types */
897 app
->playlist
.item
[a
- 1].type
= (playlist_item_type_t
)(app
->playlist
.item
[a
- 1].type
|
898 OMNPLAY_PLAYLIST_BLOCK_END
);
899 omnplay_playlist_draw_item(app
, a
- 1);
901 if(b
+ 1 < app
->playlist
.count
&& !e
)
903 app
->playlist
.item
[b
+ 1].type
= (playlist_item_type_t
)(app
->playlist
.item
[b
+ 1].type
|
904 OMNPLAY_PLAYLIST_BLOCK_BEGIN
);
905 omnplay_playlist_draw_item(app
, b
+ 1);
909 path
= gtk_tree_path_new_from_indices(sel
, -1);
910 gtk_tree_selection_select_path(gtk_tree_view_get_selection(GTK_TREE_VIEW(app
->playlist_grid
)), path
);
911 gtk_tree_view_set_cursor(GTK_TREE_VIEW(app
->playlist_grid
), path
, NULL
, FALSE
);
912 gtk_tree_path_free(path
);
914 pthread_mutex_unlock(&app
->players
.lock
);
915 pthread_mutex_unlock(&app
->playlist
.lock
);
918 static void omnplay_library_add(omnplay_instance_t
* app
, int after
)
921 playlist_item_t
* items
;
922 playlist_item_type_t t
;
924 /* find insert position */
925 idx
= get_first_selected_item_playlist(app
);
931 if(!omnplay_playlist_insert_check(app
, idx
, &t
))
934 items
= omnplay_library_get_selected(app
, &c
);
939 for(i
= 0; i
< c
; i
++)
944 omnplay_playlist_insert_items(app
, idx
, items
, c
);
949 static gboolean
omnplay_button_click(omnplay_instance_t
* app
, control_buttons_t button
)
953 case BUTTON_PLAYLIST_ITEM_ADD
:
954 omnplay_playlist_item_add(app
, 0);
956 case BUTTON_PLAYLIST_ITEM_DEL
:
957 omnplay_playlist_item_del(app
);
959 case BUTTON_PLAYLIST_ITEM_EDIT
:
960 omnplay_playlist_item_edit(app
);
962 case BUTTON_PLAYLIST_LOAD
:
963 omnplay_playlist_load(app
);
965 case BUTTON_PLAYLIST_SAVE
:
966 omnplay_playlist_save(app
);
968 case BUTTON_PLAYLIST_BLOCK_SINGLE
:
969 case BUTTON_PLAYLIST_BLOCK_LOOP
:
970 omnplay_playlist_block(app
, button
);
972 case BUTTON_PLAYLIST_ITEM_UP
:
973 omnplay_playlist_item_swap(app
, -1);
975 case BUTTON_PLAYLIST_ITEM_DOWN
:
976 omnplay_playlist_item_swap(app
, +1);
978 case BUTTON_PLAYER_CUE
:
979 case BUTTON_PLAYER_PLAY
:
980 case BUTTON_PLAYER_PAUSE
:
981 case BUTTON_PLAYER_STOP
:
982 omnplay_ctl(app
, button
);
984 case BUTTON_LIBRARY_ADD
:
985 omnplay_library_add(app
, 0);
987 case BUTTON_LIBRARY_REFRESH
:
988 omnplay_library_refresh(app
);
990 case BUTTON_LIBRARY_FIND
:
991 omnplay_library_search(app
, 0);
993 case BUTTON_LIBRARY_FIND_NEXT
:
994 omnplay_library_search(app
, 1);
1001 static gboolean
on_button_click(GtkWidget
*button
, gpointer user_data
)
1004 omnplay_instance_t
* app
= (omnplay_instance_t
*)user_data
;
1006 for(i
= 1; i
< BUTTON_LAST
; i
++)
1007 if(app
->buttons
[i
] == button
)
1008 return omnplay_button_click(app
, (control_buttons_t
)i
);
1013 static void omnplay_playlist_item_copy(omnplay_instance_t
* app
)
1017 list
= get_selected_items_playlist(app
);
1020 for(i
= 0; i
< list
[0]; i
++)
1021 app
->clipboard
.item
[i
] = app
->playlist
.item
[list
[i
+ 1]];
1022 app
->clipboard
.count
= list
[0];
1027 static void omnplay_playlist_item_paste(omnplay_instance_t
* app
, int after
)
1030 playlist_item_t
* items
;
1031 playlist_item_type_t t
;
1033 /* find insert position */
1034 idx
= get_first_selected_item_playlist(app
);
1040 if(!omnplay_playlist_insert_check(app
, idx
, &t
))
1044 if(app
->clipboard
.count
)
1046 for(i
= 0; i
< app
->clipboard
.count
; i
++)
1048 app
->clipboard
.item
[i
].type
= t
;
1049 app
->clipboard
.item
[i
].error
= 0;
1051 omnplay_playlist_insert_items(app
, idx
, app
->clipboard
.item
, app
->clipboard
.count
);
1055 static gboolean
on_playlist_grid_key(GtkWidget
*widget
, GdkEventKey
*event
, gpointer data
)
1057 omnplay_instance_t
* app
= (omnplay_instance_t
*)data
;
1059 switch(event
->keyval
)
1063 if(event
->state
& GDK_CONTROL_MASK
)
1065 omnplay_playlist_item_copy(app
);
1071 if(event
->state
& GDK_CONTROL_MASK
)
1073 omnplay_playlist_item_paste(app
, 0);
1079 if(event
->state
& GDK_CONTROL_MASK
)
1081 omnplay_playlist_item_copy(app
);
1082 omnplay_playlist_item_del(app
);
1088 if(event
->state
& GDK_CONTROL_MASK
)
1090 omnplay_playlist_save(app
);
1096 if(event
->state
& GDK_CONTROL_MASK
)
1098 omnplay_playlist_load(app
);
1102 case GDK_KEY_uparrow
:
1103 if(event
->state
& GDK_CONTROL_MASK
)
1105 omnplay_playlist_item_swap(app
, -1);
1109 case GDK_KEY_downarrow
:
1110 if(event
->state
& GDK_CONTROL_MASK
)
1112 omnplay_playlist_item_swap(app
, -1);
1117 omnplay_ctl(app
, BUTTON_PLAYER_PLAY
);
1119 case GDK_KEY_Return
:
1120 omnplay_ctl(app
, BUTTON_PLAYER_CUE
);
1122 case GDK_KEY_Insert
:
1123 omnplay_playlist_item_add(app
, 0);
1125 case GDK_KEY_Delete
:
1126 omnplay_playlist_item_del(app
);
1130 omnplay_playlist_item_edit(app
);
1137 static gboolean
on_library_grid_key(GtkWidget
*widget
, GdkEventKey
*event
, gpointer data
)
1139 omnplay_instance_t
* app
= (omnplay_instance_t
*)data
;
1141 switch(event
->keyval
)
1145 if(event
->state
& GDK_CONTROL_MASK
)
1148 playlist_item_t
* items
;
1150 items
= omnplay_library_get_selected(app
, &count
);
1156 for(i
= 0; i
< count
; i
++)
1157 app
->clipboard
.item
[i
] = items
[i
];
1159 app
->clipboard
.count
= count
;
1167 if(event
->state
& GDK_CONTROL_MASK
)
1169 g_warning("CTRL+v\n");
1175 if(event
->state
& GDK_CONTROL_MASK
)
1177 g_warning("CTRL+x\n");
1181 case GDK_KEY_BackSpace
:
1182 omnplay_library_add(app
, 0);
1185 omnplay_library_refresh(app
);
1192 static gboolean
on_library_grid_button(GtkWidget
*widget
, GdkEventButton
*event
, gpointer data
)
1194 // g_warning("on_library_grid_button: event->button=%d, event->type=%d", event->button, event->type);
1196 if(event
->button
==1 && event
->type
==GDK_2BUTTON_PRESS
)
1198 omnplay_library_add((omnplay_instance_t
* )data
, 0);
1205 static gboolean
on_playlist_grid_button(GtkWidget
*widget
, GdkEventButton
*event
, gpointer data
)
1207 // g_warning("on_playlist_grid_button");
1209 if(event
->button
==1 && event
->type
==GDK_2BUTTON_PRESS
)
1211 omnplay_ctl((omnplay_instance_t
* )data
, BUTTON_PLAYER_CUE
);
1218 void omnplay_init(omnplay_instance_t
* app
)
1221 pthread_mutexattr_t attr
;
1223 pthread_mutexattr_init(&attr
);
1224 pthread_mutexattr_settype(&attr
, PTHREAD_MUTEX_RECURSIVE
);
1226 gtk_signal_connect( GTK_OBJECT( app
->window
), "delete-event",
1227 GTK_SIGNAL_FUNC(on_main_window_delete_event
), app
);
1229 gtk_signal_connect( GTK_OBJECT( app
->window
), "destroy",
1230 GTK_SIGNAL_FUNC(on_main_window_destroy
), app
);
1232 gtk_widget_add_events(app
->playlist_grid
, GDK_BUTTON_PRESS_MASK
);
1233 gtk_widget_add_events(app
->playlist_grid
, GDK_KEY_PRESS_MASK
);
1234 gtk_signal_connect(GTK_OBJECT(app
->playlist_grid
), "key-press-event",
1235 GTK_SIGNAL_FUNC(on_playlist_grid_key
), app
);
1237 gtk_widget_add_events(app
->library_grid
, GDK_BUTTON_PRESS_MASK
);
1238 gtk_widget_add_events(app
->library_grid
, GDK_KEY_PRESS_MASK
);
1239 gtk_signal_connect(GTK_OBJECT(app
->library_grid
), "key-press-event",
1240 GTK_SIGNAL_FUNC(on_library_grid_key
), app
);
1242 gtk_signal_connect(GTK_OBJECT(app
->playlist_grid
), "button-press-event",
1243 GTK_SIGNAL_FUNC(on_playlist_grid_button
), app
);
1245 gtk_signal_connect(GTK_OBJECT(app
->library_grid
), "button-press-event",
1246 GTK_SIGNAL_FUNC(on_library_grid_button
), app
);
1249 pthread_mutex_init(&app
->players
.lock
, &attr
);
1250 pthread_mutex_init(&app
->playlist
.lock
, &attr
);
1251 pthread_mutex_init(&app
->library
.lock
, &attr
);
1253 /* create a omneon status thread */
1254 for(i
= 0; i
< app
->players
.count
; i
++)
1255 app
->players
.item
[i
].thread
= g_thread_create(
1256 omnplay_thread_proc
, &app
->players
.item
[i
], TRUE
, NULL
);
1258 /* attach buttons click */
1259 for(i
= 1; i
< BUTTON_LAST
; i
++)
1260 gtk_signal_connect(GTK_OBJECT(app
->buttons
[i
]), "clicked",
1261 GTK_SIGNAL_FUNC( on_button_click
), app
);
1264 omnplay_library_load(app
);
1266 pthread_mutexattr_destroy(&attr
);
1269 void omnplay_release(omnplay_instance_t
* app
)
1275 for(i
= 0; i
< app
->players
.count
; i
++)
1276 /* create a omneon status thread */
1277 g_thread_join(app
->players
.item
[i
].thread
);
1280 pthread_mutex_destroy(&app
->players
.lock
);
1283 pthread_mutex_destroy(&app
->playlist
.lock
);
1286 omnplay_library_save(app
);
1288 /* destroy library lock */
1289 pthread_mutex_destroy(&app
->library
.lock
);
1292 void omnplay_playlist_normalize(omnplay_instance_t
* app
)
1296 /* normalize playlist */
1297 for(i
= 0; i
< app
->playlist
.count
; i
++)
1298 if(omnplay_library_normalize_item(app
, &app
->playlist
.item
[i
]))
1299 omnplay_playlist_draw_item(app
, i
);