webadmin.php

/var/www/(Del)hsihk.com/wp-includes/ID3/module.audio-video.riff.php

<?php
/////////////////////////////////////////////////////////////////
/// getID3() by James Heinrich <info@getid3.org>               //
//  available at http://getid3.sourceforge.net                 //
//            or http://www.getid3.org                         //
/////////////////////////////////////////////////////////////////
// See readme.txt for more details                             //
/////////////////////////////////////////////////////////////////
//                                                             //
// module.audio-video.riff.php                                 //
// module for analyzing RIFF files                             //
// multiple formats supported by this module:                  //
//    Wave, AVI, AIFF/AIFC, (MP3,AC3)/RIFF, Wavpack v3, 8SVX   //
// dependencies: module.audio.mp3.php                          //
//               module.audio.ac3.php                          //
//               module.audio.dts.php                          //
//                                                            ///
/////////////////////////////////////////////////////////////////

/**
* @todo Parse AC-3/DTS audio inside WAVE correctly
* @todo Rewrite RIFF parser totally
*/

getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.mp3.php', __FILE__, true);
getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.ac3.php', __FILE__, true);
getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.dts.php', __FILE__, true);

class getid3_riff extends getid3_handler
{

    public function Analyze() {
        $info = &$this->getid3->info;

        // initialize these values to an empty array, otherwise they default to NULL
        // and you can't append array values to a NULL value
        $info['riff'] = array('raw'=>array());

        // Shortcuts
        $thisfile_riff             = &$info['riff'];
        $thisfile_riff_raw         = &$thisfile_riff['raw'];
        $thisfile_audio            = &$info['audio'];
        $thisfile_video            = &$info['video'];
        $thisfile_audio_dataformat = &$thisfile_audio['dataformat'];
        $thisfile_riff_audio       = &$thisfile_riff['audio'];
        $thisfile_riff_video       = &$thisfile_riff['video'];

        $Original['avdataoffset'] = $info['avdataoffset'];
        $Original['avdataend']    = $info['avdataend'];

        $this->fseek($info['avdataoffset']);
        $RIFFheader = $this->fread(12);
        $offset = $this->ftell();
        $RIFFtype    = substr($RIFFheader, 0, 4);
        $RIFFsize    = substr($RIFFheader, 4, 4);
        $RIFFsubtype = substr($RIFFheader, 8, 4);

        switch ($RIFFtype) {

            case 'FORM':  // AIFF, AIFC
                $info['fileformat']   = 'aiff';
                $thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
                $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($offset, ($offset + $thisfile_riff['header_size'] - 4));
                break;

            case 'RIFF':  // AVI, WAV, etc
            case 'SDSS':  // SDSS is identical to RIFF, just renamed. Used by SmartSound QuickTracks (www.smartsound.com)
            case 'RMP3':  // RMP3 is identical to RIFF, just renamed. Used by [unknown program] when creating RIFF-MP3s
                $info['fileformat']   = 'riff';
                $thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
                if ($RIFFsubtype == 'RMP3') {
                    // RMP3 is identical to WAVE, just renamed. Used by [unknown program] when creating RIFF-MP3s
                    $RIFFsubtype = 'WAVE';
                }
                $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($offset, ($offset + $thisfile_riff['header_size'] - 4));
                if (($info['avdataend'] - $info['filesize']) == 1) {
                    // LiteWave appears to incorrectly *not* pad actual output file
                    // to nearest WORD boundary so may appear to be short by one
                    // byte, in which case - skip warning
                    $info['avdataend'] = $info['filesize'];
                }

                $nextRIFFoffset = $Original['avdataoffset'] + 8 + $thisfile_riff['header_size']; // 8 = "RIFF" + 32-bit offset
                while ($nextRIFFoffset < min($info['filesize'], $info['avdataend'])) {
                    try {
                        $this->fseek($nextRIFFoffset);
                    } catch (getid3_exception $e) {
                        if ($e->getCode() == 10) {
                            //$this->warning('RIFF parser: '.$e->getMessage());
                            $this->error('AVI extends beyond '.round(PHP_INT_MAX / 1073741824).'GB and PHP filesystem functions cannot read that far, playtime may be wrong');
                            $this->warning('[avdataend] value may be incorrect, multiple AVIX chunks may be present');
                            break;
                        } else {
                            throw $e;
                        }
                    }
                    $nextRIFFheader = $this->fread(12);
                    if ($nextRIFFoffset == ($info['avdataend'] - 1)) {
                        if (substr($nextRIFFheader, 0, 1) == "\x00") {
                            // RIFF padded to WORD boundary, we're actually already at the end
                            break;
                        }
                    }
                    $nextRIFFheaderID =                         substr($nextRIFFheader, 0, 4);
                    $nextRIFFsize     = $this->EitherEndian2Int(substr($nextRIFFheader, 4, 4));
                    $nextRIFFtype     =                         substr($nextRIFFheader, 8, 4);
                    $chunkdata = array();
                    $chunkdata['offset'] = $nextRIFFoffset + 8;
                    $chunkdata['size']   = $nextRIFFsize;
                    $nextRIFFoffset = $chunkdata['offset'] + $chunkdata['size'];

                    switch ($nextRIFFheaderID) {

                        case 'RIFF':
                            $chunkdata['chunks'] = $this->ParseRIFF($chunkdata['offset'] + 4, $nextRIFFoffset);

                            if (!isset($thisfile_riff[$nextRIFFtype])) {
                                $thisfile_riff[$nextRIFFtype] = array();
                            }
                            $thisfile_riff[$nextRIFFtype][] = $chunkdata;
                            break;

                        case 'JUNK':
                            // ignore
                            $thisfile_riff[$nextRIFFheaderID][] = $chunkdata;
                            break;

                        case 'IDVX':
                            $info['divxtag']['comments'] = self::ParseDIVXTAG($this->fread($chunkdata['size']));
                            break;

                        default:
                            if ($info['filesize'] == ($chunkdata['offset'] - 8 + 128)) {
                                $DIVXTAG = $nextRIFFheader.$this->fread(128 - 12);
                                if (substr($DIVXTAG, -7) == 'DIVXTAG') {
                                    // DIVXTAG is supposed to be inside an IDVX chunk in a LIST chunk, but some bad encoders just slap it on the end of a file
                                    $this->warning('Found wrongly-structured DIVXTAG at offset '.($this->ftell() - 128).', parsing anyway');
                                    $info['divxtag']['comments'] = self::ParseDIVXTAG($DIVXTAG);
                                    break 2;
                                }
                            }
                            $this->warning('Expecting "RIFF|JUNK|IDVX" at '.$nextRIFFoffset.', found "'.$nextRIFFheaderID.'" ('.getid3_lib::PrintHexBytes($nextRIFFheaderID).') - skipping rest of file');
                            break 2;

                    }

                }
                if ($RIFFsubtype == 'WAVE') {
                    $thisfile_riff_WAVE = &$thisfile_riff['WAVE'];
                }
                break;

            default:
                $this->error('Cannot parse RIFF (this is maybe not a RIFF / WAV / AVI file?) - expecting "FORM|RIFF|SDSS|RMP3" found "'.$RIFFsubtype.'" instead');
                unset($info['fileformat']);
                return false;
        }

        $streamindex = 0;
        switch ($RIFFsubtype) {
            case 'WAVE':
                if (empty($thisfile_audio['bitrate_mode'])) {
                    $thisfile_audio['bitrate_mode'] = 'cbr';
                }
                if (empty($thisfile_audio_dataformat)) {
                    $thisfile_audio_dataformat = 'wav';
                }

                if (isset($thisfile_riff_WAVE['data'][0]['offset'])) {
                    $info['avdataoffset'] = $thisfile_riff_WAVE['data'][0]['offset'] + 8;
                    $info['avdataend']    = $info['avdataoffset'] + $thisfile_riff_WAVE['data'][0]['size'];
                }
                if (isset($thisfile_riff_WAVE['fmt '][0]['data'])) {

                    $thisfile_riff_audio[$streamindex] = self::parseWAVEFORMATex($thisfile_riff_WAVE['fmt '][0]['data']);
                    $thisfile_audio['wformattag'] = $thisfile_riff_audio[$streamindex]['raw']['wFormatTag'];
                    if (!isset($thisfile_riff_audio[$streamindex]['bitrate']) || ($thisfile_riff_audio[$streamindex]['bitrate'] == 0)) {
                        $info['error'][] = 'Corrupt RIFF file: bitrate_audio == zero';
                        return false;
                    }
                    $thisfile_riff_raw['fmt '] = $thisfile_riff_audio[$streamindex]['raw'];
                    unset($thisfile_riff_audio[$streamindex]['raw']);
                    $thisfile_audio['streams'][$streamindex] = $thisfile_riff_audio[$streamindex];

                    $thisfile_audio = getid3_lib::array_merge_noclobber($thisfile_audio, $thisfile_riff_audio[$streamindex]);
                    if (substr($thisfile_audio['codec'], 0, strlen('unknown: 0x')) == 'unknown: 0x') {
                        $info['warning'][] = 'Audio codec = '.$thisfile_audio['codec'];
                    }
                    $thisfile_audio['bitrate'] = $thisfile_riff_audio[$streamindex]['bitrate'];

                    if (empty($info['playtime_seconds'])) { // may already be set (e.g. DTS-WAV)
                        $info['playtime_seconds'] = (float) ((($info['avdataend'] - $info['avdataoffset']) * 8) / $thisfile_audio['bitrate']);
                    }

                    $thisfile_audio['lossless'] = false;
                    if (isset($thisfile_riff_WAVE['data'][0]['offset']) && isset($thisfile_riff_raw['fmt ']['wFormatTag'])) {
                        switch ($thisfile_riff_raw['fmt ']['wFormatTag']) {

                            case 0x0001:  // PCM
                                $thisfile_audio['lossless'] = true;
                                break;

                            case 0x2000:  // AC-3
                                $thisfile_audio_dataformat = 'ac3';
                                break;

                            default:
                                // do nothing
                                break;

                        }
                    }
                    $thisfile_audio['streams'][$streamindex]['wformattag']   = $thisfile_audio['wformattag'];
                    $thisfile_audio['streams'][$streamindex]['bitrate_mode'] = $thisfile_audio['bitrate_mode'];
                    $thisfile_audio['streams'][$streamindex]['lossless']     = $thisfile_audio['lossless'];
                    $thisfile_audio['streams'][$streamindex]['dataformat']   = $thisfile_audio_dataformat;
                }

                if (isset($thisfile_riff_WAVE['rgad'][0]['data'])) {

                    // shortcuts
                    $rgadData = &$thisfile_riff_WAVE['rgad'][0]['data'];
                    $thisfile_riff_raw['rgad']    = array('track'=>array(), 'album'=>array());
                    $thisfile_riff_raw_rgad       = &$thisfile_riff_raw['rgad'];
                    $thisfile_riff_raw_rgad_track = &$thisfile_riff_raw_rgad['track'];
                    $thisfile_riff_raw_rgad_album = &$thisfile_riff_raw_rgad['album'];

                    $thisfile_riff_raw_rgad['fPeakAmplitude']      = getid3_lib::LittleEndian2Float(substr($rgadData, 0, 4));
                    $thisfile_riff_raw_rgad['nRadioRgAdjust']      =        $this->EitherEndian2Int(substr($rgadData, 4, 2));
                    $thisfile_riff_raw_rgad['nAudiophileRgAdjust'] =        $this->EitherEndian2Int(substr($rgadData, 6, 2));

                    $nRadioRgAdjustBitstring      = str_pad(getid3_lib::Dec2Bin($thisfile_riff_raw_rgad['nRadioRgAdjust']), 16, '0', STR_PAD_LEFT);
                    $nAudiophileRgAdjustBitstring = str_pad(getid3_lib::Dec2Bin($thisfile_riff_raw_rgad['nAudiophileRgAdjust']), 16, '0', STR_PAD_LEFT);
                    $thisfile_riff_raw_rgad_track['name']       = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring, 0, 3));
                    $thisfile_riff_raw_rgad_track['originator'] = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring, 3, 3));
                    $thisfile_riff_raw_rgad_track['signbit']    = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring, 6, 1));
                    $thisfile_riff_raw_rgad_track['adjustment'] = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring, 7, 9));
                    $thisfile_riff_raw_rgad_album['name']       = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring, 0, 3));
                    $thisfile_riff_raw_rgad_album['originator'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring, 3, 3));
                    $thisfile_riff_raw_rgad_album['signbit']    = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring, 6, 1));
                    $thisfile_riff_raw_rgad_album['adjustment'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring, 7, 9));

                    $thisfile_riff['rgad']['peakamplitude'] = $thisfile_riff_raw_rgad['fPeakAmplitude'];
                    if (($thisfile_riff_raw_rgad_track['name'] != 0) && ($thisfile_riff_raw_rgad_track['originator'] != 0)) {
                        $thisfile_riff['rgad']['track']['name']            = getid3_lib::RGADnameLookup($thisfile_riff_raw_rgad_track['name']);
                        $thisfile_riff['rgad']['track']['originator']      = getid3_lib::RGADoriginatorLookup($thisfile_riff_raw_rgad_track['originator']);
                        $thisfile_riff['rgad']['track']['adjustment']      = getid3_lib::RGADadjustmentLookup($thisfile_riff_raw_rgad_track['adjustment'], $thisfile_riff_raw_rgad_track['signbit']);
                    }
                    if (($thisfile_riff_raw_rgad_album['name'] != 0) && ($thisfile_riff_raw_rgad_album['originator'] != 0)) {
                        $thisfile_riff['rgad']['album']['name']       = getid3_lib::RGADnameLookup($thisfile_riff_raw_rgad_album['name']);
                        $thisfile_riff['rgad']['album']['originator'] = getid3_lib::RGADoriginatorLookup($thisfile_riff_raw_rgad_album['originator']);
                        $thisfile_riff['rgad']['album']['adjustment'] = getid3_lib::RGADadjustmentLookup($thisfile_riff_raw_rgad_album['adjustment'], $thisfile_riff_raw_rgad_album['signbit']);
                    }
                }

                if (isset($thisfile_riff_WAVE['fact'][0]['data'])) {
                    $thisfile_riff_raw['fact']['NumberOfSamples'] = $this->EitherEndian2Int(substr($thisfile_riff_WAVE['fact'][0]['data'], 0, 4));

                    // This should be a good way of calculating exact playtime,
                    // but some sample files have had incorrect number of samples,
                    // so cannot use this method

                    // if (!empty($thisfile_riff_raw['fmt ']['nSamplesPerSec'])) {
                    //     $info['playtime_seconds'] = (float) $thisfile_riff_raw['fact']['NumberOfSamples'] / $thisfile_riff_raw['fmt ']['nSamplesPerSec'];
                    // }
                }
                if (!empty($thisfile_riff_raw['fmt ']['nAvgBytesPerSec'])) {
                    $thisfile_audio['bitrate'] = getid3_lib::CastAsInt($thisfile_riff_raw['fmt ']['nAvgBytesPerSec'] * 8);
                }

                if (isset($thisfile_riff_WAVE['bext'][0]['data'])) {
                    // shortcut
                    $thisfile_riff_WAVE_bext_0 = &$thisfile_riff_WAVE['bext'][0];

                    $thisfile_riff_WAVE_bext_0['title']          =                         trim(substr($thisfile_riff_WAVE_bext_0['data'],   0, 256));
                    $thisfile_riff_WAVE_bext_0['author']         =                         trim(substr($thisfile_riff_WAVE_bext_0['data'], 256,  32));
                    $thisfile_riff_WAVE_bext_0['reference']      =                         trim(substr($thisfile_riff_WAVE_bext_0['data'], 288,  32));
                    $thisfile_riff_WAVE_bext_0['origin_date']    =                              substr($thisfile_riff_WAVE_bext_0['data'], 320,  10);
                    $thisfile_riff_WAVE_bext_0['origin_time']    =                              substr($thisfile_riff_WAVE_bext_0['data'], 330,   8);
                    $thisfile_riff_WAVE_bext_0['time_reference'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_bext_0['data'], 338,   8));
                    $thisfile_riff_WAVE_bext_0['bwf_version']    = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_bext_0['data'], 346,   1));
                    $thisfile_riff_WAVE_bext_0['reserved']       =                              substr($thisfile_riff_WAVE_bext_0['data'], 347, 254);
                    $thisfile_riff_WAVE_bext_0['coding_history'] =         explode("\r\n", trim(substr($thisfile_riff_WAVE_bext_0['data'], 601)));
                    if (preg_match('#^([0-9]{4}).([0-9]{2}).([0-9]{2})$#', $thisfile_riff_WAVE_bext_0['origin_date'], $matches_bext_date)) {
                        if (preg_match('#^([0-9]{2}).([0-9]{2}).([0-9]{2})$#', $thisfile_riff_WAVE_bext_0['origin_time'], $matches_bext_time)) {
                            list($dummy, $bext_timestamp['year'], $bext_timestamp['month'],  $bext_timestamp['day'])    = $matches_bext_date;
                            list($dummy, $bext_timestamp['hour'], $bext_timestamp['minute'], $bext_timestamp['second']) = $matches_bext_time;
                            $thisfile_riff_WAVE_bext_0['origin_date_unix'] = gmmktime($bext_timestamp['hour'], $bext_timestamp['minute'], $bext_timestamp['second'], $bext_timestamp['month'], $bext_timestamp['day'], $bext_timestamp['year']);
                        } else {
                            $info['warning'][] = 'RIFF.WAVE.BEXT.origin_time is invalid';
                        }
                    } else {
                        $info['warning'][] = 'RIFF.WAVE.BEXT.origin_date is invalid';
                    }
                    $thisfile_riff['comments']['author'][] = $thisfile_riff_WAVE_bext_0['author'];
                    $thisfile_riff['comments']['title'][]  = $thisfile_riff_WAVE_bext_0['title'];
                }

                if (isset($thisfile_riff_WAVE['MEXT'][0]['data'])) {
                    // shortcut
                    $thisfile_riff_WAVE_MEXT_0 = &$thisfile_riff_WAVE['MEXT'][0];

                    $thisfile_riff_WAVE_MEXT_0['raw']['sound_information']      = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 0, 2));
                    $thisfile_riff_WAVE_MEXT_0['flags']['homogenous']           = (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['sound_information'] & 0x0001);
                    if ($thisfile_riff_WAVE_MEXT_0['flags']['homogenous']) {
                        $thisfile_riff_WAVE_MEXT_0['flags']['padding']          = ($thisfile_riff_WAVE_MEXT_0['raw']['sound_information'] & 0x0002) ? false : true;
                        $thisfile_riff_WAVE_MEXT_0['flags']['22_or_44']         =        (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['sound_information'] & 0x0004);
                        $thisfile_riff_WAVE_MEXT_0['flags']['free_format']      =        (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['sound_information'] & 0x0008);

                        $thisfile_riff_WAVE_MEXT_0['nominal_frame_size']        = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 2, 2));
                    }
                    $thisfile_riff_WAVE_MEXT_0['anciliary_data_length']         = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 6, 2));
                    $thisfile_riff_WAVE_MEXT_0['raw']['anciliary_data_def']     = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 8, 2));
                    $thisfile_riff_WAVE_MEXT_0['flags']['anciliary_data_left']  = (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['anciliary_data_def'] & 0x0001);
                    $thisfile_riff_WAVE_MEXT_0['flags']['anciliary_data_free']  = (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['anciliary_data_def'] & 0x0002);
                    $thisfile_riff_WAVE_MEXT_0['flags']['anciliary_data_right'] = (bool) ($thisfile_riff_WAVE_MEXT_0['raw']['anciliary_data_def'] & 0x0004);
                }

                if (isset($thisfile_riff_WAVE['cart'][0]['data'])) {
                    // shortcut
                    $thisfile_riff_WAVE_cart_0 = &$thisfile_riff_WAVE['cart'][0];

                    $thisfile_riff_WAVE_cart_0['version']              =                              substr($thisfile_riff_WAVE_cart_0['data'],   0,  4);
                    $thisfile_riff_WAVE_cart_0['title']                =                         trim(substr($thisfile_riff_WAVE_cart_0['data'],   4, 64));
                    $thisfile_riff_WAVE_cart_0['artist']               =                         trim(substr($thisfile_riff_WAVE_cart_0['data'],  68, 64));
                    $thisfile_riff_WAVE_cart_0['cut_id']               =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 132, 64));
                    $thisfile_riff_WAVE_cart_0['client_id']            =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 196, 64));
                    $thisfile_riff_WAVE_cart_0['category']             =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 260, 64));
                    $thisfile_riff_WAVE_cart_0['classification']       =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 324, 64));
                    $thisfile_riff_WAVE_cart_0['out_cue']              =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 388, 64));
                    $thisfile_riff_WAVE_cart_0['start_date']           =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 452, 10));
                    $thisfile_riff_WAVE_cart_0['start_time']           =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 462,  8));
                    $thisfile_riff_WAVE_cart_0['end_date']             =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 470, 10));
                    $thisfile_riff_WAVE_cart_0['end_time']             =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 480,  8));
                    $thisfile_riff_WAVE_cart_0['producer_app_id']      =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 488, 64));
                    $thisfile_riff_WAVE_cart_0['producer_app_version'] =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 552, 64));
                    $thisfile_riff_WAVE_cart_0['user_defined_text']    =                         trim(substr($thisfile_riff_WAVE_cart_0['data'], 616, 64));
                    $thisfile_riff_WAVE_cart_0['zero_db_reference']    = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_cart_0['data'], 680,  4), true);
                    for ($i = 0; $i < 8; $i++) {
                        $thisfile_riff_WAVE_cart_0['post_time'][$i]['usage_fourcc'] =                  substr($thisfile_riff_WAVE_cart_0['data'], 684 + ($i * 8), 4);
                        $thisfile_riff_WAVE_cart_0['post_time'][$i]['timer_value']  = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_cart_0['data'], 684 + ($i * 8) + 4, 4));
                    }
                    $thisfile_riff_WAVE_cart_0['url']              =                 trim(substr($thisfile_riff_WAVE_cart_0['data'],  748, 1024));
                    $thisfile_riff_WAVE_cart_0['tag_text']         = explode("\r\n", trim(substr($thisfile_riff_WAVE_cart_0['data'], 1772)));

                    $thisfile_riff['comments']['artist'][] = $thisfile_riff_WAVE_cart_0['artist'];
                    $thisfile_riff['comments']['title'][]  = $thisfile_riff_WAVE_cart_0['title'];
                }

                if (isset($thisfile_riff_WAVE['SNDM'][0]['data'])) {
                    // SoundMiner metadata

                    // shortcuts
                    $thisfile_riff_WAVE_SNDM_0      = &$thisfile_riff_WAVE['SNDM'][0];
                    $thisfile_riff_WAVE_SNDM_0_data = &$thisfile_riff_WAVE_SNDM_0['data'];
                    $SNDM_startoffset = 0;
                    $SNDM_endoffset   = $thisfile_riff_WAVE_SNDM_0['size'];

                    while ($SNDM_startoffset < $SNDM_endoffset) {
                        $SNDM_thisTagOffset = 0;
                        $SNDM_thisTagSize      = getid3_lib::BigEndian2Int(substr($thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4));
                        $SNDM_thisTagOffset += 4;
                        $SNDM_thisTagKey       =                           substr($thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4);
                        $SNDM_thisTagOffset += 4;
                        $SNDM_thisTagDataSize  = getid3_lib::BigEndian2Int(substr($thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2));
                        $SNDM_thisTagOffset += 2;
                        $SNDM_thisTagDataFlags = getid3_lib::BigEndian2Int(substr($thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2));
                        $SNDM_thisTagOffset += 2;
                        $SNDM_thisTagDataText =                            substr($thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, $SNDM_thisTagDataSize);
                        $SNDM_thisTagOffset += $SNDM_thisTagDataSize;

                        if ($SNDM_thisTagSize != (4 + 4 + 2 + 2 + $SNDM_thisTagDataSize)) {
                            $info['warning'][] = 'RIFF.WAVE.SNDM.data contains tag not expected length (expected: '.$SNDM_thisTagSize.', found: '.(4 + 4 + 2 + 2 + $SNDM_thisTagDataSize).') at offset '.$SNDM_startoffset.' (file offset '.($thisfile_riff_WAVE_SNDM_0['offset'] + $SNDM_startoffset).')';
                            break;
                        } elseif ($SNDM_thisTagSize <= 0) {
                            $info['warning'][] = 'RIFF.WAVE.SNDM.data contains zero-size tag at offset '.$SNDM_startoffset.' (file offset '.($thisfile_riff_WAVE_SNDM_0['offset'] + $SNDM_startoffset).')';
                            break;
                        }
                        $SNDM_startoffset += $SNDM_thisTagSize;

                        $thisfile_riff_WAVE_SNDM_0['parsed_raw'][$SNDM_thisTagKey] = $SNDM_thisTagDataText;
                        if ($parsedkey = self::waveSNDMtagLookup($SNDM_thisTagKey)) {
                            $thisfile_riff_WAVE_SNDM_0['parsed'][$parsedkey] = $SNDM_thisTagDataText;
                        } else {
                            $info['warning'][] = 'RIFF.WAVE.SNDM contains unknown tag "'.$SNDM_thisTagKey.'" at offset '.$SNDM_startoffset.' (file offset '.($thisfile_riff_WAVE_SNDM_0['offset'] + $SNDM_startoffset).')';
                        }
                    }

                    $tagmapping = array(
                        'tracktitle'=>'title',
                        'category'  =>'genre',
                        'cdtitle'   =>'album',
                        'tracktitle'=>'title',
                    );
                    foreach ($tagmapping as $fromkey => $tokey) {
                        if (isset($thisfile_riff_WAVE_SNDM_0['parsed'][$fromkey])) {
                            $thisfile_riff['comments'][$tokey][] = $thisfile_riff_WAVE_SNDM_0['parsed'][$fromkey];
                        }
                    }
                }

                if (isset($thisfile_riff_WAVE['iXML'][0]['data'])) {
                    // requires functions simplexml_load_string and get_object_vars
                    if ($parsedXML = getid3_lib::XML2array($thisfile_riff_WAVE['iXML'][0]['data'])) {
                        $thisfile_riff_WAVE['iXML'][0]['parsed'] = $parsedXML;
                        if (isset($parsedXML['SPEED']['MASTER_SPEED'])) {
                            @list($numerator, $denominator) = explode('/', $parsedXML['SPEED']['MASTER_SPEED']);
                            $thisfile_riff_WAVE['iXML'][0]['master_speed'] = $numerator / ($denominator ? $denominator : 1000);
                        }
                        if (isset($parsedXML['SPEED']['TIMECODE_RATE'])) {
                            @list($numerator, $denominator) = explode('/', $parsedXML['SPEED']['TIMECODE_RATE']);
                            $thisfile_riff_WAVE['iXML'][0]['timecode_rate'] = $numerator / ($denominator ? $denominator : 1000);
                        }
                        if (isset($parsedXML['SPEED']['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_LO']) && !empty($parsedXML['SPEED']['TIMESTAMP_SAMPLE_RATE']) && !empty($thisfile_riff_WAVE['iXML'][0]['timecode_rate'])) {
                            $samples_since_midnight = floatval(ltrim($parsedXML['SPEED']['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_HI'].$parsedXML['SPEED']['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_LO'], '0'));
                            $thisfile_riff_WAVE['iXML'][0]['timecode_seconds'] = $samples_since_midnight / $parsedXML['SPEED']['TIMESTAMP_SAMPLE_RATE'];
                            $h = floor( $thisfile_riff_WAVE['iXML'][0]['timecode_seconds']       / 3600);
                            $m = floor(($thisfile_riff_WAVE['iXML'][0]['timecode_seconds'] - ($h * 3600))      / 60);
                            $s = floor( $thisfile_riff_WAVE['iXML'][0]['timecode_seconds'] - ($h * 3600) - ($m * 60));
                            $f =       ($thisfile_riff_WAVE['iXML'][0]['timecode_seconds'] - ($h * 3600) - ($m * 60) - $s) * $thisfile_riff_WAVE['iXML'][0]['timecode_rate'];
                            $thisfile_riff_WAVE['iXML'][0]['timecode_string']       = sprintf('%02d:%02d:%02d:%05.2f', $h, $m, $s,       $f);
                            $thisfile_riff_WAVE['iXML'][0]['timecode_string_round'] = sprintf('%02d:%02d:%02d:%02d',   $h, $m, $s, round($f));
                        }
                        unset($parsedXML);
                    }
                }



                if (!isset($thisfile_audio['bitrate']) && isset($thisfile_riff_audio[$streamindex]['bitrate'])) {
                    $thisfile_audio['bitrate'] = $thisfile_riff_audio[$streamindex]['bitrate'];
                    $info['playtime_seconds'] = (float) ((($info['avdataend'] - $info['avdataoffset']) * 8) / $thisfile_audio['bitrate']);
                }

                if (!empty($info['wavpack'])) {
                    $thisfile_audio_dataformat = 'wavpack';
                    $thisfile_audio['bitrate_mode'] = 'vbr';
                    $thisfile_audio['encoder']      = 'WavPack v'.$info['wavpack']['version'];

                    // Reset to the way it was - RIFF parsing will have messed this up
                    $info['avdataend']        = $Original['avdataend'];
                    $thisfile_audio['bitrate'] = (($info['avdataend'] - $info['avdataoffset']) * 8) / $info['playtime_seconds'];

                    $this->fseek($info['avdataoffset'] - 44);
                    $RIFFdata = $this->fread(44);
                    $OrignalRIFFheaderSize = getid3_lib::LittleEndian2Int(substr($RIFFdata,  4, 4)) +  8;
                    $OrignalRIFFdataSize   = getid3_lib::LittleEndian2Int(substr($RIFFdata, 40, 4)) + 44;

                    if ($OrignalRIFFheaderSize > $OrignalRIFFdataSize) {
                        $info['avdataend'] -= ($OrignalRIFFheaderSize - $OrignalRIFFdataSize);
                        $this->fseek($info['avdataend']);
                        $RIFFdata .= $this->fread($OrignalRIFFheaderSize - $OrignalRIFFdataSize);
                    }

                    // move the data chunk after all other chunks (if any)
                    // so that the RIFF parser doesn't see EOF when trying
                    // to skip over the data chunk
                    $RIFFdata = substr($RIFFdata, 0, 36).substr($RIFFdata, 44).substr($RIFFdata, 36, 8);
                    $getid3_riff = new getid3_riff($this->getid3);
                    $getid3_riff->ParseRIFFdata($RIFFdata);
                    unset($getid3_riff);
                }

                if (isset($thisfile_riff_raw['fmt ']['wFormatTag'])) {
                    switch ($thisfile_riff_raw['fmt ']['wFormatTag']) {
                        case 0x0001: // PCM
                            if (!empty($info['ac3'])) {
                                // Dolby Digital WAV files masquerade as PCM-WAV, but they're not
                                $thisfile_audio['wformattag']  = 0x2000;
                                $thisfile_audio['codec']       = self::wFormatTagLookup($thisfile_audio['wformattag']);
                                $thisfile_audio['lossless']    = false;
                                $thisfile_audio['bitrate']     = $info['ac3']['bitrate'];
                                $thisfile_audio['sample_rate'] = $info['ac3']['sample_rate'];
                            }
                            if (!empty($info['dts'])) {
                                // Dolby DTS files masquerade as PCM-WAV, but they're not
                                $thisfile_audio['wformattag']  = 0x2001;
                                $thisfile_audio['codec']       = self::wFormatTagLookup($thisfile_audio['wformattag']);
                                $thisfile_audio['lossless']    = false;
                                $thisfile_audio['bitrate']     = $info['dts']['bitrate'];
                                $thisfile_audio['sample_rate'] = $info['dts']['sample_rate'];
                            }
                            break;
                        case 0x08AE: // ClearJump LiteWave
                            $thisfile_audio['bitrate_mode'] = 'vbr';
                            $thisfile_audio_dataformat   = 'litewave';

                            //typedef struct tagSLwFormat {
                            //  WORD    m_wCompFormat;     // low byte defines compression method, high byte is compression flags
                            //  DWORD   m_dwScale;         // scale factor for lossy compression
                            //  DWORD   m_dwBlockSize;     // number of samples in encoded blocks
                            //  WORD    m_wQuality;        // alias for the scale factor
                            //  WORD    m_wMarkDistance;   // distance between marks in bytes
                            //  WORD    m_wReserved;
                            //
                            //  //following paramters are ignored if CF_FILESRC is not set
                            //  DWORD   m_dwOrgSize;       // original file size in bytes
                            //  WORD    m_bFactExists;     // indicates if 'fact' chunk exists in the original file
                            //  DWORD   m_dwRiffChunkSize; // riff chunk size in the original file
                            //
                            //  PCMWAVEFORMAT m_OrgWf;     // original wave format
                            // }SLwFormat, *PSLwFormat;

                            // shortcut
                            $thisfile_riff['litewave']['raw'] = array();
                            $riff_litewave     = &$thisfile_riff['litewave'];
                            $riff_litewave_raw = &$riff_litewave['raw'];

                            $flags = array(
                                'compression_method' => 1,
                                'compression_flags'  => 1,
                                'm_dwScale'          => 4,
                                'm_dwBlockSize'      => 4,
                                'm_wQuality'         => 2,
                                'm_wMarkDistance'    => 2,
                                'm_wReserved'        => 2,
                                'm_dwOrgSize'        => 4,
                                'm_bFactExists'      => 2,
                                'm_dwRiffChunkSize'  => 4,
                            );
                            $litewave_offset = 18;
                            foreach ($flags as $flag => $length) {
                                $riff_litewave_raw[$flag] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE['fmt '][0]['data'], $litewave_offset, $length));
                                $litewave_offset += $length;
                            }

                            //$riff_litewave['quality_factor'] = intval(round((2000 - $riff_litewave_raw['m_dwScale']) / 20));
                            $riff_litewave['quality_factor'] = $riff_litewave_raw['m_wQuality'];

                            $riff_litewave['flags']['raw_source']    = ($riff_litewave_raw['compression_flags'] & 0x01) ? false : true;
                            $riff_litewave['flags']['vbr_blocksize'] = ($riff_litewave_raw['compression_flags'] & 0x02) ? false : true;
                            $riff_litewave['flags']['seekpoints']    =        (bool) ($riff_litewave_raw['compression_flags'] & 0x04);

                            $thisfile_audio['lossless']        = (($riff_litewave_raw['m_wQuality'] == 100) ? true : false);
                            $thisfile_audio['encoder_options'] = '-q'.$riff_litewave['quality_factor'];
                            break;

                        default:
                            break;
                    }
                }
                if ($info['avdataend'] > $info['filesize']) {
                    switch (!empty($thisfile_audio_dataformat) ? $thisfile_audio_dataformat : '') {
                        case 'wavpack': // WavPack
                        case 'lpac':    // LPAC
                        case 'ofr':     // OptimFROG
                        case 'ofs':     // OptimFROG DualStream
                            // lossless compressed audio formats that keep original RIFF headers - skip warning
                            break;

                        case 'litewave':
                            if (($info['avdataend'] - $info['filesize']) == 1) {
                                // LiteWave appears to incorrectly *not* pad actual output file
                                // to nearest WORD boundary so may appear to be short by one
                                // byte, in which case - skip warning
                            } else {
                                // Short by more than one byte, throw warning
                                $info['warning'][] = 'Probably truncated file - expecting '.$thisfile_riff[$RIFFsubtype]['data'][0]['size'].' bytes of data, only found '.($info['filesize'] - $info['avdataoffset']).' (short by '.($thisfile_riff[$RIFFsubtype]['data'][0]['size'] - ($info['filesize'] - $info['avdataoffset'])).' bytes)';
                                $info['avdataend'] = $info['filesize'];
                            }
                            break;

                        default:
                            if ((($info['avdataend'] - $info['filesize']) == 1) && (($thisfile_riff[$RIFFsubtype]['data'][0]['size'] % 2) == 0) && ((($info['filesize'] - $info['avdataoffset']) % 2) == 1)) {
                                // output file appears to be incorrectly *not* padded to nearest WORD boundary
                                // Output less severe warning
                                $info['warning'][] = 'File should probably be padded to nearest WORD boundary, but it is not (expecting '.$thisfile_riff[$RIFFsubtype]['data'][0]['size'].' bytes of data, only found '.($info['filesize'] - $info['avdataoffset']).' therefore short by '.($thisfile_riff[$RIFFsubtype]['data'][0]['size'] - ($info['filesize'] - $info['avdataoffset'])).' bytes)';
                                $info['avdataend'] = $info['filesize'];
                            } else {
                                // Short by more than one byte, throw warning
                                $info['warning'][] = 'Probably truncated file - expecting '.$thisfile_riff[$RIFFsubtype]['data'][0]['size'].' bytes of data, only found '.($info['filesize'] - $info['avdataoffset']).' (short by '.($thisfile_riff[$RIFFsubtype]['data'][0]['size'] - ($info['filesize'] - $info['avdataoffset'])).' bytes)';
                                $info['avdataend'] = $info['filesize'];
                            }
                            break;
                    }
                }
                if (!empty($info['mpeg']['audio']['LAME']['audio_bytes'])) {
                    if ((($info['avdataend'] - $info['avdataoffset']) - $info['mpeg']['audio']['LAME']['audio_bytes']) == 1) {
                        $info['avdataend']--;
                        $info['warning'][] = 'Extra null byte at end of MP3 data assumed to be RIFF padding and therefore ignored';
                    }
                }
                if (isset($thisfile_audio_dataformat) && ($thisfile_audio_dataformat == 'ac3')) {
                    unset($thisfile_audio['bits_per_sample']);
                    if (!empty($info['ac3']['bitrate']) && ($info['ac3']['bitrate'] != $thisfile_audio['bitrate'])) {
                        $thisfile_audio['bitrate'] = $info['ac3']['bitrate'];
                    }
                }
                break;

            case 'AVI ':
                $thisfile_video['bitrate_mode'] = 'vbr'; // maybe not, but probably
                $thisfile_video['dataformat']   = 'avi';
                $info['mime_type']      = 'video/avi';

                if (isset($thisfile_riff[$RIFFsubtype]['movi']['offset'])) {
                    $info['avdataoffset'] = $thisfile_riff[$RIFFsubtype]['movi']['offset'] + 8;
                    if (isset($thisfile_riff['AVIX'])) {
                        $info['avdataend'] = $thisfile_riff['AVIX'][(count($thisfile_riff['AVIX']) - 1)]['chunks']['movi']['offset'] + $thisfile_riff['AVIX'][(count($thisfile_riff['AVIX']) - 1)]['chunks']['movi']['size'];
                    } else {
                        $info['avdataend'] = $thisfile_riff['AVI ']['movi']['offset'] + $thisfile_riff['AVI ']['movi']['size'];
                    }
                    if ($info['avdataend'] > $info['filesize']) {
                        $info['warning'][] = 'Probably truncated file - expecting '.($info['avdataend'] - $info['avdataoffset']).' bytes of data, only found '.($info['filesize'] - $info['avdataoffset']).' (short by '.($info['avdataend'] - $info['filesize']).' bytes)';
                        $info['avdataend'] = $info['filesize'];
                    }
                }

                if (isset($thisfile_riff['AVI ']['hdrl']['strl']['indx'])) {
                    //$bIndexType = array(
                    //    0x00 => 'AVI_INDEX_OF_INDEXES',
                    //    0x01 => 'AVI_INDEX_OF_CHUNKS',
                    //    0x80 => 'AVI_INDEX_IS_DATA',
                    //);
                    //$bIndexSubtype = array(
                    //    0x01 => array(
                    //        0x01 => 'AVI_INDEX_2FIELD',
                    //    ),
                    //);
                    foreach ($thisfile_riff['AVI ']['hdrl']['strl']['indx'] as $streamnumber => $steamdataarray) {
                        $ahsisd = &$thisfile_riff['AVI ']['hdrl']['strl']['indx'][$streamnumber]['data'];

                        $thisfile_riff_raw['indx'][$streamnumber]['wLongsPerEntry'] = $this->EitherEndian2Int(substr($ahsisd,  0, 2));
                        $thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType']  = $this->EitherEndian2Int(substr($ahsisd,  2, 1));
                        $thisfile_riff_raw['indx'][$streamnumber]['bIndexType']     = $this->EitherEndian2Int(substr($ahsisd,  3, 1));
                        $thisfile_riff_raw['indx'][$streamnumber]['nEntriesInUse']  = $this->EitherEndian2Int(substr($ahsisd,  4, 4));
                        $thisfile_riff_raw['indx'][$streamnumber]['dwChunkId']      =                         substr($ahsisd,  8, 4);
                        $thisfile_riff_raw['indx'][$streamnumber]['dwReserved']     = $this->EitherEndian2Int(substr($ahsisd, 12, 4));

                        //$thisfile_riff_raw['indx'][$streamnumber]['bIndexType_name']    =    $bIndexType[$thisfile_riff_raw['indx'][$streamnumber]['bIndexType']];
                        //$thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType_name'] = $bIndexSubtype[$thisfile_riff_raw['indx'][$streamnumber]['bIndexType']][$thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType']];

                        unset($ahsisd);
                    }
                }
                if (isset($thisfile_riff['AVI ']['hdrl']['avih'][$streamindex]['data'])) {
                    $avihData = $thisfile_riff['AVI ']['hdrl']['avih'][$streamindex]['data'];

                    // shortcut
                    $thisfile_riff_raw['avih'] = array();
                    $thisfile_riff_raw_avih = &$thisfile_riff_raw['avih'];

                    $thisfile_riff_raw_avih['dwMicroSecPerFrame']    = $this->EitherEndian2Int(substr($avihData,  0, 4)); // frame display rate (or 0L)
                    if ($thisfile_riff_raw_avih['dwMicroSecPerFrame'] == 0) {
                        $info['error'][] = 'Corrupt RIFF file: avih.dwMicroSecPerFrame == zero';
                        return false;
                    }

                    $flags = array(
                        'dwMaxBytesPerSec',       // max. transfer rate
                        'dwPaddingGranularity',   // pad to multiples of this size; normally 2K.
                        'dwFlags',                // the ever-present flags
                        'dwTotalFrames',          // # frames in file
                        'dwInitialFrames',        //
                        'dwStreams',              //
                        'dwSuggestedBufferSize',  //
                        'dwWidth',                //
                        'dwHeight',               //
                        'dwScale',                //
                        'dwRate',                 //
                        'dwStart',                //
                        'dwLength',               //
                    );
                    $avih_offset = 4;
                    foreach ($flags as $flag) {
                        $thisfile_riff_raw_avih[$flag] = $this->EitherEndian2Int(substr($avihData, $avih_offset, 4));
                        $avih_offset += 4;
                    }

                    $flags = array(
                        'hasindex'     => 0x00000010,
                        'mustuseindex' => 0x00000020,
                        'interleaved'  => 0x00000100,
                        'trustcktype'  => 0x00000800,
                        'capturedfile' => 0x00010000,
                        'copyrighted'  => 0x00020010,
                    );
                    foreach ($flags as $flag => $value) {
                        $thisfile_riff_raw_avih['flags'][$flag] = (bool) ($thisfile_riff_raw_avih['dwFlags'] & $value);
                    }

                    // shortcut
                    $thisfile_riff_video[$streamindex] = array();
                    $thisfile_riff_video_current = &$thisfile_riff_video[$streamindex];

                    if ($thisfile_riff_raw_avih['dwWidth'] > 0) {
                        $thisfile_riff_video_current['frame_width'] = $thisfile_riff_raw_avih['dwWidth'];
                        $thisfile_video['resolution_x']             = $thisfile_riff_video_current['frame_width'];
                    }
                    if ($thisfile_riff_raw_avih['dwHeight'] > 0) {
                        $thisfile_riff_video_current['frame_height'] = $thisfile_riff_raw_avih['dwHeight'];
                        $thisfile_video['resolution_y']              = $thisfile_riff_video_current['frame_height'];
                    }
                    if ($thisfile_riff_raw_avih['dwTotalFrames'] > 0) {
                        $thisfile_riff_video_current['total_frames'] = $thisfile_riff_raw_avih['dwTotalFrames'];
                        $thisfile_video['total_frames']              = $thisfile_riff_video_current['total_frames'];
                    }

                    $thisfile_riff_video_current['frame_rate'] = round(1000000 / $thisfile_riff_raw_avih['dwMicroSecPerFrame'], 3);
                    $thisfile_video['frame_rate'] = $thisfile_riff_video_current['frame_rate'];
                }
                if (isset($thisfile_riff['AVI ']['hdrl']['strl']['strh'][0]['data'])) {
                    if (is_array($thisfile_riff['AVI ']['hdrl']['strl']['strh'])) {
                        for ($i = 0; $i < count($thisfile_riff['AVI ']['hdrl']['strl']['strh']); $i++) {
                            if (isset($thisfile_riff['AVI ']['hdrl']['strl']['strh'][$i]['data'])) {
                                $strhData = $thisfile_riff['AVI ']['hdrl']['strl']['strh'][$i]['data'];
                                $strhfccType = substr($strhData,  0, 4);

                                if (isset($thisfile_riff['AVI ']['hdrl']['strl']['strf'][$i]['data'])) {
                                    $strfData = $thisfile_riff['AVI ']['hdrl']['strl']['strf'][$i]['data'];

                                    // shortcut
                                    $thisfile_riff_raw_strf_strhfccType_streamindex = &$thisfile_riff_raw['strf'][$strhfccType][$streamindex];

                                    switch ($strhfccType) {
                                        case 'auds':
                                            $thisfile_audio['bitrate_mode'] = 'cbr';
                                            $thisfile_audio_dataformat      = 'wav';
                                            if (isset($thisfile_riff_audio) && is_array($thisfile_riff_audio)) {
                                                $streamindex = count($thisfile_riff_audio);
                                            }

                                            $thisfile_riff_audio[$streamindex] = self::parseWAVEFORMATex($strfData);
                                            $thisfile_audio['wformattag'] = $thisfile_riff_audio[$streamindex]['raw']['wFormatTag'];

                                            // shortcut
                                            $thisfile_audio['streams'][$streamindex] = $thisfile_riff_audio[$streamindex];
                                            $thisfile_audio_streams_currentstream = &$thisfile_audio['streams'][$streamindex];

                                            if ($thisfile_audio_streams_currentstream['bits_per_sample'] == 0) {
                                                unset($thisfile_audio_streams_currentstream['bits_per_sample']);
                                            }
                                            $thisfile_audio_streams_currentstream['wformattag'] = $thisfile_audio_streams_currentstream['raw']['wFormatTag'];
                                            unset($thisfile_audio_streams_currentstream['raw']);

                                            // shortcut
                                            $thisfile_riff_raw['strf'][$strhfccType][$streamindex] = $thisfile_riff_audio[$streamindex]['raw'];

                                            unset($thisfile_riff_audio[$streamindex]['raw']);
                                            $thisfile_audio = getid3_lib::array_merge_noclobber($thisfile_audio, $thisfile_riff_audio[$streamindex]);

                                            $thisfile_audio['lossless'] = false;
                                            switch ($thisfile_riff_raw_strf_strhfccType_streamindex['wFormatTag']) {
                                                case 0x0001:  // PCM
                                                    $thisfile_audio_dataformat  = 'wav';
                                                    $thisfile_audio['lossless'] = true;
                                                    break;

                                                case 0x0050: // MPEG Layer 2 or Layer 1
                                                    $thisfile_audio_dataformat = 'mp2'; // Assume Layer-2
                                                    break;

                                                case 0x0055: // MPEG Layer 3
                                                    $thisfile_audio_dataformat = 'mp3';
                                                    break;

                                                case 0x00FF: // AAC
                                                    $thisfile_audio_dataformat = 'aac';
                                                    break;

                                                case 0x0161: // Windows Media v7 / v8 / v9
                                                case 0x0162: // Windows Media Professional v9
                                                case 0x0163: // Windows Media Lossess v9
                                                    $thisfile_audio_dataformat = 'wma';
                                                    break;

                                                case 0x2000: // AC-3
                                                    $thisfile_audio_dataformat = 'ac3';
                                                    break;

                                                case 0x2001: // DTS
                                                    $thisfile_audio_dataformat = 'dts';
                                                    break;

                                                default:
                                                    $thisfile_audio_dataformat = 'wav';
                                                    break;
                                            }
                                            $thisfile_audio_streams_currentstream['dataformat']   = $thisfile_audio_dataformat;
                                            $thisfile_audio_streams_currentstream['lossless']     = $thisfile_audio['lossless'];
                                            $thisfile_audio_streams_currentstream['bitrate_mode'] = $thisfile_audio['bitrate_mode'];
                                            break;


                                        case 'iavs':
                                        case 'vids':
                                            // shortcut
                                            $thisfile_riff_raw['strh'][$i]                  = array();
                                            $thisfile_riff_raw_strh_current                 = &$thisfile_riff_raw['strh'][$i];

                                            $thisfile_riff_raw_strh_current['fccType']               =                         substr($strhData,  0, 4);  // same as $strhfccType;
                                            $thisfile_riff_raw_strh_current['fccHandler']            =                         substr($strhData,  4, 4);
                                            $thisfile_riff_raw_strh_current['dwFlags']               = $this->EitherEndian2Int(substr($strhData,  8, 4)); // Contains AVITF_* flags
                                            $thisfile_riff_raw_strh_current['wPriority']             = $this->EitherEndian2Int(substr($strhData, 12, 2));
                                            $thisfile_riff_raw_strh_current['wLanguage']             = $this->EitherEndian2Int(substr($strhData, 14, 2));
                                            $thisfile_riff_raw_strh_current['dwInitialFrames']       = $this->EitherEndian2Int(substr($strhData, 16, 4));
                                            $thisfile_riff_raw_strh_current['dwScale']               = $this->EitherEndian2Int(substr($strhData, 20, 4));
                                            $thisfile_riff_raw_strh_current['dwRate']                = $this->EitherEndian2Int(substr($strhData, 24, 4));
                                            $thisfile_riff_raw_strh_current['dwStart']               = $this->EitherEndian2Int(substr($strhData, 28, 4));
                                            $thisfile_riff_raw_strh_current['dwLength']              = $this->EitherEndian2Int(substr($strhData, 32, 4));
                                            $thisfile_riff_raw_strh_current['dwSuggestedBufferSize'] = $this->EitherEndian2Int(substr($strhData, 36, 4));
                                            $thisfile_riff_raw_strh_current['dwQuality']             = $this->EitherEndian2Int(substr($strhData, 40, 4));
                                            $thisfile_riff_raw_strh_current['dwSampleSize']          = $this->EitherEndian2Int(substr($strhData, 44, 4));
                                            $thisfile_riff_raw_strh_current['rcFrame']               = $this->EitherEndian2Int(substr($strhData, 48, 4));

                                            $thisfile_riff_video_current['codec'] = self::fourccLookup($thisfile_riff_raw_strh_current['fccHandler']);
                                            $thisfile_video['fourcc']             = $thisfile_riff_raw_strh_current['fccHandler'];
                                            if (!$thisfile_riff_video_current['codec'] && isset($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc']) && self::fourccLookup($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'])) {
                                                $thisfile_riff_video_current['codec'] = self::fourccLookup($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc']);
                                                $thisfile_video['fourcc']             = $thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'];
                                            }
                                            $thisfile_video['codec']              = $thisfile_riff_video_current['codec'];
                                            $thisfile_video['pixel_aspect_ratio'] = (float) 1;
                                            switch ($thisfile_riff_raw_strh_current['fccHandler']) {
                                                case 'HFYU': // Huffman Lossless Codec
                                                case 'IRAW': // Intel YUV Uncompressed
                                                case 'YUY2': // Uncompressed YUV 4:2:2
                                                    $thisfile_video['lossless'] = true;
                                                    break;

                                                default:
                                                    $thisfile_video['lossless'] = false;
                                                    break;
                                            }

                                            switch ($strhfccType) {
                                                case 'vids':
                                                    $thisfile_riff_raw_strf_strhfccType_streamindex = self::ParseBITMAPINFOHEADER(substr($strfData, 0, 40), ($info['fileformat'] == 'riff'));
                                                    $thisfile_video['bits_per_sample'] = $thisfile_riff_raw_strf_strhfccType_streamindex['biBitCount'];

                                                    if ($thisfile_riff_video_current['codec'] == 'DV') {
                                                        $thisfile_riff_video_current['dv_type'] = 2;
                                                    }
                                                    break;

                                                case 'iavs':
                                                    $thisfile_riff_video_current['dv_type'] = 1;
                                                    break;
                                            }
                                            break;

                                        default:
                                            $info['warning'][] = 'Unhandled fccType for stream ('.$i.'): "'.$strhfccType.'"';
                                            break;

                                    }
                                }
                            }

                            if (isset($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'])) {

                                $thisfile_video['fourcc'] = $thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'];
                                if (self::fourccLookup($thisfile_video['fourcc'])) {
                                    $thisfile_riff_video_current['codec'] = self::fourccLookup($thisfile_video['fourcc']);
                                    $thisfile_video['codec']              = $thisfile_riff_video_current['codec'];
                                }

                                switch ($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc']) {
                                    case 'HFYU': // Huffman Lossless Codec
                                    case 'IRAW': // Intel YUV Uncompressed
                                    case 'YUY2': // Uncompressed YUV 4:2:2
                                        $thisfile_video['lossless']        = true;
                                        //$thisfile_video['bits_per_sample'] = 24;
                                        break;

                                    default:
                                        $thisfile_video['lossless']        = false;
                                        //$thisfile_video['bits_per_sample'] = 24;
                                        break;
                                }

                            }
                        }
                    }
                }
                break;

            case 'CDDA':
                $thisfile_audio['bitrate_mode'] = 'cbr';
                $thisfile_audio_dataformat      = 'cda';
                $thisfile_audio['lossless']     = true;
                unset($info['mime_type']);

                $info['avdataoffset'] = 44;

                if (isset($thisfile_riff['CDDA']['fmt '][0]['data'])) {
                    // shortcut
                    $thisfile_riff_CDDA_fmt_0 = &$thisfile_riff['CDDA']['fmt '][0];

                    $thisfile_riff_CDDA_fmt_0['unknown1']           = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'],  0, 2));
                    $thisfile_riff_CDDA_fmt_0['track_num']          = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'],  2, 2));
                    $thisfile_riff_CDDA_fmt_0['disc_id']            = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'],  4, 4));
                    $thisfile_riff_CDDA_fmt_0['start_offset_frame'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'],  8, 4));
                    $thisfile_riff_CDDA_fmt_0['playtime_frames']    = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 12, 4));
                    $thisfile_riff_CDDA_fmt_0['unknown6']           = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 16, 4));
                    $thisfile_riff_CDDA_fmt_0['unknown7']           = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 20, 4));

                    $thisfile_riff_CDDA_fmt_0['start_offset_seconds'] = (float) $thisfile_riff_CDDA_fmt_0['start_offset_frame'] / 75;
                    $thisfile_riff_CDDA_fmt_0['playtime_seconds']     = (float) $thisfile_riff_CDDA_fmt_0['playtime_frames'] / 75;
                    $info['comments']['track']                = $thisfile_riff_CDDA_fmt_0['track_num'];
                    $info['playtime_seconds']                 = $thisfile_riff_CDDA_fmt_0['playtime_seconds'];

                    // hardcoded data for CD-audio
                    $thisfile_audio['sample_rate']     = 44100;
                    $thisfile_audio['channels']        = 2;
                    $thisfile_audio['bits_per_sample'] = 16;
                    $thisfile_audio['bitrate']         = $thisfile_audio['sample_rate'] * $thisfile_audio['channels'] * $thisfile_audio['bits_per_sample'];
                    $thisfile_audio['bitrate_mode']    = 'cbr';
                }
                break;


            case 'AIFF':
            case 'AIFC':
                $thisfile_audio['bitrate_mode'] = 'cbr';
                $thisfile_audio_dataformat      = 'aiff';
                $thisfile_audio['lossless']     = true;
                $info['mime_type']      = 'audio/x-aiff';

                if (isset($thisfile_riff[$RIFFsubtype]['SSND'][0]['offset'])) {
                    $info['avdataoffset'] = $thisfile_riff[$RIFFsubtype]['SSND'][0]['offset'] + 8;
                    $info['avdataend']    = $info['avdataoffset'] + $thisfile_riff[$RIFFsubtype]['SSND'][0]['size'];
                    if ($info['avdataend'] > $info['filesize']) {
                        if (($info['avdataend'] == ($info['filesize'] + 1)) && (($info['filesize'] % 2) == 1)) {
                            // structures rounded to 2-byte boundary, but dumb encoders
                            // forget to pad end of file to make this actually work
                        } else {
                            $info['warning'][] = 'Probable truncated AIFF file: expecting '.$thisfile_riff[$RIFFsubtype]['SSND'][0]['size'].' bytes of audio data, only '.($info['filesize'] - $info['avdataoffset']).' bytes found';
                        }
                        $info['avdataend'] = $info['filesize'];
                    }
                }

                if (isset($thisfile_riff[$RIFFsubtype]['COMM'][0]['data'])) {

                    // shortcut
                    $thisfile_riff_RIFFsubtype_COMM_0_data = &$thisfile_riff[$RIFFsubtype]['COMM'][0]['data'];

                    $thisfile_riff_audio['channels']         =         getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data,  0,  2), true);
                    $thisfile_riff_audio['total_samples']    =         getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data,  2,  4), false);
                    $thisfile_riff_audio['bits_per_sample']  =         getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data,  6,  2), true);
                    $thisfile_riff_audio['sample_rate']      = (int) getid3_lib::BigEndian2Float(substr($thisfile_riff_RIFFsubtype_COMM_0_data,  8, 10));

                    if ($thisfile_riff[$RIFFsubtype]['COMM'][0]['size'] > 18) {
                        $thisfile_riff_audio['codec_fourcc'] =                                   substr($thisfile_riff_RIFFsubtype_COMM_0_data, 18,  4);
                        $CodecNameSize                       =         getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data, 22,  1), false);
                        $thisfile_riff_audio['codec_name']   =                                   substr($thisfile_riff_RIFFsubtype_COMM_0_data, 23,  $CodecNameSize);
                        switch ($thisfile_riff_audio['codec_name']) {
                            case 'NONE':
                                $thisfile_audio['codec']    = 'Pulse Code Modulation (PCM)';
                                $thisfile_audio['lossless'] = true;
                                break;

                            case '':
                                switch ($thisfile_riff_audio['codec_fourcc']) {
                                    // http://developer.apple.com/qa/snd/snd07.html
                                    case 'sowt':
                                        $thisfile_riff_audio['codec_name'] = 'Two\'s Compliment Little-Endian PCM';
                                        $thisfile_audio['lossless'] = true;
                                        break;

                                    case 'twos':
                                        $thisfile_riff_audio['codec_name'] = 'Two\'s Compliment Big-Endian PCM';
                                        $thisfile_audio['lossless'] = true;
                                        break;

                                    default:
                                        break;
                                }
                                break;

                            default:
                                $thisfile_audio['codec']    = $thisfile_riff_audio['codec_name'];
                                $thisfile_audio['lossless'] = false;
                                break;
                        }
                    }

                    $thisfile_audio['channels']        = $thisfile_riff_audio['channels'];
                    if ($thisfile_riff_audio['bits_per_sample'] > 0) {
                        $thisfile_audio['bits_per_sample'] = $thisfile_riff_audio['bits_per_sample'];
                    }
                    $thisfile_audio['sample_rate']     = $thisfile_riff_audio['sample_rate'];
                    if ($thisfile_audio['sample_rate'] == 0) {
                        $info['error'][] = 'Corrupted AIFF file: sample_rate == zero';
                        return false;
                    }
                    $info['playtime_seconds'] = $thisfile_riff_audio['total_samples'] / $thisfile_audio['sample_rate'];
                }

                if (isset($thisfile_riff[$RIFFsubtype]['COMT'])) {
                    $offset = 0;
                    $CommentCount                                   = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset, 2), false);
                    $offset += 2;
                    for ($i = 0; $i < $CommentCount; $i++) {
                        $info['comments_raw'][$i]['timestamp']      = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset, 4), false);
                        $offset += 4;
                        $info['comments_raw'][$i]['marker_id']      = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset, 2), true);
                        $offset += 2;
                        $CommentLength                              = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset, 2), false);
                        $offset += 2;
                        $info['comments_raw'][$i]['comment']        =                           substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset, $CommentLength);
                        $offset += $CommentLength;

                        $info['comments_raw'][$i]['timestamp_unix'] = getid3_lib::DateMac2Unix($info['comments_raw'][$i]['timestamp']);
                        $thisfile_riff['comments']['comment'][] = $info['comments_raw'][$i]['comment'];
                    }
                }

                $CommentsChunkNames = array('NAME'=>'title', 'author'=>'artist', '(c) '=>'copyright', 'ANNO'=>'comment');
                foreach ($CommentsChunkNames as $key => $value) {
                    if (isset($thisfile_riff[$RIFFsubtype][$key][0]['data'])) {
                        $thisfile_riff['comments'][$value][] = $thisfile_riff[$RIFFsubtype][$key][0]['data'];
                    }
                }
