protected function concat(KalturaBatchJob $job, KalturaConcatJobData $data)
{
$this->updateJob($job, "Files concatenation started", KalturaBatchJobStatus::PROCESSING);
$jobData = $job->data;
$ffmpegBin = KBatchBase::$taskConfig->params->ffmpegCmd;
$ffprobeBin = isset(KBatchBase::$taskConfig->params->ffprobeCmd) ? KBatchBase::$taskConfig->params->ffprobeCmd : "ffprobe";
$mediaInfoBin = isset(KBatchBase::$taskConfig->params->mediaInfoCmd) ? KBatchBase::$taskConfig->params->mediaInfoCmd : "mediainfo";
$fileName = "{$job->entryId}_{$data->flavorAssetId}.mp4";
$localTempFilePath = $this->localTempPath . DIRECTORY_SEPARATOR . $fileName;
$sharedTempFilePath = $this->sharedTempPath . DIRECTORY_SEPARATOR . $fileName;
$srcFiles = array();
foreach ($data->srcFiles as $srcFile) {
/* @var $srcFile KalturaString */
$srcFiles[] = $srcFile->value;
}
$result = $this->concatFiles($ffmpegBin, $ffprobeBin, $srcFiles, $localTempFilePath, $data->offset, $data->duration);
if (!$result) {
return $this->closeJob($job, KalturaBatchJobErrorTypes::RUNTIME, null, "Failed to concat files", KalturaBatchJobStatus::FAILED);
}
try {
// get the concatenated duration
$mediaInfoParser = new KMediaInfoMediaParser($localTempFilePath, $mediaInfoBin);
$data->concatenatedDuration = $mediaInfoParser->getMediaInfo()->videoDuration;
} catch (Exception $ex) {
KalturaLog::warning('failed to get concatenatedDuration ' . print_r($ex));
}
return $this->moveFile($job, $data, $localTempFilePath, $sharedTempFilePath);
}
public function entryHandled(entry $dbEntry)
{
parent::entryHandled($dbEntry);
$originalFlavorAsset = assetPeer::retrieveOriginalByEntryId($dbEntry->getId());
$syncKey = $originalFlavorAsset->getSyncKey(asset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$sourceFilePath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
// call mediaInfo for file
$dbMediaInfo = new mediaInfo();
try {
$mediaInfoParser = new KMediaInfoMediaParser($sourceFilePath, kConf::get('bin_path_mediainfo'));
$mediaInfo = $mediaInfoParser->getMediaInfo();
$dbMediaInfo = $mediaInfo->toInsertableObject($dbMediaInfo);
$dbMediaInfo->setFlavorAssetId($originalFlavorAsset->getId());
$dbMediaInfo->save();
} catch (Exception $e) {
KalturaLog::err("Getting media info: " . $e->getMessage());
$dbMediaInfo = null;
}
// fix flavor asset according to mediainfo
if ($dbMediaInfo) {
KDLWrap::ConvertMediainfoCdl2FlavorAsset($dbMediaInfo, $originalFlavorAsset);
$flavorTags = KDLWrap::CDLMediaInfo2Tags($dbMediaInfo, array(flavorParams::TAG_WEB, flavorParams::TAG_MBR));
$originalFlavorAsset->setTags(implode(',', array_unique($flavorTags)));
}
$originalFlavorAsset->setStatusLocalReady();
$originalFlavorAsset->save();
$dbEntry->setStatus(entryStatus::READY);
$dbEntry->save();
}
/**
* extractMediaInfo extract the file info using mediainfo and parse the returned data
*
* @param string $mediaFile file full path
* @return KalturaMediaInfo or null for failure
*/
private function extractMediaInfo($mediaFile)
{
KalturaLog::debug("extractMediaInfo({$mediaFile})");
$mediaInfo = null;
try {
$mediaParser = new KMediaInfoMediaParser($mediaFile, $this->taskConfig->params->mediaInfoCmd);
$mediaInfo = $mediaParser->getMediaInfo();
} catch (Exception $ex) {
KalturaLog::err($ex->getMessage());
$mediaInfo = null;
}
try {
if (is_null($mediaInfo) && $this->taskConfig->params->mediaInfoCmd2) {
$mediaParser = new KMediaInfoMediaParser($mediaFile, $this->taskConfig->params->mediaInfoCmd2);
$mediaInfo = $mediaParser->getMediaInfo();
}
} catch (Exception $ex) {
KalturaLog::err($ex->getMessage());
$mediaInfo = null;
}
return $mediaInfo;
}
private function handleEntry($onlyExtractThumb, $prefix, $type, $entry_id, $name = null, $tags = null, $entry = null)
{
KalturaLog::debug("handleEntry({$type}, {$entry_id}, {$name})");
$this->clear($prefix, $entry_id);
$kuser_id = $this->kuser_id;
$entry_data_prefix = $kuser_id . '_' . ($prefix == '' ? 'data' : rtrim($prefix, '_'));
$uploads = myContentStorage::getFSUploadsPath();
$content = myContentStorage::getFSContentRootPath();
$media_source = $this->getParam('entry_media_source');
$media_type = $this->getParam('entry_media_type');
$entry_url = $this->getParam('entry_url');
$entry_source_link = $this->getParam('entry_source_link');
$entry_fileName = $this->getParam('entry_data');
$entry_thumbNum = $this->getParam('entry_thumb_num', 0);
$entry_thumbUrl = $this->getParam('entry_thumb_url', '');
$should_copy = $this->getParam('should_copy', false);
$skip_conversion = $this->getParam('skip_conversion', false);
$webcam_suffix = $this->getParam('webcam_suffix', '');
$duration = $this->getParam('duration', null);
$entry_fullPath = "";
$ext = null;
$entry = null;
if ($entry_id) {
$entry = entryPeer::retrieveByPK($entry_id);
} else {
$entry = new entry();
}
$this->entry = $entry;
$entry_status = $entry->getStatus();
if (is_null($entry_status)) {
$entry_status = entryStatus::READY;
}
// by the end of this block of code $entry_fullPath will point to the location of the entry
// the entry status will be set (IMPORT / PRECONVERT / READY)
// a background image is always previewed by the user no matter what source he used
// so the entry is already in the /uploads directory
// continue tracking the file upload
$te = new TrackEntry();
$te->setEntryId($entry_id);
$te->setTrackEventTypeId(TrackEntry::TRACK_ENTRY_EVENT_TYPE_ADD_ENTRY);
KalturaLog::debug("handleEntry: media_source: {$media_source}, prefix: {$prefix}");
if ($media_source == entry::ENTRY_MEDIA_SOURCE_FILE || $prefix == 'bg_') {
$full_path = $this->getParam('entry_full_path');
if ($full_path) {
$entry_fullPath = $full_path;
} else {
$entry_fullPath = $uploads . $entry_data_prefix . strrchr($entry_fileName, '.');
}
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO || $media_type == entry::ENTRY_MEDIA_TYPE_AUDIO) {
$entry_status = entryStatus::PRECONVERT;
}
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_FILE");
} else {
if ($media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
// set $entry_fileName to webcam output file and flag that conversion is not needed
$webcam_basePath = $content . '/content/webcam/' . ($webcam_suffix ? $webcam_suffix : 'my_recorded_stream_' . $kuser_id);
$entry_fullPath = $webcam_basePath . '.' . kWAMSWebcam::OUTPUT_FILE_EXT;
$ext = kWAMSWebcam::OUTPUT_FILE_EXT;
if (file_exists($entry_fullPath)) {
// continue tracking the webcam
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_WEBCAM");
} else {
KalturaLog::err("File [{$entry_fullPath}] does not exist");
$entry_status = entryStatus::ERROR_IMPORTING;
}
} else {
// if the url ends with .ext, we'll extract it this way
$urlext = strrchr($entry_url, '.');
// TODO: fix this patch
if (strlen($urlext) > 4) {
$urlext = '.jpg';
}
// if we got something wierd, assume we're downloading a jpg
$entry_fileName = $entry_data_prefix . $urlext;
KalturaLog::debug("handleEntry: media_type: {$media_type}");
if ($media_type == entry::ENTRY_MEDIA_TYPE_IMAGE) {
$duration = 0;
$entry_fullPath = $uploads . $entry_fileName;
if (!kFile::downloadUrlToFile($entry_url, $entry_fullPath)) {
KalturaLog::debug("Failed downloading file[{$entry_url}]");
$entry_status = entryStatus::ERROR_IMPORTING;
}
// track images
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_URL:ENTRY_MEDIA_TYPE_IMAGE");
} else {
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO) {
//fixme - we can extract during import
$ext = "flv";
} else {
$ext = "mp3";
}
$entry_status = entryStatus::IMPORT;
// track images
$te->setParam3Str($ext);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_URL:ENTRY_MEDIA_TYPE_VIDEO");
}
}
}
if ($ext == null) {
$entry_fullPathTmp = $entry_fullPath;
$qpos = strpos($entry_fullPathTmp, "?");
if ($qpos !== false) {
$entry_fullPathTmp = substr($entry_fullPathTmp, 0, $qpos);
}
$ext = strtolower(pathinfo($entry_fullPathTmp, PATHINFO_EXTENSION));
}
// save the Trackentry
TrackEntry::addTrackEntry($te);
KalturaLog::debug("handleEntry: ext: {$ext}");
// We don't want to reject entries based on file extentions anumore
// Remarked by Tan-Tan
//
// if ($entry_status == entryStatus::PRECONVERT && !myContentStorage::fileExtNeedConversion($ext))
// {
//
// $this->errorMsg = "insertEntryAction Error - PRECONVERT file type not acceptable ($ext)";
// KalturaLog::debug("handleEntry: err: $this->errorMsg");
// if(is_null($entry) && $this->entry_id)
// {
// $entry = entryPeer::retrieveByPK($this->entry_id);
// }
// if($entry)
// {
// $entry->setStatus(entryStatus::ERROR_CONVERTING);
// $entry->save();
// }
// return false;
// }
$media_date = null;
// We don't want to reject entries based on file extentions anumore
// Remarked by Tan-Tan
//
// // if entry is ready, validate file type (webcam is an exception since we control the file type - flv)
// if ($entry_status == entryStatus::READY &&
// $media_source != entry::ENTRY_MEDIA_SOURCE_WEBCAM && !myContentStorage::fileExtAccepted($ext))
// {
// $this->errorMsg = "insertEntryAction Error - READY file type not acceptable ($ext)";
// KalturaLog::debug("handleEntry: err: $this->errorMsg");
// if(is_null($entry) && $this->entry_id)
// {
// $entry = entryPeer::retrieveByPK($this->entry_id);
// }
// if($entry)
// {
// $entry->setStatus(entryStatus::ERROR_CONVERTING);
// $entry->save();
// }
// return false;
// }
if ($entry_status == entryStatus::ERROR_IMPORTING) {
$need_thumb = false;
// we wont be needing a thumb for an errornous entry
KalturaLog::debug("handleEntry: error importing, thumb not needed");
} else {
// thumbs are created by one of the following ways:
// 1. Image - images are already on disk for every selection method, so we can just create a thumb
// 2. Audio - no thumb is needed
// 3. Video -
// a. uploaded (file / webcam) - file is on disk and the user already selected a thumb
// b. imported - the source site had a thumbnail and we'll use it
$thumbTempPrefix = $uploads . $entry_data_prefix . '_thumbnail_';
$thumbBigFullPath = null;
$need_thumb = $type == entryType::MEDIA_CLIP;
KalturaLog::debug("handleEntry: handling media {$media_type}");
if ($media_type == entry::ENTRY_MEDIA_TYPE_IMAGE) {
// fetch media creation date
$exif_image_type = @exif_imagetype($entry_fullPath);
if ($exif_image_type == IMAGETYPE_JPEG || $exif_image_type == IMAGETYPE_TIFF_II || $exif_image_type == IMAGETYPE_TIFF_MM || $exif_image_type == IMAGETYPE_IFF || $exif_image_type == IMAGETYPE_PNG) {
$exif_data = @exif_read_data($entry_fullPath);
if ($exif_data && isset($exif_data["DateTimeOriginal"]) && $exif_data["DateTimeOriginal"]) {
$media_date = $exif_data["DateTimeOriginal"];
$ts = strtotime($media_date);
// handle invalid dates either due to bad format or out of range
if ($ts === -1 || $ts === false || $ts < strtotime('2000-01-01') || $ts > strtotime('2015-01-01')) {
$media_date = null;
}
}
}
// create thumb
$thumbFullPath = $thumbTempPrefix . '1.jpg';
$entry_thumbNum = 1;
$need_thumb = true;
//copy($entry_fullPath, $thumbFullPath);
myFileConverter::createImageThumbnail($entry_fullPath, $thumbFullPath, "image2");
//$thumbBigFullPath = $thumbFullPath; // no filesync for thumbnail of image
} else {
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO) {
if ($entry_status == entryStatus::IMPORT || $media_source == entry::ENTRY_MEDIA_SOURCE_URL) {
// import thumb and convert to our size
$thumbFullPath = $thumbTempPrefix . '1.jpg';
$entry_thumbNum = 1;
$importedThumbPath = $uploads . $entry_data_prefix . '_temp_thumb' . strrchr($entry_thumbUrl, '.');
if (kFile::downloadUrlToFile($entry_thumbUrl, $importedThumbPath)) {
myFileConverter::createImageThumbnail($importedThumbPath, $thumbFullPath, "image2");
// set thumb as big thumb so fileSync will be created.
$thumbBigFullPath = $thumbFullPath;
} else {
$need_thumb = false;
}
} else {
if ($entry_thumbNum == 0) {
$entry_thumbNum = 1;
$thumbTime = 3;
if ($duration && $duration < $thumbTime * 1000) {
$thumbTime = floor($duration / 1000);
}
// for videos - thumbail should be created in post convert
// otherwise this code will fail if the thumbanil wasn't created successfully (roman)
//myFileConverter::autoCaptureFrame($entry_fullPath, $thumbTempPrefix."big_", $thumbTime, -1, -1);
$need_thumb = false;
$thumbBigFullPath = $thumbTempPrefix . "big_" . $entry_thumbNum . '.jpg';
}
}
//else select existing thumb ($entry_thumbNum already points to the right thumbnail)
}
}
$thumbFullPath = $thumbTempPrefix . $entry_thumbNum . '.jpg';
// if we arrived here both entry and thumbnail are valid we can now update the db
// in order to have the final entry_id and move its data to its final destination
if ($onlyExtractThumb) {
return $thumbFullPath;
}
}
$entry->setkshowId($this->kshow_id);
$entry->setKuserId($kuser_id);
$entry->setCreatorKuserId($kuser_id);
if ($this->partner_id != null) {
$entry->setPartnerId($this->partner_id);
$entry->setSubpId($this->subp_id);
}
$entry->setName($name ? $name : $this->getParam('entry_name'));
// $entry->setDescription('');//$this->getParam('entry_description'));
$entry->setType($type);
$entry->setMediaType($media_type);
$entry->setTags($tags ? $tags : $this->getParam('entry_tags'));
$entry->setSource($media_source);
$entry->setSourceId($this->getParam('entry_media_id'));
if ($media_date) {
$entry->setMediaDate($media_date);
}
// if source_link wasnt given use the entry_url HOWEVER, use it only if id doesnt contain @ which suggests the use of a password
$entry->setSourceLink($entry_source_link ? $entry_source_link : (strstr($entry_url, '@') ? "" : $entry_url));
if ($media_source == entry::ENTRY_MEDIA_SOURCE_FILE) {
$entry->setSourceLink("file:{$entry_fullPath}");
}
$entry->setLicenseType($this->getParam('entry_license'));
$entry->setCredit($this->getParam('entry_credit'));
$entry->setStatus($entry_status);
if ($duration !== null) {
$entry->setLengthInMsecs($duration);
}
if ($this->entry_id == 0) {
$entry->save();
$this->entry_id = $entry->getId();
}
// move thumb to final destination and set db entry
if ($media_type != entry::ENTRY_MEDIA_TYPE_AUDIO && $entry_thumbNum && $need_thumb) {
KalturaLog::debug("handleEntry: saving none audio thumb [{$thumbBigFullPath}]");
$entry->setThumbnail('.jpg');
if ($thumbBigFullPath) {
if ($media_type != entry::ENTRY_MEDIA_TYPE_IMAGE) {
myFileConverter::convertImage($thumbBigFullPath, $thumbFullPath);
}
/*$thumbBigFinalPath = $content.$entry->getBigThumbnailPath();
myContentStorage::moveFile($thumbBigFullPath, $thumbBigFinalPath, true , $should_copy );
*/
$entryThumbKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($thumbBigFullPath, $entryThumbKey);
} else {
kFileSyncUtils::copyFromFile($thumbBigFullPath, $entryThumbKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$entry->save();
throw $e;
}
}
}
// after extracting the thumb we can move the entry to its next destination
KalturaLog::debug("handleEntry: current status [" . $entry->getStatus() . "]");
// if needed a job will be submitted for importing external media sources
if ($entry->getStatus() == entryStatus::IMPORT) {
KalturaLog::debug("handleEntry: creating import job");
// changed by Tan-Tan, Nov 09 to support the new batch mechanism
kJobsManager::addImportJob(null, $this->entry_id, $this->partner_id, $entry_url);
// remarked by Tan-Tan
// $entry_fullPath = $content.'/content/imports/data/'.$this->entry_id.".".$ext;
// myContentStorage::fullMkdir($entry_fullPath);
//
// $batchClient = new myBatchUrlImportClient();
// $batchClient->addJob($this->entry_id, $entry_url, $entry_fullPath);
} else {
if ($entry->getStatus() == entryStatus::PRECONVERT) {
if (!$skip_conversion) {
// changed by Tan-Tan, Dec 09 to support the new batch mechanism
KalturaLog::debug("handleEntry: creating original flavor asset for pre convert");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
} else {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
}
// Remarked by Tan-Tan
// $targetFileName = $this->entry_id.".".$ext;
// if ( false /* old conversion */)
// {
// // if we need to convert move entry to conversion directory
// $preConvPath = $content.'/content/preconvert/';
// myContentStorage::moveFile($entry_fullPath, $preConvPath."data/".$targetFileName, true , $should_copy );
//
// $signalFilePath = $preConvPath."files/".$targetFileName;
// myContentStorage::fullMkdir($signalFilePath);
// touch($signalFilePath);
// }
// else
// {
// $preConvPath = myContentStorage::getFSContentRootPath (). "/content/new_preconvert";
// $to_data = $preConvPath . "/$targetFileName" ;
// myContentStorage::moveFile($entry_fullPath, $to_data , true);
// touch ( $to_data . ".indicator" );
// }
}
} else {
if ($entry->getStatus() == entryStatus::PENDING || $media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
$entry->setData($entry_fullPath);
$entry->save();
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO || $media_type == entry::ENTRY_MEDIA_TYPE_AUDIO) {
KalturaLog::debug("handleEntry: creating original flavor asset for ready entry");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$ext = pathinfo($entry_fullPath, PATHINFO_EXTENSION);
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $syncKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
// // bypass to conversion
// kBusinessPreConvertDL::bypassConversion($flavorAsset, $entry);
/**
* if this is webcam entry, create mediaInfo for the source flavor asset synchronously
* since entry is ready right at the beginning
*/
if ($media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
require_once SF_ROOT_DIR . DIRECTORY_SEPARATOR . ".." . DIRECTORY_SEPARATOR . "api_v3" . DIRECTORY_SEPARATOR . "bootstrap.php";
// extract file path
$sourceFileKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$sourceFilePath = kFileSyncUtils::getLocalFilePathForKey($sourceFileKey);
// call mediaInfo for file
$mediaInfo = new mediaInfo();
try {
$mediaInfoParser = new KMediaInfoMediaParser($sourceFilePath, kConf::get('bin_path_mediainfo'));
$KalturaMediaInfo = new KalturaMediaInfo();
$KalturaMediaInfo = $mediaInfoParser->getMediaInfo();
$mediaInfo = $KalturaMediaInfo->toInsertableObject($mediaInfo);
$mediaInfo->setFlavorAssetId($flavorAsset->getId());
$mediaInfo->save();
} catch (Exception $e) {
KalturaLog::err("Getting media info: " . $e->getMessage());
$mediaInfo = null;
}
// fix flavor asset according to mediainfo
if ($mediaInfo) {
KDLWrap::ConvertMediainfoCdl2FlavorAsset($mediaInfo, $flavorAsset);
$flavorTags = KDLWrap::CDLMediaInfo2Tags($mediaInfo, array(flavorParams::TAG_WEB, flavorParams::TAG_MBR));
$flavorAsset->setTags(implode(',', $flavorTags));
}
$flavorAsset->save();
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
$flavorAsset->setStatusLocalReady();
$flavorAsset->save();
} else {
$entry->setStatus(entryStatus::ERROR_IMPORTING);
}
} else {
if ($entry->getType() == entryType::DOCUMENT) {
//TODO: document should be handled by the plugin manager)
KalturaLog::debug("handleEntry: creating original flavor asset for ready entry");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$ext = pathinfo($entry_fullPath, PATHINFO_EXTENSION);
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $syncKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
}
} else {
KalturaLog::debug("handleEntry: creating data file sync for file [{$entry_fullPath}]");
$entryDataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
if (!kFileSyncUtils::file_exists($entryDataKey)) {
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $entryDataKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $entryDataKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$entry->save();
throw $e;
}
}
$entry->setStatus(entryStatus::READY);
$entry->save();
}
}
// Remarked by Tan-Tan, the flavor asset should be synced instead of the entry
//
// $entryDataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
// if(!$should_copy)
// {
// kFileSyncUtils::moveFromFile($entry_fullPath, $entryDataKey);
// }
// else
// {
// // copy & create file sync from $entry_fullPath
// kFileSyncUtils::copyFromFile($entry_fullPath, $entryDataKey);
// }
}
}
}
if ($entry->getStatus() == entryStatus::READY) {
$entry->updateDimensions();
}
$entry->save();
return true;
}
protected function generateAmfData(KalturaBatchJob $job, KalturaConvertLiveSegmentJobData $data, $localTempFilePath)
{
$mediaInfoBin = isset(KBatchBase::$taskConfig->params->mediaInfoCmd) ? KBatchBase::$taskConfig->params->mediaInfoCmd : "mediainfo";
// only extract the data if it's the primary server since we don't use this data in the secondary
if ($data->mediaServerIndex == KalturaMediaServerIndex::PRIMARY) {
try {
// get the asset to check if it has a assetParams::TAG_RECORDING_ANCHOR tag.
// note that assetParams::TAG_RECORDING_ANCHOR is not exposed in the API so I use it's string value.
KBatchBase::impersonate($job->partnerId);
$asset = KBatchBase::$kClient->flavorAsset->get($data->assetId);
KBatchBase::unimpersonate();
if (strpos($asset->tags, self::TAG_RECORDING_ANCHOR) == false) {
return;
}
// Extract AMF data from all data frames in the segment
$amfParser = new KAMFMediaInfoParser($data->srcFilePath);
$amfArray = $amfParser->getAMFInfo();
// run mediaInfo on $localTempFilePath to get it's duration, and store it in the job data
$mediaInfoParser = new KMediaInfoMediaParser($localTempFilePath, $mediaInfoBin);
$duration = $mediaInfoParser->getMediaInfo()->videoDuration;
array_unshift($amfArray, $duration);
$amfFileName = "{$data->entryId}_{$data->assetId}_{$data->mediaServerIndex}_{$data->fileIndex}.data";
$localTempAmfFilePath = $this->localTempPath . DIRECTORY_SEPARATOR . $amfFileName;
$sharedTempAmfFilePath = $this->sharedTempPath . DIRECTORY_SEPARATOR . $amfFileName;
file_put_contents($localTempAmfFilePath, serialize($amfArray));
self::moveDataFile($data, $localTempAmfFilePath, $sharedTempAmfFilePath);
} catch (Exception $ex) {
KBatchBase::unimpersonate();
KalturaLog::warning('failed to extract AMF data or duration data ' . print_r($ex));
}
}
}
/**
* Append recorded video to live entry
*
* @action appendRecording
* @param string $entryId Live entry id
* @param string $assetId Live asset id
* @param KalturaMediaServerIndex $mediaServerIndex
* @param KalturaDataCenterContentResource $resource
* @param float $duration in seconds
* @param bool $isLastChunk Is this the last recorded chunk in the current session (i.e. following a stream stop event)
* @return KalturaLiveEntry The updated live entry
*
* @throws KalturaErrors::ENTRY_ID_NOT_FOUND
*/
function appendRecordingAction($entryId, $assetId, $mediaServerIndex, KalturaDataCenterContentResource $resource, $duration, $isLastChunk = false)
{
$dbEntry = entryPeer::retrieveByPK($entryId);
if (!$dbEntry || !$dbEntry instanceof LiveEntry) {
throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
}
$dbAsset = assetPeer::retrieveById($assetId);
if (!$dbAsset || !$dbAsset instanceof liveAsset) {
throw new KalturaAPIException(KalturaErrors::ASSET_ID_NOT_FOUND, $assetId);
}
$lastDuration = 0;
$recordedEntry = null;
if ($dbEntry->getRecordedEntryId()) {
$recordedEntry = entryPeer::retrieveByPK($dbEntry->getRecordedEntryId());
if ($recordedEntry) {
if ($recordedEntry->getReachedMaxRecordingDuration()) {
KalturaLog::err("Entry [{$entryId}] has already reached its maximal recording duration.");
throw new KalturaAPIException(KalturaErrors::LIVE_STREAM_EXCEEDED_MAX_RECORDED_DURATION, $entryId);
}
// if entry is in replacement, the replacement duration is more accurate
if ($recordedEntry->getReplacedEntryId()) {
$replacementRecordedEntry = entryPeer::retrieveByPK($recordedEntry->getReplacedEntryId());
if ($replacementRecordedEntry) {
$lastDuration = $replacementRecordedEntry->getLengthInMsecs();
}
} else {
$lastDuration = $recordedEntry->getLengthInMsecs();
}
}
}
$liveSegmentDurationInMsec = (int) ($duration * 1000);
$currentDuration = $lastDuration + $liveSegmentDurationInMsec;
$maxRecordingDuration = (kConf::get('max_live_recording_duration_hours') + 1) * 60 * 60 * 1000;
if ($currentDuration > $maxRecordingDuration) {
if ($recordedEntry) {
$recordedEntry->setReachedMaxRecordingDuration(true);
$recordedEntry->save();
}
KalturaLog::err("Entry [{$entryId}] duration [" . $lastDuration . "] and current duration [{$currentDuration}] is more than max allwoed duration [{$maxRecordingDuration}]");
throw new KalturaAPIException(KalturaErrors::LIVE_STREAM_EXCEEDED_MAX_RECORDED_DURATION, $entryId);
}
$kResource = $resource->toObject();
$filename = $kResource->getLocalFilePath();
if (!$resource instanceof KalturaServerFileResource) {
$filename = kConf::get('uploaded_segment_destination') . basename($kResource->getLocalFilePath());
kFile::moveFile($kResource->getLocalFilePath(), $filename);
chgrp($filename, kConf::get('content_group'));
chmod($filename, 0640);
}
if ($dbAsset->hasTag(assetParams::TAG_RECORDING_ANCHOR) && $mediaServerIndex == KalturaMediaServerIndex::PRIMARY) {
$dbEntry->setLengthInMsecs($currentDuration);
// Extract the exact video segment duration from the recorded file
$mediaInfoParser = new KMediaInfoMediaParser($filename, kConf::get('bin_path_mediainfo'));
$recordedSegmentDurationInMsec = $mediaInfoParser->getMediaInfo()->videoDuration;
$currentSegmentVodToLiveDeltaTime = $liveSegmentDurationInMsec - $recordedSegmentDurationInMsec;
$recordedSegmentsInfo = $dbEntry->getRecordedSegmentsInfo();
$recordedSegmentsInfo->addSegment($lastDuration, $recordedSegmentDurationInMsec, $currentSegmentVodToLiveDeltaTime);
$dbEntry->setRecordedSegmentsInfo($recordedSegmentsInfo);
if ($isLastChunk) {
// Save last elapsed recording time
$dbEntry->setLastElapsedRecordingTime($currentDuration);
}
$dbEntry->save();
}
kJobsManager::addConvertLiveSegmentJob(null, $dbAsset, $mediaServerIndex, $filename, $currentDuration);
if ($mediaServerIndex == KalturaMediaServerIndex::PRIMARY) {
if (!$dbEntry->getRecordedEntryId()) {
$this->createRecordedEntry($dbEntry, $mediaServerIndex);
}
$recordedEntry = entryPeer::retrieveByPK($dbEntry->getRecordedEntryId());
if ($recordedEntry) {
$this->ingestAsset($recordedEntry, $dbAsset, $filename);
}
}
$entry = KalturaEntryFactory::getInstanceByType($dbEntry->getType());
$entry->fromObject($dbEntry, $this->getResponseProfile());
return $entry;
}
/**
* extractMediaInfo extract the file info using mediainfo and parse the returned data
*
* @param string $mediaFile file full path
* @return KalturaMediaInfo or null for failure
*/
private function extractMediaInfo($mediaFile)
{
KalturaLog::debug("extractMediaInfo({$mediaFile})");
$mediaParser = new KMediaInfoMediaParser($mediaFile, $this->taskConfig->params->mediaInfoCmd);
return $mediaParser->getMediaInfo();
}
