2d8c84895c8e92a4735a3bbb54255237777212e5
[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_configure_from_media_format(mediacodec_h mediacodec, media_format_h format, int flags)
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_configure(handle->mc_handle, format, flags);
263
264         if (ret != MEDIACODEC_ERROR_NONE) {
265                 return __convert_error_code(ret, (char *)__FUNCTION__);
266         } else {
267                 handle->state = MEDIACODEC_STATE_IDLE;
268                 return MEDIACODEC_ERROR_NONE;
269         }
270 }
271
272 int mediacodec_prepare(mediacodec_h mediacodec)
273 {
274         MEDIACODEC_INSTANCE_CHECK(mediacodec);
275         mediacodec_s *handle = (mediacodec_s *)mediacodec;
276         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
277
278         int ret = mc_prepare(handle->mc_handle);
279
280         if (ret != MEDIACODEC_ERROR_NONE) {
281                 return __convert_error_code(ret, (char *)__FUNCTION__);
282         } else {
283                 handle->state = MEDIACODEC_STATE_READY;
284                 return MEDIACODEC_ERROR_NONE;
285         }
286 }
287
288 int mediacodec_unprepare(mediacodec_h mediacodec)
289 {
290         MEDIACODEC_INSTANCE_CHECK(mediacodec);
291         mediacodec_s *handle = (mediacodec_s *)mediacodec;
292
293         int ret = mc_unprepare(handle->mc_handle);
294
295         if (ret != MEDIACODEC_ERROR_NONE) {
296                 return __convert_error_code(ret, (char *)__FUNCTION__);
297         } else {
298                 handle->state = MEDIACODEC_STATE_IDLE;
299                 return MEDIACODEC_ERROR_NONE;
300         }
301 }
302
303 int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
304 {
305         MEDIACODEC_INSTANCE_CHECK(mediacodec);
306         mediacodec_s *handle = (mediacodec_s *)mediacodec;
307         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
308
309         int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
310
311         if (ret != MEDIACODEC_ERROR_NONE)
312                 return __convert_error_code(ret, (char *)__FUNCTION__);
313         else
314                 return MEDIACODEC_ERROR_NONE;
315 }
316
317 int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
318 {
319         MEDIACODEC_INSTANCE_CHECK(mediacodec);
320         mediacodec_s *handle = (mediacodec_s *)mediacodec;
321         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
322
323         int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
324
325         if (ret != MEDIACODEC_ERROR_NONE)
326                 return __convert_error_code(ret, (char *)__FUNCTION__);
327         else
328                 return MEDIACODEC_ERROR_NONE;
329 }
330
331 int mediacodec_flush_buffers(mediacodec_h mediacodec)
332 {
333         MEDIACODEC_INSTANCE_CHECK(mediacodec);
334         mediacodec_s *handle = (mediacodec_s *)mediacodec;
335
336         int ret = mc_flush_buffers(handle->mc_handle);
337
338         if (ret != MEDIACODEC_ERROR_NONE)
339                 return __convert_error_code(ret, (char *)__FUNCTION__);
340         else
341                 return MEDIACODEC_ERROR_NONE;
342 }
343
344 int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
345 {
346         MEDIACODEC_INSTANCE_CHECK(mediacodec);
347         mediacodec_s *handle = (mediacodec_s *)mediacodec;
348         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
349
350         int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
351
352         if (ret != MEDIACODEC_ERROR_NONE)
353                 return __convert_error_code(ret, (char *)__FUNCTION__);
354         else
355                 handle->state = MEDIACODEC_STATE_IDLE;
356
357         return MEDIACODEC_ERROR_NONE;
358 }
359
360 int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
361 {
362         MEDIACODEC_INSTANCE_CHECK(mediacodec);
363         mediacodec_s *handle = (mediacodec_s *)mediacodec;
364         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
365
366         handle->empty_buffer_cb = callback;
367         handle->empty_buffer_cb_userdata = user_data;
368
369         LOGD("set empty_buffer_cb(%p)", callback);
370
371         return MEDIACODEC_ERROR_NONE;
372 }
373
374 int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
375 {
376         MEDIACODEC_INSTANCE_CHECK(mediacodec);
377         mediacodec_s *handle = (mediacodec_s *)mediacodec;
378
379         handle->empty_buffer_cb = NULL;
380         handle->empty_buffer_cb_userdata = NULL;
381
382         return MEDIACODEC_ERROR_NONE;
383 }
384
385
386 int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
387 {
388         MEDIACODEC_INSTANCE_CHECK(mediacodec);
389         mediacodec_s *handle = (mediacodec_s *)mediacodec;
390         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
391
392         handle->fill_buffer_cb = callback;
393         handle->fill_buffer_cb_userdata = user_data;
394
395         LOGD("set fill_buffer_cb(%p)", callback);
396
397         return MEDIACODEC_ERROR_NONE;
398
399 }
400
401 int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
402 {
403         MEDIACODEC_INSTANCE_CHECK(mediacodec);
404         mediacodec_s *handle = (mediacodec_s *)mediacodec;
405
406         handle->fill_buffer_cb = NULL;
407         handle->fill_buffer_cb_userdata = NULL;
408
409         return MEDIACODEC_ERROR_NONE;
410 }
411
412 int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
413 {
414         MEDIACODEC_INSTANCE_CHECK(mediacodec);
415         mediacodec_s *handle = (mediacodec_s *)mediacodec;
416         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
417
418         handle->error_cb = callback;
419         handle->error_cb_userdata = user_data;
420
421         LOGD("set error_cb(%p)", callback);
422
423         return MEDIACODEC_ERROR_NONE;
424
425 }
426
427 int mediacodec_unset_error_cb(mediacodec_h mediacodec)
428 {
429         MEDIACODEC_INSTANCE_CHECK(mediacodec);
430         mediacodec_s *handle = (mediacodec_s *)mediacodec;
431
432         handle->error_cb = NULL;
433         handle->error_cb_userdata = NULL;
434
435         return MEDIACODEC_ERROR_NONE;
436 }
437
438 int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
439 {
440         MEDIACODEC_INSTANCE_CHECK(mediacodec);
441         mediacodec_s *handle = (mediacodec_s *)mediacodec;
442         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
443
444         handle->eos_cb = callback;
445         handle->eos_cb_userdata = user_data;
446
447         LOGD("set eos_cb(%p)", callback);
448
449         return MEDIACODEC_ERROR_NONE;
450
451 }
452
453 int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
454 {
455         MEDIACODEC_INSTANCE_CHECK(mediacodec);
456         mediacodec_s *handle = (mediacodec_s *)mediacodec;
457
458         handle->eos_cb = NULL;
459         handle->eos_cb_userdata = NULL;
460
461         return MEDIACODEC_ERROR_NONE;
462 }
463
464 int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
465 {
466         MEDIACODEC_INSTANCE_CHECK(mediacodec);
467         mediacodec_s *handle = (mediacodec_s *)mediacodec;
468         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
469
470         handle->buffer_status_cb = callback;
471         handle->buffer_status_cb_userdata = user_data;
472
473         LOGD("set buffer_status_cb(%p)", callback);
474
475         return MEDIACODEC_ERROR_NONE;
476
477 }
478
479 int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
480 {
481         MEDIACODEC_INSTANCE_CHECK(mediacodec);
482         mediacodec_s *handle = (mediacodec_s *)mediacodec;
483
484         handle->buffer_status_cb = NULL;
485         handle->buffer_status_cb_userdata = NULL;
486
487         return MEDIACODEC_ERROR_NONE;
488 }
489
490 int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
491 {
492         MEDIACODEC_INSTANCE_CHECK(mediacodec);
493         mediacodec_s *handle = (mediacodec_s *)mediacodec;
494
495         handle->supported_codec_cb = callback;
496         handle->supported_codec_cb_userdata = user_data;
497
498         LOGD("set supported_codec_cb(%p)", callback);
499         int ret = _mediacodec_foreach_supported_codec(callback, handle);
500
501         if (ret != MEDIACODEC_ERROR_NONE)
502                 return __convert_error_code(ret, (char *)__FUNCTION__);
503         else
504                 return MEDIACODEC_ERROR_NONE;
505
506         return MEDIACODEC_ERROR_NONE;
507
508 }
509
510 int mediacodec_get_packet_pool(mediacodec_h mediacodec, media_packet_pool_h *pkt_pool)
511 {
512         MEDIACODEC_INSTANCE_CHECK(mediacodec);
513         mediacodec_s *handle = (mediacodec_s *)mediacodec;
514         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
515         int ret = mc_get_packet_pool(handle->mc_handle, pkt_pool);
516
517         if (ret != MEDIACODEC_ERROR_NONE)
518                 return MEDIACODEC_ERROR_INVALID_OPERATION;
519         else
520                 return MEDIACODEC_ERROR_NONE;
521 }
522
523 static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
524 {
525         if (user_data == NULL || pkt == NULL)
526                 return 0;
527
528         mediacodec_s *handle = (mediacodec_s *)user_data;
529
530         if (handle->empty_buffer_cb)
531                 ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
532
533         return 1;
534 }
535
536 static gboolean  __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
537 {
538         if (user_data == NULL || pkt == NULL)
539                 return 0;
540
541         mediacodec_s *handle = (mediacodec_s *)user_data;
542
543         if (handle->fill_buffer_cb)
544                 ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
545
546         return 1;
547 }
548
549 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
550 {
551         if (user_data == NULL)
552                 return 0;
553
554         mediacodec_s *handle = (mediacodec_s *)user_data;
555
556         if (handle->error_cb)
557                 ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
558
559         return 1;
560 }
561
562 static gboolean __mediacodec_eos_cb(void *user_data)
563 {
564         if (user_data == NULL)
565                 return 0;
566
567         mediacodec_s *handle = (mediacodec_s *)user_data;
568
569         if (handle->eos_cb)
570                 ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
571
572         return 1;
573 }
574
575 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
576 {
577         if (user_data == NULL)
578                 return 0;
579
580         mediacodec_s *handle = (mediacodec_s *)user_data;
581
582         if (handle->supported_codec_cb)
583                 return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
584
585         return false;
586 }
587
588 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
589 {
590         if (user_data == NULL)
591                 return 0;
592
593         mediacodec_s *handle = (mediacodec_s *)user_data;
594
595         if (handle->buffer_status_cb)
596                 ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
597
598         return 1;
599 }