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, ret;
  69     uint8_t *pb;
  70     AVIOContext *dyn_buf;
  71     if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
  72         return ret;
  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_get_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     ffio_free_dyn_buf(&dyn_buf);
  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, ret;
 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 ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
 115         return ret;
 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_get_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     ffio_free_dyn_buf(&dyn_buf);
 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;
 261     AVIOContext *dyn_bc;
 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         return ret;
 270
 271     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         avio_put_str(dyn_bc, name);
 277     }
 278     len = avio_get_dyn_buf(dyn_bc, &dyn_buf);
 279     id3->len += len + 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     ffio_free_dyn_buf(&dyn_bc);
 287
 288     return ret;
 289 }
 290
 291 static int write_chapter(AVFormatContext *s, ID3v2EncContext *id3, int id, int enc)
 292 {
 293     const AVRational time_base = {1, 1000};
 294     AVChapter *ch = s->chapters[id];
 295     uint8_t *dyn_buf;
 296     AVIOContext *dyn_bc;
 297     char name[123];
 298     int len, start, end, ret;
 299
 300     if ((ret = avio_open_dyn_buf(&dyn_bc)) < 0)
 301         return ret;
 302
 303     start = av_rescale_q(ch->start, ch->time_base, time_base);
 304     end   = av_rescale_q(ch->end,   ch->time_base, time_base);
 305
 306     snprintf(name, 122, "ch%d", id);
 307     id3->len += avio_put_str(dyn_bc, name);
 308     avio_wb32(dyn_bc, start);
 309     avio_wb32(dyn_bc, end);
 310     avio_wb32(dyn_bc, 0xFFFFFFFFu);
 311     avio_wb32(dyn_bc, 0xFFFFFFFFu);
 312
 313     if ((ret = write_metadata(dyn_bc, &ch->metadata, id3, enc)) < 0)
 314         goto fail;
 315
 316     len = avio_get_dyn_buf(dyn_bc, &dyn_buf);
 317     id3->len += 16 + ID3v2_HEADER_SIZE;
 318
 319     avio_wb32(s->pb, MKBETAG('C', 'H', 'A', 'P'));
 320     avio_wb32(s->pb, len);
 321     avio_wb16(s->pb, 0);
 322     avio_write(s->pb, dyn_buf, len);
 323
 324 fail:
 325     ffio_free_dyn_buf(&dyn_bc);
 326
 327     return ret;
 328 }
 329
 330 int ff_id3v2_write_metadata(AVFormatContext *s, ID3v2EncContext *id3)
 331 {
 332     int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
 333                                   ID3v2_ENCODING_UTF8;
 334     int i, ret;
 335
 336     ff_standardize_creation_time(s);
 337     if ((ret = write_metadata(s->pb, &s->metadata, id3, enc)) < 0)
 338         return ret;
 339
 340     if ((ret = write_ctoc(s, id3, enc)) < 0)
 341         return ret;
 342
 343     for (i = 0; i < s->nb_chapters; i++) {
 344         if ((ret = write_chapter(s, id3, i, enc)) < 0)
 345             return ret;
 346     }
 347
 348     return 0;
 349 }
 350
 351 int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)
 352 {
 353     AVStream *st = s->streams[pkt->stream_index];
 354     AVDictionaryEntry *e;
 355
 356     AVIOContext *dyn_buf;
 357     uint8_t     *buf;
 358     const CodecMime *mime = ff_id3v2_mime_tags;
 359     const char  *mimetype = NULL, *desc = "";
 360     int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
 361                                   ID3v2_ENCODING_UTF8;
 362     int i, len, type = 0, ret;
 363
 364     /* get the mimetype*/
 365     while (mime->id != AV_CODEC_ID_NONE) {
 366         if (mime->id == st->codecpar->codec_id) {
 367             mimetype = mime->str;
 368             break;
 369         }
 370         mime++;
 371     }
 372     if (!mimetype) {
 373         av_log(s, AV_LOG_ERROR, "No mimetype is known for stream %d, cannot "
 374                "write an attached picture.\n", st->index);
 375         return AVERROR(EINVAL);
 376     }
 377
 378     /* get the picture type */
 379     e = av_dict_get(st->metadata, "comment", NULL, 0);
 380     for (i = 0; e && i < FF_ARRAY_ELEMS(ff_id3v2_picture_types); i++) {
 381         if (!av_strcasecmp(e->value, ff_id3v2_picture_types[i])) {
 382             type = i;
 383             break;
 384         }
 385     }
 386
 387     /* get the description */
 388     if ((e = av_dict_get(st->metadata, "title", NULL, 0)))
 389         desc = e->value;
 390
 391     /* use UTF16 only for non-ASCII strings */
 392     if (enc == ID3v2_ENCODING_UTF16BOM && string_is_ascii(desc))
 393         enc = ID3v2_ENCODING_ISO8859;
 394
 395     /* start writing */
 396     if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
 397         return ret;
 398
 399     avio_w8(dyn_buf, enc);
 400     avio_put_str(dyn_buf, mimetype);
 401     avio_w8(dyn_buf, type);
 402     id3v2_encode_string(dyn_buf, desc, enc);
 403     avio_write(dyn_buf, pkt->data, pkt->size);
 404     len = avio_get_dyn_buf(dyn_buf, &buf);
 405
 406     avio_wb32(s->pb, MKBETAG('A', 'P', 'I', 'C'));
 407     if (id3->version == 3)
 408         avio_wb32(s->pb, len);
 409     else
 410         id3v2_put_size(s->pb, len);
 411     avio_wb16(s->pb, 0);
 412     avio_write(s->pb, buf, len);
 413     ffio_free_dyn_buf(&dyn_buf);
 414
 415     id3->len += len + ID3v2_HEADER_SIZE;
 416
 417     return 0;
 418 }
 419
 420 void ff_id3v2_finish(ID3v2EncContext *id3, AVIOContext *pb,
 421                      int padding_bytes)
 422 {
 423     int64_t cur_pos;
 424
 425     if (padding_bytes < 0)
 426         padding_bytes = 10;
 427
 428     /* The ID3v2.3 specification states that 28 bits are used to represent the
 429      * size of the whole tag.  Therefore the current size of the tag needs to be
 430      * subtracted from the upper limit of 2^28-1 to clip the value correctly. */
 431     /* The minimum of 10 is an arbitrary amount of padding at the end of the tag
 432      * to fix cover art display with some software such as iTunes, Traktor,
 433      * Serato, Torq. */
 434     padding_bytes = av_clip(padding_bytes, 10, 268435455 - id3->len);
 435     ffio_fill(pb, 0, padding_bytes);
 436     id3->len += padding_bytes;
 437
 438     cur_pos = avio_tell(pb);
 439     avio_seek(pb, id3->size_pos, SEEK_SET);
 440     id3v2_put_size(pb, id3->len);
 441     avio_seek(pb, cur_pos, SEEK_SET);
 442 }
 443
 444 int ff_id3v2_write_simple(struct AVFormatContext *s, int id3v2_version,
 445                           const char *magic)
 446 {
 447     ID3v2EncContext id3 = { 0 };
 448     int ret;
 449
 450     ff_id3v2_start(&id3, s->pb, id3v2_version, magic);
 451     if ((ret = ff_id3v2_write_metadata(s, &id3)) < 0)
 452         return ret;
 453     ff_id3v2_finish(&id3, s->pb, s->metadata_header_padding);
 454
 455     return 0;
 456 }