← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gstreamer-vaapi/vivid

« back to all changes in this revision

Viewing changes to gst-libs/gst/vaapi/gstvaapicodec_objects.c

  • Committer: Package Import Robot
  • Author(s): Vincent Cheng
  • Date: 2014-08-06 23:56:00 UTC
  • mfrom: (0.1.4 sid) (1.1.3)
  • Revision ID: package-import@ubuntu.com-20140806235600-fg1kcmiu67k315q5
Tags: 0.5.9-2
http://bugs.debian.org/757283
* Remove spurious build-deps: libva-drm1, libavcodec-dev. (Closes: #757283)
* Drop Build-Depends-Indep and build docs unconditionally on all archs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/gst/vaapi/gstvaapicodec_objects.c
3
3
 *
4
4
 *  Copyright (C) 2010-2011 Splitted-Desktop Systems
5
5
 *    Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
6
 
 *  Copyright (C) 2011-2013 Intel Corporation
 
6
 *  Copyright (C) 2011-2014 Intel Corporation
7
7
 *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
8
8
 *
9
9
 *  This library is free software; you can redistribute it and/or
41
41
    gst_vaapi_codec_object_get_class(object)
42
42
 
43
43
const GstVaapiCodecObjectClass *
44
 
gst_vaapi_codec_object_get_class(GstVaapiCodecObject *object)
 
44
gst_vaapi_codec_object_get_class (GstVaapiCodecObject * object)
45
45
{
46
 
    return (const GstVaapiCodecObjectClass *)
47
 
        GST_VAAPI_MINI_OBJECT_GET_CLASS(object);
 
46
  return (const GstVaapiCodecObjectClass *)
 
47
      GST_VAAPI_MINI_OBJECT_GET_CLASS (object);
48
48
}
49
49
 
50
50
static gboolean
51
 
gst_vaapi_codec_object_create(GstVaapiCodecObject *object,
52
 
    const GstVaapiCodecObjectConstructorArgs *args)
 
51
gst_vaapi_codec_object_create (GstVaapiCodecObject * object,
 
52
    const GstVaapiCodecObjectConstructorArgs * args)
53
53
{
54
 
    const GstVaapiCodecObjectClass *klass;
55
 
 
56
 
    g_return_val_if_fail(args->param_size > 0, FALSE);
57
 
 
58
 
    if (GST_VAAPI_MINI_OBJECT_FLAG_IS_SET(object,
59
 
            GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED))
60
 
        return TRUE;
61
 
 
62
 
    klass = GST_VAAPI_CODEC_OBJECT_GET_CLASS(object);
63
 
    if (!klass->create || !klass->create(object, args))
64
 
        return FALSE;
65
 
 
66
 
    GST_VAAPI_MINI_OBJECT_FLAG_SET(object,
67
 
        GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED);
 
54
  const GstVaapiCodecObjectClass *klass;
 
55
 
 
56
  g_return_val_if_fail (args->param_size > 0, FALSE);
 
57
 
 
58
  if (GST_VAAPI_MINI_OBJECT_FLAG_IS_SET (object,
 
59
          GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED))
68
60
    return TRUE;
 
61
 
 
62
  klass = GST_VAAPI_CODEC_OBJECT_GET_CLASS (object);
 
63
  if (!klass->create || !klass->create (object, args))
 
64
    return FALSE;
 
65
 
 
66
  GST_VAAPI_MINI_OBJECT_FLAG_SET (object,
 
67
      GST_VAAPI_CODEC_OBJECT_FLAG_CONSTRUCTED);
 
68
  return TRUE;
69
69
}
70
70
 
71
71
GstVaapiCodecObject *
72
 
gst_vaapi_codec_object_new(const GstVaapiCodecObjectClass *object_class,
73
 
    GstVaapiCodecBase *codec, gconstpointer param, guint param_size,
 
72
gst_vaapi_codec_object_new (const GstVaapiCodecObjectClass * object_class,
 
73
    GstVaapiCodecBase * codec, gconstpointer param, guint param_size,
74
74
    gconstpointer data, guint data_size, guint flags)
75
75
{
76
 
    GstVaapiMiniObject *obj;
77
 
    GstVaapiCodecObject *va_obj;
78
 
    GstVaapiCodecObjectConstructorArgs args;
79
 
 
80
 
    obj = gst_vaapi_mini_object_new0(&object_class->parent_class);
81
 
    if (!obj)
82
 
        return NULL;
83
 
 
84
 
    va_obj = GST_VAAPI_CODEC_OBJECT(obj);
85
 
    va_obj->codec = codec;
86
 
 
87
 
    args.param      = param;
88
 
    args.param_size = param_size;
89
 
    args.data       = data;
90
 
    args.data_size  = data_size;
91
 
    args.flags      = flags;
92
 
 
93
 
    if (gst_vaapi_codec_object_create(va_obj, &args))
94
 
        return va_obj;
95
 
 
96
 
    gst_vaapi_mini_object_unref(obj);
 
76
  GstVaapiCodecObject *obj;
 
77
  GstVaapiCodecObjectConstructorArgs args;
 
78
 
 
79
  obj =
 
80
      (GstVaapiCodecObject *)
 
81
      gst_vaapi_mini_object_new0 (GST_VAAPI_MINI_OBJECT_CLASS (object_class));
 
82
  if (!obj)
97
83
    return NULL;
 
84
 
 
85
  obj = GST_VAAPI_CODEC_OBJECT (obj);
 
86
  obj->codec = codec;
 
87
 
 
88
  args.param = param;
 
89
  args.param_size = param_size;
 
90
  args.data = data;
 
91
  args.data_size = data_size;
 
92
  args.flags = flags;
 
93
 
 
94
  if (gst_vaapi_codec_object_create (obj, &args))
 
95
    return obj;
 
96
 
 
97
  gst_vaapi_codec_object_unref (obj);
 
98
  return NULL;
98
99
}
99
100
 
100
101
#define GET_DECODER(obj)    GST_VAAPI_DECODER_CAST((obj)->parent_instance.codec)
105
106
/* --- Inverse Quantization Matrices                                     --- */
106
107
/* ------------------------------------------------------------------------- */
107
108
 
108
 
GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiIqMatrix, gst_vaapi_iq_matrix);
 
109
GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiIqMatrix, gst_vaapi_iq_matrix);
109
110
 
