static void obs_free_graphics()
{
struct obs_video *video = &obs->video;
size_t i;
if (video->graphics) {
int cur_texture = video->cur_texture;
gs_entercontext(video->graphics);
if (video->copy_mapped)
stagesurface_unmap(video->copy_surfaces[cur_texture]);
for (i = 0; i < NUM_TEXTURES; i++) {
stagesurface_destroy(video->copy_surfaces[i]);
texture_destroy(video->render_textures[i]);
texture_destroy(video->output_textures[i]);
video->copy_surfaces[i] = NULL;
video->render_textures[i] = NULL;
video->output_textures[i] = NULL;
}
effect_destroy(video->default_effect);
video->default_effect = NULL;
gs_leavecontext();
gs_destroy(video->graphics);
video->graphics = NULL;
video->cur_texture = 0;
}
}
bool
texture_resize_capacity(Texture_data *data, const size_t size_hint)
{
assert(data);
assert(size_hint > data->size); // Will slice data
// Create new data.
Texture_data new_data;
const bool created_new = texture_create(&new_data, size_hint);
// Failed to resize.
if(!created_new)
{
texture_destroy(&new_data);
return false;
}
// Copy over data
{
memcpy(new_data.keys, data->keys, sizeof(uint32_t) * data->size);
memcpy(new_data.field_name, data->field_name, sizeof(char) * data->size * 32);
memcpy(new_data.field_texture, data->field_texture, sizeof(Ogl::Texture) * data->size * 1);
memcpy(new_data.field_render_target, data->field_render_target, sizeof(Ogl::Frame_buffer) * data->size * 1);
}
// Swap ptrs
{
uint32_t *old_keys = data->keys;
data->keys = new_data.keys;
new_data.keys = old_keys;
char *old_name = data->field_name;
data->field_name = new_data.field_name;
new_data.field_name = old_name;
Ogl::Texture *old_texture = data->field_texture;
data->field_texture = new_data.field_texture;
new_data.field_texture = old_texture;
Ogl::Frame_buffer *old_render_target = data->field_render_target;
data->field_render_target = new_data.field_render_target;
new_data.field_render_target = old_render_target;
}
// Set the Capacity
{
size_t *capacity = const_cast<size_t*>(&data->capacity);
*capacity = new_data.capacity;
}
// Destroy new data
texture_destroy(&new_data);
return true;
}
static void DestroyBackground2D(SFNode *node)
{
M_Background2D *top;
Background2DStack *ptr;
BackgroundStatus *status;
ptr = (Background2DStack *) Node_GetPrivate(node);
DeleteDrawableNode(ptr->node);
while (ChainGetCount(ptr->surfaces_links)) {
status = ChainGetEntry(ptr->surfaces_links, 0);
ChainDeleteEntry(ptr->surfaces_links, 0);
ChainDeleteItem(status->bind_stack, node);
/*force bind - bindable nodes are the only cases where we generate eventIn in the scene graph*/
if (ChainGetCount(status->bind_stack)) {
top = ChainGetEntry(status->bind_stack, 0);
if (!top->set_bind) {
top->set_bind = 1;
if (top->on_set_bind) top->on_set_bind((SFNode *) top);
}
}
free(status);
}
texture_destroy(&ptr->txh);
DeleteChain(ptr->surfaces_links);
free(ptr);
}
static void obs_source_destroy(obs_source_t source)
{
size_t i;
if (source->filter_parent)
obs_source_filter_remove(source->filter_parent, source);
for (i = 0; i < source->filters.num; i++)
obs_source_release(source->filters.array[i]);
for (i = 0; i < source->audio_wait_buffer.num; i++)
audiobuf_free(source->audio_wait_buffer.array+i);
for (i = 0; i < source->video_frames.num; i++)
source_frame_destroy(source->video_frames.array[i]);
gs_entercontext(obs->video.graphics);
texture_destroy(source->output_texture);
gs_leavecontext();
if (source->data)
source->callbacks.destroy(source->data);
bfree(source->audio_data.data);
audio_line_destroy(source->audio_line);
audio_resampler_destroy(source->resampler);
da_free(source->video_frames);
da_free(source->audio_wait_buffer);
da_free(source->filters);
pthread_mutex_destroy(&source->filter_mutex);
pthread_mutex_destroy(&source->audio_mutex);
pthread_mutex_destroy(&source->video_mutex);
dstr_free(&source->settings);
bfree(source);
}
bool
texture_create(Texture_data *data, const size_t size_hint)
{
assert(data);
assert(size_hint);
// Size up the capacity
{
size_t *capacity = const_cast<size_t*>(&data->capacity);
*capacity = size_hint;
}
// Allocate memory
bool all_alloc = true;
{
// Alloc keys
if(all_alloc)
{
data->keys = new uint32_t[size_hint];
assert(data->keys);
if(!data->keys) { all_alloc = false; }
else { memset(data->keys, 0, sizeof(uint32_t) * size_hint); }
}
// Alloc space for name
if(all_alloc)
{
data->field_name = new char[size_hint * 32];
assert(data->field_name);
if(!data->field_name) { all_alloc = false; }
else { memset(data->field_name, 0, sizeof(char) * size_hint * 32); }
}
// Alloc space for texture
if(all_alloc)
{
data->field_texture = new Ogl::Texture[size_hint * 1];
assert(data->field_texture);
if(!data->field_texture) { all_alloc = false; }
else { memset(data->field_texture, 0, sizeof(Ogl::Texture) * size_hint * 1); }
}
// Alloc space for render_target
if(all_alloc)
{
data->field_render_target = new Ogl::Frame_buffer[size_hint * 1];
assert(data->field_render_target);
if(!data->field_render_target) { all_alloc = false; }
else { memset(data->field_render_target, 0, sizeof(Ogl::Frame_buffer) * size_hint * 1); }
}
}
// Failed so clean up.
if(!all_alloc)
{
texture_destroy(data);
}
return all_alloc;
}
static void image_source_update(void *data, obs_data_t settings)
{
struct image_source *context = data;
const char *file = obs_data_getstring(settings, "file");
gs_entercontext(obs_graphics());
if (context->tex) {
texture_destroy(context->tex);
context->tex = NULL;
}
if (file) {
context->tex = gs_create_texture_from_file(file);
if (context->tex) {
context->cx = texture_getwidth(context->tex);
context->cy = texture_getheight(context->tex);
} else {
warn("failed to load texture '%s'", file);
context->cx = 0;
context->cy = 0;
}
}
gs_leavecontext();
}
void sprite_destroy(Sprite* sprite) {
texture_destroy(sprite->texture);
int i;
for(i = 0; i < NB_VERTEX_ATTRIB; ++i) {
buffer_destroy(sprite->attributes[i].buffer);
}
free(sprite);
}
AS3_Val destroyTexture( void* self, AS3_Val args )
{
Texture *texture = AS3_PtrValue(args);
texture_destroy(&texture);
return 0;
}
/* ...deallocate texture data */
static void __destroy_sv_texture(gpointer data, GstMiniObject *obj)
{
GstBuffer *buffer = (GstBuffer *)obj;
vsink_meta_t *meta = gst_buffer_get_vsink_meta(buffer);
TRACE(DEBUG, _b("destroy texture referenced by meta: %p:%p"), meta, meta->priv);
/* ...destroy texture */
texture_destroy(meta->priv);
}
static void image_source_destroy(void *data)
{
struct image_source *context = data;
gs_entercontext(obs_graphics());
texture_destroy(context->tex);
gs_leavecontext();
bfree(context);
}
XCompcapMain::~XCompcapMain()
{
ObsGsContextHolder obsctx;
if (p->tex) {
texture_destroy(p->tex);
p->tex = 0;
}
xcc_cleanup(p);
delete p;
}
static void random_destroy(void *data)
{
struct random_tex *rt = data;
if (rt) {
gs_entercontext(obs_graphics());
texture_destroy(rt->texture);
bfree(rt);
gs_leavecontext();
}
}
/* ...deallocate texture data */
static void __destroy_od_texture(gpointer data, GstMiniObject *obj)
{
GstBuffer *buffer = (GstBuffer *)obj;
vsink_meta_t *vmeta = gst_buffer_get_vsink_meta(buffer);
objdet_meta_t *ometa = gst_buffer_get_objdet_meta(buffer);
TRACE(DEBUG, _b("destroy texture referenced by meta: %p:%p"), vmeta, vmeta->priv);
/* ...destroy memory mapping */
texture_unmap(ometa->buf);
/* ...destroy texture */
texture_destroy(vmeta->priv);
}
static void obs_free_video(void)
{
struct obs_core_video *video = &obs->video;
if (video->video) {
obs_display_free(&video->main_display);
video_output_close(video->video);
video->video = NULL;
if (!video->graphics)
return;
gs_entercontext(video->graphics);
if (video->mapped_surface) {
stagesurface_unmap(video->mapped_surface);
video->mapped_surface = NULL;
}
for (size_t i = 0; i < NUM_TEXTURES; i++) {
stagesurface_destroy(video->copy_surfaces[i]);
texture_destroy(video->render_textures[i]);
texture_destroy(video->convert_textures[i]);
texture_destroy(video->output_textures[i]);
source_frame_free(&video->convert_frames[i]);
video->copy_surfaces[i] = NULL;
video->render_textures[i] = NULL;
video->convert_textures[i] = NULL;
video->output_textures[i] = NULL;
}
gs_leavecontext();
video->cur_texture = 0;
}
}
void text_renderer_destroy(text_renderer_p renderer) {
texture_destroy(renderer->texture);
for(size_t i = 0; i < renderer->lines->length; i++)
array_destroy( array_elem(renderer->lines, text_renderer_line_t, i).cells );
array_destroy(renderer->lines);
for(hash_elem_t e = hash_start(renderer->fonts); e != NULL; e = hash_next(renderer->fonts, e))
text_renderer_font_destroy(renderer, hash_key(e));
hash_destroy(renderer->fonts);
FT_Error error = FT_Done_FreeType(renderer->freetype);
if (error)
printf("FT_Done_FreeType error\n");
}
static bool set_texture_size(obs_source_t source, struct source_frame *frame)
{
if (source->output_texture) {
uint32_t width = texture_getwidth(source->output_texture);
uint32_t height = texture_getheight(source->output_texture);
if (width == frame->width && height == frame->height)
return true;
}
texture_destroy(source->output_texture);
source->output_texture = gs_create_texture(frame->width, frame->height,
GS_RGBA, 1, NULL, GS_DYNAMIC);
return source->output_texture != NULL;
}
void dc_capture_free(struct dc_capture *capture)
{
if (capture->hdc) {
SelectObject(capture->hdc, capture->old_bmp);
DeleteDC(capture->hdc);
DeleteObject(capture->bmp);
}
gs_entercontext(obs_graphics());
for (size_t i = 0; i < capture->num_textures; i++)
texture_destroy(capture->textures[i]);
gs_leavecontext();
memset(capture, 0, sizeof(struct dc_capture));
}
static inline bool set_async_texture_size(struct obs_source *source,
struct source_frame *frame)
{
enum convert_type prev, cur;
prev = get_convert_type(source->async_format);
cur = get_convert_type(frame->format);
if (source->async_texture) {
if (source->async_width == frame->width &&
source->async_height == frame->height &&
prev == cur)
return true;
}
texture_destroy(source->async_texture);
texrender_destroy(source->async_convert_texrender);
source->async_convert_texrender = NULL;
if (cur != CONVERT_NONE && init_gpu_conversion(source, frame)) {
source->async_gpu_conversion = true;
source->async_convert_texrender =
texrender_create(GS_RGBA, GS_ZS_NONE);
source->async_texture = gs_create_texture(
source->async_convert_width,
source->async_convert_height,
GS_RGBA, 1, NULL, GS_DYNAMIC);
} else {
source->async_gpu_conversion = false;
source->async_texture = gs_create_texture(
frame->width, frame->height,
GS_RGBA, 1, NULL, GS_DYNAMIC);
}
if (!source->async_texture)
return false;
source->async_width = frame->width;
source->async_height = frame->height;
return true;
}
void obs_source_destroy(struct obs_source *source)
{
size_t i;
if (!source)
return;
obs_context_data_remove(&source->context);
obs_source_dosignal(source, "source_destroy", "destroy");
if (source->context.data)
source->info.destroy(source->context.data);
if (source->filter_parent)
obs_source_filter_remove(source->filter_parent, source);
for (i = 0; i < source->filters.num; i++)
obs_source_release(source->filters.array[i]);
for (i = 0; i < source->video_frames.num; i++)
source_frame_destroy(source->video_frames.array[i]);
gs_entercontext(obs->video.graphics);
texrender_destroy(source->async_convert_texrender);
texture_destroy(source->async_texture);
gs_leavecontext();
for (i = 0; i < MAX_AV_PLANES; i++)
bfree(source->audio_data.data[i]);
audio_line_destroy(source->audio_line);
audio_resampler_destroy(source->resampler);
texrender_destroy(source->filter_texrender);
da_free(source->video_frames);
da_free(source->filters);
pthread_mutex_destroy(&source->filter_mutex);
pthread_mutex_destroy(&source->audio_mutex);
pthread_mutex_destroy(&source->video_mutex);
obs_context_data_free(&source->context);
bfree(source);
}
void extract_bin_texture(FStream* fs, const char* out_fn)
{
Texture *myst_img;
myst_img = myst_read_bin_texture(fs);
if (myst_img != 0){
FStream* out;
stream_create(&out);
stream_make(out, out_fn);
if (out->handle != 0) {
myst_write_bin_texture(out, myst_img);
}
stream_destroy(&out);
}
texture_destroy(&myst_img);
}
/*
* Create the cursor texture, either by updating if the new cursor has the same
* size or by creating a new texture if the size is different
*/
static void xcursor_create(xcursor_t *data, XFixesCursorImage *xc) {
uint32_t *pixels = xcursor_pixels(xc);
if (data->tex
&& data->last_height == xc->width
&& data->last_width == xc->height) {
texture_setimage(data->tex, (void **) pixels,
xc->width * sizeof(uint32_t), False);
} else {
if (data->tex)
texture_destroy(data->tex);
data->tex = gs_create_texture(xc->width, xc->height,
GS_BGRA, 1, (const void **) &pixels, GS_DYNAMIC);
}
bfree(pixels);
data->last_serial = xc->cursor_serial;
data->last_width = xc->width;
data->last_height = xc->height;
}
static void obs_source_destroy(obs_source_t source)
{
size_t i;
obs_source_dosignal(source, "source-destroy");
if (source->filter_parent)
obs_source_filter_remove(source->filter_parent, source);
for (i = 0; i < source->filters.num; i++)
obs_source_release(source->filters.array[i]);
for (i = 0; i < source->video_frames.num; i++)
source_frame_destroy(source->video_frames.array[i]);
gs_entercontext(obs->video.graphics);
texture_destroy(source->output_texture);
gs_leavecontext();
if (source->data)
source->callbacks.destroy(source->data);
bfree(source->audio_data.data);
audio_line_destroy(source->audio_line);
audio_resampler_destroy(source->resampler);
proc_handler_destroy(source->procs);
signal_handler_destroy(source->signals);
da_free(source->video_frames);
da_free(source->filters);
pthread_mutex_destroy(&source->filter_mutex);
pthread_mutex_destroy(&source->audio_mutex);
pthread_mutex_destroy(&source->video_mutex);
obs_data_release(source->settings);
bfree(source->name);
bfree(source);
}
static void xcc_cleanup(XCompcapMain_private *p)
{
if (p->gltex) {
texture_destroy(p->gltex);
p->gltex = 0;
}
if (p->glxpixmap) {
glXDestroyPixmap(xdisp, p->glxpixmap);
p->glxpixmap = 0;
}
if (p->pixmap) {
XFreePixmap(xdisp, p->pixmap);
p->pixmap = 0;
}
if (p->win) {
XCompositeUnredirectWindow(xdisp, p->win,
CompositeRedirectAutomatic);
XSelectInput(xdisp, p->win, 0);
p->win = 0;
}
}
void XCompcapMain::updateSettings(obs_data_t settings)
{
PLock lock(&p->lock);
XErrorLock xlock;
ObsGsContextHolder obsctx;
blog(LOG_DEBUG, "Settings updating");
Window prevWin = p->win;
xcc_cleanup(p);
if (settings) {
const char *windowName = obs_data_getstring(settings,
"capture_window");
p->win = getWindowFromString(windowName);
p->cut_top = obs_data_getint(settings, "cut_top");
p->cut_left = obs_data_getint(settings, "cut_left");
p->cut_right = obs_data_getint(settings, "cut_right");
p->cut_bot = obs_data_getint(settings, "cut_bot");
p->lockX = obs_data_getbool(settings, "lock_x");
p->swapRedBlue = obs_data_getbool(settings, "swap_redblue");
} else {
p->win = prevWin;
}
xlock.resetError();
XCompositeRedirectWindow(xdisp, p->win, CompositeRedirectAutomatic);
if (xlock.gotError()) {
blog(LOG_ERROR, "XCompositeRedirectWindow failed: %s",
xlock.getErrorText().c_str());
return;
}
XSelectInput(xdisp, p->win, StructureNotifyMask);
XSync(xdisp, 0);
XWindowAttributes attr;
if (!XGetWindowAttributes(xdisp, p->win, &attr)) {
p->win = 0;
p->width = 0;
p->height = 0;
return;
}
gs_color_format cf = GS_RGBA;
p->width = attr.width;
p->height = attr.height;
if (p->cut_top + p->cut_bot < (int)p->height) {
p->cur_cut_top = p->cut_top;
p->cur_cut_bot = p->cut_bot;
} else {
p->cur_cut_top = 0;
p->cur_cut_bot = 0;
}
if (p->cut_left + p->cut_right < (int)p->width) {
p->cur_cut_left = p->cut_left;
p->cur_cut_right = p->cut_right;
} else {
p->cur_cut_left = 0;
p->cur_cut_right = 0;
}
if (p->tex)
texture_destroy(p->tex);
uint8_t *texData = new uint8_t[width() * height() * 4];
for (unsigned int i = 0; i < width() * height() * 4; i += 4) {
texData[i + 0] = p->swapRedBlue ? 0 : 0xFF;
texData[i + 1] = 0;
texData[i + 2] = p->swapRedBlue ? 0xFF : 0;
texData[i + 3] = 0xFF;
}
const uint8_t* texDataArr[] = { texData, 0 };
p->tex = gs_create_texture(width(), height(), cf, 1,
texDataArr, 0);
delete[] texData;
if (p->swapRedBlue) {
GLuint tex = *(GLuint*)texture_getobj(p->tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
glBindTexture(GL_TEXTURE_2D, 0);
}
const int attrs[] =
{
GLX_BIND_TO_TEXTURE_RGBA_EXT, GL_TRUE,
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_DOUBLEBUFFER, GL_FALSE,
None
};
int nelem = 0;
GLXFBConfig* configs = glXChooseFBConfig(xdisp,
XCompcap::getRootWindowScreen(attr.root),
attrs, &nelem);
if (nelem <= 0) {
blog(LOG_ERROR, "no matching fb config found");
p->win = 0;
p->height = 0;
p->width = 0;
return;
}
glXGetFBConfigAttrib(xdisp, configs[0], GLX_Y_INVERTED_EXT, &nelem);
p->inverted = nelem != 0;
xlock.resetError();
p->pixmap = XCompositeNameWindowPixmap(xdisp, p->win);
if (xlock.gotError()) {
blog(LOG_ERROR, "XCompositeNameWindowPixmap failed: %s",
xlock.getErrorText().c_str());
p->pixmap = 0;
XFree(configs);
return;
}
const int attribs[] =
{
GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT,
None
};
p->glxpixmap = glXCreatePixmap(xdisp, configs[0], p->pixmap, attribs);
if (xlock.gotError()) {
blog(LOG_ERROR, "glXCreatePixmap failed: %s",
xlock.getErrorText().c_str());
XFreePixmap(xdisp, p->pixmap);
XFree(configs);
p->pixmap = 0;
p->glxpixmap = 0;
return;
}
XFree(configs);
p->gltex = gs_create_texture(p->width, p->height, cf, 1, 0,
GS_GL_DUMMYTEX);
GLuint gltex = *(GLuint*)texture_getobj(p->gltex);
glBindTexture(GL_TEXTURE_2D, gltex);
glXBindTexImageEXT(xdisp, p->glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
void xcursor_destroy(xcursor_t *data) {
if (data->tex)
texture_destroy(data->tex);
bfree(data);
}
void tilemap_destroy(struct tilemap *t)
{
texture_destroy(&t->map.texture);
texture_destroy(&t->atlas.texture);
memset(t, 0, sizeof (*t));
}
