FFmpeg: libavformat/id3v2.c Source File

FFmpeg

[フレーム]

libavformat

id3v2.c

Go to the documentation of this file.

1 /*

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 */

21 /**

22 * @file

23 * ID3v2 header parser

24 *

25 * Specifications available at:

26 * http://id3.org/Developer_Information

27 */

29 #include "config.h"

31 #if CONFIG_ZLIB

32 #include <zlib.h>

33 #endif

35 #include "libavutil/avstring.h"

36 #include "libavutil/dict.h"

37 #include "libavutil/intreadwrite.h"

38 #include "avio_internal.h"

39 #include "internal.h"

40 #include "id3v1.h"

41 #include "id3v2.h"

43 const AVMetadataConv ff_id3v2_34_metadata_conv[] = {

44 { "TALB", "album" },

45 { "TCOM", "composer" },

46 { "TCON", "genre" },

47 { "TCOP", "copyright" },

48 { "TENC", "encoded_by" },

49 { "TIT2", "title" },

50 { "TLAN", "language" },

51 { "TPE1", "artist" },

52 { "TPE2", "album_artist" },

53 { "TPE3", "performer" },

54 { "TPOS", "disc" },

55 { "TPUB", "publisher" },

56 { "TRCK", "track" },

57 { "TSSE", "encoder" },

58 { 0 }

59 };

61 const AVMetadataConv ff_id3v2_4_metadata_conv[] = {

62 { "TDRL", "date" },

63 { "TDRC", "date" },

64 { "TDEN", "creation_time" },

65 { "TSOA", "album-sort" },

66 { "TSOP", "artist-sort" },

67 { "TSOT", "title-sort" },

68 { 0 }

69 };

71 static const AVMetadataConv id3v2_2_metadata_conv[] = {

72 { "TAL", "album" },

73 { "TCO", "genre" },

74 { "TT2", "title" },

75 { "TEN", "encoded_by" },

76 { "TP1", "artist" },

77 { "TP2", "album_artist" },

78 { "TP3", "performer" },

79 { "TRK", "track" },

80 { 0 }

81 };

83 const char ff_id3v2_tags[][4] = {

84 "TALB", "TBPM", "TCOM", "TCON", "TCOP", "TDLY", "TENC", "TEXT",

85 "TFLT", "TIT1", "TIT2", "TIT3", "TKEY", "TLAN", "TLEN", "TMED",

86 "TOAL", "TOFN", "TOLY", "TOPE", "TOWN", "TPE1", "TPE2", "TPE3",

87 "TPE4", "TPOS", "TPUB", "TRCK", "TRSN", "TRSO", "TSRC", "TSSE",

88 { 0 },

89 };

91 const char ff_id3v2_4_tags[][4] = {

92 "TDEN", "TDOR", "TDRC", "TDRL", "TDTG", "TIPL", "TMCL", "TMOO",

93 "TPRO", "TSOA", "TSOP", "TSOT", "TSST",

94 { 0 },

95 };

97 const char ff_id3v2_3_tags[][4] = {

98 "TDAT", "TIME", "TORY", "TRDA", "TSIZ", "TYER",

99 { 0 },

100 };

101

102 const char *ff_id3v2_picture_types[21] = {

103 "Other",

104 "32x32 pixels 'file icon'",

105 "Other file icon",

106 "Cover (front)",

107 "Cover (back)",

108 "Leaflet page",

109 "Media (e.g. label side of CD)",

110 "Lead artist/lead performer/soloist",

111 "Artist/performer",

112 "Conductor",

113 "Band/Orchestra",

114 "Composer",

115 "Lyricist/text writer",

116 "Recording Location",

117 "During recording",

118 "During performance",

119 "Movie/video screen capture",

120 "A bright coloured fish",

121 "Illustration",

122 "Band/artist logotype",

123 "Publisher/Studio logotype",

124 };

125

