← 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): Robert Ancell
  • Date: 2009-09-08 09:33:41 UTC
  • mto: (1.4.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 52.
  • Revision ID: james.westby@ubuntu.com-20090908093341-ijo24e75x1j3hviu
Tags: upstream-2.27.92
Import upstream version 2.27.92

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbrasero-burn/brasero-session-cfg.c
564
564
}
565
565
 
566
566
static void
 
567
brasero_session_cfg_set_drive_properties_default_flags (BraseroSessionCfg *self)
 
568
{
 
569
        BraseroMedia media;
 
570
        BraseroSessionCfgPrivate *priv;
 
571
 
 
572
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
573
 
 
574
        media = brasero_burn_session_get_dest_media (BRASERO_BURN_SESSION (self));
 
575
 
 
576
        if (BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS)
 
577
        ||  BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_RESTRICTED)
 
578
        ||  BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS_DL)) {
 
579
                /* This is a special case to favour libburn/growisofs
 
580
                 * wodim/cdrecord for these types of media. */
 
581
                if (priv->supported & BRASERO_BURN_FLAG_MULTI) {
 
582
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
 
583
                                                       BRASERO_BURN_FLAG_MULTI);
 
584
 
 
585
                        priv->supported = BRASERO_BURN_FLAG_NONE;
 
586
                        priv->compulsory = BRASERO_BURN_FLAG_NONE;
 
587
                        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
 
588
                                                             &priv->supported,
 
589
                                                             &priv->compulsory);
 
590
                }
 
591
        }
 
592
 
 
593
        /* Always set this flag whenever possible */
 
594
        if (priv->supported & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
 
595
                brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
 
596
                                               BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE);
 
597
 
 
598
                if (priv->supported & BRASERO_BURN_FLAG_FAST_BLANK
 
599
                && (media & BRASERO_MEDIUM_UNFORMATTED) == 0)
 
600
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
 
601
                                                       BRASERO_BURN_FLAG_FAST_BLANK);
 
602
 
 
603
                priv->supported = BRASERO_BURN_FLAG_NONE;
 
604
                priv->compulsory = BRASERO_BURN_FLAG_NONE;
 
605
                brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
 
606
                                                     &priv->supported,
 
607
                                                     &priv->compulsory);
 
608
        }
 
609
 
 
610
        /* When copying with same drive don't set write mode, it'll be set later */
 
611
        if (!brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))
 
612
        &&  !(media & BRASERO_MEDIUM_DVD)) {
 
613
                /* use DAO whenever it's possible except for DVDs otherwise
 
614
                 * wodime which claims to support it will be used by default
 
615
                 * instead of say growisofs. */
 
616
                if (priv->supported & BRASERO_BURN_FLAG_DAO) {
 
617
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), BRASERO_BURN_FLAG_DAO);
 
618
 
 
619
                        priv->supported = BRASERO_BURN_FLAG_NONE;
 
620
                        priv->compulsory = BRASERO_BURN_FLAG_NONE;
 
621
                        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
 
622
                                                             &priv->supported,
 
623
                                                             &priv->compulsory);
 
624
 
 
625
                        /* NOTE: after setting DAO, some flags may become
 
626
                         * compulsory like BLANK_BEFORE for CDRW with data */
 
627
                }
 
628
        }
 
629
}
 
630
 
 
631
static void
567
632
brasero_session_cfg_set_drive_properties_flags (BraseroSessionCfg *self,
568
633
                                                BraseroBurnFlag flags)
569
634
{
 
635
        BraseroDrive *drive;
570
636
        BraseroMedia media;
571
637
        BraseroBurnFlag flag;
572
 
        BraseroDrive *drive;
573
638
        BraseroMedium *medium;
574
639
        BraseroBurnResult result;
575
640
        BraseroBurnFlag original_flags;
641
706
                }
642
707
        }
643
708
 
644
 
        if (BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS)
645
 
        ||  BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_RESTRICTED)
