DemuxPacket* CDVDDemuxClient::Read()
{
if (!m_IDemux)
return nullptr;
DemuxPacket* pPacket = m_IDemux->ReadDemux();
if (!pPacket)
{
return nullptr;
}
if (pPacket->iStreamId == DMX_SPECIALID_STREAMINFO)
{
RequestStreams();
CDVDDemuxUtils::FreeDemuxPacket(pPacket);
return CDVDDemuxUtils::AllocateDemuxPacket(0);
}
else if (pPacket->iStreamId == DMX_SPECIALID_STREAMCHANGE)
{
RequestStreams();
}
else if (pPacket->iStreamId >= 0 &&
pPacket->iStreamId < MAX_STREAMS &&
m_streams[pPacket->iStreamId])
{
ParsePacket(pPacket);
}
return pPacket;
}
DemuxPacket* CDVDDemuxClient::Read()
{
if (!m_IDemux)
return nullptr;
if (m_packet)
return m_packet.release();
m_packet.reset(m_IDemux->ReadDemux());
if (!m_packet)
{
return nullptr;
}
if (m_packet->iStreamId == DMX_SPECIALID_STREAMINFO)
{
RequestStreams();
CDVDDemuxUtils::FreeDemuxPacket(m_packet.release());
return CDVDDemuxUtils::AllocateDemuxPacket(0);
}
else if (m_packet->iStreamId == DMX_SPECIALID_STREAMCHANGE)
{
RequestStreams();
}
else if (m_packet->iStreamId >= 0 && m_streams.count(m_packet->iStreamId) > 0)
{
if (ParsePacket(m_packet.get()))
{
RequestStreams();
DemuxPacket *pPacket = CDVDDemuxUtils::AllocateDemuxPacket(0);
pPacket->iStreamId = DMX_SPECIALID_STREAMCHANGE;
pPacket->demuxerId = m_demuxerId;
return pPacket;
}
}
CDVDInputStream::IDisplayTime *inputStream = m_pInput->GetIDisplayTime();
if (inputStream)
{
int dispTime = inputStream->GetTime();
if (m_displayTime != dispTime)
{
m_displayTime = dispTime;
if (m_packet->dts != DVD_NOPTS_VALUE)
{
m_dtsAtDisplayTime = m_packet->dts;
}
}
if (m_dtsAtDisplayTime != DVD_NOPTS_VALUE && m_packet->dts != DVD_NOPTS_VALUE)
{
m_packet->dispTime = m_displayTime;
m_packet->dispTime += DVD_TIME_TO_MSEC(m_packet->dts - m_dtsAtDisplayTime);
}
}
return m_packet.release();
}
bool CDVDDemuxPVRClient::Open(CDVDInputStream* pInput)
{
Abort();
m_pInput = pInput;
RequestStreams();
return true;
}
bool RequestTracker::Remove(std::shared_ptr<CaptureRequest> request) {
if (!request) {
return false;
}
// Get the request.
const auto frame_number_request =
frames_in_flight_.find(request->frame_number);
if (frame_number_request == frames_in_flight_.end()) {
ALOGE("%s: Frame %u is not in flight.", __func__, request->frame_number);
return false;
} else if (request != frame_number_request->second) {
ALOGE(
"%s: Request for frame %u cannot be removed: "
"does not matched the stored request.",
__func__,
request->frame_number);
return false;
}
frames_in_flight_.erase(frame_number_request);
// Decrement the counts of used streams.
for (const auto stream : RequestStreams(*request)) {
--buffers_in_flight_[stream];
}
return true;
}
DemuxPacket* CDVDDemuxClient::Read()
{
if (!m_IDemux)
return nullptr;
DemuxPacket* pPacket = m_IDemux->ReadDemux();
if (!pPacket)
{
return nullptr;
}
if (pPacket->iStreamId == DMX_SPECIALID_STREAMINFO)
{
RequestStreams();
CDVDDemuxUtils::FreeDemuxPacket(pPacket);
return CDVDDemuxUtils::AllocateDemuxPacket(0);
}
else if (pPacket->iStreamId == DMX_SPECIALID_STREAMCHANGE)
{
RequestStreams();
}
else if (pPacket->iStreamId >= 0 &&
m_streams[pPacket->iStreamId])
{
ParsePacket(pPacket);
}
CDVDInputStream::IDisplayTime *inputStream = m_pInput->GetIDisplayTime();
if (inputStream)
{
int dispTime = inputStream->GetTime();
if (m_displayTime != dispTime)
{
m_displayTime = dispTime;
if (pPacket->dts != DVD_NOPTS_VALUE)
{
m_dtsAtDisplayTime = pPacket->dts;
}
}
if (m_dtsAtDisplayTime != DVD_NOPTS_VALUE && pPacket->dts != DVD_NOPTS_VALUE)
{
pPacket->dispTime = m_displayTime;
pPacket->dispTime += DVD_TIME_TO_MSEC(pPacket->dts - m_dtsAtDisplayTime);
}
}
return pPacket;
}
bool CDVDDemuxClient::Open(CDVDInputStream* pInput)
{
Abort();
m_pInput = pInput;
m_IDemux = dynamic_cast<CDVDInputStream::IDemux*>(m_pInput);
if (!m_IDemux)
return false;
if (!m_IDemux->OpenDemux())
return false;
RequestStreams();
return true;
}
bool RequestTracker::Add(std::shared_ptr<CaptureRequest> request) {
if (!CanAddRequest(*request)) {
return false;
}
// Add to the count for each stream used.
for (const auto stream : RequestStreams(*request)) {
++buffers_in_flight_[stream];
}
// Store the request.
frames_in_flight_[request->frame_number] = request;
return true;
}
bool CDVDDemuxClient::Open(std::shared_ptr<CDVDInputStream> pInput)
{
Abort();
m_pInput = pInput;
m_IDemux = std::dynamic_pointer_cast<CDVDInputStream::IDemux>(m_pInput);
if (!m_IDemux)
return false;
if (!m_IDemux->OpenDemux())
return false;
RequestStreams();
m_displayTime = 0;
m_dtsAtDisplayTime = DVD_NOPTS_VALUE;
return true;
}
bool CDVDDemuxClient::Open(CDVDInputStream* pInput)
{
Abort();
m_pInput = pInput;
m_IDemux = dynamic_cast<CDVDInputStream::IDemux*>(m_pInput);
if (!m_IDemux)
return false;
if (!m_IDemux->OpenDemux())
return false;
RequestStreams();
m_displayTime = 0;
m_dtsAtDisplayTime = DVD_NOPTS_VALUE;
return true;
}
bool RequestTracker::CanAddRequest(const CaptureRequest& request) const {
// Check that it's not a duplicate.
if (frames_in_flight_.count(request.frame_number) > 0) {
ALOGE("%s: Already tracking a request with frame number %d.",
__func__,
request.frame_number);
return false;
}
// Check that each stream has space
// (which implicitly checks if it is configured).
bool result = true;
for (const auto stream : RequestStreams(request)) {
if (StreamFull(stream)) {
ALOGE("%s: Stream %p is full.", __func__, stream);
return false;
}
}
return true;
}