126 const CodecMime ff_id3v2_mime_tags[] = {

127 { "image/gif", AV_CODEC_ID_GIF },

128 { "image/jpeg", AV_CODEC_ID_MJPEG },

129 { "image/jpg", AV_CODEC_ID_MJPEG },

130 { "image/png", AV_CODEC_ID_PNG },

131 { "image/tiff", AV_CODEC_ID_TIFF },

132 { "image/bmp", AV_CODEC_ID_BMP },

133 { "JPG", AV_CODEC_ID_MJPEG }, /* ID3v2.2 */

134 { "PNG", AV_CODEC_ID_PNG }, /* ID3v2.2 */

135 { "", AV_CODEC_ID_NONE },

136 };

137

138 int ff_id3v2_match(const uint8_t *buf, const char *magic)

139 {

140 return buf[0] == magic[0] &&

141 buf[1] == magic[1] &&

142 buf[2] == magic[2] &&

143 buf[3] != 0xff &&

144 buf[4] != 0xff &&

145 (buf[6] & 0x80) == 0 &&

146 (buf[7] & 0x80) == 0 &&

147 (buf[8] & 0x80) == 0 &&

148 (buf[9] & 0x80) == 0;

149 }

150

151 int ff_id3v2_tag_len(const uint8_t *buf)

152 {

153 int len = ((buf[6] & 0x7f) << 21) +

154 ((buf[7] & 0x7f) << 14) +

155 ((buf[8] & 0x7f) << 7) +

156 (buf[9] & 0x7f) +

157 ID3v2_HEADER_SIZE;

158 if (buf[5] & 0x10)

159 len += ID3v2_HEADER_SIZE;

160 return len;

161 }

162

163 static unsigned int get_size(AVIOContext *s, int len)

164 {

165 int v = 0;

166 while (len--)

167 v = (v << 7) + (avio_r8(s) & 0x7F);

168 return v;

169 }

170

171 /**

172 * Free GEOB type extra metadata.

173 */

174 static void free_geobtag(void *obj)

175 {

176 ID3v2ExtraMetaGEOB *geob = obj;

177 av_free(geob->mime_type);

178 av_free(geob->file_name);

179 av_free(geob->description);

180 av_free(geob->data);

181 av_free(geob);

182 }

183

184 /**

185 * Decode characters to UTF-8 according to encoding type. The decoded buffer is

186 * always null terminated. Stop reading when either *maxread bytes are read from

187 * pb or U+0000 character is found.

188 *

189 * @param dst Pointer where the address of the buffer with the decoded bytes is

190 * stored. Buffer must be freed by caller.

191 * @param maxread Pointer to maximum number of characters to read from the

192 * AVIOContext. After execution the value is decremented by the number of bytes

193 * actually read.

194 * @returns 0 if no error occurred, dst is uninitialized on error

195 */

196 static int decode_str(AVFormatContext *s, AVIOContext *pb, int encoding,

197 uint8_t **dst, int *maxread)

