C++ Image::Alloc方法代码示例

HRESULT WinCaptureDevice::OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex, DWORD dwStreamFlags, LONGLONG llTimestamp, IMFSample *pSample)
{
	HRESULT hr = S_OK;
	IMFMediaBuffer *pBuffer = NULL;
	if (FAILED(hrStatus))
		hr = hrStatus;

	if (SUCCEEDED(hr))
	{
		if (pSample)
		{
			hr = pSample->GetBufferByIndex(0, &pBuffer);
			if (SUCCEEDED(hr))
			{
				VideoBufferLock vbuffer(pBuffer);
				BYTE* scan0 = NULL;
				LONG stride = 0;
				hr = vbuffer.LockBuffer(InputDefaultStride, InputHeight, &scan0, &stride);
				if (SUCCEEDED(hr))
				{
					Image* img = new Image();
					if (img->Alloc(ImgFmt::RGB8u, InputWidth, InputHeight))
					{
						byte* lineIn = scan0;
						byte* lineOut = (byte*) img->Scan0;
						for (int iline = 0; iline < (int) InputHeight; iline++)
						{
							memcpy(lineOut, lineIn, InputWidth * 3);
							lineIn += stride;
							lineOut += img->Stride;
						}
						Frames.Add(img);
						// This method of keeping the frame count down is subject to race conditions, but you've already screwed up here by losing frames,
						// so losing even more is not the end of the world.
						// 'delete' is safe to call on null, so we're OK even if the above mentioned race condition catches us.
						while (Frames.Size() > MaxFrames)
							delete NextFrame();
					}
					else
					{
						delete img;
					}
				}

				SafeRelease(&pBuffer);
			}
		}
	}

	// Request the next frame.
	if (SUCCEEDED(hr) && EnableCapture == 1)
		hr = Reader->ReadSample((DWORD) MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, NULL, NULL, NULL, NULL);

	return hr;
}

void SaveExr(const Image<unsigned char>& image_in, const pangolin::VideoPixelFormat& fmt, const std::string& filename, bool top_line_first)
{
#ifdef HAVE_OPENEXR
    Image<unsigned char> image;

    if(top_line_first) {
        image = image_in;
    }else{
        image.Alloc(image_in.w,image_in.h,image_in.pitch);
        for(size_t y=0; y<image_in.h; ++y) {
            std::memcpy(image.ptr + y*image.pitch, image_in.ptr + (image_in.h-y-1)*image_in.pitch, image.pitch);
        }
    }


    Imf::Header header (image.w, image.h);
    SetOpenEXRChannels(header.channels(), fmt);

    Imf::OutputFile file (filename.c_str(), header);
    Imf::FrameBuffer frameBuffer;

    int ch=0;
    size_t ch_bits = 0;
    for(Imf::ChannelList::Iterator it = header.channels().begin(); it != header.channels().end(); ++it)
    {
        frameBuffer.insert(
            it.name(),
            Imf::Slice(
                it.channel().type,
                (char*)image.ptr + ch_bits/8,
                fmt.channel_bits[ch]/8,
                image.pitch
            )
        );

        ch_bits += fmt.channel_bits[ch++];
    }

    file.setFrameBuffer(frameBuffer);
    file.writePixels(image.h);

    if(!top_line_first) {
        image.Dealloc();
    }

#else
    throw std::runtime_error("EXR Support not enabled. Please rebuild Pangolin.");
#endif // HAVE_OPENEXR
}

size_t IntelH264Decoder::Decode(const void* buf, size_t bufSize)
{
	if (Session == nullptr)
		return 0;

	size_t consumed = 0;
	if (!IsInitialized)
	{
		consumed = Reset(buf, bufSize);
		if (!IsInitialized)
			return consumed;
	}

	bool ateData = true;
	while (ateData)
	{
		ateData = false;
		mfxFrameSurface1* surf = nullptr;
		mfxSyncPoint sync = nullptr;
		mfxBitstream bs = { 0 };
		bs.Data = (uint8_t*) buf + consumed;
		bs.DataLength = bufSize - consumed;
		bs.MaxLength = bufSize - consumed;
		mfxStatus err = MFXVideoDECODE_DecodeFrameAsync(Session, &bs, &WorkSurface, &surf, &sync);
		consumed += bs.DataOffset;
		if (bs.DataOffset != 0)
			ateData = true;
		if (err == MFX_ERR_NONE && surf != nullptr && surf->Info.FourCC == MFX_FOURCC_NV12)
		{
			if (surf->Info.FourCC == MFX_FOURCC_NV12)
			{
				Image* img = new Image();
				if (!img->Alloc(ImgFmt::RGBA8u, VideoParam.mfx.FrameInfo.Width, VideoParam.mfx.FrameInfo.Height))
					SXDIE_OOM();
				libyuv::NV12ToARGB(surf->Data.Y, surf->Data.PitchLow, surf->Data.UV, surf->Data.PitchLow, (uint8*) img->Scan0, img->Stride, img->Width, img->Height);
				img->FixBGRA_to_RGBA();
				Frames.push_back(img);
			}
			else
			{
				Log()->Error("Unexpected FourCC from MFXVideoDECODE_DecodeFrameAsync: %x", surf->Info.FourCC);
			}
		}
	}

	return consumed;

	//Reset();
	/*
	mfxVideoParam vpar = { 0 };
	vpar.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
	vpar.mfx.CodecId = MFX_CODEC_AVC;
	vpar.vpp.Out.Width = 640;
	vpar.vpp.Out.Height = 480;
	vpar.vpp.Out.FourCC = MFX_FOURCC_RGB4;
	err = MFXVideoDECODE_Init(Session, &vpar);
	if (err != MFX_ERR_NONE)
	{
		return false;
	}
	return true;
	*/
}