gstreamer/gst-libs/gst/vaapi/gstvaapidisplaycache.c

416 lines
10 KiB
C
Raw Normal View History

2012-01-12 11:46:34 +00:00
/*
* gstvaapidisplaycache.c - VA display cache
*
2013-11-22 05:37:12 +00:00
* Copyright (C) 2012-2013 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-01-12 11:46:34 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "sysdeps.h"
2012-01-12 11:46:34 +00:00
#include <glib.h>
#include <string.h>
#include "gstvaapidisplaycache.h"
#define DEBUG 1
#include "gstvaapidebug.h"
typedef struct _CacheEntry CacheEntry;
struct _CacheEntry
{
GstVaapiDisplayInfo info;
2012-01-12 11:46:34 +00:00
};
struct _GstVaapiDisplayCache
{
GstVaapiMiniObject parent_instance;
GRecMutex mutex;
GList *list;
2012-01-12 11:46:34 +00:00
};
static void
cache_entry_free (CacheEntry * entry)
2012-01-12 11:46:34 +00:00
{
GstVaapiDisplayInfo *info;
2012-01-12 11:46:34 +00:00
if (!entry)
return;
2012-01-12 11:46:34 +00:00
info = &entry->info;
2012-01-12 11:46:34 +00:00
if (info->display_name) {
g_free (info->display_name);
info->display_name = NULL;
}
g_slice_free (CacheEntry, entry);
2012-01-12 11:46:34 +00:00
}
static CacheEntry *
cache_entry_new (const GstVaapiDisplayInfo * di)
2012-01-12 11:46:34 +00:00
{
GstVaapiDisplayInfo *info;
CacheEntry *entry;
2012-01-12 11:46:34 +00:00
entry = g_slice_new (CacheEntry);
if (!entry)
2012-01-12 11:46:34 +00:00
return NULL;
info = &entry->info;
info->display = di->display;
info->va_display = di->va_display;
info->native_display = di->native_display;
info->display_type = di->display_type;
info->display_name = NULL;
if (di->display_name) {
info->display_name = g_strdup (di->display_name);
if (!info->display_name)
goto error;
}
return entry;
2016-10-19 17:04:20 +00:00
/* ERRORS */
error:
2016-10-19 17:04:20 +00:00
{
cache_entry_free (entry);
return NULL;
}
2012-01-12 11:46:34 +00:00
}
static inline gboolean
is_compatible_display_type (const GstVaapiDisplayType display_type,
guint display_types)
{
if (display_type == GST_VAAPI_DISPLAY_TYPE_ANY)
return TRUE;
if (display_types == GST_VAAPI_DISPLAY_TYPE_ANY)
return TRUE;
return ((1U << display_type) & display_types) != 0;
}
2012-01-12 11:46:34 +00:00
static GList *
cache_lookup_1 (GstVaapiDisplayCache * cache, GCompareFunc func,
gconstpointer data, guint display_types)
2012-01-12 11:46:34 +00:00
{
GList *l;
for (l = cache->list; l != NULL; l = l->next) {
GstVaapiDisplayInfo *const info = &((CacheEntry *) l->data)->info;
if (!is_compatible_display_type (info->display_type, display_types))
continue;
if (func (info, data))
break;
}
return l;
2012-01-12 11:46:34 +00:00
}
static inline const GstVaapiDisplayInfo *
cache_lookup (GstVaapiDisplayCache * cache, GCompareFunc func,
gconstpointer data, guint display_types)
2012-01-12 11:46:34 +00:00
{
GList *const m = cache_lookup_1 (cache, func, data, display_types);
2012-01-12 11:46:34 +00:00
return m ? &((CacheEntry *) m->data)->info : NULL;
2012-01-12 11:46:34 +00:00
}
static gint
compare_display (gconstpointer a, gconstpointer display)
2012-01-12 11:46:34 +00:00
{
const GstVaapiDisplayInfo *const info = a;
2012-01-12 11:46:34 +00:00
return info->display == display;
}
static gint
compare_va_display (gconstpointer a, gconstpointer va_display)
{
const GstVaapiDisplayInfo *const info = a;
return info->va_display == va_display;
}
static gint
compare_native_display (gconstpointer a, gconstpointer native_display)
{
const GstVaapiDisplayInfo *const info = a;
return info->native_display == native_display;
}
static gint
compare_display_name (gconstpointer a, gconstpointer b)
{
const GstVaapiDisplayInfo *const info = a;
const gchar *const display_name = b;
if (info->display_name == NULL && display_name == NULL)
return TRUE;
if (!info->display_name || !display_name)
return FALSE;
return strcmp (info->display_name, display_name) == 0;
2012-01-12 11:46:34 +00:00
}
static void
gst_vaapi_display_cache_finalize (GstVaapiDisplayCache * cache)
2012-01-12 11:46:34 +00:00
{
GList *l;
2012-01-12 11:46:34 +00:00
if (cache->list) {
for (l = cache->list; l != NULL; l = l->next)
cache_entry_free (l->data);
g_list_free (cache->list);
cache->list = NULL;
}
g_rec_mutex_clear (&cache->mutex);
}
static const GstVaapiMiniObjectClass *
gst_vaapi_display_cache_class (void)
{
static const GstVaapiMiniObjectClass GstVaapiDisplayCacheClass = {
.size = sizeof (GstVaapiDisplayCache),
.finalize = (GDestroyNotify) gst_vaapi_display_cache_finalize
};
return &GstVaapiDisplayCacheClass;
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_new:
*
* Creates a new VA display cache.
*
* Return value: the newly created #GstVaapiDisplayCache object
2012-01-12 11:46:34 +00:00
*/
GstVaapiDisplayCache *
gst_vaapi_display_cache_new (void)
2012-01-12 11:46:34 +00:00
{
GstVaapiDisplayCache *cache;
cache = (GstVaapiDisplayCache *)
gst_vaapi_mini_object_new (gst_vaapi_display_cache_class ());
if (!cache)
return NULL;
g_rec_mutex_init (&cache->mutex);
cache->list = NULL;
return cache;
}
/**
* gst_vaapi_display_cache_lock:
* @cache: the #GstVaapiDisplayCache
*
* Locks the display cache @cache.
*/
void
gst_vaapi_display_cache_lock (GstVaapiDisplayCache * cache)
{
g_return_if_fail (cache != NULL);
g_rec_mutex_lock (&cache->mutex);
}
/**
* gst_vaapi_display_cache_unlock:
* @cache: the #GstVaapiDisplayCache
*
* Unlocks the display cache @cache.
*/
void
gst_vaapi_display_cache_unlock (GstVaapiDisplayCache * cache)
{
g_return_if_fail (cache != NULL);
g_rec_mutex_unlock (&cache->mutex);
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_is_empty:
2012-01-12 11:46:34 +00:00
* @cache: the #GstVaapiDisplayCache
*
* Checks whether the display cache @cache is empty.
2012-01-12 11:46:34 +00:00
*
* Return value: %TRUE if the display @cache is empty, %FALSE otherwise.
2012-01-12 11:46:34 +00:00
*/
gboolean
gst_vaapi_display_cache_is_empty (GstVaapiDisplayCache * cache)
2012-01-12 11:46:34 +00:00
{
g_return_val_if_fail (cache != NULL, 0);
2012-01-12 11:46:34 +00:00
return cache->list == NULL;
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_add:
* @cache: the #GstVaapiDisplayCache
* @info: the display cache info to add
*
* Adds a new entry with data from @info. The display @info data is
* copied into the newly created cache entry.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_display_cache_add (GstVaapiDisplayCache * cache,
GstVaapiDisplayInfo * info)
2012-01-12 11:46:34 +00:00
{
CacheEntry *entry;
2012-01-12 11:46:34 +00:00
g_return_val_if_fail (cache != NULL, FALSE);
g_return_val_if_fail (info != NULL, FALSE);
2012-01-12 11:46:34 +00:00
entry = cache_entry_new (info);
if (!entry)
return FALSE;
2012-01-12 11:46:34 +00:00
cache->list = g_list_prepend (cache->list, entry);
return TRUE;
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_remove:
* @cache: the #GstVaapiDisplayCache
* @display: the display to remove from cache
*
* Removes any cache entry that matches the specified #GstVaapiDisplay.
*/
void
gst_vaapi_display_cache_remove (GstVaapiDisplayCache * cache,
GstVaapiDisplay * display)
2012-01-12 11:46:34 +00:00
{
GList *m;
2012-01-12 11:46:34 +00:00
m = cache_lookup_1 (cache, compare_display, display,
GST_VAAPI_DISPLAY_TYPE_ANY);
if (!m)
return;
2012-01-12 11:46:34 +00:00
cache_entry_free (m->data);
cache->list = g_list_delete_link (cache->list, m);
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_lookup:
* @cache: the #GstVaapiDisplayCache
* @display: the display to find
*
* Looks up the display cache for the specified #GstVaapiDisplay.
*
* Return value: a #GstVaapiDisplayInfo matching @display, or %NULL if
* none was found
*/
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup (GstVaapiDisplayCache * cache,
GstVaapiDisplay * display)
2012-01-12 11:46:34 +00:00
{
g_return_val_if_fail (cache != NULL, NULL);
g_return_val_if_fail (display != NULL, NULL);
2012-01-12 11:46:34 +00:00
return cache_lookup (cache, compare_display, display,
GST_VAAPI_DISPLAY_TYPE_ANY);
}
2012-01-12 11:46:34 +00:00
/**
* gst_vaapi_display_cache_lookup_custom:
* @cache: the #GstVaapiDisplayCache
* @func: an comparison function
* @data: user data passed to the function
*
* Looks up an element in the display @cache using the supplied
* function @func to find the desired element. It iterates over all
* elements in cache, calling the given function which should return
* %TRUE when the desired element is found.
*
* The comparison function takes two gconstpointer arguments, a
* #GstVaapiDisplayInfo as the first argument, and that is used to
* compare against the given user @data argument as the second
* argument.
*
* Return value: a #GstVaapiDisplayInfo causing @func to succeed
* (i.e. returning %TRUE), or %NULL if none was found
*/
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_custom (GstVaapiDisplayCache * cache,
GCompareFunc func, gconstpointer data, guint display_types)
{
g_return_val_if_fail (cache != NULL, NULL);
g_return_val_if_fail (func != NULL, NULL);
return cache_lookup (cache, func, data, display_types);
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_lookup_by_va_display:
* @cache: the #GstVaapiDisplayCache
* @va_display: the VA display to find
*
* Looks up the display cache for the specified VA display.
*
* Return value: a #GstVaapiDisplayInfo matching @va_display, or %NULL
* if none was found
*/
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_va_display (GstVaapiDisplayCache * cache,
VADisplay va_display)
2012-01-12 11:46:34 +00:00
{
g_return_val_if_fail (cache != NULL, NULL);
g_return_val_if_fail (va_display != NULL, NULL);
2012-01-12 11:46:34 +00:00
return cache_lookup (cache, compare_va_display, va_display,
GST_VAAPI_DISPLAY_TYPE_ANY);
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_lookup_by_native_display:
* @cache: the #GstVaapiDisplayCache
* @native_display: the native display to find
*
* Looks up the display cache for the specified native display.
*
* Return value: a #GstVaapiDisplayInfo matching @native_display, or
* %NULL if none was found
*/
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_native_display (GstVaapiDisplayCache * cache,
gpointer native_display, guint display_types)
2012-01-12 11:46:34 +00:00
{
g_return_val_if_fail (cache != NULL, NULL);
g_return_val_if_fail (native_display != NULL, NULL);
2012-01-12 11:46:34 +00:00
return cache_lookup (cache, compare_native_display, native_display,
display_types);
2012-01-12 11:46:34 +00:00
}
/**
* gst_vaapi_display_cache_lookup_by_name:
* @cache: the #GstVaapiDisplayCache
* @display_name: the display name to match
*
* Looks up the display cache for the specified display name.
2012-01-12 11:46:34 +00:00
*
* Return value: a #GstVaapiDisplayInfo matching @display_name, or
* %NULL if none was found
*/
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_name (GstVaapiDisplayCache * cache,
const gchar * display_name, guint display_types)
2012-01-12 11:46:34 +00:00
{
g_return_val_if_fail (cache != NULL, NULL);
2012-01-12 11:46:34 +00:00
return cache_lookup (cache, compare_display_name, display_name,
display_types);
2012-01-12 11:46:34 +00:00
}