← Back to branch summary

~ubuntu-branches/ubuntu/hardy/gtkpod-aac/hardy

« back to all changes in this revision

Viewing changes to src/mp4file.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-07-17 18:25:25 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070717182525-rhl5w4pk8lbk6pna
Tags: 0.99.10-2ubuntu1
* Resynchronise with gtkpod 0.9.10-2.
* Hack in dpatch support, since it was removed.
* Rename debian/patches/03-configure.dpatch to
  debian/patches/aac-configure.dpatch.
* Update debian/gtkpod-aac.diff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mp4file.c
1
 
/* Time-stamp: <2006-09-18 16:03:15 jcs>
 
1
/* Time-stamp: <2007-06-23 02:49:08 jcs>
2
2
|
3
3
|  Copyright (C) 2002-2005 Jorg Schuler <jcsjcs at users sourceforge net>
4
4
|  Part of the gtkpod project.
24
24
|
25
25
|  This product is not supported/written/published by Apple!
26
26
|
27
 
|  $Id: mp4file.c,v 1.34 2006/09/18 07:10:44 jcsjcs Exp $
 
27
|  $Id: mp4file.c 1575 2007-06-22 17:49:43Z jcsjcs $
28
28
*/
29
29
 
30
30
#ifdef HAVE_CONFIG_H
34
34
#include "charset.h"
35
35
#include "itdb.h"
36
36
#include "misc.h"
 
37
#include "prefs.h"
37
38
#include "mp4file.h"
38
 
#include "prefs.h"
 
39
 
 
40
 
39
41
 
40
42
/* ------------------------------------------------------------
41
43
 
73
75
   guint16 samplerate;        /+ e.g.: CD is 44100     +/
74
76
   guint32 peak_signal;       /+ LAME Peak Signal * 0x800000         +/
75
77
   gboolean compilation;      /+ Track is part of a compilation CD   +/
 
78
   gboolean lyrics_flag;
 
79
   gint16 bpm;
76
80
 
77
81
   If prefs_get_int("readtags") returns FALSE you only should fill in
78
82
   tracklen, bitrate, samplerate, soundcheck and filetype
134
138
#include <stdlib.h>
135
139
#include <string.h>
136
140
#include "mp4.h"
137
 
#undef PACKAGE
138
 
#undef VERSION
139
 
/* need to include config.h again because mp4.h seems to #undef
140
 
   PACKAGE */
141
 
#include <config.h>
142
 
 
143
141
 
