modules/demux/xiph_metadata.c

   1 /*****************************************************************************
   2  * xiph_metadata.h: Vorbis Comment parser
   3  *****************************************************************************
   4  * Copyright © 2008-2013 VLC authors and VideoLAN
   5  *
   6  * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
   7  *          Jean-Baptiste Kempf <jb@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <assert.h>
  29
  30 #include <vlc_common.h>
  31 #include <vlc_charset.h>
  32 #include <vlc_strings.h>
  33 #include <vlc_arrays.h>
  34 #include <vlc_input.h>
  35 #include "xiph_metadata.h"
  36
  37 input_attachment_t* ParseFlacPicture( const uint8_t *p_data, size_t size,
  38     int i_attachments, int *i_cover_score, int *i_cover_idx )
  39 {
  40     /* TODO: Merge with ID3v2 copy in modules/meta_engine/taglib.cpp. */
  41     static const char pi_cover_score[] = {
  42         0,  /* Other */
  43         5,  /* 32x32 PNG image that should be used as the file icon */
  44         4,  /* File icon of a different size or format. */
  45         20, /* Front cover image of the album. */
  46         19, /* Back cover image of the album. */
  47         13, /* Inside leaflet page of the album. */
  48         18, /* Image from the album itself. */
  49         17, /* Picture of the lead artist or soloist. */
  50         16, /* Picture of the artist or performer. */
  51         14, /* Picture of the conductor. */
  52         15, /* Picture of the band or orchestra. */
  53         9,  /* Picture of the composer. */
  54         8,  /* Picture of the lyricist or text writer. */
  55         7,  /* Picture of the recording location or studio. */
  56         10, /* Picture of the artists during recording. */
  57         11, /* Picture of the artists during performance. */
  58         6,  /* Picture from a movie or video related to the track. */
  59         1,  /* Picture of a large, coloured fish. */
  60         12, /* Illustration related to the track. */
  61         3,  /* Logo of the band or performer. */
  62         2   /* Logo of the publisher (record company). */
  63     };
  64
  65     uint32_t type, len;
  66
  67     if( size < 8 )
  68         return NULL;
  69 #define RM(x) \
  70     do { \
  71         assert(size >= (x)); \
  72         size -= (x); \
  73         p_data += (x); \
  74     } while (0)
  75
  76     type = GetDWBE( p_data );
  77     RM(4);
  78     len = GetDWBE( p_data );
  79     RM(4);
  80
  81     if( size < len )
  82         return NULL;
  83
  84     char *mime = strndup( (const char *)p_data, len );
  85     if( unlikely(mime == NULL) )
  86         return NULL;
  87     RM(len);
  88
  89     if( size < 4 )
  90     {
  91         free( mime );
  92         return NULL;
  93     }
  94
  95     len = GetDWBE( p_data );
  96     RM(4);
  97
  98     if( size < len )
  99     {
 100         free( mime );
 101         return NULL;
 102     }
 103
 104     input_attachment_t *p_attachment = NULL;
 105     char *description = strndup( (const char *)p_data, len );
 106     if( unlikely(description == NULL) )
 107         goto error;
 108     RM(len);
 109
 110     EnsureUTF8( description );
 111
 112     if( size < 20 )
 113         goto error;
 114
 115     RM(4 * 4); /* skip */
 116
 117     len = GetDWBE( p_data );
 118     RM(4);
 119
 120     if( size < len )
 121         goto error;
 122
 123     /* printf( "Picture type=%"PRIu32" mime=%s description='%s' "
 124                "file length=%zu\n", type, mime, description, len ); */
 125
 126     char name[7 + (sizeof (i_attachments) * 3) + 4 + 1];
 127
 128     snprintf( name, sizeof (name), "picture%u", i_attachments );
 129
 130     if( !strcasecmp( mime, "image/jpeg" ) )
 131         strcat( name, ".jpg" );
 132     else if( !strcasecmp( mime, "image/png" ) )
 133         strcat( name, ".png" );
 134
 135     p_attachment = vlc_input_attachment_New( name, mime, description, p_data,
 136                                              size /* XXX: len instead? */ );
 137
 138     if( type < ARRAY_SIZE(pi_cover_score) &&
 139         *i_cover_score < pi_cover_score[type] )
 140     {
 141         *i_cover_idx = i_attachments;
 142         *i_cover_score = pi_cover_score[type];
 143     }
 144
 145 error:
 146     free( mime );
 147     free( description );
 148     return p_attachment;
 149 }
 150
 151 #undef RM
 152 #define RM(x) \
 153     do { \
 154         i_data -= (x); \
 155         p_data += (x); \
 156     } while (0)
 157
 158
 159 typedef struct chapters_array_t
 160 {
 161     unsigned int i_size;
 162     seekpoint_t ** pp_chapters;
 163 } chapters_array_t;
 164
 165 static seekpoint_t * getChapterEntry( unsigned int i_index, chapters_array_t *p_array )
 166 {
 167     if ( i_index > 4096 ) return NULL;
 168     if ( i_index >= p_array->i_size )
 169     {
 170         unsigned int i_newsize = p_array->i_size;
 171         while( i_index >= i_newsize ) i_newsize += 50;
 172
 173         if ( !p_array->pp_chapters )
 174         {
 175             p_array->pp_chapters = calloc( i_newsize, sizeof( seekpoint_t * ) );
 176             if ( !p_array->pp_chapters ) return NULL;
 177             p_array->i_size = i_newsize;
 178         } else {
 179             seekpoint_t **tmp = calloc( i_newsize, sizeof( seekpoint_t * ) );
 180             if ( !tmp ) return NULL;
 181             memcpy( tmp, p_array->pp_chapters, p_array->i_size * sizeof( seekpoint_t * ) );
 182             free( p_array->pp_chapters );
 183             p_array->pp_chapters = tmp;
 184             p_array->i_size = i_newsize;
 185         }
 186     }
 187     if ( !p_array->pp_chapters[i_index] )
 188         p_array->pp_chapters[i_index] = vlc_seekpoint_New();
 189     return p_array->pp_chapters[i_index];
 190 }
 191
 192 #define XIPHMETA_Title        (1 << 0)
 193 #define XIPHMETA_Artist       (1 << 1)
 194 #define XIPHMETA_Genre        (1 << 2)
 195 #define XIPHMETA_Copyright    (1 << 3)
 196 #define XIPHMETA_Album        (1 << 4)
 197 #define XIPHMETA_TrackNum     (1 << 5)
 198 #define XIPHMETA_Description  (1 << 6)
 199 #define XIPHMETA_Rating       (1 << 7)
 200 #define XIPHMETA_Date         (1 << 8)
 201 #define XIPHMETA_Language     (1 << 9)
 202 #define XIPHMETA_Publisher    (1 << 10)
 203 #define XIPHMETA_EncodedBy    (1 << 11)
 204 #define XIPHMETA_TrackTotal   (1 << 12)
 205
 206 static char * xiph_ExtractCueSheetMeta( const char *psz_line,
 207                                         const char *psz_tag, int i_tag,
 208                                         bool b_quoted )
 209 {
 210     if( !strncasecmp( psz_line, psz_tag, i_tag ) )
 211     {
 212         if( !b_quoted )
 213             return strdup( &psz_line[i_tag] );
 214
 215         /* Unquote string value */
 216         char *psz_value = malloc( strlen( psz_line ) - i_tag + 1 );
 217         if( psz_value )
 218         {
 219             char *psz_out = psz_value;
 220             psz_line += i_tag;
 221             bool b_escaped = false;
 222             while( *psz_line )
 223             {
 224                 switch( *psz_line )
 225                 {
 226                     case '\\':
 227                         if( b_escaped )
 228                         {
 229                             b_escaped = false;
 230                             *(psz_out++) = *psz_line;
 231                         }
 232                         else
 233                         {
 234                             b_escaped = true;
 235                         }
 236                         break;
 237                     case '"':
 238                         if( b_escaped )
 239                         {
 240                             b_escaped = false;
 241                             *(psz_out++) = *psz_line;
 242                         }
 243                         break;
 244                     default:
 245                         *(psz_out++) = *psz_line;
 246                         break;
 247                 }
 248                 psz_line++;
 249             }
 250             *psz_out = 0;
 251             return psz_value;
 252         }
 253     }
 254     return NULL;
 255 }
 256
 257 static void xiph_ParseCueSheetMeta( unsigned *pi_flags, vlc_meta_t *p_meta,
 258                                     const char *psz_line,
 259                                     int *pi_seekpoint, seekpoint_t ***ppp_seekpoint,
 260                                     seekpoint_t **pp_tmppoint, bool *pb_valid )
 261 {
 262     VLC_UNUSED(pi_seekpoint);
 263     VLC_UNUSED(ppp_seekpoint);
 264
 265     seekpoint_t *p_seekpoint = *pp_tmppoint;
 266     char *psz_string;
 267
 268 #define TRY_EXTRACT_CUEMETA(var, string, quoted) \
 269     if( !(*pi_flags & XIPHMETA_##var) &&\
 270          ( psz_string = xiph_ExtractCueSheetMeta( psz_line, string, sizeof(string) - 1, quoted ) ) )\
 271     {\
 272         vlc_meta_Set( p_meta, vlc_meta_##var, psz_string );\
 273         free( psz_string );\
 274         *pi_flags |= XIPHMETA_##var;\
 275     }
 276
 277     TRY_EXTRACT_CUEMETA(Title, "TITLE \"", true)
 278     else TRY_EXTRACT_CUEMETA(Genre, "REM GENRE ", false)
 279     else TRY_EXTRACT_CUEMETA(Date, "REM DATE ", false)
 280     else TRY_EXTRACT_CUEMETA(Artist, "PERFORMER \"", true)
 281     else if( !strncasecmp( psz_line, "  TRACK ", 8 ) )
 282     {
 283         if( p_seekpoint )
 284         {
 285             if( *pb_valid )
 286                 TAB_APPEND( *pi_seekpoint, *ppp_seekpoint, p_seekpoint );
 287             else
 288                 vlc_seekpoint_Delete( p_seekpoint );
 289             *pb_valid = false;
 290         }
 291         *pp_tmppoint = p_seekpoint = vlc_seekpoint_New();
 292     }
 293     else if( p_seekpoint && !strncasecmp( psz_line, "    INDEX 01 ", 13 ) )
 294     {
 295         unsigned m, s, f;
 296         if( sscanf( &psz_line[13], "%u:%u:%u", &m, &s, &f ) == 3 )
 297         {
 298             p_seekpoint->i_time_offset = vlc_tick_from_sec(m * 60 + s) + vlc_tick_from_samples(f, 75);
 299             *pb_valid = true;
 300         }
 301     }
 302     else if( p_seekpoint && !p_seekpoint->psz_name )
 303     {
 304         p_seekpoint->psz_name = xiph_ExtractCueSheetMeta( psz_line, "    TITLE \"", 11, true );
 305     }
 306 }
 307
 308 static void xiph_ParseCueSheet( unsigned *pi_flags, vlc_meta_t *p_meta,
 309                                 const char *p_data, int i_data,
 310                                 int *pi_seekpoint, seekpoint_t ***ppp_seekpoint )
 311 {
 312     seekpoint_t *p_seekpoint = NULL;
 313     bool b_valid = false;
 314
 315     const char *p_head = p_data;
 316     const char *p_tail = p_head;
 317     while( p_tail < p_data + i_data )
 318     {
 319         if( *p_tail == 0x0D )
 320         {
 321             char *psz = strndup( p_head, p_tail - p_head );
 322             if( psz )
 323             {
 324                 xiph_ParseCueSheetMeta( pi_flags, p_meta, psz,
 325                                         pi_seekpoint, ppp_seekpoint,
 326                                         &p_seekpoint, &b_valid );
 327                 free( psz );
 328             }
 329             if( *(++p_tail) == 0x0A )
 330                 p_tail++;
 331             p_head = p_tail;
 332         }
 333         else
 334         {
 335             p_tail++;
 336         }
 337     }
 338
 339
 340     if( p_seekpoint )
 341     {
 342         if( b_valid )
 343             TAB_APPEND( *pi_seekpoint, *ppp_seekpoint, p_seekpoint );
 344         else
 345             vlc_seekpoint_Delete( p_seekpoint );
 346     }
 347 }
 348
 349 void vorbis_ParseComment( es_format_t *p_fmt, vlc_meta_t **pp_meta,
 350         const uint8_t *p_data, size_t i_data,
 351         int *i_attachments, input_attachment_t ***attachments,
 352         int *i_cover_score, int *i_cover_idx,
 353         int *i_seekpoint, seekpoint_t ***ppp_seekpoint,
 354         float (* ppf_replay_gain)[AUDIO_REPLAY_GAIN_MAX],
 355         float (* ppf_replay_peak)[AUDIO_REPLAY_GAIN_MAX] )
 356 {
 357     if( i_data < 8 )
 358         return;
 359
 360     uint32_t vendor_length = GetDWLE(p_data); RM(4);
 361
 362     if( vendor_length > i_data )
 363         return; /* invalid length */
 364
 365     RM(vendor_length); /* TODO: handle vendor payload */
 366
 367     if( i_data < 4 )
 368         return;
 369
 370     uint32_t i_comment = GetDWLE(p_data); RM(4);
 371
 372     if( i_comment > i_data || i_comment == 0 )
 373         return; /* invalid length */
 374
 375     /* */
 376     vlc_meta_t *p_meta = *pp_meta;
 377     if( !p_meta )
 378         *pp_meta = p_meta = vlc_meta_New();
 379
 380     if( unlikely( !p_meta ) )
 381         return;
 382
 383     /* */
 384     unsigned hasMetaFlags = 0;
 385
 386     chapters_array_t chapters_array = { 0, NULL };
 387
 388     for( ; i_comment > 0 && i_data >= 4; i_comment-- )
 389     {
 390         uint32_t comment_size = GetDWLE(p_data); RM(4);
 391
 392         if( comment_size > i_data )
 393             break;
 394
 395         if( comment_size == 0 )
 396             continue;
 397
 398         char* psz_comment = malloc( comment_size + 1 );
 399
 400         if( unlikely( !psz_comment ) )
 401             goto next_comment;
 402
 403         memcpy( psz_comment, p_data, comment_size );
 404         psz_comment[comment_size] = '\0';
 405
 406         EnsureUTF8( psz_comment );
 407
 408 #define IF_EXTRACT(txt,var) \
 409     if( !strncasecmp(psz_comment, txt, strlen(txt)) ) \
 410     { \
 411         const char *oldval = vlc_meta_Get( p_meta, vlc_meta_ ## var ); \
 412         if( oldval && (hasMetaFlags & XIPHMETA_##var)) \
 413         { \
 414             char * newval; \
 415             if( asprintf( &newval, "%s,%s", oldval, &psz_comment[strlen(txt)] ) == -1 ) \
 416                 newval = NULL; \
 417             vlc_meta_Set( p_meta, vlc_meta_ ## var, newval ); \
 418             free( newval ); \
 419         } \
 420         else \
 421             vlc_meta_Set( p_meta, vlc_meta_ ## var, &psz_comment[strlen(txt)] ); \
 422         hasMetaFlags |= XIPHMETA_##var; \
 423     }
 424
 425 #define IF_EXTRACT_ONCE(txt,var) \
 426     if( !strncasecmp(psz_comment, txt, strlen(txt)) && !(hasMetaFlags & XIPHMETA_##var) ) \
 427     { \
 428         vlc_meta_Set( p_meta, vlc_meta_ ## var, &psz_comment[strlen(txt)] ); \
 429         hasMetaFlags |= XIPHMETA_##var; \
 430     }
 431
 432 #define IF_EXTRACT_FMT(txt,var,fmt,target) \
 433     if( !strncasecmp(psz_comment, txt, strlen(txt)) ) \
 434     { \
 435         IF_EXTRACT(txt,var)\
 436         if( fmt )\
 437         {\
 438             free( fmt->target );\
 439             fmt->target = strdup(&psz_comment[strlen(txt)]);\
 440         }\
 441     }
 442
 443         IF_EXTRACT("TITLE=", Title )
 444         else IF_EXTRACT("ARTIST=", Artist )
 445         else IF_EXTRACT("GENRE=", Genre )
 446         else IF_EXTRACT("COPYRIGHT=", Copyright )
 447         else IF_EXTRACT("ALBUM=", Album )
 448         else if( !(hasMetaFlags & XIPHMETA_TrackNum) && !strncasecmp(psz_comment, "TRACKNUMBER=", strlen("TRACKNUMBER=" ) ) )
 449         {
 450             /* Yeah yeah, such a clever idea, let's put xx/xx inside TRACKNUMBER
 451              * Oh, and let's not use TRACKTOTAL or TOTALTRACKS... */
 452             short unsigned u_track, u_total;
 453             int nb_values = sscanf( &psz_comment[strlen("TRACKNUMBER=")], "%hu/%hu", &u_track, &u_total );
 454             if( nb_values >= 1 )
 455             {
 456                 char str[6];
 457                 snprintf(str, 6, "%u", u_track);
 458                 vlc_meta_Set( p_meta, vlc_meta_TrackNumber, str );
 459                 hasMetaFlags |= XIPHMETA_TrackNum;
 460                 if( nb_values >= 2 )
 461                 {
 462                     snprintf(str, 6, "%u", u_total);
 463                     vlc_meta_Set( p_meta, vlc_meta_TrackTotal, str );
 464                     hasMetaFlags |= XIPHMETA_TrackTotal;
 465                 }
 466             }
 467         }
 468         else IF_EXTRACT_ONCE("TRACKTOTAL=", TrackTotal )
 469         else IF_EXTRACT_ONCE("TOTALTRACKS=", TrackTotal )
 470         else IF_EXTRACT("DESCRIPTION=", Description )
 471         else IF_EXTRACT("COMMENT=", Description )
 472         else IF_EXTRACT("COMMENTS=", Description )
 473         else IF_EXTRACT("RATING=", Rating )
 474         else IF_EXTRACT("DATE=", Date )
 475         else IF_EXTRACT_FMT("LANGUAGE=", Language, p_fmt, psz_language )
 476         else IF_EXTRACT("ORGANIZATION=", Publisher )
 477         else IF_EXTRACT("ENCODER=", EncodedBy )
 478         else if( !strncasecmp( psz_comment, "METADATA_BLOCK_PICTURE=", strlen("METADATA_BLOCK_PICTURE=")))
 479         {
 480             if( attachments == NULL )
 481                 goto next_comment;
 482
 483             uint8_t *p_picture;
 484             size_t i_size = vlc_b64_decode_binary( &p_picture, &psz_comment[strlen("METADATA_BLOCK_PICTURE=")]);
 485             input_attachment_t *p_attachment = ParseFlacPicture( p_picture,
 486                 i_size, *i_attachments, i_cover_score, i_cover_idx );
 487             free( p_picture );
 488             if( p_attachment )
 489             {
 490                 TAB_APPEND_CAST( (input_attachment_t**),
 491                     *i_attachments, *attachments, p_attachment );
 492             }
 493         }
 494         else if ( ppf_replay_gain && ppf_replay_peak && !strncmp(psz_comment, "REPLAYGAIN_", 11) )
 495         {
 496             char *p = strchr( psz_comment, '=' );
 497             if (!p) goto next_comment;
 498             if ( !strncasecmp(psz_comment, "REPLAYGAIN_TRACK_GAIN=", 22) )
 499             {
 500                 (*ppf_replay_gain)[AUDIO_REPLAY_GAIN_TRACK] = us_atof( ++p );
 501             }
 502             else if ( !strncasecmp(psz_comment, "REPLAYGAIN_ALBUM_GAIN=", 22) )
 503             {
 504                 (*ppf_replay_gain)[AUDIO_REPLAY_GAIN_ALBUM] = us_atof( ++p );
 505             }
 506             else if ( !strncasecmp(psz_comment, "REPLAYGAIN_ALBUM_PEAK=", 22) )
 507             {
 508                 (*ppf_replay_peak)[AUDIO_REPLAY_GAIN_ALBUM] = us_atof( ++p );
 509             }
 510             else if ( !strncasecmp(psz_comment, "REPLAYGAIN_TRACK_PEAK=", 22) )
 511             {
 512                 (*ppf_replay_peak)[AUDIO_REPLAY_GAIN_TRACK] = us_atof( ++p );
 513             }
 514         }
 515         else if( !strncasecmp(psz_comment, "CHAPTER", 7) )
 516         {
 517             unsigned int i_chapt;
 518             seekpoint_t *p_seekpoint = NULL;
 519
 520             for( int i = 0; psz_comment[i] && psz_comment[i] != '='; i++ )
 521                 if( psz_comment[i] >= 'a' && psz_comment[i] <= 'z' )
 522                     psz_comment[i] -= 'a' - 'A';
 523
 524             if( strstr( psz_comment, "NAME=" ) &&
 525                     sscanf( psz_comment, "CHAPTER%uNAME=", &i_chapt ) == 1 )
 526             {
 527                 char *p = strchr( psz_comment, '=' );
 528                 p_seekpoint = getChapterEntry( i_chapt, &chapters_array );
 529                 if ( !p || ! p_seekpoint ) goto next_comment;
 530                 if ( ! p_seekpoint->psz_name )
 531                     p_seekpoint->psz_name = strdup( ++p );
 532             }
 533             else if( sscanf( psz_comment, "CHAPTER%u=", &i_chapt ) == 1 )
 534             {
 535                 unsigned int h, m, s, ms;
 536                 char *p = strchr( psz_comment, '=' );
 537                 if( p && sscanf( ++p, "%u:%u:%u.%u", &h, &m, &s, &ms ) == 4 )
 538                 {
 539                     p_seekpoint = getChapterEntry( i_chapt, &chapters_array );
 540                     if ( ! p_seekpoint ) goto next_comment;
 541                     p_seekpoint->i_time_offset = vlc_tick_from_sec(h * 3600 + m * 60 + s) + VLC_TICK_FROM_MS(ms);
 542                 }
 543             }
 544         }
 545         else if( !strncasecmp(psz_comment, "cuesheet=", 9) )
 546         {
 547             xiph_ParseCueSheet( &hasMetaFlags, p_meta, &psz_comment[9], comment_size - 9,
 548                                 i_seekpoint, ppp_seekpoint );
 549         }
 550         else if( strchr( psz_comment, '=' ) )
 551         {
 552             /* generic (PERFORMER/LICENSE/ORGANIZATION/LOCATION/CONTACT/ISRC,
 553              * undocumented tags and replay gain ) */
 554             char *p = strchr( psz_comment, '=' );
 555             *p++ = '\0';
 556
 557             for( int i = 0; psz_comment[i]; i++ )
 558                 if( psz_comment[i] >= 'a' && psz_comment[i] <= 'z' )
 559                     psz_comment[i] -= 'a' - 'A';
 560
 561             vlc_meta_AddExtra( p_meta, psz_comment, p );
 562         }
 563 #undef IF_EXTRACT
 564 next_comment:
 565         free( psz_comment );
 566         RM( comment_size );
 567     }
 568 #undef RM
 569
 570     for ( unsigned int i=0; i<chapters_array.i_size; i++ )
 571     {
 572         if ( !chapters_array.pp_chapters[i] ) continue;
 573         TAB_APPEND_CAST( (seekpoint_t**), *i_seekpoint, *ppp_seekpoint,
 574                          chapters_array.pp_chapters[i] );
 575     }
 576     free( chapters_array.pp_chapters );
 577 }
 578
 579 const char *FindKateCategoryName( const char *psz_tag )
 580 {
 581     for( size_t i = 0; i < sizeof(Katei18nCategories)/sizeof(Katei18nCategories[0]); i++ )
 582     {
 583         if( !strcmp( psz_tag, Katei18nCategories[i].psz_tag ) )
 584             return Katei18nCategories[i].psz_i18n;
 585     }
 586     return N_("Unknown category");
 587 }
 588