/* * Copyright (C) 2005-2013 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 "DeMultiplexer.h" #include "utils.h" //UNUSED() #include //for kodi::Log #include "TSReader.h" #include #define MAX_BUF_SIZE 8000 #define BUFFER_LENGTH 0x1000 #define READ_SIZE (1316*30) #define INITIAL_READ_SIZE (READ_SIZE * 1024) namespace MPTV { CDeMultiplexer::CDeMultiplexer(CTsReader& filter) :m_filter(filter), m_LastDataFromRtsp(0), m_bEndOfFile(false), m_reader(NULL), m_iPatVersion(-1), m_ReqPatVersion(-1), m_WaitNewPatTmo(0), m_receivedPackets(0), m_bStarting(false), m_bAudioAtEof(false), m_bVideoAtEof(false), m_bGotNewChannel(false) { m_patParser.SetCallBack(this); } CDeMultiplexer::~CDeMultiplexer() { } /// Starts the demuxer /// This method will read the file until we found the pat/sdt /// with all the audio/video pids void CDeMultiplexer::Start() { //reset some values m_bStarting = true; m_receivedPackets = 0; m_bEndOfFile = false; m_iPatVersion = -1; m_ReqPatVersion = -1; unsigned long long m_Time = GetTickCount64(); while ((GetTickCount64() - m_Time) < 5000 && m_bGotNewChannel == false) { size_t BytesRead = ReadFromFile(); if (0 == BytesRead) std::this_thread::sleep_for(std::chrono::milliseconds(10)); } m_bStarting = false; } void CDeMultiplexer::SetFileReader(FileReader* reader) { m_reader = reader; } /// This method reads the next READ_SIZE bytes from the file /// and processes the raw data /// When a TS packet has been discovered, OnTsPacket(byte* tsPacket) gets called // which in its turn deals with the packet size_t CDeMultiplexer::ReadFromFile() { if (m_filter.IsSeeking()) return 0; // Ambass : to check std::lock_guard lock(m_sectionRead); if (NULL == m_reader) return 0; byte buffer[READ_SIZE]; size_t dwReadBytes = 0; // if we are playing a RTSP stream if (m_reader->IsBuffer()) { // and, the current buffer holds data size_t nBytesToRead = m_reader->HasData(); if (nBytesToRead > sizeof(buffer)) { nBytesToRead = sizeof(buffer); } else { m_bAudioAtEof = true; m_bVideoAtEof = true; } if (nBytesToRead) { // then read raw data from the buffer if (SUCCEEDED(m_reader->Read(buffer, nBytesToRead, &dwReadBytes))) { if (dwReadBytes > 0) { // yes, then process the raw data //result=true; OnRawData(buffer, dwReadBytes); m_LastDataFromRtsp = GetTickCount64(); } } else { kodi::Log(ADDON_LOG_DEBUG, "%s: Read failed...", __FUNCTION__); } } else { if (!m_filter.IsTimeShifting()) { kodi::Log(ADDON_LOG_DEBUG, "%s: endoffile... %llu", __FUNCTION__, GetTickCount64() - m_LastDataFromRtsp); //set EOF flag and return if (GetTickCount64() - m_LastDataFromRtsp > 2000 && m_filter.State() != State_Paused) // A bit crappy, but no better idea... { kodi::Log(ADDON_LOG_DEBUG, "%s: endoffile!", __FUNCTION__); m_bEndOfFile = true; return 0; } } } return dwReadBytes; } else { // playing a local file. // read raw data from the file if (SUCCEEDED(m_reader->Read(buffer, sizeof(buffer), &dwReadBytes))) { if ((m_filter.IsTimeShifting()) && (dwReadBytes < sizeof(buffer))) { m_bAudioAtEof = true; m_bVideoAtEof = true; } if (dwReadBytes > 0) { // succeeded, process data OnRawData(buffer, (int)dwReadBytes); } else { if (!m_filter.IsTimeShifting()) { // set EOF flag and return kodi::Log(ADDON_LOG_DEBUG, "%s: endoffile!", __FUNCTION__); m_bEndOfFile = true; return 0; } } // and return return dwReadBytes; } else { kodi::Log(ADDON_LOG_DEBUG, "%s: Read failed...", __FUNCTION__); } } return 0; } /// This method gets called via ReadFile() when a new TS packet has been received /// if will : /// - decode any new pat/pmt/sdt /// - decode any audio/video packets and put the PES packets in the appropiate buffers void CDeMultiplexer::OnTsPacket(byte* tsPacket) { CTsHeader header(tsPacket); m_patParser.OnTsPacket(tsPacket); if (m_iPatVersion == -1) { // First Pat not found return; } // Wait for new PAT if required. if ((m_iPatVersion & 0x0F) != (m_ReqPatVersion & 0x0F)) { if (m_ReqPatVersion == -1) { // Now, unless channel change, m_ReqPatVersion = m_iPatVersion; // Initialize Pat Request. m_WaitNewPatTmo = GetTickCount64(); // Now, unless channel change request,timeout will be always true. } if (GetTickCount64() < m_WaitNewPatTmo) { // Timeout not reached. return; } } } void CDeMultiplexer::RequestNewPat(void) { if (m_reader) { m_ReqPatVersion++; m_ReqPatVersion &= 0x0F; kodi::Log(ADDON_LOG_DEBUG, "Request new PAT = %d", m_ReqPatVersion); m_WaitNewPatTmo = GetTickCount64() + 10000; size_t dwBytesProcessed = 0; unsigned long long m_Time = GetTickCount64(); m_bGotNewChannel = false; while ((GetTickCount64() - m_Time) < 5000 && m_bGotNewChannel == false) { size_t BytesRead = ReadFromFile(); if (0 == BytesRead) std::this_thread::sleep_for(std::chrono::milliseconds(10)); dwBytesProcessed += BytesRead; } kodi::Log(ADDON_LOG_DEBUG, "Found a new channel after processing %li bytes. File position: %I64d\n", dwBytesProcessed, m_reader->GetFilePointer()); } } /// This method gets called-back from the pat parser when a new PAT/PMT/SDT has been received /// In this method we check if any audio/video/subtitle pid or format has changed /// If not, we simply return /// If something has changed we ask the MP to rebuild the graph void CDeMultiplexer::OnNewChannel(CChannelInfo& UNUSED(info)) { m_bGotNewChannel = true; } }