33efdd6cf4ea5c8a4310254d35a9005cb542d968
[omnplay] / src / omnplay.cpp
1 /*
2 * omnplay.c -- GTK+ 2 omnplay
3 * Copyright (C) 2011 Maksym Veremeyenko <verem@m1stereo.tv>
4 *
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.
9 *
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.
14 *
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.
18 */
19
20 #ifndef _GNU_SOURCE
21 #define _GNU_SOURCE
22 #endif
23
24 #ifdef HAVE_CONFIG_H
25 # include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <gtk/gtk.h>
32 #include <gdk/gdkkeysyms.h>
33 #include <pthread.h>
34
35 #include "omnplay.h"
36 #include "ui.h"
37 #include "opts.h"
38 #include "timecode.h"
39
40 #include "omplrclnt.h"
41
42 static gboolean on_main_window_delete_event( GtkWidget *widget, GdkEvent *event, gpointer user_data )
43 {
44 gtk_exit(0);
45 return TRUE;
46 }
47
48 omnplay_instance_t* omnplay_create(int argc, char** argv)
49 {
50 int i, c;
51 omnplay_instance_t* app;
52
53 /* prepare application instance */
54 app = (omnplay_instance_t*)malloc(sizeof(omnplay_instance_t));
55 memset(app, 0, sizeof(omnplay_instance_t));
56
57 /* load parameters from command line */
58 if(!omnplay_opt(argc, argv, app) && app->players.count)
59 app->window = ui_omnplay(app);
60 else
61 omnplay_usage();
62
63 return app;
64 };
65
66 void omnplay_destroy(omnplay_instance_t* app)
67 {
68 free(app);
69 };
70
71 static int find_index_of_playlist_item(omnplay_instance_t* app, int start, int idx)
72 {
73 while(1)
74 {
75 if(app->playlist.item[start].omn_idx == idx)
76 return start;
77
78 if(app->playlist.item[start].type & OMNPLAY_PLAYLIST_BLOCK_END)
79 break;
80
81 start++;
82 };
83
84 return -1;
85 };
86
87 static void omnplay_update_status(omnplay_player_t* player, OmPlrStatus *prev , OmPlrStatus *curr)
88 {
89 int idx;
90 char tc_cur[32], tc_rem[32], state[32], status[32];
91 const char *clip;
92
93 if(curr)
94 {
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;
99
100 switch(curr->state)
101 {
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;
107 };
108 }
109 else
110 {
111 tc_cur[0] = 0;
112 tc_rem[0] = 0;
113 clip = "";
114 state[0] = 0;
115 strcpy(status, "OFFLINE");
116 };
117
118 /* update status in status page */
119 gdk_threads_enter();
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);
125 gdk_flush();
126 gdk_threads_leave();
127
128 /* update remaining time */
129 gdk_threads_enter();
130 pthread_mutex_lock(&player->app->playlist.lock);
131 pthread_mutex_lock(&player->app->players.lock);
132 if(curr->state == omPlrStatePlay || curr->state == omPlrStateCuePlay)
133 {
134 idx = find_index_of_playlist_item(player->app, player->playlist_start, curr->currClipNum);
135 if(idx >= 0)
136 {
137 frames2tc(curr->currClipStartPos + curr->currClipLen - curr->pos, 25.0, tc_rem);
138 omnplay_playlist_draw_item_rem(player->app, idx, tc_rem);
139 }
140 if(curr->currClipNum != prev->currClipNum && 1 != prev->numClips)
141 {
142 tc_rem[0] = 0;
143 idx = find_index_of_playlist_item(player->app, player->playlist_start, prev->currClipNum);
144 if(idx >= 0)
145 omnplay_playlist_draw_item_rem(player->app, idx, tc_rem);
146 };
147 }
148 else
149 {
150 tc_rem[0] = 0;
151 idx = find_index_of_playlist_item(player->app, player->playlist_start, curr->currClipNum);
152 if(idx >= 0)
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);
155 if(idx >= 0)
156 omnplay_playlist_draw_item_rem(player->app, idx, tc_rem);
157 };
158 pthread_mutex_unlock(&player->app->players.lock);
159 pthread_mutex_unlock(&player->app->playlist.lock);
160 gdk_flush();
161 gdk_threads_leave();
162
163
164 memcpy(prev, curr, sizeof(OmPlrStatus));
165 };
166
167 static void* omnplay_thread_proc(void* data)
168 {
169 int r;
170 OmPlrStatus st_curr, st_prev;
171 omnplay_player_t* player = (omnplay_player_t*)data;
172
173 /* connect */
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);
177 if(r)
178 {
179 fprintf(stderr, "ERROR: OmPlrOpen(%s, %s) failed with 0x%.8X\n",
180 player->host, player->name, r);
181
182 return (void*)r;
183 };
184
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);
189
190 /* setup directory */
191 if(player->app->players.path[0])
192 {
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);
196
197 if(r)
198 {
199 fprintf(stderr, "ERROR: OmPlrClipSetDirectory(%s) failed with 0x%.8X\n",
200 player->app->players.path, r);
201
202 pthread_mutex_lock(&player->app->players.lock);
203 OmPlrClose((OmPlrHandle)player->handle);
204 pthread_mutex_unlock(&player->app->players.lock);
205
206 return (void*)r;
207 };
208 };
209
210 /* endless loop */
211 for(r = 0 ; !player->app->f_exit && !r;)
212 {
213 /* sleep */
214 usleep(100000);
215
216 /* get status */
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);
221
222 if(r)
223 fprintf(stderr, "ERROR: OmPlrGetPlayerStatus failed with 0x%.8X\n", r);
224 else
225 if(memcmp(&st_curr, &st_prev, sizeof(OmPlrStatus)))
226 omnplay_update_status(player, &st_prev , &st_curr);
227 };
228
229 pthread_mutex_lock(&player->app->players.lock);
230 OmPlrClose((OmPlrHandle)player->handle);
231 pthread_mutex_unlock(&player->app->players.lock);
232
233 return NULL;
234 };
235
236 void get_selected_items_playlist_proc(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
237 {
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;
242 };
243
244 static int* get_selected_items_playlist(omnplay_instance_t* app)
245 {
246 int* list = NULL;
247 GtkTreeSelection *selection;
248
249 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(app->playlist_grid));
250 if(selection)
251 {
252 list = (int*)malloc(sizeof(int) * (MAX_PLAYLIST_ITEMS + 1));
253 memset(list, 0, sizeof(int) * (MAX_PLAYLIST_ITEMS + 1));
254
255 gtk_tree_selection_selected_foreach(
256 selection,
257 get_selected_items_playlist_proc,
258 list);
259
260 if(!list[0])
261 {
262 free(list);
263 list = NULL;
264 };
265 };
266
267 return list;
268 };
269
270 static int idx_in_players_range(omnplay_instance_t* app, int idx)
271 {
272 int i, r = 0;
273
274 for(i = 0; i < app->players.count && !r; i++)
275 {
276 int a, b;
277
278 a = app->players.item[i].playlist_start;
279 b = app->players.item[i].playlist_length;
280
281 if(b <= 0)
282 continue;
283
284 b = a + b - 1;
285
286 if(idx >= a && idx <= b) r = 1;
287 };
288
289 return r;
290 };
291
292 static int idxs_in_players_range(omnplay_instance_t* app, int start, int stop)
293 {
294 int i, r = 0;
295
296 for(i = 0; i < app->players.count && !r; i++)
297 {
298 int a, b;
299
300 a = app->players.item[i].playlist_start;
301 b = app->players.item[i].playlist_length;
302
303 if(b <= 0)
304 continue;
305
306 b = a + b - 1;
307
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))
313 r = 1;
314 };
315
316 return r;
317 };
318
319 static void omnplay_playlist_block(omnplay_instance_t* app, control_buttons_t button)
320 {
321 int start, stop, r, i;
322 int* list = get_selected_items_playlist(app);
323
324 if(!list)
325 return;
326
327 pthread_mutex_lock(&app->playlist.lock);
328 pthread_mutex_lock(&app->players.lock);
329
330 start = list[1];
331 stop = list[list[0]];
332
333 if(!idxs_in_players_range(app, start, stop))
334 {
335 int loop = (button == BUTTON_PLAYLIST_BLOCK_LOOP)?OMNPLAY_PLAYLIST_BLOCK_LOOP:0;
336
337 /* update selected item */
338 for(i = start; i <= stop; i++)
339 {
340 int t = OMNPLAY_PLAYLIST_BLOCK_BODY | loop;
341
342 if(i == start) t |= OMNPLAY_PLAYLIST_BLOCK_BEGIN;
343 if(i == stop) t |= OMNPLAY_PLAYLIST_BLOCK_END;
344
345 app->playlist.item[i].type = (playlist_item_type_t)t;
346
347 omnplay_playlist_draw_item(app, i);
348 };
349
350 /* update border items */
351 if(!start && !(app->playlist.item[start - 1].type & OMNPLAY_PLAYLIST_BLOCK_END))
352 {
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);
356 };
357 if((stop + 1) < app->playlist.count && !(app->playlist.item[stop + 1].type & OMNPLAY_PLAYLIST_BLOCK_BEGIN))
358 {
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);
362 };
363 }
364 else
365 fprintf(stderr, "omnplay_playlist_block: range [%d %d] do OVERLAP player\n",
366 start, stop);
367
368 pthread_mutex_unlock(&app->players.lock);
369 pthread_mutex_unlock(&app->playlist.lock);
370
371 free(list);
372 };
373
374 static int get_first_selected_item_playlist(omnplay_instance_t* app)
375 {
376 int idx;
377 int* list = get_selected_items_playlist(app);
378 if(!list) return -1;
379 idx = list[1];
380 free(list);
381 return idx;
382 };
383
384 static int get_playlist_block(omnplay_instance_t* app, int idx, int* start_ptr, int* stop_ptr)
385 {
386 int start, stop;
387
388 for(start = idx; start >= 0; start--)
389 if(app->playlist.item[start].type & OMNPLAY_PLAYLIST_BLOCK_BEGIN)
390 break;
391
392 for(stop = idx; stop < app->playlist.count; stop++)
393 if(app->playlist.item[stop].type & OMNPLAY_PLAYLIST_BLOCK_END)
394 break;
395
396 fprintf(stderr, "get_playlist_block: range %d -> %d\n", start, stop);
397
398 /* check block range */
399 if(start >= 0 && stop < app->playlist.count)
400 {
401 *start_ptr = start;
402 *stop_ptr = stop;
403 return (stop - start + 1);
404 };
405
406 return -1;
407 };
408
409 static omnplay_player_t *get_player_at_pos(omnplay_instance_t* app, int pos)
410 {
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];
414
415 return NULL;
416 };
417
418 static void omnplay_playlist_item_del(omnplay_instance_t* app)
419 {
420
421 };
422
423 static int omnplay_playlist_insert_check(omnplay_instance_t* app, int idx, playlist_item_type_t* t)
424 {
425 *t = OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE;
426
427 /* before or after playlist */
428 if(!idx || idx == app->playlist.count)
429 return 1;
430
431 /* check for block borders */
432 if( app->playlist.item[idx - 1].type & OMNPLAY_PLAYLIST_BLOCK_END &&
433 app->playlist.item[idx + 0].type & OMNPLAY_PLAYLIST_BLOCK_BEGIN)
434 return 1;
435
436 /* check for playing block */
437 if(idx_in_players_range(app, idx))
438 return 0;
439
440 if(app->playlist.item[idx].type & OMNPLAY_PLAYLIST_BLOCK_LOOP)
441 *t = OMNPLAY_PLAYLIST_ITEM_LOOP_BODY;
442 else
443 *t = OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY;
444
445 return 1;
446 };
447
448 static void omnplay_playlist_insert_items(omnplay_instance_t* app, int idx,
449 playlist_item_t* items, int count)
450 {
451 int i;
452 GtkTreePath* path;
453
454 pthread_mutex_lock(&app->playlist.lock);
455 pthread_mutex_lock(&app->players.lock);
456
457 /* shift playlist items */
458 memmove
459 (
460 &app->playlist.item[idx + count],
461 &app->playlist.item[idx],
462 (app->playlist.count - idx) * sizeof(playlist_item_t)
463 );
464
465 /* copy new items */
466 memcpy
467 (
468 &app->playlist.item[idx],
469 items,
470 count * sizeof(playlist_item_t)
471 );
472
473 /* increment servers indexes */
474 for(i = 0; i < app->players.count; i++)
475 if(app->players.item[i].playlist_start >= idx)
476 app->players.item[i].playlist_start += idx;
477
478 /* increment items count */
479 app->playlist.count += count;
480
481 /* redraw playlist */
482 omnplay_playlist_draw(app);
483
484 /* select */
485 path = gtk_tree_path_new_from_indices(idx + count, -1);
486 gtk_tree_selection_select_path(gtk_tree_view_get_selection(GTK_TREE_VIEW(app->playlist_grid)), path);
487 gtk_tree_view_set_cursor(GTK_TREE_VIEW(app->playlist_grid), path, NULL, FALSE);
488 gtk_tree_path_free(path);
489
490 pthread_mutex_unlock(&app->players.lock);
491 pthread_mutex_unlock(&app->playlist.lock);
492 };
493
494 static void omnplay_playlist_item_add(omnplay_instance_t* app, int after)
495 {
496 int idx;
497 playlist_item_t item;
498 playlist_item_type_t t;
499
500 /* find insert position */
501 idx = get_first_selected_item_playlist(app);
502 if(idx < 0)
503 idx = 0;
504 else
505 idx += (after)?1:0;
506
507 if(!omnplay_playlist_insert_check(app, idx, &t))
508 return;
509
510 fprintf(stderr, "allowed insert into idx=%d\n", idx);
511
512 /* clear item */
513 memset(&item, 0, sizeof(playlist_item_t));
514 if(ui_playlist_item_dialog(app, &item))
515 {
516 item.type = t;
517 omnplay_playlist_insert_items(app, idx, &item, 1);
518 };
519 };
520
521 static void omnplay_playlist_item_edit(omnplay_instance_t* app)
522 {
523
524 };
525
526 static void omnplay_ctl(omnplay_instance_t* app, control_buttons_t button)
527 {
528 int i, r;
529 int idx, start, stop;
530 omnplay_player_t *player;
531
532 pthread_mutex_lock(&app->playlist.lock);
533
534 idx = get_first_selected_item_playlist(app);
535
536 if(idx < 0)
537 {
538 pthread_mutex_unlock(&app->playlist.lock);
539 return;
540 };
541
542 fprintf(stderr, "cue: selected item is %d\n", idx);
543
544 if(get_playlist_block(app, idx, &start, &stop) < 0)
545 {
546 pthread_mutex_unlock(&app->playlist.lock);
547 return;
548 };
549
550 fprintf(stderr, "cue: range %d -> %d\n", start, stop);
551
552 player = get_player_at_pos(app, start);
553
554 if(!player)
555 {
556 pthread_mutex_unlock(&app->playlist.lock);
557 return;
558 };
559
560 pthread_mutex_lock(&app->players.lock);
561
562 if(BUTTON_PLAYER_STOP == button || BUTTON_PLAYER_CUE == button)
563 {
564 /* stop */
565 OmPlrStop((OmPlrHandle)player->handle);
566
567 /* detach previous clips */
568 player->playlist_length = -1;
569 OmPlrDetachAllClips((OmPlrHandle)player->handle);
570 };
571
572 if(BUTTON_PLAYER_CUE == button)
573 {
574 int o, c, p = 0;
575
576 /* Attach clips to timeline */
577 for(i = start, c = 0, o = 0; i <= stop; i++)
578 {
579 OmPlrClipInfo clip;
580
581 /* get clip info */
582 clip.maxMsTracks = 0;
583 clip.size = sizeof(clip);
584 r = OmPlrClipGetInfo((OmPlrHandle)player->handle, app->playlist.item[i].id, &clip);
585
586 if(!r)
587 {
588 unsigned int l;
589
590 fprintf(stderr, "OmPlrClipGetInfo(%s): firstFrame=%d, lastFrame=%d\n",
591 app->playlist.item[i].id, clip.firstFrame, clip.lastFrame);
592
593 /* should we fix playlist clip timings */
594 if(!(
595 app->playlist.item[i].in >= clip.firstFrame &&
596 app->playlist.item[i].in + app->playlist.item[i].dur <= clip.lastFrame) ||
597 !app->playlist.item[i].dur)
598 {
599 fprintf(stderr, "cue: item [%s] will be updated [%d;%d]->[%d;%d]\n",
600 app->playlist.item[i].id,
601 app->playlist.item[i].in, app->playlist.item[i].dur,
602 clip.firstFrame, clip.lastFrame - clip.firstFrame);
603
604 app->playlist.item[i].in = clip.firstFrame;
605 app->playlist.item[i].dur = clip.lastFrame - clip.firstFrame;
606 omnplay_playlist_draw_item(app, i);
607 };
608
609 r = OmPlrAttach((OmPlrHandle)player->handle,
610 app->playlist.item[i].id,
611 app->playlist.item[i].in,
612 app->playlist.item[i].in + app->playlist.item[i].dur,
613 0, omPlrShiftModeAfter, &l);
614 };
615
616 if(r)
617 {
618 fprintf(stderr, "cue: failed with %d, %s\n", r, OmPlrGetErrorString((OmPlrError)r));
619 app->playlist.item[i].omn_idx = -1;
620 app->playlist.item[i].omn_offset = -1;
621 }
622 else
623 {
624 app->playlist.item[i].omn_idx = c;
625 app->playlist.item[i].omn_offset = o;
626
627 /* save selected item offset */
628 if(i == idx) p = o;
629
630 c++;
631 o += app->playlist.item[i].dur;
632 };
633 };
634
635 if(c)
636 {
637 OmPlrStatus hs;
638
639 /* Set timeline min/max */
640 OmPlrSetMinPosMin((OmPlrHandle)player->handle);
641 OmPlrSetMaxPosMax((OmPlrHandle)player->handle);
642
643 /* Set timeline position */
644 hs.minPos = 0;
645 hs.size = sizeof(OmPlrStatus);
646 OmPlrGetPlayerStatus((OmPlrHandle)player->handle, &hs);
647 OmPlrSetPos((OmPlrHandle)player->handle, hs.minPos + p);
648
649 /* setup loop */
650 if(app->playlist.item[start].type & OMNPLAY_PLAYLIST_BLOCK_LOOP)
651 OmPlrLoop((OmPlrHandle)player->handle, hs.minPos, hs.maxPos);
652 else
653 OmPlrLoop((OmPlrHandle)player->handle, hs.minPos, hs.minPos);
654
655 player->playlist_start = start;
656 player->playlist_length = stop - start + 1;
657
658 /* Cue */
659 OmPlrCuePlay((OmPlrHandle)player->handle, 0.0);
660 };
661 };
662
663 if(BUTTON_PLAYER_PLAY == button)
664 {
665 /* play */
666 OmPlrPlay((OmPlrHandle)player->handle, 1.0);
667 };
668
669 if(BUTTON_PLAYER_PAUSE == button)
670 /* pause */
671 OmPlrPlay((OmPlrHandle)player->handle, 0.0);
672
673 pthread_mutex_unlock(&app->players.lock);
674
675 pthread_mutex_unlock(&app->playlist.lock);
676 };
677
678 static gboolean omnplay_button_click(omnplay_instance_t* app, control_buttons_t button)
679 {
680 switch(button)
681 {
682 case BUTTON_PLAYLIST_ITEM_ADD:
683 omnplay_playlist_item_add(app, 0);
684 break;
685 case BUTTON_PLAYLIST_ITEM_DEL:
686 omnplay_playlist_item_del(app);
687 break;
688 case BUTTON_PLAYLIST_ITEM_EDIT:
689 omnplay_playlist_item_edit(app);
690 break;
691 case BUTTON_PLAYLIST_LOAD:
692 omnplay_playlist_load(app);
693 break;
694 case BUTTON_PLAYLIST_SAVE:
695 omnplay_playlist_save(app);
696 break;
697 case BUTTON_PLAYLIST_BLOCK_SINGLE:
698 case BUTTON_PLAYLIST_BLOCK_LOOP:
699 omnplay_playlist_block(app, button);
700 break;
701 case BUTTON_PLAYLIST_ITEM_UP:
702 case BUTTON_PLAYLIST_ITEM_DOWN:
703 break;
704 case BUTTON_PLAYER_CUE:
705 case BUTTON_PLAYER_PLAY:
706 case BUTTON_PLAYER_PAUSE:
707 case BUTTON_PLAYER_STOP:
708 omnplay_ctl(app, button);
709 break;
710 case BUTTON_LIBRARY_ADD:
711 case BUTTON_LIBRARY_REFRESH:
712 break;
713 };
714
715 return TRUE;
716 };
717
718 static gboolean on_button_click(GtkWidget *button, gpointer user_data)
719 {
720 int i;
721 omnplay_instance_t* app = (omnplay_instance_t*)user_data;
722
723 for(i = 1; i < BUTTON_LAST; i++)
724 if(app->buttons[i] == button)
725 return omnplay_button_click(app, (control_buttons_t)i);
726
727 return FALSE;
728 };
729
730 void omnplay_init(omnplay_instance_t* app)
731 {
732 int i;
733 pthread_mutexattr_t attr;
734
735 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
736
737 gtk_signal_connect( GTK_OBJECT( app->window ), "destroy",
738 GTK_SIGNAL_FUNC(on_main_window_delete_event), app);
739
740 /* create lock */
741 pthread_mutex_init(&app->players.lock, &attr);
742
743 /* create a omneon status thread */
744 for(i = 0; i < app->players.count; i++)
745 pthread_create(&app->players.item[i].thread, NULL,
746 omnplay_thread_proc, &app->players.item[i]);
747
748 /* create lock */
749 pthread_mutex_init(&app->playlist.lock, &attr);
750
751 /* attach buttons click */
752 for(i = 1; i < BUTTON_LAST; i++)
753 gtk_signal_connect(GTK_OBJECT(app->buttons[i]), "clicked",
754 GTK_SIGNAL_FUNC( on_button_click), app );
755
756 };
757
758 void omnplay_release(omnplay_instance_t* app)
759 {
760 int i;
761 void* r;
762
763 app->f_exit = 1;
764
765 for(i = 0; i < app->players.count; i++)
766 /* create a omneon status thread */
767 pthread_join(app->players.item[i].thread, &r);
768
769 /* destroy lock */
770 pthread_mutex_destroy(&app->players.lock);
771
772 /* destroy lock */
773 pthread_mutex_destroy(&app->playlist.lock);
774 };