public function validateApiAccessControl()
{
$partner = $this->entry->getPartner();
if ($partner && !$partner->validateApiAccessControl()) {
KExternalErrors::dieError(KExternalErrors::SERVICE_ACCESS_CONTROL_RESTRICTED);
}
}
/**
* decideThumbGenerate is the decision layer for a single thumbnail generation
*
* @param entry $entry
* @param thumbParams $destThumbParams
* @param BatchJob $parentJob
* @return thumbAsset
*/
public static function decideThumbGenerate(entry $entry, thumbParams $destThumbParams, BatchJob $parentJob = null, $sourceAssetId = null, $runSync = false, $srcAsset = null)
{
if (is_null($srcAsset)) {
$srcAsset = self::getSourceAssetForGenerateThumbnail($sourceAssetId, $destThumbParams->getSourceParamsId(), $entry->getId());
if (is_null($srcAsset)) {
throw new APIException(APIErrors::FLAVOR_ASSET_IS_NOT_READY);
}
}
$errDescription = null;
$mediaInfo = mediaInfoPeer::retrieveByFlavorAssetId($srcAsset->getId());
$destThumbParamsOutput = self::validateThumbAndMediaInfo($destThumbParams, $mediaInfo, $errDescription);
if ($srcAsset->getType() == assetType::FLAVOR && is_null($destThumbParamsOutput->getVideoOffset())) {
$destThumbParamsOutput->setVideoOffset($entry->getThumbOffset());
}
$destThumbParamsOutput->setVideoOffset(min($destThumbParamsOutput->getVideoOffset(), $entry->getDuration()));
if (!$destThumbParamsOutput->getDensity()) {
$partner = $entry->getPartner();
if (!is_null($partner)) {
$destThumbParamsOutput->setDensity($partner->getDefThumbDensity());
}
}
$thumbAsset = assetPeer::retrieveByEntryIdAndParams($entry->getId(), $destThumbParams->getId());
if ($thumbAsset) {
$description = $thumbAsset->getDescription() . "\n" . $errDescription;
$thumbAsset->setDescription($description);
} else {
$thumbAsset = new thumbAsset();
$thumbAsset->setPartnerId($entry->getPartnerId());
$thumbAsset->setEntryId($entry->getId());
$thumbAsset->setDescription($errDescription);
$thumbAsset->setFlavorParamsId($destThumbParams->getId());
}
$thumbAsset->incrementVersion();
$thumbAsset->setTags($destThumbParamsOutput->getTags());
$thumbAsset->setFileExt($destThumbParamsOutput->getFileExt());
if ($thumbAsset->getStatus() != asset::ASSET_STATUS_READY) {
$thumbAsset->setStatus(asset::ASSET_STATUS_CONVERTING);
}
//Sets the default thumb if this the only default thumb
kBusinessPreConvertDL::setIsDefaultThumb($thumbAsset);
if (!$destThumbParamsOutput) {
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->save();
return null;
}
$thumbAsset->save();
// save flavor params
$destThumbParamsOutput->setPartnerId($entry->getPartnerId());
$destThumbParamsOutput->setEntryId($entry->getId());
$destThumbParamsOutput->setFlavorAssetId($thumbAsset->getId());
$destThumbParamsOutput->setFlavorAssetVersion($thumbAsset->getVersion());
$destThumbParamsOutput->save();
$srcSyncKey = $srcAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$srcAssetType = $srcAsset->getType();
if (!$runSync) {
$job = kJobsManager::addCapturaThumbJob($parentJob, $entry->getPartnerId(), $entry->getId(), $thumbAsset->getId(), $srcSyncKey, $srcAsset->getId(), $srcAssetType, $destThumbParamsOutput);
return $thumbAsset;
}
$errDescription = null;
// Since this method is called when trying to crop an existing thumbnail, need to add this check - thumbAssets have no mediaInfo.
$capturedPath = self::generateThumbnail($srcAsset, $destThumbParamsOutput, $errDescription, $mediaInfo ? $mediaInfo->getVideoRotation() : null);
// failed
if (!$capturedPath) {
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->setDescription($thumbAsset->getDescription() . "\n{$errDescription}");
$thumbAsset->save();
return $thumbAsset;
}
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_READY);
if (file_exists($capturedPath)) {
list($width, $height, $type, $attr) = getimagesize($capturedPath);
$thumbAsset->setWidth($width);
$thumbAsset->setHeight($height);
$thumbAsset->setSize(filesize($capturedPath));
}
$logPath = $capturedPath . '.log';
if (file_exists($logPath)) {
$thumbAsset->incLogFileVersion();
$thumbAsset->save();
// creats the file sync
$logSyncKey = $thumbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_CONVERT_LOG);
kFileSyncUtils::moveFromFile($logPath, $logSyncKey);
KalturaLog::debug("Log archived file to: " . kFileSyncUtils::getLocalFilePathForKey($logSyncKey));
} else {
$thumbAsset->save();
}
$syncKey = $thumbAsset->getSyncKey(thumbAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($capturedPath, $syncKey);
KalturaLog::debug("Thumbnail archived file to: " . kFileSyncUtils::getLocalFilePathForKey($syncKey));
if ($thumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
// increment thumbnail version
$entry->setThumbnail(".jpg");
$entry->setCreateThumb(false);
$entry->save();
$entrySyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
$syncFile = kFileSyncUtils::createSyncFileLinkForKey($entrySyncKey, $syncKey);
if ($syncFile) {
// removes the DEFAULT_THUMB tag from all other thumb assets
$entryThumbAssets = assetPeer::retrieveThumbnailsByEntryId($thumbAsset->getEntryId());
foreach ($entryThumbAssets as $entryThumbAsset) {
if ($entryThumbAsset->getId() == $thumbAsset->getId()) {
continue;
}
if (!$entryThumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
continue;
}
$entryThumbAsset->removeTags(array(thumbParams::TAG_DEFAULT_THUMB));
$entryThumbAsset->save();
}
}
}
if (!is_null($thumbAsset->getFlavorParamsId())) {
kFlowHelper::generateThumbnailsFromFlavor($thumbAsset->getEntryId(), null, $thumbAsset->getFlavorParamsId());
}
return $thumbAsset;
}
public function execute()
{
$this->entryId = $this->getRequestParameter("entryId", null);
$this->flavorId = $this->getRequestParameter("flavorId", null);
$this->storageId = $this->getRequestParameter("storageId", null);
$this->maxBitrate = $this->getRequestParameter("maxBitrate", null);
$flavorIdsStr = $this->getRequestParameter("flavorIds", null);
if ($flavorIdsStr) {
$this->flavorIds = explode(",", $flavorIdsStr);
}
$this->entry = entryPeer::retrieveByPKNoFilter($this->entryId);
if (!$this->entry) {
KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
}
if (!$this->flavorId) {
$flavorParamId = $this->getRequestParameter("flavorParamId", null);
if ($flavorParamId) {
$flavorAsset = flavorAssetPeer::retrieveByEntryIdAndFlavorParams($entry->getId(), $flavorParamId);
if (!$flavorAsset) {
KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
}
$this->flavorId = $flavorAsset->getId();
}
}
$this->validateStorageId();
$this->protocol = $this->getRequestParameter("protocol", null);
if (!$this->protocol) {
$this->protocol = StorageProfile::PLAY_FORMAT_HTTP;
}
$this->format = $this->getRequestParameter("format");
if (!$this->format) {
$this->format = StorageProfile::PLAY_FORMAT_HTTP;
}
$this->cdnHost = $this->getRequestParameter("cdnHost", null);
$partner = $this->entry->getPartner();
if (!$this->cdnHost || $partner->getForceCdnHost()) {
$this->cdnHost = myPartnerUtils::getCdnHost($this->entry->getPartnerId(), $this->protocol);
}
if ($this->maxBitrate && (!is_numeric($this->maxBitrate) || $this->maxBitrate <= 0)) {
KExternalErrors::dieError(KExternalErrors::INVALID_MAX_BITRATE);
}
$ksStr = $this->getRequestParameter("ks");
$base64Referrer = $this->getRequestParameter("referrer");
$referrer = base64_decode($base64Referrer);
if (!is_string($referrer)) {
$referrer = "";
}
// base64_decode can return binary data
$securyEntryHelper = new KSecureEntryHelper($this->entry, $ksStr, $referrer);
if ($securyEntryHelper->shouldPreview()) {
$this->clipTo = $securyEntryHelper->getPreviewLength() * 1000;
} else {
$securyEntryHelper->validateForPlay($this->entry, $ksStr);
}
// grab seekFrom parameter and normalize url
$this->seekFrom = $this->getRequestParameter("seekFrom", -1);
if ($this->seekFrom <= 0) {
$this->seekFrom = -1;
}
if ($this->entry->getStatus() == entryStatus::DELETED) {
// because the fiter was turned off - a manual check for deleted entries must be done.
die;
}
$xml = null;
switch ($this->format) {
case StorageProfile::PLAY_FORMAT_HTTP:
$xml = $this->serveHttp();
break;
case StorageProfile::PLAY_FORMAT_RTMP:
$xml = $this->serveRtmp();
break;
case StorageProfile::PLAY_FORMAT_SILVER_LIGHT:
$xml = $this->serveSilverLight();
break;
case StorageProfile::PLAY_FORMAT_APPLE_HTTP:
$xml = $this->serveAppleHttp();
break;
case "url":
return $this->serveUrl();
break;
case "hdnetworksmil":
$xml = $this->serveHDNetwork();
break;
case "hdnetwork":
$duration = $this->entry->getDurationInt();
$mediaUrl = "<media url=\"" . requestUtils::getHost() . str_replace("f4m", "smil", str_replace("hdnetwork", "hdnetworksmil", $_SERVER["REQUEST_URI"])) . "\"/>";
$xml = $this->buildXml(self::PLAY_STREAM_TYPE_RECORDED, array(), 'video/x-flv', $duration, null, $mediaUrl);
break;
}
if ($this->format == StorageProfile::PLAY_FORMAT_APPLE_HTTP) {
header("Content-Type: text/plain; charset=UTF-8");
} else {
header("Content-Type: text/xml; charset=UTF-8");
header("Content-Disposition: inline; filename=manifest.xml");
}
echo $xml;
die;
}
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);
}
if ($multi) {
list($w, $h, $type, $attr, $srcIm) = myFileConverter::createImageByFile($tempThumbPath);
if (!$im) {
$im = imagecreatetruecolor($w * $vid_slices, $h);
}
imagecopy($im, $srcIm, $w * $vid_slice, 0, 0, 0, $w, $h);
imagedestroy($srcIm);
++$vid_slice;
}
}
if ($multi) {
imagejpeg($im, $tempThumbPath);
imagedestroy($im);
}
return $tempThumbPath;
}
/**
* @param BatchJob $batchJob
* @param entry $entry
* @param string $flavorAssetId
* @param string $inputFileSyncLocalPath
* @return BatchJob
*/
public static function addConvertProfileJob(BatchJob $parentJob = null, entry $entry, $flavorAssetId, $inputFileSyncLocalPath)
{
KalturaLog::debug("Parent job [" . ($parentJob ? $parentJob->getId() : 'none') . "] entry [" . $entry->getId() . "] flavor asset [{$flavorAssetId}] input file [{$inputFileSyncLocalPath}]");
if ($entry->getConversionQuality() == conversionProfile2::CONVERSION_PROFILE_NONE) {
$entry->setStatus(entryStatus::PENDING);
$entry->save();
KalturaLog::notice('Entry should not be converted');
return null;
}
$importingSources = false;
// if file size is 0, do not create conversion profile and set entry status as error converting
if (!file_exists($inputFileSyncLocalPath) || kFile::fileSize($inputFileSyncLocalPath) == 0) {
KalturaLog::debug("Input file [{$inputFileSyncLocalPath}] does not exist");
$partner = $entry->getPartner();
$conversionProfile = myPartnerUtils::getConversionProfile2ForEntry($entry->getId());
// load the asset params to the instance pool
$flavorIds = flavorParamsConversionProfilePeer::getFlavorIdsByProfileId($conversionProfile->getId());
assetParamsPeer::retrieveByPKs($flavorIds);
$conversionRequired = false;
$sourceFileRequiredStorages = array();
$sourceIncludedInProfile = false;
$flavorAsset = assetPeer::retrieveById($flavorAssetId);
$flavors = flavorParamsConversionProfilePeer::retrieveByConversionProfile($conversionProfile->getId());
KalturaLog::debug("Found flavors [" . count($flavors) . "] in conversion profile [" . $conversionProfile->getId() . "]");
foreach ($flavors as $flavor) {
/* @var $flavor flavorParamsConversionProfile */
if ($flavor->getFlavorParamsId() == $flavorAsset->getFlavorParamsId()) {
KalturaLog::debug("Flavor [" . $flavor->getFlavorParamsId() . "] is ingested source");
$sourceIncludedInProfile = true;
continue;
}
$flavorParams = assetParamsPeer::retrieveByPK($flavor->getFlavorParamsId());
if ($flavorParams instanceof liveParams || $flavor->getOrigin() == assetParamsOrigin::INGEST) {
KalturaLog::debug("Flavor [" . $flavor->getFlavorParamsId() . "] should be ingested");
continue;
}
if ($flavor->getOrigin() == assetParamsOrigin::CONVERT_WHEN_MISSING) {
$siblingFlavorAsset = assetPeer::retrieveByEntryIdAndParams($entry->getId(), $flavor->getFlavorParamsId());
if ($siblingFlavorAsset) {
KalturaLog::debug("Flavor [" . $flavor->getFlavorParamsId() . "] already ingested");
continue;
}
}
$sourceFileRequiredStorages[] = $flavorParams->getSourceRemoteStorageProfileId();
$conversionRequired = true;
break;
}
if ($conversionRequired) {
foreach ($sourceFileRequiredStorages as $storageId) {
if ($storageId == StorageProfile::STORAGE_KALTURA_DC) {
$key = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
list($syncFile, $local) = kFileSyncUtils::getReadyFileSyncForKey($key, true, false);
if ($syncFile && $syncFile->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL && $partner && $partner->getImportRemoteSourceForConvert()) {
KalturaLog::debug("Creates import job for remote file sync");
$url = $syncFile->getExternalUrl($entry->getId());
kJobsManager::addImportJob($parentJob, $entry->getId(), $partner->getId(), $url, $flavorAsset, null, null, true);
$importingSources = true;
continue;
}
} elseif ($flavorAsset->getExternalUrl($storageId)) {
continue;
}
kBatchManager::updateEntry($entry->getId(), entryStatus::ERROR_CONVERTING);
$flavorAsset = assetPeer::retrieveById($flavorAssetId);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$flavorAsset->setDescription('Entry of size 0 should not be converted');
$flavorAsset->save();
KalturaLog::err('Entry of size 0 should not be converted');
return null;
}
} else {
if ($flavorAsset->getStatus() == asset::FLAVOR_ASSET_STATUS_QUEUED) {
if ($sourceIncludedInProfile) {
$flavorAsset->setStatusLocalReady();
} else {
$flavorAsset->setStatus(asset::FLAVOR_ASSET_STATUS_DELETED);
$flavorAsset->setDeletedAt(time());
}
$flavorAsset->save();
if ($sourceIncludedInProfile) {
kBusinessPostConvertDL::handleConvertFinished(null, $flavorAsset);
}
}
return null;
}
}
if ($entry->getStatus() != entryStatus::READY) {
$entry->setStatus(entryStatus::PRECONVERT);
}
$jobData = new kConvertProfileJobData();
$jobData->setFlavorAssetId($flavorAssetId);
$jobData->setInputFileSyncLocalPath($inputFileSyncLocalPath);
$jobData->setExtractMedia(true);
if ($entry->getType() != entryType::MEDIA_CLIP) {
$jobData->setExtractMedia(false);
$entry->setCreateThumb(false);
}
$entry->save();
$batchJob = null;
if ($parentJob) {
$batchJob = $parentJob->createChild(BatchJobType::CONVERT_PROFILE);
} else {
$batchJob = new BatchJob();
$batchJob->setEntryId($entry->getId());
$batchJob->setPartnerId($entry->getPartnerId());
$batchJob->setUseNewRoot(true);
}
$batchJob->setObjectId($entry->getId());
$batchJob->setObjectType(BatchJobObjectType::ENTRY);
if ($importingSources) {
$batchJob->setStatus(BatchJob::BATCHJOB_STATUS_DONT_PROCESS);
}
return self::addJob($batchJob, $jobData, BatchJobType::CONVERT_PROFILE);
}
public function execute()
{
KExternalErrors::setResponseErrorCode(KExternalErrors::HTTP_STATUS_NOT_FOUND);
$this->deliveryAttributes = new DeliveryProfileDynamicAttributes();
// Parse input parameters
$this->deliveryAttributes->setSeekFromTime($this->getRequestParameter("seekFrom", -1));
if ($this->deliveryAttributes->getSeekFromTime() <= 0) {
$this->deliveryAttributes->setSeekFromTime(-1);
}
$this->deliveryAttributes->setClipTo($this->getRequestParameter("clipTo", 0));
$this->deliveryAttributes->setPlaybackRate($this->getRequestParameter("playbackRate", 0));
$deliveryCode = $this->getRequestParameter("deliveryCode", null);
$playbackContext = $this->getRequestParameter("playbackContext", null);
$this->deliveryAttributes->setMediaProtocol($this->getRequestParameter("protocol", null));
if (!$this->deliveryAttributes->getMediaProtocol() || $this->deliveryAttributes->getMediaProtocol() === "null") {
$this->deliveryAttributes->setMediaProtocol(PlaybackProtocol::HTTP);
}
$this->deliveryAttributes->setFormat($this->getRequestParameter("format"));
if (!$this->deliveryAttributes->getFormat()) {
$this->deliveryAttributes->setFormat(PlaybackProtocol::HTTP);
}
if ($this->deliveryAttributes->getFormat() == self::HDNETWORKSMIL) {
$this->deliveryAttributes->setMediaProtocol(PlaybackProtocol::HTTP);
}
// Akamai HD doesn't support any other protocol
if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::AKAMAI_HDS) {
if (strpos($this->deliveryAttributes->getMediaProtocol(), "http") !== 0) {
$this->deliveryAttributes->setMediaProtocol(PlaybackProtocol::HTTP);
}
}
$tags = $this->getRequestParameter("tags", null);
if (!$tags) {
$this->deliveryAttributes->setTags(self::getDefaultTagsByFormat($this->deliveryAttributes->getFormat()));
} else {
$tagsArray = explode(',', $tags);
$tags = array();
foreach ($tagsArray as $tag) {
$tags[] = array(trim($tag));
}
$this->deliveryAttributes->setTags($tags);
}
$this->deliveryAttributes->setpreferredBitrate($this->getRequestParameter("preferredBitrate", null));
$this->maxBitrate = $this->getRequestParameter("maxBitrate", null);
if ($this->maxBitrate && (!is_numeric($this->maxBitrate) || $this->maxBitrate <= 0)) {
KExternalErrors::dieError(KExternalErrors::INVALID_MAX_BITRATE);
}
$this->deliveryAttributes->setStorageId($this->getRequestParameter("storageId", null));
$this->cdnHost = $this->getRequestParameter("cdnHost", null);
$this->deliveryAttributes->setResponseFormat($this->getRequestParameter("responseFormat", null));
// Initialize
$this->initEntry();
$this->deliveryAttributes->setEntryId($this->entryId);
$this->deliveryAttributes->setUsePlayServer((bool) $this->getRequestParameter("usePlayServer") && PermissionPeer::isValidForPartner(PermissionName::FEATURE_PLAY_SERVER, $this->entry->getPartnerId()));
if ($this->deliveryAttributes->getUsePlayServer()) {
$this->deliveryAttributes->setPlayerConfig($this->getRequestParameter("playerConfig"));
//In case request needs to be redirected to play-server we need to add the ui conf id to the manifest url as well
$this->deliveryAttributes->setUiConfId($this->getRequestParameter("uiConfId"));
}
$this->secureEntryHelper->updateDeliveryAttributes($this->deliveryAttributes);
$this->enforceEncryption();
$renderer = null;
switch ($this->entry->getType()) {
case entryType::MEDIA_CLIP:
// VOD
$renderer = $this->serveVodEntry();
break;
case entryType::LIVE_STREAM:
case entryType::LIVE_CHANNEL:
// Live stream
$renderer = $this->serveLiveEntry();
break;
default:
KExternalErrors::dieError(KExternalErrors::INVALID_ENTRY_TYPE);
}
if (!$renderer) {
KExternalErrors::dieError(KExternalErrors::BAD_QUERY, 'This format is unsupported');
}
$renderer->contributors = array();
$config = new kManifestContributorConfig();
$config->format = $this->deliveryAttributes->getFormat();
$config->deliveryCode = $deliveryCode;
$config->storageId = $this->deliveryAttributes->getStorageId();
$config->entryId = $this->entryId;
$contributors = KalturaPluginManager::getPluginInstances('IKalturaPlayManifestContributor');
foreach ($contributors as $contributor) {
/* @var $contributor IKalturaPlayManifestContributor */
$renderer->contributors = array_merge($renderer->contributors, $contributor->getManifestEditors($config));
}
$renderer->entryId = $this->entryId;
$renderer->duration = $this->duration;
if ($this->deliveryProfile) {
$renderer->tokenizer = $this->deliveryProfile->getTokenizer();
}
$renderer->defaultDeliveryCode = $this->entry->getPartner()->getDefaultDeliveryCode();
$renderer->lastModified = time();
// Handle caching
$canCacheAccessControl = false;
if (kConf::hasParam("force_caching_headers") && in_array($this->entry->getPartnerId(), kConf::get("force_caching_headers"))) {
$renderer->cachingHeadersAge = 60;
$renderer->forceCachingHeaders = true;
}
if (!$this->secureEntryHelper) {
$canCacheAccessControl = true;
// TODO: reconsider this if/when expired ktokens will be used
} else {
if (!$this->secureEntryHelper->shouldDisableCache() && !$this->secureEntryHelper->isKsAdmin() && ($this->secureEntryHelper->isKsWidget() || !$this->secureEntryHelper->hasRules())) {
$canCacheAccessControl = true;
}
}
if (!$renderer->tokenizer && $canCacheAccessControl) {
// Note: kApiCache::hasExtraFields is checked in kManifestRenderers
$renderer->cachingHeadersAge = 60;
}
if (!$this->secureEntryHelper || !$this->secureEntryHelper->shouldDisableCache()) {
$cache = kPlayManifestCacher::getInstance();
$cache->storeRendererToCache($renderer);
}
// Output the response
KExternalErrors::terminateDispatch();
$renderer->output($deliveryCode, $playbackContext);
}
/**
* Returns true if kuser or current kuser is entitled to entryId
* @param entry $entry
* @param int $kuser
* @return bool
*/
public static function isEntryEntitled(entry $entry, $kuserId = null)
{
$ks = ks::fromSecureString(kCurrentContext::$ks);
// entry is entitled when entitlement is disable
// for actions with no ks - need to check if partner have default entitlement feature enable.
if (!self::getEntitlementEnforcement() && $ks) {
KalturaLog::debug('Entry entitled: entitlement disabled');
return true;
}
$partner = $entry->getPartner();
if (!$ks && !$partner->getDefaultEntitlementEnforcement()) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: no ks and default is with no enforcement');
return true;
}
if ($ks && $ks->isWidgetSession() && $ks->getDisableEntitlementForEntry() == $entry->getId()) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: widget session that disble entitlement for this entry');
return true;
}
$allCategoriesEntry = categoryEntryPeer::retrieveActiveAndPendingByEntryId($entry->getId());
$categories = array();
foreach ($allCategoriesEntry as $categoryEntry) {
$categories[] = $categoryEntry->getCategoryId();
}
//if entry doesn't belong to any category.
$categories[] = category::CATEGORY_ID_THAT_DOES_NOT_EXIST;
$c = KalturaCriteria::create(categoryPeer::OM_CLASS);
$c->add(categoryPeer::ID, $categories, Criteria::IN);
$privacy = array(PrivacyType::ALL);
if ($ks && !$ks->isWidgetSession()) {
$privacy[] = PrivacyType::AUTHENTICATED_USERS;
}
$crit = $c->getNewCriterion(categoryPeer::PRIVACY, $privacy, Criteria::IN);
$ksPrivacyContexts = null;
// entry that doesn't belong to any category is public
//when ks is not provided - the entry is still public (for example - download action)
$categoryEntries = categoryEntryPeer::retrieveActiveByEntryId($entry->getId());
if (!count($categoryEntries) && !$ks) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: entry does not belong to any category');
return true;
}
if ($ks) {
$ksPrivacyContexts = $ks->getPrivacyContext();
if (!$ksPrivacyContexts || trim($ksPrivacyContexts) == '') {
$ksPrivacyContexts = self::DEFAULT_CONTEXT . $partner->getId();
if (!count($allCategoriesEntry)) {
// entry that doesn't belong to any category is public
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: entry does not belong to any category and privacy context on the ks is not set');
return true;
}
}
$c->add(categoryPeer::PRIVACY_CONTEXTS, $ksPrivacyContexts, KalturaCriteria::IN_LIKE);
if (!$kuserId) {
$partnerId = kCurrentContext::$partner_id ? kCurrentContext::$partner_id : kCurrentContext::$ks_partner_id;
$kuser = kuserPeer::getKuserByPartnerAndUid($partnerId, kCurrentContext::$ks_uid, true);
if ($kuser) {
$kuserId = $kuser->getId();
}
}
if ($kuserId) {
// kuser is set on the entry as creator or uploader
if ($kuserId != '' && $entry->getKuserId() == $kuserId) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: ks user is the same as entry->kuserId or entry->creatorKuserId [' . $kuserId . ']');
return true;
}
// kuser is set on the entry entitled users edit or publish
$entitledKusers = array_merge(explode(',', $entry->getEntitledKusersEdit()), explode(',', $entry->getEntitledKusersPublish()));
if (in_array($kuserId, $entitledKusers)) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: ks user is the same as entry->entitledKusersEdit or entry->entitledKusersPublish');
return true;
}
}
// kuser is set on the category as member
// this ugly code is temporery - since we have a bug in sphinxCriteria::getAllCriterionFields
if ($kuserId) {
$membersCrit = $c->getNewCriterion(categoryPeer::MEMBERS, $kuserId, Criteria::LIKE);
$membersCrit->addOr($crit);
$crit = $membersCrit;
}
} else {
//no ks = set privacy context to default.
$c->add(categoryPeer::PRIVACY_CONTEXTS, array(self::DEFAULT_CONTEXT . $partner->getId()), KalturaCriteria::IN_LIKE);
}
$c->addAnd($crit);
//remove default FORCED criteria since categories that has display in search = public - doesn't mean that all of their entries are public
KalturaCriterion::disableTag(KalturaCriterion::TAG_ENTITLEMENT_CATEGORY);
$category = categoryPeer::doSelectOne($c);
KalturaCriterion::restoreTag(KalturaCriterion::TAG_ENTITLEMENT_CATEGORY);
if ($category) {
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] entitled: ks user is a member of this category or category privacy is set to public of authenticated');
return true;
}
KalturaLog::debug('Entry [' . print_r($entry->getId(), true) . '] not entitled');
return false;
}
private static function addIsmLink(entry $entry, SimpleXMLElement $mrss)
{
if (self::$addedIsmUrl) {
return;
}
self::$addedIsmUrl = true;
$syncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_ISM);
$kalturaFileSync = kFileSyncUtils::getReadyInternalFileSyncForKey($syncKey);
$urlManager = DeliveryProfilePeer::getDeliveryProfile($entry->getId(), PlaybackProtocol::SILVER_LIGHT);
if (!$urlManager) {
return;
}
$urlManager->initDeliveryDynamicAttributes($kalturaFileSync);
$partner = $entry->getPartner();
if (!$partner->getStorageServePriority() || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_FIRST) {
if ($kalturaFileSync) {
$urlPrefix = $urlManager->getUrl();
$url = $urlManager->getFileSyncUrl($kalturaFileSync, false);
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
}
if (!$partner->getStorageServePriority() || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY) {
return null;
}
$externalFileSync = kFileSyncUtils::getReadyExternalFileSyncForKey($syncKey);
if ($externalFileSync) {
$urlManager = DeliveryProfilePeer::getRemoteDeliveryByStorageId(DeliveryProfileDynamicAttributes::init($externalFileSync->getDc(), $entry->getId(), PlaybackProtocol::SILVER_LIGHT));
if (is_null($urlManager)) {
return;
}
$url = $urlManager->getFileSyncUrl($externalFileSync, false);
$urlPrefix = $urlManager->getUrl();
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
if ($partner->getStorageServePriority() != StorageProfile::STORAGE_SERVE_PRIORITY_EXTERNAL_ONLY) {
if ($kalturaFileSync) {
$url = $urlManager->getFileSyncUrl($kalturaFileSync, false);
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
}
}
private static function addIsmLink(entry $entry, SimpleXMLElement $mrss)
{
if (self::$addedIsmUrl) {
return;
}
self::$addedIsmUrl = true;
$syncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_ISM);
$kalturaFileSync = kFileSyncUtils::getReadyInternalFileSyncForKey($syncKey);
$urlPrefix = myPartnerUtils::getIisHost($entry->getPartnerId(), StorageProfile::PLAY_FORMAT_HTTP);
$iisHost = parse_url($urlPrefix, PHP_URL_HOST);
$matches = null;
if (preg_match('/(https?:\\/\\/[^\\/]+)(.*)/', $urlPrefix, $matches)) {
$urlPrefix = $matches[1];
}
$urlPrefix = rtrim($urlPrefix, '/') . '/';
$urlManager = kUrlManager::getUrlManagerByCdn($iisHost, $entry->getId());
if ($kalturaFileSync) {
$urlManager->setFileExtension(pathinfo($kalturaFileSync->getFilePath(), PATHINFO_EXTENSION));
}
$urlManager->setProtocol(StorageProfile::PLAY_FORMAT_SILVER_LIGHT);
$partner = $entry->getPartner();
if (!$partner->getStorageServePriority() || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_FIRST) {
if ($kalturaFileSync) {
$url = $urlManager->getFileSyncUrl($kalturaFileSync, false);
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
}
if (!$partner->getStorageServePriority() || $partner->getStorageServePriority() == StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY) {
return null;
}
$externalFileSync = kFileSyncUtils::getReadyExternalFileSyncForKey($syncKey);
if ($externalFileSync) {
$urlManager = kUrlManager::getUrlManagerByStorageProfile($externalFileSync->getDc(), $entry->getId());
$urlManager->setFileExtension(pathinfo($externalFileSync->getFilePath(), PATHINFO_EXTENSION));
$urlManager->setProtocol(StorageProfile::PLAY_FORMAT_SILVER_LIGHT);
$url = $urlManager->getFileSyncUrl($externalFileSync, false);
$url = ltrim($url, '/');
if (strpos($url, "://") !== false) {
$urlPrefix = '';
}
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
if ($partner->getStorageServePriority() != StorageProfile::STORAGE_SERVE_PRIORITY_EXTERNAL_ONLY) {
if ($kalturaFileSync) {
$url = $urlManager->getFileSyncUrl($kalturaFileSync, false);
$mrss->addChild('ismUrl', $urlPrefix . $url);
return;
}
}
}
public function execute()
{
$this->seekFrom = $this->getRequestParameter("seekFrom", -1);
if ($this->seekFrom <= 0) {
$this->seekFrom = -1;
}
$this->clipTo = $this->getRequestParameter("clipTo", 0);
$this->deliveryCode = $this->getRequestParameter("deliveryCode", null);
$playbackContext = $this->getRequestParameter("playbackContext", null);
$this->protocol = $this->getRequestParameter("protocol", null);
if (!$this->protocol || $this->protocol === "null") {
$this->protocol = StorageProfile::PLAY_FORMAT_HTTP;
}
$this->format = $this->getRequestParameter("format");
if (!$this->format) {
$this->format = StorageProfile::PLAY_FORMAT_HTTP;
}
$this->tags = $this->getRequestParameter("tags", null);
if (!$this->tags) {
switch ($this->format) {
case StorageProfile::PLAY_FORMAT_SILVER_LIGHT:
$this->tags = array(array(assetParams::TAG_SLWEB));
break;
case StorageProfile::PLAY_FORMAT_APPLE_HTTP:
case StorageProfile::PLAY_FORMAT_HDS:
$this->tags = array(array(assetParams::TAG_APPLEMBR), array('ipadnew', 'iphonenew'), array('ipad', 'iphone'));
break;
default:
$this->tags = array(array(assetParams::TAG_MBR), array(assetParams::TAG_WEB));
}
} else {
$this->tags = array(array($this->tags));
}
$this->cdnHost = $this->getRequestParameter("cdnHost", null);
$this->preferredBitrate = $this->getRequestParameter("preferredBitrate", null);
$this->maxBitrate = $this->getRequestParameter("maxBitrate", null);
if ($this->maxBitrate && (!is_numeric($this->maxBitrate) || $this->maxBitrate <= 0)) {
KExternalErrors::dieError(KExternalErrors::INVALID_MAX_BITRATE);
}
$this->initEntry();
$this->initFlavorIds();
$this->storageId = $this->getRequestParameter("storageId", null);
$this->validateStorageId();
$partner = $this->entry->getPartner();
if (!$this->cdnHost || $partner->getForceCdnHost()) {
$this->cdnHost = myPartnerUtils::getCdnHost($this->entry->getPartnerId(), $this->protocol);
}
$playbackParams = array();
if (kConf::hasMap("optimized_playback")) {
$partnerId = $this->entry->getPartnerId();
$optimizedPlayback = kConf::getMap("optimized_playback");
if (array_key_exists($partnerId, $optimizedPlayback)) {
$playbackParams = $optimizedPlayback[$partnerId];
}
}
if (array_key_exists('enforce_encryption', $playbackParams) && $playbackParams['enforce_encryption']) {
if (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] != 'on') {
KExternalErrors::dieError(KExternalErrors::ACCESS_CONTROL_RESTRICTED, 'unencrypted manifest request - forbidden');
}
if (strtolower($this->protocol) != 'https') {
KExternalErrors::dieError(KExternalErrors::ACCESS_CONTROL_RESTRICTED, 'unencrypted playback protocol - forbidden');
}
}
$renderer = null;
switch ($this->format) {
case StorageProfile::PLAY_FORMAT_HTTP:
$renderer = $this->serveHttp();
break;
case StorageProfile::PLAY_FORMAT_RTMP:
$renderer = $this->serveRtmp();
break;
case StorageProfile::PLAY_FORMAT_SILVER_LIGHT:
$renderer = $this->serveSilverLight();
break;
case StorageProfile::PLAY_FORMAT_APPLE_HTTP:
$renderer = $this->serveAppleHttp();
break;
case StorageProfile::PLAY_FORMAT_HDS:
$renderer = $this->serveHds();
break;
case "url":
$this->format = "http";
// build url for an http delivery
$renderer = $this->serveUrl();
break;
case "rtsp":
$renderer = $this->serveRtsp();
break;
case "hdnetworksmil":
$renderer = $this->serveHDNetworkSmil();
break;
case "hdnetwork":
$renderer = $this->serveHDNetwork();
break;
case "hdnetworkmanifest":
$renderer = $this->serveHDNetworkManifest();
break;
}
if (!$renderer) {
KExternalErrors::dieError(KExternalErrors::BAD_QUERY, 'This format is unsupported');
}
$canCacheAccessControl = false;
if (!$this->secureEntryHelper) {
$canCacheAccessControl = true;
// TODO: reconsider this if/when expired ktokens will be used
} else {
if (!$this->secureEntryHelper->shouldDisableCache() && !$this->secureEntryHelper->isKsAdmin() && ($this->secureEntryHelper->isKsWidget() || !$this->secureEntryHelper->hasRules())) {
$canCacheAccessControl = true;
}
}
if (!$renderer->tokenizer && $canCacheAccessControl) {
// Note: kApiCache::hasExtraFields is checked in kManifestRenderers
$renderer->cachingHeadersAge = 60;
}
if (!$this->secureEntryHelper || !$this->secureEntryHelper->shouldDisableCache()) {
$cache = kPlayManifestCacher::getInstance();
$cache->storeCache($renderer);
}
$renderer->output($playbackContext);
}