646
 
        ||  BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS_DL)) {
647
 
                /* This is a special case to favour libburn/growisofs
648
 
                 * wodim/cdrecord for these types of media. */
649
 
                if (priv->supported & BRASERO_BURN_FLAG_MULTI) {
650
 
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
651
 
                                                       BRASERO_BURN_FLAG_MULTI);
652
 
 
653
 
                        priv->supported = BRASERO_BURN_FLAG_NONE;
654
 
                        priv->compulsory = BRASERO_BURN_FLAG_NONE;
655
 
                        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
656
 
                                                             &priv->supported,
657
 
                                                             &priv->compulsory);
658
 
                }
659
 
        }
660
 
 
661
 
        /* Always set this flag whenever possible */
662
 
        if (priv->supported & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
663
 
                brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
664
 
                                               BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE);
665
 
 
666
 
                if (priv->supported & BRASERO_BURN_FLAG_FAST_BLANK
667
 
                && (media & BRASERO_MEDIUM_UNFORMATTED) == 0)
668
 
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
669
 
                                                       BRASERO_BURN_FLAG_FAST_BLANK);
670
 
 
671
 
                priv->supported = BRASERO_BURN_FLAG_NONE;
672
 
                priv->compulsory = BRASERO_BURN_FLAG_NONE;
673
 
                brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
674
 
                                                     &priv->supported,
675
 
                                                     &priv->compulsory);
676
 
        }
677
 
 
678
 
        /* When copying with same drive don't set write mode, it'll be set later */
679
 
        if (!brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))
680
 
        &&  !(media & BRASERO_MEDIUM_DVD)) {
681
 
                /* use DAO whenever it's possible except for DVDs otherwise
682
 
                 * wodime which claims to support it will be used by default
683
 
                 * instead of say growisofs. */
684
 
                if (priv->supported & BRASERO_BURN_FLAG_DAO) {
685
 
                        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), BRASERO_BURN_FLAG_DAO);
686
 
 
687
 
                        priv->supported = BRASERO_BURN_FLAG_NONE;
688
 
                        priv->compulsory = BRASERO_BURN_FLAG_NONE;
689
 
                        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
690
 
                                                             &priv->supported,
691
 
                                                             &priv->compulsory);
692
 
 
693
 
                        /* NOTE: after setting DAO, some flags may become
694
 
                         * compulsory like BLANK_BEFORE for CDRW with data */
695
 
                }
696
 
        }
 
709
        brasero_session_cfg_set_drive_properties_default_flags (self);
697
710
 
698
711
        /* allow flag changed signal again */
699
712
        priv->inhibit_flag_sig = FALSE;
1081
1094
        }
1082
1095
 
1083
1096
        /* Check that current input and output work */
1084
 
        if (priv->CD_TEXT_modified) {
1085
 
                /* Try to redo what we undid (after all a new plugin could have
1086
 
                 * been activated in the mean time ...) and see what happens */
1087
 
                brasero_track_type_set_image_format (source,
1088
 
                                                     BRASERO_METADATA_INFO|
1089
 
                                                     brasero_track_type_get_image_format (source));
1090
 
                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
1091
 
                                                               source,
1092
 
                                                               FALSE);
1093
 
                if (result == BRASERO_BURN_OK) {
1094
 
                        priv->CD_TEXT_modified = FALSE;
1095
 
 
1096
 
                        priv->configuring = TRUE;
1097
 
                        brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
1098
 
                                                                     brasero_track_type_get_stream_format (source));
1099
 
                        priv->configuring = FALSE;
1100
 
                }
1101
 
                else {
1102
 
                        /* No, nothing's changed */
1103
 
                        brasero_track_type_set_stream_format (source,
1104
 
                                                              (~BRASERO_METADATA_INFO) &
1105
 
                                                              brasero_track_type_get_stream_format (source));
1106
 
                        result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
1107
 
                                                                       source,
1108
 
                                                                       FALSE);
1109
 
                }
1110
 
        }
1111
 
        else {
1112
 
                /* Don't use flags as they'll be adapted later. */
1113
 
                result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self),
1114
 
                                                        FALSE);
