/**
* Converts the source image $sourceMimeData into the destination image
* $destinationMimeData.
*
* @param mixed $sourceMimeData Source image, either a mimedata array or the
* source image path
* @param mixed $destinationMimeData
* Either a mimedata array or the target image path
* @param mixed $aliasName
* Target alias (small, medium, large...)
* @param array $parameters
* Optional parameters. Known ones so far: (basename)
* @return bool
*/
function convert( $sourceMimeData, &$destinationMimeData, $aliasName = false, $parameters = array() )
{
// if the local file doesn't exist, we need to fetch it locally
if ( !file_exists( $sourceMimeData['url'] ) )
{
$sourceFileHandler = eZClusterFileHandler::instance( $sourceMimeData['url'] );
$sourceFileHandler->fetch();
}
if ( is_string( $sourceMimeData ) )
$sourceMimeData = eZMimeType::findByFileContents( $sourceMimeData );
$this->analyzeImage( $sourceMimeData );
$currentMimeData = $sourceMimeData;
$handlers = $this->ImageHandlers;
$supportedMIMEMap = $this->SupportedMIMEMap;
if ( is_string( $destinationMimeData ) )
{
$destinationPath = $destinationMimeData;
$destinationMimeData = eZMimeType::findByFileContents( $destinationPath );
}
$filters = array();
$alias = false;
if ( $aliasName )
{
$aliasList = $this->aliasList();
if ( isset( $aliasList[$aliasName] ) )
{
$alias = $aliasList[$aliasName];
$filters = $alias['filters'];
if ( $alias['mime_type'] )
{
eZMimeType::changeMIMEType( $destinationMimeData, $alias['mime_type'] );
}
}
}
$mimeTypeOverride = $this->mimeTypeOverride( $sourceMimeData );
if ( $mimeTypeOverride )
$alias['override_mime_type'] = $mimeTypeOverride;
if ( isset( $parameters['filters'] ) )
{
$filters = array_merge( $filters, $parameters['filters'] );
}
$wantedFilters = $filters;
$mimeTypeFilters = $this->mimeTypeFilters( $sourceMimeData );
if ( is_array( $mimeTypeFilters ) )
$wantedFilters = array_merge( $wantedFilters, $mimeTypeFilters );
$filters = array();
foreach ( array_keys( $wantedFilters ) as $wantedFilterKey )
{
$wantedFilter = $wantedFilters[$wantedFilterKey];
if ( !$this->isFilterSupported( $wantedFilter['name'] ) )
{
eZDebug::writeWarning( "The filter '" . $wantedFilter['name'] . "' is not supported by any of the image handlers, will ignore this filter", __METHOD__ );
continue;
}
$filters[] = $wantedFilter;
}
if ( !$destinationMimeData['is_valid'] )
{
$destinationDirPath = $destinationMimeData['dirpath'];
$destinationBasename = $destinationMimeData['basename'];
if ( isset( $supportedMIMEMap[$sourceMimeData['name']] ) )
{
$destinationMimeData = $sourceMimeData;
if ( $alias['mime_type'] )
{
eZMimeType::changeMIMEType( $destinationMimeData, $alias['mime_type'] );
}
eZMimeType::changeFileData( $destinationMimeData, $destinationDirPath, $destinationBasename );
}
else
{
$hasDestination = false;
foreach ( $handlers as $handler )
{
$gotMimeData = true;
while( $gotMimeData )
{
$gotMimeData = false;
$outputMimeData = $handler->outputMIMEType( $this, $sourceMimeData, false, $this->SupportedFormats, $aliasName );
if ( $outputMimeData and
isset( $supportedMIMEMap[$outputMimeData['name']] ) )
{
$destinationMimeData = $outputMimeData;
eZMimeType::changeFileData( $destinationMimeData, $destinationDirPath, $destinationBasename );
$hasDestination = true;
$gotMimeData = true;
break;
}
}
}
if ( !$hasDestination )
{
if ( isset( $sourceFileHandler ) )
$sourceFileHandler->deleteLocal();
return false;
}
}
}
$wantedFilters = $filters;
$filters = array();
foreach ( array_keys( $wantedFilters ) as $wantedFilterKey )
{
$wantedFilter = $wantedFilters[$wantedFilterKey];
if ( !$this->isFilterAllowed( $wantedFilter['name'], $destinationMimeData ) )
{
continue;
}
$filters[] = $wantedFilter;
}
$result = true;
$tempFiles = array();
if ( $currentMimeData['name'] != $destinationMimeData['name'] or
count( $filters ) > 0 )
{
while ( $currentMimeData['name'] != $destinationMimeData['name'] or
count( $filters ) > 0 )
{
$nextMimeData = false;
$nextHandler = false;
foreach ( $handlers as $handler )
{
if ( !$handler )
continue;
$handlerFilters = array();
$leftoverFilters = array();
foreach ( $filters as $filter )
{
if ( $handler->isFilterSupported( $filter ) )
$handlerFilters[] = $filter;
else
$leftoverFilters[] = $filter;
}
$outputMimeData = $handler->outputMIMEType( $this, $currentMimeData, $destinationMimeData, $this->SupportedFormats, $aliasName );
if ( $outputMimeData['name'] == $destinationMimeData['name'] and count( $handlerFilters ) > 0 )
{
$nextMimeData = $outputMimeData;
$nextHandler = $handler;
break;
}
if ( $outputMimeData and
!$nextMimeData )
{
$nextMimeData = $outputMimeData;
$nextHandler = $handler;
}
}
if ( !$nextMimeData )
{
eZDebug::writeError( "None of the handlers can convert MIME-Type " . $currentMimeData['name'], __METHOD__ );
if ( isset( $sourceFile ) )
$sourceFile->deleteLocal();
return false;
}
$useTempImage = false;
if ( $nextMimeData['name'] == $destinationMimeData['name'] and
count( $leftoverFilters ) == 0 )
{
$nextMimeData['dirpath'] = $destinationMimeData['dirpath'];
}
else
{
$useTempImage = true;
$nextMimeData['dirpath'] = $this->temporaryImageDirPath();
}
eZMimeType::changeDirectoryPath( $nextMimeData, $nextMimeData['dirpath'] );
if ( $nextMimeData['dirpath'] and
!file_exists( $nextMimeData['dirpath'] ) )
eZDir::mkdir( $nextMimeData['dirpath'], false, true );
if ( $currentMimeData['name'] == $nextMimeData['name'] and
count( $handlerFilters ) == 0 )
{
if ( $currentMimeData['url'] != $nextMimeData['url'] )
{
if ( eZFileHandler::copy( $currentMimeData['url'], $nextMimeData['url'] ) )
{
if ( $useTempImage )
$tempFiles[] = $nextMimeData['url'];
}
else
{
$result = false;
break;
}
}
$currentMimeData = $nextMimeData;
}
else
{
if ( $nextHandler->convert( $this, $currentMimeData, $nextMimeData, $handlerFilters ) )
{
if ( $useTempImage )
$tempFiles[] = $nextMimeData['url'];
}
else
{
$result = false;
break;
}
// store the converted file to cluster if the conversion is between mime name
$fileHandler = eZClusterFileHandler::instance();
$fileHandler->fileStore( $nextMimeData['url'], 'image', false, $nextMimeData['name'] );
$currentMimeData = $nextMimeData;
}
$filters = $leftoverFilters;
}
}
else
{
$useCopy = false;
if ( $aliasName and
$aliasName != 'original' )
{
$destinationMimeData['filename'] = $destinationMimeData['basename'] . '_' . $aliasName . '.' . $destinationMimeData['suffix'];
if ( $destinationMimeData['dirpath'] )
$destinationMimeData['url'] = $destinationMimeData['dirpath'] . '/' . $destinationMimeData['filename'];
else
$destinationMimeData['url'] = $destinationMimeData['filename'];
}
if ( $sourceMimeData['url'] != $destinationMimeData['url'] )
{
if ( $useCopy )
{
eZFileHandler::copy( $sourceMimeData['url'], $destinationMimeData['url'] );
}
else
{
eZFileHandler::linkCopy( $sourceMimeData['url'], $destinationMimeData['url'], false );
}
$currentMimeData = $destinationMimeData;
}
}
foreach ( $tempFiles as $tempFile )
{
if ( !@unlink( $tempFile ) )
{
eZDebug::writeError( "Failed to unlink temporary image file $tempFile", __METHOD__ );
}
}
$destinationMimeData = $currentMimeData;
if ( $aliasName && $aliasName != 'original' )
{
if ( $result )
{
$destinationFilePath = $destinationMimeData['url'];
$fileHandler = eZClusterFileHandler::instance();
$fileHandler->fileStore( $destinationFilePath, 'image', true, $destinationMimeData['name'] );
}
if ( isset( $sourceFileHandler ) )
$sourceFileHandler->deleteLocal();
}
return $result;
}
/**
* Create symbolic or hard link to file.
*
* \public
* \static
*/
function fileLinkCopy($srcPath, $dstPath, $symLink)
{
eZDebugSetting::writeDebug('kernel-clustering', "fs::fileLinkCopy( '{$srcPath}', '{$dstPath}' )", __METHOD__);
eZDebug::accumulatorStart('dbfile', false, 'dbfile');
eZFileHandler::linkCopy($srcPath, $dstPath, $symLink);
eZDebug::accumulatorStop('dbfile');
}
