mambax7 /
xoopseditors
| Conditions | 270 |
| Paths | > 20000 |
| Total Lines | 1409 |
| Lines | 0 |
| Ratio | 0 % |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 470 | private function ParseID3v2Frame(&$parsed_frame) { |
||
| 471 | |||
| 472 | $getid3 = $this->getid3; |
||
| 473 | |||
| 474 | $id3v2_major_version = $getid3->info['id3v2']['majorversion']; |
||
| 475 | |||
| 476 | $frame_name_long = getid3_id3v2::FrameNameLongLookup($parsed_frame['frame_name']); |
||
| 477 | if ($frame_name_long) { |
||
| 478 | $parsed_frame['framenamelong'] = $frame_name_long; |
||
| 479 | } |
||
| 480 | |||
| 481 | $frame_name_short = getid3_id3v2::FrameNameShortLookup($parsed_frame['frame_name']); |
||
| 482 | if ($frame_name_short) { |
||
| 483 | $parsed_frame['framenameshort'] = $frame_name_short; |
||
| 484 | } |
||
| 485 | |||
| 486 | if ($id3v2_major_version >= 3) { // frame flags are not part of the ID3v2.2 standard |
||
| 487 | |||
| 488 | if ($id3v2_major_version == 3) { |
||
| 489 | |||
| 490 | // Frame Header Flags |
||
| 491 | // %abc00000 %ijk00000 |
||
| 492 | |||
| 493 | $parsed_frame['flags']['TagAlterPreservation'] = (bool)($parsed_frame['frame_flags_raw'] & 0x8000); // a - Tag alter preservation |
||
| 494 | $parsed_frame['flags']['FileAlterPreservation'] = (bool)($parsed_frame['frame_flags_raw'] & 0x4000); // b - File alter preservation |
||
| 495 | $parsed_frame['flags']['ReadOnly'] = (bool)($parsed_frame['frame_flags_raw'] & 0x2000); // c - Read only |
||
| 496 | $parsed_frame['flags']['compression'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0080); // i - Compression |
||
| 497 | $parsed_frame['flags']['Encryption'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0040); // j - Encryption |
||
| 498 | $parsed_frame['flags']['GroupingIdentity'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0020); // k - Grouping identity |
||
| 499 | |||
| 500 | |||
| 501 | } elseif ($id3v2_major_version == 4) { |
||
| 502 | |||
| 503 | // Frame Header Flags |
||
| 504 | // %0abc0000 %0h00kmnp |
||
| 505 | |||
| 506 | $parsed_frame['flags']['TagAlterPreservation'] = (bool)($parsed_frame['frame_flags_raw'] & 0x4000); // a - Tag alter preservation |
||
| 507 | $parsed_frame['flags']['FileAlterPreservation'] = (bool)($parsed_frame['frame_flags_raw'] & 0x2000); // b - File alter preservation |
||
| 508 | $parsed_frame['flags']['ReadOnly'] = (bool)($parsed_frame['frame_flags_raw'] & 0x1000); // c - Read only |
||
| 509 | $parsed_frame['flags']['GroupingIdentity'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0040); // h - Grouping identity |
||
| 510 | $parsed_frame['flags']['compression'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0008); // k - Compression |
||
| 511 | $parsed_frame['flags']['Encryption'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0004); // m - Encryption |
||
| 512 | $parsed_frame['flags']['Unsynchronisation'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0002); // n - Unsynchronisation |
||
| 513 | $parsed_frame['flags']['DataLengthIndicator'] = (bool)($parsed_frame['frame_flags_raw'] & 0x0001); // p - Data length indicator |
||
| 514 | |||
| 515 | // Frame-level de-unsynchronisation - ID3v2.4 |
||
| 516 | if ($parsed_frame['flags']['Unsynchronisation']) { |
||
| 517 | $parsed_frame['data'] = str_replace("\xFF\x00", "\xFF", $parsed_frame['data']); |
||
| 518 | } |
||
| 519 | } |
||
| 520 | |||
| 521 | // Frame-level de-compression |
||
| 522 | if ($parsed_frame['flags']['compression']) { |
||
| 523 | $parsed_frame['decompressed_size'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], 0, 4)); |
||
| 524 | |||
| 525 | if (!function_exists('gzuncompress')) { |
||
| 526 | $getid3->warning('gzuncompress() support required to decompress ID3v2 frame "'.$parsed_frame['frame_name'].'"'); |
||
| 527 | } elseif ($decompressed_data = @gzuncompress(substr($parsed_frame['data'], 4))) { |
||
| 528 | $parsed_frame['data'] = $decompressed_data; |
||
| 529 | } else { |
||
| 530 | $getid3->warning('gzuncompress() failed on compressed contents of ID3v2 frame "'.$parsed_frame['frame_name'].'"'); |
||
| 531 | } |
||
| 532 | } |
||
| 533 | } |
||
| 534 | |||
| 535 | |||
| 536 | if (isset($parsed_frame['datalength']) && ($parsed_frame['datalength'] == 0)) { |
||
| 537 | |||
| 538 | $warning = 'Frame "'.$parsed_frame['frame_name'].'" at offset '.$parsed_frame['dataoffset'].' has no data portion'; |
||
| 539 | switch ($parsed_frame['frame_name']) { |
||
| 540 | case 'WCOM': |
||
| 541 | $warning .= ' (this is known to happen with files tagged by RioPort)'; |
||
| 542 | break; |
||
| 543 | |||
| 544 | default: |
||
| 545 | break; |
||
| 546 | } |
||
| 547 | $getid3->warning($warning); |
||
| 548 | return true; |
||
| 549 | } |
||
| 550 | |||
| 551 | |||
| 552 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'UFID')) || // 4.1 UFID Unique file identifier |
||
| 553 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'UFI'))) { // 4.1 UFI Unique file identifier |
||
| 554 | |||
| 555 | // There may be more than one 'UFID' frame in a tag, |
||
| 556 | // but only one with the same 'Owner identifier'. |
||
| 557 | // <Header for 'Unique file identifier', ID: 'UFID'> |
||
| 558 | // Owner identifier <text string> $00 |
||
| 559 | // Identifier <up to 64 bytes binary data> |
||
| 560 | |||
| 561 | $frame_terminator_pos = strpos($parsed_frame['data'], "\x00"); |
||
| 562 | $frame_id_string = substr($parsed_frame['data'], 0, $frame_terminator_pos); |
||
| 563 | $parsed_frame['ownerid'] = $frame_id_string; |
||
| 564 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_terminator_pos + strlen("\x00")); |
||
| 565 | unset($parsed_frame['data']); |
||
| 566 | return true; |
||
| 567 | } |
||
| 568 | |||
| 569 | |||
| 570 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'TXXX')) || // 4.2.2 TXXX User defined text information frame |
||
| 571 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'TXX'))) { // 4.2.2 TXX User defined text information frame |
||
| 572 | |||
| 573 | // There may be more than one 'TXXX' frame in each tag, |
||
| 574 | // but only one with the same description. |
||
| 575 | // <Header for 'User defined text information frame', ID: 'TXXX'> |
||
| 576 | // Text encoding $xx |
||
| 577 | // Description <text string according to encoding> $00 (00) |
||
| 578 | // Value <text string according to encoding> |
||
| 579 | |||
| 580 | $frame_offset = 0; |
||
| 581 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 582 | |||
| 583 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 584 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 585 | } |
||
| 586 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 587 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 588 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 589 | } |
||
| 590 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 591 | if (ord($frame_description) === 0) { |
||
| 592 | $frame_description = ''; |
||
| 593 | } |
||
| 594 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 595 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 596 | |||
| 597 | $parsed_frame['description'] = $frame_description; |
||
| 598 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 599 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 600 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = trim($getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data'])); |
||
| 601 | } |
||
| 602 | unset($parsed_frame['data']); |
||
| 603 | return true; |
||
| 604 | } |
||
| 605 | |||
| 606 | |||
| 607 | if ($parsed_frame['frame_name']{0} == 'T') { // 4.2. T??[?] Text information frame |
||
| 608 | |||
| 609 | // There may only be one text information frame of its kind in an tag. |
||
| 610 | // <Header for 'Text information frame', ID: 'T000' - 'TZZZ', |
||
| 611 | // excluding 'TXXX' described in 4.2.6.> |
||
| 612 | // Text encoding $xx |
||
| 613 | // Information <text string(s) according to encoding> |
||
| 614 | |||
| 615 | $frame_offset = 0; |
||
| 616 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 617 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 618 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 619 | } |
||
| 620 | |||
| 621 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 622 | |||
| 623 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 624 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 625 | |||
| 626 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 627 | |||
| 628 | // remove possible terminating \x00 (put by encoding id or software bug) |
||
| 629 | $string = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data']); |
||
| 630 | if ($string[strlen($string)-1] = "\x00") { |
||
| 631 | $string = substr($string, 0, strlen($string)-1); |
||
| 632 | } |
||
| 633 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $string; |
||
| 634 | unset($string); |
||
| 635 | } |
||
| 636 | return true; |
||
| 637 | } |
||
| 638 | |||
| 639 | |||
| 640 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'WXXX')) || // 4.3.2 WXXX User defined URL link frame |
||
| 641 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'WXX'))) { // 4.3.2 WXX User defined URL link frame |
||
| 642 | |||
| 643 | // There may be more than one 'WXXX' frame in each tag, |
||
| 644 | // but only one with the same description |
||
| 645 | // <Header for 'User defined URL link frame', ID: 'WXXX'> |
||
| 646 | // Text encoding $xx |
||
| 647 | // Description <text string according to encoding> $00 (00) |
||
| 648 | // URL <text string> |
||
| 649 | |||
| 650 | $frame_offset = 0; |
||
| 651 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 652 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 653 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 654 | } |
||
| 655 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 656 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 657 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 658 | } |
||
| 659 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 660 | |||
| 661 | if (ord($frame_description) === 0) { |
||
| 662 | $frame_description = ''; |
||
| 663 | } |
||
| 664 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 665 | |||
| 666 | $frame_terminator_pos = strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 667 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 668 | $frame_terminator_pos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 669 | } |
||
| 670 | if ($frame_terminator_pos) { |
||
| 671 | // there are null bytes after the data - this is not according to spec |
||
| 672 | // only use data up to first null byte |
||
| 673 | $frame_urldata = (string)substr($parsed_frame['data'], 0, $frame_terminator_pos); |
||
| 674 | } else { |
||
| 675 | // no null bytes following data, just use all data |
||
| 676 | $frame_urldata = (string)$parsed_frame['data']; |
||
| 677 | } |
||
| 678 | |||
| 679 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 680 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 681 | |||
| 682 | $parsed_frame['url'] = $frame_urldata; |
||
| 683 | $parsed_frame['description'] = $frame_description; |
||
| 684 | if (!empty($parsed_frame['framenameshort']) && $parsed_frame['url']) { |
||
| 685 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['url']); |
||
| 686 | } |
||
| 687 | unset($parsed_frame['data']); |
||
| 688 | return true; |
||
| 689 | } |
||
| 690 | |||
| 691 | |||
| 692 | if ($parsed_frame['frame_name']{0} == 'W') { // 4.3. W??? URL link frames |
||
| 693 | |||
| 694 | // There may only be one URL link frame of its kind in a tag, |
||
| 695 | // except when stated otherwise in the frame description |
||
| 696 | // <Header for 'URL link frame', ID: 'W000' - 'WZZZ', excluding 'WXXX' |
||
| 697 | // described in 4.3.2.> |
||
| 698 | // URL <text string> |
||
| 699 | |||
| 700 | $parsed_frame['url'] = trim($parsed_frame['data']); |
||
| 701 | if (!empty($parsed_frame['framenameshort']) && $parsed_frame['url']) { |
||
| 702 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $parsed_frame['url']; |
||
| 703 | } |
||
| 704 | unset($parsed_frame['data']); |
||
| 705 | return true; |
||
| 706 | } |
||
| 707 | |||
| 708 | |||
| 709 | if ((($id3v2_major_version == 3) && ($parsed_frame['frame_name'] == 'IPLS')) || // 4.4 IPLS Involved people list (ID3v2.3 only) |
||
| 710 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'IPL'))) { // 4.4 IPL Involved people list (ID3v2.2 only) |
||
| 711 | |||
| 712 | // There may only be one 'IPL' frame in each tag |
||
| 713 | // <Header for 'User defined URL link frame', ID: 'IPL'> |
||
| 714 | // Text encoding $xx |
||
| 715 | // People list strings <textstrings> |
||
| 716 | |||
| 717 | $frame_offset = 0; |
||
| 718 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 719 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 720 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 721 | } |
||
| 722 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 723 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($parsed_frame['encodingid']); |
||
| 724 | |||
| 725 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 726 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 727 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data']); |
||
| 728 | } |
||
| 729 | return true; |
||
| 730 | } |
||
| 731 | |||
| 732 | |||
| 733 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'MCDI')) || // 4.4 MCDI Music CD identifier |
||
| 734 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'MCI'))) { // 4.5 MCI Music CD identifier |
||
| 735 | |||
| 736 | // There may only be one 'MCDI' frame in each tag |
||
| 737 | // <Header for 'Music CD identifier', ID: 'MCDI'> |
||
| 738 | // CD TOC <binary data> |
||
| 739 | |||
| 740 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 741 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $parsed_frame['data']; |
||
| 742 | } |
||
| 743 | return true; |
||
| 744 | } |
||
| 745 | |||
| 746 | |||
| 747 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'ETCO')) || // 4.5 ETCO Event timing codes |
||
| 748 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'ETC'))) { // 4.6 ETC Event timing codes |
||
| 749 | |||
| 750 | // There may only be one 'ETCO' frame in each tag |
||
| 751 | // <Header for 'Event timing codes', ID: 'ETCO'> |
||
| 752 | // Time stamp format $xx |
||
| 753 | // Where time stamp format is: |
||
| 754 | // $01 (32-bit value) MPEG frames from beginning of file |
||
| 755 | // $02 (32-bit value) milliseconds from beginning of file |
||
| 756 | // Followed by a list of key events in the following format: |
||
| 757 | // Type of event $xx |
||
| 758 | // Time stamp $xx (xx ...) |
||
| 759 | // The 'Time stamp' is set to zero if directly at the beginning of the sound |
||
| 760 | // or after the previous event. All events MUST be sorted in chronological order. |
||
| 761 | |||
| 762 | $frame_offset = 0; |
||
| 763 | $parsed_frame['timestampformat'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 764 | |||
| 765 | while ($frame_offset < strlen($parsed_frame['data'])) { |
||
| 766 | $parsed_frame['typeid'] = $parsed_frame['data']{$frame_offset++}; |
||
| 767 | $parsed_frame['type'] = getid3_id3v2::ETCOEventLookup($parsed_frame['typeid']); |
||
| 768 | $parsed_frame['timestamp'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 769 | $frame_offset += 4; |
||
| 770 | } |
||
| 771 | unset($parsed_frame['data']); |
||
| 772 | return true; |
||
| 773 | } |
||
| 774 | |||
| 775 | |||
| 776 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'MLLT')) || // 4.6 MLLT MPEG location lookup table |
||
| 777 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'MLL'))) { // 4.7 MLL MPEG location lookup table |
||
| 778 | |||
| 779 | // There may only be one 'MLLT' frame in each tag |
||
| 780 | // <Header for 'Location lookup table', ID: 'MLLT'> |
||
| 781 | // MPEG frames between reference $xx xx |
||
| 782 | // Bytes between reference $xx xx xx |
||
| 783 | // Milliseconds between reference $xx xx xx |
||
| 784 | // Bits for bytes deviation $xx |
||
| 785 | // Bits for milliseconds dev. $xx |
||
| 786 | // Then for every reference the following data is included; |
||
| 787 | // Deviation in bytes %xxx.... |
||
| 788 | // Deviation in milliseconds %xxx.... |
||
| 789 | |||
| 790 | $frame_offset = 0; |
||
| 791 | $parsed_frame['framesbetweenreferences'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], 0, 2)); |
||
| 792 | $parsed_frame['bytesbetweenreferences'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], 2, 3)); |
||
| 793 | $parsed_frame['msbetweenreferences'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], 5, 3)); |
||
| 794 | $parsed_frame['bitsforbytesdeviation'] = getid3_lib::BigEndian2Int($parsed_frame['data'][8]); |
||
| 795 | $parsed_frame['bitsformsdeviation'] = getid3_lib::BigEndian2Int($parsed_frame['data'][9]); |
||
| 796 | $parsed_frame['data'] = substr($parsed_frame['data'], 10); |
||
| 797 | |||
| 798 | while ($frame_offset < strlen($parsed_frame['data'])) { |
||
| 799 | $deviation_bitstream .= getid3_lib::BigEndian2Bin($parsed_frame['data']{$frame_offset++}); |
||
| 800 | } |
||
| 801 | $reference_counter = 0; |
||
| 802 | while (strlen($deviation_bitstream) > 0) { |
||
| 803 | $parsed_frame[$reference_counter]['bytedeviation'] = bindec(substr($deviation_bitstream, 0, $parsed_frame['bitsforbytesdeviation'])); |
||
| 804 | $parsed_frame[$reference_counter]['msdeviation'] = bindec(substr($deviation_bitstream, $parsed_frame['bitsforbytesdeviation'], $parsed_frame['bitsformsdeviation'])); |
||
| 805 | $deviation_bitstream = substr($deviation_bitstream, $parsed_frame['bitsforbytesdeviation'] + $parsed_frame['bitsformsdeviation']); |
||
| 806 | $reference_counter++; |
||
| 807 | } |
||
| 808 | unset($parsed_frame['data']); |
||
| 809 | return true; |
||
| 810 | } |
||
| 811 | |||
| 812 | |||
| 813 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'SYTC')) || // 4.7 SYTC Synchronised tempo codes |
||
| 814 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'STC'))) { // 4.8 STC Synchronised tempo codes |
||
| 815 | |||
| 816 | // There may only be one 'SYTC' frame in each tag |
||
| 817 | // <Header for 'Synchronised tempo codes', ID: 'SYTC'> |
||
| 818 | // Time stamp format $xx |
||
| 819 | // Tempo data <binary data> |
||
| 820 | // Where time stamp format is: |
||
| 821 | // $01 (32-bit value) MPEG frames from beginning of file |
||
| 822 | // $02 (32-bit value) milliseconds from beginning of file |
||
| 823 | |||
| 824 | $frame_offset = 0; |
||
| 825 | $parsed_frame['timestampformat'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 826 | $timestamp_counter = 0; |
||
| 827 | while ($frame_offset < strlen($parsed_frame['data'])) { |
||
| 828 | $parsed_frame[$timestamp_counter]['tempo'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 829 | if ($parsed_frame[$timestamp_counter]['tempo'] == 255) { |
||
| 830 | $parsed_frame[$timestamp_counter]['tempo'] += ord($parsed_frame['data']{$frame_offset++}); |
||
| 831 | } |
||
| 832 | $parsed_frame[$timestamp_counter]['timestamp'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 833 | $frame_offset += 4; |
||
| 834 | $timestamp_counter++; |
||
| 835 | } |
||
| 836 | unset($parsed_frame['data']); |
||
| 837 | return true; |
||
| 838 | } |
||
| 839 | |||
| 840 | |||
| 841 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'USLT')) || // 4.8 USLT Unsynchronised lyric/text transcription |
||
| 842 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'ULT'))) { // 4.9 ULT Unsynchronised lyric/text transcription |
||
| 843 | |||
| 844 | // There may be more than one 'Unsynchronised lyrics/text transcription' frame |
||
| 845 | // in each tag, but only one with the same language and content descriptor. |
||
| 846 | // <Header for 'Unsynchronised lyrics/text transcription', ID: 'USLT'> |
||
| 847 | // Text encoding $xx |
||
| 848 | // Language $xx xx xx |
||
| 849 | // Content descriptor <text string according to encoding> $00 (00) |
||
| 850 | // Lyrics/text <full text string according to encoding> |
||
| 851 | |||
| 852 | $frame_offset = 0; |
||
| 853 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 854 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 855 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 856 | } |
||
| 857 | $frame_language = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 858 | $frame_offset += 3; |
||
| 859 | if ($frame_offset > strlen($parsed_frame['data'])) { |
||
| 860 | $frame_offset = strlen($parsed_frame['data']) - 1; |
||
| 861 | } |
||
| 862 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 863 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 864 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 865 | } |
||
| 866 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 867 | if (ord($frame_description) === 0) { |
||
| 868 | $frame_description = ''; |
||
| 869 | } |
||
| 870 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 871 | |||
| 872 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 873 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 874 | |||
| 875 | $parsed_frame['data'] = $parsed_frame['data']; |
||
| 876 | $parsed_frame['language'] = $frame_language; |
||
| 877 | $parsed_frame['languagename'] = getid3_id3v2::LanguageLookup($frame_language, false); |
||
| 878 | $parsed_frame['description'] = $frame_description; |
||
| 879 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 880 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data']); |
||
| 881 | } |
||
| 882 | unset($parsed_frame['data']); |
||
| 883 | return true; |
||
| 884 | } |
||
| 885 | |||
| 886 | |||
| 887 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'SYLT')) || // 4.9 SYLT Synchronised lyric/text |
||
| 888 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'SLT'))) { // 4.10 SLT Synchronised lyric/text |
||
| 889 | |||
| 890 | // There may be more than one 'SYLT' frame in each tag, |
||
| 891 | // but only one with the same language and content descriptor. |
||
| 892 | // <Header for 'Synchronised lyrics/text', ID: 'SYLT'> |
||
| 893 | // Text encoding $xx |
||
| 894 | // Language $xx xx xx |
||
| 895 | // Time stamp format $xx |
||
| 896 | // $01 (32-bit value) MPEG frames from beginning of file |
||
| 897 | // $02 (32-bit value) milliseconds from beginning of file |
||
| 898 | // Content type $xx |
||
| 899 | // Content descriptor <text string according to encoding> $00 (00) |
||
| 900 | // Terminated text to be synced (typically a syllable) |
||
| 901 | // Sync identifier (terminator to above string) $00 (00) |
||
| 902 | // Time stamp $xx (xx ...) |
||
| 903 | |||
| 904 | $frame_offset = 0; |
||
| 905 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 906 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 907 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 908 | } |
||
| 909 | $frame_language = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 910 | $frame_offset += 3; |
||
| 911 | $parsed_frame['timestampformat'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 912 | $parsed_frame['contenttypeid'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 913 | $parsed_frame['contenttype'] = getid3_id3v2::SYTLContentTypeLookup($parsed_frame['contenttypeid']); |
||
| 914 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 915 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 916 | |||
| 917 | $parsed_frame['language'] = $frame_language; |
||
| 918 | $parsed_frame['languagename'] = getid3_id3v2::LanguageLookup($frame_language, false); |
||
| 919 | |||
| 920 | $timestamp_index = 0; |
||
| 921 | $frame_remaining_data = substr($parsed_frame['data'], $frame_offset); |
||
| 922 | while (strlen($frame_remaining_data)) { |
||
| 923 | $frame_offset = 0; |
||
| 924 | $frame_terminator_pos = strpos($frame_remaining_data, getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 925 | if ($frame_terminator_pos === false) { |
||
| 926 | $frame_remaining_data = ''; |
||
| 927 | } else { |
||
| 928 | if (ord(substr($frame_remaining_data, $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 929 | $frame_terminator_pos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 930 | } |
||
| 931 | $parsed_frame['lyrics'][$timestamp_index]['data'] = substr($frame_remaining_data, $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 932 | |||
| 933 | $frame_remaining_data = substr($frame_remaining_data, $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 934 | if (($timestamp_index == 0) && (ord($frame_remaining_data{0}) != 0)) { |
||
| 935 | // timestamp probably omitted for first data item |
||
| 936 | } else { |
||
| 937 | $parsed_frame['lyrics'][$timestamp_index]['timestamp'] = getid3_lib::BigEndian2Int(substr($frame_remaining_data, 0, 4)); |
||
| 938 | $frame_remaining_data = substr($frame_remaining_data, 4); |
||
| 939 | } |
||
| 940 | $timestamp_index++; |
||
| 941 | } |
||
| 942 | } |
||
| 943 | unset($parsed_frame['data']); |
||
| 944 | return true; |
||
| 945 | } |
||
| 946 | |||
| 947 | |||
| 948 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'COMM')) || // 4.10 COMM Comments |
||
| 949 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'COM'))) { // 4.11 COM Comments |
||
| 950 | |||
| 951 | // There may be more than one comment frame in each tag, |
||
| 952 | // but only one with the same language and content descriptor. |
||
| 953 | // <Header for 'Comment', ID: 'COMM'> |
||
| 954 | // Text encoding $xx |
||
| 955 | // Language $xx xx xx |
||
| 956 | // Short content descrip. <text string according to encoding> $00 (00) |
||
| 957 | // The actual text <full text string according to encoding> |
||
| 958 | |||
| 959 | if (strlen($parsed_frame['data']) < 5) { |
||
| 960 | |||
| 961 | $getid3->warning('Invalid data (too short) for "'.$parsed_frame['frame_name'].'" frame at offset '.$parsed_frame['dataoffset']); |
||
| 962 | return true; |
||
| 963 | } |
||
| 964 | |||
| 965 | $frame_offset = 0; |
||
| 966 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 967 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 968 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 969 | } |
||
| 970 | $frame_language = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 971 | $frame_offset += 3; |
||
| 972 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 973 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 974 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 975 | } |
||
| 976 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 977 | if (ord($frame_description) === 0) { |
||
| 978 | $frame_description = ''; |
||
| 979 | } |
||
| 980 | $frame_text = (string)substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 981 | |||
| 982 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 983 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 984 | |||
| 985 | $parsed_frame['language'] = $frame_language; |
||
| 986 | $parsed_frame['languagename'] = getid3_id3v2::LanguageLookup($frame_language, false); |
||
| 987 | $parsed_frame['description'] = $frame_description; |
||
| 988 | $parsed_frame['data'] = $frame_text; |
||
| 989 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 990 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data']); |
||
| 991 | } |
||
| 992 | return true; |
||
| 993 | } |
||
| 994 | |||
| 995 | |||
| 996 | if (($id3v2_major_version >= 4) && ($parsed_frame['frame_name'] == 'RVA2')) { // 4.11 RVA2 Relative volume adjustment (2) (ID3v2.4+ only) |
||
| 997 | |||
| 998 | // There may be more than one 'RVA2' frame in each tag, |
||
| 999 | // but only one with the same identification string |
||
| 1000 | // <Header for 'Relative volume adjustment (2)', ID: 'RVA2'> |
||
| 1001 | // Identification <text string> $00 |
||
| 1002 | // The 'identification' string is used to identify the situation and/or |
||
| 1003 | // device where this adjustment should apply. The following is then |
||
| 1004 | // repeated for every channel: |
||
| 1005 | // Type of channel $xx |
||
| 1006 | // Volume adjustment $xx xx |
||
| 1007 | // Bits representing peak $xx |
||
| 1008 | // Peak volume $xx (xx ...) |
||
| 1009 | |||
| 1010 | $frame_terminator_pos = strpos($parsed_frame['data'], "\x00"); |
||
| 1011 | $frame_id_string = substr($parsed_frame['data'], 0, $frame_terminator_pos); |
||
| 1012 | if (ord($frame_id_string) === 0) { |
||
| 1013 | $frame_id_string = ''; |
||
| 1014 | } |
||
| 1015 | $frame_remaining_data = substr($parsed_frame['data'], $frame_terminator_pos + strlen("\x00")); |
||
| 1016 | $parsed_frame['description'] = $frame_id_string; |
||
| 1017 | |||
| 1018 | while (strlen($frame_remaining_data)) { |
||
| 1019 | $frame_offset = 0; |
||
| 1020 | $frame_channeltypeid = ord(substr($frame_remaining_data, $frame_offset++, 1)); |
||
| 1021 | $parsed_frame[$frame_channeltypeid]['channeltypeid'] = $frame_channeltypeid; |
||
| 1022 | $parsed_frame[$frame_channeltypeid]['channeltype'] = getid3_id3v2::RVA2ChannelTypeLookup($frame_channeltypeid); |
||
| 1023 | $parsed_frame[$frame_channeltypeid]['volumeadjust'] = getid3_lib::BigEndian2Int(substr($frame_remaining_data, $frame_offset, 2), true); // 16-bit signed |
||
| 1024 | $frame_offset += 2; |
||
| 1025 | $parsed_frame[$frame_channeltypeid]['bitspeakvolume'] = ord(substr($frame_remaining_data, $frame_offset++, 1)); |
||
| 1026 | $frame_bytespeakvolume = ceil($parsed_frame[$frame_channeltypeid]['bitspeakvolume'] / 8); |
||
| 1027 | $parsed_frame[$frame_channeltypeid]['peakvolume'] = getid3_lib::BigEndian2Int(substr($frame_remaining_data, $frame_offset, $frame_bytespeakvolume)); |
||
| 1028 | $frame_remaining_data = substr($frame_remaining_data, $frame_offset + $frame_bytespeakvolume); |
||
| 1029 | } |
||
| 1030 | unset($parsed_frame['data']); |
||
| 1031 | return true; |
||
| 1032 | } |
||
| 1033 | |||
| 1034 | |||
| 1035 | if ((($id3v2_major_version == 3) && ($parsed_frame['frame_name'] == 'RVAD')) || // 4.12 RVAD Relative volume adjustment (ID3v2.3 only) |
||
| 1036 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'RVA'))) { // 4.12 RVA Relative volume adjustment (ID3v2.2 only) |
||
| 1037 | |||
| 1038 | // There may only be one 'RVA' frame in each tag |
||
| 1039 | // <Header for 'Relative volume adjustment', ID: 'RVA'> |
||
| 1040 | // ID3v2.2 => Increment/decrement %000000ba |
||
| 1041 | // ID3v2.3 => Increment/decrement %00fedcba |
||
| 1042 | // Bits used for volume descr. $xx |
||
| 1043 | // Relative volume change, right $xx xx (xx ...) // a |
||
| 1044 | // Relative volume change, left $xx xx (xx ...) // b |
||
| 1045 | // Peak volume right $xx xx (xx ...) |
||
| 1046 | // Peak volume left $xx xx (xx ...) |
||
| 1047 | // ID3v2.3 only, optional (not present in ID3v2.2): |
||
| 1048 | // Relative volume change, right back $xx xx (xx ...) // c |
||
| 1049 | // Relative volume change, left back $xx xx (xx ...) // d |
||
| 1050 | // Peak volume right back $xx xx (xx ...) |
||
| 1051 | // Peak volume left back $xx xx (xx ...) |
||
| 1052 | // ID3v2.3 only, optional (not present in ID3v2.2): |
||
| 1053 | // Relative volume change, center $xx xx (xx ...) // e |
||
| 1054 | // Peak volume center $xx xx (xx ...) |
||
| 1055 | // ID3v2.3 only, optional (not present in ID3v2.2): |
||
| 1056 | // Relative volume change, bass $xx xx (xx ...) // f |
||
| 1057 | // Peak volume bass $xx xx (xx ...) |
||
| 1058 | |||
| 1059 | $frame_offset = 0; |
||
| 1060 | $frame_incrdecrflags = getid3_lib::BigEndian2Bin($parsed_frame['data']{$frame_offset++}); |
||
| 1061 | $parsed_frame['incdec']['right'] = (bool)substr($frame_incrdecrflags, 6, 1); |
||
| 1062 | $parsed_frame['incdec']['left'] = (bool)substr($frame_incrdecrflags, 7, 1); |
||
| 1063 | $parsed_frame['bitsvolume'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1064 | $frame_bytesvolume = ceil($parsed_frame['bitsvolume'] / 8); |
||
| 1065 | $parsed_frame['volumechange']['right'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1066 | if ($parsed_frame['incdec']['right'] === false) { |
||
| 1067 | $parsed_frame['volumechange']['right'] *= -1; |
||
| 1068 | } |
||
| 1069 | $frame_offset += $frame_bytesvolume; |
||
| 1070 | $parsed_frame['volumechange']['left'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1071 | if ($parsed_frame['incdec']['left'] === false) { |
||
| 1072 | $parsed_frame['volumechange']['left'] *= -1; |
||
| 1073 | } |
||
| 1074 | $frame_offset += $frame_bytesvolume; |
||
| 1075 | $parsed_frame['peakvolume']['right'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1076 | $frame_offset += $frame_bytesvolume; |
||
| 1077 | $parsed_frame['peakvolume']['left'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1078 | $frame_offset += $frame_bytesvolume; |
||
| 1079 | if ($id3v2_major_version == 3) { |
||
| 1080 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_offset); |
||
| 1081 | if (strlen($parsed_frame['data']) > 0) { |
||
| 1082 | $parsed_frame['incdec']['rightrear'] = (bool)substr($frame_incrdecrflags, 4, 1); |
||
| 1083 | $parsed_frame['incdec']['leftrear'] = (bool)substr($frame_incrdecrflags, 5, 1); |
||
| 1084 | $parsed_frame['volumechange']['rightrear'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1085 | if ($parsed_frame['incdec']['rightrear'] === false) { |
||
| 1086 | $parsed_frame['volumechange']['rightrear'] *= -1; |
||
| 1087 | } |
||
| 1088 | $frame_offset += $frame_bytesvolume; |
||
| 1089 | $parsed_frame['volumechange']['leftrear'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1090 | if ($parsed_frame['incdec']['leftrear'] === false) { |
||
| 1091 | $parsed_frame['volumechange']['leftrear'] *= -1; |
||
| 1092 | } |
||
| 1093 | $frame_offset += $frame_bytesvolume; |
||
| 1094 | $parsed_frame['peakvolume']['rightrear'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1095 | $frame_offset += $frame_bytesvolume; |
||
| 1096 | $parsed_frame['peakvolume']['leftrear'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1097 | $frame_offset += $frame_bytesvolume; |
||
| 1098 | } |
||
| 1099 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_offset); |
||
| 1100 | if (strlen($parsed_frame['data']) > 0) { |
||
| 1101 | $parsed_frame['incdec']['center'] = (bool)substr($frame_incrdecrflags, 3, 1); |
||
| 1102 | $parsed_frame['volumechange']['center'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1103 | if ($parsed_frame['incdec']['center'] === false) { |
||
| 1104 | $parsed_frame['volumechange']['center'] *= -1; |
||
| 1105 | } |
||
| 1106 | $frame_offset += $frame_bytesvolume; |
||
| 1107 | $parsed_frame['peakvolume']['center'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1108 | $frame_offset += $frame_bytesvolume; |
||
| 1109 | } |
||
| 1110 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_offset); |
||
| 1111 | if (strlen($parsed_frame['data']) > 0) { |
||
| 1112 | $parsed_frame['incdec']['bass'] = (bool)substr($frame_incrdecrflags, 2, 1); |
||
| 1113 | $parsed_frame['volumechange']['bass'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1114 | if ($parsed_frame['incdec']['bass'] === false) { |
||
| 1115 | $parsed_frame['volumechange']['bass'] *= -1; |
||
| 1116 | } |
||
| 1117 | $frame_offset += $frame_bytesvolume; |
||
| 1118 | $parsed_frame['peakvolume']['bass'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesvolume)); |
||
| 1119 | $frame_offset += $frame_bytesvolume; |
||
| 1120 | } |
||
| 1121 | } |
||
| 1122 | unset($parsed_frame['data']); |
||
| 1123 | return true; |
||
| 1124 | } |
||
| 1125 | |||
| 1126 | |||
| 1127 | if (($id3v2_major_version >= 4) && ($parsed_frame['frame_name'] == 'EQU2')) { // 4.12 EQU2 Equalisation (2) (ID3v2.4+ only) |
||
| 1128 | |||
| 1129 | // There may be more than one 'EQU2' frame in each tag, |
||
| 1130 | // but only one with the same identification string |
||
| 1131 | // <Header of 'Equalisation (2)', ID: 'EQU2'> |
||
| 1132 | // Interpolation method $xx |
||
| 1133 | // $00 Band |
||
| 1134 | // $01 Linear |
||
| 1135 | // Identification <text string> $00 |
||
| 1136 | // The following is then repeated for every adjustment point |
||
| 1137 | // Frequency $xx xx |
||
| 1138 | // Volume adjustment $xx xx |
||
| 1139 | |||
| 1140 | $frame_offset = 0; |
||
| 1141 | $frame_interpolationmethod = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1142 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1143 | $frame_id_string = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1144 | if (ord($frame_id_string) === 0) { |
||
| 1145 | $frame_id_string = ''; |
||
| 1146 | } |
||
| 1147 | $parsed_frame['description'] = $frame_id_string; |
||
| 1148 | $frame_remaining_data = substr($parsed_frame['data'], $frame_terminator_pos + strlen("\x00")); |
||
| 1149 | while (strlen($frame_remaining_data)) { |
||
| 1150 | $frame_frequency = getid3_lib::BigEndian2Int(substr($frame_remaining_data, 0, 2)) / 2; |
||
| 1151 | $parsed_frame['data'][$frame_frequency] = getid3_lib::BigEndian2Int(substr($frame_remaining_data, 2, 2), true); |
||
| 1152 | $frame_remaining_data = substr($frame_remaining_data, 4); |
||
| 1153 | } |
||
| 1154 | $parsed_frame['interpolationmethod'] = $frame_interpolationmethod; |
||
| 1155 | unset($parsed_frame['data']); |
||
| 1156 | return true; |
||
| 1157 | } |
||
| 1158 | |||
| 1159 | |||
| 1160 | if ((($id3v2_major_version == 3) && ($parsed_frame['frame_name'] == 'EQUA')) || // 4.12 EQUA Equalisation (ID3v2.3 only) |
||
| 1161 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'EQU'))) { // 4.13 EQU Equalisation (ID3v2.2 only) |
||
| 1162 | |||
| 1163 | // There may only be one 'EQUA' frame in each tag |
||
| 1164 | // <Header for 'Relative volume adjustment', ID: 'EQU'> |
||
| 1165 | // Adjustment bits $xx |
||
| 1166 | // This is followed by 2 bytes + ('adjustment bits' rounded up to the |
||
| 1167 | // nearest byte) for every equalisation band in the following format, |
||
| 1168 | // giving a frequency range of 0 - 32767Hz: |
||
| 1169 | // Increment/decrement %x (MSB of the Frequency) |
||
| 1170 | // Frequency (lower 15 bits) |
||
| 1171 | // Adjustment $xx (xx ...) |
||
| 1172 | |||
| 1173 | $frame_offset = 0; |
||
| 1174 | $parsed_frame['adjustmentbits'] = $parsed_frame['data']{$frame_offset++}; |
||
| 1175 | $frame_adjustment_bytes = ceil($parsed_frame['adjustmentbits'] / 8); |
||
| 1176 | |||
| 1177 | $frame_remaining_data = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1178 | while (strlen($frame_remaining_data) > 0) { |
||
| 1179 | $frame_frequencystr = getid3_lib::BigEndian2Bin(substr($frame_remaining_data, 0, 2)); |
||
| 1180 | $frame_incdec = (bool)substr($frame_frequencystr, 0, 1); |
||
| 1181 | $frame_frequency = bindec(substr($frame_frequencystr, 1, 15)); |
||
| 1182 | $parsed_frame[$frame_frequency]['incdec'] = $frame_incdec; |
||
| 1183 | $parsed_frame[$frame_frequency]['adjustment'] = getid3_lib::BigEndian2Int(substr($frame_remaining_data, 2, $frame_adjustment_bytes)); |
||
| 1184 | if ($parsed_frame[$frame_frequency]['incdec'] === false) { |
||
| 1185 | $parsed_frame[$frame_frequency]['adjustment'] *= -1; |
||
| 1186 | } |
||
| 1187 | $frame_remaining_data = substr($frame_remaining_data, 2 + $frame_adjustment_bytes); |
||
| 1188 | } |
||
| 1189 | unset($parsed_frame['data']); |
||
| 1190 | return true; |
||
| 1191 | } |
||
| 1192 | |||
| 1193 | |||
| 1194 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'RVRB')) || // 4.13 RVRB Reverb |
||
| 1195 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'REV'))) { // 4.14 REV Reverb |
||
| 1196 | |||
| 1197 | // There may only be one 'RVRB' frame in each tag. |
||
| 1198 | // <Header for 'Reverb', ID: 'RVRB'> |
||
| 1199 | // Reverb left (ms) $xx xx |
||
| 1200 | // Reverb right (ms) $xx xx |
||
| 1201 | // Reverb bounces, left $xx |
||
| 1202 | // Reverb bounces, right $xx |
||
| 1203 | // Reverb feedback, left to left $xx |
||
| 1204 | // Reverb feedback, left to right $xx |
||
| 1205 | // Reverb feedback, right to right $xx |
||
| 1206 | // Reverb feedback, right to left $xx |
||
| 1207 | // Premix left to right $xx |
||
| 1208 | // Premix right to left $xx |
||
| 1209 | |||
| 1210 | $frame_offset = 0; |
||
| 1211 | $parsed_frame['left'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1212 | $frame_offset += 2; |
||
| 1213 | $parsed_frame['right'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1214 | $frame_offset += 2; |
||
| 1215 | $parsed_frame['bouncesL'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1216 | $parsed_frame['bouncesR'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1217 | $parsed_frame['feedbackLL'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1218 | $parsed_frame['feedbackLR'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1219 | $parsed_frame['feedbackRR'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1220 | $parsed_frame['feedbackRL'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1221 | $parsed_frame['premixLR'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1222 | $parsed_frame['premixRL'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1223 | unset($parsed_frame['data']); |
||
| 1224 | return true; |
||
| 1225 | } |
||
| 1226 | |||
| 1227 | |||
| 1228 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'APIC')) || // 4.14 APIC Attached picture |
||
| 1229 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'PIC'))) { // 4.15 PIC Attached picture |
||
| 1230 | |||
| 1231 | // There may be several pictures attached to one file, |
||
| 1232 | // each in their individual 'APIC' frame, but only one |
||
| 1233 | // with the same content descriptor |
||
| 1234 | // <Header for 'Attached picture', ID: 'APIC'> |
||
| 1235 | // Text encoding $xx |
||
| 1236 | // ID3v2.3+ => MIME type <text string> $00 |
||
| 1237 | // ID3v2.2 => Image format $xx xx xx |
||
| 1238 | // Picture type $xx |
||
| 1239 | // Description <text string according to encoding> $00 (00) |
||
| 1240 | // Picture data <binary data> |
||
| 1241 | |||
| 1242 | $frame_offset = 0; |
||
| 1243 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1244 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 1245 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 1246 | } |
||
| 1247 | |||
| 1248 | if ($id3v2_major_version == 2 && strlen($parsed_frame['data']) > $frame_offset) { |
||
| 1249 | $frame_imagetype = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 1250 | if (strtolower($frame_imagetype) == 'ima') { |
||
| 1251 | // complete hack for mp3Rage (www.chaoticsoftware.com) that puts ID3v2.3-formatted |
||
| 1252 | // MIME type instead of 3-char ID3v2.2-format image type (thanks xbhoff�pacbell*net) |
||
| 1253 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1254 | $frame_mimetype = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1255 | if (ord($frame_mimetype) === 0) { |
||
| 1256 | $frame_mimetype = ''; |
||
| 1257 | } |
||
| 1258 | $frame_imagetype = strtoupper(str_replace('image/', '', strtolower($frame_mimetype))); |
||
| 1259 | if ($frame_imagetype == 'JPEG') { |
||
| 1260 | $frame_imagetype = 'JPG'; |
||
| 1261 | } |
||
| 1262 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1263 | } else { |
||
| 1264 | $frame_offset += 3; |
||
| 1265 | } |
||
| 1266 | } |
||
| 1267 | |||
| 1268 | if ($id3v2_major_version > 2 && strlen($parsed_frame['data']) > $frame_offset) { |
||
| 1269 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1270 | $frame_mimetype = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1271 | if (ord($frame_mimetype) === 0) { |
||
| 1272 | $frame_mimetype = ''; |
||
| 1273 | } |
||
| 1274 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1275 | } |
||
| 1276 | |||
| 1277 | $frame_picturetype = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1278 | |||
| 1279 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 1280 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 1281 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 1282 | } |
||
| 1283 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1284 | if (ord($frame_description) === 0) { |
||
| 1285 | $frame_description = ''; |
||
| 1286 | } |
||
| 1287 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 1288 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 1289 | |||
| 1290 | if ($id3v2_major_version == 2) { |
||
| 1291 | $parsed_frame['imagetype'] = $frame_imagetype; |
||
| 1292 | } else { |
||
| 1293 | $parsed_frame['mime'] = $frame_mimetype; |
||
| 1294 | } |
||
| 1295 | $parsed_frame['picturetypeid'] = $frame_picturetype; |
||
| 1296 | $parsed_frame['picturetype'] = getid3_id3v2::APICPictureTypeLookup($frame_picturetype); |
||
| 1297 | $parsed_frame['description'] = $frame_description; |
||
| 1298 | $parsed_frame['data'] = substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding))); |
||
| 1299 | |||
| 1300 | if ($getid3->option_tags_images) { |
||
| 1301 | |||
| 1302 | $image_chunk_check = getid3_lib_image_size::get($parsed_frame['data']); |
||
| 1303 | if (($image_chunk_check[2] >= 1) && ($image_chunk_check[2] <= 3)) { |
||
| 1304 | $parsed_frame['image_mime'] = image_type_to_mime_type($image_chunk_check[2]); |
||
| 1305 | |||
| 1306 | if ($image_chunk_check[0]) { |
||
| 1307 | $parsed_frame['image_width'] = $image_chunk_check[0]; |
||
| 1308 | } |
||
| 1309 | |||
| 1310 | if ($image_chunk_check[1]) { |
||
| 1311 | $parsed_frame['image_height'] = $image_chunk_check[1]; |
||
| 1312 | } |
||
| 1313 | |||
| 1314 | $parsed_frame['image_bytes'] = strlen($parsed_frame['data']); |
||
| 1315 | } |
||
| 1316 | } |
||
| 1317 | |||
| 1318 | return true; |
||
| 1319 | } |
||
| 1320 | |||
| 1321 | |||
| 1322 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'GEOB')) || // 4.15 GEOB General encapsulated object |
||
| 1323 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'GEO'))) { // 4.16 GEO General encapsulated object |
||
| 1324 | |||
| 1325 | // There may be more than one 'GEOB' frame in each tag, |
||
| 1326 | // but only one with the same content descriptor |
||
| 1327 | // <Header for 'General encapsulated object', ID: 'GEOB'> |
||
| 1328 | // Text encoding $xx |
||
| 1329 | // MIME type <text string> $00 |
||
| 1330 | // Filename <text string according to encoding> $00 (00) |
||
| 1331 | // Content description <text string according to encoding> $00 (00) |
||
| 1332 | // Encapsulated object <binary data> |
||
| 1333 | |||
| 1334 | $frame_offset = 0; |
||
| 1335 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1336 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 1337 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 1338 | } |
||
| 1339 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1340 | $frame_mimetype = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1341 | if (ord($frame_mimetype) === 0) { |
||
| 1342 | $frame_mimetype = ''; |
||
| 1343 | } |
||
| 1344 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1345 | |||
| 1346 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 1347 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 1348 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 1349 | } |
||
| 1350 | $frame_filename = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1351 | if (ord($frame_filename) === 0) { |
||
| 1352 | $frame_filename = ''; |
||
| 1353 | } |
||
| 1354 | $frame_offset = $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 1355 | |||
| 1356 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 1357 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 1358 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 1359 | } |
||
| 1360 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1361 | if (ord($frame_description) === 0) { |
||
| 1362 | $frame_description = ''; |
||
| 1363 | } |
||
| 1364 | $frame_offset = $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 1365 | |||
| 1366 | $parsed_frame['objectdata'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1367 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 1368 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 1369 | |||
| 1370 | $parsed_frame['mime'] = $frame_mimetype; |
||
| 1371 | $parsed_frame['filename'] = $frame_filename; |
||
| 1372 | $parsed_frame['description'] = $frame_description; |
||
| 1373 | unset($parsed_frame['data']); |
||
| 1374 | return true; |
||
| 1375 | } |
||
| 1376 | |||
| 1377 | |||
| 1378 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'PCNT')) || // 4.16 PCNT Play counter |
||
| 1379 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'CNT'))) { // 4.17 CNT Play counter |
||
| 1380 | |||
| 1381 | // There may only be one 'PCNT' frame in each tag. |
||
| 1382 | // When the counter reaches all one's, one byte is inserted in |
||
| 1383 | // front of the counter thus making the counter eight bits bigger |
||
| 1384 | // <Header for 'Play counter', ID: 'PCNT'> |
||
| 1385 | // Counter $xx xx xx xx (xx ...) |
||
| 1386 | |||
| 1387 | $parsed_frame['data'] = getid3_lib::BigEndian2Int($parsed_frame['data']); |
||
| 1388 | return true; |
||
| 1389 | } |
||
| 1390 | |||
| 1391 | |||
| 1392 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'POPM')) || // 4.17 POPM Popularimeter |
||
| 1393 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'POP'))) { // 4.18 POP Popularimeter |
||
| 1394 | |||
| 1395 | // There may be more than one 'POPM' frame in each tag, |
||
| 1396 | // but only one with the same email address |
||
| 1397 | // <Header for 'Popularimeter', ID: 'POPM'> |
||
| 1398 | // Email to user <text string> $00 |
||
| 1399 | // Rating $xx |
||
| 1400 | // Counter $xx xx xx xx (xx ...) |
||
| 1401 | |||
| 1402 | $frame_offset = 0; |
||
| 1403 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1404 | $frame_email_address = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1405 | if (ord($frame_email_address) === 0) { |
||
| 1406 | $frame_email_address = ''; |
||
| 1407 | } |
||
| 1408 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1409 | $frame_rating = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1410 | $parsed_frame['data'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset)); |
||
| 1411 | $parsed_frame['email'] = $frame_email_address; |
||
| 1412 | $parsed_frame['rating'] = $frame_rating; |
||
| 1413 | unset($parsed_frame['data']); |
||
| 1414 | return true; |
||
| 1415 | } |
||
| 1416 | |||
| 1417 | |||
| 1418 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'RBUF')) || // 4.18 RBUF Recommended buffer size |
||
| 1419 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'BUF'))) { // 4.19 BUF Recommended buffer size |
||
| 1420 | |||
| 1421 | // There may only be one 'RBUF' frame in each tag |
||
| 1422 | // <Header for 'Recommended buffer size', ID: 'RBUF'> |
||
| 1423 | // Buffer size $xx xx xx |
||
| 1424 | // Embedded info flag %0000000x |
||
| 1425 | // Offset to next tag $xx xx xx xx |
||
| 1426 | |||
| 1427 | $frame_offset = 0; |
||
| 1428 | $parsed_frame['buffersize'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 3)); |
||
| 1429 | $frame_offset += 3; |
||
| 1430 | |||
| 1431 | $frame_embeddedinfoflags = getid3_lib::BigEndian2Bin($parsed_frame['data']{$frame_offset++}); |
||
| 1432 | $parsed_frame['flags']['embededinfo'] = (bool)substr($frame_embeddedinfoflags, 7, 1); |
||
| 1433 | $parsed_frame['nexttagoffset'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 1434 | unset($parsed_frame['data']); |
||
| 1435 | return true; |
||
| 1436 | } |
||
| 1437 | |||
| 1438 | |||
| 1439 | if (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'CRM')) { // 4.20 Encrypted meta frame (ID3v2.2 only) |
||
| 1440 | |||
| 1441 | // There may be more than one 'CRM' frame in a tag, |
||
| 1442 | // but only one with the same 'owner identifier' |
||
| 1443 | // <Header for 'Encrypted meta frame', ID: 'CRM'> |
||
| 1444 | // Owner identifier <textstring> $00 (00) |
||
| 1445 | // Content/explanation <textstring> $00 (00) |
||
| 1446 | // Encrypted datablock <binary data> |
||
| 1447 | |||
| 1448 | $frame_offset = 0; |
||
| 1449 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1450 | $frame_owner_id = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1451 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1452 | |||
| 1453 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1454 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1455 | if (ord($frame_description) === 0) { |
||
| 1456 | $frame_description = ''; |
||
| 1457 | } |
||
| 1458 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1459 | |||
| 1460 | $parsed_frame['ownerid'] = $frame_owner_id; |
||
| 1461 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1462 | $parsed_frame['description'] = $frame_description; |
||
| 1463 | unset($parsed_frame['data']); |
||
| 1464 | return true; |
||
| 1465 | } |
||
| 1466 | |||
| 1467 | |||
| 1468 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'AENC')) || // 4.19 AENC Audio encryption |
||
| 1469 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'CRA'))) { // 4.21 CRA Audio encryption |
||
| 1470 | |||
| 1471 | // There may be more than one 'AENC' frames in a tag, |
||
| 1472 | // but only one with the same 'Owner identifier' |
||
| 1473 | // <Header for 'Audio encryption', ID: 'AENC'> |
||
| 1474 | // Owner identifier <text string> $00 |
||
| 1475 | // Preview start $xx xx |
||
| 1476 | // Preview length $xx xx |
||
| 1477 | // Encryption info <binary data> |
||
| 1478 | |||
| 1479 | $frame_offset = 0; |
||
| 1480 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1481 | $frame_owner_id = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1482 | if (ord($frame_owner_id) === 0) { |
||
| 1483 | $frame_owner_id == ''; |
||
| 1484 | } |
||
| 1485 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1486 | $parsed_frame['ownerid'] = $frame_owner_id; |
||
| 1487 | $parsed_frame['previewstart'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1488 | $frame_offset += 2; |
||
| 1489 | $parsed_frame['previewlength'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1490 | $frame_offset += 2; |
||
| 1491 | $parsed_frame['encryptioninfo'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1492 | unset($parsed_frame['data']); |
||
| 1493 | return true; |
||
| 1494 | } |
||
| 1495 | |||
| 1496 | |||
| 1497 | if ((($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'LINK')) || // 4.20 LINK Linked information |
||
| 1498 | (($id3v2_major_version == 2) && ($parsed_frame['frame_name'] == 'LNK'))) { // 4.22 LNK Linked information |
||
| 1499 | |||
| 1500 | // There may be more than one 'LINK' frame in a tag, |
||
| 1501 | // but only one with the same contents |
||
| 1502 | // <Header for 'Linked information', ID: 'LINK'> |
||
| 1503 | // ID3v2.3+ => Frame identifier $xx xx xx xx |
||
| 1504 | // ID3v2.2 => Frame identifier $xx xx xx |
||
| 1505 | // URL <text string> $00 |
||
| 1506 | // ID and additional data <text string(s)> |
||
| 1507 | |||
| 1508 | $frame_offset = 0; |
||
| 1509 | if ($id3v2_major_version == 2) { |
||
| 1510 | $parsed_frame['frameid'] = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 1511 | $frame_offset += 3; |
||
| 1512 | } else { |
||
| 1513 | $parsed_frame['frameid'] = substr($parsed_frame['data'], $frame_offset, 4); |
||
| 1514 | $frame_offset += 4; |
||
| 1515 | } |
||
| 1516 | |||
| 1517 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1518 | $frame_url = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1519 | if (ord($frame_url) === 0) { |
||
| 1520 | $frame_url = ''; |
||
| 1521 | } |
||
| 1522 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1523 | $parsed_frame['url'] = $frame_url; |
||
| 1524 | |||
| 1525 | $parsed_frame['additionaldata'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1526 | if (!empty($parsed_frame['framenameshort']) && $parsed_frame['url']) { |
||
| 1527 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = utf8_encode($parsed_frame['url']); |
||
| 1528 | } |
||
| 1529 | unset($parsed_frame['data']); |
||
| 1530 | return true; |
||
| 1531 | } |
||
| 1532 | |||
| 1533 | |||
| 1534 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'POSS')) { // 4.21 POSS Position synchronisation frame (ID3v2.3+ only) |
||
| 1535 | |||
| 1536 | // There may only be one 'POSS' frame in each tag |
||
| 1537 | // <Head for 'Position synchronisation', ID: 'POSS'> |
||
| 1538 | // Time stamp format $xx |
||
| 1539 | // Position $xx (xx ...) |
||
| 1540 | |||
| 1541 | $frame_offset = 0; |
||
| 1542 | $parsed_frame['timestampformat'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1543 | $parsed_frame['position'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset)); |
||
| 1544 | unset($parsed_frame['data']); |
||
| 1545 | return true; |
||
| 1546 | } |
||
| 1547 | |||
| 1548 | |||
| 1549 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'USER')) { // 4.22 USER Terms of use (ID3v2.3+ only) |
||
| 1550 | |||
| 1551 | // There may be more than one 'Terms of use' frame in a tag, |
||
| 1552 | // but only one with the same 'Language' |
||
| 1553 | // <Header for 'Terms of use frame', ID: 'USER'> |
||
| 1554 | // Text encoding $xx |
||
| 1555 | // Language $xx xx xx |
||
| 1556 | // The actual text <text string according to encoding> |
||
| 1557 | |||
| 1558 | $frame_offset = 0; |
||
| 1559 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1560 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 1561 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 1562 | } |
||
| 1563 | $frame_language = substr($parsed_frame['data'], $frame_offset, 3); |
||
| 1564 | $frame_offset += 3; |
||
| 1565 | $parsed_frame['language'] = $frame_language; |
||
| 1566 | $parsed_frame['languagename'] = getid3_id3v2::LanguageLookup($frame_language, false); |
||
| 1567 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 1568 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 1569 | |||
| 1570 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1571 | if (!empty($parsed_frame['framenameshort']) && !empty($parsed_frame['data'])) { |
||
| 1572 | $getid3->info['id3v2']['comments'][$parsed_frame['framenameshort']][] = $getid3->iconv($parsed_frame['encoding'], 'UTF-8', $parsed_frame['data']); |
||
| 1573 | } |
||
| 1574 | unset($parsed_frame['data']); |
||
| 1575 | return true; |
||
| 1576 | } |
||
| 1577 | |||
| 1578 | |||
| 1579 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'OWNE')) { // 4.23 OWNE Ownership frame (ID3v2.3+ only) |
||
| 1580 | |||
| 1581 | // There may only be one 'OWNE' frame in a tag |
||
| 1582 | // <Header for 'Ownership frame', ID: 'OWNE'> |
||
| 1583 | // Text encoding $xx |
||
| 1584 | // Price paid <text string> $00 |
||
| 1585 | // Date of purch. <text string> |
||
| 1586 | // Seller <text string according to encoding> |
||
| 1587 | |||
| 1588 | $frame_offset = 0; |
||
| 1589 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1590 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 1591 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 1592 | } |
||
| 1593 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 1594 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 1595 | |||
| 1596 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1597 | $frame_pricepaid = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1598 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1599 | |||
| 1600 | $parsed_frame['pricepaid']['currencyid'] = substr($frame_pricepaid, 0, 3); |
||
| 1601 | $parsed_frame['pricepaid']['currency'] = getid3_id3v2::LookupCurrencyUnits($parsed_frame['pricepaid']['currencyid']); |
||
| 1602 | $parsed_frame['pricepaid']['value'] = substr($frame_pricepaid, 3); |
||
| 1603 | |||
| 1604 | $parsed_frame['purchasedate'] = substr($parsed_frame['data'], $frame_offset, 8); |
||
| 1605 | if (!getid3_id3v2::IsValidDateStampString($parsed_frame['purchasedate'])) { |
||
| 1606 | $parsed_frame['purchasedateunix'] = gmmktime (0, 0, 0, substr($parsed_frame['purchasedate'], 4, 2), substr($parsed_frame['purchasedate'], 6, 2), substr($parsed_frame['purchasedate'], 0, 4)); |
||
| 1607 | } |
||
| 1608 | $frame_offset += 8; |
||
| 1609 | |||
| 1610 | $parsed_frame['seller'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1611 | unset($parsed_frame['data']); |
||
| 1612 | return true; |
||
| 1613 | } |
||
| 1614 | |||
| 1615 | |||
| 1616 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'COMR')) { // 4.24 COMR Commercial frame (ID3v2.3+ only) |
||
| 1617 | |||
| 1618 | // There may be more than one 'commercial frame' in a tag, |
||
| 1619 | // but no two may be identical |
||
| 1620 | // <Header for 'Commercial frame', ID: 'COMR'> |
||
| 1621 | // Text encoding $xx |
||
| 1622 | // Price string <text string> $00 |
||
| 1623 | // Valid until <text string> |
||
| 1624 | // Contact URL <text string> $00 |
||
| 1625 | // Received as $xx |
||
| 1626 | // Name of seller <text string according to encoding> $00 (00) |
||
| 1627 | // Description <text string according to encoding> $00 (00) |
||
| 1628 | // Picture MIME type <string> $00 |
||
| 1629 | // Seller logo <binary data> |
||
| 1630 | |||
| 1631 | $frame_offset = 0; |
||
| 1632 | $frame_text_encoding = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1633 | if ((($id3v2_major_version <= 3) && ($frame_text_encoding > 1)) || (($id3v2_major_version == 4) && ($frame_text_encoding > 3))) { |
||
| 1634 | $getid3->warning('Invalid text encoding byte ('.$frame_text_encoding.') in frame "'.$parsed_frame['frame_name'].'" - defaulting to ISO-8859-1 encoding'); |
||
| 1635 | } |
||
| 1636 | |||
| 1637 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1638 | $frame_price_string = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1639 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1640 | $frame_rawpricearray = explode('/', $frame_price_string); |
||
| 1641 | foreach ($frame_rawpricearray as $key => $val) { |
||
| 1642 | $frame_currencyid = substr($val, 0, 3); |
||
| 1643 | $parsed_frame['price'][$frame_currencyid]['currency'] = getid3_id3v2::LookupCurrencyUnits($frame_currencyid); |
||
| 1644 | $parsed_frame['price'][$frame_currencyid]['value'] = substr($val, 3); |
||
| 1645 | } |
||
| 1646 | |||
| 1647 | $frame_date_string = substr($parsed_frame['data'], $frame_offset, 8); |
||
| 1648 | $frame_offset += 8; |
||
| 1649 | |||
| 1650 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1651 | $frame_contacturl = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1652 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1653 | |||
| 1654 | $frame_received_as_id = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1655 | |||
| 1656 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 1657 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 1658 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 1659 | } |
||
| 1660 | |||
| 1661 | $frame_sellername = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1662 | if (ord($frame_sellername) === 0) { |
||
| 1663 | $frame_sellername = ''; |
||
| 1664 | } |
||
| 1665 | |||
| 1666 | $frame_offset = $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 1667 | |||
| 1668 | $frame_terminator_pos = @strpos($parsed_frame['data'], getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding), $frame_offset); |
||
| 1669 | if (ord(substr($parsed_frame['data'], $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)), 1)) === 0) { |
||
| 1670 | $frame_terminator_pos++; // @strpos() fooled because 2nd byte of Unicode chars are often 0x00 |
||
| 1671 | } |
||
| 1672 | |||
| 1673 | $frame_description = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1674 | if (ord($frame_description) === 0) { |
||
| 1675 | $frame_description = ''; |
||
| 1676 | } |
||
| 1677 | |||
| 1678 | $frame_offset = $frame_terminator_pos + strlen(getid3_id3v2::TextEncodingTerminatorLookup($frame_text_encoding)); |
||
| 1679 | |||
| 1680 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1681 | $frame_mimetype = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1682 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1683 | |||
| 1684 | $frame_sellerlogo = substr($parsed_frame['data'], $frame_offset); |
||
| 1685 | |||
| 1686 | $parsed_frame['encodingid'] = $frame_text_encoding; |
||
| 1687 | $parsed_frame['encoding'] = $this->TextEncodingNameLookup($frame_text_encoding); |
||
| 1688 | |||
| 1689 | $parsed_frame['pricevaliduntil'] = $frame_date_string; |
||
| 1690 | $parsed_frame['contacturl'] = $frame_contacturl; |
||
| 1691 | $parsed_frame['receivedasid'] = $frame_received_as_id; |
||
| 1692 | $parsed_frame['receivedas'] = getid3_id3v2::COMRReceivedAsLookup($frame_received_as_id); |
||
| 1693 | $parsed_frame['sellername'] = $frame_sellername; |
||
| 1694 | $parsed_frame['description'] = $frame_description; |
||
| 1695 | $parsed_frame['mime'] = $frame_mimetype; |
||
| 1696 | $parsed_frame['logo'] = $frame_sellerlogo; |
||
| 1697 | unset($parsed_frame['data']); |
||
| 1698 | } |
||
| 1699 | |||
| 1700 | |||
| 1701 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'ENCR')) { // 4.25 ENCR Encryption method registration (ID3v2.3+ only) |
||
| 1702 | |||
| 1703 | // There may be several 'ENCR' frames in a tag, |
||
| 1704 | // but only one containing the same symbol |
||
| 1705 | // and only one containing the same owner identifier |
||
| 1706 | // <Header for 'Encryption method registration', ID: 'ENCR'> |
||
| 1707 | // Owner identifier <text string> $00 |
||
| 1708 | // Method symbol $xx |
||
| 1709 | // Encryption data <binary data> |
||
| 1710 | |||
| 1711 | $frame_offset = 0; |
||
| 1712 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1713 | $frame_owner_id = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1714 | if (ord($frame_owner_id) === 0) { |
||
| 1715 | $frame_owner_id = ''; |
||
| 1716 | } |
||
| 1717 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1718 | |||
| 1719 | $parsed_frame['ownerid'] = $frame_owner_id; |
||
| 1720 | $parsed_frame['methodsymbol'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1721 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1722 | return true; |
||
| 1723 | } |
||
| 1724 | |||
| 1725 | |||
| 1726 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'GRID')) { // 4.26 GRID Group identification registration (ID3v2.3+ only) |
||
| 1727 | |||
| 1728 | // There may be several 'GRID' frames in a tag, |
||
| 1729 | // but only one containing the same symbol |
||
| 1730 | // and only one containing the same owner identifier |
||
| 1731 | // <Header for 'Group ID registration', ID: 'GRID'> |
||
| 1732 | // Owner identifier <text string> $00 |
||
| 1733 | // Group symbol $xx |
||
| 1734 | // Group dependent data <binary data> |
||
| 1735 | |||
| 1736 | $frame_offset = 0; |
||
| 1737 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1738 | $frame_owner_id = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1739 | if (ord($frame_owner_id) === 0) { |
||
| 1740 | $frame_owner_id = ''; |
||
| 1741 | } |
||
| 1742 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1743 | |||
| 1744 | $parsed_frame['ownerid'] = $frame_owner_id; |
||
| 1745 | $parsed_frame['groupsymbol'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1746 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1747 | return true; |
||
| 1748 | } |
||
| 1749 | |||
| 1750 | |||
| 1751 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'PRIV')) { // 4.27 PRIV Private frame (ID3v2.3+ only) |
||
| 1752 | |||
| 1753 | // The tag may contain more than one 'PRIV' frame |
||
| 1754 | // but only with different contents |
||
| 1755 | // <Header for 'Private frame', ID: 'PRIV'> |
||
| 1756 | // Owner identifier <text string> $00 |
||
| 1757 | // The private data <binary data> |
||
| 1758 | |||
| 1759 | $frame_offset = 0; |
||
| 1760 | $frame_terminator_pos = @strpos($parsed_frame['data'], "\x00", $frame_offset); |
||
| 1761 | $frame_owner_id = substr($parsed_frame['data'], $frame_offset, $frame_terminator_pos - $frame_offset); |
||
| 1762 | if (ord($frame_owner_id) === 0) { |
||
| 1763 | $frame_owner_id = ''; |
||
| 1764 | } |
||
| 1765 | $frame_offset = $frame_terminator_pos + strlen("\x00"); |
||
| 1766 | |||
| 1767 | $parsed_frame['ownerid'] = $frame_owner_id; |
||
| 1768 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1769 | return true; |
||
| 1770 | } |
||
| 1771 | |||
| 1772 | |||
| 1773 | if (($id3v2_major_version >= 4) && ($parsed_frame['frame_name'] == 'SIGN')) { // 4.28 SIGN Signature frame (ID3v2.4+ only) |
||
| 1774 | |||
| 1775 | // There may be more than one 'signature frame' in a tag, |
||
| 1776 | // but no two may be identical |
||
| 1777 | // <Header for 'Signature frame', ID: 'SIGN'> |
||
| 1778 | // Group symbol $xx |
||
| 1779 | // Signature <binary data> |
||
| 1780 | |||
| 1781 | $frame_offset = 0; |
||
| 1782 | $parsed_frame['groupsymbol'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1783 | $parsed_frame['data'] = (string)substr($parsed_frame['data'], $frame_offset); |
||
| 1784 | return true; |
||
| 1785 | } |
||
| 1786 | |||
| 1787 | |||
| 1788 | if (($id3v2_major_version >= 4) && ($parsed_frame['frame_name'] == 'SEEK')) { // 4.29 SEEK Seek frame (ID3v2.4+ only) |
||
| 1789 | |||
| 1790 | // There may only be one 'seek frame' in a tag |
||
| 1791 | // <Header for 'Seek frame', ID: 'SEEK'> |
||
| 1792 | // Minimum offset to next tag $xx xx xx xx |
||
| 1793 | |||
| 1794 | $frame_offset = 0; |
||
| 1795 | $parsed_frame['data'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 1796 | return true; |
||
| 1797 | } |
||
| 1798 | |||
| 1799 | |||
| 1800 | if (($id3v2_major_version >= 4) && ($parsed_frame['frame_name'] == 'ASPI')) { // 4.30 ASPI Audio seek point index (ID3v2.4+ only) |
||
| 1801 | |||
| 1802 | // There may only be one 'audio seek point index' frame in a tag |
||
| 1803 | // <Header for 'Seek Point Index', ID: 'ASPI'> |
||
| 1804 | // Indexed data start (S) $xx xx xx xx |
||
| 1805 | // Indexed data length (L) $xx xx xx xx |
||
| 1806 | // Number of index points (N) $xx xx |
||
| 1807 | // Bits per index point (b) $xx |
||
| 1808 | // Then for every index point the following data is included: |
||
| 1809 | // Fraction at index (Fi) $xx (xx) |
||
| 1810 | |||
| 1811 | $frame_offset = 0; |
||
| 1812 | $parsed_frame['datastart'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 1813 | $frame_offset += 4; |
||
| 1814 | $parsed_frame['indexeddatalength'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 1815 | $frame_offset += 4; |
||
| 1816 | $parsed_frame['indexpoints'] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1817 | $frame_offset += 2; |
||
| 1818 | $parsed_frame['bitsperpoint'] = ord($parsed_frame['data']{$frame_offset++}); |
||
| 1819 | $frame_bytesperpoint = ceil($parsed_frame['bitsperpoint'] / 8); |
||
| 1820 | for ($i = 0; $i < $frame_indexpoints; $i++) { |
||
| 1821 | $parsed_frame['indexes'][$i] = getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, $frame_bytesperpoint)); |
||
| 1822 | $frame_offset += $frame_bytesperpoint; |
||
| 1823 | } |
||
| 1824 | unset($parsed_frame['data']); |
||
| 1825 | return true; |
||
| 1826 | } |
||
| 1827 | |||
| 1828 | |||
| 1829 | if (($id3v2_major_version >= 3) && ($parsed_frame['frame_name'] == 'RGAD')) { // Replay Gain Adjustment |
||
| 1830 | |||
| 1831 | // http://privatewww.essex.ac.uk/~djmrob/replaygain/file_format_id3v2.html |
||
| 1832 | // There may only be one 'RGAD' frame in a tag |
||
| 1833 | // <Header for 'Replay Gain Adjustment', ID: 'RGAD'> |
||
| 1834 | // Peak Amplitude $xx $xx $xx $xx |
||
| 1835 | // Radio Replay Gain Adjustment %aaabbbcd %dddddddd |
||
| 1836 | // Audiophile Replay Gain Adjustment %aaabbbcd %dddddddd |
||
| 1837 | // a - name code |
||
| 1838 | // b - originator code |
||
| 1839 | // c - sign bit |
||
| 1840 | // d - replay gain adjustment |
||
| 1841 | |||
| 1842 | $frame_offset = 0; |
||
| 1843 | |||
| 1844 | $parsed_frame['peakamplitude'] = (float)getid3_lib::BigEndian2Int(substr($parsed_frame['data'], $frame_offset, 4)); |
||
| 1845 | $frame_offset += 4; |
||
| 1846 | |||
| 1847 | $rg_track_adjustment = decbin(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1848 | $frame_offset += 2; |
||
| 1849 | |||
| 1850 | $rg_album_adjustment = decbin(substr($parsed_frame['data'], $frame_offset, 2)); |
||
| 1851 | $frame_offset += 2; |
||
| 1852 | |||
| 1853 | $parsed_frame['raw']['track']['name'] = bindec(substr($rg_track_adjustment, 0, 3)); |
||
| 1854 | $parsed_frame['raw']['track']['originator'] = bindec(substr($rg_track_adjustment, 3, 3)); |
||
| 1855 | $parsed_frame['raw']['track']['signbit'] = bindec($rg_track_adjustment[6]); |
||
| 1856 | $parsed_frame['raw']['track']['adjustment'] = bindec(substr($rg_track_adjustment, 7, 9)); |
||
| 1857 | $parsed_frame['raw']['album']['name'] = bindec(substr($rg_album_adjustment, 0, 3)); |
||
| 1858 | $parsed_frame['raw']['album']['originator'] = bindec(substr($rg_album_adjustment, 3, 3)); |
||
| 1859 | $parsed_frame['raw']['album']['signbit'] = bindec($rg_album_adjustment[6]); |
||
| 1860 | $parsed_frame['raw']['album']['adjustment'] = bindec(substr($rg_album_adjustment, 7, 9)); |
||
| 1861 | $parsed_frame['track']['name'] = getid3_lib_replaygain::NameLookup($parsed_frame['raw']['track']['name']); |
||
| 1862 | $parsed_frame['track']['originator'] = getid3_lib_replaygain::OriginatorLookup($parsed_frame['raw']['track']['originator']); |
||
| 1863 | $parsed_frame['track']['adjustment'] = getid3_lib_replaygain::AdjustmentLookup($parsed_frame['raw']['track']['adjustment'], $parsed_frame['raw']['track']['signbit']); |
||
| 1864 | $parsed_frame['album']['name'] = getid3_lib_replaygain::NameLookup($parsed_frame['raw']['album']['name']); |
||
| 1865 | $parsed_frame['album']['originator'] = getid3_lib_replaygain::OriginatorLookup($parsed_frame['raw']['album']['originator']); |
||
| 1866 | $parsed_frame['album']['adjustment'] = getid3_lib_replaygain::AdjustmentLookup($parsed_frame['raw']['album']['adjustment'], $parsed_frame['raw']['album']['signbit']); |
||
| 1867 | |||
| 1868 | $getid3->info['replay_gain']['track']['peak'] = $parsed_frame['peakamplitude']; |
||
| 1869 | $getid3->info['replay_gain']['track']['originator'] = $parsed_frame['track']['originator']; |
||
| 1870 | $getid3->info['replay_gain']['track']['adjustment'] = $parsed_frame['track']['adjustment']; |
||
| 1871 | $getid3->info['replay_gain']['album']['originator'] = $parsed_frame['album']['originator']; |
||
| 1872 | $getid3->info['replay_gain']['album']['adjustment'] = $parsed_frame['album']['adjustment']; |
||
| 1873 | |||
| 1874 | unset($parsed_frame['data']); |
||
| 1875 | return true; |
||
| 1876 | } |
||
| 1877 | |||
| 1878 | return true; |
||
| 1879 | } |
||
| 3280 | ?> |
||
Loading history...
In PHP, under loose comparison (like
==, or!=, orswitchconditions), values of different types might be equal.For
integervalues, zero is a special case, in particular the following results might be unexpected: