ig_api.cpp

这是DVD中伺服部分的核心代码

        OS_SemDelete(IGInfo.ICSLock);
        IGInfo.ICSLock = 0;
    }

    if (IGInfo.ParseLock)
    {
        OS_SemDelete(IGInfo.ParseLock);
        IGInfo.ParseLock = 0;
    }

    if (IGInfo.ParseWait.WaitSem)
    {
        OS_SemDelete(IGInfo.ParseWait.WaitSem);
        IGInfo.ParseWait.WaitSem = 0;
    }

    if (IGInfo.RenderWait.WaitSem)
    {
        OS_SemDelete(IGInfo.RenderWait.WaitSem);
        IGInfo.RenderWait.WaitSem = 0;
    }

    if (IGInfo.IGParseBuffer != NULL)
    {
        OS_MemFree(IGInfo.IGParseBuffer);

       IGInfo.IGParseBuffer = NULL;
    }

    /* release dfb surface */
    if (IGInfo.IGDFBInfo.PrimarySurface != NULL)
    {
        IGInfo.IGDFBInfo.PrimarySurface->Release(IGInfo.IGDFBInfo.PrimarySurface);
    }

    /* release surface manager */
    if (IGInfo.IGDFBInfo.SurfaceManager != NULL)
    {
        IGInfo.IGDFBInfo.SurfaceManager->Release(IGInfo.IGDFBInfo.SurfaceManager);
    }

    return IG_STATUS_ERROR;
}

/**
 * IGDelete - stop threads and free all memory
 *
 * @param IG_HANDLE handle - handle to the IG module
 *
 * @return IG_STATUS
 */