198 {

199 int ret;

200 uint8_t tmp;

201 uint32_t ch = 1;

202 int left = *maxread;

203 unsigned int (*get)(AVIOContext*) = avio_rb16;

204 AVIOContext *dynbuf;

205

206 if ((ret = avio_open_dyn_buf(&dynbuf)) < 0) {

207 av_log(s, AV_LOG_ERROR, "Error opening memory stream\n");

208 return ret;

209 }

210

211 switch (encoding) {

212 case ID3v2_ENCODING_ISO8859:

213 while (left && ch) {

214 ch = avio_r8(pb);

215 PUT_UTF8(ch, tmp, avio_w8(dynbuf, tmp);)

216 left--;

217 }

218 break;

219

220 case ID3v2_ENCODING_UTF16BOM:

221 if ((left -= 2) < 0) {

222 av_log(s, AV_LOG_ERROR, "Cannot read BOM value, input too short\n");

223 avio_close_dyn_buf(dynbuf, dst);

224 av_freep(dst);

225 return AVERROR_INVALIDDATA;

226 }

227 switch (avio_rb16(pb)) {

228 case 0xfffe:

229 get = avio_rl16;

230 case 0xfeff:

231 break;

232 default:

233 av_log(s, AV_LOG_ERROR, "Incorrect BOM value\n");

234 avio_close_dyn_buf(dynbuf, dst);

235 av_freep(dst);

236 *maxread = left;

237 return AVERROR_INVALIDDATA;

238 }

239 // fall-through

240

241 case ID3v2_ENCODING_UTF16BE:

242 while ((left > 1) && ch) {

243 GET_UTF16(ch, ((left -= 2) >= 0 ? get(pb) : 0), break;)

244 PUT_UTF8(ch, tmp, avio_w8(dynbuf, tmp);)

245 }

246 if (left < 0)

247 left += 2; /* did not read last char from pb */

248 break;

249

250 case ID3v2_ENCODING_UTF8:

251 while (left && ch) {

252 ch = avio_r8(pb);

253 avio_w8(dynbuf, ch);

254 left--;

255 }

256 break;

257 default:

258 av_log(s, AV_LOG_WARNING, "Unknown encoding\n");

259 }

260

261 if (ch)

262 avio_w8(dynbuf, 0);

263

264 avio_close_dyn_buf(dynbuf, dst);

265 *maxread = left;

266

267 return 0;

268 }

269

270 /**

271 * Parse a text tag.

272 */

273 static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen,

274 AVDictionary **metadata, const char *key)

275 {

276 uint8_t *dst;

277 int encoding, dict_flags = AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL;

278 unsigned genre;

279

280 if (taglen < 1)

281 return;

282

283 encoding = avio_r8(pb);

284 taglen--; /* account for encoding type byte */

285

286 if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {

287 av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", key);

288 return;

289 }

290

291 if (!(strcmp(key, "TCON") && strcmp(key, "TCO")) &&

292 (sscanf(dst, "(%d)", &genre) == 1 || sscanf(dst, "%d", &genre) == 1) &&

293 genre <= ID3v1_GENRE_MAX) {

294 av_freep(&dst);

295 dst = av_strdup(ff_id3v1_genre_str[genre]);

296 } else if (!(strcmp(key, "TXXX") && strcmp(key, "TXX"))) {

297 /* dst now contains the key, need to get value */

298 key = dst;

299 if (decode_str(s, pb, encoding, &dst, &taglen) < 0) {

300 av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", key);

301 av_freep(&key);

302 return;

303 }

304 dict_flags |= AV_DICT_DONT_STRDUP_KEY;

305 } else if (!*dst)

306 av_freep(&dst);

307

308 if (dst)

309 av_dict_set(metadata, key, dst, dict_flags);

310 }

311

312 /**

313 * Parse GEOB tag into a ID3v2ExtraMetaGEOB struct.

314 */

315 static void read_geobtag(AVFormatContext *s, AVIOContext *pb, int taglen,

316 char *tag, ID3v2ExtraMeta **extra_meta)

