← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to libbrasero-burn/brasero-session-cfg.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2011-05-18 17:53:39 UTC
  • mfrom: (1.1.47 upstream) (1.4.3 experimental)
  • Revision ID: james.westby@ubuntu.com-20110518175339-so6a6fejezs5i1pc
Tags: 3.0.0-1ubuntu1
* Rebase from Debian and GNOME3 PPA. Remaining Ubuntu changes:
* debian/control:
  - Build-Depend on dh-autoreconf, libappindicator3-dev and
    liblaunchpad-integration-3.0-dev
  - Recommends: brasero-cdrkit
  - libbrasero-media3-1 Depends on dvd+rw-tools not growisofs and
    Suggests rather than Recommends gstreamer plugin packages
* debian/patches/010_lpi.patch:
  - Launchpad integration patch
* debian/patches/012_appindicator.patch:
  - Use application indicators
* debian/rules:
  - Include autoreconf.mk
* debian/watch:
  - Watch unstable releases also

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbrasero-burn/brasero-session-cfg.c
33
33
#endif
34
34
 
35
35
#include <string.h>
 
36
#include <sys/resource.h>
36
37
 
37
38
#include <glib.h>
38
39
#include <glib-object.h>
39
40
#include <glib/gi18n-lib.h>
40
41
 
 
42
#include "brasero-volume.h"
 
43
 
41
44
#include "burn-basics.h"
42
45
#include "burn-debug.h"
43
46
#include "burn-plugin-manager.h"
70
73
        BraseroBurnFlag supported;
71
74
        BraseroBurnFlag compulsory;
72
75
 
 
76
        /* Do some caching to improve performances */
 
77
        BraseroImageFormat output_format;
73
78
        gchar *output;
74
79
 
 
80
        BraseroTrackType *source;
 
81
        goffset disc_size;
 
82
        goffset session_blocks;
 
83
        goffset session_size;
 
84
 
75
85
        BraseroSessionError is_valid;
76
86
 
77
87
        guint CD_TEXT_modified:1;
78
88
        guint configuring:1;
79
89
        guint disabled:1;
 
90
 
 
91
        guint output_msdos:1;
80
92
};
81
93
 
82
94
#define BRASERO_SESSION_CFG_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_SESSION_CFG, BraseroSessionCfgPrivate))
114
126
 
115
127
/**
116
128
 * brasero_session_cfg_has_default_output_path:
117
 
 * @cfg: a #BraseroSessionCfg
 
129
 * @session: a #BraseroSessionCfg
118
130
 *
119
131
 * This function returns whether the path returned
120
132
 * by brasero_burn_session_get_output () is an 
310
322
        BraseroBurnResult result;
311
323
        BraseroImageFormat format;
312
324
        BraseroBurnSessionClass *klass;
 
325
        BraseroSessionCfgPrivate *priv;
313
326
 
314
327
        klass = BRASERO_BURN_SESSION_CLASS (brasero_session_cfg_parent_class);
 
328
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
315
329
 
316
330
        result = klass->get_output_path (session,
317
331
                                         image,
319
333
        if (result == BRASERO_BURN_OK)
320
334
                return result;
321
335
 
322
 
        format = brasero_burn_session_get_output_format (session);
323
 
        path = brasero_image_format_get_default_path (format);
 
336
        if (priv->output_format == BRASERO_IMAGE_FORMAT_NONE)
 
337
                return BRASERO_BURN_ERR;
 
338
 
 
339
        /* Note: path and format are determined earlier in fact, in the function
 
340
         * that check the free space on the hard drive. */
 
341
        path = g_strdup (priv->output);
 
342
        format = priv->output_format;
324
343
 
325
344
        switch (format) {
326
345
        case BRASERO_IMAGE_FORMAT_BIN:
340
359
 
341
360
        default:
342
361
                g_free (path);
 
362
                g_free (priv->output);
 
363
                priv->output = NULL;
343
364
                return BRASERO_BURN_ERR;
344
365
        }
345
366
 
350
371
brasero_session_cfg_get_output_format (BraseroBurnSession *session)
351
372
{
352
373
        BraseroBurnSessionClass *klass;
 
374
        BraseroSessionCfgPrivate *priv;
353
375
        BraseroImageFormat format;
354
376
 
355
377
        klass = BRASERO_BURN_SESSION_CLASS (brasero_session_cfg_parent_class);
356
378
        format = klass->get_output_format (session);
357
379
 
358
 
        if (format == BRASERO_IMAGE_FORMAT_NONE)
359
 
                format = brasero_burn_session_get_default_output_format (session);
360
 
 
361
 
        return format;
 
380
        if (format != BRASERO_IMAGE_FORMAT_NONE)
 
381
                return format;
 
382
 
 
383
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
 
384
 
 
385
        if (priv->output_format)
 
386
                return priv->output_format;
 
387
 
 
388
        /* Cache the path for later use */
 
389
        priv->output_format = brasero_burn_session_get_default_output_format (session);
 
390
        return priv->output_format;
362
391
}
363
392
 