IG_STATUS IGDelete(IG_HANDLE handle)
{
    if (handle != (PVOID)IG_HANDLE_VALUE)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGDelete(): IG_HANDLE_VALUE\n"));
        return IG_STATUS_INVALID_HANDLE;
    }

    DBGPRINT(DBG_ON(DBG_TRACE), ("--IGDelete()\n"));

    /* must be in the stopped state to shutdown */
    if ((IG_STATE_STOPPED == IGInfo.CurrentState) || (IG_STATE_INITIALIZED == IGInfo.CurrentState))
    {
        /* set the exit flag for the parser and renderer */
        IGInfo.QuitFlags = IG_FLAGS_EXIT;

        IGSendEmptyMessageToStream(IGInfo.IGParseQ);
        IGSendEmptyMessageToStream(IGInfo.IGRenderQ);

        OS_TaskJoin(IGInfo.IGParseTask);
        OS_TaskJoin(IGInfo.IGRenderTask);

        /* Clear buffer and set timer for flip */
        IGGraphicsClearBuffer(NULL, 0);
        IGInfo.IGDFBInfo.DispLayer->SetLevel(IGInfo.IGDFBInfo.DispLayer, IG_DISPLAY_NO_SHOW);
        IGGraphicsFlip();

        /* destroy all threads and cleanup memory */
        if (IGInfo.IGParseTask)
        {
            OS_TaskJoin(IGInfo.IGParseTask);
            OS_TaskDelete(IGInfo.IGParseTask);
            IGInfo.IGParseTask = 0;
        }

        if (IGInfo.IGRenderTask)
        {
            OS_TaskJoin(IGInfo.IGRenderTask);
            OS_TaskDelete(IGInfo.IGRenderTask);
            IGInfo.IGRenderTask = 0;
        }

        if (IGInfo.TimerFlip)
        {
            OS_TimerDelete(IGInfo.TimerFlip);
            IGInfo.TimerFlip = 0;
        }

        if (IGInfo.TimerUserSelection)
        {
            OS_TimerDelete(IGInfo.TimerUserSelection);
            IGInfo.TimerUserSelection = 0;
        }

        if (IGInfo.TimerAnimation)
        {
            OS_TimerDelete(IGInfo.TimerAnimation);
            IGInfo.TimerAnimation = 0;
        }

        if (IGInfo.IGParseQ)
        {
            IGInfo.IGParseQ->Destroy();
            delete IGInfo.IGParseQ;
            IGInfo.IGParseQ = NULL;
        }

        if (IGInfo.IGParseQPool)
        {
            OS_MemFree(IGInfo.IGParseQPool);
            IGInfo.IGParseQPool = NULL;
        }

        if (IGInfo.IGRenderQ)
        {
            IGInfo.IGRenderQ->Destroy();
            delete IGInfo.IGRenderQ;
            IGInfo.IGRenderQ = NULL;
        }

        if (IGInfo.IGRenderQPool)
        {
            OS_MemFree(IGInfo.IGRenderQPool);
            IGInfo.IGRenderQPool = NULL;
        }

        if (IGInfo.ICSLock)
        {
            OS_SemDelete(IGInfo.ICSLock);
            IGInfo.ICSLock = 0;
        }

        if (IGInfo.ParseLock)
        {
            OS_SemDelete(IGInfo.ParseLock);
            IGInfo.ParseLock = 0;
        }

        if (IGInfo.BlitLock)
        {
            OS_SemDelete(IGInfo.BlitLock);
            IGInfo.BlitLock = 0;
        }

        if (IGInfo.StateLock)
        {
            OS_SemDelete(IGInfo.StateLock);
            IGInfo.StateLock = 0;
        }

        if (IGInfo.ParseWait.WaitSem)
        {
            OS_SemDelete(IGInfo.ParseWait.WaitSem);
            IGInfo.ParseWait.WaitSem = 0;
        }

        if (IGInfo.RenderWait.WaitSem)
        {
            OS_SemDelete(IGInfo.RenderWait.WaitSem);
            IGInfo.RenderWait.WaitSem = 0;
        }

        if (IGInfo.IGParseBuffer != NULL)
        {
            OS_MemFree(IGInfo.IGParseBuffer);

            IGInfo.IGParseBuffer = NULL;
        }

        /* hide IG when we shut down */
        IGGraphicsDeleteAllPalettes();

        /* release dfb surface */
        if (IGInfo.IGDFBInfo.PrimarySurface != NULL)
        {
            IGInfo.IGDFBInfo.PrimarySurface->Release(IGInfo.IGDFBInfo.PrimarySurface);
        }

        /* release surface manager */
        if (IGInfo.IGDFBInfo.SurfaceManager != NULL)
        {
            IGInfo.IGDFBInfo.SurfaceManager->Release(IGInfo.IGDFBInfo.SurfaceManager);
        }

        IGInfo.CurrentState = IG_STATE_UNINITIALIZED;
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGDelete(): IG_STATUS_NOT_STOPPED\n"));
        return IG_STATUS_NOT_STOPPED;
    }

    return IG_STATUS_SUCCESS;
}


/**
 * IGAttachEvent - Attach an event handler to the IG module
 *
 * @param IG_HANDLE handle - handle to the IG module
 *
 * @return IG_STATUS
 */
IG_STATUS IGAttachEvent(IG_HANDLE handle, PVOID Context, IG_EVENT_CALLBACK IGEvent)
{
    if (handle != (PVOID)IG_HANDLE_VALUE)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGAttachEvent(): Invalid Handle\n"));
        return IG_STATUS_INVALID_HANDLE;
    }

    /* get the context */
    IGInfo.IGEventContext = Context;

    /* get the IG CALLBACK ptr */
    IGInfo.IGEvent        = IGEvent;

    return IG_STATUS_SUCCESS;
}

/**
 * IGDetachEvent - Detach the Event handler and context from the IG module
 *
 * @param IG_HANDLE handle - handle to the IG module
 *
 * @return IG_STATUS
 */
IG_STATUS IGDetachEvent(IG_HANDLE handle)
{
    if (handle != (PVOID)IG_HANDLE_VALUE)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGDetachEvent(): Invalid Handle\n"));
        return IG_STATUS_INVALID_HANDLE;
    }

    /* remove the context */
    IGInfo.IGEventContext = NULL;

    /* remove the IG CALLBACK ptr */
    IGInfo.IGEvent        = NULL;

    return IG_STATUS_SUCCESS;
}


/**
 * IGRun - Enter the run state for the IG Module
 *
 * @param IG_HANDLE handle - handle to the IG module
 *
 * @return IG_STATUS
 */
