C++ BitmapPtr类代码示例

void FilterWipeBorder::applyInPlace(BitmapPtr pBmp)
{
    AVG_ASSERT(pBmp->getPixelFormat() == I8);
    if (m_NumPixels != 0) {
        int stride = pBmp->getStride();
        unsigned char * pPixels = pBmp->getPixels();
        IntPoint size = pBmp->getSize();
        IntPoint activeSize = pBmp->getSize()-IntPoint(2*m_NumPixels, 2*m_NumPixels);

        unsigned char * pSrcLine = pPixels+stride*m_NumPixels+m_NumPixels;
        for (int y = m_NumPixels-1; y >= 0; --y) {
            memcpy(pPixels+stride*y+m_NumPixels, pSrcLine, activeSize.x);
        }
        pSrcLine = pPixels+stride*(size.y-m_NumPixels-1)+m_NumPixels;
        for (int y = size.y-m_NumPixels; y < size.y; ++y) {
            memcpy(pPixels+stride*y+m_NumPixels, pSrcLine, activeSize.x);
        }

        for (int y = 0; y < size.y; ++y) {
            unsigned char src = *(pPixels+stride*y+m_NumPixels);
            memset(pPixels+stride*y, src, m_NumPixels);
            src = *(pPixels+stride*y+size.x-m_NumPixels-1);
            memset(pPixels+stride*y+size.x-m_NumPixels, src, m_NumPixels);
        }
    }
}

    void runFilterTests(bool bUseFloat)
    {
        BitmapPtr pBmp;
        GPUBlurFilterPtr pFilter;
        pBmp = loadTestBmp("spike");
        PixelFormat destPF;
        if (bUseFloat) {
            destPF = R32G32B32A32F;
        } else {
            destPF = B8G8R8A8;
        }
        pFilter = GPUBlurFilterPtr(new GPUBlurFilter(pBmp->getSize(), 
                pBmp->getPixelFormat(), destPF, 0.5f, false));
        runImageTest(pBmp, pFilter, 0.5f, "blur05_spike");
        runImageTest(pBmp, pFilter, 1, "blur1_spike");
        runImageTest(pBmp, pFilter, 3, "blur3_spike");

        pBmp = loadTestBmp("flat");
        pFilter = GPUBlurFilterPtr(new GPUBlurFilter(pBmp->getSize(), 
                pBmp->getPixelFormat(), destPF, 5, false));
        runImageTest(pBmp, pFilter, 5, "blur05_flat", true);

        runImageTest("rgb24-64x64", destPF);
        runImageTest("rgb24alpha-64x64", destPF);

    }

 void runTestWithBitmap(BitmapPtr pBmp)
 {
     BitmapPtr pDestBmp = FilterResizeBilinear(IntPoint(32,32)).apply(pBmp);
     string sName = string("ResizeBilinearResult")
             +getPixelFormatString(pBmp->getPixelFormat());
     testEqual(*pDestBmp, sName, pBmp->getPixelFormat());
 }

