rate-control: add rate-control attributes
[vaapi:windyuan-gstreamer-vaapi.git] / gst-libs / gst / vaapi / gstvaapiutils.c
1 /*
2  *  gstvaapiutils.c - VA-API utilities
3  *
4  *  Copyright (C) 2010-2011 Splitted-Desktop Systems
5  *  Copyright (C) 2011-2013 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 "gstvaapicompat.h"
25 #include "gstvaapiutils.h"
26 #include "gstvaapisurface.h"
27 #include "gstvaapisubpicture.h"
28 #include <stdio.h>
29 #include <stdarg.h>
30
31 #define DEBUG 1
32 #include "gstvaapidebug.h"
33
34 #define CONCAT(a, b)    CONCAT_(a, b)
35 #define CONCAT_(a, b)   a##b
36 #define STRINGIFY(x)    STRINGIFY_(x)
37 #define STRINGIFY_(x)   #x
38 #define STRCASEP(p, x)  STRCASE(CONCAT(p, x))
39 #define STRCASE(x)      case x: return STRINGIFY(x)
40
41 /* Check VA status for success or print out an error */
42 gboolean
43 vaapi_check_status(VAStatus status, const char *msg)
44 {
45     if (status != VA_STATUS_SUCCESS) {
46         GST_DEBUG("%s: %s", msg, vaErrorStr(status));
47         return FALSE;
48     }
49     return TRUE;
50 }
51
52 /* Maps VA buffer */
53 void *
54 vaapi_map_buffer(VADisplay dpy, VABufferID buf_id)
55 {
56     VAStatus status;
57     void *data = NULL;
58
59     status = vaMapBuffer(dpy, buf_id, &data);
60     if (!vaapi_check_status(status, "vaMapBuffer()"))
61         return NULL;
62     return data;
63 }
64
65 /* Unmaps VA buffer */
66 void
67 vaapi_unmap_buffer(VADisplay dpy, VABufferID buf_id, void **pbuf)
68 {
69     VAStatus status;
70
71     if (pbuf)
72         *pbuf = NULL;
73
74     status = vaUnmapBuffer(dpy, buf_id);
75     if (!vaapi_check_status(status, "vaUnmapBuffer()"))
76         return;
77 }
78
79 /* Creates and maps VA buffer */
80 gboolean
81 vaapi_create_buffer(
82     VADisplay     dpy,
83     VAContextID   ctx,
84     int           type,
85     unsigned int  size,
86     gconstpointer buf,
87     VABufferID   *buf_id_ptr,
88     gpointer     *mapped_data
89 )
90 {
91     VABufferID buf_id;
92     VAStatus status;
93     gpointer data = (gpointer)buf;
94
95     status = vaCreateBuffer(dpy, ctx, type, size, 1, data, &buf_id);
96     if (!vaapi_check_status(status, "vaCreateBuffer()"))
97         return FALSE;
98
99     if (mapped_data) {
100         data = vaapi_map_buffer(dpy, buf_id);
101         if (!data)
102             goto error;
103         *mapped_data = data;
104     }
105
106     *buf_id_ptr = buf_id;
107     return TRUE;
108
109 error:
110     vaapi_destroy_buffer(dpy, &buf_id);
111     return FALSE;
112 }
113
114 /* Destroy VA buffer */
115 void
116 vaapi_destroy_buffer(VADisplay dpy, VABufferID *buf_id_ptr)
117 {
118     if (!buf_id_ptr || *buf_id_ptr == VA_INVALID_ID)
119         return;
120
121     vaDestroyBuffer(dpy, *buf_id_ptr);
122     *buf_id_ptr = VA_INVALID_ID;
123 }
124
125 /* Return a string representation of a VAProfile */
126 const char *string_of_VAProfile(VAProfile profile)
127 {
128     switch (profile) {
129 #define MAP(profile) \
130         STRCASEP(VAProfile, profile)
131         MAP(MPEG2Simple);
132         MAP(MPEG2Main);
133         MAP(MPEG4Simple);
134         MAP(MPEG4AdvancedSimple);
135         MAP(MPEG4Main);
136 #if VA_CHECK_VERSION(0,32,0)
137         MAP(JPEGBaseline);
138         MAP(H263Baseline);
139         MAP(H264ConstrainedBaseline);
140 #endif
141         MAP(H264Baseline);
142         MAP(H264Main);
143         MAP(H264High);
144         MAP(VC1Simple);
145         MAP(VC1Main);
146         MAP(VC1Advanced);
147 #undef MAP
148     default: break;
149     }
150     return "<unknown>";
151 }
152
153 /* Return a string representation of a VAEntrypoint */
154 const char *string_of_VAEntrypoint(VAEntrypoint entrypoint)
155 {
156     switch (entrypoint) {
157 #define MAP(entrypoint) \
158         STRCASEP(VAEntrypoint, entrypoint)
159         MAP(VLD);
160         MAP(IZZ);
161         MAP(IDCT);
162         MAP(MoComp);
163         MAP(Deblocking);
164 #undef MAP
165     default: break;
166     }
167     return "<unknown>";
168 }
169
170 /* Return a string representation of a VADisplayAttributeType */
171 const char *
172 string_of_VADisplayAttributeType(VADisplayAttribType attribute_type)
173 {
174     switch (attribute_type) {
175 #define MAP(attribute_type) \
176         STRCASEP(VADisplayAttrib, attribute_type)
177         MAP(Brightness);
178         MAP(Contrast);
179         MAP(Hue);
180         MAP(Saturation);
181         MAP(BackgroundColor);
182 #if !VA_CHECK_VERSION(0,34,0)
183         MAP(DirectSurface);
184 #endif
185         MAP(Rotation);
186         MAP(OutofLoopDeblock);
187 #if VA_CHECK_VERSION(0,31,1) && !VA_CHECK_VERSION(0,34,0)
188         MAP(BLEBlackMode);
189         MAP(BLEWhiteMode);
190         MAP(BlueStretch);
191         MAP(SkinColorCorrection);
192 #endif
193         MAP(CSCMatrix);
194         MAP(BlendColor);
195         MAP(OverlayAutoPaintColorKey);
196         MAP(OverlayColorKey);
197         MAP(RenderMode);
198         MAP(RenderDevice);
199         MAP(RenderRect);
200 #undef MAP
201     default: break;
202     }
203     return "<unknown>";
204 }
205
206 /**
207  * from_GstVaapiSubpictureFlags:
208  * @flags: the #GstVaapiSubpictureFlags
209  *
210  * Converts #GstVaapiSubpictureFlags to flags suitable for
211  * vaAssociateSubpicture().
212  */
213 guint
214 from_GstVaapiSubpictureFlags(guint flags)
215 {
216     guint va_flags = 0;
217
218     if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
219         va_flags |= VA_SUBPICTURE_GLOBAL_ALPHA;
220 #ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
221     if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
222         flags |= VA_SUBPICTURE_PREMULTIPLIED_ALPHA;
223 #endif
224     return va_flags;
225 }
226
227 /**
228  * to_GstVaapiSubpictureFlags:
229  * @flags: the #GstVaapiSubpictureFlags flags to translate
230  *
231  * Converts vaQuerySubpictureFormats() @flags to #GstVaapiSubpictureFlags
232  * flags.
233  *
234  * Return value: the #GstVaapiSubpictureFlags flags
235  */
236 guint
237 to_GstVaapiSubpictureFlags(guint va_flags)
238 {
239     guint flags = 0;
240
241     if (va_flags & VA_SUBPICTURE_GLOBAL_ALPHA)
242         flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
243 #ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
244     if (va_flags & VA_SUBPICTURE_PREMULTIPLIED_ALPHA)
245         flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
246 #endif
247     return flags;
248 }
249
250 /**
251  * from_GstVideoOverlayFormatFlags:
252  * @flags: the #GstVideoOverlayFormatFlags flags to translate
253  *
254  * Converts #GstVaapiSubpictureFlags to #GstVaapiSubpictureFlags.
255  *
256  * Return value: the #GstVaapiSubpictureFlags flags
257  */
258 guint
259 from_GstVideoOverlayFormatFlags(guint ovl_flags)
260 {
261     guint flags = 0;
262
263 #ifdef HAVE_GST_VIDEO_OVERLAY_HWCAPS
264     if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
265         flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
266     if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)
267         flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
268 #endif
269     return flags;
270 }
271
272 /**
273  * to_GstVideoOverlayFormatFlags:
274  * @flags: the #GstVaapiSubpictureFlags flags to translate
275  *
276  * Converts #GstVaapiSubpictureFlags to #GstVideoOverlayFormatFlags.
277  *
278  * Return value: the #GstVideoOverlayFormatFlags flags
279  */
280 guint
281 to_GstVideoOverlayFormatFlags(guint flags)
282 {
283     guint ovl_flags = 0;
284
285 #ifdef HAVE_GST_VIDEO_OVERLAY_HWCAPS
286     if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
287         ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
288     if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
289         ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA;
290 #endif
291     return ovl_flags;
292 }
293
294 /**
295  * from_GstVaapiSurfaceRenderFlags:
296  * @flags: the #GstVaapiSurfaceRenderFlags
297  *
298  * Converts #GstVaapiSurfaceRenderFlags to flags suitable for
299  * vaPutSurface().
300  */
301 guint
302 from_GstVaapiSurfaceRenderFlags(guint flags)
303 {
304     guint va_fields = 0, va_csc = 0;
305
306     if (flags & GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD)
307         va_fields |= VA_TOP_FIELD;
308     if (flags & GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD)
309         va_fields |= VA_BOTTOM_FIELD;
310     if ((va_fields ^ (VA_TOP_FIELD|VA_BOTTOM_FIELD)) == 0)
311         va_fields  = VA_FRAME_PICTURE;
312
313 #ifdef VA_SRC_BT601
314     if (flags & GST_VAAPI_COLOR_STANDARD_ITUR_BT_601)
315         va_csc = VA_SRC_BT601;
316 #endif
317 #ifdef VA_SRC_BT709
318     if (flags & GST_VAAPI_COLOR_STANDARD_ITUR_BT_709)
319         va_csc = VA_SRC_BT709;
320 #endif
321
322     return va_fields|va_csc;
323 }
324
325 /**
326  * to_GstVaapiSurfaceStatus:
327  * @flags: the #GstVaapiSurfaceStatus flags to translate
328  *
329  * Converts vaQuerySurfaceStatus() @flags to #GstVaapiSurfaceStatus
330  * flags.
331  *
332  * Return value: the #GstVaapiSurfaceStatus flags
333  */
334 guint
335 to_GstVaapiSurfaceStatus(guint va_flags)
336 {
337     guint flags;
338     const guint va_flags_mask = (VASurfaceReady|
339                                  VASurfaceRendering|
340                                  VASurfaceDisplaying);
341
342     /* Check for core status */
343     switch (va_flags & va_flags_mask) {
344     case VASurfaceReady:
345         flags = GST_VAAPI_SURFACE_STATUS_IDLE;
346         break;
347     case VASurfaceRendering:
348         flags = GST_VAAPI_SURFACE_STATUS_RENDERING;
349         break;
350     case VASurfaceDisplaying:
351         flags = GST_VAAPI_SURFACE_STATUS_DISPLAYING;
352         break;
353     default:
354         flags = 0;
355         break;
356     }
357
358     /* Check for encoder status */
359 #if VA_CHECK_VERSION(0,30,0)
360     if (va_flags & VASurfaceSkipped)
361         flags |= GST_VAAPI_SURFACE_STATUS_SKIPPED;
362 #endif
363     return flags;
364 }
365
366 /* Translate GstVaapiRotation value to VA-API rotation value */
367 guint
368 from_GstVaapiRotation(guint value)
369 {
370     switch (value) {
371     case GST_VAAPI_ROTATION_0:   return VA_ROTATION_NONE;
372     case GST_VAAPI_ROTATION_90:  return VA_ROTATION_90;
373     case GST_VAAPI_ROTATION_180: return VA_ROTATION_180;
374     case GST_VAAPI_ROTATION_270: return VA_ROTATION_270;
375     }
376     GST_ERROR("unsupported GstVaapiRotation value %d", value);
377     return VA_ROTATION_NONE;
378 }
379
380 /* Translate VA-API rotation value to GstVaapiRotation value */
381 guint
382 to_GstVaapiRotation(guint value)
383 {
384     switch (value) {
385     case VA_ROTATION_NONE: return GST_VAAPI_ROTATION_0;
386     case VA_ROTATION_90:   return GST_VAAPI_ROTATION_90;
387     case VA_ROTATION_180:  return GST_VAAPI_ROTATION_180;
388     case VA_ROTATION_270:  return GST_VAAPI_ROTATION_270;
389     }
390     GST_ERROR("unsupported VA-API rotation value %d", value);
391     return GST_VAAPI_ROTATION_0;
392 }
393
394 guint
395 from_GstVaapiRateControl(guint value)
396 {
397     switch (value) {
398     case GST_VAAPI_RATECONTROL_NONE:   return VA_RC_NONE;
399     case GST_VAAPI_RATECONTROL_CBR:  return VA_RC_CBR;
400     case GST_VAAPI_RATECONTROL_VBR: return VA_RC_VBR;
401     case GST_VAAPI_RATECONTROL_VCM: return VA_RC_VCM;
402     case GST_VAAPI_RATECONTROL_CQP: return VA_RC_CQP;
403     case GST_VAAPI_RATECONTROL_VBR_CONSTRAINED: return VA_RC_VBR_CONSTRAINED;
404     }
405     GST_ERROR("unsupported GstVaapiRateControl value %d", value);
406     return VA_RC_NONE;
407 }
408
409 guint
410 to_GstVaapiRateControl(guint value)
411 {
412     switch (value) {
413     case VA_RC_NONE: return GST_VAAPI_RATECONTROL_NONE;
414     case VA_RC_CBR:   return GST_VAAPI_RATECONTROL_CBR;
415     case VA_RC_VBR:  return GST_VAAPI_RATECONTROL_VBR;
416     case VA_RC_VCM:  return GST_VAAPI_RATECONTROL_VCM;
417     case VA_RC_CQP: return GST_VAAPI_RATECONTROL_CQP;
418     case VA_RC_VBR_CONSTRAINED: return GST_VAAPI_RATECONTROL_VBR_CONSTRAINED;
419     }
420     GST_ERROR("unsupported VA-API Rate Control value %d", value);
421     return GST_VAAPI_RATECONTROL_NONE;
422 }
423
424 const char *
425 string_of_VARateControl(guint rate_control)
426 {
427     switch (rate_control) {
428     case VA_RC_NONE: return "VA_RC_NONE";
429     case VA_RC_CBR: return "VA_RC_CBR";
430     case VA_RC_VBR: return "VA_RC_VBR";
431     case VA_RC_VCM: return "VA_RC_VCM";
432     case VA_RC_CQP: return "VA_RC_CQP";
433     case VA_RC_VBR_CONSTRAINED: return "VA_RC_VBR_CONSTRAINED";
434     default: break;
435     }
436     return "<unknown>";
437 }