gst-libs/gst/vaapi/gstvaapicodec_objects.c

   1 /*
   2  *  gstvaapicodec_objects.c - VA codec objects abstraction
   3  *
   4  *  Copyright (C) 2010-2011 Splitted-Desktop Systems
   5  *  Copyright (C) 2011-2012 Intel Corporation
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Lesser General Public License
   9  *  as published by the Free Software Foundation; either version 2.1
  10  *  of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  *  Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "sysdeps.h"
  24 #include <string.h>
  25 #include <gst/vaapi/gstvaapicontext.h>
  26 #include "gstvaapicodec_objects.h"
  27 #include "gstvaapidecoder_priv.h"
  28 #include "gstvaapicompat.h"
  29 #include "gstvaapiutils.h"
  30
  31 #define DEBUG 1
  32 #include "gstvaapidebug.h"
  33
  34 /* ------------------------------------------------------------------------- */
  35 /* --- Base Codec Object                                                 --- */
  36 /* ------------------------------------------------------------------------- */
  37
  38 G_DEFINE_TYPE(GstVaapiCodecObject, gst_vaapi_codec_object, GST_TYPE_MINI_OBJECT)
  39
  40 static void
  41 gst_vaapi_codec_object_finalize(GstMiniObject *object)
  42 {
  43     GstVaapiCodecObject * const obj = GST_VAAPI_CODEC_OBJECT(object);
  44
  45     obj->codec = NULL;
  46 }
  47
  48 static void
  49 gst_vaapi_codec_object_init(GstVaapiCodecObject *obj)
  50 {
  51     obj->codec = NULL;
  52 }
  53
  54 static gboolean
  55 gst_vaapi_codec_object_create(
  56     GstVaapiCodecObject                      *obj,
  57     const GstVaapiCodecObjectConstructorArgs *args
  58 )
  59 {
  60     obj->codec = args->codec;
  61     return TRUE;
  62 }
  63
  64 static void
  65 gst_vaapi_codec_object_class_init(GstVaapiCodecObjectClass *klass)
  66 {
  67     GstMiniObjectClass * const object_class = GST_MINI_OBJECT_CLASS(klass);
  68
  69     object_class->finalize = gst_vaapi_codec_object_finalize;
  70     klass->construct       = gst_vaapi_codec_object_create;
  71 }
  72
  73 GstVaapiCodecObject *
  74 gst_vaapi_codec_object_new(
  75     GType              type,
  76     GstVaapiCodecBase *codec,
  77     gconstpointer      param,
  78     guint              param_size,
  79     gconstpointer      data,
  80     guint              data_size
  81 )
  82 {
  83     GstMiniObject *obj;
  84     GstVaapiCodecObject *va_obj;
  85     GstVaapiCodecObjectConstructorArgs args;
  86
  87     obj = gst_mini_object_new(type);
  88     if (!obj)
  89         return NULL;
  90
  91     va_obj = GST_VAAPI_CODEC_OBJECT(obj);
  92     args.codec      = codec;
  93     args.param      = param;
  94     args.param_size = param_size;
  95     args.data       = data;
  96     args.data_size  = data_size;
  97     args.flags      = 0;
  98     if (gst_vaapi_codec_object_construct(va_obj, &args))
  99         return va_obj;
 100
 101     gst_mini_object_unref(obj);
 102     return NULL;
 103 }
 104
 105 gboolean
 106 gst_vaapi_codec_object_construct(
 107     GstVaapiCodecObject                      *obj,
 108     const GstVaapiCodecObjectConstructorArgs *args
 109 )
 110 {
 111     GstVaapiCodecObjectClass *klass;
 112
 113     g_return_val_if_fail(GST_VAAPI_CODEC_OBJECT(obj), FALSE);
 114     g_return_val_if_fail(args->codec != NULL, FALSE);
 115     g_return_val_if_fail(args->param_size > 0, FALSE);
 116
 117     if (GST_MINI_OBJECT_FLAG_IS_SET(obj, GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED))
 118         return TRUE;
 119
 120     klass = GST_VAAPI_CODEC_OBJECT_GET_CLASS(obj);
 121     if (!klass || !klass->construct || !klass->construct(obj, args))
 122         return FALSE;
 123
 124     GST_MINI_OBJECT_FLAG_SET(obj, GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED);
 125     return TRUE;
 126 }
 127
 128 #define GET_DECODER(obj)    GST_VAAPI_DECODER_CAST((obj)->parent_instance.codec)
 129 #define GET_CONTEXT(obj)    GET_DECODER(obj)->priv->context
 130 #define GET_VA_DISPLAY(obj) GET_DECODER(obj)->priv->va_display
 131 #define GET_VA_CONTEXT(obj) GET_DECODER(obj)->priv->va_context
 132
 133 /* ------------------------------------------------------------------------- */
 134 /* --- Inverse Quantization Matrices                                     --- */
 135 /* ------------------------------------------------------------------------- */
 136
 137 GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiIqMatrix,
 138                             gst_vaapi_iq_matrix,
 139                             GST_VAAPI_TYPE_CODEC_OBJECT)
 140
 141 static void
 142 gst_vaapi_iq_matrix_destroy(GstVaapiIqMatrix *iq_matrix)
 143 {
 144     vaapi_destroy_buffer(GET_VA_DISPLAY(iq_matrix), &iq_matrix->param_id);
 145     iq_matrix->param = NULL;
 146 }
 147
 148 static gboolean
 149 gst_vaapi_iq_matrix_create(
 150     GstVaapiIqMatrix                         *iq_matrix,
 151     const GstVaapiCodecObjectConstructorArgs *args
 152 )
 153 {
 154     return vaapi_create_buffer(GET_VA_DISPLAY(iq_matrix),
 155                                GET_VA_CONTEXT(iq_matrix),
 156                                VAIQMatrixBufferType,
 157                                args->param_size,
 158                                args->param,
 159                                &iq_matrix->param_id,
 160                                &iq_matrix->param);
 161 }
 162
 163 static void
 164 gst_vaapi_iq_matrix_init(GstVaapiIqMatrix *iq_matrix)
 165 {
 166     iq_matrix->param    = NULL;
 167     iq_matrix->param_id = VA_INVALID_ID;
 168 }
 169
 170 GstVaapiIqMatrix *
 171 gst_vaapi_iq_matrix_new(
 172     GstVaapiDecoder *decoder,
 173     gconstpointer    param,
 174     guint            param_size
 175 )
 176 {
 177     GstVaapiCodecObject *object;
 178
 179     g_return_val_if_fail(GST_VAAPI_IS_DECODER(decoder), NULL);
 180
 181     object = gst_vaapi_codec_object_new(
 182         GST_VAAPI_TYPE_IQ_MATRIX,
 183         GST_VAAPI_CODEC_BASE(decoder),
 184         param, param_size,
 185         NULL, 0
 186     );
 187     if (!object)
 188         return NULL;
 189     return GST_VAAPI_IQ_MATRIX_CAST(object);
 190 }
 191
 192 /* ------------------------------------------------------------------------- */
 193 /* --- VC-1 Bit Planes                                                   --- */
 194 /* ------------------------------------------------------------------------- */
 195
 196 GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiBitPlane,
 197                             gst_vaapi_bitplane,
 198                             GST_VAAPI_TYPE_CODEC_OBJECT)
 199
 200 static void
 201 gst_vaapi_bitplane_destroy(GstVaapiBitPlane *bitplane)
 202 {
 203     vaapi_destroy_buffer(GET_VA_DISPLAY(bitplane), &bitplane->data_id);
 204     bitplane->data = NULL;
 205 }
 206
 207 static gboolean
 208 gst_vaapi_bitplane_create(
 209     GstVaapiBitPlane                         *bitplane,
 210     const GstVaapiCodecObjectConstructorArgs *args
 211 )
 212 {
 213     return vaapi_create_buffer(GET_VA_DISPLAY(bitplane),
 214                                GET_VA_CONTEXT(bitplane),
 215                                VABitPlaneBufferType,
 216                                args->param_size,
 217                                args->param,
 218                                &bitplane->data_id,
 219                                (void **)&bitplane->data);
 220 }
 221
 222 static void
 223 gst_vaapi_bitplane_init(GstVaapiBitPlane *bitplane)
 224 {
 225     bitplane->data      = NULL;
 226     bitplane->data_id   = VA_INVALID_ID;
 227 }
 228
 229 GstVaapiBitPlane *
 230 gst_vaapi_bitplane_new(GstVaapiDecoder *decoder, guint8 *data, guint data_size)
 231 {
 232     GstVaapiCodecObject *object;
 233
 234     g_return_val_if_fail(GST_VAAPI_IS_DECODER(decoder), NULL);
 235
 236     object = gst_vaapi_codec_object_new(
 237         GST_VAAPI_TYPE_BITPLANE,
 238         GST_VAAPI_CODEC_BASE(decoder),
 239         data, data_size,
 240         NULL, 0
 241     );
 242     if (!object)
 243         return NULL;
 244     return GST_VAAPI_BITPLANE_CAST(object);
 245 }
 246
 247 /* ------------------------------------------------------------------------- */
 248 /* --- JPEG Huffman Tables                                               --- */
 249 /* ------------------------------------------------------------------------- */
 250
 251 #if USE_JPEG_DECODER
 252 GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiHuffmanTable,
 253                             gst_vaapi_huffman_table,
 254                             GST_VAAPI_TYPE_CODEC_OBJECT)
 255
 256 static void
 257 gst_vaapi_huffman_table_destroy(GstVaapiHuffmanTable *huf_table)
 258 {
 259     vaapi_destroy_buffer(GET_VA_DISPLAY(huf_table), &huf_table->param_id);
 260     huf_table->param = NULL;
 261 }
 262
 263 static gboolean
 264 gst_vaapi_huffman_table_create(
 265     GstVaapiHuffmanTable                     *huf_table,
 266     const GstVaapiCodecObjectConstructorArgs *args
 267 )
 268 {
 269     return vaapi_create_buffer(GET_VA_DISPLAY(huf_table),
 270                                GET_VA_CONTEXT(huf_table),
 271                                VAHuffmanTableBufferType,
 272                                args->param_size,
 273                                args->param,
 274                                &huf_table->param_id,
 275                                (void **)&huf_table->param);
 276 }
 277
 278 static void
 279 gst_vaapi_huffman_table_init(GstVaapiHuffmanTable *huf_table)
 280 {
 281     huf_table->param    = NULL;
 282     huf_table->param_id = VA_INVALID_ID;
 283 }
 284
 285 GstVaapiHuffmanTable *
 286 gst_vaapi_huffman_table_new(
 287     GstVaapiDecoder *decoder,
 288     guint8          *data,
 289     guint            data_size
 290 )
 291 {
 292     GstVaapiCodecObject *object;
 293
 294     g_return_val_if_fail(GST_VAAPI_IS_DECODER(decoder), NULL);
 295
 296     object = gst_vaapi_codec_object_new(
 297         GST_VAAPI_TYPE_HUFFMAN_TABLE,
 298         GST_VAAPI_CODEC_BASE(decoder),
 299         data, data_size,
 300         NULL, 0
 301     );
 302     if (!object)
 303         return NULL;
 304     return GST_VAAPI_HUFFMAN_TABLE_CAST(object);
 305 }
 306 #endif