<?php
require_once("StoredFile.php");

define('INDCH', ' ');

/**
 * Auxiliary class for GreenBox playlist editing methods.
 *
 * remark: dcterms:extent format: hh:mm:ss.ssssss
 *
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @version $Revision$
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 */
class Playlist extends StoredFile {

    public function __construct($p_gunid=NULL)
    {
        parent::__construct($p_gunid);
    }


    /**
     * Create instance of Playlist object and insert empty file
     *
     * @param GreenBox $gb
     * 		reference to GreenBox object
     * @param global $plid
     * 		unique id
     * @param string $fname
     * 		name of new file
     * @param int $parid
     * 		local object id of parent folder
     * @return instance of Playlist object
     */
    public function create(&$gb, $plid, $fname=NULL, $parid=NULL)
    {
        $tmpFname = uniqid('');
        $oid = BasicStor::AddObj($tmpFname , 'playlist', $parid);
        if (PEAR::isError($oid)) {
        	return $oid;
        }
        $values = array(
            "id" => $oid,
            "metadata" => dirname(__FILE__).'/emptyPlaylist.xml',
            "gunid" => $plid,
            "filetype" => "playlist");
        $pl =& StoredFile::Insert($values);
        if (PEAR::isError($pl)) {
            $res = BasicStor::RemoveObj($oid);
            return $pl;
        }
        $fname = ($fname == '' || is_null($fname) ? "newFile.xml" : $fname );
        $res = $gb->bsRenameFile($oid, $fname);
        if (PEAR::isError($res)) {
        	return $res;
        }
        $res = $pl->setState('ready');
        if (PEAR::isError($res)) {
        	return $res;
        }
        $res = $pl->setMime('application/smil');
        if (PEAR::isError($res)) {
        	return $res;
        }
        $res = $pl->setAuxMetadata();
        if (PEAR::isError($res)) {
        	return $res;
        }
        return $pl;
    }


    /**
     * Lock playlist for edit
     *
     * @param GreenBox $gb
     * 		reference to GreenBox object
     * @param int $subjid
     * 		local subject (user) id
     * @param boolean $val
     * 		if false do unlock
     * @return boolean
     * 		previous state or error object
     */
    public function lock(&$gb, $subjid=NULL, $val=TRUE)
    {
        if ($val && $gb->isEdited($this->gunid) !== FALSE) {
            return PEAR::raiseError(
                'Playlist::lock: playlist already locked'
            );
        }
        $r = $gb->setEditFlag($this->gunid, $val, NULL, $subjid);
        return $r;
    }


    /**
     * Unlock playlist (+recalculate and pregenerate XML)
     *
     * @param GreenBox $gb
     * 		reference to GreenBox object
     * @return boolean
     * 		previous state or error object
     */
    public function unlock(&$gb)
    {
        $r = $this->recalculateTimes();
        if (PEAR::isError($r)) {
        	return $r;
        }
        $r = $this->md->regenerateXmlFile();
        if (PEAR::isError($r)) {
        	return $r;
        }
        $r = $this->lock($gb, $this->gunid, NULL, FALSE);
        return $r;
    }


    /**
     *  Add audioClip specified by local id to the playlist
     *
     * @param string $acId
     * 		local ID of added file
     * @param string $fadeIn
     * 		optional, in time format hh:mm:ss.ssssss - total duration
     * @param string $fadeOut
     * 		optional, in time format hh:mm:ss.ssssss - total duration
     * @param string $plElGunid
     * 		optional playlist element gunid
     * @param string $length
     * 		optional length in in time format hh:mm:ss.ssssss -
     *      for webstream (or for overrule length of audioclip)
     * @param string $clipstart
     *      optional clipstart in time format hh:mm:ss.ssssss - relative to begin
     * @param string $clipend
     *      optional $clipend in time format hh:mm:ss.ssssss - relative to begin
     * @return string
     * 		generated playlistElement gunid
     */
    public function addAudioClip($acId, $fadeIn=NULL, $fadeOut=NULL, $plElGunid=NULL,
        $length=NULL, $clipstart=NULL, $clipend=NULL)
    {
        $plGunid = $this->gunid;
        // get information about audioClip
        $acInfo = $this->getAudioClipInfo($acId);
        if (PEAR::isError($acInfo)) {
        	return $acInfo;
        }
        extract($acInfo);   // 'acGunid', 'acLen', 'acTit', 'elType'
        if (!is_null($length)) {
        	$acLen = $length;
        }
        // get information about playlist and containers
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'

        // insert new playlist element
        $offset = $plLen;
		
		 // insert default values if parameter was empty
        $clipStart = !is_null($clipstart) ? $clipstart : '00:00:00.000000';
        $clipEnd = !is_null($clipend) ? $clipend : $acLen;
        
        $acLengthS = $clipLengthS = self::playlistTimeToSeconds($acLen);
        if (!is_null($clipStart)) {
            $clipLengthS = $acLengthS - self::playlistTimeToSeconds($clipStart);    
        }
        if (!is_null($clipEnd)) {
            $clipLengthS = $clipLengthS - ($acLengthS - self::playlistTimeToSeconds($clipEnd));   
        }
        $clipLength = self::secondsToPlaylistTime($clipLengthS);
		
        $plElInfo = $this->insertPlaylistElement($parid, $offset, $clipStart, $clipEnd, $clipLength,
            $acGunid, $acLen, $acTit, $fadeIn, $fadeOut, $plElGunid,
            $elType);
        if (PEAR::isError($plElInfo)) {
        	return $plElInfo;
        }
        return $plElInfo['plElGunid'];
    }


    /**
     * Remove audioClip from playlist
     *
     * @param string $plElGunid
     * 		global id of deleted playlistElement
     * @return boolean
     */
    public function delAudioClip($plElGunid)
    {
        $plGunid = $this->gunid;
        // get information about playlist and containers
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'

        // get array of playlist elements:
        $plElArr = $this->md->getMetadataElement('playlistElement', $parid);
        if (PEAR::isError($plElArr)) {
        	return $plElArr;
        }
        $found = FALSE;
        foreach ($plElArr as $el) {
            $plElGunidArr = $this->md->getMetadataElement('id', $el['mid']);
            if (PEAR::isError($plElGunidArr)) {
            	return $plElGunidArr;
            }
            // select playlist element to remove
            if ($plElGunidArr[0]['value'] == $plElGunid) {
                $acArr = $this->md->getMetadataElement('audioClip', $el['mid']);
                if (PEAR::isError($acArr)) {
                	return $acArr;
                }
                $storedAcMid = $acArr[0]['mid'];
                $acLenArr = $this->md->getMetadataElement('playlength', $storedAcMid);
                if (PEAR::isError($acLenArr)) {
                	return $acLenArr;
                }
                $acLen = $acLenArr[0]['value'];
                // remove playlist element:
                $r = $this->md->setMetadataElement($el['mid'], NULL);
                if (PEAR::isError($r)) {
                	return $r;
                }
                $found = TRUE;
            }
        }
        if (!$found) {
            return PEAR::raiseError(
                "Playlist::delAudioClip: playlistElement not found".
                " ($plElGunid)"
            );
        }
        return TRUE;
    }


