<Website>

getID3

PHK Home

File: /lib/module.audio-video.riff.php

Size:75757
Storage flags:strip

<?php
























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 {

protected 
$container 'riff'

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


 
 
$info['riff'] = array('raw'=>array());


 
$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($RIFFheader04);
$RIFFsize substr($RIFFheader44);
$RIFFsubtype substr($RIFFheader84);

switch (
$RIFFtype) {

case 
'FORM'
 
 
$this->container 'aiff';
$thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
$thisfile_riff[$RIFFsubtype] = $this->ParseRIFF($offset, ($offset $thisfile_riff['header_size'] - 4));
break;

case 
'RIFF'
 case 
'SDSS'
 case 
'RMP3'
 
 
$this->container 'riff';
$thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
if (
$RIFFsubtype == 'RMP3') {

 
$RIFFsubtype 'WAVE';
}
if (
$RIFFsubtype != 'AMV ') {

 
 
$thisfile_riff[$RIFFsubtype] = $this->ParseRIFF($offset, ($offset $thisfile_riff['header_size'] - 4));
}
if ((
$info['avdataend'] - $info['filesize']) == 1) {

 
 
 
$info['avdataend'] = $info['filesize'];
}

$nextRIFFoffset $Original['avdataoffset'] + $thisfile_riff['header_size']; 
 while (
$nextRIFFoffset min($info['filesize'], $info['avdataend'])) {
try {
$this->fseek($nextRIFFoffset);
} catch (
getid3_exception $e) {
if (
$e->getCode() == 10) {

 
$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($nextRIFFheader01) == "\x00") {

 break;
}
}
$nextRIFFheaderID substr($nextRIFFheader04);
$nextRIFFsize $this->EitherEndian2Int(substr($nextRIFFheader44));
$nextRIFFtype substr($nextRIFFheader84);
$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 
'AMV ':
unset(
$info['riff']);
$info['amv'] = $this->ParseRIFFAMV($chunkdata['offset'] + 4$nextRIFFoffset);
break;

case 
'JUNK':

 
$thisfile_riff[$nextRIFFheaderID][] = $chunkdata;
break;

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

default:
if (
$info['filesize'] == ($chunkdata['offset'] - 128)) {
$DIVXTAG $nextRIFFheader.$this->fread(128 12);
if (
substr($DIVXTAG, -7) == 'DIVXTAG') {

 
$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');

 return 
false;
}

$streamindex 0;
switch (
$RIFFsubtype) {


 case 
'WAVE':
$info['fileformat'] = 'wav';

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'], 0strlen('unknown: 0x')) == 'unknown: 0x') {
$info['warning'][] = 'Audio codec = '.$thisfile_audio['codec'];
}
$thisfile_audio['bitrate'] = $thisfile_riff_audio[$streamindex]['bitrate'];

if (empty(
$info['playtime_seconds'])) { 
 
$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
 
$thisfile_audio['lossless'] = true;
break;

case 
0x2000
 
$thisfile_audio_dataformat 'ac3';
break;

default:

 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'])) {


 
$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($rgadData04));
$thisfile_riff_raw_rgad['nRadioRgAdjust'] = $this->EitherEndian2Int(substr($rgadData42));
$thisfile_riff_raw_rgad['nAudiophileRgAdjust'] = $this->EitherEndian2Int(substr($rgadData62));

$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($nRadioRgAdjustBitstring03));
$thisfile_riff_raw_rgad_track['originator'] = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring33));
$thisfile_riff_raw_rgad_track['signbit'] = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring61));
$thisfile_riff_raw_rgad_track['adjustment'] = getid3_lib::Bin2Dec(substr($nRadioRgAdjustBitstring79));
$thisfile_riff_raw_rgad_album['name'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring03));
$thisfile_riff_raw_rgad_album['originator'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring33));
$thisfile_riff_raw_rgad_album['signbit'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring61));
$thisfile_riff_raw_rgad_album['adjustment'] = getid3_lib::Bin2Dec(substr($nAudiophileRgAdjustBitstring79));

$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'], 04));


 
 


 
 
 }
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'])) {

 
$thisfile_riff_WAVE_bext_0 = &$thisfile_riff_WAVE['bext'][0];

