OMX_ERRORTYPE VideoFilter::ProcessPartialInput()
{
if(PartialInputHdr.pBuffer == NULL) {
PartialInputHdr.pBuffer = (OMX_U8*)AllocateInputBuffer(2*pInBufferHdr->nAllocLen);
if(PartialInputHdr.pBuffer == NULL) {
LOG_WARNING("Allocate buffer for partial input failed, size: %d.\n", 2*pInBufferHdr->nAllocLen);
return OMX_ErrorInsufficientResources;
}
PartialInputHdr.nAllocLen = 2*pInBufferHdr->nAllocLen;
PartialInputHdr.nFlags = pInBufferHdr->nFlags;
PartialInputHdr.nTimeStamp = pInBufferHdr->nTimeStamp;
}
else {
if(PartialInputHdr.nAllocLen - PartialInputHdr.nFilledLen < pInBufferHdr->nFilledLen) {
OMX_PTR pBuffer = NULL;
pBuffer = AllocateInputBuffer(2*PartialInputHdr.nAllocLen);
if(pBuffer == NULL) {
LOG_WARNING("Allocate buffer for partial input failed, size: %d.\n", PartialInputHdr.nAllocLen);
return OMX_ErrorInsufficientResources;
}
fsl_osal_memcpy(pBuffer, PartialInputHdr.pBuffer, PartialInputHdr.nFilledLen);
FreeInputBuffer(PartialInputHdr.pBuffer);
PartialInputHdr.pBuffer = (OMX_U8 *)pBuffer;
PartialInputHdr.nAllocLen *= 2;
}
}
fsl_osal_memcpy(PartialInputHdr.pBuffer + PartialInputHdr.nFilledLen, pInBufferHdr->pBuffer, pInBufferHdr->nFilledLen);
PartialInputHdr.nFilledLen += pInBufferHdr->nFilledLen;
ports[IN_PORT]->SendBuffer(pInBufferHdr);
pInBufferHdr = NULL;
return OMX_ErrorNone;
}
OMX_ERRORTYPE VideoFilter::DoFreeBuffer(OMX_PTR buffer,OMX_U32 nPortIndex)
{
if(nPortIndex == IN_PORT)
FreeInputBuffer(buffer);
if(nPortIndex == OUT_PORT)
FreeOutputBuffer(buffer);
return OMX_ErrorNone;
}
OMX_ERRORTYPE VideoFilter::ReturnInputBuffer()
{
if(PartialInputHdr.pBuffer != NULL) {
FreeInputBuffer(PartialInputHdr.pBuffer);
fsl_osal_memset(&PartialInputHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
pInBufferHdr = NULL;
}
else if(pInBufferHdr != NULL) {
ports[IN_PORT]->SendBuffer(pInBufferHdr);
pInBufferHdr = NULL;
}
return OMX_ErrorNone;
}
NTSTATUS
AllocateConsole(
IN HANDLE ConsoleHandle,
IN LPWSTR Title,
IN USHORT TitleLength,
IN HANDLE ClientProcessHandle,
OUT PHANDLE StdIn,
OUT PHANDLE StdOut,
OUT PHANDLE StdErr,
OUT PCONSOLE_PER_PROCESS_DATA ProcessData,
IN OUT PCONSOLE_INFO ConsoleInfo,
IN BOOLEAN WindowVisible,
IN DWORD dwConsoleThreadId,
IN HDESK Desktop
)
/*++
Routine Description:
This routine allocates and initialized a console and its associated
data - input buffer and screen buffer.
Arguments:
ConsoleHandle - Handle of console to allocate.
dwWindowSize - Initial size of screen buffer window, in rows and columns.
nFont - Initial number of font text is displayed in.
dwScreenBufferSize - Initial size of screen buffer, in rows and columns.
nInputBufferSize - Initial size of input buffer, in events.
dwWindowFlags -
StdIn - On return, contains handle to stdin.
StdOut - On return, contains handle to stdout.
StdErr - On return, contains handle to stderr.
ProcessData - On return, contains the initialized per-process data.
Return Value:
Note:
The console handle table lock must be held when calling this routine.
--*/
{
PCONSOLE_INFORMATION Console;
NTSTATUS Status;
BOOL Success;
//
// allocate console data
//
Console = (PCONSOLE_INFORMATION)HeapAlloc(pConHeap, MAKE_TAG( CONSOLE_TAG ) | HEAP_ZERO_MEMORY,
sizeof(CONSOLE_INFORMATION));
if (Console == NULL) {
return STATUS_NO_MEMORY;
}
ConsoleHandles[IndexFromHandle(ConsoleHandle)] = Console;
Console->Flags = WindowVisible ? 0 : CONSOLE_NO_WINDOW;
Console->hIcon = ConsoleInfo->hIcon;
Console->iIconId = ConsoleInfo->iIconId;
Console->dwHotKey = ConsoleInfo->dwHotKey;
Console->CP = OEMCP;
Console->OutputCP = ConsoleOutputCP;
Console->ReserveKeys = CONSOLE_NOSHORTCUTKEY;
Console->ConsoleHandle = ConsoleHandle;
Console->bIconInit = TRUE;
Console->VerticalClientToWindow = VerticalClientToWindow;
Console->HorizontalClientToWindow = HorizontalClientToWindow;
//
// must wait for window to be destroyed or client impersonation won't
// work.
//
Status = NtDuplicateObject(NtCurrentProcess(),
CONSOLE_CLIENTTHREADHANDLE(CSR_SERVER_QUERYCLIENTTHREAD()),
NtCurrentProcess(),
&Console->ClientThreadHandle,
0,
FALSE,
DUPLICATE_SAME_ACCESS
);
if (!NT_SUCCESS(Status)) {
goto ErrorExit5;
}
#if DBG
//
// Make sure the handle isn't protected so we can close it later
//
UnProtectHandle(Console->ClientThreadHandle);
#endif // DBG
InitializeListHead(&Console->OutputQueue);
InitializeListHead(&Console->ProcessHandleList);
InitializeListHead(&Console->ExeAliasList);
Status = NtCreateEvent(&Console->InitEvents[INITIALIZATION_SUCCEEDED],
EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE);
if (!NT_SUCCESS(Status)) {
goto ErrorExit4a;
}
Status = NtCreateEvent(&Console->InitEvents[INITIALIZATION_FAILED],
EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE);
if (!NT_SUCCESS(Status)) {
goto ErrorExit4;
}
Status = RtlInitializeCriticalSection(&Console->ConsoleLock);
if (!NT_SUCCESS(Status)) {
goto ErrorExit3a;
}
InitializeConsoleCommandData(Console);
//
// initialize input buffer
//
Status = CreateInputBuffer(ConsoleInfo->nInputBufferSize,
&Console->InputBuffer);
if (!NT_SUCCESS(Status)) {
goto ErrorExit3;
}
Console->Title = (PWCHAR)HeapAlloc(pConHeap,MAKE_TAG( TITLE_TAG ),TitleLength+sizeof(WCHAR));
if (Console->Title == NULL) {
Status = STATUS_NO_MEMORY;
goto ErrorExit2;
}
RtlCopyMemory(Console->Title,Title,TitleLength);
Console->Title[TitleLength/sizeof(WCHAR)] = (WCHAR)0; // NULL terminate
Console->TitleLength = TitleLength;
Console->OriginalTitle = (PWCHAR)HeapAlloc(pConHeap,MAKE_TAG( TITLE_TAG ),TitleLength+sizeof(WCHAR));
if (Console->OriginalTitle == NULL) {
Status = STATUS_NO_MEMORY;
goto ErrorExit1;
}
RtlCopyMemory(Console->OriginalTitle,Title,TitleLength);
Console->OriginalTitle[TitleLength/sizeof(WCHAR)] = (WCHAR)0; // NULL terminate
Console->OriginalTitleLength = TitleLength;
Status = NtCreateEvent(&Console->TerminationEvent,
EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE);
if (!NT_SUCCESS(Status)) {
goto ErrorExit1a;
}
//
// initialize screen buffer. we don't call OpenConsole to do this
// because we need to specify the font, windowsize, etc.
//
Status = DoCreateScreenBuffer(Console,
ConsoleInfo,
Console->Title);
if (!NT_SUCCESS(Status)) {
goto ErrorExit1b;
}
Console->CurrentScreenBuffer = Console->ScreenBuffers;
Status = InitializeIoHandleTable(Console,
ProcessData,
StdIn,
StdOut,
StdErr
);
if (!NT_SUCCESS(Status)) {
goto ErrorExit0;
}
//
// map event handles
//
if (!MapHandle(ClientProcessHandle,
Console->InitEvents[INITIALIZATION_SUCCEEDED],
&ConsoleInfo->InitEvents[INITIALIZATION_SUCCEEDED]
)) {
Status = STATUS_NO_MEMORY;
goto ErrorExit0;
}
if (!MapHandle(ClientProcessHandle,
Console->InitEvents[INITIALIZATION_FAILED],
&ConsoleInfo->InitEvents[INITIALIZATION_FAILED]
)) {
Status = STATUS_NO_MEMORY;
goto ErrorExit0;
}
if (!MapHandle(ClientProcessHandle,
Console->InputBuffer.InputWaitEvent,
&ConsoleInfo->InputWaitHandle
)) {
Status = STATUS_NO_MEMORY;
goto ErrorExit0;
}
Success = PostThreadMessage(dwConsoleThreadId,
CM_CREATE_CONSOLE_WINDOW,
(DWORD)Console,
(LONG)ClientProcessHandle
);
if (!Success) {
KdPrint(("CONSRV: PostThreadMessage failed %d\n",GetLastError()));
Status = STATUS_UNSUCCESSFUL;
goto ErrorExit0;
}
return STATUS_SUCCESS;
ErrorExit0:
Console->ScreenBuffers->RefCount = 0;
FreeScreenBuffer(Console->ScreenBuffers);
ErrorExit1b:
NtClose(Console->TerminationEvent);
ErrorExit1a:
HeapFree(pConHeap,0,Console->OriginalTitle);
ErrorExit1:
HeapFree(pConHeap,0,Console->Title);
ErrorExit2:
Console->InputBuffer.RefCount = 0;
FreeInputBuffer(&Console->InputBuffer);
ErrorExit3:
RtlDeleteCriticalSection(&Console->ConsoleLock);
ErrorExit3a:
NtClose(Console->InitEvents[INITIALIZATION_FAILED]);
ErrorExit4:
NtClose(Console->InitEvents[INITIALIZATION_SUCCEEDED]);
ErrorExit4a:
NtClose(Console->ClientThreadHandle);
ErrorExit5:
HeapFree(pConHeap,0,Console);
return Status;
}