IG_STATUS IGRun(IG_HANDLE handle)
{
    if (handle != (PVOID)IG_HANDLE_VALUE)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGRun(): Invalid Handle\n"));
        return IG_STATUS_INVALID_HANDLE;
    }

    if ((IG_STATE_STOPPED == IGInfo.CurrentState) || (IG_STATE_INITIALIZED == IGInfo.CurrentState))
    {
        /* intialize */
        OS_SemTake(IGInfo.StateLock, OS_WAIT_FOREVER);

        IGInfo.StreamAcquired     = 0;
        IGInfo.ParseWait.WaitPTS  = 0;
        IGInfo.RenderWait.WaitPTS = 0;
        IGInfo.CurPTS             = 0;
        IGInfo.CoordsHalfWidth    = 0;
        IGInfo.CopyingPES         = 0;
        IGInfo.CopyingMultiPES    = 0;
        IGInfo.SequenceDesc       = 0;
        IGInfo.fGotStartPtr       = 0;
        IGInfo.ParseReadPtr       = 0;
        IGInfo.PESWritePtr        = 1;
        IGInfo.PESWriteStart      = 1;
        gWaitForFrame             = 1;

        /* clear the pes header */
        memset(&IGInfo.CurPesInfo, 0, sizeof(PES_HDR_INFO));

        /* clearing binary semaphores */
        OS_SemTake(IGInfo.RenderWait.WaitSem, OS_NO_WAIT);
        OS_SemTake(IGInfo.ParseWait.WaitSem, OS_NO_WAIT);

        /* Clear the entire screen */
        OS_SemTake(IGInfo.BlitLock, OS_WAIT_FOREVER);
        IGGraphicsClearScreen();
        OS_SemGive(IGInfo.BlitLock);
        OS_TimerSet(IGInfo.TimerFlip, 1);
        OS_TaskYield();

        /* clear the stop flag */
        IGInfo.QuitFlags    = IG_FLAGS_RUN;
        IGInfo.CurrentState = IG_STATE_RUNNING;

        OS_SemGive(IGInfo.StateLock);
        DBGPRINT(DBG_ON(DBG_TRACE), ("--IGRun()\n"));

        return IG_STATUS_SUCCESS;
    }
    else
    {
        return IG_STATUS_NOT_INITIALIZED;
    }
}

/**
 * IGRun - Enter the stop state for the IG Module
 *
 * @param IG_HANDLE handle - handle to the IG module
 *
 * @return IG_STATUS
 */
IG_STATUS IGStop(IG_HANDLE handle)
{
    if (handle != (PVOID)IG_HANDLE_VALUE)
    {
        return IG_STATUS_INVALID_HANDLE;
    }

    if (IG_STATE_RUNNING == IGInfo.CurrentState)
    {
        /* stop the rendering thread, deque all messages to IGParse */
        IGInfo.QuitFlags = IG_FLAGS_STOP;
        IGInfo.CurrentState = IG_STATE_STOPPED;

        OS_SemTake(IGInfo.StateLock, OS_WAIT_FOREVER);

        /* clear the frame buffer here and clear all the object lists */
        IGFlush();

        /* popups are not on to start */
        IGInfo.fPopupEnabled = FALSE;

        DBGPRINT(DBG_ON(DBG_TRACE), ("--IGStop()\n"));
#ifdef ALLOW_IG_PROFILING
        ULONG TickRate = OS_GetTickRate();
        if (1 == IGStats.Profiling)
        {
            ULONG PixelsPerSec = 0;
            ULONG PixelsRemain = 0;
            if ((IGStats.TotalRLETicks/TickRate) != 0)
            {
                PixelsPerSec = IGStats.TotalPixelsDecoded/(IGStats.TotalRLETicks/TickRate);
                PixelsRemain = IGStats.TotalPixelsDecoded%(IGStats.TotalRLETicks/TickRate);
            }

            DBGPRINT(DBG_ON(DBG_ERROR), ("IGTotalBlitTime: %u.%u\nIGTotalFlipTime: %u.%u\nIGTotalRLETime: %u.%u\n"