    /**
     * Change fadeIn and fadeOut values for playlist Element
     *
     * @param string $plElGunid
     * 		playlistElement gunid
     * @param string $fadeIn
     * 		new value in ss.ssssss or extent format
     * @param string $fadeOut
     * 		new value in ss.ssssss or extent format
     * @return boolean
     */
    public function changeFadeInfo($plElGunid, $fadeIn, $fadeOut)
    {
        $plGunid = $this->gunid;
        // get information about playlist and containers
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'

        // get array of playlist elements:
        $plElArr = $this->md->getMetadataElement('playlistElement', $parid);
        if (PEAR::isError($plElArr)) {
        	return $plElArr;
        }
        foreach ($plElArr as $el) {
            $plElGunidArr = $this->md->getMetadataElement('id', $el['mid']);
            if (PEAR::isError($plElGunidArr)) {
            	return $plElGunidArr;
            }
            // select playlist element:
            if ($plElGunidArr[0]['value'] != $plElGunid) {
            	continue;
            }
            $found = TRUE;
            // get fadeInfo:
            $fiMid = $this->_getMidOrInsert('fadeInfo', $el['mid']);
            if (PEAR::isError($fiMid)) {
            	return $fiMid;
            }
            $fiGunid = StoredFile::CreateGunid();
            $r = $this->_getMidOrInsert('id', $fiMid, $fiGunid, 'A');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $fadeInId = $this->_getMidOrInsert('fadeIn', $fiMid, $fadeIn, 'A');
            if (PEAR::isError($fadeInId)) {
            	return $fadeInId;
            }
            $fadeOutId = $this->_getMidOrInsert('fadeOut', $fiMid, $fadeOut, 'A');
            if (PEAR::isError($fadeOutId)) {
            	return $fadeOutId;
            }
            $r = $this->_setValueOrInsert(
                $fadeInId, $fadeIn, $fiMid, 'fadeIn');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $r = $this->_setValueOrInsert(
                $fadeOutId, $fadeOut, $fiMid, 'fadeOut');
            if (PEAR::isError($r)) {
            	return $r;
            }
            return true;
        }
        return false;
    }
    
        /**
     * Change cueIn/curOut values for playlist element
     *
     * @param string $plElGunid
     * 		playlistElement gunid
     * @param string $fadeIn
     * 		new value in ss.ssssss or extent format
     * @param string $fadeOut
     * 		new value in ss.ssssss or extent format
     * @return boolean or pear error object
     */
    public function changeClipLength($plElGunid, $clipStart, $clipEnd)
    {
        $plGunid = $this->gunid;
        // get information about playlist and containers
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'

        // get array of playlist elements:
        $plElArr = $this->md->getMetadataElement('playlistElement', $parid);
        if (PEAR::isError($plElArr)) {
        	return $plElArr;
        }
        foreach ($plElArr as $el) {
            $plElGunidArr = $this->md->getMetadataElement('id', $el['mid']);
            if (PEAR::isError($plElGunidArr)) {
            	return $plElGunidArr;
            }
            // select playlist element:
            if ($plElGunidArr[0]['value'] != $plElGunid) {
            	continue;
            }
            $found = TRUE;
            // get clipStart Mid
            $clipStartMid = $this->_getMidOrInsert('clipStart', $el['mid']);
            if (PEAR::isError($clipStartMid)) {
            	return $clipStartMid;
            }
            // get clipEnd Mid
            $clipEndMid = $this->_getMidOrInsert('clipEnd', $el['mid']);
            if (PEAR::isError($clipEndMid)) {
            	return $clipEndMid;
            }
            // get clipLength Mid
            $clipLengthMid = $this->_getMidOrInsert('clipLength', $el['mid']);
            if (PEAR::isError($clipLengthMid)) {
            	return $clipLengthMid;
            }
            // set clipStart value
            $r = $this->md->setMetadataElement($clipStartMid, $clipStart);
            if (PEAR::isError($r)) {
            	return $r;
            }
            // setClipend value
            $r = $this->md->setMetadataElement($clipEndMid, $clipEnd);
            if (PEAR::isError($r)) {
            	return $r;
            }
            // set playlength value
            $clipLength = self::secondsToPlaylistTime(self::playlistTimeToSeconds($clipEnd) - self::playlistTimeToSeconds($clipStart));
            $r = $this->md->setMetadataElement($clipLengthMid, $clipLength);
            if (PEAR::isError($r)) {
            	return $r;
            }
            $this->recalculateTimes();
            return true;
        }
        return false;
    }


    /**
     * Move audioClip to the new position in the playlist
     *
     * @param string $plElGunid
     * 		playlistElement gunid
     * @param int $newPos
     * 		new position in playlist
     * @return mixed
     */
    public function moveAudioClip($plElGunid, $newPos)
    {
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        $els =& $arr['children'];
        foreach ($els as $i => $el) {
            if ($el['elementname'] != 'playlistElement') {
                $metadata = array_splice($els, $i, 1);
                continue;
            }
        }
        foreach ($els as $i => $el) {
            if ($el['attrs']['id'] == $plElGunid) {
                $movedi = $i;
            }
            $r = $this->delAudioClip($el['attrs']['id']);
            if (PEAR::isError($r)) {
            	return $r;
            }
        }
        if ($newPos < 1) {
        	$newPos = 1;
        }
        if ($newPos>count($els)) {
        	$newPos = count($els);
        }
        $movedel = array_splice($els, $movedi, 1);
        array_splice($els, $newPos-1, 0, $movedel);
        foreach ($els as $i => $el) {
            $plElGunid2 = $el['attrs']['id'];
            $fadeIn = NULL;
            $fadeOut = NULL;
            foreach ($el['children'] as $j => $af) {
                switch ($af['elementname']) {
                    case "audioClip":
                    case "playlist":
                        $acGunid = $af['attrs']['id'];
                        break;
                    case "fadeInfo":
                        $fadeIn = $af['attrs']['fadeIn'];
                        $fadeOut = $af['attrs']['fadeOut'];
                        break;
                    default:
                        return PEAR::raiseError(
                            "Playlist::moveAudioClip: unknown element type".
                            " in playlistElement ({$af['elementname']})"
                        );
                }
            }
            $acId = BasicStor::IdFromGunid($acGunid);
            if (PEAR::isError($acId)) {
            	return $acId;
            }
            if (is_null($acId)) {
                return PEAR::raiseError(
                    "Playlist::moveAudioClip: null audioClip gunid"
                );
            }
            $r = $this->addAudioClip($acId, $fadeIn, $fadeOut, $plElGunid2);
            if (PEAR::isError($r)) {
            	return $r;
            }
        }
        return TRUE;
    }


