Added internal API for static loading ini when binding c# API
[platform/core/api/mediacodec.git] / src / media_codec.c
1 /*
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <media_codec.h>
21 #include <media_codec_private.h>
22 #include <media_codec_port.h>
23 #include <system_info.h>
24
25 #include <dlog.h>
26
27 static gboolean  __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data);
28 static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data);
29 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data);
30 static gboolean __mediacodec_eos_cb(void *user_data);
31 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data);
32 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data);
33
34 /*
35  * Internal Implementation
36  */
37 int __convert_error_code(int code, char *func_name)
38 {
39         int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
40         char *msg = "MEDIACOODEC_INVALID_OPERATION";
41
42         switch (code) {
43         case MC_ERROR_NONE:
44                 ret = MEDIACODEC_ERROR_NONE;
45                 msg = "MEDIACODEC_ERROR_NONE";
46                 break;
47         case MC_PARAM_ERROR:
48         case MC_INVALID_ARG:
49                 ret = MEDIACODEC_ERROR_INVALID_PARAMETER;
50                 msg = "MEDIACODEC_ERROR_INVALID_PARAMETER";
51                 break;
52         case MC_PERMISSION_DENIED:
53                 ret = MEDIACODEC_ERROR_PERMISSION_DENIED;
54                 msg = "MEDIACODEC_ERROR_PERMISSION_DENIED";
55                 break;
56         case MC_INVALID_STATUS:
57                 ret = MEDIACODEC_ERROR_INVALID_STATE;
58                 msg = "MEDIACODEC_ERROR_INVALID_STATE";
59                 break;
60         case MC_NOT_SUPPORTED:
61                 ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
62                 msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE";
63                 break;
64         case MC_ERROR:
65         case MC_INTERNAL_ERROR:
66         case MC_HW_ERROR:
67                 ret = MEDIACODEC_ERROR_INVALID_OPERATION;
68                 msg = "MEDIACODEC_ERROR_INVALID_OPERATION";
69                 break;
70         case MC_INVALID_STREAM:
71                 ret = MEDIACODEC_ERROR_INVALID_STREAM;
72                 msg = "MEDIACODEC_ERROR_INVALID_STREAM";
73                 break;
74         case MC_CODEC_NOT_FOUND:
75                 ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND;
76                 msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND";
77                 break;
78         case MC_ERROR_DECODE:
79                 ret = MEDIACODEC_ERROR_DECODE;
80                 msg = "MEDIACODEC_ERROR_DECODE";
81                 break;
82         case MC_INVALID_IN_BUF:
83                 ret = MEDIACODEC_ERROR_INVALID_INBUFFER;
84                 msg = "MEDIACODEC_ERROR_INVALID_INBUFFER";
85                 break;
86         case MC_INVALID_OUT_BUF:
87                 ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER;
88                 msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER";
89                 break;
90         case MC_NOT_INITIALIZED:
91                 ret = MEDIACODEC_ERROR_NOT_INITIALIZED;
92                 msg = "MEDIACODEC_ERROR_NOT_INITIALIZED";
93                 break;
94         case MC_OUTPUT_BUFFER_EMPTY:
95         case MC_OUTPUT_BUFFER_OVERFLOW:
96                 ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE;
97                 msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE";
98                 break;
99         case MC_OUT_OF_MEMORY:
100                 ret = MEDIACODEC_ERROR_OUT_OF_MEMORY;
101                 msg = "MEDIACODEC_ERROR_OUT_OF_MEMORY";
102                 break;
103         default:
104                 ret = MEDIACODEC_ERROR_INTERNAL;
105                 msg = "MEDIACODEC_ERROR_INTERNAL";
106                 break;
107         }
108         LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
109         return ret;
110 }
111
112 /*
113  *  Public Implementation
114  */
115
116 int mediacodec_create(mediacodec_h *mediacodec)
117 {
118         MEDIACODEC_INSTANCE_CHECK(mediacodec);
119         mediacodec_s *handle;
120         int ret;
121
122         LOGD("mediacodec_create..");
123
124         handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
125         if (handle != NULL) {
126                 memset(handle, 0 , sizeof(mediacodec_s));
127         } else {
128                 LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
129                 return MEDIACODEC_ERROR_OUT_OF_MEMORY;
130         }
131
132         ret = mc_create(&handle->mc_handle);
133         if (ret != MEDIACODEC_ERROR_NONE) {
134                 LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
135                 handle->state = MEDIACODEC_STATE_NONE;
136                 g_free(handle->mc_handle);
137                 g_free(handle);
138                 handle = NULL;
139                 return MEDIACODEC_ERROR_INVALID_OPERATION;
140         } else {
141                 *mediacodec = (mediacodec_h)handle;
142                 handle->state = MEDIACODEC_STATE_IDLE;
143                 LOGD("new handle : %p", *mediacodec);
144         }
145
146         /* set callback */
147         mc_set_empty_buffer_cb(handle->mc_handle, (mediacodec_input_buffer_used_cb)__mediacodec_empty_buffer_cb, handle);
148         mc_set_fill_buffer_cb(handle->mc_handle, (mediacodec_output_buffer_available_cb)__mediacodec_fill_buffer_cb, handle);
149         mc_set_error_cb(handle->mc_handle, (mediacodec_error_cb)__mediacodec_error_cb, handle);
150         mc_set_eos_cb(handle->mc_handle, (mediacodec_eos_cb)__mediacodec_eos_cb, handle);
151         mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
152         mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
153
154         return MEDIACODEC_ERROR_NONE;
155
156 }
157
158 int mediacodec_destroy(mediacodec_h mediacodec)
159 {
160         LOGD("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
161         MEDIACODEC_INSTANCE_CHECK(mediacodec);
162         mediacodec_s *handle = (mediacodec_s *)mediacodec;
163
164         int ret = mc_destroy(handle->mc_handle);
165         if (ret != MEDIACODEC_ERROR_NONE) {
166                 LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
167                 return MEDIACODEC_ERROR_INVALID_OPERATION;
168         } else {
169                 handle->state = MEDIACODEC_STATE_NONE;
170                 free(handle);
171                 handle = NULL;
172                 return MEDIACODEC_ERROR_NONE;
173         }
174 }
175
176 int mediacodec_set_codec(mediacodec_h mediacodec, mediacodec_codec_type_e codec_id, int flags)
177 {
178         MEDIACODEC_INSTANCE_CHECK(mediacodec);
179         mediacodec_s *handle = (mediacodec_s *)mediacodec;
180         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
181
182         int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
183
184         if (ret != MEDIACODEC_ERROR_NONE) {
185                 return __convert_error_code(ret, (char *)__FUNCTION__);
186         } else {
187                 handle->state = MEDIACODEC_STATE_IDLE;
188                 return MEDIACODEC_ERROR_NONE;
189         }
190 }
191
192 int mediacodec_set_vdec_info(mediacodec_h mediacodec, int width, int height)
193 {
194         MEDIACODEC_INSTANCE_CHECK(mediacodec);
195         mediacodec_s *handle = (mediacodec_s *)mediacodec;
196         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
197
198         int ret = mc_set_vdec_info(handle->mc_handle, width, height);
199
200         if (ret != MEDIACODEC_ERROR_NONE) {
201                 return __convert_error_code(ret, (char *)__FUNCTION__);
202         } else {
203                 handle->state = MEDIACODEC_STATE_IDLE;
204                 return MEDIACODEC_ERROR_NONE;
205         }
206 }
207
208 int mediacodec_set_venc_info(mediacodec_h mediacodec, int width, int height, int fps, int target_bits)
209 {
210         MEDIACODEC_INSTANCE_CHECK(mediacodec);
211         mediacodec_s *handle = (mediacodec_s *)mediacodec;
212         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
213
214         int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
215
216         if (ret != MEDIACODEC_ERROR_NONE) {
217                 return __convert_error_code(ret, (char *)__FUNCTION__);
218         } else {
219                 handle->state = MEDIACODEC_STATE_IDLE;
220                 return MEDIACODEC_ERROR_NONE;
221         }
222 }
223
224 int mediacodec_set_adec_info(mediacodec_h mediacodec, int samplerate, int channel, int bit)
225 {
226         MEDIACODEC_INSTANCE_CHECK(mediacodec);
227         mediacodec_s *handle = (mediacodec_s *)mediacodec;
228         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
229
230         int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
231
232         if (ret != MEDIACODEC_ERROR_NONE) {
233                 return __convert_error_code(ret, (char *)__FUNCTION__);
234         } else {
235                 handle->state = MEDIACODEC_STATE_IDLE;
236                 return MEDIACODEC_ERROR_NONE;
237         }
238 }
239
240 int mediacodec_set_aenc_info(mediacodec_h mediacodec, int samplerate, int channel, int bit, int bitrate)
241 {
242         MEDIACODEC_INSTANCE_CHECK(mediacodec);
243         mediacodec_s *handle = (mediacodec_s *)mediacodec;
244         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
245
246         int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
247
248         if (ret != MEDIACODEC_ERROR_NONE) {
249                 return __convert_error_code(ret, (char *)__FUNCTION__);
250         } else {
251                 handle->state = MEDIACODEC_STATE_IDLE;
252                 return MEDIACODEC_ERROR_NONE;
253         }
254 }
255
256 int mediacodec_prepare(mediacodec_h mediacodec)
257 {
258         MEDIACODEC_INSTANCE_CHECK(mediacodec);
259         mediacodec_s *handle = (mediacodec_s *)mediacodec;
260         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
261
262         int ret = mc_prepare(handle->mc_handle);
263
264         if (ret != MEDIACODEC_ERROR_NONE) {
265                 return __convert_error_code(ret, (char *)__FUNCTION__);
266         } else {
267                 handle->state = MEDIACODEC_STATE_READY;
268                 return MEDIACODEC_ERROR_NONE;
269         }
270 }
271
272 int mediacodec_unprepare(mediacodec_h mediacodec)
273 {
274         MEDIACODEC_INSTANCE_CHECK(mediacodec);
275         mediacodec_s *handle = (mediacodec_s *)mediacodec;
276
277         int ret = mc_unprepare(handle->mc_handle);
278
279         if (ret != MEDIACODEC_ERROR_NONE) {
280                 return __convert_error_code(ret, (char *)__FUNCTION__);
281         } else {
282                 handle->state = MEDIACODEC_STATE_IDLE;
283                 return MEDIACODEC_ERROR_NONE;
284         }
285 }
286
287 int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
288 {
289         MEDIACODEC_INSTANCE_CHECK(mediacodec);
290         mediacodec_s *handle = (mediacodec_s *)mediacodec;
291         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
292
293         int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
294
295         if (ret != MEDIACODEC_ERROR_NONE)
296                 return __convert_error_code(ret, (char *)__FUNCTION__);
297         else
298                 return MEDIACODEC_ERROR_NONE;
299 }
300
301 int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
302 {
303         MEDIACODEC_INSTANCE_CHECK(mediacodec);
304         mediacodec_s *handle = (mediacodec_s *)mediacodec;
305         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
306
307         int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
308
309         if (ret != MEDIACODEC_ERROR_NONE)
310                 return __convert_error_code(ret, (char *)__FUNCTION__);
311         else
312                 return MEDIACODEC_ERROR_NONE;
313 }
314
315 int mediacodec_flush_buffers(mediacodec_h mediacodec)
316 {
317         MEDIACODEC_INSTANCE_CHECK(mediacodec);
318         mediacodec_s *handle = (mediacodec_s *)mediacodec;
319
320         int ret = mc_flush_buffers(handle->mc_handle);
321
322         if (ret != MEDIACODEC_ERROR_NONE)
323                 return __convert_error_code(ret, (char *)__FUNCTION__);
324         else
325                 return MEDIACODEC_ERROR_NONE;
326 }
327
328 int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
329 {
330         MEDIACODEC_INSTANCE_CHECK(mediacodec);
331         mediacodec_s *handle = (mediacodec_s *)mediacodec;
332         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
333
334         int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
335
336         if (ret != MEDIACODEC_ERROR_NONE)
337                 return __convert_error_code(ret, (char *)__FUNCTION__);
338         else
339                 handle->state = MEDIACODEC_STATE_IDLE;
340                 return MEDIACODEC_ERROR_NONE;
341 }
342
343 int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
344 {
345         MEDIACODEC_INSTANCE_CHECK(mediacodec);
346         mediacodec_s *handle = (mediacodec_s *)mediacodec;
347         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
348
349         handle->empty_buffer_cb = callback;
350         handle->empty_buffer_cb_userdata = user_data;
351
352         LOGD("set empty_buffer_cb(%p)", callback);
353
354         return MEDIACODEC_ERROR_NONE;
355 }
356
357 int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
358 {
359         MEDIACODEC_INSTANCE_CHECK(mediacodec);
360         mediacodec_s *handle = (mediacodec_s *)mediacodec;
361
362         handle->empty_buffer_cb = NULL;
363         handle->empty_buffer_cb_userdata = NULL;
364
365         return MEDIACODEC_ERROR_NONE;
366 }
367
368
369 int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
370 {
371         MEDIACODEC_INSTANCE_CHECK(mediacodec);
372         mediacodec_s *handle = (mediacodec_s *)mediacodec;
373         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
374
375         handle->fill_buffer_cb = callback;
376         handle->fill_buffer_cb_userdata = user_data;
377
378         LOGD("set fill_buffer_cb(%p)", callback);
379
380         return MEDIACODEC_ERROR_NONE;
381
382 }
383
384 int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
385 {
386         MEDIACODEC_INSTANCE_CHECK(mediacodec);
387         mediacodec_s *handle = (mediacodec_s *)mediacodec;
388
389         handle->fill_buffer_cb = NULL;
390         handle->fill_buffer_cb_userdata = NULL;
391
392         return MEDIACODEC_ERROR_NONE;
393 }
394
395 int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
396 {
397         MEDIACODEC_INSTANCE_CHECK(mediacodec);
398         mediacodec_s *handle = (mediacodec_s *)mediacodec;
399         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
400
401         handle->error_cb = callback;
402         handle->error_cb_userdata = user_data;
403
404         LOGD("set error_cb(%p)", callback);
405
406         return MEDIACODEC_ERROR_NONE;
407
408 }
409
410 int mediacodec_unset_error_cb(mediacodec_h mediacodec)
411 {
412         MEDIACODEC_INSTANCE_CHECK(mediacodec);
413         mediacodec_s *handle = (mediacodec_s *)mediacodec;
414
415         handle->error_cb = NULL;
416         handle->error_cb_userdata = NULL;
417
418         return MEDIACODEC_ERROR_NONE;
419 }
420
421 int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
422 {
423         MEDIACODEC_INSTANCE_CHECK(mediacodec);
424         mediacodec_s *handle = (mediacodec_s *)mediacodec;
425         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
426
427         handle->eos_cb = callback;
428         handle->eos_cb_userdata = user_data;
429
430         LOGD("set eos_cb(%p)", callback);
431
432         return MEDIACODEC_ERROR_NONE;
433
434 }
435
436 int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
437 {
438         MEDIACODEC_INSTANCE_CHECK(mediacodec);
439         mediacodec_s *handle = (mediacodec_s *)mediacodec;
440
441         handle->eos_cb = NULL;
442         handle->eos_cb_userdata = NULL;
443
444         return MEDIACODEC_ERROR_NONE;
445 }
446
447 int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
448 {
449         MEDIACODEC_INSTANCE_CHECK(mediacodec);
450         mediacodec_s *handle = (mediacodec_s *)mediacodec;
451         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
452
453         handle->buffer_status_cb = callback;
454         handle->buffer_status_cb_userdata = user_data;
455
456         LOGD("set buffer_status_cb(%p)", callback);
457
458         return MEDIACODEC_ERROR_NONE;
459
460 }
461
462 int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
463 {
464         MEDIACODEC_INSTANCE_CHECK(mediacodec);
465         mediacodec_s *handle = (mediacodec_s *)mediacodec;
466
467         handle->buffer_status_cb = NULL;
468         handle->buffer_status_cb_userdata = NULL;
469
470         return MEDIACODEC_ERROR_NONE;
471 }
472
473 int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
474 {
475         MEDIACODEC_INSTANCE_CHECK(mediacodec);
476         mediacodec_s *handle = (mediacodec_s *)mediacodec;
477
478         handle->supported_codec_cb = callback;
479         handle->supported_codec_cb_userdata = user_data;
480
481         LOGD("set supported_codec_cb(%p)", callback);
482         int ret = _mediacodec_foreach_supported_codec(callback, handle);
483
484         if (ret != MEDIACODEC_ERROR_NONE)
485                 return __convert_error_code(ret, (char *)__FUNCTION__);
486         else
487                 return MEDIACODEC_ERROR_NONE;
488
489         return MEDIACODEC_ERROR_NONE;
490
491 }
492
493 int mediacodec_get_packet_pool(mediacodec_h mediacodec, media_packet_pool_h *pkt_pool)
494 {
495         MEDIACODEC_INSTANCE_CHECK(mediacodec);
496         mediacodec_s *handle = (mediacodec_s *)mediacodec;
497         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
498         int ret = mc_get_packet_pool(handle->mc_handle, pkt_pool);
499
500         if (ret != MEDIACODEC_ERROR_NONE)
501                 return MEDIACODEC_ERROR_INVALID_OPERATION;
502         else
503                 return MEDIACODEC_ERROR_NONE;
504 }
505
506 static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
507 {
508         if (user_data == NULL || pkt == NULL)
509                 return 0;
510
511         mediacodec_s *handle = (mediacodec_s *)user_data;
512
513         if (handle->empty_buffer_cb)
514                 ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
515
516         return 1;
517 }
518
519 static gboolean  __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
520 {
521         if (user_data == NULL || pkt == NULL)
522                 return 0;
523
524         mediacodec_s *handle = (mediacodec_s *)user_data;
525
526         if (handle->fill_buffer_cb)
527                 ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
528
529         return 1;
530 }
531
532 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
533 {
534         if (user_data == NULL)
535                 return 0;
536
537         mediacodec_s *handle = (mediacodec_s *)user_data;
538
539         if (handle->error_cb)
540                 ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
541
542         return 1;
543 }
544
545 static gboolean __mediacodec_eos_cb(void *user_data)
546 {
547         if (user_data == NULL)
548                 return 0;
549
550         mediacodec_s *handle = (mediacodec_s *)user_data;
551
552         if (handle->eos_cb)
553                 ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
554
555         return 1;
556 }
557
558 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
559 {
560         if (user_data == NULL)
561                 return 0;
562
563         mediacodec_s *handle = (mediacodec_s *)user_data;
564
565         if (handle->supported_codec_cb)
566                 return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
567
568         return false;
569 }
570
571 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
572 {
573         if (user_data == NULL)
574                 return 0;
575
576         mediacodec_s *handle = (mediacodec_s *)user_data;
577
578         if (handle->buffer_status_cb)
579                 ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
580
581         return 1;
582 }