PHP kFileSyncUtils::getReadyLocalFilePathForKey方法代码示例

 /**
  * Will forward to the regular swf player according to the widget_id 
  */
 public function execute()
 {
     $entryId = $this->getRequestParameter("entry_id");
     $flavorId = $this->getRequestParameter("flavor");
     $fileName = $this->getRequestParameter("file_name");
     $ksStr = $this->getRequestParameter("ks");
     $referrer = $this->getRequestParameter("referrer");
     $referrer = base64_decode($referrer);
     if (!is_string($referrer)) {
         // base64_decode can return binary data
         $referrer = "";
     }
     // get entry
     $entry = entryPeer::retrieveByPK($entryId);
     if (is_null($entry)) {
         KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
     }
     myPartnerUtils::blockInactivePartner($entry->getPartnerId());
     $securyEntryHelper = new KSecureEntryHelper($entry, $ksStr, $referrer);
     $securyEntryHelper->validateForDownload($entry, $ksStr);
     $flavorAsset = null;
     if ($flavorId) {
         // get flavor asset
         $flavorAsset = flavorAssetPeer::retrieveById($flavorId);
         if (is_null($flavorAsset) || $flavorAsset->getStatus() != flavorAsset::FLAVOR_ASSET_STATUS_READY) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
         // the request flavor should belong to the requested entry
         if ($flavorAsset->getEntryId() != $entryId) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
     } else {
         $flavorAsset = flavorAssetPeer::retrieveBestPlayByEntryId($entry->getId());
     }
     // Gonen 26-04-2010: in case entry has no flavor with 'mbr' tag - we return the source
     if (!$flavorAsset && ($entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_VIDEO || $entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_AUDIO)) {
         $flavorAsset = flavorAssetPeer::retrieveOriginalByEntryId($entryId);
     }
     if ($flavorAsset) {
         $syncKey = $this->getSyncKeyAndForFlavorAsset($entry, $flavorAsset);
     } else {
         $syncKey = $this->getBestSyncKeyForEntry($entry);
     }
     list($fileBaseName, $fileExt) = $this->getFileName($entry, $flavorAsset);
     if (!$fileName) {
         $fileName = $fileBaseName;
     }
     if ($fileExt) {
         $fileName = $fileName . '.' . $fileExt;
     }
     if (is_null($syncKey)) {
         KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
     }
     $this->handleFileSyncRedirection($syncKey);
     $filePath = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     $this->dumpFile($filePath, $fileName);
     die;
     // no view
 }

 public static function fromThumbAsset($thumbAsset)
 {
     $fileSyncKey = $thumbAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
     $thumbPath = kFileSyncUtils::getReadyLocalFilePathForKey($fileSyncKey);
     $thumbWidth = $thumbAsset->getWidth();
     $thumbHeight = $thumbAsset->getHeight();
     return self::fromParams($thumbWidth, $thumbHeight, $thumbPath, false);
 }

 private function reconvertEntry($entry_id, $conversion_profile_id, $job_priority)
 {
     $entry = entryPeer::retrieveByPK($entry_id);
     $this->error = "";
     if (!$entry) {
         $error = "Cannot reconvert entry [{$entry_id}]. Might be a deleted entry";
         return array($entry_id, null, null, $error);
     }
     $flavorAsset = assetPeer::retrieveOriginalByEntryId($entry_id);
     if (!$flavorAsset) {
         $flavorAsset = assetPeer::retrieveReadyWebByEntryId($entry_id);
         if (!$flavorAsset) {
             $flavorAssets = assetPeer::retrieveFlavorsByEntryId($entry_id);
             if (!$flavorAssets) {
                 $error = "Cannot find good enough flavor asset to re-convert from";
                 return array($entry_id, $entry, null, $error);
             }
             $flavorAsset = $flavorAssets[0];
             // choose the first one
         }
     }
     $syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
     $filePath = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     if (!$filePath) {
         $error = "Cannot find a fileSync for the flavorAsset [" . $flavorAsset->getId() . "]";
         return array($entry_id, $entry, null, $error);
     }
     $dbBatchJob = new BatchJob();
     $dbBatchJob->setEntryId($entry_id);
     $dbBatchJob->setPartnerId($entry->getPartnerId());
     $dbBatchJob->setStatus(BatchJob::BATCHJOB_STATUS_PENDING);
     $dbBatchJob->setDc(kDataCenterMgr::getCurrentDcId());
     //$dbBatchJob->setPriority ( $job_priority ); Not supported anymore
     $dbBatchJob->setObjectId($entry_id);
     $dbBatchJob->setObjectType(BatchJobObjectType::ENTRY);
     $dbBatchJob->setJobType(BatchJobType::CONVERT_PROFILE);
     $dbBatchJob->save();
     // creates a convert profile job
     $convertProfileData = new kConvertProfileJobData();
     $convertProfileData->setFlavorAssetId($flavorAsset->getId());
     $convertProfileData->setInputFileSyncLocalPath($filePath);
     kJobsManager::addJob($dbBatchJob, $convertProfileData, BatchJobType::CONVERT_PROFILE);
     // save again afget the addJob
     $dbBatchJob->save();
     return array($entry_id, $entry, $dbBatchJob, $error);
 }

 public function getLocalThumbFilePath($version, $width, $height, $type, $bgcolor = "ffffff", $crop_provider = null, $quality = 0, $src_x = 0, $src_y = 0, $src_w = 0, $src_h = 0, $vid_sec = -1, $vid_slice = 0, $vid_slices = -1, $density = 0, $stripProfiles = false, $flavorId = null, $fileName = null)
 {
     KalturaLog::log("flavor_id [{$flavorId}] file_name [{$fileName}]");
     if (is_null($flavorId)) {
         KExternalErrors::dieError(KExternalErrors::MISSING_PARAMETER, 'flavor_id');
     }
     $flavor = assetPeer::retrieveById($flavorId);
     if (is_null($flavor)) {
         KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND, $flavorId);
     }
     $flavorSyncKey = $flavor->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
     $file_path = kFileSyncUtils::getReadyLocalFilePathForKey($flavorSyncKey);
     $orig_image_path = null;
     if (is_dir($file_path)) {
         if (is_null($fileName)) {
             KExternalErrors::dieError(KExternalErrors::MISSING_PARAMETER, 'file name');
         }
         $orig_image_path = $file_path . DIRECTORY_SEPARATOR . $fileName;
     }
     try {
         return myEntryUtils::resizeEntryImage($this, $version, $width, $height, $type, $bgcolor, $crop_provider, $quality, $src_x, $src_y, $src_w, $src_h, $vid_sec, $vid_slice, $vid_slices, $orig_image_path, $density);
     } catch (Exception $ex) {
         if ($ex->getCode() == kFileSyncException::FILE_DOES_NOT_EXIST_ON_CURRENT_DC) {
             $remoteFileSync = kFileSyncUtils::getOriginFileSyncForKey($flavorSyncKey, false);
             if (!$remoteFileSync) {
                 // file does not exist on any DC - die
                 KalturaLog::err("No FileSync for flavor [{$flavorId}]");
                 KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
             }
             if ($remoteFileSync->getDc() == kDataCenterMgr::getCurrentDcId()) {
                 KalturaLog::err("Trying to redirect to myself - stop here.");
                 KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
             }
             if (!in_array($remoteFileSync->getDc(), kDataCenterMgr::getDcIds())) {
                 KalturaLog::err("Origin file sync is on remote storage.");
                 KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
             }
             $remoteUrl = kDataCenterMgr::getRedirectExternalUrl($remoteFileSync);
             kFileUtils::dumpUrl($remoteUrl);
         }
     }
 }

 public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser)
 {
     $entry_id = $this->getP("entry_id");
     $kshow_id = $this->getP("kshow_id");
     // Make sure the request is for a ready roughcut
     $c = entryPeer::getCriteriaFilter()->getFilter();
     $c->addAnd(entryPeer::STATUS, entryStatus::READY, Criteria::EQUAL);
     list($kshow, $entry, $error, $error_obj) = myKshowUtils::getKshowAndEntry($kshow_id, $entry_id);
     if ($error_obj) {
         $this->addError($error_obj);
         return;
     }
     $version = $this->getP("version");
     // it's a path on the disk
     if (kString::beginsWith($version, ".")) {
         // someone is trying to hack in the system
         return sfView::ERROR;
     } elseif ($version == "-1") {
         $version = null;
     }
     // in case we're making a roughcut out of a regular invite, we start from scratch
     $entry_data_path = kFileSyncUtils::getLocalFilePathForKey($entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version));
     //replaced__getDataPath
     if ($entry->getMediaType() != entry::ENTRY_MEDIA_TYPE_SHOW || $entry_data_path === null) {
         $this->xml_content = "<xml></xml>";
         return;
     }
     $sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version);
     $file_name = kFileSyncUtils::getReadyLocalFilePathForKey($sync_key, false);
     // fetch content of file from disk - it should hold the XML
     if (kString::endsWith($file_name, "xml")) {
         $xml_content = kFileSyncUtils::file_get_contents($sync_key, false, false);
         if (!$xml_content) {
             $xml_content = "<xml></xml>";
         }
         myMetadataUtils::updateEntryForPending($entry, $version, $xml_content);
         $this->addMsg("metadata", $xml_content);
     } else {
         $this->addError(APIErrors::INVALID_FILE_NAME, $file_name);
     }
 }

 /**
  * Will forward to the regular swf player according to the widget_id 
  */
 public function execute()
 {
     // where file is {entryId/flavorId}.{ism,ismc,ismv}
     $objectId = $type = null;
     $objectIdStr = $this->getRequestParameter("objectId");
     if ($objectIdStr) {
         list($objectId, $type) = @explode(".", $objectIdStr);
     }
     if (!$type || !$objectId) {
         KExternalErrors::dieError(KExternalErrors::MISSING_PARAMETER);
     }
     $ks = $this->getRequestParameter("ks");
     $referrer = base64_decode($this->getRequestParameter("referrer"));
     if (!is_string($referrer)) {
         // base64_decode can return binary data
         $referrer = '';
     }
     $syncKey = $this->getFileSyncKey($objectId, $type);
     KalturaMonitorClient::initApiMonitor(false, 'extwidget.serveIsm', $this->entry->getPartnerId());
     myPartnerUtils::enforceDelivery($this->entry, $this->flavorAsset);
     if (!kFileSyncUtils::file_exists($syncKey, false)) {
         list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($syncKey, true, false);
         if (is_null($fileSync)) {
             KalturaLog::log("Error - no FileSync for type [{$type}] objectId [{$objectId}]");
             KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
         }
         $remoteUrl = kDataCenterMgr::getRedirectExternalUrl($fileSync);
         kFileUtils::dumpUrl($remoteUrl);
     }
     $path = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     if ($type == 'ism') {
         $fileData = $this->fixIsmManifestForReplacedEntry($path);
         $renderer = new kRendererString($fileData, 'image/ism');
         $renderer->output();
         KExternalErrors::dieGracefully();
     } else {
         kFileUtils::dumpFile($path);
     }
 }

 /**
  * here we'll manipulate the video asset and set the from_byte & to_byte from the milliseconds
  *
  */
 private static function fixMetadataImpl(&$xml_doc, &$total_duration, $timeline)
 {
     self::log(__METHOD__);
     /*
     	$xml_doc = new DOMDocument();
     	$xml_doc->loadXML( $content );
     */
     //		$meatadata_elem_list = $xml_doc->getElementsByTagName( "MetaData" );
     //		if ( $meatadata_elem_list != null && $meatadata_elem_list->length > 0 )
     $duration_list = $xml_doc->getElementsByTagName("SeqDuration");
     if ($duration_list != null && $duration_list->length > 0) {
         $total_duration = $duration_list->item(0)->nodeValue;
     }
     $xpath = new DOMXPath($xml_doc);
     $assets = $xpath->query($timeline == "video" ? "//VideoAssets/vidAsset" : ($timeline == "audio" ? "//AudioAssets/AudAsset" : "//VoiceAssets/voiAsset"));
     $lastTimestamp = 0;
     $real_start_byte = 0;
     // the start byte of the current clip in the final merged stream
     $calculated_total_bytes = 0;
     // use the entryPool and a 2-pass iteration to reduce the hits to the DB
     $id_list = array();
     $entry_pool = new entryPool();
     // first pass - populate the entryPool in a single request to the DB
     self::log(__METHOD__, "Before assets");
     foreach ($assets as $asset) {
         $type = $asset->getAttribute("type");
         if ($type != "VIDEO" && $type != "AUDIO") {
             continue;
         }
         // fetch the file name from the DB
         $asset_id = $asset->getAttribute("k_id");
         $id_list[] = $asset_id;
     }
     self::log(__METHOD__, "After assets", count($id_list), $id_list);
     if ($id_list) {
         $entry_pool->addEntries(entryPeer::retrieveByPKsNoFilter($id_list));
     }
     // second pass - the entryPool is supposed to already be populated
     $was_modified = false;
     foreach ($assets as $asset) {
         // fix only VIDEO assets
         $type = $asset->getAttribute("type");
         if ($type != "VIDEO" && $type != "AUDIO") {
             continue;
         }
         // fetch the file name from the DB
         $asset_id = $asset->getAttribute("k_id");
         self::log(__METHOD__, "in loop", $asset_id);
         //$entry = entryPeer::retrieveByPKNoFilter( $asset_id );
         $entry = $entry_pool->retrieveByPK($asset_id);
         // is supposed to exist already in the pool
         if ($entry == NULL) {
             // set an error on the asset element
             $asset->setAttribute("fix_status", "error in k_id [{$asset_id}]");
             $was_modified = true;
             continue;
         } elseif ($entry->getStatus() == entryStatus::DELETED) {
             // set an error on the asset element
             $asset->setAttribute("fix_status", "error in k_id [{$asset_id}] - asset was deleted");
             $was_modified = true;
             continue;
         }
         $file_name = null;
         //TODO: need to work on only an FLV asset
         $flavor_asset_play = assetPeer::retrieveBestPlayByEntryId($entry->getId());
         if (!$flavor_asset_play) {
             KalturaLog::log(__METHOD__ . ' ' . __LINE__ . ' no play flavor asset for entry ' . $entry->getId());
         } else {
             $file_name = kFileSyncUtils::getReadyLocalFilePathForKey($flavor_asset_play->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET));
         }
         $use_multi_flavor = false;
         $flv_file_name_edit = false;
         $flavor_asset_edit = assetPeer::retrieveBestEditByEntryId($entry->getId());
         if (!$flavor_asset_edit) {
             KalturaLog::log(__METHOD__ . ' ' . __LINE__ . ' no edit flavor asset for entry ' . $entry->getId());
         } else {
             $flv_file_name_edit = kFileSyncUtils::getReadyLocalFilePathForKey($flavor_asset_edit->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET));
             $use_multi_flavor = $flv_file_name_edit && file_exists($flv_file_name_edit) && $timeline == "video";
         }
         if (!$flv_file_name_edit && !$file_name) {
             KalturaLog::log(__METHOD__ . ' ' . __LINE__ . ' no edit & play flavor assets for entry ' . $entry->getId());
             continue;
         }
         $flv_file_name = kFile::fixPath($file_name);
         $stream_info_list = $asset->getElementsByTagName("StreamInfo");
         foreach ($stream_info_list as $stream_info) {
             $file_name = "?";
             try {
                 $stream_info->setAttribute("file_name", kFileSyncUtils::getReadyLocalFilePathForKey($flavor_asset_play->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET)));
                 // replaced__getDataPath
                 $start_byte = $stream_info->getAttribute("start_byte");
                 $end_byte = $stream_info->getAttribute("end_byte");
                 $total_bytes = $stream_info->getAttribute("total_bytes");
                 if ($start_byte == NULL) {
                     $start_byte = self::MISSING_VALUE;
                 }
//.........这里部分代码省略.........

 private static function getUrlAndName($entry)
 {
     $data = kFileSyncUtils::getReadyLocalFilePathForKey($entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA));
     // replaced__getDataPath
     $entry_type = self::getEntryType($entry);
     if ($entry_type->type == self::TYPE_RTMP) {
         // the url should be where the RTMP service is
         $url = self::getRTMPPath();
         // the name should start with the content directory
         // and should not include the file extension !
         $name = pathinfo($data, PATHINFO_DIRNAME) . "/" . kFile::getFileNameNoExtension($data);
     } else {
         $url = requestUtils::getHost() . $data;
         $name = pathinfo($data, PATHINFO_BASENAME);
     }
     $url_name = new urlName();
     $url_name->url = $url;
     $url_name->name = $name;
     return $url_name;
 }

 /**
  * Will forward to the regular swf player according to the widget_id 
  */
 public function execute()
 {
     $entryId = $this->getRequestParameter("entry_id");
     $flavorId = $this->getRequestParameter("flavor");
     $fileName = $this->getRequestParameter("file_name");
     $fileName = basename($fileName);
     $ksStr = $this->getRequestParameter("ks");
     $referrer = $this->getRequestParameter("referrer");
     $referrer = base64_decode($referrer);
     if (!is_string($referrer)) {
         // base64_decode can return binary data
         $referrer = "";
     }
     $entry = null;
     if ($ksStr) {
         try {
             kCurrentContext::initKsPartnerUser($ksStr);
         } catch (Exception $ex) {
             KExternalErrors::dieError(KExternalErrors::INVALID_KS);
         }
     } else {
         $entry = kCurrentContext::initPartnerByEntryId($entryId);
         if (!$entry) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     }
     kEntitlementUtils::initEntitlementEnforcement();
     if (!$entry) {
         $entry = entryPeer::retrieveByPK($entryId);
         if (!$entry) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     } else {
         if (!kEntitlementUtils::isEntryEntitled($entry)) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     }
     myPartnerUtils::blockInactivePartner($entry->getPartnerId());
     $securyEntryHelper = new KSecureEntryHelper($entry, $ksStr, $referrer, accessControlContextType::DOWNLOAD);
     $securyEntryHelper->validateForDownload($entry, $ksStr);
     $flavorAsset = null;
     if ($flavorId) {
         // get flavor asset
         $flavorAsset = assetPeer::retrieveById($flavorId);
         if (is_null($flavorAsset) || $flavorAsset->getStatus() != flavorAsset::FLAVOR_ASSET_STATUS_READY) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
         // the request flavor should belong to the requested entry
         if ($flavorAsset->getEntryId() != $entryId) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
     } else {
         $flavorAsset = assetPeer::retrieveBestPlayByEntryId($entry->getId());
     }
     // Gonen 26-04-2010: in case entry has no flavor with 'mbr' tag - we return the source
     if (!$flavorAsset && ($entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_VIDEO || $entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_AUDIO)) {
         $flavorAsset = assetPeer::retrieveOriginalByEntryId($entryId);
     }
     if ($flavorAsset) {
         $syncKey = $this->getSyncKeyAndForFlavorAsset($entry, $flavorAsset);
     } else {
         $syncKey = $this->getBestSyncKeyForEntry($entry);
     }
     if (is_null($syncKey)) {
         KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
     }
     $this->handleFileSyncRedirection($syncKey);
     $filePath = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     $wamsAssetId = kFileSyncUtils::getWamsAssetIdForKey($syncKey);
     $wamsURL = kFileSyncUtils::getWamsURLForKey($syncKey);
     list($fileBaseName, $fileExt) = $this->getFileName($entry, $flavorAsset);
     if (!$fileName) {
         $fileName = $fileBaseName;
     }
     if ($fileExt && !is_dir($filePath)) {
         $fileName = $fileName . '.' . $fileExt;
     }
     //enable downloading file_name which inside the flavor asset directory
     if (is_dir($filePath)) {
         $filePath = $filePath . DIRECTORY_SEPARATOR . $fileName;
     }
     $this->dumpFile($filePath, $fileName, $wamsAssetId, $wamsURL);
     die;
     // no view
 }

 /**
  * Will forward to the regular swf player according to the widget_id 
  */
 public function execute()
 {
     // where file is {entryId/flavorId}.{ism,ismc,ismv}
     $objectId = $type = null;
     $objectIdStr = $this->getRequestParameter("objectId");
     list($objectId, $type) = @explode(".", $objectIdStr);
     if (!$type || !$objectId) {
         die;
     }
     $ks = $this->getRequestParameter("ks");
     $referrer = base64_decode($this->getRequestParameter("referrer"));
     if (!is_string($referrer)) {
         // base64_decode can return binary data
         $referrer = '';
     }
     if ($type == "ism" || $type == "ismc") {
         // backward compatiblity - to be removed once ismc is created with pure objectId.ext instead of entryId_flavorId_version.ext
         if (strlen($objectId) != 10) {
             $version = substr($objectId, 13);
             $objectId = substr($objectId, 0, 10);
         } else {
             $version = null;
         }
         $entry = entryPeer::retrieveByPK($objectId);
         if (is_null($entry)) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
         $syncKey = $entry->getSyncKey($type == "ism" ? entry::FILE_SYNC_ENTRY_SUB_TYPE_ISM : entry::FILE_SYNC_ENTRY_SUB_TYPE_ISMC, $version);
     } else {
         if ($type == "ismv") {
             // backward compatiblity - to be removed once ismc is created with pure objectId.ext instead of entryId_flavorId_version.ext
             if (strlen($objectId) != 10) {
                 $version = substr($objectId, 22);
                 $objectId = substr($objectId, 11, 10);
             } else {
                 $version = null;
             }
             $flavorAsset = flavorAssetPeer::retrieveById($objectId);
             if (is_null($flavorAsset)) {
                 KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
             }
             $entry = entryPeer::retrieveByPK($flavorAsset->getEntryId());
             if (is_null($entry)) {
                 KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
             }
             $syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET, $version);
         } else {
             die;
         }
     }
     if (!kFileSyncUtils::file_exists($syncKey, false)) {
         list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($syncKey, true, false);
         if (is_null($fileSync)) {
             KalturaLog::log("Error - no FileSync for type [{$type}] objectId [{$objectId}]");
             KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
         }
         $remoteUrl = kDataCenterMgr::getRedirectExternalUrl($fileSync);
         kFile::dumpUrl($remoteUrl);
     }
     $path = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     kFile::dumpFile($path);
 }

 public static function resizeEntryImage(entry $entry, $version, $width, $height, $type, $bgcolor = "ffffff", $crop_provider = null, $quality = 0, $src_x = 0, $src_y = 0, $src_w = 0, $src_h = 0, $vid_sec = -1, $vid_slice = 0, $vid_slices = -1, $orig_image_path = null)
 {
     $contentPath = myContentStorage::getFSContentRootPath();
     $entry_status = $entry->getStatus();
     $tempThumbName = $entry->getId() . "_{$width}_{$height}_{$type}_{$crop_provider}_{$bgcolor}_{$quality}_{$src_x}_{$src_y}_{$src_w}_{$src_h}_{$vid_sec}_{$vid_slice}_{$vid_slices}_{$entry_status}";
     $entryThumbFilename = $entry->getThumbnail() ? $entry->getThumbnail() : "0.jpg";
     if ($entry->getStatus() != entryStatus::READY || @$entryThumbFilename[0] == '&') {
         $tempThumbName .= "_NOCACHE_";
     }
     // we remove the & from the template thumb otherwise getGeneralEntityPath will drop $tempThumbName from the final path
     $entryThumbFilename = str_replace("&", "", $entryThumbFilename);
     $basePath = myContentStorage::getGeneralEntityPath("entry/tempthumb", $entry->getIntId(), $tempThumbName, $entryThumbFilename, $version);
     $tempThumbPath = $contentPath . $basePath;
     $cachedTempThumbPath = myContentStorage::getFSCacheRootPath() . $basePath;
     if (file_exists($cachedTempThumbPath)) {
         header("X-Kaltura:cached-local-thumb-exists," . md5($cachedTempThumbPath));
         return $cachedTempThumbPath;
     }
     if (file_exists($tempThumbPath)) {
         header("X-Kaltura:cached-thumb-exists," . md5($tempThumbPath));
         return $tempThumbPath;
     }
     if ($orig_image_path === null || !file_exists($orig_image_path)) {
         $sub_type = $entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_IMAGE ? entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA : entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB;
         $orig_image_key = $entry->getSyncKey($sub_type, $version);
         $orig_image_path = kFileSyncUtils::getReadyLocalFilePathForKey($orig_image_key);
     }
     // remark added so ffmpeg will try to load the thumbnail from the original source
     //if (!file_exists($orig_image_path))
     //	KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
     // check a request for animated thumbs without a concrete vid_slice
     // in which case we'll create all the frames as one wide image
     $multi = $vid_slice == -1 && $vid_slices != -1;
     $count = $multi ? $vid_slices : 1;
     $im = null;
     if ($multi) {
         $vid_slice = 0;
     }
     while ($count--) {
         if ($entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_VIDEO && ($vid_sec != -1 || $vid_slices != -1) || !file_exists($orig_image_path)) {
             if ($vid_sec != -1) {
                 $calc_vid_sec = min($vid_sec, floor($entry->getLengthInMsecs() / 1000));
             } else {
                 if ($vid_slices != -1) {
                     $calc_vid_sec = floor($entry->getLengthInMsecs() / $vid_slices * min($vid_slice, $vid_slices) / 1000);
                 } else {
                     if ($entry->getStatus() != entryStatus::READY && $entry->getLengthInMsecs() == 0) {
                         $calc_vid_sec = $entry->getPartner() && $entry->getPartner()->getDefThumbOffset() ? $entry->getPartner()->getDefThumbOffset() : 3;
                     } else {
                         $calc_vid_sec = $entry->getBestThumbOffset();
                     }
                 }
             }
             $capturedThumbName = $entry->getId() . "_sec_{$calc_vid_sec}";
             $capturedThumbPath = $contentPath . myContentStorage::getGeneralEntityPath("entry/tempthumb", $entry->getIntId(), $capturedThumbName, $entry->getThumbnail(), $version);
             $orig_image_path = $capturedThumbPath . "temp_1.jpg";
             // if we already captured the frame at that second, dont recapture, just use the existing file
             if (!file_exists($orig_image_path)) {
                 // creating the thumbnail is a very heavy operation
                 // prevent calling it in parallel for the same thubmnail for 5 minutes
                 $cache = new myCache("thumb-processing", 5 * 60);
                 // 5 minutes
                 $processing = $cache->get($orig_image_path);
                 if ($processing) {
                     KExternalErrors::dieError(KExternalErrors::PROCESSING_CAPTURE_THUMBNAIL);
                 }
                 $cache->put($orig_image_path, true);
                 $flavorAsset = flavorAssetPeer::retrieveOriginalReadyByEntryId($entry->getId());
                 if (is_null($flavorAsset) || !($flavorAsset->hasTag(flavorParams::TAG_MBR) || $flavorAsset->hasTag(flavorParams::TAG_WEB))) {
                     // try the best playable
                     $flavorAsset = flavorAssetPeer::retrieveHighestBitrateByEntryId($entry->getId());
                 }
                 if (is_null($flavorAsset)) {
                     // if no READY ORIGINAL entry is available, try to retreive a non-READY ORIGINAL entry
                     $flavorAsset = flavorAssetPeer::retreiveOriginalByEntryId($entry->getId());
                 }
                 if (is_null($flavorAsset)) {
                     KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
                 }
                 $flavorSyncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
                 $entry_data_path = kFileSyncUtils::getReadyLocalFilePathForKey($flavorSyncKey);
                 if (!$entry_data_path) {
                     // since this is not really being processed on this server, and will probably cause redirect in thumbnailAction
                     // remove from cache so later requests will still get redirected and will not fail on PROCESSING_CAPTURE_THUMBNAIL
                     $cache->remove($orig_image_path);
                     throw new kFileSyncException('no ready filesync on current DC', kFileSyncException::FILE_DOES_NOT_EXIST_ON_CURRENT_DC);
                 }
                 myFileConverter::autoCaptureFrame($entry_data_path, $capturedThumbPath . "temp_", $calc_vid_sec, -1, -1);
                 $cache->remove($orig_image_path);
             }
         }
         kFile::fullMkdir($tempThumbPath);
         if ($crop_provider) {
             $convertedImagePath = myFileConverter::convertImageUsingCropProvider($orig_image_path, $tempThumbPath, $width, $height, $type, $crop_provider, $bgcolor, true, $quality, $src_x, $src_y, $src_w, $src_h);
         } else {
             $convertedImagePath = myFileConverter::convertImage($orig_image_path, $tempThumbPath, $width, $height, $type, $bgcolor, true, $quality, $src_x, $src_y, $src_w, $src_h);
         }
         // die if resize operation failed
         if ($convertedImagePath === null) {
             KExternalErrors::dieError(KExternalErrors::IMAGE_RESIZE_FAILED);
//.........这里部分代码省略.........

 public function execute()
 {
     requestUtils::handleConditionalGet();
     // set the memory size to be able to serve big files in a single chunk
     ini_set("memory_limit", "64M");
     // set the execution time to be able to serve big files in a single chunk
     ini_set("max_execution_time", 240);
     $meta = $this->getRequestParameter("meta", false);
     $file_info = $this->getRequestParameter("file_info");
     $this->entry_id = 0;
     $this->kshow_id = 0;
     $version = $this->getRequestParameter("version", null);
     // returned the version feature to allow rollback
     $addPadding = false;
     if (!empty($file_info)) {
         $file_info_arr = explode("-", $file_info);
         // the format of file_info is assumed <kshow_id>-<video|audio|voice>-<1|2|3>
         // OR
         // e<entry_id>-<video|audio|voice>-<1|2|3>
         if (count($file_info_arr) == 0) {
             $this->error = "Invalid request format [{$file_info}]";
             return sfView::ERROR;
         }
         if ($file_info_arr[0][0] == 'e') {
             $this->entry_id = substr($file_info_arr[0], 1);
         } else {
             $this->kshow_id = $file_info_arr[0];
         }
         if (count($file_info_arr) == 1) {
             // on this case we assume that the single info parameter is an entry id
             // we redirect to it !
             $entry = entryPeer::retrieveByPK($this->entry_id);
             if (!$entry) {
                 // very bad - no such entry !!
                 echo "no entry " . $this->entry_id;
                 die;
             }
             $dataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
             // replaced__getDataPath
             $path = kFileSyncUtils::getReadyLocalFilePathForKey($dataKey);
             $host = requestUtils::getHost();
             $this->redirect($host . $path);
         }
         $this->timeline = $file_info_arr[1];
         if (count($file_info_arr) > 2) {
             // this migth include a .flv suffix
             $last_token = $file_info_arr[2];
             $last_token_srr = explode(".", $last_token);
             $this->streamNum = $last_token_srr[0];
             if (count($file_info_arr) > 3) {
                 $version = $file_info_arr[3];
             }
             if (count($file_info_arr) > 4 && $file_info_arr[4] == "padding") {
                 $addPadding = true;
             }
         } else {
             $this->streamNum = 3;
         }
     } else {
         $this->kshow_id = @$_GET["kshow_id"];
         $this->entry_id = @$_GET["entry_id"];
         $this->timeline = @$_GET["timeline"];
         $this->streamNum = $this->getRequestParameter('num', 3);
     }
     $entry = null;
     if ($this->entry_id) {
         $entry = entryPeer::retrieveByPK($this->entry_id);
         if (!$entry) {
             $this->error = "No such entry " . $this->entry_id;
             return sfView::ERROR;
         }
         $this->kshow_id = $entry->getKshowId();
     }
     $kshow = kshowPeer::retrieveByPK($this->kshow_id);
     if (!$kshow) {
         $this->error = "No such kshow " . $this->kshow_id;
         return sfView::ERROR;
     }
     if (!$entry) {
         // if we received only the kshow (old widgets) retrieve the entry
         $entry = entryPeer::retrieveByPK($kshow->getShowEntryId());
     }
     if (!$entry) {
         $this->error = "No such entry for kshow " . $this->kshow_id;
         return sfView::ERROR;
     }
     // update the widget log only for video && stream 1
     if ($this->timeline == "video" && $this->streamNum == 1) {
         $referer = @$_SERVER['HTTP_REFERER'];
         //since we're using a cdn this is useless
         //$kshow->incPlays();
         //WidgetLog::incPlaysIfExists( $this->kshow_id , $this->entry_id );
     }
     $dataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version);
     // replaced__getDataPath
     $path = kFileSyncUtils::getReadyLocalFilePathForKey($dataKey);
     $this->flv_streamer = new myFlvStreamer($path, $this->timeline, $this->streamNum, $addPadding);
     $this->total_length = $this->flv_streamer->getTotalLength(true);
     // $total_length;
     //$this->getController()->setRenderMode ( sfView::RENDER_CLIENT );
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                 }
                 if (count($extra_user_entries)) {
                     $kuser_entry_list = array_merge($extra_user_entries, $kuser_entry_list);
                 }
             }
         } else {
             $kuser_entry_list = array();
         }
         if ($merge_entry_lists) {
             $kshow_entry_list = kArray::append($kshow_entry_list, $kuser_entry_list);
             $kuser_entry_list = null;
         }
     }
     $this->benchmarkEnd("list_type_kuser");
     $this->benchmarkStart("list_type_episode");
     if ($list_type & self::LIST_TYPE_EPISODE) {
         if ($kshow && $kshow->getEpisodeId()) {
             // episode_id will point to the "parent" kshow
             // fetch the entries of the parent kshow
             $c = new Criteria();
             $c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
             //				$c->addAnd ( entryPeer::MEDIA_TYPE , entry::ENTRY_MEDIA_TYPE_SHOW , Criteria::NOT_EQUAL );
             $c->addAnd(entryPeer::KSHOW_ID, $kshow->getEpisodeId());
             $this->addIgnoreIdList($c, $aggrigate_id_list);
             //				$this->addOffsetAndLimit ( $c ); // limit the number of the inherited entries from the episode
             if ($disable_user_data) {
                 $parent_kshow_entries = entryPeer::doSelect($c);
             } else {
                 $parent_kshow_entries = entryPeer::doSelectJoinkuser($c);
             }
             if (count($parent_kshow_entries)) {
                 $kshow_entry_list = kArray::append($kshow_entry_list, $parent_kshow_entries);
             }
         }
     }
     $this->benchmarkEnd("list_type_episode");
     // fetch all entries that were used in the roughcut - those of other kusers
     // - appeared under kuser_entry_list when someone else logged in
     $this->benchmarkStart("list_type_roughcut");
     $entry_data_from_roughcut_map = array();
     // will hold an associative array where the id is the key
     if ($list_type & self::LIST_TYPE_ROUGHCUT) {
         if ($entry->getType() == entryType::MIX) {
             $sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version);
             $roughcut_file_name = kFileSyncUtils::getReadyLocalFilePathForKey($sync_key);
             $entry_data_from_roughcut = myFlvStreamer::getAllAssetsData($roughcut_file_name);
             $final_id_list = array();
             foreach ($entry_data_from_roughcut as $data) {
                 $id = $data["id"];
                 // first element is the id
                 $entry_data_from_roughcut_map[] = $data;
                 $found = false;
                 foreach ($kshow_entry_list as $entry) {
                     // see we are not fetching duplicate entries
                     if ($entry->getId() == $id) {
                         $found = true;
                         break;
                     }
                 }
                 if (!$found) {
                     $final_id_list[] = $id;
                 }
             }
             if (count($final_id_list) > 0) {
                 // allow deleted entries when searching for entries on the roughcut
                 // don't forget to return the status at the end of the process
                 entryPeer::allowDeletedInCriteriaFilter();
                 $c = new Criteria();
                 $c->addAnd(entryPeer::ID, $final_id_list, Criteria::IN);
                 $c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
                 $this->addIgnoreIdList($c, $aggrigate_id_list);
                 //				$this->addOffsetAndLimit ( $c );
                 if ($disable_user_data) {
                     $extra_entries = entryPeer::doSelect($c);
                 } else {
                     $extra_entries = entryPeer::doSelectJoinkuser($c);
                 }
                 // return the status to the criteriaFilter
                 entryPeer::blockDeletedInCriteriaFilter();
                 // merge the 2 lists into 1:
                 $kshow_entry_list = kArray::append($kshow_entry_list, $extra_entries);
             }
         }
     }
     $this->benchmarkEnd("list_type_roughcut");
     $this->benchmarkStart("create_wrapper");
     $entry_wrapper = objectWrapperBase::getWrapperClass($kshow_entry_list, objectWrapperBase::DETAIL_LEVEL_REGULAR, -3, 0, array("contributorScreenName"));
     //$entry_wrapper->addFields ( array ( "kuser.screenName" ) );
     $this->addMsg("show", $entry_wrapper);
     // if ! $disable_roughcut_entry_data - add the roughcut_entry_data
     if (!$disable_roughcut_entry_data) {
         $this->addMsg("roughcut_entry_data", $entry_data_from_roughcut_map);
     }
     if (count($kuser_entry_list) > 0) {
         $this->addMsg("user", objectWrapperBase::getWrapperClass($kuser_entry_list, objectWrapperBase::DETAIL_LEVEL_REGULAR));
     } else {
         $this->addMsg("user", null);
     }
     $this->benchmarkEnd("create_wrapper");
 }

 /**
  * Get all ready media entries that exist in the given mix id
  *
  * @action getReadyMediaEntries
  * @param string $mixId
  * @param int $version Desired version to get the data from
  * @return KalturaMediaEntryArray
  */
 public function getReadyMediaEntriesAction($mixId, $version = -1)
 {
     $dbEntry = entryPeer::retrieveByPK($mixId);
     if (!$dbEntry || $dbEntry->getType() != KalturaEntryType::MIX) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $mixId);
     }
     $dataSyncKey = $dbEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
     $mixFileName = kFileSyncUtils::getReadyLocalFilePathForKey($dataSyncKey, false);
     if (!$mixFileName) {
         KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
     }
     $entryDataFromMix = myFlvStreamer::getAllAssetsData($mixFileName);
     $ids = array();
     foreach ($entryDataFromMix as $data) {
         $ids[] = $data["id"];
     }
     $c = KalturaCriteria::create(entryPeer::OM_CLASS);
     $c->addAnd(entryPeer::ID, $ids, Criteria::IN);
     $c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
     $dbEntries = entryPeer::doSelect($c);
     $mediaEntries = KalturaMediaEntryArray::fromEntryArray($dbEntries);
     return $mediaEntries;
 }

 /**
  * Will forward to the regular swf player according to the widget_id 
  */
 public function execute()
 {
     $entryId = $this->getRequestParameter("entry_id");
     $flavorId = $this->getRequestParameter("flavor");
     $fileName = $this->getRequestParameter("file_name");
     $fileName = basename($fileName);
     $ksStr = $this->getRequestParameter("ks");
     $referrer = $this->getRequestParameter("referrer");
     $referrer = base64_decode($referrer);
     if (!is_string($referrer)) {
         // base64_decode can return binary data
         $referrer = "";
     }
     $entry = null;
     if ($ksStr) {
         try {
             kCurrentContext::initKsPartnerUser($ksStr);
         } catch (Exception $ex) {
             KExternalErrors::dieError(KExternalErrors::INVALID_KS);
         }
     } else {
         $entry = kCurrentContext::initPartnerByEntryId($entryId);
         if (!$entry) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     }
     kEntitlementUtils::initEntitlementEnforcement();
     if (!$entry) {
         $entry = entryPeer::retrieveByPK($entryId);
         if (!$entry) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     } else {
         if (!kEntitlementUtils::isEntryEntitled($entry)) {
             KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
         }
     }
     KalturaMonitorClient::initApiMonitor(false, 'extwidget.download', $entry->getPartnerId());
     myPartnerUtils::blockInactivePartner($entry->getPartnerId());
     $shouldPreview = false;
     $securyEntryHelper = new KSecureEntryHelper($entry, $ksStr, $referrer, ContextType::DOWNLOAD);
     if ($securyEntryHelper->shouldPreview()) {
         $shouldPreview = true;
     } else {
         $securyEntryHelper->validateForDownload();
     }
     $flavorAsset = null;
     if ($flavorId) {
         // get flavor asset
         $flavorAsset = assetPeer::retrieveById($flavorId);
         if (is_null($flavorAsset) || !$flavorAsset->isLocalReadyStatus()) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
         // the request flavor should belong to the requested entry
         if ($flavorAsset->getEntryId() != $entryId) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
         if (!$securyEntryHelper->isAssetAllowed($flavorAsset)) {
             KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
         }
     } else {
         $flavorAssets = assetPeer::retrieveReadyWebByEntryId($entry->getId());
         foreach ($flavorAssets as $curFlavorAsset) {
             if ($securyEntryHelper->isAssetAllowed($curFlavorAsset)) {
                 $flavorAsset = $curFlavorAsset;
                 break;
             }
         }
     }
     // Gonen 26-04-2010: in case entry has no flavor with 'mbr' tag - we return the source
     if (!$flavorAsset && ($entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_VIDEO || $entry->getMediaType() == entry::ENTRY_MEDIA_TYPE_AUDIO)) {
         $flavorAsset = assetPeer::retrieveOriginalByEntryId($entryId);
         if (!$securyEntryHelper->isAssetAllowed($flavorAsset)) {
             $flavorAsset = null;
         }
     }
     if ($flavorAsset) {
         $syncKey = $this->getSyncKeyAndForFlavorAsset($entry, $flavorAsset);
     } else {
         $syncKey = $this->getBestSyncKeyForEntry($entry);
     }
     if (is_null($syncKey)) {
         KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
     }
     $this->handleFileSyncRedirection($syncKey);
     $filePath = kFileSyncUtils::getReadyLocalFilePathForKey($syncKey);
     list($fileBaseName, $fileExt) = kAssetUtils::getFileName($entry, $flavorAsset);
     if (!$fileName) {
         $fileName = $fileBaseName;
     }
     if ($fileExt && !is_dir($filePath)) {
         $fileName = $fileName . '.' . $fileExt;
     }
     $preview = 0;
     if ($shouldPreview && $flavorAsset) {
         $preview = $flavorAsset->estimateFileSize($entry, $securyEntryHelper->getPreviewLength());
     } else {
//.........这里部分代码省略.........