FFmpeg: libavformat/id3v2.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /