ig_graphics.cpp

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

        }
        else
        {
            if (TempRegion.x2 > (IGInfo.IGDFBInfo.ScreenWidth-1))
            {
                TempRegion.x2 = IGInfo.IGDFBInfo.ScreenWidth-1;
            }            
        }

        /* check height */
        if (TempRegion.y2 > (IGInfo.IGDFBInfo.ScreenHeight-1))
        {
            TempRegion.y2 = IGInfo.IGDFBInfo.ScreenHeight-1;
        }

        /* NOTE: make sure the regions always start on even coordinates, 
           if they change to odd they seem to shift graphics */             
        if ((TempRegion.x1 & 0x01) != 0)
        {
            TempRegion.x1--;
        }

        if ((TempRegion.y1 & 0x01) != 0)
        {
            TempRegion.y1--;
        }

        if (TempRegion.x1 < 0)
        {
            TempRegion.x1 = 0;
        }

        if (TempRegion.y1 < 0)
        {
            TempRegion.y1 = 0;
        }       
        
        if (IGInfo.IGDFBInfo.PrimarySurface->Flip(IGInfo.IGDFBInfo.PrimarySurface, &TempRegion, DSFLIP_NONE) != DFB_OK)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("Failed to flip surface\n"));
        }

#ifdef ALLOW_IG_PROFILING
        if (IGStats.Profiling == 1)
        {
            IGStats.TotalFlipTicks += OS_GetTicks() - TickStart;
        }
#endif

        DBGPRINT(DBG_ON(DBG_VERBOSE), ("Flipped Region: (%d %d) w=%d h=%d\n", gIGFlipRegion.x1, gIGFlipRegion.y1,
                gIGFlipRegion.x2-gIGFlipRegion.x1, gIGFlipRegion.y2-gIGFlipRegion.y1));

    }
    else
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("IG Not Flipping (%d %d) w=%d h=%d\n", gIGFlipRegion.x1, gIGFlipRegion.y1,
                gIGFlipRegion.x2-gIGFlipRegion.x1, gIGFlipRegion.y2-gIGFlipRegion.y1));
    }

    OS_SemGive(IGInfo.BlitLock);
    return IG_STATUS_SUCCESS;
}

/**
 * IGGraphicsClearBuffer - present the backbuffer on screen
 *
 * @param void
 *
 * @return IG_STATUS
 */
IG_STATUS IGGraphicsClearBuffer(int *fUpdateScreen, int HaveSem)
{
    if (HaveSem == 0)
    {
        OS_SemTake(IGInfo.BlitLock, OS_WAIT_FOREVER);
    }

    if (0 == gIGImageIndex)
    {
        if (HaveSem == 0)
        {
            OS_SemGive(IGInfo.BlitLock);
        }

        return (IG_STATUS_SUCCESS);
    }

    /* use color 255 to clear the screen, this is the clear color */
    IGInfo.IGDFBInfo.PrimarySurface->SetColorIndex(IGInfo.IGDFBInfo.PrimarySurface, 0xFF);

    /* clean up all rectangles in the list with one call */
    IGInfo.IGDFBInfo.PrimarySurface->FillRectangles(IGInfo.IGDFBInfo.PrimarySurface, IGCleanupList, gIGImageIndex);

    /* set to invalid region */
    if (IGInfo.CoordsHalfWidth == 0)
    {
        gIGFlipRegion.x1 = IGInfo.IGDFBInfo.ScreenWidth;
        gIGFlipRegion.x2 = 0;
        gIGFlipRegion.y1 = IGInfo.IGDFBInfo.ScreenHeight;
        gIGFlipRegion.y2 = 0;
    }
    else
    {
        gIGFlipRegion.x1 = IGInfo.IGDFBInfo.ScreenWidth/2;
        gIGFlipRegion.x2 = 0;
        gIGFlipRegion.y1 = IGInfo.IGDFBInfo.ScreenHeight;
        gIGFlipRegion.y2 = 0;
    }

    for (ULONG i=0; i<gIGImageIndex; i++)
    {
        if (IGCleanupList[i].x < gIGFlipRegion.x1)
        {
            gIGFlipRegion.x1 = IGCleanupList[i].x;
        }

        if (IGCleanupList[i].x + IGCleanupList[i].w > gIGFlipRegion.x2)
        {
            gIGFlipRegion.x2 = IGCleanupList[i].x + IGCleanupList[i].w;
        }

        if (IGCleanupList[i].y < gIGFlipRegion.y1)
        {
            gIGFlipRegion.y1 = IGCleanupList[i].y;
        }

        if (IGCleanupList[i].y + IGCleanupList[i].h > gIGFlipRegion.y2)
        {
            gIGFlipRegion.y2 = IGCleanupList[i].y + IGCleanupList[i].h;
        }

        /* cleanup the image list as we go so new entries stick */
        memset(&IGCleanupList[i], 0, sizeof(DFBRectangle));
    }

    /* say the list is now cleared */
    gIGImageIndex = 0;

    if (HaveSem == 0)
    {
        OS_SemGive(IGInfo.BlitLock);
    }

    return (IG_STATUS_SUCCESS);
}

