protected function servePlaylist($entry)
{
// allow only manual playlist
if ($entry->getMediaType() != entry::ENTRY_MEDIA_TYPE_TEXT) {
KExternalErrors::dieError(KExternalErrors::INVALID_ENTRY_TYPE);
}
// get request parameters
$flavorParamIds = $this->getRequestParameter("flavorParamIds");
if ($flavorParamIds) {
$flavorParamIds = explode(',', $flavorParamIds);
}
$version = $this->getRequestParameter("v");
// execute the playlist
if ($version) {
$entry->setDesiredVersion($version);
}
list($entryIds, $durations, $referenceEntry) = myPlaylistUtils::executeStitchedPlaylist($entry);
if (!$referenceEntry) {
KExternalErrors::dieError(KExternalErrors::ENTRY_NOT_FOUND);
}
// load the flavor assets
// Note: not filtering by $flavorParamIds here, so that in case some flavor is missing
// we can fill in the gap using some other flavor params
$c = new Criteria();
$c->add(assetPeer::ENTRY_ID, $entryIds, Criteria::IN);
$c->add(assetPeer::STATUS, flavorAsset::FLAVOR_ASSET_STATUS_READY);
$flavorTypes = assetPeer::retrieveAllFlavorsTypes();
$c->add(assetPeer::TYPE, $flavorTypes, Criteria::IN);
$flavorAssets = assetPeer::doSelect($c);
// group the flavors by entry and flavor params
$groupedFlavors = array();
foreach ($flavorAssets as $flavor) {
if (!isset($groupedFlavors[$flavor->getEntryId()])) {
$groupedFlavors[$flavor->getEntryId()] = array();
}
$groupedFlavors[$flavor->getEntryId()][$flavor->getFlavorParamsId()] = $flavor;
}
// remove entries that don't have flavors
for ($i = count($entryIds) - 1; $i >= 0; $i--) {
$entryId = $entryIds[$i];
if (isset($groupedFlavors[$entryId])) {
continue;
}
unset($entryIds[$i]);
unset($durations[$i]);
}
// get the flavor params of the reference entry that should be returned
$referenceEntryFlavorParamsIds = array_keys($groupedFlavors[$referenceEntry->getId()]);
if ($flavorParamIds) {
$flavorParamIds = array_intersect($referenceEntryFlavorParamsIds, $flavorParamIds);
} else {
$flavorParamIds = $referenceEntryFlavorParamsIds;
}
if (!$flavorParamIds) {
KExternalErrors::dieError(KExternalErrors::FLAVOR_NOT_FOUND);
}
// build the sequences
$storeCache = true;
$sequences = array();
foreach ($flavorParamIds as $flavorParamsId) {
$referenceFlavor = $groupedFlavors[$referenceEntry->getId()][$flavorParamsId];
// build the clips of the current sequence
$clips = array();
foreach ($entryIds as $entryId) {
if (isset($groupedFlavors[$entryId][$flavorParamsId])) {
$flavor = $groupedFlavors[$entryId][$flavorParamsId];
} else {
// don't have a flavor for this entry in the desired flavor params,
// choose the one with the closest bitrate
$flavor = null;
foreach ($groupedFlavors[$entryId] as $curFlavor) {
if (!$flavor || abs($curFlavor->getBitrate() - $referenceFlavor->getBitrate()) < abs($flavor->getBitrate() - $referenceFlavor->getBitrate())) {
$flavor = $curFlavor;
}
}
}
// get the file path of the flavor
$syncKey = $flavor->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($syncKey, false, false);
if ($fileSync) {
$resolvedFileSync = kFileSyncUtils::resolve($fileSync);
$path = $resolvedFileSync->getFullPath();
} else {
error_log('missing file sync for flavor ' . $flavor->getId() . ' version ' . $flavor->getVersion());
$path = '';
$storeCache = false;
}
$clips[] = array('type' => 'source', 'path' => $path);
}
$sequences[] = array('clips' => $clips);
}
// build the json
$mediaSet = array('durations' => $durations, 'sequences' => $sequences);
$json = json_encode($mediaSet);
$renderer = new kRendererString($json, self::JSON_CONTENT_TYPE);
if ($storeCache) {
$this->storeCache($renderer, $entry->getPartnerId());
}
$renderer->output();
KExternalErrors::dieGracefully();
}
public function getListResponse(KalturaFilterPager $pager, KalturaDetachedResponseProfile $responseProfile = null)
{
$types = assetPeer::retrieveAllFlavorsTypes();
return $this->getTypeListResponse($pager, $responseProfile, $types);
}
public function validateForSubmission(EntryDistribution $entryDistribution, $action)
{
$validationErrors = parent::validateForSubmission($entryDistribution, $action);
// make sure that all flavor assets marked for distribution have a flavor params id assigned to them
$flavorAssetIds = explode(',', $entryDistribution->getFlavorAssetIds());
if (count($flavorAssetIds)) {
$c = new Criteria();
$c->addAnd(assetPeer::ID, $flavorAssetIds, Criteria::IN);
$flavorTypes = assetPeer::retrieveAllFlavorsTypes();
$c->add(assetPeer::TYPE, $flavorTypes, Criteria::IN);
$flavorAssets = assetPeer::doSelect($c);
foreach ($flavorAssets as $asset) {
/* @var $asset flavorAsset */
if (strlen($asset->getFlavorParamsId()) <= 0) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, 'flavor asset', 'flavor asset must be assigned to a flavor params id');
}
}
}
return $validationErrors;
}
/**
* Get Flavor Asset with the relevant Flavor Params (Flavor Params can exist without Flavor Asset & vice versa)
*
* @action getFlavorAssetsWithParams
* @param string $entryId
* @return KalturaFlavorAssetWithParamsArray
*/
public function getFlavorAssetsWithParamsAction($entryId)
{
$dbEntry = entryPeer::retrieveByPK($entryId);
if (!$dbEntry) {
throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
}
// get all the flavor params of partner 0 and the current partner (note that partner 0 is defined as partner group in service.ct)
$c = new Criteria();
$flavorTypes = assetParamsPeer::retrieveAllFlavorParamsTypes();
$c->add(assetParamsPeer::TYPE, $flavorTypes, Criteria::IN);
$partnerIds = array($dbEntry->getPartnerId(), PartnerPeer::GLOBAL_PARTNER);
$c->add(assetParamsPeer::PARTNER_ID, array_map('strval', $partnerIds), Criteria::IN);
$flavorParamsDb = assetParamsPeer::doSelect($c);
// get the flavor assets for this entry
$c = new Criteria();
$flavorTypes = assetPeer::retrieveAllFlavorsTypes();
$c->add(assetPeer::TYPE, $flavorTypes, Criteria::IN);
$c->add(assetPeer::ENTRY_ID, $entryId);
$c->add(assetPeer::STATUS, array(flavorAsset::FLAVOR_ASSET_STATUS_DELETED, flavorAsset::FLAVOR_ASSET_STATUS_TEMP), Criteria::NOT_IN);
$flavorAssetsDb = assetPeer::doSelect($c);
// find what flavot params are required
$requiredFlavorParams = array();
foreach ($flavorAssetsDb as $item) {
$requiredFlavorParams[$item->getFlavorParamsId()] = true;
}
// now merge the results, first organize the flavor params in an array with the id as the key
$flavorParamsArray = array();
foreach ($flavorParamsDb as $item) {
$flavorParams = $item->getId();
$flavorParamsArray[$flavorParams] = $item;
if (isset($requiredFlavorParams[$flavorParams])) {
unset($requiredFlavorParams[$flavorParams]);
}
}
// adding missing required flavors params to the list
if (count($requiredFlavorParams)) {
$flavorParamsDb = assetParamsPeer::retrieveByPKsNoFilter(array_keys($requiredFlavorParams));
foreach ($flavorParamsDb as $item) {
$flavorParamsArray[$item->getId()] = $item;
}
}
$usedFlavorParams = array();
// loop over the flavor assets and add them, if it has flavor params add them too
$flavorAssetWithParamsArray = new KalturaFlavorAssetWithParamsArray();
foreach ($flavorAssetsDb as $flavorAssetDb) {
$flavorParamsId = $flavorAssetDb->getFlavorParamsId();
$flavorAssetWithParams = new KalturaFlavorAssetWithParams();
$flavorAssetWithParams->entryId = $entryId;
$flavorAsset = KalturaFlavorAsset::getInstance($flavorAssetDb, $this->getResponseProfile());
$flavorAssetWithParams->flavorAsset = $flavorAsset;
if (isset($flavorParamsArray[$flavorParamsId])) {
$flavorParamsDb = $flavorParamsArray[$flavorParamsId];
$flavorParams = KalturaFlavorParamsFactory::getFlavorParamsInstance($flavorParamsDb->getType());
$flavorParams->fromObject($flavorParamsDb, $this->getResponseProfile());
$flavorAssetWithParams->flavorParams = $flavorParams;
// we want to log which flavor params are in use, there could be more
// than one flavor asset using same params
$usedFlavorParams[$flavorParamsId] = $flavorParamsId;
}
// else if ($flavorAssetDb->getIsOriginal())
// {
// // create a dummy flavor params
// $flavorParams = new KalturaFlavorParams();
// $flavorParams->name = "Original source";
// $flavorAssetWithParams->flavorParams = $flavorParams;
// }
$flavorAssetWithParamsArray[] = $flavorAssetWithParams;
}
// copy the remaining params
foreach ($flavorParamsArray as $flavorParamsId => $flavorParamsDb) {
if (isset($usedFlavorParams[$flavorParamsId])) {
// flavor params already exists for a flavor asset, not need
// to list it one more time
continue;
}
$flavorParams = KalturaFlavorParamsFactory::getFlavorParamsInstance($flavorParamsDb->getType());
$flavorParams->fromObject($flavorParamsDb, $this->getResponseProfile());
$flavorAssetWithParams = new KalturaFlavorAssetWithParams();
$flavorAssetWithParams->entryId = $entryId;
$flavorAssetWithParams->flavorParams = $flavorParams;
$flavorAssetWithParamsArray[] = $flavorAssetWithParams;
}
return $flavorAssetWithParamsArray;
}
