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