110
111
void
111
 
gst_vaapi_iq_matrix_destroy(GstVaapiIqMatrix *iq_matrix)
 
112
gst_vaapi_iq_matrix_destroy (GstVaapiIqMatrix * iq_matrix)
112
113
{
113
 
    vaapi_destroy_buffer(GET_VA_DISPLAY(iq_matrix), &iq_matrix->param_id);
114
 
    iq_matrix->param = NULL;
 
114
  vaapi_destroy_buffer (GET_VA_DISPLAY (iq_matrix), &iq_matrix->param_id);
 
115
  iq_matrix->param = NULL;
115
116
}
116
117
 
117
118
gboolean
118
 
gst_vaapi_iq_matrix_create(
119
 
    GstVaapiIqMatrix                         *iq_matrix,
120
 
    const GstVaapiCodecObjectConstructorArgs *args
121
 
)
 
119
gst_vaapi_iq_matrix_create (GstVaapiIqMatrix * iq_matrix,
 
120
    const GstVaapiCodecObjectConstructorArgs * args)
122
121
{
123
 
    iq_matrix->param_id = VA_INVALID_ID;
124
 
    return vaapi_create_buffer(GET_VA_DISPLAY(iq_matrix),
125
 
                               GET_VA_CONTEXT(iq_matrix),
126
 
                               VAIQMatrixBufferType,
127
 
                               args->param_size,
128
 
                               args->param,
129
 
                               &iq_matrix->param_id,
130
 
                               &iq_matrix->param);
 
122
  iq_matrix->param_id = VA_INVALID_ID;
 
123
  return vaapi_create_buffer (GET_VA_DISPLAY (iq_matrix),
 
124
      GET_VA_CONTEXT (iq_matrix), VAIQMatrixBufferType,
 
125
      args->param_size, args->param, &iq_matrix->param_id, &iq_matrix->param);
131
126
}
132
127
 
133
128
GstVaapiIqMatrix *
134
 
gst_vaapi_iq_matrix_new(
135
 
    GstVaapiDecoder *decoder,
136
 
    gconstpointer    param,
137
 
    guint            param_size
138
 
)
 
129
gst_vaapi_iq_matrix_new (GstVaapiDecoder * decoder,
 
130
    gconstpointer param, guint param_size)
