Demuxer improved, cellPamf improved

File reading improved

rpcs3/Emu/SysCalls/Modules/cellDmux.cpp

@@ -4,25 +4,334 @@
 #include "cellPamf.h"
 #include "cellDmux.h"
 
-extern "C"
-{
-#include "libavformat\avformat.h"
-}
-
 void cellDmux_init();
 Module cellDmux(0x0007, cellDmux_init);
 
 void dmuxQueryAttr(u32 info_addr /* may be 0 */, mem_ptr_t<CellDmuxAttr> attr)
 {
-	attr->demuxerVerLower = 0; // TODO: check values
-	attr->demuxerVerUpper = 0;
-	attr->memSize = 1024 * 1024; // 1M
+	attr->demuxerVerLower = 0x280000; // TODO: check values
+	attr->demuxerVerUpper = 0x260000;
+	attr->memSize = 0x10000; // 0x3e8e6 from ps3
 }
 
 void dmuxQueryEsAttr(u32 info_addr /* may be 0 */, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
 					 const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> attr)
 {
-	attr->memSize = 1024 * 1024;
+	if (esFilterId->filterIdMajor >= 0xe0)
+		attr->memSize = 0x500000; // 0x45fa49 from ps3
+	else
+		attr->memSize = 0x10000; // 0x73d9 from ps3
+
+	cellDmux.Warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", (u32)esFilterId->filterIdMajor, (u32)esFilterId->filterIdMinor,
+		(u32)esFilterId->supplementalInfo1, (u32)esFilterId->supplementalInfo2);
+}
+
+u32 dmuxOpen(Demuxer* data)
+{
+	Demuxer& dmux = *data;
+
+	u32 dmux_id = cellDmux.GetNewId(data);
+
+	dmux.id = dmux_id;
+
+	thread t("Demuxer[" + std::to_string(dmux_id) + "] Thread", [&]()
+	{
+		ConLog.Write("Demuxer enter (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg);
+
+		DemuxerTask task;
+		DemuxerStream stream;
+		/*
+		ElementaryStream* esAVC[16]; memset(esAVC, 0, sizeof(esAVC));
+		ElementaryStream* esM2V[16]; memset(esM2V, 0, sizeof(esM2V));
+		ElementaryStream* esDATA[16]; memset(esDATA, 0, sizeof(esDATA));
+		ElementaryStream* esATRAX[48]; memset(esATRAX, 0, sizeof(esATRAX));
+		ElementaryStream* esAC3[48]; memset(esAC3, 0, sizeof(esAC3));
+		ElementaryStream* esLPCM[48]; memset(esLPCM, 0, sizeof(esLPCM));
+		*/
+		ElementaryStream* esALL[192]; memset(esALL, 0, sizeof(esALL));
+		ElementaryStream** esAVC = &esALL[0];
+
+		u32 cb_add = 0;
+
+		while (true)
+		{
+			if (Emu.IsStopped())
+			{
+				break;
+			}
+			
+			if (dmux.job.IsEmpty() && dmux.is_running)
+			{
+				// default task (demuxing) (if there is no other work)
+				be_t<u32> code;
+				be_t<u16> len;
+				u8 ch;
+
+				if (!stream.peek(code)) 
+				{
+					// demuxing finished
+					task.type = dmuxResetStream;
+					goto task;
+				}
+				else switch (code.ToLE())
+				{
+				case PACK_START_CODE:
+					{
+						stream.skip(14);
+					}
+					break;
+
+				case SYSTEM_HEADER_START_CODE:
+					{
+						stream.skip(18);
+					}
+					break;
+
+				case PADDING_STREAM:
+				case PRIVATE_STREAM_2:
+					{
+						// unknown
+						stream.skip(4);
+						stream.get(len);
+						stream.skip(len);
+					}
+					break;
+
+				case PRIVATE_STREAM_1:
+					{
+						// audio AT3+ (and probably LPCM or user data)
+						stream.skip(4);
+						stream.get(len);
+
+						// skipping...
+						stream.skip(len);
+					}
+					break;
+
+				case 0x1e0: case 0x1e1: case 0x1e2: case 0x1e3:
+				case 0x1e4: case 0x1e5: case 0x1e6: case 0x1e7:
+				case 0x1e8: case 0x1e9: case 0x1ea: case 0x1eb:
+				case 0x1ec: case 0x1ed: case 0x1ee: case 0x1ef:
+					{
+						// video AVC
+						ch = code - 0x1e0;
+						if (esAVC[ch])
+						{
+							ElementaryStream& es = *esAVC[ch];
+							if (es.isfull())
+							{
+								Sleep(1);
+								continue;
+							}
+
+							stream.skip(4);
+							stream.get(len);
+							PesHeader pes(stream);
+
+							if (!pes.size && !es.hasdata()) // fatal error
+							{
+								ConLog.Error("PES not found");
+								return;
+							}
+
+							if (pes.size && es.hasdata()) // new AU detected
+							{
+								es.finish(stream);
+								// callback
+								mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+								esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
+								esMsg->supplementalInfo = stream.userdata;
+								Callback cb;
+								cb.SetAddr(es.cbFunc);
+								cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+								cb.Branch(false);
+							}
+
+							if (pes.size)
+							{
+								//ConLog.Write("*** AVC AU detected (pts=0x%x, dts=0x%x)", pes.pts, pes.dts);
+							}
+
+							es.push(stream, len - pes.size - 3, pes);
+						}
+						else
+						{
+							stream.skip(4);
+							stream.get(len);
+							stream.skip(len);
+						}
+					}
+					break;
+
+				case 0x1c0: case 0x1c1: case 0x1c2: case 0x1c3:
+				case 0x1c4: case 0x1c5: case 0x1c6: case 0x1c7:
+				case 0x1c8: case 0x1c9: case 0x1ca: case 0x1cb:
+				case 0x1cc: case 0x1cd: case 0x1ce: case 0x1cf:
+				case 0x1d0: case 0x1d1: case 0x1d2: case 0x1d3:
+				case 0x1d4: case 0x1d5: case 0x1d6: case 0x1d7:
+				case 0x1d8: case 0x1d9: case 0x1da: case 0x1db:
+				case 0x1dc: case 0x1dd: case 0x1de: case 0x1df:
+					{
+						// unknown
+						stream.skip(4);
+						stream.get(len);
+						stream.skip(len);
+					}
+					break;
+
+				case USER_DATA_START_CODE:
+					{
+						ConLog.Error("USER_DATA_START_CODE found");
+						return;
+					}
+
+				default:
+					{
+						// search
+						stream.skip(1);
+					}
+					break;
+
+				}
+				continue;
+			}
+
+			// wait for task with yielding (if no default work)
+			if (!dmux.job.Pop(task))
+			{
+				break; // Emu is stopped
+			}
+task:
+			switch (task.type)
+			{
+			case dmuxSetStream:
+				{
+					stream = task.stream;
+					ConLog.Write("*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
+						stream.addr, stream.size, stream.discontinuity, stream.userdata);
+					if (stream.discontinuity) for (u32 i = 0; i < 192; i++)
+					{
+						if (esALL[i])
+						{
+							esALL[i]->reset();
+						}
+					}
+					dmux.is_running = true;
+				}
+				break;
+
+			case dmuxResetStream:
+			case dmuxResetStreamAndWaitDone:
+				{
+					// TODO: send CELL_DMUX_MSG_TYPE_DEMUX_DONE callback and provide waiting condition
+					mem_ptr_t<CellDmuxMsg> dmuxMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+					dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
+					dmuxMsg->supplementalInfo = stream.userdata;
+					Callback cb;
+					cb.SetAddr(dmux.cbFunc);
+					cb.Handle(dmux.id, dmuxMsg.GetAddr(), dmux.cbArg);
+					cb.Branch(task.type == dmuxResetStreamAndWaitDone);
+					dmux.is_running = false;
+				}
+				break;
+
+			case dmuxClose:
+				{
+					dmux.is_finished = true;
+					ConLog.Write("Demuxer exit");
+					return;
+				}
+
+			case dmuxEnableEs:
+				{
+					ElementaryStream& es = *task.es.es_ptr;
+					if (es.fidMajor >= 0xe0 &&
+						es.fidMajor <= 0xef &&
+						es.fidMinor == 0 &&
+						es.sup1 == 1 &&
+						es.sup2 == 0)
+					{
+						esAVC[es.fidMajor - 0xe0] = task.es.es_ptr;
+					}
+					else
+					{
+						ConLog.Warning("dmuxEnableEs: (TODO) unsupported filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2);
+					}
+					es.dmux = &dmux;
+				}
+				break;
+
+			case dmuxDisableEs:
+				{
+					ElementaryStream& es = *task.es.es_ptr;
+					if (es.dmux != &dmux)
+					{
+						ConLog.Warning("dmuxDisableEs: invalid elementary stream");
+						break;
+					}
+					for (u32 i = 0; i < 192; i++)
+					{
+						if (esALL[i] == &es)
+						{
+							esALL[i] = nullptr;
+						}
+					}
+					es.dmux = nullptr;
+					Emu.GetIdManager().RemoveID(task.es.es);
+				}
+				break;
+
+			case dmuxReleaseAu:
+				{
+					task.es.es_ptr->release();
+				}
+				break;
+
+			case dmuxFlushEs:
+				{
+					ElementaryStream& es = *task.es.es_ptr;
+
+					if (es.hasdata())
+					{
+						es.finish(stream);
+						// callback
+						mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+						esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
+						esMsg->supplementalInfo = stream.userdata;
+						Callback cb;
+						cb.SetAddr(es.cbFunc);
+						cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+						cb.Branch(false);
+					}
+
+					// callback
+					mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+					esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE;
+					esMsg->supplementalInfo = stream.userdata;
+					Callback cb;
+					cb.SetAddr(es.cbFunc);
+					cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+					cb.Branch(false);
+				}
+				break;
+
+			case dmuxResetEs:
+				{
+					task.es.es_ptr->reset();
+				}
+				break;
+
+			default:
+				ConLog.Error("Demuxer error: unknown task(%d)", task.type);
+				return;
+			}
+		}
+		ConLog.Warning("Demuxer aborted");
+	});
+
+	t.detach();
+
+	return dmux_id;
 }
 
 int cellDmuxQueryAttr(const mem_ptr_t<CellDmuxType> demuxerType, mem_ptr_t<CellDmuxAttr> demuxerAttr)
@@ -61,53 +370,6 @@ int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<Ce
 	return CELL_OK;
 }
 
-u32 dmuxOpen(Demuxer* data)
-{
-	Demuxer& dmux = *data;
-
-	u32 id = cellDmux.GetNewId(data);
-
-	thread t("Demuxer [" + std::to_string(id) + "] Thread", [&]()
-	{
-		ConLog.Write("Demuxer enter (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg);
-
-		DemuxerTask task;
-
-		while (true)
-		{
-			if (!dmux.job.Pop(task))
-			{
-				break;
-			}
-
-			switch (task.type)
-			{
-			case dmuxSetStream:
-			case dmuxResetStream:
-			case dmuxEnableEs:
-			case dmuxDisableEs:
-			case dmuxResetEs:
-			case dmuxGetAu:
-			case dmuxPeekAu:
-			case dmuxReleaseAu:
-			case dmuxFlushEs:
-			case dmuxClose:
-				dmux.is_finished = true;
-				ConLog.Write("Demuxer exit");
-				return;
-			default:
-				ConLog.Error("Demuxer error: unknown task(%d)", task.type);
-			}
-		}
-
-		ConLog.Warning("Demuxer aborted");
-	});
-
-	t.detach();
-
-	return id;
-}
-
 int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResource> demuxerResource, 
 				 const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
 {
@@ -131,7 +393,7 @@ int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Cell
 
 	// TODO: check demuxerResource and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource->memAddr, demuxerResource->memSize, (CellDmuxCbMsg&)demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource->memAddr, demuxerResource->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
@@ -159,7 +421,7 @@ int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Ce
 
 	// TODO: check demuxerResourceEx and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResourceEx->memAddr, demuxerResourceEx->memSize, (CellDmuxCbMsg&)demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	demuxerHandle = dmuxOpen(new Demuxer(demuxerResourceEx->memAddr, demuxerResourceEx->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
@@ -187,7 +449,7 @@ int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<C
 
 	// TODO: check demuxerType2, demuxerResource2 and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource2->memAddr, demuxerResource2->memSize, (CellDmuxCbMsg&)demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource2->memAddr, demuxerResource2->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
@@ -221,7 +483,7 @@ int cellDmuxClose(u32 demuxerHandle)
 
 int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize, bool discontinuity, u64 userData)
 {
-	cellDmux.Warning("cellDmuxSetStream(demuxerHandle=%d, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx",
+	cellDmux.Log("cellDmuxSetStream(demuxerHandle=%d, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx",
 		demuxerHandle, streamAddress, streamSize, discontinuity, userData);
 
 	Demuxer* dmux;
@@ -235,8 +497,9 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
 		return CELL_DMUX_ERROR_FATAL;
 	}
 
-	if (!dmux->job.IsEmpty())
+	if (dmux->is_running)
 	{
+		Sleep(1); // performance hack
 		return CELL_DMUX_ERROR_BUSY;
 	}
 
@@ -248,12 +511,22 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
 	info.userdata = userData;
 
 	dmux->job.Push(task);
+
+	while (!dmux->is_running)
+	{
+		if (Emu.IsStopped())
+		{
+			ConLog.Warning("cellDmuxSetStream(%d) aborted", demuxerHandle);
+			break;
+		}
+		Sleep(1);
+	}
 	return CELL_OK;
 }
 
 int cellDmuxResetStream(u32 demuxerHandle)
 {
-	cellDmux.Warning("cellDmuxResetStream(demuxerHandle=%d)", demuxerHandle);
+	cellDmux.Log("cellDmuxResetStream(demuxerHandle=%d)", demuxerHandle);
 
 	Demuxer* dmux;
 	if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@@ -268,7 +541,7 @@ int cellDmuxResetStream(u32 demuxerHandle)
 
 int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
 {
-	cellDmux.Error("cellDmuxResetStreamAndWaitDone(demuxerHandle=%d)", demuxerHandle);
+	cellDmux.Log("cellDmuxResetStreamAndWaitDone(demuxerHandle=%d)", demuxerHandle);
 
 	Demuxer* dmux;
 	if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@@ -276,9 +549,17 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	dmux->job.Push(DemuxerTask(dmuxResetStream));
+	dmux->job.Push(DemuxerTask(dmuxResetStreamAndWaitDone));
 
-	// TODO: wait done
+	while (dmux->is_running)
+	{
+		if (Emu.IsStopped())
+		{
+			ConLog.Warning("cellDmuxResetStreamAndWaitDone(%d) aborted", demuxerHandle);
+			break;
+		}
+		Sleep(1);
+	}
 
 	return CELL_OK;
 }
@@ -314,7 +595,7 @@ int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr
 int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
 						 const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> esAttr)
 {
-	cellDmux.Error("cellDmuxQueryEsAttr2(demuxerType2_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
+	cellDmux.Warning("cellDmuxQueryEsAttr2(demuxerType2_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
 		demuxerType2.GetAddr(), esFilterId.GetAddr(), esSpecificInfo_addr, esAttr.GetAddr());
 
 	if (!demuxerType2.IsGood() || !esFilterId.IsGood() || !esAttr.IsGood())
@@ -373,13 +654,17 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
 
 	ElementaryStream* es = new ElementaryStream(dmux, esResourceInfo->memAddr, esResourceInfo->memSize,
 		esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2,
-		(CellDmuxCbEsMsg&)esCb->cbEsMsgFunc, esCb->cbArg_addr, esSpecificInfo_addr);
+		esCb->cbEsMsgFunc, esCb->cbArg_addr, esSpecificInfo_addr);
 
 	u32 id = cellDmux.GetNewId(es);
+	es->id = id;
+
+	cellDmux.Warning("*** New ES(dmux=%d, addr=0x%x, size=0x%x, filter(0x%x, 0x%x, 0x%x, 0x%x), cb=0x%x(arg=0x%x), spec=0x%x): id = %d",
+		demuxerHandle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, (u32)esCb->cbEsMsgFunc, es->cbArg, es->spec, id);
 
 	DemuxerTask task(dmuxEnableEs);
-	task.au.es = id;
-	task.au.es_ptr = es;
+	task.es.es = id;
+	task.es.es_ptr = es;
 
 	dmux->job.Push(task);
 	return CELL_OK;
@@ -396,8 +681,8 @@ int cellDmuxDisableEs(u32 esHandle)
 	}
 
 	DemuxerTask task(dmuxDisableEs);
-	task.esHandle = esHandle;
-	task.au.es_ptr = es;
+	task.es.es = esHandle;
+	task.es.es_ptr = es;
 
 	es->dmux->job.Push(task);
 	return CELL_OK;
@@ -405,7 +690,7 @@ int cellDmuxDisableEs(u32 esHandle)
 
 int cellDmuxResetEs(u32 esHandle)
 {
-	cellDmux.Warning("cellDmuxResetEs(esHandle=0x%x)", esHandle);
+	cellDmux.Log("cellDmuxResetEs(esHandle=0x%x)", esHandle);
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -414,44 +699,17 @@ int cellDmuxResetEs(u32 esHandle)
 	}
 
 	DemuxerTask task(dmuxResetEs);
-	task.esHandle = esHandle;
-	task.au.es_ptr = es;
+	task.es.es = esHandle;
+	task.es.es_ptr = es;
 
 	es->dmux->job.Push(task);
 	return CELL_OK;
 }
 
-int cellDmuxGetAu(u32 esHandle, const u32 auInfo_ptr_addr, u32 auSpecificInfo_ptr_addr)
+int cellDmuxGetAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
 {
-	cellDmux.Error("cellDmuxGetAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfo_ptr_addr, auSpecificInfo_ptr_addr);
-	return CELL_OK;
-}
-
-int cellDmuxPeekAu(u32 esHandle, const u32 auInfo_ptr_addr, u32 auSpecificInfo_ptr_addr)
-{
-	cellDmux.Error("cellDmuxPeekAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfo_ptr_addr, auSpecificInfo_ptr_addr);
-	return CELL_OK;
-}
-
-int cellDmuxGetAuEx(u32 esHandle, const u32 auInfoEx_ptr_addr, u32 auSpecificInfo_ptr_addr)
-{
-	cellDmux.Error("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfoEx_ptr_addr, auSpecificInfo_ptr_addr);
-	return CELL_OK;
-}
-
-int cellDmuxPeekAuEx(u32 esHandle, const u32 auInfoEx_ptr_addr, u32 auSpecificInfo_ptr_addr)
-{
-	cellDmux.Error("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfoEx_ptr_addr, auSpecificInfo_ptr_addr);
-	return CELL_OK;
-}
-
-int cellDmuxReleaseAu(u32 esHandle)
-{
-	cellDmux.Warning("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
+	cellDmux.Log("cellDmuxGetAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
+		esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -459,9 +717,125 @@ int cellDmuxReleaseAu(u32 esHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
+	if (!auInfo_ptr.IsGood() || !auSpecificInfo_ptr.IsGood())
+	{
+		return CELL_DMUX_ERROR_FATAL;
+	}
+
+	u32 info;
+	u32 spec;
+	if (!es->peek(info, true, spec, true))
+	{
+		return CELL_DMUX_ERROR_EMPTY;
+	}
+
+	auInfo_ptr = info;
+	auSpecificInfo_ptr = spec;
+	return CELL_OK;
+}
+
+int cellDmuxPeekAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
+{
+	cellDmux.Log("cellDmuxPeekAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
+		esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+
+	ElementaryStream* es;
+	if (!Emu.GetIdManager().GetIDData(esHandle, es))
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (!auInfo_ptr.IsGood() || !auSpecificInfo_ptr.IsGood())
+	{
+		return CELL_DMUX_ERROR_FATAL;
+	}
+
+	u32 info;
+	u32 spec;
+	if (!es->peek(info, true, spec, false))
+	{
+		return CELL_DMUX_ERROR_EMPTY;
+	}
+
+	auInfo_ptr = info;
+	auSpecificInfo_ptr = spec;
+	return CELL_OK;
+}
+
+int cellDmuxGetAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
+{
+	cellDmux.Log("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
+		esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+
+	ElementaryStream* es;
+	if (!Emu.GetIdManager().GetIDData(esHandle, es))
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (!auInfoEx_ptr.IsGood() || !auSpecificInfo_ptr.IsGood())
+	{
+		return CELL_DMUX_ERROR_FATAL;
+	}
+
+	u32 info;
+	u32 spec;
+	if (!es->peek(info, false, spec, true))
+	{
+		return CELL_DMUX_ERROR_EMPTY;
+	}
+
+	auInfoEx_ptr = info;
+	auSpecificInfo_ptr = spec;
+	return CELL_OK;
+}
+
+int cellDmuxPeekAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
+{
+	cellDmux.Log("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
+		esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+
+	ElementaryStream* es;
+	if (!Emu.GetIdManager().GetIDData(esHandle, es))
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (!auInfoEx_ptr.IsGood() || !auSpecificInfo_ptr.IsGood())
+	{
+		return CELL_DMUX_ERROR_FATAL;
+	}
+
+	u32 info;
+	u32 spec;
+	if (!es->peek(info, false, spec, false))
+	{
+		return CELL_DMUX_ERROR_EMPTY;
+	}
+
+	auInfoEx_ptr = info;
+	auSpecificInfo_ptr = spec;
+	return CELL_OK;
+}
+
+int cellDmuxReleaseAu(u32 esHandle)
+{
+	cellDmux.Log("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
+
+	ElementaryStream* es;
+	if (!Emu.GetIdManager().GetIDData(esHandle, es))
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (!es->canrelease())
+	{
+		return CELL_DMUX_ERROR_SEQ;
+	}
+
 	DemuxerTask task(dmuxReleaseAu);
-	task.esHandle = esHandle;
-	task.au.es_ptr = es;
+	task.es.es = esHandle;
+	task.es.es_ptr = es;
 
 	es->dmux->job.Push(task);
 	return CELL_OK;
@@ -469,7 +843,7 @@ int cellDmuxReleaseAu(u32 esHandle)
 
 int cellDmuxFlushEs(u32 esHandle)
 {
-	cellDmux.Warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
+	cellDmux.Log("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -478,8 +852,8 @@ int cellDmuxFlushEs(u32 esHandle)
 	}
 
 	DemuxerTask task(dmuxFlushEs);
-	task.esHandle = esHandle;
-	task.au.es_ptr = es;
+	task.es.es = esHandle;
+	task.es.es_ptr = es;
 
 	es->dmux->job.Push(task);
 	return CELL_OK;