364
393
/**
365
394
 * brasero_session_cfg_get_error:
366
 
 * @cfg: a #BraseroSessionCfg
 
395
 * @session: a #BraseroSessionCfg
367
396
 *
368
397
 * This function returns the current status and if
369
398
 * autoconfiguration is/was successful.
372
401
 **/
373
402
 
374
403
BraseroSessionError
375
 
brasero_session_cfg_get_error (BraseroSessionCfg *self)
 
404
brasero_session_cfg_get_error (BraseroSessionCfg *session)
376
405
{
377
406
        BraseroSessionCfgPrivate *priv;
378
407
 
379
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
408
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
380
409
 
381
410
        if (priv->is_valid == BRASERO_SESSION_VALID
382
411
        &&  priv->CD_TEXT_modified)
387
416
 
388
417
/**
389
418
 * brasero_session_cfg_disable:
390
 
 * @cfg: a #BraseroSessionCfg
 
419
 * @session: a #BraseroSessionCfg
391
420
 *
392
421
 * This function disables autoconfiguration
393
422
 *
394
423
 **/
395
424
 
396
425
void
397
 
brasero_session_cfg_disable (BraseroSessionCfg *self)
 
426
brasero_session_cfg_disable (BraseroSessionCfg *session)
398
427
{
399
428
        BraseroSessionCfgPrivate *priv;
400
429
 
401
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
430
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
402
431
        priv->disabled = TRUE;
403
432
}
404
433
 
405
434
/**
406
435
 * brasero_session_cfg_enable:
407
 
 * @cfg: a #BraseroSessionCfg
 
436
 * @session: a #BraseroSessionCfg
408
437
 *
409
438
 * This function (re)-enables autoconfiguration
410
439
 *
411
440
 **/
412
441
 
413
442
void
414
 
brasero_session_cfg_enable (BraseroSessionCfg *self)
 
443
brasero_session_cfg_enable (BraseroSessionCfg *session)
415
444
{
416
445
        BraseroSessionCfgPrivate *priv;
417
446
 
418
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
447
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
419
448
        priv->disabled = FALSE;
420
449
}
421
450
 
521
550
                                                BraseroBurnFlag flags)
522
551
{
523
552
        BraseroDrive *drive;
524
 
        BraseroMedia media;
525
553
        BraseroBurnFlag flag;
526
554
        BraseroMedium *medium;
527
555
        BraseroBurnResult result;
531
559
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
532
560
 
533
561
        original_flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
 
562
 
 
563
        /* If the session is invalid no need to check the flags: just add them.
 
564
         * The correct flags will be re-computed anyway when the session becomes
 
565
         * valid again. */
 
566
        if (priv->is_valid != BRASERO_SESSION_VALID) {
 
567
                BRASERO_BURN_LOG ("Session currently not ready for flag computation: adding flags (will update later)");
 
568
                brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self), flags);
 
569
                return;
 
570
        }
 
571
 
534
572
        BRASERO_BURN_LOG ("Resetting all flags");
535
573
        BRASERO_BURN_LOG_FLAGS (original_flags, "Current are");
536
574
        BRASERO_BURN_LOG_FLAGS (flags, "New should be");
547
585
                return;
548
586
        }
549
587
 
550
 
        media = brasero_medium_get_status (medium);
551
 
 
552
588
        /* This prevents signals to be emitted while (re-) adding them one by one */
553
589
        g_object_freeze_notify (G_OBJECT (self));
554
590
 
652
688
static void
653
689
brasero_session_cfg_check_drive_settings (BraseroSessionCfg *self)
654
690
{
655
 
        BraseroSessionCfgPrivate *priv;
656
691
        BraseroBurnFlag flags;
657
692
 
658
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
659
 
 
660
693
        /* Try to properly update the flags for the current drive */
661
694
        flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
662
695
        if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
669
702
}
670
703
 
671
704
static BraseroSessionError
 
705
brasero_session_cfg_check_volume_size (BraseroSessionCfg *self)
 