    /**
     * Recalculate total length of playlist and relativeOffset values
     * of all playlistElements according to legth and fadeIn values.
     * FadeOut values adjusted to next fadeIn.
     *
     * @return boolean
     */
    public function recalculateTimes()
    {
        $plGunid = $this->gunid;
        // get information about playlist and containers
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'
        // get array of playlist elements:
        $plElArr = $this->md->getMetadataElement('playlistElement', $parid);
        if (PEAR::isError($plElArr)) {
        	return $plElArr;
        }
        $peArr = array();
        $len = 0;
        $nextOffset = $len;
        $prevFiMid = NULL;
        $lastLenS = NULL;
        foreach ($plElArr as $el) {
            $elId = $el['mid'];
            // get playlistElement gunid:
            $plElGunidArr = $this->md->getMetadataElement('id', $elId);
            if (PEAR::isError($plElGunidArr)) {
            	return $plElGunidArr;
            }
            $plElGunid = $plElGunidArr[0]['value'];
            // get relativeOffset:
            $offArr = $this->md->getMetadataElement('relativeOffset', $elId);
            if (PEAR::isError($offArr)) {
            	return $offArr;
            }
            // get clipStart:
            $clipStartArr = $this->md->getMetadataElement('clipStart', $elId);
            if (PEAR::isError($clipStartArr)) {
            	return $clipStartArr;
            }
            $clipStart = $clipStartArr[0]['value'];
            $clipStartS = Playlist::playlistTimeToSeconds($clipStart);
            // get clipEnd:
            $clipEndArr = $this->md->getMetadataElement('clipEnd', $elId);
            if (PEAR::isError($clipEndArr)) {
            	return $clipEndArr;
            }
            $clipEnd = $clipEndArr[0]['value'];
            $clipEndS = Playlist::playlistTimeToSeconds($clipEnd);
            // get clipLength:
            $lenArr = $this->md->getMetadataElement('clipLength', $elId);
            if (PEAR::isError($lenArr)) {
            	return $lenArr;
            }
            $offsetId = $offArr[0]['mid'];
            $offset = $offArr[0]['value'];
            // get audioClip:
            $acArr = $this->md->getMetadataElement('audioClip', $elId);
            if (is_array($acArr) && (!isset($acArr[0]) || is_null($acArr[0]))) {
                $acArr = $this->md->getMetadataElement('playlist', $elId);
            }
            if (PEAR::isError($acArr)) {
            	return $acArr;
            }
            $storedAcMid = $acArr[0]['mid'];
            // get playlength:
            $acLenArr = $this->md->getMetadataElement('playlength', $storedAcMid);
            if (PEAR::isError($acLenArr)) {
            	return $acLenArr;
            }
            $acLen = $acLenArr[0]['value'];
            // get fadeInfo:
            $fiArr = $this->md->getMetadataElement('fadeInfo', $elId);
            if (PEAR::isError($fiArr)) {
            	return $fiArr;
            }
            if (isset($fiArr[0]['mid'])) {
                $fiMid = $fiArr[0]['mid'];
                $fadeInArr = $this->md->getMetadataElement('fadeIn', $fiMid);
                if (PEAR::isError($fadeInArr)) {
                	return $fadeInArr;
                }
                $fadeIn = $fadeInArr[0]['value'];
                $fadeOutArr = $this->md->getMetadataElement('fadeOut', $fiMid);
                if (PEAR::isError($fadeOutArr)) {
                	return $fadeOutArr;
                }
                $fadeOut = $fadeOutArr[0]['value'];
            } else {
                $fiMid = NULL;
                $fadeIn = '00:00:00.000000';
                $fadeOut = '00:00:00.000000';
            }
            $fadeInS = Playlist::playlistTimeToSeconds($fadeIn);
            if (!is_null($lastLenS)) {
                if ($lastLenS < $fadeInS) {
                    return PEAR::raiseError(
                        "Playlist::recalculateTimes: fadeIn too big");
                }
            }
            /*
            this seems made for crossfade
            if ($len > 0) {
            	$len = $len - $fadeInS;
            }
            */
            
            $newOffset = Playlist::secondsToPlaylistTime($len);
            $r = $this->_setValueOrInsert($offsetId, $newOffset, $elId, 'relativeOffset');
            if (PEAR::isError($r)) {
            	return $r;
            }
            
            // commulate length for next offset
            $acLenS = Playlist::playlistTimeToSeconds($acLen);
            $len = $len + $acLenS;
            if (!is_null($prevFiMid)) {
                $foMid = $this->_getMidOrInsert('fadeOut', $prevFiMid, $fadeIn, 'A');
                if (PEAR::isError($foMid)){
                	return $foMid;
                }
                $r = $this->_setValueOrInsert(
                    $foMid, $fadeIn, $prevFiMid, 'fadeOut', 'A');
                if (PEAR::isError($r)) {
                	return $r;
                }
            }
            // respect clipStart and clipEnd
            if (!is_null($clipStart)) {
                $len = $len - $clipStartS;    
            }
            if (!is_null($clipEnd)) {
                $len = $len - ($acLenS - $clipEndS);   
            }
            
            $prevFiMid = $fiMid;
            $lastLenS = $acLenS;
        }
        $newPlLen = Playlist::secondsToPlaylistTime($len);
        $r = $this->setPlaylistLength($newPlLen, $parid, $metaParid);
        if (PEAR::isError($r)) {
        	return $r;
        }
        return TRUE;
    }


