Ego_Output.php

gehe zur Dokumentation dieser Datei

<?php
require_once 'base/Ego_System.php';
require_once 'base/functions.php';
 
class Ego_Output {
    private $page = null;
 
    private $site = null;
 
    private $file = '';
 
    private $info = array();
 
    private $pool = '';
 
    private $mime_type = '';
 
    private $cache = '';
 
    private $generator = 'Server-File';
 
    private $etag = '';
 
    private $name = '';
 
    private $is_image = false;
 
    private $is_valid = false;
 
    private $web_format = false;
 
    private $temporary = false;
 
    private $quality = 100;
 
    private $multipart_support = false;
 
    public static $convert_types = [
        'avif' => [
            'label' => 'Avif',
            'mime' => 'image/avif'
        ],
        'webp' => [
            'label' => 'WebP',
            'mime' => 'image/webp'
        ]
    ];
 
    private $converted = '';
 
    private $error = false;
 
    public function __construct($source = null, $pool = '', $dir = '') {
        if (is_a($source, 'Page')) {
            // Datei einer Seite
            $this->page = $source;
            $this->site = $this->page->getSite();
 
            // Mediapool Unterverzeichnis erkennen
            if ($dir == '' && ($_REQUEST['dir'] || $_REQUEST['c_date'])) {
                $dir = $_REQUEST['dir'] ?: $_REQUEST['c_date'];
                if ($_REQUEST['c_date'] && !is_numeric($dir) && strpos($dir, DIRECTORY_SEPARATOR) === false) {
                    // Mediapool Archive erwarten immer Zeitstempel
                    $dir = strtotime($dir);
                }
            }
 
            if ($_REQUEST['thumbnail']) {
                // Ein Thumbnail über die URL generieren
                [$width, $height, $index] = explode('x', $_REQUEST['thumbnail'], 3);
                $this->file = $this->getThumbnail((int) $width, (int) ($height ?? $width), $pool, $dir, [
                    'index' => (int) $index
                ]);
                $this->detectMimeType();
                $this->is_image = true;
                if ($pool) {
                    $this->pool = $pool;
                }
            } elseif ($pool) {
                $this->pool = $pool;
                $file = $this->page->getMediapool()->get($this->pool, $dir);
                $this->info = $file;
                if (!$file['quarantine']) {
                    $this->file = $file['file'];
                }
 
                if (
                    $this->info['convert']
                    && $this->info['isImage']
                    && isset(self::$convert_types[$this->info['suffix']])
                ) {
                    // Automatische Umwandlung durchführen
                    $this->convertImage($this->info['suffix'], (bool) $_REQUEST['reset']);
                } else if ($this->info['isVideo'] && $this->site->admin['mediapool']['video_compress'] && !$GLOBALS['is_index']) {
                    // Automatisch zur passenden Datei für das Endgerät wechseln
                    require_once 'base/Ego_Mobile.php';
                    $mobile = new Ego_Mobile();
                    $is_mobile = $mobile->isMobile();
                    $is_tablet = $mobile->isTablet();
 
                    $files = [];
 
                    foreach (Ego_System::VIDEO_RESOLUTIONS as $height => $scale) {
                        $files["{$height}p"] = $this->page->getMediapool()->get("{$this->info['title']}_{$height}p.mp4", '_compress');
                    }
 
                    $files = array_reverse($files);
 
                    if (
                        ($is_mobile && !$is_tablet && ($data = $files['360p'])) // 360p nur für Mobile
                        || ($is_tablet && ($data = $files['720p'])) // 720p nur für Tablets
                        || ($data = $files['1080p']) // 1080p nur für Desktops
                    ) {
                        $this->file = $data['file'];
                        $this->mime_type = $data['mime'];
                    } else {
                        // Wenn nichts zutrifft, dann die höhste verfügbare Auflösung verwenden (ansonsten die Originaldatei)
                        $existing_files = array_filter($files);
                        if ($data = array_pop($existing_files)) {
                            $this->file = $data['file'];
                            $this->mime_type = $data['mime'];
                        }
                    }
                } else {
                    $this->detectMimeType();
                }
                $type = $file['suffix'];
            } elseif (!$this->page->extra['quarantine']) {
                // Bei der Ausgabe eines Multimedia Ausschnitts wird die Originalseite referenziert
                if ($this->page->field['type'] == 'multimedia/image' && $this->page->extra['crop_image']) {
                    $extra = array(
                        'edit' => $this->page->extra['edit'],
                        'crop_image' => true
                    );
                    $this->page = $this->page->getParents()->nextPage();
                    $this->page->extra = array_merge($this->page->extra, $extra);
                }
 
                $this->file = $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->site->name.'/';
                if ($_REQUEST['c_date']) {
                    // Als "c_date" das vom Page Konstruktor ermittelte Datum verwenden
                    $archive_file = $this->file . $this->page->getMediaFilename(
                        false,
                        '_'.Ego_System::dateEncode($this->page->field['c_date'])
                    );
                    if (Ego_System::file_exists($archive_file)) {
                        $this->file = $archive_file;
                    } else {
                        // Gibt es keine passende Version, wird das Original verwendet
                        $this->file .= $this->page->getMediaFilename();
                    }
                } else {
                    $this->file .= $this->page->getMediaFilename();
                }
                $this->mime_type = $this->page->extra['mime_type'];
 
                if (
                    $this->page->field['type'] == 'multimedia/image'
                    && isset(self::$convert_types[ltrim($_SERVER['REQUEST_SUFFIX'], '.')])
                    && !in_array($this->mime_type, ['image/svg+xml', self::$convert_types[ltrim($_SERVER['REQUEST_SUFFIX'], '.')]['mime']])
                ) {
                    // Automatische Umwandlung durchführen
                    $this->convertImage($type = $this->page->extra['image_type'] = ltrim($_SERVER['REQUEST_SUFFIX'], '.'), (bool) $_REQUEST['reset']);
                } else {
                    $type = $this->page->extra['image_type'];
                }
 
                // Automatisch zur passenden Datei für das Endgerät wechseln
                if ($this->site->admin['video']['compress'] && !$GLOBALS['is_index']) {
                    require_once 'base/Ego_Mobile.php';
                    $mobile = new Ego_Mobile();
                    $files = [
                        '360p' => $this->page->getMediapool()->get('360p.mp4'),
                        '720p' => $this->page->getMediapool()->get('720p.mp4'),
                        '1080p' => $this->page->getMediapool()->get('1080p.mp4')
                    ];
                    $is_mobile = $mobile->isMobile();
                    $is_tablet = $mobile->isTablet();
                    if (
                        ($is_mobile && !$is_tablet && ($data = $files['360p'])) // 360p nur für Mobile
                        || ($is_tablet && ($data = $files['720p'])) // 720p nur für Tablets
                        || ($data = $files['1080p']) // 1080p nur für Desktops
                    ) {
                        $this->file = $data['file'];
                        $this->mime_type = $data['mime'];
                    } else {
                        // Wenn nichts zutrifft, dann die höhste verfügbare Auflösung verwenden (ansonsten die Originaldatei)
                        $existing_files = array_filter($files);
                        if ($data = array_pop($existing_files)) {
                            $this->file = $data['file'];
                            $this->mime_type = $data['mime'];
                        }
                    }
                }
            }
 
            // Bestimmte MimeTypes setzen
            if (!empty($type)) {
                $formats = array(
                    'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                    'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
                    'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
                    'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                    'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
                    'xps' => 'application/vnd.ms-xpsdocument',
                    'svg' => 'image/svg+xml'
                );
                if (array_key_exists($type, $formats)) {
                    $this->mime_type = $formats[$type];
                }
            }
        } elseif (is_string($source)) {
            if (strpos($source, 'string:') === 0) {
                // Übergebenen String in eine temporäre Datei speichern
                $file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'output');
                Ego_System::file_put_contents($file, substr($source, 7));
                $this->setFile($file);
                $this->setTemporary(true);
            } else {
                // Existierende Datei verwenden
                $this->setFile($source);
            }
            if (!empty($GLOBALS['site']) && is_a($GLOBALS['site'], 'Site')) {
                $this->site = $GLOBALS['site'];
            } elseif (class_exists('Site')) {
                $this->site = new Site();
            }
        }
 