317 {

318 ID3v2ExtraMetaGEOB *geob_data = NULL;

319 ID3v2ExtraMeta *new_extra = NULL;

320 char encoding;

321 unsigned int len;

322

323 if (taglen < 1)

324 return;

325

326 geob_data = av_mallocz(sizeof(ID3v2ExtraMetaGEOB));

327 if (!geob_data) {

328 av_log(s, AV_LOG_ERROR, "Failed to alloc %zu bytes\n",

329 sizeof(ID3v2ExtraMetaGEOB));

330 return;

331 }

332

333 new_extra = av_mallocz(sizeof(ID3v2ExtraMeta));

334 if (!new_extra) {

335 av_log(s, AV_LOG_ERROR, "Failed to alloc %zu bytes\n",

336 sizeof(ID3v2ExtraMeta));

337 goto fail;

338 }

339

340 /* read encoding type byte */

341 encoding = avio_r8(pb);

342 taglen--;

343

344 /* read MIME type (always ISO-8859) */

345 if (decode_str(s, pb, ID3v2_ENCODING_ISO8859, &geob_data->mime_type,

346 &taglen) < 0 ||

347 taglen <= 0)

348 goto fail;

349

350 /* read file name */

351 if (decode_str(s, pb, encoding, &geob_data->file_name, &taglen) < 0 ||

352 taglen <= 0)

353 goto fail;

354

355 /* read content description */

356 if (decode_str(s, pb, encoding, &geob_data->description, &taglen) < 0 ||

357 taglen < 0)

358 goto fail;

359

360 if (taglen) {

361 /* save encapsulated binary data */

362 geob_data->data = av_malloc(taglen);

363 if (!geob_data->data) {

364 av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", taglen);

365 goto fail;

366 }

367 if ((len = avio_read(pb, geob_data->data, taglen)) < taglen)

368 av_log(s, AV_LOG_WARNING,

369 "Error reading GEOB frame, data truncated.\n");

370 geob_data->datasize = len;

371 } else {

372 geob_data->data = NULL;

373 geob_data->datasize = 0;

374 }

375

376 /* add data to the list */

377 new_extra->tag = "GEOB";

378 new_extra->data = geob_data;

379 new_extra->next = *extra_meta;

380 *extra_meta = new_extra;

381

382 return;

383

384 fail:

385 av_log(s, AV_LOG_ERROR, "Error reading frame %s, skipped\n", tag);

386 free_geobtag(geob_data);

387 av_free(new_extra);

388 return;

389 }

390

391 static int is_number(const char *str)

392 {

393 while (*str >= '0' && *str <= '9')

394 str++;

395 return !*str;

396 }

397

398 static AVDictionaryEntry *get_date_tag(AVDictionary *m, const char *tag)

399 {

400 AVDictionaryEntry *t;

401 if ((t = av_dict_get(m, tag, NULL, AV_DICT_MATCH_CASE)) &&

402 strlen(t->value) == 4 && is_number(t->value))

403 return t;

404 return NULL;

405 }

406

407 static void merge_date(AVDictionary **m)

408 {

409 AVDictionaryEntry *t;

410 char date[17] = { 0 }; // YYYY-MM-DD hh:mm

411

412 if (!(t = get_date_tag(*m, "TYER")) &&

413 !(t = get_date_tag(*m, "TYE")))

414 return;

415 av_strlcpy(date, t->value, 5);

416 av_dict_set(m, "TYER", NULL, 0);

417 av_dict_set(m, "TYE", NULL, 0);

418

419 if (!(t = get_date_tag(*m, "TDAT")) &&

420 !(t = get_date_tag(*m, "TDA")))

421 goto finish;

422 snprintf(date + 4, sizeof(date) - 4, "-%.2s-%.2s", t->value + 2, t->value);

423 av_dict_set(m, "TDAT", NULL, 0);

424 av_dict_set(m, "TDA", NULL, 0);

425

426 if (!(t = get_date_tag(*m, "TIME")) &&

427 !(t = get_date_tag(*m, "TIM")))

428 goto finish;

429 snprintf(date + 10, sizeof(date) - 10,

430 " %.2s:%.2s", t->value, t->value + 2);

431 av_dict_set(m, "TIME", NULL, 0);

432 av_dict_set(m, "TIM", NULL, 0);

433

434 finish:

435 if (date[0])

436 av_dict_set(m, "date", date, 0);

437 }

438

439 static void free_apic(void *obj)

440 {

441 ID3v2ExtraMetaAPIC *apic = obj;

442 av_buffer_unref(&apic->buf);

443 av_freep(&apic->description);

444 av_freep(&apic);

445 }

446

447 static void read_apic(AVFormatContext *s, AVIOContext *pb, int taglen,

448 char *tag, ID3v2ExtraMeta **extra_meta)