144
142
static gboolean mp4_scan_soundcheck (MP4FileHandle mp4File, Track *track)
145
143
{
204
202
    {
205
203
        MP4TrackId trackId;
206
204
        const char *trackType;
207
 
 
208
 
        trackId = MP4FindTrackId(mp4File, 0, NULL, 0);
209
 
        trackType = MP4GetTrackType(mp4File, trackId);
210
 
 
211
 
        if (trackType &&
212
 
            ((strcmp(trackType, MP4_AUDIO_TRACK_TYPE) == 0) ||
213
 
             (strcmp(trackType, MP4_VIDEO_TRACK_TYPE) == 0) ||
214
 
             (strcmp(trackType, MP4_OD_TRACK_TYPE) == 0)))
 
205
        u_int32_t track_cur, tracks_num;
 
206
        gboolean audio_or_video_found = FALSE;
 
207
 
 
208
        tracks_num = MP4GetNumberOfTracks (mp4File, NULL,  0);
 
209
 
 
210
        for (track_cur=0; track_cur < tracks_num; ++track_cur)
215
211
        {
216
 
            success = mp4_scan_soundcheck (mp4File, track);
 
212
            trackId = MP4FindTrackId(mp4File, track_cur, NULL, 0);
 
213
            trackType = MP4GetTrackType(mp4File, trackId);
 
214
 
 
215
            if (trackType &&
 
216
                ((strcmp(trackType, MP4_AUDIO_TRACK_TYPE) == 0) ||
 
217
                 (strcmp(trackType, MP4_VIDEO_TRACK_TYPE) == 0) ||
 
218
                 (strcmp(trackType, MP4_OD_TRACK_TYPE) == 0)))
 
219
            {
 
220
                audio_or_video_found = TRUE;
 
221
                success = mp4_scan_soundcheck (mp4File, track);
 
222
            }
 
223
            if (audio_or_video_found) break;
217
224
        }
218
 
        else
 
225
        if (!audio_or_video_found)
219
226
        {
220
227
            gchar *filename = charset_to_utf8 (mp4FileName);
221
 
            gtkpod_warning (_("'%s' does not appear to be a mp4 audio file.\n"),
222
 
                            filename);
 
228
            gtkpod_warning (
 
229
                _("'%s' does not appear to be a mp4 audio or video file.\n"),
 
230
                filename);
223
231
            g_free (filename);
224
232
        }
225
233
        MP4Close(mp4File);
251
259
    {
252
260
        MP4TrackId trackId;
253
261
        const char *trackType;
254
 
 
255
 
        trackId = MP4FindTrackId(mp4File, 0, NULL, 0);
256
 
        trackType = MP4GetTrackType(mp4File, trackId);
257
 
        if (trackType &&
258
 
            ((strcmp(trackType, MP4_AUDIO_TRACK_TYPE) == 0) ||
259
 
             (strcmp(trackType, MP4_VIDEO_TRACK_TYPE) == 0) ||
260
 
             (strcmp(trackType, MP4_OD_TRACK_TYPE) == 0)))
 
262
        u_int32_t track_cur, tracks_num;
 
263
        gboolean audio_or_video_found = FALSE;
 
264
/*      gboolean artwork_found = FALSE; not used yet */
 
265
 
 
266
        tracks_num = MP4GetNumberOfTracks (mp4File, NULL,  0);
 
267
 
 
268
        for (track_cur=0; track_cur < tracks_num; ++track_cur)
261
269
        {
262
 
            gchar *value;
263
 
            guint16 numvalue, numvalue2;
264
 
            MP4Duration trackDuration = MP4GetTrackDuration(mp4File, trackId);
265
 
            double msDuration = 
266
 
                (double)MP4ConvertFromTrackDuration(mp4File, trackId,
267
 
                                                    trackDuration,
268
 
                                                    MP4_MSECS_TIME_SCALE);
269
 
            guint32 avgBitRate = MP4GetTrackBitRate(mp4File, trackId);
270
 
            guint32 samplerate = MP4GetTrackTimeScale(mp4File, trackId);
271
 
 
272
 
            track = gp_track_new ();
273
 
 
274
 
            track->tracklen = msDuration;
275
 
            track->bitrate = avgBitRate/1000;
276
 
            track->samplerate = samplerate;
277
 
            value = strrchr (mp4FileName, '.');
278
 
            if (value)
279
 
            {
280
 
                if (g_strcasecmp (value, ".m4a") == 0)
281
 
                    track->filetype = g_strdup ("AAC audio file");
282
 
                if (g_strcasecmp (value, ".m4p") == 0)
283
 
                    track->filetype = g_strdup ("Protected AAC audio file");
284
 
                if (g_strcasecmp (value, ".m4b") == 0)
285
 
                    track->filetype = g_strdup ("AAC audio book file");
286
 
                if (g_strcasecmp (value, ".mp4") == 0)
287
 
                    track->filetype = g_strdup ("MP4 video file");
288
 
            }
289
 
            if (prefs_get_int("readtags"))
290
 
            {
291
 
                if (MP4GetMetadataName(mp4File, &value) && value != NULL)
292
 
                {
293
 
                    track->title = charset_to_utf8 (value);
294
 
                    g_free(value);
295
 
                }
296
 
                if (MP4GetMetadataArtist(mp4File, &value) && value != NULL)
297
 
                {
298
 
                    track->artist = charset_to_utf8 (value);
299
 
                    g_free(value);
300
 
                }
301
 
                if (MP4GetMetadataWriter(mp4File, &value) && value != NULL)
302
 
                {
303
 
                    track->composer = charset_to_utf8 (value);
304
 
                    g_free(value);
305
 
                }
306
 
                if (MP4GetMetadataComment(mp4File, &value) && value != NULL)
307
 
                {
308
 
                    track->comment = charset_to_utf8 (value);
309
 
                    g_free(value);
310
 
                }
311
 
                if (MP4GetMetadataYear(mp4File, &value) && value != NULL)
312
 
                {
313
 
                    track->year = atoi (value);
314
 
                    g_free(value);
315
 
                }
316
 
                if (MP4GetMetadataAlbum(mp4File, &value) && value != NULL)
317
 
                {
318
 
                    track->album = charset_to_utf8 (value);
319
 
                    g_free(value);
320
 
                }
321
 
                if (MP4GetMetadataTrack(mp4File, &numvalue, &numvalue2))
322
 
                {
323
 
                    track->track_nr = numvalue;
324
 
                    track->tracks = numvalue2;
325
 
                }
326
 
                if (MP4GetMetadataDisk(mp4File, &numvalue, &numvalue2))
327
 
                {
328
 
                    track->cd_nr = numvalue;
329
 
                    track->cds = numvalue2;
330
 
                }
331
 
                if (MP4GetMetadataGenre(mp4File, &value) && value != NULL)
332
 
                {
333
 
                    track->genre = charset_to_utf8 (value);
334
 
                    g_free(value);
335
 
                }
336
 
            }
337
 
            mp4_scan_soundcheck (mp4File, track);
 
270
            trackId = MP4FindTrackId(mp4File, track_cur, NULL, 0);
 
271
            trackType = MP4GetTrackType(mp4File, trackId);
 
272
            if (trackType &&
 
273
                (audio_or_video_found == FALSE) &&
 
274
                ((strcmp(trackType, MP4_AUDIO_TRACK_TYPE) == 0) ||
 
275
                 (strcmp(trackType, MP4_VIDEO_TRACK_TYPE) == 0) ||
 
276
                 (strcmp(trackType, MP4_OD_TRACK_TYPE) == 0)))
 
277
            {
 
278
                gchar *value;
 
279
                guint16 numvalue, numvalue2;
 
280
                MP4Duration trackDuration = MP4GetTrackDuration(mp4File, trackId);
 
281
                double msDuration = 
 
282
                    (double)MP4ConvertFromTrackDuration(mp4File, trackId,
 
283
                                                        trackDuration,
 
284
                                                        MP4_MSECS_TIME_SCALE);
 
285
                guint32 avgBitRate = MP4GetTrackBitRate(mp4File, trackId);
 
286
                guint32 samplerate = MP4GetTrackTimeScale(mp4File, trackId);
 
287
                
 
288
                track = gp_track_new ();
 
289
                
 
290
                track->tracklen = msDuration;
 
291
                track->bitrate = avgBitRate/1000;
 
292
                track->samplerate = samplerate;
 
293
                value = strrchr (mp4FileName, '.');
 
294
                if (value)
 
295
                {
 
296
                    if (g_strcasecmp (value, ".m4a") == 0)
 
297
                        track->filetype = g_strdup ("AAC audio file");
 
298
                    if (g_strcasecmp (value, ".m4p") == 0)
 
299
                        track->filetype = g_strdup ("Protected AAC audio file");
 
300
                    if (g_strcasecmp (value, ".m4b") == 0)
 
301
                        track->filetype = g_strdup ("AAC audio book file");
 
302
                    if (g_strcasecmp (value, ".mp4") == 0)
 
303
                        track->filetype = g_strdup ("MP4 video file");
 
304
                }
 
305
                if (prefs_get_int("readtags"))
 
306
                {
 
307
                    if (MP4GetMetadataName(mp4File, &value) && value != NULL)
 
308
                    {
 
309
                        track->title = charset_to_utf8 (value);
 
310
                        g_free(value);
 
311
                    }
 
312
                    if (MP4GetMetadataArtist(mp4File, &value) && value != NULL)
 
313
                    {
 
314
                        track->artist = charset_to_utf8 (value);
 
315
                        g_free(value);
 
316
                    }
 
317
                    if (MP4GetMetadataWriter(mp4File, &value) && value != NULL)
 
318
                    {
 
319
                        track->composer = charset_to_utf8 (value);
 
320
                        g_free(value);
 
321
                    }
 
322
                    if (MP4GetMetadataComment(mp4File, &value) && value != NULL)
 
323
                    {
 
324
                        track->comment = charset_to_utf8 (value);
 
325
                        g_free(value);
 
326
                    }
 
327
                    if (MP4GetMetadataYear(mp4File, &value) && value != NULL)
 
328
                    {
 
329
                        track->year = atoi (value);
 
330
                        g_free(value);
 
331
                    }
 
332
                    if (MP4GetMetadataAlbum(mp4File, &value) && value != NULL)
 
333
                    {
 
334
                        track->album = charset_to_utf8 (value);
 
335
                        g_free(value);
 
336
                    }
 
337
                    if (MP4GetMetadataTrack(mp4File, &numvalue, &numvalue2))
 
338
                    {
 
339
                        track->track_nr = numvalue;
 
340
                        track->tracks = numvalue2;
 
341
                    }
 
342
                    if (MP4GetMetadataDisk(mp4File, &numvalue, &numvalue2))
 
343
                    {
 
344
                        track->cd_nr = numvalue;
 
345
                        track->cds = numvalue2;
 
346
                    }
 
347
                    if (MP4GetMetadataGrouping(mp4File, &value) && value != NULL)
 
348
                    {
 
349
                        track->grouping = charset_to_utf8 (value);
 
350
                        g_free (value);
 
351
                    }
 
352
                    if (MP4GetMetadataGenre(mp4File, &value) && value != NULL)
 
353
                    {
 
354
                        track->genre = charset_to_utf8 (value);
 
355
                        g_free(value);
 
356
                    }
 
357
                    if (MP4GetMetadataTempo (mp4File, &numvalue))
 
358
                    {
 
359
                        track->BPM = numvalue;
 
360
                    }
 
361
                }
 
362
                mp4_scan_soundcheck (mp4File, track);
 
363
                audio_or_video_found = TRUE;
 
364
 
 
365
                if (prefs_get_int("coverart_apic"))
 
366
                {
 
367
                    u_int8_t *image_data;
 
368
                    u_int32_t image_data_len;
 
369
                    if (MP4GetMetadataCoverArt (mp4File,
 
370
                                                &image_data, &image_data_len))
 
371
                    {
 
372
                        if (image_data)
 
373
                        {
 
374
/*                          FILE *file = fopen ("/tmp/tttt", "w");
 
375
                            fwrite (image_data, 1, image_data_len, file);
 
376
                            fclose (file);*/
 
377
                            gp_track_set_thumbnails_from_data (track,
 
378
                                                               image_data,
 
379
                                                               image_data_len);
 
380
                            g_free (image_data);
 
381
                        }
 
382
                    }
 
383
                }
 
384
            }
338
385
        }
339
 
        else
 
386
        if (!audio_or_video_found)
340
387
        {
341
388
            gchar *filename = charset_to_utf8 (mp4FileName);
342
 
            gtkpod_warning (_("'%s' does not appear to be a mp4 audio file.\n"),
343
 
                            filename);
 
389
            gtkpod_warning (
 
390
                _("'%s' does not appear to be a mp4 audio or video file.\n"),
 
391
                filename);
344
392
            g_free (filename);
345
393
        }
346
394
        MP4Close(mp4File);
435
483
 
436
484
            MP4SetMetadataDisk (mp4File, track->cd_nr, track->cds);
437
485
 
 
486
            MP4SetMetadataTempo (mp4File, track->BPM);
 
487
 
 
488
            value = charset_from_utf8 (track->grouping);
 
489
            MP4SetMetadataGrouping (mp4File, value);
 
490
            g_free (value);
 
491
 
438
492
            value = charset_from_utf8 (track->genre);
439
493
            MP4SetMetadataGenre (mp4File, value);
440
494
            g_free (value);