139
131
{
140
 
    GstVaapiCodecObject *object;
 
132
  GstVaapiCodecObject *object;
141
133
 
142
 
    object = gst_vaapi_codec_object_new(
143
 
        &GstVaapiIqMatrixClass,
144
 
        GST_VAAPI_CODEC_BASE(decoder),
145
 
        param, param_size,
146
 
        NULL, 0,
147
 
        0
148
 
    );
149
 
    if (!object)
150
 
        return NULL;
151
 
    return GST_VAAPI_IQ_MATRIX_CAST(object);
 
134
  object = gst_vaapi_codec_object_new (&GstVaapiIqMatrixClass,
 
135
      GST_VAAPI_CODEC_BASE (decoder), param, param_size, NULL, 0, 0);
 
136
  if (!object)
 
137
    return NULL;
 
138
  return GST_VAAPI_IQ_MATRIX_CAST (object);
152
139
}
153
140
 
154
141
/* ------------------------------------------------------------------------- */
155
142
/* --- VC-1 Bit Planes                                                   --- */
156
143
/* ------------------------------------------------------------------------- */
157
144
 
158
 
GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiBitPlane, gst_vaapi_bitplane);
 
145
GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiBitPlane, gst_vaapi_bitplane);
159
146
 
160
147
void
161
 
gst_vaapi_bitplane_destroy(GstVaapiBitPlane *bitplane)
 
148
gst_vaapi_bitplane_destroy (GstVaapiBitPlane * bitplane)
162
149
{
163
 
    vaapi_destroy_buffer(GET_VA_DISPLAY(bitplane), &bitplane->data_id);
164
 
    bitplane->data = NULL;
 
150
  vaapi_destroy_buffer (GET_VA_DISPLAY (bitplane), &bitplane->data_id);
 
151
  bitplane->data = NULL;
165
152
}
166
153
 
167
154
gboolean
168
 
gst_vaapi_bitplane_create(
169
 
    GstVaapiBitPlane                         *bitplane,
170
 
    const GstVaapiCodecObjectConstructorArgs *args
171
 
)
 
155
gst_vaapi_bitplane_create (GstVaapiBitPlane * bitplane,
 
156
    const GstVaapiCodecObjectConstructorArgs * args)
172
157
{
173
 
    bitplane->data_id = VA_INVALID_ID;
174
 
    return vaapi_create_buffer(GET_VA_DISPLAY(bitplane),
175
 
                               GET_VA_CONTEXT(bitplane),
176
 
                               VABitPlaneBufferType,
177
 
                               args->param_size,
178
 
                               args->param,
179
 
                               &bitplane->data_id,
180
 
                               (void **)&bitplane->data);
 
158
  bitplane->data_id = VA_INVALID_ID;
 
159
  return vaapi_create_buffer (GET_VA_DISPLAY (bitplane),
 
160
      GET_VA_CONTEXT (bitplane), VABitPlaneBufferType, args->param_size,
 
161
      args->param, &bitplane->data_id, (void **) &bitplane->data);
181
162
}
182
163
 
183
164
 
184
165
GstVaapiBitPlane *
185
 
gst_vaapi_bitplane_new(GstVaapiDecoder *decoder, guint8 *data, guint data_size)
 
166
gst_vaapi_bitplane_new (GstVaapiDecoder * decoder, guint8 * data,
 
167
    guint data_size)
186
168
{
187
 
    GstVaapiCodecObject *object;
 
169
  GstVaapiCodecObject *object;
188
170
 
189
 
    object = gst_vaapi_codec_object_new(
190
 
        &GstVaapiBitPlaneClass,
191
 
        GST_VAAPI_CODEC_BASE(decoder),
192
 
        data, data_size,
193
 
        NULL, 0,
194
 
        0
195
 
    );
196
 
    if (!object)
197
 
        return NULL;
198
 
    return GST_VAAPI_BITPLANE_CAST(object);
 
171
  object = gst_vaapi_codec_object_new (&GstVaapiBitPlaneClass,
 
172
      GST_VAAPI_CODEC_BASE (decoder), data, data_size, NULL, 0, 0);
 
173
  if (!object)
 
174
    return NULL;
 
175
  return GST_VAAPI_BITPLANE_CAST (object);
199
176
}
200
177
 
201
178
/* ------------------------------------------------------------------------- */
203
180
/* ------------------------------------------------------------------------- */
204
181
 
205
182
#if USE_JPEG_DECODER
206
 
GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiHuffmanTable, gst_vaapi_huffman_table);
 
183
GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiHuffmanTable, gst_vaapi_huffman_table);
207
184
 
208
185
void
209
 
gst_vaapi_huffman_table_destroy(GstVaapiHuffmanTable *huf_table)
 
186
gst_vaapi_huffman_table_destroy (GstVaapiHuffmanTable * huf_table)
210
187
{
211
 
    vaapi_destroy_buffer(GET_VA_DISPLAY(huf_table), &huf_table->param_id);
212
 
    huf_table->param = NULL;
 
188
  vaapi_destroy_buffer (GET_VA_DISPLAY (huf_table), &huf_table->param_id);
 
189
  huf_table->param = NULL;
213
190
}
214
191
 