    /**
     * Find info about clip at specified offset in playlist.
     *
     * @param string $offset
     * 		current playtime (hh:mm:ss.ssssss)
     * @param int $distance
     * 		0=current clip; 1=next clip ...
     * @return array of matching clip info:
     *   <ul>
     *      <li>gunid string, global unique id of clip</li>
     *      <li>elapsed string, already played time of clip</li>
     *      <li>remaining string, remaining time of clip</li>
     *      <li>duration string, total playlength of clip </li>
     *   </ul>
     */
    public function displayPlaylistClipAtOffset($offset, $distance=0)
    {
        $offsetS = Playlist::playlistTimeToSeconds($offset);
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        $plArr = array('els'=>array());
        // cycle over playlistElements inside playlist:
        foreach ($arr['children'] as $i => $plEl) {
            switch ($plEl['elementname']) {
                case "playlistElement":  // process playlistElement
                    $plElObj = new PlaylistElement($this, $plEl);
                    $plInfo = $plElObj->analyze();
                    $plArr['els'][] = $plInfo;
                    break;
                default:
            }
        }
        $res = array('gunid'=>NULL, 'elapsed'=>NULL,
                     'remaining'=>NULL, 'duration'=>NULL);
        $dd = 0;
        $found = FALSE;
        foreach ($plArr['els'] as $el) {
            extract($el);   // acGunid, acLen, acLenS, clipEnd, clipEndS, clipStart, clipStartS,
                            // elOffset, elOffsetS, fadeIn, fadeInS, fadeOut, fadeOutS, type
            $lengthS = $acLenS;
            if ($clipEndS) {
                $lengthS = $clipEndS;
            }
            if ($clipStartS) {
                $lengthS = $lengthS - $clipStartS;
            }
            if ( ($offsetS >= $elOffsetS) && ($offsetS < ($elOffsetS + $lengthS)) ) {
            	$found = TRUE;
            }
            if ($found) {               // we've found offset
                switch ($el['type']) {
                case "playlist":
                    $pl = StoredFile::RecallByGunid($acGunid);
                    if (is_null($pl) || PEAR::isError($pl)) {
                    	return $pl;
                    }
                    if ($dd > 0) {
                        $offsetLoc = "00:00:00.000000";
                    } else {
                        $offsetLoc = Playlist::secondsToPlaylistTime($offsetS - $elOffsetS);
                    }
                    $distanceLoc = $distance - $dd;
                    $res2 = $pl->displayPlaylistClipAtOffset($offsetLoc, $distanceLoc);
                    if (PEAR::isError($res2)) {
                    	return $res2;
                    }
                    if (!is_null($res2['gunid'])) {
                    	return $res2;
                    }
                    $dd += $res2['dd'];
                    break;
                case "audioClip":
                    if ($dd == $distance) {
                        $playedS = $offsetS - $elOffsetS;
                        if ($playedS < 0) {
                        	$playedS = 0;
                        }
                        $remainS = $lengthS - $playedS;
                        $res  = array('gunid'=>$acGunid,
                            'elapsed'   => Playlist::secondsToPlaylistTime($playedS),
                            'remaining' => Playlist::secondsToPlaylistTime($remainS),
                            'duration'  => Playlist::secondsToPlaylistTime($lengthS),
                        );
                        return $res;
                    }
                    $res['dd'] = $dd;
                    break;
                }
                $dd++;
            }
        }
        return $res;
    }


    /**
     * Return array with gunids of all sub-playlists and clips used in
     * the playlist
     *
     * @return array with hash elements:
     *              gunid - global id
     *              type  - playlist | audioClip
     */
    public function export()
    {
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        $plArr = array('els'=>array());
        // cycle over playlistElements inside playlist:
        foreach ($arr['children'] as $i => $plEl) {
            switch ($plEl['elementname']) {
            case "playlistElement":  // process playlistElement
                $plElObj = new PlaylistElement($this, $plEl);
                $plInfo = $plElObj->analyze();
                $plArr['els'][] = $plInfo;
                break;
            default:
            }
        }
        $res  = array(array('gunid'=>$plGunid, 'type'=>'playlist'));
        $dd = 0;
        $found = FALSE;
        foreach ($plArr['els'] as $el) {
            extract($el);   // acLen, elOffset, acGunid, fadeIn, fadeOut, playlist
            switch ($el['type']) {
            case "playlist":
                $pl = StoredFile::RecallByGunid($acGunid);
                if (is_null($pl) || PEAR::isError($pl)) {
                	return $pl;
                }
                $res2 = $pl->export();
                if (PEAR::isError($res2)) {
                	return $res2;
                }
                $res = array_merge($res, $res2);
                break;
            default:
                $res[]  = array('gunid'=>$acGunid, 'type'=>$el['type']);
                break;
            }
        }
        return $res;
    }


    /**
     * Convert playlist time value to float seconds
     *
     * @param string $plt
     * 		playlist time value (HH:mm:ss.dddddd)
     * @return int
     * 		seconds
     */
    public static function playlistTimeToSeconds($plt)
    {
        $arr = split(':', $plt);
        if (isset($arr[2])) {
          return (intval($arr[0])*60 + intval($arr[1]))*60 + floatval($arr[2]);
        }
        if (isset($arr[1])) {
        	return intval($arr[0])*60 + floatval($arr[1]);
        }
        return floatval($arr[0]);
    }


    /**
     * Convert float seconds value to playlist time format
     *
     * @param float $seconds
     * @return string
     * 		time in playlist time format (HH:mm:ss.dddddd)
     */
    public static function secondsToPlaylistTime($p_seconds)
    {
        $seconds = $p_seconds;
        $milliseconds = intval(($seconds - intval($seconds)) * 1000);
        $milliStr = str_pad($milliseconds, 6, '0');
        $hours = floor($seconds / 3600);
        $seconds -= $hours * 3600;
        $minutes = floor($seconds / 60);
        $seconds -= $minutes * 60;
        $res = sprintf("%02d:%02d:%02d.%s", $hours, $minutes, $seconds, $milliStr);
        return $res;
    }


    /**
     * Cyclic-recursion checking
     *
     * @param string $insGunid
     * 		gunid of playlist being inserted
     * @return boolean
     * 		true if recursion is detected
     */
    public function cyclicRecursion($insGunid)
    {
        if ($this->gunid == $insGunid) {
        	return TRUE;
        }
        $pl = StoredFile::RecallByGunid($insGunid);
        if (is_null($pl) || PEAR::isError($pl)) {
        	return $pl;
        }
        $arr = $pl->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        $els =& $arr['children'];
        if (!is_array($els)) {
        	return FALSE;
        }
        foreach ($els as $i => $plEl) {
            if ($plEl['elementname'] != "playlistElement") {
            	continue;
            }
            foreach ($plEl['children'] as $j => $elCh) {
                if ($elCh['elementname'] != "playlist") {
                	continue;
                }
                $nextGunid = $elCh['attrs']['id'];
                $res = $this->cyclicRecursion($nextGunid);
                if ($res) {
                	return TRUE;
                }
            }
        }
        return FALSE;
    }