/*
                if (isset($thisfile_riff[$RIFFsubtype]['ID3 '])) {
                    getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.tag.id3v2.php', __FILE__, true);
                    $getid3_temp = new getID3();
                    $getid3_temp->openfile($this->getid3->filename);
                    $getid3_id3v2 = new getid3_id3v2($getid3_temp);
                    $getid3_id3v2->StartingOffset = $thisfile_riff[$RIFFsubtype]['ID3 '][0]['offset'] + 8;
                    if ($thisfile_riff[$RIFFsubtype]['ID3 '][0]['valid'] = $getid3_id3v2->Analyze()) {
                        $info['id3v2'] = $getid3_temp->info['id3v2'];
                    }
                    unset($getid3_temp, $getid3_id3v2);
                }
*/
                break;

            case '8SVX':
                $thisfile_audio['bitrate_mode']    = 'cbr';
                $thisfile_audio_dataformat         = '8svx';
                $thisfile_audio['bits_per_sample'] = 8;
                $thisfile_audio['channels']        = 1; // overridden below, if need be
                $info['mime_type']                = 'audio/x-aiff';

                if (isset($thisfile_riff[$RIFFsubtype]['BODY'][0]['offset'])) {
                    $info['avdataoffset'] = $thisfile_riff[$RIFFsubtype]['BODY'][0]['offset'] + 8;
                    $info['avdataend']    = $info['avdataoffset'] + $thisfile_riff[$RIFFsubtype]['BODY'][0]['size'];
                    if ($info['avdataend'] > $info['filesize']) {
                        $info['warning'][] = 'Probable truncated AIFF file: expecting '.$thisfile_riff[$RIFFsubtype]['BODY'][0]['size'].' bytes of audio data, only '.($info['filesize'] - $info['avdataoffset']).' bytes found';
                    }
                }

                if (isset($thisfile_riff[$RIFFsubtype]['VHDR'][0]['offset'])) {
                    // shortcut
                    $thisfile_riff_RIFFsubtype_VHDR_0 = &$thisfile_riff[$RIFFsubtype]['VHDR'][0];

                    $thisfile_riff_RIFFsubtype_VHDR_0['oneShotHiSamples']  =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'],  0, 4));
                    $thisfile_riff_RIFFsubtype_VHDR_0['repeatHiSamples']   =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'],  4, 4));
                    $thisfile_riff_RIFFsubtype_VHDR_0['samplesPerHiCycle'] =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'],  8, 4));
                    $thisfile_riff_RIFFsubtype_VHDR_0['samplesPerSec']     =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 12, 2));
                    $thisfile_riff_RIFFsubtype_VHDR_0['ctOctave']          =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 14, 1));
                    $thisfile_riff_RIFFsubtype_VHDR_0['sCompression']      =   getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 15, 1));
                    $thisfile_riff_RIFFsubtype_VHDR_0['Volume']            = getid3_lib::FixedPoint16_16(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 16, 4));

                    $thisfile_audio['sample_rate'] = $thisfile_riff_RIFFsubtype_VHDR_0['samplesPerSec'];

                    switch ($thisfile_riff_RIFFsubtype_VHDR_0['sCompression']) {
                        case 0:
                            $thisfile_audio['codec']    = 'Pulse Code Modulation (PCM)';
                            $thisfile_audio['lossless'] = true;
                            $ActualBitsPerSample        = 8;
                            break;

                        case 1:
                            $thisfile_audio['codec']    = 'Fibonacci-delta encoding';
                            $thisfile_audio['lossless'] = false;
                            $ActualBitsPerSample        = 4;
                            break;

                        default:
                            $info['warning'][] = 'Unexpected sCompression value in 8SVX.VHDR chunk - expecting 0 or 1, found "'.sCompression.'"';
                            break;
                    }
                }

                if (isset($thisfile_riff[$RIFFsubtype]['CHAN'][0]['data'])) {
                    $ChannelsIndex = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['CHAN'][0]['data'], 0, 4));
                    switch ($ChannelsIndex) {
                        case 6: // Stereo
                            $thisfile_audio['channels'] = 2;
                            break;

                        case 2: // Left channel only
                        case 4: // Right channel only
                            $thisfile_audio['channels'] = 1;
                            break;

                        default:
                            $info['warning'][] = 'Unexpected value in 8SVX.CHAN chunk - expecting 2 or 4 or 6, found "'.$ChannelsIndex.'"';
                            break;
                    }

                }

                $CommentsChunkNames = array('NAME'=>'title', 'author'=>'artist', '(c) '=>'copyright', 'ANNO'=>'comment');
                foreach ($CommentsChunkNames as $key => $value) {
                    if (isset($thisfile_riff[$RIFFsubtype][$key][0]['data'])) {
                        $thisfile_riff['comments'][$value][] = $thisfile_riff[$RIFFsubtype][$key][0]['data'];
                    }
                }

                $thisfile_audio['bitrate'] = $thisfile_audio['sample_rate'] * $ActualBitsPerSample * $thisfile_audio['channels'];
                if (!empty($thisfile_audio['bitrate'])) {
                    $info['playtime_seconds'] = ($info['avdataend'] - $info['avdataoffset']) / ($thisfile_audio['bitrate'] / 8);
                }
                break;


            case 'CDXA':
                $info['mime_type'] = 'video/mpeg';
                if (!empty($thisfile_riff['CDXA']['data'][0]['size'])) {
                    if (getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.mpeg.php', __FILE__, false)) {
                        $getid3_temp = new getID3();
                        $getid3_temp->openfile($this->getid3->filename);
                        $getid3_mpeg = new getid3_mpeg($getid3_temp);
                        $getid3_mpeg->Analyze();
                        if (empty($getid3_temp->info['error'])) {
                            $info['audio']   = $getid3_temp->info['audio'];
                            $info['video']   = $getid3_temp->info['video'];
                            $info['mpeg']    = $getid3_temp->info['mpeg'];
                            $info['warning'] = $getid3_temp->info['warning'];
                        }
                        unset($getid3_temp, $getid3_mpeg);
                    }
                }
                break;


            default:
                $info['error'][] = 'Unknown RIFF type: expecting one of (WAVE|RMP3|AVI |CDDA|AIFF|AIFC|8SVX|CDXA), found "'.$RIFFsubtype.'" instead';
                unset($info['fileformat']);
                break;
        }

        switch ($RIFFsubtype) {
            case 'WAVE':
            case 'AIFF':
            case 'AIFC':
                $ID3v2_key_good = 'id3 ';
                $ID3v2_keys_bad = array('ID3 ', 'tag ');
                foreach ($ID3v2_keys_bad as $ID3v2_key_bad) {
                    if (isset($thisfile_riff[$RIFFsubtype][$ID3v2_key_bad]) && !array_key_exists($ID3v2_key_good, $thisfile_riff[$RIFFsubtype])) {
                        $thisfile_riff[$RIFFsubtype][$ID3v2_key_good] = $thisfile_riff[$RIFFsubtype][$ID3v2_key_bad];
                        $info['warning'][] = 'mapping "'.$ID3v2_key_bad.'" chunk to "'.$ID3v2_key_good.'"';
                    }
                }

                if (isset($thisfile_riff[$RIFFsubtype]['id3 '])) {
                    getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.tag.id3v2.php', __FILE__, true);
                    $getid3_temp = new getID3();
                    $getid3_temp->openfile($this->getid3->filename);
                    $getid3_id3v2 = new getid3_id3v2($getid3_temp);
                    $getid3_id3v2->StartingOffset = $thisfile_riff[$RIFFsubtype]['id3 '][0]['offset'] + 8;
                    if ($thisfile_riff[$RIFFsubtype]['id3 '][0]['valid'] = $getid3_id3v2->Analyze()) {
                        $info['id3v2'] = $getid3_temp->info['id3v2'];
                    }
                    unset($getid3_temp, $getid3_id3v2);
                }
                break;
        }

        if (isset($thisfile_riff_WAVE['DISP']) && is_array($thisfile_riff_WAVE['DISP'])) {
            $thisfile_riff['comments']['title'][] = trim(substr($thisfile_riff_WAVE['DISP'][count($thisfile_riff_WAVE['DISP']) - 1]['data'], 4));
        }
        if (isset($thisfile_riff_WAVE['INFO']) && is_array($thisfile_riff_WAVE['INFO'])) {
            self::parseComments($thisfile_riff_WAVE['INFO'], $thisfile_riff['comments']);
        }
        if (isset($thisfile_riff['AVI ']['INFO']) && is_array($thisfile_riff['AVI ']['INFO'])) {
            self::parseComments($thisfile_riff['AVI ']['INFO'], $thisfile_riff['comments']);
        }

        if (empty($thisfile_audio['encoder']) && !empty($info['mpeg']['audio']['LAME']['short_version'])) {
            $thisfile_audio['encoder'] = $info['mpeg']['audio']['LAME']['short_version'];
        }

        if (!isset($info['playtime_seconds'])) {
            $info['playtime_seconds'] = 0;
        }
        if (isset($thisfile_riff_raw['strh'][0]['dwLength']) && isset($thisfile_riff_raw['avih']['dwMicroSecPerFrame'])) {
            // needed for >2GB AVIs where 'avih' chunk only lists number of frames in that chunk, not entire movie
            $info['playtime_seconds'] = $thisfile_riff_raw['strh'][0]['dwLength'] * ($thisfile_riff_raw['avih']['dwMicroSecPerFrame'] / 1000000);
        } elseif (isset($thisfile_riff_raw['avih']['dwTotalFrames']) && isset($thisfile_riff_raw['avih']['dwMicroSecPerFrame'])) {
            $info['playtime_seconds'] = $thisfile_riff_raw['avih']['dwTotalFrames'] * ($thisfile_riff_raw['avih']['dwMicroSecPerFrame'] / 1000000);
        }

        if ($info['playtime_seconds'] > 0) {
            if (isset($thisfile_riff_audio) && isset($thisfile_riff_video)) {

                if (!isset($info['bitrate'])) {
                    $info['bitrate'] = ((($info['avdataend'] - $info['avdataoffset']) / $info['playtime_seconds']) * 8);
                }

            } elseif (isset($thisfile_riff_audio) && !isset($thisfile_riff_video)) {

                if (!isset($thisfile_audio['bitrate'])) {
                    $thisfile_audio['bitrate'] = ((($info['avdataend'] - $info['avdataoffset']) / $info['playtime_seconds']) * 8);
                }

            } elseif (!isset($thisfile_riff_audio) && isset($thisfile_riff_video)) {

                if (!isset($thisfile_video['bitrate'])) {
                    $thisfile_video['bitrate'] = ((($info['avdataend'] - $info['avdataoffset']) / $info['playtime_seconds']) * 8);
                }

            }
        }


        if (isset($thisfile_riff_video) && isset($thisfile_audio['bitrate']) && ($thisfile_audio['bitrate'] > 0) && ($info['playtime_seconds'] > 0)) {

            $info['bitrate'] = ((($info['avdataend'] - $info['avdataoffset']) / $info['playtime_seconds']) * 8);
            $thisfile_audio['bitrate'] = 0;
            $thisfile_video['bitrate'] = $info['bitrate'];
            foreach ($thisfile_riff_audio as $channelnumber => $audioinfoarray) {
                $thisfile_video['bitrate'] -= $audioinfoarray['bitrate'];
                $thisfile_audio['bitrate'] += $audioinfoarray['bitrate'];
            }
            if ($thisfile_video['bitrate'] <= 0) {
                unset($thisfile_video['bitrate']);
            }
            if ($thisfile_audio['bitrate'] <= 0) {
                unset($thisfile_audio['bitrate']);
            }
        }

        if (isset($info['mpeg']['audio'])) {
            $thisfile_audio_dataformat      = 'mp'.$info['mpeg']['audio']['layer'];
            $thisfile_audio['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
            $thisfile_audio['channels']     = $info['mpeg']['audio']['channels'];
            $thisfile_audio['bitrate']      = $info['mpeg']['audio']['bitrate'];
            $thisfile_audio['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
            if (!empty($info['mpeg']['audio']['codec'])) {
                $thisfile_audio['codec'] = $info['mpeg']['audio']['codec'].' '.$thisfile_audio['codec'];
            }
            if (!empty($thisfile_audio['streams'])) {
                foreach ($thisfile_audio['streams'] as $streamnumber => $streamdata) {
                    if ($streamdata['dataformat'] == $thisfile_audio_dataformat) {
                        $thisfile_audio['streams'][$streamnumber]['sample_rate']  = $thisfile_audio['sample_rate'];
                        $thisfile_audio['streams'][$streamnumber]['channels']     = $thisfile_audio['channels'];
                        $thisfile_audio['streams'][$streamnumber]['bitrate']      = $thisfile_audio['bitrate'];
                        $thisfile_audio['streams'][$streamnumber]['bitrate_mode'] = $thisfile_audio['bitrate_mode'];
                        $thisfile_audio['streams'][$streamnumber]['codec']        = $thisfile_audio['codec'];
                    }
                }
            }
            $getid3_mp3 = new getid3_mp3($this->getid3);
            $thisfile_audio['encoder_options'] = $getid3_mp3->GuessEncoderOptions();
            unset($getid3_mp3);
        }


        if (!empty($thisfile_riff_raw['fmt ']['wBitsPerSample']) && ($thisfile_riff_raw['fmt ']['wBitsPerSample'] > 0)) {
            switch ($thisfile_audio_dataformat) {
                case 'ac3':
                    // ignore bits_per_sample
                    break;

                default:
                    $thisfile_audio['bits_per_sample'] = $thisfile_riff_raw['fmt ']['wBitsPerSample'];
                    break;
            }
        }


        if (empty($thisfile_riff_raw)) {
            unset($thisfile_riff['raw']);
        }
        if (empty($thisfile_riff_audio)) {
            unset($thisfile_riff['audio']);
        }
        if (empty($thisfile_riff_video)) {
            unset($thisfile_riff['video']);
        }

        return true;
    }

    public function ParseRIFF($startoffset, $maxoffset) {
        $info = &$this->getid3->info;

        $RIFFchunk = false;
        $FoundAllChunksWeNeed = false;

        try {
            $this->fseek($startoffset);
            $maxoffset = min($maxoffset, $info['avdataend']);
            while ($this->ftell() < $maxoffset) {
                $chunknamesize = $this->fread(8);
                //$chunkname =                          substr($chunknamesize, 0, 4);
                $chunkname = str_replace("\x00", '_', substr($chunknamesize, 0, 4));  // note: chunk names of 4 null bytes do appear to be legal (has been observed inside INFO and PRMI chunks, for example), but makes traversing array keys more difficult
                $chunksize =  $this->EitherEndian2Int(substr($chunknamesize, 4, 4));
                //if (strlen(trim($chunkname, "\x00")) < 4) {
                if (strlen($chunkname) < 4) {
                    $this->error('Expecting chunk name at offset '.($this->ftell() - 8).' but found nothing. Aborting RIFF parsing.');
                    break;
                }
                if (($chunksize == 0) && ($chunkname != 'JUNK')) {
                    $this->warning('Chunk ('.$chunkname.') size at offset '.($this->ftell() - 4).' is zero. Aborting RIFF parsing.');
                    break;
                }
                if (($chunksize % 2) != 0) {
                    // all structures are packed on word boundaries
                    $chunksize++;
                }

                switch ($chunkname) {
                    case 'LIST':
                        $listname = $this->fread(4);
                        if (preg_match('#^(movi|rec )$#i', $listname)) {
                            $RIFFchunk[$listname]['offset'] = $this->ftell() - 4;
                            $RIFFchunk[$listname]['size']   = $chunksize;

                            if (!$FoundAllChunksWeNeed) {
                                $WhereWeWere      = $this->ftell();
                                $AudioChunkHeader = $this->fread(12);
                                $AudioChunkStreamNum  =                              substr($AudioChunkHeader, 0, 2);
                                $AudioChunkStreamType =                              substr($AudioChunkHeader, 2, 2);
                                $AudioChunkSize       = getid3_lib::LittleEndian2Int(substr($AudioChunkHeader, 4, 4));

                                if ($AudioChunkStreamType == 'wb') {
                                    $FirstFourBytes = substr($AudioChunkHeader, 8, 4);
                                    if (preg_match('/^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\xEB]/s', $FirstFourBytes)) {
                                        // MP3
                                        if (getid3_mp3::MPEGaudioHeaderBytesValid($FirstFourBytes)) {
                                            $getid3_temp = new getID3();
                                            $getid3_temp->openfile($this->getid3->filename);
                                            $getid3_temp->info['avdataoffset'] = $this->ftell() - 4;
                                            $getid3_temp->info['avdataend']    = $this->ftell() + $AudioChunkSize;
                                            $getid3_mp3 = new getid3_mp3($getid3_temp);
                                            $getid3_mp3->getOnlyMPEGaudioInfo($getid3_temp->info['avdataoffset'], false);
                                            if (isset($getid3_temp->info['mpeg']['audio'])) {
                                                $info['mpeg']['audio']         = $getid3_temp->info['mpeg']['audio'];
                                                $info['audio']                 = $getid3_temp->info['audio'];
                                                $info['audio']['dataformat']   = 'mp'.$info['mpeg']['audio']['layer'];
                                                $info['audio']['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
                                                $info['audio']['channels']     = $info['mpeg']['audio']['channels'];
                                                $info['audio']['bitrate']      = $info['mpeg']['audio']['bitrate'];
                                                $info['audio']['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
                                                //$info['bitrate']               = $info['audio']['bitrate'];
                                            }
                                            unset($getid3_temp, $getid3_mp3);
                                        }

                                    } elseif (strpos($FirstFourBytes, getid3_ac3::syncword) === 0) {

                                        // AC3
                                        $getid3_temp = new getID3();
                                        $getid3_temp->openfile($this->getid3->filename);
                                        $getid3_temp->info['avdataoffset'] = $this->ftell() - 4;
                                        $getid3_temp->info['avdataend']    = $this->ftell() + $AudioChunkSize;
                                        $getid3_ac3 = new getid3_ac3($getid3_temp);
                                        $getid3_ac3->Analyze();
                                        if (empty($getid3_temp->info['error'])) {
                                            $info['audio']   = $getid3_temp->info['audio'];
                                            $info['ac3']     = $getid3_temp->info['ac3'];
                                            if (!empty($getid3_temp->info['warning'])) {
                                                foreach ($getid3_temp->info['warning'] as $key => $value) {
                                                    $info['warning'][] = $value;
                                                }
                                            }
                                        }
                                        unset($getid3_temp, $getid3_ac3);
                                    }
                                }
                                $FoundAllChunksWeNeed = true;
                                $this->fseek($WhereWeWere);
                            }
                            $this->fseek($chunksize - 4, SEEK_CUR);

                        } else {

                            if (!isset($RIFFchunk[$listname])) {
                                $RIFFchunk[$listname] = array();
                            }
                            $LISTchunkParent    = $listname;
                            $LISTchunkMaxOffset = $this->ftell() - 4 + $chunksize;
                            if ($parsedChunk = $this->ParseRIFF($this->ftell(), $LISTchunkMaxOffset)) {
                                $RIFFchunk[$listname] = array_merge_recursive($RIFFchunk[$listname], $parsedChunk);
                            }

                        }
                        break;

                    default:
                        if (preg_match('#^[0-9]{2}(wb|pc|dc|db)$#', $chunkname)) {
                            $this->fseek($chunksize, SEEK_CUR);
                            break;
                        }
                        $thisindex = 0;
                        if (isset($RIFFchunk[$chunkname]) && is_array($RIFFchunk[$chunkname])) {
                            $thisindex = count($RIFFchunk[$chunkname]);
                        }
                        $RIFFchunk[$chunkname][$thisindex]['offset'] = $this->ftell() - 8;
                        $RIFFchunk[$chunkname][$thisindex]['size']   = $chunksize;
                        switch ($chunkname) {
                            case 'data':
                                $info['avdataoffset'] = $this->ftell();
                                $info['avdataend']    = $info['avdataoffset'] + $chunksize;

                                $testData = $this->fread(36);
                                if ($testData === '') {
                                    break;
                                }
                                if (preg_match('/^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\xEB]/s', substr($testData, 0, 4))) {

                                    // Probably is MP3 data
                                    if (getid3_mp3::MPEGaudioHeaderBytesValid(substr($testData, 0, 4))) {
                                        $getid3_temp = new getID3();
                                        $getid3_temp->openfile($this->getid3->filename);
                                        $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
                                        $getid3_temp->info['avdataend']    = $info['avdataend'];
                                        $getid3_mp3 = new getid3_mp3($getid3_temp);
                                        $getid3_mp3->getOnlyMPEGaudioInfo($info['avdataoffset'], false);
                                        if (empty($getid3_temp->info['error'])) {
                                            $info['audio'] = $getid3_temp->info['audio'];
                                            $info['mpeg']  = $getid3_temp->info['mpeg'];
                                        }
                                        unset($getid3_temp, $getid3_mp3);
                                    }

                                } elseif (($isRegularAC3 = (substr($testData, 0, 2) == getid3_ac3::syncword)) || substr($testData, 8, 2) == strrev(getid3_ac3::syncword)) {

                                    // This is probably AC-3 data
                                    $getid3_temp = new getID3();
                                    if ($isRegularAC3) {
                                        $getid3_temp->openfile($this->getid3->filename);
                                        $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
                                        $getid3_temp->info['avdataend']    = $info['avdataend'];
                                    }
                                    $getid3_ac3 = new getid3_ac3($getid3_temp);
                                    if ($isRegularAC3) {
                                        $getid3_ac3->Analyze();
                                    } else {
                                        // Dolby Digital WAV
                                        // AC-3 content, but not encoded in same format as normal AC-3 file
                                        // For one thing, byte order is swapped
                                        $ac3_data = '';
                                        for ($i = 0; $i < 28; $i += 2) {
                                            $ac3_data .= substr($testData, 8 + $i + 1, 1);
                                            $ac3_data .= substr($testData, 8 + $i + 0, 1);
                                        }
                                        $getid3_ac3->AnalyzeString($ac3_data);
                                    }

                                    if (empty($getid3_temp->info['error'])) {
                                        $info['audio'] = $getid3_temp->info['audio'];
                                        $info['ac3']   = $getid3_temp->info['ac3'];
                                        if (!empty($getid3_temp->info['warning'])) {
                                            foreach ($getid3_temp->info['warning'] as $newerror) {
                                                $this->warning('getid3_ac3() says: ['.$newerror.']');
                                            }
                                        }
                                    }
                                    unset($getid3_temp, $getid3_ac3);

                                } elseif (preg_match('/^('.implode('|', array_map('preg_quote', getid3_dts::$syncwords)).')/', $testData)) {

                                    // This is probably DTS data
                                    $getid3_temp = new getID3();
                                    $getid3_temp->openfile($this->getid3->filename);
                                    $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
                                    $getid3_dts = new getid3_dts($getid3_temp);
                                    $getid3_dts->Analyze();
                                    if (empty($getid3_temp->info['error'])) {
                                        $info['audio']            = $getid3_temp->info['audio'];
                                        $info['dts']              = $getid3_temp->info['dts'];
                                        $info['playtime_seconds'] = $getid3_temp->info['playtime_seconds']; // may not match RIFF calculations since DTS-WAV often used 14/16 bit-word packing
                                        if (!empty($getid3_temp->info['warning'])) {
                                            foreach ($getid3_temp->info['warning'] as $newerror) {
                                                $this->warning('getid3_dts() says: ['.$newerror.']');
                                            }
                                        }
                                    }

                                    unset($getid3_temp, $getid3_dts);

                                } elseif (substr($testData, 0, 4) == 'wvpk') {

                                    // This is WavPack data
                                    $info['wavpack']['offset'] = $info['avdataoffset'];
                                    $info['wavpack']['size']   = getid3_lib::LittleEndian2Int(substr($testData, 4, 4));
                                    $this->parseWavPackHeader(substr($testData, 8, 28));

                                } else {
                                    // This is some other kind of data (quite possibly just PCM)
                                    // do nothing special, just skip it
                                }
                                $nextoffset = $info['avdataend'];
                                $this->fseek($nextoffset);
                                break;

                            case 'iXML':
                            case 'bext':
                            case 'cart':
                            case 'fmt ':
                            case 'strh':
                            case 'strf':
                            case 'indx':
                            case 'MEXT':
                            case 'DISP':
                                // always read data in
                            case 'JUNK':
                                // should be: never read data in
                                // but some programs write their version strings in a JUNK chunk (e.g. VirtualDub, AVIdemux, etc)
                                if ($chunksize < 1048576) {
                                    if ($chunksize > 0) {
                                        $RIFFchunk[$chunkname][$thisindex]['data'] = $this->fread($chunksize);
                                        if ($chunkname == 'JUNK') {
                                            if (preg_match('#^([\\x20-\\x7F]+)#', $RIFFchunk[$chunkname][$thisindex]['data'], $matches)) {
                                                // only keep text characters [chr(32)-chr(127)]
                                                $info['riff']['comments']['junk'][] = trim($matches[1]);
                                            }
                                            // but if nothing there, ignore
                                            // remove the key in either case
                                            unset($RIFFchunk[$chunkname][$thisindex]['data']);
                                        }
                                    }
                                } else {
                                    $this->warning('Chunk "'.$chunkname.'" at offset '.$this->ftell().' is unexpectedly larger than 1MB (claims to be '.number_format($chunksize).' bytes), skipping data');
                                    $this->fseek($chunksize, SEEK_CUR);
                                }
                                break;

                            //case 'IDVX':
                            //    $info['divxtag']['comments'] = self::ParseDIVXTAG($this->fread($chunksize));
                            //    break;

                            default:
                                if (!empty($LISTchunkParent) && (($RIFFchunk[$chunkname][$thisindex]['offset'] + $RIFFchunk[$chunkname][$thisindex]['size']) <= $LISTchunkMaxOffset)) {
                                    $RIFFchunk[$LISTchunkParent][$chunkname][$thisindex]['offset'] = $RIFFchunk[$chunkname][$thisindex]['offset'];
                                    $RIFFchunk[$LISTchunkParent][$chunkname][$thisindex]['size']   = $RIFFchunk[$chunkname][$thisindex]['size'];
                                    unset($RIFFchunk[$chunkname][$thisindex]['offset']);
                                    unset($RIFFchunk[$chunkname][$thisindex]['size']);
                                    if (isset($RIFFchunk[$chunkname][$thisindex]) && empty($RIFFchunk[$chunkname][$thisindex])) {
                                        unset($RIFFchunk[$chunkname][$thisindex]);
                                    }
                                    if (isset($RIFFchunk[$chunkname]) && empty($RIFFchunk[$chunkname])) {
                                        unset($RIFFchunk[$chunkname]);
                                    }
                                    $RIFFchunk[$LISTchunkParent][$chunkname][$thisindex]['data'] = $this->fread($chunksize);
                                } elseif ($chunksize < 2048) {
                                    // only read data in if smaller than 2kB
                                    $RIFFchunk[$chunkname][$thisindex]['data'] = $this->fread($chunksize);
                                } else {
                                    $this->fseek($chunksize, SEEK_CUR);
                                }
                                break;
                        }
                        break;
                }
            }

        } catch (getid3_exception $e) {
            if ($e->getCode() == 10) {
                $this->warning('RIFF parser: '.$e->getMessage());
            } else {
                throw $e;
            }
        }

        return $RIFFchunk;
    }

    public function ParseRIFFdata(&$RIFFdata) {
        $info = &$this->getid3->info;
        if ($RIFFdata) {
            $tempfile = tempnam(GETID3_TEMP_DIR, 'getID3');
            $fp_temp  = fopen($tempfile, 'wb');
            $RIFFdataLength = strlen($RIFFdata);
            $NewLengthString = getid3_lib::LittleEndian2String($RIFFdataLength, 4);
            for ($i = 0; $i < 4; $i++) {
                $RIFFdata[($i + 4)] = $NewLengthString[$i];
            }
            fwrite($fp_temp, $RIFFdata);
            fclose($fp_temp);

            $getid3_temp = new getID3();
            $getid3_temp->openfile($tempfile);
            $getid3_temp->info['filesize']     = $RIFFdataLength;
            $getid3_temp->info['filenamepath'] = $info['filenamepath'];
            $getid3_temp->info['tags']         = $info['tags'];
            $getid3_temp->info['warning']      = $info['warning'];
            $getid3_temp->info['error']        = $info['error'];
            $getid3_temp->info['comments']     = $info['comments'];
            $getid3_temp->info['audio']        = (isset($info['audio']) ? $info['audio'] : array());
            $getid3_temp->info['video']        = (isset($info['video']) ? $info['video'] : array());
            $getid3_riff = new getid3_riff($getid3_temp);
            $getid3_riff->Analyze();

            $info['riff']     = $getid3_temp->info['riff'];
            $info['warning']  = $getid3_temp->info['warning'];
            $info['error']    = $getid3_temp->info['error'];
            $info['tags']     = $getid3_temp->info['tags'];
            $info['comments'] = $getid3_temp->info['comments'];
            unset($getid3_riff, $getid3_temp);
            unlink($tempfile);
        }
        return false;
    }

    public static function parseComments(&$RIFFinfoArray, &$CommentsTargetArray) {
        $RIFFinfoKeyLookup = array(
            'IARL'=>'archivallocation',
            'IART'=>'artist',
            'ICDS'=>'costumedesigner',
            'ICMS'=>'commissionedby',
            'ICMT'=>'comment',
            'ICNT'=>'country',
            'ICOP'=>'copyright',
            'ICRD'=>'creationdate',
            'IDIM'=>'dimensions',
            'IDIT'=>'digitizationdate',
            'IDPI'=>'resolution',
            'IDST'=>'distributor',
            'IEDT'=>'editor',
            'IENG'=>'engineers',
            'IFRM'=>'accountofparts',
            'IGNR'=>'genre',
            'IKEY'=>'keywords',
            'ILGT'=>'lightness',
            'ILNG'=>'language',
            'IMED'=>'orignalmedium',
            'IMUS'=>'composer',
            'INAM'=>'title',
            'IPDS'=>'productiondesigner',
            'IPLT'=>'palette',
            'IPRD'=>'product',
            'IPRO'=>'producer',
            'IPRT'=>'part',
            'IRTD'=>'rating',
            'ISBJ'=>'subject',
            'ISFT'=>'software',
            'ISGN'=>'secondarygenre',
            'ISHP'=>'sharpness',
            'ISRC'=>'sourcesupplier',
            'ISRF'=>'digitizationsource',
            'ISTD'=>'productionstudio',
            'ISTR'=>'starring',
            'ITCH'=>'encoded_by',
            'IWEB'=>'url',
            'IWRI'=>'writer',
            '____'=>'comment',
        );
        foreach ($RIFFinfoKeyLookup as $key => $value) {
            if (isset($RIFFinfoArray[$key])) {
                foreach ($RIFFinfoArray[$key] as $commentid => $commentdata) {
                    if (trim($commentdata['data']) != '') {
                        if (isset($CommentsTargetArray[$value])) {
                            $CommentsTargetArray[$value][] =     trim($commentdata['data']);
                        } else {
                            $CommentsTargetArray[$value] = array(trim($commentdata['data']));
                        }
                    }
                }
            }
        }
        return true;
    }

    public static function parseWAVEFORMATex($WaveFormatExData) {
        // shortcut
        $WaveFormatEx['raw'] = array();
        $WaveFormatEx_raw    = &$WaveFormatEx['raw'];

        $WaveFormatEx_raw['wFormatTag']      = substr($WaveFormatExData,  0, 2);
        $WaveFormatEx_raw['nChannels']       = substr($WaveFormatExData,  2, 2);
        $WaveFormatEx_raw['nSamplesPerSec']  = substr($WaveFormatExData,  4, 4);
        $WaveFormatEx_raw['nAvgBytesPerSec'] = substr($WaveFormatExData,  8, 4);
        $WaveFormatEx_raw['nBlockAlign']     = substr($WaveFormatExData, 12, 2);
        $WaveFormatEx_raw['wBitsPerSample']  = substr($WaveFormatExData, 14, 2);
        if (strlen($WaveFormatExData) > 16) {
            $WaveFormatEx_raw['cbSize']      = substr($WaveFormatExData, 16, 2);
        }
        $WaveFormatEx_raw = array_map('getid3_lib::LittleEndian2Int', $WaveFormatEx_raw);

        $WaveFormatEx['codec']           = self::wFormatTagLookup($WaveFormatEx_raw['wFormatTag']);
        $WaveFormatEx['channels']        = $WaveFormatEx_raw['nChannels'];
        $WaveFormatEx['sample_rate']     = $WaveFormatEx_raw['nSamplesPerSec'];
        $WaveFormatEx['bitrate']         = $WaveFormatEx_raw['nAvgBytesPerSec'] * 8;
        $WaveFormatEx['bits_per_sample'] = $WaveFormatEx_raw['wBitsPerSample'];

        return $WaveFormatEx;
    }

    public function parseWavPackHeader($WavPackChunkData) {
        // typedef struct {
        //     char ckID [4];
        //     long ckSize;
        //     short version;
        //     short bits;                // added for version 2.00
        //     short flags, shift;        // added for version 3.00
        //     long total_samples, crc, crc2;
        //     char extension [4], extra_bc, extras [3];
        // } WavpackHeader;

        // shortcut
        $info = &$this->getid3->info;
        $info['wavpack']  = array();
        $thisfile_wavpack = &$info['wavpack'];

        $thisfile_wavpack['version']           = getid3_lib::LittleEndian2Int(substr($WavPackChunkData,  0, 2));
        if ($thisfile_wavpack['version'] >= 2) {
            $thisfile_wavpack['bits']          = getid3_lib::LittleEndian2Int(substr($WavPackChunkData,  2, 2));
        }
        if ($thisfile_wavpack['version'] >= 3) {
            $thisfile_wavpack['flags_raw']     = getid3_lib::LittleEndian2Int(substr($WavPackChunkData,  4, 2));
            $thisfile_wavpack['shift']         = getid3_lib::LittleEndian2Int(substr($WavPackChunkData,  6, 2));
            $thisfile_wavpack['total_samples'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData,  8, 4));
            $thisfile_wavpack['crc1']          = getid3_lib::LittleEndian2Int(substr($WavPackChunkData, 12, 4));
            $thisfile_wavpack['crc2']          = getid3_lib::LittleEndian2Int(substr($WavPackChunkData, 16, 4));
            $thisfile_wavpack['extension']     =                              substr($WavPackChunkData, 20, 4);
            $thisfile_wavpack['extra_bc']      = getid3_lib::LittleEndian2Int(substr($WavPackChunkData, 24, 1));
            for ($i = 0; $i <= 2; $i++) {
                $thisfile_wavpack['extras'][]  = getid3_lib::LittleEndian2Int(substr($WavPackChunkData, 25 + $i, 1));
            }

            // shortcut
            $thisfile_wavpack['flags'] = array();
            $thisfile_wavpack_flags = &$thisfile_wavpack['flags'];

            $thisfile_wavpack_flags['mono']                 = (bool) ($thisfile_wavpack['flags_raw'] & 0x000001);
            $thisfile_wavpack_flags['fast_mode']            = (bool) ($thisfile_wavpack['flags_raw'] & 0x000002);
            $thisfile_wavpack_flags['raw_mode']             = (bool) ($thisfile_wavpack['flags_raw'] & 0x000004);
            $thisfile_wavpack_flags['calc_noise']           = (bool) ($thisfile_wavpack['flags_raw'] & 0x000008);
            $thisfile_wavpack_flags['high_quality']         = (bool) ($thisfile_wavpack['flags_raw'] & 0x000010);
            $thisfile_wavpack_flags['3_byte_samples']       = (bool) ($thisfile_wavpack['flags_raw'] & 0x000020);
            $thisfile_wavpack_flags['over_20_bits']         = (bool) ($thisfile_wavpack['flags_raw'] & 0x000040);
            $thisfile_wavpack_flags['use_wvc']              = (bool) ($thisfile_wavpack['flags_raw'] & 0x000080);
            $thisfile_wavpack_flags['noiseshaping']         = (bool) ($thisfile_wavpack['flags_raw'] & 0x000100);
            $thisfile_wavpack_flags['very_fast_mode']       = (bool) ($thisfile_wavpack['flags_raw'] & 0x000200);
            $thisfile_wavpack_flags['new_high_quality']     = (bool) ($thisfile_wavpack['flags_raw'] & 0x000400);
            $thisfile_wavpack_flags['cancel_extreme']       = (bool) ($thisfile_wavpack['flags_raw'] & 0x000800);
            $thisfile_wavpack_flags['cross_decorrelation']  = (bool) ($thisfile_wavpack['flags_raw'] & 0x001000);
            $thisfile_wavpack_flags['new_decorrelation']    = (bool) ($thisfile_wavpack['flags_raw'] & 0x002000);
            $thisfile_wavpack_flags['joint_stereo']         = (bool) ($thisfile_wavpack['flags_raw'] & 0x004000);
            $thisfile_wavpack_flags['extra_decorrelation']  = (bool) ($thisfile_wavpack['flags_raw'] & 0x008000);
            $thisfile_wavpack_flags['override_noiseshape']  = (bool) ($thisfile_wavpack['flags_raw'] & 0x010000);
            $thisfile_wavpack_flags['override_jointstereo'] = (bool) ($thisfile_wavpack['flags_raw'] & 0x020000);
            $thisfile_wavpack_flags['copy_source_filetime'] = (bool) ($thisfile_wavpack['flags_raw'] & 0x040000);
            $thisfile_wavpack_flags['create_exe']           = (bool) ($thisfile_wavpack['flags_raw'] & 0x080000);
        }

        return true;
    }

    public static function ParseBITMAPINFOHEADER($BITMAPINFOHEADER, $littleEndian=true) {

        $parsed['biSize']          = substr($BITMAPINFOHEADER,  0, 4); // number of bytes required by the BITMAPINFOHEADER structure
        $parsed['biWidth']         = substr($BITMAPINFOHEADER,  4, 4); // width of the bitmap in pixels
        $parsed['biHeight']        = substr($BITMAPINFOHEADER,  8, 4); // height of the bitmap in pixels. If biHeight is positive, the bitmap is a 'bottom-up' DIB and its origin is the lower left corner. If biHeight is negative, the bitmap is a 'top-down' DIB and its origin is the upper left corner
        $parsed['biPlanes']        = substr($BITMAPINFOHEADER, 12, 2); // number of color planes on the target device. In most cases this value must be set to 1
        $parsed['biBitCount']      = substr($BITMAPINFOHEADER, 14, 2); // Specifies the number of bits per pixels
        $parsed['biSizeImage']     = substr($BITMAPINFOHEADER, 20, 4); // size of the bitmap data section of the image (the actual pixel data, excluding BITMAPINFOHEADER and RGBQUAD structures)
        $parsed['biXPelsPerMeter'] = substr($BITMAPINFOHEADER, 24, 4); // horizontal resolution, in pixels per metre, of the target device
        $parsed['biYPelsPerMeter'] = substr($BITMAPINFOHEADER, 28, 4); // vertical resolution, in pixels per metre, of the target device
        $parsed['biClrUsed']       = substr($BITMAPINFOHEADER, 32, 4); // actual number of color indices in the color table used by the bitmap. If this value is zero, the bitmap uses the maximum number of colors corresponding to the value of the biBitCount member for the compression mode specified by biCompression
        $parsed['biClrImportant']  = substr($BITMAPINFOHEADER, 36, 4); // number of color indices that are considered important for displaying the bitmap. If this value is zero, all colors are important
        $parsed = array_map('getid3_lib::'.($littleEndian ? 'Little' : 'Big').'Endian2Int', $parsed);

        $parsed['fourcc']          = substr($BITMAPINFOHEADER, 16, 4);  // compression identifier

        return $parsed;
    }

    public static function ParseDIVXTAG($DIVXTAG, $raw=false) {
        // structure from "IDivX" source, Form1.frm, by "Greg Frazier of Daemonic Software Group", email: gfrazier@icestorm.net, web: http://dsg.cjb.net/
        // source available at http://files.divx-digest.com/download/c663efe7ef8ad2e90bf4af4d3ea6188a/on0SWN2r/edit/IDivX.zip
        // 'Byte Layout:                   '1111111111111111
        // '32 for Movie - 1               '1111111111111111
        // '28 for Author - 6              '6666666666666666
        // '4  for year - 2                '6666666666662222
        // '3  for genre - 3               '7777777777777777
        // '48 for Comments - 7            '7777777777777777
        // '1  for Rating - 4              '7777777777777777
        // '5  for Future Additions - 0    '333400000DIVXTAG
        // '128 bytes total

        static $DIVXTAGgenre  = array(
             0 => 'Action',
             1 => 'Action/Adventure',
             2 => 'Adventure',
             3 => 'Adult',
             4 => 'Anime',
             5 => 'Cartoon',
             6 => 'Claymation',
             7 => 'Comedy',
             8 => 'Commercial',
             9 => 'Documentary',
            10 => 'Drama',
            11 => 'Home Video',
            12 => 'Horror',
            13 => 'Infomercial',
            14 => 'Interactive',
            15 => 'Mystery',
            16 => 'Music Video',
            17 => 'Other',
            18 => 'Religion',
            19 => 'Sci Fi',
            20 => 'Thriller',
            21 => 'Western',
        ),
        $DIVXTAGrating = array(
             0 => 'Unrated',
             1 => 'G',
             2 => 'PG',
             3 => 'PG-13',
             4 => 'R',
             5 => 'NC-17',
        );

        $parsed['title']     =        trim(substr($DIVXTAG,   0, 32));
        $parsed['artist']    =        trim(substr($DIVXTAG,  32, 28));
        $parsed['year']      = intval(trim(substr($DIVXTAG,  60,  4)));
        $parsed['comment']   =        trim(substr($DIVXTAG,  64, 48));
        $parsed['genre_id']  = intval(trim(substr($DIVXTAG, 112,  3)));
        $parsed['rating_id'] =         ord(substr($DIVXTAG, 115,  1));
        //$parsed['padding'] =             substr($DIVXTAG, 116,  5);  // 5-byte null
        //$parsed['magic']   =             substr($DIVXTAG, 121,  7);  // "DIVXTAG"

        $parsed['genre']  = (isset($DIVXTAGgenre[$parsed['genre_id']])   ? $DIVXTAGgenre[$parsed['genre_id']]   : $parsed['genre_id']);
        $parsed['rating'] = (isset($DIVXTAGrating[$parsed['rating_id']]) ? $DIVXTAGrating[$parsed['rating_id']] : $parsed['rating_id']);

        if (!$raw) {
            unset($parsed['genre_id'], $parsed['rating_id']);
            foreach ($parsed as $key => $value) {
                if (!$value === '') {
                    unset($parsed['key']);
                }
            }
        }

        foreach ($parsed as $tag => $value) {
            $parsed[$tag] = array($value);
        }

        return $parsed;
    }

    public static function waveSNDMtagLookup($tagshortname) {
        $begin = __LINE__;

        /** This is not a comment!

            ©kwd    keywords
            ©BPM    bpm
            ©trt    tracktitle
            ©des    description
            ©gen    category
            ©fin    featuredinstrument
            ©LID    longid
            ©bex    bwdescription
            ©pub    publisher
            ©cdt    cdtitle
            ©alb    library
            ©com    composer

        */

        return getid3_lib::EmbeddedLookup($tagshortname, $begin, __LINE__, __FILE__, 'riff-sndm');
    }

    public static function wFormatTagLookup($wFormatTag) {

        $begin = __LINE__;

        /** This is not a comment!

            0x0000    Microsoft Unknown Wave Format
            0x0001    Pulse Code Modulation (PCM)
            0x0002    Microsoft ADPCM
            0x0003    IEEE Float
            0x0004    Compaq Computer VSELP
            0x0005    IBM CVSD
            0x0006    Microsoft A-Law
            0x0007    Microsoft mu-Law
            0x0008    Microsoft DTS
            0x0010    OKI ADPCM
            0x0011    Intel DVI/IMA ADPCM
            0x0012    Videologic MediaSpace ADPCM
            0x0013    Sierra Semiconductor ADPCM
            0x0014    Antex Electronics G.723 ADPCM
            0x0015    DSP Solutions DigiSTD
            0x0016    DSP Solutions DigiFIX
            0x0017    Dialogic OKI ADPCM
            0x0018    MediaVision ADPCM
            0x0019    Hewlett-Packard CU
            0x0020    Yamaha ADPCM
            0x0021    Speech Compression Sonarc
            0x0022    DSP Group TrueSpeech
            0x0023    Echo Speech EchoSC1
            0x0024    Audiofile AF36
            0x0025    Audio Processing Technology APTX
            0x0026    AudioFile AF10
            0x0027    Prosody 1612
            0x0028    LRC
            0x0030    Dolby AC2
            0x0031    Microsoft GSM 6.10
            0x0032    MSNAudio
            0x0033    Antex Electronics ADPCME
            0x0034    Control Resources VQLPC
            0x0035    DSP Solutions DigiREAL
            0x0036    DSP Solutions DigiADPCM
            0x0037    Control Resources CR10
            0x0038    Natural MicroSystems VBXADPCM
            0x0039    Crystal Semiconductor IMA ADPCM
            0x003A    EchoSC3
            0x003B    Rockwell ADPCM
            0x003C    Rockwell Digit LK
            0x003D    Xebec
            0x0040    Antex Electronics G.721 ADPCM
            0x0041    G.728 CELP
            0x0042    MSG723
            0x0050    MPEG Layer-2 or Layer-1
            0x0052    RT24
            0x0053    PAC
            0x0055    MPEG Layer-3
            0x0059    Lucent G.723
            0x0060    Cirrus
            0x0061    ESPCM
            0x0062    Voxware
            0x0063    Canopus Atrac
            0x0064    G.726 ADPCM
            0x0065    G.722 ADPCM
            0x0066    DSAT
            0x0067    DSAT Display
            0x0069    Voxware Byte Aligned
            0x0070    Voxware AC8
            0x0071    Voxware AC10
            0x0072    Voxware AC16
            0x0073    Voxware AC20
            0x0074    Voxware MetaVoice
            0x0075    Voxware MetaSound
            0x0076    Voxware RT29HW
            0x0077    Voxware VR12
            0x0078    Voxware VR18
            0x0079    Voxware TQ40
            0x0080    Softsound
            0x0081    Voxware TQ60
            0x0082    MSRT24
            0x0083    G.729A
            0x0084    MVI MV12
            0x0085    DF G.726
            0x0086    DF GSM610
            0x0088    ISIAudio
            0x0089    Onlive
            0x0091    SBC24
            0x0092    Dolby AC3 SPDIF
            0x0093    MediaSonic G.723
            0x0094    Aculab PLC    Prosody 8kbps
            0x0097    ZyXEL ADPCM
            0x0098    Philips LPCBB
            0x0099    Packed
            0x00FF    AAC
            0x0100    Rhetorex ADPCM
            0x0101    IBM mu-law
            0x0102    IBM A-law
            0x0103    IBM AVC Adaptive Differential Pulse Code Modulation (ADPCM)
            0x0111    Vivo G.723
            0x0112    Vivo Siren
            0x0123    Digital G.723
            0x0125    Sanyo LD ADPCM
            0x0130    Sipro Lab Telecom ACELP NET
            0x0131    Sipro Lab Telecom ACELP 4800
            0x0132    Sipro Lab Telecom ACELP 8V3
            0x0133    Sipro Lab Telecom G.729
            0x0134    Sipro Lab Telecom G.729A
            0x0135    Sipro Lab Telecom Kelvin
            0x0140    Windows Media Video V8
            0x0150    Qualcomm PureVoice
            0x0151    Qualcomm HalfRate
            0x0155    Ring Zero Systems TUB GSM
            0x0160    Microsoft Audio 1
            0x0161    Windows Media Audio V7 / V8 / V9
            0x0162    Windows Media Audio Professional V9
            0x0163    Windows Media Audio Lossless V9
            0x0200    Creative Labs ADPCM
            0x0202    Creative Labs Fastspeech8
            0x0203    Creative Labs Fastspeech10
            0x0210    UHER Informatic GmbH ADPCM
            0x0220    Quarterdeck
            0x0230    I-link Worldwide VC
            0x0240    Aureal RAW Sport
            0x0250    Interactive Products HSX
            0x0251    Interactive Products RPELP
            0x0260    Consistent Software CS2
            0x0270    Sony SCX
            0x0300    Fujitsu FM Towns Snd
            0x0400    BTV Digital
            0x0401    Intel Music Coder
            0x0450    QDesign Music
            0x0680    VME VMPCM
            0x0681    AT&T Labs TPC
            0x08AE    ClearJump LiteWave
            0x1000    Olivetti GSM
            0x1001    Olivetti ADPCM
            0x1002    Olivetti CELP
            0x1003    Olivetti SBC
            0x1004    Olivetti OPR
            0x1100    Lernout & Hauspie Codec (0x1100)
            0x1101    Lernout & Hauspie CELP Codec (0x1101)
            0x1102    Lernout & Hauspie SBC Codec (0x1102)
            0x1103    Lernout & Hauspie SBC Codec (0x1103)
            0x1104    Lernout & Hauspie SBC Codec (0x1104)
            0x1400    Norris
            0x1401    AT&T ISIAudio
            0x1500    Soundspace Music Compression
            0x181C    VoxWare RT24 Speech
            0x1FC4    NCT Soft ALF2CD (www.nctsoft.com)
            0x2000    Dolby AC3
            0x2001    Dolby DTS
            0x2002    WAVE_FORMAT_14_4
            0x2003    WAVE_FORMAT_28_8
            0x2004    WAVE_FORMAT_COOK
            0x2005    WAVE_FORMAT_DNET
            0x674F    Ogg Vorbis 1
            0x6750    Ogg Vorbis 2
            0x6751    Ogg Vorbis 3
            0x676F    Ogg Vorbis 1+
            0x6770    Ogg Vorbis 2+
            0x6771    Ogg Vorbis 3+
            0x7A21    GSM-AMR (CBR, no SID)
            0x7A22    GSM-AMR (VBR, including SID)
            0xFFFE    WAVE_FORMAT_EXTENSIBLE
            0xFFFF    WAVE_FORMAT_DEVELOPMENT

        */

        return getid3_lib::EmbeddedLookup('0x'.str_pad(strtoupper(dechex($wFormatTag)), 4, '0', STR_PAD_LEFT), $begin, __LINE__, __FILE__, 'riff-wFormatTag');
    }

    public static function fourccLookup($fourcc) {

        $begin = __LINE__;

        /** This is not a comment!

            swot    http://developer.apple.com/qa/snd/snd07.html
            ____    No Codec (____)
            _BIT    BI_BITFIELDS (Raw RGB)
            _JPG    JPEG compressed
            _PNG    PNG compressed W3C/ISO/IEC (RFC-2083)
            _RAW    Full Frames (Uncompressed)
            _RGB    Raw RGB Bitmap
            _RL4    RLE 4bpp RGB
            _RL8    RLE 8bpp RGB
            3IV1    3ivx MPEG-4 v1
            3IV2    3ivx MPEG-4 v2
            3IVX    3ivx MPEG-4
            AASC    Autodesk Animator
            ABYR    Kensington ?ABYR?
            AEMI    Array Microsystems VideoONE MPEG1-I Capture
            AFLC    Autodesk Animator FLC
            AFLI    Autodesk Animator FLI
            AMPG    Array Microsystems VideoONE MPEG
            ANIM    Intel RDX (ANIM)
            AP41    AngelPotion Definitive
            ASV1    Asus Video v1
            ASV2    Asus Video v2
            ASVX    Asus Video 2.0 (audio)
            AUR2    AuraVision Aura 2 Codec - YUV 4:2:2
            AURA    AuraVision Aura 1 Codec - YUV 4:1:1
            AVDJ    Independent JPEG Group\'s codec (AVDJ)
            AVRN    Independent JPEG Group\'s codec (AVRN)
            AYUV    4:4:4 YUV (AYUV)
            AZPR    Quicktime Apple Video (AZPR)
            BGR     Raw RGB32
            BLZ0    Blizzard DivX MPEG-4
            BTVC    Conexant Composite Video
            BINK    RAD Game Tools Bink Video
            BT20    Conexant Prosumer Video
            BTCV    Conexant Composite Video Codec
            BW10    Data Translation Broadway MPEG Capture
            CC12    Intel YUV12
            CDVC    Canopus DV
            CFCC    Digital Processing Systems DPS Perception
            CGDI    Microsoft Office 97 Camcorder Video
            CHAM    Winnov Caviara Champagne
            CJPG    Creative WebCam JPEG
            CLJR    Cirrus Logic YUV 4:1:1
            CMYK    Common Data Format in Printing (Colorgraph)
            CPLA    Weitek 4:2:0 YUV Planar
            CRAM    Microsoft Video 1 (CRAM)
            cvid    Radius Cinepak
            CVID    Radius Cinepak
            CWLT    Microsoft Color WLT DIB
            CYUV    Creative Labs YUV
            CYUY    ATI YUV
            D261    H.261
            D263    H.263
            DIB     Device Independent Bitmap
            DIV1    FFmpeg OpenDivX
            DIV2    Microsoft MPEG-4 v1/v2
            DIV3    DivX ;-) MPEG-4 v3.x Low-Motion
            DIV4    DivX ;-) MPEG-4 v3.x Fast-Motion
            DIV5    DivX MPEG-4 v5.x
            DIV6    DivX ;-) (MS MPEG-4 v3.x)
            DIVX    DivX MPEG-4 v4 (OpenDivX / Project Mayo)
            divx    DivX MPEG-4
            DMB1    Matrox Rainbow Runner hardware MJPEG
            DMB2    Paradigm MJPEG
            DSVD    ?DSVD?
            DUCK    Duck TrueMotion 1.0
            DPS0    DPS/Leitch Reality Motion JPEG
            DPSC    DPS/Leitch PAR Motion JPEG
            DV25    Matrox DVCPRO codec
            DV50    Matrox DVCPRO50 codec
            DVC     IEC 61834 and SMPTE 314M (DVC/DV Video)
            DVCP    IEC 61834 and SMPTE 314M (DVC/DV Video)
            DVHD    IEC Standard DV 1125 lines @ 30fps / 1250 lines @ 25fps
            DVMA    Darim Vision DVMPEG (dummy for MPEG compressor) (www.darvision.com)
            DVSL    IEC Standard DV compressed in SD (SDL)
            DVAN    ?DVAN?
            DVE2    InSoft DVE-2 Videoconferencing
            dvsd    IEC 61834 and SMPTE 314M DVC/DV Video
            DVSD    IEC 61834 and SMPTE 314M DVC/DV Video
            DVX1    Lucent DVX1000SP Video Decoder
            DVX2    Lucent DVX2000S Video Decoder
            DVX3    Lucent DVX3000S Video Decoder
            DX50    DivX v5
            DXT1    Microsoft DirectX Compressed Texture (DXT1)
            DXT2    Microsoft DirectX Compressed Texture (DXT2)
            DXT3    Microsoft DirectX Compressed Texture (DXT3)
            DXT4    Microsoft DirectX Compressed Texture (DXT4)
            DXT5    Microsoft DirectX Compressed Texture (DXT5)
            DXTC    Microsoft DirectX Compressed Texture (DXTC)
            DXTn    Microsoft DirectX Compressed Texture (DXTn)
            EM2V    Etymonix MPEG-2 I-frame (www.etymonix.com)
            EKQ0    Elsa ?EKQ0?
            ELK0    Elsa ?ELK0?
            ESCP    Eidos Escape
            ETV1    eTreppid Video ETV1
            ETV2    eTreppid Video ETV2
            ETVC    eTreppid Video ETVC
            FLIC    Autodesk FLI/FLC Animation
            FLV1    Sorenson Spark
            FLV4    On2 TrueMotion VP6
            FRWT    Darim Vision Forward Motion JPEG (www.darvision.com)
            FRWU    Darim Vision Forward Uncompressed (www.darvision.com)
            FLJP    D-Vision Field Encoded Motion JPEG
            FPS1    FRAPS v1
            FRWA    SoftLab-Nsk Forward Motion JPEG w/ alpha channel
            FRWD    SoftLab-Nsk Forward Motion JPEG
            FVF1    Iterated Systems Fractal Video Frame
            GLZW    Motion LZW (gabest@freemail.hu)
            GPEG    Motion JPEG (gabest@freemail.hu)
            GWLT    Microsoft Greyscale WLT DIB
            H260    Intel ITU H.260 Videoconferencing
            H261    Intel ITU H.261 Videoconferencing
            H262    Intel ITU H.262 Videoconferencing
            H263    Intel ITU H.263 Videoconferencing
            H264    Intel ITU H.264 Videoconferencing
            H265    Intel ITU H.265 Videoconferencing
            H266    Intel ITU H.266 Videoconferencing
            H267    Intel ITU H.267 Videoconferencing
            H268    Intel ITU H.268 Videoconferencing
            H269    Intel ITU H.269 Videoconferencing
            HFYU    Huffman Lossless Codec
            HMCR    Rendition Motion Compensation Format (HMCR)
            HMRR    Rendition Motion Compensation Format (HMRR)
            I263    FFmpeg I263 decoder
            IF09    Indeo YVU9 ("YVU9 with additional delta-frame info after the U plane")
            IUYV    Interlaced version of UYVY (www.leadtools.com)
            IY41    Interlaced version of Y41P (www.leadtools.com)
            IYU1    12 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard
            IYU2    24 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard
            IYUV    Planar YUV format (8-bpp Y plane, followed by 8-bpp 2×2 U and V planes)
            i263    Intel ITU H.263 Videoconferencing (i263)
            I420    Intel Indeo 4
            IAN     Intel Indeo 4 (RDX)
            ICLB    InSoft CellB Videoconferencing
            IGOR    Power DVD
            IJPG    Intergraph JPEG
            ILVC    Intel Layered Video
            ILVR    ITU-T H.263+
            IPDV    I-O Data Device Giga AVI DV Codec
            IR21    Intel Indeo 2.1
            IRAW    Intel YUV Uncompressed
            IV30    Intel Indeo 3.0
            IV31    Intel Indeo 3.1
            IV32    Ligos Indeo 3.2
            IV33    Ligos Indeo 3.3
            IV34    Ligos Indeo 3.4
            IV35    Ligos Indeo 3.5
            IV36    Ligos Indeo 3.6
            IV37    Ligos Indeo 3.7
            IV38    Ligos Indeo 3.8
            IV39    Ligos Indeo 3.9
            IV40    Ligos Indeo Interactive 4.0
            IV41    Ligos Indeo Interactive 4.1
            IV42    Ligos Indeo Interactive 4.2
            IV43    Ligos Indeo Interactive 4.3
            IV44    Ligos Indeo Interactive 4.4
            IV45    Ligos Indeo Interactive 4.5
            IV46    Ligos Indeo Interactive 4.6
            IV47    Ligos Indeo Interactive 4.7
            IV48    Ligos Indeo Interactive 4.8
            IV49    Ligos Indeo Interactive 4.9
            IV50    Ligos Indeo Interactive 5.0
            JBYR    Kensington ?JBYR?
            JPEG    Still Image JPEG DIB
            JPGL    Pegasus Lossless Motion JPEG
            KMVC    Team17 Software Karl Morton\'s Video Codec
            LSVM    Vianet Lighting Strike Vmail (Streaming) (www.vianet.com)
            LEAD    LEAD Video Codec
            Ljpg    LEAD MJPEG Codec
            MDVD    Alex MicroDVD Video (hacked MS MPEG-4) (www.tiasoft.de)
            MJPA    Morgan Motion JPEG (MJPA) (www.morgan-multimedia.com)
            MJPB    Morgan Motion JPEG (MJPB) (www.morgan-multimedia.com)
            MMES    Matrox MPEG-2 I-frame
            MP2v    Microsoft S-Mpeg 4 version 1 (MP2v)
            MP42    Microsoft S-Mpeg 4 version 2 (MP42)
            MP43    Microsoft S-Mpeg 4 version 3 (MP43)
            MP4S    Microsoft S-Mpeg 4 version 3 (MP4S)
            MP4V    FFmpeg MPEG-4
            MPG1    FFmpeg MPEG 1/2
            MPG2    FFmpeg MPEG 1/2
            MPG3    FFmpeg DivX ;-) (MS MPEG-4 v3)
            MPG4    Microsoft MPEG-4
            MPGI    Sigma Designs MPEG
            MPNG    PNG images decoder
            MSS1    Microsoft Windows Screen Video
            MSZH    LCL (Lossless Codec Library) (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)
            M261    Microsoft H.261
            M263    Microsoft H.263
            M4S2    Microsoft Fully Compliant MPEG-4 v2 simple profile (M4S2)
            m4s2    Microsoft Fully Compliant MPEG-4 v2 simple profile (m4s2)
            MC12    ATI Motion Compensation Format (MC12)
            MCAM    ATI Motion Compensation Format (MCAM)
            MJ2C    Morgan Multimedia Motion JPEG2000
            mJPG    IBM Motion JPEG w/ Huffman Tables
            MJPG    Microsoft Motion JPEG DIB
            MP42    Microsoft MPEG-4 (low-motion)
            MP43    Microsoft MPEG-4 (fast-motion)
            MP4S    Microsoft MPEG-4 (MP4S)
            mp4s    Microsoft MPEG-4 (mp4s)
            MPEG    Chromatic Research MPEG-1 Video I-Frame
            MPG4    Microsoft MPEG-4 Video High Speed Compressor
            MPGI    Sigma Designs MPEG
            MRCA    FAST Multimedia Martin Regen Codec
            MRLE    Microsoft Run Length Encoding
            MSVC    Microsoft Video 1
            MTX1    Matrox ?MTX1?
            MTX2    Matrox ?MTX2?
            MTX3    Matrox ?MTX3?
            MTX4    Matrox ?MTX4?
            MTX5    Matrox ?MTX5?
            MTX6    Matrox ?MTX6?
            MTX7    Matrox ?MTX7?
            MTX8    Matrox ?MTX8?
            MTX9    Matrox ?MTX9?
            MV12    Motion Pixels Codec (old)
            MWV1    Aware Motion Wavelets
            nAVI    SMR Codec (hack of Microsoft MPEG-4) (IRC #shadowrealm)
            NT00    NewTek LightWave HDTV YUV w/ Alpha (www.newtek.com)
            NUV1    NuppelVideo
            NTN1    Nogatech Video Compression 1
            NVS0    nVidia GeForce Texture (NVS0)
            NVS1    nVidia GeForce Texture (NVS1)
            NVS2    nVidia GeForce Texture (NVS2)
            NVS3    nVidia GeForce Texture (NVS3)
            NVS4    nVidia GeForce Texture (NVS4)
            NVS5    nVidia GeForce Texture (NVS5)
            NVT0    nVidia GeForce Texture (NVT0)
            NVT1    nVidia GeForce Texture (NVT1)
            NVT2    nVidia GeForce Texture (NVT2)
            NVT3    nVidia GeForce Texture (NVT3)
            NVT4    nVidia GeForce Texture (NVT4)
            NVT5    nVidia GeForce Texture (NVT5)
            PIXL    MiroXL, Pinnacle PCTV
            PDVC    I-O Data Device Digital Video Capture DV codec
            PGVV    Radius Video Vision
            PHMO    IBM Photomotion
            PIM1    MPEG Realtime (Pinnacle Cards)
            PIM2    Pegasus Imaging ?PIM2?
            PIMJ    Pegasus Imaging Lossless JPEG
            PVEZ    Horizons Technology PowerEZ
            PVMM    PacketVideo Corporation MPEG-4
            PVW2    Pegasus Imaging Wavelet Compression
            Q1.0    Q-Team\'s QPEG 1.0 (www.q-team.de)
            Q1.1    Q-Team\'s QPEG 1.1 (www.q-team.de)
            QPEG    Q-Team QPEG 1.0
            qpeq    Q-Team QPEG 1.1
            RGB     Raw BGR32
            RGBA    Raw RGB w/ Alpha
            RMP4    REALmagic MPEG-4 (unauthorized XVID copy) (www.sigmadesigns.com)
            ROQV    Id RoQ File Video Decoder
            RPZA    Quicktime Apple Video (RPZA)
            RUD0    Rududu video codec (http://rududu.ifrance.com/rududu/)
            RV10    RealVideo 1.0 (aka RealVideo 5.0)
            RV13    RealVideo 1.0 (RV13)
            RV20    RealVideo G2
            RV30    RealVideo 8
            RV40    RealVideo 9
            RGBT    Raw RGB w/ Transparency
            RLE     Microsoft Run Length Encoder
            RLE4    Run Length Encoded (4bpp, 16-color)
            RLE8    Run Length Encoded (8bpp, 256-color)
            RT21    Intel Indeo RealTime Video 2.1
            rv20    RealVideo G2
            rv30    RealVideo 8
            RVX     Intel RDX (RVX )
            SMC     Apple Graphics (SMC )
            SP54    Logitech Sunplus Sp54 Codec for Mustek GSmart Mini 2
            SPIG    Radius Spigot
            SVQ3    Sorenson Video 3 (Apple Quicktime 5)
            s422    Tekram VideoCap C210 YUV 4:2:2
            SDCC    Sun Communication Digital Camera Codec
            SFMC    CrystalNet Surface Fitting Method
            SMSC    Radius SMSC
            SMSD    Radius SMSD
            smsv    WorldConnect Wavelet Video
            SPIG    Radius Spigot
            SPLC    Splash Studios ACM Audio Codec (www.splashstudios.net)
            SQZ2    Microsoft VXTreme Video Codec V2
            STVA    ST Microelectronics CMOS Imager Data (Bayer)
            STVB    ST Microelectronics CMOS Imager Data (Nudged Bayer)
            STVC    ST Microelectronics CMOS Imager Data (Bunched)
            STVX    ST Microelectronics CMOS Imager Data (Extended CODEC Data Format)
            STVY    ST Microelectronics CMOS Imager Data (Extended CODEC Data Format with Correction Data)
            SV10    Sorenson Video R1
            SVQ1    Sorenson Video
            T420    Toshiba YUV 4:2:0
            TM2A    Duck TrueMotion Archiver 2.0 (www.duck.com)
            TVJP    Pinnacle/Truevision Targa 2000 board (TVJP)
            TVMJ    Pinnacle/Truevision Targa 2000 board (TVMJ)
            TY0N    Tecomac Low-Bit Rate Codec (www.tecomac.com)
            TY2C    Trident Decompression Driver
            TLMS    TeraLogic Motion Intraframe Codec (TLMS)
            TLST    TeraLogic Motion Intraframe Codec (TLST)
            TM20    Duck TrueMotion 2.0
            TM2X    Duck TrueMotion 2X
            TMIC    TeraLogic Motion Intraframe Codec (TMIC)
            TMOT    Horizons Technology TrueMotion S
            tmot    Horizons TrueMotion Video Compression
            TR20    Duck TrueMotion RealTime 2.0
            TSCC    TechSmith Screen Capture Codec
            TV10    Tecomac Low-Bit Rate Codec
            TY2N    Trident ?TY2N?
            U263    UB Video H.263/H.263+/H.263++ Decoder
            UMP4    UB Video MPEG 4 (www.ubvideo.com)
            UYNV    Nvidia UYVY packed 4:2:2
            UYVP    Evans & Sutherland YCbCr 4:2:2 extended precision
            UCOD    eMajix.com ClearVideo
            ULTI    IBM Ultimotion
            UYVY    UYVY packed 4:2:2
            V261    Lucent VX2000S
            VIFP    VFAPI Reader Codec (www.yks.ne.jp/~hori/)
            VIV1    FFmpeg H263+ decoder
            VIV2    Vivo H.263
            VQC2    Vector-quantised codec 2 (research) http://eprints.ecs.soton.ac.uk/archive/00001310/01/VTC97-js.pdf)
            VTLP    Alaris VideoGramPiX
            VYU9    ATI YUV (VYU9)
            VYUY    ATI YUV (VYUY)
            V261    Lucent VX2000S
            V422    Vitec Multimedia 24-bit YUV 4:2:2 Format
            V655    Vitec Multimedia 16-bit YUV 4:2:2 Format
            VCR1    ATI Video Codec 1
            VCR2    ATI Video Codec 2
            VCR3    ATI VCR 3.0
            VCR4    ATI VCR 4.0
            VCR5    ATI VCR 5.0
            VCR6    ATI VCR 6.0
            VCR7    ATI VCR 7.0
            VCR8    ATI VCR 8.0
            VCR9    ATI VCR 9.0
            VDCT    Vitec Multimedia Video Maker Pro DIB
            VDOM    VDOnet VDOWave
            VDOW    VDOnet VDOLive (H.263)
            VDTZ    Darim Vison VideoTizer YUV
            VGPX    Alaris VideoGramPiX
            VIDS    Vitec Multimedia YUV 4:2:2 CCIR 601 for V422
            VIVO    Vivo H.263 v2.00
            vivo    Vivo H.263
            VIXL    Miro/Pinnacle Video XL
            VLV1    VideoLogic/PURE Digital Videologic Capture
            VP30    On2 VP3.0
            VP31    On2 VP3.1
            VP6F    On2 TrueMotion VP6
            VX1K    Lucent VX1000S Video Codec
            VX2K    Lucent VX2000S Video Codec
            VXSP    Lucent VX1000SP Video Codec
            WBVC    Winbond W9960
            WHAM    Microsoft Video 1 (WHAM)
            WINX    Winnov Software Compression
            WJPG    AverMedia Winbond JPEG
            WMV1    Windows Media Video V7
            WMV2    Windows Media Video V8
            WMV3    Windows Media Video V9
            WNV1    Winnov Hardware Compression
            XYZP    Extended PAL format XYZ palette (www.riff.org)
            x263    Xirlink H.263
            XLV0    NetXL Video Decoder
            XMPG    Xing MPEG (I-Frame only)
            XVID    XviD MPEG-4 (www.xvid.org)
            XXAN    ?XXAN?
            YU92    Intel YUV (YU92)
            YUNV    Nvidia Uncompressed YUV 4:2:2
            YUVP    Extended PAL format YUV palette (www.riff.org)
            Y211    YUV 2:1:1 Packed
            Y411    YUV 4:1:1 Packed
            Y41B    Weitek YUV 4:1:1 Planar
            Y41P    Brooktree PC1 YUV 4:1:1 Packed
            Y41T    Brooktree PC1 YUV 4:1:1 with transparency
            Y42B    Weitek YUV 4:2:2 Planar
            Y42T    Brooktree UYUV 4:2:2 with transparency
            Y422    ADS Technologies Copy of UYVY used in Pyro WebCam firewire camera
            Y800    Simple, single Y plane for monochrome images
            Y8      Grayscale video
            YC12    Intel YUV 12 codec
            YUV8    Winnov Caviar YUV8
            YUV9    Intel YUV9
            YUY2    Uncompressed YUV 4:2:2
            YUYV    Canopus YUV
            YV12    YVU12 Planar
            YVU9    Intel YVU9 Planar (8-bpp Y plane, followed by 8-bpp 4x4 U and V planes)
            YVYU    YVYU 4:2:2 Packed
            ZLIB    Lossless Codec Library zlib compression (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)
            ZPEG    Metheus Video Zipper

        */

        return getid3_lib::EmbeddedLookup($fourcc, $begin, __LINE__, __FILE__, 'riff-fourcc');
    }

    private function EitherEndian2Int($byteword, $signed=false) {
        if ($this->getid3->info['fileformat'] == 'riff') {
            return getid3_lib::LittleEndian2Int($byteword, $signed);
        }
        return getid3_lib::BigEndian2Int($byteword, false, $signed);
    }

}