mirror of
https://github.com/Yetangitu/ampache
synced 2025-10-04 10:19:25 +02:00
4aa256cb07
Remove misleading, unvetted, or in some cases just plain wrong data. Packages and categories weren't being used correctly. They still aren't.
1233 lines
31 KiB
PHP
1233 lines
31 KiB
PHP
<?php
|
|
/* vim:set tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab: */
|
|
/**
|
|
* vainfo Class
|
|
*
|
|
*
|
|
* LICENSE: GNU General Public License, version 2 (GPLv2)
|
|
* Copyright (c) 2001 - 2011 Ampache.org All Rights Reserved
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License v2
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* @package Ampache
|
|
* @copyright 2001 - 2011 Ampache.org
|
|
* @license http://opensource.org/licenses/gpl-2.0 GPLv2
|
|
* @link http://www.ampache.org/
|
|
*/
|
|
|
|
/**
|
|
* vainfo Class
|
|
*
|
|
* This class takes the information pulled from getID3 and returns it in a
|
|
* Ampache friendly way.
|
|
*
|
|
* @package Ampache
|
|
* @copyright 2001 - 2011 Ampache.org
|
|
* @license http://opensource.org/licenses/gpl-2.0 GPLv2
|
|
* @link http://www.ampache.org/
|
|
*/
|
|
class vainfo {
|
|
|
|
// {{{ property
|
|
|
|
/**
|
|
* Default encoding
|
|
*
|
|
* @var string
|
|
*/
|
|
public $encoding = '';
|
|
|
|
/**
|
|
* Default id3v1 encoding
|
|
*
|
|
* @var string
|
|
*/
|
|
public $encoding_id3v1 = 'ISO-8859-1';
|
|
|
|
/**
|
|
* Default id3v2 encoding
|
|
*
|
|
* @var string
|
|
*/
|
|
public $encoding_id3v2 = 'ISO-8859-1';
|
|
|
|
/* Loaded Variables */
|
|
/**
|
|
* Filename
|
|
*
|
|
* @var string
|
|
*/
|
|
public $filename = '';
|
|
|
|
/**
|
|
* Media type
|
|
*
|
|
* @var string
|
|
*/
|
|
public $type = '';
|
|
|
|
/**
|
|
* Media tags
|
|
*
|
|
* @var array
|
|
*/
|
|
public $tags = array();
|
|
|
|
/* Internal Information */
|
|
/**
|
|
* GetID3 analyzed data.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_raw = array();
|
|
|
|
/**
|
|
* GetID3 object
|
|
*
|
|
* @var object
|
|
*/
|
|
protected $_getID3 = '';
|
|
|
|
/**
|
|
* Iconv use flag
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $_iconv = false;
|
|
|
|
/**
|
|
* File encoding charset
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $_file_encoding = '';
|
|
|
|
/**
|
|
* File pattern
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $_file_pattern = '';
|
|
|
|
/**
|
|
* Directory pattern
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $_dir_pattern = '';
|
|
|
|
/* Internal Private */
|
|
/**
|
|
* Pathinfo results array
|
|
*
|
|
* @var array
|
|
*/
|
|
private $_pathinfo;
|
|
|
|
/**
|
|
* Tag broken flag. If tag is broken, return true.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
private $_broken = false;
|
|
|
|
// }}}
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* This function just sets up the class, it doesn't
|
|
* actually pull the information
|
|
*
|
|
* @todo Some mp3 is still broken... I think this is related to mb_detect_order().
|
|
* @param string $file filename
|
|
* @param string $encoding Default encode character set
|
|
* @param string $encoding_id3v1 Default id3v1 encode character set
|
|
* @param string $encoding_iv3v2 Default id3v2 encode character set
|
|
* @param string $dir_pattern Directory pattern
|
|
* @param string $file_pattern File pattern
|
|
* @return mixed If can't analyze file, return false. default return: void
|
|
*/
|
|
public function __construct($file, $encoding = null, $encoding_id3v1 = null, $encoding_id3v2 = null, $dir_pattern, $file_pattern) {
|
|
|
|
/* Check for ICONV */
|
|
if (function_exists('iconv') && Config::get('use_iconv') == "1") {
|
|
$this->_iconv = true;
|
|
}
|
|
else {
|
|
$this->_iconv = false;
|
|
}
|
|
|
|
$this->filename = $file;
|
|
if ($encoding) {
|
|
$this->encoding = $encoding;
|
|
}
|
|
else {
|
|
$this->encoding = Config::get('site_charset');
|
|
}
|
|
|
|
/* These are needed for the filename mojo */
|
|
$this->_file_pattern = $file_pattern;
|
|
$this->_dir_pattern = $dir_pattern;
|
|
|
|
if(strtoupper(substr(PHP_OS,0,3)) == 'WIN') {
|
|
$this->_pathinfo = str_replace('%3A', ':', urlencode($this->filename));
|
|
$this->_pathinfo = pathinfo(str_replace('%5C', '\\', $this->_pathinfo));
|
|
}
|
|
else {
|
|
$this->_pathinfo = pathinfo(str_replace('%2F', '/', urlencode($this->filename)));
|
|
}
|
|
$this->_pathinfo['extension'] = strtolower($this->_pathinfo['extension']);
|
|
|
|
// Initialize getID3 engine
|
|
$this->_getID3 = new getID3();
|
|
|
|
$this->_getID3->option_md5_data = false;
|
|
$this->_getID3->option_md5_data_source = false;
|
|
$this->_getID3->option_tags_html = false;
|
|
$this->_getID3->option_extra_info = true;
|
|
$this->_getID3->option_tag_lyrics3 = true;
|
|
$this->_getID3->option_tags_process = true;
|
|
$this->_getID3->encoding = $this->encoding;
|
|
|
|
// get id3tag encoding (try to work around off-spec id3v1 tags)
|
|
try {
|
|
$this->_raw = $this->_getID3->analyze($file);
|
|
}
|
|
catch (Exception $error) {
|
|
debug_event('Getid3()',"Broken file detected $file - " . $error->message,'1');
|
|
$this->_broken = true;
|
|
return false;
|
|
}
|
|
|
|
/* Use default mb_detect_order in php.ini or not */
|
|
if (Config::get('mb_detect_order')) {
|
|
$mb_order = Config::get('mb_detect_order');
|
|
}
|
|
elseif (function_exists('mb_detect_order')) {
|
|
$mb_order = implode(", ", mb_detect_order());
|
|
}
|
|
else {
|
|
$mb_order = "auto";
|
|
}
|
|
|
|
$test_tags = array('artist', 'album', 'genre', 'title');
|
|
|
|
if ($encoding_id3v1) {
|
|
$this->encoding_id3v1 = $encoding_id3v1;
|
|
}
|
|
else {
|
|
foreach ($test_tags as $tag) {
|
|
if ($value = $this->_raw['id3v1'][$tag]) {
|
|
$tags[$tag] = $value;
|
|
}
|
|
}
|
|
|
|
$this->encoding_id3v1 = self::_detect_encoding($tags, $mb_order);
|
|
}
|
|
|
|
if (Config::get('getid3_detect_id3v2_encoding')) {
|
|
foreach ($test_tags as $tag) {
|
|
if ($value = $this->_raw['id3v2']['comments'][$tag]) {
|
|
$tags[$tag] = $value;
|
|
}
|
|
}
|
|
|
|
$this->encoding_id3v2 = self::_detect_encoding($tags, $mb_order);
|
|
$this->_getID3->encoding_id3v2 = $this->encoding_id3v2;
|
|
}
|
|
|
|
$this->_getID3->encoding_id3v1 = $this->encoding_id3v1;
|
|
|
|
} // vainfo
|
|
|
|
/**
|
|
* _detect_encoding
|
|
* Takes an array of tags and attempts to automatically detect their
|
|
* encoding.
|
|
*/
|
|
private static function _detect_encoding($tags, $mb_order) {
|
|
if (function_exists('mb_detect_encoding')) {
|
|
debug_event('vainfo', "id3v -> $id3v", 5);
|
|
$encodings = array();
|
|
$tags = array('artist', 'album', 'genre', 'title');
|
|
foreach ($tags as $tag) {
|
|
$encodings[mb_detect_encoding($tag, $mb_order, true)]++;
|
|
}
|
|
|
|
debug_event('vainfo', 'encoding detection: ' . print_r($encodings, true), 5);
|
|
$high = 0;
|
|
foreach ($encodings as $key => $value) {
|
|
if ($value > $high) {
|
|
$encoding = $key;
|
|
$high = $value;
|
|
}
|
|
}
|
|
|
|
if ($encoding != 'ASCII' && $encoding != '0') {
|
|
return $encoding;
|
|
}
|
|
else {
|
|
return 'ISO-8859-1';
|
|
}
|
|
}
|
|
return 'ISO-8859-1';
|
|
}
|
|
|
|
|
|
/**
|
|
* get_info
|
|
* This function runs the various steps to gathering the metadata
|
|
*/
|
|
public function get_info() {
|
|
|
|
// If this is broken, don't waste time figuring it out a second
|
|
// time, just return their rotting carcass of a media file.
|
|
if ($this->_broken) {
|
|
$this->tags = $this->set_broken();
|
|
return true;
|
|
}
|
|
|
|
/* Get the Raw file information */
|
|
try {
|
|
$this->_raw = $this->_getID3->analyze($this->filename);
|
|
}
|
|
catch (Exception $error) {
|
|
debug_event('Getid3()',"Unable to catalog file:" . $error->message,'1');
|
|
}
|
|
|
|
/* Figure out what type of file we are dealing with */
|
|
$this->type = $this->_get_type();
|
|
|
|
$enabled_sources = (array)Config::get('metadata_order');
|
|
|
|
if (in_array('filename', $enabled_sources)) {
|
|
$this->tags['filename'] = $this->_parse_filename($this->filename);
|
|
}
|
|
|
|
if (in_array('getID3', $enabled_sources)) {
|
|
$this->tags['getID3'] = $this->_get_tags();
|
|
}
|
|
|
|
$this->_get_plugin_tags();
|
|
|
|
} // get_info
|
|
|
|
/**
|
|
* get_tag_type
|
|
* This takes the result set and the tag_order defined in your config
|
|
* file and tries to figure out which tag type(s) it should use. If your
|
|
* tag_order doesn't match anything then it throws up its hands and uses
|
|
* everything.
|
|
*/
|
|
public static function get_tag_type($results, $config_key = 'metadata_order') {
|
|
|
|
$order = (array)Config::get($config_key);
|
|
|
|
/* Iterate through the defined key order adding them to an
|
|
* ordered array as we go.
|
|
*/
|
|
|
|
foreach($order as $key) {
|
|
if ($results[$key]) {
|
|
$returned_keys[] = $key;
|
|
}
|
|
}
|
|
|
|
/* If we didn't find anything then default to everything.
|
|
*/
|
|
if (!isset($returned_keys)) {
|
|
$returned_keys = array_keys($results);
|
|
$returned_keys = sort($returned_keys);
|
|
}
|
|
|
|
return $returned_keys;
|
|
|
|
} // get_tag_type
|
|
|
|
/**
|
|
* clean_tag_info
|
|
* This function takes the array from vainfo along with the
|
|
* key we've decided on and the filename and returns it in a
|
|
* sanitized format that ampache can actually use
|
|
*/
|
|
public static function clean_tag_info($results, $keys, $filename = null) {
|
|
|
|
$info = array();
|
|
|
|
if ($filename) {
|
|
$info['file'] = $filename;
|
|
}
|
|
|
|
// Iteration!
|
|
foreach ($keys as $key) {
|
|
$tags = $results[$key];
|
|
|
|
$info['file'] = $info['file']
|
|
? $info['file']
|
|
: $tags['file'];
|
|
|
|
|
|
$info['bitrate'] = $info['bitrate']
|
|
? $info['bitrate']
|
|
: intval($tags['bitrate']);
|
|
|
|
$info['rate'] = $info['rate']
|
|
? $info['rate']
|
|
: intval($tags['rate']);
|
|
|
|
$info['mode'] = $info['mode']
|
|
? $info['mode']
|
|
: $tags['mode'];
|
|
|
|
$info['size'] = $info['size']
|
|
? $info['size']
|
|
: $tags['size'];
|
|
|
|
$info['mime'] = $info['mime']
|
|
? $info['mime']
|
|
: $tags['mime'];
|
|
|
|
$info['encoding'] = $info['encoding']
|
|
? $info['encoding']
|
|
: $tags['encoding'];
|
|
|
|
$info['time'] = $info['time']
|
|
? $info['time']
|
|
: intval($tags['time']);
|
|
|
|
$info['channels'] = $info['channels']
|
|
? $info['channels']
|
|
: $tags['channels'];
|
|
|
|
/* These are used to generate the correct IDs later */
|
|
$info['title'] = $info['title']
|
|
? $info['title']
|
|
: stripslashes(trim($tags['title']));
|
|
|
|
$info['year'] = $info['year']
|
|
? $info['year']
|
|
: intval($tags['year']);
|
|
|
|
$info['disk'] = $info['disk']
|
|
? $info['disk']
|
|
: intval($tags['disk']);
|
|
|
|
$info['artist'] = $info['artist']
|
|
? $info['artist']
|
|
: trim($tags['artist']);
|
|
|
|
$info['album'] = $info['album']
|
|
? $info['album']
|
|
: trim($tags['album']);
|
|
|
|
// multiple genre support
|
|
if ((!$info['genre']) && $tags['genre']) {
|
|
if (!is_array($tags['genre'])) {
|
|
// not all tag formats will return an array, but we need one
|
|
$info['genre'][] = trim($tags['genre']);
|
|
}
|
|
else {
|
|
// if we trim the array we lose everything after 1st entry
|
|
foreach ($tags['genre'] as $genre) {
|
|
$info['genre'][] = trim($genre);
|
|
}
|
|
}
|
|
}
|
|
|
|
$info['mb_trackid'] = $info['mb_trackid']
|
|
? $info['mb_trackid']
|
|
: trim($tags['mb_trackid']);
|
|
|
|
$info['mb_albumid'] = $info['mb_albumid']
|
|
? $info['mb_albumid']
|
|
: trim($tags['mb_albumid']);
|
|
|
|
$info['mb_artistid'] = $info['mb_artistid']
|
|
? $info['mb_artistid']
|
|
: trim($tags['mb_artistid']);
|
|
|
|
/* @TODO language doesn't import from id3tag. @momo-i */
|
|
$info['language'] = $info['language']
|
|
? $info['language']
|
|
: Dba::escape($tags['language']);
|
|
|
|
$info['lyrics'] = $info['lyrics']
|
|
? $info['lyrics']
|
|
: str_replace(
|
|
array("\r\n","\r","\n"),
|
|
'<br />',
|
|
strip_tags($tags['lyrics']));
|
|
|
|
$info['track'] = $info['track']
|
|
? $info['track']
|
|
: intval($tags['track']);
|
|
|
|
$info['resolution_x'] = $info['resolution_x']
|
|
? $info['resolution_x']
|
|
: intval($tags['resolution_x']);
|
|
|
|
$info['resolution_y'] = $info['resolution_y']
|
|
? $info['resolution_y']
|
|
: intval($tags['resolution_y']);
|
|
|
|
$info['audio_codec'] = $info['audio_codec']
|
|
? $info['audio_codec']
|
|
: Dba::escape($tags['audio_codec']);
|
|
|
|
$info['video_codec'] = $info['video_codec']
|
|
? $info['video_codec']
|
|
: Dba::escape($tags['video_codec']);
|
|
}
|
|
|
|
// I really think this belongs somewhere else
|
|
$slash_point = strpos($info['disk'], '/');
|
|
if ($slash_point !== false) {
|
|
$info['disk'] = substr($info['disk'], 0, $slash_point);
|
|
}
|
|
|
|
|
|
return $info;
|
|
|
|
} // clean_tag_info
|
|
|
|
/**
|
|
* _get_type
|
|
* This function takes the raw information and figures out
|
|
* what type of file we are dealing with for use by the tag
|
|
* function
|
|
*/
|
|
public function _get_type() {
|
|
|
|
/* There are a few places that the file type can
|
|
* come from, in the end we trust the encoding
|
|
* type
|
|
*/
|
|
if ($type = $this->_raw['video']['dataformat']) {
|
|
// Manually set the tag information
|
|
if ($type == 'flv') {
|
|
$this->_raw['tags']['flv'] = array();
|
|
}
|
|
if ($type == 'quicktime') {
|
|
$this->_raw['tags']['quicktime'] = array();
|
|
}
|
|
if($type == 'mpeg' OR $type == 'mpg') {
|
|
$this->_raw['tags']['mpeg'] = array();
|
|
}
|
|
if($type == 'asf') {
|
|
$this->_raw['tags']['asf'] = array();
|
|
}
|
|
if($type == 'wmv') {
|
|
$this->_raw['tags']['wmv'] = array();
|
|
}
|
|
else {
|
|
$this->_raw['tags']['avi'] = array();
|
|
}
|
|
$type = $this->_clean_type($type);
|
|
return $type;
|
|
}
|
|
if ($type = $this->_raw['audio']['streams']['0']['dataformat']) {
|
|
$type = $this->_clean_type($type);
|
|
return $type;
|
|
}
|
|
if ($type = $this->_raw['audio']['dataformat']) {
|
|
$type = $this->_clean_type($type);
|
|
return $type;
|
|
}
|
|
if ($type = $this->_raw['fileformat']) {
|
|
$type = $this->_clean_type($type);
|
|
return $type;
|
|
}
|
|
|
|
return false;
|
|
|
|
} // _get_type
|
|
|
|
|
|
/**
|
|
* _get_tags
|
|
* This function takes the raw information and the type and
|
|
* attempts to gather the tags and then normalize them into
|
|
* ['tag_name']['var'] = value
|
|
*/
|
|
public function _get_tags() {
|
|
|
|
$results = array();
|
|
|
|
/* The tags can come in many different shapes and colors
|
|
* depending on the encoding time of day and phase of the moon.
|
|
*/
|
|
foreach ($this->_raw['tags'] as $key => $tag_array) {
|
|
switch ($key) {
|
|
case 'vorbiscomment':
|
|
debug_event('_get_tags', 'Parsing vorbis', '5');
|
|
$results[$key] = $this->_parse_vorbiscomment($tag_array);
|
|
break;
|
|
case 'id3v1':
|
|
debug_event('_get_tags', 'Parsing id3v1', '5');
|
|
$results[$key] = $this->_parse_id3v1($tag_array);
|
|
break;
|
|
case 'id3v2':
|
|
debug_event('_get_tags', 'Parsing id3v2', '5');
|
|
$results[$key] = $this->_parse_id3v2($tag_array);
|
|
break;
|
|
case 'ape':
|
|
debug_event('_get_tags', 'Parsing ape', '5');
|
|
$results[$key] = $this->_parse_ape($tag_array);
|
|
break;
|
|
case 'quicktime':
|
|
debug_event('_get_tags', 'Parsing quicktime', '5');
|
|
$results[$key] = $this->_parse_quicktime($tag_array);
|
|
break;
|
|
case 'riff':
|
|
debug_event('_get_tags', 'Parsing riff', '5');
|
|
$results[$key] = $this->_parse_riff($tag_array);
|
|
break;
|
|
case 'flv':
|
|
debug_event('_get_tags', 'Parsing flv', '5');
|
|
$results[$key] = $this->_parse_flv($this->_raw);
|
|
break;
|
|
case 'mpg':
|
|
case 'mpeg':
|
|
debug_event('_get_tags', 'Parsing MPEG', '5');
|
|
$results['mpeg'] = $this->_parse_mpg($this->_raw);
|
|
break;
|
|
case 'asf':
|
|
case 'wmv':
|
|
debug_event('_get_tags', 'Parsing WMV/WMA/ASF', '5');
|
|
$results['asf'] = $this->_parse_wmv($this->_raw);
|
|
break;
|
|
case 'avi':
|
|
debug_event('_get_tags', 'Parsing avi', '5');
|
|
$results[$key] = $this->_parse_avi($this->_raw);
|
|
break;
|
|
case 'lyrics3':
|
|
debug_event('_get_tags', 'Parsing lyrics3', '5');
|
|
$results[$key] = $this->_parse_lyrics($tag_array);
|
|
break;
|
|
default:
|
|
debug_event('vainfo','Error: Unable to determine tag type of ' . $key . ' for file ' . $this->filename . ' Assuming id3v2','5');
|
|
$results[$key] = $this->_parse_id3v2($this->_raw['id3v2']['comments']);
|
|
break;
|
|
} // end switch
|
|
} // end foreach
|
|
|
|
|
|
$cleaned = self::clean_tag_info($results, self::get_tag_type($results, 'getid3_tag_order'), $this->filename);
|
|
$cleaned = array_merge($cleaned, $this->_get_info());
|
|
$cleaned['raw'] = $results;
|
|
|
|
return $cleaned;
|
|
|
|
} // _get_tags
|
|
|
|
/**
|
|
* _get_plugin_tags
|
|
* Get additional metadata from plugins
|
|
*/
|
|
private function _get_plugin_tags() {
|
|
$tag_order = Config::get('metadata_order');
|
|
if (!is_array($tag_order)) {
|
|
$tag_order = array($tag_order);
|
|
}
|
|
|
|
$plugin_names = Plugin::get_plugins('get_metadata');
|
|
foreach ($tag_order as $key => $tag_source) {
|
|
if (in_array($tag_source, $plugin_names)) {
|
|
$plugin = new Plugin($tag_source);
|
|
if ($plugin->load()) {
|
|
$this->tags[$tag_source] = $plugin->_plugin->get_metadata(self::clean_tag_info($this->tags, self::get_tag_type($this->tags), $this->filename));
|
|
}
|
|
}
|
|
}
|
|
} // _get_plugin_tags
|
|
|
|
/**
|
|
* _get_info
|
|
* Gather and return the general information about a song (vbr/cbr,
|
|
* sample rate, channels, etc.)
|
|
*/
|
|
private function _get_info() {
|
|
|
|
$array = array();
|
|
|
|
/* Try to pull the information directly from
|
|
* the audio array
|
|
*/
|
|
if ($this->_raw['audio']['bitrate_mode']) {
|
|
$array['mode'] = $this->_raw['audio']['bitrate_mode'];
|
|
if ($array['mode'] == 'con') {
|
|
$array['mode'] = 'cbr';
|
|
}
|
|
}
|
|
if ($this->_raw['audio']['bitrate']) {
|
|
$array['bitrate'] = $this->_raw['audio']['bitrate'];
|
|
}
|
|
if ($this->_raw['audio']['channels']) {
|
|
$array['channels'] = intval($this->_raw['audio']['channels']);
|
|
}
|
|
if ($this->_raw['audio']['sample_rate']) {
|
|
$array['rate'] = intval($this->_raw['audio']['sample_rate']);
|
|
}
|
|
if ($this->_raw['filesize']) {
|
|
$array['size'] = intval($this->_raw['filesize']);
|
|
}
|
|
if ($this->_raw['encoding']) {
|
|
$array['encoding'] = $this->_raw['encoding'];
|
|
}
|
|
if ($this->_raw['mime_type']) {
|
|
$array['mime'] = $this->_raw['mime_type'];
|
|
}
|
|
if ($this->_raw['playtime_seconds']) {
|
|
$array['time'] = $this->_raw['playtime_seconds'];
|
|
}
|
|
|
|
return $array;
|
|
|
|
} // _get_info
|
|
|
|
/**
|
|
* _clean_type
|
|
* This standardizes the type that we are given into a recognized type.
|
|
*/
|
|
private function _clean_type($type) {
|
|
|
|
switch ($type) {
|
|
case 'mp3':
|
|
case 'mp2':
|
|
case 'mpeg3':
|
|
return 'mp3';
|
|
break;
|
|
case 'vorbis':
|
|
return 'ogg';
|
|
break;
|
|
case 'flac':
|
|
case 'flv':
|
|
case 'mpg':
|
|
case 'mpeg':
|
|
case 'asf':
|
|
case 'wmv':
|
|
case 'avi':
|
|
case 'quicktime':
|
|
return $type;
|
|
default:
|
|
/* Log the fact that we couldn't figure it out */
|
|
debug_event('vainfo','Unable to determine file type from ' . $type . ' on file ' . $this->filename,'5');
|
|
return $type;
|
|
break;
|
|
} // end switch on type
|
|
|
|
} // _clean_type
|
|
|
|
/**
|
|
* _parse_lyrics
|
|
* This function takes a lyrics3 from getid3()
|
|
* nothing to do?
|
|
*/
|
|
private function _parse_lyrics($tags) {
|
|
|
|
/* Results array */
|
|
$array = array();
|
|
|
|
/* go through them all! */
|
|
foreach ($tags as $tag => $data) {
|
|
if ($tag == 'unsynchedlyrics' || $tag == 'unsynchronised lyric') {
|
|
$tag = 'lyrics';
|
|
}
|
|
$array[$tag] = $this->_clean_tag($data['0']);
|
|
|
|
} // end foreach
|
|
|
|
return $array;
|
|
|
|
} // _parse_lyrics
|
|
|
|
/**
|
|
* _parse_vorbiscomment
|
|
* This function takes a vorbiscomment from getid3() and then
|
|
* returns the elements translated using iconv if needed in a
|
|
* pretty little format
|
|
*/
|
|
private function _parse_vorbiscomment($tags) {
|
|
|
|
/* Results array */
|
|
$array = array();
|
|
|
|
/* go through them all! */
|
|
foreach ($tags as $tag=>$data) {
|
|
|
|
/* We need to translate a few of these tags */
|
|
switch ($tag) {
|
|
|
|
case 'genre':
|
|
// multiple genre support
|
|
foreach($data as $foo) {
|
|
$array['genre'][] = $this->_clean_tag($foo,'');
|
|
}
|
|
break;
|
|
case 'tracknumber':
|
|
$array['track'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
case 'discnumber':
|
|
$array['disk'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
case 'date':
|
|
$array['year'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
default:
|
|
$array[$tag] = $this->_clean_tag($data['0']);
|
|
break;
|
|
} // end switch
|
|
|
|
} // end foreach
|
|
|
|
return $array;
|
|
|
|
} // _parse_vorbiscomment
|
|
|
|
/**
|
|
* _parse_id3v1
|
|
* This function takes an id3v1 tag set from getid3() and then
|
|
* returns the elements (translated using iconv if needed) in a
|
|
* pretty little format.
|
|
*/
|
|
private function _parse_id3v1($tags) {
|
|
|
|
$array = array();
|
|
|
|
/* Go through all the tags */
|
|
foreach ($tags as $tag=>$data) {
|
|
|
|
/* This is our baseline for naming
|
|
* so no translation needed
|
|
*/
|
|
$array[$tag] = $this->_clean_tag($data['0']);
|
|
|
|
} // end foreach
|
|
|
|
return $array;
|
|
|
|
} // _parse_id3v1
|
|
|
|
/**
|
|
* _parse_id3v2
|
|
* This function takes an id3v2 tag set from getid3() and then
|
|
* returns the elements (translated using iconv if needed) in a
|
|
* pretty little format.
|
|
*/
|
|
private function _parse_id3v2($tags) {
|
|
|
|
$array = array();
|
|
|
|
/* Go through the tags */
|
|
foreach ($tags as $tag=>$data) {
|
|
|
|
/**
|
|
* the new getid3 handles this differently
|
|
* so we now need to account for it :(
|
|
*/
|
|
switch ($tag) {
|
|
case 'genre':
|
|
// multiple genre support
|
|
foreach($data as $genre) {
|
|
$array['genre'][] = $this->_clean_tag($genre);
|
|
}
|
|
break;
|
|
case 'pos':
|
|
$el = explode('/', $data['0']);
|
|
$array['disk'] = $el[0];
|
|
break;
|
|
case 'track_number':
|
|
$array['track'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
case 'comments':
|
|
$array['comment'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
case 'title':
|
|
$array['title'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
default:
|
|
$array[$tag] = $this->_clean_tag($data['0']);
|
|
break;
|
|
} // end switch on tag
|
|
|
|
} // end foreach
|
|
|
|
$id3v2 = $this->_raw['id3v2'];
|
|
|
|
if(!empty($id3v2['UFID'])) {
|
|
foreach ($id3v2['UFID'] as $ufid) {
|
|
if ($ufid['ownerid'] == 'http://musicbrainz.org') {
|
|
$array['mb_trackid'] = $this->_clean_tag($ufid['data']);
|
|
}
|
|
}
|
|
|
|
for ($i = 0, $size = sizeof($id3v2['comments']['text']) ; $i < $size ; $i++) {
|
|
if ($id3v2['TXXX'][$i]['description'] == 'MusicBrainz Album Id') {
|
|
$array['mb_albumid'] = $this->_clean_tag($id3v2['comments']['text'][$i]);
|
|
}
|
|
elseif ($id3v2['TXXX'][$i]['description'] == 'MusicBrainz Artist Id') {
|
|
$array['mb_artistid'] = $this->_clean_tag($id3v2['comments']['text'][$i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $array;
|
|
|
|
} // _parse_id3v2
|
|
|
|
/**
|
|
* _parse_ape
|
|
* This function takes ape tags set by getid3() and then
|
|
* returns the elements translated using iconv if needed in a
|
|
* pretty little format
|
|
*/
|
|
private function _parse_ape($tags) {
|
|
|
|
foreach ($tags as $tag=>$data) {
|
|
switch ($tag) {
|
|
|
|
case 'genre':
|
|
// multiple genre support
|
|
foreach($data as $genre) {
|
|
$array['genre'][] = $this->_clean_tag($genre);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
$array[$tag] = $this->_clean_tag($data['0'], $this->_file_encoding);
|
|
break;
|
|
} // end switch on tag
|
|
|
|
} // end foreach tags
|
|
|
|
return $array;
|
|
|
|
} // _parse_ape
|
|
|
|
/**
|
|
* _parse_riff
|
|
* this function takes the riff take information passed by getid3() and
|
|
* then reformats it so that it matches the other formats. May require iconv
|
|
*/
|
|
private function _parse_riff($tags) {
|
|
|
|
foreach ($tags as $tag=>$data) {
|
|
|
|
switch ($tag) {
|
|
case 'product':
|
|
$array['album'] = $this->_clean_tag($data['0'], $this->_file_encoding);
|
|
break;
|
|
default:
|
|
$array[$tag] = $this->_clean_tag($data['0'], $this->_file_encoding);
|
|
break;
|
|
} // end switch on tag
|
|
|
|
} // foreach tags
|
|
|
|
return $array;
|
|
|
|
} // _parse_riff
|
|
|
|
/**
|
|
* _parse_quicktime
|
|
* this function takes the quicktime tags set by getid3() and then
|
|
* returns the elements translated using iconv if needed in a
|
|
* pretty little format
|
|
*/
|
|
private function _parse_quicktime($tags) {
|
|
|
|
/* Results array */
|
|
$array = array();
|
|
|
|
/* go through them all! */
|
|
foreach ($tags as $tag=>$data) {
|
|
|
|
/* We need to translate a few of these tags */
|
|
switch ($tag) {
|
|
case 'creation_date':
|
|
if (strlen($data['0']) > 4) {
|
|
/* Weird Date format, attempt to normalize */
|
|
$data['0'] = date("Y",strtotime($data['0']));
|
|
}
|
|
$array['year'] = $this->_clean_tag($data['0']);
|
|
break;
|
|
} // end switch
|
|
|
|
$array[$tag] = $this->_clean_tag($data['0']);
|
|
|
|
} // end foreach
|
|
|
|
// Also add in any video related stuff we might find
|
|
if (strpos($this->_raw['mime_type'], 'video') !== false) {
|
|
$info = $this->_parse_avi($this->_raw);
|
|
$info['video_codec'] = $this->_raw['quicktime']['ftyp']['fourcc'];
|
|
$array = array_merge($info, $array);
|
|
}
|
|
|
|
return $array;
|
|
|
|
} // _parse_quicktime
|
|
|
|
/**
|
|
* _parse_avi
|
|
* This attempts to parse our the information on an avi file and present it in some
|
|
* kind of sane format, this is a little hard as these files don't have tags
|
|
*/
|
|
private function _parse_avi($tags) {
|
|
|
|
$array = array();
|
|
|
|
$array['title'] = urldecode($this->_pathinfo['filename']);
|
|
$array['video_codec'] = $tags['video']['fourcc'];
|
|
$array['audio_codec'] = $tags['audio']['dataformat'];
|
|
$array['resolution_x'] = $tags['video']['resolution_x'];
|
|
$array['resolution_y'] = $tags['video']['resolution_y'];
|
|
$array['mime'] = $tags['mime_type'];
|
|
$array['comment'] = $tags['video']['codec'];
|
|
|
|
return $array;
|
|
|
|
} // _parse_avi
|
|
|
|
/**
|
|
* _parse_mpg
|
|
* This attempts to parse our the information on a mpg file and present it in some
|
|
* kind of sane format, this is a little hard as these files don't have tags
|
|
*/
|
|
private function _parse_mpg($tags) {
|
|
|
|
$array = array();
|
|
|
|
$array['title'] = urldecode($this->_pathinfo['filename']);
|
|
$array['video_codec'] = $tags['video']['codec'];
|
|
$array['audio_codec'] = $tags['audio']['dataformat'];
|
|
$array['resolution_x'] = $tags['video']['resolution_x'];
|
|
$array['resolution_y'] = $tags['video']['resolution_y'];
|
|
$array['mime'] = $tags['mime_type'];
|
|
$array['comment'] = $tags['video']['codec'];
|
|
|
|
return $array;
|
|
|
|
} // _parse_mpg
|
|
|
|
/**
|
|
* _parse_wmv
|
|
* This attempts to parse our the information on a asf/wmv file and present it in some
|
|
* kind of sane format, this is a little hard as these files don't have tags
|
|
*/
|
|
private function _parse_wmv($tags) {
|
|
|
|
$array = array();
|
|
|
|
$array['mime'] = $tags['mime_type'];
|
|
|
|
switch($array['mime']) {
|
|
default:
|
|
case 'video/x-ms-wmv':
|
|
if(isset($tags['tags']['asf']['title']['0'])) {
|
|
$array['title'] = $tags['tags']['asf']['title']['0'];
|
|
}
|
|
else {
|
|
$array['title'] = urldecode($this->_pathinfo['filename']);
|
|
}
|
|
$array['video_codec'] = $tags['video']['streams']['2']['codec'];
|
|
$array['audio_codec'] = $tags['audio']['streams']['1']['codec'];
|
|
$array['resolution_x'] = $tags['video']['streams']['2']['resolution_x'];
|
|
$array['resolution_y'] = $tags['video']['streams']['2']['resolution_y'];
|
|
$array['comment'] = $tags['tags']['asf']['title']['1'];
|
|
break;
|
|
}
|
|
|
|
return $array;
|
|
|
|
} // _parse_wmv
|
|
|
|
/**
|
|
* _parse_flv
|
|
* This attempts to parse our the information on an flv file and present it in some
|
|
* kind of sane format, this is a little hard as these files don't have tags
|
|
*/
|
|
private function _parse_flv($tags) {
|
|
|
|
$array = array();
|
|
|
|
$array['title'] = urldecode($this->_pathinfo['filename']);
|
|
$array['video_codec'] = $tags['video']['codec'];
|
|
$array['audio_codec'] = $tags['audio']['dataformat'];
|
|
$array['resolution_x'] = $tags['video']['resolution_x'];
|
|
$array['resolution_y'] = $tags['video']['resolution_y'];
|
|
$array['mime'] = $tags['mime_type'];
|
|
$array['comment'] = $tags['video']['codec'];
|
|
|
|
return $array;
|
|
|
|
} // _parse_flv
|
|
|
|
/**
|
|
* _parse_filename
|
|
*
|
|
* This function uses the passed file and dir patterns
|
|
* To pull out extra tag information and populate it into
|
|
* its own array
|
|
*
|
|
* @param string $filename Filename that want to parse
|
|
* @return array Parsed results
|
|
*/
|
|
private function _parse_filename($filename) {
|
|
|
|
$results = array();
|
|
|
|
// Correctly detect the slash we need to use here
|
|
if (strpos($filename, '/') !== false) {
|
|
$slash_type = '/';
|
|
}
|
|
else {
|
|
$slash_type = '\\';
|
|
}
|
|
|
|
$pattern = preg_quote($this->_dir_pattern) . $slash_type . preg_quote($this->_file_pattern);
|
|
preg_match_all("/\%\w/",$pattern,$elements);
|
|
|
|
$preg_pattern = preg_quote($pattern);
|
|
$preg_pattern = preg_replace("/\%[Ty]/","([0-9]+?)",$preg_pattern);
|
|
$preg_pattern = preg_replace("/\%\w/","(.+?)",$preg_pattern);
|
|
$preg_pattern = str_replace("/","\/",$preg_pattern);
|
|
$preg_pattern = str_replace(" ","\s",$preg_pattern);
|
|
$preg_pattern = "/" . $preg_pattern . "\..+$/";
|
|
preg_match($preg_pattern,$filename,$matches);
|
|
/* Cut out the Full line, we don't need that */
|
|
array_shift($matches);
|
|
|
|
/* Foreach through what we've found */
|
|
foreach ($matches as $key=>$value) {
|
|
$new_key = translate_pattern_code($elements['0'][$key]);
|
|
if ($new_key) {
|
|
$results[$new_key] = $value;
|
|
}
|
|
} // end foreach matches
|
|
|
|
$results['size'] = filesize($filename);
|
|
|
|
return $results;
|
|
|
|
} // _parse_filename
|
|
|
|
/**
|
|
* _id3v2_tag_to_frame
|
|
*
|
|
* This translates the tag name to a frame, if there a many it returns the first
|
|
* one if finds that exists in the raw
|
|
*
|
|
* @param string $tag_name Tag name
|
|
* @return mixed If found id3v2 frame, return frame. If not found, return false.
|
|
*/
|
|
private function _id3v2_tag_to_frame($tag_name) {
|
|
|
|
static $map = array(
|
|
'comment'=>array('COM','COMM'),
|
|
'cd_ident'=>array('MCDI','MCI'),
|
|
'album'=>array('TAL','TALB'),
|
|
'language'=>array('TLA','TLAN'),
|
|
'mood'=>array('TMOO'),
|
|
'artist'=>array('TPE1'),
|
|
'year'=>array('TDRC'));
|
|
|
|
foreach ($map[$tag_name] as $frame) {
|
|
if (isset($this->_raw['id3v2'][$frame])) {
|
|
return $frame;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
} // _id3v2_tag_to_frame
|
|
|
|
/**
|
|
* _clean_tag
|
|
*
|
|
* This function cleans up the tag that it's passed using Iconv
|
|
* if we've got it. It also takes an optional encoding param
|
|
* for the cases where we know what the tags source encoding
|
|
* is, and or if it's different then the encoding recorded
|
|
* in the file
|
|
*
|
|
* @param string $tag Encoding string
|
|
* @param string $encoding Encode charset
|
|
* @return string Return encoded string
|
|
*/
|
|
private function _clean_tag($tag, $encoding = null) {
|
|
|
|
// Default to getID3's native encoding
|
|
if (!$encoding) {
|
|
$encoding = $this->_getID3->encoding;
|
|
}
|
|
// If we've got iconv then go ahead and clear her up
|
|
if (strcmp($encoding, $this->encoding) == 0) {
|
|
debug_event('vainfo', "\$encoding -> ${encoding}, \$this->encoding -> {$this->encoding}", 5);
|
|
return $tag;
|
|
}
|
|
if ($this->_iconv) {
|
|
debug_event('vainfo', 'Use iconv()',5);
|
|
|
|
// Try GNU iconv //TRANSLIT extension first
|
|
$new_encoding = $this->encoding . '//TRANSLIT';
|
|
$clean = iconv($encoding, $new_encoding, $tag);
|
|
|
|
// If that fails, do a plain conversion
|
|
if(strcmp($clean, '') == 0) {
|
|
$clean = iconv($encoding, $this->encoding, $tag);
|
|
}
|
|
}
|
|
elseif (function_exists('mb_convert_encoding')) {
|
|
debug_event('vainfo', 'Use mbstring',5);
|
|
debug_event('vainfo', "Try to convert from {$this->encoding} to $encoding", 5);
|
|
$clean = mb_convert_encoding($tag, $encoding, $this->encoding);
|
|
}
|
|
else {
|
|
$clean = $tag;
|
|
}
|
|
|
|
return $clean;
|
|
|
|
} // _clean_tag
|
|
|
|
/**
|
|
* set_broken
|
|
*
|
|
* This fills all tag types with Unknown (Broken)
|
|
*
|
|
* @return array Return broken title, album, artist
|
|
*/
|
|
public function set_broken() {
|
|
|
|
/* Pull In the config option */
|
|
$order = Config::get('tag_order');
|
|
|
|
if (!is_array($order)) {
|
|
$order = array($order);
|
|
}
|
|
|
|
$key = array_shift($order);
|
|
|
|
$broken[$key]['title'] = '**BROKEN** ' . $this->filename;
|
|
$broken[$key]['album'] = 'Unknown (Broken)';
|
|
$broken[$key]['artist'] = 'Unknown (Broken)';
|
|
|
|
return $broken;
|
|
|
|
} // set_broken
|
|
|
|
} // end class vainfo
|
|
?>
|