encoder: fix subclassing process.
[vaapi:gstreamer-vaapi.git] / gst-libs / gst / vaapi / gstvaapiencoder.c
1 /*
2  *  gstvaapiencoder.c - VA encoder abstraction
3  *
4  *  Copyright (C) 2013 Intel Corporation
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public License
8  *  as published by the Free Software Foundation; either version 2.1
9  *  of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free
18  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301 USA
20  */
21 #include "sysdeps.h"
22 #include "gstvaapicompat.h"
23 #include "gstvaapiencoder.h"
24 #include "gstvaapiencoder_priv.h"
25 #include "gstvaapicontext.h"
26 #include "gstvaapidisplay_priv.h"
27
28 #define DEBUG 1
29 #include "gstvaapidebug.h"
30
31 #define GST_VAAPI_ENCODER_LOCK(encoder)                         \
32   G_STMT_START {                                                \
33     g_mutex_lock (&(GST_VAAPI_ENCODER_CAST(encoder))->lock);    \
34   } G_STMT_END
35
36 #define GST_VAAPI_ENCODER_UNLOCK(encoder)                               \
37   G_STMT_START {                                                        \
38     g_mutex_unlock (&(GST_VAAPI_ENCODER_CAST(encoder))->lock);          \
39   } G_STMT_END
40
41 #define GST_VAAPI_ENCODER_BUF_FREE_WAIT(encoder)                        \
42   G_STMT_START {                                                        \
43     g_cond_wait (&(GST_VAAPI_ENCODER_CAST(encoder))->codedbuf_free,     \
44                  &(GST_VAAPI_ENCODER_CAST(encoder))->lock);             \
45   } G_STMT_END
46
47 #define GST_VAAPI_ENCODER_BUF_FREE_SIGNAL(encoder)                      \
48   G_STMT_START {                                                        \
49     g_cond_signal (&(GST_VAAPI_ENCODER_CAST(encoder))->codedbuf_free);  \
50   } G_STMT_END
51
52 #define GST_VAAPI_ENCODER_FREE_SURFACE_WAIT(encoder)                    \
53   G_STMT_START {                                                        \
54     g_cond_wait (&(GST_VAAPI_ENCODER_CAST(encoder))->surface_free,      \
55                  &(GST_VAAPI_ENCODER_CAST(encoder))->lock);             \
56   } G_STMT_END
57
58 #define GST_VAAPI_ENCODER_FREE_SURFACE_SIGNAL(encoder)                  \
59   G_STMT_START {                                                        \
60     g_cond_signal (&(GST_VAAPI_ENCODER_CAST(encoder))->surface_free);   \
61   } G_STMT_END
62
63 #define GST_VAAPI_ENCODER_SYNC_SIGNAL(encoder)                          \
64   G_STMT_START {                                                        \
65     g_cond_signal (&(GST_VAAPI_ENCODER_CAST(encoder))->sync_ready);     \
66   } G_STMT_END
67
68 static inline gboolean
69 GST_VAAPI_ENCODER_SYNC_WAIT_TIMEOUT (GstVaapiEncoder * encoder, gint64 timeout)
70 {
71   gint64 end_time = g_get_monotonic_time () + timeout;
72   return g_cond_wait_until (&encoder->sync_ready, &encoder->lock, end_time);
73 }
74
75 typedef struct
76 {
77   GstVaapiEncPicture *picture;
78   GstVaapiCodedBufferProxy *buf;
79 } GstVaapiEncoderSyncPic;
80
81 GstVaapiEncoder *
82 gst_vaapi_encoder_ref (GstVaapiEncoder * encoder)
83 {
84   return gst_vaapi_object_ref (encoder);
85 }
86
87 void
88 gst_vaapi_encoder_unref (GstVaapiEncoder * encoder)
89 {
90   gst_vaapi_object_unref (encoder);
91 }
92
93 void
94 gst_vaapi_encoder_replace (GstVaapiEncoder ** old_encoder_ptr,
95     GstVaapiEncoder * new_encoder)
96 {
97   gst_vaapi_object_replace (old_encoder_ptr, new_encoder);
98 }
99
100 static void
101 _coded_buffer_proxy_released_notify (GstVaapiEncoder * encoder)
102 {
103   GST_VAAPI_ENCODER_LOCK (encoder);
104   GST_VAAPI_ENCODER_BUF_FREE_SIGNAL (encoder);
105   GST_VAAPI_ENCODER_UNLOCK (encoder);
106 }
107
108 static GstVaapiCodedBufferProxy *
109 gst_vaapi_encoder_create_coded_buffer (GstVaapiEncoder * encoder)
110 {
111   GstVaapiCodedBufferPool *const pool =
112     GST_VAAPI_CODED_BUFFER_POOL (encoder->codedbuf_pool);
113   GstVaapiCodedBufferProxy *codedbuf_proxy;
114
115   GST_VAAPI_ENCODER_LOCK (encoder);
116   do {
117     codedbuf_proxy = gst_vaapi_coded_buffer_proxy_new_from_pool (pool);
118     if (codedbuf_proxy)
119       break;
120
121     /* Wait for a free coded buffer to become available */
122     GST_VAAPI_ENCODER_BUF_FREE_WAIT (encoder);
123     codedbuf_proxy = gst_vaapi_coded_buffer_proxy_new_from_pool (pool);
124   } while (0);
125   GST_VAAPI_ENCODER_UNLOCK (encoder);
126   if (!codedbuf_proxy)
127     return NULL;
128
129   gst_vaapi_coded_buffer_proxy_set_destroy_notify (codedbuf_proxy,
130       (GDestroyNotify)_coded_buffer_proxy_released_notify, encoder);
131   return codedbuf_proxy;
132 }
133
134 static void
135 _surface_proxy_released_notify (GstVaapiEncoder * encoder)
136 {
137   GST_VAAPI_ENCODER_FREE_SURFACE_SIGNAL (encoder);
138 }
139
140 GstVaapiSurfaceProxy *
141 gst_vaapi_encoder_create_surface (GstVaapiEncoder * encoder)
142 {
143   GstVaapiSurfaceProxy *proxy;
144
145   g_assert (encoder && encoder->context);
146   g_return_val_if_fail (encoder->context, NULL);
147
148   GST_VAAPI_ENCODER_LOCK (encoder);
149   while (!gst_vaapi_context_get_surface_count (encoder->context)) {
150     GST_VAAPI_ENCODER_FREE_SURFACE_WAIT (encoder);
151   }
152   proxy = gst_vaapi_context_get_surface_proxy (encoder->context);
153   GST_VAAPI_ENCODER_UNLOCK (encoder);
154
155   gst_vaapi_surface_proxy_set_destroy_notify (proxy,
156       (GDestroyNotify) _surface_proxy_released_notify, encoder);
157
158   return proxy;
159 }
160
161 void
162 gst_vaapi_encoder_release_surface (GstVaapiEncoder * encoder,
163     GstVaapiSurfaceProxy * surface)
164 {
165   GST_VAAPI_ENCODER_LOCK (encoder);
166   gst_vaapi_surface_proxy_unref (surface);
167   GST_VAAPI_ENCODER_UNLOCK (encoder);
168 }
169
170 static GstVaapiEncoderSyncPic *
171 _create_sync_picture (GstVaapiEncPicture * picture,
172     GstVaapiCodedBufferProxy * coded_buf)
173 {
174   GstVaapiEncoderSyncPic *sync = g_slice_new0 (GstVaapiEncoderSyncPic);
175
176   g_assert (picture && coded_buf);
177   sync->picture = gst_vaapi_enc_picture_ref (picture);
178   sync->buf = gst_vaapi_coded_buffer_proxy_ref (coded_buf);
179   return sync;
180 }
181
182 static void
183 _free_sync_picture (GstVaapiEncoder * encoder,
184     GstVaapiEncoderSyncPic * sync_pic)
185 {
186   g_assert (sync_pic);
187
188   if (sync_pic->picture)
189     gst_vaapi_enc_picture_unref (sync_pic->picture);
190   if (sync_pic->buf)
191     gst_vaapi_coded_buffer_proxy_unref (sync_pic->buf);
192   g_slice_free (GstVaapiEncoderSyncPic, sync_pic);
193 }
194
195 static void
196 gst_vaapi_encoder_free_sync_pictures (GstVaapiEncoder * encoder)
197 {
198   GstVaapiEncoderSyncPic *sync;
199
200   GST_VAAPI_ENCODER_LOCK (encoder);
201   while (!g_queue_is_empty (&encoder->sync_pictures)) {
202     sync =
203         (GstVaapiEncoderSyncPic *) g_queue_pop_head (&encoder->sync_pictures);
204     GST_VAAPI_ENCODER_UNLOCK (encoder);
205     _free_sync_picture (encoder, sync);
206     GST_VAAPI_ENCODER_LOCK (encoder);
207   }
208   GST_VAAPI_ENCODER_UNLOCK (encoder);
209 }
210
211 static gboolean
212 gst_vaapi_encoder_push_sync_picture (GstVaapiEncoder * encoder,
213     GstVaapiEncoderSyncPic * sync_pic)
214 {
215   GST_VAAPI_ENCODER_LOCK (encoder);
216   g_queue_push_tail (&encoder->sync_pictures, sync_pic);
217   GST_VAAPI_ENCODER_SYNC_SIGNAL (encoder);
218   GST_VAAPI_ENCODER_UNLOCK (encoder);
219   return TRUE;
220 }
221
222 static GstVaapiEncoderStatus
223 gst_vaapi_encoder_pop_sync_picture (GstVaapiEncoder * encoder,
224     GstVaapiEncoderSyncPic ** sync_pic, guint64 timeout)
225 {
226   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
227
228   *sync_pic = NULL;
229
230   GST_VAAPI_ENCODER_LOCK (encoder);
231   if (g_queue_is_empty (&encoder->sync_pictures) &&
232       !GST_VAAPI_ENCODER_SYNC_WAIT_TIMEOUT (encoder, timeout))
233     goto timeout;
234
235   if (g_queue_is_empty (&encoder->sync_pictures)) {
236     ret = GST_VAAPI_ENCODER_STATUS_UNKNOWN_ERR;
237     goto end;
238   }
239
240   *sync_pic =
241       (GstVaapiEncoderSyncPic *) g_queue_pop_head (&encoder->sync_pictures);
242   g_assert (*sync_pic);
243   ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
244   goto end;
245
246 timeout:
247   ret = GST_VAAPI_ENCODER_STATUS_TIMEOUT;
248
249 end:
250   GST_VAAPI_ENCODER_UNLOCK (encoder);
251   return ret;
252 }
253
254 GstVaapiEncoderStatus
255 gst_vaapi_encoder_put_frame (GstVaapiEncoder * encoder,
256     GstVideoCodecFrame * frame)
257 {
258   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
259   GstVaapiEncoderClass *klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
260   GstVaapiEncPicture *picture = NULL;
261   GstVaapiCodedBufferProxy *coded_buf = NULL;
262   GstVaapiEncoderSyncPic *sync_pic = NULL;
263
264 again:
265   picture = NULL;
266   sync_pic = NULL;
267   ret = klass->reordering (encoder, frame, FALSE, &picture);
268
269   if (ret == GST_VAAPI_ENCODER_STATUS_FRAME_NOT_READY)
270     return GST_VAAPI_ENCODER_STATUS_SUCCESS;
271
272   g_assert (picture);
273   if (ret != GST_VAAPI_ENCODER_STATUS_SUCCESS)
274     goto error;
275   if (!picture) {
276     ret = GST_VAAPI_ENCODER_STATUS_PICTURE_ERR;
277     goto error;
278   }
279
280   coded_buf = gst_vaapi_encoder_create_coded_buffer (encoder);
281   if (!coded_buf) {
282     ret = GST_VAAPI_ENCODER_STATUS_OBJECT_ERR;
283     goto error;
284   }
285
286   ret = klass->encode (encoder, picture, coded_buf);
287   if (ret != GST_VAAPI_ENCODER_STATUS_SUCCESS)
288     goto error;
289
290   /* another thread would sync and get coded buffer */
291   sync_pic = _create_sync_picture (picture, coded_buf);
292   gst_vaapi_coded_buffer_proxy_replace (&coded_buf, NULL);
293   gst_vaapi_enc_picture_replace (&picture, NULL);
294
295   if (!gst_vaapi_encoder_push_sync_picture (encoder, sync_pic)) {
296     ret = GST_VAAPI_ENCODER_STATUS_THREAD_ERR;
297     goto error;
298   }
299
300   frame = NULL;
301   goto again;
302
303 error:
304   gst_vaapi_enc_picture_replace (&picture, NULL);
305   gst_vaapi_coded_buffer_proxy_replace (&coded_buf, NULL);
306   if (sync_pic)
307     _free_sync_picture (encoder, sync_pic);
308   GST_ERROR ("encoding failed, error:%d", ret);
309   return ret;
310 }
311
312 GstVaapiEncoderStatus
313 gst_vaapi_encoder_get_buffer (GstVaapiEncoder * encoder,
314     GstVideoCodecFrame ** frame,
315     GstVaapiCodedBufferProxy ** codedbuf, gint64 us_of_timeout)
316 {
317   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
318   GstVaapiEncoderSyncPic *sync_pic = NULL;
319   GstVaapiSurfaceStatus surface_status;
320   GstVaapiEncPicture *picture;
321
322   ret = gst_vaapi_encoder_pop_sync_picture (encoder, &sync_pic, us_of_timeout);
323   if (ret != GST_VAAPI_ENCODER_STATUS_SUCCESS)
324     goto end;
325
326   picture = sync_pic->picture;
327
328   if (!picture->surface || !gst_vaapi_surface_sync (picture->surface)) {
329     ret = GST_VAAPI_ENCODER_STATUS_PARAM_ERR;
330     goto end;
331   }
332   if (!gst_vaapi_surface_query_status (picture->surface, &surface_status)) {
333     ret = GST_VAAPI_ENCODER_STATUS_PICTURE_ERR;
334     goto end;
335   }
336   if (frame)
337     *frame = gst_video_codec_frame_ref (picture->frame);
338   if (codedbuf)
339     *codedbuf = gst_vaapi_coded_buffer_proxy_ref (sync_pic->buf);
340
341 end:
342   if (sync_pic)
343     _free_sync_picture (encoder, sync_pic);
344   return ret;
345 }
346
347 GstVaapiEncoderStatus
348 gst_vaapi_encoder_flush (GstVaapiEncoder * encoder)
349 {
350   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
351
352   return klass->flush (encoder);
353 }
354
355 GstVaapiEncoderStatus
356 gst_vaapi_encoder_get_codec_data (GstVaapiEncoder * encoder,
357     GstBuffer ** codec_data)
358 {
359   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
360   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
361
362   *codec_data = NULL;
363   if (!klass->get_codec_data)
364     return GST_VAAPI_ENCODER_STATUS_SUCCESS;
365
366   ret = klass->get_codec_data (encoder, codec_data);
367   return ret;
368 }
369
370 static gboolean
371 gst_vaapi_encoder_ensure_context (GstVaapiEncoder * encoder)
372 {
373   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
374   GstVaapiContextInfo info;
375   GstVaapiContext *context;
376
377   if (GST_VAAPI_ENCODER_CONTEXT (encoder))
378     return TRUE;
379
380   memset (&info, 0, sizeof (info));
381   if (!klass->get_context_info (encoder, &info))
382     return FALSE;
383
384   context = gst_vaapi_context_new_full (GST_VAAPI_ENCODER_DISPLAY (encoder),
385       &info);
386   if (!context)
387     return FALSE;
388
389   GST_VAAPI_ENCODER_CONTEXT (encoder) = context;
390   GST_VAAPI_ENCODER_VA_CONTEXT (encoder) = gst_vaapi_context_get_id (context);
391   return TRUE;
392 }
393
394 GstCaps *
395 gst_vaapi_encoder_set_format (GstVaapiEncoder * encoder,
396     GstVideoCodecState * in_state, GstCaps * ref_caps)
397 {
398   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
399   GstCaps *out_caps = NULL;
400
401   if (!GST_VIDEO_INFO_WIDTH (&in_state->info) ||
402       !GST_VIDEO_INFO_HEIGHT (&in_state->info)) {
403     GST_WARNING ("encoder set format failed, width or height equal to 0.");
404     return NULL;
405   }
406   GST_VAAPI_ENCODER_VIDEO_INFO (encoder) = in_state->info;
407
408   out_caps = klass->set_format (encoder, in_state, ref_caps);
409   if (!out_caps)
410     goto error;
411
412   if (GST_VAAPI_ENCODER_CAPS (encoder) &&
413       gst_caps_is_equal (out_caps, GST_VAAPI_ENCODER_CAPS (encoder))) {
414     gst_caps_unref (out_caps);
415     return GST_VAAPI_ENCODER_CAPS (encoder);
416   }
417   gst_caps_replace (&GST_VAAPI_ENCODER_CAPS (encoder), out_caps);
418   g_assert (GST_VAAPI_ENCODER_CONTEXT (encoder) == NULL);
419   gst_vaapi_object_replace (&GST_VAAPI_ENCODER_CONTEXT (encoder), NULL);
420
421   if (!gst_vaapi_encoder_ensure_context (encoder))
422     goto error;
423
424   encoder->codedbuf_size = (GST_VAAPI_ENCODER_WIDTH (encoder) *
425       GST_VAAPI_ENCODER_HEIGHT (encoder) * 400) / (16 * 16);
426
427   encoder->codedbuf_pool = gst_vaapi_coded_buffer_pool_new (encoder,
428       encoder->codedbuf_size);
429   if (!encoder->codedbuf_pool) {
430     GST_ERROR ("failed to initialized coded buffer pool");
431     goto error;
432   }
433   gst_vaapi_video_pool_set_capacity (encoder->codedbuf_pool, 5);
434
435   return out_caps;
436
437 error:
438   gst_caps_replace (&GST_VAAPI_ENCODER_CAPS (encoder), NULL);
439   gst_caps_replace (&out_caps, NULL);
440   GST_ERROR ("encoder set format failed");
441   return NULL;
442 }
443
444 static gboolean
445 gst_vaapi_encoder_init (GstVaapiEncoder * encoder, GstVaapiDisplay * display)
446 {
447   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
448
449   g_return_val_if_fail (display != NULL, FALSE);
450
451 #define CHECK_VTABLE_HOOK(FUNC) do {            \
452     if (!klass->FUNC)                           \
453       goto error_invalid_vtable;                \
454   } while (0)
455
456   CHECK_VTABLE_HOOK (init);
457   CHECK_VTABLE_HOOK (finalize);
458   CHECK_VTABLE_HOOK (encode);
459   CHECK_VTABLE_HOOK (reordering);
460   CHECK_VTABLE_HOOK (flush);
461   CHECK_VTABLE_HOOK (get_context_info);
462   CHECK_VTABLE_HOOK (set_format);
463
464 #undef CHECK_VTABLE_HOOK
465
466   encoder->display = gst_vaapi_display_ref (display);
467   encoder->va_display = gst_vaapi_display_get_display (display);
468   encoder->va_context = VA_INVALID_ID;
469
470   gst_video_info_init (&encoder->video_info);
471
472   g_mutex_init (&encoder->lock);
473   g_cond_init (&encoder->codedbuf_free);
474   g_cond_init (&encoder->surface_free);
475   g_queue_init (&encoder->sync_pictures);
476   g_cond_init (&encoder->sync_ready);
477
478   return klass->init (encoder);
479
480   /* ERRORS */
481 error_invalid_vtable:
482   {
483     GST_ERROR ("invalid subclass hook (internal error)");
484     return FALSE;
485   }
486 }
487
488 void
489 gst_vaapi_encoder_finalize (GstVaapiEncoder * encoder)
490 {
491   GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder);
492
493   klass->finalize (encoder);
494
495   gst_vaapi_encoder_free_sync_pictures (encoder);
496   gst_vaapi_video_pool_replace (&encoder->codedbuf_pool, NULL);
497
498   gst_vaapi_object_replace (&encoder->context, NULL);
499   gst_vaapi_display_replace (&encoder->display, NULL);
500   encoder->va_display = NULL;
501   g_mutex_clear (&encoder->lock);
502   g_cond_clear (&encoder->codedbuf_free);
503   g_cond_clear (&encoder->surface_free);
504   g_queue_clear (&encoder->sync_pictures);
505   g_cond_clear (&encoder->sync_ready);
506 }
507
508 GstVaapiEncoder *
509 gst_vaapi_encoder_new (const GstVaapiEncoderClass * klass,
510     GstVaapiDisplay * display)
511 {
512   GstVaapiEncoder *encoder;
513
514   encoder = (GstVaapiEncoder *)
515       gst_vaapi_mini_object_new0 (GST_VAAPI_MINI_OBJECT_CLASS (klass));
516   if (!encoder)
517     return NULL;
518
519   if (!gst_vaapi_encoder_init (encoder, display))
520     goto error;
521   return encoder;
522
523 error:
524   gst_vaapi_encoder_unref (encoder);
525   return NULL;
526 }