2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
23 #include <media_codec.h>
24 #include <media_codec_private.h>
25 #include <media_codec_port.h>
26 #include <media_codec_port_gst.h>
27 #include <media_codec_spec_emul.h>
30 mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE];
32 int mc_create(MMHandleType *mediacodec)
34 mc_handle_t *new_mediacodec = NULL;
35 int ret = MC_ERROR_NONE;
37 /* alloc mediacodec structure */
38 new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t));
40 if (!new_mediacodec) {
41 LOGE("Cannot allocate memory for mediacodec");
45 memset(new_mediacodec, 0, sizeof(mc_handle_t));
47 new_mediacodec->is_encoder = false;
48 new_mediacodec->is_video = false;
49 new_mediacodec->is_hw = true;
50 new_mediacodec->is_prepared = false;
51 new_mediacodec->codec_id = MEDIACODEC_NONE;
53 new_mediacodec->ports[0] = NULL;
54 new_mediacodec->ports[1] = NULL;
56 new_mediacodec->num_supported_decoder = 0;
57 new_mediacodec->num_supported_encoder = 0;
59 new_mediacodec->core = NULL;
60 new_mediacodec->ini = &mc_ini;
64 ret = mc_ini_load(&mc_ini);
65 if (ret != MC_ERROR_NONE)
71 _mc_create_codec_map_from_ini(new_mediacodec, spec_emul);
73 /* create decoder map from ini */
74 _mc_create_decoder_map_from_ini(new_mediacodec);
76 /* create encoder map from ini */
77 _mc_create_encoder_map_from_ini(new_mediacodec);
79 *mediacodec = (MMHandleType)new_mediacodec;
85 return MC_INVALID_ARG;
88 int mc_destroy(MMHandleType mediacodec)
90 int ret = MC_ERROR_NONE;
91 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
94 LOGE("fail invaild param\n");
95 return MC_INVALID_ARG;
98 LOGD("mediacodec : %p", mediacodec);
100 if (mc_handle->core != NULL) {
101 if (mc_gst_unprepare(mc_handle) != MC_ERROR_NONE) {
102 LOGE("mc_gst_unprepare() failed");
107 mc_handle->is_prepared = false;
109 /* free mediacodec structure */
111 g_free((void *)mc_handle);
118 int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, int flags)
120 int ret = MC_ERROR_NONE;
121 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
125 LOGE("fail invaild param");
126 return MC_INVALID_ARG;
129 /* Mandatory setting */
130 if (!GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags)) {
131 LOGE("should be encoder or decoder");
132 return MC_PARAM_ERROR;
135 /* if user doesn't set codec-type, s/w codec would be set */
136 if (!GET_IS_HW(flags) && !GET_IS_SW(flags))
137 flags |= MEDIACODEC_SUPPORT_TYPE_SW;
139 for (i = 0; i < mc_handle->ini->num_supported_codecs; i++) {
140 if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type))
143 LOGD("support_list : %d, i : %d", mc_handle->ini->num_supported_codecs, i);
145 if (i == mc_handle->ini->num_supported_codecs)
146 return MC_NOT_SUPPORTED;
148 mc_handle->port_type = spec_emul[i].port_type;
150 mc_handle->is_encoder = GET_IS_ENCODER(flags) ? 1 : 0;
151 mc_handle->is_hw = GET_IS_HW(flags) ? 1 : 0;
152 mc_handle->codec_id = codec_id;
153 mc_handle->is_video = CHECK_BIT(codec_id, 13);
155 mc_handle->is_prepared = false;
157 LOGD("encoder : %d, hardware : %d, codec_id : %x, video : %d",
158 mc_handle->is_encoder, mc_handle->is_hw, mc_handle->codec_id, mc_handle->is_video);
163 int mc_set_vdec_info(MMHandleType mediacodec, int width, int height)
165 int ret = MC_ERROR_NONE;
166 mc_handle_t* mc_handle = (mc_handle_t *)mediacodec;
169 LOGE("fail invaild param\n");
170 return MC_INVALID_ARG;
173 if ((width <= 0) || (height <= 0))
174 return MC_PARAM_ERROR;
176 MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
177 MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
179 mc_handle->info.decoder.width = width;
180 mc_handle->info.decoder.height = height;
182 mc_handle->is_prepared = true;
187 int mc_set_venc_info(MMHandleType mediacodec, int width, int height, int fps, int target_bits)
189 int ret = MC_ERROR_NONE;
190 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
193 LOGE("fail invaild param\n");
194 return MC_INVALID_ARG;
197 if ((width <= 0) || (height <= 0))
198 return MC_PARAM_ERROR;
200 MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
201 MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
203 mc_handle->info.encoder.width = width;
204 mc_handle->info.encoder.height = height;
205 mc_handle->info.encoder.fps = fps;
206 mc_handle->info.encoder.bitrate = target_bits * 1000;
207 mc_handle->is_prepared = true;
212 int mc_set_adec_info(MMHandleType mediacodec, int samplerate, int channel, int bit)
214 int ret = MC_ERROR_NONE;
215 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
218 LOGE("fail invaild param\n");
219 return MC_INVALID_ARG;
222 if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
223 return MC_PARAM_ERROR;
225 MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
226 MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
228 mc_handle->info.decoder.samplerate = samplerate;
229 mc_handle->info.decoder.channel = channel;
230 mc_handle->info.decoder.bit = bit;
231 mc_handle->is_prepared = true;
236 int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int bit, int bitrate)
238 int ret = MC_ERROR_NONE;
239 mc_handle_t * mc_handle = (mc_handle_t *) mediacodec;
242 LOGE("fail invaild param\n");
243 return MC_INVALID_ARG;
246 if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
247 return MC_PARAM_ERROR;
249 MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
250 MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
252 mc_handle->info.encoder.samplerate = samplerate;
253 mc_handle->info.encoder.channel = channel;
254 mc_handle->info.encoder.bit = bit;
255 mc_handle->info.encoder.bitrate = bitrate * 1000;
257 mc_handle->is_prepared = true;
262 int mc_prepare(MMHandleType mediacodec)
264 int ret = MC_ERROR_NONE;
265 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
268 LOGE("fail invaild param\n");
269 return MC_INVALID_ARG;
272 if (!mc_handle->is_prepared)
273 return MC_NOT_INITIALIZED;
275 /* setting core details */
276 switch (mc_handle->port_type) {
277 case MEDIACODEC_PORT_TYPE_GENERAL:
280 case MEDIACODEC_PORT_TYPE_OMX:
283 case MEDIACODEC_PORT_TYPE_GST:
284 mc_gst_prepare(mc_handle);
294 int mc_unprepare(MMHandleType mediacodec)
296 int ret = MC_ERROR_NONE;
297 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
300 LOGE("fail invaild param\n");
301 return MC_INVALID_ARG;
304 /* deinit core details */
305 switch (mc_handle->port_type) {
306 case MEDIACODEC_PORT_TYPE_GENERAL:
309 case MEDIACODEC_PORT_TYPE_OMX:
312 case MEDIACODEC_PORT_TYPE_GST:
313 ret = mc_gst_unprepare(mc_handle);
323 int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
325 int ret = MC_ERROR_NONE;
327 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
330 LOGE("fail invaild param");
331 return MC_INVALID_ARG;
335 LOGE("invaild input buffer");
336 return MC_INVALID_IN_BUF;
339 switch (mc_handle->port_type) {
340 case MEDIACODEC_PORT_TYPE_GENERAL:
343 case MEDIACODEC_PORT_TYPE_OMX:
346 case MEDIACODEC_PORT_TYPE_GST:
347 ret = mc_gst_process_input(mc_handle, inbuf, timeOutUs);
357 int mc_get_output(MMHandleType mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
359 int ret = MC_ERROR_NONE;
360 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
363 LOGE("fail invaild param\n");
364 return MC_INVALID_ARG;
367 /* setting core details */
368 switch (mc_handle->port_type) {
369 case MEDIACODEC_PORT_TYPE_GENERAL:
372 case MEDIACODEC_PORT_TYPE_OMX:
375 case MEDIACODEC_PORT_TYPE_GST:
376 ret = mc_gst_get_output(mc_handle, outbuf, timeOutUs);
386 int mc_flush_buffers(MMHandleType mediacodec)
388 int ret = MC_ERROR_NONE;
389 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
392 LOGE("fail invaild param\n");
393 return MC_INVALID_ARG;
396 /* setting core details */
397 switch (mc_handle->port_type) {
398 case MEDIACODEC_PORT_TYPE_GENERAL:
401 case MEDIACODEC_PORT_TYPE_OMX:
404 case MEDIACODEC_PORT_TYPE_GST:
405 ret = mc_gst_flush_buffers(mc_handle);
415 int mc_get_supported_type(MMHandleType mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
417 int ret = MC_ERROR_NONE;
418 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
419 mc_codec_map_t *codec_map;
420 int num_supported_codec = 0;
426 LOGE("fail invaild param\n");
427 return MC_INVALID_ARG;
430 codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
431 num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
433 for (i = 0; i < num_supported_codec; i++) {
434 if (codec_map[i].id == codec_type) {
435 if (codec_map[i].hardware)
436 *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
438 *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
445 int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
447 int ret = MC_ERROR_NONE;
448 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
451 LOGE("fail invaild param\n");
452 return MC_INVALID_ARG;
455 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
456 LOGE("Already set mediacodec_empty_buffer_cb");
457 return MC_PARAM_ERROR;
460 return MC_INVALID_ARG;
462 LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
464 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
465 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
467 return MC_ERROR_NONE;
473 int mc_unset_empty_buffer_cb(MMHandleType mediacodec)
475 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
478 LOGE("fail invaild param\n");
479 return MC_INVALID_ARG;
482 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
483 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
485 return MC_ERROR_NONE;
488 int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
490 int ret = MC_ERROR_NONE;
491 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
494 LOGE("fail invaild param\n");
495 return MC_INVALID_ARG;
498 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
499 LOGE("Already set mediacodec_fill_buffer_cb");
500 return MC_PARAM_ERROR;
503 return MC_INVALID_ARG;
505 LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
507 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
508 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
509 return MC_ERROR_NONE;
515 int mc_unset_fill_buffer_cb(MMHandleType mediacodec)
517 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
520 LOGE("fail invaild param\n");
521 return MC_INVALID_ARG;
524 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
525 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
527 return MC_ERROR_NONE;
530 int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void *user_data)
532 int ret = MC_ERROR_NONE;
533 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
536 LOGE("fail invaild param\n");
537 return MC_INVALID_ARG;
540 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
541 LOGE("Already set mediacodec_fill_buffer_cb\n");
542 return MC_PARAM_ERROR;
545 return MC_INVALID_ARG;
547 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
549 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = (mc_error_cb) callback;
550 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = user_data;
551 return MC_ERROR_NONE;
557 int mc_unset_error_cb(MMHandleType mediacodec)
559 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
562 LOGE("fail invaild param");
563 return MC_INVALID_ARG;
566 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
567 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
569 return MC_ERROR_NONE;
572 int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void *user_data)
574 int ret = MC_ERROR_NONE;
575 mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
578 LOGE("fail invaild param\n");
579 return MC_INVALID_ARG;
582 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
583 LOGE("Already set mediacodec_fill_buffer_cb");
584 return MC_PARAM_ERROR;
587 return MC_INVALID_ARG;
589 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
591 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = (mc_eos_cb) callback;
592 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = user_data;
593 return MC_ERROR_NONE;
599 int mc_unset_eos_cb(MMHandleType mediacodec)
601 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
604 LOGE("fail invaild param\n");
605 return MC_INVALID_ARG;
608 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
609 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
611 return MC_ERROR_NONE;
614 int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
616 int ret = MC_ERROR_NONE;
617 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
620 LOGE("fail invaild param\n");
621 return MC_INVALID_ARG;
624 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
625 LOGE("Already set mediacodec_need_data_cb\n");
626 return MC_PARAM_ERROR;
629 return MC_INVALID_ARG;
631 LOGD("Set start feed callback(cb = %p, data = %p)\n", callback, user_data);
633 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = (mc_buffer_status_cb) callback;
634 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = user_data;
635 return MC_ERROR_NONE;
641 int mc_unset_buffer_status_cb(MMHandleType mediacodec)
643 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
646 LOGE("fail invaild param\n");
647 return MC_INVALID_ARG;
650 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
651 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
653 return MC_ERROR_NONE;
656 int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
658 int ret = MC_ERROR_NONE;
659 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
662 LOGE("fail invaild param\n");
663 return MC_INVALID_ARG;
666 if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
667 LOGE("Already set mediacodec_supported_codec_cb\n");
668 return MC_PARAM_ERROR;
671 return MC_INVALID_ARG;
673 LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
675 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
676 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
677 return MC_ERROR_NONE;
683 int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void *user_data)
685 int ret = MEDIACODEC_NONE;
689 gboolean codec[CODEC_NR_ITEMS] = {0,};
691 for (i = 0; i < mc_ini.num_supported_codecs; i++) {
692 index = codec_type_to_simple_enumeration(spec_emul[i].codec_id);
696 for (i = 0; i < CODEC_NR_ITEMS; i++) {
698 index = simple_to_codec_type_enumeration(i);
699 if (!callback(index, user_data)) {
705 if (!callback(-1, user_data)) {
706 ret = MEDIACODEC_ERROR_INTERNAL;
711 LOGD("foreach callback returned error");
715 int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool)
717 int ret = MC_ERROR_NONE;
718 mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
721 LOGE("fail invaild param\n");
722 return MC_INVALID_ARG;
725 /* setting core details */
726 switch (mc_handle->port_type) {
727 case MEDIACODEC_PORT_TYPE_GENERAL:
730 case MEDIACODEC_PORT_TYPE_OMX:
733 case MEDIACODEC_PORT_TYPE_GST:
734 ret = mc_gst_get_packet_pool(mc_handle, pool);
744 void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
746 int indx = 0, count = 0;
747 int codec_list = mediacodec->ini->codec_list;
748 for (indx = 0; indx < codec_list; indx++) {
749 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
750 mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
751 mediacodec->decoder_map[count].hardware = 1; /* hardware */
752 mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[0].name;
753 mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[0].mime;
754 mediacodec->decoder_map[count].type.out_format =
755 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[0].format);
759 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
760 mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
761 mediacodec->decoder_map[count].hardware = 0; /* software */
762 mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[2].name;
763 mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[2].mime;
764 mediacodec->decoder_map[count].type.out_format =
765 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[2].format);
769 mediacodec->num_supported_decoder = count;
774 void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
776 int indx = 0, count = 0;
777 int codec_list = mediacodec->ini->codec_list;
779 for (indx = 0; indx < codec_list; indx++) {
780 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
781 mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
782 mediacodec->encoder_map[count].hardware = 1;
783 mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[1].name;
784 mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[1].mime;
785 mediacodec->encoder_map[count].type.out_format =
786 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[1].format);
790 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
791 mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
792 mediacodec->encoder_map[count].hardware = 0;
793 mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[3].name;
794 mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[3].mime;
795 mediacodec->encoder_map[count].type.out_format =
796 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[3].format);
800 mediacodec->num_supported_encoder = count;
804 void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul)
806 int indx = 0, count = 0;
807 int codec_list = mediacodec->ini->codec_list;
809 for (indx = 0; indx < codec_list; indx++) {
810 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
811 spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
812 spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
813 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
816 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
817 spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
818 spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
819 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
822 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
823 spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
824 spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
825 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
828 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
829 spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
830 spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
831 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
836 mediacodec->ini->num_supported_codecs = count;
837 LOGE("supported codecs :%d", count);
841 void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul)
843 int indx = 0, count = 0;
844 int codec_list = ini->codec_list;
846 for (indx = 0; indx < codec_list; indx++) {
847 if (strcmp(ini->codec[indx].codec_info[0].name, "")) {
848 spec_emul[count].codec_id = ini->codec[indx].codec_id;
849 spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
850 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
853 if (strcmp(ini->codec[indx].codec_info[1].name, "")) {
854 spec_emul[count].codec_id = ini->codec[indx].codec_id;
855 spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
856 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
859 if (strcmp(ini->codec[indx].codec_info[2].name, "")) {
860 spec_emul[count].codec_id = ini->codec[indx].codec_id;
861 spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
862 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
865 if (strcmp(ini->codec[indx].codec_info[3].name, "")) {
866 spec_emul[count].codec_id = ini->codec[indx].codec_id;
867 spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
868 spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
873 ini->num_supported_codecs = count;
874 LOGE("supported codecs :%d", count);
878 const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id)
880 guint media_codec_id_u = (guint)media_codec_id;
882 switch (media_codec_id_u) {
885 case MEDIACODEC_ALAW:
887 case MEDIACODEC_ULAW:
889 case MEDIACODEC_AMR_NB:
891 case MEDIACODEC_AMR_WB:
893 case MEDIACODEC_G729:
895 case MEDIACODEC_AAC_LC:
897 case MEDIACODEC_AAC_HE:
899 case MEDIACODEC_AAC_HE_PS:
903 case MEDIACODEC_VORBIS:
905 case MEDIACODEC_FLAC:
907 case MEDIACODEC_WMAV1:
909 case MEDIACODEC_WMAV2:
911 case MEDIACODEC_WMAPRO:
913 case MEDIACODEC_WMALSL:
915 case MEDIACODEC_H261:
917 case MEDIACODEC_H263:
919 case MEDIACODEC_H264:
921 case MEDIACODEC_MJPEG:
923 case MEDIACODEC_MPEG1:
925 case MEDIACODEC_MPEG2:
927 case MEDIACODEC_MPEG4:
929 case MEDIACODEC_HEVC:
942 const int simple_to_codec_type_enumeration(codec_type_e codec_id)
944 guint codec_id_u = (guint)codec_id;
946 switch (codec_id_u) {
948 return MEDIACODEC_L16;
950 return MEDIACODEC_ALAW;
952 return MEDIACODEC_ULAW;
954 return MEDIACODEC_AMR_NB;
956 return MEDIACODEC_AMR_WB;
958 return MEDIACODEC_G729;
960 return MEDIACODEC_AAC_LC;
962 return MEDIACODEC_AAC_HE;
964 return MEDIACODEC_AAC_HE_PS;
966 return MEDIACODEC_MP3;
968 return MEDIACODEC_VORBIS;
970 return MEDIACODEC_FLAC;
972 return MEDIACODEC_WMAV1;
974 return MEDIACODEC_WMAV2;
976 return MEDIACODEC_WMAPRO;
978 return MEDIACODEC_WMALSL;
980 return MEDIACODEC_H261;
982 return MEDIACODEC_H263;
984 return MEDIACODEC_H264;
986 return MEDIACODEC_MJPEG;
988 return MEDIACODEC_MPEG1;
990 return MEDIACODEC_MPEG2;
992 return MEDIACODEC_MPEG4;
994 return MEDIACODEC_HEVC;
996 return MEDIACODEC_VP8;
998 return MEDIACODEC_VP9;
1000 return MEDIACODEC_VC1;