$thisfile_riff_WAVE_bext_0['title'] = trim(substr($thisfile_riff_WAVE_bext_0['data'], 0256));
$thisfile_riff_WAVE_bext_0['author'] = trim(substr($thisfile_riff_WAVE_bext_0['data'], 25632));
$thisfile_riff_WAVE_bext_0['reference'] = trim(substr($thisfile_riff_WAVE_bext_0['data'], 28832));
$thisfile_riff_WAVE_bext_0['origin_date'] = substr($thisfile_riff_WAVE_bext_0['data'], 32010);
$thisfile_riff_WAVE_bext_0['origin_time'] = substr($thisfile_riff_WAVE_bext_0['data'], 3308);
$thisfile_riff_WAVE_bext_0['time_reference'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_bext_0['data'], 3388));
$thisfile_riff_WAVE_bext_0['bwf_version'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_bext_0['data'], 3461));
$thisfile_riff_WAVE_bext_0['reserved'] = substr($thisfile_riff_WAVE_bext_0['data'], 347254);
$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'])) {

 
$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'], 02));
$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'], 22));
}
$thisfile_riff_WAVE_MEXT_0['anciliary_data_length'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 62));
$thisfile_riff_WAVE_MEXT_0['raw']['anciliary_data_def'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_MEXT_0['data'], 82));
$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'])) {

 
$thisfile_riff_WAVE_cart_0 = &$thisfile_riff_WAVE['cart'][0];

$thisfile_riff_WAVE_cart_0['version'] = substr($thisfile_riff_WAVE_cart_0['data'], 04);
$thisfile_riff_WAVE_cart_0['title'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 464));
$thisfile_riff_WAVE_cart_0['artist'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 6864));
$thisfile_riff_WAVE_cart_0['cut_id'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 13264));
$thisfile_riff_WAVE_cart_0['client_id'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 19664));
$thisfile_riff_WAVE_cart_0['category'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 26064));
$thisfile_riff_WAVE_cart_0['classification'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 32464));
$thisfile_riff_WAVE_cart_0['out_cue'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 38864));
$thisfile_riff_WAVE_cart_0['start_date'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 45210));
$thisfile_riff_WAVE_cart_0['start_time'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 4628));
$thisfile_riff_WAVE_cart_0['end_date'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 47010));
$thisfile_riff_WAVE_cart_0['end_time'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 4808));
$thisfile_riff_WAVE_cart_0['producer_app_id'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 48864));
$thisfile_riff_WAVE_cart_0['producer_app_version'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 55264));
$thisfile_riff_WAVE_cart_0['user_defined_text'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 61664));
$thisfile_riff_WAVE_cart_0['zero_db_reference'] = getid3_lib::LittleEndian2Int(substr($thisfile_riff_WAVE_cart_0['data'], 6804), 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) + 44));
}
$thisfile_riff_WAVE_cart_0['url'] = trim(substr($thisfile_riff_WAVE_cart_0['data'], 7481024));
$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'])) {



 
$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_thisTagOffset4));
$SNDM_thisTagOffset += 4;
$SNDM_thisTagKey substr($thisfile_riff_WAVE_SNDM_0_data$SNDM_startoffset $SNDM_thisTagOffset4);
$SNDM_thisTagOffset += 4;
$SNDM_thisTagDataSize getid3_lib::BigEndian2Int(substr($thisfile_riff_WAVE_SNDM_0_data$SNDM_startoffset $SNDM_thisTagOffset2));
$SNDM_thisTagOffset += 2;
$SNDM_thisTagDataFlags getid3_lib::BigEndian2Int(substr($thisfile_riff_WAVE_SNDM_0_data$SNDM_startoffset $SNDM_thisTagOffset2));
$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 != ($SNDM_thisTagDataSize)) {
$info['warning'][] = 'RIFF.WAVE.SNDM.data contains tag not expected length (expected: '.$SNDM_thisTagSize.', found: '.($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'])) {

 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$sround($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'];


 
$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($RIFFdata44)) + 8;
$OrignalRIFFdataSize getid3_lib::LittleEndian2Int(substr($RIFFdata404)) + 44;

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


 
 
 
$RIFFdata substr($RIFFdata036).substr($RIFFdata44).substr($RIFFdata368);
$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
 if (!empty(
$info['ac3'])) {

 
$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'])) {

 
$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
 
$thisfile_audio['bitrate_mode'] = 'vbr';
$thisfile_audio_dataformat 'litewave';


 
 
 
 
 
 
 
 
 
 
 
 
 
 


 
$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'] = $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'
 case 
'lpac'
 case 
'ofr'
 case 
'ofs'
 
 break;

case 
'litewave':
if ((
$info['avdataend'] - $info['filesize']) == 1) {

 
 
 } else {

 
$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)) {

 
 
$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 {

 
$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 ':
$info['fileformat'] = 'avi';
$info['mime_type'] = 'video/avi';

$thisfile_video['bitrate_mode'] = 'vbr'
 
$thisfile_video['dataformat'] = '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'])) {

 
 
 
 
 
 
 
 
 
 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($ahsisd02));
$thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType'] = $this->EitherEndian2Int(substr($ahsisd21));
$thisfile_riff_raw['indx'][$streamnumber]['bIndexType'] = $this->EitherEndian2Int(substr($ahsisd31));
$thisfile_riff_raw['indx'][$streamnumber]['nEntriesInUse'] = $this->EitherEndian2Int(substr($ahsisd44));
$thisfile_riff_raw['indx'][$streamnumber]['dwChunkId'] = substr($ahsisd84);
$thisfile_riff_raw['indx'][$streamnumber]['dwReserved'] = $this->EitherEndian2Int(substr($ahsisd124));


 

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


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

$thisfile_riff_raw_avih['dwMicroSecPerFrame'] = $this->EitherEndian2Int(substr($avihData04)); 
 if (
$thisfile_riff_raw_avih['dwMicroSecPerFrame'] == 0) {
$info['error'][] = 'Corrupt RIFF file: avih.dwMicroSecPerFrame == zero';
return 
false;
}

$flags = array(
'dwMaxBytesPerSec'
 
'dwPaddingGranularity'
 
'dwFlags'
 
'dwTotalFrames'
 
'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_offset4));
$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);
}


 
$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($strhData04);

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


 
$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'];


 
$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']);


 
$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
 
