45d9454182359a984512041439d81c11822c6170
[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
341         return MEDIACODEC_ERROR_NONE;
342 }
343
344 int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
345 {
346         MEDIACODEC_INSTANCE_CHECK(mediacodec);
347         mediacodec_s *handle = (mediacodec_s *)mediacodec;
348         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
349
350         handle->empty_buffer_cb = callback;
351         handle->empty_buffer_cb_userdata = user_data;
352
353         LOGD("set empty_buffer_cb(%p)", callback);
354
355         return MEDIACODEC_ERROR_NONE;
356 }
357
358 int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
359 {
360         MEDIACODEC_INSTANCE_CHECK(mediacodec);
361         mediacodec_s *handle = (mediacodec_s *)mediacodec;
362
363         handle->empty_buffer_cb = NULL;
364         handle->empty_buffer_cb_userdata = NULL;
365
366         return MEDIACODEC_ERROR_NONE;
367 }
368
369
370 int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
371 {
372         MEDIACODEC_INSTANCE_CHECK(mediacodec);
373         mediacodec_s *handle = (mediacodec_s *)mediacodec;
374         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
375
376         handle->fill_buffer_cb = callback;
377         handle->fill_buffer_cb_userdata = user_data;
378
379         LOGD("set fill_buffer_cb(%p)", callback);
380
381         return MEDIACODEC_ERROR_NONE;
382
383 }
384
385 int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
386 {
387         MEDIACODEC_INSTANCE_CHECK(mediacodec);
388         mediacodec_s *handle = (mediacodec_s *)mediacodec;
389
390         handle->fill_buffer_cb = NULL;
391         handle->fill_buffer_cb_userdata = NULL;
392
393         return MEDIACODEC_ERROR_NONE;
394 }
395
396 int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
397 {
398         MEDIACODEC_INSTANCE_CHECK(mediacodec);
399         mediacodec_s *handle = (mediacodec_s *)mediacodec;
400         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
401
402         handle->error_cb = callback;
403         handle->error_cb_userdata = user_data;
404
405         LOGD("set error_cb(%p)", callback);
406
407         return MEDIACODEC_ERROR_NONE;
408
409 }
410
411 int mediacodec_unset_error_cb(mediacodec_h mediacodec)
412 {
413         MEDIACODEC_INSTANCE_CHECK(mediacodec);
414         mediacodec_s *handle = (mediacodec_s *)mediacodec;
415
416         handle->error_cb = NULL;
417         handle->error_cb_userdata = NULL;
418
419         return MEDIACODEC_ERROR_NONE;
420 }
421
422 int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
423 {
424         MEDIACODEC_INSTANCE_CHECK(mediacodec);
425         mediacodec_s *handle = (mediacodec_s *)mediacodec;
426         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
427
428         handle->eos_cb = callback;
429         handle->eos_cb_userdata = user_data;
430
431         LOGD("set eos_cb(%p)", callback);
432
433         return MEDIACODEC_ERROR_NONE;
434
435 }
436
437 int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
438 {
439         MEDIACODEC_INSTANCE_CHECK(mediacodec);
440         mediacodec_s *handle = (mediacodec_s *)mediacodec;
441
442         handle->eos_cb = NULL;
443         handle->eos_cb_userdata = NULL;
444
445         return MEDIACODEC_ERROR_NONE;
446 }
447
448 int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
449 {
450         MEDIACODEC_INSTANCE_CHECK(mediacodec);
451         mediacodec_s *handle = (mediacodec_s *)mediacodec;
452         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
453
454         handle->buffer_status_cb = callback;
455         handle->buffer_status_cb_userdata = user_data;
456
457         LOGD("set buffer_status_cb(%p)", callback);
458
459         return MEDIACODEC_ERROR_NONE;
460
461 }
462
463 int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
464 {
465         MEDIACODEC_INSTANCE_CHECK(mediacodec);
466         mediacodec_s *handle = (mediacodec_s *)mediacodec;
467
468         handle->buffer_status_cb = NULL;
469         handle->buffer_status_cb_userdata = NULL;
470
471         return MEDIACODEC_ERROR_NONE;
472 }
473
474 int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
475 {
476         MEDIACODEC_INSTANCE_CHECK(mediacodec);
477         mediacodec_s *handle = (mediacodec_s *)mediacodec;
478
479         handle->supported_codec_cb = callback;
480         handle->supported_codec_cb_userdata = user_data;
481
482         LOGD("set supported_codec_cb(%p)", callback);
483         int ret = _mediacodec_foreach_supported_codec(callback, handle);
484
485         if (ret != MEDIACODEC_ERROR_NONE)
486                 return __convert_error_code(ret, (char *)__FUNCTION__);
487         else
488                 return MEDIACODEC_ERROR_NONE;
489
490         return MEDIACODEC_ERROR_NONE;
491
492 }
493
494 int mediacodec_get_packet_pool(mediacodec_h mediacodec, media_packet_pool_h *pkt_pool)
495 {
496         MEDIACODEC_INSTANCE_CHECK(mediacodec);
497         mediacodec_s *handle = (mediacodec_s *)mediacodec;
498         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
499         int ret = mc_get_packet_pool(handle->mc_handle, pkt_pool);
500
501         if (ret != MEDIACODEC_ERROR_NONE)
502                 return MEDIACODEC_ERROR_INVALID_OPERATION;
503         else
504                 return MEDIACODEC_ERROR_NONE;
505 }
506
507 static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
508 {
509         if (user_data == NULL || pkt == NULL)
510                 return 0;
511
512         mediacodec_s *handle = (mediacodec_s *)user_data;
513
514         if (handle->empty_buffer_cb)
515                 ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
516
517         return 1;
518 }
519
520 static gboolean  __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
521 {
522         if (user_data == NULL || pkt == NULL)
523                 return 0;
524
525         mediacodec_s *handle = (mediacodec_s *)user_data;
526
527         if (handle->fill_buffer_cb)
528                 ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
529
530         return 1;
531 }
532
533 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
534 {
535         if (user_data == NULL)
536                 return 0;
537
538         mediacodec_s *handle = (mediacodec_s *)user_data;
539
540         if (handle->error_cb)
541                 ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
542
543         return 1;
544 }
545
546 static gboolean __mediacodec_eos_cb(void *user_data)
547 {
548         if (user_data == NULL)
549                 return 0;
550
551         mediacodec_s *handle = (mediacodec_s *)user_data;
552
553         if (handle->eos_cb)
554                 ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
555
556         return 1;
557 }
558
559 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
560 {
561         if (user_data == NULL)
562                 return 0;
563
564         mediacodec_s *handle = (mediacodec_s *)user_data;
565
566         if (handle->supported_codec_cb)
567                 return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
568
569         return false;
570 }
571
572 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
573 {
574         if (user_data == NULL)
575                 return 0;
576
577         mediacodec_s *handle = (mediacodec_s *)user_data;
578
579         if (handle->buffer_status_cb)
580                 ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
581
582         return 1;
583 }