Ubuntu
gst-plugins-bad1.0 package

Merge ~alfonsosanchezbeato/ubuntu/+source/gst-plugins-bad1.0:master into ~ubuntu-desktop/ubuntu/+source/gst-plugins-bad1.0:master

  1. Git
  2. lp:~alfonsosanchezbeato/ubuntu/+source/gst-plugins-bad1.0
  3. master
  4. Merge into master
Proposed by Alfonso Sanchez-Beato on 2015-07-24
Status: Merged
Merged at revision: 05a75e4abee4eb258ca0c1baa5bd63c5875fde15
Proposed branch: ~alfonsosanchezbeato/ubuntu/+source/gst-plugins-bad1.0:master
Merge into: ~ubuntu-desktop/ubuntu/+source/gst-plugins-bad1.0:master
Diff against target: 1395 lines (+305/-220)
1 file modified
debian/patches/adding-mirsink-and-android-media-over-hybris-support.patch (+305/-220)
Reviewer Review Type Date Requested Status
Jim Hodapp (community) code Approve on 2015-07-24
Ubuntu Desktop 2015-07-24 Pending
Review via email: mp+265791@code.launchpad.net

Commit Message

Send error messages to the client in amchybris

Send error messages to the gstreamer client when an error happens in
amchybris, so it can react. Based on changes to the androidmedia plugin.

Description of the Change

Send error messages to the client in amchybris

Send error messages to the gstreamer client when an error happens in
amchybris, so it can react. Based on changes to the androidmedia plugin.

To post a comment you must log in.
Jim Hodapp (jhodapp) wrote :

See 14 inline comments below for some minor changes.

review: Needs Fixing (code)
Jim Hodapp (jhodapp) wrote :

Seems the macro that prints out the error also prints out the line number and file for each error. My comments no longer apply.

