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  int ret = avio_get_str(pb, taglen, mimetype, sizeof(mimetype));
609  if (ret < 0 || ret >= taglen)
610  goto fail;
611  taglen -= ret;
612  } else {
613  if (avio_read(pb, mimetype, 3) < 0)
614  goto fail;
615 
616  mimetype[3] = 0;
617  taglen -= 3;
618  }
619 
620  while (mime->id != AV_CODEC_ID_NONE) {
621  if (!av_strncasecmp(mime->str, mimetype, sizeof(mimetype))) {
622  id = mime->id;
623  break;
624  }
625  mime++;
626  }
627  if (id == AV_CODEC_ID_NONE) {
629  "Unknown attached picture mimetype: %s, skipping.\n", mimetype);
630  goto fail;
631  }
632  apic->id = id;
633 
634  /* picture type */
635  pic_type = avio_r8(pb);
636  taglen--;
637  if (pic_type < 0 || pic_type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {
638  av_log(s, AV_LOG_WARNING, "Unknown attached picture type %d.\n",
639  pic_type);
640  pic_type = 0;
641  }
642  apic->type = ff_id3v2_picture_types[pic_type];
643 
644  /* description and picture data */
645  if (decode_str(s, pb, enc, &apic->description, &taglen) < 0) {
646  av_log(s, AV_LOG_ERROR,
647  "Error decoding attached picture description.\n");
648  goto fail;
649  }
650 
652  if (!apic->buf || !taglen || avio_read(pb, apic->buf->data, taglen) != taglen)
653  goto fail;
654  memset(apic->buf->data + taglen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
655 
656  new_extra->tag = "APIC";
657  new_extra->next = *extra_meta;
658  *extra_meta = new_extra;
659 
660  // The description must be unique, and some ID3v2 tag writers add spaces
661  // to write several APIC entries with the same description.
662  rstrip_spaces(apic->description);
663 
664  return;
665 
666 fail:
667  if (apic)
668  free_apic(apic);
669  av_freep(&new_extra);
670  avio_seek(pb, end, SEEK_SET);
671 }
672 
673 static void free_chapter(void *obj)
674 {
675  ID3v2ExtraMetaCHAP *chap = obj;
676  av_freep(&chap->element_id);
677  av_dict_free(&chap->meta);
678 }
679 
680 static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, const char *ttag, ID3v2ExtraMeta **extra_meta, int isv34)
681 {
682  int taglen;
683  char tag[5];
684  ID3v2ExtraMeta *new_extra = NULL;
685  ID3v2ExtraMetaCHAP *chap = NULL;
686 
687  new_extra = av_mallocz(sizeof(*new_extra));
688  if (!new_extra)
689  return;
690 
691  chap = &new_extra->data.chap;
692 
693  if (decode_str(s, pb, 0, &chap->element_id, &len) < 0)
694  goto fail;
695 
696  if (len < 16)
697  goto fail;
698 
699  chap->start = avio_rb32(pb);
700  chap->end = avio_rb32(pb);
701  avio_skip(pb, 8);
702 
703  len -= 16;
704  while (len > 10) {
705  if (avio_read(pb, tag, 4) < 4)
706  goto fail;
707  tag[4] = 0;
708  taglen = avio_rb32(pb);
709  avio_skip(pb, 2);
710  len -= 10;
711  if (taglen < 0 || taglen > len)
712  goto fail;
713  if (tag[0] == 'T')
714  read_ttag(s, pb, taglen, &chap->meta, tag);
715  else
716  avio_skip(pb, taglen);
717  len -= taglen;
718  }
719 
720  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_34_metadata_conv);
721  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_4_metadata_conv);
722 
723  new_extra->tag = "CHAP";
724  new_extra->next = *extra_meta;
725  *extra_meta = new_extra;
726 
727  return;
728 
729 fail:
730  free_chapter(chap);
731  av_freep(&new_extra);
732 }
733 
734 static void free_priv(void *obj)
735 {
736  ID3v2ExtraMetaPRIV *priv = obj;
737  av_freep(&priv->owner);
738  av_freep(&priv->data);
739 }
740 
741 static void read_priv(AVFormatContext *s, AVIOContext *pb, int taglen,
742  const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
743 {
744  ID3v2ExtraMeta *meta;
745  ID3v2ExtraMetaPRIV *priv;
746 
747  meta = av_mallocz(sizeof(*meta));
748  if (!meta)
749  return;
750 
751  priv = &meta->data.priv;
752 
753  if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &priv->owner, &taglen) < 0)
754  goto fail;
755 
756  priv->data = av_malloc(taglen);
757  if (!priv->data)
758  goto fail;
759 
760  priv->datasize = taglen;
761 
762  if (avio_read(pb, priv->data, priv->datasize) != priv->datasize)
763  goto fail;
764 
765  meta->tag = "PRIV";
766  meta->next = *extra_meta;
767  *extra_meta = meta;
768 
769  return;
770 
771 fail:
772  free_priv(priv);
773  av_freep(&meta);
774 }
775 
776 typedef struct ID3v2EMFunc {
777  const char *tag3;
778  const char *tag4;
779  void (*read)(AVFormatContext *s, AVIOContext *pb, int taglen,
780  const char *tag, ID3v2ExtraMeta **extra_meta,
781  int isv34);
782  void (*free)(void *obj);
783 } ID3v2EMFunc;
784 
786  { "GEO", "GEOB", read_geobtag, free_geobtag },
787  { "PIC", "APIC", read_apic, free_apic },
788  { "CHAP","CHAP", read_chapter, free_chapter },
789  { "PRIV","PRIV", read_priv, free_priv },
790  { NULL }
791 };
792 
793 /**
794  * Get the corresponding ID3v2EMFunc struct for a tag.
795  * @param isv34 Determines if v2.2 or v2.3/4 strings are used
796  * @return A pointer to the ID3v2EMFunc struct if found, NULL otherwise.
797  */
798 static const ID3v2EMFunc *get_extra_meta_func(const char *tag, int isv34)
799 {
800  int i = 0;
801  while (id3v2_extra_meta_funcs[i].tag3) {
802  if (tag && !memcmp(tag,
803  (isv34 ? id3v2_extra_meta_funcs[i].tag4 :
804  id3v2_extra_meta_funcs[i].tag3),
805  (isv34 ? 4 : 3)))
806  return &id3v2_extra_meta_funcs[i];
807  i++;
808  }
809  return NULL;
810 }
811 
812 static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
814  uint8_t flags, ID3v2ExtraMeta **extra_meta)
815 {
816  int isv34, unsync;
817  unsigned tlen;
818  char tag[5];
819  int64_t next, end = avio_tell(pb) + len;
820  int taghdrlen;
821  const char *reason = NULL;
822  AVIOContext pb_local;
823  AVIOContext *pbx;
824  unsigned char *buffer = NULL;
825  int buffer_size = 0;
826  const ID3v2EMFunc *extra_func = NULL;
827  unsigned char *uncompressed_buffer = NULL;
828  av_unused int uncompressed_buffer_size = 0;
829  const char *comm_frame;
830 
831  av_log(s, AV_LOG_DEBUG, "id3v2 ver:%d flags:%02X len:%d\n", version, flags, len);
832 
833  switch (version) {
834  case 2:
835  if (flags & 0x40) {
836  reason = "compression";
837  goto error;
838  }
839  isv34 = 0;
840  taghdrlen = 6;
841  comm_frame = "COM";
842  break;
843 
844  case 3:
845  case 4:
846  isv34 = 1;
847  taghdrlen = 10;
848  comm_frame = "COMM";
849  break;
850 
851  default:
852  reason = "version";
853  goto error;
854  }
855 
856  unsync = flags & 0x80;
857 
858  if (isv34 && flags & 0x40) { /* Extended header present, just skip over it */
859  int extlen = get_size(pb, 4);
860  if (version == 4)
861  /* In v2.4 the length includes the length field we just read. */
862  extlen -= 4;
863 
864  if (extlen < 0) {
865  reason = "invalid extended header length";
866  goto error;
867  }
868  avio_skip(pb, extlen);
869  len -= extlen + 4;
870  if (len < 0) {
871  reason = "extended header too long.";
872  goto error;
873  }
874  }
875 
876  while (len >= taghdrlen) {
877  unsigned int tflags = 0;
878  int tunsync = 0;
879  int tcomp = 0;
880  int tencr = 0;
881  unsigned long av_unused dlen;
882 
883  if (isv34) {
884  if (avio_read(pb, tag, 4) < 4)
885  break;
886  tag[4] = 0;
887  if (version == 3) {
888  tlen = avio_rb32(pb);
889  } else {
890  /* some encoders incorrectly uses v3 sizes instead of syncsafe ones
891  * so check the next tag to see which one to use */
892  tlen = avio_rb32(pb);
893  if (tlen > 0x7f) {
894  if (tlen < len) {
895  int64_t cur = avio_tell(pb);
896 
897  if (ffio_ensure_seekback(pb, 2 /* tflags */ + tlen + 4 /* next tag */))
898  break;
899 
900  if (check_tag(pb, cur + 2 + size_to_syncsafe(tlen), 4) == 1)
901  tlen = size_to_syncsafe(tlen);
902  else if (check_tag(pb, cur + 2 + tlen, 4) != 1)
903  break;
904  avio_seek(pb, cur, SEEK_SET);
905  } else
906  tlen = size_to_syncsafe(tlen);
907  }
908  }
909  tflags = avio_rb16(pb);
910  tunsync = tflags & ID3v2_FLAG_UNSYNCH;
911  } else {
912  if (avio_read(pb, tag, 3) < 3)
913  break;
914  tag[3] = 0;
915  tlen = avio_rb24(pb);
916  }
917  if (tlen > (1<<28))
918  break;
919  len -= taghdrlen + tlen;
920 
921  if (len < 0)
922  break;
923 
924  next = avio_tell(pb) + tlen;
925 
926  if (!tlen) {
927  if (tag[0])
928  av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n",
929  tag);
930  continue;
931  }
932 
933  if (tflags & ID3v2_FLAG_DATALEN) {
934  if (tlen < 4)
935  break;
936  dlen = avio_rb32(pb);
937  tlen -= 4;
938  } else
939  dlen = tlen;
940 
941  tcomp = tflags & ID3v2_FLAG_COMPRESSION;
942  tencr = tflags & ID3v2_FLAG_ENCRYPTION;
943 
944  /* skip encrypted tags and, if no zlib, compressed tags */
945  if (tencr || (!CONFIG_ZLIB && tcomp)) {
946  const char *type;
947  if (!tcomp)
948  type = "encrypted";
949  else if (!tencr)
950  type = "compressed";
951  else
952  type = "encrypted and compressed";
953 
954  av_log(s, AV_LOG_WARNING, "Skipping %s ID3v2 frame %s.\n", type, tag);
955  avio_skip(pb, tlen);
956  /* check for text tag or supported special meta tag */
957  } else if (tag[0] == 'T' ||
958  !memcmp(tag, "USLT", 4) ||
959  !strcmp(tag, comm_frame) ||
960  (extra_meta &&
961  (extra_func = get_extra_meta_func(tag, isv34)))) {
962  pbx = pb;
963 
964  if (unsync || tunsync || tcomp) {
965  av_fast_malloc(&buffer, &buffer_size, tlen);
966  if (!buffer) {
967  av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);
968  goto seek;
969  }
970  }
971  if (unsync || tunsync) {
972  uint8_t *b = buffer;
973  uint8_t *t = buffer;
974  uint8_t *end = t + tlen;
975 
976  if (avio_read(pb, buffer, tlen) != tlen) {
977  av_log(s, AV_LOG_ERROR, "Failed to read tag data\n");
978  goto seek;
979  }
980 
981  while (t != end) {
982  *b++ = *t++;
983  if (t != end && t[-1] == 0xff && !t[0])
984  t++;
985  }
986 
987  ffio_init_context(&pb_local, buffer, b - buffer, 0, NULL, NULL, NULL,
988  NULL);
989  tlen = b - buffer;
990  pbx = &pb_local; // read from sync buffer
991  }
992 
993 #if CONFIG_ZLIB
994  if (tcomp) {
995  int err;
996 
997  av_log(s, AV_LOG_DEBUG, "Compresssed frame %s tlen=%d dlen=%ld\n", tag, tlen, dlen);
998 
999  if (tlen <= 0)
1000  goto seek;
1001  if (dlen / 32768 > tlen)
1002  goto seek;
1003 
1004  av_fast_malloc(&uncompressed_buffer, &uncompressed_buffer_size, dlen);
1005  if (!uncompressed_buffer) {
1006  av_log(s, AV_LOG_ERROR, "Failed to alloc %ld bytes\n", dlen);
1007  goto seek;
1008  }
1009 
1010  if (!(unsync || tunsync)) {
1011  err = avio_read(pb, buffer, tlen);
1012  if (err < 0) {
1013  av_log(s, AV_LOG_ERROR, "Failed to read compressed tag\n");
1014  goto seek;
1015  }
1016  tlen = err;
1017  }
1018 
1019  err = uncompress(uncompressed_buffer, &dlen, buffer, tlen);
1020  if (err != Z_OK) {
1021  av_log(s, AV_LOG_ERROR, "Failed to uncompress tag: %d\n", err);
1022  goto seek;
1023  }
1024  ffio_init_context(&pb_local, uncompressed_buffer, dlen, 0, NULL, NULL, NULL, NULL);
1025  tlen = dlen;
1026  pbx = &pb_local; // read from sync buffer
1027  }
1028 #endif
1029  if (tag[0] == 'T')
1030  /* parse text tag */
1031  read_ttag(s, pbx, tlen, metadata, tag);
1032  else if (!memcmp(tag, "USLT", 4))
1033  read_uslt(s, pbx, tlen, metadata);
1034  else if (!strcmp(tag, comm_frame))
1035  read_comment(s, pbx, tlen, metadata);
1036  else
1037  /* parse special meta tag */
1038  extra_func->read(s, pbx, tlen, tag, extra_meta, isv34);
1039  } else if (!tag[0]) {
1040  if (tag[1])
1041  av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding\n");
1042  avio_skip(pb, tlen);
1043  break;
1044  }
1045  /* Skip to end of tag */
1046 seek:
1047  avio_seek(pb, next, SEEK_SET);
1048  }
1049 
1050  /* Footer preset, always 10 bytes, skip over it */
1051  if (version == 4 && flags & 0x10)
1052  end += 10;
1053 
1054 error:
1055  if (reason)
1056  av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n",
1057  version, reason);
1058  avio_seek(pb, end, SEEK_SET);
1059  av_free(buffer);
1060  av_free(uncompressed_buffer);
1061  return;
1062 }
1063 
1064 static void id3v2_read_internal(AVIOContext *pb, AVDictionary **metadata,
1065  AVFormatContext *s, const char *magic,
1066  ID3v2ExtraMeta **extra_meta, int64_t max_search_size)
1067 {
1068  int len, ret;
1070  int found_header;
1071  int64_t start, off;
1072 
1073  if (max_search_size && max_search_size < ID3v2_HEADER_SIZE)
1074  return;
1075 
1076  start = avio_tell(pb);
1077  do {
1078  /* save the current offset in case there's nothing to read/skip */
1079  off = avio_tell(pb);
1080  if (max_search_size && off - start >= max_search_size - ID3v2_HEADER_SIZE) {
1081  avio_seek(pb, off, SEEK_SET);
1082  break;
1083  }
1084 
1086  if (ret >= 0)
1087  ret = avio_read(pb, buf, ID3v2_HEADER_SIZE);
1088  if (ret != ID3v2_HEADER_SIZE) {
1089  avio_seek(pb, off, SEEK_SET);
1090  break;
1091  }
1092  found_header = ff_id3v2_match(buf, magic);
1093  if (found_header) {
1094  /* parse ID3v2 header */
1095  len = ((buf[6] & 0x7f) << 21) |
1096  ((buf[7] & 0x7f) << 14) |
1097  ((buf[8] & 0x7f) << 7) |
1098  (buf[9] & 0x7f);
1099  id3v2_parse(pb, metadata, s, len, buf[3], buf[5], extra_meta);
1100  } else {
1101  avio_seek(pb, off, SEEK_SET);
1102  }
1103  } while (found_header);
1104  ff_metadata_conv(metadata, NULL, ff_id3v2_34_metadata_conv);
1105  ff_metadata_conv(metadata, NULL, id3v2_2_metadata_conv);
1106  ff_metadata_conv(metadata, NULL, ff_id3v2_4_metadata_conv);
1107  merge_date(metadata);
1108 }
1109 
1111  const char *magic, ID3v2ExtraMeta **extra_meta)
1112 {
1113  id3v2_read_internal(pb, metadata, NULL, magic, extra_meta, 0);
1114 }
1115 
1116 void ff_id3v2_read(AVFormatContext *s, const char *magic,
1117  ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
1118 {
1119  id3v2_read_internal(s->pb, &s->metadata, s, magic, extra_meta, max_search_size);
1120 }
1121 
1123 {
1124  ID3v2ExtraMeta *current = *extra_meta, *next;
1125  const ID3v2EMFunc *extra_func;
1126 
1127  while (current) {
1128  if ((extra_func = get_extra_meta_func(current->tag, 1)))
1129  extra_func->free(&current->data);
1130  next = current->next;
1131  av_freep(&current);
1132  current = next;
1133  }
1134 
1135  *extra_meta = NULL;
1136 }
1137 
1139 {
1140  ID3v2ExtraMeta *cur;
1141 
1142  for (cur = extra_meta; cur; cur = cur->next) {
1143  ID3v2ExtraMetaAPIC *apic;
1144  AVStream *st;
1145 
1146  if (strcmp(cur->tag, "APIC"))
1147  continue;
1148  apic = &cur->data.apic;
1149 
1150  if (!(st = avformat_new_stream(s, NULL)))
1151  return AVERROR(ENOMEM);
1152 
1155  st->codecpar->codec_id = apic->id;
1156 
1157  if (AV_RB64(apic->buf->data) == PNGSIG)
1159 
1160  if (apic->description[0])
1161  av_dict_set(&st->metadata, "title", apic->description, 0);
1162 
1163  av_dict_set(&st->metadata, "comment", apic->type, 0);
1164 
1166  st->attached_pic.buf = apic->buf;
1167  st->attached_pic.data = apic->buf->data;
1169  st->attached_pic.stream_index = st->index;
1171 
1172  apic->buf = NULL;
1173  }
1174 
1175  return 0;
1176 }
1177 
1179 {
1180  int ret = 0;
1181  ID3v2ExtraMeta *cur;
1182  AVRational time_base = {1, 1000};
1183  ID3v2ExtraMetaCHAP **chapters = NULL;
1184  int num_chapters = 0;
1185  int i;
1186 
1187  // since extra_meta is a linked list where elements are prepended,
1188  // we need to reverse the order of chapters
1189  for (cur = extra_meta; cur; cur = cur->next) {
1190  ID3v2ExtraMetaCHAP *chap;
1191 
1192  if (strcmp(cur->tag, "CHAP"))
1193  continue;
1194  chap = &cur->data.chap;
1195 
1196  if ((ret = av_dynarray_add_nofree(&chapters, &num_chapters, chap)) < 0)
1197  goto end;
1198  }
1199 
1200  for (i = 0; i < (num_chapters / 2); i++) {
1201  ID3v2ExtraMetaCHAP *right;
1202  int right_index;
1203 
1204  right_index = (num_chapters - 1) - i;
1205  right = chapters[right_index];
1206 
1207  chapters[right_index] = chapters[i];
1208  chapters[i] = right;
1209  }
1210 
1211  for (i = 0; i < num_chapters; i++) {
1212  ID3v2ExtraMetaCHAP *chap;
1213  AVChapter *chapter;
1214 
1215  chap = chapters[i];
1216  chapter = avpriv_new_chapter(s, i, time_base, chap->start, chap->end, chap->element_id);
1217  if (!chapter)
1218  continue;
1219 
1220  if ((ret = av_dict_copy(&chapter->metadata, chap->meta, 0)) < 0)
1221  goto end;
1222  }
1223 
1224 end:
1225  av_freep(&chapters);
1226  return ret;
1227 }
1228 
1230 {
1231  ID3v2ExtraMeta *cur;
1233 
1234  for (cur = extra_meta; cur; cur = cur->next) {
1235  if (!strcmp(cur->tag, "PRIV")) {
1236  ID3v2ExtraMetaPRIV *priv = &cur->data.priv;
1237  AVBPrint bprint;
1238  char *escaped, *key;
1239  int i, ret;
1240 
1241  if ((key = av_asprintf(ID3v2_PRIV_METADATA_PREFIX "%s", priv->owner)) == NULL) {
1242  return AVERROR(ENOMEM);
1243  }
1244 
1245  av_bprint_init(&bprint, priv->datasize + 1, AV_BPRINT_SIZE_UNLIMITED);
1246 
1247  for (i = 0; i < priv->datasize; i++) {
1248  if (priv->data[i] < 32 || priv->data[i] > 126 || priv->data[i] == '\\') {
1249  av_bprintf(&bprint, "\\x%02x", priv->data[i]);
1250  } else {
1251  av_bprint_chars(&bprint, priv->data[i], 1);
1252  }
1253  }
1254 
1255  if ((ret = av_bprint_finalize(&bprint, &escaped)) < 0) {
1256  av_free(key);
1257  return ret;
1258  }
1259 
1260  if ((ret = av_dict_set(metadata, key, escaped, dict_flags)) < 0) {
1261  return ret;
1262  }
1263  }
1264  }
1265 
1266  return 0;
1267 }
1268 
1270 {
1271  return ff_id3v2_parse_priv_dict(&s->metadata, extra_meta);
1272 }
#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:1269
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:320
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:785
static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata, AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta)
Definition: id3v2.c:812
const char * tag3
Definition: id3v2.c:777
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:885
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
#define FF_ARRAY_ELEMS(a)
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:552
static void error(const char *err)
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:770
AVDictionary * metadata
Definition: avformat.h:1204
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:4606
Format I/O context.
Definition: avformat.h:1243
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:1064
#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
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4481
static void read_priv(AVFormatContext *s, AVIOContext *pb, int taglen, const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
Definition: id3v2.c:741
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:1178
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:782
#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:524
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:1483
#define AV_BPRINT_SIZE_UNLIMITED
const AVMetadataConv ff_id3v2_4_metadata_conv[]
Definition: id3v2.c:64
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:734
#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:1122
#define PNGSIG
Definition: png.h:49
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:133
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
union ID3v2ExtraMeta::@258 data
#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:948
uint8_t * owner
Definition: id3v2.h:73
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:852
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:779
Stream structure.
Definition: avformat.h:884
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:1285
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:1138
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:1229
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:191
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:798
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:673
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:937
#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:778
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:1116
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:1110
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:1049
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:680
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:966
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:27