/**
 * IGGraphicsClearScreen - present the backbuffer on screen
 *
 * @param void
 *
 * @return IG_STATUS
 */
IG_STATUS IGGraphicsClearScreen()
{
    IDirectFBSurface *ClearSurf = NULL;
    IDirectFBPalette *ClearPal = NULL;
    DFBColor ClearColor = {0,0,0,0};

    /* get the primary surface for this diplay layer */
    if (IGInfo.IGDFBInfo.DispLayer->GetSurface(IGInfo.IGDFBInfo.DispLayer, &ClearSurf) != DFB_OK)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to get surface\n"));
        goto errout;
    }

    /* get the surfaces palette */
    if (ClearSurf->GetPalette(ClearSurf, &ClearPal) != DFB_OK)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to get palette!\n"));
        goto errout;
    }

    /* set default transparent palette entry */
    if (ClearPal->SetEntries(ClearPal, &ClearColor, 1, 0xff) != DFB_OK)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to set transparent palette entry!\n"));
        goto errout;
    }

    /* set surface color index to transparent */
    if (ClearSurf->SetColorIndex(ClearSurf, 0xff) != DFB_OK)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to set color index!\n"));
        goto errout;
    }

    if (IGInfo.CoordsHalfWidth == 0)
    {
        /* clear the surface */
        if (ClearSurf->FillRectangle(ClearSurf, 0, 0, IGInfo.IGDFBInfo.ScreenWidth-1, IGInfo.IGDFBInfo.ScreenHeight-1) != DFB_OK)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to clear surface!\n"));
            goto errout;
        }

        /* set to valid region */
        gIGFlipRegion.x1 = 0;
        gIGFlipRegion.x2 = IGInfo.IGDFBInfo.ScreenWidth-1;
        gIGFlipRegion.y1 = 0;
        gIGFlipRegion.y2 = IGInfo.IGDFBInfo.ScreenHeight-1;
    }
    else
    {
        /* clear the surface */
        if (ClearSurf->FillRectangle(ClearSurf, 0, 0, (IGInfo.IGDFBInfo.ScreenWidth/2) -1, IGInfo.IGDFBInfo.ScreenHeight-1) != DFB_OK)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearScreen: Failed to clear surface!\n"));
            goto errout;
        }

        /* set to valid region */
        gIGFlipRegion.x1 = 0;
        gIGFlipRegion.x2 = (IGInfo.IGDFBInfo.ScreenWidth/2)-1;
        gIGFlipRegion.y1 = 0;
        gIGFlipRegion.y2 = IGInfo.IGDFBInfo.ScreenHeight-1;
    }

    if (ClearPal)
    {
        ClearPal->Release(ClearPal);
    }

    if (ClearSurf)
    {
        ClearSurf->Release(ClearSurf);
    }

   return IG_STATUS_SUCCESS;

