← 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-span.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Moog
  • Date: 2009-07-28 01:12:27 UTC
  • mto: (1.4.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 46.
  • Revision ID: james.westby@ubuntu.com-20090728011227-tiva9yorc5d1r5hs
Tags: upstream-2.27.5
Import upstream version 2.27.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbrasero-burn/brasero-session-span.c
36
36
#include "brasero-medium.h"
37
37
 
38
38
#include "burn-debug.h"
39
 
#include "brasero-session-helper.h"
40
39
#include "brasero-track.h"
41
40
#include "brasero-track-data.h"
42
41
#include "brasero-track-data-cfg.h"
53
52
 
54
53
G_DEFINE_TYPE (BraseroSessionSpan, brasero_session_span, BRASERO_TYPE_BURN_SESSION);
55
54
 
56
 
/**
57
 
 * brasero_session_span_get_max_space:
58
 
 * @session: a #BraseroSessionSpan
59
 
 *
60
 
 * Returns the maximum required space (in sectors) 
61
 
 * among all the possible spanned batches.
62
 
 * This means that when burningto a media
63
 
 * it will also be the minimum required
64
 
 * space to burn all the contents in several
65
 
 * batches.
66
 
 *
67
 
 * Return value: a #goffset.
68
 
 **/
69
 
 
70
 
goffset
71
 
brasero_session_span_get_max_space (BraseroSessionSpan *session)
 
55
static goffset
 
56
brasero_session_span_get_available_medium_space (BraseroSessionSpan *session)
72
57
{
73
 
        GSList *tracks;
74
 
        goffset max_sectors = 0;
75
 
        BraseroSessionSpanPrivate *priv;
76
 
 
77
 
        g_return_val_if_fail (BRASERO_IS_SESSION_SPAN (session), 0);
78
 
 
79
 
        priv = BRASERO_SESSION_SPAN_PRIVATE (session);
80
 
 
81
 
        if (priv->last_track) {
82
 
                tracks = g_slist_find (priv->track_list, priv->last_track);
83
 
 
84
 
                if (!tracks->next)
85
 
                        return 0;
86
 
 
87
 
                tracks = tracks->next;
88
 
        }
89
 
        else if (priv->track_list)
90
 
                tracks = priv->track_list;
 
58
        BraseroDrive *burner;
 
59
        BraseroMedium *medium;
 
60
        BraseroBurnFlag flags;
 
61
        goffset available_blocks = 0;
 
62
 
 
63
        /* Retrieve the size available for burning */
 
64
        burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (session));
 
65
        if (!burner)
 
66
                return 0;
 
67
 
 
68
        medium = brasero_drive_get_medium (burner);
 
69
        if (!medium)
 
70
                return 0;
 
71
 
 
72
        flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (session));
 
73
        if (flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND))
 
74
                brasero_medium_get_free_space (medium, NULL, &available_blocks);
 
75
        else if (brasero_burn_session_can_blank (BRASERO_BURN_SESSION (session)) == BRASERO_BURN_OK)
 
76
                brasero_medium_get_capacity (medium, NULL, &available_blocks);
91
77
        else
92
 
                tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (session));
93
 
 
94
 
        for (; tracks; tracks = tracks->next) {
95
 
                BraseroTrack *track;
96
 
                goffset track_blocks = 0;
97
 
 
98
 
                track = tracks->data;
99
 
 
100
 
                if (BRASERO_IS_TRACK_DATA_CFG (track))
101
 
                        return brasero_track_data_cfg_span_max_space (BRASERO_TRACK_DATA_CFG (track));
102
 
 
103
 
                /* This is the common case */
104
 
                brasero_track_get_size (BRASERO_TRACK (track),
105
 
                                        &track_blocks,
106
 
                                        NULL);
107
 
 
108
 
                max_sectors = MAX (max_sectors, track_blocks);
109
 
        }
110
 
 
111
 
        return max_sectors;
 
78
                brasero_medium_get_free_space (medium, NULL, &available_blocks);
 
79
 
 
80
        BRASERO_BURN_LOG ("Available space for spanning %" G_GINT64_FORMAT, available_blocks);
 
81
        return available_blocks;
112
82
}
113
83
 
114
 
/**
115
 
 * brasero_session_span_again:
116
 
 * @session: a #BraseroSessionSpan
117
 
 *
118
 
 * Checks whether some data were not included during calls to brasero_session_span_next ().
119
 
 *
120
 
 * Return value: a #BraseroBurnResult. BRASERO_BURN_OK if there is not anymore data.
121
 
 * BRASERO_BURN_RETRY if the operation was successful and a new #BraseroTrackDataCfg was created.
122
 
 * BRASERO_BURN_ERR otherwise.
123
 
 **/