$thisfile_audio_dataformat 'wav';
$thisfile_audio['lossless'] = true;
break;

case 
0x0050
 
$thisfile_audio_dataformat 'mp2'
 break;

case 
0x0055
 
$thisfile_audio_dataformat 'mp3';
break;

case 
0x00FF
 
$thisfile_audio_dataformat 'aac';
break;

case 
0x0161
 case 
0x0162
 case 
0x0163
 
$thisfile_audio_dataformat 'wma';
break;

case 
0x2000
 
$thisfile_audio_dataformat 'ac3';
break;

case 
0x2001
 
$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':

 
$thisfile_riff_raw['strh'][$i] = array();
$thisfile_riff_raw_strh_current = &$thisfile_riff_raw['strh'][$i];

$thisfile_riff_raw_strh_current['fccType'] = substr($strhData04); 
 
$thisfile_riff_raw_strh_current['fccHandler'] = substr($strhData44);
$thisfile_riff_raw_strh_current['dwFlags'] = $this->EitherEndian2Int(substr($strhData84)); 
 
$thisfile_riff_raw_strh_current['wPriority'] = $this->EitherEndian2Int(substr($strhData122));
$thisfile_riff_raw_strh_current['wLanguage'] = $this->EitherEndian2Int(substr($strhData142));
$thisfile_riff_raw_strh_current['dwInitialFrames'] = $this->EitherEndian2Int(substr($strhData164));
$thisfile_riff_raw_strh_current['dwScale'] = $this->EitherEndian2Int(substr($strhData204));
$thisfile_riff_raw_strh_current['dwRate'] = $this->EitherEndian2Int(substr($strhData244));
$thisfile_riff_raw_strh_current['dwStart'] = $this->EitherEndian2Int(substr($strhData284));
$thisfile_riff_raw_strh_current['dwLength'] = $this->EitherEndian2Int(substr($strhData324));
$thisfile_riff_raw_strh_current['dwSuggestedBufferSize'] = $this->EitherEndian2Int(substr($strhData364));
$thisfile_riff_raw_strh_current['dwQuality'] = $this->EitherEndian2Int(substr($strhData404));
$thisfile_riff_raw_strh_current['dwSampleSize'] = $this->EitherEndian2Int(substr($strhData444));
$thisfile_riff_raw_strh_current['rcFrame'] = $this->EitherEndian2Int(substr($strhData484));