215
192
gboolean
216
 
gst_vaapi_huffman_table_create(
217
 
    GstVaapiHuffmanTable                     *huf_table,
218
 
    const GstVaapiCodecObjectConstructorArgs *args
219
 
)
 
193
gst_vaapi_huffman_table_create (GstVaapiHuffmanTable * huf_table,
 
194
    const GstVaapiCodecObjectConstructorArgs * args)
220
195
{
221
 
    huf_table->param_id = VA_INVALID_ID;
222
 
    return vaapi_create_buffer(GET_VA_DISPLAY(huf_table),
223
 
                               GET_VA_CONTEXT(huf_table),
224
 
                               VAHuffmanTableBufferType,
225
 
                               args->param_size,
226
 
                               args->param,
227
 
                               &huf_table->param_id,
228
 
                               (void **)&huf_table->param);
 
196
  huf_table->param_id = VA_INVALID_ID;
 
197
  return vaapi_create_buffer (GET_VA_DISPLAY (huf_table),
 
198
      GET_VA_CONTEXT (huf_table), VAHuffmanTableBufferType, args->param_size,
 
199
      args->param, &huf_table->param_id, (void **) &huf_table->param);
229
200
}
230
201
 
231
202
GstVaapiHuffmanTable *
232
 
gst_vaapi_huffman_table_new(
233
 
    GstVaapiDecoder *decoder,
234
 
    guint8          *data,
235
 
    guint            data_size
236
 
)
237
 
{
238
 
    GstVaapiCodecObject *object;
239
 
 
240
 
    object = gst_vaapi_codec_object_new(
241
 
        &GstVaapiHuffmanTableClass,
242
 
        GST_VAAPI_CODEC_BASE(decoder),
243
 
        data, data_size,
244
 
        NULL, 0,
245
 
        0
246
 
    );
247
 
    if (!object)
248
 
        return NULL;
249
 
    return GST_VAAPI_HUFFMAN_TABLE_CAST(object);
250
 
}
 
203
gst_vaapi_huffman_table_new (GstVaapiDecoder * decoder,
 
204
    guint8 * data, guint data_size)
 
205
{
 
206
  GstVaapiCodecObject *object;
 
207
 
 
208
  object = gst_vaapi_codec_object_new (&GstVaapiHuffmanTableClass,
 
209
      GST_VAAPI_CODEC_BASE (decoder), data, data_size, NULL, 0, 0);
 
210
  if (!object)
 
211
    return NULL;
 
212
  return GST_VAAPI_HUFFMAN_TABLE_CAST (object);
 
213
}
 
214
#endif
 
215
#if USE_VP8_DECODER
 
216
GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiProbabilityTable,
 
217
    gst_vaapi_probability_table);
 
218
 
 
219
void
 
220
gst_vaapi_probability_table_destroy (GstVaapiProbabilityTable * prob_table)
 
221
{
 
222
  vaapi_destroy_buffer (GET_VA_DISPLAY (prob_table), &prob_table->param_id);
 
223
  prob_table->param = NULL;
 
224
}
 
225
 
 
226
gboolean
 
227
gst_vaapi_probability_table_create (GstVaapiProbabilityTable * prob_table,
 
228
    const GstVaapiCodecObjectConstructorArgs * args)
 
229
{
 
230
  prob_table->param_id = VA_INVALID_ID;
 
231
  return vaapi_create_buffer (GET_VA_DISPLAY (prob_table),
 
232
      GET_VA_CONTEXT (prob_table),
 
233
      VAProbabilityBufferType,
 
234
      args->param_size, args->param, &prob_table->param_id, &prob_table->param);
 
235
}
 
236
 
 
237
GstVaapiProbabilityTable *
 
238
gst_vaapi_probability_table_new (GstVaapiDecoder * decoder,
 
239
    gconstpointer param, guint param_size)
 
240
{
 
241
  GstVaapiCodecObject *object;
 
242
 
 
243
  object = gst_vaapi_codec_object_new (&GstVaapiProbabilityTableClass,
 
244
      GST_VAAPI_CODEC_BASE (decoder), param, param_size, NULL, 0, 0);
 
245
  if (!object)
 
246
    return NULL;
 
247
  return GST_VAAPI_PROBABILITY_TABLE_CAST (object);
 
248
}
 
249
 
251
250
#endif