706
{
 
707
        struct rlimit limit;
 
708
        BraseroSessionCfgPrivate *priv;
 
709
 
 
710
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
711
        if (!priv->disc_size) {
 
712
                GFileInfo *info;
 
713
                gchar *directory;
 
714
                GFile *file = NULL;
 
715
                const gchar *filesystem;
 
716
 
 
717
                /* Cache the path for later use */
 
718
                if (priv->output_format == BRASERO_IMAGE_FORMAT_NONE)
 
719
                        priv->output_format = brasero_burn_session_get_output_format (BRASERO_BURN_SESSION (self));
 
720
 
 
721
                if (!priv->output) {
 
722
                        gchar *name = NULL;
 
723
 
 
724
                        /* If we try to copy a volume get (and use) its name */
 
725
                        if (brasero_track_type_get_has_medium (priv->source)) {
 
726
                                BraseroMedium *medium;
 
727
 
 
728
                                medium = brasero_burn_session_get_src_medium (BRASERO_BURN_SESSION (self));
 
729
                                if (medium)
 
730
                                        name = brasero_volume_get_name (BRASERO_VOLUME (medium));
 
731
                        }
 
732
 
 
733
                        priv->output = brasero_image_format_get_default_path (priv->output_format, name);
 
734
                        g_free (name);
 
735
                }
 
736
 
 
737
                directory = g_path_get_dirname (priv->output);
 
738
                file = g_file_new_for_path (directory);
 
739
                g_free (directory);
 
740
 
 
741
                if (file == NULL)
 
742
                        goto error;
 
743
 
 
744
                /* Check permissions first */
 
745
                info = g_file_query_info (file,
 
746
                                          G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
 
747
                                          G_FILE_QUERY_INFO_NONE,
 
748
                                          NULL,
 
749
                                          NULL);
 
750
                if (!info) {
 
751
                        g_object_unref (file);
 
752
                        goto error;
 
753
                }
 
754
 
 
755
                if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
 
756
                        g_object_unref (info);
 
757
                        g_object_unref (file);
 
758
                        goto error;
 
759
                }
 
760
                g_object_unref (info);
 
761
 
 
762
                /* Now size left */
 
763
                info = g_file_query_filesystem_info (file,
 
764
                                                     G_FILE_ATTRIBUTE_FILESYSTEM_FREE ","
 
765
                                                     G_FILE_ATTRIBUTE_FILESYSTEM_TYPE,
 
766
                                                     NULL,
 
767
                                                     NULL);
 
768
                g_object_unref (file);
 
769
 
 
770
                if (!info)
 
771
                        goto error;
 
772
 
 
773
                /* Now check the filesystem type: the problem here is that some
 
774
                 * filesystems have a maximum file size limit of 4 GiB and more than
 
775
                 * often we need a temporary file size of 4 GiB or more. */
 
776
                filesystem = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
 
777
                if (!g_strcmp0 (filesystem, "msdos"))
 
778
                        priv->output_msdos = TRUE;
 
779
                else
 
780
                        priv->output_msdos = FALSE;
 
781
 
 
782
                priv->disc_size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
 
783
                g_object_unref (info);
 
784
        }
 
785
 
 
786
        BRASERO_BURN_LOG ("Session size %lli/Hard drive size %lli",
 
787
                          priv->session_size,
 
788
                          priv->disc_size);
 
789
 
 
790
        if (priv->output_msdos && priv->session_size >= 2147483648ULL)
 
791
                goto error;
 
792
 
 
793
        if (priv->session_size > priv->disc_size)
 
794
                goto error;
 
795
 
 
796
        /* Last but not least, use getrlimit () to check that we are allowed to
 
797
         * write a file of such length and that quotas won't get in our way */
 
798
        if (getrlimit (RLIMIT_FSIZE, &limit))
 
799
                goto error;
 
800
 
 
801
        if (limit.rlim_cur < priv->session_size)
 
802
                goto error;
 
803
 
 
804
        priv->is_valid = BRASERO_SESSION_VALID;
 
805
        return BRASERO_SESSION_VALID;
 
806
 
 
807
error:
 
808
 
 
809
        priv->is_valid = BRASERO_SESSION_INSUFFICIENT_SPACE;
 
810
        return BRASERO_SESSION_INSUFFICIENT_SPACE;
 
811
}
 
812
 
 
813
static BraseroSessionError
672
814
brasero_session_cfg_check_size (BraseroSessionCfg *self)
673
815
{
674
816
        BraseroSessionCfgPrivate *priv;
677
819
        BraseroDrive *burner;
678
820
        GValue *value = NULL;
679
821
        /* in sectors */
680
 
        goffset session_size;
681
822
        goffset max_sectors;
682
 
        goffset disc_size;
683
823
 
684
824
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
685
825
 
 
826
        /* Get the session size if need be */
 
827
        if (!priv->session_blocks) {
 
828
                if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
 
829
                                                     BRASERO_DATA_TRACK_SIZE_TAG,
 
830
                                                     &value) == BRASERO_BURN_OK) {
 
831
                        priv->session_blocks = g_value_get_int64 (value);
 
832
                        priv->session_size = priv->session_blocks * 2048;
 
833
                }
 
834
                else if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
 
835
                                                          BRASERO_STREAM_TRACK_SIZE_TAG,
 
836
                                                          &value) == BRASERO_BURN_OK) {
 
837
                        priv->session_blocks = g_value_get_int64 (value);
 
838
                        priv->session_size = priv->session_blocks * 2352;
 
839
                }
 
840
                else
 
841
                        brasero_burn_session_get_size (BRASERO_BURN_SESSION (self),
 
842
                                                       &priv->session_blocks,
 
843
                                                       &priv->session_size);
 
844
        }
 
845
 
 
846
        /* Get the disc and its size if need be */