        // Erkennen, ob die auszugebende Datei ein Bild (außer SVG und ICO: diese werden immer direkt und ohne ImageMagick Transformation ausgegeben)
        $ignore_image_mimes = array('image/svg+xml', 'image/x-icon', 'image/vnd.microsoft.icon');
        $ignore_image_types = array('svg', 'ico');
 
        if (!$this->is_image) {
            if ($this->page && $this->page->field['type'] == 'multimedia/image') {
                $this->is_image = !in_array($this->page->extra['mime_type'], $ignore_image_mimes);
            } elseif ($this->file) {
                if ($pool) {
                    $this->is_image = preg_match(
                        '/\.(' . implode(
                            '|',
                            array_filter(
                                Ego_System::getFormats('image'),
                                function ($type) use ($ignore_image_types) {
                                    return !in_array($type, $ignore_image_types);
                                }
                            )
                        ) . ')$/ims',
                        $pool
                    );
                } else {
                    $this->is_image = !(strpos($this->mime_type, 'image') === false || in_array($this->mime_type, $ignore_image_mimes));
                    if ($this->page && $this->page->extra['mime_type'] && $this->page->extra['image_type']) {
                        $this->is_valid = true; // Kopierte Multimedia Seitentypen unterstützen
                    }
                }
            }
        }
 
