Moovrelocator.class.php

Go to the documentation of this file.

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
// get absolute path to this lib
define('PATH_MOOVRELOCATOR', CH_DIRECTORY_PATH_PLUGINS . 'moovrelocator/lib/');
 
// atom poc class
require_once PATH_MOOVRELOCATOR.'atom'.DIRECTORY_SEPARATOR.'Atom.class.php';
 
// bytearray to operate direct on bytes in memory just to simulate Adobe's AS3 Bytearray
require_once PATH_MOOVRELOCATOR.'bytes'.DIRECTORY_SEPARATOR.'Bytearray.class.php';
 
// transform (taken from php-reader)
require_once PATH_MOOVRELOCATOR.'bytes'.DIRECTORY_SEPARATOR.'Transform.class.php';
 
class Moovrelocator
{
    private static $_instance = null;
 
    private $_outputFile = false;
 
    private $_filesize = 0;
 
    private $_fp = false;
 
    private $_ftypBytes;
 
    private $_moovBytes;
 
    private $_middleBytes;
 
    private $_fileAtoms = array();
 
    private $_lastAtom = null;
 
    private $_successfullyParsed = false;
 
    private $_fileValid = null;
 
 
    public function setInput($filename = null)
    {
        // reset previously retrieved results
        $this->_reset();
 
        // check and open file
        if (!file_exists($filename) || !($this->_fp = fopen($filename, 'rb'))) {
            return 'cannot open file: '.$filename;
        }
 
        // get size of file
        $this->_filesize = filesize($filename);
 
        // empty file?
        if ($this->_filesize == 0) {
            return 'file '.$filename.' seems to be empty!';
        }
 
        // parse file's atoms
        while (!feof($this->_fp) && ftell($this->_fp) < $this->_filesize) {
            $this->_fileAtoms[] = $this->_parseAtomsFromInput();
        }
 
        $moovEOFCheck = $this->_moovAtomAtEOF();
        if ($moovEOFCheck !== true) {
            return $moovEOFCheck;
        } else {
            // successful parsed the file!
            $this->_successfullyParsed = true;
        }
 
        // success
        return true;
    }
 
 
    private function _parseAtomsFromInput()
    {
        // reset file stream pointer to position of the lastAtom.offset + size
        if ((isset($this->_fileAtoms[count($this->_fileAtoms) - 1]))) {
            $lastAtom = $this->_fileAtoms[count($this->_fileAtoms) - 1];
            $position = $lastAtom->getSize() + $lastAtom->getOffset();
            if (ftell($this->_fp) <= $position) {
                fseek($this->_fp, $position);
            }
        }
 
        // get 8 bytes -> get totalSize and boxType
        $atomData = unpack('NtotalSize/NboxType', fread($this->_fp, 8));
        // store offset, size and type
        $offset = ftell($this->_fp) - 8;
        $size = $atomData['totalSize'];
        $type = pack('N', $atomData['boxType']);
 
        // check 64 bit size (files > 4GB)
        if ($size == 1) {
            $highInt = $atomData['totalSize'];
            $size = ($highInt << 32) | $atomData['totalSize'];
        }
 
        // positioning of file-pointer
        fseek($this->_fp, ($size + $offset));
 
        // give back atom
        return self::factory($offset, $size, $type);
    }
 
 
    private function _isValidQTFile()
    {
        // check if file was succesfully parsed
        if (!$this->_successfullyParsed) {
            return 'please open a file first!';
        }
 
        // get first atom
        $firstAtom = $this->_fileAtoms[0];
 
        // check first for being valid (first atom MUST be ftyp)
        if ($firstAtom->getType() != Atom::FTYP_ATOM) {
            $this->_fileValid = false;
            return 'encountered non-QT top-level atom (is this a Quicktime file?)';
        }
 
        // check last for being valid
        $lastAtom = $this->_fileAtoms[count($this->_fileAtoms) - 1];
 
        if (!Atom::isValidAtom($lastAtom->getType())) {
            $this->_fileValid = false;
            return 'encountered non-QT top-level atom (is this a Quicktime file?';
        }
 
        // store validity
        return $this->_fileValid = true;
    }
 
 
    private function _moovAtomAtEOF()
    {
        if ($this->_fileAtoms[count($this->_fileAtoms) - 1]->getType() != Atom::MOOV_ATOM) {
            return 'The moov-atom isn\'t located at the end of the file, the file is allready ready for progressive download or it is a invalid file';
        }
 
        // moov is at end of file...
        return true;
    }
 
 
    public function setOutput($filename)
    {
        // store filename
        $this->_outputFile = $filename;
 
        // success
        return true;
    }
 
 
    public function relocateMoovAtom($filename, $outputFilename = null, $overwrite = false)
    {
        // read file, preprocess (parse atoms/boxes)
        $result = $this->setInput($filename);
        if ($result !== true) {
            return $result;
        }
 
        if (is_null($outputFilename) && $overwrite === true) {
            $fileResult = $filename;
        } else {
            $fileResult = $outputFilename;
        }
 
        // set the output filename and path
        $result = $this->setOutput($fileResult);
        if ($result !== true) {
            return $result;
        }
 
        // moov positioning fix
        $result = $this->fix();
        if ($result !== true) {
            return $result;
        }
 
        // success
        return true;
    }
 
 
    public function fix()
    {
        // check if file was succesfully parsed
        if (!$this->_successfullyParsed) {
            return 'please open a file first! (syntax: '.__CLASS__.'->setInput($filename);)';
        }
 
        if (!$this->_outputFile) {
            return 'please set an outputfile first! (syntax: '.__CLASS__.'->setOutput($file);)';
        }
 
        // check if moov atom is allready at beginning of file
        if (!$this->_moovAtomAtEOF()) {
            return 'nothing to do! moov allready at begin of file!';
        }
 
        // Bytearray's holding bytes from file
        $this->_ftypBytes = new Bytearray();
        $this->_middleBytes = new Bytearray();
        $this->_moovBytes = new Bytearray();
 
        // read in file's bytes
        $result = $this->_readBytes();
        if ($result !== true) {
            return $result;
        }
 
        // now start swapping
        $result = $this->_swapIndex();
        if ($result !== true) {
            return $result;
        }
 
        // write new file
        $result = $this->_writeFile();
        if ($result !== true) {
            return $result;
        }
 
        // everythings fine!
        return true;
    }
 
 
    private function _readBytes()
    {
        // read bytes from all found atoms
        for ($atom = 0; $atom < count($this->_fileAtoms); $atom++) {
 
            // get the current atom/box
            $currentAtom = $this->_fileAtoms[$atom];
            $currentAtomType = $currentAtom->getType();
 
            // keep ftyp atom
            if ($currentAtomType == Atom::FTYP_ATOM) {
                // set file pointer to begin of file
                fseek($this->_fp, 0);
                $bytes = fread($this->_fp, $currentAtom->getSize());
                $this->_ftypBytes->writeBytes($bytes);
 
            } else if ($currentAtomType == Atom::MOOV_ATOM) {
                $bytes = fread($this->_fp, $currentAtom->getSize());
                $this->_moovBytes->writeBytes($bytes);
 
            } else {
                $bytes = fread($this->_fp, $currentAtom->getSize());
                $this->_middleBytes->writeBytes($bytes);
            }
        }
 
        return true;
    }
 
 
    private function _swapIndex()
    {
        $moovSize = $this->_moovBytes->bytesAvailable();
 
        $moovAType = '';
        $moovASize = 0;
        $offsetCount = 0;
 
        $compressionCheck = $this->_moovBytes->readBytes(12, 4);
 
        if ($compressionCheck == Atom::CMOV_ATOM) {
            throw new Exception('compressed MP4/QT-file can\'t do this file: '.$file);
        }
 
        // begin of metadata
        $metaDataOffsets = array();
        $metaDataStrings = array();
        $metaDataCurrentLevel = 0;
 
        $moovStartOffset = 12;
 
        for ($i = $moovStartOffset; $i < $moovSize - $moovStartOffset; $i++) {
            $moovAType = $this->_moovBytes->readUTFBytes($i, 4);
 
            if (Atom::isValidAtom($moovAType)) {
 
                $moovASize = $this->_moovBytes->readUnsignedInt($i - 4);
 
                if (($moovASize > 8) && ($moovASize + $i < ($moovSize - $moovStartOffset))) {
 
                    try {
                        $containerLength = 0;
                        $containerString = $moovAType;
 
                        for ($mi = count($metaDataOffsets) - 1; $mi > - 1; $mi--) {
 
                            $containerLength = $metaDataOffsets[$mi];
 
                            if ($i - $moovStartOffset < $containerLength && $i - $moovStartOffset + $moovASize > $containerLength) {
                                throw new Exception('bad atom nested size');
                            }
 
                            if ($i - $moovStartOffset == $containerLength) {
                                array_pop($metaDataOffsets);
                                array_pop($metaDataStrings);
                            } else {
                                $containerString = $metaDataStrings[$mi].".".$containerString;
                            }
                        }
 
                        if (($i - $moovStartOffset) <= $containerLength) {
                            array_push($metaDataOffsets, ($i - $moovStartOffset + $moovASize));
                            array_push($metaDataStrings, $moovAType);
                        }
 
                        if ($moovAType != Atom::STCO_ATOM && $moovAType != Atom::CO64_ATOM) {
                            $i += 4;
                        } elseif ($moovAType == Atom::URL_ATOM || $moovAType == Atom::XML_ATOM) {
                            $i += $moovASize - 4;
                        }
                    }
                    catch(Exception $e) {
                        echo 'EXCEPTION: '.$e->getMessage();
                    }
                }
            }
 
 
            if ($moovAType == Atom::STCO_ATOM) {
                $moovASize = $this->_moovBytes->readUnsignedInt($i - 4);
 
                if ($i + $moovASize - $moovStartOffset > $moovSize) {
                    throw new Exception('bad atom size');
                    return;
                }
 
                $offsetCount = $this->_moovBytes->readUnsignedInt($i + 8);
 
                for ($j = 0; $j < $offsetCount; $j++) {
                    $position = ($i + 12 + $j * 4);
 
                    $currentOffset = $this->_moovBytes->readUnsignedInt($position);
 
                    // cause of mooving the moov-atom right before the rest of data
                    // (behind ftyp) the new offset is caluclated:
                    // current-offset + size of moov atom (box) = new offset
                    $currentOffset += $moovSize;
 
                    $this->_moovBytes->writeBytes(Transform::toUInt32BE($currentOffset), $position + 1);
                }
                $i += $moovASize - 4;
 
            } else if ($moovAType == Atom::CO64_ATOM) {
                $moovASize = $this->_moovBytes->readUnsignedInt($i - 4);
 
                if ($i + $moovASize - $moovStartOffset > $moovSize) {
                    throw new Exception('bad atom size');
                    return;
                }
 
                $offsetCount = $this->_moovBytes->readDouble($i + 8);
 
                for ($j2 = 0; $j2 < $offsetCount; $j2++) {
                    $position = ($i + 12 + $j * 8);
 
                    $currentOffset = $this->_moovBytes->readUnsignedInt($position);
 
                    // cause of mooving the moov-atom right before the rest of data
                    // (behind ftyp) the new offset is caluclated:
                    // current-offset + size of moov atom (box) = new offset
                    $currentOffset += $moovSize;
 
                    // TODO implement!
                    //$this->_moovBytes->writeBytes(Transform::toUInt64BE($currentOffset), $position+1);
                }
                $i += $moovASize - 4;
            }
        }
 
        return true;
    }
 
 
    private function _writeFile()
    {
        // check if we need to unlink exisiting outputfile
        if (file_exists($this->_outputFile)) {
 
            // close handle
            if ($this->_fp) {
                @fclose($this->_fp);
                $this->_fp = null;
            }
 
            if (!@unlink($this->_outputFile)) {
                return 'error deleting file: '.$this->_outputFile.' outputfile "'.$this->_outputFile.'" exists (overwite = true)!';
            }
        }
 
        // open predefined output file
        if (!$fh = fopen($this->_outputFile, 'wb+')) {
            return 'error opening outputfile: '.$this->_outputFile.' for wb+ access!';
        }
 
        // put ftyp atom/box in
        if (!fwrite($fh, $this->_ftypBytes->readAllBytes())) {
            return 'error writing ftyp-atom to outputfile: '.$this->_outputFile;
        }
 
        // put moov atom in
        if (!fwrite($fh, $this->_moovBytes->readAllBytes())) {
            return 'error writing moov-atom to outputfile: '.$this->_outputFile;
        }
 
        // put rest data in
        if (!fwrite($fh, $this->_middleBytes->readAllBytes())) {
            return 'error writing other atom(s) to outputfile: '.$this->_outputFile;
        }
 
        // close handle
        fclose($fh);
 
        // everything's fine
        return true;
    }
 
 
    public static function factory($offset, $size, $type)
    {
        // instanciate a new atom-object
        $atom = new Atom();
 
        // setup ...
        $atom->setOffset($offset);
        $atom->setSize($size);
        $atom->setType($type);
 
        // and give back ...
        return $atom;
    }
 
    private function _reset()
    {
        $this->_fileAtoms = array();
        $this->_lastAtom = null;
        $this->_successfullyParsed = false;
        $this->_fileValid = null;
 
        if ($this->_fp) {
            @fclose($this->_fp);
        }
    }
 
 
    public static function getInstance()
    {
        if (is_null(self::$_instance)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
 
 
    private function __clone()
    {
        // empty container
    }
 
 
    public function __destruct()
    {
        // close handle
        $this->_reset();
    }
}
 
?>