mp3splt-gtk 0.9.2
Loading...
Searching...
No Matches
import.c
Go to the documentation of this file.
1/**********************************************************
2 *
3 * mp3splt-gtk -- utility based on mp3splt,
4 * for mp3/ogg splitting without decoding
5 *
6 * Copyright: (C) 2005-2010 Alexandru Munteanu
7 * Contact: m@ioalex.net
8 *
9 * http://mp3splt.sourceforge.net/
10 *
11 *********************************************************/
12
13/**********************************************************
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
28 * USA.
29 *
30 *********************************************************/
31
32/*!********************************************************
33 * \file
34 * The magic behind the splitpoint input
35 *
36 * All functions that are needed in order to read in
37 * cddb, cue or similar files.
38 *********************************************************/
39
40#include "import.h"
41
42static void set_import_filters(GtkFileChooser *chooser);
43static void build_import_filter(GtkFileChooser *chooser,
44 const gchar *filter_name, const gchar *filter_pattern,
45 const gchar *filter_pattern_upper,
46 GList **filters, GtkFileFilter *all_filter);
47static gpointer add_audacity_labels_splitpoints(ui_with_fname *ui_fname);
48static gpointer add_cddb_splitpoints(ui_with_fname *ui_fname);
49static gpointer add_cue_splitpoints(ui_with_fname *ui_fname);
50static gpointer add_plugin_internal_cue_splitpoints(ui_with_fname *ui_fname);
51
53void import_event(GtkWidget *widget, ui_state *ui)
54{
55 GtkWidget *file_chooser =
56 gtk_file_chooser_dialog_new(_("Choose file to import"),
57 NULL,
58 GTK_FILE_CHOOSER_ACTION_OPEN,
59 _("_Cancel"),
60 GTK_RESPONSE_CANCEL,
61 _("_Open"),
62 GTK_RESPONSE_ACCEPT,
63 NULL);
64
65 wh_set_browser_directory_handler(ui, file_chooser);
66 set_import_filters(GTK_FILE_CHOOSER(file_chooser));
67
68 if (gtk_dialog_run(GTK_DIALOG(file_chooser)) == GTK_RESPONSE_ACCEPT)
69 {
70 gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
71
72 import_file(filename, ui, TRUE);
73
74 g_free(filename);
75 filename = NULL;
76
77 remove_status_message(ui->gui);
78 }
79
80 gtk_widget_destroy(file_chooser);
81}
82
83static ui_with_fname *create_ui_with_fname(ui_state *ui, const gchar *filename)
84{
85 ui_with_fname *ui_fname = g_malloc0(sizeof(ui_with_fname));
86 ui_fname->ui = ui;
87 ui_fname->fname = strdup(filename);
88 ui_fname->is_checked_output_radio_box = get_checked_output_radio_box(ui);
89 const gchar *output_format = gtk_entry_get_text(GTK_ENTRY(ui->gui->output_entry));
90 if (output_format != NULL)
91 {
92 ui_fname->output_format = g_strdup(output_format);
93 }
94
95 return ui_fname;
96}
97
102void import_file(gchar *filename, ui_state *ui, gboolean force_import_cue)
103{
104 if (filename == NULL)
105 {
106 return;
107 }
108
109 gchar *ext = strrchr(filename, '.');
110 GString *ext_str = g_string_new(ext);
111
112 g_string_ascii_up(ext_str);
113
114 if (!force_import_cue &&
115 ((strstr(ext_str->str, ".MP3") != NULL) ||
116 (strstr(ext_str->str, ".OGG") != NULL) ||
117 (strstr(ext_str->str, ".FLAC") != NULL)))
118 {
119 file_chooser_ok_event(filename, ui);
120 remove_status_message(ui->gui);
121 }
122 else if ((strstr(ext_str->str, ".CUE") != NULL))
123 {
124 ui_with_fname *ui_fname = create_ui_with_fname(ui, filename);
125 create_thread_and_unref((GThreadFunc)add_cue_splitpoints,
126 (gpointer) ui_fname, ui, "import_cue");
127 }
128 else if ((strstr(ext_str->str, ".CDDB") != NULL))
129 {
130 ui_with_fname *ui_fname = create_ui_with_fname(ui, filename);
131 create_thread_and_unref((GThreadFunc)add_cddb_splitpoints,
132 (gpointer) ui_fname, ui, "import_cddb");
133 }
134 else if ((strstr(ext_str->str, ".TXT") != NULL))
135 {
136 ui_with_fname *ui_fname = create_ui_with_fname(ui, filename);
137 create_thread_and_unref((GThreadFunc)add_audacity_labels_splitpoints,
138 (gpointer) ui_fname, ui, "import_audacity");
139 }
140 else
141 {
142 ui_with_fname *ui_fname = create_ui_with_fname(ui, filename);
143 create_thread_and_unref((GThreadFunc)add_plugin_internal_cue_splitpoints,
144 (gpointer) ui_fname, ui, "import_internal");
145 }
146
147 if (ext_str)
148 {
149 g_string_free(ext_str, FALSE);
150 }
151}
152
153void import_cue_file_from_the_configuration_directory(ui_state *ui)
154{
155 gchar *configuration_directory = get_configuration_directory();
156
157 gsize filename_size = strlen(configuration_directory) + 20;
158 gchar *splitpoints_cue_filename = g_malloc(filename_size * sizeof(gchar));
159 g_snprintf(splitpoints_cue_filename, filename_size, "%s%s%s", configuration_directory,
160 G_DIR_SEPARATOR_S, "splitpoints.cue");
161
162 if (file_exists(splitpoints_cue_filename))
163 {
164 ui->importing_cue_from_configuration_directory = TRUE;
165
166 mp3splt_set_int_option(ui->mp3splt_state,
167 SPLT_OPT_CUE_SET_SPLITPOINT_NAMES_FROM_REM_NAME, SPLT_TRUE);
168 import_file(splitpoints_cue_filename, ui, FALSE);
169 }
170
171 g_free(configuration_directory);
172 g_free(splitpoints_cue_filename);
173}
174
175static gboolean import_files_to_batch(ui_with_fnames *ui_wf)
176{
177 ui_state *ui = ui_wf->ui;
178 char **splt_filenames = ui_wf->filenames;
179
180 gint i = 0;
181 for (i = 0;i < ui_wf->num_of_filenames;i++)
182 {
183 if (!splt_filenames[i])
184 {
185 continue;
186 }
187
188 multiple_files_add_filename(splt_filenames[i], ui);
189
190 free(splt_filenames[i]);
191 splt_filenames[i] = NULL;
192 }
193
194 free(splt_filenames);
195 splt_filenames = NULL;
196
197 g_free(ui_wf);
198
199 return FALSE;
200}
201
202static gboolean import_files_to_batch_end(ui_state *ui)
203{
204 if (ui->infos->multiple_files_tree_number > 0)
205 {
206 gtk_widget_set_sensitive(ui->gui->multiple_files_remove_all_files_button, TRUE);
207 }
208
209 set_process_in_progress_and_wait_safe(FALSE, ui);
210
211 return FALSE;
212}
213
214static gpointer import_files_to_batch_thread(ui_with_list *ui_wl)
215{
216 ui_state *ui = ui_wl->ui;
217
218 set_process_in_progress_and_wait_safe(TRUE, ui);
219
220 GSList *current_file = ui_wl->list;
221 while (current_file)
222 {
223 gchar *filename = current_file->data;
224
225 int err = SPLT_OK;
226 int num_of_files_found = 0;
227
228 char **splt_filenames =
229 mp3splt_find_filenames(ui->mp3splt_state, filename, &num_of_files_found, &err);
230
231 if (splt_filenames)
232 {
233 ui_with_fnames *ui_wf = g_malloc0(sizeof(ui_with_fnames));
234 ui_wf->ui = ui;
235 ui_wf->filenames = splt_filenames;
236 ui_wf->num_of_filenames = num_of_files_found;
237
238 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)import_files_to_batch, ui_wf, NULL);
239 }
240
241 g_free(filename);
242 filename = NULL;
243
244 current_file = g_slist_next(current_file);
245 }
246
247 g_slist_free(ui_wl->list);
248
249 g_free(ui_wl);
250
251 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)import_files_to_batch_end, ui, NULL);
252
253 return NULL;
254}
255
256void import_files_to_batch_and_free(GSList *files, ui_state *ui)
257{
258 ui_with_list *ui_wl = g_malloc0(sizeof(ui_with_list));
259 ui_wl->ui = ui;
260 ui_wl->list = files;
261
262 create_thread_and_unref((GThreadFunc)import_files_to_batch_thread,
263 (gpointer) ui_wl, ui, "import_to_batch");
264}
265
267static void set_import_filters(GtkFileChooser *chooser)
268{
269 GtkFileFilter *all_filter = gtk_file_filter_new();
270 gtk_file_filter_set_name(GTK_FILE_FILTER(all_filter),
271 _("CDDB (*.cddb), CUE (*.cue), Audacity labels (*.txt), internal sheet (*.flac), chapters (*.mp3)"));
272
273 GList *filters = NULL;
274
275 build_import_filter(chooser, _("CDDB files (*.cddb)"), "*.cddb", "*.CDDB",
276 &filters, all_filter);
277 build_import_filter(chooser, _("CUE files (*.cue)"), "*.cue", "*.CUE",
278 &filters, all_filter);
279 build_import_filter(chooser, _("Audacity labels files (*.txt)"), "*.txt", "*.TXT",
280 &filters, all_filter);
281 build_import_filter(chooser, _("FLAC internal sheet (*.flac)"), "*.flac", "*.FLAC",
282 &filters, all_filter);
283 build_import_filter(chooser, _("ID3v2 chapters (*.mp3)"), "*.mp3", "*.MP3",
284 &filters, all_filter);
285 build_import_filter(chooser, _("All files"), "*", NULL, &filters, NULL);
286
287 gtk_file_chooser_add_filter(chooser, all_filter);
288
289 GList *iter = NULL;
290 for (iter = filters; iter != NULL; iter = g_list_next(iter))
291 {
292 gtk_file_chooser_add_filter(chooser, iter->data);
293 }
294}
295
296static void build_import_filter(GtkFileChooser *chooser,
297 const gchar *filter_name, const gchar *filter_pattern,
298 const gchar *filter_pattern_upper,
299 GList **filters, GtkFileFilter *all_filter)
300{
301 GtkFileFilter *filter = gtk_file_filter_new();
302 gtk_file_filter_set_name(GTK_FILE_FILTER(filter), filter_name);
303 gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), filter_pattern);
304
305 if (filter_pattern_upper)
306 {
307 gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), filter_pattern_upper);
308 }
309
310 if (all_filter)
311 {
312 gtk_file_filter_add_pattern(GTK_FILE_FILTER(all_filter), filter_pattern);
313 if (filter_pattern_upper)
314 {
315 gtk_file_filter_add_pattern(GTK_FILE_FILTER(all_filter), filter_pattern_upper);
316 }
317 }
318
319 *filters = g_list_append(*filters, filter);
320}
321
322static gboolean add_audacity_labels_splitpoints_end(ui_with_err *ui_err)
323{
324 ui_state *ui = ui_err->ui;
325 gint err = ui_err->err;
326
327 if (err >= 0)
328 {
330 }
331
333
334 set_process_in_progress_and_wait_safe(FALSE, ui_err->ui);
335
336 g_free(ui_err);
337
338 return FALSE;
339}
340
341static gpointer add_audacity_labels_splitpoints(ui_with_fname *ui_fname)
342{
343 ui_state *ui = ui_fname->ui;
344
345 set_process_in_progress_and_wait_safe(TRUE, ui);
346
347 gchar *filename = ui_fname->fname;
348 if (ui_fname->output_format) { g_free(ui_fname->output_format); }
349 g_free(ui_fname);
350
351 gint err = mp3splt_import(ui->mp3splt_state, AUDACITY_LABELS_IMPORT, filename);
352 g_free(filename);
353
354 ui_with_err *ui_err = g_malloc0(sizeof(ui_with_err));
355 ui_err->ui = ui;
356 ui_err->err = err;
357
358 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)add_audacity_labels_splitpoints_end,
359 ui_err, NULL);
360
361 return NULL;
362}
363
364static gboolean add_plugin_internal_cue_splitpoints_end(ui_with_err *ui_err)
365{
366 ui_state *ui = ui_err->ui;
367 gint err = ui_err->err;
368
369 if (err >= 0)
370 {
372 }
373
375
376 set_process_in_progress_and_wait_safe(FALSE, ui_err->ui);
377
378 g_free(ui_err);
379
380 return FALSE;
381}
382
383static gpointer add_plugin_internal_cue_splitpoints(ui_with_fname *ui_fname)
384{
385 ui_state *ui = ui_fname->ui;
386
387 set_process_in_progress_and_wait_safe(TRUE, ui);
388
389 update_output_options(ui, ui_fname->is_checked_output_radio_box, ui_fname->output_format);
390
391 gchar *filename = ui_fname->fname;
392 if (ui_fname->output_format) { g_free(ui_fname->output_format); }
393 g_free(ui_fname);
394
395 gint err = mp3splt_import(ui->mp3splt_state, PLUGIN_INTERNAL_IMPORT, filename);
396 g_free(filename);
397
398 ui_with_err *ui_err = g_malloc0(sizeof(ui_with_err));
399 ui_err->ui = ui;
400 ui_err->err = err;
401
402 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)add_plugin_internal_cue_splitpoints_end,
403 ui_err, NULL);
404
405 return NULL;
406}
407
408static gboolean add_cddb_splitpoints_end(ui_with_err *ui_err)
409{
410 ui_state *ui = ui_err->ui;
411 gint err = ui_err->err;
412
413 if (err >= 0)
414 {
416 }
417
419
420 set_process_in_progress_and_wait_safe(FALSE, ui);
421
422 g_free(ui_err);
423
424 return FALSE;
425}
426
428static gpointer add_cddb_splitpoints(ui_with_fname *ui_fname)
429{
430 ui_state *ui = ui_fname->ui;
431
432 set_process_in_progress_and_wait_safe(TRUE, ui);
433
434 update_output_options(ui, ui_fname->is_checked_output_radio_box, ui_fname->output_format);
435
436 gchar *filename = ui_fname->fname;
437 if (ui_fname->output_format) { g_free(ui_fname->output_format); }
438 g_free(ui_fname);
439
440 gint err = mp3splt_import(ui->mp3splt_state, CDDB_IMPORT, filename);
441 g_free(filename);
442
443 ui_with_err *ui_err = g_malloc0(sizeof(ui_with_err));
444 ui_err->ui = ui;
445 ui_err->err = err;
446
447 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)add_cddb_splitpoints_end,
448 ui_err, NULL);
449
450 return NULL;
451}
452
453static gboolean add_cue_splitpoints_end(ui_with_err *ui_err)
454{
455 ui_state *ui = ui_err->ui;
456
457 if (!ui->importing_cue_from_configuration_directory)
458 {
459 long max_point = 0;
460
461 splt_code err = SPLT_OK;
462 splt_points *points = mp3splt_get_splitpoints(ui->mp3splt_state, &err);
464 if (points != NULL)
465 {
466 mp3splt_points_init_iterator(points);
467 const splt_point *point = NULL;
468 while ((point = mp3splt_points_next(points)))
469 {
470 long point_value = mp3splt_point_get_value(point);
471 if (point_value > max_point) { max_point = point_value; }
472 }
473 }
474
475 splt_point *splitpoint = mp3splt_point_new(max_point + (100 * 60 * 100), NULL);
476 mp3splt_point_set_name(splitpoint, _("--- last cue splitpoint ---"));
477 mp3splt_append_splitpoint(ui->mp3splt_state, splitpoint);
478 }
479 else
480 {
481 ui->importing_cue_from_configuration_directory = FALSE;
482 }
483
484 if (ui_err->err >= 0)
485 {
487 }
488 print_status_bar_confirmation(ui_err->err, ui);
489
490 mp3splt_set_int_option(ui->mp3splt_state,
491 SPLT_OPT_CUE_SET_SPLITPOINT_NAMES_FROM_REM_NAME, SPLT_FALSE);
492
493 //The cue file has provided libmp3splt with a input filename.
494 //But since we use the filename from the gui instead we need to set
495 //the value the gui uses, too, which we do in the next line.
496 const gchar *filename_to_split = mp3splt_get_filename_to_split(ui->mp3splt_state);
497
498 if (file_exists(filename_to_split))
499 {
500 file_chooser_ok_event(filename_to_split, ui);
501 }
502
503 set_process_in_progress_and_wait_safe(FALSE, ui_err->ui);
504
505 g_free(ui_err);
506
507 return FALSE;
508}
509
511static gpointer add_cue_splitpoints(ui_with_fname *ui_fname)
512{
513 ui_state *ui = ui_fname->ui;
514
515 set_process_in_progress_and_wait_safe(TRUE, ui);
516
517 update_output_options(ui, ui_fname->is_checked_output_radio_box, ui_fname->output_format);
518
519 gchar *filename = ui_fname->fname;
520 if (ui_fname->output_format) { g_free(ui_fname->output_format); }
521 g_free(ui_fname);
522
523 mp3splt_set_filename_to_split(ui->mp3splt_state, NULL);
524
525 gint err = mp3splt_import(ui->mp3splt_state, CUE_IMPORT, filename);
526 g_free(filename);
527
528 ui_with_err *ui_err = g_malloc0(sizeof(ui_with_err));
529 ui_err->ui = ui;
530 ui_err->err = err;
531
532 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)add_cue_splitpoints_end,
533 ui_err, NULL);
534
535 return NULL;
536}
537
void update_splitpoints_from_mp3splt_state(ui_state *ui)
updates the current splitpoints in ui->mp3splt_state
void import_file(gchar *filename, ui_state *ui, gboolean force_import_cue)
Handles the import of an input file (audio or splitpoint)
Definition import.c:102
void import_event(GtkWidget *widget, ui_state *ui)
What happens if the "Import" button is pressed.
Definition import.c:53
void print_status_bar_confirmation(gint error, ui_state *ui)
Output an error message from libmp3splt to the status bar.
void remove_status_message(gui_state *gui)
Removes status bar message.
void update_output_options(ui_state *ui, gboolean is_checked_output_radio_box, gchar *output_format)
Update the output options.
gboolean get_checked_output_radio_box(ui_state *ui)
returns the checked output radio box
gint file_exists(const gchar *fname)
check if specified file exists
Definition utilities.c:62