1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2 /*
3 * Libbrasero-burn
4 * Copyright (C) Philippe Rouquier 2005-2009 <bonfire-app@wanadoo.fr>
5 *
6 * Libbrasero-burn is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * The Libbrasero-burn authors hereby grant permission for non-GPL compatible
12 * GStreamer plugins to be used and distributed together with GStreamer
13 * and Libbrasero-burn. This permission is above and beyond the permissions granted
14 * by the GPL license by which Libbrasero-burn is covered. If you modify this code
15 * you may extend this exception to your version of the code, but you are not
16 * obligated to do so. If you do not wish to do so, delete this exception
17 * statement from your version.
18 *
19 * Libbrasero-burn is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU Library General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to:
26 * The Free Software Foundation, Inc.,
27 * 51 Franklin Street, Fifth Floor
28 * Boston, MA 02110-1301, USA.
29 */
30
31 #ifdef HAVE_CONFIG_H
32 # include <config.h>
33 #endif
34
35 #include <glib.h>
36
37 #include "brasero-medium.h"
38 #include "brasero-drive.h"
39 #include "brasero-track-type.h"
40 #include "brasero-track-type-private.h"
41
42 /**
43 * brasero_track_type_new:
44 *
45 * Creates a new #BraseroTrackType structure.
46 * Free it with brasero_track_type_free ().
47 *
48 * Return value: a #BraseroTrackType pointer.
49 **/
50
51 BraseroTrackType *
brasero_track_type_new(void)52 brasero_track_type_new (void)
53 {
54 return g_new0 (BraseroTrackType, 1);
55 }
56
57 /**
58 * brasero_track_type_free:
59 * @type: a #BraseroTrackType.
60 *
61 * Frees #BraseroTrackType structure.
62 *
63 **/
64
65 void
brasero_track_type_free(BraseroTrackType * type)66 brasero_track_type_free (BraseroTrackType *type)
67 {
68 if (!type)
69 return;
70
71 g_free (type);
72 }
73
74 /**
75 * brasero_track_type_get_image_format:
76 * @type: a #BraseroTrackType.
77 *
78 * Returns the format of an image when
79 * brasero_track_type_get_has_image () returned
80 * TRUE.
81 *
82 * Return value: a #BraseroImageFormat
83 **/
84
85 BraseroImageFormat
brasero_track_type_get_image_format(const BraseroTrackType * type)86 brasero_track_type_get_image_format (const BraseroTrackType *type)
87 {
88 g_return_val_if_fail (type != NULL, BRASERO_IMAGE_FORMAT_NONE);
89
90 if (type->type != BRASERO_TRACK_TYPE_IMAGE)
91 return BRASERO_IMAGE_FORMAT_NONE;
92
93 return type->subtype.img_format;
94 }
95
96 /**
97 * brasero_track_type_get_data_fs:
98 * @type: a #BraseroTrackType.
99 *
100 * Returns the parameters for the image generation
101 * when brasero_track_type_get_has_data () returned
102 * TRUE.
103 *
104 * Return value: a #BraseroImageFS
105 **/
106
107 BraseroImageFS
brasero_track_type_get_data_fs(const BraseroTrackType * type)108 brasero_track_type_get_data_fs (const BraseroTrackType *type)
109 {
110 g_return_val_if_fail (type != NULL, BRASERO_IMAGE_FS_NONE);
111
112 if (type->type != BRASERO_TRACK_TYPE_DATA)
113 return BRASERO_IMAGE_FS_NONE;
114
115 return type->subtype.fs_type;
116 }
117
118 /**
119 * brasero_track_type_get_stream_format:
120 * @type: a #BraseroTrackType.
121 *
122 * Returns the format for a stream (song or video)
123 * when brasero_track_type_get_has_stream () returned
124 * TRUE.
125 *
126 * Return value: a #BraseroStreamFormat
127 **/
128
129 BraseroStreamFormat
brasero_track_type_get_stream_format(const BraseroTrackType * type)130 brasero_track_type_get_stream_format (const BraseroTrackType *type)
131 {
132 g_return_val_if_fail (type != NULL, BRASERO_AUDIO_FORMAT_NONE);
133
134 if (type->type != BRASERO_TRACK_TYPE_STREAM)
135 return BRASERO_AUDIO_FORMAT_NONE;
136
137 return type->subtype.stream_format;
138 }
139
140 /**
141 * brasero_track_type_get_medium_type:
142 * @type: a #BraseroTrackType.
143 *
144 * Returns the medium type
145 * when brasero_track_type_get_has_medium () returned
146 * TRUE.
147 *
148 * Return value: a #BraseroMedia
149 **/
150
151 BraseroMedia
brasero_track_type_get_medium_type(const BraseroTrackType * type)152 brasero_track_type_get_medium_type (const BraseroTrackType *type)
153 {
154 g_return_val_if_fail (type != NULL, BRASERO_MEDIUM_NONE);
155
156 if (type->type != BRASERO_TRACK_TYPE_DISC)
157 return BRASERO_MEDIUM_NONE;
158
159 return type->subtype.media;
160 }
161
162 /**
163 * brasero_track_type_set_image_format:
164 * @type: a #BraseroTrackType.
165 * @format: a #BraseroImageFormat
166 *
167 * Sets the #BraseroImageFormat. Must be called
168 * after brasero_track_type_set_has_image ().
169 *
170 **/
171
172 void
brasero_track_type_set_image_format(BraseroTrackType * type,BraseroImageFormat format)173 brasero_track_type_set_image_format (BraseroTrackType *type,
174 BraseroImageFormat format)
175 {
176 g_return_if_fail (type != NULL);
177
178 if (type->type != BRASERO_TRACK_TYPE_IMAGE)
179 return;
180
181 type->subtype.img_format = format;
182 }
183
184 /**
185 * brasero_track_type_set_data_fs:
186 * @type: a #BraseroTrackType.
187 * @fs_type: a #BraseroImageFS
188 *
189 * Sets the #BraseroImageFS. Must be called
190 * after brasero_track_type_set_has_data ().
191 *
192 **/
193
194 void
brasero_track_type_set_data_fs(BraseroTrackType * type,BraseroImageFS fs_type)195 brasero_track_type_set_data_fs (BraseroTrackType *type,
196 BraseroImageFS fs_type)
197 {
198 g_return_if_fail (type != NULL);
199
200 if (type->type != BRASERO_TRACK_TYPE_DATA)
201 return;
202
203 type->subtype.fs_type = fs_type;
204 }
205
206 /**
207 * brasero_track_type_set_stream_format:
208 * @type: a #BraseroTrackType.
209 * @format: a #BraseroImageFormat
210 *
211 * Sets the #BraseroStreamFormat. Must be called
212 * after brasero_track_type_set_has_stream ().
213 *
214 **/
215
216 void
brasero_track_type_set_stream_format(BraseroTrackType * type,BraseroStreamFormat format)217 brasero_track_type_set_stream_format (BraseroTrackType *type,
218 BraseroStreamFormat format)
219 {
220 g_return_if_fail (type != NULL);
221
222 if (type->type != BRASERO_TRACK_TYPE_STREAM)
223 return;
224
225 type->subtype.stream_format = format;
226 }
227
228 /**
229 * brasero_track_type_set_medium_type:
230 * @type: a #BraseroTrackType.
231 * @media: a #BraseroMedia
232 *
233 * Sets the #BraseroMedia. Must be called
234 * after brasero_track_type_set_has_medium ().
235 *
236 **/
237
238 void
brasero_track_type_set_medium_type(BraseroTrackType * type,BraseroMedia media)239 brasero_track_type_set_medium_type (BraseroTrackType *type,
240 BraseroMedia media)
241 {
242 g_return_if_fail (type != NULL);
243
244 if (type->type != BRASERO_TRACK_TYPE_DISC)
245 return;
246
247 type->subtype.media = media;
248 }
249
250 /**
251 * brasero_track_type_is_empty:
252 * @type: a #BraseroTrackType.
253 *
254 * Returns TRUE if no type was set.
255 *
256 * Return value: a #gboolean
257 **/
258
259 gboolean
brasero_track_type_is_empty(const BraseroTrackType * type)260 brasero_track_type_is_empty (const BraseroTrackType *type)
261 {
262 g_return_val_if_fail (type != NULL, FALSE);
263
264 return (type->type == BRASERO_TRACK_TYPE_NONE);
265 }
266
267 /**
268 * brasero_track_type_get_has_data:
269 * @type: a #BraseroTrackType.
270 *
271 * Returns TRUE if DATA type (see brasero_track_data_new ()) was set.
272 *
273 * Return value: a #gboolean
274 **/
275
276 gboolean
brasero_track_type_get_has_data(const BraseroTrackType * type)277 brasero_track_type_get_has_data (const BraseroTrackType *type)
278 {
279 g_return_val_if_fail (type != NULL, FALSE);
280
281 return type->type == BRASERO_TRACK_TYPE_DATA;
282 }
283
284 /**
285 * brasero_track_type_get_has_image:
286 * @type: a #BraseroTrackType.
287 *
288 * Returns TRUE if IMAGE type (see brasero_track_image_new ()) was set.
289 *
290 * Return value: a #gboolean
291 **/
292
293 gboolean
brasero_track_type_get_has_image(const BraseroTrackType * type)294 brasero_track_type_get_has_image (const BraseroTrackType *type)
295 {
296 g_return_val_if_fail (type != NULL, FALSE);
297
298 return type->type == BRASERO_TRACK_TYPE_IMAGE;
299 }
300
301 /**
302 * brasero_track_type_get_has_stream:
303 * @type: a #BraseroTrackType.
304 *
305 * This function returns %TRUE if IMAGE type (see brasero_track_stream_new ()) was set.
306 *
307 * Return value: a #gboolean
308 **/
309
310 gboolean
brasero_track_type_get_has_stream(const BraseroTrackType * type)311 brasero_track_type_get_has_stream (const BraseroTrackType *type)
312 {
313 g_return_val_if_fail (type != NULL, FALSE);
314
315 return type->type == BRASERO_TRACK_TYPE_STREAM;
316 }
317
318 /**
319 * brasero_track_type_get_has_medium:
320 * @type: a #BraseroTrackType.
321 *
322 * Returns TRUE if MEDIUM type (see brasero_track_disc_new ()) was set.
323 *
324 * Return value: a #gboolean
325 **/
326
327 gboolean
brasero_track_type_get_has_medium(const BraseroTrackType * type)328 brasero_track_type_get_has_medium (const BraseroTrackType *type)
329 {
330 g_return_val_if_fail (type != NULL, FALSE);
331
332 return type->type == BRASERO_TRACK_TYPE_DISC;
333 }
334
335 /**
336 * brasero_track_type_set_has_data:
337 * @type: a #BraseroTrackType.
338 *
339 * Set DATA type for @type.
340 *
341 **/
342
343 void
brasero_track_type_set_has_data(BraseroTrackType * type)344 brasero_track_type_set_has_data (BraseroTrackType *type)
345 {
346 g_return_if_fail (type != NULL);
347
348 type->type = BRASERO_TRACK_TYPE_DATA;
349 }
350
351 /**
352 * brasero_track_type_set_has_image:
353 * @type: a #BraseroTrackType.
354 *
355 * Set IMAGE type for @type.
356 *
357 **/
358
359 void
brasero_track_type_set_has_image(BraseroTrackType * type)360 brasero_track_type_set_has_image (BraseroTrackType *type)
361 {
362 g_return_if_fail (type != NULL);
363
364 type->type = BRASERO_TRACK_TYPE_IMAGE;
365 }
366
367 /**
368 * brasero_track_type_set_has_stream:
369 * @type: a #BraseroTrackType.
370 *
371 * Set STREAM type for @type
372 *
373 **/
374
375 void
brasero_track_type_set_has_stream(BraseroTrackType * type)376 brasero_track_type_set_has_stream (BraseroTrackType *type)
377 {
378 g_return_if_fail (type != NULL);
379
380 type->type = BRASERO_TRACK_TYPE_STREAM;
381 }
382
383 /**
384 * brasero_track_type_set_has_medium:
385 * @type: a #BraseroTrackType.
386 *
387 * Set MEDIUM type for @type.
388 *
389 **/
390
391 void
brasero_track_type_set_has_medium(BraseroTrackType * type)392 brasero_track_type_set_has_medium (BraseroTrackType *type)
393 {
394 g_return_if_fail (type != NULL);
395
396 type->type = BRASERO_TRACK_TYPE_DISC;
397 }
398
399 /**
400 * brasero_track_type_equal:
401 * @type_A: a #BraseroTrackType.
402 * @type_B: a #BraseroTrackType.
403 *
404 * Returns TRUE if @type_A and @type_B represents
405 * the same type and subtype.
406 *
407 * Return value: a #gboolean
408 **/
409
410 gboolean
brasero_track_type_equal(const BraseroTrackType * type_A,const BraseroTrackType * type_B)411 brasero_track_type_equal (const BraseroTrackType *type_A,
412 const BraseroTrackType *type_B)
413 {
414 g_return_val_if_fail (type_A != NULL, FALSE);
415 g_return_val_if_fail (type_B != NULL, FALSE);
416
417 if (type_A->type != type_B->type)
418 return FALSE;
419
420 switch (type_A->type) {
421 case BRASERO_TRACK_TYPE_DATA:
422 if (type_A->subtype.fs_type != type_B->subtype.fs_type)
423 return FALSE;
424 break;
425
426 case BRASERO_TRACK_TYPE_DISC:
427 if (type_B->subtype.media != type_A->subtype.media)
428 return FALSE;
429 break;
430
431 case BRASERO_TRACK_TYPE_IMAGE:
432 if (type_A->subtype.img_format != type_B->subtype.img_format)
433 return FALSE;
434 break;
435
436 case BRASERO_TRACK_TYPE_STREAM:
437 if (type_A->subtype.stream_format != type_B->subtype.stream_format)
438 return FALSE;
439 break;
440
441 default:
442 break;
443 }
444
445 return TRUE;
446 }
447
448 #if 0
449 /**
450 * brasero_track_type_match:
451 * @type_A: a #BraseroTrackType.
452 * @type_B: a #BraseroTrackType.
453 *
454 * Returns TRUE if @type_A and @type_B match.
455 *
456 * (Used internally)
457 *
458 * Return value: a #gboolean
459 **/
460
461 gboolean
462 brasero_track_type_match (const BraseroTrackType *type_A,
463 const BraseroTrackType *type_B)
464 {
465 g_return_val_if_fail (type_A != NULL, FALSE);
466 g_return_val_if_fail (type_B != NULL, FALSE);
467
468 if (type_A->type != type_B->type)
469 return FALSE;
470
471 switch (type_A->type) {
472 case BRASERO_TRACK_TYPE_DATA:
473 if (!(type_A->subtype.fs_type & type_B->subtype.fs_type))
474 return FALSE;
475 break;
476
477 case BRASERO_TRACK_TYPE_DISC:
478 if (!(type_A->subtype.media & type_B->subtype.media))
479 return FALSE;
480 break;
481
482 case BRASERO_TRACK_TYPE_IMAGE:
483 if (!(type_A->subtype.img_format & type_B->subtype.img_format))
484 return FALSE;
485 break;
486
487 case BRASERO_TRACK_TYPE_STREAM:
488 if (!(type_A->subtype.stream_format & type_B->subtype.stream_format))
489 return FALSE;
490 break;
491
492 default:
493 break;
494 }
495
496 return TRUE;
497 }
498
499 #endif
500