$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'
 case 
'IRAW'
 case 
'YUY2'
 
$thisfile_video['lossless'] = true;
break;

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

switch (
$strhfccType) {
case 
'vids':
$thisfile_riff_raw_strf_strhfccType_streamindex self::ParseBITMAPINFOHEADER(substr($strfData040), ($this->container == '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'
 case 
'IRAW'
 case 
'YUY2'
 
$thisfile_video['lossless'] = true;

 break;

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

 break;
}

}
}
}
}
break;


case 
'AMV ':
$info['fileformat'] = 'amv';
$info['mime_type'] = 'video/amv';

$thisfile_video['bitrate_mode'] = 'vbr'
 
$thisfile_video['dataformat'] = 'mjpeg';
$thisfile_video['codec'] = 'mjpeg';
$thisfile_video['lossless'] = false;
$thisfile_video['bits_per_sample'] = 24;

$thisfile_audio['dataformat'] = 'adpcm';
$thisfile_audio['lossless'] = false;
break;



 case 
'CDDA':
$info['fileformat'] = 'cda';
unset(
$info['mime_type']);

$thisfile_audio_dataformat 'cda';

$info['avdataoffset'] = 44;

if (isset(
$thisfile_riff['CDDA']['fmt '][0]['data'])) {

 
$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'], 02));
$thisfile_riff_CDDA_fmt_0['track_num'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 22));
$thisfile_riff_CDDA_fmt_0['disc_id'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 44));
$thisfile_riff_CDDA_fmt_0['start_offset_frame'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 84));
$thisfile_riff_CDDA_fmt_0['playtime_frames'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 124));
$thisfile_riff_CDDA_fmt_0['unknown6'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 164));
$thisfile_riff_CDDA_fmt_0['unknown7'] = $this->EitherEndian2Int(substr($thisfile_riff_CDDA_fmt_0['data'], 204));

$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'];


 
$thisfile_audio['lossless'] = true;
$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':
$info['fileformat'] = 'aiff';
$info['mime_type'] = 'audio/x-aiff';

$thisfile_audio['bitrate_mode'] = 'cbr';
$thisfile_audio_dataformat 'aiff';
$thisfile_audio['lossless'] = true;

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)) {

 
 } 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'])) {


 
$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_data02), true);
$thisfile_riff_audio['total_samples'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data24), false);
$thisfile_riff_audio['bits_per_sample'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data62), true);
$thisfile_riff_audio['sample_rate'] = (int) getid3_lib::BigEndian2Float(substr($thisfile_riff_RIFFsubtype_COMM_0_data810));

if (
$thisfile_riff[$RIFFsubtype]['COMM'][0]['size'] > 18) {
$thisfile_riff_audio['codec_fourcc'] = substr($thisfile_riff_RIFFsubtype_COMM_0_data184);
$CodecNameSize getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_COMM_0_data221), false);
$thisfile_riff_audio['codec_name'] = substr($thisfile_riff_RIFFsubtype_COMM_0_data23$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']) {

 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'], $offset2), false);
$offset += 2;
for (
$i 0$i $CommentCount$i++) {
$info['comments_raw'][$i]['timestamp'] = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset4), false);
$offset += 4;
$info['comments_raw'][$i]['marker_id'] = getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset2), true);
$offset += 2;
$CommentLength getid3_lib::BigEndian2Int(substr($thisfile_riff[$RIFFsubtype]['COMT'][0]['data'], $offset2), 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'];
}
}













break;


 case 
'8SVX':
$info['fileformat'] = '8svx';
$info['mime_type'] = 'audio/8svx';

$thisfile_audio['bitrate_mode'] = 'cbr';
$thisfile_audio_dataformat '8svx';
$thisfile_audio['bits_per_sample'] = 8;
$thisfile_audio['channels'] = 1

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'])) {

 
$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'], 04));
$thisfile_riff_RIFFsubtype_VHDR_0['repeatHiSamples'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 44));
$thisfile_riff_RIFFsubtype_VHDR_0['samplesPerHiCycle'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 84));
$thisfile_riff_RIFFsubtype_VHDR_0['samplesPerSec'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 122));
$thisfile_riff_RIFFsubtype_VHDR_0['ctOctave'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 141));
$thisfile_riff_RIFFsubtype_VHDR_0['sCompression'] = getid3_lib::BigEndian2Int(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 151));
$thisfile_riff_RIFFsubtype_VHDR_0['Volume'] = getid3_lib::FixedPoint16_16(substr($thisfile_riff_RIFFsubtype_VHDR_0['data'], 164));