    /**
     * Export playlist as simplified SMIL XML file.
     *
     * @param boolean $toString
     *		if false don't real export,
     *      return misc info about playlist only
     * @return string
     * 		XML string or hasharray with misc info
     */
    public function outputToSmil($toString=TRUE)
    {
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        if ($toString) {
            $r = PlaylistTagExport::OutputToSmil($this, $arr);
            if (PEAR::isError($r)) {
            	return $r;
            }
            return $r;
        } else {
            return array(
                'type'       => 'playlist',
                'gunid'      => $plGunid,
                'src'        => PL_URL_RELPATH."$plGunid.smil",
                'playlength' => $arr['attrs']['playlength'],
            );
        }
    }


    /**
     * Export playlist as M3U file.
     *
     * @param boolean $toString
     * 		if false don't real export,
     *      return misc info about playlist only
     *  @return string|array
     * 		M3U string or hasharray with misc info
     */
    public function outputToM3u($toString=TRUE)
    {
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        if ($toString) {
            $r = PlaylistTagExport::OutputToM3u($this, $arr);
            if (PEAR::isError($r)) {
            	return $r;
            }
            return $r;
        } else {
            return array(
                'type'       => 'playlist',
                'gunid'      => $plGunid,
                'uri'        => PL_URL_RELPATH."$plGunid.m3u",
                'playlength' => $arr['attrs']['playlength'],
                'title'      => $arr['attrs']['title'],
            );
        }
    }


    /**
     * Export playlist as RSS XML file
     *
     * @param boolean $toString
     * 		if false don't really export,
     *      return misc info about playlist only
     * @return mixed
     * 		XML string or hasharray with misc info
     */
    public function outputToRss($toString=TRUE)
    {
        $plGunid = $this->gunid;
        $arr = $this->md->genPhpArray();
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        if ($toString) {
            $r = PlaylistTagExport::OutputToRss($this, $arr);
            if (PEAR::isError($r)) {
            	return $r;
            }
            return $r;
        } else {
            return array(
                'type'       => 'playlist',
                'gunid'      => $plGunid,
                'src'        => PL_URL_RELPATH."$plGunid.smil",
                'playlength' => $arr['attrs']['playlength'],
            );
        }
    }