686
847
        burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
687
848
        if (!burner) {
688
849
                priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
689
850
                return BRASERO_SESSION_NO_OUTPUT;
690
851
        }
691
852
 
692
 
        /* FIXME: here we could check the hard drive space */
693
 
        if (brasero_drive_is_fake (burner)) {
694
 
                priv->is_valid = BRASERO_SESSION_VALID;
695
 
                return BRASERO_SESSION_VALID;
696
 
        }
 
853
        if (brasero_drive_is_fake (burner))
 
854
                return brasero_session_cfg_check_volume_size (self);
697
855
 
698
856
        medium = brasero_drive_get_medium (burner);
699
857
        if (!medium) {
701
859
                return BRASERO_SESSION_NO_OUTPUT;
702
860
        }
703
861
 
704
 
        disc_size = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (self));
705
 
        if (disc_size < 0)
706
 
                disc_size = 0;
707
 
 
708
 
        /* get input track size */
709
 
        session_size = 0;
710
 
 
711
 
        if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
712
 
                                             BRASERO_DATA_TRACK_SIZE_TAG,
713
 
                                             &value) == BRASERO_BURN_OK) {
714
 
                session_size = g_value_get_int64 (value);
715
 
        }
716
 
        else if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
717
 
                                                  BRASERO_STREAM_TRACK_SIZE_TAG,
718
 
                                                  &value) == BRASERO_BURN_OK) {
719
 
                session_size = g_value_get_int64 (value);
720
 
        }
721
 
        else
722
 
                brasero_burn_session_get_size (BRASERO_BURN_SESSION (self),
723
 
                                               &session_size,
724
 
                                               NULL);
 
862
        /* Get both sizes if need be */
 
863
        if (!priv->disc_size) {
 
864
                priv->disc_size = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (self));
 
865
                if (priv->disc_size < 0)
 
866
                        priv->disc_size = 0;
 
867
        }
725
868
 
726
869
        BRASERO_BURN_LOG ("Session size %lli/Disc size %lli",
727
 
                          session_size,
728
 
                          disc_size);
 
870
                          priv->session_blocks,
 
871
                          priv->disc_size);
729
872
 
730
 
        if (session_size < disc_size) {
 
873
        if (priv->session_blocks < priv->disc_size) {
731
874
                priv->is_valid = BRASERO_SESSION_VALID;
732
875
                return BRASERO_SESSION_VALID;
733
876
        }
743
886
         * when we propose overburning to the user, we could ask if he wants
744
887
         * us to determine how much data can be written to a particular disc
745
888
         * provided he has chosen a real disc. */
746
 
        max_sectors = disc_size * 103 / 100;
747
 
        if (max_sectors < session_size) {
 
889
        max_sectors = priv->disc_size * 103 / 100;
 
890
        if (max_sectors < priv->session_blocks) {
748
891
                priv->is_valid = BRASERO_SESSION_INSUFFICIENT_SPACE;
749
892
                return BRASERO_SESSION_INSUFFICIENT_SPACE;
750
893
        }
787
930
        }
788
931
}
789
932
 
790
 
static void
791
 
brasero_session_cfg_update (BraseroSessionCfg *self)
 
933
static gboolean
 
934
brasero_session_cfg_can_update (BraseroSessionCfg *self)
792
935
{
793
 
        BraseroTrackType *source = NULL;
794
936
        BraseroSessionCfgPrivate *priv;
795
937
        BraseroBurnResult result;
796
938
        BraseroStatus *status;
797
 
        BraseroDrive *burner;
798
939
 
799
940
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
800
941
 
 
942
        if (priv->disabled)
 
943
                return FALSE;
 
944
 
801
945
        if (priv->configuring)
802
 
                return;
 
946
                return FALSE;
803
947
 
804
948
        /* Make sure the session is ready */
805
949
        status = brasero_status_new ();
811
955
                g_signal_emit (self,
812
956
                               session_cfg_signals [IS_VALID_SIGNAL],
813
957
                               0);
814
 
                return;
 
958
                return FALSE;
815
959
        }
816
960
 
817
961
        if (result == BRASERO_BURN_ERR) {
827
971
                                g_signal_emit (self,
828
972
                                               session_cfg_signals [IS_VALID_SIGNAL],
829
973
                                               0);
830
 
                                return;
 
974
                                return FALSE;
831
975
                        }
832
976
 
833
977
                        g_error_free (error);
834
978
                }
835
979
        }
836
980
        g_object_unref (status);
 
981
        return TRUE;
 
982
}
 
983
 
 
984
static void
 
985
brasero_session_cfg_update (BraseroSessionCfg *self)
 
986
{
 
987
        BraseroSessionCfgPrivate *priv;
 
988
        BraseroBurnResult result;
 
989
        BraseroDrive *burner;
 
990
 
 
991
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
837
992
 
838
993
        /* Make sure there is a source */
839
 
        source = brasero_track_type_new ();
840
 
        brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), source);