$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'], 04));
switch (
$ChannelsIndex) {
case 
6
 
$thisfile_audio['channels'] = 2;
break;

case 
2
 case 
4
 
$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['fileformat'] = 'vcd'
 
$info['mime_type'] = 'video/mpeg';

if (!empty(
$thisfile_riff['CDXA']['data'][0]['size'])) {
getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.mpeg.php'__FILE__true);

$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';

 }

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'])) {

 
$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':

 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 
ParseRIFFAMV($startoffset$maxoffset) {



 
 
 
 
 
 
 
 
 
 
 
 
 
 

$info = &$this->getid3->info;
$RIFFchunk false;

try {

$this->fseek($startoffset);
$maxoffset min($maxoffset$info['avdataend']);
$AMVheader $this->fread(284);
if (
substr($AMVheader08) != 'hdrlamvh') {
throw new 
Exception('expecting "hdrlamv" at offset '.($startoffset 0).', found "'.substr($AMVheader08).'"');
}
if (
substr($AMVheader84) != "\x38\x00\x00\x00") { 
 throw new 
Exception('expecting "0x38000000" at offset '.($startoffset 8).', found "'.getid3_lib::PrintHexBytes(substr($AMVheader84)).'"');
}
$RIFFchunk = array();
$RIFFchunk['amvh']['us_per_frame'] = getid3_lib::LittleEndian2Int(substr($AMVheader124));
$RIFFchunk['amvh']['reserved28'] = substr($AMVheader1628); 
 
$RIFFchunk['amvh']['resolution_x'] = getid3_lib::LittleEndian2Int(substr($AMVheader444));
$RIFFchunk['amvh']['resolution_y'] = getid3_lib::LittleEndian2Int(substr($AMVheader484));
$RIFFchunk['amvh']['frame_rate_int'] = getid3_lib::LittleEndian2Int(substr($AMVheader524));
$RIFFchunk['amvh']['reserved0'] = getid3_lib::LittleEndian2Int(substr($AMVheader564)); 
 
$RIFFchunk['amvh']['reserved1'] = getid3_lib::LittleEndian2Int(substr($AMVheader604)); 
 
$RIFFchunk['amvh']['runtime_sec'] = getid3_lib::LittleEndian2Int(substr($AMVheader641));
$RIFFchunk['amvh']['runtime_min'] = getid3_lib::LittleEndian2Int(substr($AMVheader651));
$RIFFchunk['amvh']['runtime_hrs'] = getid3_lib::LittleEndian2Int(substr($AMVheader662));

$info['video']['frame_rate'] = 1000000 $RIFFchunk['amvh']['us_per_frame'];
$info['video']['resolution_x'] = $RIFFchunk['amvh']['resolution_x'];
$info['video']['resolution_y'] = $RIFFchunk['amvh']['resolution_y'];
$info['playtime_seconds'] = ($RIFFchunk['amvh']['runtime_hrs'] * 3600) + ($RIFFchunk['amvh']['runtime_min'] * 60) + $RIFFchunk['amvh']['runtime_sec'];



if (
substr($AMVheader6820) != 'LIST'."\x00\x00\x00\x00".'strlstrh'."\x38\x00\x00\x00") {
throw new 
Exception('expecting "LIST<0x00000000>strlstrh<0x38000000>" at offset '.($startoffset 68).', found "'.getid3_lib::PrintHexBytes(substr($AMVheader6820)).'"');
}

 if (
substr($AMVheader1448) != 'strf'."\x24\x00\x00\x00") {
throw new 
Exception('expecting "strf<0x24000000>" at offset '.($startoffset 144).', found "'.getid3_lib::PrintHexBytes(substr($AMVheader1448)).'"');
}


if (
substr($AMVheader18820) != 'LIST'."\x00\x00\x00\x00".'strlstrh'."\x30\x00\x00\x00") {
throw new 
Exception('expecting "LIST<0x00000000>strlstrh<0x30000000>" at offset '.($startoffset 188).', found "'.getid3_lib::PrintHexBytes(substr($AMVheader18820)).'"');
}

 if (
substr($AMVheader2568) != 'strf'."\x14\x00\x00\x00") {
throw new 
Exception('expecting "strf<0x14000000>" at offset '.($startoffset 256).', found "'.getid3_lib::PrintHexBytes(substr($AMVheader2568)).'"');
}

 
 
 
 
 
 
 
 
 
 
 
$RIFFchunk['strf']['wformattag'] = getid3_lib::LittleEndian2Int(substr($AMVheader2642));
$RIFFchunk['strf']['nchannels'] = getid3_lib::LittleEndian2Int(substr($AMVheader2662));
$RIFFchunk['strf']['nsamplespersec'] = getid3_lib::LittleEndian2Int(substr($AMVheader2684));
$RIFFchunk['strf']['navgbytespersec'] = getid3_lib::LittleEndian2Int(substr($AMVheader2724));
$RIFFchunk['strf']['nblockalign'] = getid3_lib::LittleEndian2Int(substr($AMVheader2762));
$RIFFchunk['strf']['wbitspersample'] = getid3_lib::LittleEndian2Int(substr($AMVheader2782));
$RIFFchunk['strf']['cbsize'] = getid3_lib::LittleEndian2Int(substr($AMVheader2802));
$RIFFchunk['strf']['reserved'] = getid3_lib::LittleEndian2Int(substr($AMVheader2822));


$info['audio']['lossless'] = false;
$info['audio']['sample_rate'] = $RIFFchunk['strf']['nsamplespersec'];
$info['audio']['channels'] = $RIFFchunk['strf']['nchannels'];
$info['audio']['bits_per_sample'] = $RIFFchunk['strf']['wbitspersample'];
$info['audio']['bitrate'] = $info['audio']['sample_rate'] * $info['audio']['channels'] * $info['audio']['bits_per_sample'];
$info['audio']['bitrate_mode'] = 'cbr';


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

return 
$RIFFchunk;
}


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 str_replace("\x00"'_'substr($chunknamesize04)); 
 
$chunksize $this->EitherEndian2Int(substr($chunknamesize44));

 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) {

 
$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($AudioChunkHeader02);
$AudioChunkStreamType substr($AudioChunkHeader22);
$AudioChunkSize getid3_lib::LittleEndian2Int(substr($AudioChunkHeader44));

if (
$AudioChunkStreamType == 'wb') {
$FirstFourBytes substr($AudioChunkHeader84);
if (
preg_match('/^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\xEB]/s'$FirstFourBytes)) {

 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__CLASS__);
$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']);

 }
unset(
$getid3_temp$getid3_mp3);
}

} elseif (
strpos($FirstFourBytesgetid3_ac3::syncword) === 0) {


 
$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 4SEEK_CUR);

} else {

if (!isset(
$RIFFchunk[$listname])) {
$RIFFchunk[$listname] = array();
}
$LISTchunkParent $listname;
$LISTchunkMaxOffset $this->ftell() - $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($chunksizeSEEK_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($testData04))) {


 if (
getid3_mp3::MPEGaudioHeaderBytesValid(substr($testData04))) {
$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__CLASS__);
$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($testData02) == getid3_ac3::syncword)) || substr($testData82) == strrev(getid3_ac3::syncword)) {


 
$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 {

 
 
 
$ac3_data '';
for (
$i 0$i 28$i += 2) {
$ac3_data .= substr($testData$i 11);
$ac3_data .= substr($testData$i 01);
}
$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)) {


 
$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']; 
 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($testData04) == 'wvpk') {


 
$info['wavpack']['offset'] = $info['avdataoffset'];
$info['wavpack']['size'] = getid3_lib::LittleEndian2Int(substr($testData44));
$this->parseWavPackHeader(substr($testData828));

} else {

 
 }