void Image::setFilename(const std::string& sFilename, TextureCompression comp)
{
    assertValid();
    AVG_TRACE(Logger::category::MEMORY, Logger::severity::INFO, "Loading " << sFilename);
    BitmapPtr pBmp = loadBitmap(sFilename);
    if (comp == TEXTURECOMPRESSION_B5G6R5 && pBmp->hasAlpha()) {
        throw Exception(AVG_ERR_UNSUPPORTED, 
                "B5G6R5-compressed textures with an alpha channel are not supported.");
    }
    changeSource(FILE);
    m_pBmp = pBmp;

    m_sFilename = sFilename;

    switch (comp) {
        case TEXTURECOMPRESSION_B5G6R5:
            m_pBmp = BitmapPtr(new Bitmap(pBmp->getSize(), B5G6R5, sFilename));
            if (!BitmapLoader::get()->isBlueFirst()) {
                FilterFlipRGB().applyInPlace(pBmp);
            }
            m_pBmp->copyPixels(*pBmp);
            break;
        case TEXTURECOMPRESSION_NONE:
            break;
        default:
            assert(false);
    }

    if (m_State == GPU) {
        m_pSurface->destroy();
        setupSurface();
    }
    assertValid();
}

 void runImageTest(const string& sFName, PixelFormat destPF)
 {
     BitmapPtr pBmp = loadTestBmp(sFName);
     GPUBlurFilterPtr pFilter(new GPUBlurFilter(pBmp->getSize(), 
             pBmp->getPixelFormat(), destPF, 2, false));
     runImageTest(pBmp, pFilter, 2, string("blur_")+sFName, true);
 }

    void runTests()
    {
        BitmapPtr pBmp = loadTestBmp("chromakey");
        BitmapPtr pDestBmp;
        GPUChromaKeyFilter filter(pBmp->getSize());
        for (int erosion = 0; erosion < 3; ++erosion) {
            filter.setParams(Pixel32(0,255,0), 0.1, 0.2, 0.1, 0.1, erosion, 0);
            pDestBmp = filter.apply(pBmp);
            testEqual(*pDestBmp, "ChromaKeyResult"+toString(erosion), B8G8R8A8, 0.3, 
                    0.7);
        }
        filter.setParams(Pixel32(0,255,0), 0.0, 0.0, 0.0, 0.0, 0, 0.1);
        pDestBmp = filter.apply(pBmp);
        testEqual(*pDestBmp, "ChromaKeySpillResult1", B8G8R8A8, 0.3, 0.7);
        filter.setParams(Pixel32(0,255,0), 0.1, 0.1, 0.1, 0.0, 0, 0.1);
        pDestBmp = filter.apply(pBmp);
        testEqual(*pDestBmp, "ChromaKeySpillResult2", B8G8R8A8, 0.3, 0.7);
        filter.setParams(Pixel32(0,255,0), 0.1, 0.1, 0.1, 0.0, 0, 0.2);
        pDestBmp = filter.apply(pBmp);
        testEqual(*pDestBmp, "ChromaKeySpillResult3", B8G8R8A8, 0.3, 0.7);

        pBmp = loadTestBmp("chromakey-median");
        filter.setParams(Pixel32(0,255,0), 0.1, 0.1, 0.1, 0.0, 0, 0.0);
        pDestBmp = filter.apply(pBmp);
        testEqual(*pDestBmp, "ChromaKeyMedianResult", B8G8R8A8, 1, 6);
    }

void GraphicsTest::testEqual(Bitmap& resultBmp, Bitmap& baselineBmp, 
        const string& sFName, float maxAverage, float maxStdDev)
{
    BitmapPtr pDiffBmp;
    try {
        pDiffBmp = resultBmp.subtract(baselineBmp);
    } catch (Exception& e) {
        TEST_FAILED("Error: " << e.getStr() << ". File: '" << sFName << "'.");
        string sResultName = "resultimages/"+sFName;
        resultBmp.save(sResultName+".png");
        baselineBmp.save(sResultName+"_baseline.png");
    }
    if (pDiffBmp) {
        float average = pDiffBmp->getAvg();
        float stdDev = pDiffBmp->getStdDev();
        if (average > maxAverage || stdDev > maxStdDev) {
            TEST_FAILED("Error: Decoded image differs from baseline '" << 
                    sFName << "'. average=" << average << ", stdDev=" << stdDev);
    //        resultBmp.dump();
    //        baselineBmp.dump();
            string sResultName = "resultimages/"+sFName;
            resultBmp.save(sResultName+".png");
            baselineBmp.save(sResultName+"_baseline.png");
            BitmapPtr pDiffBmp = resultBmp.subtract(baselineBmp);
            pDiffBmp->save(sResultName+"_diff.png");
        }
    }
}

    void runMipmapTest(OGLMemoryMode memoryMode, const string& sFName)
    {
        cerr << "    Testing mipmap support, " << sFName << ", " << 
                oglMemoryMode2String(memoryMode) << endl;
        BitmapPtr pOrigBmp = loadTestBmp(sFName);
        GLContextManager* pCM = GLContextManager::get();
        MCTexturePtr pTex = pCM->createTextureFromBmp(pOrigBmp, true);
        pCM->uploadData();
        pTex->generateMipmaps();

        if (GLContext::getCurrent()->isGLES()) {
            // GLES doesn't support attaching texture mipmap levels other than 0 to
            // FBOs, so moveTextureToBmp() will fail. Skip result image comparison.
            return;
        }
        BitmapPtr pResultBmp = pTex->moveTextureToBmp(1);
        IntPoint newSize(pOrigBmp->getSize()/2);
        TEST(pResultBmp->getSize() == newSize);
        FilterResizeBilinear resizer(newSize);
        BitmapPtr pBaselineBmp = resizer.apply(pOrigBmp);
        string sName;
        if (memoryMode == MM_PBO) {
            sName = "pbo-mipmap";
        } else {
            sName = "ogl-mipmap";
        }
        testEqual(*pResultBmp, *pBaselineBmp, sName, 7, 15);
    }

