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 = NULL;
365  char *key = NULL;
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  goto error;
392 
393  av_dict_set(metadata, key, text, 0);
394 
395  ok = 1;
396 error:
397  if (!ok)
398  av_log(s, AV_LOG_ERROR, "Error reading lyrics, skipped\n");
399  av_free(descriptor);
400  av_free(text);
401  av_free(key);
402 }
403 
404 /**
405  * Parse a comment tag.
406  */
407 static void read_comment(AVFormatContext *s, AVIOContext *pb, int taglen,
408  AVDictionary **metadata)
409 {
410  const char *key = "comment";
411  uint8_t *dst;
412  int encoding, dict_flags = AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL;
413  av_unused int language;
414 
415  if (taglen < 4)
416  return;
417 
418  encoding = avio_r8(pb);
419  language = avio_rl24(pb);
420  taglen -= 4;
421 
422  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
423  av_log(s, AV_LOG_ERROR, "Error reading comment frame, skipped\n");
424  return;
425  }
426 
427  if (dst && !*dst)
428  av_freep(&dst);
429 
430  if (dst) {
431  key = (const char *) dst;
432  dict_flags |= AV_DICT_DONT_STRDUP_KEY;
433  }
434 
435  if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {
436  av_log(s, AV_LOG_ERROR, "Error reading comment frame, skipped\n");
437  if (dict_flags & AV_DICT_DONT_STRDUP_KEY)
438  av_freep((void*)&key);
439  return;
440  }
441 
442  if (dst)
443  av_dict_set(metadata, key, (const char *) dst, dict_flags);
444 }
445 
446 /**
447  * Parse GEOB tag into a ID3v2ExtraMetaGEOB struct.
448  */
449 static void read_geobtag(AVFormatContext *s, AVIOContext *pb, int taglen,
450  const char *tag, ID3v2ExtraMeta **extra_meta,
451  int isv34)
452 {
453  ID3v2ExtraMetaGEOB *geob_data = NULL;
454  ID3v2ExtraMeta *new_extra = NULL;
455  char encoding;
456  unsigned int len;
457 
458  if (taglen < 1)
459  return;
460 
461  geob_data = av_mallocz(sizeof(ID3v2ExtraMetaGEOB));
462  if (!geob_data) {
463  av_log(s, AV_LOG_ERROR, "Failed to alloc %"SIZE_SPECIFIER" bytes\n",
464  sizeof(ID3v2ExtraMetaGEOB));
465  return;
466  }
467 
468  new_extra = av_mallocz(sizeof(ID3v2ExtraMeta));
469  if (!new_extra) {
470  av_log(s, AV_LOG_ERROR, "Failed to alloc %"SIZE_SPECIFIER" bytes\n",
471  sizeof(ID3v2ExtraMeta));
472  goto fail;
473  }
474 
475  /* read encoding type byte */
476  encoding = avio_r8(pb);
477  taglen--;
478 
479  /* read MIME type (always ISO-8859) */
480  if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &geob_data->mime_type,
481  &taglen) < 0 ||
482  taglen <= 0)
483  goto fail;
484 
485  /* read file name */
486  if (decode_str(s, pb, encoding, &geob_data->file_name, &taglen) < 0 ||
487  taglen <= 0)
488  goto fail;
489 
490  /* read content description */
491  if (decode_str(s, pb, encoding, &geob_data->description, &taglen) < 0 ||
492  taglen < 0)
493  goto fail;
494 
495  if (taglen) {
496  /* save encapsulated binary data */
497  geob_data->data = av_malloc(taglen);
498  if (!geob_data->data) {
499  av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", taglen);
500  goto fail;
501  }
502  if ((len = avio_read(pb, geob_data->data, taglen)) < taglen)
504  "Error reading GEOB frame, data truncated.\n");
505  geob_data->datasize = len;
506  } else {
507  geob_data->data = NULL;
508  geob_data->datasize = 0;
509  }
510 
511  /* add data to the list */
512  new_extra->tag = "GEOB";
513  new_extra->data = geob_data;
514  new_extra->next = *extra_meta;
515  *extra_meta = new_extra;
516 
517  return;
518 
519 fail:
520  av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", tag);
521  free_geobtag(geob_data);
522  av_free(new_extra);
523  return;
524 }
525 
526 static int is_number(const char *str)
527 {
528  while (*str >= '0' && *str <= '9')
529  str++;
530  return !*str;
531 }
532 
534 {
536  if ((t = av_dict_get(m, tag, NULL, AV_DICT_MATCH_CASE)) &&
537  strlen(t->value) == 4 && is_number(t->value))
538  return t;
539  return NULL;
540 }
541 
542 static void merge_date(AVDictionary **m)
543 {
545  char date[17] = { 0 }; // YYYY-MM-DD hh:mm
546 
547  if (!(t = get_date_tag(*m, "TYER")) &&
548  !(t = get_date_tag(*m, "TYE")))
549  return;
550  av_strlcpy(date, t->value, 5);
551  av_dict_set(m, "TYER", NULL, 0);
552  av_dict_set(m, "TYE", NULL, 0);
553 
554  if (!(t = get_date_tag(*m, "TDAT")) &&
555  !(t = get_date_tag(*m, "TDA")))
556  goto finish;
557  snprintf(date + 4, sizeof(date) - 4, "-%.2s-%.2s", t->value + 2, t->value);
558  av_dict_set(m, "TDAT", NULL, 0);
559  av_dict_set(m, "TDA", NULL, 0);
560 
561  if (!(t = get_date_tag(*m, "TIME")) &&
562  !(t = get_date_tag(*m, "TIM")))
563  goto finish;
564  snprintf(date + 10, sizeof(date) - 10,
565  " %.2s:%.2s", t->value, t->value + 2);
566  av_dict_set(m, "TIME", NULL, 0);
567  av_dict_set(m, "TIM", NULL, 0);
568 
569 finish:
570  if (date[0])
571  av_dict_set(m, "date", date, 0);
572 }
573 
574 static void free_apic(void *obj)
575 {
576  ID3v2ExtraMetaAPIC *apic = obj;
577  av_buffer_unref(&apic->buf);
578  av_freep(&apic->description);
579  av_freep(&apic);
580 }
581 
582 static void rstrip_spaces(char *buf)
583 {
584  size_t len = strlen(buf);
585  while (len > 0 && buf[len - 1] == ' ')
586  buf[--len] = 0;
587 }
588 
589 static void read_apic(AVFormatContext *s, AVIOContext *pb, int taglen,
590  const char *tag, ID3v2ExtraMeta **extra_meta,
591  int isv34)
592 {
593  int enc, pic_type;
594  char mimetype[64] = {0};
595  const CodecMime *mime = ff_id3v2_mime_tags;
596  enum AVCodecID id = AV_CODEC_ID_NONE;
597  ID3v2ExtraMetaAPIC *apic = NULL;
598  ID3v2ExtraMeta *new_extra = NULL;
599  int64_t end = avio_tell(pb) + taglen;
600 
601  if (taglen <= 4 || (!isv34 && taglen <= 6))
602  goto fail;
603 
604  new_extra = av_mallocz(sizeof(*new_extra));
605  apic = av_mallocz(sizeof(*apic));
606  if (!new_extra || !apic)
607  goto fail;
608 
609  enc = avio_r8(pb);
610  taglen--;
611 
612  /* mimetype */
613  if (isv34) {
614  taglen -= avio_get_str(pb, taglen, mimetype, sizeof(mimetype));
615  } else {
616  if (avio_read(pb, mimetype, 3) < 0)
617  goto fail;
618 
619  mimetype[3] = 0;
620  taglen -= 3;
621  }
622 
623  while (mime->id != AV_CODEC_ID_NONE) {
624  if (!av_strncasecmp(mime->str, mimetype, sizeof(mimetype))) {
625  id = mime->id;
626  break;
627  }
628  mime++;
629  }
630  if (id == AV_CODEC_ID_NONE) {
632  "Unknown attached picture mimetype: %s, skipping.\n", mimetype);
633  goto fail;
634  }
635  apic->id = id;
636 
637  /* picture type */
638  pic_type = avio_r8(pb);
639  taglen--;
640  if (pic_type < 0 || pic_type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {
641  av_log(s, AV_LOG_WARNING, "Unknown attached picture type %d.\n",
642  pic_type);
643  pic_type = 0;
644  }
645  apic->type = ff_id3v2_picture_types[pic_type];
646 
647  /* description and picture data */
648  if (decode_str(s, pb, enc, &apic->description, &taglen) < 0) {
649  av_log(s, AV_LOG_ERROR,
650  "Error decoding attached picture description.\n");
651  goto fail;
652  }
653 
655  if (!apic->buf || !taglen || avio_read(pb, apic->buf->data, taglen) != taglen)
656  goto fail;
657  memset(apic->buf->data + taglen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
658 
659  new_extra->tag = "APIC";
660  new_extra->data = apic;
661  new_extra->next = *extra_meta;
662  *extra_meta = new_extra;
663 
664  // The description must be unique, and some ID3v2 tag writers add spaces
665  // to write several APIC entries with the same description.
666  rstrip_spaces(apic->description);
667 
668  return;
669 
670 fail:
671  if (apic)
672  free_apic(apic);
673  av_freep(&new_extra);
674  avio_seek(pb, end, SEEK_SET);
675 }
676 
677 static void free_chapter(void *obj)
678 {
679  ID3v2ExtraMetaCHAP *chap = obj;
680  av_freep(&chap->element_id);
681  av_dict_free(&chap->meta);
682  av_freep(&chap);
683 }
684 
685 static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, const char *ttag, ID3v2ExtraMeta **extra_meta, int isv34)
686 {
687  int taglen;
688  char tag[5];
689  ID3v2ExtraMeta *new_extra = NULL;
690  ID3v2ExtraMetaCHAP *chap = NULL;
691 
692  new_extra = av_mallocz(sizeof(*new_extra));
693  chap = av_mallocz(sizeof(*chap));
694 
695  if (!new_extra || !chap)
696  goto fail;
697 
698  if (decode_str(s, pb, 0, &chap->element_id, &len) < 0)
699  goto fail;
700 
701  if (len < 16)
702  goto fail;
703 
704  chap->start = avio_rb32(pb);
705  chap->end = avio_rb32(pb);
706  avio_skip(pb, 8);
707 
708  len -= 16;
709  while (len > 10) {
710  if (avio_read(pb, tag, 4) < 4)
711  goto fail;
712  tag[4] = 0;
713  taglen = avio_rb32(pb);
714  avio_skip(pb, 2);
715  len -= 10;
716  if (taglen < 0 || taglen > len)
717  goto fail;
718  if (tag[0] == 'T')
719  read_ttag(s, pb, taglen, &chap->meta, tag);
720  else
721  avio_skip(pb, taglen);
722  len -= taglen;
723  }
724 
725  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_34_metadata_conv);
726  ff_metadata_conv(&chap->meta, NULL, ff_id3v2_4_metadata_conv);
727 
728  new_extra->tag = "CHAP";
729  new_extra->data = chap;
730  new_extra->next = *extra_meta;
731  *extra_meta = new_extra;
732 
733  return;
734 
735 fail:
736  if (chap)
737  free_chapter(chap);
738  av_freep(&new_extra);
739 }
740 
741 static void free_priv(void *obj)
742 {
743  ID3v2ExtraMetaPRIV *priv = obj;
744  av_freep(&priv->owner);
745  av_freep(&priv->data);
746  av_freep(&priv);
747 }
748 
749 static void read_priv(AVFormatContext *s, AVIOContext *pb, int taglen,
750  const char *tag, ID3v2ExtraMeta **extra_meta, int isv34)
751 {
752  ID3v2ExtraMeta *meta;
753  ID3v2ExtraMetaPRIV *priv;
754 
755  meta = av_mallocz(sizeof(*meta));
756  priv = av_mallocz(sizeof(*priv));
757 
758  if (!meta || !priv)
759  goto fail;
760 
761  if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &priv->owner, &taglen) < 0)
762  goto fail;
763 
764  priv->data = av_malloc(taglen);
765  if (!priv->data)
766  goto fail;
767 
768  priv->datasize = taglen;
769 
770  if (avio_read(pb, priv->data, priv->datasize) != priv->datasize)
771  goto fail;
772 
773  meta->tag = "PRIV";
774  meta->data = priv;
775  meta->next = *extra_meta;
776  *extra_meta = meta;
777 
778  return;
779 
780 fail:
781  if (priv)
782  free_priv(priv);
783  av_freep(&meta);
784 }
785 
786 typedef struct ID3v2EMFunc {
787  const char *tag3;
788  const char *tag4;
789  void (*read)(AVFormatContext *s, AVIOContext *pb, int taglen,
790  const char *tag, ID3v2ExtraMeta **extra_meta,
791  int isv34);
792  void (*free)(void *obj);
793 } ID3v2EMFunc;
794 
796  { "GEO", "GEOB", read_geobtag, free_geobtag },
797  { "PIC", "APIC", read_apic, free_apic },
798  { "CHAP","CHAP", read_chapter, free_chapter },
799  { "PRIV","PRIV", read_priv, free_priv },
800  { NULL }
801 };
802 
803 /**
804  * Get the corresponding ID3v2EMFunc struct for a tag.
805  * @param isv34 Determines if v2.2 or v2.3/4 strings are used
806  * @return A pointer to the ID3v2EMFunc struct if found, NULL otherwise.
807  */
808 static const ID3v2EMFunc *get_extra_meta_func(const char *tag, int isv34)
809 {
810  int i = 0;
811  while (id3v2_extra_meta_funcs[i].tag3) {
812  if (tag && !memcmp(tag,
813  (isv34 ? id3v2_extra_meta_funcs[i].tag4 :
814  id3v2_extra_meta_funcs[i].tag3),
815  (isv34 ? 4 : 3)))
816  return &id3v2_extra_meta_funcs[i];
817  i++;
818  }
819  return NULL;
820 }
821 
822 static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
824  uint8_t flags, ID3v2ExtraMeta **extra_meta)
825 {
826  int isv34, unsync;
827  unsigned tlen;
828  char tag[5];
829  int64_t next, end = avio_tell(pb) + len;
830  int taghdrlen;
831  const char *reason = NULL;
832  AVIOContext pb_local;
833  AVIOContext *pbx;
834  unsigned char *buffer = NULL;
835  int buffer_size = 0;
836  const ID3v2EMFunc *extra_func = NULL;
837  unsigned char *uncompressed_buffer = NULL;
838  av_unused int uncompressed_buffer_size = 0;
839  const char *comm_frame;
840 
841  av_log(s, AV_LOG_DEBUG, "id3v2 ver:%d flags:%02X len:%d\n", version, flags, len);
842 
843  switch (version) {
844  case 2:
845  if (flags & 0x40) {
846  reason = "compression";
847  goto error;
848  }
849  isv34 = 0;
850  taghdrlen = 6;
851  comm_frame = "COM";
852  break;
853 
854  case 3:
855  case 4:
856  isv34 = 1;
857  taghdrlen = 10;
858  comm_frame = "COMM";
859  break;
860 
861  default:
862  reason = "version";
863  goto error;
864  }
865 
866  unsync = flags & 0x80;
867 
868  if (isv34 && flags & 0x40) { /* Extended header present, just skip over it */
869  int extlen = get_size(pb, 4);
870  if (version == 4)
871  /* In v2.4 the length includes the length field we just read. */
872  extlen -= 4;
873 
874  if (extlen < 0) {
875  reason = "invalid extended header length";
876  goto error;
877  }
878  avio_skip(pb, extlen);
879  len -= extlen + 4;
880  if (len < 0) {
881  reason = "extended header too long.";
882  goto error;
883  }
884  }
885 
886  while (len >= taghdrlen) {
887  unsigned int tflags = 0;
888  int tunsync = 0;
889  int tcomp = 0;
890  int tencr = 0;
891  unsigned long av_unused dlen;
892 
893  if (isv34) {
894  if (avio_read(pb, tag, 4) < 4)
895  break;
896  tag[4] = 0;
897  if (version == 3) {
898  tlen = avio_rb32(pb);
899  } else {
900  /* some encoders incorrectly uses v3 sizes instead of syncsafe ones
901  * so check the next tag to see which one to use */
902  tlen = avio_rb32(pb);
903  if (tlen > 0x7f) {
904  if (tlen < len) {
905  int64_t cur = avio_tell(pb);
906 
907  if (ffio_ensure_seekback(pb, 2 /* tflags */ + tlen + 4 /* next tag */))
908  break;
909 
910  if (check_tag(pb, cur + 2 + size_to_syncsafe(tlen), 4) == 1)
911  tlen = size_to_syncsafe(tlen);
912  else if (check_tag(pb, cur + 2 + tlen, 4) != 1)
913  break;
914  avio_seek(pb, cur, SEEK_SET);
915  } else
916  tlen = size_to_syncsafe(tlen);
917  }
918  }
919  tflags = avio_rb16(pb);
920  tunsync = tflags & ID3v2_FLAG_UNSYNCH;
921  } else {
922  if (avio_read(pb, tag, 3) < 3)
923  break;
924  tag[3] = 0;
925  tlen = avio_rb24(pb);
926  }
927  if (tlen > (1<<28))
928  break;
929  len -= taghdrlen + tlen;
930 
931  if (len < 0)
932  break;
933 
934  next = avio_tell(pb) + tlen;
935 
936  if (!tlen) {
937  if (tag[0])
938  av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n",
939  tag);
940  continue;
941  }
942 
943  if (tflags & ID3v2_FLAG_DATALEN) {
944  if (tlen < 4)
945  break;
946  dlen = avio_rb32(pb);
947  tlen -= 4;
948  } else
949  dlen = tlen;
950 
951  tcomp = tflags & ID3v2_FLAG_COMPRESSION;
952  tencr = tflags & ID3v2_FLAG_ENCRYPTION;
953 
954  /* skip encrypted tags and, if no zlib, compressed tags */
955  if (tencr || (!CONFIG_ZLIB && tcomp)) {
956  const char *type;
957  if (!tcomp)
958  type = "encrypted";
959  else if (!tencr)
960  type = "compressed";
961  else
962  type = "encrypted and compressed";
963 
964  av_log(s, AV_LOG_WARNING, "Skipping %s ID3v2 frame %s.\n", type, tag);
965  avio_skip(pb, tlen);
966  /* check for text tag or supported special meta tag */
967  } else if (tag[0] == 'T' ||
968  !memcmp(tag, "USLT", 4) ||
969  !strcmp(tag, comm_frame) ||
970  (extra_meta &&
971  (extra_func = get_extra_meta_func(tag, isv34)))) {
972  pbx = pb;
973 
974  if (unsync || tunsync || tcomp) {
975  av_fast_malloc(&buffer, &buffer_size, tlen);
976  if (!buffer) {
977  av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);
978  goto seek;
979  }
980  }
981  if (unsync || tunsync) {
982  uint8_t *b = buffer;
983  uint8_t *t = buffer;
984  uint8_t *end = t + tlen;
985 
986  if (avio_read(pb, buffer, tlen) != tlen) {
987  av_log(s, AV_LOG_ERROR, "Failed to read tag data\n");
988  goto seek;
989  }
990 
991  while (t != end) {
992  *b++ = *t++;
993  if (t != end && t[-1] == 0xff && !t[0])
994  t++;
995  }
996 
997  ffio_init_context(&pb_local, buffer, b - buffer, 0, NULL, NULL, NULL,
998  NULL);
999  tlen = b - buffer;
1000  pbx = &pb_local; // read from sync buffer
1001  }
1002 
1003 #if CONFIG_ZLIB
1004  if (tcomp) {
1005  int err;
1006 
1007  av_log(s, AV_LOG_DEBUG, "Compresssed frame %s tlen=%d dlen=%ld\n", tag, tlen, dlen);
1008 
1009  av_fast_malloc(&uncompressed_buffer, &uncompressed_buffer_size, dlen);
1010  if (!uncompressed_buffer) {
1011  av_log(s, AV_LOG_ERROR, "Failed to alloc %ld bytes\n", dlen);
1012  goto seek;
1013  }
1014 
1015  if (!(unsync || tunsync)) {
1016  err = avio_read(pb, buffer, tlen);
1017  if (err < 0) {
1018  av_log(s, AV_LOG_ERROR, "Failed to read compressed tag\n");
1019  goto seek;
1020  }
1021  tlen = err;
1022  }
1023 
1024  err = uncompress(uncompressed_buffer, &dlen, buffer, tlen);
1025  if (err != Z_OK) {
1026  av_log(s, AV_LOG_ERROR, "Failed to uncompress tag: %d\n", err);
1027  goto seek;
1028  }
1029  ffio_init_context(&pb_local, uncompressed_buffer, dlen, 0, NULL, NULL, NULL, NULL);
1030  tlen = dlen;
1031  pbx = &pb_local; // read from sync buffer
1032  }
1033 #endif
1034  if (tag[0] == 'T')
1035  /* parse text tag */
1036  read_ttag(s, pbx, tlen, metadata, tag);
1037  else if (!memcmp(tag, "USLT", 4))
1038  read_uslt(s, pbx, tlen, metadata);
1039  else if (!strcmp(tag, comm_frame))
1040  read_comment(s, pbx, tlen, metadata);
1041  else
1042  /* parse special meta tag */
1043  extra_func->read(s, pbx, tlen, tag, extra_meta, isv34);
1044  } else if (!tag[0]) {
1045  if (tag[1])
1046  av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding\n");
1047  avio_skip(pb, tlen);
1048  break;
1049  }
1050  /* Skip to end of tag */
1051 seek:
1052  avio_seek(pb, next, SEEK_SET);
1053  }
1054 
1055  /* Footer preset, always 10 bytes, skip over it */
1056  if (version == 4 && flags & 0x10)
1057  end += 10;
1058 
1059 error:
1060  if (reason)
1061  av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n",
1062  version, reason);
1063  avio_seek(pb, end, SEEK_SET);
1064  av_free(buffer);
1065  av_free(uncompressed_buffer);
1066  return;
1067 }
1068 
1069 static void id3v2_read_internal(AVIOContext *pb, AVDictionary **metadata,
1070  AVFormatContext *s, const char *magic,
1071  ID3v2ExtraMeta **extra_meta, int64_t max_search_size)
1072 {
1073  int len, ret;
1075  int found_header;
1076  int64_t start, off;
1077 
1078  if (max_search_size && max_search_size < ID3v2_HEADER_SIZE)
1079  return;
1080 
1081  start = avio_tell(pb);
1082  do {
1083  /* save the current offset in case there's nothing to read/skip */
1084  off = avio_tell(pb);
1085  if (max_search_size && off - start >= max_search_size - ID3v2_HEADER_SIZE) {
1086  avio_seek(pb, off, SEEK_SET);
1087  break;
1088  }
1089 
1091  if (ret >= 0)
1092  ret = avio_read(pb, buf, ID3v2_HEADER_SIZE);
1093  if (ret != ID3v2_HEADER_SIZE) {
1094  avio_seek(pb, off, SEEK_SET);
1095  break;
1096  }
1097  found_header = ff_id3v2_match(buf, magic);
1098  if (found_header) {
1099  /* parse ID3v2 header */
1100  len = ((buf[6] & 0x7f) << 21) |
1101  ((buf[7] & 0x7f) << 14) |
1102  ((buf[8] & 0x7f) << 7) |
1103  (buf[9] & 0x7f);
1104  id3v2_parse(pb, metadata, s, len, buf[3], buf[5], extra_meta);
1105  } else {
1106  avio_seek(pb, off, SEEK_SET);
1107  }
1108  } while (found_header);
1109  ff_metadata_conv(metadata, NULL, ff_id3v2_34_metadata_conv);
1110  ff_metadata_conv(metadata, NULL, id3v2_2_metadata_conv);
1111  ff_metadata_conv(metadata, NULL, ff_id3v2_4_metadata_conv);
1112  merge_date(metadata);
1113 }
1114 
1116  const char *magic, ID3v2ExtraMeta **extra_meta)
1117 {
1118  id3v2_read_internal(pb, metadata, NULL, magic, extra_meta, 0);
1119 }
1120 
1121 void ff_id3v2_read(AVFormatContext *s, const char *magic,
1122  ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
1123 {
1124  id3v2_read_internal(s->pb, &s->metadata, s, magic, extra_meta, max_search_size);
1125 }
1126 
1128 {
1129  ID3v2ExtraMeta *current = *extra_meta, *next;
1130  const ID3v2EMFunc *extra_func;
1131 
1132  while (current) {
1133  if ((extra_func = get_extra_meta_func(current->tag, 1)))
1134  extra_func->free(current->data);
1135  next = current->next;
1136  av_freep(&current);
1137  current = next;
1138  }
1139 
1140  *extra_meta = NULL;
1141 }
1142 
1144 {
1145  ID3v2ExtraMeta *cur;
1146 
1147  for (cur = *extra_meta; cur; cur = cur->next) {
1148  ID3v2ExtraMetaAPIC *apic;
1149  AVStream *st;
1150 
1151  if (strcmp(cur->tag, "APIC"))
1152  continue;
1153  apic = cur->data;
1154 
1155  if (!(st = avformat_new_stream(s, NULL)))
1156  return AVERROR(ENOMEM);
1157 
1160  st->codecpar->codec_id = apic->id;
1161 
1162  if (AV_RB64(apic->buf->data) == PNGSIG)
1164 
1165  if (apic->description[0])
1166  av_dict_set(&st->metadata, "title", apic->description, 0);
1167 
1168  av_dict_set(&st->metadata, "comment", apic->type, 0);
1169 
1171  st->attached_pic.buf = apic->buf;
1172  st->attached_pic.data = apic->buf->data;
1174  st->attached_pic.stream_index = st->index;
1176 
1177  apic->buf = NULL;
1178  }
1179 
1180  return 0;
1181 }
1182 
1184 {
1185  int ret = 0;
1186  ID3v2ExtraMeta *cur;
1187  AVRational time_base = {1, 1000};
1188  ID3v2ExtraMetaCHAP **chapters = NULL;
1189  int num_chapters = 0;
1190  int i;
1191 
1192  // since extra_meta is a linked list where elements are prepended,
1193  // we need to reverse the order of chapters
1194  for (cur = *extra_meta; cur; cur = cur->next) {
1195  ID3v2ExtraMetaCHAP *chap;
1196 
1197  if (strcmp(cur->tag, "CHAP"))
1198  continue;
1199  chap = cur->data;
1200 
1201  if ((ret = av_dynarray_add_nofree(&chapters, &num_chapters, chap)) < 0)
1202  goto end;
1203  }
1204 
1205  for (i = 0; i < (num_chapters / 2); i++) {
1206  ID3v2ExtraMetaCHAP *right;
1207  int right_index;
1208 
1209  right_index = (num_chapters - 1) - i;
1210  right = chapters[right_index];
1211 
1212  chapters[right_index] = chapters[i];
1213  chapters[i] = right;
1214  }
1215 
1216  for (i = 0; i < num_chapters; i++) {
1217  ID3v2ExtraMetaCHAP *chap;
1218  AVChapter *chapter;
1219 
1220  chap = chapters[i];
1221  chapter = avpriv_new_chapter(s, i, time_base, chap->start, chap->end, chap->element_id);
1222  if (!chapter)
1223  continue;
1224 
1225  if ((ret = av_dict_copy(&chapter->metadata, chap->meta, 0)) < 0)
1226  goto end;
1227  }
1228 
1229 end:
1230  av_freep(&chapters);
1231  return ret;
1232 }
1233 
1235 {
1236  ID3v2ExtraMeta *cur;
1238 
1239  for (cur = *extra_meta; cur; cur = cur->next) {
1240  if (!strcmp(cur->tag, "PRIV")) {
1241  ID3v2ExtraMetaPRIV *priv = cur->data;
1242  AVBPrint bprint;
1243  char *escaped, *key;
1244  int i, ret;
1245 
1246  if ((key = av_asprintf(ID3v2_PRIV_METADATA_PREFIX "%s", priv->owner)) == NULL) {
1247  return AVERROR(ENOMEM);
1248  }
1249 
1250  av_bprint_init(&bprint, priv->datasize + 1, AV_BPRINT_SIZE_UNLIMITED);
1251 
1252  for (i = 0; i < priv->datasize; i++) {
1253  if (priv->data[i] < 32 || priv->data[i] > 126 || priv->data[i] == '\\') {
1254  av_bprintf(&bprint, "\\x%02x", priv->data[i]);
1255  } else {
1256  av_bprint_chars(&bprint, priv->data[i], 1);
1257  }
1258  }
1259 
1260  if ((ret = av_bprint_finalize(&bprint, &escaped)) < 0) {
1261  av_free(key);
1262  return ret;
1263  }
1264 
1265  if ((ret = av_dict_set(metadata, key, escaped, dict_flags)) < 0) {
1266  av_free(key);
1267  av_free(escaped);
1268  return ret;
1269  }
1270  }
1271  }
1272 
1273  return 0;
1274 }
1275 
1277 {
1278  return ff_id3v2_parse_priv_dict(&s->metadata, extra_meta);
1279 }
#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:526
static AVDictionaryEntry * get_date_tag(AVDictionary *m, const char *tag)
Definition: id3v2.c:533
#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:795
static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata, AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta)
Definition: id3v2.c:822
const char * tag3
Definition: id3v2.c:787
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:589
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:574
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:1143
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:1069
#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:1183
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:1234
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:749
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:792
#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:741
#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:1276
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:1127
#define PNGSIG
Definition: png.h:47
static void read_comment(AVFormatContext *s, AVIOContext *pb, int taglen, AVDictionary **metadata)
Parse a comment tag.
Definition: id3v2.c:407
uint8_t * data
Definition: id3v2.h: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:449
#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:542
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:789
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:582
static const ID3v2EMFunc * get_extra_meta_func(const char *tag, int isv34)
Get the corresponding ID3v2EMFunc struct for a tag.
Definition: id3v2.c:808
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:677
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:788
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:1121
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:1115
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:685
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