841
 
 
842
 
        if (brasero_track_type_is_empty (source)) {
843
 
                brasero_track_type_free (source);
844
 
 
 
994
        if (priv->source) {
 
995
                brasero_track_type_free (priv->source);
 
996
                priv->source = NULL;
 
997
        }
 
998
 
 
999
        priv->source = brasero_track_type_new ();
 
1000
        brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), priv->source);
 
1001
 
 
1002
        if (brasero_track_type_is_empty (priv->source)) {
845
1003
                priv->is_valid = BRASERO_SESSION_EMPTY;
846
1004
                g_signal_emit (self,
847
1005
                               session_cfg_signals [IS_VALID_SIGNAL],
850
1008
        }
851
1009
 
852
1010
        /* it can be empty with just an empty track */
853
 
        if (brasero_track_type_get_has_medium (source)
854
 
        &&  brasero_track_type_get_medium_type (source) == BRASERO_MEDIUM_NONE) {
855
 
                brasero_track_type_free (source);
856
 
 
 
1011
        if (brasero_track_type_get_has_medium (priv->source)
 
1012
        &&  brasero_track_type_get_medium_type (priv->source) == BRASERO_MEDIUM_NONE) {
857
1013
                priv->is_valid = BRASERO_SESSION_NO_INPUT_MEDIUM;
858
1014
                g_signal_emit (self,
859
1015
                               session_cfg_signals [IS_VALID_SIGNAL],
861
1017
                return;
862
1018
        }
863
1019
 
864
 
        if (brasero_track_type_get_has_image (source)
865
 
        &&  brasero_track_type_get_image_format (source) == BRASERO_IMAGE_FORMAT_NONE) {
 
1020
        if (brasero_track_type_get_has_image (priv->source)
 
1021
        &&  brasero_track_type_get_image_format (priv->source) == BRASERO_IMAGE_FORMAT_NONE) {
866
1022
                gchar *uri;
867
1023
                GSList *tracks;
868
1024
 
869
 
                brasero_track_type_free (source);
870
 
 
871
1025
                tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (self));
872
1026
 
873
1027
                /* It can be two cases:
897
1051
        /* make sure there is an output set */
898
1052
        burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
899
1053
        if (!burner) {
900
 
                brasero_track_type_free (source);
901
 
 
902
1054
                priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
903
1055
                g_signal_emit (self,
904
1056
                               session_cfg_signals [IS_VALID_SIGNAL],
906
1058
                return;
907
1059
        }
908
1060
 
 
1061
        /* In case the output was an image remove the path cache. It will be
 
1062
         * re-computed on demand. */
 
1063
        if (priv->output) {
 
1064
                g_free (priv->output);
 
1065
                priv->output = NULL;
 
1066
        }
 
1067
 
 
1068
        if (priv->output_format)
 
1069
                priv->output_format = BRASERO_IMAGE_FORMAT_NONE;
 
1070
 
909
1071
        /* Check that current input and output work */
910
 
        if (brasero_track_type_get_has_stream (source)) {
 
1072
        if (brasero_track_type_get_has_stream (priv->source)) {
911
1073
                if (priv->CD_TEXT_modified) {
912
1074
                        /* Try to redo what we undid (after all a new plugin
913
1075
                         * could have been activated in the mean time ...) and
914
1076
                         * see what happens */
915
 
                        brasero_track_type_set_stream_format (source,
 
1077
                        brasero_track_type_set_stream_format (priv->source,
916
1078
                                                              BRASERO_METADATA_INFO|
917
 
                                                              brasero_track_type_get_stream_format (source));
918
 
                        result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
 
1079
                                                              brasero_track_type_get_stream_format (priv->source));
 
1080
                        result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
919
1081
                        if (result == BRASERO_BURN_OK) {
920
1082
                                priv->CD_TEXT_modified = FALSE;
921
1083
 
922
1084
                                priv->configuring = TRUE;
923
1085
                                brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
924
 
                                                                             brasero_track_type_get_stream_format (source));
 
1086
                                                                             brasero_track_type_get_stream_format (priv->source));
925
1087
                                priv->configuring = FALSE;
926
1088
                        }
927
1089
                        else {
928
1090
                                /* No, nothing's changed */
929
 
                                brasero_track_type_set_stream_format (source,
 
1091
                                brasero_track_type_set_stream_format (priv->source,
930
1092
                                                                      (~BRASERO_METADATA_INFO) &
931
 
                                                                      brasero_track_type_get_stream_format (source));
932
 
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
 
1093
                                                                      brasero_track_type_get_stream_format (priv->source));
 
1094
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
933
1095
                        }
934
1096
                }
935
1097
                else {
936
1098
                        result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self), FALSE);
937
1099
 
938
1100
                        if (result != BRASERO_BURN_OK
939
 
                        && (brasero_track_type_get_stream_format (source) & BRASERO_METADATA_INFO)) {
 
1101
                        && (brasero_track_type_get_stream_format (priv->source) & BRASERO_METADATA_INFO)) {
940
1102
                                /* Another special case in case some burning backends 
941
1103
                                 * don't support CD-TEXT for audio (libburn). If no
942
1104
                                 * other backend is available remove CD-TEXT option but
943
1105
                                 * tell user... */
944
 
                                brasero_track_type_set_stream_format (source,
 
1106
                                brasero_track_type_set_stream_format (priv->source,
945
1107
                                                                      (~BRASERO_METADATA_INFO) &
946
 
                                                                      brasero_track_type_get_stream_format (source));
 
1108
                                                                      brasero_track_type_get_stream_format (priv->source));
947
1109
 
948
 
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
 
1110
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
949
1111
 
950
1112
                                BRASERO_BURN_LOG ("Tested support without Metadata information (result %d)", result);
951
1113
                                if (result == BRASERO_BURN_OK) {
953
1115
 
954
1116
                                        priv->configuring = TRUE;
955
1117
                                        brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
956
 
                                                                                     brasero_track_type_get_has_stream (source));
 
1118
                                                                                     brasero_track_type_get_has_stream (priv->source));
957
1119
                                        priv->configuring = FALSE;
958
1120
                                }
959
1121
                        }
960
1122
                }
961
1123
        }
