RefPtr<MediaDataDecoder::InitPromise>
VorbisDataDecoder::Init()
{
vorbis_info_init(&mVorbisInfo);
vorbis_comment_init(&mVorbisComment);
PodZero(&mVorbisDsp);
PodZero(&mVorbisBlock);
AutoTArray<unsigned char*,4> headers;
AutoTArray<size_t,4> headerLens;
if (!XiphExtradataToHeaders(headers, headerLens,
mInfo.mCodecSpecificConfig->Elements(),
mInfo.mCodecSpecificConfig->Length())) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
for (size_t i = 0; i < headers.Length(); i++) {
if (NS_FAILED(DecodeHeader(headers[i], headerLens[i]))) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR,
__func__);
}
}
MOZ_ASSERT(mPacketCount == 3);
int r = vorbis_synthesis_init(&mVorbisDsp, &mVorbisInfo);
if (r) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
r = vorbis_block_init(&mVorbisDsp, &mVorbisBlock);
if (r) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
if (mInfo.mRate != (uint32_t)mVorbisDsp.vi->rate) {
LOG(LogLevel::Warning,
("Invalid Vorbis header: container and codec rate do not match!"));
}
if (mInfo.mChannels != (uint32_t)mVorbisDsp.vi->channels) {
LOG(LogLevel::Warning,
("Invalid Vorbis header: container and codec channels do not match!"));
}
AudioConfig::ChannelLayout layout(mVorbisDsp.vi->channels);
if (!layout.IsValid()) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
return InitPromise::CreateAndResolve(TrackInfo::kAudioTrack, __func__);
}
nsresult
VorbisDataDecoder::Init()
{
vorbis_info_init(&mVorbisInfo);
vorbis_comment_init(&mVorbisComment);
PodZero(&mVorbisDsp);
PodZero(&mVorbisBlock);
size_t available = mInfo.mCodecSpecificConfig->Length();
uint8_t *p = mInfo.mCodecSpecificConfig->Elements();
for(int i = 0; i < 3; i++) {
if (available < 2) {
return NS_ERROR_FAILURE;
}
available -= 2;
size_t length = BigEndian::readUint16(p);
p += 2;
if (available < length) {
return NS_ERROR_FAILURE;
}
available -= length;
if (NS_FAILED(DecodeHeader((const unsigned char*)p, length))) {
return NS_ERROR_FAILURE;
}
p += length;
}
MOZ_ASSERT(mPacketCount == 3);
int r = vorbis_synthesis_init(&mVorbisDsp, &mVorbisInfo);
if (r) {
return NS_ERROR_FAILURE;
}
r = vorbis_block_init(&mVorbisDsp, &mVorbisBlock);
if (r) {
return NS_ERROR_FAILURE;
}
if (mInfo.mRate != (uint32_t)mVorbisDsp.vi->rate) {
LOG(LogLevel::Warning,
("Invalid Vorbis header: container and codec rate do not match!"));
}
if (mInfo.mChannels != (uint32_t)mVorbisDsp.vi->channels) {
LOG(LogLevel::Warning,
("Invalid Vorbis header: container and codec channels do not match!"));
}
return NS_OK;
}
void Inflator::ProcessInput(bool flush)
{
while (true)
{
if (m_inQueue.IsEmpty())
return;
switch (m_state)
{
case PRE_STREAM:
if (!flush && m_inQueue.CurrentSize() < MaxPrestreamHeaderSize())
return;
ProcessPrestreamHeader();
m_state = WAIT_HEADER;
m_maxDistance = 0;
m_current = 0;
m_lastFlush = 0;
m_window.Resize(1 << GetLog2WindowSize());
break;
case WAIT_HEADER:
{
// maximum number of bytes before actual compressed data starts
const unsigned int MAX_HEADER_SIZE = bitsToBytes(3+5+5+4+19*7+286*15+19*15);
if (m_inQueue.CurrentSize() < (flush ? 1 : MAX_HEADER_SIZE))
return;
DecodeHeader();
break;
}
case DECODING_BODY:
if (!DecodeBody())
return;
break;
case POST_STREAM:
if (!flush && m_inQueue.CurrentSize() < MaxPoststreamTailSize())
return;
ProcessPoststreamTail();
m_state = m_repeat ? PRE_STREAM : AFTER_END;
Filter::MessageEnd(GetAutoSignalPropagation());
break;
case AFTER_END:
m_inQueue.TransferTo(*AttachedTransformation());
return;
}
}
}
void Inflator::ProcessInput(bool flush)
{
while (true)
{
switch (m_state)
{
case PRE_STREAM:
if (!flush && m_inQueue.CurrentSize() < MaxPrestreamHeaderSize())
return;
ProcessPrestreamHeader();
m_state = WAIT_HEADER;
m_wrappedAround = false;
m_current = 0;
m_lastFlush = 0;
m_window.New(1 << GetLog2WindowSize());
break;
case WAIT_HEADER:
{
// maximum number of bytes before actual compressed data starts
const size_t MAX_HEADER_SIZE = BitsToBytes(3+5+5+4+19*7+286*15+19*15);
if (m_inQueue.CurrentSize() < (flush ? 1 : MAX_HEADER_SIZE))
return;
DecodeHeader();
break;
}
case DECODING_BODY:
if (!DecodeBody())
return;
break;
case POST_STREAM:
if (!flush && m_inQueue.CurrentSize() < MaxPoststreamTailSize())
return;
ProcessPoststreamTail();
m_state = m_repeat ? PRE_STREAM : AFTER_END;
Output(0, NULL, 0, GetAutoSignalPropagation(), true); // TODO: non-blocking
if (m_inQueue.IsEmpty())
return;
break;
case AFTER_END:
m_inQueue.TransferTo(*AttachedTransformation());
return;
}
}
}
CCart::CCart(const uint8 *gamedata, uint32 gamesize)
{
LYNX_HEADER header;
uint32 loop;
mWriteEnableBank0=FALSE;
mWriteEnableBank1=FALSE;
mCartRAM=FALSE;
mCRC32 = 0;
mCRC32 = crc32(mCRC32,gamedata,gamesize);
// Checkout the header bytes
if(gamesize <= HEADER_RAW_SIZE)
throw(-1);
header = DecodeHeader(gamedata);
gamedata += HEADER_RAW_SIZE;
gamesize -= HEADER_RAW_SIZE;
InfoROMSize = gamesize;
// Sanity checks on the header
if(header.magic[0]!='L' || header.magic[1]!='Y' || header.magic[2]!='N' || header.magic[3]!='X' || header.version!=1)
{
throw(-1);
}
// Setup name & manufacturer
strncpy(mName,(char*)&header.cartname, 32);
strncpy(mManufacturer,(char*)&header.manufname, 16);
// Setup rotation
mRotation=header.rotation;
if(mRotation!=CART_NO_ROTATE && mRotation!=CART_ROTATE_LEFT && mRotation!=CART_ROTATE_RIGHT) mRotation=CART_NO_ROTATE;
// Set the filetypes
CTYPE banktype0,banktype1;
switch(header.page_size_bank0)
{
case 0x000:
banktype0=UNUSED;
mMaskBank0=0;
mShiftCount0=0;
mCountMask0=0;
break;
case 0x100:
banktype0=C64K;
mMaskBank0=0x00ffff;
mShiftCount0=8;
mCountMask0=0x0ff;
break;
case 0x200:
banktype0=C128K;
mMaskBank0=0x01ffff;
mShiftCount0=9;
mCountMask0=0x1ff;
break;
case 0x400:
banktype0=C256K;
mMaskBank0=0x03ffff;
mShiftCount0=10;
mCountMask0=0x3ff;
break;
case 0x800:
banktype0=C512K;
mMaskBank0=0x07ffff;
mShiftCount0=11;
mCountMask0=0x7ff;
break;
default:
//return(0);
//CLynxException lynxerr;
//lynxerr.Message() << "Handy Error: File format invalid (Bank0)";
//lynxerr.Description()
// << "The image you selected was not a recognised game cartridge format." << endl
// << "(see the Handy User Guide for more information).";
//throw(lynxerr);
throw(0);
break;
}
switch(header.page_size_bank1)
{
case 0x000:
banktype1=UNUSED;
mMaskBank1=0;
mShiftCount1=0;
mCountMask1=0;
break;
case 0x100:
banktype1=C64K;
mMaskBank1=0x00ffff;
mShiftCount1=8;
mCountMask1=0x0ff;
break;
case 0x200:
banktype1=C128K;
mMaskBank1=0x01ffff;
mShiftCount1=9;
mCountMask1=0x1ff;
break;
case 0x400:
banktype1=C256K;
mMaskBank1=0x03ffff;
mShiftCount1=10;
mCountMask1=0x3ff;
break;
case 0x800:
banktype1=C512K;
mMaskBank1=0x07ffff;
mShiftCount1=11;
mCountMask1=0x7ff;
break;
default:
//return(0);
//CLynxException lynxerr;
//lynxerr.Message() << "Handy Error: File format invalid (Bank1)";
//lynxerr.Description()
// << "The image you selected was not a recognised game cartridge format." << endl
// << "(see the Handy User Guide for more information).";
//throw(lynxerr);
throw(0);
break;
}
// Make some space for the new carts
mCartBank0 = (uint8*) new uint8[mMaskBank0+1];
mCartBank1 = (uint8*) new uint8[mMaskBank1+1];
// Set default bank
mBank=bank0;
// Initialiase
for(loop=0;loop<mMaskBank0+1;loop++)
mCartBank0[loop]=DEFAULT_CART_CONTENTS;
for(loop=0;loop<mMaskBank1+1;loop++)
mCartBank1[loop]=DEFAULT_CART_CONTENTS;
// Read in the BANK0 bytes
md5_context md5;
md5.starts();
if(mMaskBank0)
{
int size = std::min(gamesize, mMaskBank0+1);
memcpy(mCartBank0, gamedata, size);
md5.update(mCartBank0, size);
gamedata += size;
gamesize -= size;
}
// Read in the BANK0 bytes
if(mMaskBank1)
{
int size = std::min(gamesize, mMaskBank1+1);
memcpy(mCartBank1, gamedata, size);
md5.update(mCartBank1, size);
gamedata += size;
}
md5.finish(MD5);
// As this is a cartridge boot unset the boot address
gCPUBootAddress=0;
// Dont allow an empty Bank1 - Use it for shadow SRAM/EEPROM
if(banktype1==UNUSED)
{
// Delete the single byte allocated earlier
delete[] mCartBank1;
// Allocate some new memory for us
banktype1=C64K;
mMaskBank1=0x00ffff;
mShiftCount1=8;
mCountMask1=0x0ff;
mCartBank1 = (uint8*) new uint8[mMaskBank1+1];
for(loop=0;loop<mMaskBank1+1;loop++) mCartBank1[loop]=DEFAULT_RAM_CONTENTS;
mWriteEnableBank1=TRUE;
mCartRAM=TRUE;
}
}
inline typename blb<F,LR,HR, L>::BLBFEEDR
blb<F,LR,HR,L>::Decode() {
void* in_use_buffer;
int size, code;
bool bDone = false;
BLBFEEDRD retl;
BLBLIVEFEED lf;
BLBHISTFEED hf;
while(!bDone) {
size = bb_sizeof_nextmsg(m_connection->connection());
if(size < 0) {
//m_log->warning("Error Receiving Data");
break;
}
else if(size == BB_SVC_INCOMPLETE) {
//m_log->warning("Incomplete Message in Receive");
break;
}
// if the message is larger than our buffer, allocate a temporary buffer
m_buffer.Alloca(size);
in_use_buffer = m_buffer;
code = bb_rcvdata(m_connection->connection(), in_use_buffer, m_buffer.size());
if(code < 0) {
//m_log->warning("Bloomberg API. Permission Problem.");
break;
}
if(code<-1900) {
bDone = true;
if(code==ExitFAILCONNECTION || code==ExitFAILRECEIVE) {
//m_log->warning("Error Receiving Data");
break;
}
}
//
switch(code) {
//________________________________________ HISTORY
case BB_SVC_MGETHISTORYX: {
hf = DecodeHistory((bb_history_type*)in_use_buffer);
if(hf) retl.append(hf);
break;
}
//case BB_SVC_GETHISTORYX: {
// DecodeHistory((bb_msg_history_t*)in_use_buffer);
// break;
//}
//________________________________________ STATIC DATA
case BB_SVC_GETDATAX: {
hf = DecodeStaticData((bb_msg_fieldsx_t *)in_use_buffer);
if(hf) retl.append(hf);
break;
}
//________________________________________ GOT HEADER FOR LIVE RATE
case BB_SVC_GETHEADERX: {
lf = DecodeHeader((bb_header_type*)in_use_buffer);
if(lf) retl.append(lf);
break;
}
case BB_SVC_TICKMONITOR:
case BB_SVC_TICKMONITORX:
case BB_SVC_TICKMONITOR_TYPED:
case BB_SVC_TICKMONITOR_TYPEDX:
case BB_SVC_TICKMONITOR_ENHANCED: {
HandleMonitor((bb_monid_type*)in_use_buffer);
break;
}
case BB_SVC_TICKDATA: {
LIVE_LIST ll = UpDateLiveData((bb_tick_type*)in_use_buffer);
for(typename live_list::const_iterator it=ll->begin();it!=ll->end();++it)
retl.append(*it);
break;
}
case BB_SVC_STATUS: {
// printf("STATUS Message...\n");
break;
}
case BB_SVC_CONNECTSUCCEEDED: {
//m_log->info("Successfully connected to Bloomberg API.");
//SecurityConnection();
break;
}
//
case BB_SVC_CONNECTFAILED: {
//m_log->info("Connection to Bloomberg API Failed.");
break;
}
default: {
//m_log->warning("Unexpected message type.");
break;
}
}
}
return BLBFEEDR(new blbfeedr(retl));
}
CCart::CCart(Stream* fp)
{
uint64 gamesize;
uint8 raw_header[HEADER_RAW_SIZE];
LYNX_HEADER header;
uint32 loop;
mWriteEnableBank0 = FALSE;
mWriteEnableBank1 = FALSE;
mCartRAM = FALSE;
if(fp)
{
gamesize = fp->size();
// Checkout the header bytes
if(gamesize < HEADER_RAW_SIZE)
{
throw MDFN_Error(0, _("Lynx ROM image is too small: %llu bytes"), (unsigned long long)gamesize);
}
fp->read(raw_header, HEADER_RAW_SIZE);
}
else
{
gamesize = HEADER_RAW_SIZE;
memset(raw_header, 0, sizeof(raw_header));
memcpy(raw_header, "LYNX", 4);
raw_header[8] = 0x01;
}
header = DecodeHeader(raw_header);
gamesize -= HEADER_RAW_SIZE;
InfoROMSize = gamesize;
// Sanity checks on the header
if(header.magic[0]!='L' || header.magic[1]!='Y' || header.magic[2]!='N' || header.magic[3]!='X' || header.version!=1)
{
throw MDFN_Error(0, _("Missing or corrupted \"LYNX\" header magic."));
}
// Setup name & manufacturer
strncpy(mName,(char*)&header.cartname, 32);
strncpy(mManufacturer,(char*)&header.manufname, 16);
// Setup rotation
mRotation=header.rotation;
if(mRotation!=CART_NO_ROTATE && mRotation!=CART_ROTATE_LEFT && mRotation!=CART_ROTATE_RIGHT) mRotation=CART_NO_ROTATE;
// Set the filetypes
CTYPE banktype0,banktype1;
switch(header.page_size_bank0)
{
case 0x000:
banktype0=UNUSED;
mMaskBank0=0;
mShiftCount0=0;
mCountMask0=0;
break;
case 0x100:
banktype0=C64K;
mMaskBank0=0x00ffff;
mShiftCount0=8;
mCountMask0=0x0ff;
break;
case 0x200:
banktype0=C128K;
mMaskBank0=0x01ffff;
mShiftCount0=9;
mCountMask0=0x1ff;
break;
case 0x400:
banktype0=C256K;
mMaskBank0=0x03ffff;
mShiftCount0=10;
mCountMask0=0x3ff;
break;
case 0x800:
banktype0=C512K;
mMaskBank0=0x07ffff;
mShiftCount0=11;
mCountMask0=0x7ff;
break;
default:
throw MDFN_Error(0, _("Lynx file format invalid (Bank0)"));
break;
}
switch(header.page_size_bank1)
{
case 0x000:
banktype1=UNUSED;
mMaskBank1=0;
mShiftCount1=0;
mCountMask1=0;
break;
case 0x100:
banktype1=C64K;
mMaskBank1=0x00ffff;
mShiftCount1=8;
mCountMask1=0x0ff;
break;
case 0x200:
banktype1=C128K;
mMaskBank1=0x01ffff;
mShiftCount1=9;
mCountMask1=0x1ff;
break;
case 0x400:
banktype1=C256K;
mMaskBank1=0x03ffff;
mShiftCount1=10;
mCountMask1=0x3ff;
break;
case 0x800:
banktype1=C512K;
mMaskBank1=0x07ffff;
mShiftCount1=11;
mCountMask1=0x7ff;
break;
default:
throw MDFN_Error(0, _("Lynx file format invalid (Bank1)"));
break;
}
// Make some space for the new carts
mCartBank0.reset(new uint8[mMaskBank0+1]);
mCartBank1.reset(new uint8[mMaskBank1+1]);
// Set default bank
mBank=bank0;
// Initialiase
for(loop=0;loop<mMaskBank0+1;loop++)
mCartBank0[loop]=DEFAULT_CART_CONTENTS;
for(loop=0;loop<mMaskBank1+1;loop++)
mCartBank1[loop]=DEFAULT_CART_CONTENTS;
// Read in the BANK0 bytes
md5_context md5;
md5.starts();
if(mMaskBank0)
{
uint64 size = std::min<uint64>(gamesize, mMaskBank0+1);
fp->read(mCartBank0.get(), size);
md5.update(mCartBank0.get(), size);
gamesize -= size;
}
// Read in the BANK0 bytes
if(mMaskBank1)
{
uint64 size = std::min<uint64>(gamesize, mMaskBank1+1);
fp->read(mCartBank1.get(), size);
md5.update(mCartBank1.get(), size);
}
md5.finish(MD5);
// As this is a cartridge boot unset the boot address
gCPUBootAddress=0;
// Dont allow an empty Bank1 - Use it for shadow SRAM/EEPROM
if(banktype1==UNUSED)
{
// Allocate some new memory for us
banktype1=C64K;
mMaskBank1=0x00ffff;
mShiftCount1=8;
mCountMask1=0x0ff;
mCartBank1.reset(new uint8[mMaskBank1+1]);
for(loop=0;loop<mMaskBank1+1;loop++) mCartBank1[loop]=DEFAULT_RAM_CONTENTS;
mWriteEnableBank1=TRUE;
mCartRAM=TRUE;
}
}
void CActiveReader::RunL()
{
// the read has completed - for the moment we are not really interested at the moment
if (iAuto)
{
switch (iReadState)
{
case EReadHeader:
iReaderOutputConsole->Printf(_L("Header byte recvd\n"));
iReadState = (DecodeHeader() == KHCIUARTCommandHeader ? EReadOpcode : EReadConnectionHandleFlags);
break;
case EReadOpcode:
{
iReaderOutputConsole->Printf(_L("Opcode bytes recvd\n"));
TInt opcode = DecodeOpcode();
if (opcode == 0)
//NoOpCommand has no more parameters
{
iReadComplete = ETrue;
iReadState = EReadHeader; // start again
}
else
{
iReadState = EReadCommandLength;
}
}
break;
case EReadCommandLength:
iReaderOutputConsole->Printf(_L("Length byte recvd\n"));
iReadState = EReadCommandRemainder;
break;
case EReadDataLength:
iReaderOutputConsole->Printf(_L("Length byte recvd\n"));
iReadState = EReadDataRemainder;
break;
case EReadConnectionHandleFlags:
iReaderOutputConsole->Printf(_L("ConnectionHandle bytes recvd\n"));
iReadState = EReadDataLength;
break;
case EReadCommandRemainder:
case EReadDataRemainder:
iReaderOutputConsole->Printf(_L("Remainder bytes recvd\n"));
iReadComplete = ETrue;
iReadState = EReadHeader; // start again
break;
default:
__DEBUGGER();
}
if (iReadComplete)
{
iReaderOutputConsole->Printf(_L("Decoding...\n"));
if (DecodeHeader() == KHCIUARTCommandHeader)
{
iReaderOutputConsole->Printf(_L("Decode: Command\n"));
iEmulator.CommandReceived(iOpcodeBuf, iRemainderBuf);
}
else
{
iReaderOutputConsole->Printf(_L("Decode: ACL Data\n"));
iEmulator.ACLDataReceived(iConnectionHandleFlagsBuf, iRemainderBuf);
}
iReadComplete = EFalse;
}
}
// queue another one
DoRead();
}
int cParserMPEG2Audio::FindHeaders(uint8_t **poutbuf, int *poutbuf_size,
uint8_t *buf, int buf_size,
int64_t pts, int64_t dts)
{
*poutbuf = NULL;
*poutbuf_size = 0;
/* add a new packet descriptor */
if (pts != DVD_NOPTS_VALUE || dts != DVD_NOPTS_VALUE)
{
int i = (m_CurrentFrameStartIndex + 1) & (AV_PARSER_PTS_NB - 1);
m_CurrentFrameStartIndex = i;
m_CurrentFrameOffset[i] = m_CurrentOffset;
m_CurrentFrameEnd[i] = m_CurrentOffset + buf_size;
m_CurrentFramePTS[i] = pts;
m_CurrentFrameDTS[i] = dts;
}
if (m_FetchTimestamp)
{
m_FetchTimestamp = false;
FetchTimestamp(0, false);
}
const uint8_t *buf_ptr = buf;
while (buf_size > 0)
{
int len = m_FrameInBufferPtr - m_FrameInBuffer;
if (m_FrameSize == 0)
{
/* special case for next header for first frame in free
format case (XXX: find a simpler method) */
if (m_FrameFreeFormatNextHeader != 0)
{
m_FrameInBuffer[3] = m_FrameFreeFormatNextHeader;
m_FrameInBuffer[2] = m_FrameFreeFormatNextHeader>>8;
m_FrameInBuffer[1] = m_FrameFreeFormatNextHeader>>16;
m_FrameInBuffer[0] = m_FrameFreeFormatNextHeader>>24;
m_FrameInBufferPtr = m_FrameInBuffer + 4;
m_FrameFreeFormatNextHeader = 0;
goto got_header;
}
/* no header seen : find one. We need at least MPA_HEADER_SIZE
bytes to parse it */
len = min(MPA_HEADER_SIZE - len, buf_size);
if (len > 0)
{
memcpy(m_FrameInBufferPtr, buf_ptr, len);
buf_ptr += len;
buf_size -= len;
m_FrameInBufferPtr += len;
}
if ((m_FrameInBufferPtr - m_FrameInBuffer) >= MPA_HEADER_SIZE)
{
got_header:
MPADecodeHeader s;
uint32_t header = ((m_FrameInBuffer[0] << 24) | (m_FrameInBuffer[1] << 16) | (m_FrameInBuffer[2] << 8) | m_FrameInBuffer[3]);
if (CheckHeader(header) && DecodeHeader(&s, header))
{
if ((header&SAME_HEADER_MASK) != (m_FrameHeader&SAME_HEADER_MASK) && m_FrameHeader)
m_HeaderCount = -3;
m_FrameHeader = header;
m_FrameSize = s.frame_size;
m_SampleRate = s.sample_rate;
m_Channels = s.nb_channels;
m_BitRate = s.bit_rate;
m_HeaderCount++;
}
else
{
m_HeaderCount = -2;
/* no sync found : move by one byte (inefficient, but simple!) */
memmove(m_FrameInBuffer, m_FrameInBuffer + 1, m_FrameInBufferPtr - m_FrameInBuffer - 1);
m_FrameInBufferPtr--;
//LOGDBG("skip %x", header);
/* reset free format frame size to give a chance
to get a new bitrate */
m_FrameFreeFormatFrameSize = 0;
}
}
}
else if (len < m_FrameSize)
mfxStatus AVC_Spl::ProcessNalUnit(mfxI32 nalType, mfxBitstream * nalUnit)
{
if (!nalUnit)
return MFX_ERR_MORE_DATA;
switch (nalType)
{
case NAL_UT_IDR_SLICE:
case NAL_UT_SLICE:
case NAL_UT_CODED_SLICE_EXTENSION:
{
AVCSlice * pSlice = DecodeSliceHeader(nalUnit);
if (pSlice)
{
mfxStatus sts = AddSlice(pSlice);
if (sts == MFX_ERR_NOT_ENOUGH_BUFFER)
{
return sts;
}
if (!m_pLastSlice)
{
AddSliceNalUnit(nalUnit, pSlice);
}
else
{
m_lastNalUnit = nalUnit;
}
if (sts == MFX_ERR_NONE)
{
return sts;
}
}
}
break;
case NAL_UT_SPS:
case NAL_UT_PPS:
case NAL_UT_SPS_EX:
case NAL_UNIT_SUBSET_SPS:
case NAL_UNIT_PREFIX:
DecodeHeader(nalUnit);
AddNalUnit(nalUnit);
break;
case NAL_UT_SEI:
DecodeSEI(nalUnit);
AddNalUnit(nalUnit);
break;
case NAL_UT_AUD:
AddNalUnit(nalUnit);
break;
case NAL_UT_DPA:
case NAL_UT_DPB:
case NAL_UT_DPC:
case NAL_UT_FD:
case NAL_UT_UNSPECIFIED:
break;
case NAL_END_OF_STREAM:
case NAL_END_OF_SEQ:
{
AddNalUnit(nalUnit);
}
break;
default:
break;
};
return MFX_ERR_MORE_DATA;
}
