modules/meta_engine/taglib.cpp

   1 /*****************************************************************************
   2  * taglib.cpp: Taglib tag parser/writer
   3  *****************************************************************************
   4  * Copyright (C) 2003-2011 VLC authors and VideoLAN
   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 it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * 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_demux.h>              /* demux_meta_t */
  33 #include <vlc_strings.h>            /* vlc_b64_decode_binary */
  34 #include <vlc_input.h>              /* for attachment_new */
  35 #include <vlc_url.h>                /* make_path */
  36 #include <vlc_mime.h>               /* mime type */
  37 #include <vlc_fs.h>
  38
  39 #include <sys/stat.h>
  40
  41 #ifdef _WIN32
  42 # include <vlc_charset.h>
  43 # include <io.h>
  44 #else
  45 # include <unistd.h>
  46 #endif
  47
  48
  49 // Taglib headers
  50 #ifdef _WIN32
  51 # define TAGLIB_STATIC
  52 #endif
  53 #include <taglib.h>
  54 #define VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
  55 #define TAGLIB_VERSION VERSION_INT(TAGLIB_MAJOR_VERSION, \
  56                                    TAGLIB_MINOR_VERSION, \
  57                                    TAGLIB_PATCH_VERSION)
  58
  59 #include <fileref.h>
  60 #include <tag.h>
  61 #include <tbytevector.h>
  62
  63 #if TAGLIB_VERSION >= VERSION_INT(1,7,0)
  64 # define TAGLIB_HAVE_APEFILE_H
  65 # include <apefile.h>
  66 # ifdef TAGLIB_WITH_ASF                     // ASF pictures comes with v1.7.0
  67 #  define TAGLIB_HAVE_ASFPICTURE_H
  68 #  include <asffile.h>
  69 # endif
  70 #endif
  71
  72 #if TAGLIB_VERSION >= VERSION_INT(1,9,0)
  73 # include <opusfile.h>
  74 #endif
  75
  76 #include <apetag.h>
  77 #include <flacfile.h>
  78 #include <mpcfile.h>
  79 #include <mpegfile.h>
  80 #include <oggfile.h>
  81 #include <oggflacfile.h>
  82 #include "../demux/xiph_metadata.h"
  83
  84 #include <aifffile.h>
  85 #include <wavfile.h>
  86
  87 #if defined(TAGLIB_WITH_MP4)
  88 # include <mp4file.h>
  89 #endif
  90
  91 #include <speexfile.h>
  92 #include <trueaudiofile.h>
  93 #include <vorbisfile.h>
  94 #include <wavpackfile.h>
  95
  96 #include <attachedpictureframe.h>
  97 #include <textidentificationframe.h>
  98 #include <uniquefileidentifierframe.h>
  99
 100 // taglib is not thread safe
 101 static vlc_mutex_t taglib_lock = VLC_STATIC_MUTEX;
 102
 103 // Local functions
 104 static int ReadMeta    ( vlc_object_t * );
 105 static int WriteMeta   ( vlc_object_t * );
 106
 107 vlc_module_begin ()
 108     set_capability( "meta reader", 1000 )
 109     set_callbacks( ReadMeta, NULL )
 110     add_submodule ()
 111         set_capability( "meta writer", 50 )
 112         set_callbacks( WriteMeta, NULL )
 113 vlc_module_end ()
 114
 115 using namespace TagLib;
 116
 117 static void ExtractTrackNumberValues( vlc_meta_t* p_meta, const char *psz_value )
 118 {
 119     unsigned int i_trknum, i_trktot;
 120     if( sscanf( psz_value, "%u/%u", &i_trknum, &i_trktot ) == 2 )
 121     {
 122         char psz_trck[11];
 123         snprintf( psz_trck, sizeof( psz_trck ), "%u", i_trknum );
 124         vlc_meta_SetTrackNum( p_meta, psz_trck );
 125         snprintf( psz_trck, sizeof( psz_trck ), "%u", i_trktot );
 126         vlc_meta_Set( p_meta, vlc_meta_TrackTotal, psz_trck );
 127     }
 128 }
 129
 130 /**
 131  * Read meta information from APE tags
 132  * @param tag: the APE tag
 133  * @param p_demux_meta: the demuxer meta
 134  * @param p_meta: the meta
 135  */
 136 static void ReadMetaFromAPE( APE::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
 137 {
 138     APE::Item item;
 139
 140     item = tag->itemListMap()["COVER ART (FRONT)"];
 141     if( !item.isEmpty() )
 142     {
 143         input_attachment_t *p_attachment;
 144
 145         const ByteVector picture = item.value();
 146         const char *p_data = picture.data();
 147         unsigned i_data = picture.size();
 148
 149         size_t desc_len = strnlen(p_data, i_data);
 150         if (desc_len < i_data) {
 151             const char *psz_name = p_data;
 152             p_data += desc_len + 1; /* '\0' */
 153             i_data -= desc_len + 1;
 154             msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
 155                      psz_name, "image/jpeg", i_data );
 156
 157             p_attachment = vlc_input_attachment_New( "cover", "image/jpeg",
 158                                     psz_name, p_data, i_data );
 159             if( p_attachment )
 160                 TAB_APPEND_CAST( (input_attachment_t**),
 161                                  p_demux_meta->i_attachments, p_demux_meta->attachments,
 162                                  p_attachment );
 163
 164             vlc_meta_SetArtURL( p_meta, "attachment://cover" );
 165         }
 166     }
 167
 168 #define SET( keyName, metaName ) \
 169     item = tag->itemListMap()[keyName]; \
 170     if( !item.isEmpty() ) vlc_meta_Set##metaName( p_meta, item.toString().toCString( true ) ); \
 171
 172     SET( "ALBUM", Album );
 173     SET( "ARTIST", Artist );
 174     SET( "COMMENT", Description );
 175     SET( "GENRE", Genre );
 176     SET( "TITLE", Title );
 177     SET( "COPYRIGHT", Copyright );
 178     SET( "LANGUAGE", Language );
 179     SET( "PUBLISHER", Publisher );
 180
 181 #undef SET
 182
 183     /* */
 184     item = tag->itemListMap()["TRACK"];
 185     if( !item.isEmpty() )
 186     {
 187         ExtractTrackNumberValues( p_meta, item.toString().toCString( true ) );
 188     }
 189 }
 190
 191
 192 #ifdef TAGLIB_HAVE_ASFPICTURE_H
 193 /**
 194  * Read meta information from APE tags
 195  * @param tag: the APE tag
 196  * @param p_demux_meta: the demuxer meta
 197  * @param p_meta: the meta
 198  */
 199 static void ReadMetaFromASF( ASF::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
 200 {
 201     // List the pictures
 202     ASF::AttributeList list = tag->attributeListMap()["WM/Picture"];
 203     ASF::AttributeList::Iterator iter;
 204     for( iter = list.begin(); iter != list.end(); iter++ )
 205     {
 206         const ASF::Picture asfPicture = (*iter).toPicture();
 207         const ByteVector picture = asfPicture.picture();
 208         const char *psz_mime = asfPicture.mimeType().toCString();
 209         const char *p_data = picture.data();
 210         const unsigned i_data = picture.size();
 211         char *psz_name;
 212         input_attachment_t *p_attachment;
 213
 214         if( asfPicture.description().size() > 0 )
 215             psz_name = strdup( asfPicture.description().toCString( true ) );
 216         else
 217         {
 218             if( asprintf( &psz_name, "%i", asfPicture.type() ) == -1 )
 219                 continue;
 220         }
 221
 222         msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
 223                  psz_name, psz_mime, i_data );
 224
 225         p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
 226                                 psz_name, p_data, i_data );
 227         if( p_attachment )
 228             TAB_APPEND_CAST( (input_attachment_t**),
 229                              p_demux_meta->i_attachments, p_demux_meta->attachments,
 230                              p_attachment );
 231         free( psz_name );
 232
 233         char *psz_url;
 234         if( asprintf( &psz_url, "attachment://%s",
 235                       p_attachment->psz_name ) == -1 )
 236             continue;
 237         vlc_meta_SetArtURL( p_meta, psz_url );
 238         free( psz_url );
 239     }
 240 }
 241 #endif
 242
 243
 244 /**
 245  * Read meta information from id3v2 tags
 246  * @param tag: the id3v2 tag
 247  * @param p_demux_meta: the demuxer meta
 248  * @param p_meta: the meta
 249  */
 250 static void ReadMetaFromId3v2( ID3v2::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
 251 {
 252     // Get the unique file identifier
 253     ID3v2::FrameList list = tag->frameListMap()["UFID"];
 254     ID3v2::FrameList::Iterator iter;
 255     for( iter = list.begin(); iter != list.end(); iter++ )
 256     {
 257         ID3v2::UniqueFileIdentifierFrame* p_ufid =
 258                 dynamic_cast<ID3v2::UniqueFileIdentifierFrame*>(*iter);
 259         if( !p_ufid )
 260             continue;
 261         const char *owner = p_ufid->owner().toCString();
 262         if (!strcmp( owner, "http://musicbrainz.org" ))
 263         {
 264             /* ID3v2 UFID contains up to 64 bytes binary data
 265              * but in our case it will be a '\0'
 266              * terminated string */
 267             char psz_ufid[64];
 268             int max_size = __MIN( p_ufid->identifier().size(), 63);
 269             strncpy( psz_ufid, p_ufid->identifier().data(), max_size );
 270             psz_ufid[max_size] = '\0';
 271             vlc_meta_SetTrackID( p_meta, psz_ufid );
 272         }
 273     }
 274
 275     // Get the use text
 276     list = tag->frameListMap()["TXXX"];
 277     for( iter = list.begin(); iter != list.end(); iter++ )
 278     {
 279         ID3v2::UserTextIdentificationFrame* p_txxx =
 280                 dynamic_cast<ID3v2::UserTextIdentificationFrame*>(*iter);
 281         if( !p_txxx )
 282             continue;
 283         if( !strcmp( p_txxx->description().toCString( true ), "TRACKTOTAL" ) )
 284         {
 285             vlc_meta_Set( p_meta, vlc_meta_TrackTotal, p_txxx->fieldList().back().toCString( true ) );
 286             continue;
 287         }
 288         vlc_meta_AddExtra( p_meta, p_txxx->description().toCString( true ),
 289                            p_txxx->fieldList().back().toCString( true ) );
 290     }
 291
 292     // Get some more information
 293 #define SET( tagName, metaName )                                               \
 294     list = tag->frameListMap()[tagName];                                       \
 295     if( !list.isEmpty() )                                                      \
 296         vlc_meta_Set##metaName( p_meta,                                        \
 297                                 (*list.begin())->toString().toCString( true ) );
 298
 299     SET( "TCOP", Copyright );
 300     SET( "TENC", EncodedBy );
 301     SET( "TLAN", Language );
 302     SET( "TPUB", Publisher );
 303
 304 #undef SET
 305
 306     /* */
 307     list = tag->frameListMap()["TRCK"];
 308     if( !list.isEmpty() )
 309     {
 310         ExtractTrackNumberValues( p_meta, (*list.begin())->toString().toCString( true ) );
 311     }
 312
 313     /* Preferred type of image
 314      * The 21 types are defined in id3v2 standard:
 315      * http://www.id3.org/id3v2.4.0-frames */
 316     static const int pi_cover_score[] = {
 317         0,  /* Other */
 318         5,  /* 32x32 PNG image that should be used as the file icon */
 319         4,  /* File icon of a different size or format. */
 320         20, /* Front cover image of the album. */
 321         19, /* Back cover image of the album. */
 322         13, /* Inside leaflet page of the album. */
 323         18, /* Image from the album itself. */
 324         17, /* Picture of the lead artist or soloist. */
 325         16, /* Picture of the artist or performer. */
 326         14, /* Picture of the conductor. */
 327         15, /* Picture of the band or orchestra. */
 328         9,  /* Picture of the composer. */
 329         8,  /* Picture of the lyricist or text writer. */
 330         7,  /* Picture of the recording location or studio. */
 331         10, /* Picture of the artists during recording. */
 332         11, /* Picture of the artists during performance. */
 333         6,  /* Picture from a movie or video related to the track. */
 334         1,  /* Picture of a large, coloured fish. */
 335         12, /* Illustration related to the track. */
 336         3,  /* Logo of the band or performer. */
 337         2   /* Logo of the publisher (record company). */
 338     };
 339     #define PI_COVER_SCORE_SIZE (sizeof (pi_cover_score) / sizeof (pi_cover_score[0]))
 340     int i_score = -1;
 341
 342     // Try now to get embedded art
 343     list = tag->frameListMap()[ "APIC" ];
 344     if( list.isEmpty() )
 345         return;
 346
 347     TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
 348     for( iter = list.begin(); iter != list.end(); iter++ )
 349     {
 350         ID3v2::AttachedPictureFrame* p_apic =
 351             dynamic_cast<ID3v2::AttachedPictureFrame*>(*iter);
 352         if( !p_apic )
 353             continue;
 354         input_attachment_t *p_attachment;
 355
 356         const char *psz_mime;
 357         char *psz_name, *psz_description;
 358
 359         // Get the mime and description of the image.
 360         // If the description is empty, take the type as a description
 361         psz_mime = p_apic->mimeType().toCString( true );
 362         if( p_apic->description().size() > 0 )
 363             psz_description = strdup( p_apic->description().toCString( true ) );
 364         else
 365         {
 366             if( asprintf( &psz_description, "%i", p_apic->type() ) == -1 )
 367                 psz_description = NULL;
 368         }
 369
 370         if( !psz_description )
 371             continue;
 372         psz_name = psz_description;
 373
 374         /* some old iTunes version not only sets incorrectly the mime type
 375          * or the description of the image,
 376          * but also embeds incorrectly the image.
 377          * Recent versions seem to behave correctly */
 378         if( !strncmp( psz_mime, "PNG", 3 ) ||
 379             !strncmp( psz_name, "\xC2\x89PNG", 5 ) )
 380         {
 381             msg_Warn( p_demux_meta, "Invalid picture embedded by broken iTunes version" );
 382             free( psz_description );
 383             continue;
 384         }
 385
 386         const ByteVector picture = p_apic->picture();
 387         const char *p_data = picture.data();
 388         const unsigned i_data = picture.size();
 389
 390         msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
 391                  psz_name, psz_mime, i_data );
 392
 393         p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
 394                                 psz_description, p_data, i_data );
 395         if( !p_attachment )
 396         {
 397             free( psz_description );
 398             continue;
 399         }
 400         TAB_APPEND_CAST( (input_attachment_t**),
 401                          p_demux_meta->i_attachments, p_demux_meta->attachments,
 402                          p_attachment );
 403         free( psz_description );
 404
 405         unsigned i_pic_type = p_apic->type();
 406         if( i_pic_type >= PI_COVER_SCORE_SIZE )
 407             i_pic_type = 0; // Defaults to "Other"
 408
 409         if( pi_cover_score[i_pic_type] > i_score )
 410         {
 411             i_score = pi_cover_score[i_pic_type];
 412             char *psz_url;
 413             if( asprintf( &psz_url, "attachment://%s",
 414                           p_attachment->psz_name ) == -1 )
 415                 continue;
 416             vlc_meta_SetArtURL( p_meta, psz_url );
 417             free( psz_url );
 418         }
 419     }
 420 }
 421
 422
 423 /**
 424  * Read the meta information from XiphComments
 425  * @param tag: the Xiph Comment
 426  * @param p_demux_meta: the demuxer meta
 427  * @param p_meta: the meta
 428  */
 429 static void ReadMetaFromXiph( Ogg::XiphComment* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
 430 {
 431     StringList list;
 432     bool hasTrackTotal = false;
 433 #define SET( keyName, metaName )                                               \
 434     list = tag->fieldListMap()[keyName];                                       \
 435     if( !list.isEmpty() )                                                      \
 436         vlc_meta_Set##metaName( p_meta, (*list.begin()).toCString( true ) );
 437
 438     SET( "COPYRIGHT", Copyright );
 439     SET( "ORGANIZATION", Publisher );
 440     SET( "DATE", Date );
 441     SET( "ENCODER", EncodedBy );
 442     SET( "RATING", Rating );
 443     SET( "LANGUAGE", Language );
 444 #undef SET
 445
 446     list = tag->fieldListMap()["TRACKNUMBER"];
 447     if( !list.isEmpty() )
 448     {
 449         const char *psz_value;
 450         unsigned short u_track;
 451         unsigned short u_total;
 452         psz_value = (*list.begin()).toCString( true );
 453         if( sscanf( psz_value, "%hu/%hu", &u_track, &u_total ) == 2)
 454         {
 455             char str[6];
 456             snprintf(str, 6, "%u", u_track);
 457             vlc_meta_SetTrackNum( p_meta, str);
 458             snprintf(str, 6, "%u", u_total);
 459             vlc_meta_SetTrackTotal( p_meta, str);
 460             hasTrackTotal = true;
 461         }
 462         else
 463             vlc_meta_SetTrackNum( p_meta, psz_value);
 464     }
 465     if( !hasTrackTotal )
 466     {
 467         list = tag->fieldListMap()["TRACKTOTAL"];
 468         if( list.isEmpty() )
 469             list = tag->fieldListMap()["TOTALTRACKS"];
 470         if( !list.isEmpty() )
 471             vlc_meta_SetTrackTotal( p_meta, (*list.begin()).toCString( true ) );
 472     }
 473
 474     // Try now to get embedded art
 475     StringList mime_list = tag->fieldListMap()[ "COVERARTMIME" ];
 476     StringList art_list = tag->fieldListMap()[ "COVERART" ];
 477
 478     input_attachment_t *p_attachment;
 479
 480     if( mime_list.size() != 0 && art_list.size() != 0 )
 481     {
 482         // We get only the first covert art
 483         if( mime_list.size() > 1 || art_list.size() > 1 )
 484             msg_Warn( p_demux_meta, "Found %i embedded arts, so using only the first one",
 485                     art_list.size() );
 486
 487         const char* psz_name = "cover";
 488         const char* psz_mime = mime_list[0].toCString(true);
 489         const char* psz_description = "cover";
 490
 491         uint8_t *p_data;
 492         int i_data = vlc_b64_decode_binary( &p_data, art_list[0].toCString(true) );
 493
 494         msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %i bytes",
 495                 psz_name, psz_mime, i_data );
 496
 497         p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
 498                 psz_description, p_data, i_data );
 499         free( p_data );
 500     }
 501     else
 502     {
 503         art_list = tag->fieldListMap()[ "METADATA_BLOCK_PICTURE" ];
 504         if( art_list.size() == 0 )
 505             return;
 506
 507         uint8_t *p_data;
 508         int i_cover_score;
 509         int i_cover_idx;
 510         int i_data = vlc_b64_decode_binary( &p_data, art_list[0].toCString(true) );
 511         i_cover_score = i_cover_idx = 0;
 512         /* TODO: Use i_cover_score / i_cover_idx to select the picture. */
 513         p_attachment = ParseFlacPicture( p_data, i_data, 0,
 514             &i_cover_score, &i_cover_idx );
 515     }
 516
 517     TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
 518     if (p_attachment) {
 519         TAB_APPEND_CAST( (input_attachment_t**),
 520                 p_demux_meta->i_attachments, p_demux_meta->attachments,
 521                 p_attachment );
 522
 523         char *psz_url;
 524         if( asprintf( &psz_url, "attachment://%s", p_attachment->psz_name ) != -1 ) {
 525             vlc_meta_SetArtURL( p_meta, psz_url );
 526             free( psz_url );
 527         }
 528     }
 529 }
 530
 531
 532 #if defined(TAGLIB_WITH_MP4)
 533 /**
 534  * Read the meta information from mp4 specific tags
 535  * @param tag: the mp4 tag
 536  * @param p_demux_meta: the demuxer meta
 537  * @param p_meta: the meta
 538  */
 539 static void ReadMetaFromMP4( MP4::Tag* tag, demux_meta_t *p_demux_meta, vlc_meta_t* p_meta )
 540 {
 541     if( tag->itemListMap().contains("covr") )
 542     {
 543         MP4::CoverArtList list = tag->itemListMap()["covr"].toCoverArtList();
 544         const char *psz_format = list[0].format() == MP4::CoverArt::PNG ? "image/png" : "image/jpeg";
 545
 546         msg_Dbg( p_demux_meta, "Found embedded art (%s) is %i bytes",
 547                  psz_format, list[0].data().size() );
 548
 549         TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
 550         input_attachment_t *p_attachment =
 551                 vlc_input_attachment_New( "cover", psz_format, "cover",
 552                                           list[0].data().data(), list[0].data().size() );
 553         TAB_APPEND_CAST( (input_attachment_t**),
 554                          p_demux_meta->i_attachments, p_demux_meta->attachments,
 555                          p_attachment );
 556         vlc_meta_SetArtURL( p_meta, "attachment://cover" );
 557     }
 558 }
 559 #endif
 560
 561
 562 /**
 563  * Get the tags from the file using TagLib
 564  * @param p_this: the demux object
 565  * @return VLC_SUCCESS if the operation success
 566  */
 567 static int ReadMeta( vlc_object_t* p_this)
 568 {
 569     vlc_mutex_locker locker (&taglib_lock);
 570     demux_meta_t*   p_demux_meta = (demux_meta_t *)p_this;
 571     demux_t*        p_demux = p_demux_meta->p_demux;
 572     vlc_meta_t*     p_meta;
 573     FileRef f;
 574
 575     p_demux_meta->p_meta = NULL;
 576     if( strcmp( p_demux->psz_access, "file" ) )
 577         return VLC_EGENERIC;
 578
 579     char *psz_path = strdup( p_demux->psz_file );
 580     if( !psz_path )
 581         return VLC_ENOMEM;
 582
 583 #if defined(_WIN32)
 584     wchar_t *wpath = ToWide( psz_path );
 585     if( wpath == NULL )
 586     {
 587         free( psz_path );
 588         return VLC_EGENERIC;
 589     }
 590     f = FileRef( wpath );
 591     free( wpath );
 592 #else
 593     f = FileRef( psz_path );
 594 #endif
 595     free( psz_path );
 596
 597     if( f.isNull() )
 598         return VLC_EGENERIC;
 599     if( !f.tag() || f.tag()->isEmpty() )
 600         return VLC_EGENERIC;
 601
 602     p_demux_meta->p_meta = p_meta = vlc_meta_New();
 603     if( !p_meta )
 604         return VLC_ENOMEM;
 605
 606
 607     // Read the tags from the file
 608     Tag* p_tag = f.tag();
 609
 610 #define SET( tag, meta )                                                       \
 611     if( !p_tag->tag().isNull() && !p_tag->tag().isEmpty() )                    \
 612         vlc_meta_Set##meta( p_meta, p_tag->tag().toCString(true) )
 613 #define SETINT( tag, meta )                                                    \
 614     if( p_tag->tag() )                                                         \
 615     {                                                                          \
 616         char psz_tmp[10];                                                      \
 617         snprintf( psz_tmp, 10, "%d", p_tag->tag() );                           \
 618         vlc_meta_Set##meta( p_meta, psz_tmp );                                 \
 619     }
 620
 621     SET( title, Title );
 622     SET( artist, Artist );
 623     SET( album, Album );
 624     SET( comment, Description );
 625     SET( genre, Genre );
 626     SETINT( year, Date );
 627     SETINT( track, TrackNum );
 628
 629 #undef SETINT
 630 #undef SET
 631
 632
 633     // Try now to read special tags
 634 #ifdef TAGLIB_HAVE_APEFILE_H
 635     if( APE::File* ape = dynamic_cast<APE::File*>(f.file()) )
 636     {
 637         if( ape->APETag() )
 638             ReadMetaFromAPE( ape->APETag(), p_demux_meta, p_meta );
 639     }
 640     else
 641 #endif
 642 #ifdef TAGLIB_HAVE_ASFPICTURE_H
 643     if( ASF::File* asf = dynamic_cast<ASF::File*>(f.file()) )
 644     {
 645         if( asf->tag() )
 646             ReadMetaFromASF( asf->tag(), p_demux_meta, p_meta );
 647     }
 648     else
 649 #endif
 650     if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
 651     {
 652         if( flac->ID3v2Tag() )
 653             ReadMetaFromId3v2( flac->ID3v2Tag(), p_demux_meta, p_meta );
 654         else if( flac->xiphComment() )
 655             ReadMetaFromXiph( flac->xiphComment(), p_demux_meta, p_meta );
 656     }
 657 #if defined(TAGLIB_WITH_MP4)
 658     else if( MP4::File *mp4 = dynamic_cast<MP4::File*>(f.file()) )
 659     {
 660         if( mp4->tag() )
 661             ReadMetaFromMP4( mp4->tag(), p_demux_meta, p_meta );
 662     }
 663 #endif
 664     else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
 665     {
 666         if( mpc->APETag() )
 667             ReadMetaFromAPE( mpc->APETag(), p_demux_meta, p_meta );
 668     }
 669     else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
 670     {
 671         if( mpeg->ID3v2Tag() )
 672             ReadMetaFromId3v2( mpeg->ID3v2Tag(), p_demux_meta, p_meta );
 673         else if( mpeg->APETag() )
 674             ReadMetaFromAPE( mpeg->APETag(), p_demux_meta, p_meta );
 675     }
 676     else if( dynamic_cast<Ogg::File*>(f.file()) )
 677     {
 678         if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
 679             ReadMetaFromXiph( ogg_flac->tag(), p_demux_meta, p_meta );
 680         else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
 681             ReadMetaFromXiph( ogg_speex->tag(), p_demux_meta, p_meta );
 682         else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
 683             ReadMetaFromXiph( ogg_vorbis->tag(), p_demux_meta, p_meta );
 684 #if defined(TAGLIB_OPUSFILE_H)
 685         else if( Ogg::Opus::File* ogg_opus = dynamic_cast<Ogg::Opus::File*>(f.file()) )
 686             ReadMetaFromXiph( ogg_opus->tag(), p_demux_meta, p_meta );
 687 #endif
 688     }
 689     else if( dynamic_cast<RIFF::File*>(f.file()) )
 690     {
 691         if( RIFF::AIFF::File* riff_aiff = dynamic_cast<RIFF::AIFF::File*>(f.file()) )
 692             ReadMetaFromId3v2( riff_aiff->tag(), p_demux_meta, p_meta );
 693         else if( RIFF::WAV::File* riff_wav = dynamic_cast<RIFF::WAV::File*>(f.file()) )
 694             ReadMetaFromId3v2( riff_wav->tag(), p_demux_meta, p_meta );
 695     }
 696     else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
 697     {
 698         if( trueaudio->ID3v2Tag() )
 699             ReadMetaFromId3v2( trueaudio->ID3v2Tag(), p_demux_meta, p_meta );
 700     }
 701     else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
 702     {
 703         if( wavpack->APETag() )
 704             ReadMetaFromAPE( wavpack->APETag(), p_demux_meta, p_meta );
 705     }
 706
 707     return VLC_SUCCESS;
 708 }
 709
 710
 711 /**
 712  * Write meta information to APE tags
 713  * @param tag: the APE tag
 714  * @param p_item: the input item
 715  */
 716 static void WriteMetaToAPE( APE::Tag* tag, input_item_t* p_item )
 717 {
 718     char* psz_meta;
 719 #define WRITE( metaName, keyName )                      \
 720     psz_meta = input_item_Get##metaName( p_item );      \
 721     if( psz_meta )                                      \
 722     {                                                   \
 723         String key( keyName, String::UTF8 );            \
 724         String value( psz_meta, String::UTF8 );         \
 725         tag->addValue( key, value, true );              \
 726     }                                                   \
 727     free( psz_meta );
 728
 729     WRITE( Copyright, "COPYRIGHT" );
 730     WRITE( Language, "LANGUAGE" );
 731     WRITE( Publisher, "PUBLISHER" );
 732
 733 #undef WRITE
 734 }
 735
 736
 737 /**
 738  * Write meta information to id3v2 tags
 739  * @param tag: the id3v2 tag
 740  * @param p_input: the input item
 741  */
 742 static void WriteMetaToId3v2( ID3v2::Tag* tag, input_item_t* p_item )
 743 {
 744     char* psz_meta;
 745 #define WRITE( metaName, tagName )                                            \
 746     psz_meta = input_item_Get##metaName( p_item );                            \
 747     if( psz_meta )                                                            \
 748     {                                                                         \
 749         ByteVector p_byte( tagName, 4 );                                      \
 750         tag->removeFrames( p_byte );                                         \
 751         ID3v2::TextIdentificationFrame* p_frame =                             \
 752             new ID3v2::TextIdentificationFrame( p_byte, String::UTF8 );       \
 753         p_frame->setText( psz_meta );                                         \
 754         tag->addFrame( p_frame );                                             \
 755     }                                                                         \
 756     free( psz_meta );
 757
 758     WRITE( Copyright, "TCOP" );
 759     WRITE( EncodedBy, "TENC" );
 760     WRITE( Language,  "TLAN" );
 761     WRITE( Publisher, "TPUB" );
 762
 763 #undef WRITE
 764     /* Track Total as Custom Field */
 765     psz_meta = input_item_GetTrackTotal( p_item );
 766     if ( psz_meta )
 767     {
 768         ID3v2::FrameList list = tag->frameListMap()["TXXX"];
 769         ID3v2::UserTextIdentificationFrame *p_txxx;
 770         for( ID3v2::FrameList::Iterator iter = list.begin(); iter != list.end(); iter++ )
 771         {
 772             p_txxx = dynamic_cast<ID3v2::UserTextIdentificationFrame*>(*iter);
 773             if( !p_txxx )
 774                 continue;
 775             if( !strcmp( p_txxx->description().toCString( true ), "TRACKTOTAL" ) )
 776             {
 777                 p_txxx->setText( psz_meta );
 778                 FREENULL( psz_meta );
 779                 break;
 780             }
 781         }
 782         if( psz_meta ) /* not found in existing custom fields */
 783         {
 784             ByteVector p_byte( "TXXX", 4 );
 785             p_txxx = new ID3v2::UserTextIdentificationFrame( p_byte );
 786             p_txxx->setDescription( "TRACKTOTAL" );
 787             p_txxx->setText( psz_meta );
 788             free( psz_meta );
 789             tag->addFrame( p_txxx );
 790         }
 791     }
 792
 793     /* Write album art */
 794     char *psz_url = input_item_GetArtworkURL( p_item );
 795     if( psz_url == NULL )
 796         return;
 797
 798     char *psz_path = make_path( psz_url );
 799     free( psz_url );
 800     if( psz_path == NULL )
 801         return;
 802
 803     const char *psz_mime = vlc_mime_Ext2Mime( psz_path );
 804
 805     FILE *p_file = vlc_fopen( psz_path, "rb" );
 806     if( p_file == NULL )
 807     {
 808         free( psz_path );
 809         return;
 810     }
 811
 812     struct stat st;
 813     if( vlc_stat( psz_path, &st ) == -1 )
 814     {
 815         free( psz_path );
 816         fclose( p_file );
 817         return;
 818     }
 819     off_t file_size = st.st_size;
 820
 821     free( psz_path );
 822
 823     /* Limit picture size to 10MiB */
 824     if( file_size > 10485760 )
 825     {
 826       fclose( p_file );
 827       return;
 828     }
 829
 830     char *p_buffer = new (std::nothrow) char[file_size];
 831     if( p_buffer == NULL )
 832     {
 833         fclose( p_file );
 834         return;
 835     }
 836
 837     if( fread( p_buffer, 1, file_size, p_file ) != (unsigned)file_size )
 838     {
 839         fclose( p_file );
 840         delete[] p_buffer;
 841         return;
 842     }
 843     fclose( p_file );
 844
 845     ByteVector data( p_buffer, file_size );
 846     delete[] p_buffer;
 847
 848     ID3v2::FrameList frames = tag->frameList( "APIC" );
 849     ID3v2::AttachedPictureFrame *frame = NULL;
 850     if( frames.isEmpty() )
 851     {
 852         frame = new TagLib::ID3v2::AttachedPictureFrame;
 853         tag->addFrame( frame );
 854     }
 855     else
 856     {
 857         frame = static_cast<ID3v2::AttachedPictureFrame *>( frames.back() );
 858     }
 859
 860     frame->setPicture( data );
 861     frame->setMimeType( psz_mime );
 862 }
 863
 864
 865 /**
 866  * Write the meta information to XiphComments
 867  * @param tag: the Xiph Comment
 868  * @param p_input: the input item
 869  */
 870 static void WriteMetaToXiph( Ogg::XiphComment* tag, input_item_t* p_item )
 871 {
 872     char* psz_meta;
 873 #define WRITE( metaName, keyName )                      \
 874     psz_meta = input_item_Get##metaName( p_item );      \
 875     if( psz_meta )                                      \
 876     {                                                   \
 877         String key( keyName, String::UTF8 );            \
 878         String value( psz_meta, String::UTF8 );         \
 879         tag->addField( key, value, true );              \
 880     }                                                   \
 881     free( psz_meta );
 882
 883     WRITE( TrackNum, "TRACKNUMBER" );
 884     WRITE( TrackTotal, "TRACKTOTAL" );
 885     WRITE( Copyright, "COPYRIGHT" );
 886     WRITE( Publisher, "ORGANIZATION" );
 887     WRITE( Date, "DATE" );
 888     WRITE( EncodedBy, "ENCODER" );
 889     WRITE( Rating, "RATING" );
 890     WRITE( Language, "LANGUAGE" );
 891
 892 #undef WRITE
 893 }
 894
 895
 896 /**
 897  * Set the tags to the file using TagLib
 898  * @param p_this: the demux object
 899  * @return VLC_SUCCESS if the operation success
 900  */
 901
 902 static int WriteMeta( vlc_object_t *p_this )
 903 {
 904     vlc_mutex_locker locker (&taglib_lock);
 905     meta_export_t *p_export = (meta_export_t *)p_this;
 906     input_item_t *p_item = p_export->p_item;
 907     FileRef f;
 908
 909     if( !p_item )
 910     {
 911         msg_Err( p_this, "Can't save meta data of an empty input" );
 912         return VLC_EGENERIC;
 913     }
 914
 915 #if defined(_WIN32)
 916     wchar_t *wpath = ToWide( p_export->psz_file );
 917     if( wpath == NULL )
 918         return VLC_EGENERIC;
 919     f = FileRef( wpath );
 920     free( wpath );
 921 #else
 922     f = FileRef( p_export->psz_file );
 923 #endif
 924
 925     if( f.isNull() || !f.tag() || f.file()->readOnly() )
 926     {
 927         msg_Err( p_this, "File %s can't be opened for tag writing",
 928                  p_export->psz_file );
 929         return VLC_EGENERIC;
 930     }
 931
 932     msg_Dbg( p_this, "Writing metadata for %s", p_export->psz_file );
 933
 934     Tag *p_tag = f.tag();
 935
 936     char *psz_meta;
 937
 938 #define SET( a, b )                                             \
 939     psz_meta = input_item_Get ## a( p_item );                   \
 940     if( psz_meta )                                              \
 941     {                                                           \
 942         String tmp( psz_meta, String::UTF8 );                   \
 943         p_tag->set##b( tmp );                                   \
 944     }                                                           \
 945     free( psz_meta );
 946
 947     // Saving all common fields
 948     // If the title is empty, use the name
 949     SET( TitleFbName, Title );
 950     SET( Artist, Artist );
 951     SET( Album, Album );
 952     SET( Description, Comment );
 953     SET( Genre, Genre );
 954
 955 #undef SET
 956
 957     psz_meta = input_item_GetDate( p_item );
 958     if( !EMPTY_STR(psz_meta) ) p_tag->setYear( atoi( psz_meta ) );
 959     else p_tag->setYear( 0 );
 960     free( psz_meta );
 961
 962     psz_meta = input_item_GetTrackNum( p_item );
 963     if( !EMPTY_STR(psz_meta) ) p_tag->setTrack( atoi( psz_meta ) );
 964     else p_tag->setTrack( 0 );
 965     free( psz_meta );
 966
 967
 968     // Try now to write special tags
 969 #ifdef TAGLIB_HAVE_APEFILE_H
 970     if( APE::File* ape = dynamic_cast<APE::File*>(f.file()) )
 971     {
 972         if( ape->APETag() )
 973             WriteMetaToAPE( ape->APETag(), p_item );
 974     }
 975     else
 976 #endif
 977     if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
 978     {
 979         if( flac->ID3v2Tag() )
 980             WriteMetaToId3v2( flac->ID3v2Tag(), p_item );
 981         else if( flac->xiphComment() )
 982             WriteMetaToXiph( flac->xiphComment(), p_item );
 983     }
 984     else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
 985     {
 986         if( mpc->APETag() )
 987             WriteMetaToAPE( mpc->APETag(), p_item );
 988     }
 989     else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
 990     {
 991         if( mpeg->ID3v2Tag() )
 992             WriteMetaToId3v2( mpeg->ID3v2Tag(), p_item );
 993         else if( mpeg->APETag() )
 994             WriteMetaToAPE( mpeg->APETag(), p_item );
 995     }
 996     else if( dynamic_cast<Ogg::File*>(f.file()) )
 997     {
 998         if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
 999             WriteMetaToXiph( ogg_flac->tag(), p_item );
1000         else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
1001             WriteMetaToXiph( ogg_speex->tag(), p_item );
1002         else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
1003             WriteMetaToXiph( ogg_vorbis->tag(), p_item );
1004 #if defined(TAGLIB_OPUSFILE_H)
1005         else if( Ogg::Opus::File* ogg_opus = dynamic_cast<Ogg::Opus::File*>(f.file()) )
1006             WriteMetaToXiph( ogg_opus->tag(), p_item );
1007 #endif
1008     }
1009     else if( dynamic_cast<RIFF::File*>(f.file()) )
1010     {
1011         if( RIFF::AIFF::File* riff_aiff = dynamic_cast<RIFF::AIFF::File*>(f.file()) )
1012             WriteMetaToId3v2( riff_aiff->tag(), p_item );
1013         else if( RIFF::WAV::File* riff_wav = dynamic_cast<RIFF::WAV::File*>(f.file()) )
1014             WriteMetaToId3v2( riff_wav->tag(), p_item );
1015     }
1016     else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
1017     {
1018         if( trueaudio->ID3v2Tag() )
1019             WriteMetaToId3v2( trueaudio->ID3v2Tag(), p_item );
1020     }
1021     else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
1022     {
1023         if( wavpack->APETag() )
1024             WriteMetaToAPE( wavpack->APETag(), p_item );
1025     }
1026
1027     // Save the meta data
1028     f.save();
1029
1030     return VLC_SUCCESS;
1031 }
1032