c2042b3dec863ec6095eb06be4fdd372eb6d4d0a
[vlc.git] / modules / meta_engine / taglib.cpp
1 /*****************************************************************************
2  * taglib.cpp: Taglib tag parser/writer
3  *****************************************************************************
4  * Copyright (C) 2003-2008 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Clément Stenac <zorglub@videolan.org>
8  *          Rafaël Carré <funman@videolanorg>
9  *          Rémi Duraffort <ivoire@videolan.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <vlc_common.h>
31 #include <vlc_plugin.h>
32 #include <vlc_playlist.h>
33 #include <vlc_meta.h>
34 #include <vlc_demux.h>
35 #include <vlc_strings.h>
36 #include <vlc_charset.h>
37
38 #ifdef WIN32
39 # include <io.h>
40 #else
41 # include <unistd.h>
42 #endif
43
44
45 // Taglib headers
46 #include <fileref.h>
47 #include <tag.h>
48 #include <tbytevector.h>
49
50 #include <apetag.h>
51 #include <id3v2tag.h>
52 #include <xiphcomment.h>
53
54 #include <flacfile.h>
55 #include <mpcfile.h>
56 #include <mpegfile.h>
57 #include <oggfile.h>
58 #include <oggflacfile.h>
59 #include <speexfile.h>
60 #include <trueaudiofile.h>
61 #include <vorbisfile.h>
62 #include <wavpackfile.h>
63
64 #include <attachedpictureframe.h>
65 #include <textidentificationframe.h>
66 #include <uniquefileidentifierframe.h>
67
68
69 // Local functions
70 static int ReadMeta    ( vlc_object_t * );
71 static int DownloadArt ( vlc_object_t * );
72 static int WriteMeta   ( vlc_object_t * );
73
74 vlc_module_begin ()
75     set_capability( "meta reader", 1000 )
76     set_callbacks( ReadMeta, NULL )
77     add_submodule ()
78         set_capability( "art downloader", 50 )
79         set_callbacks( DownloadArt, NULL )
80     add_submodule ()
81         set_capability( "meta writer", 50 )
82         set_callbacks( WriteMeta, NULL )
83 vlc_module_end ()
84
85 using namespace TagLib;
86
87
88 /**
89  * Read meta informations from APE tags
90  * @param tag: the APE tag
91  * @param p_demux; the demux object
92  * @param p_demux_meta: the demuxer meta
93  * @param p_meta: the meta
94  */
95 static void ReadMetaFromAPE( APE::Tag* tag, demux_t* p_demux, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
96 {
97     APE::Item item;
98 #define SET( keyName, metaName ) \
99     item = tag->itemListMap()[keyName]; \
100     vlc_meta_Set##metaName( p_meta, item.toString().toCString( true ) );\
101
102     SET( "COPYRIGHT", Copyright );
103     SET( "LANGUAGE", Language );
104     SET( "PUBLISHER", Publisher );
105
106 #undef SET
107 }
108
109
110
111 /**
112  * Read meta information from id3v2 tags
113  * @param tag: the id3v2 tag
114  * @param p_demux; the demux object
115  * @param p_demux_meta: the demuxer meta
116  * @param p_meta: the meta
117  */
118 static void ReadMetaFromId3v2( ID3v2::Tag* tag, demux_t* p_demux, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
119 {
120     // Get the unique file identifier
121     ID3v2::FrameList list = tag->frameListMap()["UFID"];
122     ID3v2::FrameList::Iterator iter;
123     for( iter = list.begin(); iter != list.end(); iter++ )
124     {
125         ID3v2::UniqueFileIdentifierFrame* p_ufid =
126                 dynamic_cast<ID3v2::UniqueFileIdentifierFrame*>(*iter);
127         const char *owner = p_ufid->owner().toCString();
128         if (!strcmp( owner, "http://musicbrainz.org" ))
129         {
130             /* ID3v2 UFID contains up to 64 bytes binary data
131              * but in our case it will be a '\0'
132              * terminated string */
133             char psz_ufid[64];
134             int max_size = __MIN( p_ufid->identifier().size(), 63);
135             strncpy( psz_ufid, p_ufid->identifier().data(), max_size );
136             psz_ufid[max_size] = '\0';
137             vlc_meta_SetTrackID( p_meta, psz_ufid );
138         }
139     }
140
141     // Get the use text
142     list = tag->frameListMap()["TXXX"];
143     for( iter = list.begin(); iter != list.end(); iter++ )
144     {
145         ID3v2::UserTextIdentificationFrame* p_txxx =
146                 dynamic_cast<ID3v2::UserTextIdentificationFrame*>(*iter);
147         vlc_meta_AddExtra( p_meta, p_txxx->description().toCString( true ),
148                            p_txxx->fieldList().toString().toCString( true ) );
149     }
150
151     // Get some more informations
152 #define SET( tagName, metaName )                                               \
153     list = tag->frameListMap()[tagName];                                       \
154     if( !list.isEmpty() )                                                      \
155         vlc_meta_Set##metaName( p_meta,                                        \
156                                 (*list.begin())->toString().toCString( true ) );
157
158     SET( "TCOP", Copyright );
159     SET( "TENC", EncodedBy );
160     SET( "TLAN", Language );
161     SET( "TPUB", Publisher );
162
163 #undef SET
164
165     /* Preferred type of image
166      * The 21 types are defined in id3v2 standard:
167      * http://www.id3.org/id3v2.4.0-frames */
168     static const int pi_cover_score[] = {
169         0,  /* Other */
170         5,  /* 32x32 PNG image that should be used as the file icon */
171         4,  /* File icon of a different size or format. */
172         20, /* Front cover image of the album. */
173         19, /* Back cover image of the album. */
174         13, /* Inside leaflet page of the album. */
175         18, /* Image from the album itself. */
176         17, /* Picture of the lead artist or soloist. */
177         16, /* Picture of the artist or performer. */
178         14, /* Picture of the conductor. */
179         15, /* Picture of the band or orchestra. */
180         9,  /* Picture of the composer. */
181         8,  /* Picture of the lyricist or text writer. */
182         7,  /* Picture of the recording location or studio. */
183         10, /* Picture of the artists during recording. */
184         11, /* Picture of the artists during performance. */
185         6,  /* Picture from a movie or video related to the track. */
186         1,  /* Picture of a large, coloured fish. */
187         12, /* Illustration related to the track. */
188         3,  /* Logo of the band or performer. */
189         2   /* Logo of the publisher (record company). */
190     };
191     int i_score = -1;
192
193     // Try now to get embedded art
194     list = tag->frameListMap()[ "APIC" ];
195     if( list.isEmpty() )
196         return;
197
198     TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
199     for( ID3v2::FrameList::Iterator iter = list.begin();
200          iter != list.end(); iter++ )
201     {
202         ID3v2::AttachedPictureFrame* p_apic =
203             dynamic_cast<ID3v2::AttachedPictureFrame*>(*iter);
204         input_attachment_t *p_attachment;
205
206         const char *psz_mime;
207         const char *p_data; int i_data;
208         char *psz_name, *psz_description;
209
210         // Get the mime and description of the image.
211         // If the description is empty, take the type as a description
212         psz_mime = p_apic->mimeType().toCString( true );
213         if( p_apic->description().size() > 0 )
214             psz_description = strdup( p_apic->description().toCString( true ) );
215         else
216         {
217             if( asprintf( &psz_description, "%i", p_apic->type() ) == -1 )
218                 psz_description = NULL;
219         }
220
221         if( !psz_description )
222             continue;
223         psz_name = psz_description;
224
225         /* some old iTunes version not only sets incorrectly the mime type
226          * or the description of the image,
227          * but also embeds incorrectly the image.
228          * Recent versions seem to behave correctly */
229         if( !strncmp( psz_mime, "PNG", 3 ) ||
230             !strncmp( psz_name, "\xC2\x89PNG", 5 ) )
231         {
232             msg_Warn( p_demux, "Invalid picture embedded by broken iTunes version" );
233             free( psz_description );
234             continue;
235         }
236
237         p_data = p_apic->picture().data();
238         i_data = p_apic->picture().size();
239
240         msg_Dbg( p_demux, "Found embedded art: %s (%s) is %i bytes",
241                  psz_name, psz_mime, i_data );
242
243         p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
244                                 psz_description, p_data, i_data );
245         TAB_APPEND_CAST( (input_attachment_t**),
246                          p_demux_meta->i_attachments, p_demux_meta->attachments,
247                          p_attachment );
248         free( psz_description );
249
250         if( pi_cover_score[p_apic->type()] > i_score )
251         {
252             i_score = pi_cover_score[p_apic->type()];
253             char *psz_url;
254             if( asprintf( &psz_url, "attachment://%s",
255                           p_attachment->psz_name ) == -1 )
256                 continue;
257             vlc_meta_SetArtURL( p_meta, psz_url );
258             free( psz_url );
259         }
260     }
261 }
262
263
264
265 /**
266  * Read the meta informations from XiphComments
267  * @param tag: the Xiph Comment
268  * @param p_demux; the demux object
269  * @param p_demux_meta: the demuxer meta
270  * @param p_meta: the meta
271  */
272 static void ReadMetaFromXiph( Ogg::XiphComment* tag, demux_t* p_demux, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
273 {
274 #define SET( keyName, metaName )                                               \
275     StringList list = tag->fieldListMap()[keyName];                            \
276     if( !list.isEmpty() )                                                      \
277         vlc_meta_Set##metaName( p_meta, (*list.begin()).toCString( true ) );
278
279     SET( "COPYRIGHT", Copyright );
280 #undef SET
281
282     // Try now to get embedded art
283     StringList mime_list = tag->fieldListMap()[ "COVERARTMIME" ];
284     StringList art_list = tag->fieldListMap()[ "COVERART" ];
285
286     // We get only the first covert art
287     if( mime_list.size() > 1 || art_list.size() > 1 )
288         msg_Warn( p_demux, "Found %i embedded arts, so using only the first one",
289                   art_list.size() );
290     else if( mime_list.size() == 0 || art_list.size() == 0 )
291         return;
292
293     input_attachment_t *p_attachment;
294
295     const char* psz_name = "cover";
296     const char* psz_mime = mime_list[0].toCString(true);
297     const char* psz_description = "cover";
298
299     uint8_t *p_data;
300     int i_data = vlc_b64_decode_binary( &p_data, art_list[0].toCString(true) );
301
302     msg_Dbg( p_demux, "Found embedded art: %s (%s) is %i bytes",
303              psz_name, psz_mime, i_data );
304
305     TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
306               p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
307               psz_description, p_data, i_data );
308     free( p_data );
309
310     TAB_APPEND_CAST( (input_attachment_t**),
311                      p_demux_meta->i_attachments, p_demux_meta->attachments,
312                      p_attachment );
313
314     vlc_meta_SetArtURL( p_meta, "attachment://cover" );
315 }
316
317
318
319 /**
320  * Get the tags from the file using TagLib
321  * @param p_this: the demux object
322  * @return VLC_SUCCESS if the operation success
323  */
324 static int ReadMeta( vlc_object_t* p_this)
325 {
326     demux_t*        p_demux = (demux_t*)p_this;
327     demux_meta_t*   p_demux_meta = (demux_meta_t*)p_demux->p_private;
328     vlc_meta_t*     p_meta;
329     TagLib::FileRef f;
330
331     p_demux_meta->p_meta = NULL;
332     const char* local_name = ToLocale( p_demux->psz_path );
333     if( !local_name )
334         return VLC_EGENERIC;
335     f = FileRef( local_name );
336     LocaleFree( local_name );
337
338     if( f.isNull() )
339         return VLC_EGENERIC;
340     if( !f.tag() || f.tag()->isEmpty() )
341         return VLC_EGENERIC;
342
343     p_demux_meta->p_meta = p_meta = vlc_meta_New();
344     if( !p_meta )
345         return VLC_ENOMEM;
346
347
348     // Read the tags from the file
349     Tag* p_tag = f.tag();
350
351 #define SET( tag, meta )                                                       \
352     if( !p_tag->tag().isNull() && !p_tag->tag().isEmpty() )                    \
353         vlc_meta_Set##meta( p_meta, p_tag->tag().toCString(true) )
354 #define SETINT( tag, meta )                                                    \
355     if( p_tag->tag() )                                                         \
356     {                                                                          \
357         char psz_tmp[10];                                                      \
358         snprintf( psz_tmp, 10, "%d", p_tag->tag() );                           \
359         vlc_meta_Set##meta( p_meta, psz_tmp );                                 \
360     }
361
362     SET( title, Title );
363     SET( artist, Artist );
364     SET( album, Album );
365     SET( comment, Description );
366     SET( genre, Genre );
367     SETINT( year, Date );
368     SETINT( track, Tracknum );
369
370 #undef SETINT
371 #undef SET
372
373
374     // Try now to read special tags
375     if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
376     {
377         if( flac->ID3v2Tag() )
378             ReadMetaFromId3v2( flac->ID3v2Tag(), p_demux, p_demux_meta, p_meta );
379         else if( flac->xiphComment() )
380             ReadMetaFromXiph( flac->xiphComment(), p_demux, p_demux_meta, p_meta );
381     }
382     else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
383     {
384         if( mpc->APETag() )
385             ReadMetaFromAPE( mpc->APETag(), p_demux, p_demux_meta, p_meta );
386     }
387     else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
388     {
389         if( mpeg->ID3v2Tag() )
390             ReadMetaFromId3v2( mpeg->ID3v2Tag(), p_demux, p_demux_meta, p_meta );
391         else if( mpeg->APETag() )
392             ReadMetaFromAPE( mpeg->APETag(), p_demux, p_demux_meta, p_meta );
393     }
394     else if( Ogg::File* ogg = dynamic_cast<Ogg::File*>(f.file()) )
395     {
396         if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
397             ReadMetaFromXiph( ogg_flac->tag(), p_demux, p_demux_meta, p_meta );
398         else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
399             ReadMetaFromXiph( ogg_speex->tag(), p_demux, p_demux_meta, p_meta );
400         else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
401             ReadMetaFromXiph( ogg_vorbis->tag(), p_demux, p_demux_meta, p_meta );
402     }
403     else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
404     {
405         if( trueaudio->ID3v2Tag() )
406             ReadMetaFromId3v2( trueaudio->ID3v2Tag(), p_demux, p_demux_meta, p_meta );
407     }
408     else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
409     {
410         if( wavpack->APETag() )
411             ReadMetaFromAPE( wavpack->APETag(), p_demux, p_demux_meta, p_meta );
412     }
413
414     return VLC_SUCCESS;
415 }
416
417
418
419 /**
420  * Write meta informations to APE tags
421  * @param tag: the APE tag
422  * @param p_item: the input item
423  */
424 static void WriteMetaToAPE( APE::Tag* tag, input_item_t* p_item )
425 {
426     char* psz_meta;
427 #define WRITE( metaName, keyName )                      \
428     psz_meta = input_item_Get##metaName( p_item );      \
429     if( psz_meta )                                      \
430     {                                                   \
431         String key( keyName, String::UTF8 );            \
432         String value( psz_meta, String::UTF8 );         \
433         tag->addValue( key, value, true );              \
434     }                                                   \
435     free( psz_meta );
436
437     WRITE( Copyright, "COPYRIGHT" );
438     WRITE( Language, "LANGUAGE" );
439     WRITE( Publisher, "PUBLISHER" );
440
441 #undef WRITE
442 }
443
444
445
446 /**
447  * Write meta information to id3v2 tags
448  * @param tag: the id3v2 tag
449  * @param p_input: the input item
450  */
451 static void WriteMetaToId3v2( ID3v2::Tag* tag, input_item_t* p_item )
452 {
453     char* psz_meta;
454 #define WRITE( metaName, tagName )                                            \
455     psz_meta = input_item_Get##metaName( p_item );                            \
456     if( psz_meta )                                                            \
457     {                                                                         \
458         ByteVector p_byte( tagName, 4 );                                      \
459         tag->removeFrames( p_byte );                                         \
460         ID3v2::TextIdentificationFrame* p_frame =                             \
461             new ID3v2::TextIdentificationFrame( p_byte, String::UTF8 );       \
462         p_frame->setText( psz_meta );                                         \
463         tag->addFrame( p_frame );                                             \
464     }                                                                         \
465     free( psz_meta );
466
467     WRITE( Copyright, "TCOP" );
468     WRITE( EncodedBy, "TENC" );
469     WRITE( Language,  "TLAN" );
470     WRITE( Publisher, "TPUB" );
471
472 #undef WRITE
473 }
474
475
476
477 /**
478  * Write the meta informations to XiphComments
479  * @param tag: the Xiph Comment
480  * @param p_input: the input item
481  */
482 static void WriteMetaToXiph( Ogg::XiphComment* tag, input_item_t* p_item )
483 {
484     char* psz_meta;
485 #define WRITE( metaName, keyName )                      \
486     psz_meta = input_item_Get##metaName( p_item );      \
487     if( psz_meta )                                      \
488     {                                                   \
489         String key( keyName, String::UTF8 );            \
490         String value( psz_meta, String::UTF8 );         \
491         tag->addField( key, value, true );              \
492     }                                                   \
493     free( psz_meta );
494
495     WRITE( Copyright, "COPYRIGHT" );
496
497 #undef WRITE
498 }
499
500
501
502 /**
503  * Set the tags to the file using TagLib
504  * @param p_this: the demux object
505  * @return VLC_SUCCESS if the operation success
506  */
507
508 static int WriteMeta( vlc_object_t *p_this )
509 {
510     playlist_t *p_playlist = (playlist_t *)p_this;
511     meta_export_t *p_export = (meta_export_t *)p_playlist->p_private;
512     input_item_t *p_item = p_export->p_item;
513
514     if( !p_item )
515     {
516         msg_Err( p_this, "Can't save meta data of an empty input" );
517         return VLC_EGENERIC;
518     }
519
520     FileRef f( p_export->psz_file );
521     if( f.isNull() || !f.tag() || f.file()->readOnly() )
522     {
523         msg_Err( p_this, "File %s can't be opened for tag writing\n",
524             p_export->psz_file );
525         return VLC_EGENERIC;
526     }
527
528     msg_Dbg( p_this, "Writing metadata for %s", p_export->psz_file );
529
530     Tag *p_tag = f.tag();
531
532     char *psz_meta;
533
534 #define SET( a, b )                                         \
535     if( b )                                                 \
536     {                                                       \
537         String* psz_tmp = new String( b, String::UTF8 );    \
538         p_tag->set##a( *psz_tmp );                          \
539         delete psz_tmp;                                     \
540     }
541
542     // Saving all common fields
543     // If the title is empty, use the name
544     psz_meta = input_item_GetTitle( p_item );
545     if( !psz_meta ) psz_meta = input_item_GetName( p_item );
546     SET( Title, psz_meta );
547     free( psz_meta );
548
549     psz_meta = input_item_GetArtist( p_item );
550     SET( Artist, psz_meta );
551     free( psz_meta );
552
553     psz_meta = input_item_GetAlbum( p_item );
554     SET( Album, psz_meta );
555     free( psz_meta );
556
557     psz_meta = input_item_GetDescription( p_item );
558     SET( Comment, psz_meta );
559     free( psz_meta );
560
561     psz_meta = input_item_GetGenre( p_item );
562     SET( Genre, psz_meta );
563     free( psz_meta );
564
565 #undef SET
566
567     psz_meta = input_item_GetDate( p_item );
568     if( psz_meta ) p_tag->setYear( atoi( psz_meta ) );
569     free( psz_meta );
570
571     psz_meta = input_item_GetTrackNum( p_item );
572     if( psz_meta ) p_tag->setTrack( atoi( psz_meta ) );
573     free( psz_meta );
574
575
576     // Try now to write special tags
577     if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
578     {
579         if( flac->ID3v2Tag() )
580             WriteMetaToId3v2( flac->ID3v2Tag(), p_item );
581         else if( flac->xiphComment() )
582             WriteMetaToXiph( flac->xiphComment(), p_item );
583     }
584     else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
585     {
586         if( mpc->APETag() )
587             WriteMetaToAPE( mpc->APETag(), p_item );
588     }
589     else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
590     {
591         if( mpeg->ID3v2Tag() )
592             WriteMetaToId3v2( mpeg->ID3v2Tag(), p_item );
593         else if( mpeg->APETag() )
594             WriteMetaToAPE( mpeg->APETag(), p_item );
595     }
596     else if( Ogg::File* ogg = dynamic_cast<Ogg::File*>(f.file()) )
597     {
598         if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
599             WriteMetaToXiph( ogg_flac->tag(), p_item );
600         else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
601             WriteMetaToXiph( ogg_speex->tag(), p_item );
602         else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
603             WriteMetaToXiph( ogg_vorbis->tag(), p_item );
604     }
605     else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
606     {
607         if( trueaudio->ID3v2Tag() )
608             WriteMetaToId3v2( trueaudio->ID3v2Tag(), p_item );
609     }
610     else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
611     {
612         if( wavpack->APETag() )
613             WriteMetaToAPE( wavpack->APETag(), p_item );
614     }
615
616     // Save the meta data
617     f.save();
618
619     return VLC_SUCCESS;
620 }
621
622
623
624 static int DownloadArt( vlc_object_t *p_this )
625 {
626     /* We need to be passed the file name
627      * Fetch the thing from the file, save it to the cache folder
628      */
629     return VLC_EGENERIC;
630 }
631