1115
 
                if (result != BRASERO_BURN_OK
1116
 
                &&  brasero_track_type_get_has_stream (source)
1117
 
                && (brasero_track_type_get_stream_format (source) & BRASERO_METADATA_INFO)) {
1118
 
                        /* Another special case in case some burning backends 
1119
 
                         * don't support CD-TEXT for audio (libburn). If no
1120
 
                         * other backend is available remove CD-TEXT option but
1121
 
                         * tell user... */
1122
 
                        brasero_track_type_set_stream_format (source,
1123
 
                                                              (~BRASERO_METADATA_INFO) &
1124
 
                                                              brasero_track_type_get_stream_format (source));
1125
 
 
1126
 
                        result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
1127
 
                                                                       source,
1128
 
                                                                       FALSE);
1129
 
                        BRASERO_BURN_LOG ("Tested support without Metadata information (result %d)", result);
 
1097
        if (brasero_track_type_get_has_stream (source)) {
 
1098
                if (priv->CD_TEXT_modified) {
 
1099
                        /* Try to redo what we undid (after all a new plugin could have
 
1100
                         * been activated in the mean time ...) and see what happens */
 
1101
                        brasero_track_type_set_stream_format (source,
 
1102
                                                              BRASERO_METADATA_INFO|
 
1103
                                                              brasero_track_type_get_stream_format (source));
 
1104
                        result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
 
1105
                                                                       source,
 
1106
                                                                       FALSE);
1130
1107
                        if (result == BRASERO_BURN_OK) {
1131
 
                                priv->CD_TEXT_modified = TRUE;
 
1108
                                priv->CD_TEXT_modified = FALSE;
1132
1109
 
1133
1110
                                priv->configuring = TRUE;
1134
1111
                                brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
1135
 
                                                                             brasero_track_type_get_has_stream (source));
 
1112
                                                                             brasero_track_type_get_stream_format (source));
1136
1113
                                priv->configuring = FALSE;
1137
1114
                        }
1138
 
                }
 
1115
                        else {
 
1116
                                /* No, nothing's changed */
 
1117
                                brasero_track_type_set_stream_format (source,
 
1118
                                                                      (~BRASERO_METADATA_INFO) &
 
1119
                                                                      brasero_track_type_get_stream_format (source));
 
1120
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
 
1121
                                                                               source,
 
1122
                                                                               FALSE);
 
1123
                        }
 
1124
                }
 
1125
                else {
 
1126
                        result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self), FALSE);
 
1127
 
 
1128
                        if (result != BRASERO_BURN_OK
 
1129
                        && (brasero_track_type_get_stream_format (source) & BRASERO_METADATA_INFO)) {
 
1130
                                /* Another special case in case some burning backends 
 
1131
                                 * don't support CD-TEXT for audio (libburn). If no
 
1132
                                 * other backend is available remove CD-TEXT option but
 
1133
                                 * tell user... */
 
1134
                                brasero_track_type_set_stream_format (source,
 
1135
                                                                      (~BRASERO_METADATA_INFO) &
 
1136
                                                                      brasero_track_type_get_stream_format (source));
 
1137
 
 
1138
                                result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self),
 
1139
                                                                               source,
 
1140
                                                                               FALSE);
 
1141
                                BRASERO_BURN_LOG ("Tested support without Metadata information (result %d)", result);
 
1142
                                if (result == BRASERO_BURN_OK) {
 
1143
                                        priv->CD_TEXT_modified = TRUE;
 
1144
 
 
1145
                                        priv->configuring = TRUE;
 
1146
                                        brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
 
1147
                                                                                     brasero_track_type_get_has_stream (source));
 
1148
                                        priv->configuring = FALSE;
 
1149
                                }
 
1150
                        }
 
1151
                }
 
1152
        }
 
