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

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