124
 
 
125
84
BraseroBurnResult
126
85
brasero_session_span_again (BraseroSessionSpan *session)
127
86
{
156
115
        return (tracks != NULL)? BRASERO_BURN_RETRY:BRASERO_BURN_OK;
157
116
}
158
117
 
159
 
/**
160
 
 * brasero_session_span_possible:
161
 
 * @session: a #BraseroSessionSpan
162
 
 *
163
 
 * Checks if a new #BraseroTrackData can be created from the files remaining in the tree 
164
 
 * after calls to brasero_session_span_next (). The maximum size of the data will be the one
165
 
 * of the medium inserted in the #BraseroDrive set for @session (see brasero_burn_session_set_burner ()).
166
 
 *
167
 
 * Return value: a #BraseroBurnResult. BRASERO_BURN_OK if there is not anymore data.
168
 
 * BRASERO_BURN_RETRY if the operation was successful and a new #BraseroTrackDataCfg was created.
169
 
 * BRASERO_BURN_ERR otherwise.
170
 
 **/
171
 
 
172
118
BraseroBurnResult
173
119
brasero_session_span_possible (BraseroSessionSpan *session)
174
120
{
182
128
 
183
129
        priv = BRASERO_SESSION_SPAN_PRIVATE (session);
184
130
 
185
 
        max_sectors = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (session));
 
131
        max_sectors = brasero_session_span_get_available_medium_space (session);
186
132
        if (max_sectors <= 0)
187
133
                return BRASERO_BURN_ERR;
188
134
 
218
164
        return BRASERO_BURN_RETRY;
219
165
}
220
166
 
221
 
/**
222
 
 * brasero_session_span_start:
223
 
 * @session: a #BraseroSessionSpan
224
 
 *
225
 
 * Get the object ready for spanning a #BraseroBurnSession object. This function
226
 
 * must be called before brasero_session_span_next ().
227
 
 *
228
 
 * Return value: a #BraseroBurnResult. BRASERO_BURN_OK if successful.
229
 
 **/
230
 
 
231
167
BraseroBurnResult
232
168
brasero_session_span_start (BraseroSessionSpan *session)
233
169
{
246
182
        return BRASERO_BURN_OK;
247
183
}
248
184
 
249
 
/**
250
 
 * brasero_session_span_next:
251
 
 * @session: a #BraseroSessionSpan
252
 
 *
253
 
 * Sets the next batch of data to be burnt onto the medium inserted in the #BraseroDrive
254
 
 * set for @session (see brasero_burn_session_set_burner ()). Its free space or it capacity
255
 
 * will be used as the maximum amount of data to be burnt.
256
 
 *
257
 
 * Return value: a #BraseroBurnResult. BRASERO_BURN_OK if successful.
258
 
 **/
259
 
 
260
185
BraseroBurnResult
261
186
brasero_session_span_next (BraseroSessionSpan *session)
262
187
{
272
197
 
273
198
        g_return_val_if_fail (priv->track_list != NULL, BRASERO_BURN_ERR);
274
199
 
275
 
        max_sectors = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (session));
 
200
        max_sectors = brasero_session_span_get_available_medium_space (session);
276
201
        if (max_sectors <= 0)
277
202
                return BRASERO_BURN_ERR;
278
203
 
354
279
        return (pushed? BRASERO_BURN_RETRY:BRASERO_BURN_ERR);
355
280
}
356
281
 
357
 
/**
358
 
 * brasero_session_span_stop:
359
 
 * @session: a #BraseroSessionSpan
360
 
 *
361
 
 * Ends and cleans a spanning operation started with brasero_session_span_start ().
362
 
 *
363
 
 **/
364
 
 
365
282
void
366
283
brasero_session_span_stop (BraseroSessionSpan *session)
367
284
{
407
324
        object_class->finalize = brasero_session_span_finalize;
408
325
}
409
326
 
410
 
/**
411
 
 * brasero_session_span_new:
412
 
 *
413
 
 * Creates a new #BraseroSessionSpan object.
414
 
 *
415
 
 * Return value: a #BraseroSessionSpan object
416
 
 **/
417
 
 
418
327
BraseroSessionSpan *
419
328
brasero_session_span_new (void)
420
329
{