void CChildView::OnPaint() 
{
   CPaintDC dc(this); // device context for painting

   // If the unbounded_buffer object contains a Bitmap object, 
   // draw the image to the client area.
   BitmapPtr pBitmap;
   if (try_receive(m_MandelbrotImages, pBitmap))
   {
      if (pBitmap != NULL)
      {
         // Draw the bitmap to the client area.
         Graphics g(dc);
         g.DrawImage(pBitmap.get(), 0, 0);
      }
   }
   // Draw the image on a worker thread if the image is not available.
   else
   {
      RECT rc;
      GetClientRect(&rc);
      m_DrawingTasks.run([rc,this]() {
         DrawMandelbrot(BitmapPtr(new Bitmap(rc.right, rc.bottom)));
      });
   }
}

 void runTests()
 {
     BitmapPtr pBmp = BitmapPtr(new Bitmap(IntPoint(16,16), I8));
     FilterFill<Pixel8>(0).applyInPlace(pBmp);
     *(pBmp->getPixels()+pBmp->getStride()*7+7) = 255;
     BitmapPtr pDestBmp = FilterBlur().apply(pBmp);
     testEqual(*pDestBmp, "BlurResult", I8);
 }

 void runSaveTest(PixelFormat pf)
 {
     cerr << "    Testing save for " << pf << endl;
     BitmapPtr pBmp = initBmp(pf);
     pBmp->save("test.png");
     BitmapPtr pLoadedBmp = loadBitmap("test.png");
     ::remove("test.png");
     testEqual(*pLoadedBmp, *pBmp, "BmpSave");
 }

void VideoWriterThread::convertRGBImage(BitmapPtr pSrcBmp)
{
    ScopeTimer timer(ProfilingZoneConvertImage);
    unsigned char* rgbData[3] = {pSrcBmp->getPixels(), NULL, NULL};
    int rgbStride[3] = {pSrcBmp->getLineLen(), 0, 0};

    sws_scale(m_pFrameConversionContext, rgbData, rgbStride,
              0, m_Size.y, m_pConvertedFrame->data, m_pConvertedFrame->linesize);
}

 void runImageTests(const string& sFName, PixelFormat pf)
 {
     cerr << "    Testing " << sFName << endl;
     BitmapPtr pBmp = loadTestBmp(sFName, pf);
     GPUBandpassFilter f(pBmp->getSize(), pf, 0.5, 1.5, 1, false);
     BitmapPtr pDestBmp = f.apply(pBmp);
     TEST(fabs(pDestBmp->getAvg() -128) < 0.06);
     testEqual(*pDestBmp, "bandpass_"+sFName, pf, 0.2, 0.5);
     TEST(pDestBmp->getPixelFormat() == pf);
 }

 void initBmp(BitmapPtr pBmp) 
 {
     PIXEL * pPixels = (PIXEL *)(pBmp->getPixels());
     PIXEL color = PIXEL(0,0,0);
     FilterFill<PIXEL>(color).applyInPlace(pBmp);
     pPixels[0] = PIXEL(1,0,0);
     pPixels[3] = PIXEL(2,0,0);
     pPixels = (PIXEL*)((char *)pPixels+3*pBmp->getStride());
     pPixels[0] = PIXEL(0,0,3);
     pPixels[3] = PIXEL(0,0,4);
 }

Sprite::Sprite(BitmapPtr pBitmap)
{
	m_pBitmap = pBitmap;
	SetRect(&m_rcPosition, 0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
	m_ptVelocity.x = m_ptVelocity.y = 0;
	m_iZOrder = 0;
	SetRect(&m_rcBounds, 0, 0, 640, 480);
	m_baBoundsAction = BA_STOP;
	m_bHidden = FALSE;
	CalcCollisionRec();
}