void CDXVADecoderH264::CopyBitstream(BYTE* pDXVABuffer, BYTE* pBuffer, UINT& nSize)
{
CH264Nalu Nalu;
int nDummy;
int nSlices = 0;
UINT m_nSize = nSize;
int slice_step = 1;
int nDxvaNalLength;
while (!nSlices && slice_step <= 2) {
Nalu.SetBuffer(pBuffer, m_nSize, slice_step == 1 ? m_nNALLength : 0);
nSize = 0;
while (Nalu.ReadNext()) {
switch (Nalu.GetType()) {
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
// Skip the NALU if the data length is below 0
if (Nalu.GetDataLength() < 0) {
break;
}
// For AVC1, put startcode 0x000001
pDXVABuffer[0] = pDXVABuffer[1] = 0;
pDXVABuffer[2] = 1;
// Copy NALU
__try {
memcpy(pDXVABuffer + 3, Nalu.GetDataBuffer(), Nalu.GetDataLength());
} __except (EXCEPTION_EXECUTE_HANDLER) {
break;
}
// Update slice control buffer
nDxvaNalLength = (int)Nalu.GetDataLength() + 3;
m_pSliceShort[nSlices].BSNALunitDataLocation = nSize;
m_pSliceShort[nSlices].SliceBytesInBuffer = nDxvaNalLength;
nSize += nDxvaNalLength;
pDXVABuffer += nDxvaNalLength;
nSlices++;
break;
}
}
slice_step++;
}
// Complete with zero padding (buffer size should be a multiple of 128)
nDummy = 128 - (nSize % 128);
memset(pDXVABuffer, 0, nDummy);
m_pSliceShort[nSlices - 1].SliceBytesInBuffer += nDummy;
nSize += nDummy;
}
HRESULT CDXVADecoderH264_DXVA1::CopyBitstream(BYTE* pDXVABuffer, BYTE* pBuffer, UINT& nSize, UINT nDXVASize/* = UINT_MAX*/)
{
CH264Nalu Nalu;
UINT m_nSize = nSize;
int nDxvaNalLength;
m_nSlices = 0;
Nalu.SetBuffer(pBuffer, m_nSize, m_nNALLength);
nSize = 0;
while (Nalu.ReadNext()) {
switch (Nalu.GetType()) {
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
// Skip the NALU if the data length is below 0
if ((int)Nalu.GetDataLength() < 0) {
break;
}
// For AVC1, put startcode 0x000001
pDXVABuffer[0] = pDXVABuffer[1] = 0; pDXVABuffer[2] = 1;
// Copy NALU
memcpy_sse(pDXVABuffer + 3, Nalu.GetDataBuffer(), Nalu.GetDataLength());
// Update slice control buffer
nDxvaNalLength = Nalu.GetDataLength() + 3;
m_pSliceShort[m_nSlices].BSNALunitDataLocation = nSize;
m_pSliceShort[m_nSlices].SliceBytesInBuffer = nDxvaNalLength;
nSize += nDxvaNalLength;
pDXVABuffer += nDxvaNalLength;
m_nSlices++;
break;
}
}
// Complete bitstream buffer with zero padding (buffer size should be a multiple of 128)
if (nSize % 128) {
int nDummy = 128 - (nSize % 128);
memset(pDXVABuffer, 0, nDummy);
m_pSliceShort[m_nSlices-1].SliceBytesInBuffer += nDummy;
nSize += nDummy;
}
return S_OK;
}
HRESULT CH264SequenceParser::ParseNALs(const BYTE *buffer, size_t buflen, int nal_size)
{
CH264Nalu nalu;
nalu.SetBuffer(buffer, buflen, nal_size);
while (nalu.ReadNext()) {
const BYTE *data = nalu.GetDataBuffer() + 1;
const size_t len = nalu.GetDataLength() - 1;
if (nalu.GetType() == NALU_TYPE_SPS) {
ParseSPS(data, len);
break;
}
}
return S_OK;
}
size_t avc_parse_annexb(BYTE *extra, int extrasize, BYTE *dst)
{
size_t dstSize = 0;
CH264Nalu Nalu;
Nalu.SetBuffer(extra, extrasize, 0);
while (Nalu.ReadNext()) {
if (Nalu.GetType() == NALU_TYPE_SPS || Nalu.GetType() == NALU_TYPE_PPS) {
size_t len = Nalu.GetDataLength();
AV_WB16(dst+dstSize, (uint16_t)len);
dstSize += 2;
memcpy(dst+dstSize, Nalu.GetDataBuffer(), Nalu.GetDataLength());
dstSize += Nalu.GetDataLength();
}
}
return dstSize;
}
void CDXVADecoderH264::CopyBitstream(BYTE* pDXVABuffer, BYTE* pBuffer, UINT& nSize)
{
CH264Nalu Nalu;
int nDummy;
int nSlices = 0;
int nDxvaNalLength;
Nalu.SetBuffer (pBuffer, nSize, m_nNALLength);
nSize = 0;
{
while (Nalu.ReadNext())
{
switch (Nalu.GetType())
{
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
// For AVC1, put startcode 0x000001
pDXVABuffer[0]=pDXVABuffer[1]=0;pDXVABuffer[2]=1;
// Copy NALU
memcpy (pDXVABuffer+3, Nalu.GetDataBuffer(), Nalu.GetDataLength());
// Update slice control buffer
nDxvaNalLength = Nalu.GetDataLength()+3;
m_pSliceShort[nSlices].BSNALunitDataLocation = nSize;
m_pSliceShort[nSlices].SliceBytesInBuffer = nDxvaNalLength;
nSize += nDxvaNalLength;
pDXVABuffer += nDxvaNalLength;
nSlices++;
break;
}
}
// Complete with zero padding (buffer size should be a multiple of 128)
nDummy = 128 - (nSize %128);
memset (pDXVABuffer, 0, nDummy);
m_pSliceShort[nSlices-1].SliceBytesInBuffer += nDummy;
nSize += nDummy;
}
}
HRESULT CDXVADecoderH264::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop)
{
HRESULT hr = S_FALSE;
UINT nSlices = 0;
int nSurfaceIndex = -1;
int nFieldType = -1;
int nSliceType = -1;
int nFramePOC = INT_MIN;
int nOutPOC = INT_MIN;
REFERENCE_TIME rtOutStart = _I64_MIN;
CH264Nalu Nalu;
UINT nNalOffset = 0;
CComPtr<IMediaSample> pSampleToDeliver;
CComQIPtr<IMPCDXVA2Sample> pDXVA2Sample;
int slice_step = 1;
if (FFH264DecodeBuffer(m_pFilter->GetAVCtx(), pDataIn, nSize, &nFramePOC, &nOutPOC, &rtOutStart) == -1) {
return S_FALSE;
}
while (!nSlices && slice_step <= 2) {
Nalu.SetBuffer(pDataIn, nSize, slice_step == 1 ? m_nNALLength : 0);
while (Nalu.ReadNext()) {
switch (Nalu.GetType()) {
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
if (m_bUseLongSlice) {
m_pSliceLong[nSlices].BSNALunitDataLocation = nNalOffset;
m_pSliceLong[nSlices].SliceBytesInBuffer = (UINT)Nalu.GetDataLength() + 3; //.GetRoundedDataLength();
m_pSliceLong[nSlices].slice_id = nSlices;
FF264UpdateRefFrameSliceLong(&m_DXVAPicParams, &m_pSliceLong[nSlices], m_pFilter->GetAVCtx());
if (nSlices > 0) {
m_pSliceLong[nSlices - 1].NumMbsForSlice = m_pSliceLong[nSlices].NumMbsForSlice = m_pSliceLong[nSlices].first_mb_in_slice - m_pSliceLong[nSlices - 1].first_mb_in_slice;
}
}
nSlices++;
nNalOffset += (UINT)(Nalu.GetDataLength() + 3);
if (nSlices > MAX_SLICES) {
break;
}
break;
}
}
slice_step++;
}
if (!nSlices) {
return S_FALSE;
}
m_nMaxWaiting = min(max(m_DXVAPicParams.num_ref_frames, 3), 8);
// If parsing fail (probably no PPS/SPS), continue anyway it may arrived later (happen on truncated streams)
if (FAILED(FFH264BuildPicParams(&m_DXVAPicParams, &m_DXVAScalingMatrix, &nFieldType, &nSliceType, m_pFilter->GetAVCtx(), m_pFilter->GetPCIVendor()))) {
return S_FALSE;
}
TRACE_H264("CDXVADecoderH264::DecodeFrame() : nFramePOC = %11d, nOutPOC = %11d[%11d], [%d - %d], rtOutStart = [%20I64d]\n", nFramePOC, nOutPOC, m_nOutPOC, m_DXVAPicParams.field_pic_flag, m_DXVAPicParams.RefPicFlag, rtOutStart);
// Wait I frame after a flush
if (m_bFlushed && !m_DXVAPicParams.IntraPicFlag) {
TRACE_H264("CDXVADecoderH264::DecodeFrame() : Flush - wait I frame\n");
m_nBrokenFramesFlag = 0;
m_nBrokenFramesFlag_POC = 0;
m_nfield_pic_flag = m_DXVAPicParams.field_pic_flag;
m_nRefPicFlag = m_DXVAPicParams.RefPicFlag;
m_nPrevOutPOC = INT_MIN;
return S_FALSE;
}
/* Disabled, because that causes serious problems.
// Some magic code for detecting the incorrect decoding of interlaced frames ...
// TODO : necessary to make it better, and preferably on the side of ffmpeg ...
if (m_nfield_pic_flag && m_nfield_pic_flag == m_DXVAPicParams.field_pic_flag && m_nRefPicFlag == m_DXVAPicParams.RefPicFlag) {
if (m_nPrevOutPOC == m_nOutPOC && m_nOutPOC == INT_MIN) {
m_nBrokenFramesFlag_POC++;
}
m_nBrokenFramesFlag++;
} else {
m_nBrokenFramesFlag = 0;
m_nBrokenFramesFlag_POC = 0;
}
m_nfield_pic_flag = m_DXVAPicParams.field_pic_flag;
m_nRefPicFlag = m_DXVAPicParams.RefPicFlag;
m_nPrevOutPOC = m_nOutPOC;
if (m_nBrokenFramesFlag > 4) {
m_nBrokenFramesFlag = 0;
if (m_nBrokenFramesFlag_POC > 1) {
TRACE_H264("CDXVADecoderH264::DecodeFrame() : Detected broken frames ... flush data\n");
m_nBrokenFramesFlag_POC = 0;
Flush();
return S_FALSE;
}
}
//
*/
CHECK_HR_TRACE(GetFreeSurfaceIndex(nSurfaceIndex, &pSampleToDeliver, rtStart, rtStop));
FFH264SetCurrentPicture(nSurfaceIndex, &m_DXVAPicParams, m_pFilter->GetAVCtx());
CHECK_HR_TRACE(BeginFrame(nSurfaceIndex, pSampleToDeliver));
m_DXVAPicParams.StatusReportFeedbackNumber++;
// Send picture parameters
CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_PictureParametersBufferType, sizeof(m_DXVAPicParams), &m_DXVAPicParams));
CHECK_HR_TRACE(Execute());
// Add bitstream, slice control and quantization matrix
CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_BitStreamDateBufferType, nSize, pDataIn, &nSize));
if (m_bUseLongSlice) {
CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_Slice_H264_Long)*nSlices, m_pSliceLong));
} else {
CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_Slice_H264_Short)*nSlices, m_pSliceShort));
}
CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_InverseQuantizationMatrixBufferType, sizeof(DXVA_Qmatrix_H264), (void*)&m_DXVAScalingMatrix));
// Decode bitstream
CHECK_HR_TRACE(Execute());
CHECK_HR_TRACE(EndFrame(nSurfaceIndex));
#if defined(_DEBUG) && 0
DisplayStatus();
#endif
bool bAdded = AddToStore(nSurfaceIndex, pSampleToDeliver, m_DXVAPicParams.RefPicFlag, rtStart, rtStop,
m_DXVAPicParams.field_pic_flag, (FF_FIELD_TYPE)nFieldType,
(FF_SLICE_TYPE)nSliceType, nFramePOC);
FFH264UpdateRefFramesList(&m_DXVAPicParams, m_pFilter->GetAVCtx());
ClearUnusedRefFrames();
if (bAdded) {
hr = DisplayNextFrame();
}
if (nOutPOC != INT_MIN) {
m_nOutPOC = nOutPOC;
m_rtOutStart = rtOutStart;
}
m_bFlushed = false;
return hr;
}
HRESULT CDXVADecoderH264::DecodeFrame (BYTE* pDataIn, UINT nSize, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop)
{
HRESULT hr = S_FALSE;
CH264Nalu Nalu;
UINT nSlices = 0;
int nSurfaceIndex;
int nFieldType;
int nSliceType;
int nFramePOC;
IDirect3DSurface9* pSampleToDeliver;
int nDXIndex = 0;
UINT nNalOffset = 0;
int nOutPOC;
REFERENCE_TIME rtOutStart;
if(pDataIn == NULL || nSize == 0)
return S_FALSE;
Nalu.SetBuffer (pDataIn, nSize, m_nNALLength);
FFH264DecodeBuffer (m_pFilter->GetAVCtx(), pDataIn, nSize, &nFramePOC, &nOutPOC, &rtOutStart);
//CLog::Log(LOGDEBUG, "nFramePOC = %d nOutPOC %d rtOutStart%d", nFramePOC, nOutPOC, rtOutStart);
while (Nalu.ReadNext())
{
switch (Nalu.GetType())
{
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
if(m_bUseLongSlice)
{
m_pSliceLong[nSlices].BSNALunitDataLocation = nNalOffset;
m_pSliceLong[nSlices].SliceBytesInBuffer = Nalu.GetDataLength()+3; //.GetRoundedDataLength();
m_pSliceLong[nSlices].slice_id = nSlices;
FF264UpdateRefFrameSliceLong(&m_DXVAPicParams, &m_pSliceLong[nSlices], m_pFilter->GetAVCtx());
if (nSlices>0)
m_pSliceLong[nSlices-1].NumMbsForSlice = m_pSliceLong[nSlices].NumMbsForSlice = m_pSliceLong[nSlices].first_mb_in_slice - m_pSliceLong[nSlices-1].first_mb_in_slice;
}
nSlices++;
nNalOffset += (UINT)(Nalu.GetDataLength() + 3);
if (nSlices > MAX_SLICES) break;
break;
}
}
if (nSlices == 0) return S_FALSE;
m_nMaxWaiting = min (max (m_DXVAPicParams.num_ref_frames, 3), 8);
// If parsing fail (probably no PPS/SPS), continue anyway it may arrived later (happen on truncated streams)
if (FAILED (FFH264BuildPicParams (&m_DXVAPicParams, &m_DXVAScalingMatrix, &nFieldType, &nSliceType, m_pFilter->GetAVCtx(), m_pFilter->GetPCIVendor())))
return S_FALSE;
// Wait I frame after a flush
if (m_bFlushed && !m_DXVAPicParams.IntraPicFlag)
return S_FALSE;
CHECK_HR (GetFreeSurfaceIndex (nSurfaceIndex, &pSampleToDeliver, rtStart, rtStop));
FFH264SetCurrentPicture (nSurfaceIndex, &m_DXVAPicParams, m_pFilter->GetAVCtx());
CHECK_HR (BeginFrame(pSampleToDeliver));
m_DXVAPicParams.StatusReportFeedbackNumber++;
// TRACE("CDXVADecoderH264 : Decode frame %u\n", m_DXVAPicParams.StatusReportFeedbackNumber);
// Send picture parameters
CHECK_HR (AddExecuteBuffer (DXVA2_PictureParametersBufferType, sizeof(m_DXVAPicParams), &m_DXVAPicParams));
CHECK_HR (Execute());
// Add bitstream, slice control and quantization matrix
CHECK_HR (AddExecuteBuffer (DXVA2_BitStreamDateBufferType, nSize, pDataIn, &nSize));
if (m_bUseLongSlice)
{
CHECK_HR(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_Slice_H264_Long)*nSlices, m_pSliceLong));
}
else
{
CHECK_HR (AddExecuteBuffer (DXVA2_SliceControlBufferType, sizeof (DXVA_Slice_H264_Short)*nSlices, m_pSliceShort));
}
CHECK_HR (AddExecuteBuffer (DXVA2_InverseQuantizationMatrixBufferType, sizeof (DXVA_Qmatrix_H264), (void*)&m_DXVAScalingMatrix));
// Decode bitstream
CHECK_HR (Execute());
CHECK_HR (EndFrame(nSurfaceIndex));
#ifdef _DEBUG
//DisplayStatus();
#endif
bool bAdded = AddToStore (nSurfaceIndex, m_DXVAPicParams.RefPicFlag, rtStart, rtStop,
m_DXVAPicParams.field_pic_flag, (FF_FIELD_TYPE)nFieldType,
(FF_SLICE_TYPE)nSliceType, nFramePOC);
FFH264UpdateRefFramesList (&m_DXVAPicParams, m_pFilter->GetAVCtx());
ClearUnusedRefFrames();
if (bAdded)
{
hr = DisplayNextFrame();
if (nOutPOC != -1)
{
m_nOutPOC = nOutPOC;
m_rtOutStart = rtOutStart;
}
}
m_bFlushed = false;
return hr;
}
HRESULT CStreamParser::ParseH264AnnexB(Packet *pPacket)
{
if (!m_pPacketBuffer) {
m_pPacketBuffer = InitPacket(pPacket);
}
m_pPacketBuffer->Append(pPacket);
BYTE *start = m_pPacketBuffer->GetData();
BYTE *end = start + m_pPacketBuffer->GetDataSize();
MOVE_TO_H264_START_CODE(start, end);
while(start <= end-4) {
BYTE *next = start + 1;
MOVE_TO_H264_START_CODE(next, end);
// End of buffer reached
if(next >= end-4) {
break;
}
size_t size = next - start;
CH264Nalu Nalu;
Nalu.SetBuffer(start, (int)size, 0);
Packet *p2 = NULL;
while (Nalu.ReadNext()) {
Packet *p3 = new Packet();
p3->SetDataSize(Nalu.GetDataLength() + 4);
// Write size of the NALU (Big Endian)
AV_WB32(p3->GetData(), (uint32_t)Nalu.GetDataLength());
memcpy(p3->GetData() + 4, Nalu.GetDataBuffer(), Nalu.GetDataLength());
if (!p2) {
p2 = p3;
} else {
p2->Append(p3);
SAFE_DELETE(p3);
}
}
if (!p2)
break;
p2->StreamId = m_pPacketBuffer->StreamId;
p2->bDiscontinuity = m_pPacketBuffer->bDiscontinuity;
m_pPacketBuffer->bDiscontinuity = FALSE;
p2->bSyncPoint = m_pPacketBuffer->bSyncPoint;
m_pPacketBuffer->bSyncPoint = FALSE;
p2->rtStart = m_pPacketBuffer->rtStart;
m_pPacketBuffer->rtStart = Packet::INVALID_TIME;
p2->rtStop = m_pPacketBuffer->rtStop;
m_pPacketBuffer->rtStop = Packet::INVALID_TIME;
p2->pmt = m_pPacketBuffer->pmt;
m_pPacketBuffer->pmt = NULL;
m_queue.Queue(p2);
if(pPacket->rtStart != Packet::INVALID_TIME) {
m_pPacketBuffer->rtStart = pPacket->rtStart;
m_pPacketBuffer->rtStop = pPacket->rtStop;
pPacket->rtStart = Packet::INVALID_TIME;
}
if(pPacket->bDiscontinuity) {
m_pPacketBuffer->bDiscontinuity = pPacket->bDiscontinuity;
pPacket->bDiscontinuity = FALSE;
}
if(pPacket->bSyncPoint) {
m_pPacketBuffer->bSyncPoint = pPacket->bSyncPoint;
pPacket->bSyncPoint = FALSE;
}
if(m_pPacketBuffer->pmt) {
DeleteMediaType(m_pPacketBuffer->pmt);
}
m_pPacketBuffer->pmt = pPacket->pmt;
pPacket->pmt = NULL;
start = next;
}
if(start > m_pPacketBuffer->GetData()) {
m_pPacketBuffer->RemoveHead(start - m_pPacketBuffer->GetData());
}
SAFE_DELETE(pPacket);
do {
pPacket = NULL;
REFERENCE_TIME rtStart = Packet::INVALID_TIME, rtStop = rtStart = Packet::INVALID_TIME;
std::deque<Packet *>::iterator it;
for (it = m_queue.GetQueue()->begin(); it != m_queue.GetQueue()->end(); ++it) {
// Skip the first
if (it == m_queue.GetQueue()->begin()) {
continue;
}
Packet *p = *it;
BYTE* pData = p->GetData();
if((pData[4]&0x1f) == 0x09) {
m_bHasAccessUnitDelimiters = true;
}
if ((pData[4]&0x1f) == 0x09 || (!m_bHasAccessUnitDelimiters && p->rtStart != Packet::INVALID_TIME)) {
pPacket = p;
if (p->rtStart == Packet::INVALID_TIME && rtStart != Packet::INVALID_TIME) {
p->rtStart = rtStart;
p->rtStop = rtStop;
}
break;
}
if (rtStart == Packet::INVALID_TIME) {
rtStart = p->rtStart;
rtStop = p->rtStop;
}
}
if (pPacket) {
Packet *p = m_queue.Get();
Packet *p2 = NULL;
while ((p2 = m_queue.Get()) != pPacket) {
p->Append(p2);
SAFE_DELETE(p2);
}
// Return
m_queue.GetQueue()->push_front(pPacket);
Queue(p);
}
} while (pPacket != NULL);
return S_OK;
}
STDMETHODIMP CDecMSDKMVC::Decode(const BYTE *buffer, int buflen, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, BOOL bSyncPoint, BOOL bDiscontinuity)
{
if (!m_mfxSession)
return E_UNEXPECTED;
HRESULT hr = S_OK;
CBitstreamBuffer bsBuffer(&m_buff);
mfxStatus sts = MFX_ERR_NONE;
mfxBitstream bs = { 0 };
BOOL bFlush = (buffer == nullptr);
if (rtStart >= -TIMESTAMP_OFFSET && rtStart != AV_NOPTS_VALUE)
bs.TimeStamp = rtStart + TIMESTAMP_OFFSET;
else
bs.TimeStamp = MFX_TIMESTAMP_UNKNOWN;
bs.DecodeTimeStamp = MFX_TIMESTAMP_UNKNOWN;
if (!bFlush) {
if (m_pAnnexBConverter) {
BYTE *pOutBuffer = nullptr;
int pOutSize = 0;
hr = m_pAnnexBConverter->Convert(&pOutBuffer, &pOutSize, buffer, buflen);
if (FAILED(hr))
return hr;
bsBuffer.SetBuffer(pOutBuffer, pOutSize, true);
}
else {
bsBuffer.SetBuffer((BYTE *)buffer, buflen, false);
}
// Check the buffer for SEI NALU, and some unwanted NALUs that need filtering
// MSDK's SEI reading functionality is slightly buggy
CH264Nalu nalu;
nalu.SetBuffer(bsBuffer.GetBuffer(), bsBuffer.GetBufferSize(), 0);
BOOL bNeedFilter = FALSE;
while (nalu.ReadNext()) {
if (nalu.GetType() == NALU_TYPE_SEI) {
ParseSEI(nalu.GetDataBuffer() + 1, nalu.GetDataLength() - 1, bs.TimeStamp);
}
else if (nalu.GetType() == NALU_TYPE_EOSEQ) {
bsBuffer.EnsureWriteable();
// This is rather ugly, and relies on the bitstream being AnnexB, so simply overwriting the EOS NAL with zero works.
// In the future a more elaborate bitstream filter might be advised
memset(bsBuffer.GetBuffer() + nalu.GetNALPos(), 0, 4);
}
}
bs.Data = bsBuffer.GetBuffer();
bs.DataLength = mfxU32(bsBuffer.GetBufferSize());
bs.MaxLength = bs.DataLength;
AddFrameToGOP(bs.TimeStamp);
}
if (!m_bDecodeReady) {
sts = MFXVideoDECODE_DecodeHeader(m_mfxSession, &bs, &m_mfxVideoParams);
if (sts == MFX_ERR_NOT_ENOUGH_BUFFER) {
hr = AllocateMVCExtBuffers();
if (FAILED(hr))
return hr;
sts = MFXVideoDECODE_DecodeHeader(m_mfxSession, &bs, &m_mfxVideoParams);
}
if (sts == MFX_ERR_NONE) {
m_mfxVideoParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
m_mfxVideoParams.AsyncDepth = ASYNC_DEPTH;
sts = MFXVideoDECODE_Init(m_mfxSession, &m_mfxVideoParams);
if (sts != MFX_ERR_NONE) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Error initializing the MSDK decoder (%d)", sts));
return E_FAIL;
}
if (m_mfxExtMVCSeq.NumView != 2) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Only MVC with two views is supported"));
return E_FAIL;
}
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Initialized MVC with View Ids %d, %d", m_mfxExtMVCSeq.View[0].ViewId, m_mfxExtMVCSeq.View[1].ViewId));
m_bDecodeReady = TRUE;
}
}
if (!m_bDecodeReady)
return S_FALSE;
mfxSyncPoint sync = nullptr;
// Loop over the decoder to ensure all data is being consumed
while (1) {
MVCBuffer *pInputBuffer = GetBuffer();
if (pInputBuffer == nullptr)
return E_OUTOFMEMORY;
mfxFrameSurface1 *outsurf = nullptr;
sts = MFXVideoDECODE_DecodeFrameAsync(m_mfxSession, bFlush ? nullptr : &bs, &pInputBuffer->surface, &outsurf, &sync);
if (sts == MFX_ERR_INCOMPATIBLE_VIDEO_PARAM) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Incompatible video parameters detected, flushing decoder"));
bsBuffer.Clear();
bFlush = TRUE;
m_bDecodeReady = FALSE;
continue;
}
if (sync) {
MVCBuffer * pOutputBuffer = FindBuffer(outsurf);
pOutputBuffer->queued = 1;
pOutputBuffer->sync = sync;
HandleOutput(pOutputBuffer);
continue;
}
if (sts != MFX_ERR_MORE_SURFACE && sts < 0)
break;
}
if (!bs.DataOffset && !sync && !bFlush) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Decoder did not consume any data, discarding"));
bs.DataOffset = mfxU32(bsBuffer.GetBufferSize());
}
bsBuffer.Consume(bs.DataOffset);
if (sts != MFX_ERR_MORE_DATA && sts < 0) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Error from Decode call (%d)", sts));
return S_FALSE;
}
return S_OK;
}