« back to all changes in this revision
Viewing changes to idjcpython/IDJCmultitagger.py
- browse files at revision 1.1.3
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.3
- Committer: Bazaar Package Importer
- Author(s): Lionel Le Folgoc (mr_pouit)
- Date: 2007-01-15 01:49:58 UTC
- mto: (1.1.8 upstream) (5.1.1 sid)
- mto: This revision was merged to the branch mainline in revision 5.
- Revision ID: james.westby@ubuntu.com-20070115014958-j2g4ki53lnlnmnfp
Tags: upstream-0.6.9
Import upstream version 0.6.9
- files added:
- AUTHORS
- Man
- artwork
- c
- doc
- idjcpython
- files removed:
- idjc-0.6.8.tar.gz
added
removed
idjcpython/IDJCmultitagger.py
1
#!/usr/bin/python
2
3
# IDJCmultitagger.py: GTK based id3 and vorbis tagger for mp3/ogg/flac files.
4
# Copyright (C) 2006 Stephen Fairchild
5
#
6
# This program 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
# This program is distributed in the hope that it will be useful,
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
# GNU General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
20
import pygtk
21
pygtk.require('2.0')
22
import gtk, os, eyeD3, sys
23
from IDJCfree import *
24
from idjc_config import *
25
from langheader import *
26
27
class mp4tagger(gtk.VBox):
28
def load_tag(self, pathname):
29
self.idjc.mixer_write("MP4P=%s\nACTN=mp4readtagrequest\nend\n" % pathname, True)
30
data = ""
31
while 1:
32
line = self.idjc.mixer_read()
33
if line == "":
34
print "mixer crashed during mp4 tag read operation"
35
return
36
if line == "idjcmixer: mp4fileinfo Not Valid\n":
37
return
38
if line == "idjcmixer: mp4tagread end\n":
39
break
40
if line.startswith("idjcmixer: mp4tagread "):
41
data += line[22:]
42
kvplist = self.make_pairs(data)
43
recommended = [ u"artist", u"title", u"track", u"totaltracks", u"album", u"genre", u"date", u"comment" ]
44
precede = u""
45
for recommend in recommended:
46
for key, value in kvplist:
47
if key == recommend:
48
break
49
else:
50
precede = precede + recommend + u"=\n"
51
self.textbuffer.set_text(precede + data)
52
53
def save_tag(self, pathname):
54
kvp = self.make_pairs()
55
text = u""
56
self.idjc.mixer_write("MP4T=\n")
57
for key, value in kvp:
58
self.idjc.mixer_write("+MP4T=" + key + "=" + value + "\n")
59
self.idjc.mixer_write("MP4P=" + pathname + "\n")
60
self.idjc.mixer_write("ACTN=mp4writetagrequest\nend\n", True)
61
print "mp4 tag saved"
62
63
def make_pairs(self, data = None): # Returns a list of tuples of key value pairs
64
kvp = [ ] # Any keys containing a space are rejected
65
if data == None:
66
textiter = self.textbuffer.get_start_iter()
67
data = textiter.get_text(self.textbuffer.get_end_iter())
68
data = data.splitlines()
69
for line in data:
70
if line.count("="):
71
key, value = line.split("=", 1)
72
key = key.strip()
73
value = value.strip()
74
if key != "" and value != "" and key.count(" ") == 0:
75
kvp.append((key.strip(), value.strip()))
76
return kvp
77
78
def __init__(self, pathname, idjcroot):
79
self.idjc = idjcroot
80
gtk.VBox.__init__(self)
81
scrolled_window = gtk.ScrolledWindow()
82
scrolled_window.set_size_request(350, 250)
83
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
84
textview = gtk.TextView()
85
self.textbuffer = textview.get_buffer()
86
scrolled_window.add(textview)
87
textview.show()
88
gtk.VBox.add(self, scrolled_window)
89
scrolled_window.show()
90
textview.set_editable(True)
91
textview.set_cursor_visible(True)
92
textview.set_wrap_mode(gtk.WRAP_NONE)
93
textview.set_justification(gtk.JUSTIFY_LEFT)
94
95
class vorbistagger(gtk.VBox):
96
def load_ogg_tag(self, pathname):
97
self.vc = os.getenv("vorbiscomment")
98
if self.vc == "" or self.vc == None:
99
self.vc = "vorbiscomment" # For standalone version
100
if self.vc != "missing":
101
try:
102
(write, read) = os.popen2([ self.vc, "--raw", pathname ])
103
write.close()
104
data = read.read()
105
read.close()
106
except:
107
print "Problem reading in file", pathname
108
else:
109
self.load_tag(data)
110
111
def load_flac_tag(self, pathname):
112
self.mf = os.getenv("metaflac")
113
if self.mf == "" or self.mf == None:
114
self.mf = "metaflac" # For standalone version
115
if self.mf != "missing":
116
try:
117
(write, read) = os.popen2([ self.mf, "--no-utf8-convert", "--export-tags-to=-" , pathname ])
118
write.close()
119
data = read.read()
120
read.close()
121
except:
122
print "Problem reading in file", pathname
123
else:
124
self.load_tag(data)
125
126
def load_tag(self, data):
127
# Have some fun here by adding empty keys that are recommended like ALBUM=
128
# whenever none is present in the tag. It saves the user from having to type them.
129
kvplist = self.make_pairs(data)
130
recommended = [ u"ARTIST", u"TITLE", u"TRACKNUMBER", u"ALBUM", u"GENRE", u"DATE" ]
131
precede = u""
132
for recommend in recommended:
133
for key, value in kvplist:
134
if key == recommend:
135
break
136
else:
137
precede = precede + recommend + u"=\n"
138
self.textbuffer.set_text(precede + data)
139
140
def save_ogg_tag(self, pathname):
141
if self.vc != "missing":
142
kvp = self.make_pairs()
143
text = u""
144
for key, value in kvp:
145
text = text + key + "=" + value + "\n"
146
write, read = os.popen2([self.vc, "--raw", "-w", pathname])
147
try:
148
write.write(text)
149
write.close()
150
read.read()
151
read.close()
152
except BrokenPipe:
153
pass
154
print "Ogg tag saved"
155
156
def save_flac_tag(self, pathname):
157
if self.mf != "missing":
158
kvp = self.make_pairs()
159
text = u""
160
for key, value in kvp:
161
text = text + key + "=" + value + "\n"
162
write, read = os.popen2(["metaflac", "--no-utf8-convert", "--remove-all-tags", "--import-tags-from=-", pathname])
163
try:
164
write.write(text)
165
write.close()
166
read.read()
167
read.close()
168
except BrokenPipe:
169
pass
170
print "Flac tag saved"
171
172
def make_pairs(self, data = None): # Returns a list of tuples of key value pairs
173
kvp = [ ] # Any keys containing a space are rejected
174
if data == None:
175
textiter = self.textbuffer.get_start_iter()
176
data = textiter.get_text(self.textbuffer.get_end_iter())
177
data = data.splitlines()
178
for line in data:
179
if line.count("="):
180
key, value = line.split("=", 1)
181
key = key.strip()
182
value = value.strip()
183
if key != "" and value != "" and key.count(" ") == 0:
184
kvp.append((key.strip(), value.strip()))
185
return kvp
186
187
def __init__(self, pathname):
188
gtk.VBox.__init__(self)
189
scrolled_window = gtk.ScrolledWindow()
190
scrolled_window.set_size_request(350, 250)
191
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
192
textview = gtk.TextView()
193
self.textbuffer = textview.get_buffer()
194
scrolled_window.add(textview)
195
textview.show()
196
gtk.VBox.add(self, scrolled_window)
197
scrolled_window.show()
198
textview.set_editable(True)
199
textview.set_cursor_visible(True)
200
textview.set_wrap_mode(gtk.WRAP_NONE)
201
textview.set_justification(gtk.JUSTIFY_LEFT)
202
203
class id3tagger(gtk.VBox):
204
def textfilter(self, text):
205
if text == None:
206
text = ""
207
while text != "" and text[-1] == "\x00":
208
text = text[:-1]
209
return unicode(text.strip())
210
211
def cb_genre(self, combo, textbox):
212
if combo.get_active() != 255:
213
newtext = eyeD3.genres[combo.get_active()]
214
textbox.set_text(newtext)
215
if newtext == "Unknown":
216
combo.set_active(255)
217
218
def cb_genre_unpress(self, textbox, event, combo):
219
lt = textbox.get_text().lstrip()
220
textbox.set_text(lt)
221
lt = lt.lower().strip()
222
cursor_pos = textbox.get_position()
223
if lt == "unknown":
224
combo.set_active(255)
225
else:
226
value = 0
227
for each in eyeD3.genres:
228
if each.lower() == lt:
229
combo.set_active(value)
230
break
231
value = value + 1
232
else:
233
combo.set_active(255)
234
textbox.set_position(cursor_pos)
235
return False
236
237
def load_tag(self, pathname, extension):
238
self.tag = eyeD3.Tag()
239
exception = False
240
if True or extension == "mp3":
241
try:
242
self.tagv2found = self.tag.link(pathname, eyeD3.ID3_V2)
243
except:
244
self.tagv2found = 0
245
else:
246
self.tagv2found = 0
247
if self.tagv2found == 0:
248
try:
249
self.tagv1found = self.tag.link(pathname, eyeD3.ID3_V1)
250
except eyeD3.tag.TagException:
251
self.tagv2found = 1
252
self.tag.link(pathname, eyeD3.ID3_V2) # Use a blank v2 tag as the basis
253
# Now we can load up the fields from what is in the tag.
254
self.title.set_text(self.textfilter(self.tag.getTitle()))
255
self.artist.set_text(self.textfilter(self.tag.getArtist()))
256
self.album.set_text(self.textfilter(self.tag.getAlbum()))
257
self.year.set_text(self.textfilter(self.tag.getYear()))
258
genre = self.tag.getGenre()
259
if genre == None or genre.id == None or genre.id == 255:
260
genre_value = 255
261
self.genre_text.set_text("Unknown")
262
else:
263
genre_value = genre.id
264
self.std_genre.set_active(genre_value)
265
track = self.tag.getTrackNum()
266
if type(track[0]) is int:
267
tracktext = str(track[0])
268
if type(track[1]) is int and track[1] > 0:
269
tracktext = tracktext + "/" + str(track[1])
270
self.track.set_text(tracktext)
271
comments = self.tag.getComments()
272
if len(comments):
273
for self.ourcomment in comments: # Show the idjc comment in preference to the others
274
if self.ourcomment.description == self.idjc_comment_desc:
275
break
276
else:
277
self.ourcomment = comments[0]
278
self.comment.set_text(self.textfilter(self.ourcomment.comment))
279
else:
280
self.ourcomment = None
281
282
def save_tag(self, pathname):
283
self.tag.setVersion(eyeD3.ID3_V2_4)
284
self.tag.setTextEncoding(eyeD3.UTF_8_ENCODING)
285
self.tag.setArtist(self.textfilter(self.artist.get_text()))
286
self.tag.setTitle(self.textfilter(self.title.get_text()))
287
self.tag.setAlbum(self.textfilter(self.album.get_text()))
288
trackstring = self.track.get_text().split("/")
289
if len(trackstring) >= 1 and len(trackstring) <= 2:
290
try:
291
tracknum = int(trackstring[0].strip())
292
if tracknum < 0:
293
raise ValueError
294
if len(trackstring) == 2:
295
tracktotal = int(trackstring[1].strip())
296
if tracktotal < 0:
297
raise ValueError
298
else:
299
tracktotal = None
300
except ValueError:
301
print "Bad entry for track"
302
self.tag.setTrackNum([ None, None ])
303
else:
304
self.tag.setTrackNum([ tracknum, tracktotal])
305
self.tag.frames.removeFramesByID("TYER")
306
try:
307
datevalue = int(self.textfilter(self.year.get_text()))
308
if datevalue >= 1000 and datevalue <= 9999:
309
self.tag.setDate(int(self.textfilter(self.year.get_text())))
310
else:
311
raise ValueError
312
except ValueError:
313
print "Year field will be left blank"
314
self.tag.setGenre(self.std_genre.get_active())
315
self.tag.addComment(self.textfilter(self.comment.get_text()), self.idjc_comment_desc, self.idjc_comment_lang)
316
try:
317
self.tag.update(eyeD3.ID3_V1_1)
318
except UnicodeEncodeError:
319
print "ID3 v1.1 tag was not written because of an illegal character in one of the fields (not a member of the ISO-8859-1 character set)"
320
else:
321
print "Wrote ID3 v1.1 tag."
322
if True or os.path.splitext(pathname)[1] == ".mp3":
323
self.tag.update(eyeD3.ID3_V2_4)
324
print "Wrote ID3 v2.4 tag."
325
else:
326
print "ID3 v2.4 tag not written for non-mp3 files."
327
328
def __init__(self, pathname):
329
gtk.VBox.__init__(self)
330
self.idjc_comment_desc = "idjc-comment"
331
self.idjc_comment_lang = "XXX"
332
333
frame = gtk.Frame(" " + standard_tags_text + " ")
334
frame.set_border_width(6)
335
gtk.VBox.pack_start(self, frame, False, False, 0)
336
sthbox = gtk.HBox()
337
sthbox.set_spacing(2)
338
sthbox.set_border_width(8)
339
frame.add(sthbox)
340
frame.show()
341
sthbox.show()
342
stlvbox = gtk.VBox()
343
sthbox.pack_start(stlvbox, False, False, 1)
344
stlvbox.show()
345
strvbox = gtk.VBox()
346
sthbox.pack_start(strvbox, True, True, 1)
347
strvbox.show()
348
349
title = gtk.Label(tag_title_text)
350
stlvbox.add(title)
351
title.show()
352
353
self.title = gtk.Entry()
354
self.title.set_width_chars(30)
355
strvbox.add(self.title)
356
self.title.show()
357
358
artist = gtk.Label(tag_artist_text)
359
stlvbox.add(artist)
360
artist.show()
361
362
self.artist = gtk.Entry()
363
strvbox.add(self.artist)
364
self.artist.show()
365
366
album = gtk.Label(tag_album_text)
367
stlvbox.add(album)
368
album.show()
369
370
self.album = gtk.Entry()
371
strvbox.add(self.album)
372
self.album.show()
373
374
track = gtk.Label(tag_track_text)
375
stlvbox.add(track)
376
track.show()
377
378
self.track = gtk.Entry()
379
strvbox.add(self.track)
380
self.track.show()
381
382
year = gtk.Label(tag_year_text)
383
stlvbox.add(year)
384
year.show()
385
386
self.year = gtk.Entry()
387
strvbox.add(self.year)
388
self.year.show()
389
390
genre = gtk.Label(tag_genre_text)
391
stlvbox.add(genre)
392
genre.show()
393
394
genre_box = gtk.HBox()
395
self.genre_text = gtk.Entry()
396
genre_box.pack_start(self.genre_text, True, True, 0)
397
self.genre_text.show()
398
self.genre_text.set_text("Unknown")
399
self.std_genre = gtk.combo_box_new_text()
400
self.std_genre.set_wrap_width(5)
401
value = 0
402
for each in eyeD3.genres:
403
self.std_genre.append_text(each + " (" + str(value) + ")")
404
value = value + 1
405
self.std_genre.connect("changed", self.cb_genre, self.genre_text)
406
self.genre_text.connect("key_release_event", self.cb_genre_unpress, self.std_genre)
407
self.std_genre.set_active(255)
408
genre_box.pack_end(self.std_genre, False, False, 0)
409
self.std_genre.show()
410
strvbox.add(genre_box)
411
genre_box.show()
412
413
comment = gtk.Label(tag_comment_text)
414
stlvbox.add(comment)
415
comment.show()
416
417
self.comment = gtk.Entry()
418
strvbox.add(self.comment)
419
self.comment.show()
420
421
422
class multitag:
423
def destroy_and_quit(self, widget, data = None):
424
gtk.main_quit()
425
sys.exit(0)
426
427
def update_playlists(self, pathname, idjcroot):
428
newplaylistdata = idjcroot.player_left.get_media_metadata(pathname)
429
idjcroot.player_left.update_playlist(newplaylistdata)
430
idjcroot.player_right.update_playlist(newplaylistdata)
431
432
def is_supported(self, pathname):
433
supported = [ "mp3", "ogg", "flac" ]
434
try:
435
if mp4enabled:
436
supported.append("mp4")
437
supported.append("m4a")
438
except:
439
pass
440
extension = os.path.splitext(pathname)[1][1:].lower()
441
if supported.count(extension) != 1:
442
print "File type", extension, "is not supported."
443
return False
444
else:
445
return extension
446
447
def __init__(self, pathname = None, encoding = "latin1", idjcroot = None):
448
if pathname == None:
449
return
450
extension = self.is_supported(pathname)
451
if extension == False:
452
return
453
454
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
455
if idjcroot is not None:
456
idjcroot.window_group.add_window(self.window)
457
self.window.set_title(tagger_window_title_text)
458
self.window.set_destroy_with_parent(True)
459
self.window.set_border_width(9)
460
self.window.set_resizable(True)
461
self.window.set_icon_from_file(pkgdatadir + "icon" + gfext)
462
if idjcroot == None:
463
self.window.connect("destroy", self.destroy_and_quit)
464
vbox = gtk.VBox()
465
self.window.add(vbox)
466
vbox.show()
467
label = gtk.Label()
468
if idjcroot:
469
label.set_markup(u"<b>" + tagger_filename_text + u" " + rich_safe(unicode(os.path.split(pathname)[1], encoding).encode("utf-8", "replace")) + u"</b>")
470
else:
471
label.set_markup(u"<b>" + tagger_filename_text + u" " + rich_safe(unicode(os.path.split(pathname)[1], "latin1").encode("utf-8", "replace")) + u"</b>")
472
vbox.pack_start(label, False, False, 6)
473
label.show()
474
475
hbox = gtk.HBox()
476
hbox.set_border_width(2)
477
apply_button = gtk.Button(None, gtk.STOCK_APPLY)
478
if idjcroot is not None:
479
apply_button.connect_object_after("clicked", self.update_playlists, pathname, idjcroot)
480
hbox.pack_end(apply_button, False, False, 0)
481
apply_button.show()
482
close_button = gtk.Button(None, gtk.STOCK_CLOSE)
483
close_button.connect_object("clicked", gtk.Window.destroy, self.window)
484
hbox.pack_end(close_button, False, False, 10)
485
close_button.show()
486
reload_button = gtk.Button(None, gtk.STOCK_REVERT_TO_SAVED)
487
hbox.pack_start(reload_button, False, False, 10)
488
reload_button.show()
489
vbox.pack_end(hbox, False, False, 0)
490
hbox.show()
491
hbox = gtk.HBox()
492
vbox.pack_end(hbox, False, False, 2)
493
hbox.show()
494
495
notebook = gtk.Notebook()
496
notebook.set_border_width(2)
497
vbox.pack_start(notebook, True, True, 0)
498
notebook.show()
499
if (extension == "mp4" or extension == "m4a") and idjcroot != None and mp4enabled:
500
self.mp4 = mp4tagger(pathname, idjcroot)
501
reload_button.connect_object("clicked", self.mp4.load_tag, pathname)
502
apply_button.connect_object("clicked", self.mp4.save_tag, pathname)
503
reload_button.clicked()
504
label = gtk.Label("MP4 Tag")
505
notebook.append_page(self.mp4, label)
506
label.show()
507
self.mp4.show()
508
elif extension == "mp3":
509
self.id3 = id3tagger(pathname)
510
reload_button.connect_object("clicked", self.id3.load_tag, pathname, extension)
511
apply_button.connect_object("clicked", self.id3.save_tag, pathname)
512
reload_button.clicked()
513
self.vorbis = None
514
label = gtk.Label("ID3 Tag")
515
notebook.append_page(self.id3, label)
516
self.id3.show()
517
label.show()
518
else:
519
self.vorbis = vorbistagger(pathname)
520
if extension == "ogg":
521
reload_button.connect_object("clicked", self.vorbis.load_ogg_tag, pathname)
522
apply_button.connect_object("clicked", self.vorbis.save_ogg_tag, pathname)
523
elif extension == "flac":
524
reload_button.connect_object("clicked", self.vorbis.load_flac_tag, pathname)
525
apply_button.connect_object("clicked", self.vorbis.save_flac_tag, pathname)
526
reload_button.clicked()
527
label = gtk.Label(vorbis_tag_text)
528
notebook.append_page(self.vorbis, label)
529
self.vorbis.show()
530
label.show()
531
self.id3 = id3tagger(pathname)
532
self.id3.load_tag(pathname, extension)
533
if (self.id3.tagv2found == 0 and self.id3.tagv1found == 0) or extension == "ogg":
534
self.id3.destroy()
535
self.id3 = None
536
else:
537
reload_button.connect_object("clicked", self.id3.load_tag, pathname, extension)
538
apply_button.connect_object("clicked", self.id3.save_tag, pathname)
539
label = gtk.Label(id3_tag_text)
540
notebook.append_page(self.id3, label)
541
self.id3.show()
542
label.show()
543
apply_button.connect_object_after("clicked", gtk.Window.destroy, self.window)
544
self.window.show()
545
546
if __name__ == "__main__":
547
os.environ["CHARSET"]="UTF-8"
548
if len(sys.argv) != 2 or os.path.isfile(sys.argv[1]) == False:
549
print "The media tagger from IDJC. Copyright Stephen Fairchild 2006\nReleased under the GNU General Public License V2.0\nUsage:", sys.argv[0], "filename"
550
else:
551
multitag(sys.argv[1])
552
gtk.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1