1153
        else if (brasero_track_type_get_has_medium (source)
 
1154
        &&  (brasero_track_type_get_medium_type (source) & BRASERO_MEDIUM_HAS_AUDIO)) {
 
1155
                BraseroImageFormat format = BRASERO_IMAGE_FORMAT_NONE;
 
1156
 
 
1157
                /* If we copy an audio disc check the image
 
1158
                 * type we're writing to as it may mean that
 
1159
                 * CD-TEXT cannot be copied.
 
1160
                 * Make sure that the writing backend
 
1161
                 * supports writing CD-TEXT?
 
1162
                 * no, if a backend reports it supports an
 
1163
                 * image type it should be able to burn all
 
1164
                 * its data. */
 
1165
                if (!brasero_burn_session_is_dest_file (BRASERO_BURN_SESSION (self))) {
 
1166
                        BraseroTrackType *tmp_type;
 
1167
 
 
1168
                        tmp_type = brasero_track_type_new ();
 
1169
 
 
1170
                        /* NOTE: this is the same as brasero_burn_session_can_burn () */
 
1171
                        result = brasero_burn_session_get_tmp_image_type_same_src_dest (BRASERO_BURN_SESSION (self), tmp_type);
 
1172
                        if (result == BRASERO_BURN_OK)
 
1173
                                format = brasero_track_type_get_image_format (tmp_type);
 
1174
                        else
 
1175
                                format = BRASERO_IMAGE_FORMAT_NONE;
 
1176
 
 
1177
                        brasero_track_type_free (tmp_type);
 
1178
 
 
1179
                        BRASERO_BURN_LOG ("Temporary image type %i", format);
 
1180
                }
 
1181
                else {
 
1182
                        result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self),
 
1183
                                                                FALSE);
 
1184
                        format = brasero_burn_session_get_output_format (BRASERO_BURN_SESSION (self));
 
1185
                }
 
1186
 
 
1187
                priv->CD_TEXT_modified = FALSE;
 
1188
                if (!(format & (BRASERO_IMAGE_FORMAT_CDRDAO|BRASERO_IMAGE_FORMAT_CUE)))
 
1189
                        priv->CD_TEXT_modified = TRUE;
 
1190
        }
 
1191
        else {
 
1192
                /* Don't use flags as they'll be adapted later. */
 
1193
                priv->CD_TEXT_modified = FALSE;
 
1194
                result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self),
 
1195
                                                        FALSE);
1139
1196
        }
1140
1197
 
1141
1198
        if (result != BRASERO_BURN_OK) {
1395
1452
 * @cfg: a #BraseroSessionCfg
1396
1453
 * @flags: a #BraseroBurnFlag
1397
1454
 *
1398
 
 * Adds all flags from @flags that are not supported.
 
1455
 * Adds all flags from @flags that are supported.
1399
1456
 *
1400
1457
 **/
1401
1458
 
1404
1461
                               BraseroBurnFlag flags)
1405
1462
{
1406
1463
        BraseroSessionCfgPrivate *priv;
1407
 
        BraseroDrive *drive;
1408
1464
 
1409
1465
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
1410
1466
 
1414
1470
        if ((brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self)) & flags) == flags)
1415
1471
                return;
1416
1472
 
1417
 
        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), flags);
1418
 
        priv->supported = BRASERO_BURN_FLAG_NONE;
1419
 
        priv->compulsory = BRASERO_BURN_FLAG_NONE;
1420
 
        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
1421
 
                                             &priv->supported,
1422
 
                                             &priv->compulsory);
1423
 
 
1424
 
        /* Always save flags */
1425
 
        drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
1426
 
        if (drive && brasero_drive_get_medium (drive))
1427
 
                brasero_session_cfg_save_drive_flags (self, brasero_drive_get_medium (drive));
1428
 
 
 
1473
        brasero_session_cfg_add_drive_properties_flags (self, flags);
1429
1474
        brasero_session_cfg_update (self,
1430
1475
                                    FALSE,
1431
1476
                                    FALSE);
1450
1495
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
1451
1496
 
1452
1497
        brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (self), flags);
1453
 
        priv->supported = BRASERO_BURN_FLAG_NONE;
1454
 
        priv->compulsory = BRASERO_BURN_FLAG_NONE;
1455
 
        brasero_burn_session_get_burn_flags (BRASERO_BURN_SESSION (self),
1456
 
                                             &priv->supported,
1457
 
                                             &priv->compulsory);
 
1498
 
 
1499
        /* For this case reset all flags as some flags could
 
1500
         * be made available after the removal of one flag
 
1501
         * Example: After the removal of MULTI, FAST_BLANK
 
1502
         * becomes available again for DVDRW sequential */
 
1503
        brasero_session_cfg_set_drive_properties_default_flags (self);
1458
1504
 
1459
1505
        /* Always save flags */
1460
1506
        drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));