int omxplayer_StartPlaying(const char *filename)
{
char fullVideoPath[2048];
LogDebug(VB_MEDIAOUT, "omxplayer_StartPlaying(%s)\n", filename);
bzero(&mediaOutputStatus, sizeof(mediaOutputStatus));
if (snprintf(fullVideoPath, 2048, "%s/%s", getVideoDirectory(), filename)
>= 2048)
{
LogErr(VB_MEDIAOUT, "Unable to play %s, full path name too long\n",
filename);
return 0;
}
if (getFPPmode() == REMOTE_MODE)
CheckForHostSpecificFile(getSetting("HostName"), fullVideoPath);
if (!FileExists(fullVideoPath))
{
LogErr(VB_MEDIAOUT, "%s does not exist!\n", fullVideoPath);
return 0;
}
// Create Pipes to/from omxplayer
pid_t omxplayerPID = forkpty(&pipeFromOMX[0], 0, 0, 0);
if (omxplayerPID == 0) // omxplayer process
{
ShutdownControlSocket();
seteuid(1000); // 'pi' user
execl("/opt/fpp/scripts/omxplayer", "/opt/fpp/scripts/omxplayer", fullVideoPath, NULL);
LogErr(VB_MEDIAOUT, "omxplayer_StartPlaying(), ERROR, we shouldn't "
"be here, this means that execl() failed\n");
exit(EXIT_FAILURE);
}
else // Parent process
{
mediaOutput->childPID = omxplayerPID;
}
// Clear active file descriptor sets
FD_ZERO (&omx_active_fd_set);
// Set description for reading from omxplayer
FD_SET (pipeFromOMX[0], &omx_active_fd_set);
mediaOutputStatus.status = MEDIAOUTPUTSTATUS_PLAYING;
omxVolumeShift = omxplayer_GetVolumeShift(getVolume());
return 1;
}
/*
* Initialize effects constructs
*/
int InitEffects(void)
{
std::string localFilename = getEffectDirectory();
localFilename += "/background.eseq";
if ((getFPPmode() == REMOTE_MODE) &&
CheckForHostSpecificFile(getSetting("HostName"), localFilename)) {
localFilename = "background_";
localFilename += getSetting("HostName");
LogInfo(VB_EFFECT, "Automatically starting background effect "
"sequence %s\n", localFilename.c_str());
StartEffect(localFilename.c_str(), 0, 1);
} else if (FileExists(localFilename)) {
LogInfo(VB_EFFECT, "Automatically starting background effect sequence "
"background.eseq\n");
StartEffect("background", 0, 1);
}
pauseBackgroundEffects = getSettingInt("pauseBackgroundEffects");
return 1;
}
int Sequence::OpenSequenceFile(const char *filename, int startSeconds) {
LogDebug(VB_SEQUENCE, "OpenSequenceFile(%s, %d)\n", filename, startSeconds);
if (!filename || !filename[0])
{
LogErr(VB_SEQUENCE, "Empty Sequence Filename!\n", filename);
return 0;
}
size_t bytesRead = 0;
m_seqFileSize = 0;
if (IsSequenceRunning())
CloseSequenceFile();
m_seqStarting = 1;
m_seqPaused = 0;
m_seqDuration = 0;
m_seqSecondsElapsed = 0;
m_seqSecondsRemaining = 0;
strcpy(m_seqFilename, filename);
char tmpFilename[2048];
unsigned char tmpData[2048];
strcpy(tmpFilename,(const char *)getSequenceDirectory());
strcat(tmpFilename,"/");
strcat(tmpFilename, filename);
if (getFPPmode() == REMOTE_MODE)
CheckForHostSpecificFile(getSetting("HostName"), tmpFilename);
if (!FileExists(tmpFilename))
{
LogErr(VB_SEQUENCE, "Sequence file %s does not exist\n", tmpFilename);
m_seqStarting = 0;
return 0;
}
m_seqFile = fopen((const char *)tmpFilename, "r");
if (m_seqFile == NULL)
{
LogErr(VB_SEQUENCE, "Error opening sequence file: %s. fopen returned NULL\n",
tmpFilename);
m_seqStarting = 0;
return 0;
}
if (getFPPmode() == MASTER_MODE)
{
SendSeqSyncStartPacket(filename);
// Give the remotes a head start spining up so they are ready
usleep(100000);
}
///////////////////////////////////////////////////////////////////////
// Check 4-byte File format identifier
char seqFormatID[5];
strcpy(seqFormatID, " ");
bytesRead = fread(seqFormatID, 1, 4, m_seqFile);
seqFormatID[4] = 0;
if ((bytesRead != 4) || (strcmp(seqFormatID, "PSEQ") && strcmp(seqFormatID, "FSEQ")))
{
LogErr(VB_SEQUENCE, "Error opening sequence file: %s. Incorrect File Format header: '%s', bytesRead: %d\n",
filename, seqFormatID, bytesRead);
fseek(m_seqFile, 0L, SEEK_SET);
bytesRead = fread(tmpData, 1, DATA_DUMP_SIZE, m_seqFile);
HexDump("Sequence File head:", tmpData, bytesRead);
fclose(m_seqFile);
m_seqFile = NULL;
m_seqStarting = 0;
return 0;
}
///////////////////////////////////////////////////////////////////////
// Get Channel Data Offset
bytesRead = fread(tmpData, 1, 2, m_seqFile);
if (bytesRead != 2)
{
LogErr(VB_SEQUENCE, "Sequence file %s too short, unable to read channel data offset value\n", filename);
fseek(m_seqFile, 0L, SEEK_SET);
bytesRead = fread(tmpData, 1, DATA_DUMP_SIZE, m_seqFile);
HexDump("Sequence File head:", tmpData, bytesRead);
fclose(m_seqFile);
m_seqFile = NULL;
m_seqStarting = 0;
return 0;
}
m_seqChanDataOffset = tmpData[0] + (tmpData[1] << 8);
///////////////////////////////////////////////////////////////////////
// Now that we know the header size, read the whole header in one shot
fseek(m_seqFile, 0L, SEEK_SET);
bytesRead = fread(tmpData, 1, m_seqChanDataOffset, m_seqFile);
if (bytesRead != m_seqChanDataOffset)
{
LogErr(VB_SEQUENCE, "Sequence file %s too short, unable to read fixed header size value\n", filename);
fseek(m_seqFile, 0L, SEEK_SET);
bytesRead = fread(tmpData, 1, DATA_DUMP_SIZE, m_seqFile);
HexDump("Sequence File head:", tmpData, bytesRead);
fclose(m_seqFile);
m_seqFile = NULL;
m_seqStarting = 0;
return 0;
}
m_seqVersionMinor = tmpData[6];
m_seqVersionMajor = tmpData[7];
m_seqVersion = (m_seqVersionMajor * 256) + m_seqVersionMinor;
m_seqFixedHeaderSize =
(tmpData[8]) + (tmpData[9] << 8);
m_seqStepSize =
(tmpData[10]) + (tmpData[11] << 8) +
(tmpData[12] << 16) + (tmpData[13] << 24);
m_seqNumPeriods =
(tmpData[14]) + (tmpData[15] << 8) +
(tmpData[16] << 16) + (tmpData[17] << 24);
m_seqStepTime =
(tmpData[18]) + (tmpData[19] << 8);
m_seqNumUniverses =
(tmpData[20]) + (tmpData[21] << 8);
m_seqUniverseSize =
(tmpData[22]) + (tmpData[23] << 8);
m_seqGamma = tmpData[24];
m_seqColorEncoding = tmpData[25];
// End of v1.0 fields
if (m_seqVersion > 0x0100)
{
}
m_seqRefreshRate = 1000 / m_seqStepTime;
fseek(m_seqFile, 0L, SEEK_END);
m_seqFileSize = ftell(m_seqFile);
m_seqDuration = (int)((float)(m_seqFileSize - m_seqChanDataOffset)
/ ((float)m_seqStepSize * (float)m_seqRefreshRate));
m_seqSecondsRemaining = m_seqDuration;
fseek(m_seqFile, m_seqChanDataOffset, SEEK_SET);
m_seqFilePosition = m_seqChanDataOffset;
LogDebug(VB_SEQUENCE, "Sequence File Information\n");
LogDebug(VB_SEQUENCE, "seqFilename : %s\n", m_seqFilename);
LogDebug(VB_SEQUENCE, "seqVersion : %d.%d\n",
m_seqVersionMajor, m_seqVersionMinor);
LogDebug(VB_SEQUENCE, "seqFormatID : %s\n", seqFormatID);
LogDebug(VB_SEQUENCE, "seqChanDataOffset : %d\n", m_seqChanDataOffset);
LogDebug(VB_SEQUENCE, "seqFixedHeaderSize : %d\n", m_seqFixedHeaderSize);
LogDebug(VB_SEQUENCE, "seqStepSize : %d\n", m_seqStepSize);
LogDebug(VB_SEQUENCE, "seqNumPeriods : %d\n", m_seqNumPeriods);
LogDebug(VB_SEQUENCE, "seqStepTime : %dms\n", m_seqStepTime);
LogDebug(VB_SEQUENCE, "seqNumUniverses : %d *\n", m_seqNumUniverses);
LogDebug(VB_SEQUENCE, "seqUniverseSize : %d *\n", m_seqUniverseSize);
LogDebug(VB_SEQUENCE, "seqGamma : %d *\n", m_seqGamma);
LogDebug(VB_SEQUENCE, "seqColorEncoding : %d *\n", m_seqColorEncoding);
LogDebug(VB_SEQUENCE, "seqRefreshRate : %d\n", m_seqRefreshRate);
LogDebug(VB_SEQUENCE, "seqFileSize : %lu\n", m_seqFileSize);
LogDebug(VB_SEQUENCE, "seqDuration : %d\n", m_seqDuration);
LogDebug(VB_SEQUENCE, "'*' denotes field is currently ignored by FPP\n");
m_seqPaused = 0;
m_seqSingleStep = 0;
m_seqSingleStepBack = 0;
int frameNumber = 0;
if (startSeconds)
{
int frameNumber = startSeconds * m_seqRefreshRate;
int newPos = m_seqChanDataOffset + (frameNumber * m_seqStepSize);
LogDebug(VB_SEQUENCE, "Seeking to byte %d in %s\n", newPos, m_seqFilename);
fseek(m_seqFile, newPos, SEEK_SET);
}
ReadSequenceData();
SetChannelOutputFrameNumber(frameNumber);
SetChannelOutputRefreshRate(m_seqRefreshRate);
StartChannelOutputThread();
m_seqStarting = 0;
return m_seqFileSize;
}