449 {

450 int enc, pic_type;

451 char mimetype[64];

452 const CodecMime *mime = ff_id3v2_mime_tags;

453 enum AVCodecID id = AV_CODEC_ID_NONE;

454 ID3v2ExtraMetaAPIC *apic = NULL;

455 ID3v2ExtraMeta *new_extra = NULL;

456 int64_t end = avio_tell(pb) + taglen;

457

458 if (taglen <= 4)

459 goto fail;

460

461 new_extra = av_mallocz(sizeof(*new_extra));

462 apic = av_mallocz(sizeof(*apic));

463 if (!new_extra || !apic)

464 goto fail;

465

466 enc = avio_r8(pb);

467 taglen--;

468

469 /* mimetype */

470 taglen -= avio_get_str(pb, taglen, mimetype, sizeof(mimetype));

471 while (mime->id != AV_CODEC_ID_NONE) {

472 if (!av_strncasecmp(mime->str, mimetype, sizeof(mimetype))) {

473 id = mime->id;

474 break;

475 }

476 mime++;

477 }

478 if (id == AV_CODEC_ID_NONE) {

479 av_log(s, AV_LOG_WARNING,

480 "Unknown attached picture mimetype: %s, skipping.\n", mimetype);

481 goto fail;

482 }

483 apic->id = id;

484

485 /* picture type */

486 pic_type = avio_r8(pb);

487 taglen--;

488 if (pic_type < 0 || pic_type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {

489 av_log(s, AV_LOG_WARNING, "Unknown attached picture type %d.\n",

490 pic_type);

491 pic_type = 0;

492 }

493 apic->type = ff_id3v2_picture_types[pic_type];

494

495 /* description and picture data */

496 if (decode_str(s, pb, enc, &apic->description, &taglen) < 0) {

497 av_log(s, AV_LOG_ERROR,

498 "Error decoding attached picture description.\n");

499 goto fail;

500 }

501

502 apic->buf = av_buffer_alloc(taglen + FF_INPUT_BUFFER_PADDING_SIZE);

503 if (!apic->buf || !taglen || avio_read(pb, apic->buf->data, taglen) != taglen)

504 goto fail;

505 memset(apic->buf->data + taglen, 0, FF_INPUT_BUFFER_PADDING_SIZE);

506

507 new_extra->tag = "APIC";

508 new_extra->data = apic;

509 new_extra->next = *extra_meta;

510 *extra_meta = new_extra;

511

512 return;

513

514 fail:

515 if (apic)

516 free_apic(apic);

517 av_freep(&new_extra);

518 avio_seek(pb, end, SEEK_SET);

519 }

520

521 static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, char *ttag, ID3v2ExtraMeta **extra_meta)

522 {

523 AVRational time_base = {1, 1000};

524 uint32_t start, end;

525 AVChapter *chapter;

526 uint8_t *dst = NULL;

527 int taglen;

528 char tag[5];

529

530 if (decode_str(s, pb, 0, &dst, &len) < 0)

531 return;

532 if (len < 16)

533 return;

534

535 start = avio_rb32(pb);

536 end = avio_rb32(pb);

537 avio_skip(pb, 8);

538

539 chapter = avpriv_new_chapter(s, s->nb_chapters + 1, time_base, start, end, dst);

540 if (!chapter) {

541 av_free(dst);

542 return;

543 }

544

545 len -= 16;

546 while (len > 10) {

547 avio_read(pb, tag, 4);

548 tag[4] = 0;

549 taglen = avio_rb32(pb);

550 avio_skip(pb, 2);

551 len -= 10;

552 if (taglen < 0 || taglen > len) {

553 av_free(dst);

554 return;

555 }

556 if (tag[0] == 'T')

557 read_ttag(s, pb, taglen, &chapter->metadata, tag);

558 else

559 avio_skip(pb, taglen);

560 len -= taglen;

561 }

562

563 ff_metadata_conv(&chapter->metadata, NULL, ff_id3v2_34_metadata_conv);

564 ff_metadata_conv(&chapter->metadata, NULL, ff_id3v2_4_metadata_conv);

565 av_free(dst);

566 }