$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':

 case 
'JUNK':

 
 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)) {

 
$info['riff']['comments']['junk'][] = trim($matches[1]);
}

 
 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($chunksizeSEEK_CUR);
}
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) {

 
$RIFFchunk[$chunkname][$thisindex]['data'] = $this->fread($chunksize);
} else {
$this->fseek($chunksizeSEEK_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($RIFFdataLength4);
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) {

 
$WaveFormatEx['raw'] = array();
$WaveFormatEx_raw = &$WaveFormatEx['raw'];

$WaveFormatEx_raw['wFormatTag'] = substr($WaveFormatExData02);
$WaveFormatEx_raw['nChannels'] = substr($WaveFormatExData22);
$WaveFormatEx_raw['nSamplesPerSec'] = substr($WaveFormatExData44);
$WaveFormatEx_raw['nAvgBytesPerSec'] = substr($WaveFormatExData84);
$WaveFormatEx_raw['nBlockAlign'] = substr($WaveFormatExData122);
$WaveFormatEx_raw['wBitsPerSample'] = substr($WaveFormatExData142);
if (
strlen($WaveFormatExData) > 16) {
$WaveFormatEx_raw['cbSize'] = substr($WaveFormatExData162);
}
$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) {

 
 
 
 
 
 
 
 


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

$thisfile_wavpack['version'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData02));
if (
$thisfile_wavpack['version'] >= 2) {
$thisfile_wavpack['bits'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData22));
}
if (
$thisfile_wavpack['version'] >= 3) {
$thisfile_wavpack['flags_raw'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData42));
$thisfile_wavpack['shift'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData62));
$thisfile_wavpack['total_samples'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData84));
$thisfile_wavpack['crc1'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData124));
$thisfile_wavpack['crc2'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData164));
$thisfile_wavpack['extension'] = substr($WavPackChunkData204);
$thisfile_wavpack['extra_bc'] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData241));
for (
$i 0$i <= 2$i++) {
$thisfile_wavpack['extras'][] = getid3_lib::LittleEndian2Int(substr($WavPackChunkData25 $i1));
}


 
$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($BITMAPINFOHEADER04); 
 
