FFmpeg
id3v2.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Fabrice Bellard
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 /**
22  * @file
23  * ID3v2 header parser
24  *
25  * Specifications available at:
26  * http://id3.org/Developer_Information
27  */
28 
29 #include "config.h"
30 
31 #if CONFIG_ZLIB
32 #include <zlib.h>
33 #endif
34 
35 #include "libavutil/avstring.h"
36 #include "libavutil/bprint.h"
37 #include "libavutil/dict.h"
38 #include "libavutil/intreadwrite.h"
39 #include "libavcodec/png.h"
40 #include "avio_internal.h"
41 #include "internal.h"
42 #include "id3v1.h"
43 #include "id3v2.h"
44 
46  { "TALB", "album" },
47  { "TCOM", "composer" },
48  { "TCON", "genre" },
49  { "TCOP", "copyright" },
50  { "TENC", "encoded_by" },
51  { "TIT2", "title" },
52  { "TLAN", "language" },
53  { "TPE1", "artist" },
54  { "TPE2", "album_artist" },
55  { "TPE3", "performer" },
56  { "TPOS", "disc" },
57  { "TPUB", "publisher" },
58  { "TRCK", "track" },
59  { "TSSE", "encoder" },
60  { "USLT", "lyrics" },
61  { 0 }
62 };
63 
65  { "TCMP", "compilation" },
66  { "TDRC", "date" },
67  { "TDRL", "date" },
68  { "TDEN", "creation_time" },
69  { "TSOA", "album-sort" },
70  { "TSOP", "artist-sort" },
71  { "TSOT", "title-sort" },
72  { 0 }
73 };
74 
76  { "TAL", "album" },
77  { "TCO", "genre" },
78  { "TCP", "compilation" },
79  { "TT2", "title" },
80  { "TEN", "encoded_by" },
81  { "TP1", "artist" },
82  { "TP2", "album_artist" },
83  { "TP3", "performer" },
84  { "TRK", "track" },
85  { 0 }
86 };
87 
88 const char ff_id3v2_tags[][4] = {
89  "TALB", "TBPM", "TCOM", "TCON", "TCOP", "TDLY", "TENC", "TEXT",
90  "TFLT", "TIT1", "TIT2", "TIT3", "TKEY", "TLAN", "TLEN", "TMED",
91  "TOAL", "TOFN", "TOLY", "TOPE", "TOWN", "TPE1", "TPE2", "TPE3",
92  "TPE4", "TPOS", "TPUB", "TRCK", "TRSN", "TRSO", "TSRC", "TSSE",
93  { 0 },
94 };
95 
96 const char ff_id3v2_4_tags[][4] = {
97  "TDEN", "TDOR", "TDRC", "TDRL", "TDTG", "TIPL", "TMCL", "TMOO",
98  "TPRO", "TSOA", "TSOP", "TSOT", "TSST",
99  { 0 },
100 };
101 
102 const char ff_id3v2_3_tags[][4] = {
103  "TDAT", "TIME", "TORY", "TRDA", "TSIZ", "TYER",
104  { 0 },
105 };
106 
107 const char * const ff_id3v2_picture_types[21] = {
108  "Other",
109  "32x32 pixels 'file icon'",
110  "Other file icon",
111  "Cover (front)",
112  "Cover (back)",
113  "Leaflet page",
114  "Media (e.g. label side of CD)",
115  "Lead artist/lead performer/soloist",
116  "Artist/performer",
117  "Conductor",
118  "Band/Orchestra",
119  "Composer",
120  "Lyricist/text writer",
121  "Recording Location",
122  "During recording",
123  "During performance",
124  "Movie/video screen capture",
125  "A bright coloured fish",
126  "Illustration",
127  "Band/artist logotype",
128  "Publisher/Studio logotype",
129 };
130 
132  { "image/gif", AV_CODEC_ID_GIF },
133  { "image/jpeg", AV_CODEC_ID_MJPEG },
134  { "image/jpg", AV_CODEC_ID_MJPEG },
135  { "image/png", AV_CODEC_ID_PNG },
136  { "image/tiff", AV_CODEC_ID_TIFF },
137  { "image/bmp", AV_CODEC_ID_BMP },
138  { "JPG", AV_CODEC_ID_MJPEG }, /* ID3v2.2 */
139  { "PNG", AV_CODEC_ID_PNG }, /* ID3v2.2 */
140  { "", AV_CODEC_ID_NONE },
141 };
142 
143 int ff_id3v2_match(const uint8_t *buf, const char *magic)
144 {
145  return buf[0] == magic[0] &&
146  buf[1] == magic[1] &&
147  buf[2] == magic[2] &&
148  buf[3] != 0xff &&
149  buf[4] != 0xff &&
150  (buf[6] & 0x80) == 0 &&
151  (buf[7] & 0x80) == 0 &&
152  (buf[8] & 0x80) == 0 &&
153  (buf[9] & 0x80) == 0;
154 }
155 
156 int ff_id3v2_tag_len(const uint8_t *buf)
157 {
158  int len = ((buf[6] & 0x7f) << 21) +
159  ((buf[7] & 0x7f) << 14) +
160  ((buf[8] & 0x7f) << 7) +
161  (buf[9] & 0x7f) +
163  if (buf[5] & 0x10)
164  len += ID3v2_HEADER_SIZE;
165  return len;
166 }
167 
168 static unsigned int get_size(AVIOContext *s, int len)
169 {
170  int v = 0;
171  while (len--)
172  v = (v << 7) + (avio_r8(s) & 0x7F);
173  return v;
174 }
175 
176 static unsigned int size_to_syncsafe(unsigned int size)
177 {
178  return (((size) & (0x7f << 0)) >> 0) +
179  (((size) & (0x7f << 8)) >> 1) +
180  (((size) & (0x7f << 16)) >> 2) +
181  (((size) & (0x7f << 24)) >> 3);
182 }
183 
184 /* No real verification, only check that the tag consists of
185  * a combination of capital alpha-numerical characters */
186 static int is_tag(const char *buf, unsigned int len)
187 {
188  if (!len)
189  return 0;
190 
191  while (len--)
192  if ((buf[len] < 'A' ||
193  buf[len] > 'Z') &&
194  (buf[len] < '0' ||
195  buf[len] > '9'))
196  return 0;
197 
198  return 1;
199 }
200 
201 /**
202  * Return 1 if the tag of length len at the given offset is valid, 0 if not, -1 on error
203  */
204 static int check_tag(AVIOContext *s, int offset, unsigned int len)
205 {
206  char tag[4];
207 
208  if (len > 4 ||
209  avio_seek(s, offset, SEEK_SET) < 0 ||
210  avio_read(s, tag, len) < (int)len)
211  return -1;
212  else if (!AV_RB32(tag) || is_tag(tag, len))
213  return 1;
214 
215  return 0;
216 }
217 
218 /**
219  * Free GEOB type extra metadata.
220  */
221 static void free_geobtag(void *obj)
222 {
223  ID3v2ExtraMetaGEOB *geob = obj;
224  av_freep(&geob->mime_type);
225  av_freep(&geob->file_name);
226  av_freep(&geob->description);
227  av_freep(&geob->data);
228 }
229 
230 /**
231  * Decode characters to UTF-8 according to encoding type. The decoded buffer is
232  * always null terminated. Stop reading when either *maxread bytes are read from
233  * pb or U+0000 character is found.
234  *
235  * @param dst Pointer where the address of the buffer with the decoded bytes is
236  * stored. Buffer must be freed by caller.
237  * @param maxread Pointer to maximum number of characters to read from the
238  * AVIOContext. After execution the value is decremented by the number of bytes
239  * actually read.
240  * @returns 0 if no error occurred, dst is uninitialized on error
241  */
242 static int decode_str(AVFormatContext *s, AVIOContext *pb, int encoding,
243  uint8_t **dst, int *maxread)
244 {
245  int ret;
246  uint8_t tmp;
247  uint32_t ch = 1;
248  int left = *maxread;
249  unsigned int (*get)(AVIOContext*) = avio_rb16;
250  AVIOContext *dynbuf;
251 
252  if ((ret = avio_open_dyn_buf(&dynbuf)) < 0) {
253  av_log(s, AV_LOG_ERROR, "Error opening memory stream\n");
254  return ret;
255  }
256 
257  switch (encoding) {
259  while (left && ch) {
260  ch = avio_r8(pb);
261  PUT_UTF8(ch, tmp, avio_w8(dynbuf, tmp);)
262  left--;
263  }
264  break;
265 
267  if ((left -= 2) < 0) {
268  av_log(s, AV_LOG_ERROR, "Cannot read BOM value, input too short\n");
269  ffio_free_dyn_buf(&dynbuf);
270  *dst = NULL;
271  return AVERROR_INVALIDDATA;
272  }
273  switch (avio_rb16(pb)) {
274  case 0xfffe:
275  get = avio_rl16;
276  case 0xfeff:
277  break;
278  default:
279  av_log(s, AV_LOG_ERROR, "Incorrect BOM value\n");
280  ffio_free_dyn_buf(&dynbuf);
281  *dst = NULL;
282  *maxread = left;
283  return AVERROR_INVALIDDATA;
284  }
285  // fall-through
286 
288  while ((left > 1) && ch) {
289  GET_UTF16(ch, ((left -= 2) >= 0 ? get(pb) : 0), break;)
290  PUT_UTF8(ch, tmp, avio_w8(dynbuf, tmp);)
291  }
292  if (left < 0)
293  left += 2; /* did not read last char from pb */
294  break;
295 
296  case ID3v2_ENCODING_UTF8:
297  while (left && ch) {
298  ch = avio_r8(pb);
299  avio_w8(dynbuf, ch);
300  left--;
301  }
302  break;
303  default:
304  av_log(s, AV_LOG_WARNING, "Unknown encoding\n");
305  }
306 
307  if (ch)
308  avio_w8(dynbuf, 0);
309 
310  avio_close_dyn_buf(dynbuf, dst);
311  *maxread = left;
312 
313  return 0;
314 }
315 
316 /**
317  * Parse a text tag.
318  */
319 static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen,
320  AVDictionary **metadata, const char *key)
321 {
322  uint8_t *dst;
323  int encoding, dict_flags = AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL;
324  unsigned genre;
325 
326  if (taglen < 1)
327  return;
328 
329  encoding = avio_r8(pb);
330  taglen--; /* account for encoding type byte */
331 
332  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
333  av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", key);
334  return;
335  }
336 
337  if (!(strcmp(key, "TCON") && strcmp(key, "TCO")) &&
338  (sscanf(dst, "(%d)", &genre) == 1 || sscanf(dst, "%d", &genre) == 1) &&
339  genre <= ID3v1_GENRE_MAX) {
340  av_freep(&dst);
341  dst = av_strdup(ff_id3v1_genre_str[genre]);
342  } else if (!(strcmp(key, "TXXX") && strcmp(key, "TXX"))) {
343  /* dst now contains the key, need to get value */
344  key = dst;
345  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
346  av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", key);
347  av_freep(&key);
348  return;
349  }
350  dict_flags |= AV_DICT_DONT_STRDUP_KEY;
351  } else if (!*dst)
352  av_freep(&dst);
353 
354  if (dst)
355  av_dict_set(metadata, key, dst, dict_flags);
356 }
357 
358 static void read_uslt(AVFormatContext *s, AVIOContext *pb, int taglen,
359  AVDictionary **metadata)
360 {
361  uint8_t lang[4];
362  uint8_t *descriptor = NULL; // 'Content descriptor'
363  uint8_t *text;
364  char *key;
365  int encoding;
366  int ok = 0;
367 
368  if (taglen < 1)
369  goto error;
370 
371  encoding = avio_r8(pb);
372  taglen--;
373 
374  if (avio_read(pb, lang, 3) < 3)
375  goto error;
376  lang[3] = '\0';
377  taglen -= 3;
378 
379  if (decode_str(s, pb, encoding, &descriptor, &taglen) < 0)
380  goto error;
381 
382  if (decode_str(s, pb, encoding, &text, &taglen) < 0)
383  goto error;
384 
385  // FFmpeg does not support hierarchical metadata, so concatenate the keys.
386  key = av_asprintf("lyrics-%s%s%s", descriptor[0] ? (char *)descriptor : "",
387  descriptor[0] ? "-" : "",
388  lang);
389  if (!key) {
390  av_free(text);
391  goto error;
392  }
393 
394  av_dict_set(metadata, key, text,
396 
397  ok = 1;
398 error:
399  if (!ok)
400  av_log(s, AV_LOG_ERROR, "Error reading lyrics, skipped\n");
401  av_free(descriptor);
402 }
403 
404 /**
405  * Parse a comment tag.
406  */
407 static void read_comment(AVFormatContext *s, AVIOContext *pb, int taglen,
408  AVDictionary **metadata)
409 {
410  const char *key = "comment";
411  uint8_t *dst;
412  int encoding, dict_flags = AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL;
413  av_unused int language;
414 
415  if (taglen < 4)
416  return;
417 
418  encoding = avio_r8(pb);
419  language = avio_rl24(pb);
420  taglen -= 4;
421 
422  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
423  av_log(s, AV_LOG_ERROR, "Error reading comment frame, skipped\n");
424  return;
425  }
426 
427  if (dst && !*dst)
428  av_freep(&dst);
429 
430  if (dst) {
431  key = (const char *) dst;
432  dict_flags |= AV_DICT_DONT_STRDUP_KEY;
433  }
434 
435  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
436  av_log(s, AV_LOG_ERROR, "Error reading comment frame, skipped\n");
437  if (dict_flags & AV_DICT_DONT_STRDUP_KEY)
438  av_freep((void*)&key);
439  return;
440  }
441 
442  if (dst)
443  av_dict_set(metadata, key, (const char *) dst, dict_flags);
444 }
445 
446 /**
447  * Parse GEOB tag into a ID3v2ExtraMetaGEOB struct.
448  */
449 static void read_geobtag(AVFormatContext *s, AVIOContext *pb, int taglen,
450  const char *tag, ID3v2ExtraMeta **extra_meta,
451  int isv34)
452 {
453  ID3v2ExtraMetaGEOB *geob_data = NULL;
454  ID3v2ExtraMeta *new_extra = NULL;
455  char encoding;
456  unsigned int len;
457 
458  if (taglen < 1)
459  return;
460 
461  new_extra = av_mallocz(sizeof(ID3v2ExtraMeta));
462  if (!new_extra) {
463  av_log(s, AV_LOG_ERROR, "Failed to alloc %"SIZE_SPECIFIER" bytes\n",
464  sizeof(ID3v2ExtraMeta));
465  return;
466  }
467 
468  geob_data = &new_extra->data.geob;
469 
470  /* read encoding type byte */
471  encoding = avio_r8(pb);
472  taglen--;
473 
474  /* read MIME type (always ISO-8859) */
475  if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &geob_data->mime_type,
476  &taglen) < 0 ||
477  taglen <= 0)
478  goto fail;
479 
480  /* read file name */
481  if (decode_str(s, pb, encoding, &geob_data->file_name, &taglen) < 0 ||
482  taglen <= 0)
483  goto fail;
484 
485  /* read content description */
486  if (decode_str(s, pb, encoding, &geob_data->description, &taglen) < 0 ||
487  taglen < 0)
488  goto fail;
489 
490  if (taglen) {
491  /* save encapsulated binary data */
492  geob_data->data = av_malloc(taglen);
493  if (!geob_data->data) {
494  av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", taglen);
495  goto fail;
496  }
497  if ((len = avio_read(pb, geob_data->data, taglen)) < taglen)
499  "Error reading GEOB frame, data truncated.\n");
500  geob_data->datasize = len;
501  } else {
502  geob_data->data = NULL;
503  geob_data->datasize = 0;
504  }
505 
506  /* add data to the list */
507  new_extra->tag = "GEOB";
508  new_extra->next = *extra_meta;
509  *extra_meta = new_extra;
510 
511  return;
512 
513 fail:
514  av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", tag);
515  free_geobtag(geob_data);
516  av_free(new_extra);
517  return;
518 }
519 
520 static int is_number(const char *str)
521 {
522  while (*str >= '0' && *str <= '9')
523  str++;
524  return !*str;
525 }
526 
528 {
530  if ((t = av_dict_get(m, tag, NULL, AV_DICT_MATCH_CASE)) &&
531  strlen(t->value) == 4 && is_number(t->value))
532  return t;
533  return NULL;
534 }
535 
536 static void merge_date(AVDictionary **m)
537 {
539  char date[17] = { 0 }; // YYYY-MM-DD hh:mm
540 
541  if (!(t = get_date_tag(*m, "TYER")) &&
542  !(t = get_date_tag(*m, "TYE")))
543  return;
544  av_strlcpy(date, t->value, 5);
545  av_dict_set(m, "TYER", NULL, 0);
546  av_dict_set(m, "TYE", NULL, 0);
547 
548  if (!(t = get_date_tag(*m, "TDAT")) &&
549  !(t = get_date_tag(*m, "TDA")))
550  goto finish;
551  snprintf(date + 4, sizeof(date) - 4, "-%.2s-%.2s", t->value + 2, t->value);
552  av_dict_set(m, "TDAT", NULL, 0);
553  av_dict_set(m, "TDA", NULL, 0);
554 
555  if (!(t = get_date_tag(*m, "TIME")) &&
556  !(t = get_date_tag(*m, "TIM")))
557  goto finish;
558  snprintf(date + 10, sizeof(date) - 10,
559  " %.2s:%.2s", t->value, t->value + 2);
560  av_dict_set(m, "TIME", NULL, 0);
561  av_dict_set(m, "TIM", NULL, 0);
562 
563 finish:
564  if (date[0])
565  av_dict_set(m, "date", date, 0);
566 }
567 
568 static void free_apic(void *obj)
569 {
570  ID3v2ExtraMetaAPIC *apic = obj;
571  av_buffer_unref(&apic->buf);
572  av_freep(&apic->description);
573 }
574 
575 static void rstrip_spaces(char *buf)
576 {
577  size_t len = strlen(buf);
578  while (len > 0 && buf[len - 1] == ' ')
579  buf[--len] = 0;
580 }
581 
582 static void read_apic(AVFormatContext *s, AVIOContext *pb, int taglen,
583  const char *tag, ID3v2ExtraMeta **extra_meta,
584  int isv34)
585 {
586  int enc, pic_type;
587  char mimetype[64] = {0};
588  const CodecMime *mime = ff_id3v2_mime_tags;
589  enum AVCodecID id = AV_CODEC_ID_NONE;
590  ID3v2ExtraMetaAPIC *apic = NULL;
591  ID3v2ExtraMeta *new_extra = NULL;
592  int64_t end = avio_tell(pb) + taglen;
593 
594  if (taglen <= 4 || (!isv34 && taglen <= 6))
595  goto fail;
596 
597  new_extra = av_mallocz(sizeof(*new_extra));
598  if (!new_extra)
599  goto fail;
600 
601  apic = &new_extra->data.apic;
602 
603  enc = avio_r8(pb);
604  taglen--;
605 
606  /* mimetype */
607  if (isv34) {
608  taglen -= avio_get_str(pb, taglen, mimetype, sizeof(mimetype));
609  } else {
610  if (avio_read(pb, mimetype, 3) < 0)
611  goto fail;
612 
613  mimetype[3] = 0;
614  taglen -= 3;
615  }
616 
617  while (mime->id != AV_CODEC_ID_NONE) {
618  if (!av_strncasecmp(mime->str, mimetype, sizeof(mimetype))) {
619  id = mime->id;
620  break;
621  }
622  mime++;
623  }
624  if (id == AV_CODEC_ID_NONE) {
626  "Unknown attached picture mimetype: %s, skipping.\n", mimetype);
627  goto fail;
628  }
629  apic->id = id;
630 
631  /* picture type */
632  pic_type = avio_r8(pb);
633  taglen--;
634  if (pic_type < 0 || pic_type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {
635  av_log(s, AV_LOG_WARNING, "Unknown attached picture type %d.\n",
636  pic_type);
637  pic_type = 0;
638  }
639  apic->type = ff_id3v2_picture_types[pic_type];
640 
641  /* description and picture data */
642  if (decode_str(s, pb, enc, &apic->description, &taglen) < 0) {
643  av_log(s, AV_LOG_ERROR,
644  "Error decoding attached picture description.\n");
645  goto fail;
646  }
647 
649  if (!apic->buf || !taglen || avio_read(pb, apic->buf->data, taglen) != taglen)
650  goto fail;
651  memset(apic->buf->data + taglen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
652 
653  new_extra->tag = "APIC";
654  new_extra->next = *extra_meta;
655  *extra_meta = new_extra;
656 
657  // The description must be unique, and some ID3v2 tag writers add spaces
658  // to write several APIC entries with the same description.
659  rstrip_spaces(apic->description);
660 
661  return;
662 
663 fail:
664  if (apic)
665  free_apic(apic);
666  av_freep(&new_extra);
667  avio_seek(pb, end, SEEK_SET);
668 }
669 
670 static void free_chapter(void *obj)
671 {
672  ID3v2ExtraMetaCHAP *chap = obj;
673  av_freep(&chap->element_id);
674  av_dict_free(&chap->meta);
675 }
676 
677 static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, const char *ttag, ID3v2ExtraMeta **extra_meta, int isv34)
678 {
679  int taglen;
680  char tag[5];
681  ID3v2ExtraMeta *new_extra = NULL;
682  ID3v2ExtraMetaCHAP *chap = NULL;
683 
684  new_extra = av_mallocz(sizeof(*new_extra));
685  if (!new_extra)
686  return;
687 
688  chap = &new_extra->data.chap;
689 
690  if (decode_str(s, pb, 0, &chap->element_id, &len) < 0)
691  goto fail;
692 
693  if (len < 16)
694  goto fail;
695 
696  chap->start = avio_rb32(pb);
697  chap->end = avio_rb32(pb);
698  avio_skip(pb, 8);
699 
700  len -= 16;
701  while (len > 10) {
702  if (avio_read(pb, tag, 4) < 4)
703  goto fail;
704  tag[4] = 0;
705  taglen = avio_rb32(pb);
706  avio_skip(pb, 2);
707  len -= 10;
708  if (taglen < 0 || taglen > len)
709  goto fail;
710  if (tag[0] == 'T')
711  read_ttag(s, pb, taglen, &chap->meta, tag);
712  else
713  avio_skip(pb, taglen);
714  len -= taglen;
715  }
716 
717  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_34_metadata_conv);
718  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_4_metadata_conv);
719 
720  new_extra->tag = "CHAP";
721  new_extra->next = *extra_meta;
722  *extra_meta = new_extra;
723 
724  return;
725 
726 fail:
727  free_chapter(chap);
728  av_freep(&new_extra);
729 }
730 
731 static void free_priv(void *obj)
732 {
733  ID3v2ExtraMetaPRIV *priv = obj;
734  av_freep(&priv->owner);
735  av_freep(&priv->data);
736 }
737 
738 static void read_priv(AVFormatContext *s, AVIOContext *pb, int taglen,
739  const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
740 {
741  ID3v2ExtraMeta *meta;
742  ID3v2ExtraMetaPRIV *priv;
743 
744  meta = av_mallocz(sizeof(*meta));
745  if (!meta)
746  return;
747 
748  priv = &meta->data.priv;
749 
750  if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &priv->owner, &taglen) < 0)
751  goto fail;
752 
753  priv->data = av_malloc(taglen);
754  if (!priv->data)
755  goto fail;
756 
757  priv->datasize = taglen;
758 
759  if (avio_read(pb, priv->data, priv->datasize) != priv->datasize)
760  goto fail;
761 
762  meta->tag = "PRIV";
763  meta->next = *extra_meta;
764  *extra_meta = meta;
765 
766  return;
767 
768 fail:
769  free_priv(priv);
770  av_freep(&meta);
771 }
772 
773 typedef struct ID3v2EMFunc {
774  const char *tag3;
775  const char *tag4;
776  void (*read)(AVFormatContext *s, AVIOContext *pb, int taglen,
777  const char *tag, ID3v2ExtraMeta **extra_meta,
778  int isv34);
779  void (*free)(void *obj);
780 } ID3v2EMFunc;
781 
783  { "GEO", "GEOB", read_geobtag, free_geobtag },
784  { "PIC", "APIC", read_apic, free_apic },
785  { "CHAP","CHAP", read_chapter, free_chapter },
786  { "PRIV","PRIV", read_priv, free_priv },
787  { NULL }
788 };
789 
790 /**
791  * Get the corresponding ID3v2EMFunc struct for a tag.
792  * @param isv34 Determines if v2.2 or v2.3/4 strings are used
793  * @return A pointer to the ID3v2EMFunc struct if found, NULL otherwise.
794  */
795 static const ID3v2EMFunc *get_extra_meta_func(const char *tag, int isv34)
796 {
797  int i = 0;
798  while (id3v2_extra_meta_funcs[i].tag3) {
799  if (tag && !memcmp(tag,
800  (isv34 ? id3v2_extra_meta_funcs[i].tag4 :
801  id3v2_extra_meta_funcs[i].tag3),
802  (isv34 ? 4 : 3)))
803  return &id3v2_extra_meta_funcs[i];
804  i++;
805  }
806  return NULL;
807 }
808 
809 static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
811  uint8_t flags, ID3v2ExtraMeta **extra_meta)
812 {
813  int isv34, unsync;
814  unsigned tlen;
815  char tag[5];
816  int64_t next, end = avio_tell(pb) + len;
817  int taghdrlen;
818  const char *reason = NULL;
819  AVIOContext pb_local;
820  AVIOContext *pbx;
821  unsigned char *buffer = NULL;
822  int buffer_size = 0;
823  const ID3v2EMFunc *extra_func = NULL;
824  unsigned char *uncompressed_buffer = NULL;
825  av_unused int uncompressed_buffer_size = 0;
826  const char *comm_frame;
827 
828  av_log(s, AV_LOG_DEBUG, "id3v2 ver:%d flags:%02X len:%d\n", version, flags, len);
829 
830  switch (version) {
831  case 2:
832  if (flags & 0x40) {
833  reason = "compression";
834  goto error;
835  }
836  isv34 = 0;
837  taghdrlen = 6;
838  comm_frame = "COM";
839  break;
840 
841  case 3:
842  case 4:
843  isv34 = 1;
844  taghdrlen = 10;
845  comm_frame = "COMM";
846  break;
847 
848  default:
849  reason = "version";
850  goto error;
851  }
852 
853  unsync = flags & 0x80;
854 
855  if (isv34 && flags & 0x40) { /* Extended header present, just skip over it */
856  int extlen = get_size(pb, 4);
857  if (version == 4)
858  /* In v2.4 the length includes the length field we just read. */
859  extlen -= 4;
860 
861  if (extlen < 0) {
862  reason = "invalid extended header length";
863  goto error;
864  }
865  avio_skip(pb, extlen);
866  len -= extlen + 4;
867  if (len < 0) {
868  reason = "extended header too long.";
869  goto error;
870  }
871  }
872 
873  while (len >= taghdrlen) {
874  unsigned int tflags = 0;
875  int tunsync = 0;
876  int tcomp = 0;
877  int tencr = 0;
878  unsigned long av_unused dlen;
879 
880  if (isv34) {
881  if (avio_read(pb, tag, 4) < 4)
882  break;
883  tag[4] = 0;
884  if (version == 3) {
885  tlen = avio_rb32(pb);
886  } else {
887  /* some encoders incorrectly uses v3 sizes instead of syncsafe ones
888  * so check the next tag to see which one to use */
889  tlen = avio_rb32(pb);
890  if (tlen > 0x7f) {
891  if (tlen < len) {
892  int64_t cur = avio_tell(pb);
893 
894  if (ffio_ensure_seekback(pb, 2 /* tflags */ + tlen + 4 /* next tag */))
895  break;
896 
897  if (check_tag(pb, cur + 2 + size_to_syncsafe(tlen), 4) == 1)
898  tlen = size_to_syncsafe(tlen);
899  else if (check_tag(pb, cur + 2 + tlen, 4) != 1)
900  break;
901  avio_seek(pb, cur, SEEK_SET);
902  } else
903  tlen = size_to_syncsafe(tlen);
904  }
905  }
906  tflags = avio_rb16(pb);
907  tunsync = tflags & ID3v2_FLAG_UNSYNCH;
908  } else {
909  if (avio_read(pb, tag, 3) < 3)
910  break;
911  tag[3] = 0;
912  tlen = avio_rb24(pb);
913  }
914  if (tlen > (1<<28))
915  break;
916  len -= taghdrlen + tlen;
917 
918  if (len < 0)
919  break;
920 
921  next = avio_tell(pb) + tlen;
922 
923  if (!tlen) {
924  if (tag[0])
925  av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n",
926  tag);
927  continue;
928  }
929 
930  if (tflags & ID3v2_FLAG_DATALEN) {
931  if (tlen < 4)
932  break;
933  dlen = avio_rb32(pb);
934  tlen -= 4;
935  } else
936  dlen = tlen;
937 
938  tcomp = tflags & ID3v2_FLAG_COMPRESSION;
939  tencr = tflags & ID3v2_FLAG_ENCRYPTION;
940 
941  /* skip encrypted tags and, if no zlib, compressed tags */
942  if (tencr || (!CONFIG_ZLIB && tcomp)) {
943  const char *type;
944  if (!tcomp)
945  type = "encrypted";
946  else if (!tencr)
947  type = "compressed";
948  else
949  type = "encrypted and compressed";
950 
951  av_log(s, AV_LOG_WARNING, "Skipping %s ID3v2 frame %s.\n", type, tag);
952  avio_skip(pb, tlen);
953  /* check for text tag or supported special meta tag */
954  } else if (tag[0] == 'T' ||
955  !memcmp(tag, "USLT", 4) ||
956  !strcmp(tag, comm_frame) ||
957  (extra_meta &&
958  (extra_func = get_extra_meta_func(tag, isv34)))) {
959  pbx = pb;
960 
961  if (unsync || tunsync || tcomp) {
962  av_fast_malloc(&buffer, &buffer_size, tlen);
963  if (!buffer) {
964  av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);
965  goto seek;
966  }
967  }
968  if (unsync || tunsync) {
969  uint8_t *b = buffer;
970  uint8_t *t = buffer;
971  uint8_t *end = t + tlen;
972 
973  if (avio_read(pb, buffer, tlen) != tlen) {
974  av_log(s, AV_LOG_ERROR, "Failed to read tag data\n");
975  goto seek;
976  }
977 
978  while (t != end) {
979  *b++ = *t++;
980  if (t != end && t[-1] == 0xff && !t[0])
981  t++;
982  }
983 
984  ffio_init_context(&pb_local, buffer, b - buffer, 0, NULL, NULL, NULL,
985  NULL);
986  tlen = b - buffer;
987  pbx = &pb_local; // read from sync buffer
988  }
989 
990 #if CONFIG_ZLIB
991  if (tcomp) {
992  int err;
993 
994  av_log(s, AV_LOG_DEBUG, "Compresssed frame %s tlen=%d dlen=%ld\n", tag, tlen, dlen);
995 
996  av_fast_malloc(&uncompressed_buffer, &uncompressed_buffer_size, dlen);
997  if (!uncompressed_buffer) {
998  av_log(s, AV_LOG_ERROR, "Failed to alloc %ld bytes\n", dlen);
999  goto seek;
1000  }
1001 
1002  if (!(unsync || tunsync)) {
1003  err = avio_read(pb, buffer, tlen);
1004  if (err < 0) {
1005  av_log(s, AV_LOG_ERROR, "Failed to read compressed tag\n");
1006  goto seek;
1007  }
1008  tlen = err;
1009  }
1010 
1011  err = uncompress(uncompressed_buffer, &dlen, buffer, tlen);
1012  if (err != Z_OK) {
1013  av_log(s, AV_LOG_ERROR, "Failed to uncompress tag: %d\n", err);
1014  goto seek;
1015  }
1016  ffio_init_context(&pb_local, uncompressed_buffer, dlen, 0, NULL, NULL, NULL, NULL);
1017  tlen = dlen;
1018  pbx = &pb_local; // read from sync buffer
1019  }
1020 #endif
1021  if (tag[0] == 'T')
1022  /* parse text tag */
1023  read_ttag(s, pbx, tlen, metadata, tag);
1024  else if (!memcmp(tag, "USLT", 4))
1025  read_uslt(s, pbx, tlen, metadata);
1026  else if (!strcmp(tag, comm_frame))
1027  read_comment(s, pbx, tlen, metadata);
1028  else
1029  /* parse special meta tag */
1030  extra_func->read(s, pbx, tlen, tag, extra_meta, isv34);
1031  } else if (!tag[0]) {
1032  if (tag[1])
1033  av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding\n");
1034  avio_skip(pb, tlen);
1035  break;
1036  }
1037  /* Skip to end of tag */
1038 seek:
1039  avio_seek(pb, next, SEEK_SET);
1040  }
1041 
1042  /* Footer preset, always 10 bytes, skip over it */
1043  if (version == 4 && flags & 0x10)
1044  end += 10;
1045 
1046 error:
1047  if (reason)
1048  av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n",
1049  version, reason);
1050  avio_seek(pb, end, SEEK_SET);
1051  av_free(buffer);
1052  av_free(uncompressed_buffer);
1053  return;
1054 }
1055 
1056 static void id3v2_read_internal(AVIOContext *pb, AVDictionary **metadata,
1057  AVFormatContext *s, const char *magic,
1058  ID3v2ExtraMeta **extra_meta, int64_t max_search_size)
1059 {
1060  int len, ret;
1062  int found_header;
1063  int64_t start, off;
1064 
1065  if (max_search_size && max_search_size < ID3v2_HEADER_SIZE)
1066  return;
1067 
1068  start = avio_tell(pb);
1069  do {
1070  /* save the current offset in case there's nothing to read/skip */
1071  off = avio_tell(pb);
1072  if (max_search_size && off - start >= max_search_size - ID3v2_HEADER_SIZE) {
1073  avio_seek(pb, off, SEEK_SET);
1074  break;
1075  }
1076 
1078  if (ret >= 0)
1079  ret = avio_read(pb, buf, ID3v2_HEADER_SIZE);
1080  if (ret != ID3v2_HEADER_SIZE) {
1081  avio_seek(pb, off, SEEK_SET);
1082  break;
1083  }
1084  found_header = ff_id3v2_match(buf, magic);
1085  if (found_header) {
1086  /* parse ID3v2 header */
1087  len = ((buf[6] & 0x7f) << 21) |
1088  ((buf[7] & 0x7f) << 14) |
1089  ((buf[8] & 0x7f) << 7) |
1090  (buf[9] & 0x7f);
1091  id3v2_parse(pb, metadata, s, len, buf[3], buf[5], extra_meta);
1092  } else {
1093  avio_seek(pb, off, SEEK_SET);
1094  }
1095  } while (found_header);
1096  ff_metadata_conv(metadata, NULL, ff_id3v2_34_metadata_conv);
1097  ff_metadata_conv(metadata, NULL, id3v2_2_metadata_conv);
1098  ff_metadata_conv(metadata, NULL, ff_id3v2_4_metadata_conv);
1099  merge_date(metadata);
1100 }
1101 
1103  const char *magic, ID3v2ExtraMeta **extra_meta)
1104 {
1105  id3v2_read_internal(pb, metadata, NULL, magic, extra_meta, 0);
1106 }
1107 
1108 void ff_id3v2_read(AVFormatContext *s, const char *magic,
1109  ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
1110 {
1111  id3v2_read_internal(s->pb, &s->metadata, s, magic, extra_meta, max_search_size);
1112 }
1113 
1115 {
1116  ID3v2ExtraMeta *current = *extra_meta, *next;
1117  const ID3v2EMFunc *extra_func;
1118 
1119  while (current) {
1120  if ((extra_func = get_extra_meta_func(current->tag, 1)))
1121  extra_func->free(&current->data);
1122  next = current->next;
1123  av_freep(&current);
1124  current = next;
1125  }
1126 
1127  *extra_meta = NULL;
1128 }
1129 
1131 {
1132  ID3v2ExtraMeta *cur;
1133 
1134  for (cur = extra_meta; cur; cur = cur->next) {
1135  ID3v2ExtraMetaAPIC *apic;
1136  AVStream *st;
1137 
1138  if (strcmp(cur->tag, "APIC"))
1139  continue;
1140  apic = &cur->data.apic;
1141 
1142  if (!(st = avformat_new_stream(s, NULL)))
1143  return AVERROR(ENOMEM);
1144 
1147  st->codecpar->codec_id = apic->id;
1148 
1149  if (AV_RB64(apic->buf->data) == PNGSIG)
1151 
1152  if (apic->description[0])
1153  av_dict_set(&st->metadata, "title", apic->description, 0);
1154 
1155  av_dict_set(&st->metadata, "comment", apic->type, 0);
1156 
1158  st->attached_pic.buf = apic->buf;
1159  st->attached_pic.data = apic->buf->data;
1161  st->attached_pic.stream_index = st->index;
1163 
1164  apic->buf = NULL;
1165  }
1166 
1167  return 0;
1168 }
1169 
1171 {
1172  int ret = 0;
1173  ID3v2ExtraMeta *cur;
1174  AVRational time_base = {1, 1000};
1175  ID3v2ExtraMetaCHAP **chapters = NULL;
1176  int num_chapters = 0;
1177  int i;
1178 
1179  // since extra_meta is a linked list where elements are prepended,
1180  // we need to reverse the order of chapters
1181  for (cur = extra_meta; cur; cur = cur->next) {
1182  ID3v2ExtraMetaCHAP *chap;
1183 
1184  if (strcmp(cur->tag, "CHAP"))
1185  continue;
1186  chap = &cur->data.chap;
1187 
1188  if ((ret = av_dynarray_add_nofree(&chapters, &num_chapters, chap)) < 0)
1189  goto end;
1190  }
1191 
1192  for (i = 0; i < (num_chapters / 2); i++) {
1193  ID3v2ExtraMetaCHAP *right;
1194  int right_index;
1195 
1196  right_index = (num_chapters - 1) - i;
1197  right = chapters[right_index];
1198 
1199  chapters[right_index] = chapters[i];
1200  chapters[i] = right;
1201  }
1202 
1203  for (i = 0; i < num_chapters; i++) {
1204  ID3v2ExtraMetaCHAP *chap;
1205  AVChapter *chapter;
1206 
1207  chap = chapters[i];
1208  chapter = avpriv_new_chapter(s, i, time_base, chap->start, chap->end, chap->element_id);
1209  if (!chapter)
1210  continue;
1211 
1212  if ((ret = av_dict_copy(&chapter->metadata, chap->meta, 0)) < 0)
1213  goto end;
1214  }
1215 
1216 end:
1217  av_freep(&chapters);
1218  return ret;
1219 }
1220 
1222 {
1223  ID3v2ExtraMeta *cur;
1225 
1226  for (cur = extra_meta; cur; cur = cur->next) {
1227  if (!strcmp(cur->tag, "PRIV")) {
1228  ID3v2ExtraMetaPRIV *priv = &cur->data.priv;
1229  AVBPrint bprint;
1230  char *escaped, *key;
1231  int i, ret;
1232 
1233  if ((key = av_asprintf(ID3v2_PRIV_METADATA_PREFIX "%s", priv->owner)) == NULL) {
1234  return AVERROR(ENOMEM);
1235  }
1236 
1237  av_bprint_init(&bprint, priv->datasize + 1, AV_BPRINT_SIZE_UNLIMITED);
1238 
1239  for (i = 0; i < priv->datasize; i++) {
1240  if (priv->data[i] < 32 || priv->data[i] > 126 || priv->data[i] == '\\') {
1241  av_bprintf(&bprint, "\\x%02x", priv->data[i]);
1242  } else {
1243  av_bprint_chars(&bprint, priv->data[i], 1);
1244  }
1245  }
1246 
1247  if ((ret = av_bprint_finalize(&bprint, &escaped)) < 0) {
1248  av_free(key);
1249  return ret;
1250  }
1251 
1252  if ((ret = av_dict_set(metadata, key, escaped, dict_flags)) < 0) {
1253  return ret;
1254  }
1255  }
1256  }
1257 
1258  return 0;
1259 }
1260 
1262 {
1263  return ff_id3v2_parse_priv_dict(&s->metadata, extra_meta);
1264 }
#define NULL
Definition: coverity.c:32
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1261
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
AVDictionary * meta
Definition: id3v2.h:81
version
Definition: libkvazaar.c:317
ID3v2ExtraMetaPRIV priv
Definition: id3v2.h:91
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1428
static int is_number(const char *str)
Definition: id3v2.c:520
static AVDictionaryEntry * get_date_tag(AVDictionary *m, const char *tag)
Definition: id3v2.c:527
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static const ID3v2EMFunc id3v2_extra_meta_funcs[]
Definition: id3v2.c:782
static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata, AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta)
Definition: id3v2.c:809
const char * tag3
Definition: id3v2.c:774
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
uint8_t * element_id
Definition: id3v2.h:79
uint32_t datasize
Definition: id3v2.h:58
int index
stream index in AVFormatContext
Definition: avformat.h:881
int size
Definition: packet.h:364
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:225
#define ID3v2_PRIV_METADATA_PREFIX
Definition: id3v2.h:42
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
static void read_apic(AVFormatContext *s, AVIOContext *pb, int taglen, const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
Definition: id3v2.c:582
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
static void free_apic(void *obj)
Definition: id3v2.c:568
const char ff_id3v2_4_tags[][4]
ID3v2.4-only text information frames.
Definition: id3v2.c:96
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define PUT_UTF8(val, tmp, PUT_BYTE)
Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
Definition: common.h:479
static void error(const char *err)
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:770
AVDictionary * metadata
Definition: avformat.h:1200
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1383
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
static int decode_str(AVFormatContext *s, AVIOContext *pb, int encoding, uint8_t **dst, int *maxread)
Decode characters to UTF-8 according to encoding type.
Definition: id3v2.c:242
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that&#39;s been allocated with av_malloc() or another memory allocation function...
Definition: dict.h:73
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4580
Format I/O context.
Definition: avformat.h:1239
char str[32]
Definition: internal.h:48
Public dictionary API.
static void id3v2_read_internal(AVIOContext *pb, AVDictionary **metadata, AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, int64_t max_search_size)
Definition: id3v2.c:1056
#define ID3v2_HEADER_SIZE
Definition: id3v2.h:30
const AVMetadataConv ff_id3v2_34_metadata_conv[]
Definition: id3v2.c:45
uint8_t
#define av_malloc(s)
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
static void read_priv(AVFormatContext *s, AVIOContext *pb, int taglen, const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
Definition: id3v2.c:738
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:91
uint32_t end
Definition: id3v2.h:80
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1170
uint8_t * description
Definition: id3v2.h:61
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static void finish(void)
Definition: movenc.c:345
uint8_t * data
Definition: packet.h:363
const char * type
Definition: id3v2.h:67
uint32_t tag
Definition: movenc.c:1597
enum AVCodecID id
Definition: internal.h:49
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:296
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
uint8_t * data
Definition: id3v2.h:62
void(* free)(void *obj)
Definition: id3v2.c:779
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static int is_tag(const char *buf, unsigned int len)
Definition: id3v2.c:186
#define GET_UTF16(val, GET_16BIT, ERROR)
Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:451
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
#define AV_BPRINT_SIZE_UNLIMITED
const AVMetadataConv ff_id3v2_4_metadata_conv[]
Definition: id3v2.c:64
union ID3v2ExtraMeta::@261 data
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
static void free_priv(void *obj)
Definition: id3v2.c:731
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:346
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1114
#define PNGSIG
Definition: png.h:47
static void read_comment(AVFormatContext *s, AVIOContext *pb, int taglen, AVDictionary **metadata)
Parse a comment tag.
Definition: id3v2.c:407
uint8_t * data
Definition: id3v2.h:74
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:123
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
static unsigned int size_to_syncsafe(unsigned int size)
Definition: id3v2.c:176
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
const CodecMime ff_id3v2_mime_tags[]
Definition: id3v2.c:131
#define b
Definition: input.c:41
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:778
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen, AVDictionary **metadata, const char *key)
Parse a text tag.
Definition: id3v2.c:319
uint32_t start
Definition: id3v2.h:80
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void free_geobtag(void *obj)
Free GEOB type extra metadata.
Definition: id3v2.c:221
static unsigned int get_size(AVIOContext *s, int len)
Definition: id3v2.c:168
static void read_geobtag(AVFormatContext *s, AVIOContext *pb, int taglen, const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
Parse GEOB tag into a ID3v2ExtraMetaGEOB struct.
Definition: id3v2.c:449
#define s(width, name)
Definition: cbs_vp9.c:257
#define ID3v2_FLAG_UNSYNCH
Definition: id3v2.h:38
AVDictionary * metadata
Definition: avformat.h:944
uint8_t * owner
Definition: id3v2.h:73
#define FF_ARRAY_ELEMS(a)
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:848
static void merge_date(AVDictionary **m)
Definition: id3v2.c:536
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1458
void(* read)(AVFormatContext *s, AVIOContext *pb, int taglen, const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
Definition: id3v2.c:776
Stream structure.
Definition: avformat.h:880
const char ff_id3v2_tags[][4]
A list of text information frames allowed in both ID3 v2.3 and v2.4 http://www.id3.org/id3v2.4.0-frames http://www.id3.org/id3v2.4.0-changes.
Definition: id3v2.c:88
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
struct ID3v2ExtraMeta * next
Definition: id3v2.h:86
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define ID3v2_FLAG_COMPRESSION
Definition: id3v2.h:40
enum AVCodecID id
Definition: id3v2.h:69
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
uint8_t * description
Definition: id3v2.h:68
ID3v2ExtraMetaAPIC apic
Definition: id3v2.h:88
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
Definition: id3v2.c:1130
ID3v2ExtraMetaCHAP chap
Definition: id3v2.h:89
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Undefined Behavior In the C language
Definition: undefined.txt:3
int ff_id3v2_parse_priv_dict(AVDictionary **metadata, ID3v2ExtraMeta *extra_meta)
Parse PRIV tags into a dictionary.
Definition: id3v2.c:1221
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define snprintf
Definition: snprintf.h:34
int size
Size of data in bytes.
Definition: buffer.h:93
static void read_uslt(AVFormatContext *s, AVIOContext *pb, int taglen, AVDictionary **metadata)
Definition: id3v2.c:358
#define SIZE_SPECIFIER
Definition: internal.h:229
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static int check_tag(AVIOContext *s, int offset, unsigned int len)
Return 1 if the tag of length len at the given offset is valid, 0 if not, -1 on error.
Definition: id3v2.c:204
static void rstrip_spaces(char *buf)
Definition: id3v2.c:575
static const ID3v2EMFunc * get_extra_meta_func(const char *tag, int isv34)
Get the corresponding ID3v2EMFunc struct for a tag.
Definition: id3v2.c:795
uint8_t * mime_type
Definition: id3v2.h:59
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1002
static void free_chapter(void *obj)
Definition: id3v2.c:670
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:738
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:91
int
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:143
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:88
const char * tag
Definition: id3v2.h:85
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
#define ID3v2_FLAG_ENCRYPTION
Definition: id3v2.h:39
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
const char * tag4
Definition: id3v2.c:775
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
Read an ID3v2 tag, including supported extra metadata.
Definition: id3v2.c:1108
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
const char ff_id3v2_3_tags[][4]
ID3v2.3-only text information frames.
Definition: id3v2.c:102
uint8_t * file_name
Definition: id3v2.h:60
ID3v2ExtraMetaGEOB geob
Definition: id3v2.h:90
#define av_free(p)
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1102
char * value
Definition: dict.h:87
int len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:156
AVBufferRef * buf
Definition: id3v2.h:66
uint32_t datasize
Definition: id3v2.h:75
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
const char *const ff_id3v2_picture_types[21]
Definition: id3v2.c:107
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:864
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:746
#define ID3v2_FLAG_DATALEN
Definition: id3v2.h:37
int stream_index
Definition: packet.h:365
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define ID3v1_GENRE_MAX
Definition: id3v1.h:29
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
Definition: id3v1.c:27
enum AVCodecID id
static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, const char *ttag, ID3v2ExtraMeta **extra_meta, int isv34)
Definition: id3v2.c:677
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:962
int i
Definition: input.c:407
GLuint buffer
Definition: opengl_enc.c:101
#define av_unused
Definition: attributes.h:131
static const AVMetadataConv id3v2_2_metadata_conv[]
Definition: id3v2.c:75
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140
static uint8_t tmp[11]
Definition: aes_ctr.c:26