567

568 typedef struct ID3v2EMFunc {

569 const char *tag3;

570 const char *tag4;

571 void (*read)(AVFormatContext *, AVIOContext *, int, char *,

572 ID3v2ExtraMeta **);

573 void (*free)(void *obj);

574 } ID3v2EMFunc;

575

576 static const ID3v2EMFunc id3v2_extra_meta_funcs[] = {

577 { "GEO", "GEOB", read_geobtag, free_geobtag },

578 { "PIC", "APIC", read_apic, free_apic },

579 { "CHAP","CHAP", read_chapter, NULL },

580 { NULL }

581 };

582

583 /**

584 * Get the corresponding ID3v2EMFunc struct for a tag.

585 * @param isv34 Determines if v2.2 or v2.3/4 strings are used

586 * @return A pointer to the ID3v2EMFunc struct if found, NULL otherwise.

587 */

588 static const ID3v2EMFunc *get_extra_meta_func(const char *tag, int isv34)

589 {

590 int i = 0;

591 while (id3v2_extra_meta_funcs[i].tag3) {

592 if (tag && !memcmp(tag,

593 (isv34 ? id3v2_extra_meta_funcs[i].tag4 :

594 id3v2_extra_meta_funcs[i].tag3),

595 (isv34 ? 4 : 3)))

596 return &id3v2_extra_meta_funcs[i];

597 i++;

598 }

599 return NULL;

600 }

601

602 static void id3v2_parse(AVFormatContext *s, int len, uint8_t version,

603 uint8_t flags, ID3v2ExtraMeta **extra_meta)