review: Approve (code)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1diff --git a/debian/patches/adding-mirsink-and-android-media-over-hybris-support.patch b/debian/patches/adding-mirsink-and-android-media-over-hybris-support.patch
2index 87acd10..d574b0d 100644
3--- a/debian/patches/adding-mirsink-and-android-media-over-hybris-support.patch
4+++ b/debian/patches/adding-mirsink-and-android-media-over-hybris-support.patch
5@@ -14,7 +14,7 @@ Forwarded: no
6 ext/mir/Makefile.am | 17 +
7 ext/mir/gstmirsink.c | 848 ++++++++++
8 ext/mir/gstmirsink.h | 134 ++
9- ext/mir/mirpool.c | 434 ++++++
10+ ext/mir/mirpool.c | 434 +++++
11 ext/mir/mirpool.h | 91 ++
12 gst-libs/gst/Makefile.am | 8 +-
13 gst-libs/gst/mir/Makefile.am | 26 +
14@@ -25,16 +25,16 @@ Forwarded: no
15 sys/Makefile.am | 6 +
16 sys/androidmedia/Makefile.am | 16 +-
17 sys/androidmedia/gstamc-constants.h | 7 +
18- sys/androidmedia/gstamc.h | 162 +-
19+ sys/androidmedia/gstamc.h | 97 +-
20 sys/androidmedia/gstamcaudiodec.h | 8 +
21- sys/androidmedia/gstamcaudiodechybris.c | 1278 +++++++++++++++
22- sys/androidmedia/gstamchybris.c | 2137 +++++++++++++++++++++++++
23+ sys/androidmedia/gstamcaudiodechybris.c | 1291 +++++++++++++++
24+ sys/androidmedia/gstamchybris.c | 2182 +++++++++++++++++++++++++
25 sys/androidmedia/gstamcvideodec.h | 30 +
26- sys/androidmedia/gstamcvideodechybris.c | 2327 ++++++++++++++++++++++++++++
27+ sys/androidmedia/gstamcvideodechybris.c | 2399 ++++++++++++++++++++++++++++
28 tests/check/Makefile.am | 7 +
29 tests/check/pipelines/gstamcvideodec.c | 538 +++++++
30 tests/check/pipelines/gstamcvideodec_egl.c | 56 +
31- 25 files changed, 8656 insertions(+), 36 deletions(-)
32+ 25 files changed, 8751 insertions(+), 6 deletions(-)
33 create mode 100644 ext/mir/Makefile.am
34 create mode 100644 ext/mir/gstmirsink.c
35 create mode 100644 ext/mir/gstmirsink.h
36@@ -2404,10 +2404,10 @@ index ae52464..f5bb86f 100644
37
38 enum
39 diff --git a/sys/androidmedia/gstamc.h b/sys/androidmedia/gstamc.h
40-index 88d49fb..2fddc05 100644
41+index 88d49fb..567752e 100644
42 --- a/sys/androidmedia/gstamc.h
43 +++ b/sys/androidmedia/gstamc.h
44-@@ -24,12 +24,73 @@
45+@@ -24,12 +24,67 @@
46 #include <gst/gst.h>
47 #include <gst/video/video.h>
48 #include <gst/audio/audio.h>
49@@ -2433,12 +2433,6 @@ index 88d49fb..2fddc05 100644
50 + gsize size;
51 +};
52 +#endif
53-+
54-+#ifndef HAVE_ANDROID_MEDIA_HYBRIS
55-+#define MAYBE_GERROR , GError **err
56-+#else
57-+#define MAYBE_GERROR
58-+#endif
59
60 G_BEGIN_DECLS
61
62@@ -2482,7 +2476,7 @@ index 88d49fb..2fddc05 100644
63 typedef struct _GstAmcCodecInfo GstAmcCodecInfo;
64 typedef struct _GstAmcCodecType GstAmcCodecType;
65 typedef struct _GstAmcCodec GstAmcCodec;
66-@@ -58,16 +119,29 @@ struct _GstAmcCodecInfo {
67+@@ -58,16 +113,29 @@ struct _GstAmcCodecInfo {
68 };
69
70 struct _GstAmcFormat {
71@@ -2512,105 +2506,66 @@ index 88d49fb..2fddc05 100644
72 };
73
74 struct _GstAmcBufferInfo {
75-@@ -79,43 +153,67 @@ struct _GstAmcBufferInfo {
76-
77- extern GQuark gst_amc_codec_info_quark;
78-
79--GstAmcCodec * gst_amc_codec_new (const gchar *name, GError **err);
80-+GstAmcCodec * gst_amc_codec_new (const gchar *name MAYBE_GERROR);
81+@@ -82,7 +150,15 @@ extern GQuark gst_amc_codec_info_quark;
82+ GstAmcCodec * gst_amc_codec_new (const gchar *name, GError **err);
83 void gst_amc_codec_free (GstAmcCodec * codec);
84
85--gboolean gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format, gint flags, GError **err);
86--GstAmcFormat * gst_amc_codec_get_output_format (GstAmcCodec * codec, GError **err);
87--
88--gboolean gst_amc_codec_start (GstAmcCodec * codec, GError **err);
89--gboolean gst_amc_codec_stop (GstAmcCodec * codec, GError **err);
90--gboolean gst_amc_codec_flush (GstAmcCodec * codec, GError **err);
91--gboolean gst_amc_codec_release (GstAmcCodec * codec, GError **err);
92--
93--GstAmcBuffer * gst_amc_codec_get_output_buffer (GstAmcCodec * codec, gint index, GError **err);
94--GstAmcBuffer * gst_amc_codec_get_input_buffer (GstAmcCodec * codec, gint index, GError **err);
95--
96--gint gst_amc_codec_dequeue_input_buffer (GstAmcCodec * codec, gint64 timeoutUs, GError **err);
97--gint gst_amc_codec_dequeue_output_buffer (GstAmcCodec * codec, GstAmcBufferInfo *info, gint64 timeoutUs, GError **err);
98--
99--gboolean gst_amc_codec_queue_input_buffer (GstAmcCodec * codec, gint index, const GstAmcBufferInfo *info, GError **err);
100--gboolean gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index, GError **err);
101--
102--
103--GstAmcFormat * gst_amc_format_new_audio (const gchar *mime, gint sample_rate, gint channels, GError **err);
104--GstAmcFormat * gst_amc_format_new_video (const gchar *mime, gint width, gint height, GError **err);
105 +#ifdef HAVE_ANDROID_MEDIA_HYBRIS
106-+gboolean gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format, SurfaceTextureClientHybris stc, gint flags);
107++gboolean gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format,
108++ SurfaceTextureClientHybris stc, gint flags, GError **err);
109 +gboolean gst_amc_codec_set_surface_texture_client (GstAmcCodec * codec, SurfaceTextureClientHybris stc);
110 +SurfaceTextureClientHybris gst_amc_codec_get_surface_texture_client (GstAmcCodec * codec);
111 +#else
112-+gboolean gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format, gint flags MAYBE_GERROR);
113+ gboolean gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format, gint flags, GError **err);
114 +#endif
115 +gboolean gst_amc_codec_queue_csd (GstAmcCodec * codec, GstAmcFormat * format);
116-+GstAmcFormat * gst_amc_codec_get_output_format (GstAmcCodec * codec MAYBE_GERROR);
117-+
118-+gboolean gst_amc_codec_start (GstAmcCodec * codec MAYBE_GERROR);
119-+gboolean gst_amc_codec_stop (GstAmcCodec * codec MAYBE_GERROR);
120-+gboolean gst_amc_codec_flush (GstAmcCodec * codec MAYBE_GERROR);
121-+gboolean gst_amc_codec_release (GstAmcCodec * codec MAYBE_GERROR);
122-+
123+ GstAmcFormat * gst_amc_codec_get_output_format (GstAmcCodec * codec, GError **err);
124+
125+ gboolean gst_amc_codec_start (GstAmcCodec * codec, GError **err);
126+@@ -90,18 +166,31 @@ gboolean gst_amc_codec_stop (GstAmcCodec * codec, GError **err);
127+ gboolean gst_amc_codec_flush (GstAmcCodec * codec, GError **err);
128+ gboolean gst_amc_codec_release (GstAmcCodec * codec, GError **err);
129+
130 +#ifdef HAVE_ANDROID_MEDIA_HYBRIS
131 +GstAmcBuffer * gst_amc_codec_get_output_buffers (GstAmcCodec * codec, gsize * n_buffers);
132 +GstAmcBuffer * gst_amc_codec_get_input_buffers (GstAmcCodec * codec, gsize * n_buffers);
133 +#endif
134 +
135-+GstAmcBuffer * gst_amc_codec_get_output_buffer (GstAmcCodec * codec, gint index MAYBE_GERROR);
136-+GstAmcBuffer * gst_amc_codec_get_input_buffer (GstAmcCodec * codec, gint index MAYBE_GERROR);
137+ GstAmcBuffer * gst_amc_codec_get_output_buffer (GstAmcCodec * codec, gint index, GError **err);
138+ GstAmcBuffer * gst_amc_codec_get_input_buffer (GstAmcCodec * codec, gint index, GError **err);
139 +void gst_amc_codec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers);
140-+
141-+gint gst_amc_codec_dequeue_input_buffer (GstAmcCodec * codec, gint64 timeoutUs MAYBE_GERROR);
142-+gint gst_amc_codec_dequeue_output_buffer (GstAmcCodec * codec, GstAmcBufferInfo *info, gint64 timeoutUs MAYBE_GERROR);
143-+
144-+gboolean gst_amc_codec_queue_input_buffer (GstAmcCodec * codec, gint index, const GstAmcBufferInfo *info MAYBE_GERROR);
145+
146+ gint gst_amc_codec_dequeue_input_buffer (GstAmcCodec * codec, gint64 timeoutUs, GError **err);
147+ gint gst_amc_codec_dequeue_output_buffer (GstAmcCodec * codec, GstAmcBufferInfo *info, gint64 timeoutUs, GError **err);
148+
149+ gboolean gst_amc_codec_queue_input_buffer (GstAmcCodec * codec, gint index, const GstAmcBufferInfo *info, GError **err);
150 +#ifdef HAVE_ANDROID_MEDIA_HYBRIS
151-+gboolean gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index, gboolean render);
152++gboolean gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index, gboolean render, GError **err);
153 +#else
154-+gboolean gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index MAYBE_GERROR);
155+ gboolean gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index, GError **err);
156+-
157 +#endif
158-+
159-+GstAmcFormat * gst_amc_format_new_audio (const gchar *mime, gint sample_rate, gint channels MAYBE_GERROR);
160+
161+ GstAmcFormat * gst_amc_format_new_audio (const gchar *mime, gint sample_rate, gint channels, GError **err);
162 +#ifdef HAVE_ANDROID_MEDIA_HYBRIS
163-+GstAmcFormat * gst_amc_format_new_video (const gchar *mime, gint width, gint height, gint buffsize);
164++GstAmcFormat * gst_amc_format_new_video (const gchar *mime, gint width, gint height, gint buffsize, GError **err);
165 +#else
166-+GstAmcFormat * gst_amc_format_new_video (const gchar *mime, gint width, gint height MAYBE_GERROR);
167+ GstAmcFormat * gst_amc_format_new_video (const gchar *mime, gint width, gint height, GError **err);
168 +#endif
169 void gst_amc_format_free (GstAmcFormat * format);
170
171--gchar * gst_amc_format_to_string (GstAmcFormat * format, GError **err);
172-+gchar * gst_amc_format_to_string (GstAmcFormat * format MAYBE_GERROR);
173-+
174-+gboolean gst_amc_format_contains_key (GstAmcFormat *format, const gchar *key MAYBE_GERROR);
175+ gchar * gst_amc_format_to_string (GstAmcFormat * format, GError **err);
176+@@ -117,6 +206,10 @@ gboolean gst_amc_format_set_string (GstAmcFormat *format, const gchar *key, cons
177+ gboolean gst_amc_format_get_buffer (GstAmcFormat *format, const gchar *key, guint8 **data, gsize *size, GError **err);
178+ gboolean gst_amc_format_set_buffer (GstAmcFormat *format, const gchar *key, guint8 *data, gsize size, GError **err);
179
180--gboolean gst_amc_format_contains_key (GstAmcFormat *format, const gchar *key, GError **err);
181-+gboolean gst_amc_format_get_float (GstAmcFormat *format, const gchar *key, gfloat *value MAYBE_GERROR);
182-+gboolean gst_amc_format_set_float (GstAmcFormat *format, const gchar *key, gfloat value MAYBE_GERROR);
183-+gboolean gst_amc_format_get_int (GstAmcFormat *format, const gchar *key, gint *value MAYBE_GERROR);
184-+gboolean gst_amc_format_set_int (GstAmcFormat *format, const gchar *key, gint value MAYBE_GERROR);
185-+gboolean gst_amc_format_get_string (GstAmcFormat *format, const gchar *key, gchar **value MAYBE_GERROR);
186-+gboolean gst_amc_format_set_string (GstAmcFormat *format, const gchar *key, const gchar *value MAYBE_GERROR);
187-+gboolean gst_amc_format_get_buffer (GstAmcFormat *format, const gchar *key, guint8 **data, gsize *size MAYBE_GERROR);
188-+gboolean gst_amc_format_set_buffer (GstAmcFormat *format, const gchar *key, guint8 *data, gsize size MAYBE_GERROR);
189-
190--gboolean gst_amc_format_get_float (GstAmcFormat *format, const gchar *key, gfloat *value, GError **err);
191--gboolean gst_amc_format_set_float (GstAmcFormat *format, const gchar *key, gfloat value, GError **err);
192--gboolean gst_amc_format_get_int (GstAmcFormat *format, const gchar *key, gint *value, GError **err);
193--gboolean gst_amc_format_set_int (GstAmcFormat *format, const gchar *key, gint value, GError **err);
194--gboolean gst_amc_format_get_string (GstAmcFormat *format, const gchar *key, gchar **value, GError **err);
195--gboolean gst_amc_format_set_string (GstAmcFormat *format, const gchar *key, const gchar *value, GError **err);
196--gboolean gst_amc_format_get_buffer (GstAmcFormat *format, const gchar *key, guint8 **data, gsize *size, GError **err);
197--gboolean gst_amc_format_set_buffer (GstAmcFormat *format, const gchar *key, guint8 *data, gsize size, GError **err);
198 +#ifdef HAVE_ANDROID_MEDIA_HYBRIS
199 +void gst_amc_surface_texture_client_set_hardware_rendering (SurfaceTextureClientHybris stc, gboolean hardware_rendering);
200 +#endif
201-
202++
203 GstVideoFormat gst_amc_color_format_to_video_format (const GstAmcCodecInfo * codec_info, const gchar * mime, gint color_format);
204 gint gst_amc_video_format_to_color_format (const GstAmcCodecInfo * codec_info, const gchar * mime, GstVideoFormat video_format);
205+
206 diff --git a/sys/androidmedia/gstamcaudiodec.h b/sys/androidmedia/gstamcaudiodec.h
207 index 04e9734..72d68fc 100644
208 --- a/sys/androidmedia/gstamcaudiodec.h
209@@ -2639,10 +2594,10 @@ index 04e9734..72d68fc 100644
210 };
211 diff --git a/sys/androidmedia/gstamcaudiodechybris.c b/sys/androidmedia/gstamcaudiodechybris.c
212 new file mode 100644
213-index 0000000..fae2930
214+index 0000000..f361418
215 --- /dev/null
216 +++ b/sys/androidmedia/gstamcaudiodechybris.c
217-@@ -0,0 +1,1278 @@
218+@@ -0,0 +1,1291 @@
219 +/*
220 + * Initially based on gst-omx/omx/gstomxvideodec.c
221 + *
222@@ -3011,10 +2966,11 @@ index 0000000..fae2930
223 +{
224 + GstAmcAudioDec *self = GST_AMC_AUDIO_DEC (decoder);
225 + GstAmcAudioDecClass *klass = GST_AMC_AUDIO_DEC_GET_CLASS (self);
226++ GError *err = NULL;
227 +
228 + GST_DEBUG_OBJECT (self, "Opening decoder");
229 +
230-+ self->codec = gst_amc_codec_new (klass->codec_info->name);
231++ self->codec = gst_amc_codec_new (klass->codec_info->name, &err);
232 + if (!self->codec)
233 + return FALSE;
234 + self->started = FALSE;
235@@ -3060,6 +3016,7 @@ index 0000000..fae2930
236 +{
237 + GstAmcAudioDec *self;
238 + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
239++ GError *err = NULL;
240 +
241 + g_return_val_if_fail (GST_IS_AMC_AUDIO_DEC (element),
242 + GST_STATE_CHANGE_FAILURE);
243@@ -3077,7 +3034,7 @@ index 0000000..fae2930
244 + break;
245 + case GST_STATE_CHANGE_PAUSED_TO_READY:
246 + self->flushing = TRUE;
247-+ gst_amc_codec_flush (self->codec);
248++ gst_amc_codec_flush (self->codec, &err);
249 + g_mutex_lock (&self->drain_lock);
250 + self->draining = FALSE;
251 + g_cond_broadcast (&self->drain_cond);
252@@ -3117,9 +3074,10 @@ index 0000000..fae2930
253 + gint rate, channels;
254 + guint32 channel_mask = 0;
255 + GstAudioChannelPosition to[64];
256++ GError *err = NULL;
257 +
258-+ if (!gst_amc_format_get_int (format, "sample-rate", &rate) ||
259-+ !gst_amc_format_get_int (format, "channel-count", &channels)) {
260++ if (!gst_amc_format_get_int (format, "sample-rate", &rate, &err) ||
261++ !gst_amc_format_get_int (format, "channel-count", &channels, &err)) {
262 + GST_ERROR_OBJECT (self, "Failed to get output format metadata");
263 + return FALSE;
264 + }
265@@ -3130,8 +3088,9 @@ index 0000000..fae2930
266 + }
267 +
268 + /* Not always present */
269-+ if (gst_amc_format_contains_key (format, "channel-mask"))
270-+ gst_amc_format_get_int (format, "channel-mask", (gint *) & channel_mask);
271++ if (gst_amc_format_contains_key (format, "channel-mask", NULL))
272++ gst_amc_format_get_int (format, "channel-mask", (gint *) & channel_mask,
273++ NULL);
274 +
275 + gst_amc_audio_channel_mask_to_positions (channel_mask, channels,
276 + self->positions);
277@@ -3164,6 +3123,7 @@ index 0000000..fae2930
278 + gboolean is_eos;
279 + GstAmcBufferInfo buffer_info;
280 + gint idx;
281++ GError *err = NULL;
282 +
283 + GST_AUDIO_DECODER_STREAM_LOCK (self);
284 +
285@@ -3175,7 +3135,9 @@ index 0000000..fae2930
286 + GST_AUDIO_DECODER_STREAM_UNLOCK (self);
287 + /* Wait at most 100ms here, some codecs don't fail dequeueing if
288 + * the codec is flushing, causing deadlocks during shutdown */
289-+ idx = gst_amc_codec_dequeue_output_buffer (self->codec, &buffer_info, 100000);
290++ idx =
291++ gst_amc_codec_dequeue_output_buffer (self->codec, &buffer_info, 100000,
292++ &err);
293 + GST_AUDIO_DECODER_STREAM_LOCK (self);
294 + /*} */
295 +
296@@ -3202,11 +3164,11 @@ index 0000000..fae2930
297 +
298 + GST_DEBUG_OBJECT (self, "Output format has changed");
299 +
300-+ format = gst_amc_codec_get_output_format (self->codec);
301++ format = gst_amc_codec_get_output_format (self->codec, &err);
302 + if (!format)
303 + goto format_error;
304 +
305-+ format_string = gst_amc_format_to_string (format);
306++ format_string = gst_amc_format_to_string (format, &err);
307 + GST_DEBUG_OBJECT (self, "Got new output format: %s", format_string);
308 + g_free (format_string);
309 +
310@@ -3299,7 +3261,7 @@ index 0000000..fae2930
311 + gst_audio_decoder_finish_frame (GST_AUDIO_DECODER (self), outbuf, 1);
312 + }
313 +
314-+ if (!gst_amc_codec_release_output_buffer (self->codec, idx, TRUE))
315++ if (!gst_amc_codec_release_output_buffer (self->codec, idx, TRUE, &err))
316 + goto failed_release;
317 +
318 + if (is_eos || flow_ret == GST_FLOW_EOS) {
319@@ -3440,13 +3402,14 @@ index 0000000..fae2930
320 +gst_amc_audio_dec_stop (GstAudioDecoder * decoder)
321 +{
322 + GstAmcAudioDec *self;
323++ GError *err = NULL;
324 +
325 + self = GST_AMC_AUDIO_DEC (decoder);
326 + GST_DEBUG_OBJECT (self, "Stopping decoder");
327 + self->flushing = TRUE;
328 + if (self->started) {
329-+ gst_amc_codec_flush (self->codec);
330-+ gst_amc_codec_stop (self->codec);
331++ gst_amc_codec_flush (self->codec, &err);
332++ gst_amc_codec_stop (self->codec, &err);
333 + self->started = FALSE;
334 + if (self->input_buffers)
335 + gst_amc_codec_free_buffers (self->input_buffers, self->n_input_buffers);
336@@ -3485,6 +3448,7 @@ index 0000000..fae2930
337 + gboolean needs_disable = FALSE;
338 + gchar *format_string;
339 + gint rate, channels;
340++ GError *err = NULL;
341 +
342 + self = GST_AMC_AUDIO_DEC (decoder);
343 +
344@@ -3540,7 +3504,7 @@ index 0000000..fae2930
345 + return FALSE;
346 + }
347 +
348-+ format = gst_amc_format_new_audio (mime, rate, channels);
349++ format = gst_amc_format_new_audio (mime, rate, channels, &err);
350 + if (!format) {
351 + GST_ERROR_OBJECT (self, "Failed to create audio format");
352 + return FALSE;
353@@ -3559,7 +3523,7 @@ index 0000000..fae2930
354 + gst_buffer_map (codec_data, &minfo, GST_MAP_READ);
355 + data = g_memdup (minfo.data, minfo.size);
356 + self->codec_datas = g_list_prepend (self->codec_datas, data);
357-+ gst_amc_format_set_buffer (format, "csd-0", data, minfo.size);
358++ gst_amc_format_set_buffer (format, "csd-0", data, minfo.size, &err);
359 + gst_buffer_unmap (codec_data, &minfo);
360 + } else if (gst_structure_has_field (s, "streamheader")) {
361 + const GValue *sh = gst_structure_get_value (s, "streamheader");
362@@ -3589,25 +3553,25 @@ index 0000000..fae2930
363 + gst_buffer_map (buf, &minfo, GST_MAP_READ);
364 + data = g_memdup (minfo.data, minfo.size);
365 + self->codec_datas = g_list_prepend (self->codec_datas, data);
366-+ gst_amc_format_set_buffer (format, fname, data, minfo.size);
367++ gst_amc_format_set_buffer (format, fname, data, minfo.size, &err);
368 + gst_buffer_unmap (buf, &minfo);
369 + g_free (fname);
370 + j++;
371 + }
372 + }
373 +
374-+ format_string = gst_amc_format_to_string (format);
375++ format_string = gst_amc_format_to_string (format, &err);
376 + GST_DEBUG_OBJECT (self, "Configuring codec with format: %s", format_string);
377 + g_free (format_string);
378 +
379-+ if (!gst_amc_codec_configure (self->codec, format, NULL, 0)) {
380++ if (!gst_amc_codec_configure (self->codec, format, NULL, 0, &err)) {
381 + GST_ERROR_OBJECT (self, "Failed to configure codec");
382 + return FALSE;
383 + }
384 +
385 + gst_amc_format_free (format);
386 +
387-+ if (!gst_amc_codec_start (self->codec)) {
388++ if (!gst_amc_codec_start (self->codec, &err)) {
389 + GST_ERROR_OBJECT (self, "Failed to start codec");
390 + return FALSE;
391 + }
392@@ -3637,6 +3601,7 @@ index 0000000..fae2930
393 +gst_amc_audio_dec_flush (GstAudioDecoder * decoder, gboolean hard)
394 +{
395 + GstAmcAudioDec *self;
396++ GError *err = NULL;
397 +
398 + self = GST_AMC_AUDIO_DEC (decoder);
399 +
400@@ -3648,7 +3613,7 @@ index 0000000..fae2930
401 + }
402 +
403 + self->flushing = TRUE;
404-+ gst_amc_codec_flush (self->codec);
405++ gst_amc_codec_flush (self->codec, &err);
406 +
407 + /* Wait until the srcpad loop is finished,
408 + * unlock GST_AUDIO_DECODER_STREAM_LOCK to prevent deadlocks
409@@ -3679,6 +3644,7 @@ index 0000000..fae2930
410 + guint offset = 0;
411 + GstClockTime timestamp, duration, timestamp_offset = 0;
412 + GstMapInfo minfo;
413++ GError *err = NULL;
414 +
415 + memset (&minfo, 0, sizeof (minfo));
416 +
417@@ -3727,7 +3693,7 @@ index 0000000..fae2930
418 + GST_AUDIO_DECODER_STREAM_UNLOCK (self);
419 + /* Wait at most 100ms here, some codecs don't fail dequeueing if
420 + * the codec is flushing, causing deadlocks during shutdown */
421-+ idx = gst_amc_codec_dequeue_input_buffer (self->codec, 100000);
422++ idx = gst_amc_codec_dequeue_input_buffer (self->codec, 100000, &err);
423 + GST_AUDIO_DECODER_STREAM_LOCK (self);
424 +
425 + if (idx < 0) {
426@@ -3757,7 +3723,7 @@ index 0000000..fae2930
427 +
428 + if (self->downstream_flow_ret != GST_FLOW_OK) {
429 + memset (&buffer_info, 0, sizeof (buffer_info));
430-+ gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info);
431++ gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info, &err);
432 + goto downstream_error;
433 + }
434 +
435@@ -3797,7 +3763,8 @@ index 0000000..fae2930
436 + "Queueing buffer %d: size %d time %" G_GINT64_FORMAT " flags 0x%08x",
437 + idx, buffer_info.size, buffer_info.presentation_time_us,
438 + buffer_info.flags);
439-+ if (!gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info))
440++ if (!gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info,
441++ &err))
442 + goto queue_error;
443 + }
444 + gst_buffer_unmap (inbuf, &minfo);
445@@ -3861,6 +3828,7 @@ index 0000000..fae2930
446 +{
447 + GstFlowReturn ret;
448 + gint idx;
449++ GError *err = NULL;
450 +
451 + GST_DEBUG_OBJECT (self, "Draining codec");
452 + if (!self->started) {
453@@ -3882,7 +3850,7 @@ index 0000000..fae2930
454 + * class drop the EOS event. We will send it later when
455 + * the EOS buffer arrives on the output port.
456 + * Wait at most 0.5s here. */
457-+ idx = gst_amc_codec_dequeue_input_buffer (self->codec, 500000);
458++ idx = gst_amc_codec_dequeue_input_buffer (self->codec, 500000, &err);
459 + GST_AUDIO_DECODER_STREAM_LOCK (self);
460 +
461 + if (idx >= 0 && idx < self->n_input_buffers) {
462@@ -3898,7 +3866,7 @@ index 0000000..fae2930
463 + gst_util_uint64_scale (self->last_upstream_ts, 1, GST_USECOND);
464 + buffer_info.flags |= BUFFER_FLAG_END_OF_STREAM;
465 +
466-+ if (gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info)) {
467++ if (gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info, &err)) {
468 + GST_DEBUG_OBJECT (self, "Waiting until codec is drained");
469 + g_cond_wait (&self->drain_cond, &self->drain_lock);
470 + GST_DEBUG_OBJECT (self, "Drained codec");
471@@ -3923,14 +3891,14 @@ index 0000000..fae2930
472 +}
473 diff --git a/sys/androidmedia/gstamchybris.c b/sys/androidmedia/gstamchybris.c
474 new file mode 100644
475-index 0000000..16fdacc
476+index 0000000..abc6677
477 --- /dev/null
478 +++ b/sys/androidmedia/gstamchybris.c
479-@@ -0,0 +1,2137 @@
480+@@ -0,0 +1,2182 @@
481 +/*
482 + * Initially based on gstamc.c
483 + *
484-+ * Copyright (C) 2013, Canonical Ltd.
485++ * Copyright (C) 2013-2015, Canonical Ltd.
486 + * Author: Jim Hodapp <jim.hodapp@canonical.com>
487 + *
488 + * This library is free software; you can redistribute it and/or
489@@ -4128,13 +4096,12 @@ index 0000000..16fdacc
490 +#endif
491 +
492 +static gchar *
493-+locale_to_utf8 (gchar * str, gssize len)
494++locale_to_utf8 (gchar * str, gssize len, GError ** err)
495 +{
496-+ GError *error = NULL;
497 + gsize bytes_read = 0, bytes_written = 0;
498 + gchar *out = NULL;
499 +
500-+ out = g_locale_to_utf8 (str, len, &bytes_read, &bytes_written, &error);
501++ out = g_locale_to_utf8 (str, len, &bytes_read, &bytes_written, err);
502 + if (bytes_read == 0)
503 + GST_WARNING ("Zero bytes read for UTF8 string conversion");
504 + if (bytes_written == 0)
505@@ -4143,8 +4110,28 @@ index 0000000..16fdacc
506 + return out;
507 +}
508 +
509++G_GNUC_PRINTF (4, 5)
510++ static void
511++ gst_amc_set_error (GQuark domain, gint code, GError ** err,
512++ const gchar * format, ...)
513++{
514++ gchar *message;
515++ va_list var_args;
516++
517++ if (!err)
518++ return;
519++
520++ va_start (var_args, format);
521++ message = g_strdup_vprintf (format, var_args);
522++ va_end (var_args);
523++
524++ g_set_error (err, domain, code, "%s", message);
525++
526++ g_free (message);
527++}
528++
529 +GstAmcCodec *
530-+gst_amc_codec_new (const gchar * name)
531++gst_amc_codec_new (const gchar * name, GError ** err)
532 +{
533 + GstAmcCodec *codec = NULL;
534 + gchar *name_str = NULL;
535@@ -4156,15 +4143,17 @@ index 0000000..16fdacc
536 + codec = g_slice_new0 (GstAmcCodec);
537 +
538 + name_str = g_strdup (name);
539-+ name_str = locale_to_utf8 (name_str, strlen (name));
540-+ if (name_str == NULL)
541++ name_str = locale_to_utf8 (name_str, strlen (name), err);
542++ if (name_str == NULL) {
543 + goto error;
544++ }
545 + GST_DEBUG ("codec name '%s'", name_str);
546 +
547 + codec->surface_texture_client = NULL;
548 + codec->codec_delegate = media_codec_create_by_codec_name (name_str);
549 + if (codec->codec_delegate == NULL) {
550-+ GST_ERROR ("Failed to create codec '%s'", name_str);
551++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_SETTINGS, err,
552++ "Failed to create codec '%s'", name_str);
553 + goto error;
554 + }
555 +
556@@ -4198,10 +4187,10 @@ index 0000000..16fdacc
557 +
558 +gboolean
559 +gst_amc_codec_configure (GstAmcCodec * codec, GstAmcFormat * format,
560-+ SurfaceTextureClientHybris stc, gint flags)
561++ SurfaceTextureClientHybris stc, gint flags, GError ** err)
562 +{
563 + gboolean ret = TRUE;
564-+ int err = 0;
565++ int res = 0;
566 +
567 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
568 +
569@@ -4221,8 +4210,8 @@ index 0000000..16fdacc
570 + }
571 +
572 + if (i >= MAX_TRIES) {
573-+ GST_ERROR
574-+ ("Failed to get a valid texture id, cannot configure the codec.");
575++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
576++ "Failed to get a valid texture id, cannot configure the codec.");
577 + ret = FALSE;
578 + goto done;
579 + }
580@@ -4262,9 +4251,10 @@ index 0000000..16fdacc
581 + }
582 + }
583 +
584-+ err = media_codec_configure (codec->codec_delegate, format->format, stc, 0);
585-+ if (err > 0) {
586-+ GST_ERROR ("Failed to configure media codec");
587++ res = media_codec_configure (codec->codec_delegate, format->format, stc, 0);
588++ if (res > 0) {
589++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_SETTINGS, err,
590++ "Failed to configure media codec");
591 + ret = FALSE;
592 + goto done;
593 + }
594@@ -4321,7 +4311,7 @@ index 0000000..16fdacc
595 +}
596 +
597 +GstAmcFormat *
598-+gst_amc_codec_get_output_format (GstAmcCodec * codec)
599++gst_amc_codec_get_output_format (GstAmcCodec * codec, GError ** err)
600 +{
601 + GstAmcFormat *ret = NULL;
602 +
603@@ -4333,7 +4323,8 @@ index 0000000..16fdacc
604 +
605 + ret->format = media_codec_get_output_format (codec->codec_delegate);
606 + if (ret->format == NULL) {
607-+ GST_ERROR ("Failed to get output format");
608++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_SETTINGS, err,
609++ "Failed to get output format");
610 + g_slice_free (GstAmcFormat, ret);
611 + ret = NULL;
612 + goto done;
613@@ -4345,18 +4336,19 @@ index 0000000..16fdacc
614 +}
615 +
616 +gboolean
617-+gst_amc_codec_start (GstAmcCodec * codec)
618++gst_amc_codec_start (GstAmcCodec * codec, GError ** err)
619 +{
620 + gboolean ret = TRUE;
621-+ int err = 0;
622++ int res = 0;
623 +
624 + g_return_val_if_fail (codec != NULL, FALSE);
625 +
626 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
627 +
628-+ err = media_codec_start (codec->codec_delegate);
629-+ if (err > 0) {
630-+ GST_ERROR ("Failed to start media codec");
631++ res = media_codec_start (codec->codec_delegate);
632++ if (res > 0) {
633++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
634++ "Failed to get start media codec");
635 + ret = FALSE;
636 + goto done;
637 + }
638@@ -4366,18 +4358,19 @@ index 0000000..16fdacc
639 +}
640 +
641 +gboolean
642-+gst_amc_codec_stop (GstAmcCodec * codec)
643++gst_amc_codec_stop (GstAmcCodec * codec, GError ** err)
644 +{
645 + gboolean ret = TRUE;
646-+ int err = 0;
647++ int res = 0;
648 +
649 + g_return_val_if_fail (codec != NULL, FALSE);
650 +
651 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
652 +
653-+ err = media_codec_stop (codec->codec_delegate);
654-+ if (err > 0) {
655-+ GST_ERROR ("Failed to start media codec");
656++ res = media_codec_stop (codec->codec_delegate);
657++ if (res > 0) {
658++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
659++ "Failed to stop media codec");
660 + ret = FALSE;
661 + goto done;
662 + }
663@@ -4396,18 +4389,19 @@ index 0000000..16fdacc
664 +}
665 +
666 +gboolean
667-+gst_amc_codec_flush (GstAmcCodec * codec)
668++gst_amc_codec_flush (GstAmcCodec * codec, GError ** err)
669 +{
670 + gboolean ret = TRUE;
671-+ gint err = 0;
672++ gint res = 0;
673 +
674 + g_return_val_if_fail (codec != NULL, FALSE);
675 +
676 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
677 +
678-+ err = media_codec_flush (codec->codec_delegate);
679-+ if (err < 0) {
680-+ GST_ERROR ("Failed to flush the media codec (err: %d)", err);
681++ res = media_codec_flush (codec->codec_delegate);
682++ if (res < 0) {
683++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
684++ "Failed to flush the media codec (res: %d)", res);
685 + ret = FALSE;
686 + goto done;
687 + }
688@@ -4417,18 +4411,19 @@ index 0000000..16fdacc
689 +}
690 +
691 +gboolean
692-+gst_amc_codec_release (GstAmcCodec * codec)
693++gst_amc_codec_release (GstAmcCodec * codec, GError ** err)
694 +{
695 + gboolean ret = TRUE;
696-+ gint err = 0;
697++ gint res = 0;
698 +
699 + g_return_val_if_fail (codec != NULL, FALSE);
700 +
701 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
702 +
703-+ err = media_codec_release (codec->codec_delegate);
704-+ if (err < 0) {
705-+ GST_ERROR ("Failed to release media codec (err: %d)", err);
706++ res = media_codec_release (codec->codec_delegate);
707++ if (res < 0) {
708++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
709++ "Failed to release media codec (res: %d)", res);
710 + ret = FALSE;
711 + goto done;
712 + }
713@@ -4487,7 +4482,7 @@ index 0000000..16fdacc
714 +}
715 +
716 +GstAmcBuffer *
717-+gst_amc_codec_get_output_buffer (GstAmcCodec * codec, gint index)
718++gst_amc_codec_get_output_buffer (GstAmcCodec * codec, gint index, GError ** err)
719 +{
720 + GstAmcBuffer *ret = NULL;
721 +
722@@ -4555,7 +4550,7 @@ index 0000000..16fdacc
723 +}
724 +
725 +GstAmcBuffer *
726-+gst_amc_codec_get_input_buffer (GstAmcCodec * codec, gint index)
727++gst_amc_codec_get_input_buffer (GstAmcCodec * codec, gint index, GError ** err)
728 +{
729 + GstAmcBuffer *ret = NULL;
730 +
731@@ -4566,7 +4561,8 @@ index 0000000..16fdacc
732 +
733 + ret->data = media_codec_get_nth_input_buffer (codec->codec_delegate, index);
734 + if (!ret->data) {
735-+ GST_ERROR ("Failed to get input buffer address %d", index);
736++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
737++ "Failed to get input buffer address %d", index);
738 + goto error;
739 + }
740 +
741@@ -4583,7 +4579,8 @@ index 0000000..16fdacc
742 +}
743 +
744 +gint
745-+gst_amc_codec_dequeue_input_buffer (GstAmcCodec * codec, gint64 timeoutUs)
746++gst_amc_codec_dequeue_input_buffer (GstAmcCodec * codec, gint64 timeoutUs,
747++ GError ** err)
748 +{
749 + gint ret = G_MININT;
750 + size_t index = 0;
751@@ -4594,11 +4591,17 @@ index 0000000..16fdacc
752 +
753 + ret =
754 + media_codec_dequeue_input_buffer (codec->codec_delegate, &index,
755-+ timeoutUs);
756++ timeoutUs);
757 + if (ret < 0) {
758 + GST_DEBUG ("Failed to dequeue input buffer (ret: %d)", ret);
759-+ if (ret == -11)
760++ if (ret == -11) {
761 + ret = INFO_TRY_AGAIN_LATER;
762++ }
763++ if (ret != INFO_TRY_AGAIN_LATER) {
764++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
765++ "Failed to dequeue input buffer (ret: %d)", ret);
766++ ret = G_MININT;
767++ }
768 + goto done;
769 + }
770 + ret = index;
771@@ -4611,7 +4614,7 @@ index 0000000..16fdacc
772 +
773 +gint
774 +gst_amc_codec_dequeue_output_buffer (GstAmcCodec * codec,
775-+ GstAmcBufferInfo * info, gint64 timeoutUs)
776++ GstAmcBufferInfo * info, gint64 timeoutUs, GError ** err)
777 +{
778 + gint ret = G_MININT;
779 + MediaCodecBufferInfo priv_info;
780@@ -4637,6 +4640,10 @@ index 0000000..16fdacc
781 + } else if (ret == INFO_OUTPUT_BUFFERS_CHANGED) {
782 + GST_INFO ("Output buffers have changed");
783 + goto done;
784++ } else if (ret < 0) {
785++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
786++ "Failed to dequeue output buffer (ret: %d)", ret);
787++ ret = G_MININT;
788 + }
789 +
790 + info->flags = priv_info.flags;
791@@ -4655,10 +4662,10 @@ index 0000000..16fdacc
792 +
793 +gboolean
794 +gst_amc_codec_queue_input_buffer (GstAmcCodec * codec, gint index,
795-+ const GstAmcBufferInfo * info)
796++ const GstAmcBufferInfo * info, GError ** err)
797 +{
798 + gboolean ret = TRUE;
799-+ gint err = 0;
800++ gint res = 0;
801 + MediaCodecBufferInfo buf_info;
802 +
803 + g_return_val_if_fail (codec != NULL, FALSE);
804@@ -4678,9 +4685,10 @@ index 0000000..16fdacc
805 + buf_info.presentation_time_us);
806 + GST_DEBUG ("buf_info.flags %d", buf_info.flags);
807 +
808-+ err = media_codec_queue_input_buffer (codec->codec_delegate, &buf_info);
809-+ if (err < 0) {
810-+ GST_ERROR ("Failed to queue input buffer (err: %d, index: %d)", err, index);
811++ res = media_codec_queue_input_buffer (codec->codec_delegate, &buf_info);
812++ if (res < 0) {
813++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
814++ "Failed to queue input buffer (res: %d, index: %d)", res, index);
815 + ret = FALSE;
816 + goto done;
817 + }
818@@ -4691,20 +4699,20 @@ index 0000000..16fdacc
819 +
820 +gboolean
821 +gst_amc_codec_release_output_buffer (GstAmcCodec * codec, gint index,
822-+ gboolean render)
823++ gboolean render, GError ** err)
824 +{
825 + gboolean ret = TRUE;
826-+ gint err = 0;
827++ gint res = 0;
828 +
829 + g_return_val_if_fail (codec != NULL, FALSE);
830 +
831 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
832 +
833-+ err =
834++ res =
835 + media_codec_release_output_buffer (codec->codec_delegate, index, render);
836-+ if (err < 0) {
837-+ GST_ERROR ("Failed to release output buffer (err: %d, index: %d)", err,
838-+ index);
839++ if (res < 0) {
840++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
841++ "Failed to release output buffer (res: %d, index: %d)", res, index);
842 + ret = FALSE;
843 + goto done;
844 + }
845@@ -4714,7 +4722,8 @@ index 0000000..16fdacc
846 +}
847 +
848 +GstAmcFormat *
849-+gst_amc_format_new_audio (const gchar * mime, gint sample_rate, gint channels)
850++gst_amc_format_new_audio (const gchar * mime, gint sample_rate, gint channels,
851++ GError ** err)
852 +{
853 +#if 0
854 + JNIEnv *env;
855@@ -4772,7 +4781,7 @@ index 0000000..16fdacc
856 +
857 +GstAmcFormat *
858 +gst_amc_format_new_video (const gchar * mime, gint width, gint height,
859-+ gint buffsize)
860++ gint buffsize, GError ** err)
861 +{
862 + GstAmcFormat *format = NULL;
863 + gchar *mime_str = NULL;
864@@ -4782,7 +4791,7 @@ index 0000000..16fdacc
865 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
866 +
867 + mime_str = g_strdup (mime);
868-+ mime_str = locale_to_utf8 (mime_str, strlen (mime_str));
869++ mime_str = locale_to_utf8 (mime_str, strlen (mime_str), err);
870 + if (mime_str == NULL)
871 + goto error;
872 +
873@@ -4791,7 +4800,8 @@ index 0000000..16fdacc
874 + format->format =
875 + media_format_create_video_format (mime_str, width, height, 0, buffsize);
876 + if (format->format == NULL) {
877-+ GST_ERROR ("Failed to create format '%s'", mime);
878++ gst_amc_set_error (GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, err,
879++ "Failed to create format '%s'", mime);
880 + goto error;
881 + }
882 +
883@@ -4821,67 +4831,70 @@ index 0000000..16fdacc
884 +}
885 +
886 +gchar *
887-+gst_amc_format_to_string (GstAmcFormat * format)
888++gst_amc_format_to_string (GstAmcFormat * format, GError ** err)
889 +{
890 + return NULL;
891 +}
892 +
893 +gboolean
894-+gst_amc_format_contains_key (GstAmcFormat * format, const gchar * key)
895++gst_amc_format_contains_key (GstAmcFormat * format, const gchar * key,
896++ GError ** err)
897 +{
898 + return FALSE;
899 +}
900 +
901 +gboolean
902 +gst_amc_format_get_float (GstAmcFormat * format, const gchar * key,
903-+ gfloat * value)
904++ gfloat * value, GError ** err)
905 +{
906 + return FALSE;
907 +}
908 +
909 +gboolean
910 +gst_amc_format_set_float (GstAmcFormat * format, const gchar * key,
911-+ gfloat value)
912++ gfloat value, GError ** err)
913 +{
914 + return FALSE;
915 +}
916 +
917 +gboolean
918-+gst_amc_format_get_int (GstAmcFormat * format, const gchar * key, gint * value)
919++gst_amc_format_get_int (GstAmcFormat * format, const gchar * key, gint * value,
920++ GError ** err)
921 +{
922 + return FALSE;
923 +}
924 +
925 +gboolean
926-+gst_amc_format_set_int (GstAmcFormat * format, const gchar * key, gint value)
927++gst_amc_format_set_int (GstAmcFormat * format, const gchar * key, gint value,
928++ GError ** err)
929 +{
930 + return FALSE;
931 +}
932 +
933 +gboolean
934 +gst_amc_format_get_string (GstAmcFormat * format, const gchar * key,
935-+ gchar ** value)
936++ gchar ** value, GError ** err)
937 +{
938 + return FALSE;
939 +}
940 +
941 +gboolean
942 +gst_amc_format_set_string (GstAmcFormat * format, const gchar * key,
943-+ const gchar * value)
944++ const gchar * value, GError ** err)
945 +{
946 + return FALSE;
947 +}
948 +
949 +gboolean
950 +gst_amc_format_get_buffer (GstAmcFormat * format, const gchar * key,
951-+ guint8 ** data, gsize * size)
952++ guint8 ** data, gsize * size, GError ** err)
953 +{
954 + return FALSE;
955 +}
956 +
957 +gboolean
958 +gst_amc_format_set_buffer (GstAmcFormat * format, const gchar * key,
959-+ guint8 * data, gsize size)
960++ guint8 * data, gsize size, GError ** err)
961 +{
962 + gchar *key_str = NULL;
963 + gboolean ret = FALSE;
964@@ -4893,7 +4906,7 @@ index 0000000..16fdacc
965 + GST_DEBUG ("%s", __PRETTY_FUNCTION__);
966 +
967 + key_str = g_strdup (key);
968-+ key_str = locale_to_utf8 (key_str, strlen (key));
969++ key_str = locale_to_utf8 (key_str, strlen (key), err);
970 + if (!key_str)
971 + goto done;
972 +
973@@ -5121,7 +5134,7 @@ index 0000000..16fdacc
974 + }
975 +
976 + mime = g_malloc (len);
977-+ mime = locale_to_utf8 (supported_type_str, len);
978++ mime = locale_to_utf8 (supported_type_str, len, NULL);
979 + if (!mime) {
980 + GST_ERROR ("Failed to convert supported type to UTF8");
981 + valid_codec = FALSE;
982@@ -6134,10 +6147,10 @@ index c6c2b4f..53fdb27 100644
983 struct _GstAmcVideoDecClass
984 diff --git a/sys/androidmedia/gstamcvideodechybris.c b/sys/androidmedia/gstamcvideodechybris.c
985 new file mode 100644
986-index 0000000..49a0203
987+index 0000000..cff94c4
988 --- /dev/null
989 +++ b/sys/androidmedia/gstamcvideodechybris.c
990-@@ -0,0 +1,2327 @@
991+@@ -0,0 +1,2399 @@
992 +/*
993 + * Initially based on gstamcvideodec.c
994 + *
995@@ -6192,6 +6205,16 @@ index 0000000..49a0203
996 +GST_DEBUG_CATEGORY_STATIC (gst_amc_video_dec_debug_category);
997 +#define GST_CAT_DEFAULT gst_amc_video_dec_debug_category
998 +
999++#define GST_VIDEO_DECODER_ERROR_FROM_ERROR(el, err) G_STMT_START { \
1000++ gchar *__dbg = g_strdup (err->message); \
1001++ GstVideoDecoder *__dec = GST_VIDEO_DECODER (el); \
1002++ GST_WARNING_OBJECT (el, "error: %s", __dbg); \
1003++ _gst_video_decoder_error (__dec, 1, \
1004++ err->domain, err->code, \
1005++ NULL, __dbg, __FILE__, GST_FUNCTION, __LINE__); \
1006++ g_clear_error (&err); \
1007++} G_STMT_END
1008++
1009 +#define WAIT_FOR_SRC_CAPS_MS 100
1010 +#define DEC_ALIGNMENT_BYTES 4096
1011 +
1012@@ -6651,12 +6674,13 @@ index 0000000..49a0203
1013 +{
1014 + GstAmcVideoDec *self = GST_AMC_VIDEO_DEC (decoder);
1015 + GstAmcVideoDecClass *klass = GST_AMC_VIDEO_DEC_GET_CLASS (self);
1016++ GError *err = NULL;
1017 +
1018 + GST_DEBUG_OBJECT (self, "Opening hardware decoder");
1019 +
1020-+ self->codec = gst_amc_codec_new (klass->codec_info->name);
1021++ self->codec = gst_amc_codec_new (klass->codec_info->name, &err);
1022 + if (!self->codec) {
1023-+ GST_WARNING_OBJECT (self, "Failed to get valid hardware decoder");
1024++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1025 + return FALSE;
1026 + }
1027 + self->started = FALSE;
1028@@ -6705,6 +6729,7 @@ index 0000000..49a0203
1029 +{
1030 + GstAmcVideoDec *self;
1031 + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1032++ GError *err = NULL;
1033 +
1034 + g_return_val_if_fail (GST_IS_AMC_VIDEO_DEC (element),
1035 + GST_STATE_CHANGE_FAILURE);
1036@@ -6723,7 +6748,9 @@ index 0000000..49a0203
1037 + case GST_STATE_CHANGE_PAUSED_TO_READY:
1038 + GST_VIDEO_DECODER_STREAM_LOCK(self);
1039 + self->flushing = TRUE;
1040-+ gst_amc_codec_flush (self->codec);
1041++ gst_amc_codec_flush (self->codec, &err);
1042++ if (err)
1043++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1044 + GST_VIDEO_DECODER_STREAM_UNLOCK(self);
1045 +
1046 + g_mutex_lock (&self->drain_lock);
1047@@ -7445,6 +7472,7 @@ index 0000000..49a0203
1048 + SurfaceTextureClientHybris surface_texture_client = NULL;
1049 + guint8 i = 0;
1050 + const guint8 MAX_TRIES = 3;
1051++ GError *err = NULL;
1052 +
1053 + GST_DEBUG_OBJECT (self, "%s", __PRETTY_FUNCTION__);
1054 +
1055@@ -7475,13 +7503,16 @@ index 0000000..49a0203
1056 + GST_INFO_OBJECT (self, "surface_texture_client: %p", surface_texture_client);
1057 +
1058 + /* Configure the hardware decoder */
1059-+ if (!gst_amc_codec_configure (self->codec, format, surface_texture_client, 0)) {
1060++ if (!gst_amc_codec_configure (self->codec, format,
1061++ surface_texture_client, 0, &err)) {
1062 + GST_ERROR_OBJECT (self, "Failed to configure codec");
1063++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1064 + return FALSE;
1065 + }
1066 +
1067-+ if (!gst_amc_codec_start (self->codec)) {
1068++ if (!gst_amc_codec_start (self->codec, &err)) {
1069 + GST_ERROR_OBJECT (self, "Failed to start codec");
1070++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1071 + return FALSE;
1072 + }
1073 +
1074@@ -7516,6 +7547,7 @@ index 0000000..49a0203
1075 + GstAmcBufferInfo buffer_info;
1076 + gint idx;
1077 + GstVideoDecoder *decoder = GST_VIDEO_DECODER (self);
1078++ GError *err = NULL;
1079 +
1080 + GST_VIDEO_DECODER_STREAM_LOCK (self);
1081 +
1082@@ -7530,14 +7562,16 @@ index 0000000..49a0203
1083 + * the codec is flushing, causing deadlocks during shutdown */
1084 + idx =
1085 + gst_amc_codec_dequeue_output_buffer (self->codec, &buffer_info,
1086-+ self->current_timeout);
1087++ self->current_timeout, &err);
1088 + GST_PAD_STREAM_LOCK (GST_VIDEO_DECODER_SRC_PAD (decoder));
1089 + GST_VIDEO_DECODER_STREAM_LOCK (self);
1090 +
1091 + GST_DEBUG_OBJECT (self, "Tried to dequeue output buffer (idx: %d)", idx);
1092 + if (idx < 0) {
1093-+ if (self->flushing || self->downstream_flow_ret == GST_FLOW_FLUSHING)
1094++ if (self->flushing || self->downstream_flow_ret == GST_FLOW_FLUSHING) {
1095++ g_clear_error (&err);
1096 + goto flushing;
1097++ }
1098 +
1099 + switch (idx) {
1100 + case INFO_OUTPUT_BUFFERS_CHANGED:{
1101@@ -7564,7 +7598,7 @@ index 0000000..49a0203
1102 +
1103 + GST_INFO_OBJECT (self, "Output format has changed");
1104 +
1105-+ format = gst_amc_codec_get_output_format (self->codec);
1106++ format = gst_amc_codec_get_output_format (self->codec, &err);
1107 + if (!format)
1108 + goto format_error;
1109 +
1110@@ -7640,8 +7674,13 @@ index 0000000..49a0203
1111 + GST_TIME_ARGS (-deadline));
1112 + flow_ret = gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
1113 +
1114-+ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE))
1115++ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE, &err)) {
1116 + GST_ERROR_OBJECT (self, "Failed to release output buffer index %d", idx);
1117++ if (err && !self->flushing)
1118++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1119++ g_clear_error (&err);
1120++ }
1121++
1122 + } else if (!frame && buffer_info.size > 0) {
1123 + GstBuffer *outbuf;
1124 +
1125@@ -7656,9 +7695,13 @@ index 0000000..49a0203
1126 +
1127 + if (!gst_amc_video_dec_fill_buffer (self, idx, &buffer_info, outbuf)) {
1128 + gst_buffer_unref (outbuf);
1129-+ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE))
1130++ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE, &err)) {
1131 + GST_ERROR_OBJECT (self, "Failed to release output buffer index %d",
1132 + idx);
1133++ if (err && !self->flushing)
1134++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1135++ g_clear_error (&err);
1136++ }
1137 + goto invalid_buffer;
1138 + }
1139 +
1140@@ -7682,9 +7725,13 @@ index 0000000..49a0203
1141 + GST_ERROR_OBJECT (self, "Cannot fill output buffer index %d", idx);
1142 + gst_buffer_replace (&frame->output_buffer, NULL);
1143 + gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
1144-+ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE))
1145++ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE, &err)) {
1146 + GST_ERROR_OBJECT (self, "Failed to release output buffer index %d",
1147 + idx);
1148++ if (err && !self->flushing)
1149++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1150++ g_clear_error (&err);
1151++ }
1152 + goto invalid_buffer;
1153 + }
1154 +
1155@@ -7694,8 +7741,12 @@ index 0000000..49a0203
1156 + GST_ERROR_OBJECT (self, "Dropping frame");
1157 + flow_ret = gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
1158 +
1159-+ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE))
1160++ if (!gst_amc_codec_release_output_buffer (self->codec, idx, FALSE, &err)) {
1161 + GST_ERROR_OBJECT (self, "Failed to release output buffer index %d", idx);
1162++ if (err && !self->flushing)
1163++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1164++ g_clear_error (&err);
1165++ }
1166 + } else {
1167 + GST_ERROR_OBJECT (self, "Unexpected condition output buffer index %d", idx);
1168 + }
1169@@ -7730,6 +7781,7 @@ index 0000000..49a0203
1170 +
1171 +dequeue_error:
1172 + {
1173++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1174 + GST_ERROR_OBJECT (self, "dec_loop, dequeue_error");
1175 + GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1176 + ("Failed to dequeue output buffer"));
1177@@ -7752,9 +7804,11 @@ index 0000000..49a0203
1178 + }
1179 +format_error:
1180 + {
1181-+ GST_ERROR_OBJECT (self, "dec_loop, format_error");
1182-+ GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1183-+ ("Failed to handle format"));
1184++ if (err)
1185++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1186++ else
1187++ GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1188++ ("Failed to handle format"));
1189 + gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (self), gst_event_new_eos ());
1190 + gst_pad_pause_task (GST_VIDEO_DECODER_SRC_PAD (self));
1191 + self->downstream_flow_ret = GST_FLOW_ERROR;
1192@@ -7830,13 +7884,18 @@ index 0000000..49a0203
1193 +gst_amc_video_dec_stop (GstVideoDecoder * decoder)
1194 +{
1195 + GstAmcVideoDec *self;
1196++ GError *err = NULL;
1197 +
1198 + self = GST_AMC_VIDEO_DEC (decoder);
1199 + GST_DEBUG_OBJECT (self, "Stopping decoder");
1200 + self->flushing = TRUE;
1201 + if (self->started) {
1202-+ gst_amc_codec_flush (self->codec);
1203-+ gst_amc_codec_stop (self->codec);
1204++ gst_amc_codec_flush (self->codec, &err);
1205++ if (err)
1206++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1207++ gst_amc_codec_stop (self->codec, &err);
1208++ if (err)
1209++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1210 + self->started = FALSE;
1211 + if (self->input_buffers)
1212 + gst_amc_codec_free_buffers (self->input_buffers, self->n_input_buffers);
1213@@ -7877,6 +7936,7 @@ index 0000000..49a0203
1214 + guint8 *codec_data = NULL;
1215 + gsize codec_data_size = 0;
1216 + int buffsize;
1217++ GError *err = NULL;
1218 +
1219 + self = GST_AMC_VIDEO_DEC (decoder);
1220 +
1221@@ -7964,16 +8024,20 @@ index 0000000..49a0203
1222 + state->info.width, state->info.height, buffsize);
1223 + format =
1224 + gst_amc_format_new_video (mime, state->info.width, state->info.height,
1225-+ buffsize);
1226++ buffsize, &err);
1227 + if (!format) {
1228 + GST_ERROR_OBJECT (self, "Failed to create video format");
1229++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1230 + return FALSE;
1231 + }
1232 +
1233 + /* FIXME: This buffer needs to be valid until the codec is stopped again */
1234-+ if (self->codec_data)
1235++ if (self->codec_data) {
1236 + gst_amc_format_set_buffer (format, "csd-0", self->codec_data,
1237-+ self->codec_data_size);
1238++ self->codec_data_size, &err);
1239++ if (err)
1240++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1241++ }
1242 +
1243 + /* Configure the hardware codec with format */
1244 + ret = gst_amc_video_dec_configure_self (decoder, format);
1245@@ -8009,6 +8073,7 @@ index 0000000..49a0203
1246 +gst_amc_video_dec_flush (GstVideoDecoder * decoder)
1247 +{
1248 + GstAmcVideoDec *self;
1249++ GError *err = NULL;
1250 +
1251 + self = GST_AMC_VIDEO_DEC (decoder);
1252 +
1253@@ -8020,7 +8085,9 @@ index 0000000..49a0203
1254 + }
1255 +
1256 + self->flushing = TRUE;
1257-+ gst_amc_codec_flush (self->codec);
1258++ gst_amc_codec_flush (self->codec, &err);
1259++ if (err)
1260++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1261 +
1262 + /* Wait until the srcpad loop is finished,
1263 + * unlock GST_VIDEO_DECODER_STREAM_LOCK to prevent deadlocks
1264@@ -8096,6 +8163,7 @@ index 0000000..49a0203
1265 + GstClockTime timestamp, duration, timestamp_offset = 0;
1266 + GstMapInfo minfo;
1267 + gboolean first_buff = TRUE;
1268++ GError *err = NULL;
1269 +
1270 + memset (&minfo, 0, sizeof (minfo));
1271 +
1272@@ -8142,14 +8210,16 @@ index 0000000..49a0203
1273 + /* Wait at most 100ms here, some codecs don't fail dequeueing if
1274 + * the codec is flushing, causing deadlocks during shutdown */
1275 + idx =
1276-+ gst_amc_codec_dequeue_input_buffer (self->codec, wait_buff_us);
1277++ gst_amc_codec_dequeue_input_buffer (self->codec, wait_buff_us, &err);
1278 + GST_PAD_STREAM_LOCK (GST_VIDEO_DECODER_SINK_PAD (decoder));
1279 + GST_VIDEO_DECODER_STREAM_LOCK (self);
1280 +
1281 + GST_DEBUG_OBJECT (self, "Tried to dequeue input buffer idx: %d", idx);
1282 + if (idx < 0) {
1283-+ if (self->flushing)
1284++ if (self->flushing) {
1285++ g_clear_error (&err);
1286 + goto flushing;
1287++ }
1288 + switch (idx) {
1289 + case INFO_TRY_AGAIN_LATER:
1290 + GST_DEBUG_OBJECT (self, "Dequeueing input buffer timed out");
1291@@ -8195,7 +8265,10 @@ index 0000000..49a0203
1292 +
1293 + if (self->downstream_flow_ret != GST_FLOW_OK) {
1294 + memset (&buffer_info, 0, sizeof (buffer_info));
1295-+ gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info);
1296++ gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info, &err);
1297++ if (err && !self->flushing)
1298++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1299++ g_clear_error (&err);
1300 + goto downstream_error;
1301 + }
1302 +
1303@@ -8239,8 +8312,14 @@ index 0000000..49a0203
1304 + "Queueing buffer %d: size %d time %" G_GINT64_FORMAT " flags 0x%08x",
1305 + idx, buffer_info.size, buffer_info.presentation_time_us,
1306 + buffer_info.flags);
1307-+ if (!gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info))
1308++ if (!gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info,
1309++ &err)) {
1310++ if (self->flushing) {
1311++ g_clear_error (&err);
1312++ goto flushing;
1313++ }
1314 + goto queue_error;
1315++ }
1316 +
1317 + first_buff = FALSE;
1318 + }
1319@@ -8280,9 +8359,7 @@ index 0000000..49a0203
1320 + }
1321 +dequeue_error:
1322 + {
1323-+ GST_ERROR_OBJECT (self, "handle_frame, dequeue_error");
1324-+ GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1325-+ ("Failed to dequeue input buffer"));
1326++ GST_ELEMENT_ERROR_FROM_ERROR (self, err);
1327 + if (minfo.data)
1328 + gst_buffer_unmap (frame->input_buffer, &minfo);
1329 + gst_video_codec_frame_unref (frame);
1330@@ -8290,9 +8367,7 @@ index 0000000..49a0203
1331 + }
1332 +queue_error:
1333 + {
1334-+ GST_ERROR_OBJECT (self, "handle_frame, queue_error");
1335-+ GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1336-+ ("Failed to queue input buffer"));
1337++ GST_VIDEO_DECODER_ERROR_FROM_ERROR (self, err);
1338 + if (minfo.data)
1339 + gst_buffer_unmap (frame->input_buffer, &minfo);
1340 + gst_video_codec_frame_unref (frame);
1341@@ -8323,6 +8398,7 @@ index 0000000..49a0203
1342 +{
1343 + GstFlowReturn ret;
1344 + gint idx;
1345++ GError *err = NULL;
1346 +
1347 + GST_DEBUG_OBJECT (self, "Draining codec");
1348 + if (!self->started) {
1349@@ -8346,7 +8422,8 @@ index 0000000..49a0203
1350 + * class drop the EOS event. We will send it later when
1351 + * the EOS buffer arrives on the output port.
1352 + * Wait at most 0.5s here. */
1353-+ idx = gst_amc_codec_dequeue_input_buffer (self->codec, self->current_timeout);
1354++ idx = gst_amc_codec_dequeue_input_buffer (self->codec, self->current_timeout,
1355++ &err);
1356 + GST_DEBUG_OBJECT (self, "dequeued input buffer with idx: %d", idx);
1357 + GST_VIDEO_DECODER_STREAM_LOCK (self);
1358 +
1359@@ -8363,13 +8440,14 @@ index 0000000..49a0203
1360 + gst_util_uint64_scale (self->last_upstream_ts, 1, GST_USECOND);
1361 + buffer_info.flags |= BUFFER_FLAG_END_OF_STREAM;
1362 +
1363-+ if (gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info)) {
1364++ if (gst_amc_codec_queue_input_buffer (self->codec, idx, &buffer_info, &err)) {
1365 + GST_DEBUG_OBJECT (self, "Waiting until codec is drained");
1366 + g_cond_wait (&self->drain_cond, &self->drain_lock);
1367 + GST_DEBUG_OBJECT (self, "Drained codec");
1368 + ret = GST_FLOW_OK;
1369 + } else {
1370 + GST_ERROR_OBJECT (self, "Failed to queue input buffer");
1371++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1372 + ret = GST_FLOW_ERROR;
1373 + }
1374 +
1375@@ -8381,6 +8459,8 @@ index 0000000..49a0203
1376 + ret = GST_FLOW_ERROR;
1377 + } else {
1378 + GST_ERROR_OBJECT (self, "Failed to acquire buffer for EOS: %d", idx);
1379++ if (err)
1380++ GST_ELEMENT_WARNING_FROM_ERROR (self, err);
1381 + ret = GST_FLOW_ERROR;
1382 + }
1383 +
1384@@ -8395,6 +8475,11 @@ index 0000000..49a0203
1385 +
1386 + GST_DEBUG_OBJECT (element, "%s", __PRETTY_FUNCTION__);
1387 +
1388++ if (self->codec == NULL) {
1389++ GST_WARNING_OBJECT (self, "codec not set yet");
1390++ return;
1391++ }
1392++
1393 + stc = gst_context_get_surface_texture_client (context);
1394 + if (!stc)
1395 + GST_ERROR_OBJECT (self,

Subscribers

People subscribed via source and target branches