962
 
        else if (brasero_track_type_get_has_medium (source)
963
 
        &&  (brasero_track_type_get_medium_type (source) & BRASERO_MEDIUM_HAS_AUDIO)) {
 
1124
        else if (brasero_track_type_get_has_medium (priv->source)
 
1125
        &&  (brasero_track_type_get_medium_type (priv->source) & BRASERO_MEDIUM_HAS_AUDIO)) {
964
1126
                BraseroImageFormat format = BRASERO_IMAGE_FORMAT_NONE;
965
1127
 
966
1128
                /* If we copy an audio disc check the image
1013
1175
        }
1014
1176
 
1015
1177
        if (result != BRASERO_BURN_OK) {
1016
 
                if (brasero_track_type_get_has_medium (source)
1017
 
                && (brasero_track_type_get_medium_type (source) & BRASERO_MEDIUM_PROTECTED)
1018
 
                &&  brasero_burn_library_input_supported (source) != BRASERO_BURN_OK) {
 
1178
                if (brasero_track_type_get_has_medium (priv->source)
 
1179
                && (brasero_track_type_get_medium_type (priv->source) & BRASERO_MEDIUM_PROTECTED)
 
1180
                &&  brasero_burn_library_input_supported (priv->source) != BRASERO_BURN_OK) {
1019
1181
                        /* This is a special case to display a helpful message */
1020
1182
                        priv->is_valid = BRASERO_SESSION_DISC_PROTECTED;
1021
1183
                        g_signal_emit (self,
1029
1191
                                       0);
1030
1192
                }
1031
1193
 
1032
 
                brasero_track_type_free (source);
1033
1194
                return;
1034
1195
        }
1035
1196
 
1036
1197
        /* Special case for video projects */
1037
 
        if (brasero_track_type_get_has_stream (source)
1038
 
        &&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (source))) {
 
1198
        if (brasero_track_type_get_has_stream (priv->source)
 
1199
        &&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (priv->source))) {
1039
1200
                /* Only set if it was not already set */
1040
1201
                if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self), BRASERO_VCD_TYPE, NULL) != BRASERO_BURN_OK)
1041
1202
                        brasero_burn_session_tag_add_int (BRASERO_BURN_SESSION (self),
1043
1204
                                                          BRASERO_SVCD);
1044
1205
        }
1045
1206
 
1046
 
        brasero_track_type_free (source);
1047
 
 
1048
1207
        /* Configure flags */
1049
1208
        priv->configuring = TRUE;
1050
1209
 
1083
1242
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1084
1243
        if (priv->disabled)
1085
1244
                return;
 
1245
        
 
1246
        priv->session_blocks = 0;
 
1247
        priv->session_size = 0;
1086
1248
 
1087
1249
        session_flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (session));
