2020-03-29 19:33:16 +01:00
< ? php
2021-11-14 23:20:59 +00:00
declare ( strict_types = 1 );
2020-03-29 20:56:35 +01:00
// {{{ License
2021-04-15 23:28:28 +01:00
2020-05-20 17:53:53 +01:00
// This file is part of GNU social - https://www.gnu.org/software/social
2020-03-29 20:56:35 +01:00
//
// GNU social is free software: you can redistribute it and/or modify
2020-05-10 21:43:15 +01:00
// it under the terms of the GNU Affero General Public License as published by
2020-03-29 20:56:35 +01:00
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU social 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.
//
2020-05-10 21:43:15 +01:00
// You should have received a copy of the GNU Affero General Public License
2020-03-29 20:56:35 +01:00
// along with GNU social. If not, see <http://www.gnu.org/licenses/>.
2021-04-15 23:28:28 +01:00
2020-03-29 20:56:35 +01:00
// }}}
2020-03-29 19:33:16 +01:00
2021-12-02 15:12:31 +00:00
namespace Component\Attachment\Entity ;
2020-03-29 19:33:16 +01:00
2021-04-16 17:11:34 +01:00
use App\Core\Cache ;
2021-04-16 11:46:53 +01:00
use App\Core\DB\DB ;
2020-08-15 07:18:23 +01:00
use App\Core\Entity ;
2021-04-16 11:46:53 +01:00
use App\Core\Event ;
2021-04-18 02:17:57 +01:00
use App\Core\GSFile ;
2021-04-16 11:46:53 +01:00
use App\Core\Log ;
2021-08-18 17:30:54 +01:00
use App\Core\Router\Router ;
2021-04-16 16:57:25 +01:00
use App\Util\Common ;
2021-07-22 20:56:29 +01:00
use App\Util\Exception\ClientException ;
2021-04-16 11:46:53 +01:00
use App\Util\Exception\NotFoundException ;
2021-08-18 17:30:54 +01:00
use App\Util\Exception\NotStoredLocallyException ;
2021-04-16 11:46:53 +01:00
use App\Util\Exception\ServerException ;
2021-09-06 23:47:28 +01:00
use App\Util\TemporaryFile ;
2020-05-10 21:43:15 +01:00
use DateTimeInterface ;
2021-07-22 20:56:29 +01:00
use Symfony\Component\Mime\MimeTypes ;
2020-05-10 21:43:15 +01:00
2020-03-29 19:33:16 +01:00
/**
2021-04-15 23:28:28 +01:00
* Entity for Attachment thumbnails
2020-03-29 19:33:16 +01:00
*
* @ category DB
* @ package GNUsocial
*
* @ author Zach Copley < zach @ status . net >
* @ copyright 2010 StatusNet Inc .
* @ author Mikael Nordfeldth < mmn @ hethane . se >
* @ copyright 2009 - 2014 Free Software Foundation , Inc http :// www . fsf . org
2021-02-19 23:29:43 +00:00
* @ author Hugo Sales < hugo @ hsal . es >
2021-07-20 21:17:53 +01:00
* @ author Diogo Peralta Cordeiro < mail @ diogo . site >
2021-09-22 15:08:30 +01:00
* @ author Eliseu Amaro < mail @ eliseuama . ro >
2021-02-19 23:29:43 +00:00
* @ copyright 2020 - 2021 Free Software Foundation , Inc http :// www . fsf . org
2020-03-29 19:33:16 +01:00
* @ license https :// www . gnu . org / licenses / agpl . html GNU AGPL v3 or later
*/
2021-04-16 20:27:33 +01:00
class AttachmentThumbnail extends Entity
2020-03-29 19:33:16 +01:00
{
2021-09-22 15:08:30 +01:00
public const SIZE_SMALL = 0 ;
public const SIZE_MEDIUM = 1 ;
public const SIZE_BIG = 2 ;
2021-11-14 23:20:59 +00:00
public const SIZE_MAP = [
'small' => self :: SIZE_SMALL ,
'medium' => self :: SIZE_MEDIUM ,
'big' => self :: SIZE_BIG ,
];
2020-03-30 15:00:13 +01:00
// {{{ Autocode
2021-05-05 17:03:03 +01:00
// @codeCoverageIgnoreStart
2021-04-15 23:28:28 +01:00
private int $attachment_id ;
2021-12-26 21:32:09 +00:00
private ? string $mimetype = null ;
private int $size = 0 ;
2021-05-01 22:48:44 +01:00
private string $filename ;
2021-09-25 13:12:32 +01:00
private int $width ;
private int $height ;
2021-11-14 23:20:59 +00:00
private DateTimeInterface $modified ;
2020-03-30 16:13:51 +01:00
2021-04-15 23:28:28 +01:00
public function setAttachmentId ( int $attachment_id ) : self
2020-03-30 16:13:51 +01:00
{
2021-04-15 23:28:28 +01:00
$this -> attachment_id = $attachment_id ;
2020-03-30 16:13:51 +01:00
return $this ;
}
2020-08-08 17:11:18 +01:00
2021-04-15 23:28:28 +01:00
public function getAttachmentId () : int
2020-03-30 16:13:51 +01:00
{
2021-04-15 23:28:28 +01:00
return $this -> attachment_id ;
2020-03-30 16:13:51 +01:00
}
2021-07-22 20:56:29 +01:00
public function setMimetype ( ? string $mimetype ) : self
{
2021-12-26 21:32:09 +00:00
$this -> mimetype = \is_null ( $mimetype ) ? null : mb_substr ( $mimetype , 0 , 129 );
2021-07-22 20:56:29 +01:00
return $this ;
}
public function getMimetype () : ? string
{
return $this -> mimetype ;
}
2021-09-22 15:08:30 +01:00
public function setSize ( int $size ) : self
2020-03-30 16:13:51 +01:00
{
2021-09-22 15:08:30 +01:00
$this -> size = $size ;
return $this ;
2020-03-30 16:13:51 +01:00
}
2021-12-26 15:12:06 +00:00
public function getSize () : int
{
return $this -> size ;
}
2021-05-01 22:48:44 +01:00
public function setFilename ( string $filename ) : self
{
2021-12-26 15:12:06 +00:00
$this -> filename = mb_substr ( $filename , 0 , 191 );
2021-05-01 22:48:44 +01:00
return $this ;
}
public function getFilename () : string
{
return $this -> filename ;
}
2021-12-26 15:12:06 +00:00
public function setWidth ( int $width ) : self
2020-03-30 16:13:51 +01:00
{
2021-12-26 15:12:06 +00:00
$this -> width = $width ;
2020-03-30 16:13:51 +01:00
return $this ;
}
2020-08-08 17:11:18 +01:00
2021-09-25 13:12:32 +01:00
public function getWidth () : int
{
return $this -> width ;
}
2021-12-26 15:12:06 +00:00
public function setHeight ( int $height ) : self
2021-09-25 13:12:32 +01:00
{
2021-12-26 15:12:06 +00:00
$this -> height = $height ;
2021-09-25 13:12:32 +01:00
return $this ;
}
public function getHeight () : int
{
return $this -> height ;
}
2021-12-26 15:12:06 +00:00
public function setModified ( DateTimeInterface $modified ) : self
2021-09-25 13:12:32 +01:00
{
2021-12-26 15:12:06 +00:00
$this -> modified = $modified ;
2021-09-25 13:12:32 +01:00
return $this ;
}
2021-12-26 15:12:06 +00:00
public function getModified () : DateTimeInterface
{
return $this -> modified ;
}
2021-05-05 17:03:03 +01:00
// @codeCoverageIgnoreEnd
2020-03-30 15:00:13 +01:00
// }}} Autocode
2020-03-29 19:33:16 +01:00
2021-11-14 23:20:59 +00:00
public static function sizeIntToStr ( ? int $size ) : string
{
$map = array_flip ( self :: SIZE_MAP );
return $map [ $size ] ? ? $map [ self :: SIZE_SMALL ];
}
public static function sizeStrToInt ( string $size )
{
2021-11-25 23:08:30 +00:00
return self :: SIZE_MAP [ $size ] ? ? self :: SIZE_SMALL ;
2021-11-14 23:20:59 +00:00
}
2021-08-18 17:30:54 +01:00
private ? Attachment $attachment = null ;
2021-04-16 16:57:25 +01:00
2021-08-18 17:30:54 +01:00
public function setAttachment ( ? Attachment $attachment )
2021-04-16 16:57:25 +01:00
{
$this -> attachment = $attachment ;
}
public function getAttachment ()
{
2021-11-14 23:20:59 +00:00
if ( isset ( $this -> attachment ) && ! \is_null ( $this -> attachment )) {
2021-04-16 16:57:25 +01:00
return $this -> attachment ;
} else {
return $this -> attachment = DB :: findOneBy ( 'attachment' , [ 'id' => $this -> attachment_id ]);
}
}
2021-11-14 23:20:59 +00:00
public static function getCacheKey ( int $id , int $size )
{
return " thumb- { $id } - { $size } " ;
}
2021-07-20 21:17:53 +01:00
/**
2021-11-14 23:20:59 +00:00
* @ param ? string $size 'small' | 'medium' | 'big'
2021-07-20 21:17:53 +01:00
*
2021-08-18 22:10:19 +01:00
* @ throws ClientException
* @ throws NotFoundException
2021-07-20 21:17:53 +01:00
* @ throws ServerException
*
2021-09-27 19:47:25 +01:00
* @ return ? self
2021-07-20 21:17:53 +01:00
*/
2021-09-23 16:19:34 +01:00
public static function getOrCreate ( Attachment $attachment , ? string $size = null , bool $crop = false ) : ? self
2021-04-16 11:46:53 +01:00
{
2021-11-14 23:20:59 +00:00
$size ? ? = Common :: config ( 'thumbnail' , 'default_size' );
$size_int = self :: sizeStrToInt ( $size );
2021-04-16 11:46:53 +01:00
try {
2021-11-14 23:20:59 +00:00
return Cache :: get (
self :: getCacheKey ( $attachment -> getId (), $size_int ),
fn () => DB :: findOneBy ( 'attachment_thumbnail' , [ 'attachment_id' => $attachment -> getId (), 'size' => $size_int ]),
);
2021-09-22 15:08:30 +01:00
} catch ( NotFoundException ) {
2021-11-14 23:20:59 +00:00
if ( \is_null ( $attachment -> getWidth ()) || \is_null ( $attachment -> getHeight ())) {
2021-09-22 15:08:30 +01:00
return null ;
2021-08-14 15:07:17 +01:00
}
2021-09-22 15:08:30 +01:00
[ $predicted_width , $predicted_height ] = self :: predictScalingValues ( $attachment -> getWidth (), $attachment -> getHeight (), $size , $crop );
2021-11-15 17:09:14 +00:00
if ( \is_null ( $attachment -> getPath ()) || ! file_exists ( $attachment -> getPath ())) {
2021-09-23 16:19:34 +01:00
// Before we quit, check if there's any other thumb
$alternative_thumbs = DB :: findBy ( 'attachment_thumbnail' , [ 'attachment_id' => $attachment -> getId ()]);
2021-11-14 23:20:59 +00:00
usort ( $alternative_thumbs , fn ( $l , $r ) => $r -> getSize () <=> $l -> getSize ());
if ( empty ( $alternative_thumbs )) {
2021-09-23 16:19:34 +01:00
throw new NotStoredLocallyException ();
} else {
return $alternative_thumbs [ 0 ];
}
2021-08-14 15:07:17 +01:00
}
2021-08-18 22:10:19 +01:00
$thumbnail = self :: create ([ 'attachment_id' => $attachment -> getId ()]);
$mimetype = $attachment -> getMimetype ();
$event_map [ $mimetype ] = [];
$major_mime = GSFile :: mimetypeMajor ( $mimetype );
$event_map [ $major_mime ] = [];
Event :: handle ( 'FileResizerAvailable' , [ & $event_map , $mimetype ]);
// Always prefer specific encoders
2021-09-06 23:47:28 +01:00
/** @var callable[] function(string $source, ?TemporaryFile &$destination, int &$width, int &$height, bool $smart_crop, ?string &$mimetype): bool */
2021-08-18 22:10:19 +01:00
$encoders = array_merge ( $event_map [ $mimetype ], $event_map [ $major_mime ]);
foreach ( $encoders as $encoder ) {
2021-09-06 23:47:28 +01:00
/** @var ?TemporaryFile */
2021-07-22 20:56:29 +01:00
$temp = null ; // Let the EncoderPlugin create a temporary file for us
2021-09-22 15:08:30 +01:00
if ( $encoder ( $attachment -> getPath (), $temp , $predicted_width , $predicted_height , $crop , $mimetype )) {
2021-08-18 17:30:54 +01:00
$thumbnail -> setAttachment ( $attachment );
2021-09-22 15:08:30 +01:00
$thumbnail -> setSize ( $size_int );
2021-09-06 23:47:28 +01:00
$mimetype = $temp -> getMimeType ();
$ext = '.' . MimeTypes :: getDefault () -> getExtensions ( $mimetype )[ 0 ];
2021-08-14 16:47:45 +01:00
$filename = " { $predicted_width } x { $predicted_height } { $ext } - " . $attachment -> getFilehash ();
2021-07-22 20:56:29 +01:00
$thumbnail -> setFilename ( $filename );
2021-07-22 21:17:23 +01:00
$thumbnail -> setMimetype ( $mimetype );
2021-09-25 13:12:32 +01:00
$thumbnail -> setWidth ( $predicted_width );
$thumbnail -> setHeight ( $predicted_height );
2021-07-22 20:56:29 +01:00
DB :: persist ( $thumbnail );
DB :: flush ();
$temp -> move ( Common :: config ( 'thumbnail' , 'dir' ), $filename );
return $thumbnail ;
}
2021-04-16 11:46:53 +01:00
}
2021-09-22 15:08:30 +01:00
return null ;
2021-04-16 11:46:53 +01:00
}
}
2021-04-16 16:57:25 +01:00
public function getPath ()
{
2021-11-14 23:20:59 +00:00
return Common :: config ( 'thumbnail' , 'dir' ) . \DIRECTORY_SEPARATOR . $this -> getFilename ();
2021-04-16 16:57:25 +01:00
}
2021-04-25 22:26:53 +01:00
public function getUrl ()
{
2021-11-14 23:20:59 +00:00
return Router :: url ( 'attachment_thumbnail' , [ 'id' => $this -> getAttachmentId (), 'size' => self :: sizeIntToStr ( $this -> getSize ())]);
2021-04-25 22:26:53 +01:00
}
2020-08-07 03:03:55 +01:00
/**
2021-04-29 19:12:32 +01:00
* Delete an attachment thumbnail
2020-08-07 03:03:55 +01:00
*/
2021-04-29 19:12:32 +01:00
public function delete ( bool $flush = true ) : void
2020-08-07 03:03:55 +01:00
{
2021-04-29 19:12:32 +01:00
$filepath = $this -> getPath ();
if ( file_exists ( $filepath )) {
if ( @ unlink ( $filepath ) === false ) {
2021-08-18 17:30:54 +01:00
// @codeCoverageIgnoreStart
2021-09-22 15:08:30 +01:00
Log :: warning ( " Failed deleting file for attachment thumbnail with id= { $this -> getAttachmentId () } , size= { $this -> getSize () } at { $filepath } " );
2021-08-18 17:30:54 +01:00
// @codeCoverageIgnoreEnd
2021-04-29 19:12:32 +01:00
}
}
2021-11-14 23:20:59 +00:00
Cache :: delete ( self :: getCacheKey ( $this -> getAttachmentId (), $this -> getSize ()));
2021-04-29 19:12:32 +01:00
DB :: remove ( $this );
if ( $flush ) {
DB :: flush ();
}
2020-08-07 03:03:55 +01:00
}
2021-05-01 22:48:44 +01:00
/**
* Gets scaling values for images of various types . Cropping can be enabled .
*
* Values will scale _up_ to fit max values if cropping is enabled !
* With cropping disabled , the max value of each axis will be respected .
*
2021-11-14 23:20:59 +00:00
* @ param int $existing_width Original width
* @ param int $existing_height Original height
2021-05-01 22:48:44 +01:00
*
* @ return array [ predicted width , predicted height ]
*/
public static function predictScalingValues (
2021-08-18 17:30:54 +01:00
int $existing_width ,
int $existing_height ,
2021-09-22 15:08:30 +01:00
string $requested_size ,
2021-11-14 23:20:59 +00:00
bool $crop ,
2021-05-02 16:02:26 +01:00
) : array {
2021-09-22 15:08:30 +01:00
/**
* 1 : 1 => Square
* 4 : 3 => SD
* 11 : 8 => Academy Ratio
* 3 : 2 => Classic 35 mm
* 16 : 10 => Golden Ratio
* 16 : 9 => Widescreen
* 2.2 : 1 => Standard 70 mm film
*/
$allowed_aspect_ratios = [ 1 , 1.3 , 1.376 , 1.5 , 1.6 , 1.7 , 2.2 ]; // Ascending array
$sizes = [
'small' => Common :: config ( 'thumbnail' , 'small' ),
'medium' => Common :: config ( 'thumbnail' , 'medium' ),
'big' => Common :: config ( 'thumbnail' , 'big' ),
];
// We only scale if the image is larger than the minimum width and height for a thumbnail
if ( $existing_width < Common :: config ( 'thumbnail' , 'minimum_width' ) && $existing_height < Common :: config ( 'thumbnail' , 'minimum_height' )) {
return [ $existing_width , $existing_height ];
}
// We only scale if the total of pixels is greater than the maximum allowed for a thumbnail
$total_of_pixels = $existing_width * $existing_height ;
if ( $total_of_pixels < Common :: config ( 'thumbnail' , 'maximum_pixels' )) {
return [ $existing_width , $existing_height ];
}
// Is this a portrait image?
$flip = $existing_height > $existing_width ;
// Find the aspect ratio of the given image
$existing_aspect_ratio = ! $flip ? $existing_width / $existing_height : $existing_height / $existing_width ;
// Binary search the closer allowed aspect ratio
$left = 0 ;
2021-11-14 23:20:59 +00:00
$right = \count ( $allowed_aspect_ratios ) - 1 ;
2021-09-22 15:08:30 +01:00
while ( $left < $right ) {
$mid = floor ( $left + ( $right - $left ) / 2 );
// Comparing absolute distances with middle value and right value
if ( abs ( $existing_aspect_ratio - $allowed_aspect_ratios [ $mid ]) < abs ( $existing_aspect_ratio - $allowed_aspect_ratios [ $right ])) {
// search the left side of the array
$right = $mid ;
2021-08-18 17:30:54 +01:00
} else {
2021-09-22 15:08:30 +01:00
// search the right side of the array
$left = $mid + 1 ;
2021-05-01 22:48:44 +01:00
}
}
2021-09-22 15:08:30 +01:00
$closest_aspect_ratio = $allowed_aspect_ratios [ $left ];
unset ( $mid , $left , $right );
// TODO: For crop, we should test a threshold and understand if the image would better be cropped
// Resulting width and height
$rw = ( int ) ( $sizes [ $requested_size ]);
$rh = ( int ) ( $rw / $closest_aspect_ratio );
2021-08-18 17:30:54 +01:00
2021-09-22 15:08:30 +01:00
return ! $flip ? [ $rw , $rh ] : [ $rh , $rw ];
2021-05-01 22:48:44 +01:00
}
2020-03-29 19:33:16 +01:00
public static function schemaDef () : array
{
return [
2021-05-02 16:02:26 +01:00
'name' => 'attachment_thumbnail' ,
2020-03-29 19:33:16 +01:00
'fields' => [
2021-04-15 23:28:28 +01:00
'attachment_id' => [ 'type' => 'int' , 'foreign key' => true , 'target' => 'Attachment.id' , 'multiplicity' => 'one to one' , 'not null' => true , 'description' => 'thumbnail for what attachment' ],
2021-08-18 22:10:19 +01:00
'mimetype' => [ 'type' => 'varchar' , 'length' => 129 , 'description' => 'resource mime type 64+1+64, images hardly will show up with long mimetypes, this is probably safe considering rfc6838#section-4.2' ],
2021-09-22 15:08:30 +01:00
'size' => [ 'type' => 'int' , 'not null' => true , 'default' => 0 , 'description' => '0 = small; 1 = medium; 2 = big' ],
2021-07-22 21:17:23 +01:00
'filename' => [ 'type' => 'varchar' , 'length' => 191 , 'not null' => true , 'description' => 'thumbnail filename' ],
2021-09-25 13:12:32 +01:00
'width' => [ 'type' => 'int' , 'not null' => true , 'description' => 'width in pixels, if it can be described as such and data is available' ],
'height' => [ 'type' => 'int' , 'not null' => true , 'description' => 'height in pixels, if it can be described as such and data is available' ],
2021-07-22 21:17:23 +01:00
'modified' => [ 'type' => 'timestamp' , 'not null' => true , 'default' => 'CURRENT_TIMESTAMP' , 'description' => 'date this record was modified' ],
2020-03-29 19:33:16 +01:00
],
2021-09-22 15:08:30 +01:00
'primary key' => [ 'attachment_id' , 'size' ],
2021-05-02 16:02:26 +01:00
'indexes' => [
2021-04-15 23:28:28 +01:00
'attachment_thumbnail_attachment_id_idx' => [ 'attachment_id' ],
2020-06-30 17:26:40 +01:00
],
2020-03-29 19:33:16 +01:00
];
}
2020-06-30 17:26:40 +01:00
}