604 {

605 int isv34, unsync;

606 unsigned tlen;

607 char tag[5];

608 int64_t next, end = avio_tell(s->pb) + len;

609 int taghdrlen;

610 const char *reason = NULL;

611 AVIOContext pb;

612 AVIOContext *pbx;

613 unsigned char *buffer = NULL;

614 int buffer_size = 0;

615 const ID3v2EMFunc *extra_func = NULL;

616 unsigned char *uncompressed_buffer = NULL;

617 int uncompressed_buffer_size = 0;

618

619 av_log(s, AV_LOG_DEBUG, "id3v2 ver:%d flags:%02X len:%d\n", version, flags, len);

620

621 switch (version) {

622 case 2:

623 if (flags & 0x40) {

624 reason = "compression";

625 goto error;

626 }

627 isv34 = 0;

628 taghdrlen = 6;

629 break;

630

631 case 3:

632 case 4:

633 isv34 = 1;

634 taghdrlen = 10;

635 break;

636

637 default:

638 reason = "version";

639 goto error;

640 }

641

642 unsync = flags & 0x80;

643

644 if (isv34 && flags & 0x40) { /* Extended header present, just skip over it */

645 int extlen = get_size(s->pb, 4);

646 if (version == 4)

647 /* In v2.4 the length includes the length field we just read. */

648 extlen -= 4;

649

650 if (extlen < 0) {

651 reason = "invalid extended header length";

652 goto error;

653 }

654 avio_skip(s->pb, extlen);

655 len -= extlen + 4;

656 if (len < 0) {

657 reason = "extended header too long.";

658 goto error;

659 }

660 }

661

662 while (len >= taghdrlen) {

663 unsigned int tflags = 0;

664 int tunsync = 0;

665 int tcomp = 0;

666 int tencr = 0;

667 unsigned long dlen;

668

669 if (isv34) {

670 avio_read(s->pb, tag, 4);

671 tag[4] = 0;

672 if (version == 3) {

673 tlen = avio_rb32(s->pb);

674 } else

675 tlen = get_size(s->pb, 4);

676 tflags = avio_rb16(s->pb);

677 tunsync = tflags & ID3v2_FLAG_UNSYNCH;

678 } else {

679 avio_read(s->pb, tag, 3);

680 tag[3] = 0;

681 tlen = avio_rb24(s->pb);

682 }

683 if (tlen > (1<<28))

684 break;

685 len -= taghdrlen + tlen;

686

687 if (len < 0)

688 break;

689

690 next = avio_tell(s->pb) + tlen;

691

692 if (!tlen) {

693 if (tag[0])

694 av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n",

695 tag);

696 continue;

697 }

698

699 if (tflags & ID3v2_FLAG_DATALEN) {

700 if (tlen < 4)

701 break;

702 dlen = avio_rb32(s->pb);

703 tlen -= 4;

704 } else

705 dlen = tlen;

706

707 tcomp = tflags & ID3v2_FLAG_COMPRESSION;

708 tencr = tflags & ID3v2_FLAG_ENCRYPTION;

709

710 /* skip encrypted tags and, if no zlib, compressed tags */

711 if (tencr || (!CONFIG_ZLIB && tcomp)) {

712 const char *type;

713 if (!tcomp)

714 type = "encrypted";

715 else if (!tencr)

716 type = "compressed";

717 else

718 type = "encrypted and compressed";

719

720 av_log(s, AV_LOG_WARNING, "Skipping %s ID3v2 frame %s.\n", type, tag);

721 avio_skip(s->pb, tlen);

722 /* check for text tag or supported special meta tag */

723 } else if (tag[0] == 'T' ||

724 (extra_meta &&

725 (extra_func = get_extra_meta_func(tag, isv34)))) {

726 pbx = s->pb;

727

728 if (unsync || tunsync || tcomp) {

729 av_fast_malloc(&buffer, &buffer_size, tlen);

730 if (!buffer) {

731 av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);

732 goto seek;

733 }

734 }

735 if (unsync || tunsync) {

736 int64_t end = avio_tell(s->pb) + tlen;

737 uint8_t *b;

738

739 b = buffer;

740 while (avio_tell(s->pb) < end && b - buffer < tlen && !s->pb->eof_reached) {

741 *b++ = avio_r8(s->pb);

742 if (*(b - 1) == 0xff && avio_tell(s->pb) < end - 1 &&

743 b - buffer < tlen &&

744 !s->pb->eof_reached ) {

745 uint8_t val = avio_r8(s->pb);

746 *b++ = val ? val : avio_r8(s->pb);

747 }

748 }

749 ffio_init_context(&pb, buffer, b - buffer, 0, NULL, NULL, NULL,

750 NULL);

751 tlen = b - buffer;

752 pbx = &pb; // read from sync buffer

753 }

754

755 #if CONFIG_ZLIB

756 if (tcomp) {

757 int err;

758

759 av_log(s, AV_LOG_DEBUG, "Compresssed frame %s tlen=%d dlen=%ld\n", tag, tlen, dlen);

760

761 av_fast_malloc(&uncompressed_buffer, &uncompressed_buffer_size, dlen);

762 if (!uncompressed_buffer) {

763 av_log(s, AV_LOG_ERROR, "Failed to alloc %ld bytes\n", dlen);

764 goto seek;

765 }

766

767 if (!(unsync || tunsync)) {

768 err = avio_read(s->pb, buffer, tlen);

769 if (err < 0) {

770 av_log(s, AV_LOG_ERROR, "Failed to read compressed tag\n");

771 goto seek;

772 }

773 tlen = err;

774 }

775

776 err = uncompress(uncompressed_buffer, &dlen, buffer, tlen);

777 if (err != Z_OK) {

778 av_log(s, AV_LOG_ERROR, "Failed to uncompress tag: %d\n", err);

779 goto seek;

780 }

781 ffio_init_context(&pb, uncompressed_buffer, dlen, 0, NULL, NULL, NULL, NULL);

782 tlen = dlen;

783 pbx = &pb; // read from sync buffer

784 }

785 #endif

786 if (tag[0] == 'T')

787 /* parse text tag */

788 read_ttag(s, pbx, tlen, &s->metadata, tag);

789 else

790 /* parse special meta tag */

791 extra_func->read(s, pbx, tlen, tag, extra_meta);

792 } else if (!tag[0]) {

793 if (tag[1])

794 av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding\n");

795 avio_skip(s->pb, tlen);

796 break;

797 }

