git.sesse.net Git - ffmpeg/blob - libavformat/id3v2enc.c

   1 /*
   2  * ID3v2 header writer
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22 #include <string.h>
  23
  24 #include "libavutil/avstring.h"
  25 #include "libavutil/dict.h"
  26 #include "libavutil/intreadwrite.h"
  27 #include "avformat.h"
  28 #include "avio.h"
  29 #include "avio_internal.h"
  30 #include "id3v2.h"
  31
  32 static void id3v2_put_size(AVIOContext *pb, int size)
  33 {
  34     avio_w8(pb, size >> 21 & 0x7f);
  35     avio_w8(pb, size >> 14 & 0x7f);
  36     avio_w8(pb, size >> 7  & 0x7f);
  37     avio_w8(pb, size       & 0x7f);
  38 }
  39
  40 static int string_is_ascii(const uint8_t *str)
  41 {
  42     while (*str && *str < 128) str++;
  43     return !*str;
  44 }
  45
  46 static void id3v2_encode_string(AVIOContext *pb, const uint8_t *str,
  47                                enum ID3v2Encoding enc)
  48 {
  49     int (*put)(AVIOContext*, const char*);
  50
  51     if (enc == ID3v2_ENCODING_UTF16BOM) {
  52         avio_wl16(pb, 0xFEFF);      /* BOM */
  53         put = avio_put_str16le;
  54     } else
  55         put = avio_put_str;
  56
  57     put(pb, str);
  58 }
  59
  60 /**
  61  * Write a text frame with one (normal frames) or two (TXXX frames) strings
  62  * according to encoding (only UTF-8 or UTF-16+BOM supported).
  63  * @return number of bytes written or a negative error code.
  64  */
  65 static int id3v2_put_ttag(ID3v2EncContext *id3, AVIOContext *avioc, const char *str1, const char *str2,
  66                           uint32_t tag, enum ID3v2Encoding enc)
  67 {
  68     int len;
  69     uint8_t *pb;
  70     AVIOContext *dyn_buf;
  71     if (avio_open_dyn_buf(&dyn_buf) < 0)
  72         return AVERROR(ENOMEM);
  73
  74     /* check if the strings are ASCII-only and use UTF16 only if
  75      * they're not */
  76     if (enc == ID3v2_ENCODING_UTF16BOM && string_is_ascii(str1) &&
  77         (!str2 || string_is_ascii(str2)))
  78         enc = ID3v2_ENCODING_ISO8859;
  79
  80     avio_w8(dyn_buf, enc);
  81     id3v2_encode_string(dyn_buf, str1, enc);
  82     if (str2)
  83         id3v2_encode_string(dyn_buf, str2, enc);
  84     len = avio_close_dyn_buf(dyn_buf, &pb);
  85
  86     avio_wb32(avioc, tag);
  87     /* ID3v2.3 frame size is not sync-safe */
  88     if (id3->version == 3)
  89         avio_wb32(avioc, len);
  90     else
  91         id3v2_put_size(avioc, len);
  92     avio_wb16(avioc, 0);
  93     avio_write(avioc, pb, len);
  94
  95     av_freep(&pb);
  96     return len + ID3v2_HEADER_SIZE;
  97 }
  98
  99 /**
 100  * Write a priv frame with owner and data. 'key' is the owner prepended with
 101  * ID3v2_PRIV_METADATA_PREFIX. 'data' is provided as a string. Any \xXX
 102  * (where 'X' is a valid hex digit) will be unescaped to the byte value.
 103  */
 104 static int id3v2_put_priv(ID3v2EncContext *id3, AVIOContext *avioc, const char *key, const char *data)
 105 {
 106     int len;
 107     uint8_t *pb;
 108     AVIOContext *dyn_buf;
 109
 110     if (!av_strstart(key, ID3v2_PRIV_METADATA_PREFIX, &key)) {
 111         return 0;
 112     }
 113
 114     if (avio_open_dyn_buf(&dyn_buf) < 0)
 115         return AVERROR(ENOMEM);
 116
 117     // owner + null byte.
 118     avio_write(dyn_buf, key, strlen(key) + 1);
 119
 120     while (*data) {
 121         if (av_strstart(data, "\\x", &data)) {
 122             if (data[0] && data[1] && av_isxdigit(data[0]) && av_isxdigit(data[1])) {
 123                 char digits[] = {data[0], data[1], 0};
 124                 avio_w8(dyn_buf, strtol(digits, NULL, 16));
 125                 data += 2;
 126             } else {
 127                 ffio_free_dyn_buf(&dyn_buf);
 128                 av_log(avioc, AV_LOG_ERROR, "Invalid escape '\\x%.2s' in metadata tag '"
 129                        ID3v2_PRIV_METADATA_PREFIX "%s'.\n", data, key);
 130                 return AVERROR(EINVAL);
 131             }
 132         } else {
 133             avio_write(dyn_buf, data++, 1);
 134         }
 135     }
 136
 137     len = avio_close_dyn_buf(dyn_buf, &pb);
 138
 139     avio_wb32(avioc, MKBETAG('P', 'R', 'I', 'V'));
 140     if (id3->version == 3)
 141         avio_wb32(avioc, len);
 142     else
 143         id3v2_put_size(avioc, len);
 144     avio_wb16(avioc, 0);
 145     avio_write(avioc, pb, len);
 146
 147     av_free(pb);
 148
 149     return len + ID3v2_HEADER_SIZE;
 150 }
 151
 152 static int id3v2_check_write_tag(ID3v2EncContext *id3, AVIOContext *pb, AVDictionaryEntry *t,
 153                                  const char table[][4], enum ID3v2Encoding enc)
 154 {
 155     uint32_t tag;
 156     int i;
 157
 158     if (t->key[0] != 'T' || strlen(t->key) != 4)
 159         return -1;
 160     tag = AV_RB32(t->key);
 161     for (i = 0; *table[i]; i++)
 162         if (tag == AV_RB32(table[i]))
 163             return id3v2_put_ttag(id3, pb, t->value, NULL, tag, enc);
 164     return -1;
 165 }
 166
 167 static void id3v2_3_metadata_split_date(AVDictionary **pm)
 168 {
 169     AVDictionaryEntry *mtag = NULL;
 170     AVDictionary *dst = NULL;
 171     const char *key, *value;
 172     char year[5] = {0}, day_month[5] = {0};
 173     int i;
 174
 175     while ((mtag = av_dict_get(*pm, "", mtag, AV_DICT_IGNORE_SUFFIX))) {
 176         key = mtag->key;
 177         if (!av_strcasecmp(key, "date")) {
 178             /* split date tag using "YYYY-MM-DD" format into year and month/day segments */
 179             value = mtag->value;
 180             i = 0;
 181             while (value[i] >= '0' && value[i] <= '9') i++;
 182             if (value[i] == '\0' || value[i] == '-') {
 183                 av_strlcpy(year, value, sizeof(year));
 184                 av_dict_set(&dst, "TYER", year, 0);
 185
 186                 if (value[i] == '-' &&
 187                     value[i+1] >= '0' && value[i+1] <= '1' &&
 188                     value[i+2] >= '0' && value[i+2] <= '9' &&
 189                     value[i+3] == '-' &&
 190                     value[i+4] >= '0' && value[i+4] <= '3' &&
 191                     value[i+5] >= '0' && value[i+5] <= '9' &&
 192                     (value[i+6] == '\0' || value[i+6] == ' ')) {
 193                     snprintf(day_month, sizeof(day_month), "%.2s%.2s", value + i + 4, value + i + 1);
 194                     av_dict_set(&dst, "TDAT", day_month, 0);
 195                 }
 196             } else
 197                 av_dict_set(&dst, key, value, 0);
 198         } else
 199             av_dict_set(&dst, key, mtag->value, 0);
 200     }
 201     av_dict_free(pm);
 202     *pm = dst;
 203 }
 204
 205 void ff_id3v2_start(ID3v2EncContext *id3, AVIOContext *pb, int id3v2_version,
 206                     const char *magic)
 207 {
 208     id3->version = id3v2_version;
 209
 210     avio_wb32(pb, MKBETAG(magic[0], magic[1], magic[2], id3v2_version));
 211     avio_w8(pb, 0);
 212     avio_w8(pb, 0); /* flags */
 213
 214     /* reserve space for size */
 215     id3->size_pos = avio_tell(pb);
 216     avio_wb32(pb, 0);
 217 }
 218
 219 static int write_metadata(AVIOContext *pb, AVDictionary **metadata,
 220                           ID3v2EncContext *id3, int enc)
 221 {
 222     AVDictionaryEntry *t = NULL;
 223     int ret;
 224
 225     ff_metadata_conv(metadata, ff_id3v2_34_metadata_conv, NULL);
 226     if (id3->version == 3)
 227         id3v2_3_metadata_split_date(metadata);
 228     else if (id3->version == 4)
 229         ff_metadata_conv(metadata, ff_id3v2_4_metadata_conv, NULL);
 230
 231     while ((t = av_dict_get(*metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {
 232         if ((ret = id3v2_check_write_tag(id3, pb, t, ff_id3v2_tags, enc)) > 0) {
 233             id3->len += ret;
 234             continue;
 235         }
 236         if ((ret = id3v2_check_write_tag(id3, pb, t, id3->version == 3 ?
 237                                          ff_id3v2_3_tags : ff_id3v2_4_tags, enc)) > 0) {
 238             id3->len += ret;
 239             continue;
 240         }
 241
 242         if ((ret = id3v2_put_priv(id3, pb, t->key, t->value)) > 0) {
 243             id3->len += ret;
 244             continue;
 245         } else if (ret < 0) {
 246             return ret;
 247         }
 248
 249         /* unknown tag, write as TXXX frame */
 250         if ((ret = id3v2_put_ttag(id3, pb, t->key, t->value, MKBETAG('T', 'X', 'X', 'X'), enc)) < 0)
 251             return ret;
 252         id3->len += ret;
 253     }
 254
 255     return 0;
 256 }
 257
 258 static int write_ctoc(AVFormatContext *s, ID3v2EncContext *id3, int enc)
 259 {
 260     uint8_t *dyn_buf = NULL;
 261     AVIOContext *dyn_bc = NULL;
 262     char name[123];
 263     int len, ret;
 264
 265     if (s->nb_chapters == 0)
 266         return 0;
 267
 268     if ((ret = avio_open_dyn_buf(&dyn_bc)) < 0)
 269         goto fail;
 270
 271     id3->len += avio_put_str(dyn_bc, "toc");
 272     avio_w8(dyn_bc, 0x03);
 273     avio_w8(dyn_bc, s->nb_chapters);
 274     for (int i = 0; i < s->nb_chapters; i++) {
 275         snprintf(name, 122, "ch%d", i);
 276         id3->len += avio_put_str(dyn_bc, name);
 277     }
 278     len = avio_close_dyn_buf(dyn_bc, &dyn_buf);
 279     id3->len += 16 + ID3v2_HEADER_SIZE;
 280
 281     avio_wb32(s->pb, MKBETAG('C', 'T', 'O', 'C'));
 282     avio_wb32(s->pb, len);
 283     avio_wb16(s->pb, 0);
 284     avio_write(s->pb, dyn_buf, len);
 285
 286 fail:
 287     if (dyn_bc && !dyn_buf)
 288         avio_close_dyn_buf(dyn_bc, &dyn_buf);
 289     av_freep(&dyn_buf);
 290
 291     return ret;
 292 }
 293
 294 static int write_chapter(AVFormatContext *s, ID3v2EncContext *id3, int id, int enc)
 295 {
 296     const AVRational time_base = {1, 1000};
 297     AVChapter *ch = s->chapters[id];
 298     uint8_t *dyn_buf = NULL;
 299     AVIOContext *dyn_bc = NULL;
 300     char name[123];
 301     int len, start, end, ret;
 302
 303     if ((ret = avio_open_dyn_buf(&dyn_bc)) < 0)
 304         goto fail;
 305
 306     start = av_rescale_q(ch->start, ch->time_base, time_base);
 307     end   = av_rescale_q(ch->end,   ch->time_base, time_base);
 308
 309     snprintf(name, 122, "ch%d", id);
 310     id3->len += avio_put_str(dyn_bc, name);
 311     avio_wb32(dyn_bc, start);
 312     avio_wb32(dyn_bc, end);
 313     avio_wb32(dyn_bc, 0xFFFFFFFFu);
 314     avio_wb32(dyn_bc, 0xFFFFFFFFu);
 315
 316     if ((ret = write_metadata(dyn_bc, &ch->metadata, id3, enc)) < 0)
 317         goto fail;
 318
 319     len = avio_close_dyn_buf(dyn_bc, &dyn_buf);
 320     id3->len += 16 + ID3v2_HEADER_SIZE;
 321
 322     avio_wb32(s->pb, MKBETAG('C', 'H', 'A', 'P'));
 323     avio_wb32(s->pb, len);
 324     avio_wb16(s->pb, 0);
 325     avio_write(s->pb, dyn_buf, len);
 326
 327 fail:
 328     if (dyn_bc && !dyn_buf)
 329         avio_close_dyn_buf(dyn_bc, &dyn_buf);
 330     av_freep(&dyn_buf);
 331
 332     return ret;
 333 }
 334
 335 int ff_id3v2_write_metadata(AVFormatContext *s, ID3v2EncContext *id3)
 336 {
 337     int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
 338                                   ID3v2_ENCODING_UTF8;
 339     int i, ret;
 340
 341     ff_standardize_creation_time(s);
 342     if ((ret = write_metadata(s->pb, &s->metadata, id3, enc)) < 0)
 343         return ret;
 344
 345     if ((ret = write_ctoc(s, id3, enc)) < 0)
 346         return ret;
 347
 348     for (i = 0; i < s->nb_chapters; i++) {
 349         if ((ret = write_chapter(s, id3, i, enc)) < 0)
 350             return ret;
 351     }
 352
 353     return 0;
 354 }
 355
 356 int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)
 357 {
 358     AVStream *st = s->streams[pkt->stream_index];
 359     AVDictionaryEntry *e;
 360
 361     AVIOContext *dyn_buf;
 362     uint8_t     *buf;
 363     const CodecMime *mime = ff_id3v2_mime_tags;
 364     const char  *mimetype = NULL, *desc = "";
 365     int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
 366                                   ID3v2_ENCODING_UTF8;
 367     int i, len, type = 0;
 368
 369     /* get the mimetype*/
 370     while (mime->id != AV_CODEC_ID_NONE) {
 371         if (mime->id == st->codecpar->codec_id) {
 372             mimetype = mime->str;
 373             break;
 374         }
 375         mime++;
 376     }
 377     if (!mimetype) {
 378         av_log(s, AV_LOG_ERROR, "No mimetype is known for stream %d, cannot "
 379                "write an attached picture.\n", st->index);
 380         return AVERROR(EINVAL);
 381     }
 382
 383     /* get the picture type */
 384     e = av_dict_get(st->metadata, "comment", NULL, 0);
 385     for (i = 0; e && i < FF_ARRAY_ELEMS(ff_id3v2_picture_types); i++) {
 386         if (!av_strcasecmp(e->value, ff_id3v2_picture_types[i])) {
 387             type = i;
 388             break;
 389         }
 390     }
 391
 392     /* get the description */
 393     if ((e = av_dict_get(st->metadata, "title", NULL, 0)))
 394         desc = e->value;
 395
 396     /* use UTF16 only for non-ASCII strings */
 397     if (enc == ID3v2_ENCODING_UTF16BOM && string_is_ascii(desc))
 398         enc = ID3v2_ENCODING_ISO8859;
 399
 400     /* start writing */
 401     if (avio_open_dyn_buf(&dyn_buf) < 0)
 402         return AVERROR(ENOMEM);
 403
 404     avio_w8(dyn_buf, enc);
 405     avio_put_str(dyn_buf, mimetype);
 406     avio_w8(dyn_buf, type);
 407     id3v2_encode_string(dyn_buf, desc, enc);
 408     avio_write(dyn_buf, pkt->data, pkt->size);
 409     len = avio_close_dyn_buf(dyn_buf, &buf);
 410
 411     avio_wb32(s->pb, MKBETAG('A', 'P', 'I', 'C'));
 412     if (id3->version == 3)
 413         avio_wb32(s->pb, len);
 414     else
 415         id3v2_put_size(s->pb, len);
 416     avio_wb16(s->pb, 0);
 417     avio_write(s->pb, buf, len);
 418     av_freep(&buf);
 419
 420     id3->len += len + ID3v2_HEADER_SIZE;
 421
 422     return 0;
 423 }
 424
 425 void ff_id3v2_finish(ID3v2EncContext *id3, AVIOContext *pb,
 426                      int padding_bytes)
 427 {
 428     int64_t cur_pos;
 429
 430     if (padding_bytes < 0)
 431         padding_bytes = 10;
 432
 433     /* The ID3v2.3 specification states that 28 bits are used to represent the
 434      * size of the whole tag.  Therefore the current size of the tag needs to be
 435      * subtracted from the upper limit of 2^28-1 to clip the value correctly. */
 436     /* The minimum of 10 is an arbitrary amount of padding at the end of the tag
 437      * to fix cover art display with some software such as iTunes, Traktor,
 438      * Serato, Torq. */
 439     padding_bytes = av_clip(padding_bytes, 10, 268435455 - id3->len);
 440     ffio_fill(pb, 0, padding_bytes);
 441     id3->len += padding_bytes;
 442
 443     cur_pos = avio_tell(pb);
 444     avio_seek(pb, id3->size_pos, SEEK_SET);
 445     id3v2_put_size(pb, id3->len);
 446     avio_seek(pb, cur_pos, SEEK_SET);
 447 }
 448
 449 int ff_id3v2_write_simple(struct AVFormatContext *s, int id3v2_version,
 450                           const char *magic)
 451 {
 452     ID3v2EncContext id3 = { 0 };
 453     int ret;
 454
 455     ff_id3v2_start(&id3, s->pb, id3v2_version, magic);
 456     if ((ret = ff_id3v2_write_metadata(s, &id3)) < 0)
 457         return ret;
 458     ff_id3v2_finish(&id3, s->pb, s->metadata_header_padding);
 459
 460     return 0;
 461 }