errout:

    if (ClearPal)
    {
        ClearPal->Release(ClearPal);
    }

    if (ClearSurf)
    {
        ClearSurf->Release(ClearSurf);
    }

    return IG_STATUS_ERROR;
}

/**
 * IGGraphicsSetFlipRegion - setup the flipping region
 *
 * @param x1 - start x of the region
 * @param x2 - end x of the region
 * @param y1 - start y of the region
 * @param y2 - end y of the region
 *
 * @return void
 */
void IGGraphicsSetFlipRegion(int x1, int y1, int x2, int y2)
{
    if (IGInfo.CoordsHalfWidth == 0)
    {
        gIGFlipRegion.x1 = x1;
        gIGFlipRegion.y1 = y1;
        gIGFlipRegion.x2 = x2;
        gIGFlipRegion.y2 = y2;

        if (gIGFlipRegion.x1 < 0)
        {
            gIGFlipRegion.x1 = 0;
        }

        if (gIGFlipRegion.y1 < 0)
        {
            gIGFlipRegion.y1 = 0;
        }

        if (gIGFlipRegion.x2 >= IGInfo.IGDFBInfo.ScreenWidth)
        {
            gIGFlipRegion.x2 = IGInfo.IGDFBInfo.ScreenWidth-1;
        }

        if (gIGFlipRegion.y2 >= IGInfo.IGDFBInfo.ScreenHeight)
        {
            gIGFlipRegion.y2 = IGInfo.IGDFBInfo.ScreenHeight-1;
        }
    }
    else
    {
        gIGFlipRegion.x1 = x1/2;
        gIGFlipRegion.y1 = y1;
        gIGFlipRegion.x2 = x2/2;
        gIGFlipRegion.y2 = y2;

        if (gIGFlipRegion.x1 < 0)
        {
            gIGFlipRegion.x1 = 0;
        }

        if (gIGFlipRegion.y1 < 0)
        {
            gIGFlipRegion.y1 = 0;
        }

        if (gIGFlipRegion.x2 >= (IGInfo.IGDFBInfo.ScreenWidth/2))
        {
            gIGFlipRegion.x2 = (IGInfo.IGDFBInfo.ScreenWidth/2) -1;
        }

        if (gIGFlipRegion.y2 >= IGInfo.IGDFBInfo.ScreenHeight)
        {
            gIGFlipRegion.y2 = IGInfo.IGDFBInfo.ScreenHeight-1;
        }
    }
}

/**
 * IGGraphicsClearFlipRegion - Clear just the flipping region
 *
 * @param void
 *
 * @return IG_STATUS
 */
IG_STATUS IGGraphicsClearFlipRegion()
{
    DFBRectangle r;
    r.x = gIGFlipRegion.x1;
    r.y = gIGFlipRegion.y1;
    r.w = gIGFlipRegion.x2 - gIGFlipRegion.x1+1;
    r.h = gIGFlipRegion.y2 - gIGFlipRegion.y1+1;

    if (r.w <= 0)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearFlipRegion: Failed to clear region width too small\n"));
        return IG_STATUS_ERROR;
    }

    if (r.h <= 0)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("IGGraphicsClearFlipRegion: Failed to clear region height too small\n"));
        return IG_STATUS_ERROR;
    }

    /* use color 255 to clear the screen, this is the clear color */
    IGInfo.IGDFBInfo.PrimarySurface->SetColorIndex(IGInfo.IGDFBInfo.PrimarySurface, 0xFF);

    /* clear the flipping region */
    IGInfo.IGDFBInfo.PrimarySurface->FillRectangle(IGInfo.IGDFBInfo.PrimarySurface, r.x, r.y, r.w, r.h);

    gIGImageIndex = 0;

    return IG_STATUS_SUCCESS;
}