/*
* Copyright (C) 2005-2012 Team Kodi
* https://kodi.tv
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
*************************************************************************
* This file is a modified version from Team MediaPortal's
* TsReader DirectShow filter
* MediaPortal is a GPL'ed HTPC-Application
* Copyright (C) 2005-2012 Team MediaPortal
* http://www.team-mediaportal.com
*
* Changes compared to Team MediaPortal's version:
* - Code cleanup for PVR addon usage
* - Code refactoring for cross platform usage
*************************************************************************
* This file originates from TSFileSource, a GPL directshow push
* source filter that provides an MPEG transport stream output.
* Copyright (C) 2005-2006 nate, bear
* http://forums.dvbowners.com/
*/
#include "MultiFileReader.h"
#include //for kodi::Log
#include
#include
#include "TSDebug.h"
#include
#include "utils.h"
#include
#include
#include "os-dependent.h"
#include
//Maximum time in msec to wait for the buffer file to become available - Needed for DVB radio (this sometimes takes some time)
#define MAX_BUFFER_TIMEOUT 1500
template void SafeDelete(T*& p)
{
if (p)
{
delete p;
p = nullptr;
}
}
namespace MPTV
{
MultiFileReader::MultiFileReader() :
m_TSBufferFile(),
m_TSFile(),
m_startPosition(0),
m_currentFileStartOffset(0),
m_endPosition(0),
m_currentPosition(0),
m_lastZapPosition(0),
m_filesAdded(0),
m_filesRemoved(0),
m_TSFileId(0),
m_bDelay(0)
{
}
MultiFileReader::~MultiFileReader()
{
//CloseFile called by ~FileReader
}
long MultiFileReader::SetFileName(const std::string& fileName)
{
return m_TSBufferFile.SetFileName(fileName);
}
long MultiFileReader::OpenFile(const std::string& fileName)
{
SetFileName(fileName);
return OpenFile();
}
//
// OpenFile
//
long MultiFileReader::OpenFile()
{
// The underlying CFileStreamBuffer class used by kodi::vfs::CFile.Open() appears
// to be incompatible with the TS buffer files created by the TvServer, so disable
// the buffering.
m_TSBufferFile.SetNoBuffer();
long hResult = m_TSBufferFile.OpenFile();
kodi::Log(ADDON_LOG_DEBUG, "MultiFileReader: buffer file opened return code %d.", hResult);
if (hResult != S_OK)
return hResult;
m_lastZapPosition = 0;
m_currentFileStartOffset = 0;
int retryCount = 0;
while ((m_TSBufferFile.GetFileSize() == 0) && (retryCount < 50))
{
retryCount++;
kodi::Log(ADDON_LOG_DEBUG, "MultiFileReader: buffer file has zero length, closing, waiting 100 ms and re-opening. Attempt: %d.", retryCount);
m_TSBufferFile.CloseFile();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
hResult = m_TSBufferFile.OpenFile();
kodi::Log(ADDON_LOG_DEBUG, "MultiFileReader: buffer file opened return code %d.", hResult);
}
if (RefreshTSBufferFile() == S_FALSE)
{
// For radio the buffer sometimes needs some time to become available, so wait and try it more than once
kodi::tools::CEndTime timeout(MAX_BUFFER_TIMEOUT);
do
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
if (timeout.MillisLeft() == 0)
{
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader: timed out while waiting for buffer file to become available");
kodi::QueueNotification(QUEUE_ERROR, "", "Time out while waiting for buffer file");
return S_FALSE;
}
} while (RefreshTSBufferFile() == S_FALSE);
}
m_currentPosition = 0;
return hResult;
}
//
// CloseFile
//
long MultiFileReader::CloseFile()
{
long hr;
std::vector::iterator it;
m_TSBufferFile.CloseFile();
hr = m_TSFile.CloseFile();
for (it = m_tsFiles.begin(); it < m_tsFiles.end(); ++it)
{
delete (*it);
}
m_tsFiles.clear();
m_TSFileId = 0;
return hr;
}
bool MultiFileReader::IsFileInvalid()
{
return m_TSBufferFile.IsFileInvalid();
}
int64_t MultiFileReader::SetFilePointer(int64_t llDistanceToMove, unsigned long dwMoveMethod)
{
RefreshTSBufferFile();
if (dwMoveMethod == FILE_END)
{
m_currentPosition = m_endPosition + llDistanceToMove;
}
else if (dwMoveMethod == FILE_CURRENT)
{
m_currentPosition += llDistanceToMove;
}
else // if (dwMoveMethod == FILE_BEGIN)
{
m_currentPosition = m_startPosition + llDistanceToMove;
}
if (m_currentPosition < m_startPosition)
m_currentPosition = m_startPosition;
if (m_currentPosition > m_endPosition)
{
kodi::Log(ADDON_LOG_ERROR, "Seeking beyond the end position: %I64d > %I64d", m_currentPosition, m_endPosition);
m_currentPosition = m_endPosition;
}
return m_currentPosition;
}
int64_t MultiFileReader::SetCurrentFilePointer(int64_t timeShiftBufferFilePos, long timeshiftBufferFileID)
{
RefreshTSBufferFile();
if (m_TSFileId != timeshiftBufferFileID)
{
// We have to switch to a different buffer file
TSDEBUG(ADDON_LOG_DEBUG, "Change buffer file from %i to %i", m_TSFileId, timeshiftBufferFileID);
MultiFileReaderFile *file = NULL;
std::vector::iterator it = m_tsFiles.begin();
for (; it < m_tsFiles.end(); ++it)
{
file = *it;
if (file->filePositionId == timeshiftBufferFileID)
break;
};
if (!file)
{
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader::no buffer file with id=%i", timeshiftBufferFileID);
kodi::QueueNotification(QUEUE_ERROR, "", "No buffer file");
return m_currentPosition;
}
if (m_currentPosition < (file->startPosition + timeShiftBufferFilePos))
{
m_TSFile.CloseFile();
m_TSFile.SetFileName(file->filename.c_str());
m_TSFile.OpenFile();
m_TSFileId = file->filePositionId;
m_currentFileStartOffset = file->startPosition;
TSDEBUG(ADDON_LOG_DEBUG, "MultiFileReader::Read() Current File Changed to %s TS file id=%i\n", file->filename.c_str(), m_TSFileId);
}
}
// Reposition the read pointer within the current timeshift buffer file
TSDEBUG(ADDON_LOG_DEBUG, "Move read pointer within buffer file %i; %I64d -> %i64d", m_TSFileId, m_currentPosition, m_currentFileStartOffset + timeShiftBufferFilePos);
m_currentPosition = m_currentFileStartOffset + timeShiftBufferFilePos;
if (m_currentPosition > m_endPosition)
{
kodi::Log(ADDON_LOG_ERROR, "Seeking beyond the end position: %I64d > %I64d", m_currentPosition, m_endPosition);
m_currentPosition = m_endPosition;
}
return m_currentPosition;
}
int64_t MultiFileReader::GetFilePointer()
{
return m_currentPosition;
}
long MultiFileReader::Read(unsigned char* pbData, size_t lDataLength, size_t *dwReadBytes)
{
// If the file has already been closed, don't continue
if (m_TSBufferFile.IsFileInvalid())
return S_FALSE;
RefreshTSBufferFile();
if (m_currentPosition < m_startPosition)
{
kodi::Log(ADDON_LOG_INFO, "%s: current position adjusted from %%I64dd to %%I64dd.", __FUNCTION__, m_currentPosition, m_startPosition);
m_currentPosition = m_startPosition;
}
// Find out which file the currentPosition is in.
MultiFileReaderFile *file = NULL;
std::vector::iterator it = m_tsFiles.begin();
for (; it < m_tsFiles.end(); ++it)
{
file = *it;
if (m_currentPosition < (file->startPosition + file->length))
break;
};
// kodi::Log(ADDON_LOG_DEBUG, "%s: reading %ld bytes. File %s, start %d, current %d, end %d.", __FUNCTION__, lDataLength, file->filename.c_str(), m_startPosition, m_currentPosition, m_endPosition);
if (!file)
{
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader::no file");
kodi::QueueNotification(QUEUE_ERROR, "", "No buffer file");
return S_FALSE;
}
if (m_currentPosition < (file->startPosition + file->length))
{
if (m_TSFileId != file->filePositionId)
{
m_TSFile.CloseFile();
m_TSFile.SetFileName(file->filename.c_str());
if (m_TSFile.OpenFile() != S_OK)
{
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader: can't open %s\n", file->filename.c_str());
return S_FALSE;
}
m_TSFileId = file->filePositionId;
m_currentFileStartOffset = file->startPosition;
TSDEBUG(ADDON_LOG_DEBUG, "MultiFileReader::Read() Current File Changed to %s TS file id=%i\n", file->filename.c_str(), m_TSFileId);
}
int64_t seekPosition = m_currentPosition - file->startPosition;
m_TSFile.SetFilePointer(seekPosition, FILE_BEGIN);
int64_t posSeeked = m_TSFile.GetFilePointer();
if (posSeeked != seekPosition)
{
m_TSFile.SetFilePointer(seekPosition, FILE_BEGIN);
posSeeked = m_TSFile.GetFilePointer();
if (posSeeked != seekPosition)
{
kodi::Log(ADDON_LOG_ERROR, "SEEK FAILED");
return S_FALSE;
}
}
size_t bytesRead = 0;
long hr;
int64_t bytesToRead = file->length - seekPosition;
if ((int64_t)lDataLength > bytesToRead)
{
// kodi::Log(ADDON_LOG_DEBUG, "%s: datalength %lu bytesToRead %lli.", __FUNCTION__, lDataLength, bytesToRead);
hr = m_TSFile.Read(pbData, (size_t)bytesToRead, &bytesRead);
if (FAILED(hr))
{
kodi::Log(ADDON_LOG_ERROR, "READ FAILED1");
return S_FALSE;
}
m_currentPosition += bytesToRead;
hr = this->Read(pbData + bytesToRead, lDataLength - (size_t)bytesToRead, dwReadBytes);
if (FAILED(hr))
{
kodi::Log(ADDON_LOG_ERROR, "READ FAILED2");
}
*dwReadBytes += bytesRead;
}
else
{
hr = m_TSFile.Read(pbData, lDataLength, dwReadBytes);
if (FAILED(hr))
{
kodi::Log(ADDON_LOG_ERROR, "READ FAILED3");
}
m_currentPosition += lDataLength;
}
}
else
{
// The current position is past the end of the last file
*dwReadBytes = 0;
}
// kodi::Log(ADDON_LOG_DEBUG, "%s: read %lu bytes. start %lli, current %lli, end %lli.", __FUNCTION__, *dwReadBytes, m_startPosition, m_currentPosition, m_endPosition);
return S_OK;
}
long MultiFileReader::RefreshTSBufferFile()
{
if (m_TSBufferFile.IsFileInvalid())
{
kodi::Log(ADDON_LOG_ERROR, "%s: buffer file is invalid.", __FUNCTION__);
return S_FALSE;
}
size_t bytesRead;
MultiFileReaderFile *file;
int64_t currentPosition;
int32_t filesAdded, filesRemoved;
int32_t filesAdded2, filesRemoved2;
long Error = 0;
long Loop = 10;
Wchar_t* pBuffer = NULL;
do
{
Error = 0;
currentPosition = -1;
filesAdded = -1;
filesRemoved = -1;
filesAdded2 = -2;
filesRemoved2 = -2;
int64_t fileLength = m_TSBufferFile.GetFileSize();
// Min file length is Header ( int64_t + int32_t + int32_t ) + filelist ( > 0 ) + Footer ( int32_t + int32_t )
int64_t minimumlength = (int64_t)(sizeof(currentPosition) + sizeof(filesAdded) + sizeof(filesRemoved) + sizeof(Wchar_t) + sizeof(filesAdded2) + sizeof(filesRemoved2));
if (fileLength <= minimumlength)
{
kodi::Log(ADDON_LOG_ERROR, "%s: TSBufferFile too short. Minimum length %ld, current length %ld", __FUNCTION__, minimumlength, fileLength);
return S_FALSE;
}
m_TSBufferFile.SetFilePointer(0, FILE_BEGIN);
size_t readLength = sizeof(currentPosition) + sizeof(filesAdded) + sizeof(filesRemoved);
unsigned char* readBuffer = new unsigned char[readLength];
long result = m_TSBufferFile.Read(readBuffer, readLength, &bytesRead);
if (!SUCCEEDED(result) || bytesRead != readLength)
Error |= 0x02;
if (Error == 0)
{
currentPosition = *((int64_t*)(readBuffer + 0));
filesAdded = *((int32_t*)(readBuffer + sizeof(currentPosition)));
filesRemoved = *((int32_t*)(readBuffer + sizeof(currentPosition) + sizeof(filesAdded)));
}
delete[] readBuffer;
// If no files added or removed, break the loop !
if ((m_filesAdded == filesAdded) && (m_filesRemoved == filesRemoved))
break;
int64_t remainingLength = fileLength - sizeof(currentPosition) - sizeof(filesAdded) - sizeof(filesRemoved) - sizeof(filesAdded2) - sizeof(filesRemoved2);
// Above 100kb seems stupid and figure out a problem !!!
if (remainingLength > 100000)
Error |= 0x10;
pBuffer = (Wchar_t*) new char[(unsigned int)remainingLength];
result = m_TSBufferFile.Read((unsigned char*)pBuffer, (uint32_t)remainingLength, &bytesRead);
if (!SUCCEEDED(result) || (int64_t)bytesRead != remainingLength)
Error |= 0x20;
readLength = sizeof(filesAdded) + sizeof(filesRemoved);
readBuffer = new unsigned char[readLength];
result = m_TSBufferFile.Read(readBuffer, readLength, &bytesRead);
if (!SUCCEEDED(result) || bytesRead != readLength)
Error |= 0x40;
if (Error == 0)
{
filesAdded2 = *((int32_t*)(readBuffer + 0));
filesRemoved2 = *((int32_t*)(readBuffer + sizeof(filesAdded2)));
}
delete[] readBuffer;
if ((filesAdded2 != filesAdded) || (filesRemoved2 != filesRemoved))
{
Error |= 0x80;
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader has error 0x%x in Loop %d. Try to clear SMB Cache.", Error, 10 - Loop);
kodi::Log(ADDON_LOG_DEBUG, "%s: filesAdded %d, filesAdded2 %d, filesRemoved %d, filesRemoved2 %d.", __FUNCTION__, filesAdded, filesAdded2, filesRemoved, filesRemoved2);
// try to clear local / remote SMB file cache. This should happen when we close the filehandle
m_TSBufferFile.CloseFile();
m_TSBufferFile.OpenFile();
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
if (Error)
delete[] pBuffer;
Loop--;
} while (Error && Loop); // If Error is set, try again...until Loop reaches 0.
if (Loop < 8)
{
kodi::Log(ADDON_LOG_DEBUG, "MultiFileReader has waited %d times for TSbuffer integrity.", 10 - Loop);
if (Error)
{
kodi::Log(ADDON_LOG_ERROR, "MultiFileReader has failed for TSbuffer integrity. Error : %x", Error);
return E_FAIL;
}
}
if ((m_filesAdded != filesAdded) || (m_filesRemoved != filesRemoved))
{
int32_t filesToRemove = filesRemoved - m_filesRemoved;
int32_t filesToAdd = filesAdded - m_filesAdded;
int32_t fileID = filesRemoved;
int64_t nextStartPosition = 0;
TSDEBUG(ADDON_LOG_DEBUG, "MultiFileReader: Files Added %i, Removed %i\n", filesToAdd, filesToRemove);
// Removed files that aren't present anymore.
while ((filesToRemove > 0) && (!m_tsFiles.empty()))
{
file = m_tsFiles.at(0);
TSDEBUG(ADDON_LOG_DEBUG, "MultiFileReader: Removing file %s\n", file->filename.c_str());
SafeDelete(file);
m_tsFiles.erase(m_tsFiles.begin());
filesToRemove--;
}
// Figure out what the start position of the next new file will be
if (!m_tsFiles.empty())
{
file = m_tsFiles.back();
if (filesToAdd > 0)
{
// If we're adding files the changes are the one at the back has a partial length
// so we need update it.
GetFileLength(file->filename.c_str(), file->length);
}
nextStartPosition = file->startPosition + file->length;
}
// Get the real path of the buffer file
std::string sFilename;
std::string path;
m_TSBufferFile.GetFileName(sFilename);
//size_t pos = sFilename.find_last_of(PATH_SEPARATOR_CHAR);
size_t pos = sFilename.find_last_of('/');
path = sFilename.substr(0, pos + 1);
// Create a list of files in the .tsbuffer file.
std::vector filenames;
Wchar_t* pwCurrFile = pBuffer; //Get a pointer to the first wchar filename string in pBuffer
size_t length = WcsLen(pwCurrFile);
//kodi::Log(ADDON_LOG_DEBUG, "%s: WcsLen(%d), sizeof(Wchar_t) == %d sizeof(wchar_t) == %d.", __FUNCTION__, length, sizeof(Wchar_t), sizeof(wchar_t));
while (length > 0)
{
// Convert the current filename (wchar to normal char)
char* wide2normal = new char[length + 1];
WcsToMbs(wide2normal, pwCurrFile, length);
wide2normal[length] = '\0';
std::string sCurrFile = wide2normal;
//kodi::Log(ADDON_LOG_DEBUG, "%s: filename %s (%s).", __FUNCTION__, wide2normal, sCurrFile.c_str());
delete[] wide2normal;
// Modify filename path here to include the real (local) path
pos = sCurrFile.find_last_of(92);
std::string name = sCurrFile.substr(pos + 1);
if (path.length() > 0 && name.length() > 0)
{
// Replace the original path with our local path
filenames.push_back(path + name);
}
else
{
// Keep existing path
filenames.push_back(sCurrFile);
}
// Move the wchar buffer pointer to the next wchar string
pwCurrFile += (length + 1);
length = WcsLen(pwCurrFile);
}
// Go through files
std::vector::iterator itFiles = m_tsFiles.begin();
std::vector::iterator itFilenames = filenames.begin();
while (itFiles < m_tsFiles.end())
{
file = *itFiles;
++itFiles;
fileID++;
if (itFilenames < filenames.end())
{
// TODO: Check that the filenames match. ( Ambass : With buffer integrity check, probably no need to do this !)
++itFilenames;
}
else
{
kodi::Log(ADDON_LOG_DEBUG, "MultiFileReader: Missing files!!\n");
}
}
while (itFilenames < filenames.end())
{
std::string pFilename = *itFilenames;
TSDEBUG(ADDON_LOG_DEBUG, "%s: Adding file %s (%" PRId64 ")\n", __FUNCTION__, pFilename.c_str(), nextStartPosition);
file = new MultiFileReaderFile();
file->filename = pFilename;
file->startPosition = nextStartPosition;
fileID++;
file->filePositionId = fileID;
GetFileLength(file->filename.c_str(), file->length);
m_tsFiles.push_back(file);
nextStartPosition = file->startPosition + file->length;
++itFilenames;
}
m_filesAdded = filesAdded;
m_filesRemoved = filesRemoved;
delete[] pBuffer;
}
if (!m_tsFiles.empty())
{
file = m_tsFiles.front();
m_startPosition = file->startPosition;
// Since the buffer file may be re-used when a channel is changed, we
// want the start position to reflect the position in the file after the last
// channel change, or the real start position, whichever is larger
if (m_lastZapPosition > m_startPosition)
{
m_startPosition = m_lastZapPosition;
}
file = m_tsFiles.back();
file->length = currentPosition;
m_endPosition = file->startPosition + currentPosition;
TSDEBUG(ADDON_LOG_DEBUG, "StartPosition %lli, EndPosition %lli, CurrentPosition %lli\n", m_startPosition, m_endPosition, m_currentPosition);
}
else
{
m_startPosition = 0;
m_endPosition = 0;
}
return S_OK;
}
long MultiFileReader::GetFileLength(const char* pFilename, int64_t &length)
{
//USES_CONVERSION;
length = 0;
// Try to open the file
kodi::vfs::CFile hFile;
if (hFile.OpenFile(pFilename, 0))
{
length = hFile.GetLength();
}
else
{
kodi::Log(ADDON_LOG_ERROR, "Failed to open file %s : 0x%x(%s)\n", pFilename, errno, strerror(errno));
kodi::QueueFormattedNotification(QUEUE_ERROR, "Failed to open file %s", pFilename);
return S_FALSE;
}
return S_OK;
}
int64_t MultiFileReader::GetFileSize()
{
RefreshTSBufferFile();
return m_endPosition - m_startPosition;
}
int64_t MultiFileReader::OnChannelChange(void)
{
m_lastZapPosition = m_currentPosition;
return m_currentPosition;
}
}