1088
1250
        if (is_loaded) {
1103
1265
{
1104
1266
        BraseroSessionCfgPrivate *priv;
1105
1267
 
 
1268
        if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 
1269
                return;
 
1270
 
1106
1271
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1107
 
        if (priv->disabled)
1108
 
                return;
 
1272
        priv->session_blocks = 0;
 
1273
        priv->session_size = 0;
1109
1274
 
1110
1275
        if (BRASERO_IS_TRACK_DATA_CFG (track))
1111
1276
                g_signal_connect (track,
1117
1282
         * - check if all flags are supported
1118
1283
         * - check available formats for path
1119
1284
         * - set one path */
 
1285
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1120
1286
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1121
 
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1122
1287
}
1123
1288
 
1124
1289
static void
1128
1293
{
1129
1294
        BraseroSessionCfgPrivate *priv;
1130
1295
 
 
1296
        if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 
1297
                return;
 
1298
 
1131
1299
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1132
 
        if (priv->disabled)
1133
 
                return;
 
1300
        priv->session_blocks = 0;
 
1301
        priv->session_size = 0;
1134
1302
 
1135
1303
        /* Just in case */
1136
1304
        g_signal_handlers_disconnect_by_func (track,
1148
1316
                                   BraseroTrack *track)
1149
1317
{
1150
1318
        BraseroSessionCfgPrivate *priv;
 
1319
        BraseroTrackType *current;
 
1320
 
 
1321
        if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 
1322
                return;
1151
1323
 
1152
1324
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1153
 
        if (priv->disabled)
1154
 
                return;
 
1325
        priv->session_blocks = 0;
 
1326
        priv->session_size = 0;
 
1327
 
 
1328
        current = brasero_track_type_new ();
 
1329
        brasero_burn_session_get_input_type (session, current);
 
1330
        if (brasero_track_type_equal (current, priv->source)) {
 
1331
                /* This is a shortcut if the source type has not changed */
 
1332
                brasero_track_type_free (current);
 
1333
                brasero_session_cfg_check_size (BRASERO_SESSION_CFG (session));
 
1334
                g_signal_emit (session,
 
1335
                               session_cfg_signals [IS_VALID_SIGNAL],
 
1336
                               0);
 
1337
                return;
 
1338
        }
 
1339
        brasero_track_type_free (current);
1155
1340
 
1156
1341
        /* when that happens it's mostly because a medium source changed, or
1157
1342
         * a new image was set. 
1158
1343
         * - check if all flags are supported
1159
1344
         * - check available formats for path
1160
1345
         * - set one path if need be */
 
1346
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1161
1347
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1162
 
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1163
1348
}
1164
1349
 
1165
1350
static void
1167
1352
                                    BraseroMedium *former)
1168
1353
{
1169
1354
        BraseroSessionCfgPrivate *priv;
1170
 
        BraseroTrackType *type;
 
1355
 
 
1356
        if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 
1357
                return;
1171
1358
 
1172
1359
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1173
 
        if (priv->disabled)
1174
 
                return;
 
1360
        priv->disc_size = 0;
1175
1361
 
1176
1362
        /* Case for video project */
1177
 
        type = brasero_track_type_new ();
1178
 
        brasero_burn_session_get_input_type (session, type);
1179
 
 
1180
 
        if (brasero_track_type_get_has_stream (type)
1181
 
        &&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (type))) {
 
1363
        if (priv->source
 
1364
        &&  brasero_track_type_get_has_stream (priv->source)
 
1365
        &&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (priv->source))) {
1182
1366
                BraseroMedia media;
1183
1367
 
1184
1368
                media = brasero_burn_session_get_dest_media (session);
1204
1388
                                                                  BRASERO_AUDIO_FORMAT_AC3);
1205
1389
                }
1206
1390
        }
1207
 
        brasero_track_type_free (type);
1208
1391
 
1209
1392
        /* In this case need to :
1210
1393
         * - check if all flags are supported
1211
1394
         * - for images, set a path if it wasn't already set */
 
1395
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1212
1396
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1213
 
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1214
1397
}
1215
1398
 
1216
1399
static void
1219
1402
{
1220
1403
        BraseroSessionCfgPrivate *priv;
1221
1404
 
 
1405
        if (!brasero_session_cfg_can_update (self))
 
1406
                return;
 
1407
 
1222
1408
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
1223
 
        if (priv->disabled)
1224
 
                return;
 
1409
        priv->disc_size = 0;
 
1410
        priv->session_blocks = 0;
 
1411
        priv->session_size = 0;
1225
1412
 
1226
1413
        /* In this case we need to check if:
1227
1414
         * - flags are supported or not supported anymore
1228
1415
         * - image types as input/output are supported
1229
1416
         * - if the current set of input/output still works */
 
1417
        brasero_session_cfg_update (self);
1230
1418
        brasero_session_cfg_check_drive_settings (self);
1231
 
        brasero_session_cfg_update (self);
1232
1419
}
1233
1420
 
1234
1421
/**
1235
1422
 * brasero_session_cfg_add_flags:
1236
 
 * @cfg: a #BraseroSessionCfg
 
1423
 * @session: a #BraseroSessionCfg
1237
1424
 * @flags: a #BraseroBurnFlag
1238
1425
 *
1239
1426
 * Adds all flags from @flags that are supported.
1241
1428
 **/
1242
1429
 
1243
1430
void
1244
 
brasero_session_cfg_add_flags (BraseroSessionCfg *self,
 
1431
brasero_session_cfg_add_flags (BraseroSessionCfg *session,
1245
1432
                               BraseroBurnFlag flags)
1246
1433
{
1247
1434
        BraseroSessionCfgPrivate *priv;
1248
1435
 
1249
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
1436
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1250
1437
 
1251
1438
        if ((priv->supported & flags) != flags)
1252
1439
                return;
1253
1440
 
1254
 
        if ((brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self)) & flags) == flags)
 