798 /* Skip to end of tag */

799 seek:

800 avio_seek(s->pb, next, SEEK_SET);

801 }

802

803 /* Footer preset, always 10 bytes, skip over it */

804 if (version == 4 && flags & 0x10)

805 end += 10;

806

807 error:

808 if (reason)

809 av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n",

810 version, reason);

811 avio_seek(s->pb, end, SEEK_SET);

812 av_free(buffer);

813 av_free(uncompressed_buffer);

814 return;

815 }

816

817 void ff_id3v2_read(AVFormatContext *s, const char *magic,

818 ID3v2ExtraMeta **extra_meta)

819 {

820 int len, ret;

821 uint8_t buf[ID3v2_HEADER_SIZE];

822 int found_header;

823 int64_t off;

824

825 do {

826 /* save the current offset in case there's nothing to read/skip */

827 off = avio_tell(s->pb);

828 ret = avio_read(s->pb, buf, ID3v2_HEADER_SIZE);

829 if (ret != ID3v2_HEADER_SIZE) {

830 avio_seek(s->pb, off, SEEK_SET);

831 break;

832 }

833 found_header = ff_id3v2_match(buf, magic);

834 if (found_header) {

835 /* parse ID3v2 header */

836 len = ((buf[6] & 0x7f) << 21) |

837 ((buf[7] & 0x7f) << 14) |

838 ((buf[8] & 0x7f) << 7) |

839 (buf[9] & 0x7f);

840 id3v2_parse(s, len, buf[3], buf[5], extra_meta);

841 } else {

842 avio_seek(s->pb, off, SEEK_SET);

843 }

844 } while (found_header);

845 ff_metadata_conv(&s->metadata, NULL, ff_id3v2_34_metadata_conv);

846 ff_metadata_conv(&s->metadata, NULL, id3v2_2_metadata_conv);

847 ff_metadata_conv(&s->metadata, NULL, ff_id3v2_4_metadata_conv);

848 merge_date(&s->metadata);

849 }

850

851 void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)

852 {

853 ID3v2ExtraMeta *current = *extra_meta, *next;

854 const ID3v2EMFunc *extra_func;

855

856 while (current) {

857 if ((extra_func = get_extra_meta_func(current->tag, 1)))

858 extra_func->free(current->data);

859 next = current->next;

860 av_freep(&current);

861 current = next;

862 }

863 }

864

865 int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)

866 {

867 ID3v2ExtraMeta *cur;

868

869 for (cur = *extra_meta; cur; cur = cur->next) {

870 ID3v2ExtraMetaAPIC *apic;

871 AVStream *st;

872

873 if (strcmp(cur->tag, "APIC"))

874 continue;

875 apic = cur->data;

876

877 if (!(st = avformat_new_stream(s, NULL)))

878 return AVERROR(ENOMEM);

879

880 st->disposition |= AV_DISPOSITION_ATTACHED_PIC;

881 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

882 st->codec->codec_id = apic->id;

883 av_dict_set(&st->metadata, "title", apic->description, 0);

884 av_dict_set(&st->metadata, "comment", apic->type, 0);

885

886 av_init_packet(&st->attached_pic);

887 st->attached_pic.buf = apic->buf;

888 st->attached_pic.data = apic->buf->data;

889 st->attached_pic.size = apic->buf->size - FF_INPUT_BUFFER_PADDING_SIZE;

890 st->attached_pic.stream_index = st->index;

891 st->attached_pic.flags |= AV_PKT_FLAG_KEY;

892

893 apic->buf = NULL;

894 }

895

896 return 0;

897 }

Generated on Sat Jan 25 2014 19:52:02 for FFmpeg by doxygen 1.8.2