|
|
|
@ -1,9 +1,23 @@ |
|
|
|
<?php |
|
|
|
/** |
|
|
|
* Copyright (c) 2013 Georg Ehrke <georg@ownCloud.com> |
|
|
|
* This file is licensed under the Affero General Public License version 3 or |
|
|
|
* later. |
|
|
|
* See the COPYING-README file. |
|
|
|
* @author Georg Ehrke <georg@owncloud.com> |
|
|
|
* @author Olivier Paroz <owncloud@interfasys.ch> |
|
|
|
* |
|
|
|
* @copyright Copyright (c) 2015, ownCloud, Inc. |
|
|
|
* @license AGPL-3.0 |
|
|
|
* |
|
|
|
* This code is free software: you can redistribute it and/or modify |
|
|
|
* it under the terms of the GNU Affero General Public License, version 3, |
|
|
|
* 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 Affero General Public License for more details. |
|
|
|
* |
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3, |
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/> |
|
|
|
* |
|
|
|
*/ |
|
|
|
|
|
|
|
namespace Test; |
|
|
|
@ -12,121 +26,99 @@ class Preview extends TestCase { |
|
|
|
|
|
|
|
const TEST_PREVIEW_USER1 = "test-preview-user1"; |
|
|
|
|
|
|
|
/** |
|
|
|
* @var \OC\Files\View |
|
|
|
*/ |
|
|
|
/** @var \OC\Files\View */ |
|
|
|
private $rootView; |
|
|
|
/** |
|
|
|
* Note that using 756 with an image with a ratio of 1.6 brings interesting rounding issues |
|
|
|
* |
|
|
|
* @var int maximum width allowed for a preview |
|
|
|
* */ |
|
|
|
private $configMaxWidth = 756; |
|
|
|
/** @var int maximum height allowed for a preview */ |
|
|
|
private $configMaxHeight = 756; |
|
|
|
private $keepAspect; |
|
|
|
private $scalingUp; |
|
|
|
|
|
|
|
private $samples = []; |
|
|
|
private $sampleFileId; |
|
|
|
private $sampleFilename; |
|
|
|
private $sampleWidth; |
|
|
|
private $sampleHeight; |
|
|
|
private $maxScaleFactor; |
|
|
|
/** @var int width of the max preview */ |
|
|
|
private $maxPreviewWidth; |
|
|
|
/** @var int height of the max preview */ |
|
|
|
private $maxPreviewHeight; |
|
|
|
/** @var int height of the max preview, which is the same as the one of the original image */ |
|
|
|
private $maxPreviewRatio; |
|
|
|
private $cachedBigger = []; |
|
|
|
|
|
|
|
/** @var \OC\Files\Storage\Storage */ |
|
|
|
private $originalStorage; |
|
|
|
|
|
|
|
/** |
|
|
|
* Make sure your configuration file doesn't contain any additional providers |
|
|
|
*/ |
|
|
|
protected function setUp() { |
|
|
|
parent::setUp(); |
|
|
|
|
|
|
|
// FIXME: use proper tearDown with $this->loginAsUser() and $this->logout()
|
|
|
|
// (would currently break the tests for some reason)
|
|
|
|
$this->originalStorage = \OC\Files\Filesystem::getStorage('/'); |
|
|
|
|
|
|
|
// create a new user with his own filesystem view
|
|
|
|
// this gets called by each test in this test class
|
|
|
|
$userManager = \OC::$server->getUserManager(); |
|
|
|
$userManager->clearBackends(); |
|
|
|
$backend = new \OC_User_Dummy(); |
|
|
|
\OC_User::useBackend($backend); |
|
|
|
$userManager->registerBackend($backend); |
|
|
|
$backend->createUser(self::TEST_PREVIEW_USER1, self::TEST_PREVIEW_USER1); |
|
|
|
$user = \OC::$server->getUserManager()->get(self::TEST_PREVIEW_USER1); |
|
|
|
\OC::$server->getUserSession()->setUser($user); |
|
|
|
\OC\Files\Filesystem::init(self::TEST_PREVIEW_USER1, '/' . self::TEST_PREVIEW_USER1 . '/files'); |
|
|
|
$this->loginAsUser(self::TEST_PREVIEW_USER1); |
|
|
|
|
|
|
|
\OC\Files\Filesystem::mount('OC\Files\Storage\Temporary', array(), '/'); |
|
|
|
$storage = new \OC\Files\Storage\Temporary([]); |
|
|
|
\OC\Files\Filesystem::mount($storage, [], '/' . self::TEST_PREVIEW_USER1 . '/'); |
|
|
|
|
|
|
|
$this->rootView = new \OC\Files\View(''); |
|
|
|
$this->rootView->mkdir('/'.self::TEST_PREVIEW_USER1); |
|
|
|
$this->rootView->mkdir('/'.self::TEST_PREVIEW_USER1.'/files'); |
|
|
|
$this->rootView->mkdir('/' . self::TEST_PREVIEW_USER1); |
|
|
|
$this->rootView->mkdir('/' . self::TEST_PREVIEW_USER1 . '/files'); |
|
|
|
|
|
|
|
// We simulate the max dimension set in the config
|
|
|
|
\OC::$server->getConfig() |
|
|
|
->setSystemValue('preview_max_x', $this->configMaxWidth); |
|
|
|
\OC::$server->getConfig() |
|
|
|
->setSystemValue('preview_max_y', $this->configMaxHeight); |
|
|
|
// Used to test upscaling
|
|
|
|
$this->maxScaleFactor = 2; |
|
|
|
\OC::$server->getConfig() |
|
|
|
->setSystemValue('preview_max_scale_factor', $this->maxScaleFactor); |
|
|
|
|
|
|
|
// We need to enable the providers we're going to use in the tests
|
|
|
|
$providers = [ |
|
|
|
'OC\\Preview\\JPEG', |
|
|
|
'OC\\Preview\\PNG', |
|
|
|
'OC\\Preview\\GIF', |
|
|
|
'OC\\Preview\\TXT', |
|
|
|
'OC\\Preview\\Postscript' |
|
|
|
]; |
|
|
|
\OC::$server->getConfig() |
|
|
|
->setSystemValue('enabledPreviewProviders', $providers); |
|
|
|
|
|
|
|
// Sample is 1680x1050 JPEG
|
|
|
|
$this->prepareSample('testimage.jpg', 1680, 1050); |
|
|
|
// Sample is 2400x1707 EPS
|
|
|
|
$this->prepareSample('testimage.eps', 2400, 1707); |
|
|
|
// Sample is 1200x450 PNG
|
|
|
|
$this->prepareSample('testimage-wide.png', 1200, 450); |
|
|
|
// Sample is 64x64 GIF
|
|
|
|
$this->prepareSample('testimage.gif', 64, 64); |
|
|
|
} |
|
|
|
|
|
|
|
protected function tearDown() { |
|
|
|
\OC\Files\Filesystem::clearMounts(); |
|
|
|
\OC\Files\Filesystem::mount($this->originalStorage, array(), '/'); |
|
|
|
$this->logout(); |
|
|
|
|
|
|
|
parent::tearDown(); |
|
|
|
} |
|
|
|
|
|
|
|
public function testIsMaxSizeWorking() { |
|
|
|
// Max size from config
|
|
|
|
$maxX = 1024; |
|
|
|
$maxY = 1024; |
|
|
|
|
|
|
|
\OC::$server->getConfig()->setSystemValue('preview_max_x', $maxX); |
|
|
|
\OC::$server->getConfig()->setSystemValue('preview_max_y', $maxY); |
|
|
|
|
|
|
|
// Sample is 1680x1050 JPEG
|
|
|
|
$sampleFile = '/' . self::TEST_PREVIEW_USER1 . '/files/testimage.jpg'; |
|
|
|
$this->rootView->file_put_contents($sampleFile, file_get_contents(\OC::$SERVERROOT.'/tests/data/testimage.jpg')); |
|
|
|
$fileInfo = $this->rootView->getFileInfo($sampleFile); |
|
|
|
$fileId = $fileInfo['fileid']; |
|
|
|
|
|
|
|
$largeX = 1920; |
|
|
|
$largeY = 1080; |
|
|
|
$preview = new \OC\Preview(self::TEST_PREVIEW_USER1, 'files/', 'testimage.jpg', $largeX, $largeY); |
|
|
|
|
|
|
|
$this->assertEquals($preview->isFileValid(), true); |
|
|
|
|
|
|
|
// There should be no cached copy
|
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
|
|
|
|
$this->assertNotEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $maxX . '-' . $maxY . '-max.png', $isCached); |
|
|
|
$this->assertNotEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $maxX . '-' . $maxY . '.png', $isCached); |
|
|
|
$this->assertNotEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $largeX . '-' . $largeY . '.png', $isCached); |
|
|
|
|
|
|
|
// The returned preview should be of max size
|
|
|
|
$image = $preview->getPreview(); |
|
|
|
|
|
|
|
$this->assertEquals($image->width(), $maxX); |
|
|
|
$this->assertEquals($image->height(), $maxY); |
|
|
|
|
|
|
|
// The max thumbnail should be created
|
|
|
|
$maxThumbCacheFile = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $maxX . '-' . $maxY . '-max.png'; |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($maxThumbCacheFile), true); |
|
|
|
|
|
|
|
// A preview of the asked size should not have been created
|
|
|
|
$thumbCacheFile = \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $largeX . '-' . $largeY . '.png'; |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), false); |
|
|
|
|
|
|
|
// 2nd request should indicate that we have a cached copy of max dimension
|
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
$this->assertEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $maxX . '-' . $maxY . '.png', $isCached); |
|
|
|
|
|
|
|
// Smaller previews should be based on the cached max preview
|
|
|
|
$smallX = 50; |
|
|
|
$smallY = 50; |
|
|
|
$preview = new \OC\Preview(self::TEST_PREVIEW_USER1, 'files/', 'testimage.jpg', $smallX, $smallY); |
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
|
|
|
|
$this->assertEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $maxX . '-' . $maxY . '.png', $isCached); |
|
|
|
|
|
|
|
// A small preview should be created
|
|
|
|
$image = $preview->getPreview(); |
|
|
|
$this->assertEquals($image->width(), $smallX); |
|
|
|
$this->assertEquals($image->height(), $smallY); |
|
|
|
|
|
|
|
// The cache should contain the small preview
|
|
|
|
$thumbCacheFile = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $smallX . '-' . $smallY . '.png'; |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), true); |
|
|
|
|
|
|
|
// 2nd request should indicate that we have a cached copy of the exact dimension
|
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
|
|
|
|
$this->assertEquals(\OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $smallX . '-' . $smallY . '.png', $isCached); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Tests if a preview can be deleted |
|
|
|
*/ |
|
|
|
public function testIsPreviewDeleted() { |
|
|
|
|
|
|
|
$sampleFile = '/'.self::TEST_PREVIEW_USER1.'/files/test.txt'; |
|
|
|
$sampleFile = '/' . self::TEST_PREVIEW_USER1 . '/files/test.txt'; |
|
|
|
|
|
|
|
$this->rootView->file_put_contents($sampleFile, 'dummy file data'); |
|
|
|
|
|
|
|
|
|
|
|
$x = 50; |
|
|
|
$y = 50; |
|
|
|
|
|
|
|
@ -134,23 +126,30 @@ class Preview extends TestCase { |
|
|
|
$preview->getPreview(); |
|
|
|
|
|
|
|
$fileInfo = $this->rootView->getFileInfo($sampleFile); |
|
|
|
/** @var int $fileId */ |
|
|
|
$fileId = $fileInfo['fileid']; |
|
|
|
$thumbCacheFile = $this->buildCachePath($fileId, $x, $y, true); |
|
|
|
|
|
|
|
$thumbCacheFile = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $x . '-' . $y . '.png'; |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), true); |
|
|
|
$this->assertSame( |
|
|
|
true, $this->rootView->file_exists($thumbCacheFile), "$thumbCacheFile \n" |
|
|
|
); |
|
|
|
|
|
|
|
$preview->deletePreview(); |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), false); |
|
|
|
$this->assertSame(false, $this->rootView->file_exists($thumbCacheFile)); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Tests if all previews can be deleted |
|
|
|
* |
|
|
|
* We test this first to make sure we'll be able to cleanup after each preview generating test |
|
|
|
*/ |
|
|
|
public function testAreAllPreviewsDeleted() { |
|
|
|
|
|
|
|
$sampleFile = '/'.self::TEST_PREVIEW_USER1.'/files/test.txt'; |
|
|
|
$sampleFile = '/' . self::TEST_PREVIEW_USER1 . '/files/test.txt'; |
|
|
|
|
|
|
|
$this->rootView->file_put_contents($sampleFile, 'dummy file data'); |
|
|
|
|
|
|
|
|
|
|
|
$x = 50; |
|
|
|
$y = 50; |
|
|
|
|
|
|
|
@ -158,104 +157,697 @@ class Preview extends TestCase { |
|
|
|
$preview->getPreview(); |
|
|
|
|
|
|
|
$fileInfo = $this->rootView->getFileInfo($sampleFile); |
|
|
|
/** @var int $fileId */ |
|
|
|
$fileId = $fileInfo['fileid']; |
|
|
|
|
|
|
|
$thumbCacheFolder = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/'; |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->is_dir($thumbCacheFolder), true); |
|
|
|
|
|
|
|
$thumbCacheFolder = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . |
|
|
|
'/' . $fileId . '/'; |
|
|
|
|
|
|
|
$this->assertSame(true, $this->rootView->is_dir($thumbCacheFolder), "$thumbCacheFolder \n"); |
|
|
|
|
|
|
|
$preview->deleteAllPreviews(); |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->is_dir($thumbCacheFolder), false); |
|
|
|
$this->assertSame(false, $this->rootView->is_dir($thumbCacheFolder)); |
|
|
|
} |
|
|
|
|
|
|
|
public function txtBlacklist() { |
|
|
|
$txt = 'random text file'; |
|
|
|
|
|
|
|
return array( |
|
|
|
array('txt', $txt, false), |
|
|
|
); |
|
|
|
return [ |
|
|
|
['txt', $txt, false], |
|
|
|
]; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* @dataProvider txtBlacklist |
|
|
|
* |
|
|
|
* @param $extension |
|
|
|
* @param $data |
|
|
|
* @param $expectedResult |
|
|
|
*/ |
|
|
|
public function testIsTransparent($extension, $data, $expectedResult) { |
|
|
|
|
|
|
|
$x = 32; |
|
|
|
$y = 32; |
|
|
|
|
|
|
|
$sample = '/'.self::TEST_PREVIEW_USER1.'/files/test.'.$extension; |
|
|
|
$sample = '/' . self::TEST_PREVIEW_USER1 . '/files/test.' . $extension; |
|
|
|
$this->rootView->file_put_contents($sample, $data); |
|
|
|
$preview = new \OC\Preview(self::TEST_PREVIEW_USER1, 'files/', 'test.'.$extension, $x, $y); |
|
|
|
$preview = new \OC\Preview( |
|
|
|
self::TEST_PREVIEW_USER1, 'files/', 'test.' . $extension, $x, |
|
|
|
$y |
|
|
|
); |
|
|
|
$image = $preview->getPreview(); |
|
|
|
$resource = $image->resource(); |
|
|
|
|
|
|
|
//http://stackoverflow.com/questions/5702953/imagecolorat-and-transparency
|
|
|
|
$colorIndex = imagecolorat($resource, 1, 1); |
|
|
|
$colorInfo = imagecolorsforindex($resource, $colorIndex); |
|
|
|
$this->assertEquals( |
|
|
|
$this->assertSame( |
|
|
|
$expectedResult, |
|
|
|
$colorInfo['alpha'] === 127, |
|
|
|
'Failed asserting that only previews for text files are transparent.' |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
public function testCreationFromCached() { |
|
|
|
/** |
|
|
|
* We generate the data to use as it makes it easier to adjust in case we need to test |
|
|
|
* something different |
|
|
|
* |
|
|
|
* @return array |
|
|
|
*/ |
|
|
|
public static function dimensionsDataProvider() { |
|
|
|
$data = []; |
|
|
|
$samples = [ |
|
|
|
[200, 800], |
|
|
|
[200, 800], |
|
|
|
[50, 400], |
|
|
|
[4, 60], |
|
|
|
]; |
|
|
|
$keepAspect = false; |
|
|
|
$scalingUp = false; |
|
|
|
|
|
|
|
for ($a = 0; $a < sizeof($samples); $a++) { |
|
|
|
for ($b = 0; $b < 2; $b++) { |
|
|
|
for ($c = 0; $c < 2; $c++) { |
|
|
|
for ($d = 0; $d < 4; $d++) { |
|
|
|
$coordinates = [ |
|
|
|
[ |
|
|
|
-rand($samples[$a][0], $samples[$a][1]), |
|
|
|
-rand($samples[$a][0], $samples[$a][1]) |
|
|
|
], |
|
|
|
[ |
|
|
|
rand($samples[$a][0], $samples[$a][1]), |
|
|
|
rand($samples[$a][0], $samples[$a][1]) |
|
|
|
], |
|
|
|
[ |
|
|
|
-rand($samples[$a][0], $samples[$a][1]), |
|
|
|
rand($samples[$a][0], $samples[$a][1]) |
|
|
|
], |
|
|
|
[ |
|
|
|
rand($samples[$a][0], $samples[$a][1]), |
|
|
|
-rand($samples[$a][0], $samples[$a][1]) |
|
|
|
] |
|
|
|
]; |
|
|
|
$row = [$a]; |
|
|
|
$row[] = $coordinates[$d][0]; |
|
|
|
$row[] = $coordinates[$d][1]; |
|
|
|
$row[] = $keepAspect; |
|
|
|
$row[] = $scalingUp; |
|
|
|
$data[] = $row; |
|
|
|
} |
|
|
|
$scalingUp = !$scalingUp; |
|
|
|
} |
|
|
|
$keepAspect = !$keepAspect; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return $data; |
|
|
|
} |
|
|
|
|
|
|
|
$sampleFile = '/'.self::TEST_PREVIEW_USER1.'/files/test.txt'; |
|
|
|
/** |
|
|
|
* Tests if a preview of max dimensions gets created |
|
|
|
* |
|
|
|
* @dataProvider dimensionsDataProvider |
|
|
|
* |
|
|
|
* @param int $sampleId |
|
|
|
* @param int $widthAdjustment |
|
|
|
* @param int $heightAdjustment |
|
|
|
* @param bool $keepAspect |
|
|
|
* @param bool $scalingUp |
|
|
|
*/ |
|
|
|
public function testCreateMaxAndNormalPreviewsAtFirstRequest( |
|
|
|
$sampleId, $widthAdjustment, $heightAdjustment, $keepAspect = false, $scalingUp = false |
|
|
|
) { |
|
|
|
//$this->markTestSkipped('Not testing this at this time');
|
|
|
|
|
|
|
|
// Get the right sample for the experiment
|
|
|
|
$this->getSample($sampleId); |
|
|
|
$sampleWidth = $this->sampleWidth; |
|
|
|
$sampleHeight = $this->sampleHeight; |
|
|
|
$sampleFileId = $this->sampleFileId; |
|
|
|
|
|
|
|
// Adjust the requested size so that we trigger various test cases
|
|
|
|
$previewWidth = $sampleWidth + $widthAdjustment; |
|
|
|
$previewHeight = $sampleHeight + $heightAdjustment; |
|
|
|
$this->keepAspect = $keepAspect; |
|
|
|
$this->scalingUp = $scalingUp; |
|
|
|
|
|
|
|
// Generates the max preview
|
|
|
|
$preview = $this->createPreview($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
// There should be no cached thumbnails
|
|
|
|
$thumbnailFolder = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . |
|
|
|
'/' . $sampleFileId; |
|
|
|
$this->assertSame(false, $this->rootView->is_dir($thumbnailFolder)); |
|
|
|
|
|
|
|
$this->rootView->file_put_contents($sampleFile, 'dummy file data'); |
|
|
|
$image = $preview->getPreview(); |
|
|
|
$this->assertNotSame(false, $image); |
|
|
|
|
|
|
|
// create base preview
|
|
|
|
$x = 150; |
|
|
|
$y = 150; |
|
|
|
$maxThumbCacheFile = $this->buildCachePath( |
|
|
|
$sampleFileId, $this->maxPreviewWidth, $this->maxPreviewHeight, true, '-max' |
|
|
|
); |
|
|
|
|
|
|
|
$preview = new \OC\Preview(self::TEST_PREVIEW_USER1, 'files/', 'test.txt', $x, $y); |
|
|
|
$preview->getPreview(); |
|
|
|
$this->assertSame( |
|
|
|
true, $this->rootView->file_exists($maxThumbCacheFile), "$maxThumbCacheFile \n" |
|
|
|
); |
|
|
|
|
|
|
|
$fileInfo = $this->rootView->getFileInfo($sampleFile); |
|
|
|
$fileId = $fileInfo['fileid']; |
|
|
|
// We check the dimensions of the file we've just stored
|
|
|
|
$maxPreview = imagecreatefromstring($this->rootView->file_get_contents($maxThumbCacheFile)); |
|
|
|
|
|
|
|
$thumbCacheFile = '/' . self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $x . '-' . $y . '.png'; |
|
|
|
$this->assertEquals($this->maxPreviewWidth, imagesx($maxPreview)); |
|
|
|
$this->assertEquals($this->maxPreviewHeight, imagesy($maxPreview)); |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), true); |
|
|
|
// A thumbnail of the asked dimensions should also have been created (within the constraints of the max preview)
|
|
|
|
list($limitedPreviewWidth, $limitedPreviewHeight) = |
|
|
|
$this->simulatePreviewDimensions($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
$actualWidth = $image->width(); |
|
|
|
$actualHeight = $image->height(); |
|
|
|
|
|
|
|
// create smaller previews
|
|
|
|
$preview = new \OC\Preview(self::TEST_PREVIEW_USER1, 'files/', 'test.txt', 50, 50); |
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
$this->assertEquals( |
|
|
|
(int)$limitedPreviewWidth, $image->width(), "$actualWidth x $actualHeight \n" |
|
|
|
); |
|
|
|
$this->assertEquals((int)$limitedPreviewHeight, $image->height()); |
|
|
|
|
|
|
|
// And it should be cached
|
|
|
|
$this->checkCache($sampleFileId, $limitedPreviewWidth, $limitedPreviewHeight); |
|
|
|
|
|
|
|
$this->assertEquals(self::TEST_PREVIEW_USER1 . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/150-150.png', $isCached); |
|
|
|
$preview->deleteAllPreviews(); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Tests if the second preview will be based off the cached max preview |
|
|
|
* |
|
|
|
* @dataProvider dimensionsDataProvider |
|
|
|
* |
|
|
|
* @param int $sampleId |
|
|
|
* @param int $widthAdjustment |
|
|
|
* @param int $heightAdjustment |
|
|
|
* @param bool $keepAspect |
|
|
|
* @param bool $scalingUp |
|
|
|
*/ |
|
|
|
public function testSecondPreviewsGetCachedMax( |
|
|
|
$sampleId, $widthAdjustment, $heightAdjustment, $keepAspect = false, $scalingUp = false |
|
|
|
) { |
|
|
|
//$this->markTestSkipped('Not testing this at this time');
|
|
|
|
|
|
|
|
$this->getSample($sampleId); |
|
|
|
$sampleWidth = $this->sampleWidth; |
|
|
|
$sampleHeight = $this->sampleHeight; |
|
|
|
$sampleFileId = $this->sampleFileId; |
|
|
|
|
|
|
|
//Creates the Max preview which will be used in the rest of the test
|
|
|
|
$this->createMaxPreview(); |
|
|
|
|
|
|
|
// Adjust the requested size so that we trigger various test cases
|
|
|
|
$previewWidth = $sampleWidth + $widthAdjustment; |
|
|
|
$previewHeight = $sampleHeight + $heightAdjustment; |
|
|
|
$this->keepAspect = $keepAspect; |
|
|
|
$this->scalingUp = $scalingUp; |
|
|
|
|
|
|
|
$preview = $this->createPreview($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
// A cache query should return the thumbnail of max dimension
|
|
|
|
$isCached = $preview->isCached($sampleFileId); |
|
|
|
$cachedMaxPreview = $this->buildCachePath( |
|
|
|
$sampleFileId, $this->maxPreviewWidth, $this->maxPreviewHeight, false, '-max' |
|
|
|
); |
|
|
|
$this->assertSame($cachedMaxPreview, $isCached); |
|
|
|
} |
|
|
|
|
|
|
|
/* |
|
|
|
public function testScalingUp() { |
|
|
|
/** |
|
|
|
* Make sure that the max preview can never be deleted |
|
|
|
* |
|
|
|
* For this test to work, the preview we generate first has to be the size of max preview |
|
|
|
*/ |
|
|
|
public function testMaxPreviewCannotBeDeleted() { |
|
|
|
//$this->markTestSkipped('Not testing this at this time');
|
|
|
|
|
|
|
|
$sampleFile = '/'.$this->user.'/files/test.txt'; |
|
|
|
$this->keepAspect = true; |
|
|
|
$this->getSample(0); |
|
|
|
$fileId = $this->sampleFileId; |
|
|
|
|
|
|
|
$this->rootView->file_put_contents($sampleFile, 'dummy file data'); |
|
|
|
//Creates the Max preview which we will try to delete
|
|
|
|
$preview = $this->createMaxPreview(); |
|
|
|
|
|
|
|
// create base preview
|
|
|
|
$x = 150; |
|
|
|
$y = 150; |
|
|
|
// We try to deleted the preview
|
|
|
|
$preview->deletePreview(); |
|
|
|
$this->assertNotSame(false, $preview->isCached($fileId)); |
|
|
|
|
|
|
|
$preview = new \OC\Preview($this->user, 'files/', 'test.txt', $x, $y); |
|
|
|
$preview->deleteAllPreviews(); |
|
|
|
} |
|
|
|
|
|
|
|
public static function aspectDataProvider() { |
|
|
|
$data = []; |
|
|
|
$samples = 4; |
|
|
|
$keepAspect = false; |
|
|
|
$scalingUp = false; |
|
|
|
for ($a = 0; $a < $samples; $a++) { |
|
|
|
for ($b = 0; $b < 2; $b++) { |
|
|
|
for ($c = 0; $c < 2; $c++) { |
|
|
|
$row = [$a]; |
|
|
|
$row[] = $keepAspect; |
|
|
|
$row[] = $scalingUp; |
|
|
|
$data[] = $row; |
|
|
|
$scalingUp = !$scalingUp; |
|
|
|
} |
|
|
|
$keepAspect = !$keepAspect; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return $data; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* We ask for a preview larger than what is set in the configuration, |
|
|
|
* so we should be getting either the max preview or a preview the size |
|
|
|
* of the dimensions set in the config |
|
|
|
* |
|
|
|
* @dataProvider aspectDataProvider |
|
|
|
* |
|
|
|
* @param int $sampleId |
|
|
|
* @param bool $keepAspect |
|
|
|
* @param bool $scalingUp |
|
|
|
*/ |
|
|
|
public function testDoNotCreatePreviewsLargerThanConfigMax( |
|
|
|
$sampleId, $keepAspect = false, $scalingUp = false |
|
|
|
) { |
|
|
|
//$this->markTestSkipped('Not testing this at this time');
|
|
|
|
|
|
|
|
$this->getSample($sampleId); |
|
|
|
|
|
|
|
//Creates the Max preview which will be used in the rest of the test
|
|
|
|
$this->createMaxPreview(); |
|
|
|
|
|
|
|
// Now we will create the real preview
|
|
|
|
$previewWidth = 4000; |
|
|
|
$previewHeight = 4000; |
|
|
|
$this->keepAspect = $keepAspect; |
|
|
|
$this->scalingUp = $scalingUp; |
|
|
|
|
|
|
|
// Tries to create the very large preview
|
|
|
|
$preview = $this->createPreview($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
$image = $preview->getPreview(); |
|
|
|
$this->assertNotSame(false, $image); |
|
|
|
|
|
|
|
list($expectedWidth, $expectedHeight) = |
|
|
|
$this->simulatePreviewDimensions($previewWidth, $previewHeight); |
|
|
|
$this->assertEquals($expectedWidth, $image->width()); |
|
|
|
$this->assertEquals($expectedHeight, $image->height()); |
|
|
|
|
|
|
|
// A preview of the asked size should not have been created since it's larger that our max dimensions
|
|
|
|
$postfix = $this->getThumbnailPostfix($previewWidth, $previewHeight); |
|
|
|
$thumbCacheFile = $this->buildCachePath( |
|
|
|
$this->sampleFileId, $previewWidth, $previewHeight, false, $postfix |
|
|
|
); |
|
|
|
$this->assertSame( |
|
|
|
false, $this->rootView->file_exists($thumbCacheFile), "$thumbCacheFile \n" |
|
|
|
); |
|
|
|
|
|
|
|
$preview->deleteAllPreviews(); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Makes sure we're getting the proper cached thumbnail |
|
|
|
* |
|
|
|
* When we start by generating a preview which keeps the aspect ratio |
|
|
|
* 200-125-with-aspect |
|
|
|
* 300-300 ✓ |
|
|
|
* |
|
|
|
* When we start by generating a preview of exact dimensions |
|
|
|
* 200-200 ✓ |
|
|
|
* 300-188-with-aspect |
|
|
|
* |
|
|
|
* @dataProvider aspectDataProvider |
|
|
|
* |
|
|
|
* @param int $sampleId |
|
|
|
* @param bool $keepAspect |
|
|
|
* @param bool $scalingUp |
|
|
|
*/ |
|
|
|
public function testIsBiggerWithAspectRatioCached( |
|
|
|
$sampleId, $keepAspect = false, $scalingUp = false |
|
|
|
) { |
|
|
|
//$this->markTestSkipped('Not testing this at this time');
|
|
|
|
|
|
|
|
$previewWidth = 400; |
|
|
|
$previewHeight = 400; |
|
|
|
$this->getSample($sampleId); |
|
|
|
$fileId = $this->sampleFileId; |
|
|
|
$this->keepAspect = $keepAspect; |
|
|
|
$this->scalingUp = $scalingUp; |
|
|
|
|
|
|
|
// Caching the max preview in our preview array for the test
|
|
|
|
$this->cachedBigger[] = $this->buildCachePath( |
|
|
|
$fileId, $this->maxPreviewWidth, $this->maxPreviewHeight, false, '-max' |
|
|
|
); |
|
|
|
|
|
|
|
$this->getSmallerThanMaxPreview($fileId, $previewWidth, $previewHeight); |
|
|
|
// We switch the aspect ratio, to generate a thumbnail we should not be picked up
|
|
|
|
$this->keepAspect = !$keepAspect; |
|
|
|
$this->getSmallerThanMaxPreview($fileId, $previewWidth + 100, $previewHeight + 100); |
|
|
|
|
|
|
|
// Small thumbnails are always cropped
|
|
|
|
$this->keepAspect = false; |
|
|
|
// Smaller previews should be based on the previous, larger preview, with the correct aspect ratio
|
|
|
|
$this->createThumbnailFromBiggerCachedPreview($fileId, 36, 36); |
|
|
|
|
|
|
|
// 2nd cache query should indicate that we have a cached copy of the exact dimension
|
|
|
|
$this->getCachedSmallThumbnail($fileId, 36, 36); |
|
|
|
|
|
|
|
// We create a preview in order to be able to delete the cache
|
|
|
|
$preview = $this->createPreview(rand(), rand()); |
|
|
|
$preview->deleteAllPreviews(); |
|
|
|
$this->cachedBigger = []; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Initialises the preview |
|
|
|
* |
|
|
|
* @param int $width |
|
|
|
* @param int $height |
|
|
|
* |
|
|
|
* @return \OC\Preview |
|
|
|
*/ |
|
|
|
private function createPreview($width, $height) { |
|
|
|
$preview = new \OC\Preview( |
|
|
|
self::TEST_PREVIEW_USER1, 'files/', $this->sampleFilename, $width, |
|
|
|
$height |
|
|
|
); |
|
|
|
|
|
|
|
$this->assertSame(true, $preview->isFileValid()); |
|
|
|
|
|
|
|
$preview->setKeepAspect($this->keepAspect); |
|
|
|
$preview->setScalingup($this->scalingUp); |
|
|
|
|
|
|
|
return $preview; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Creates the Max preview which will be used in the rest of the test |
|
|
|
* |
|
|
|
* @return \OC\Preview |
|
|
|
*/ |
|
|
|
private function createMaxPreview() { |
|
|
|
$this->keepAspect = true; |
|
|
|
$preview = $this->createPreview($this->maxPreviewWidth, $this->maxPreviewHeight); |
|
|
|
$preview->getPreview(); |
|
|
|
|
|
|
|
$fileInfo = $this->rootView->getFileInfo($sampleFile); |
|
|
|
$fileId = $fileInfo['fileid']; |
|
|
|
return $preview; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Makes sure the preview which was just created has been saved to disk |
|
|
|
* |
|
|
|
* @param int $fileId |
|
|
|
* @param int $previewWidth |
|
|
|
* @param int $previewHeight |
|
|
|
*/ |
|
|
|
private function checkCache($fileId, $previewWidth, $previewHeight) { |
|
|
|
$postfix = $this->getThumbnailPostfix($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
$thumbCacheFile = $this->buildCachePath( |
|
|
|
$fileId, $previewWidth, $previewHeight, true, $postfix |
|
|
|
); |
|
|
|
|
|
|
|
$this->assertSame( |
|
|
|
true, $this->rootView->file_exists($thumbCacheFile), "$thumbCacheFile \n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Computes special filename postfixes |
|
|
|
* |
|
|
|
* @param int $width |
|
|
|
* @param int $height |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
private function getThumbnailPostfix($width, $height) { |
|
|
|
// Need to take care of special postfix added to the dimensions
|
|
|
|
$postfix = ''; |
|
|
|
$isMaxPreview = ($width === $this->maxPreviewWidth |
|
|
|
&& $height === $this->maxPreviewHeight) ? true : false; |
|
|
|
if ($isMaxPreview) { |
|
|
|
$postfix = '-max'; |
|
|
|
} |
|
|
|
if ($this->keepAspect && !$isMaxPreview) { |
|
|
|
$postfix = '-with-aspect'; |
|
|
|
} |
|
|
|
|
|
|
|
return $postfix; |
|
|
|
} |
|
|
|
|
|
|
|
private function getSmallerThanMaxPreview($fileId, $previewWidth, $previewHeight) { |
|
|
|
$preview = $this->createPreview($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
$image = $preview->getPreview(); |
|
|
|
$this->assertNotSame(false, $image); |
|
|
|
|
|
|
|
$thumbCacheFile = '/' . $this->user . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/' . $x . '-' . $y . '.png'; |
|
|
|
// A thumbnail of the asked dimensions should also have been created (within the constraints of the max preview)
|
|
|
|
list($limitedPreviewWidth, $limitedPreviewHeight) = |
|
|
|
$this->simulatePreviewDimensions($previewWidth, $previewHeight); |
|
|
|
|
|
|
|
$this->assertEquals($this->rootView->file_exists($thumbCacheFile), true); |
|
|
|
$this->assertEquals($limitedPreviewWidth, $image->width()); |
|
|
|
$this->assertEquals($limitedPreviewHeight, $image->height()); |
|
|
|
|
|
|
|
// And it should be cached
|
|
|
|
$this->checkCache($fileId, $limitedPreviewWidth, $limitedPreviewHeight); |
|
|
|
|
|
|
|
// create bigger previews - with scale up
|
|
|
|
$preview = new \OC\Preview($this->user, 'files/', 'test.txt', 250, 250); |
|
|
|
$this->cachedBigger[] = $preview->isCached($fileId); |
|
|
|
} |
|
|
|
|
|
|
|
private function createThumbnailFromBiggerCachedPreview($fileId, $width, $height) { |
|
|
|
$preview = $this->createPreview($width, $height); |
|
|
|
|
|
|
|
// A cache query should return a thumbnail of slightly larger dimensions
|
|
|
|
// and with the proper aspect ratio
|
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
$expectedCachedBigger = $this->getExpectedCachedBigger(); |
|
|
|
|
|
|
|
$this->assertSame($expectedCachedBigger, $isCached); |
|
|
|
|
|
|
|
$image = $preview->getPreview(); |
|
|
|
$this->assertNotSame(false, $image); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Picks the bigger cached preview with the correct aspect ratio or the max preview if it's |
|
|
|
* smaller than that |
|
|
|
* |
|
|
|
* For non-upscaled images, we pick the only picture without aspect ratio |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
private function getExpectedCachedBigger() { |
|
|
|
$foundPreview = null; |
|
|
|
$foundWidth = null; |
|
|
|
$foundHeight = null; |
|
|
|
$maxPreview = null; |
|
|
|
$maxWidth = null; |
|
|
|
$maxHeight = null; |
|
|
|
|
|
|
|
foreach ($this->cachedBigger as $cached) { |
|
|
|
$size = explode('-', basename($cached)); |
|
|
|
$width = (int)$size[0]; |
|
|
|
$height = (int)$size[1]; |
|
|
|
|
|
|
|
if (strpos($cached, 'max')) { |
|
|
|
$maxWidth = $width; |
|
|
|
$maxHeight = $height; |
|
|
|
$maxPreview = $cached; |
|
|
|
continue; |
|
|
|
} |
|
|
|
|
|
|
|
// We pick the larger preview with no aspect ratio
|
|
|
|
if (!strpos($cached, 'aspect') && !strpos($cached, 'max')) { |
|
|
|
$foundPreview = $cached; |
|
|
|
$foundWidth = $width; |
|
|
|
$foundHeight = $height; |
|
|
|
} |
|
|
|
} |
|
|
|
if ($foundWidth > $maxWidth && $foundHeight > $maxHeight) { |
|
|
|
$foundPreview = $maxPreview; |
|
|
|
} |
|
|
|
|
|
|
|
return $foundPreview; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* A small thumbnail of exact dimensions should be in the cache |
|
|
|
* |
|
|
|
* @param int $fileId |
|
|
|
* @param int $width |
|
|
|
* @param int $height |
|
|
|
*/ |
|
|
|
private function getCachedSmallThumbnail($fileId, $width, $height) { |
|
|
|
$preview = $this->createPreview($width, $height); |
|
|
|
|
|
|
|
$isCached = $preview->isCached($fileId); |
|
|
|
$thumbCacheFile = $this->buildCachePath($fileId, $width, $height); |
|
|
|
|
|
|
|
$this->assertSame($thumbCacheFile, $isCached, "$thumbCacheFile \n"); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Builds the complete path to a cached thumbnail starting from the user folder |
|
|
|
* |
|
|
|
* @param int $fileId |
|
|
|
* @param int $width |
|
|
|
* @param int $height |
|
|
|
* @param bool $user |
|
|
|
* @param string $postfix |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
private function buildCachePath($fileId, $width, $height, $user = false, $postfix = '') { |
|
|
|
$userPath = ''; |
|
|
|
if ($user) { |
|
|
|
$userPath = '/' . self::TEST_PREVIEW_USER1 . '/'; |
|
|
|
} |
|
|
|
|
|
|
|
return $userPath . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId |
|
|
|
. '/' . $width . '-' . $height . $postfix . '.png'; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Stores the sample in the filesystem and stores it in the $samples array |
|
|
|
* |
|
|
|
* @param string $fileName |
|
|
|
* @param int $sampleWidth |
|
|
|
* @param int $sampleHeight |
|
|
|
*/ |
|
|
|
private function prepareSample($fileName, $sampleWidth, $sampleHeight) { |
|
|
|
$imgData = file_get_contents(\OC::$SERVERROOT . '/tests/data/' . $fileName); |
|
|
|
$imgPath = '/' . self::TEST_PREVIEW_USER1 . '/files/' . $fileName; |
|
|
|
$this->rootView->file_put_contents($imgPath, $imgData); |
|
|
|
$fileInfo = $this->rootView->getFileInfo($imgPath); |
|
|
|
|
|
|
|
list($maxPreviewWidth, $maxPreviewHeight) = |
|
|
|
$this->setMaxPreview($sampleWidth, $sampleHeight); |
|
|
|
|
|
|
|
$this->samples[] = |
|
|
|
[ |
|
|
|
'sampleFileId' => $fileInfo['fileid'], |
|
|
|
'sampleFileName' => $fileName, |
|
|
|
'sampleWidth' => $sampleWidth, |
|
|
|
'sampleHeight' => $sampleHeight, |
|
|
|
'maxPreviewWidth' => $maxPreviewWidth, |
|
|
|
'maxPreviewHeight' => $maxPreviewHeight |
|
|
|
]; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Sets the variables used to define the boundaries which need to be respected when using a |
|
|
|
* specific sample |
|
|
|
* |
|
|
|
* @param $sampleId |
|
|
|
*/ |
|
|
|
private function getSample($sampleId) { |
|
|
|
// Corrects a rounding difference when using the EPS (Imagick converted) sample
|
|
|
|
$filename = $this->samples[$sampleId]['sampleFileName']; |
|
|
|
$splitFileName = pathinfo($filename); |
|
|
|
$extension = $splitFileName['extension']; |
|
|
|
$correction = ($extension === 'eps') ? 1 : 0; |
|
|
|
$maxPreviewHeight = $this->samples[$sampleId]['maxPreviewHeight']; |
|
|
|
$maxPreviewHeight = $maxPreviewHeight - $correction; |
|
|
|
|
|
|
|
$this->sampleFileId = $this->samples[$sampleId]['sampleFileId']; |
|
|
|
$this->sampleFilename = $this->samples[$sampleId]['sampleFileName']; |
|
|
|
$this->sampleWidth = $this->samples[$sampleId]['sampleWidth']; |
|
|
|
$this->sampleHeight = $this->samples[$sampleId]['sampleHeight']; |
|
|
|
$this->maxPreviewWidth = $this->samples[$sampleId]['maxPreviewWidth']; |
|
|
|
$this->maxPreviewHeight = $maxPreviewHeight; |
|
|
|
$ratio = $this->maxPreviewWidth / $this->maxPreviewHeight; |
|
|
|
$this->maxPreviewRatio = $ratio; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Defines the size of the max preview |
|
|
|
* |
|
|
|
* @fixme the Imagick previews don't have the exact same size on disk as they're calculated here |
|
|
|
* |
|
|
|
* @param int $sampleWidth |
|
|
|
* @param int $sampleHeight |
|
|
|
* |
|
|
|
* @return array |
|
|
|
*/ |
|
|
|
private function setMaxPreview($sampleWidth, $sampleHeight) { |
|
|
|
// Max previews are never scaled up
|
|
|
|
$this->scalingUp = false; |
|
|
|
// Max previews always keep the aspect ratio
|
|
|
|
$this->keepAspect = true; |
|
|
|
// We set this variable in order to be able to calculate the max preview with the proper aspect ratio
|
|
|
|
$this->maxPreviewRatio = $sampleWidth / $sampleHeight; |
|
|
|
$maxPreviewWidth = min($sampleWidth, $this->configMaxWidth); |
|
|
|
$maxPreviewHeight = min($sampleHeight, $this->configMaxHeight); |
|
|
|
list($maxPreviewWidth, $maxPreviewHeight) = |
|
|
|
$this->applyAspectRatio($maxPreviewWidth, $maxPreviewHeight); |
|
|
|
|
|
|
|
return [$maxPreviewWidth, $maxPreviewHeight]; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Calculates the expected dimensions of the preview to be able to assess if we've got the |
|
|
|
* right result |
|
|
|
* |
|
|
|
* @param int $askedWidth |
|
|
|
* @param int $askedHeight |
|
|
|
* |
|
|
|
* @return array |
|
|
|
*/ |
|
|
|
private function simulatePreviewDimensions($askedWidth, $askedHeight) { |
|
|
|
$askedWidth = min($askedWidth, $this->configMaxWidth); |
|
|
|
$askedHeight = min($askedHeight, $this->configMaxHeight); |
|
|
|
|
|
|
|
if ($this->keepAspect) { |
|
|
|
// Defines the box in which the preview has to fit
|
|
|
|
$scaleFactor = $this->scalingUp ? $this->maxScaleFactor : 1; |
|
|
|
$newPreviewWidth = min($askedWidth, $this->maxPreviewWidth * $scaleFactor); |
|
|
|
$newPreviewHeight = min($askedHeight, $this->maxPreviewHeight * $scaleFactor); |
|
|
|
list($newPreviewWidth, $newPreviewHeight) = |
|
|
|
$this->applyAspectRatio($newPreviewWidth, $newPreviewHeight); |
|
|
|
} else { |
|
|
|
list($newPreviewWidth, $newPreviewHeight) = |
|
|
|
$this->fixSize($askedWidth, $askedHeight); |
|
|
|
} |
|
|
|
|
|
|
|
return [(int)$newPreviewWidth, (int)$newPreviewHeight]; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Resizes the boundaries to match the aspect ratio |
|
|
|
* |
|
|
|
* @param int $askedWidth |
|
|
|
* @param int $askedHeight |
|
|
|
* |
|
|
|
* @return \int[] |
|
|
|
*/ |
|
|
|
private function applyAspectRatio($askedWidth, $askedHeight) { |
|
|
|
$originalRatio = $this->maxPreviewRatio; |
|
|
|
if ($askedWidth / $originalRatio < $askedHeight) { |
|
|
|
$askedHeight = round($askedWidth / $originalRatio); |
|
|
|
} else { |
|
|
|
$askedWidth = round($askedHeight * $originalRatio); |
|
|
|
} |
|
|
|
|
|
|
|
return [(int)$askedWidth, (int)$askedHeight]; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Clips or stretches the dimensions so that they fit in the boundaries |
|
|
|
* |
|
|
|
* @param int $askedWidth |
|
|
|
* @param int $askedHeight |
|
|
|
* |
|
|
|
* @return array |
|
|
|
*/ |
|
|
|
private function fixSize($askedWidth, $askedHeight) { |
|
|
|
if ($this->scalingUp) { |
|
|
|
$askedWidth = min($this->configMaxWidth, $askedWidth); |
|
|
|
$askedHeight = min($this->configMaxHeight, $askedHeight); |
|
|
|
} |
|
|
|
|
|
|
|
$this->assertEquals($this->user . '/' . \OC\Preview::THUMBNAILS_FOLDER . '/' . $fileId . '/150-150.png', $isCached); |
|
|
|
return [(int)$askedWidth, (int)$askedHeight]; |
|
|
|
} |
|
|
|
*/ |
|
|
|
} |
Thomas Müller
11 years ago