    /**
     * Set values of auxiliary metadata
     *
     * @return mixed
     * 		true or error object
     */
    private function setAuxMetadata()
    {
        // get info about playlist
        $plInfo = $this->getPlaylistInfo();
        if (PEAR::isError($plInfo)) {
        	return $plInfo;
        }
        extract($plInfo);   // 'plLen', 'parid', 'metaParid'
        // set gunid as id attr in playlist tag:
        $mid = $this->_getMidOrInsert('id', $parid, $this->gunid, 'A');
        if (PEAR::isError($mid)) {
        	return $mid;
        }
        $r = $this->_setValueOrInsert(
            $mid, $this->gunid, $parid,  'id', 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        return TRUE;
    }


    /**
     * Get audioClip length and title
     *
     * @param int $acId
     * 		local id of audioClip inserted to playlist
     * @return array with fields:
     *  <ul>
     *   <li>acGunid, string - audioClip gunid</li>
     *   <li>acLen string - length of clip in dcterms:extent format</li>
     *   <li>acTit string - clip title</li>
     *   <li>elType string - audioClip | playlist</li>
     *  </ul>
     */
    private function getAudioClipInfo($acId)
    {
        $ac = StoredFile::Recall($acId);
        if (is_null($ac) || PEAR::isError($ac)) {
        	return $ac;
        }
        $acGunid = $ac->gunid;
        $r = $ac->md->getMetadataElement('dcterms:extent');
        if (PEAR::isError($r)) {
        	return $r;
        }
        if (isset($r[0]['value'])) {
        	$acLen = $r[0]['value'];
        } else {
        	$acLen = '00:00:00.000000';
        }
        $r = $ac->md->getMetadataElement('dc:title');
        if (PEAR::isError($r)) {
        	return $r;
        }
        if (isset($r[0]['value'])) {
        	$acTit = $r[0]['value'];
        } else {
        	$acTit = $acGunid;
        }
        $elType = BasicStor::GetObjType($acId);
        $trTbl = array('audioclip'=>'audioClip', 'webstream'=>'audioClip',
            'playlist'=>'playlist');
        $elType = $trTbl[$elType];
        if ($elType == 'webstream') {
        	$elType = 'audioClip';
        }
        return compact('acGunid', 'acLen', 'acTit', 'elType');
    }


    /**
     * Get info about playlist
     *
     * @return array with fields:
     *  <ul>
     *   <li>plLen string - length of playlist in dcterms:extent format</li>
     *   <li>parid int - metadata record id of playlist container</li>
     *   <li>metaParid int - metadata record id of metadata container</li>
     *  </ul>
     */
    private function getPlaylistInfo()
    {
        $parid = $this->getContainer('playlist');
        if (PEAR::isError($parid)) {
        	return $parid;
        }
        // get playlist length and record id:
        $r = $this->md->getMetadataElement('playlength', $parid);
        if (PEAR::isError($r)) {
        	return $r;
        }
        if (isset($r[0])) {
            $plLen = $r[0]['value'];
        } else {
            $r = $this->md->getMetadataElement('dcterms:extent');
            if (PEAR::isError($r)) {
            	return $r;
            }
            if (isset($r[0])) {
                $plLen = $r[0]['value'];
            } else {
                $plLen = '00:00:00.000000';
            }
        }
        // get main playlist container
        $parid = $this->getContainer('playlist');
        if (PEAR::isError($parid)) {
        	return $parid;
        }
        // get metadata container (optionally insert it)
        $metaParid = $this->getContainer('metadata', $parid, TRUE);
        if (PEAR::isError($metaParid)) {
        	return $metaParid;
        }
        return compact('plLen', 'parid', 'metaParid');
    }


    /**
     * Get container record id, optionally insert new container
     *
     * @param string $containerName
     * @param int $parid
     * 		parent record id
     * @param boolean $insertIfNone - flag if insert may be done
     *      if container wouldn't be found
     * @return int
     * 		metadata record id of container
     */
    private function getContainer($containerName, $parid=NULL, $insertIfNone=FALSE)
    {
        $r = $this->md->getMetadataElement($containerName, $parid);
        if (PEAR::isError($r)) {
        	return $r;
        }
        $id = $r[0]['mid'];
        if (!is_null($id)) {
        	return $id;
        }
        if (!$insertIfNone || is_null($parid)) {
            return PEAR::raiseError(
                "Playlist::getContainer: can't find container ($containerName)"
            );
        }
        $id = $this->md->insertMetadataElement($parid, $containerName);
        if (PEAR::isError($id)) {
        	return $id;
        }
        return $id;
    }


    /**
     * Insert a new playlist element.
     *
     * @param int $parid
     * 		parent record id
     * @param string $offset
     * 		relative offset in extent format
     * @param string $clipstart
     * 		audioClip clipstart in extent format
     * @param string $clipEnd
     * 		audioClip clipEnd in extent format
     * @param string $clipLength
     * 		 audioClip playlength in extent format (?)
     * @param string $acGunid
     * 		audioClip gunid
     * @param string $acLen
     * 		audioClip length in extent format
     * @param string $acTit
     * 		audioClip title
     * @param string $fadeIn
     * 		fadeIn value in ss.ssssss or extent format
     * @param string $fadeOut
     * 		fadeOut value in ss.ssssss or extent format
     * @param string $plElGunid
     * 		optional playlist element gunid
     * @param string $elType
     * 		optional 'audioClip' | 'playlist'
     * @return array with fields:
     *  <ul>
     *   <li>plElId int - record id of playlistElement</li>
     *   <li>plElGunid string - gl.unique id of playlistElement</li>
     *   <li>fadeInId int - record id</li>
     *   <li>fadeOutId int - record id</li>
     *  </ul>
     */
    private function insertPlaylistElement($parid, $offset, $clipStart, $clipEnd, $clipLength, $acGunid, $acLen, $acTit,
        $fadeIn=NULL, $fadeOut=NULL, $plElGunid=NULL, $elType='audioClip')
    {
        // insert playlistElement
        $r = $this->md->insertMetadataElement($parid, 'playlistElement');
        if (PEAR::isError($r)) {
        	return $r;
        }
        $plElId = $r;
        // create and insert gunid (id attribute)
        if (is_null($plElGunid)) {
        	$plElGunid = StoredFile::CreateGunid();
        }
        $r = $this->md->insertMetadataElement($plElId, 'id', $plElGunid, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        // insert relativeOffset
        $r = $this->md->insertMetadataElement(
            $plElId, 'relativeOffset', $offset, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        // insert clipLength
        $r = $this->md->insertMetadataElement(
            $plElId, 'clipLength', $clipLength, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        // insert clipStart
        $r = $this->md->insertMetadataElement(
            $plElId, 'clipStart', $clipStart, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        // insert clipEnd
        $r = $this->md->insertMetadataElement(
            $plElId, 'clipEnd', $clipEnd, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        // insert audioClip (or playlist) element into playlistElement
        $r = $this->md->insertMetadataElement($plElId, $elType);
        if (PEAR::isError($r)) {
        	return $r;
        }
        $acId = $r;
        $r = $this->md->insertMetadataElement($acId, 'id', $acGunid, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        $r = $this->md->insertMetadataElement($acId, 'playlength', $acLen, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        $r = $this->md->insertMetadataElement($acId, 'title', $acTit, 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        $fadeInId=NULL;
        $fadeOutId=NULL;
        if (!is_null($fadeIn) || !is_null($fadeOut)) {
            // insert fadeInfo element into playlistElement
            $r = $this->md->insertMetadataElement($plElId, 'fadeInfo');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $fiId = $r;
            $fiGunid = StoredFile::CreateGunid();
            $r = $this->md->insertMetadataElement($fiId, 'id', $fiGunid, 'A');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $r = $this->md->insertMetadataElement($fiId, 'fadeIn', $fadeIn, 'A');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $fadeInId = $r;
            $r = $this->md->insertMetadataElement($fiId, 'fadeOut', $fadeOut, 'A');
            if (PEAR::isError($r)) {
            	return $r;
            }
            $fadeOutId = $r;
        }
        return compact('plElId', 'plElGunid', 'fadeInId', 'fadeOutId');
    }


    /**
     * Return record id, optionally insert new record
     *
     * @param string $category
     * 		qualified name of metadata category
     * @param int $parid
     * 		parent record id
     * @param string $value
     * 		value for inserted record
     * @param string $predxml
     * 		'A' | 'T' (attribute or tag)
     * @return int
     * 		metadata record id
     */
    private function _getMidOrInsert($category, $parid, $value=NULL, $predxml='T')
    {
        $arr = $this->md->getMetadataElement($category, $parid);
        if (PEAR::isError($arr)) {
        	return $arr;
        }
        $mid = NULL;
        if (isset($arr[0]['mid'])) {
        	$mid = $arr[0]['mid'];
        }
        if (!is_null($mid)) {
        	return $mid;
        }
        $mid = $this->md->insertMetadataElement($parid, $category, $value, $predxml);
        if (PEAR::isError($mid)) {
        	return $mid;
        }
        return $mid;
    }


    /**
     * Set value of metadata record, optionally insert new record
     *
     * @param int $mid
     * 		record id
     * @param string $value
     * 		value for inserted record
     * @param int $parid
     * 		parent record id
     * @param string $category
     * 		qualified name of metadata category
     * @param string $predxml
     * 		'A' | 'T' (attribute or tag)
     * @return boolean
     */
    private function _setValueOrInsert($mid, $value, $parid, $category, $predxml='T')
    {
        if (is_null($mid)) {
            $r = $this->md->insertMetadataElement(
                $parid, $category, $value, $predxml);
        } else {
            $r = $this->md->setMetadataElement($mid, $value);
        }
        if (PEAR::isError($r)) {
        	return $r;
        }
        return TRUE;
    }


    /**
     * Set playlist length - dcterm:extent
     *
     * @param string $newPlLen
     * 		new length in extent format
     * @param int $parid
     * 		playlist container record id
     * @param int $metaParid
     * 		metadata container record id
     * @return boolean
     */
    private function setPlaylistLength($newPlLen, $parid, $metaParid)
    {
        $mid = $this->_getMidOrInsert('playlength', $parid, $newPlLen, 'A');
        if (PEAR::isError($mid)) {
        	return $mid;
        }
        $r = $this->_setValueOrInsert(
            $mid, $newPlLen, $parid,  'playlength', 'A');
        if (PEAR::isError($r)) {
        	return $r;
        }
        $mid = $this->_getMidOrInsert('dcterms:extent', $metaParid, $newPlLen);
        if (PEAR::isError($mid)) {
        	return $mid;
        }
        $r = $this->_setValueOrInsert(
            $mid, $newPlLen, $metaParid,  'dcterms:extent');
        if (PEAR::isError($r)) {
        	return $r;
        }
        return TRUE;
    }

} // class Playlist


/**
 * Auxiliary class for GB playlist editing methods
 *
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 */
class PlaylistElement {
    private $pl = NULL;
    private $plEl = NULL;

    public function PlaylistElement(&$pl, $plEl)
    {
        $this->pl = $pl;
        $this->plEl = $plEl;
    }


    public function analyze()
    {
        $plInfo = array(
            'acLen' => '00:00:00.000000',
            'acLenS' => 0,
            'fadeIn' => '00:00:00.000000',
            'fadeInS' => 0,
            'fadeOut' => '00:00:00.000000',
            'fadeOutS' => 0,
            'clipStart' => '00:00:00.000000',
            'clipStartS' => 0,
            'clipEnd' => '00:00:00.000000',
            'clipEndS' => 0 
        );
        $plInfo['elOffset'] = $this->plEl['attrs']['relativeOffset'];
        $plInfo['elOffsetS'] = Playlist::playlistTimeToSeconds($plInfo['elOffset']);
        // cycle over tags inside playlistElement
        foreach ($this->plEl['children'] as $j => $acFi) {
            switch ($acFi['elementname']) {
	            case "playlist":
	                $plInfo['type'] = 'playlist';
	                break;
	            case "audioClip":
	                $plInfo['type'] = 'audioClip';
	                break;
	        }
	        switch ($acFi['elementname']) {
	            case "playlist":
	            case "audioClip":
	                $plInfo['acLen'] = $acFi['attrs']['playlength'];
	                $plInfo['acLenS'] = Playlist::playlistTimeToSeconds($plInfo['acLen']);
	                $plInfo['acGunid'] = $acFi['attrs']['id'];
	                break;
	            case "fadeInfo":
	                $plInfo['fadeIn'] = $acFi['attrs']['fadeIn'];
	                $plInfo['fadeInS'] = Playlist::playlistTimeToSeconds($plInfo['fadeIn']);
	                $plInfo['fadeOut'] = $acFi['attrs']['fadeOut'];
	                $plInfo['fadeOutS'] = Playlist::playlistTimeToSeconds($plInfo['fadeOut']);
	                break;
            }
            $plInfo['clipStart'] = $this->plEl['attrs']['clipStart'];
            $plInfo['clipStartS'] = Playlist::playlistTimeToSeconds($this->plEl['attrs']['clipStart']);
            $plInfo['clipEnd'] = $this->plEl['attrs']['clipEnd'];
            $plInfo['clipEndS'] = Playlist::playlistTimeToSeconds($this->plEl['attrs']['clipEnd']);
        }
        return $plInfo;
    }
} // class PlaylistElement


/**
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 * @todo Rename this class PlaylistTag
 */
class PlaylistTagExport
{
    public static function OutputToSmil(&$pl, $plt, $ind='')
    {
        $ind2 = $ind.INDCH;
        $ind3 = $ind2.INDCH;
        $ind4 = $ind3.INDCH;
        $res = "";
        foreach ($plt['children'] as $ple) {
            switch ($ple['elementname']) {
                case "playlistElement":
                    $r = PlaylistElementExport::OutputToSmil($pl, $ple, $ind4);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$res .= $r;
                    }
                    break;
                case "metadata":
                    $r = PlaylistMetadataExport::OutputToSmil($pl, $ple, $ind4);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$res .= $r;
                    }
                    break;
                default:
            }
        }
        $res = "$ind<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
            "$ind<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n".
            "$ind2<body>\n".
            "$ind3<par>\n".
            "$res".
            "$ind3</par>\n".
            "$ind2</body>\n".
            "$ind</smil>\n";
        return $res;
    }


    public static function OutputToM3u(&$pl, $plt, $ind='')
    {
        $res = "";
        foreach ($plt['children'] as $ple) {
            switch ($ple['elementname']) {
                case"playlistElement":
                    $r = PlaylistElementExport::OutputToM3u($pl, $ple);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$res .= $r;
                    }
                break;
            }
        }
        $res = "#EXTM3U\n$res";
        return $res;
    }


    public static function OutputToRss(&$pl, $plt, $ind='')
    {
        $ind2 = $ind.INDCH;
        $ind3 = $ind2.INDCH;
        $res = "";
        foreach ($plt['children'] as $ple) {
            switch ($ple['elementname']) {
                case "playlistElement":
                    $r = PlaylistElementExport::OutputToRss($pl, $ple, $ind3);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$res .= $r;
                    }
                break;
                case "metadata":
                    $r = PlaylistMetadataExport::OutputToRss($pl, $ple, $ind3);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$res .= $r;
                    }
                break;
                default:
            }
        }
        $res = "$ind<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n".
            "$ind<rss version=\"2.0\">\n".
            "$ind2<channel>\n".
            "$res".
            "$ind2</channel>\n".
            "$ind</rss>\n";
        return $res;
    }
}


/**
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 * @todo Rename this class "PlaylistElement"
 */
class PlaylistElementExport {

    public static function OutputToSmil(&$pl, $ple, $ind='')
    {
        $acOrPl = NULL;
        $finfo = array('fi'=>0, 'fo'=>0);
        $ind2 = $ind.INDCH;
        $ind3 = $ind2.INDCH;
        $anim = '';
        foreach ($ple['children'] as $ac) {
            switch ($ac['elementname']) {
                case "audioClip":
                    $r = PlaylistAudioClipExport::OutputToSmil($pl, $ac, $ind2);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                    break;
                case "playlist":
                    $gunid = $ac['attrs']['id'];
                    $pl2 = StoredFile::RecallByGunid($gunid);
                    if (is_null($pl2) || PEAR::isError($pl2)) {
                    	return $pl2;
                    }
                    $r = $pl2->outputToSmil(FALSE);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                    break;
                case "fadeInfo":
                    $r = PlaylistFadeInfoExport::OutputToSmil($pl, $ac, $ind2);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$finfo = $r;
                    }
                    break;
                default:
                    return PEAR::raiseError(
                        "PlaylistElementExport::OutputToSmil:".
                        " unknown tag {$ac['elementname']}"
                    );
            }
        }
        $beginS = Playlist::playlistTimeToSeconds($ple['attrs']['relativeOffset']);
        $playlengthS = Playlist::playlistTimeToSeconds($acOrPl['playlength']);
        $fadeOutS = Playlist::playlistTimeToSeconds($finfo['fo']);
        $fiBeginS = 0;
        $fiEndS = Playlist::playlistTimeToSeconds($finfo['fi']);
        $foBeginS = ($playlengthS - $fadeOutS);
        $foEndS = Playlist::playlistTimeToSeconds($acOrPl['playlength']);
        foreach (array('fi','fo') as $ff) {
            if (${$ff."EndS"} - ${$ff."BeginS"} > 0) {
                $anim .= "{$ind2}<animate attributeName = \"soundLevel\"\n".
                    "{$ind3}from = \"".($ff == 'fi' ? 0 : 100)."%\"\n".
                    "{$ind3}to = \"".($ff == 'fi' ? 100 : 0)."%\"\n".
                    "{$ind3}calcMode = \"linear\"\n".
                    "{$ind3}begin = \"{${$ff."BeginS"}}s\"\n".
                    "{$ind3}end = \"{${$ff."EndS"}}s\"\n".
                    "{$ind3}fill = \"freeze\"\n".
                    "{$ind2}/>\n"
                ;
            }
        }
        $src = $acOrPl['src'];
        $str = "$ind<audio src=\"$src\" begin=\"{$beginS}s\"".
            ($anim ? ">\n$anim$ind</audio>" : " />").
            " <!-- {$acOrPl['type']}, {$acOrPl['gunid']}, {$acOrPl['playlength']}  -->".
            "\n";
        return $str;
    }


    public static function OutputToM3u(&$pl, $ple, $ind='')
    {
        $acOrPl = NULL;
        foreach ($ple['children'] as $ac) {
            switch ($ac['elementname']) {
                case "audioClip":
                    $r = PlaylistAudioClipExport::OutputToM3u($pl, $ac);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                	break;
                case "playlist":
                    $gunid = $ac['attrs']['id'];
                    $pl2 = StoredFile::RecallByGunid($gunid);
                    if (is_null($pl2) || PEAR::isError($pl2)) {
                    	return $pl2;
                    }
                    $r = $pl2->outputToM3u(FALSE);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                	break;
            }
        }
        if (is_null($acOrPl)) {
        	return '';
        }
        $playlength = ceil(Playlist::playlistTimeToSeconds($acOrPl['playlength']));
        $title = $acOrPl['title'];
        $uri = (isset($acOrPl['uri']) ? $acOrPl['uri'] : '???' );
        $res  = "#EXTINF: $playlength, $title\n";
        $res .= "$uri\n";
        return $res;
    }


    public static function OutputToRss(&$pl, $ple, $ind='')
    {
        $acOrPl = NULL;
        $ind2 = $ind.INDCH;
        $anim = '';
        foreach ($ple['children'] as $ac) {
            switch ($ac['elementname']) {
                case "audioClip":
                    $r = PlaylistAudioClipExport::OutputToRss($pl, $ac, $ind2);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                	break;
                case "playlist":
                    $gunid = $ac['attrs']['id'];
                    $pl2 = StoredFile::RecallByGunid($gunid);
                    if (is_null($pl2) || PEAR::isError($pl2)) {
                    	return $pl2;
                    }
                    $r = $pl2->outputToRss(FALSE);
                    if (PEAR::isError($r)) {
                    	return $r;
                    }
                    if (!is_null($r)) {
                    	$acOrPl = $r;
                    }
                	break;
                case "fadeInfo":
                	break;
                default:
                    return PEAR::raiseError(
                        "PlaylistElementExport::OutputToRss:".
                        " unknown tag {$ac['elementname']}"
                    );
            }
        }
        $title = (isset($acOrPl['title']) ? htmlspecialchars($acOrPl['title']) : '' );
        $desc = (isset($acOrPl['desc']) ? htmlspecialchars($acOrPl['desc']) : '' );
        $link = htmlspecialchars($acOrPl['src']);
        $desc = '';
        $str = "$ind<item>\n".
            "$ind2<title>$title</title>\n".
            "$ind2<description>$desc</description>\n".
            "$ind2<link>$link</link>\n".
            "$ind</item>\n";
        return $str;
    }
}


/**
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 * @todo Rename this class to PlaylistAudioClip (notice the caps)
 */
class PlaylistAudioClipExport
{

    public static function OutputToSmil(&$pl, $plac, $ind='')
    {
        $gunid = $plac['attrs']['id'];
        $ac = StoredFile::RecallByGunid($gunid);
        if (is_null($ac) || PEAR::isError($ac)) {
        	return $ac;
        }
        $RADext = $ac->getFileExtension();
        if (PEAR::isError($RADext)) {
        	return $RADext;
        }
        return array(
            'type'       => 'audioclip',
            'gunid'      => $gunid,
            'src'        => AC_URL_RELPATH."$gunid.$RADext",
            'playlength' => $plac['attrs']['playlength'],
        );
    }


    public static function OutputToM3u(&$pl, $plac, $ind='')
    {
        $gunid = $plac['attrs']['id'];
        $ac = StoredFile::RecallByGunid($gunid);
        if (is_null($ac) || PEAR::isError($ac)) {
        	return $ac;
        }
        $RADext = $ac->getFileExtension();
        if (PEAR::isError($RADext)) {
        	return $RADext;
        }
        return array(
            'playlength' => $plac['attrs']['playlength'],
            'title'      => $plac['attrs']['title'],
            'uri'        => AC_URL_RELPATH."$gunid.$RADext",
        );
    }


    public static function OutputToRss(&$pl, $plac, $ind='')
    {
        $gunid = $plac['attrs']['id'];
        $ac = StoredFile::RecallByGunid($gunid);
        if (is_null($ac) || PEAR::isError($ac)) {
        	return $ac;
        }
        $RADext = $ac->getFileExtension();
        if (PEAR::isError($RADext)) {
        	return $RADext;
        }
        $title = $pl->gb->bsGetMetadataValue($ac->getId(), 'dc:title');
        $desc = $pl->gb->bsGetMetadataValue($ac->getId(), 'dc:description');
        return array(
            'type'       => 'audioclip',
            'gunid'      => $gunid,
            'src'        => "http://XXX/YY/$gunid.$RADext",
            'playlength' => $plac['attrs']['playlength'],
            'title'      => $title,
            'desc'      => $desc,
        );
    }
}


/**
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 * @todo Rename this class "PlaylistFadeInfo" (notive the caps)
 */
class PlaylistFadeInfoExport
{

    public static function OutputToSmil(&$pl, $plfi, $ind='')
    {
        $r = array(
            'fi'=>$plfi['attrs']['fadeIn'],
            'fo'=>$plfi['attrs']['fadeOut'],
        );
        return $r;
    }


    public static function OutputToM3u(&$pl, $plfa, $ind='')
    {
    	return '';
    }


    public static function OutputToRss(&$pl, $plfa, $ind='')
    {
    	return '';
    }

}


/**
 * @author Tomas Hlava <th@red2head.com>
 * @author Paul Baranowski <paul@paulbaranowski.org>
 * @package Campcaster
 * @subpackage StorageServer
 * @copyright 2006 MDLF, Inc.
 * @license http://www.gnu.org/licenses/gpl.txt
 * @link http://www.campware.org
 * @todo Rename this class to PlaylistMetadata (notice the caps)
 */
class PlaylistMetadataExport
{
    public static function OutputToSmil(&$pl, $md, $ind='')
    {
    	return NULL;
    }


    public static function OutputToM3u(&$pl, $md, $ind='')
    {
    	return NULL;
    }


    public static function OutputToRss(&$pl, $md, $ind='')
    {
    	return NULL;
    }
}

?>