/**
* \brief uninitialize OpenGL context, freeing textures, buffers etc.
*/
static void uninitGl(void) {
int i = 0;
if (DeletePrograms && fragprog)
DeletePrograms(1, &fragprog);
fragprog = 0;
while (default_texs[i] != 0)
i++;
if (i)
DeleteTextures(i, default_texs);
default_texs[0] = 0;
clearOSD();
clearEOSD();
if (largeeosdtex[0])
DeleteTextures(2, largeeosdtex);
largeeosdtex[0] = 0;
if (DeleteBuffers && gl_buffer)
DeleteBuffers(1, &gl_buffer);
gl_buffer = 0; gl_buffersize = 0;
gl_bufferptr = NULL;
if (DeleteBuffers && gl_buffer_uv[0])
DeleteBuffers(2, gl_buffer_uv);
gl_buffer_uv[0] = gl_buffer_uv[1] = 0; gl_buffersize_uv = 0;
gl_bufferptr_uv[0] = gl_bufferptr_uv[1] = 0;
#ifdef CONFIG_GL_X11
if (mesa_bufferptr)
FreeMemoryMESA(mDisplay, mScreen, mesa_bufferptr);
#endif
mesa_bufferptr = NULL;
err_shown = 0;
}
uint GLColorTarget::GenerateDepthTexture()
{
//- Generate Frame buffer --------------------------------------------------
glGenFramebuffers(1, &m_DepthFrameBuffer); GLERROR();
glBindFramebuffer(GL_FRAMEBUFFER, m_DepthFrameBuffer); GLERROR();
glGenTextures(1, &m_DepthTexture); GLERROR();
glBindTexture(GL_TEXTURE_2D, m_DepthTexture); GLERROR();
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16,
DEPTHTEXRES, DEPTHTEXRES, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLERROR();
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthTexture, 0); GLERROR();
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
LogError("Framebuffer error at %s,%d", __FILE__, __LINE__);
DeleteBuffers(1, &m_DepthTexture);
DeleteBuffers(1, &m_DepthBuffer);
return 0;
}
glDrawBuffer(GL_NONE);
return m_DepthTexture;
}
static int Control(vout_display_t *vd, int query, va_list ap)
{
vout_display_sys_t *sys = vd->sys;
switch (query) {
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP: {
const vout_display_cfg_t *cfg = va_arg(ap,
const vout_display_cfg_t *);
/* Update the window size */
uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
const uint32_t values[] = {
cfg->display.width, cfg->display.height
};
xcb_configure_window(sys->conn, sys->drawable.dest, mask, values);
DeleteBuffers(vd);
CreateBuffers(vd, cfg);
xcb_flush(sys->conn);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_RESET_PICTURES:
vlc_assert_unreachable();
default:
msg_Err(vd, "Unknown request in XCB RENDER display");
return VLC_EGENERIC;
}
}
GrGLBuffer::GrGLBuffer(GrGLGpu* gpu, size_t size, GrGpuBufferType intendedType,
GrAccessPattern accessPattern, const void* data)
: INHERITED(gpu, size, intendedType, accessPattern)
, fIntendedType(intendedType)
, fBufferID(0)
, fUsage(gr_to_gl_access_pattern(intendedType, accessPattern))
, fGLSizeInBytes(0)
, fHasAttachedToTexture(false) {
GL_CALL(GenBuffers(1, &fBufferID));
if (fBufferID) {
GrGLenum target = gpu->bindBuffer(fIntendedType, this);
CLEAR_ERROR_BEFORE_ALLOC(gpu->glInterface());
// make sure driver can allocate memory for this buffer
GL_ALLOC_CALL(gpu->glInterface(), BufferData(target,
(GrGLsizeiptr) size,
data,
fUsage));
if (CHECK_ALLOC_ERROR(gpu->glInterface()) != GR_GL_NO_ERROR) {
GL_CALL(DeleteBuffers(1, &fBufferID));
fBufferID = 0;
} else {
fGLSizeInBytes = size;
}
}
VALIDATE();
this->registerWithCache(SkBudgeted::kYes);
if (!fBufferID) {
this->resourcePriv().removeScratchKey();
}
}
bool VideoOutputNullVDPAU::InitBuffers(void)
{
QMutexLocker locker(&m_lock);
if (!m_render || !codec_is_vdpau_hw(video_codec_id))
return false;
uint buffer_size = m_decoder_buffer_size + MIN_PROCESS_BUFFER;
const QSize video_dim = window.GetActualVideoDim();
vbuffers.Init(buffer_size, false, 2, 1, 4, 1);
bool ok = CreateVideoSurfaces(buffer_size);
if (ok)
{
for (int i = 0; i < m_video_surfaces.size(); i++)
ok &= vbuffers.CreateBuffer(video_dim.width(),
video_dim.height(), i,
m_render->GetRender(m_video_surfaces[i]),
FMT_VDPAU);
}
if (!ok)
{
DeleteBuffers();
LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create VDPAU buffers");
return false;
}
LOG(VB_PLAYBACK, LOG_INFO, LOC + "Created VDPAU buffers");
return ok;
}
void GLVec4ScalarBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fFboTextureId));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(1, &fVboId));
}
void GrGLVertexBuffer::onRelease() {
// make sure we've not been abandoned
if (fBufferID) {
GPUGL->notifyVertexBufferDelete(this);
GL_CALL(DeleteBuffers(1, &fBufferID));
fBufferID = 0;
}
}
void VideoOutputVDPAU::TearDown(void)
{
QMutexLocker locker(&m_lock);
DeinitPIPS();
DeinitPIPLayer();
DeleteBuffers();
RestoreDisplay();
DeleteRender();
}
void GLCpuPosInstancedArraysBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(fBuffers.count(), fBuffers.begin()));
GR_GL_CALL(gl, DeleteVertexArrays(1, &fVAO));
fBuffers.reset();
}
void
VideoNode::Disconnected(const media_source &src,
const media_destination &dst)
{
if (src != fInput.source)
return;
if (dst != fInput.destination)
return;
DeleteBuffers();
// disconnect the connection
fInput.source = media_source::null;
}
//===================================================================
void DeltaAccumulationBuffer::SetBuffer(const char* pBuffer, size_t bufferSize)
{
DeleteBuffers();
m_bufferSize = bufferSize;
{
try
{
m_pOriginalBuffer = new char[m_bufferSize];
#ifdef USE_MAP_STREAMLOG
g_totalResourceBufferMemory += (long)m_bufferSize;
#endif
}
catch (std::bad_alloc)
{
Log(logASSERT, "Ran out of memory; could not allocate base delta buffer.\n");
m_pOriginalBuffer = NULL;
m_bufferSize = 0;
return;
}
try
{
m_pAccumulatedDeltaBuffer = new char[m_bufferSize];
#ifdef USE_MAP_STREAMLOG
g_totalResourceBufferMemory += (long)m_bufferSize;
#endif
}
catch (std::bad_alloc)
{
Log(logASSERT, "Ran out of memory; could not allocate delta accumulation buffer.\n");
m_pAccumulatedDeltaBuffer = NULL;
delete [] m_pOriginalBuffer;
m_pOriginalBuffer = NULL;
m_bufferSize = 0;
return;
}
memcpy(m_pOriginalBuffer, pBuffer, m_bufferSize);
memcpy(m_pAccumulatedDeltaBuffer, pBuffer, m_bufferSize);
}
#ifdef USE_MAP_STREAMLOG
StreamLog::Get() << "DeltaAccumulationBuffer: g_totalResourceBufferMemory: " << g_totalResourceBufferMemory << " bytes" << "\n";
#endif
}
void GrGLBuffer::onRelease() {
if (!this->wasDestroyed()) {
VALIDATE();
// make sure we've not been abandoned or already released
if (fBufferID) {
GL_CALL(DeleteBuffers(1, &fBufferID));
fBufferID = 0;
fGLSizeInBytes = 0;
}
fMapPtr = nullptr;
VALIDATE();
}
INHERITED::onRelease();
}
void Message::SetCipher(const char *new_cipher)
{
int new_len=(int)strlen(new_cipher);
if(new_len>msg_len) //realloacte buffers
{
DeleteBuffers();
AllocateBuffers(new_len);
}
msg_len=new_len;
strcpy(cipher,new_cipher);
SetInfo(true);
}
static void
release_buffer(struct ref* ref)
{
struct rb_buffer* buffer = NULL;
struct rb_context* ctxt = NULL;
ASSERT(ref);
buffer = CONTAINER_OF(ref, struct rb_buffer, ref);
ctxt = buffer->ctxt;
if(buffer->name == ctxt->state_cache.buffer_binding[buffer->binding])
OGL(BindBuffer(buffer->target, 0));
OGL(DeleteBuffers(1, &buffer->name));
MEM_FREE(ctxt->allocator, buffer);
RB(context_ref_put(ctxt));
}
void GrGLBufferImpl::release(GrGpuGL* gpu) {
// make sure we've not been abandoned or already released
if (NULL != fCPUData) {
VALIDATE();
sk_free(fCPUData);
fCPUData = NULL;
} else if (fDesc.fID && !fDesc.fIsWrapped) {
VALIDATE();
GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
if (GR_GL_ARRAY_BUFFER == fBufferType) {
gpu->notifyVertexBufferDelete(fDesc.fID);
} else {
SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
gpu->notifyIndexBufferDelete(fDesc.fID);
}
fDesc.fID = 0;
}
fLockPtr = NULL;
}
GrGLBuffer::GrGLBuffer(GrGLGpu* gpu, size_t size, GrBufferType intendedType,
GrAccessPattern accessPattern, bool cpuBacked, const void* data)
: INHERITED(gpu, size, intendedType, accessPattern, cpuBacked),
fCPUData(nullptr),
fIntendedType(intendedType),
fBufferID(0),
fSizeInBytes(size),
fUsage(gr_to_gl_access_pattern(intendedType, accessPattern)),
fGLSizeInBytes(0),
fHasAttachedToTexture(false) {
if (this->isCPUBacked()) {
// Core profile uses vertex array objects, which disallow client side arrays.
SkASSERT(!gpu->glCaps().isCoreProfile());
if (gpu->caps()->mustClearUploadedBufferData()) {
fCPUData = sk_calloc_throw(fSizeInBytes);
} else {
fCPUData = sk_malloc_flags(fSizeInBytes, SK_MALLOC_THROW);
}
if (data) {
memcpy(fCPUData, data, fSizeInBytes);
}
} else {
GL_CALL(GenBuffers(1, &fBufferID));
if (fBufferID) {
GrGLenum target = gpu->bindBuffer(fIntendedType, this);
CLEAR_ERROR_BEFORE_ALLOC(gpu->glInterface());
// make sure driver can allocate memory for this buffer
GL_ALLOC_CALL(gpu->glInterface(), BufferData(target,
(GrGLsizeiptr) fSizeInBytes,
data,
fUsage));
if (CHECK_ALLOC_ERROR(gpu->glInterface()) != GR_GL_NO_ERROR) {
GL_CALL(DeleteBuffers(1, &fBufferID));
fBufferID = 0;
} else {
fGLSizeInBytes = fSizeInBytes;
}
}
}
VALIDATE();
this->registerWithCache(SkBudgeted::kYes);
}
void GrGLBuffer::onRelease() {
if (!this->wasDestroyed()) {
VALIDATE();
// make sure we've not been abandoned or already released
if (fCPUData) {
SkASSERT(!fBufferID);
sk_free(fCPUData);
fCPUData = nullptr;
} else if (fBufferID) {
GL_CALL(DeleteBuffers(1, &fBufferID));
fBufferID = 0;
fGLSizeInBytes = 0;
this->glGpu()->notifyBufferReleased(this);
}
fMapPtr = nullptr;
VALIDATE();
}
INHERITED::onRelease();
}
void GrGLBufferImpl::release(GrGLGpu* gpu) {
VALIDATE();
// make sure we've not been abandoned or already released
if (fCPUData) {
sk_free(fCPUData);
fCPUData = nullptr;
} else if (fDesc.fID) {
GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
if (GR_GL_ARRAY_BUFFER == fBufferType) {
gpu->notifyVertexBufferDelete(fDesc.fID);
} else {
SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
gpu->notifyIndexBufferDelete(fDesc.fID);
}
fDesc.fID = 0;
fGLSizeInBytes = 0;
}
fMapPtr = nullptr;
VALIDATE();
}
void SoundStream::Close() {
// Clean up everything
Stop();
if (mBuffers.GetElementCount() > 0)
DeleteBuffers();
// Set SoundBase variables to defaults
mContext = NULL;
mOpenALSourceID = 0;
mImportance = 0;
mVolume = 1.0f;
mPitch = 1.0f;
mPosition = kFastVector3DZero;
mIsRelativePosition = false;
mIsPlaying = false;
mIsPaused = false;
mIsStopped = true;
mIsFadingIn = false;
mIsFadingOut = false;
mFadeTime = 0;
}
status_t
VideoNode::Connected(const media_source &src,
const media_destination &dst,
const media_format &format,
media_input *out_input)
{
/* The connection process:
* BBufferProducer::FormatProposal
* BBufferConsumer::AcceptFormat
* BBufferProducer::PrepareToConnect
* we are here => BBufferConsumer::Connected
* BBufferProducer::Connect
*/
if (dst != fInput.destination)
return B_MEDIA_BAD_DESTINATION;
fInput.source = src;
fInput.format = format;
if (fInput.format.u.raw_video.field_rate < 1.0)
fInput.format.u.raw_video.field_rate = 25.0;
color_space colorspace = format.u.raw_video.display.format;
BRect frame(0, 0, format.u.raw_video.display.line_width - 1, format.u.raw_video.display.line_count - 1);
status_t err;
DeleteBuffers();
err = CreateBuffers(frame, colorspace, fOverlayEnabled);
if (err) {
printf("VideoNode::Connected failed, fOverlayEnabled = %d\n", fOverlayEnabled);
return err;
}
*out_input = fInput;
return B_OK;
}
status_t
VideoNode::FormatChanged(const media_source &src,
const media_destination &dst,
int32 from_change_count,
const media_format &format)
{
printf("VideoNode::FormatChanged enter\n");
if (src != fInput.source)
return B_MEDIA_BAD_SOURCE;
if (dst != fInput.destination)
return B_MEDIA_BAD_DESTINATION;
color_space colorspace = format.u.raw_video.display.format;
BRect frame(0, 0, format.u.raw_video.display.line_width - 1, format.u.raw_video.display.line_count - 1);
status_t err;
DeleteBuffers();
if (fOverlayEnabled) {
fVideoView->RemoveOverlay();
err = CreateBuffers(frame, colorspace, true); // try overlay
if (err) {
printf("VideoNode::FormatChanged creating overlay buffer failed\n");
err = CreateBuffers(frame, colorspace, false); // no overlay
}
} else {
err = CreateBuffers(frame, colorspace, false); // no overlay
}
if (err) {
printf("VideoNode::FormatChanged failed (lost buffer group!)\n");
return B_MEDIA_BAD_FORMAT;
}
fInput.format = format;
printf("VideoNode::FormatChanged leave\n");
return B_OK;
}
GL3CharacterRenderer::~GL3CharacterRenderer() {
GL(DeleteVertexArrays(1, &bodyVao));
GL(DeleteBuffers(1, &bodyVbo));
GL(DeleteVertexArrays(1, &headVao));
GL(DeleteBuffers(1, &headVbo));
}
//TODO(Meanzie): At the moment everytime the mesh is compile we are getting new buffers, if we have dynamic buffers such as UIText
//we don't want to generate new buffers but rather reuse the old ones
b32 wish_mesh::Compile()
{
DeleteBuffers();
//Generate the buffers
//Needs information about how to compile?
//For now let's just make one buffer per thingy
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
{
glGenBuffers(1, Buffers);
glBindBuffer(GL_ARRAY_BUFFER, Buffers[0]);
//Buffer the data I assume?
glBufferData(
GL_ARRAY_BUFFER,
(GLsizeiptr)(NumVertices* VertexSize),
(void*)Vertices,
DrawMode);
//Assumption is VNT
if (MeshType == WISH_VERTEX_VT)
{
//Position
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, VertexSize, (void*)0);
//Texture
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, VertexSize, (void*)(3 * sizeof(GLfloat)));
}
if (MeshType == WISH_VERTEX_VNT)
{
//Position
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, VertexSize, (void*)0);
//Normal
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, VertexSize, (void*)(3 * sizeof(GLfloat)));
//Texture
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, VertexSize, (void*)(6 * sizeof(GLfloat)));
}
else if (MeshType == WISH_VERTEX_VNTBW)
{
//Position
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, VertexSize, (void*)0);
//Normal
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, VertexSize, (void*)(3 * sizeof(GLfloat)));
//UV
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, VertexSize, (void*)(6 * sizeof(GLfloat)));
//Bones
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_INT, GL_FALSE, VertexSize, (void*)(8 * sizeof(GLfloat)));
//Weights
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, VertexSize, (void*)(8 * sizeof(GLfloat) + 4 * sizeof(GLint)));
}
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(
GL_ELEMENT_ARRAY_BUFFER,
(GLsizeiptr)(NumIndices * sizeof(GLuint)),
(void*)Indices,
DrawMode);
}
glBindVertexArray(0);
IsCompiled = true; //Flag as compiled
return IsCompiled;
}
bool VideoOutputVDPAU::InitBuffers(void)
{
QMutexLocker locker(&m_lock);
if (!m_render)
return false;
uint buffer_size = m_decoder_buffer_size + m_process_buffer_size;
const QSize video_dim = codec_is_std(video_codec_id) ?
window.GetVideoDim() : window.GetActualVideoDim();
vbuffers.Init(buffer_size, false, 2, 1, 4, 1);
bool ok = false;
if (codec_is_vdpau(video_codec_id))
{
ok = CreateVideoSurfaces(buffer_size);
if (ok)
{
for (int i = 0; i < m_video_surfaces.size(); i++)
ok &= vbuffers.CreateBuffer(video_dim.width(),
video_dim.height(), i,
m_render->GetRender(m_video_surfaces[i]),
FMT_VDPAU);
}
}
else if (codec_is_std(video_codec_id))
{
ok = CreateVideoSurfaces(NUM_REFERENCE_FRAMES);
if (ok)
ok = vbuffers.CreateBuffers(FMT_YV12,
video_dim.width(), video_dim.height());
}
if (!ok)
{
LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create VDPAU buffers");
}
else
{
m_video_mixer = m_render->CreateVideoMixer(video_dim, 2,
m_mixer_features);
ok = m_video_mixer;
m_pause_surface = m_video_surfaces[0];
if (ok && (m_mixer_features & kVDPFeatSharpness))
m_render->SetMixerAttribute(m_video_mixer,
kVDPAttribSharpness,
m_sharpen);
if (ok && (m_mixer_features & kVDPFeatDenoise))
m_render->SetMixerAttribute(m_video_mixer,
kVDPAttribNoiseReduction,
m_denoise);
if (ok && m_skip_chroma)
m_render->SetMixerAttribute(m_video_mixer,
kVDPAttribSkipChroma, 1);
if (ok && (db_letterbox_colour == kLetterBoxColour_Gray25))
m_render->SetMixerAttribute(m_video_mixer,
kVDPAttribBackground, 0x7F7F7FFF);
}
if (!ok)
{
LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create VDPAU mixer");
DeleteBuffers();
}
return ok;
}
wish_mesh::~wish_mesh()
{
DeleteBuffers();
}
status_t
VideoConsumer::CreateBuffers(const media_format& format)
{
FUNCTION("VideoConsumer::CreateBuffers\n");
// delete any old buffers
DeleteBuffers();
status_t status = B_OK;
// create a buffer group
uint32 width = format.u.raw_video.display.line_width;
uint32 height = format.u.raw_video.display.line_count;
color_space colorSpace = format.u.raw_video.display.format;
PROGRESS("VideoConsumer::CreateBuffers - Width = %ld - Height = %ld - "
"Colorspace = %d\n", width, height, colorSpace);
fBuffers = new BBufferGroup();
status = fBuffers->InitCheck();
if (B_OK != status) {
ERROR("VideoConsumer::CreateBuffers - ERROR CREATING BUFFER GROUP\n");
return status;
}
// and attach the bitmaps to the buffer group
BRect bounds(0, 0, width - 1, height - 1);
for (uint32 i = 0; i < kBufferCount; i++) {
// figure out the bitmap creation flags
uint32 bitmapFlags = 0;
if (fTryOverlay) {
// try to use hardware overlay
bitmapFlags |= B_BITMAP_WILL_OVERLAY;
if (i == 0)
bitmapFlags |= B_BITMAP_RESERVE_OVERLAY_CHANNEL;
} else
bitmapFlags = B_BITMAP_IS_LOCKED;
fBitmap[i] = new BBitmap(bounds, bitmapFlags, colorSpace);
status = fBitmap[i]->InitCheck();
if (status >= B_OK) {
buffer_clone_info info;
uint8* bits = (uint8*)fBitmap[i]->Bits();
info.area = area_for(bits);
area_info bitmapAreaInfo;
status = get_area_info(info.area, &bitmapAreaInfo);
if (status != B_OK) {
fprintf(stderr, "VideoConsumer::CreateBuffers() - "
"get_area_info(): %s\n", strerror(status));
return status;
}
//printf("area info for bitmap %ld (%p):\n", i, fBitmap[i]->Bits());
//printf(" area: %ld\n", bitmapAreaInfo.area);
//printf(" size: %ld\n", bitmapAreaInfo.size);
//printf(" lock: %ld\n", bitmapAreaInfo.lock);
//printf(" protection: %ld\n", bitmapAreaInfo.protection);
//printf(" ram size: %ld\n", bitmapAreaInfo.ram_size);
//printf(" copy_count: %ld\n", bitmapAreaInfo.copy_count);
//printf(" out_count: %ld\n", bitmapAreaInfo.out_count);
//printf(" address: %p\n", bitmapAreaInfo.address);
info.offset = bits - (uint8*)bitmapAreaInfo.address;
info.size = (size_t)fBitmap[i]->BitsLength();
info.flags = 0;
info.buffer = 0;
// the media buffer id
BBuffer* buffer = NULL;
if ((status = fBuffers->AddBuffer(info, &buffer)) != B_OK) {
ERROR("VideoConsumer::CreateBuffers - ERROR ADDING BUFFER "
"TO GROUP (%ld): %s\n", i, strerror(status));
return status;
} else {
PROGRESS("VideoConsumer::CreateBuffers - SUCCESSFUL ADD "
"BUFFER TO GROUP\n");
}
fBufferMap[i] = buffer;
} else {
ERROR("VideoConsumer::CreateBuffers - ERROR CREATING VIDEO RING "
"BUFFER (Index %ld Width %ld Height %ld Colorspace %d: %s\n",
i, width, height, colorSpace, strerror(status));
return status;
}
}
FUNCTION("VideoConsumer::CreateBuffers - EXIT\n");
return status;
}
VideoConsumer::~VideoConsumer()
{
Quit();
DeleteBuffers();
}
void GLCpuPosInstancedArraysBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(fBuffers.count(), fBuffers.begin()));
GR_GL_CALL(gl, DeleteVertexArrays(1, &fVAO));
}
VideoNode::~VideoNode()
{
Quit();
DeleteBuffers();
delete fBitmapLocker;
}
void GLInterfaceWrapper::DeleteBuffer( GLuint& buffer ) const {
DeleteBuffers( 1, &buffer );
buffer = 0;
}
