research.m1stereo.tv/gitweb/ - melted_gui/blob - src/playlist.c

   1 /*
   2  * playlist.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 #ifdef HAVE_CONFIG_H
  21 #  include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <pthread.h>
  30
  31 #include "omnplay.h"
  32 #include "ui.h"
  33 #include "timecode.h"
  34
  35 static int load_file_ply(omnplay_instance_t* app, char* filename)
  36 {
  37     FILE* f;
  38     char *ID, *CH, *B, *IN, *OUT, *DUR, *REST, *l;
  39     int count = 0, i;
  40     playlist_item_t* items;
  41
  42     /* allocate space for strings and items */
  43     items = malloc(sizeof(playlist_item_t) * MAX_PLAYLIST_ITEMS);
  44     memset(items, 0, sizeof(playlist_item_t) * MAX_PLAYLIST_ITEMS);
  45     ID = malloc(PATH_MAX);
  46     CH = malloc(PATH_MAX);
  47     B = malloc(PATH_MAX);
  48     IN = malloc(PATH_MAX);
  49     OUT = malloc(PATH_MAX);
  50     DUR = malloc(PATH_MAX);
  51     REST = malloc(PATH_MAX);
  52     l = malloc(PATH_MAX);
  53
  54     /* open and process file */
  55     f = fopen(filename, "rt");
  56     if(f)
  57     {
  58         while( !feof(f) )
  59         {
  60             char* s;
  61
  62             /* load string */
  63             memset(l, 0, PATH_MAX);
  64             fgets(l, PATH_MAX, f);
  65
  66             /* remove newlines */
  67             if( (s = strchr(l, '\n')) ) *s = 0;
  68             if( (s = strchr(l, '\r')) ) *s = 0;
  69             if( (s = strchr(l, '\t')) ) *s = 0;
  70
  71             /* check for empty line */
  72             if(l[0] && l[0] != '#')
  73             {
  74                 if (6 != sscanf(l, "%128[^,],%128[^,],%128[^,],%128[^,],%128[^,],%128[^,],%s",
  75                     ID, CH, B, IN, OUT, DUR, REST))
  76                 {
  77                     /* setup item */
  78                     tc2frames(IN, 25.0, &items[count].in);
  79                     tc2frames(DUR, 25.0, &items[count].dur);
  80                     strncpy(items[count].id, ID, PATH_MAX);
  81                     items[count].player = atol(CH) - 1;
  82                     switch(atol(B))
  83                     {
  84                         case 1: items[count].type = OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE; break;
  85                         case 2: items[count].type = OMNPLAY_PLAYLIST_ITEM_LOOP_BEGIN; break;
  86                         case 3: items[count].type = OMNPLAY_PLAYLIST_ITEM_LOOP_BODY; break;
  87                         case 4: items[count].type = OMNPLAY_PLAYLIST_ITEM_LOOP_END; break;
  88                         case 6: items[count].type = OMNPLAY_PLAYLIST_ITEM_BLOCK_END; break;
  89                         case 0:
  90                             if(!count)
  91                                 items[count].type = OMNPLAY_PLAYLIST_ITEM_BLOCK_BEGIN;
  92                             else if(items[count - 1].type == OMNPLAY_PLAYLIST_ITEM_BLOCK_BEGIN ||
  93                                     items[count - 1].type == OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY)
  94                                 items[count].type = OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY;
  95                             else
  96                                 items[count].type = OMNPLAY_PLAYLIST_ITEM_BLOCK_BEGIN;
  97                             break;
  98                     };
  99 #if 0
 100                     {
 101                         char* n;
 102                         switch(items[count].type)
 103                         {
 104                             case OMNPLAY_PLAYLIST_ITEM_BLOCK_BEGIN:       n = "BLOCK_BEGIN"; break;
 105                             case OMNPLAY_PLAYLIST_ITEM_BLOCK_BODY:        n = "BLOCK_BODY"; break;
 106                             case OMNPLAY_PLAYLIST_ITEM_BLOCK_END:         n = "BLOCK_END"; break;
 107                             case OMNPLAY_PLAYLIST_ITEM_BLOCK_SINGLE:      n = "BLOCK_SINGLE"; break;
 108                             case OMNPLAY_PLAYLIST_ITEM_LOOP_BEGIN:        n = "LOOP_BEGIN"; break;
 109                             case OMNPLAY_PLAYLIST_ITEM_LOOP_BODY:         n = "LOOP_BODY"; break;
 110                             case OMNPLAY_PLAYLIST_ITEM_LOOP_END:          n = "LOOP_END"; break;
 111                             case OMNPLAY_PLAYLIST_ITEM_LOOP_SINGLE:       n = "LOOP_SINGLE"; break;
 112                         };
 113                         fprintf(stderr, "src=[%s]\ndst=[idx=%d,block=%s,block_id=%d,in=%d,out=%d]\n",
 114                             l, count, n, items[count].type, items[count].in, items[count].dur);
 115                     };
 116 #endif
 117
 118                     count++;
 119                 }
 120             };
 121         }
 122
 123         fclose(f);
 124     }
 125
 126     /* add loaded items to playlist */
 127     if(count)
 128     {
 129         pthread_mutex_lock(&app->playlist.lock);
 130         for(i = 0; i < count && app->playlist.count + 1 < MAX_PLAYLIST_ITEMS; i++)
 131         {
 132             omnplay_library_normalize_item(app, &items[i]);
 133             app->playlist.item[app->playlist.count++] = items[i];
 134         };
 135         app->playlist.ver_curr++;
 136         pthread_mutex_unlock(&app->playlist.lock);
 137     }
 138
 139     /* free data */
 140     free(items);
 141     free(ID);
 142     free(CH);
 143     free(IN);
 144     free(OUT);
 145     free(DUR);
 146     free(REST);
 147     free(l);
 148
 149     return count;
 150 };
 151
 152 void omnplay_playlist_load(omnplay_instance_t* app)
 153 {
 154     int r;
 155     GtkWidget *dialog;
 156
 157     dialog = gtk_file_chooser_dialog_new("Open File",
 158         GTK_WINDOW (app->window),
 159         GTK_FILE_CHOOSER_ACTION_OPEN,
 160         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 161         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 162         NULL);
 163
 164     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
 165         (app->playlist.path)?app->playlist.path:getenv("HOME"));
 166
 167     r = gtk_dialog_run(GTK_DIALOG(dialog));
 168
 169     if(r == GTK_RESPONSE_ACCEPT)
 170     {
 171         char *filename;
 172
 173         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 174
 175         r = load_file_ply(app, filename);
 176
 177         if(r)
 178             omnplay_playlist_draw(app);
 179
 180         if(app->playlist.path)
 181             g_free(app->playlist.path);
 182         if((app->playlist.path = filename))
 183         {
 184             char* e = strrchr(app->playlist.path, '/');
 185             if(e) *e = 0;
 186         }
 187     }
 188
 189     gtk_widget_destroy (dialog);
 190 };
 191
 192 void omnplay_playlist_save(omnplay_instance_t* app)
 193 {
 194 };
 195
 196 void omnplay_playlist_draw(omnplay_instance_t* app)
 197 {
 198     int i;
 199     char tc1[12], tc2[12];
 200     GtkListStore *list_store;
 201     GtkTreeIter iter;
 202
 203     list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(app->playlist_grid)));
 204     gtk_list_store_clear(list_store);
 205
 206     pthread_mutex_lock(&app->playlist.lock);
 207
 208     for(i = 0;i < app->playlist.count; i++)
 209     {
 210         gtk_list_store_append(list_store, &iter);
 211
 212         gtk_list_store_set(list_store, &iter,
 213             0, "",
 214             1, app->playlist.block_icons[app->playlist.item[i].type],
 215             2, (0 == app->playlist.item[i].player)?"A":"B",
 216             3, app->playlist.item[i].id,
 217             4, frames2tc(app->playlist.item[i].in, 25.0, tc1),
 218             5, frames2tc(app->playlist.item[i].dur, 25.0, tc2),
 219             6, app->playlist.item[i].title,
 220             7, i,
 221             8, (app->playlist.item[i].error != 0),
 222             9, (app->playlist.item[i].error & PLAYLIST_ITEM_ERROR_LIB)?"red":"orange",
 223             -1 );
 224     }
 225
 226     app->playlist.ver_prev = app->playlist.ver_curr;
 227
 228     pthread_mutex_unlock(&app->playlist.lock);
 229 };
 230
 231 typedef struct omnplay_playlist_draw_item_desc
 232 {
 233     GtkListStore *list_store;
 234     omnplay_instance_t* app;
 235     int idx;
 236 } omnplay_playlist_draw_item_t;
 237
 238 static gboolean omnplay_playlist_draw_item_proc(
 239     GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
 240 {
 241     int i;
 242     char tc1[12], tc2[12];
 243     omnplay_playlist_draw_item_t* item = (omnplay_playlist_draw_item_t*)user_data;
 244     omnplay_instance_t* app = item->app;
 245
 246     gtk_tree_model_get(model, iter, 7, &i, -1);
 247
 248     if(i != item->idx) return FALSE;
 249
 250     gtk_list_store_set(item->list_store, iter,
 251         0, "",
 252         1, app->playlist.block_icons[app->playlist.item[i].type],
 253         2, (0 == app->playlist.item[i].player)?"A":"B",
 254         3, app->playlist.item[i].id,
 255         4, frames2tc(app->playlist.item[i].in, 25.0, tc1),
 256         5, frames2tc(app->playlist.item[i].dur, 25.0, tc2),
 257         6, app->playlist.item[i].title,
 258         7, i,
 259         8, (app->playlist.item[i].error != 0),
 260         9, (app->playlist.item[i].error & PLAYLIST_ITEM_ERROR_LIB)?"red":"orange",
 261         -1 );
 262
 263     return TRUE;
 264 };
 265
 266 void omnplay_playlist_draw_item(omnplay_instance_t* app, int idx)
 267 {
 268     GtkListStore *list_store;
 269     omnplay_playlist_draw_item_t item;
 270
 271     list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(app->playlist_grid)));
 272
 273     pthread_mutex_lock(&app->playlist.lock);
 274
 275     item.idx = idx;
 276     item.app = app;
 277     item.list_store = list_store;
 278     gtk_tree_model_foreach(GTK_TREE_MODEL(list_store), omnplay_playlist_draw_item_proc, &item);
 279
 280     pthread_mutex_unlock(&app->playlist.lock);
 281 };
 282
 283 static gboolean omnplay_playlist_draw_item_rem_proc(
 284     GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
 285 {
 286     int i;
 287     void** args                 = (void**)user_data;
 288     GtkListStore *list_store    = (GtkListStore *)args[1];
 289     int idx                     = (int)args[2];
 290     char* rem                   = (char*)args[3];
 291
 292     gtk_tree_model_get(model, iter, 7, &i, -1);
 293
 294     if(i != idx) return FALSE;
 295
 296     gtk_list_store_set(list_store, iter, 0, rem, -1);
 297
 298     return TRUE;
 299 };
 300
 301 void omnplay_playlist_draw_item_rem(omnplay_instance_t* app, int idx, char* rem)
 302 {
 303     void* item[4];
 304     GtkListStore *list_store;
 305
 306     list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(app->playlist_grid)));
 307
 308     item[0] = (void*)app;
 309     item[1] = (void*)list_store;
 310     item[2] = (void*)idx;
 311     item[3] = (void*)rem;
 312
 313     gtk_tree_model_foreach(GTK_TREE_MODEL(list_store), omnplay_playlist_draw_item_rem_proc, item);
 314 };