← Back to branch summary

~ubuntu-branches/debian/wheezy/quodlibet/wheezy

« back to all changes in this revision

Viewing changes to formats/mp4.py

  • Committer: Bazaar Package Importer
  • Author(s): Luca Falavigna
  • Date: 2009-01-30 23:55:34 UTC
  • mto: (18.1.1 squeeze) (2.1.9 sid)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: james.westby@ubuntu.com-20090130235534-45857nfsgobw4apc
Tags: upstream-2.0
Import upstream version 2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
formats/mp4.py
1
 
# Copyright 2005 Alexey Bobyakov <claymore.ws@gmail.com>, Joe Wreschnig
2
 
# Copyright 2006 Lukas Lalinsky
3
 
#
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License version 2 as
6
 
# published by the Free Software Foundation
7
 
#
8
 
# $Id: mp4.py 4047 2007-04-30 03:49:58Z piman $
9
 
 
10
 
import tempfile
11
 
import gst
12
 
import util
13
 
 
14
 
from formats._audio import AudioFile
15
 
 
16
 
extensions = ['.mp4', '.m4a']
17
 
if gst.registry_get_default().find_plugin("faad") is None:
18
 
    extensions = []
19
 
 
20
 
try:
21
 
    from mutagen.mp4 import MP4
22
 
except ImportError:
23
 
    extensions = []
24
 
 
25
 
class MP4File(AudioFile):
26
 
    multiple_values = False
27
 
    format = "MPEG-4 AAC"
28
 
 
29
 
    __translate = {
30
 
        "\xa9nam": "title",
31
 
        "\xa9alb": "album",
32
 
        "\xa9ART": "artist",
33
 
        "aART": "albumartist",
34
 
        "\xa9wrt": "composer",
35
 
        "\xa9day": "date",
36
 
        "\xa9cmt": "comment",
37
 
        "\xa9grp": "grouping",
38
 
        "\xa9gen": "genre",
39
 
        "tmpo": "bpm",
40
 
        "\xa9too": "encodedby",
41
 
        "----:com.apple.iTunes:MusicBrainz Artist Id":
42
 
            "musicbrainz_artistid",
43
 
        "----:com.apple.iTunes:MusicBrainz Track Id": "musicbrainz_trackid",
44
 
        "----:com.apple.iTunes:MusicBrainz Album Id": "musicbrainz_albumid",
45
 
        "----:com.apple.iTunes:MusicBrainz Album Artist Id":
46
 
            "musicbrainz_albumartistid",
47
 
        "----:com.apple.iTunes:MusicIP PUID": "musicip_puid",
48
 
        "----:com.apple.iTunes:MusicBrainz Album Status":
49
 
            "musicbrainz_albumstatus",
50
 
        "----:com.apple.iTunes:MusicBrainz Album Type":
51
 
            "musicbrainz_albumtype",
52
 
        "----:com.apple.iTunes:MusicBrainz Album Release Country":
53
 
            "releasecountry",
54
 
    }
55
 
    __rtranslate = dict([(v, k) for k, v in __translate.iteritems()])
56
 
 
57
 
    __tupletranslate = {
58
 
        "disk": "discnumber",
59
 
        "trkn": "tracknumber",
60
 
        }
61
 
    __rtupletranslate = dict([(v, k) for k, v in __tupletranslate.iteritems()])
62
 
 
63
 
    def __init__(self, filename):
64
 
        self.__covers = []
65
 
        audio = MP4(filename)
66
 
        self["~#length"] = int(audio.info.length)
67
 
        self["~#bitrate"] = int(audio.info.bitrate)
68
 
        for key, values in audio.items():
69
 
            if key in self.__tupletranslate:
70
 
                name = self.__tupletranslate[key]
71
 
                cur, total = values[0]
72
 
                if total:
73
 
                    self[name] = u"%d/%d" % (cur, total)
74
 
                else:
75
 
                    self[name] = unicode(cur)
76
 
            elif key in self.__translate:
77
 
                name = self.__translate[key]
78
 
                if key == "tmpo":
79
 
                    self[name] = "\n".join(map(unicode, values))
80
 
                elif key.startswith("----"):
81
 
                    self[name] = "\n".join(
82
 
                        map(lambda v: util.decode(v).strip("\x00"), values))
83
 
                else:
84
 
                    self[name] = "\n".join(values)
85
 
            elif key == "covr":
86
 
                self["~picture"] = "y"
87
 
        self.sanitize(filename)
88
 
 
89
 
    def write(self):
90
 
        audio = MP4(self["~filename"])
91
 
        for key in self.__rtranslate.keys() + self.__rtupletranslate.keys():
92
 
            try: del(audio[key])
93
 
            except KeyError: pass
94
 
 
95
 
        for key in self.realkeys():
96
 
            try: name = self.__rtranslate[key]
97
 
            except KeyError: continue
98
 
            values = self.list(key)
99
 
            if name == "tmpo":
100
 
                values = map(int, values)
101
 
            elif name.startswith("----"):
102
 
                values = map(lambda v: v.encode("utf-8"), values)
103
 
            audio[name] = values
104
 
        track, tracks = self("~#track"), self("~#tracks", 0)
105
 
        if track:
106
 
            audio["trkn"] = [(track, tracks)]
107
 
        disc, discs = self("~#disc"), self("~#discs", 0)
108
 
        if disc:
109
 
            audio["disk"] = [(disc, discs)]
110
 
        audio.save()
111
 
        self.sanitize()
112
 
 
113
 
    def can_change(self, key=None):
114
 
        OK = self.__rtranslate.keys() + self.__rtupletranslate.keys()
115
 
        if key is None: return OK
116
 
        else: return super(MP4File, self).can_change(key) and (key in OK)
117
 
 
118
 
    def get_format_cover(self):
119
 
        tag = MP4(self["~filename"])
120
 
        for cover in tag.get("covr", []):
121
 
            fn = tempfile.NamedTemporaryFile()
122
 
            fn.write(cover)
123
 
            fn.flush()
124
 
            fn.seek(0, 0)
125
 
            return fn
126
 
        else:
127
 
            return None
128
 
 
129
 
info = MP4File