$parsed['biWidth'] = substr($BITMAPINFOHEADER44); 
 
$parsed['biHeight'] = substr($BITMAPINFOHEADER84); 
 
$parsed['biPlanes'] = substr($BITMAPINFOHEADER122); 
 
$parsed['biBitCount'] = substr($BITMAPINFOHEADER142); 
 
$parsed['biSizeImage'] = substr($BITMAPINFOHEADER204); 
 
$parsed['biXPelsPerMeter'] = substr($BITMAPINFOHEADER244); 
 
$parsed['biYPelsPerMeter'] = substr($BITMAPINFOHEADER284); 
 
$parsed['biClrUsed'] = substr($BITMAPINFOHEADER324); 
 
$parsed['biClrImportant'] = substr($BITMAPINFOHEADER364); 
 
$parsed array_map('getid3_lib::'.($littleEndian 'Little' 'Big').'Endian2Int'$parsed);

$parsed['fourcc'] = substr($BITMAPINFOHEADER164); 

return 
$parsed;
}

public static function 
ParseDIVXTAG($DIVXTAG$raw=false) {

 
 
 
 
 
 
 
 
 
 

static 
$DIVXTAGgenre = array(
=> 'Action',
=> 'Action/Adventure',
=> 'Adventure',
=> 'Adult',
=> 'Anime',
=> 'Cartoon',
=> 'Claymation',
=> 'Comedy',
=> 'Commercial',
=> '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(
=> 'Unrated',
=> 'G',
=> 'PG',
=> 'PG-13',
=> 'R',
=> 'NC-17',
);

$parsed['title'] = trim(substr($DIVXTAG032));
$parsed['artist'] = trim(substr($DIVXTAG3228));
$parsed['year'] = intval(trim(substr($DIVXTAG604)));
$parsed['comment'] = trim(substr($DIVXTAG6448));
$parsed['genre_id'] = intval(trim(substr($DIVXTAG1123)));
$parsed['rating_id'] = ord(substr($DIVXTAG1151));

 

$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__;


















return 
getid3_lib::EmbeddedLookup($tagshortname$begin__LINE____FILE__'riff-sndm');
}

public static function 
wFormatTagLookup($wFormatTag) {

$begin __LINE__;



































































































































































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__;




































































































































































































































































































































































































return 
getid3_lib::EmbeddedLookup($fourcc$begin__LINE____FILE__'riff-fourcc');
}

private function 
EitherEndian2Int($byteword$signed=false) {
if (
$this->container == 'riff') {
return 
getid3_lib::LittleEndian2Int($byteword$signed);
}
return 
getid3_lib::BigEndian2Int($bytewordfalse$signed);
}

}

For more information about the PHK package format: http://phk.tekwire.net