        if ($this->is_image) {
            $this->web_format = in_array(
                $this->mime_type,
                Ego_System::getFormats('web')
            );
            if (is_numeric($_REQUEST['quality'])) {
                // In der URL gesetzt
                $this->quality = (int) $_REQUEST['quality'];
            } else if (is_numeric($GLOBALS['quality'])) {
                // Vom Template gesetzt
                $this->quality = (int) $GLOBALS['quality'];
            } elseif (is_numeric($GLOBALS['egotec_conf']['image']['quality'])) {
                // Aus den Einstellungen des Mandanten auslesen
                $this->quality = (int) $GLOBALS['egotec_conf']['image']['quality'];
            }
        }
    }
 
    private function isValid($download = false) {
        return (
            $this->is_valid
            || (
                (
                    in_array($this->page->field['type'], array('multimedia/file', 'multimedia/image', 'multimedia/category'))
                    || $this->pool
                )
                && (
                    (
                        $download
                        && $this->page->field['type'] == 'multimedia/category'
                    )
                    || Ego_System::file_exists($this->file)
                )
                && $this->page->hasRights('view')
            )
        );
    }
 
    public function convertImage($format, $reset = false) {
        if ($this->file && $this->page) {
            $cache_file = $GLOBALS['egotec_conf']['var_dir']
                . 'converted/'
                . $this->page->getSite()->name . '/'
                . $this->page->getSite()->language . '/'
                . $this->page->field['id'] . '/'
                . $format . '_' . md5($this->file) . '_' . md5(filemtime($this->file));
 
            // Mime-Type ändern
            if (isset(self::$convert_types[$format])) {
                $this->mime_type = self::$convert_types[$format]['mime'];
            }
 
            // Zwischengespeicherte Datei verwenden
            if (!$reset && Ego_System::file_exists($cache_file)) {
                $this->file = $cache_file;
            } else {
                $this->clearConvertedImages($format);
 
                // Datei neu umwandeln
                $tmp_file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'convert');
                Ego_System::copy($this->file, $tmp_file);
 
                // Zu verwendende Methode für die Umwandlung bestimmen
                $method = $GLOBALS['egotec_conf']['files']["convert_$format"] ?: '';
 
                switch ($method) {
                    case 'avifenc':
                        Ego_System::mkdir(dirname($cache_file));
                        Ego_System::exec('avifenc', [
                            '--jobs ' . ($GLOBALS['egotec_conf']['files']['max_cores'] ?: 1),
                            '--min 0',
                            '--max 63',
                            '-a end-usage=q',
                            '-a cq-level=32',
                            '-a tune=ssim',
                            '-a deltaq-mode=3',
                            '-a sharpness=3',
                            '-y 420',
                            $tmp_file,
                            $cache_file
                        ]);
 
                        // ...und zwischenspeichern
                        $this->file = $cache_file;
                        break;
 
                    default:
                        require_once 'base/Ego_Image.php';
                        $image = new Ego_Image($tmp_file);
 
                        if ($converted_file = $image->convert($format, [
                            'output' => $cache_file
                        ])) {
                            // ...und zwischenspeichern
                            $this->file = $converted_file;
                        }
                }
 
                @unlink($tmp_file);
            }
 
            // Merken, dass diese Datei umgewandelt wurde
            $this->converted = $format;
            $this->name = preg_replace('/\.[^.]+$/', ".$format", $this->getName());
        }
        return $this->converted != '';
    }
 
    public function clearConvertedImages($format = '') {
        if ($this->file && $this->page) {
            foreach (glob(
                $GLOBALS['egotec_conf']['var_dir']
                . 'converted/'
                . $this->page->getSite()->name . '/'
                . $this->page->getSite()->language . '/'
                . $this->page->field['id'] . '/'
                . ($format ?: '[!_]*') . '_' . md5($this->file) . '_*'
            ) as $file) {
                @unlink($file);
            }
        }
    }
 
    public function getConvertedImages() {
        $files = [];
 
        if ($this->file && $this->page) {
            foreach (glob(
                $GLOBALS['egotec_conf']['var_dir']
                . 'converted/'
                . $this->page->getSite()->name . '/'
                . $this->page->getSite()->language . '/'
                . $this->page->field['id'] . '/'
                .  '[!_]*_' . md5($this->file) . '_*'
            ) as $file) {
                if (preg_match('/^([^_]+)_/', basename($file), $matches)) {
                    $files[] = [
                        'format' => $format = $matches[1],
                        'label' => self::$convert_types[$format]['label'],
                        'size' => Ego_System::byte_format(@filesize($file)),
                        'file' => $file
                    ];
                }
            }
        }
 
        return $files;
    }
 
    private function detectMimeType() {
        require_once 'base/Ego_MimeType.php';
        $mime = new Ego_MimeType();
        $this->mime_type = $mime->autoDetect($this->file);
    }
 
    public function error($image = false, $code = 404) {
        Ego_System::header($code);
 
        $forced_error_image = [];
        if (($this->is_image || $image || !empty($forced_error_image = $this->forceErrorImage())) && !$this->error) {
            $error_image = true;
            if (class_exists('Imagick')) {
                $width = $this->page ? $this->page->extra['origImgWidth'] : 0;
                if (!is_numeric($width) || $_REQUEST['width']) {
                    $width = (int) ($_REQUEST['width'] ?? $forced_error_image['width']);
                }
                $height = $this->page ? $this->page->extra['origImgHeight'] : 0;
                if (!is_numeric($height) || $_REQUEST['height']) {
                    $height = (int) ($_REQUEST['height'] ?? $forced_error_image['height']);
                }
 
                if ($width && $height) {
                    $this->file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'transform');
 
                    $image = new Imagick();
                    $draw = new ImagickDraw();
                    $image->newImage($width, $height, new ImagickPixel('grey'));
 
                    $font_size = ceil(min(array($width, $height)) / 6);
                    $draw->setFillColor('lightgrey');
                    $draw->setFontSize($font_size);
                    $draw->setTextAlignment(Imagick::ALIGN_CENTER);
                    $image->annotateImage(
                        $draw,
                        ceil($width / 2),
                        ceil($height / 2) + ceil($font_size / 2),
                        0,
                        Ego_System::isDevMode() ? ($forced_error_image['text'] ?? "{$width} x {$height}") : $code
                    );
                    $image->setImageFormat('png');
                    $image->writeImage($this->file);
 
                    $this->setTemporary(true);
 
                    $error_image = false;
                }
            }
            if ($error_image) {
                $this->file = $GLOBALS['egotec_conf']['egotec_dir'] . 'pub' .
                    DIRECTORY_SEPARATOR . 'missing_file.gif';
            }
            $this->detectMimeType();
            $this->is_valid = true;
            $this->error = true;
            $error = $this->read();
        } elseif ($this->site) {
            $error = $this->site->getErrorPage();
        } else {
            $site = new Site();
            $error = $site->getErrorPage();
        }
        return $error;
    }
 
    private function forceErrorImage() {
        $result = [];
 
        if (
            $this->mime_type == 'image/svg+xml'
            || ($this->pool && mb_substr(mb_strtolower($this->pool), -4) == '.svg')
        ) {
            $result = [
                'width' => 1024,
                'height' => 768,
                'text' => 'SVG'
            ];
        }
 
        return $result;
    }
 
    private function prepend(&$page, &$site, &$auth, &$smarty) {
        if (
            !$this->pool
            && $page
            && $site
            && ($file = $site->getSiteFile($page->field['type'].DIRECTORY_SEPARATOR.'index.php'))
        ) {
            require_once($file);
        }
    }
 
    public function setName($name) {
        $this->name = $name;
    }
 
    public function getName() {
        if ($this->name != '') {
            return $this->name;
        } elseif ($this->pool) {
            return $this->pool;
        } elseif ($this->page) {
            $suffix = '.'.$this->page->extra['image_type'];
            return preg_replace(
                '/'.preg_quote($suffix, '/').'$/i',
                '',
                strtr($this->page->field['name'], '/\:*?"<>|', '_________')
            ).$suffix;
        } else {
            return basename($this->file);
        }
    }
 
    private function setDefaultHeaders($length = 0) {
        if (!empty($this->etag)) {
            Ego_System::header('ETag: "'.$this->etag.'"');
        }
        Ego_System::header('Content-Type: '.$this->mime_type.'; charset=UTF-8');
        $t = $this->page ? $this->site->getCacheExpire() : 0;
        if (!$t) { // Keiner darf cachen
            Ego_System::noCache();
        } else {
            /* Bei Bildern ist das Feld cache immer 0. Es wird trotzdem immer ein Header gesendet,
             * so dass Browser und Proxy cachen dürfen. */
            Ego_System::header("Expires: ". gmdate("D, d M Y H:i:s", time() + $t) . " GMT");
 
            /* Bei HTTPS und PDF muss für IE8 (und kleiner) immer "Pragma: public" stehen
             * ansonsten gibt es komische Probleme bei "Ziel speichern unter"
             * und Seitenaufruf von PDFs bei HTTPS */
            if (
                $_SERVER['HTTPS'] == 'on'
                && in_array(
                    mb_strtolower($this->page->extra['image_type']),
                    array('pdf', 'doc', 'docx', 'dot')
                )
            ) {
                Ego_System::header("Pragma: public");
            }
            if (
                $this->page->field['cache']&2
                && $GLOBALS['auth']->isNobody()
            ) {
                // Proxy und/oder Browser darf cachen
                Ego_System::header('Cache-Control: public');
            } else {
                // Nur Browser darf cachen
                Ego_System::header('Cache-Control: private');
            }
        }
        if (!$GLOBALS['egotec_conf']['no_content_length_header']) {
            if (!$length) {
                $length = $this->getFilesize($this->file);
            }
            Ego_System::header('Content-Length: '.$length);
        }
        if ($this->page) {
            Ego_System::header("Last-Modified: ".gmdate("D, d M Y H:i:s", Ego_System::dateEncode($this->page->field['c_date']))." GMT");
            if ($this->page->extra['meta_robots'] && $this->page->extra['meta_robots'] != 'index') {
                Ego_System::header('X-Robots-Tag: '.$this->page->extra['meta_robots']);
            }
        }
    }
 
    private function setSingleHeaders() {
        Ego_System::header('Content-Disposition: inline; filename="'.$this->getName().'";');
        Ego_System::header('Content-Transfer-Encoding: binary');
        Ego_System::header('Accept-Ranges: bytes');
        Ego_System::header('Content-Size: '.$this->getFilesize($this->file));
        Ego_System::header('Connection: Keep-Alive');
        $this->setDefaultHeaders();
        ob_clean();
        flush();
        readfile_chunked($this->file);
    }
 
    private function setRangeHeaders() {
        $fp = @fopen($this->file, 'rb');
        $size = $this->getFilesize($this->file);
        $length = $size;
        $start = 0;
        $end = $size - 1;
        if (isset($_SERVER['HTTP_RANGE'])) {
            $c_end = $end;
            [, $range] = explode('=', $_SERVER['HTTP_RANGE'], 2);
            if (strpos($range, ',') !== false) {
                // Multiple Range
                if ($this->multipart_support) {
                    $boundary = md5('multipart_byteranges');
                    Ego_System::header(206);
                    Ego_System::header("Content-Length: $size");
                    Ego_System::header('Content-Type: multipart/byteranges; boundary=' . $boundary);
                    foreach (explode(',', $range) as $multi_range) {
                        $multi_range = explode('-', trim($multi_range));
                        if ($multi_range[0] == '-') {
                            $start = $size - substr($multi_range, 1);
                            $end = $c_end;
                        } else {
                            $start = $multi_range[0];
                            $end = (isset($multi_range[1]) && is_numeric($multi_range[1])) ? $multi_range[1] : $size;
                        }
                        fseek($fp, $start);
                        $buffer = 1024 * 8;
                        echo "--{$boundary}\r\n";
                        echo "Content-Type: {$this->mime_type}\r\n";
                        echo "Content-Range: bytes $start-$end/$size\r\n\r\n";
                        while (!feof($fp) && ($p = ftell($fp)) <= $end) {
                            if ($p + $buffer > $end) {
                                $buffer = $end - $p + 1;
                            }
                            set_time_limit(0);
                            echo fread($fp, $buffer);
                        }
                        echo "\r\n";
                        flush();
                    }
                    echo "--{$boundary}--\r\n\r\n";
                    fclose($fp);
                } else {
                    // Multiple Range nicht unterstützen und stattdessen als Download behandeln
                    $this->setDownloadHeaders();
                }
                return;
            } else {
                // Single Range
                if ($range[0] == '-') {
                    $c_start = $size - substr($range, 1);
                } else {
                    $range = explode('-', $range);
                    $c_start = $range[0];
                    $c_end = (isset($range[1]) && is_numeric($range[1])) ? $range[1] : $size;
                }
                $c_end = $c_end > $end ? $end : $c_end;
                if ($c_start > $c_end || $c_start > $size - 1 || $c_end >= $size) {
                    Ego_System::header(416);
                    Ego_System::header("Content-Range: bytes $start-$end/$size");
                    exit;
                }
                $start = $c_start;
                $end = $c_end;
                $length = $end - $start + 1;
                fseek($fp, $start);
                Ego_System::header(206);
            }
        }
        Ego_System::header("Content-Range: bytes $start-$end/$size");
        $this->setDefaultHeaders($length);
        $buffer = 1024 * 8;
        while (!feof($fp) && ($p = ftell($fp)) <= $end) {
            if ($p + $buffer > $end) {
                $buffer = $end - $p + 1;
            }
            set_time_limit(0);
            echo fread($fp, $buffer);
            flush();
        }
        fclose($fp);
    }
 
    private function setDownloadHeaders() {
        Ego_System::header('Content-Description: File Transfer');
        Ego_System::header('Content-Disposition: attachment; filename="'.$this->getName().'";');
        Ego_System::header('Content-Transfer-Encoding: binary');
        Ego_System::header('Connection: close');
        $this->setDefaultHeaders();
        ob_clean();
        flush();
        readfile_chunked($this->file);
    }
 
    public function read($download = false) {
        // Datei aus dem Cache ermitteln
        if (
            !empty($this->etag)
            && $_SERVER['HTTP_IF_NONE_MATCH'] == '"' . $this->etag . '"'
            && $GLOBALS['auth']->isNobody()
        ) {
            Ego_System::header('Cache-Control: private');
            Ego_System::header(304);
            exit;
        }
 
        if ($this->isValid($download)) {
            $this->prepend($this->page, $this->site, $GLOBALS['auth'], $GLOBALS['smarty']);
 
            // In der Entwicklungsumgebung immer Platzhalter Bilder anzeigen
            if (
                $GLOBALS['egotec_conf']['dev']['images']
                && $this->is_image
                && !$download
            ) {
                $this->error(true);
            }
 
            // Parameter für die Modifizierung ermitteln
            $modify = array();
            $modify_keys = array('clip', 'rotation', 'mirror', 'grayscale');
            if ($_REQUEST['original'] && !$GLOBALS['auth']->isNobody()) {
                // Angemeldete Benutzer dürfen das Original sehen
                unset($_REQUEST['width'], $_REQUEST['height']);
 
                // Im Original wird die Rotation beibehalten
                $modify_keys = array('rotation', 'mirror', 'grayscale');
            }
 
            foreach ($modify_keys as $param) {
                if (isset($_REQUEST[$param])) {
                    $modify[$param] = $_REQUEST[$param];
                } else {
                    if ($this->pool) {
                        if (isset($this->info[$param]) && !empty($this->info[$param])) {
                            $modify[$param] = $this->info[$param];
                        }
                    } elseif ($this->page->field['type'] == 'multimedia/image') {
                        if (isset($this->page->extra['edit'][$param])) {
                            $modify[$param] = $this->page->extra['edit'][$param];
                        }
                    }
                }
            }
 
            if (
                (!$download || !empty($modify))
                && $this->is_image
                && ($_REQUEST['width']
                    || $_REQUEST['height']
                    || $this->quality != 100
                    || !$this->web_format
                    || !empty($modify))
            ) {
                // Bild transformieren
                try {
                    $this->transform((int) $_REQUEST['width'], (int) $_REQUEST['height'], $modify);
                } catch (Ego_Image_Exception $e) {
                    $this->error(true, 406);
                }
            }
            if ($download) {
                if (
                    !$this->page
                    && @is_dir($this->file)
                ) {
                    // Bei einem Verzeichnis wird automatisch ein Archiv erzeugt
                    $this->setTemporary(true);
                    $this->setFile($this->createArchive($this->file));
                } elseif (
                    $this->page
                    && $this->page->field['type'] == 'multimedia/category'
                    && !empty($this->site->admin['allow_download'])
                    && !empty($this->page->extra['allow_download'])
                ) {
                    // Archiv erstellen
                    $this->file = $this->page->export();
                    $this->detectMimeType();
                    $this->setTemporary(true);
                    $this->page->extra['image_type'] = 'tar.gz';
                }
                // Datei herunterladen
                $this->setDownloadHeaders();
            } else {
                // Datei ausgeben
                $partial = false;
                if (
                    ( // Ehemals immer für Videos, zur Kontrolle -> Issue #2010
                        isset($_SERVER['HTTP_RANGE']) // Range Header werden angefordert
                    )
                    && (
                        !preg_match('/MSIE (.*?);/', $_SERVER['HTTP_USER_AGENT'], $matches)
                        || $matches[1] > 8 // Range Header nicht für MSIE 8 und kleiner
                    )
                ) {
                    // teilweise
                    $this->setRangeHeaders();
                    $partial = true;
                } else {
                    // direkt
                    $this->setSingleHeaders();
                }
                if (
                    !$partial
                    && $this->site
                    && !empty($this->cache)
                    && ($this->page->field['cache']&3) != 0
                    && !$GLOBALS['no_cache']
                ) {
                    // Ausgabe cachen
                    $info = array(
                        'headers' => $GLOBALS['egotec']['response_headers'],
                        'stats' => $GLOBALS['stats'],
                        'type' => $this->page->field['type']
                    );
                    $this->site->setCacheEntry($this->cache . '.info', $info);
                    $this->site->setCacheEntry($this->cache, $this->file);
                }
            }
            if ($this->temporary) {
                @unlink($this->file);
            }
            exit;
        }
        return $this->error($this->page && strpos($this->page->extra['mime_type'], 'image/') === 0);
    }
 
    public function download() {
 
        return $this->read(true);
    }
 
    public function pdf($name = '', $temporary = true, $cookie = true, $return = 1) {
        if ($this->isValid()) {
            // Einstellungen
            $smarty = $GLOBALS['smarty'];
            $site = $this->site;
            $page = $this->page;
            $context = null;
            if ($cookie && !empty($_COOKIE[EGOTEC])) {
                $context = stream_context_create(array(
                    'http' => array(
                        'method' => 'GET',
                        'header' => "Cookie: ".EGOTEC."=".$_COOKIE[EGOTEC]."\r\n"
                    )
                ));
            }
            $s = Ego_System::file_get_contents($this->file, true, $context);
            if (!empty($name)) {
                $this->setName($name);
            }
            $_REQUEST['title'] = $this->getName();
 
            // Generierung durchführen
            $no_pdf_header = true;
            include('pdf/pdf_create.php');
 
            // Datei übernehmen
            $pdf_file = $GLOBALS['egotec_conf']['tmp_dir'].'output'.md5(microtime()).'.pdf';
            Ego_System::file_put_contents($pdf_file, $s);
            if ($temporary) {
                $this->removeFile();
            }
            $this->setTemporary($return !== 3);
            $this->setFile($pdf_file);
 
            // Datei ausgeben
            switch ($return) {
                case 1:
                    // Download
                    return $this->download();
                case 2:
                    // Ausgabe
                    return $this->read();
                case 3:
                    // Pfad zur generierten PDF Datei
                    return $this->file;
            }
        }
        return $this->error();
    }
 
    public function transform($width, $height, $modify = array()) {
        if ($this->is_image) {
            // Hook für eigene Transformationen erkennen
            $output_transform = $this->page && method_exists($this->page, 'outputTransform');
 
            // Wasserzeichen erkennen
            $output_watermark = '';
            if ($this->pool) {
                // Mediapool (ohne Vererbung)
                $list = md5($_REQUEST['dir']);
                $key = md5($this->pool);
                if ($this->page->extra['mediapool'][$list][$key]['watermark']) {
                    $output_watermark = $this->page->extra['mediapool'][$list][$key]['watermark'];
                }
            } elseif ($this->page) {
                // Multimedia (mit Vererbung)
                $inherit = $this->page->inheritExtra(array('watermark'));
                if ($inherit['watermark']) {
                    $output_watermark = $inherit['watermark'];
                }
            }
 
            // Kompressionen sind nur mit JPG Dateien möglich
            $quality_mime_types = array('image/jpeg', 'image/jpg', 'image/webp', 'image/avif');
            $quality = in_array($this->mime_type, $quality_mime_types) ? $this->quality : 0;
 
            if ($width > 0 || $height > 0 || !empty($modify) || $output_transform || $output_watermark || $quality) {
                require_once 'base/Ego_Image.php';
                $size = Ego_Image::getDimensions($this->file);
 
                // Breite und Höhe dürfen nicht größer sein als das Original
                if ($width > $size[0] || $height > $size[1]) {
                    $width = $size[0];
                    $height = $size[1];
                }
 
                if (!$_REQUEST['max'] || $size[0] > $width || $size[1] > $height || !empty($modify)) {
                    $dir = $GLOBALS['egotec_conf']['cachemedia_dir'];
                    if ($this->page) {
                        $dir .= $this->site->name . DIRECTORY_SEPARATOR . $this->site->language . DIRECTORY_SEPARATOR . $this->page->field['id'] . DIRECTORY_SEPARATOR;
                        $dir .= Ego_System::dateEncode($_REQUEST['c_date'] ? $_REQUEST['c_date'] : $this->page->field['c_date']) .
                                DIRECTORY_SEPARATOR;
                    } else {
                        $dir .= '_output' . DIRECTORY_SEPARATOR;
                    }
                    Ego_System::mkdir($dir);
 
                    $file = $dir . $width . 'x' . $height . 'x' . $this->quality . ($this->web_format ? '' : '_jpg');
                    if ($this->pool) {
                        $file .= '_' . str_replace('.', '_', base64_encode($this->pool));
                    } elseif (!$this->page) {
                        $file .= '_' . md5($this->file);
                    }
                    if ($output_watermark) {
                        $file .= '_' . md5($output_watermark);
                    }
                    if ($this->converted) {
                        $file .= '_' . $this->converted;
                    }
                    if (!empty($modify)) {
                        $file .= '_' . md5(serialize($modify));
                    }
 
                    // Hook um abzufragen ob die Cache verwendet werden soll
                    $output_cache = $this->page && method_exists($this->page, 'outputCache');
 
                    if (
                        !$_REQUEST['c_date']
                        && !$this->error
                        && (!$output_cache || $this->page->outputCache($width, $height))
                        && Ego_System::file_exists($file)
                    ) {
                        // Datei aus dem Cache verwenden
                        $this->file = $file;
                        Ego_System::header("X-Cache: CMS");
                    } else {
                        // Keine unnötige Skalierung bei Originalgröße und voller Qualität
                        if (
                            !$_REQUEST['c_date']
                            && $size[0] == $width
                            && $size[1] == $height
                            && empty($modify)
                            && (!in_array($this->mime_type, $quality_mime_types)
                                || $this->quality == 100)
                            && !$output_transform
                            && !$output_watermark
                        ) {
                            return false;
                        }
 
                        // Datei neu generieren
                        $imageTransform = new Ego_Image();
                        $tmp = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'transform');
 
                        if (Ego_System::copy($this->file, $tmp)) {
                            $imageTransform->load($tmp);
 
                            // Ausgabe modifizieren
                            if (!empty($modify)) {
                                // Bild spiegeln
                                if ($modify['mirror']) {
                                    if (strpos($modify['mirror'], 'v') !== false) {
                                        $imageTransform->mirror(true, false);
                                    }
                                    if (strpos($modify['mirror'], 'h') !== false) {
                                        $imageTransform->mirror(false, true);
                                    }
                                }
 
                                // Bild rotieren
                                if ($modify['rotation']) {
                                    $imageTransform->rotate((int) $modify['rotation']);
                                }
 
                                // Bildausschnitt verwenden
                                if ($modify['clip']) {
                                    [$x1, $y1, $x2, $y2] = explode(',', $modify['clip'], 4);
                                    $cwidth = $x2 - $x1;
                                    $cheight = $y2 - $y1;
 
                                    $imageTransform->crop($x1, $y1, $x2, $y2);
 
                                    $size[0] = $cwidth;
                                    $size[1] = $cheight;
 
                                    // Breite und Höhe dürfen nicht größer sein als der Ausschnitt
                                    if ($width > $cwidth) {
                                        $width = $cwidth;
                                    } elseif (!$width) {
                                        $width = (int)round($cwidth * ($height / $cheight));
                                    }
                                    if ($height > $cheight) {
                                        $height = $cheight;
                                    } elseif (!$height) {
                                        $height = (int)round($cheight * ($width / $cwidth));
                                    }
                                }
 
                                // Bild in Graustufen
                                if ($modify['grayscale']) {
                                    $imageTransform->grayscale();
                                }
                            }
 
                            if ($_REQUEST['max']) {
                                if ($width) {
                                    // Breite ändern, Seitenverhältnis beibehalten
                                    $w = $width;
                                    $h = (int)round($size[1] * ($width / $size[0]));
                                }
                                if ($height && $h > $height) {
                                    // Höhe ändern, Seitenverhältnis beibehalten
                                    $w = (int)round($w * ($height / $h));
                                    $h = $height;
                                }
                                $imageTransform->resize($w, $h);
                            } else {
                                if ($width && $height) {
                                    // Höhe und Breite ändern
                                    $imageTransform->resize($width, $height);
                                } else if ($width) {
                                    // Breite ändern, Seitenverhältnis beibehalten
                                    $imageTransform->scaleByX($width);
                                } else if ($height) {
                                    // Höhe ändern, Seitenverhältnis beibehalten
                                    $imageTransform->scaleByY($height);
                                }
                            }
 
                            // Hook für eigene Transformationen anwenden
                            if ($output_transform) {
                                $this->page->outputTransform($imageTransform, $tmp, $width, $height, $modify);
                            }
 
                            // Wasserzeichen einfügen
                            if ($output_watermark) {
                                $imageTransform->watermark($output_watermark);
                            }
 
                            if (
                                !$this->error
                                && $imageTransform->save($file, ($this->web_format ? '' : 'jpeg'), $quality)
                            ) {
                                $imageTransform->free();
                                $this->file = $file;
                            }
                        }
                        @unlink($tmp);
                    }
                } else {
                    return false;
                }
            }
        }
        return true;
    }
 
    public function setFile($file) {
        $this->file = $file;
        $this->detectMimeType();
        $this->is_valid = true;
    }
 
    public function removeFile() {
        @unlink($this->file);
        $this->file = '';
        $this->is_valid = false;
    }
 
    public function setCache($cache, $etag = '') {
        $this->cache = $cache;
        $this->etag = $etag;
    }
 
    public function setTemporary($temporary) {
        $this->temporary = $temporary;
    }
 
    public function createArchive($path, $type = 'tar') {
        if (@is_dir($path)) {
            // Archiv erstellen
            $dir = $GLOBALS['egotec_conf']['tmp_dir'];
            $name = basename($path);
 
            $cwd = getcwd();
            chdir($dir);
            switch ($type) {
                case 'zip':
                    $file = $name.'.zip';
                    require_once 'Archive/Zip.php';
                    $zip = new Archive_Zip($file);
                    $files = [];
 
                    foreach (scandir($path) as $entry) {
                        if (!in_array($entry, ['.', '..'])) {
                            $files[] = rtrim($path, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $entry;
                        }
                    }
 
                    $zip->add($files, ['remove_all_path' => true]);
                    break;
 
                case 'tar':
                default:
                    $file = $name.'.tar.gz';
                    require_once 'Archive/Tar.php';
                    $zip = new Archive_Tar($file, 'gz');
                    $zip->_separator = ',';
                    $zip->setIgnoreList(array($dir));
                    $zip->createModify(rtrim($path, DIRECTORY_SEPARATOR), '', $name);
            }
            chdir($cwd);
 
            return $dir.$file;
        }
        return null;
    }
 
    public static function export($key, $type) {
        $source = '';
        switch ($type) {
            case 'workflow':
                require_once 'workflow/Ego_Workflow.php';
                $workflow = new Ego_Workflow($key);
                $source = $workflow->export();
                break;
            case 'template':
                require_once 'base/template/Ego_Template.php';
                $template = new Ego_Template($key);
                $source = $template->export();
        }
        if (!empty($source)) {
            $output = new Ego_Output($source);
            $output->setTemporary(true);
            $output->download();
        }
    }
 
    private function getThumbnail($width, $height = 0, $pool = '', $dir = '', $params = []) {
        if ($this->page) {
            return $this->page->getThumbnail($width, $height, $pool, $dir, $params);
        } else {
            // TODO Thumbnail für Dateien, die keinem Page Objekt zugeordnet sind
        }
        return null;
    }
 
    public function getFile() {
        return $this->file;
    }
 
    private function getFilesize($file) {
        return (int) @filesize($file);
    }
}
?>