1441
        if ((brasero_burn_session_get_flags (BRASERO_BURN_SESSION (session)) & flags) == flags)
1255
1442
                return;
1256
1443
 
1257
 
        brasero_session_cfg_add_drive_properties_flags (self, flags);
1258
 
        brasero_session_cfg_update (self);
 
1444
        brasero_session_cfg_add_drive_properties_flags (session, flags);
 
1445
 
 
1446
        if (brasero_session_cfg_can_update (session))
 
1447
                brasero_session_cfg_update (session);
1259
1448
}
1260
1449
 
1261
1450
/**
1262
1451
 * brasero_session_cfg_remove_flags:
1263
 
 * @cfg: a #BraseroSessionCfg
 
1452
 * @session: a #BraseroSessionCfg
1264
1453
 * @flags: a #BraseroBurnFlag
1265
1454
 *
1266
1455
 * Removes all flags that are not compulsory.
1268
1457
 **/
1269
1458
 
1270
1459
void
1271
 
brasero_session_cfg_remove_flags (BraseroSessionCfg *self,
 
1460
brasero_session_cfg_remove_flags (BraseroSessionCfg *session,
1272
1461
                                  BraseroBurnFlag flags)
1273
1462
{
1274
 
        BraseroSessionCfgPrivate *priv;
1275
 
 
1276
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
1277
 
 
1278
 
        brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (self), flags);
 
1463
        brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (session), flags);
1279
1464
 
1280
1465
        /* For this case reset all flags as some flags could
1281
1466
         * be made available after the removal of one flag
1282
1467
         * Example: After the removal of MULTI, FAST_BLANK
1283
1468
         * becomes available again for DVDRW sequential */
1284
 
        brasero_session_cfg_set_drive_properties_default_flags (self);
1285
 
        brasero_session_cfg_update (self);
 
1469
        brasero_session_cfg_set_drive_properties_default_flags (session);
 
1470
 
 
1471
        if (brasero_session_cfg_can_update (session))
 
1472
                brasero_session_cfg_update (session);
1286
1473
}
1287
1474
 
1288
1475
/**
1289
1476
 * brasero_session_cfg_is_supported:
1290
 
 * @cfg: a #BraseroSessionCfg
 
1477
 * @session: a #BraseroSessionCfg
1291
1478
 * @flag: a #BraseroBurnFlag
1292
1479
 *
1293
1480
 * Checks whether a particular flag is supported.
1297
1484
 **/
1298
1485
 
1299
1486
gboolean
1300
 
brasero_session_cfg_is_supported (BraseroSessionCfg *self,
 
1487
brasero_session_cfg_is_supported (BraseroSessionCfg *session,
1301
1488
                                  BraseroBurnFlag flag)
1302
1489
{
1303
1490
        BraseroSessionCfgPrivate *priv;
1304
1491
 
1305
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
1492
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1306
1493
        return (priv->supported & flag) == flag;
1307
1494
}
1308
1495
 
1309
1496
/**
1310
1497
 * brasero_session_cfg_is_compulsory:
1311
 
 * @cfg: a #BraseroSessionCfg
 
1498
 * @session: a #BraseroSessionCfg
1312
1499
 * @flag: a #BraseroBurnFlag
1313
1500
 *
1314
1501
 * Checks whether a particular flag is compulsory.
1318
1505
 **/
1319
1506
 
1320
1507
gboolean
1321
 
brasero_session_cfg_is_compulsory (BraseroSessionCfg *self,
 
1508
brasero_session_cfg_is_compulsory (BraseroSessionCfg *session,
1322
1509
                                   BraseroBurnFlag flag)
1323
1510
{
1324
1511
        BraseroSessionCfgPrivate *priv;
1325
1512
 
1326
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
1513
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1327
1514
        return (priv->compulsory & flag) == flag;
1328
1515
}
1329
1516
 
1335
1522
 
1336
1523
        priv = BRASERO_SESSION_CFG_PRIVATE (object);
1337
1524
 
 
1525
        priv->is_valid = BRASERO_SESSION_EMPTY;
1338
1526
        manager = brasero_plugin_manager_get_default ();
1339
1527
        g_signal_connect (manager,
1340
1528
                          "caps-changed",
1366
1554
                                              brasero_session_cfg_caps_changed,
1367
1555
                                              object);
1368
1556
 
 
1557
        if (priv->source) {
 
1558
                brasero_track_type_free (priv->source);
 
1559
                priv->source = NULL;
 
1560
        }
 
1561
 
 
1562
        if (priv->output) {
 
1563
                g_free (priv->output);
 
1564
                priv->output = NULL;
 
1565
        }
 
1566
 
1369
1567
        G_OBJECT_CLASS (brasero_session_cfg_parent_class)->finalize (object);
1370
1568
}
1371
1569