/*
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#include <stdio.h>
#include <stdlib.h>
/*
-* Internal Implementation
-*/
+ * Internal Implementation
+ */
int __convert_error_code(int code, char *func_name)
{
- int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
- char *msg = "MEDIACOODEC_INVALID_OPERATION";
-
- switch (code) {
- case MC_ERROR_NONE:
- ret = MEDIACODEC_ERROR_NONE;
- msg = "MEDIACODEC_ERROR_NONE";
- break;
- case MC_PARAM_ERROR:
- case MC_INVALID_ARG:
- ret = MEDIACODEC_ERROR_INVALID_PARAMETER;
- msg = "MEDIACODEC_ERROR_INVALID_PARAMETER";
- break;
- case MC_PERMISSION_DENIED:
- ret = MEDIACODEC_ERROR_PERMISSION_DENIED;
- msg = "MEDIACODEC_ERROR_PERMISSION_DENIED";
- break;
- case MC_INVALID_STATUS:
- ret = MEDIACODEC_ERROR_INVALID_STATE;
- msg = "MEDIACODEC_ERROR_INVALID_STATE";
- break;
- case MC_NOT_SUPPORTED:
- ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
- msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE";
- break;
- case MC_ERROR:
- case MC_INTERNAL_ERROR:
- case MC_HW_ERROR:
- ret = MEDIACODEC_ERROR_INVALID_OPERATION;
- msg = "MEDIACODEC_ERROR_INVALID_OPERATION";
- break;
- case MC_INVALID_STREAM:
- ret = MEDIACODEC_ERROR_INVALID_STREAM;
- msg = "MEDIACODEC_ERROR_INVALID_STREAM";
- break;
- case MC_CODEC_NOT_FOUND:
- ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND;
- msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND";
- break;
- case MC_ERROR_DECODE:
- ret = MEDIACODEC_ERROR_DECODE;
- msg = "MEDIACODEC_ERROR_DECODE";
- break;
- case MC_INVALID_IN_BUF:
- ret = MEDIACODEC_ERROR_INVALID_INBUFFER;
- msg = "MEDIACODEC_ERROR_INVALID_INBUFFER";
- break;
- case MC_INVALID_OUT_BUF:
- ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER;
- msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER";
- break;
- case MC_NOT_INITIALIZED:
- ret = MEDIACODEC_ERROR_NOT_INITIALIZED;
- msg = "MEDIACODEC_ERROR_NOT_INITIALIZED";
- break;
- case MC_OUTPUT_BUFFER_EMPTY:
- case MC_OUTPUT_BUFFER_OVERFLOW:
- ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE;
- msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE";
- break;
- default:
- ret = MEDIACODEC_ERROR_INTERNAL;
- msg = "MEDIACODEC_ERROR_INTERNAL";
- break;
- }
- LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
- return ret;
+ int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
+ char *msg = "MEDIACOODEC_INVALID_OPERATION";
+
+ switch (code) {
+ case MC_ERROR_NONE:
+ ret = MEDIACODEC_ERROR_NONE;
+ msg = "MEDIACODEC_ERROR_NONE";
+ break;
+ case MC_PARAM_ERROR:
+ case MC_INVALID_ARG:
+ ret = MEDIACODEC_ERROR_INVALID_PARAMETER;
+ msg = "MEDIACODEC_ERROR_INVALID_PARAMETER";
+ break;
+ case MC_PERMISSION_DENIED:
+ ret = MEDIACODEC_ERROR_PERMISSION_DENIED;
+ msg = "MEDIACODEC_ERROR_PERMISSION_DENIED";
+ break;
+ case MC_INVALID_STATUS:
+ ret = MEDIACODEC_ERROR_INVALID_STATE;
+ msg = "MEDIACODEC_ERROR_INVALID_STATE";
+ break;
+ case MC_NOT_SUPPORTED:
+ ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
+ msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE";
+ break;
+ case MC_ERROR:
+ case MC_INTERNAL_ERROR:
+ case MC_HW_ERROR:
+ ret = MEDIACODEC_ERROR_INVALID_OPERATION;
+ msg = "MEDIACODEC_ERROR_INVALID_OPERATION";
+ break;
+ case MC_INVALID_STREAM:
+ ret = MEDIACODEC_ERROR_INVALID_STREAM;
+ msg = "MEDIACODEC_ERROR_INVALID_STREAM";
+ break;
+ case MC_CODEC_NOT_FOUND:
+ ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND;
+ msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND";
+ break;
+ case MC_ERROR_DECODE:
+ ret = MEDIACODEC_ERROR_DECODE;
+ msg = "MEDIACODEC_ERROR_DECODE";
+ break;
+ case MC_INVALID_IN_BUF:
+ ret = MEDIACODEC_ERROR_INVALID_INBUFFER;
+ msg = "MEDIACODEC_ERROR_INVALID_INBUFFER";
+ break;
+ case MC_INVALID_OUT_BUF:
+ ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER;
+ msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER";
+ break;
+ case MC_NOT_INITIALIZED:
+ ret = MEDIACODEC_ERROR_NOT_INITIALIZED;
+ msg = "MEDIACODEC_ERROR_NOT_INITIALIZED";
+ break;
+ case MC_OUTPUT_BUFFER_EMPTY:
+ case MC_OUTPUT_BUFFER_OVERFLOW:
+ ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE;
+ msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE";
+ break;
+ default:
+ ret = MEDIACODEC_ERROR_INTERNAL;
+ msg = "MEDIACODEC_ERROR_INTERNAL";
+ break;
+ }
+ LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
+ return ret;
}
/*
int mediacodec_create(mediacodec_h *mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle;
- int ret;
-
- LOGD("mediacodec_create..");
-
- handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
- if (handle != NULL) {
- memset(handle, 0 , sizeof(mediacodec_s));
- } else {
- LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
- return MEDIACODEC_ERROR_OUT_OF_MEMORY;
- }
-
- ret = mc_create(&handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE) {
- LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
- handle->state = MEDIACODEC_STATE_NONE;
- free(handle);
- handle = NULL;
- return MEDIACODEC_ERROR_INVALID_OPERATION;
- } else {
- *mediacodec = (mediacodec_h)handle;
- handle->state = MEDIACODEC_STATE_IDLE;
- LOGD("new handle : %p", *mediacodec);
- }
-
- /* set callback */
- mc_set_empty_buffer_cb(handle->mc_handle, (mediacodec_input_buffer_used_cb)__mediacodec_empty_buffer_cb, handle);
- mc_set_fill_buffer_cb(handle->mc_handle, (mediacodec_output_buffer_available_cb)__mediacodec_fill_buffer_cb, handle);
- mc_set_error_cb(handle->mc_handle, (mediacodec_error_cb)__mediacodec_error_cb, handle);
- mc_set_eos_cb(handle->mc_handle, (mediacodec_eos_cb)__mediacodec_eos_cb, handle);
- mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
- mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
-
- return MEDIACODEC_ERROR_NONE;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle;
+ int ret;
+
+ LOGD("mediacodec_create..");
+
+ handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
+ if (handle != NULL) {
+ memset(handle, 0 , sizeof(mediacodec_s));
+ } else {
+ LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
+ return MEDIACODEC_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = mc_create(&handle->mc_handle);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
+ handle->state = MEDIACODEC_STATE_NONE;
+ free(handle);
+ handle = NULL;
+ return MEDIACODEC_ERROR_INVALID_OPERATION;
+ } else {
+ *mediacodec = (mediacodec_h)handle;
+ handle->state = MEDIACODEC_STATE_IDLE;
+ LOGD("new handle : %p", *mediacodec);
+ }
+
+ /* set callback */
+ mc_set_empty_buffer_cb(handle->mc_handle, (mediacodec_input_buffer_used_cb)__mediacodec_empty_buffer_cb, handle);
+ mc_set_fill_buffer_cb(handle->mc_handle, (mediacodec_output_buffer_available_cb)__mediacodec_fill_buffer_cb, handle);
+ mc_set_error_cb(handle->mc_handle, (mediacodec_error_cb)__mediacodec_error_cb, handle);
+ mc_set_eos_cb(handle->mc_handle, (mediacodec_eos_cb)__mediacodec_eos_cb, handle);
+ mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
+ mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
+
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_destroy(mediacodec_h mediacodec)
{
- LOGD("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
-
- int ret = mc_destroy(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE) {
- LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
- return MEDIACODEC_ERROR_INVALID_OPERATION;
- } else {
- handle->state = MEDIACODEC_STATE_NONE;
- free(handle);
- handle = NULL;
- return MEDIACODEC_ERROR_NONE;
- }
+ LOGD("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+
+ int ret = mc_destroy(handle->mc_handle);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
+ return MEDIACODEC_ERROR_INVALID_OPERATION;
+ } else {
+ handle->state = MEDIACODEC_STATE_NONE;
+ free(handle);
+ handle = NULL;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_set_codec(mediacodec_h mediacodec, mediacodec_codec_type_e codec_id, int flags)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_set_vdec_info(mediacodec_h mediacodec, int width, int height)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_set_vdec_info(handle->mc_handle, width, height);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_set_vdec_info(handle->mc_handle, width, height);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_set_venc_info(mediacodec_h mediacodec, int width, int height, int fps, int target_bits)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_set_adec_info(mediacodec_h mediacodec, int samplerate, int channel, int bit)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_set_aenc_info(mediacodec_h mediacodec, int samplerate, int channel, int bit, int bitrate)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_prepare(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_prepare(handle->mc_handle);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_READY;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_prepare(handle->mc_handle);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_READY;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_unprepare(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- int ret = mc_unprepare(handle->mc_handle);
+ int ret = mc_unprepare(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
+ }
}
int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
- int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
+ int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- return MEDIACODEC_ERROR_NONE;
- }
+ if (ret != MEDIACODEC_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ else
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
- int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
+ int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- return MEDIACODEC_ERROR_NONE;
- }
+ if (ret != MEDIACODEC_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ else
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_flush_buffers(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- int ret = mc_flush_buffers(handle->mc_handle);
+ int ret = mc_flush_buffers(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- return MEDIACODEC_ERROR_NONE;
- }
+ if (ret != MEDIACODEC_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ else
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
-
- int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
-
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- handle->state = MEDIACODEC_STATE_IDLE;
- return MEDIACODEC_ERROR_NONE;
- }
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+
+ int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
+
+ if (ret != MEDIACODEC_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ else
+ handle->state = MEDIACODEC_STATE_IDLE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
- handle->empty_buffer_cb = callback;
- handle->empty_buffer_cb_userdata = user_data;
+ handle->empty_buffer_cb = callback;
+ handle->empty_buffer_cb_userdata = user_data;
- LOGD("set empty_buffer_cb(%p)", callback);
+ LOGD("set empty_buffer_cb(%p)", callback);
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->empty_buffer_cb = NULL;
- handle->empty_buffer_cb_userdata = NULL;
+ handle->empty_buffer_cb = NULL;
+ handle->empty_buffer_cb_userdata = NULL;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
- handle->fill_buffer_cb = callback;
- handle->fill_buffer_cb_userdata = user_data;
+ handle->fill_buffer_cb = callback;
+ handle->fill_buffer_cb_userdata = user_data;
- LOGD("set fill_buffer_cb(%p)", callback);
+ LOGD("set fill_buffer_cb(%p)", callback);
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->fill_buffer_cb = NULL;
- handle->fill_buffer_cb_userdata = NULL;
+ handle->fill_buffer_cb = NULL;
+ handle->fill_buffer_cb_userdata = NULL;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
- handle->error_cb = callback;
- handle->error_cb_userdata = user_data;
+ handle->error_cb = callback;
+ handle->error_cb_userdata = user_data;
- LOGD("set error_cb(%p)", callback);
+ LOGD("set error_cb(%p)", callback);
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unset_error_cb(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->error_cb = NULL;
- handle->error_cb_userdata = NULL;
+ handle->error_cb = NULL;
+ handle->error_cb_userdata = NULL;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
- handle->eos_cb = callback;
- handle->eos_cb_userdata = user_data;
+ handle->eos_cb = callback;
+ handle->eos_cb_userdata = user_data;
- LOGD("set eos_cb(%p)", callback);
+ LOGD("set eos_cb(%p)", callback);
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->eos_cb = NULL;
- handle->eos_cb_userdata = NULL;
+ handle->eos_cb = NULL;
+ handle->eos_cb_userdata = NULL;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
- handle->buffer_status_cb = callback;
- handle->buffer_status_cb_userdata = user_data;
+ handle->buffer_status_cb = callback;
+ handle->buffer_status_cb_userdata = user_data;
- LOGD("set buffer_status_cb(%p)", callback);
+ LOGD("set buffer_status_cb(%p)", callback);
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->buffer_status_cb = NULL;
- handle->buffer_status_cb_userdata = NULL;
+ handle->buffer_status_cb = NULL;
+ handle->buffer_status_cb_userdata = NULL;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
- MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s *handle = (mediacodec_s *)mediacodec;
+ MEDIACODEC_INSTANCE_CHECK(mediacodec);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
- handle->supported_codec_cb = callback;
- handle->supported_codec_cb_userdata = user_data;
+ handle->supported_codec_cb = callback;
+ handle->supported_codec_cb_userdata = user_data;
- LOGD("set supported_codec_cb(%p)", callback);
- int ret = _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle);
+ LOGD("set supported_codec_cb(%p)", callback);
+ int ret = _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle);
- if (ret != MEDIACODEC_ERROR_NONE) {
- return __convert_error_code(ret, (char *)__FUNCTION__);
- } else {
- return MEDIACODEC_ERROR_NONE;
- }
+ if (ret != MEDIACODEC_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ else
+ return MEDIACODEC_ERROR_NONE;
- return MEDIACODEC_ERROR_NONE;
+ return MEDIACODEC_ERROR_NONE;
}
static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
{
- if (user_data == NULL || pkt == NULL)
- return 0;
+ if (user_data == NULL || pkt == NULL)
+ return 0;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if (handle->empty_buffer_cb) {
- ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
- }
+ if (handle->empty_buffer_cb)
+ ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
- return 1;
+ return 1;
}
static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
{
- if (user_data == NULL || pkt == NULL)
- return 0;
+ if (user_data == NULL || pkt == NULL)
+ return 0;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if (handle->fill_buffer_cb) {
- ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
- }
+ if (handle->fill_buffer_cb)
+ ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
- return 1;
+ return 1;
}
static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
{
- if (user_data == NULL)
- return 0;
+ if (user_data == NULL)
+ return 0;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if (handle->error_cb) {
- ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
- }
+ if (handle->error_cb)
+ ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
- return 1;
+ return 1;
}
static gboolean __mediacodec_eos_cb(void *user_data)
{
- if (user_data == NULL)
- return 0;
+ if (user_data == NULL)
+ return 0;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if (handle->eos_cb) {
- ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
- }
+ if (handle->eos_cb)
+ ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
- return 1;
+ return 1;
}
static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
{
- if (user_data == NULL)
- return 0;
+ if (user_data == NULL)
+ return 0;
+
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ if (handle->supported_codec_cb)
+ return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
- if (handle->supported_codec_cb) {
- return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
- }
- return false;
+ return false;
}
static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
{
- if (user_data == NULL)
- return 0;
+ if (user_data == NULL)
+ return 0;
- mediacodec_s *handle = (mediacodec_s *)user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if (handle->buffer_status_cb) {
- ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
- }
+ if (handle->buffer_status_cb)
+ ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
- return 1;
+ return 1;
}
void mc_init_bits(mc_bitstream_t *stream, unsigned char *data, int size)
{
- stream->data = data;
- stream->numBytes = size;
- stream->bitcnt = 32;
- stream->bytePos = 0;
- stream->dataBitPos = 0;
- stream->buffer = 0;
+ stream->data = data;
+ stream->numBytes = size;
+ stream->bitcnt = 32;
+ stream->bytePos = 0;
+ stream->dataBitPos = 0;
+ stream->buffer = 0;
}
short mc_show_bits(mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData)
{
- unsigned char *bits;
- unsigned int dataBitPos = stream->dataBitPos;
- unsigned int bitcnt = stream->bitcnt;
- unsigned int dataBytePos;
- unsigned int i;
-
- if (nbits > (32 - bitcnt)) {
- dataBytePos = dataBitPos >> 3;
- bitcnt = dataBitPos & 7;
- if (dataBytePos > stream->numBytes - 4) {
- stream->buffer = 0;
- for (i = 0; i < stream->numBytes - dataBytePos; i++) {
- stream->buffer |= stream->data[dataBytePos + i];
- stream->buffer <<= 8;
- }
- stream->buffer <<= 8 * (3 - i);
- } else {
- bits = &stream->data[dataBytePos];
- stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
- }
- stream->bitcnt = bitcnt;
- }
- bitcnt += nbits;
-
- *pulOutData = (stream->buffer >> (32 - bitcnt)) & mask[(unsigned short)nbits];
-
- return 0;
+ unsigned char *bits;
+ unsigned int dataBitPos = stream->dataBitPos;
+ unsigned int bitcnt = stream->bitcnt;
+ unsigned int dataBytePos;
+ unsigned int i;
+
+ if (nbits > (32 - bitcnt)) {
+ dataBytePos = dataBitPos >> 3;
+ bitcnt = dataBitPos & 7;
+ if (dataBytePos > stream->numBytes - 4) {
+ stream->buffer = 0;
+ for (i = 0; i < stream->numBytes - dataBytePos; i++) {
+ stream->buffer |= stream->data[dataBytePos + i];
+ stream->buffer <<= 8;
+ }
+ stream->buffer <<= 8 * (3 - i);
+ } else {
+ bits = &stream->data[dataBytePos];
+ stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
+ }
+ stream->bitcnt = bitcnt;
+ }
+ bitcnt += nbits;
+
+ *pulOutData = (stream->buffer >> (32 - bitcnt)) & mask[(unsigned short)nbits];
+
+ return 0;
}
short mc_read_bits(mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData)
{
- unsigned char *bits;
- unsigned int dataBitPos = stream->dataBitPos;
- unsigned int bitcnt = stream->bitcnt;
- unsigned int dataBytePos;
+ unsigned char *bits;
+ unsigned int dataBitPos = stream->dataBitPos;
+ unsigned int bitcnt = stream->bitcnt;
+ unsigned int dataBytePos;
- if ((dataBitPos + nbits) > (stream->numBytes << 3)) {
- *pulOutData = 0;
- return -1;
- }
+ if ((dataBitPos + nbits) > (stream->numBytes << 3)) {
+ *pulOutData = 0;
+ return -1;
+ }
- if (nbits > (32 - bitcnt)) {
- dataBytePos = dataBitPos >> 3;
- bitcnt = dataBitPos & 7;
- bits = &stream->data[dataBytePos];
- stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
- }
+ if (nbits > (32 - bitcnt)) {
+ dataBytePos = dataBitPos >> 3;
+ bitcnt = dataBitPos & 7;
+ bits = &stream->data[dataBytePos];
+ stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
+ }
- stream->dataBitPos += nbits;
- stream->bitcnt = (unsigned char)(bitcnt + nbits);
+ stream->dataBitPos += nbits;
+ stream->bitcnt = (unsigned char)(bitcnt + nbits);
- *pulOutData = (stream->buffer >> (32 - stream->bitcnt)) & mask[(unsigned short)nbits];
+ *pulOutData = (stream->buffer >> (32 - stream->bitcnt)) & mask[(unsigned short)nbits];
- return 0;
+ return 0;
}
short mc_byte_align(mc_bitstream_t *stream)
{
- unsigned char *bits;
- unsigned int dataBitPos = stream->dataBitPos;
- unsigned int bitcnt = stream->bitcnt;
- unsigned int dataBytePos;
- unsigned int leftBits;
-
- leftBits = 8 - (dataBitPos & 0x7);
- if (leftBits == 8) {
- if ((dataBitPos + 8) > (unsigned int)(stream->numBytes << 3))
- return (-1);
- dataBitPos += 8;
- bitcnt += 8;
- } else {
- dataBytePos = dataBitPos >> 3;
- dataBitPos += leftBits;
- bitcnt += leftBits;
- }
-
- if (bitcnt > 32) {
- dataBytePos = dataBitPos >> 3;
- bits = &stream->data[dataBytePos];
- stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
- }
-
-
- stream->dataBitPos = dataBitPos;
- stream->bitcnt = bitcnt;
-
- return 0;
+ unsigned char *bits;
+ unsigned int dataBitPos = stream->dataBitPos;
+ unsigned int bitcnt = stream->bitcnt;
+ unsigned int dataBytePos;
+ unsigned int leftBits;
+
+ leftBits = 8 - (dataBitPos & 0x7);
+ if (leftBits == 8) {
+ if ((dataBitPos + 8) > (unsigned int)(stream->numBytes << 3))
+ return (-1);
+ dataBitPos += 8;
+ bitcnt += 8;
+ } else {
+ dataBytePos = dataBitPos >> 3;
+ dataBitPos += leftBits;
+ bitcnt += leftBits;
+ }
+
+ if (bitcnt > 32) {
+ dataBytePos = dataBitPos >> 3;
+ bits = &stream->data[dataBytePos];
+ stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
+ }
+
+
+ stream->dataBitPos = dataBitPos;
+ stream->bitcnt = bitcnt;
+
+ return 0;
}
unsigned int __mc_bytestream_to_nal(unsigned char *data, int size)
{
- unsigned char val, zero_count;
- unsigned char *pNal = data;
- int index = 0;
+ unsigned char val, zero_count;
+ unsigned char *pNal = data;
+ int index = 0;
- zero_count = 0;
+ zero_count = 0;
- val = pNal[index++];
- while (!val) {
- zero_count++;
- val = pNal[index++];
- }
+ val = pNal[index++];
+ while (!val) {
+ zero_count++;
+ val = pNal[index++];
+ }
- zero_count = 0;
+ zero_count = 0;
- while (1) {
- if (index >= size)
- return (index - 1);
+ while (1) {
+ if (index >= size)
+ return (index - 1);
- val = pNal[index++];
+ val = pNal[index++];
- if (!val)
- zero_count++;
- else {
- if ((zero_count >= 2) && (val == 1))
- break;
- else {
- zero_count = 0;
- }
- }
- }
+ if (!val)
+ zero_count++;
+ else {
+ if ((zero_count >= 2) && (val == 1))
+ break;
+ else
+ zero_count = 0;
+ }
+ }
- if (zero_count > 3)
- zero_count = 3;
+ if (zero_count > 3)
+ zero_count = 3;
- return (index - zero_count - 1);
+ return (index - zero_count - 1);
}
int __mc_decode_sps(mc_bitstream_t *pstream, int *width, int *height)
{
- int ret = MC_ERROR_NONE;
- unsigned int tmp = 0;
+ int ret = MC_ERROR_NONE;
+ unsigned int tmp = 0;
- int profile_idc = 0;
+ int profile_idc = 0;
- mc_read_bits(pstream, 8, &tmp);
- mc_read_bits(pstream, 1, &tmp);
- mc_read_bits(pstream, 1, &tmp);
- mc_read_bits(pstream, 1, &tmp);
- mc_read_bits(pstream, 5, &tmp);
- mc_read_bits(pstream, 8, &tmp);
+ mc_read_bits(pstream, 8, &tmp);
+ mc_read_bits(pstream, 1, &tmp);
+ mc_read_bits(pstream, 1, &tmp);
+ mc_read_bits(pstream, 1, &tmp);
+ mc_read_bits(pstream, 5, &tmp);
+ mc_read_bits(pstream, 8, &tmp);
- profile_idc = tmp;
+ profile_idc = tmp;
- if (profile_idc > 51)
- ret = MC_INVALID_IN_BUF;
+ if (profile_idc > 51)
+ ret = MC_INVALID_IN_BUF;
- /*TODO parse width, height, etc...*/
+ /*TODO parse width, height, etc...*/
- return ret;
+ return ret;
}
int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bool *codec_config, bool *sync_flag, bool *slice)
{
- int ret = MC_ERROR_NONE;
- int stacked_length = 0;
- int nal_length = 0;
- unsigned int syntax = 0;
- unsigned int state = 0;
- int count = 0;
- int nal_unit_type = 0;
-
- mc_bitstream_t pstream;
-
- nal_unit_type = nal[2] == 1 ? (nal[3] & 0x1F) : (nal[4] & 0x1F);
-
- if (nal_unit_type == 0x7 || nal_unit_type == 0x8 || nal_unit_type == 0x9) {
-
- while (1) {
- nal_length = __mc_bytestream_to_nal(nal + stacked_length, byte_length - stacked_length);
-
- mc_init_bits(&pstream, nal + stacked_length, byte_length - stacked_length);
- mc_read_bits(&pstream, 32, &syntax);
- mc_read_bits(&pstream, 8, &syntax);
-
- switch (syntax & 0x1F) {
- case NAL_SEQUENCE_PARAMETER_SET:
- LOGD("nal_unit_type : SPS");
- if ((ret = __mc_decode_sps(&pstream, NULL, NULL)) != MC_ERROR_NONE)
- return ret;
- state |= MC_EXIST_SPS;
- break;
- case NAL_PICTURE_PARAMETER_SET:
- LOGD("nal_unit_type : PPS");
- state |= MC_EXIST_PPS;
- break;
- case NAL_SLICE_IDR:
- LOGD("nal_unit_type : IDR");
- state |= MC_EXIST_IDR;
- break;
- default:
- state |= MC_EXIST_SLICE;
- LOGD("nal_unit_type : %x", syntax & 0x1F);
- break;
- }
-
- LOGD("stacked_length : %d, nal_length : %d, byte_length : %d", stacked_length, nal_length, byte_length);
-
- stacked_length += nal_length;
- count++;
-
- if ((stacked_length >= byte_length) || count > 5)
- break;
- }
- } else if (nal_unit_type == 0x5) {
- state |= MC_EXIST_IDR;
- LOGD("nal_unit_type is IDR");
- } else if (nal_unit_type == 0x01 || nal_unit_type == 0x02 || nal_unit_type == 0x03 || nal_unit_type == 0x04) {
- state |= MC_EXIST_SLICE;
- LOGD("nal_unit_type : %x", nal_unit_type);
- } else {
- LOGD("Non VCL");
- }
-
- LOGD("for debug state :%d, %d", state, MC_VALID_FIRST_SLICE);
-
- /* input port */
- if (!port && !CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE))
- return MC_INVALID_IN_BUF;
-
- /* output port */
- if (port) {
- *codec_config = CHECK_VALID_PACKET(state, MC_VALID_HEADER) ? 1 : 0;
- *sync_flag = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
- *slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 : 0;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ int stacked_length = 0;
+ int nal_length = 0;
+ unsigned int syntax = 0;
+ unsigned int state = 0;
+ int count = 0;
+ int nal_unit_type = 0;
+
+ mc_bitstream_t pstream;
+
+ nal_unit_type = nal[2] == 1 ? (nal[3] & 0x1F) : (nal[4] & 0x1F);
+
+ if (nal_unit_type == 0x7 || nal_unit_type == 0x8 || nal_unit_type == 0x9) {
+
+ while (1) {
+ nal_length = __mc_bytestream_to_nal(nal + stacked_length, byte_length - stacked_length);
+
+ mc_init_bits(&pstream, nal + stacked_length, byte_length - stacked_length);
+ mc_read_bits(&pstream, 32, &syntax);
+ mc_read_bits(&pstream, 8, &syntax);
+
+ switch (syntax & 0x1F) {
+ case NAL_SEQUENCE_PARAMETER_SET:
+ LOGD("nal_unit_type : SPS");
+ if ((ret = __mc_decode_sps(&pstream, NULL, NULL)) != MC_ERROR_NONE)
+ return ret;
+ state |= MC_EXIST_SPS;
+ break;
+ case NAL_PICTURE_PARAMETER_SET:
+ LOGD("nal_unit_type : PPS");
+ state |= MC_EXIST_PPS;
+ break;
+ case NAL_SLICE_IDR:
+ LOGD("nal_unit_type : IDR");
+ state |= MC_EXIST_IDR;
+ break;
+ default:
+ state |= MC_EXIST_SLICE;
+ LOGD("nal_unit_type : %x", syntax & 0x1F);
+ break;
+ }
+
+ LOGD("stacked_length : %d, nal_length : %d, byte_length : %d", stacked_length, nal_length, byte_length);
+
+ stacked_length += nal_length;
+ count++;
+
+ if ((stacked_length >= byte_length) || count > 5)
+ break;
+ }
+ } else if (nal_unit_type == 0x5) {
+ state |= MC_EXIST_IDR;
+ LOGD("nal_unit_type is IDR");
+ } else if (nal_unit_type == 0x01 || nal_unit_type == 0x02 || nal_unit_type == 0x03 || nal_unit_type == 0x04) {
+ state |= MC_EXIST_SLICE;
+ LOGD("nal_unit_type : %x", nal_unit_type);
+ } else {
+ LOGD("Non VCL");
+ }
+
+ LOGD("for debug state :%d, %d", state, MC_VALID_FIRST_SLICE);
+
+ /* input port */
+ if (!port && !CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE))
+ return MC_INVALID_IN_BUF;
+
+ /* output port */
+ if (port) {
+ *codec_config = CHECK_VALID_PACKET(state, MC_VALID_HEADER) ? 1 : 0;
+ *sync_flag = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
+ *slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 : 0;
+ }
+
+ return ret;
}
int _mc_check_valid_h263_frame(unsigned char *p, int size)
{
- unsigned char *end = p + size - 3;
- int count = 0;
+ unsigned char *end = p + size - 3;
+ int count = 0;
- do {
- /* Found the start of the frame, now try to find the end */
- if ((p[0] == 0x00) && (p[1] == 0x00) && ((p[2]&0xFC) == 0x80))
- count++;
- p++;
- } while (count == 1 && p < end);
+ do {
+ /* Found the start of the frame, now try to find the end */
+ if ((p[0] == 0x00) && (p[1] == 0x00) && ((p[2]&0xFC) == 0x80))
+ count++;
+ p++;
+ } while (count == 1 && p < end);
- if (count != 1)
- return MC_INVALID_IN_BUF; /* frame boundary violated */
+ if (count != 1)
+ return MC_INVALID_IN_BUF; /* frame boundary violated */
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
bool _mc_is_voss(unsigned char *buf, int size, int *codec_size)
{
- unsigned char *p = buf;
- unsigned char *end = p + size - 3;
- if (size < 4)
- return false;
-
- if (!((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB0)))
- return false;
-
- if (codec_size) {
- for (; p < end ; p++) {
- if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
- *codec_size = p-buf;
- break;
- }
- }
- }
-
- return true;
+ unsigned char *p = buf;
+ unsigned char *end = p + size - 3;
+ if (size < 4)
+ return false;
+
+ if (!((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB0)))
+ return false;
+
+ if (codec_size) {
+ for (; p < end ; p++) {
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
+ *codec_size = p-buf;
+ break;
+ }
+ }
+ }
+
+ return true;
}
bool _mc_is_ivop(unsigned char *p, int size, int pos)
{
- if (size < (pos + 5))
- return false;
-
- p = p + pos;
-
- if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
- /* VOP_CODING_TYPE (binary) Coding method
- // 00 intra-coded (I)
- // 01 predictive-coded (P)
- // 10 bidirectionally-predictive-coded (B)
- // 11 sprite (S)
- */
- if ((p[4] & 0xC0) == 0x0) /*I-VOP */
- return true;
- }
- return false;
+ if (size < (pos + 5))
+ return false;
+
+ p = p + pos;
+
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
+ /* VOP_CODING_TYPE (binary) Coding method
+ // 00 intra-coded (I)
+ // 01 predictive-coded (P)
+ // 10 bidirectionally-predictive-coded (B)
+ // 11 sprite (S)
+ */
+ if ((p[4] & 0xC0) == 0x0) /*I-VOP */
+ return true;
+ }
+ return false;
}
bool _mc_is_vop(unsigned char *p, int size, int pos)
{
- if (size < (pos + 4))
- return false;
+ if (size < (pos + 4))
+ return false;
- p = p + pos;
+ p = p + pos;
- if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6))
- return true;
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6))
+ return true;
- return false;
+ return false;
}
int _mc_check_mpeg4_out_bytestream(unsigned char *buf, int buf_length, bool* need_codec_data, bool *need_sync_flag)
{
- int codec_data_size = 0;
- g_return_val_if_fail(need_codec_data != NULL, MC_PARAM_ERROR);
- g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
+ int codec_data_size = 0;
+ g_return_val_if_fail(need_codec_data != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
- *need_codec_data = FALSE;
- *need_sync_flag = FALSE;
+ *need_codec_data = FALSE;
+ *need_sync_flag = FALSE;
- if (_mc_is_voss(buf, buf_length, &codec_data_size))
- *need_codec_data = TRUE;
- if (_mc_is_ivop(buf, buf_length, codec_data_size))
- *need_sync_flag = TRUE;
+ if (_mc_is_voss(buf, buf_length, &codec_data_size))
+ *need_codec_data = TRUE;
+ if (_mc_is_ivop(buf, buf_length, codec_data_size))
+ *need_sync_flag = TRUE;
- return codec_data_size;
+ return codec_data_size;
}
bool _mc_check_h263_out_bytestream(unsigned char *p, int buf_length, bool* need_sync_flag)
{
- g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
- *need_sync_flag = FALSE;
+ *need_sync_flag = FALSE;
- /* PSC not present */
- if ((p[0] != 0x00) || (p[1] != 0x00) || ((p[2]&0xFC) != 0x80)) {
- return false;
- }
+ /* PSC not present */
+ if ((p[0] != 0x00) || (p[1] != 0x00) || ((p[2]&0xFC) != 0x80))
+ return false;
- /* PTYPE Field, Bit 9: Picture Coding Type, "0" INTRA (I-picture), "1" INTER (P-picture) */
- if (!(p[4] & 0x2)) {
- *need_sync_flag = TRUE;
- }
+ /* PTYPE Field, Bit 9: Picture Coding Type, "0" INTRA (I-picture), "1" INTER (P-picture) */
+ if (!(p[4] & 0x2))
+ *need_sync_flag = TRUE;
- return TRUE;
+ return TRUE;
}
#define DEFAULT_SW_ENCODER_FORMAT ""
typedef struct {
- gchar cname[MEDIA_CODEC_INI_MAX_STRLEN];
- mediacodec_codec_type_e ctype;
-}codec_list_t;
-
-static codec_list_t general_codec_list[]={
- {"h261", MEDIACODEC_H261},
- {"h263", MEDIACODEC_H263},
- {"h264", MEDIACODEC_H264},
- {"mjpeg", MEDIACODEC_MJPEG},
- {"mpeg1", MEDIACODEC_MPEG1},
- {"mpeg2", MEDIACODEC_MPEG2},
- {"mpeg4", MEDIACODEC_MPEG4},
- {"hevc", MEDIACODEC_HEVC},
- {"vp8", MEDIACODEC_VP8},
- {"vp9", MEDIACODEC_VP9},
- {"vc1", MEDIACODEC_VC1},
- {"aac_lc", MEDIACODEC_AAC_LC},
- {"aac_he", MEDIACODEC_AAC_HE},
- {"aac_he_ps", MEDIACODEC_AAC_HE_PS},
- {"mp3", MEDIACODEC_MP3},
- {"amr_nb", MEDIACODEC_AMR_NB},
- {"amr_wb", MEDIACODEC_AMR_WB},
- {"vorbis", MEDIACODEC_VORBIS},
- {"flac", MEDIACODEC_FLAC},
- {"wmav1", MEDIACODEC_WMAV1},
- {"wmav2", MEDIACODEC_WMAV2},
- {"wmapro", MEDIACODEC_WMAPRO},
+ gchar cname[MEDIA_CODEC_INI_MAX_STRLEN];
+ mediacodec_codec_type_e ctype;
+} codec_list_t;
+
+static codec_list_t general_codec_list[] = {
+ {"h261", MEDIACODEC_H261},
+ {"h263", MEDIACODEC_H263},
+ {"h264", MEDIACODEC_H264},
+ {"mjpeg", MEDIACODEC_MJPEG},
+ {"mpeg1", MEDIACODEC_MPEG1},
+ {"mpeg2", MEDIACODEC_MPEG2},
+ {"mpeg4", MEDIACODEC_MPEG4},
+ {"hevc", MEDIACODEC_HEVC},
+ {"vp8", MEDIACODEC_VP8},
+ {"vp9", MEDIACODEC_VP9},
+ {"vc1", MEDIACODEC_VC1},
+ {"aac_lc", MEDIACODEC_AAC_LC},
+ {"aac_he", MEDIACODEC_AAC_HE},
+ {"aac_he_ps", MEDIACODEC_AAC_HE_PS},
+ {"mp3", MEDIACODEC_MP3},
+ {"amr_nb", MEDIACODEC_AMR_NB},
+ {"amr_wb", MEDIACODEC_AMR_WB},
+ {"vorbis", MEDIACODEC_VORBIS},
+ {"flac", MEDIACODEC_FLAC},
+ {"wmav1", MEDIACODEC_WMAV1},
+ {"wmav2", MEDIACODEC_WMAV2},
+ {"wmapro", MEDIACODEC_WMAPRO},
};
/* internal functions, macros here */
static void _mc_ini_check_ini_status(void);
/* macro */
-#define MEDIA_CODEC_INI_GET_STRING( x_dict, x_item, x_ini, x_default ) \
- do \
-{ \
- gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
- \
- if ( str && \
- ( strlen( str ) > 0 ) && \
- ( strlen( str ) < MEDIA_CODEC_INI_MAX_STRLEN ) ) \
- { \
- strcpy ( x_item, str ); \
- } \
- else \
- { \
- strcpy ( x_item, x_default ); \
- } \
-}while(0)
-
-#define MEDIA_CODEC_INI_GET_STRING_FROM_LIST( x_dict, x_list, x_ini, x_default ) \
- do \
-{ \
- char *token = NULL; \
- char *usr_ptr = NULL; \
- int index = 0; \
- const char *delimiters = " ,"; \
- gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
- MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
- token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
- while (token) \
- { \
- if (index == 0) \
- strncpy(x_list.name,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
- else if (index == 1) \
- strncpy(x_list.mime,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
- else if (index == 2) \
- strncpy(x_list.format,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
- index++;\
- token = strtok_r( NULL, delimiters, &usr_ptr ); \
- } \
-}while(0)
-
-#define MEDIA_CODEC_INI_GET_COLOR( x_dict, x_item, x_ini, x_default ) \
- do \
-{ \
- gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
- \
- if ( str && \
- ( strlen( str ) > 0 ) && \
- ( strlen( str ) < MEDIA_CODEC_INI_MAX_STRLEN ) ) \
- { \
- x_item = (guint) strtoul(str, NULL, 16); \
- } \
- else \
- { \
- x_item = (guint) strtoul(x_default, NULL, 16); \
- } \
-}while(0)
+#define MEDIA_CODEC_INI_GET_STRING(x_dict, x_item, x_ini, x_default) \
+do {\
+ gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
+ \
+ if (str && \
+ (strlen(str) > 0) && \
+ (strlen(str) < MEDIA_CODEC_INI_MAX_STRLEN)) \
+ strcpy(x_item, str); \
+ else \
+ strcpy(x_item, x_default); \
+} while (0)
+
+#define MEDIA_CODEC_INI_GET_STRING_FROM_LIST(x_dict, x_list, x_ini, x_default) \
+do {\
+ char *token = NULL; \
+ char *usr_ptr = NULL; \
+ int index = 0; \
+ const char *delimiters = " ,"; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+ while (token) {\
+ if (index == 0) \
+ strncpy(x_list.name, token, MEDIA_CODEC_INI_MAX_STRLEN-1);\
+ else if (index == 1) \
+ strncpy(x_list.mime, token, MEDIA_CODEC_INI_MAX_STRLEN-1);\
+ else if (index == 2) \
+ strncpy(x_list.format, token, MEDIA_CODEC_INI_MAX_STRLEN-1);\
+ index++;\
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
+ } \
+} while (0)
+
+#define MEDIA_CODEC_INI_GET_COLOR(x_dict, x_item, x_ini, x_default) \
+do {\
+ gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
+ \
+ if (str && \
+ (strlen(str) > 0) && \
+ (strlen(str) < MEDIA_CODEC_INI_MAX_STRLEN)) \
+ x_item = (guint) strtoul(str, NULL, 16); \
+ else \
+ x_item = (guint) strtoul(x_default, NULL, 16); \
+} while (0)
/* x_ini is the list of index to set TRUE at x_list[index] */
-#define MEDIA_CODEC_INI_GET_BOOLEAN_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
- do \
-{ \
- int index = 0; \
- const char *delimiters = " ,"; \
- char *usr_ptr = NULL; \
- char *token = NULL; \
- gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
- MEDIA_CODEC_INI_GET_STRING( x_dict, temp_arr, x_ini, x_default); \
- token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
- while (token) \
- { \
- index = atoi(token); \
- if (index < 0 || index > x_list_max -1) \
- { \
- LOGW("%d is not valid index\n", index); \
- } \
- else \
- { \
- x_list[index] = TRUE; \
- } \
- token = strtok_r( NULL, delimiters, &usr_ptr ); \
- } \
-}while(0)
+#define MEDIA_CODEC_INI_GET_BOOLEAN_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
+do {\
+ int index = 0; \
+ const char *delimiters = " ,"; \
+ char *usr_ptr = NULL; \
+ char *token = NULL; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+ while (token) {\
+ index = atoi(token); \
+ if (index < 0 || index > x_list_max -1) \
+ LOGW("%d is not valid index\n", index); \
+ else \
+ x_list[index] = TRUE; \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
+ } \
+} while (0)
/* x_ini is the list of value to be set at x_list[index] */
-#define MEDIA_CODEC_INI_GET_INT_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
- do \
-{ \
- int index = 0; \
- int value = 0; \
- const char *delimiters = " ,"; \
- char *usr_ptr = NULL; \
- char *token = NULL; \
- gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
- MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
- token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
- while (token) \
- { \
- if ( index > x_list_max -1) \
- { \
- LOGE("%d is not valid index\n", index); \
- break; \
- } \
- else \
- { \
- value = atoi(token); \
- x_list[index] = value; \
- index++; \
- } \
- token = strtok_r( NULL, delimiters, &usr_ptr ); \
- } \
-}while(0)
-
-#define MEDIA_CODEC_GET_DEFAULT_LIST( x_list, x_default ) \
- do \
-{ \
- strncpy( x_list, x_default, MEDIA_CODEC_INI_MAX_STRLEN - 1);\
-}while(0)
-#define MEDIA_CODEC_PRINT_LIST( x_list, x_message ) \
- do \
-{ \
- codec_info_t codec_list= x_list;\
- printf("%s =", x_message);\
- printf("%s %s %s\n", codec_list.name, codec_list.mime, codec_list.format);\
-}while(0)
-
-media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat )
+#define MEDIA_CODEC_INI_GET_INT_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
+do {\
+ int index = 0; \
+ int value = 0; \
+ const char *delimiters = " ,"; \
+ char *usr_ptr = NULL; \
+ char *token = NULL; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+ while (token) {\
+ if (index > x_list_max -1) {\
+ LOGE("%d is not valid index\n", index); \
+ break; \
+ } \
+ else {\
+ value = atoi(token); \
+ x_list[index] = value; \
+ index++; \
+ } \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
+ } \
+} while (0)
+
+#define MEDIA_CODEC_GET_DEFAULT_LIST(x_list, x_default) \
+do {\
+ strncpy(x_list, x_default, MEDIA_CODEC_INI_MAX_STRLEN - 1);\
+} while (0)
+#define MEDIA_CODEC_PRINT_LIST(x_list, x_message) \
+do {\
+ codec_info_t codec_list = x_list;\
+ LOGW("%s =", x_message);\
+ LOGW("%s %s %s\n", codec_list.name, codec_list.mime, codec_list.format);\
+} while (0)
+
+media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat)
{
- media_format_mimetype_e iformat = MEDIA_FORMAT_I420;
- if (!strcmp(sformat,"I420")) {
- iformat = MEDIA_FORMAT_I420;
- goto endf;
- } else if (!strcmp(sformat,"NV12")) {
- iformat = MEDIA_FORMAT_NV12;
- goto endf;
- } else if (!strcmp(sformat,"NV12T")) {
- iformat = MEDIA_FORMAT_NV12T;
- goto endf;
- } else if (!strcmp(sformat,"YV12")) {
- iformat = MEDIA_FORMAT_YV12;
- goto endf;
- } else if (!strcmp(sformat,"NV21")) {
- iformat = MEDIA_FORMAT_NV21;
- goto endf;
- } else if (!strcmp(sformat,"NV16")) {
- iformat = MEDIA_FORMAT_NV16;
- } else if (!strcmp(sformat,"YUYV")) {
- iformat = MEDIA_FORMAT_YUYV;
- goto endf;
- } else if (!strcmp(sformat,"UYVY")) {
- iformat = MEDIA_FORMAT_UYVY;
- goto endf;
- } else if (!strcmp(sformat,"422P")) {
- iformat = MEDIA_FORMAT_422P;
- goto endf;
- } else if (!strcmp(sformat,"RGB565")) {
- iformat = MEDIA_FORMAT_RGB565;
- goto endf;
- } else if (!strcmp(sformat,"RGB888")) {
- iformat = MEDIA_FORMAT_RGB888;
- goto endf;
- } else if (!strcmp(sformat,"RGBA")) {
- iformat = MEDIA_FORMAT_RGBA;
- goto endf;
- } else if (!strcmp(sformat,"ARGB")) {
- iformat = MEDIA_FORMAT_ARGB;
- goto endf;
- } else if (!strcmp(sformat,"PCM")) {
- iformat = MEDIA_FORMAT_PCM;
- goto endf;
- } else if (!strcmp(sformat,"H261")) {
- iformat = MEDIA_FORMAT_H261;
- goto endf;
- } else if (!strcmp(sformat,"H263")) {
- iformat = MEDIA_FORMAT_H263;
- goto endf;
- } else if (!strcmp(sformat,"H263P")) {
- iformat = MEDIA_FORMAT_H263P;
- goto endf;
- } else if (!strcmp(sformat,"H264_SP")) {
- iformat = MEDIA_FORMAT_H264_SP;
- goto endf;
- } else if (!strcmp(sformat,"H264_MP")) {
- iformat = MEDIA_FORMAT_H264_MP;
- goto endf;
- } else if (!strcmp(sformat,"H264_HP")) {
- iformat = MEDIA_FORMAT_H264_HP;
- goto endf;
- } else if (!strcmp(sformat,"MPEG4_SP")) {
- iformat = MEDIA_FORMAT_MPEG4_SP;
- goto endf;
- } else if (!strcmp(sformat,"MPEG4_ASP")) {
- iformat = MEDIA_FORMAT_MPEG4_ASP;
- goto endf;
- } else if (!strcmp(sformat,"AMR_NB")) {
- iformat = MEDIA_FORMAT_AMR_NB;
- goto endf;
- } else if (!strcmp(sformat,"AMR_WB")) {
- iformat = MEDIA_FORMAT_AMR_WB;
- goto endf;
- } else if (!strcmp(sformat,"AAC_LC")) {
- iformat = MEDIA_FORMAT_AAC_LC;
- goto endf;
- } else if (!strcmp(sformat,"AAC_HE")) {
- iformat = MEDIA_FORMAT_AAC_HE;
- goto endf;
- } else if (!strcmp(sformat,"AAC_HE_PS")) {
- iformat = MEDIA_FORMAT_AAC_HE_PS;
- goto endf;
- } else if (!strcmp(sformat,"MP3")) {
- iformat = MEDIA_FORMAT_MP3;
- goto endf;
- } else if (!strcmp(sformat,"VORBIS")) {
- iformat = MEDIA_FORMAT_VORBIS;
- goto endf;
- } else if (!strcmp(sformat,"FLAC")) {
- iformat = MEDIA_FORMAT_FLAC;
- goto endf;
- } else if (!strcmp(sformat,"WMAV1")) {
- iformat = MEDIA_FORMAT_WMAV1;
- goto endf;
- } else if (!strcmp(sformat,"WMAV2")) {
- iformat = MEDIA_FORMAT_WMAV2;
- goto endf;
- } else if (!strcmp(sformat,"WMAPRO")) {
- iformat = MEDIA_FORMAT_WMAPRO;
- goto endf;
- }
+ media_format_mimetype_e iformat = MEDIA_FORMAT_I420;
+ if (!strcmp(sformat, "I420")) {
+ iformat = MEDIA_FORMAT_I420;
+ goto endf;
+ } else if (!strcmp(sformat, "NV12")) {
+ iformat = MEDIA_FORMAT_NV12;
+ goto endf;
+ } else if (!strcmp(sformat, "NV12T")) {
+ iformat = MEDIA_FORMAT_NV12T;
+ goto endf;
+ } else if (!strcmp(sformat, "YV12")) {
+ iformat = MEDIA_FORMAT_YV12;
+ goto endf;
+ } else if (!strcmp(sformat, "NV21")) {
+ iformat = MEDIA_FORMAT_NV21;
+ goto endf;
+ } else if (!strcmp(sformat, "NV16")) {
+ iformat = MEDIA_FORMAT_NV16;
+ } else if (!strcmp(sformat, "YUYV")) {
+ iformat = MEDIA_FORMAT_YUYV;
+ goto endf;
+ } else if (!strcmp(sformat, "UYVY")) {
+ iformat = MEDIA_FORMAT_UYVY;
+ goto endf;
+ } else if (!strcmp(sformat, "422P")) {
+ iformat = MEDIA_FORMAT_422P;
+ goto endf;
+ } else if (!strcmp(sformat, "RGB565")) {
+ iformat = MEDIA_FORMAT_RGB565;
+ goto endf;
+ } else if (!strcmp(sformat, "RGB888")) {
+ iformat = MEDIA_FORMAT_RGB888;
+ goto endf;
+ } else if (!strcmp(sformat, "RGBA")) {
+ iformat = MEDIA_FORMAT_RGBA;
+ goto endf;
+ } else if (!strcmp(sformat, "ARGB")) {
+ iformat = MEDIA_FORMAT_ARGB;
+ goto endf;
+ } else if (!strcmp(sformat, "PCM")) {
+ iformat = MEDIA_FORMAT_PCM;
+ goto endf;
+ } else if (!strcmp(sformat, "H261")) {
+ iformat = MEDIA_FORMAT_H261;
+ goto endf;
+ } else if (!strcmp(sformat, "H263")) {
+ iformat = MEDIA_FORMAT_H263;
+ goto endf;
+ } else if (!strcmp(sformat, "H263P")) {
+ iformat = MEDIA_FORMAT_H263P;
+ goto endf;
+ } else if (!strcmp(sformat, "H264_SP")) {
+ iformat = MEDIA_FORMAT_H264_SP;
+ goto endf;
+ } else if (!strcmp(sformat, "H264_MP")) {
+ iformat = MEDIA_FORMAT_H264_MP;
+ goto endf;
+ } else if (!strcmp(sformat, "H264_HP")) {
+ iformat = MEDIA_FORMAT_H264_HP;
+ goto endf;
+ } else if (!strcmp(sformat, "MPEG4_SP")) {
+ iformat = MEDIA_FORMAT_MPEG4_SP;
+ goto endf;
+ } else if (!strcmp(sformat, "MPEG4_ASP")) {
+ iformat = MEDIA_FORMAT_MPEG4_ASP;
+ goto endf;
+ } else if (!strcmp(sformat, "AMR_NB")) {
+ iformat = MEDIA_FORMAT_AMR_NB;
+ goto endf;
+ } else if (!strcmp(sformat, "AMR_WB")) {
+ iformat = MEDIA_FORMAT_AMR_WB;
+ goto endf;
+ } else if (!strcmp(sformat, "AAC_LC")) {
+ iformat = MEDIA_FORMAT_AAC_LC;
+ goto endf;
+ } else if (!strcmp(sformat, "AAC_HE")) {
+ iformat = MEDIA_FORMAT_AAC_HE;
+ goto endf;
+ } else if (!strcmp(sformat, "AAC_HE_PS")) {
+ iformat = MEDIA_FORMAT_AAC_HE_PS;
+ goto endf;
+ } else if (!strcmp(sformat, "MP3")) {
+ iformat = MEDIA_FORMAT_MP3;
+ goto endf;
+ } else if (!strcmp(sformat, "VORBIS")) {
+ iformat = MEDIA_FORMAT_VORBIS;
+ goto endf;
+ } else if (!strcmp(sformat, "FLAC")) {
+ iformat = MEDIA_FORMAT_FLAC;
+ goto endf;
+ } else if (!strcmp(sformat, "WMAV1")) {
+ iformat = MEDIA_FORMAT_WMAV1;
+ goto endf;
+ } else if (!strcmp(sformat, "WMAV2")) {
+ iformat = MEDIA_FORMAT_WMAV2;
+ goto endf;
+ } else if (!strcmp(sformat, "WMAPRO")) {
+ iformat = MEDIA_FORMAT_WMAPRO;
+ goto endf;
+ }
endf:
- LOGD("sformat : %x", iformat);
- return iformat;
+ LOGD("sformat : %x", iformat);
+ return iformat;
}
int mc_ini_load(mc_ini_t *ini)
{
- gchar cname[256];
- int i = 0;
- dictionary *dict = NULL;
+ gchar cname[256];
+ int i = 0;
+ dictionary *dict = NULL;
- static const int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+ static const int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
- _mc_ini_check_ini_status();
+ _mc_ini_check_ini_status();
- /* first, try to load existing ini file */
- dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
+ /* first, try to load existing ini file */
+ dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
- /* if no file exists. create one with set of default values */
- if (!dict) {
+ /* if no file exists. create one with set of default values */
+ if (!dict) {
#ifdef MEDIA_CODEC_DEFAULT_INI
- LOGD("No inifile found. codec will create default inifile.\n");
- if (FALSE == _generate_default_ini()) {
- LOGW("Creating default inifile failed. Media Codec will use default values.\n");
- } else {
- /* load default ini */
- dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
- }
+ LOGD("No inifile found. codec will create default inifile.\n");
+ if (FALSE == _generate_default_ini()) {
+ LOGW("Creating default inifile failed. Media Codec will use default values.\n");
+ } else {
+ /* load default ini */
+ dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
+ }
#else
- LOGD("No ini file found. \n");
- return LOGERROR_FILE_NOT_FOUND;
+ LOGD("No ini file found. \n");
+ return LOGERROR_FILE_NOT_FOUND;
#endif
- }
-
- /* get ini values */
- memset(ini, 0, sizeof(mc_ini_t));
-
- if (dict) {/* if dict is available */
- /* general */
- MEDIA_CODEC_INI_GET_STRING( dict, ini->port_name, "port_in_use:media_codec_port",DEFAULT_PORT);
- /* codec */
- for (i = 0; i < codec_list; i++) {
- memset(cname, 0x00, 256);
- strcpy(cname, general_codec_list[i].cname);
- int len = strlen(cname);
- ini->codec[i].codec_id = general_codec_list[i].ctype;
- sprintf(cname+len, "%s", ":hw_decoder");
- MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[0], cname, DEFAULT_VALUE);
- sprintf(cname+len, "%s", ":hw_encoder");
- MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[1], cname, DEFAULT_VALUE);
- sprintf(cname+len, "%s", ":sw_decoder");
- MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[2], cname, DEFAULT_VALUE);
- sprintf(cname+len, "%s", ":sw_encoder");
- MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[3], cname, DEFAULT_VALUE);
- }
- } else {/* if dict is not available just fill the structure with default value */
-
- LOGW("failed to load ini. using hardcoded default\n");
- /* general */
- strncpy( ini->port_name, DEFAULT_PORT, MEDIA_CODEC_INI_MAX_STRLEN - 1);
- for (i = 0; i < codec_list; i++) {
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].name, DEFAULT_HW_DECODER_NAME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].mime, DEFAULT_HW_DECODER_MIME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].format, DEFAULT_HW_DECODER_FORMAT);
-
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].name, DEFAULT_HW_ENCODER_NAME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].mime, DEFAULT_HW_ENCODER_MIME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].format, DEFAULT_HW_ENCODER_FORMAT);
-
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].name, DEFAULT_SW_DECODER_NAME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].mime, DEFAULT_SW_DECODER_MIME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].format, DEFAULT_SW_DECODER_FORMAT);
-
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].name, DEFAULT_SW_ENCODER_NAME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].mime, DEFAULT_SW_ENCODER_MIME);
- MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].format, DEFAULT_SW_ENCODER_FORMAT);
- }
- }
-
- if (0 == strcmp(ini->port_name, "GST_PORT"))
- ini->port_type = GST_PORT;
- else {
- LOGE("Invalid port is set to [%s] [%d]\n", ini->port_name,ini->port_type);
- goto ERROR;
- }
- LOGD("The port is set to [%s] [%d]\n", ini->port_name, ini->port_type);
-
- for (i = 0; i < codec_list; i++) {
- memset(cname, 0x00, 256);
- strcpy(cname, general_codec_list[i].cname);
- int len = strlen(cname);
- sprintf(cname+len, "%s", ":hw_decoder");
- MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[0],cname);
- sprintf(cname+len, "%s", ":hw_encoder");
- MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[1],cname);
- sprintf(cname+len, "%s", ":sw_decoder");
- MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[2],cname);
- sprintf(cname+len, "%s", ":sw_encoder");
- MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[3],cname);
- }
-
- /* free dict as we got our own structure */
- iniparser_freedict(dict);
-
- /* dump structure */
- LOGD("codec settings -----------------------------------\n");
-
- /* general */
- LOGD("port_name: %s\n", ini->port_name);
- LOGD("port_type : %d\n", ini->port_type);
-
- return MC_ERROR_NONE;
+ }
+
+ /* get ini values */
+ memset(ini, 0, sizeof(mc_ini_t));
+
+ if (dict) {/* if dict is available */
+ /* general */
+ MEDIA_CODEC_INI_GET_STRING(dict, ini->port_name, "port_in_use:media_codec_port", DEFAULT_PORT);
+ /* codec */
+ for (i = 0; i < codec_list; i++) {
+ memset(cname, 0x00, 256);
+ strcpy(cname, general_codec_list[i].cname);
+ int len = strlen(cname);
+ ini->codec[i].codec_id = general_codec_list[i].ctype;
+ sprintf(cname+len, "%s", ":hw_decoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[0], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":hw_encoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[1], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":sw_decoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[2], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":sw_encoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[3], cname, DEFAULT_VALUE);
+ }
+ } else {/* if dict is not available just fill the structure with default value */
+
+ LOGW("failed to load ini. using hardcoded default\n");
+ /* general */
+ strncpy(ini->port_name, DEFAULT_PORT, MEDIA_CODEC_INI_MAX_STRLEN - 1);
+ for (i = 0; i < codec_list; i++) {
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[0].name, DEFAULT_HW_DECODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[0].mime, DEFAULT_HW_DECODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[0].format, DEFAULT_HW_DECODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[1].name, DEFAULT_HW_ENCODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[1].mime, DEFAULT_HW_ENCODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[1].format, DEFAULT_HW_ENCODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[2].name, DEFAULT_SW_DECODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[2].mime, DEFAULT_SW_DECODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[2].format, DEFAULT_SW_DECODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[3].name, DEFAULT_SW_ENCODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[3].mime, DEFAULT_SW_ENCODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[3].format, DEFAULT_SW_ENCODER_FORMAT);
+ }
+ }
+
+ if (0 == strcmp(ini->port_name, "GST_PORT"))
+ ini->port_type = GST_PORT;
+ else {
+ LOGE("Invalid port is set to [%s] [%d]\n", ini->port_name, ini->port_type);
+ goto ERROR;
+ }
+ LOGD("The port is set to [%s] [%d]\n", ini->port_name, ini->port_type);
+
+ for (i = 0; i < codec_list; i++) {
+ memset(cname, 0x00, 256);
+ strcpy(cname, general_codec_list[i].cname);
+ int len = strlen(cname);
+ sprintf(cname+len, "%s", ":hw_decoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[0], cname);
+ sprintf(cname+len, "%s", ":hw_encoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[1], cname);
+ sprintf(cname+len, "%s", ":sw_decoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[2], cname);
+ sprintf(cname+len, "%s", ":sw_encoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[3], cname);
+ }
+
+ /* free dict as we got our own structure */
+ iniparser_freedict(dict);
+
+ /* dump structure */
+ LOGD("codec settings -----------------------------------\n");
+
+ /* general */
+ LOGD("port_name: %s\n", ini->port_name);
+ LOGD("port_type : %d\n", ini->port_type);
+
+ return MC_ERROR_NONE;
ERROR:
- return MC_COURRPTED_INI;
+ return MC_COURRPTED_INI;
}
static void _mc_ini_check_ini_status(void)
{
- struct stat ini_buff;
-
- if (g_stat(MEDIA_CODEC_INI_DEFAULT_PATH, &ini_buff) < 0) {
- LOGW("failed to get codec ini status\n");
- } else {
- if (ini_buff.st_size < 5) {
- LOGW("codec.ini file size=%d, Corrupted! So, Removed\n", (int)ini_buff.st_size);
-
- if (g_remove(MEDIA_CODEC_INI_DEFAULT_PATH) == -1) {
- LOGE("failed to delete corrupted ini");
- }
- }
- }
+ struct stat ini_buff;
+
+ if (g_stat(MEDIA_CODEC_INI_DEFAULT_PATH, &ini_buff) < 0) {
+ LOGW("failed to get codec ini status\n");
+ } else {
+ if (ini_buff.st_size < 5) {
+ LOGW("codec.ini file size=%d, Corrupted! So, Removed\n", (int)ini_buff.st_size);
+
+ if (g_remove(MEDIA_CODEC_INI_DEFAULT_PATH) == -1)
+ LOGE("failed to delete corrupted ini");
+ }
+ }
}
#ifdef MEDIA_CODEC_DEFAULT_INI
static gboolean _generate_default_ini(void)
{
- FILE *fp = NULL;
- gchar *default_ini = MEDIA_CODEC_DEFAULT_INI;
+ FILE *fp = NULL;
+ gchar *default_ini = MEDIA_CODEC_DEFAULT_INI;
- /* create new file */
- fp = fopen(MEDIA_CODEC_INI_DEFAULT_PATH, "wt");
+ /* create new file */
+ fp = fopen(MEDIA_CODEC_INI_DEFAULT_PATH, "wt");
- if (!fp) {
- return FALSE;
- }
+ if (!fp)
+ return FALSE;
- /* writing default ini file */
- if (strlen(default_ini) !=
- fwrite(default_ini, 1, strlen(default_ini), fp)) {
- fclose(fp);
- return FALSE;
- }
+ /* writing default ini file */
+ if (strlen(default_ini) !=
+ fwrite(default_ini, 1, strlen(default_ini), fp)) {
+ fclose(fp);
+ return FALSE;
+ }
- fclose(fp);
- return TRUE;
+ fclose(fp);
+ return TRUE;
}
#endif
void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
{
- int indx = 0, count = 0;
- int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
- for (indx = 0; indx < codec_list; indx++) {
- if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
- mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
- mediacodec->decoder_map[count].hardware = 1; /* hardware */
- mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[0].name;
- mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[0].mime;
- mediacodec->decoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[0].format);
- count++;
- }
-
- if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
- mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
- mediacodec->decoder_map[count].hardware = 0; /* software */
- mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[2].name;
- mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[2].mime;
- mediacodec->decoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[2].format);
- count++;
- }
- }
- mediacodec->num_supported_decoder = count;
- return;
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+ for (indx = 0; indx < codec_list; indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
+ mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->decoder_map[count].hardware = 1; /* hardware */
+ mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[0].name;
+ mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[0].mime;
+ mediacodec->decoder_map[count].type.out_format =
+ _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[0].format);
+ count++;
+ }
+
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
+ mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->decoder_map[count].hardware = 0; /* software */
+ mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[2].name;
+ mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[2].mime;
+ mediacodec->decoder_map[count].type.out_format =
+ _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[2].format);
+ count++;
+ }
+ }
+ mediacodec->num_supported_decoder = count;
+ return;
}
void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
{
- int indx = 0, count = 0;
- int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
-
- for (indx=0;indx < codec_list; indx++) {
- if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
- mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
- mediacodec->encoder_map[count].hardware = 1;
- mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[1].name;
- mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[1].mime;
- mediacodec->encoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[1].format);
- count++;
- }
-
- if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
- mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
- mediacodec->encoder_map[count].hardware = 0;
- mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[3].name;
- mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[3].mime;
- mediacodec->encoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[3].format);
- count++;
- }
- }
- mediacodec->num_supported_encoder = count;
- return;
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+
+ for (indx = 0; indx < codec_list; indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
+ mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->encoder_map[count].hardware = 1;
+ mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[1].name;
+ mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[1].mime;
+ mediacodec->encoder_map[count].type.out_format =
+ _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[1].format);
+ count++;
+ }
+
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
+ mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->encoder_map[count].hardware = 0;
+ mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[3].name;
+ mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[3].mime;
+ mediacodec->encoder_map[count].type.out_format =
+ _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[3].format);
+ count++;
+ }
+ }
+ mediacodec->num_supported_encoder = count;
+ return;
}
void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul)
{
- int indx = 0, count = 0;
- int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
- for (indx=0;indx <codec_list;indx++) {
- if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
- spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
- spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
- spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
- count++;
- }
- if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
- spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
- spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
- spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
- count++;
- }
- if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
- spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
- spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
- spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
- count++;
- }
- if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
- spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
- spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
- spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
- count++;
- }
- }
-
- mediacodec->num_supported_codecs = count;
- return;
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+ for (indx = 0; indx < codec_list; indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ }
+
+ mediacodec->num_supported_codecs = count;
+ return;
}
#endif /* #ifdef _MEDIA_CODEC_INI_C_ */
/*
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
*
*/
#include <stdio.h>
int mc_create(MMHandleType *mediacodec)
{
- mc_handle_t *new_mediacodec = NULL;
- int ret = MC_ERROR_NONE;
- int i;
- int support_list = sizeof(spec_emul) / sizeof(spec_emul[0]);
+ mc_handle_t *new_mediacodec = NULL;
+ int ret = MC_ERROR_NONE;
+ int i;
+ int support_list = sizeof(spec_emul) / sizeof(spec_emul[0]);
- /* alloc mediacodec structure */
- new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t));
+ /* alloc mediacodec structure */
+ new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t));
- if (!new_mediacodec) {
- LOGE("Cannot allocate memory for mediacodec");
- ret = MC_ERROR;
- goto ERROR;
- }
- memset(new_mediacodec, 0, sizeof(mc_handle_t));
- memset(spec_emul, 0, sizeof(mc_codec_spec_t)*MEDIA_CODEC_MAX_CODEC_TYPE);
+ if (!new_mediacodec) {
+ LOGE("Cannot allocate memory for mediacodec");
+ ret = MC_ERROR;
+ goto ERROR;
+ }
+ memset(new_mediacodec, 0, sizeof(mc_handle_t));
+ memset(spec_emul, 0, sizeof(mc_codec_spec_t)*MEDIA_CODEC_MAX_CODEC_TYPE);
- new_mediacodec->is_encoder = false;
- new_mediacodec->is_video = false;
- new_mediacodec->is_hw = true;
- new_mediacodec->is_prepared = false;
- new_mediacodec->codec_id = MEDIACODEC_NONE;
+ new_mediacodec->is_encoder = false;
+ new_mediacodec->is_video = false;
+ new_mediacodec->is_hw = true;
+ new_mediacodec->is_prepared = false;
+ new_mediacodec->codec_id = MEDIACODEC_NONE;
- new_mediacodec->ports[0] = NULL;
- new_mediacodec->ports[1] = NULL;
+ new_mediacodec->ports[0] = NULL;
+ new_mediacodec->ports[1] = NULL;
- new_mediacodec->num_supported_codecs = 0;
- new_mediacodec->num_supported_decoder = 0;
- new_mediacodec->num_supported_encoder = 0;
+ new_mediacodec->num_supported_codecs = 0;
+ new_mediacodec->num_supported_decoder = 0;
+ new_mediacodec->num_supported_encoder = 0;
- new_mediacodec->core = NULL;
+ new_mediacodec->core = NULL;
- /* load ini files */
- ret = mc_ini_load(&new_mediacodec->ini);
- if(ret != MC_ERROR_NONE)
- goto ERROR;
- _mc_create_codec_map_from_ini(new_mediacodec, spec_emul);
+ /* load ini files */
+ ret = mc_ini_load(&new_mediacodec->ini);
+ if (ret != MC_ERROR_NONE)
+ goto ERROR;
+ _mc_create_codec_map_from_ini(new_mediacodec, spec_emul);
- for (i = 0; i < new_mediacodec->num_supported_codecs; i++) {
- new_mediacodec->supported_codecs =
- g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id));
- }
+ for (i = 0; i < new_mediacodec->num_supported_codecs; i++) {
+ new_mediacodec->supported_codecs =
+ g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id));
+ }
- /* create decoder map from ini */
- _mc_create_decoder_map_from_ini(new_mediacodec);
+ /* create decoder map from ini */
+ _mc_create_decoder_map_from_ini(new_mediacodec);
- /* create encoder map from ini */
- _mc_create_encoder_map_from_ini(new_mediacodec);
+ /* create encoder map from ini */
+ _mc_create_encoder_map_from_ini(new_mediacodec);
- *mediacodec = (MMHandleType)new_mediacodec;
+ *mediacodec = (MMHandleType)new_mediacodec;
- return ret;
+ return ret;
ERROR:
- return MC_INVALID_ARG;
+ return MC_INVALID_ARG;
}
int mc_destroy(MMHandleType mediacodec)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- LOGD("mediacodec : %p", mediacodec);
+ LOGD("mediacodec : %p", mediacodec);
- if (mc_handle->core != NULL) {
- if (mc_gst_unprepare(mc_handle) != MC_ERROR_NONE) {
- LOGE("mc_gst_unprepare() failed");
- return MC_ERROR;
- }
- }
+ if (mc_handle->core != NULL) {
+ if (mc_gst_unprepare(mc_handle) != MC_ERROR_NONE) {
+ LOGE("mc_gst_unprepare() failed");
+ return MC_ERROR;
+ }
+ }
- mc_handle->is_prepared = false;
- g_list_free(mc_handle->supported_codecs);
+ mc_handle->is_prepared = false;
+ g_list_free(mc_handle->supported_codecs);
- /* free mediacodec structure */
- if (mc_handle) {
- g_free((void *)mc_handle);
- mc_handle = NULL;
- }
+ /* free mediacodec structure */
+ if (mc_handle) {
+ g_free((void *)mc_handle);
+ mc_handle = NULL;
+ }
- return ret;
+ return ret;
}
int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, int flags)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- int i;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+ int i;
- if (!mc_handle) {
- LOGE("fail invaild param");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param");
+ return MC_INVALID_ARG;
+ }
- /* Mandatory setting */
- if (!GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags)) {
- LOGE("should be encoder or decoder");
- return MC_PARAM_ERROR;
- }
+ /* Mandatory setting */
+ if (!GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags)) {
+ LOGE("should be encoder or decoder");
+ return MC_PARAM_ERROR;
+ }
- /* if user doesn't set codec-type, s/w codec would be set */
- if (!GET_IS_HW(flags) && !GET_IS_SW(flags))
- flags |= MEDIACODEC_SUPPORT_TYPE_SW;
+ /* if user doesn't set codec-type, s/w codec would be set */
+ if (!GET_IS_HW(flags) && !GET_IS_SW(flags))
+ flags |= MEDIACODEC_SUPPORT_TYPE_SW;
- for (i = 0; i < mc_handle->num_supported_codecs; i++) {
- if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type)) {
- break;
- }
- }
- LOGD("support_list : %d, i : %d", mc_handle->num_supported_codecs, i);
+ for (i = 0; i < mc_handle->num_supported_codecs; i++) {
+ if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type))
+ break;
+ }
+ LOGD("support_list : %d, i : %d", mc_handle->num_supported_codecs, i);
- if (i == mc_handle->num_supported_codecs)
- return MC_NOT_SUPPORTED;
+ if (i == mc_handle->num_supported_codecs)
+ return MC_NOT_SUPPORTED;
- mc_handle->port_type = spec_emul[i].port_type;
+ mc_handle->port_type = spec_emul[i].port_type;
- mc_handle->is_encoder = GET_IS_ENCODER(flags) ? 1 : 0;
- mc_handle->is_hw = GET_IS_HW(flags) ? 1 : 0;
- mc_handle->codec_id = codec_id;
- mc_handle->is_video = CHECK_BIT(codec_id, 13);
+ mc_handle->is_encoder = GET_IS_ENCODER(flags) ? 1 : 0;
+ mc_handle->is_hw = GET_IS_HW(flags) ? 1 : 0;
+ mc_handle->codec_id = codec_id;
+ mc_handle->is_video = CHECK_BIT(codec_id, 13);
- mc_handle->is_prepared = false;
+ mc_handle->is_prepared = false;
- LOGD("encoder : %d, hardware : %d, codec_id : %x, video : %d",
- mc_handle->is_encoder, mc_handle->is_hw, mc_handle->codec_id, mc_handle->is_video);
+ LOGD("encoder : %d, hardware : %d, codec_id : %x, video : %d",
+ mc_handle->is_encoder, mc_handle->is_hw, mc_handle->codec_id, mc_handle->is_video);
- return ret;
+ return ret;
}
int mc_set_vdec_info(MMHandleType mediacodec, int width, int height)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t *)mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if ((width <= 0) || (height <= 0))
- return MC_PARAM_ERROR;
-
- MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
-
- mc_handle->info.decoder.width = width;
- mc_handle->info.decoder.height = height;
-
- mc_handle->is_prepared = true;
-
- switch (mc_handle->codec_id) {
- case MEDIACODEC_H264:
- mc_sniff_bitstream = mc_sniff_h264_bitstream;
- LOGD("mc_sniff_h264_bitstream");
- break;
- case MEDIACODEC_MPEG4:
- mc_sniff_bitstream = mc_sniff_mpeg4_bitstream;
- break;
- case MEDIACODEC_H263:
- mc_sniff_bitstream = mc_sniff_h263_bitstream;
- break;
- default:
- LOGE("NOT SUPPORTED!!!!");
- break;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t* mc_handle = (mc_handle_t *)mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if ((width <= 0) || (height <= 0))
+ return MC_PARAM_ERROR;
+
+ MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+
+ mc_handle->info.decoder.width = width;
+ mc_handle->info.decoder.height = height;
+
+ mc_handle->is_prepared = true;
+
+ switch (mc_handle->codec_id) {
+ case MEDIACODEC_H264:
+ mc_sniff_bitstream = mc_sniff_h264_bitstream;
+ LOGD("mc_sniff_h264_bitstream");
+ break;
+ case MEDIACODEC_MPEG4:
+ mc_sniff_bitstream = mc_sniff_mpeg4_bitstream;
+ break;
+ case MEDIACODEC_H263:
+ mc_sniff_bitstream = mc_sniff_h263_bitstream;
+ break;
+ default:
+ LOGE("NOT SUPPORTED!!!!");
+ break;
+ }
+
+ return ret;
}
int mc_set_venc_info(MMHandleType mediacodec, int width, int height, int fps, int target_bits)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- if ((width <= 0) || (height <= 0))
- return MC_PARAM_ERROR;
+ if ((width <= 0) || (height <= 0))
+ return MC_PARAM_ERROR;
- MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
- mc_handle->info.encoder.width = width;
- mc_handle->info.encoder.height = height;
- mc_handle->info.encoder.fps = fps;
- mc_handle->info.encoder.bitrate = target_bits;
- mc_handle->is_prepared = true;
- mc_sniff_bitstream = mc_sniff_yuv;
+ mc_handle->info.encoder.width = width;
+ mc_handle->info.encoder.height = height;
+ mc_handle->info.encoder.fps = fps;
+ mc_handle->info.encoder.bitrate = target_bits;
+ mc_handle->is_prepared = true;
+ mc_sniff_bitstream = mc_sniff_yuv;
- return ret;
+ return ret;
}
int mc_set_adec_info(MMHandleType mediacodec, int samplerate, int channel, int bit)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
- return MC_PARAM_ERROR;
+ if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
+ return MC_PARAM_ERROR;
- MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
- mc_handle->info.decoder.samplerate = samplerate;
- mc_handle->info.decoder.channel = channel;
- mc_handle->info.decoder.bit = bit;
- mc_handle->is_prepared = true;
+ mc_handle->info.decoder.samplerate = samplerate;
+ mc_handle->info.decoder.channel = channel;
+ mc_handle->info.decoder.bit = bit;
+ mc_handle->is_prepared = true;
- return ret;
+ return ret;
}
int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int bit, int bitrate)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t * mc_handle = (mc_handle_t *) mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t * mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
- return MC_PARAM_ERROR;
+ if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
+ return MC_PARAM_ERROR;
- MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
- mc_handle->info.encoder.samplerate = samplerate;
- mc_handle->info.encoder.channel = channel;
- mc_handle->info.encoder.bit = bit;
- mc_handle->info.encoder.bitrate = bitrate;
+ mc_handle->info.encoder.samplerate = samplerate;
+ mc_handle->info.encoder.channel = channel;
+ mc_handle->info.encoder.bit = bit;
+ mc_handle->info.encoder.bitrate = bitrate;
- mc_handle->is_prepared = true;
+ mc_handle->is_prepared = true;
- return ret;
+ return ret;
}
int mc_prepare(MMHandleType mediacodec)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (!mc_handle->is_prepared)
- return MC_NOT_INITIALIZED;
-
- /* setting core details */
- switch (mc_handle->port_type) {
- case MEDIACODEC_PORT_TYPE_GENERAL:
- {
- }
- break;
-
- case MEDIACODEC_PORT_TYPE_OMX:
- {
- }
- break;
-
- case MEDIACODEC_PORT_TYPE_GST:
- {
- mc_gst_prepare(mc_handle);
- }
- break;
-
- default:
- break;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (!mc_handle->is_prepared)
+ return MC_NOT_INITIALIZED;
+
+ /* setting core details */
+ switch (mc_handle->port_type) {
+ case MEDIACODEC_PORT_TYPE_GENERAL:
+ break;
+
+ case MEDIACODEC_PORT_TYPE_OMX:
+ break;
+
+ case MEDIACODEC_PORT_TYPE_GST:
+ mc_gst_prepare(mc_handle);
+ break;
+
+ default:
+ break;
+ }
+
+ return ret;
}
int mc_unprepare(MMHandleType mediacodec)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- /* deinit core details */
- switch (mc_handle->port_type) {
- case MEDIACODEC_PORT_TYPE_GENERAL:
- {
- }
- break;
-
- case MEDIACODEC_PORT_TYPE_OMX:
- {
- }
- break;
-
- case MEDIACODEC_PORT_TYPE_GST:
- {
- ret = mc_gst_unprepare(mc_handle);
- }
- break;
-
- default:
- break;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ /* deinit core details */
+ switch (mc_handle->port_type) {
+ case MEDIACODEC_PORT_TYPE_GENERAL:
+ break;
+
+ case MEDIACODEC_PORT_TYPE_OMX:
+ break;
+
+ case MEDIACODEC_PORT_TYPE_GST:
+ ret = mc_gst_unprepare(mc_handle);
+ break;
+
+ default:
+ break;
+ }
+
+ return ret;
}
int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
{
- int ret = MC_ERROR_NONE;
+ int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param");
+ return MC_INVALID_ARG;
+ }
- if (mc_handle->is_video) {
- if ((ret = mc_sniff_bitstream(mc_handle, inbuf)) != MC_ERROR_NONE) {
- return MC_INVALID_IN_BUF;
- }
- }
+ if (mc_handle->is_video) {
+ if ((ret = mc_sniff_bitstream(mc_handle, inbuf)) != MC_ERROR_NONE)
+ return MC_INVALID_IN_BUF;
+ }
- switch (mc_handle->port_type) {
- case MEDIACODEC_PORT_TYPE_GENERAL:
- break;
+ switch (mc_handle->port_type) {
+ case MEDIACODEC_PORT_TYPE_GENERAL:
+ break;
- case MEDIACODEC_PORT_TYPE_OMX:
- break;
+ case MEDIACODEC_PORT_TYPE_OMX:
+ break;
- case MEDIACODEC_PORT_TYPE_GST:
- {
- ret = mc_gst_process_input(mc_handle, inbuf, timeOutUs);
- }
- break;
+ case MEDIACODEC_PORT_TYPE_GST:
+ ret = mc_gst_process_input(mc_handle, inbuf, timeOutUs);
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return ret;
+ return ret;
}
int mc_get_output(MMHandleType mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- /* setting core details */
- switch (mc_handle->port_type) {
- case MEDIACODEC_PORT_TYPE_GENERAL:
- break;
+ /* setting core details */
+ switch (mc_handle->port_type) {
+ case MEDIACODEC_PORT_TYPE_GENERAL:
+ break;
- case MEDIACODEC_PORT_TYPE_OMX:
- break;
+ case MEDIACODEC_PORT_TYPE_OMX:
+ break;
- case MEDIACODEC_PORT_TYPE_GST:
- {
- ret = mc_gst_get_output(mc_handle, outbuf, timeOutUs);
- }
- break;
+ case MEDIACODEC_PORT_TYPE_GST:
+ ret = mc_gst_get_output(mc_handle, outbuf, timeOutUs);
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return ret;
+ return ret;
}
int mc_flush_buffers(MMHandleType mediacodec)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- /* setting core details */
- switch (mc_handle->port_type) {
- case MEDIACODEC_PORT_TYPE_GENERAL:
- break;
+ /* setting core details */
+ switch (mc_handle->port_type) {
+ case MEDIACODEC_PORT_TYPE_GENERAL:
+ break;
- case MEDIACODEC_PORT_TYPE_OMX:
- break;
+ case MEDIACODEC_PORT_TYPE_OMX:
+ break;
- case MEDIACODEC_PORT_TYPE_GST:
- {
- ret = mc_gst_flush_buffers(mc_handle);
- }
- break;
+ case MEDIACODEC_PORT_TYPE_GST:
+ ret = mc_gst_flush_buffers(mc_handle);
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return ret;
+ return ret;
}
int mc_get_supported_type(MMHandleType mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- mc_codec_map_t *codec_map;
- int num_supported_codec = 0;
- int i;
-
- *support_type = 0;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
- codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
- num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
-
- for (i = 0; i < num_supported_codec; i++)
- {
- if (codec_map[i].id == codec_type)
- {
- if (codec_map[i].hardware)
- *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
- else
- *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
- break;
- }
-
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_codec_map_t *codec_map;
+ int num_supported_codec = 0;
+ int i;
+
+ *support_type = 0;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+ codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
+ num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
+
+ for (i = 0; i < num_supported_codec; i++) {
+ if (codec_map[i].id == codec_type) {
+ if (codec_map[i].hardware)
+ *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
+ else
+ *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
+ break;
+ }
+ }
+
+ return ret;
}
int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
- LOGE("Already set mediacodec_empty_buffer_cb");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
+ LOGE("Already set mediacodec_empty_buffer_cb");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
- LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
+ LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
- return MC_ERROR_NONE;
- }
+ return MC_ERROR_NONE;
+ }
- return ret;
+ return ret;
}
int mc_unset_empty_buffer_cb(MMHandleType mediacodec)
{
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
- LOGE("Already set mediacodec_fill_buffer_cb");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
-
- LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
-
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
- return MC_ERROR_NONE;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
+ LOGE("Already set mediacodec_fill_buffer_cb");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
+
+ LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
+
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
+ return MC_ERROR_NONE;
+ }
+
+ return ret;
}
int mc_unset_fill_buffer_cb(MMHandleType mediacodec)
{
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
- LOGE("Already set mediacodec_fill_buffer_cb\n");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
-
- LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
-
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = (mc_error_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = user_data;
- return MC_ERROR_NONE;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
+ LOGE("Already set mediacodec_fill_buffer_cb\n");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
+
+ LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
+
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = (mc_error_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = user_data;
+ return MC_ERROR_NONE;
+ }
+
+ return ret;
}
int mc_unset_error_cb(MMHandleType mediacodec)
{
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param");
+ return MC_INVALID_ARG;
+ }
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
- LOGE("Already set mediacodec_fill_buffer_cb");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
-
- LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
-
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = (mc_eos_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = user_data;
- return MC_ERROR_NONE;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
+ LOGE("Already set mediacodec_fill_buffer_cb");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
+
+ LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
+
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = (mc_eos_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = user_data;
+ return MC_ERROR_NONE;
+ }
+
+ return ret;
}
int mc_unset_eos_cb(MMHandleType mediacodec)
{
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
- LOGE("Already set mediacodec_need_data_cb\n");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
-
- LOGD("Set start feed callback(cb = %p, data = %p)\n", callback, user_data);
-
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = (mc_buffer_status_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = user_data;
- return MC_ERROR_NONE;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
+ LOGE("Already set mediacodec_need_data_cb\n");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
+
+ LOGD("Set start feed callback(cb = %p, data = %p)\n", callback, user_data);
+
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = (mc_buffer_status_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = user_data;
+ return MC_ERROR_NONE;
+ }
+
+ return ret;
}
int mc_unset_buffer_status_cb(MMHandleType mediacodec)
{
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
- LOGE("Already set mediacodec_supported_codec_cb\n");
- return MC_PARAM_ERROR;
- } else {
- if (!callback) {
- return MC_INVALID_ARG;
- }
-
- LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
-
- mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
- mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
- return MC_ERROR_NONE;
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
+ LOGE("Already set mediacodec_supported_codec_cb\n");
+ return MC_PARAM_ERROR;
+ } else {
+ if (!callback)
+ return MC_INVALID_ARG;
+
+ LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
+
+ mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
+ mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
+ return MC_ERROR_NONE;
+ }
+
+ return ret;
}
int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
- int ret = MC_ERROR_NONE;
- mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- int codecs_num;
- gpointer tmp;
-
- if (!mc_handle) {
- LOGE("fail invaild param\n");
- return MC_INVALID_ARG;
- }
-
- if (mc_handle->supported_codecs) {
- codecs_num = g_list_length(mc_handle->supported_codecs);
- LOGD("supported_codecs : %d", codecs_num);
-
- while (codecs_num) {
- tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num - 1);
- if (tmp) {
- if (!callback(GPOINTER_TO_INT(tmp), user_data)) {
- ret = MEDIACODEC_ERROR_INTERNAL;
- goto CALLBACK_ERROR;
- }
- }
- codecs_num--;
- }
-
- if (!callback(-1, user_data)) {
- ret = MEDIACODEC_ERROR_INTERNAL;
- goto CALLBACK_ERROR;
- }
- }
+ int ret = MC_ERROR_NONE;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ int codecs_num;
+ gpointer tmp;
+
+ if (!mc_handle) {
+ LOGE("fail invaild param\n");
+ return MC_INVALID_ARG;
+ }
+
+ if (mc_handle->supported_codecs) {
+ codecs_num = g_list_length(mc_handle->supported_codecs);
+ LOGD("supported_codecs : %d", codecs_num);
+
+ while (codecs_num) {
+ tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num - 1);
+ if (tmp) {
+ if (!callback(GPOINTER_TO_INT(tmp), user_data)) {
+ ret = MEDIACODEC_ERROR_INTERNAL;
+ goto CALLBACK_ERROR;
+ }
+ }
+ codecs_num--;
+ }
+
+ if (!callback(-1, user_data)) {
+ ret = MEDIACODEC_ERROR_INTERNAL;
+ goto CALLBACK_ERROR;
+ }
+ }
CALLBACK_ERROR:
- LOGD("foreach callback returned error");
- return ret;
+ LOGD("foreach callback returned error");
+ return ret;
}
int mc_sniff_h264_bitstream(mc_handle_t *handle, media_packet_h pkt)
{
- int ret = MC_ERROR_NONE;
- void *buf_data = NULL;
- void *codec_data = NULL;
- unsigned int codec_data_size = 0;
- uint64_t buf_size = 0;
- bool eos = false;
- bool codec_config = false;
-
- media_packet_get_buffer_size(pkt, &buf_size);
- media_packet_get_buffer_data_ptr(pkt, &buf_data);
- media_packet_get_codec_data(pkt, &codec_data, &codec_data_size);
- media_packet_is_end_of_stream(pkt, &eos);
- media_packet_is_codec_config(pkt, &codec_config);
-
- LOGD("codec_data_size : %d, buf_size : %d, codec_config : %d, eos : %d",
- codec_data_size, (int)buf_size, codec_config, eos);
-
- if (codec_config) {
- if (codec_data_size == 0)
- ret = _mc_check_h264_bytestream(buf_data, (int)buf_size, 0, NULL, NULL, NULL);
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ void *buf_data = NULL;
+ void *codec_data = NULL;
+ unsigned int codec_data_size = 0;
+ uint64_t buf_size = 0;
+ bool eos = false;
+ bool codec_config = false;
+
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ media_packet_get_codec_data(pkt, &codec_data, &codec_data_size);
+ media_packet_is_end_of_stream(pkt, &eos);
+ media_packet_is_codec_config(pkt, &codec_config);
+
+ LOGD("codec_data_size : %d, buf_size : %d, codec_config : %d, eos : %d",
+ codec_data_size, (int)buf_size, codec_config, eos);
+
+ if (codec_config) {
+ if (codec_data_size == 0)
+ ret = _mc_check_h264_bytestream(buf_data, (int)buf_size, 0, NULL, NULL, NULL);
+ }
+
+ return ret;
}
int mc_sniff_mpeg4_bitstream(mc_handle_t *handle, media_packet_h pkt)
{
- uint64_t buf_size = 0;
- unsigned char *buf_data = NULL;
- void *codec_data = NULL;
- int codec_data_size = 0, voss_size = 0;
- bool eos = false;
- bool codec_config = false;
- bool sync_frame = false;
-
- media_packet_get_buffer_size(pkt, &buf_size);
- media_packet_get_buffer_data_ptr(pkt, (void *)&buf_data);
- media_packet_get_codec_data(pkt, &codec_data, &codec_data_size);
- media_packet_is_end_of_stream(pkt, &eos);
- media_packet_is_codec_config(pkt, &codec_config);
- media_packet_is_sync_frame(pkt, &sync_frame);
-
- LOGD("codec_data_size : %d, buff_size : %d, codec_config : %d, sync_frame : %d, eos : %d",
- codec_data_size, (int)buf_size, codec_config, sync_frame, eos);
-
- if (eos)
- return MC_ERROR_NONE;
-
- if (codec_config) {
- if (codec_data) {
- if (!_mc_is_voss(codec_data, codec_data_size, NULL))/*voss not in codec data */
- return MC_INVALID_IN_BUF;
- }
- /* Codec data + I-frame in buffer */
- if (_mc_is_voss(buf_data, buf_size, &voss_size)) {
- if (_mc_is_ivop(buf_data, buf_size, voss_size)) /* IVOP after codec_data */
- return MC_ERROR_NONE;
- } else {
- if (_mc_is_ivop(buf_data, buf_size, 0)) /* IVOP at the start */
- return MC_ERROR_NONE;
- }
- } else if (_mc_is_vop(buf_data, buf_size, 0))
- return MC_ERROR_NONE;
-
- return MC_INVALID_IN_BUF;
+ uint64_t buf_size = 0;
+ unsigned char *buf_data = NULL;
+ void *codec_data = NULL;
+ int codec_data_size = 0, voss_size = 0;
+ bool eos = false;
+ bool codec_config = false;
+ bool sync_frame = false;
+
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_buffer_data_ptr(pkt, (void *)&buf_data);
+ media_packet_get_codec_data(pkt, &codec_data, &codec_data_size);
+ media_packet_is_end_of_stream(pkt, &eos);
+ media_packet_is_codec_config(pkt, &codec_config);
+ media_packet_is_sync_frame(pkt, &sync_frame);
+
+ LOGD("codec_data_size : %d, buff_size : %d, codec_config : %d, sync_frame : %d, eos : %d",
+ codec_data_size, (int)buf_size, codec_config, sync_frame, eos);
+
+ if (eos)
+ return MC_ERROR_NONE;
+
+ if (codec_config) {
+ if (codec_data) {
+ if (!_mc_is_voss(codec_data, codec_data_size, NULL))/*voss not in codec data */
+ return MC_INVALID_IN_BUF;
+ }
+ /* Codec data + I-frame in buffer */
+ if (_mc_is_voss(buf_data, buf_size, &voss_size)) {
+ if (_mc_is_ivop(buf_data, buf_size, voss_size)) /* IVOP after codec_data */
+ return MC_ERROR_NONE;
+ } else {
+ if (_mc_is_ivop(buf_data, buf_size, 0)) /* IVOP at the start */
+ return MC_ERROR_NONE;
+ }
+ } else if (_mc_is_vop(buf_data, buf_size, 0))
+ return MC_ERROR_NONE;
+
+ return MC_INVALID_IN_BUF;
}
int mc_sniff_h263_bitstream(mc_handle_t *handle, media_packet_h pkt)
{
- void *buf_data = NULL;
- uint64_t buf_size = 0;
- bool eos = false;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ bool eos = false;
- media_packet_get_buffer_size(pkt, &buf_size);
- media_packet_get_buffer_data_ptr(pkt, &buf_data);
- media_packet_is_end_of_stream(pkt, &eos);
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ media_packet_is_end_of_stream(pkt, &eos);
- if (eos)
- return MC_ERROR_NONE;
+ if (eos)
+ return MC_ERROR_NONE;
- return _mc_check_valid_h263_frame((unsigned char *)buf_data, (int)buf_size);
+ return _mc_check_valid_h263_frame((unsigned char *)buf_data, (int)buf_size);
}
int mc_sniff_yuv(mc_handle_t *handle, media_packet_h pkt)
{
- int ret = MC_ERROR_NONE;
+ int ret = MC_ERROR_NONE;
#if 0 /* libtbm, media-tool should be updated */
- uint64_t buf_size = 0;
- int plane_num = 0;
- int padded_width = 0;
- int padded_height = 0;
- int allocated_buffer = 0;
- int index;
-
- media_packet_get_buffer_size(pkt, &buf_size);
- media_packet_get_video_number_of_planes(pkt, &plane_num);
-
- for (index = 0; index < plane_num; index++) {
- media_packet_get_video_stride_width(pkt, index, &padded_width);
- media_packet_get_video_stride_height(pkt, index, &padded_height);
- allocated_buffer += padded_width * padded_height;
-
- LOGD("%d plane size : %d", padded_width * padded_height);
- }
-
- if (buf_size > allocated_buffer) {
- LOGE("Buffer exceeds maximum size [buf_size: %d, allocated_size :%d", (int)buf_size, allocated_buffer);
- ret = MC_INVALID_IN_BUF;
- }
+ uint64_t buf_size = 0;
+ int plane_num = 0;
+ int padded_width = 0;
+ int padded_height = 0;
+ int allocated_buffer = 0;
+ int index;
+
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_video_number_of_planes(pkt, &plane_num);
+
+ for (index = 0; index < plane_num; index++) {
+ media_packet_get_video_stride_width(pkt, index, &padded_width);
+ media_packet_get_video_stride_height(pkt, index, &padded_height);
+ allocated_buffer += padded_width * padded_height;
+
+ LOGD("%d plane size : %d", padded_width * padded_height);
+ }
+
+ if (buf_size > allocated_buffer) {
+ LOGE("Buffer exceeds maximum size [buf_size: %d, allocated_size :%d", (int)buf_size, allocated_buffer);
+ ret = MC_INVALID_IN_BUF;
+ }
#endif
- return ret;
+ return ret;
}
/*
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
*
*/
#include <glib.h>
#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
/*
-* Internal Implementation
-*/
+ * Internal Implementation
+ */
static gpointer feed_task(gpointer data);
static void __mc_gst_stop_feed(GstElement *pipeline, gpointer data);
static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data);
static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos);
static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest,
- unsigned char *nv12t_src, int yuv420_width, int yuv420_height,
- int left, int top, int right, int buttom);
+ unsigned char *nv12t_src, int yuv420_width, int yuv420_height,
+ int left, int top, int right, int buttom);
static void _mc_send_eos_signal(mc_gst_core_t *core);
static void _mc_wait_for_eos(mc_gst_core_t *core);
int(*vdec_h264_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG H.264 Decoder Vtable */
- &__mc_fill_vdec_packet_with_outbuf,
- &__mc_vdec_caps};
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_caps};
int(*vdec_mpeg4_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG MPEG4 Decoder Vtable */
- &__mc_fill_vdec_packet_with_outbuf,
- &__mc_vdec_mpeg4_caps};
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_mpeg4_caps};
int(*venc_mpeg4_sw_vtable[])() = {&__mc_fill_inbuf_with_venc_packet, /* SPRD MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_venc_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_venc_caps};
int(*vdec_h263_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG MPEG4 Decoder Vtable */
- &__mc_fill_vdec_packet_with_outbuf,
- &__mc_vdec_h263_caps};
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_h263_caps};
int(*venc_h263_sw_vtable[])() = {&__mc_fill_inbuf_with_venc_packet, /* SPRD MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_venc_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_venc_caps};
#ifdef TIZEN_PROFILE_LITE
int(*vdec_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD H.264 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_sprddec_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_caps};
int(*venc_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD H.264 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_sprdenc_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_caps};
int(*vdec_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD MPEG4 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_sprddec_mpeg4_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
int(*venc_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_sprdenc_mpeg4_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
int(*vdec_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD MPEG4 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_sprddec_mpeg4_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
int(*venc_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_sprdenc_mpeg4_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
#else
int(*vdec_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* EXYNOS H.264 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_h264dec_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_h264dec_caps};
int(*venc_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* EXYNOS H.264 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_hw_h264enc_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_hw_h264enc_caps};
int(*vdec_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* EXYNOS MPEG4 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_sprddec_mpeg4_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
int(*venc_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* EXYNOS MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_sprdenc_mpeg4_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
int(*vdec_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* EXYNOS MPEG4 Decoder Vtable */
- &__mc_fill_video_packet_with_mm_video_buffer,
- &__mc_sprddec_mpeg4_caps};
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
int(*venc_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* EXYNOS MPEG4 Encoder Vtable */
- &__mc_fill_venc_packet_with_outbuf,
- &__mc_sprdenc_mpeg4_caps};
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
#endif
/* audio vtable */
int(*adec_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_packet_with_outbuf, &__mc_adec_caps};
int(*aenc_aac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC LC Encoder vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_aenc_aac_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_aenc_aac_caps};
int(*adec_aac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC LC Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_aac_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_aac_caps};
int(*adec_aacv12_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC HE Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_aacv12_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_aacv12_caps};
int(*adec_mp3_vtable[])() = {&__mc_fill_inbuf_with_packet, /* MP3 Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_mp3_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_mp3_caps};
int(*adec_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-NB Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_amrnb_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_amrnb_caps};
int(*adec_amrwb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-WB Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_amrwb_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_amrwb_caps};
int(*aenc_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-NB Encoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_aenc_amrnb_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_aenc_amrnb_caps};
int(*adec_vorbis_vtable[])() = {&__mc_fill_inbuf_with_packet, /* VORBIS Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_vorbis_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_vorbis_caps};
int(*adec_flac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FLAC Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_flac_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_flac_caps};
int(*adec_wma_vtable[])() = {&__mc_fill_inbuf_with_packet, /* WMA Decoder Vtable */
- &__mc_fill_packet_with_outbuf,
- &__mc_adec_wma_caps};
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_wma_caps};
/*
* fill_inbuf virtual functions
-*/
+ */
int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff)
{
- return core->vtable[fill_inbuf](core, pkt, buff);
+ return core->vtable[fill_inbuf](core, pkt, buff);
}
int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
- int ret = MC_ERROR_NONE;
+ int ret = MC_ERROR_NONE;
- MMVideoBuffer *mm_vbuffer = NULL;
- void *buf_data = NULL;
- uint64_t buf_size = 0;
+ MMVideoBuffer *mm_vbuffer = NULL;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
- ret = media_packet_get_buffer_size(pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return MC_ERROR;
- }
+ ret = media_packet_get_buffer_size(pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return MC_ERROR;
- }
+ ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- mm_vbuffer = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt);
+ mm_vbuffer = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt);
- if (mm_vbuffer != NULL) {
- gst_buffer_prepend_memory(mc_buffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_vbuffer, sizeof(*mm_vbuffer), 0,
- sizeof(*mm_vbuffer), mm_vbuffer, free));
- LOGD("scmn_mm_vbuffer is appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mc_buffer->buffer));
- }
+ if (mm_vbuffer != NULL) {
+ gst_buffer_prepend_memory(mc_buffer->buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_vbuffer, sizeof(*mm_vbuffer), 0,
+ sizeof(*mm_vbuffer), mm_vbuffer, free));
+ LOGD("scmn_mm_vbuffer is appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mc_buffer->buffer));
+ }
- if (buf_data != NULL) {
- gst_buffer_prepend_memory(mc_buffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
- buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
- LOGD("packet data is apended, %d, %d", buf_size, gst_buffer_n_memory(mc_buffer->buffer));
- }
- return ret;
+ if (buf_data != NULL) {
+ gst_buffer_prepend_memory(mc_buffer->buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
+ buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
+ LOGD("packet data is apended, %d, %d", buf_size, gst_buffer_n_memory(mc_buffer->buffer));
+ }
+ return ret;
}
int __mc_fill_inbuf_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
- int ret = MC_ERROR_NONE;
- void *buf_data = NULL;
- uint64_t buf_size = 0;
+ int ret = MC_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
- ret = media_packet_get_buffer_size(pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return MC_ERROR;
- }
+ ret = media_packet_get_buffer_size(pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return MC_ERROR;
- }
+ ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- if (buf_data != NULL) {
- gst_buffer_append_memory(mc_buffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
- buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
- LOGD("packet data is apended");
- }
+ if (buf_data != NULL) {
+ gst_buffer_append_memory(mc_buffer->buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
+ buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
+ LOGD("packet data is apended");
+ }
- return ret;
+ return ret;
}
int __mc_fill_inbuf_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
- int ret = MC_ERROR_NONE;
- void *uv_ptr = NULL;
- void *y_ptr = NULL;
- int buf_size = 0;
- int stride_width;
- int stride_height;
- int width;
- int height;
- uint32_t plane_num;
- int i;
- int j;
- int stride = 0;
-
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
- width = enc_info->width;
- height = enc_info->height;
-
- ret = media_packet_get_number_of_video_planes(pkt, &plane_num);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_get_number_of_video_planes failed");
- return MC_ERROR;
- }
-
- ret = media_packet_get_video_plane_data_ptr(pkt, 0, &y_ptr);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_get_video_plane_data_ptr failed");
- return MC_ERROR;
- }
-
- ret = media_packet_get_video_stride_width(pkt, 0, &stride_width);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_get_video_stride_width failed");
- return MC_ERROR;
- }
-
- ret = media_packet_get_video_stride_height(pkt, 0, &stride_height);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_get_video_stride_width failed");
- return MC_ERROR;
- }
-
- if (width == stride_width) {
- mc_buffer->buf_size += stride_width * stride_height;
-
- for (i = 1; i < plane_num; i++) {
- media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
- media_packet_get_video_stride_width(pkt, i, &stride_width);
- media_packet_get_video_stride_height(pkt, i, &stride_height);
-
- buf_size = stride_width * stride_height;
-
- memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
- LOGD("width is same with stride");
- LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
- mc_buffer->buf_size += buf_size;
-
- }
- } else {
-
- for (j = 0; j < height; j++) {
- memcpy(y_ptr + mc_buffer->buf_size, y_ptr + stride, width);
- mc_buffer->buf_size += width;
- stride += stride_width;
- }
-
- stride = 0;
-
- for (i = 1; i < plane_num; i++) {
- media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
- media_packet_get_video_stride_width(pkt, i, &stride_width);
- media_packet_get_video_stride_height(pkt, i, &stride_height);
-
- for (j = 0; j < height>>1; j++) {
- memcpy(y_ptr + mc_buffer->buf_size, uv_ptr + stride, width>>1);
- mc_buffer->buf_size += width>>1;
- stride += stride_width;
- }
-
- memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
- LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
- mc_buffer->buf_size += buf_size;
- }
- }
-
- if (y_ptr != NULL) {
- gst_buffer_append_memory(mc_buffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mc_buffer->buf_size, 0,
- mc_buffer->buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
- LOGD("%d plane data apended : width : %d, height : %d, size : %d",
- i, stride_width, stride_height, mc_buffer->buf_size);
- }
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ void *uv_ptr = NULL;
+ void *y_ptr = NULL;
+ int buf_size = 0;
+ int stride_width;
+ int stride_height;
+ int width;
+ int height;
+ uint32_t plane_num;
+ int i;
+ int j;
+ int stride = 0;
+
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+
+ width = enc_info->width;
+ height = enc_info->height;
+
+ ret = media_packet_get_number_of_video_planes(pkt, &plane_num);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_number_of_video_planes failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_plane_data_ptr(pkt, 0, &y_ptr);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_plane_data_ptr failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_stride_width failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_stride_height(pkt, 0, &stride_height);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_stride_width failed");
+ return MC_ERROR;
+ }
+
+ if (width == stride_width) {
+ mc_buffer->buf_size += stride_width * stride_height;
+
+ for (i = 1; i < plane_num; i++) {
+ media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
+ media_packet_get_video_stride_width(pkt, i, &stride_width);
+ media_packet_get_video_stride_height(pkt, i, &stride_height);
+
+ buf_size = stride_width * stride_height;
+
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
+ LOGD("width is same with stride");
+ LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
+ mc_buffer->buf_size += buf_size;
+
+ }
+ } else {
+
+ for (j = 0; j < height; j++) {
+ memcpy(y_ptr + mc_buffer->buf_size, y_ptr + stride, width);
+ mc_buffer->buf_size += width;
+ stride += stride_width;
+ }
+
+ stride = 0;
+
+ for (i = 1; i < plane_num; i++) {
+ media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
+ media_packet_get_video_stride_width(pkt, i, &stride_width);
+ media_packet_get_video_stride_height(pkt, i, &stride_height);
+
+ for (j = 0; j < height>>1; j++) {
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr + stride, width>>1);
+ mc_buffer->buf_size += width>>1;
+ stride += stride_width;
+ }
+
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
+ LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
+ mc_buffer->buf_size += buf_size;
+ }
+ }
+
+ if (y_ptr != NULL) {
+ gst_buffer_append_memory(mc_buffer->buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mc_buffer->buf_size, 0,
+ mc_buffer->buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
+ LOGD("%d plane data apended : width : %d, height : %d, size : %d",
+ i, stride_width, stride_height, mc_buffer->buf_size);
+ }
+
+ return ret;
}
/*
* fill_outbuf virtual functions
-*/
+ */
int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- return core->vtable[fill_outbuf](core, data, size, out_pkt);
+ return core->vtable[fill_outbuf](core, data, size, out_pkt);
}
int __mc_fill_vdec_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt)
{
- int i;
- int stride_width;
- int stride_height;
- uint32_t width;
- uint32_t height;
- uint32_t plane_num;
- uint32_t buf_size;
- uint32_t plane_size;
- int ret = MC_ERROR_NONE;
- void *pkt_data = NULL;
- tbm_surface_h tsurf = NULL;
- tbm_surface_info_s tsurf_info;
- tbm_bo bo[MM_VIDEO_BUFFER_PLANE_MAX];
- tbm_bo_handle thandle;
-
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
-
- width = dec_info->width;
- height = dec_info->height;
- stride_width = ALIGN(width, 4);
- stride_height = ALIGN(height, 4);
- buf_size = stride_width * stride_height * 3 / 2;
-
- if (buf_size > size)
- return MC_ERROR;
-
- memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
-
- bo[0] = tbm_bo_alloc(core->bufmgr, buf_size, TBM_BO_WC);
- if (!bo[0]) {
- LOGE("bo allocation failed");
- return MC_ERROR;
- }
-
- tsurf_info.width = dec_info->width;
- tsurf_info.height = dec_info->height;
- tsurf_info.format = TBM_FORMAT_YVU420;
- tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YVU420);
- tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_YVU420);
- tsurf_info.size = 0;
-
- for (i = 0; i < tsurf_info.num_planes; i++) {
- if (i == 0) {
- tsurf_info.planes[i].stride = stride_width;
- tsurf_info.planes[i].size = stride_width * stride_height;
- tsurf_info.planes[i].offset = 0;
- tsurf_info.size = tsurf_info.planes[i].size;
- } else {
- tsurf_info.planes[i].stride = stride_width>>1;
- tsurf_info.planes[i].size = (stride_width>>1) * (stride_height>>1);
- tsurf_info.planes[i].offset = (tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size);
- tsurf_info.size += tsurf_info.planes[i].size;
- }
- }
-
- thandle = tbm_bo_map(bo[0], TBM_DEVICE_CPU, TBM_OPTION_WRITE);
- memcpy(thandle.ptr, data, tsurf_info.size);
- tbm_bo_unmap(bo[0]);
-
- tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, bo, 1);
-
- if (tsurf) {
- media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
- (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, pkt);
- }
-
- return MC_ERROR_NONE;
+ int i;
+ int stride_width;
+ int stride_height;
+ uint32_t width;
+ uint32_t height;
+ uint32_t plane_num;
+ uint32_t buf_size;
+ uint32_t plane_size;
+ int ret = MC_ERROR_NONE;
+ void *pkt_data = NULL;
+ tbm_surface_h tsurf = NULL;
+ tbm_surface_info_s tsurf_info;
+ tbm_bo bo[MM_VIDEO_BUFFER_PLANE_MAX];
+ tbm_bo_handle thandle;
+
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+
+ width = dec_info->width;
+ height = dec_info->height;
+ stride_width = ALIGN(width, 4);
+ stride_height = ALIGN(height, 4);
+ buf_size = stride_width * stride_height * 3 / 2;
+
+ if (buf_size > size)
+ return MC_ERROR;
+
+ memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
+
+ bo[0] = tbm_bo_alloc(core->bufmgr, buf_size, TBM_BO_WC);
+ if (!bo[0]) {
+ LOGE("bo allocation failed");
+ return MC_ERROR;
+ }
+
+ tsurf_info.width = dec_info->width;
+ tsurf_info.height = dec_info->height;
+ tsurf_info.format = TBM_FORMAT_YVU420;
+ tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YVU420);
+ tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_YVU420);
+ tsurf_info.size = 0;
+
+ for (i = 0; i < tsurf_info.num_planes; i++) {
+ if (i == 0) {
+ tsurf_info.planes[i].stride = stride_width;
+ tsurf_info.planes[i].size = stride_width * stride_height;
+ tsurf_info.planes[i].offset = 0;
+ tsurf_info.size = tsurf_info.planes[i].size;
+ } else {
+ tsurf_info.planes[i].stride = stride_width>>1;
+ tsurf_info.planes[i].size = (stride_width>>1) * (stride_height>>1);
+ tsurf_info.planes[i].offset = (tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size);
+ tsurf_info.size += tsurf_info.planes[i].size;
+ }
+ }
+
+ thandle = tbm_bo_map(bo[0], TBM_DEVICE_CPU, TBM_OPTION_WRITE);
+ memcpy(thandle.ptr, data, tsurf_info.size);
+ tbm_bo_unmap(bo[0]);
+
+ tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, bo, 1);
+
+ if (tsurf) {
+ media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
+ (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, pkt);
+ }
+
+ return MC_ERROR_NONE;
}
int __mc_fill_video_packet_with_mm_video_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void *pkt_data = NULL;
- MMVideoBuffer *mm_vbuffer = NULL;
- int i;
- int bo_num = 0;
-
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
- mm_vbuffer = (MMVideoBuffer *)data;
-
- LOGD("buf_share_method %d", mm_vbuffer->type);
-
- LOGD("a[0] : %p, a[1] : %p, p[0] : %p, p[1] : %p",
- mm_vbuffer->data[0], mm_vbuffer->data[1], mm_vbuffer->handle.paddr[0], mm_vbuffer->handle.paddr[1]);
- LOGD("s[0]:%d, e[0]:%d, w[0]:%d, h[0]:%d",
- mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], mm_vbuffer->width[0], mm_vbuffer->height[0]);
-
- if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_PHYSICAL_ADDRESS) {
- media_packet_set_buffer_size(*out_pkt, mm_vbuffer->width[0]*mm_vbuffer->height[0]*3/2);
- media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
-
- __csc_tiled_to_linear_crop(pkt_data, mm_vbuffer->data[0],
- mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], 0, 0, 0, 0);
- __csc_tiled_to_linear_crop(pkt_data+mm_vbuffer->stride_width[0]*mm_vbuffer->stride_height[0],
- mm_vbuffer->data[1], mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0]/2, 0, 0, 0, 0);
- } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_DMABUF_FD) {
- LOGD("FD type");
- } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
- tbm_surface_h tsurf = NULL;
- tbm_surface_info_s tsurf_info;
- memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
-
- /* create tbm surface */
- for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
- if (mm_vbuffer->handle.bo[i]) {
- bo_num++;
- tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
- }
- }
-
- if (bo_num > 0) {
- tsurf_info.width = codec_info->width;
- tsurf_info.height = codec_info->height;
- tsurf_info.format = TBM_FORMAT_NV12; /* bo_format */
- tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
- tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
- tsurf_info.size = 0;
-
- for (i = 0; i < tsurf_info.num_planes; i++) {
- tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
- tsurf_info.planes[i].size = mm_vbuffer->stride_width[i] * mm_vbuffer->stride_height[i];
-
- if (i < bo_num)
- tsurf_info.planes[i].offset = 0;
- else
- tsurf_info.planes[i].offset = tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size;
-
- tsurf_info.size += tsurf_info.planes[i].size;
- }
- LOGD("%d plane stride : %d, size : %d",tsurf_info.planes[i].stride, tsurf_info.planes[i].size);
- tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, (tbm_bo *)mm_vbuffer->handle.bo, bo_num);
- }
-
- if (tsurf) {
- media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
- (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, out_pkt);
- }
- }
-
- return MC_ERROR_NONE;
+ void *pkt_data = NULL;
+ MMVideoBuffer *mm_vbuffer = NULL;
+ int i;
+ int bo_num = 0;
+
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
+ mm_vbuffer = (MMVideoBuffer *)data;
+
+ LOGD("buf_share_method %d", mm_vbuffer->type);
+
+ LOGD("a[0] : %p, a[1] : %p, p[0] : %p, p[1] : %p",
+ mm_vbuffer->data[0], mm_vbuffer->data[1], mm_vbuffer->handle.paddr[0], mm_vbuffer->handle.paddr[1]);
+ LOGD("s[0]:%d, e[0]:%d, w[0]:%d, h[0]:%d",
+ mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], mm_vbuffer->width[0], mm_vbuffer->height[0]);
+
+ if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_PHYSICAL_ADDRESS) {
+ media_packet_set_buffer_size(*out_pkt, mm_vbuffer->width[0]*mm_vbuffer->height[0]*3/2);
+ media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
+
+ __csc_tiled_to_linear_crop(pkt_data, mm_vbuffer->data[0],
+ mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], 0, 0, 0, 0);
+ __csc_tiled_to_linear_crop(pkt_data+mm_vbuffer->stride_width[0]*mm_vbuffer->stride_height[0],
+ mm_vbuffer->data[1], mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0]/2, 0, 0, 0, 0);
+ } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_DMABUF_FD) {
+ LOGD("FD type");
+ } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
+ tbm_surface_h tsurf = NULL;
+ tbm_surface_info_s tsurf_info;
+ memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
+
+ /* create tbm surface */
+ for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
+ if (mm_vbuffer->handle.bo[i]) {
+ bo_num++;
+ tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
+ }
+ }
+
+ if (bo_num > 0) {
+ tsurf_info.width = codec_info->width;
+ tsurf_info.height = codec_info->height;
+ tsurf_info.format = TBM_FORMAT_NV12; /* bo_format */
+ tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
+ tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
+ tsurf_info.size = 0;
+
+ for (i = 0; i < tsurf_info.num_planes; i++) {
+ tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
+ tsurf_info.planes[i].size = mm_vbuffer->stride_width[i] * mm_vbuffer->stride_height[i];
+
+ if (i < bo_num)
+ tsurf_info.planes[i].offset = 0;
+ else
+ tsurf_info.planes[i].offset = tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size;
+
+ tsurf_info.size += tsurf_info.planes[i].size;
+ }
+ LOGD("%d plane stride : %d, size : %d", tsurf_info.planes[i].stride, tsurf_info.planes[i].size);
+ tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, (tbm_bo *)mm_vbuffer->handle.bo, bo_num);
+ }
+
+ if (tsurf) {
+ media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
+ (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, out_pkt);
+ }
+ }
+
+ return MC_ERROR_NONE;
}
int __mc_fill_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void *pkt_data = NULL;
- int ret = MC_ERROR_NONE;
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ void *pkt_data = NULL;
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_create_alloc failed");
- return MC_ERROR;
- }
+ ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_create_alloc failed");
+ return MC_ERROR;
+ }
- media_packet_set_buffer_size(*out_pkt, size);
- media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
- memcpy(pkt_data, data, size);
+ media_packet_set_buffer_size(*out_pkt, size);
+ media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
+ memcpy(pkt_data, data, size);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_fill_venc_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void *pkt_data = NULL;
- bool codec_config = FALSE;
- bool sync_flag = FALSE;
- bool slice = FALSE;
- int codec_data_size = 0;
- int ret = MC_ERROR_NONE;
-
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- switch (core->out_mime) {
- case MEDIA_FORMAT_H264_SP:
- case MEDIA_FORMAT_H264_MP:
- case MEDIA_FORMAT_H264_HP:
- ret = _mc_check_h264_bytestream((unsigned char *)data, size, 1, &codec_config, &sync_flag, &slice);
- break;
- case MEDIA_FORMAT_MPEG4_SP:
- case MEDIA_FORMAT_MPEG4_ASP:
- codec_data_size = _mc_check_mpeg4_out_bytestream((unsigned char *)data, size, &codec_config, &sync_flag);
- break;
- case MEDIA_FORMAT_H263:
- case MEDIA_FORMAT_H263P:
- if (!_mc_check_h263_out_bytestream((unsigned char *)data, size, &sync_flag))
- return MC_INVALID_IN_BUF;
- break;
- default:
- return MC_INVALID_IN_BUF;
- }
- LOGD("codec_config : %d, sync_flag : %d, slice : %d", codec_config, sync_flag, slice);
-
- ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("media_packet_create_alloc failed");
- return MC_ERROR;
- }
-
- media_packet_set_buffer_size(*out_pkt, size);
- media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
- memcpy(pkt_data, data, size);
-
- core->need_sync_flag = sync_flag ? 1 : 0;
- core->need_codec_data = codec_config ? 1 : 0;
-
- return ret;
+ void *pkt_data = NULL;
+ bool codec_config = FALSE;
+ bool sync_flag = FALSE;
+ bool slice = FALSE;
+ int codec_data_size = 0;
+ int ret = MC_ERROR_NONE;
+
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ switch (core->out_mime) {
+ case MEDIA_FORMAT_H264_SP:
+ case MEDIA_FORMAT_H264_MP:
+ case MEDIA_FORMAT_H264_HP:
+ ret = _mc_check_h264_bytestream((unsigned char *)data, size, 1, &codec_config, &sync_flag, &slice);
+ break;
+ case MEDIA_FORMAT_MPEG4_SP:
+ case MEDIA_FORMAT_MPEG4_ASP:
+ codec_data_size = _mc_check_mpeg4_out_bytestream((unsigned char *)data, size, &codec_config, &sync_flag);
+ break;
+ case MEDIA_FORMAT_H263:
+ case MEDIA_FORMAT_H263P:
+ if (!_mc_check_h263_out_bytestream((unsigned char *)data, size, &sync_flag))
+ return MC_INVALID_IN_BUF;
+ break;
+ default:
+ return MC_INVALID_IN_BUF;
+ }
+ LOGD("codec_config : %d, sync_flag : %d, slice : %d", codec_config, sync_flag, slice);
+
+ ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_create_alloc failed");
+ return MC_ERROR;
+ }
+
+ media_packet_set_buffer_size(*out_pkt, size);
+ media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
+ memcpy(pkt_data, data, size);
+
+ core->need_sync_flag = sync_flag ? 1 : 0;
+ core->need_codec_data = codec_config ? 1 : 0;
+
+ return ret;
}
/*
* create_caps virtual functions
-*/
+ */
int __mc_create_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- return core->vtable[create_caps](core, caps, buff, codec_config);
+ return core->vtable[create_caps](core, caps, buff, codec_config);
}
int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "I420",
- "width", G_TYPE_INT, enc_info->width,
- "height", G_TYPE_INT, enc_info->height,
- "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
- NULL);
+ *caps = gst_caps_new_simple("video/x-raw",
+ "format", G_TYPE_STRING, "I420",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
+ NULL);
- LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps);
+ LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_hw_h264enc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "SN12",
- "width", G_TYPE_INT, enc_info->width,
- "height", G_TYPE_INT, enc_info->height,
- "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
- NULL);
- //g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
- g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate*1000, NULL);
+ *caps = gst_caps_new_simple("video/x-raw",
+ "format", G_TYPE_STRING, "SN12",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
+ NULL);
+ g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate*1000, NULL);
- LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps);
+ LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_sprdenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "format", G_TYPE_STRING, "SN12",
- "width", G_TYPE_INT, enc_info->width,
- "height", G_TYPE_INT, enc_info->height,
- "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "format", G_TYPE_STRING, "SN12",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
- g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
- g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
+ g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
+ g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
- LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
+ LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_sprdenc_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "SN12",
- "width", G_TYPE_INT, enc_info->width,
- "height", G_TYPE_INT, enc_info->height,
- "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
+ *caps = gst_caps_new_simple("video/x-raw",
+ "format", G_TYPE_STRING, "SN12",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
- g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
+ g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
- LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
+ LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("%d, %d, ", dec_info->width, dec_info->height);
- *caps = gst_caps_new_simple(core->mime,
- "parsed", G_TYPE_BOOLEAN, TRUE,
- "alignment", G_TYPE_STRING, "au",
- "stream-format", G_TYPE_STRING, "byte-stream",
- "width", G_TYPE_INT, dec_info->width,
- "height", G_TYPE_INT, dec_info->height, NULL);
+ LOGD("%d, %d, ", dec_info->width, dec_info->height);
+ *caps = gst_caps_new_simple(core->mime,
+ "parsed", G_TYPE_BOOLEAN, TRUE,
+ "alignment", G_TYPE_STRING, "au",
+ "stream-format", G_TYPE_STRING, "byte-stream",
+ "width", G_TYPE_INT, dec_info->width,
+ "height", G_TYPE_INT, dec_info->height, NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ return MC_ERROR_NONE;
}
int __mc_sprddec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("%d, %d, ", dec_info->width, dec_info->height);
+ LOGD("%d, %d, ", dec_info->width, dec_info->height);
- *caps = gst_caps_new_simple(core->mime,
- "mpegversion", G_TYPE_INT, 4,
- "width", G_TYPE_INT, dec_info->width,
- "height", G_TYPE_INT, dec_info->height,
- "framerate", GST_TYPE_FRACTION, 30, 1,
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "mpegversion", G_TYPE_INT, 4,
+ "width", G_TYPE_INT, dec_info->width,
+ "height", G_TYPE_INT, dec_info->height,
+ "framerate", GST_TYPE_FRACTION, 30, 1,
+ NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_sprddec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("%d, %d, ", dec_info->width, dec_info->height);
- *caps = gst_caps_new_simple(core->mime,
- "width", G_TYPE_INT, dec_info->width,
- "height", G_TYPE_INT, dec_info->height,
- "framerate", GST_TYPE_FRACTION, 30, 1,
- "alignment", G_TYPE_STRING, "au",
- "stream-format", G_TYPE_STRING, "byte-stream", NULL);
+ LOGD("%d, %d, ", dec_info->width, dec_info->height);
+ *caps = gst_caps_new_simple(core->mime,
+ "width", G_TYPE_INT, dec_info->width,
+ "height", G_TYPE_INT, dec_info->height,
+ "framerate", GST_TYPE_FRACTION, 30, 1,
+ "alignment", G_TYPE_STRING, "au",
+ "stream-format", G_TYPE_STRING, "byte-stream", NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_vdec_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "variant", G_TYPE_STRING, "itu", NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "variant", G_TYPE_STRING, "itu", NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ return MC_ERROR_NONE;
}
int __mc_vdec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "mpegversion", G_TYPE_INT, 4,
- "systemstream", G_TYPE_BOOLEAN, false, NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "mpegversion", G_TYPE_INT, 4,
+ "systemstream", G_TYPE_BOOLEAN, false, NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ return MC_ERROR_NONE;
}
int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "alignment", G_TYPE_STRING, "au",
- "stream-format", G_TYPE_STRING, "byte-stream", NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "alignment", G_TYPE_STRING, "au",
+ "stream-format", G_TYPE_STRING, "byte-stream", NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ return MC_ERROR_NONE;
}
int __mc_vdec_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "alignment", G_TYPE_STRING, "au",
- "stream-format", G_TYPE_STRING, "byte-stream", NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "alignment", G_TYPE_STRING, "au",
+ "stream-format", G_TYPE_STRING, "byte-stream", NULL);
- LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
- return MC_ERROR_NONE;
+ LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height);
+ return MC_ERROR_NONE;
}
int __mc_aenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, enc_info->samplerate,
- "channels", G_TYPE_INT, enc_info->channel,
- "format", G_TYPE_STRING, "F32LE",
- "layout", G_TYPE_STRING, "interleaved", NULL);
-
-/*
-+----GstAudioEncoder
- +----avenc_aac
-
-Element Properties:
- compliance : Adherence of the encoder to the specifications
- flags: readable, writable
- Enum "GstFFMpegCompliance" Default: 0, "normal"
- (2): verystrict - Strictly conform to older spec
- (1): strict - Strictly conform to current spec
- (0): normal - Normal behavior
- (-1): unofficial - Allow unofficial extensions
- (-2): experimental - Allow nonstandardized experimental things
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, enc_info->samplerate,
+ "channels", G_TYPE_INT, enc_info->channel,
+ "format", G_TYPE_STRING, "F32LE",
+ "layout", G_TYPE_STRING, "interleaved", NULL);
+
+ /*
+ +----GstAudioEncoder
+ +----avenc_aac
+
+ Element Properties:
+compliance : Adherence of the encoder to the specifications
+flags: readable, writable
+Enum "GstFFMpegCompliance" Default: 0, "normal"
+(2): verystrict - Strictly conform to older spec
+(1): strict - Strictly conform to current spec
+(0): normal - Normal behavior
+(-1): unofficial - Allow unofficial extensions
+(-2): experimental - Allow nonstandardized experimental things
*/
- g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
+ g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_aenc_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, enc_info->samplerate,
- "channels", G_TYPE_INT, enc_info->channel,
- "format", G_TYPE_STRING, "F32LE",
- "layout", G_TYPE_STRING, "interleaved", NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, enc_info->samplerate,
+ "channels", G_TYPE_INT, enc_info->channel,
+ "format", G_TYPE_STRING, "F32LE",
+ "layout", G_TYPE_STRING, "interleaved", NULL);
- g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
+ g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, enc_info->samplerate,
- "channels", G_TYPE_INT, enc_info->channel,
- "format", G_TYPE_STRING, "S16LE",
- "layout", G_TYPE_STRING, "interleaved",
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, enc_info->samplerate,
+ "channels", G_TYPE_INT, enc_info->channel,
+ "format", G_TYPE_STRING, "S16LE",
+ "layout", G_TYPE_STRING, "interleaved",
+ NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- int ret = MC_ERROR_NONE;
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
- *caps = gst_caps_new_simple(core->mime,
- "framed", G_TYPE_BOOLEAN, TRUE,
- "mpegversion", G_TYPE_INT, 4,
- "stream-format", G_TYPE_STRING, "adts",
- "rate", G_TYPE_INT, dec_info->samplerate,
- "channels", G_TYPE_INT, dec_info->channel,
- NULL);
+ LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
+ *caps = gst_caps_new_simple(core->mime,
+ "framed", G_TYPE_BOOLEAN, TRUE,
+ "mpegversion", G_TYPE_INT, 4,
+ "stream-format", G_TYPE_STRING, "adts",
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ "channels", G_TYPE_INT, dec_info->channel,
+ NULL);
- if (codec_config && (!core->encoder)) {
- guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
- ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_codecdata failed");
- return ret;
- }
- }
+ if (codec_config && (!core->encoder)) {
+ guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
+ ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_codecdata failed");
+ return ret;
+ }
+ }
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return ret;
+ return ret;
}
int __mc_adec_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- int ret = MC_ERROR_NONE;
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
- *caps = gst_caps_new_simple(core->mime,
- "framed", G_TYPE_BOOLEAN, TRUE,
- "mpegversion", G_TYPE_INT, 4,
- "stream-format", G_TYPE_STRING, "adts",
- "rate", G_TYPE_INT, dec_info->samplerate,
- "channels", G_TYPE_INT, dec_info->channel,
- NULL);
+ LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
+ *caps = gst_caps_new_simple(core->mime,
+ "framed", G_TYPE_BOOLEAN, TRUE,
+ "mpegversion", G_TYPE_INT, 4,
+ "stream-format", G_TYPE_STRING, "adts",
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ "channels", G_TYPE_INT, dec_info->channel,
+ NULL);
- if (codec_config && (!core->encoder)) {
- guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
- ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_codecdata failed");
- return ret;
- }
- }
+ if (codec_config && (!core->encoder)) {
+ guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
+ ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_codecdata failed");
+ return ret;
+ }
+ }
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return ret;
+ return ret;
}
int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- int ret = MC_ERROR_NONE;
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)");
- *caps = gst_caps_new_simple(core->mime,
- "mpegversion", G_TYPE_INT, 4, /*TODO : need adding version /profile*/
- "framed", G_TYPE_BOOLEAN, TRUE,
- "stream-format", G_TYPE_STRING, "raw",
- "channels", G_TYPE_INT, dec_info->channel,
- "rate", G_TYPE_INT, dec_info->samplerate,
- NULL);
+ LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)");
+ *caps = gst_caps_new_simple(core->mime,
+ "mpegversion", G_TYPE_INT, 4, /*TODO : need adding version /profile*/
+ "framed", G_TYPE_BOOLEAN, TRUE,
+ "stream-format", G_TYPE_STRING, "raw",
+ "channels", G_TYPE_INT, dec_info->channel,
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ NULL);
- if (codec_config && (!core->encoder)) {
- guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
- ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_codecdata failed");
- return ret;
- }
- }
+ if (codec_config && (!core->encoder)) {
+ guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/
+ ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_codecdata failed");
+ return ret;
+ }
+ }
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return ret;
+ return ret;
}
int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "framed", G_TYPE_BOOLEAN, TRUE,
- "mpegversion", G_TYPE_INT, 1, /* To-Do : plz check */
- "mpegaudioversion", G_TYPE_INT, 1, /* To-Do : plz check */
- "layer", G_TYPE_INT, 3, /* To-Do : plz check */
- "rate", G_TYPE_INT, dec_info->samplerate,
- "channels", G_TYPE_INT, dec_info->channel,
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "framed", G_TYPE_BOOLEAN, TRUE,
+ "mpegversion", G_TYPE_INT, 1, /* To-Do : plz check */
+ "mpegaudioversion", G_TYPE_INT, 1, /* To-Do : plz check */
+ "layer", G_TYPE_INT, 3, /* To-Do : plz check */
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ "channels", G_TYPE_INT, dec_info->channel,
+ NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, 8000,
- "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, 8000,
+ "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */
+ NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, 16000,
- "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, 16000,
+ "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */
+ NULL);
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
int __mc_adec_vorbis_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- int ret = MC_ERROR_NONE;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ int ret = MC_ERROR_NONE;
- *caps = gst_caps_new_simple(core->mime,
- "channels", G_TYPE_INT, dec_info->channel,
- "rate", G_TYPE_INT, dec_info->samplerate,
- /* FIXME - Insert 'Stream Header' */
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "channels", G_TYPE_INT, dec_info->channel,
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ /* FIXME - Insert 'Stream Header' */
+ NULL);
- LOGD(" ----- VORBIS Need Additional Caps -----------");
- /*
- * Need to extract from each Stream header ... or
- * Need to get Demuxer's Caps from each Stream heade
- */
- if (codec_config && (!core->encoder)) {
- guint streamheader_size = 4096; /* VORBIS_CODECDATA_SIZE = 4096 */
- ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_streamheader failed");
- return ret;
- }
- }
+ LOGD(" ----- VORBIS Need Additional Caps -----------");
+ /*
+ * Need to extract from each Stream header ... or
+ * Need to get Demuxer's Caps from each Stream heade
+ */
+ if (codec_config && (!core->encoder)) {
+ guint streamheader_size = 4096; /* VORBIS_CODECDATA_SIZE = 4096 */
+ ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_streamheader failed");
+ return ret;
+ }
+ }
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return ret;
+ return ret;
}
int __mc_adec_flac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
- int ret = MC_ERROR_NONE;
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+ int ret = MC_ERROR_NONE;
- *caps = gst_caps_new_simple(core->mime,
- "channels", G_TYPE_INT, dec_info->channel,
- "rate", G_TYPE_INT, dec_info->samplerate,
- "framed", G_TYPE_BOOLEAN, TRUE,
- /* FIXME - Insert More Info */
- NULL);
+ *caps = gst_caps_new_simple(core->mime,
+ "channels", G_TYPE_INT, dec_info->channel,
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ "framed", G_TYPE_BOOLEAN, TRUE,
+ /* FIXME - Insert More Info */
+ NULL);
- LOGD(" ----- FLAC Need Additional Caps -----------");
- /*
- * Need to extract from each Stream header ... or
- * Need to get Demuxer's Caps from each Stream heade
- */
- if (codec_config && (!core->encoder)) {
- guint streamheader_size = 4096; /* FLAC_CODECDATA_SIZE = 4096 */
- ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_streamheader failed");
- return ret;
- }
- }
+ LOGD(" ----- FLAC Need Additional Caps -----------");
+ /*
+ * Need to extract from each Stream header ... or
+ * Need to get Demuxer's Caps from each Stream heade
+ */
+ if (codec_config && (!core->encoder)) {
+ guint streamheader_size = 4096; /* FLAC_CODECDATA_SIZE = 4096 */
+ ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_streamheader failed");
+ return ret;
+ }
+ }
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
- return ret;
+ return ret;
}
int __mc_adec_wma_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- int ret = MC_ERROR_NONE;
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
-
- /*
- * Need to extract from Stream Type Specific ... or
- * Need to get Demuxer's Caps from Stream Type Specific
- */
- guint16 format_tag = 0;
- gint wma_version = 0;
- gint block_align = 1024; /*FIXME : Need checking */
- gint bitrate = 128000; /*FIXME : Need checking */
-
- LOGD(" ----- WMA Need Additional Caps -----------");
- if (core->codec_id == MEDIACODEC_WMAV1) {
- format_tag = 352; /* 0x160 */
- wma_version = 1;
- } else if (core->codec_id == MEDIACODEC_WMAV2) {
- format_tag = 353; /* 0x161 */
- wma_version = 2;
- } else if (core->codec_id == MEDIACODEC_WMAPRO) {
- format_tag = 354; /* 0x162 */
- wma_version = 3;
- } else if (core->codec_id == MEDIACODEC_WMALSL) {
- format_tag = 355; /* 0x163 */
- wma_version = 3;
- } else {
- LOGE("Not support WMA format");
- }
-
- *caps = gst_caps_new_simple(core->mime,
- "rate", G_TYPE_INT, dec_info->samplerate,
- "channels", G_TYPE_INT, dec_info->channel,
- "bitrate", G_TYPE_INT, bitrate,
- "depth", G_TYPE_INT, dec_info->bit,
- /* FIXME - Need More Info */
- "wmaversion", G_TYPE_INT, wma_version,
- "format_tag", G_TYPE_INT, format_tag,
- "block_align", G_TYPE_INT, block_align,
- NULL);
-
- if (codec_config && (!core->encoder)) {
- guint codecdata_size = 64; /* WMA_CODECDATA_SIZE = 64 */
- ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
- if (ret != MC_ERROR_NONE) {
- LOGW("__mc_set_caps_codecdata failed");
- return ret;
- }
- }
-
- LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
-
- return ret;
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+
+ /*
+ * Need to extract from Stream Type Specific ... or
+ * Need to get Demuxer's Caps from Stream Type Specific
+ */
+ guint16 format_tag = 0;
+ gint wma_version = 0;
+ gint block_align = 1024; /*FIXME : Need checking */
+ gint bitrate = 128000; /*FIXME : Need checking */
+
+ LOGD(" ----- WMA Need Additional Caps -----------");
+ if (core->codec_id == MEDIACODEC_WMAV1) {
+ format_tag = 352; /* 0x160 */
+ wma_version = 1;
+ } else if (core->codec_id == MEDIACODEC_WMAV2) {
+ format_tag = 353; /* 0x161 */
+ wma_version = 2;
+ } else if (core->codec_id == MEDIACODEC_WMAPRO) {
+ format_tag = 354; /* 0x162 */
+ wma_version = 3;
+ } else if (core->codec_id == MEDIACODEC_WMALSL) {
+ format_tag = 355; /* 0x163 */
+ wma_version = 3;
+ } else {
+ LOGE("Not support WMA format");
+ }
+
+ *caps = gst_caps_new_simple(core->mime,
+ "rate", G_TYPE_INT, dec_info->samplerate,
+ "channels", G_TYPE_INT, dec_info->channel,
+ "bitrate", G_TYPE_INT, bitrate,
+ "depth", G_TYPE_INT, dec_info->bit,
+ /* FIXME - Need More Info */
+ "wmaversion", G_TYPE_INT, wma_version,
+ "format_tag", G_TYPE_INT, format_tag,
+ "block_align", G_TYPE_INT, block_align,
+ NULL);
+
+ if (codec_config && (!core->encoder)) {
+ guint codecdata_size = 64; /* WMA_CODECDATA_SIZE = 64 */
+ ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("__mc_set_caps_codecdata failed");
+ return ret;
+ }
+ }
+
+ LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel);
+
+ return ret;
}
static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * name, GstBuffer * buf, ...)
{
- GstStructure *struc = NULL;
- va_list va;
- GValue arr_val = { 0 };
- GValue buf_val = { 0 };
+ GstStructure *struc = NULL;
+ va_list va;
+ GValue arr_val = { 0 };
+ GValue buf_val = { 0 };
- g_return_val_if_fail(name != NULL, NULL);
- g_return_val_if_fail(caps != NULL, NULL);
- g_return_val_if_fail(gst_caps_is_fixed(caps), NULL);
- caps = gst_caps_make_writable(caps);
+ g_return_val_if_fail(name != NULL, NULL);
+ g_return_val_if_fail(caps != NULL, NULL);
+ g_return_val_if_fail(gst_caps_is_fixed(caps), NULL);
+ caps = gst_caps_make_writable(caps);
- struc = gst_caps_get_structure(caps, 0);
- if (!struc)
- LOGW("cannot get structure from caps.\n");
+ struc = gst_caps_get_structure(caps, 0);
+ if (!struc)
+ LOGW("cannot get structure from caps.\n");
- g_value_init(&arr_val, GST_TYPE_ARRAY);
+ g_value_init(&arr_val, GST_TYPE_ARRAY);
- va_start(va, buf);
- while (buf) {
- g_value_init(&buf_val, GST_TYPE_BUFFER);
- gst_value_set_buffer(&buf_val, buf);
- gst_value_array_append_value(&arr_val, &buf_val);
- g_value_unset(&buf_val);
+ va_start(va, buf);
+ while (buf) {
+ g_value_init(&buf_val, GST_TYPE_BUFFER);
+ gst_value_set_buffer(&buf_val, buf);
+ gst_value_array_append_value(&arr_val, &buf_val);
+ g_value_unset(&buf_val);
- buf = va_arg(va, GstBuffer *);
- }
- va_end(va);
+ buf = va_arg(va, GstBuffer *);
+ }
+ va_end(va);
- gst_structure_take_value(struc, name, &arr_val);
+ gst_structure_take_value(struc, name, &arr_val);
- return caps;
+ return caps;
}
int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer*buff, guint streamheader_size)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- void *buf_data = NULL;
- uint64_t buf_size = 0;
- GstBuffer *header1, *header2, *header3;
- guint hsize1, hsize2, hsize3;
- GstBuffer *tmp_header;
- guint8 *tmp_buf = NULL;
- GstMapInfo map;
-
- ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return ret;
- }
-
- ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return ret;
- }
-
- LOGD("Set caps for streamheader in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
-
- if (core->codec_id == MEDIACODEC_VORBIS) {
- /*
- * hsize1 : Identification Header (packet type 1) - fixed 30 byte
- * hsize2 : Comment Header (packet type 3) - variable byte (need calculate)
- * hsize3 : Setup Header (packet type 5) - variable byte (Used remained bytes)
- */
-
- /* First of all, Need to fins and calculate size of hsize2 */
- tmp_header = gst_buffer_new_and_alloc(streamheader_size);
- gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
- gst_buffer_map(tmp_header, &map, GST_MAP_READ);
- tmp_buf = map.data;
- tmp_buf += (30 + 7); /* hsize1 + '0x03' + 'vorbis'*/
- hsize2 = (7 + 4);
- hsize2 += GST_READ_UINT32_LE(tmp_buf);
- hsize2 += (4 + 1);
- LOGD("Find streamheader hsize2(%d)", hsize2);
- gst_buffer_unmap(tmp_header, &map);
- gst_buffer_unref(tmp_header);
-
- /* hsize1 : Identification Header (packet type 1) - fixed 30 byte */
- hsize1 = 30;
- header1 = gst_buffer_new_and_alloc(hsize1);
- gst_buffer_fill(header1, 0, buf_data, hsize1);
- gst_buffer_map(header1, &map, GST_MAP_READ);
- tmp_buf = map.data;
- /* '0x01' + 'vorbis' */
- if (*tmp_buf != 0x01) {
- LOGE("[ERROR] Invalid Caps of Stream header1");
- gst_buffer_unmap(header1, &map);
- return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
- }
- gst_buffer_unmap(header1, &map);
-
- /* hsize2 : Comment Header (packet type 3) - variable byte */
- header2 = gst_buffer_new_and_alloc(hsize2);
- gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
- gst_buffer_map(header2, &map, GST_MAP_READ);
- tmp_buf = map.data;
- /* '0x03' + 'vorbis' */
- if (*tmp_buf != 0x03) {
- LOGE("[ERROR] Invalid Caps of Stream header2");
- gst_buffer_unmap(header2, &map);
- return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
- }
- gst_buffer_unmap(header2, &map);
-
- /* hsize3 : Setup Header (packet type 5) - variable byte */
- hsize3 = streamheader_size - (hsize1 + hsize2);
- header3 = gst_buffer_new_and_alloc(hsize3);
- gst_buffer_fill(header3, 0, (buf_data + (hsize1 + hsize2)), hsize3);
- gst_buffer_map(header3, &map, GST_MAP_READ);
- tmp_buf = map.data;
- /* '0x05' + 'vorbis' */
- if (*tmp_buf != 0x05) {
- LOGE("[ERROR] Invalid Caps of Stream header3");
- gst_buffer_unmap(header3, &map);
- return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
- }
- gst_buffer_unmap(header3, &map);
-
- LOGD("[vorbis] streamheader hsize1 (%d) + hsize2 (%d) + hsize3 (%d) = Total (%d)",
- hsize1, hsize2, hsize3, (hsize1 + hsize2 + hsize3));
-
- __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, header3, NULL);
-
- gst_buffer_unref(header1);
- gst_buffer_unref(header2);
- gst_buffer_unref(header3);
- } else if (core->codec_id == MEDIACODEC_FLAC) {
- /*
- * hsize1 : Stream Info (type 0) - fixed 51 byte
- * hsize2 : Stream Comment (type 4) - variable byte (need calculate)
- */
-
- /* First of all, Need to fins and calculate size of hsize2 */
- tmp_header = gst_buffer_new_and_alloc(streamheader_size);
- gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
- gst_buffer_map(tmp_header, &map, GST_MAP_READ);
- tmp_buf = map.data;
- hsize2 = 4 + ((tmp_buf[52] << 16) | (tmp_buf[53] << 8) | (tmp_buf[54]));
- LOGD("Find streamheader hsize2(%d)", hsize2);
- gst_buffer_unmap(tmp_header, &map);
- gst_buffer_unref(tmp_header);
-
- /* hsize1 : Stream Info (type 0) - fixed 51 byte */
- hsize1 = 51;
- header1 = gst_buffer_new_and_alloc(hsize1);
- gst_buffer_fill(header1, 0, buf_data, hsize1);
- gst_buffer_map(header1, &map, GST_MAP_READ);
- tmp_buf = map.data;
- /* '0x7f' + 'FLAC' */
- if (*tmp_buf != 0x07f) {
- LOGE("[ERROR] Invalid Caps of Stream header1 (Info)");
- gst_buffer_unmap(header1, &map);
- gst_buffer_unref(header1);
- return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
- }
- gst_buffer_unmap(header1, &map);
-
- /* hsize2 : Stream Comment (type 4) - variable byte (need calculate) */
- header2 = gst_buffer_new_and_alloc(hsize2);
- gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
- gst_buffer_map(header2, &map, GST_MAP_READ);
- tmp_buf = map.data;
- /* '0x84' */
- if (*tmp_buf != 0x84) {
- LOGE("[ERROR] Invalid Caps of Stream header2 (Comment)");
- gst_buffer_unmap(header2, &map);
- gst_buffer_unref(header1);
- gst_buffer_unref(header2);
- return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
- }
- gst_buffer_unmap(header2, &map);
-
- LOGD("[flac] streamheader hsize1 (%d) + hsize2 (%d) = Total (%d)", hsize1, hsize2, (hsize1 + hsize2));
- __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, NULL);
- gst_buffer_unref(header1);
- gst_buffer_unref(header2);
- } else {
- LOGE("Not support case of Stream header Caps");
- }
-
- /* Update gstbuffer's data ptr and size for using previous streamheader.*/
- LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
- gst_buffer_remove_memory_range(buff->buffer, streamheader_size, -1);
- gst_buffer_set_size(buff->buffer, buf_size - streamheader_size);
- LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
-
- return ret;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ GstBuffer *header1, *header2, *header3;
+ guint hsize1, hsize2, hsize3;
+ GstBuffer *tmp_header;
+ guint8 *tmp_buf = NULL;
+ GstMapInfo map;
+
+ ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ LOGD("Set caps for streamheader in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
+
+ if (core->codec_id == MEDIACODEC_VORBIS) {
+ /*
+ * hsize1 : Identification Header (packet type 1) - fixed 30 byte
+ * hsize2 : Comment Header (packet type 3) - variable byte (need calculate)
+ * hsize3 : Setup Header (packet type 5) - variable byte (Used remained bytes)
+ */
+
+ /* First of all, Need to fins and calculate size of hsize2 */
+ tmp_header = gst_buffer_new_and_alloc(streamheader_size);
+ gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
+ gst_buffer_map(tmp_header, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ tmp_buf += (30 + 7); /* hsize1 + '0x03' + 'vorbis'*/
+ hsize2 = (7 + 4);
+ hsize2 += GST_READ_UINT32_LE(tmp_buf);
+ hsize2 += (4 + 1);
+ LOGD("Find streamheader hsize2(%d)", hsize2);
+ gst_buffer_unmap(tmp_header, &map);
+ gst_buffer_unref(tmp_header);
+
+ /* hsize1 : Identification Header (packet type 1) - fixed 30 byte */
+ hsize1 = 30;
+ header1 = gst_buffer_new_and_alloc(hsize1);
+ gst_buffer_fill(header1, 0, buf_data, hsize1);
+ gst_buffer_map(header1, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x01' + 'vorbis' */
+ if (*tmp_buf != 0x01) {
+ LOGE("[ERROR] Invalid Caps of Stream header1");
+ gst_buffer_unmap(header1, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header1, &map);
+
+ /* hsize2 : Comment Header (packet type 3) - variable byte */
+ header2 = gst_buffer_new_and_alloc(hsize2);
+ gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
+ gst_buffer_map(header2, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x03' + 'vorbis' */
+ if (*tmp_buf != 0x03) {
+ LOGE("[ERROR] Invalid Caps of Stream header2");
+ gst_buffer_unmap(header2, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header2, &map);
+
+ /* hsize3 : Setup Header (packet type 5) - variable byte */
+ hsize3 = streamheader_size - (hsize1 + hsize2);
+ header3 = gst_buffer_new_and_alloc(hsize3);
+ gst_buffer_fill(header3, 0, (buf_data + (hsize1 + hsize2)), hsize3);
+ gst_buffer_map(header3, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x05' + 'vorbis' */
+ if (*tmp_buf != 0x05) {
+ LOGE("[ERROR] Invalid Caps of Stream header3");
+ gst_buffer_unmap(header3, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header3, &map);
+
+ LOGD("[vorbis] streamheader hsize1 (%d) + hsize2 (%d) + hsize3 (%d) = Total (%d)",
+ hsize1, hsize2, hsize3, (hsize1 + hsize2 + hsize3));
+
+ __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, header3, NULL);
+
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ gst_buffer_unref(header3);
+ } else if (core->codec_id == MEDIACODEC_FLAC) {
+ /*
+ * hsize1 : Stream Info (type 0) - fixed 51 byte
+ * hsize2 : Stream Comment (type 4) - variable byte (need calculate)
+ */
+
+ /* First of all, Need to fins and calculate size of hsize2 */
+ tmp_header = gst_buffer_new_and_alloc(streamheader_size);
+ gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
+ gst_buffer_map(tmp_header, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ hsize2 = 4 + ((tmp_buf[52] << 16) | (tmp_buf[53] << 8) | (tmp_buf[54]));
+ LOGD("Find streamheader hsize2(%d)", hsize2);
+ gst_buffer_unmap(tmp_header, &map);
+ gst_buffer_unref(tmp_header);
+
+ /* hsize1 : Stream Info (type 0) - fixed 51 byte */
+ hsize1 = 51;
+ header1 = gst_buffer_new_and_alloc(hsize1);
+ gst_buffer_fill(header1, 0, buf_data, hsize1);
+ gst_buffer_map(header1, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x7f' + 'FLAC' */
+ if (*tmp_buf != 0x07f) {
+ LOGE("[ERROR] Invalid Caps of Stream header1 (Info)");
+ gst_buffer_unmap(header1, &map);
+ gst_buffer_unref(header1);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header1, &map);
+
+ /* hsize2 : Stream Comment (type 4) - variable byte (need calculate) */
+ header2 = gst_buffer_new_and_alloc(hsize2);
+ gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
+ gst_buffer_map(header2, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x84' */
+ if (*tmp_buf != 0x84) {
+ LOGE("[ERROR] Invalid Caps of Stream header2 (Comment)");
+ gst_buffer_unmap(header2, &map);
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header2, &map);
+
+ LOGD("[flac] streamheader hsize1 (%d) + hsize2 (%d) = Total (%d)", hsize1, hsize2, (hsize1 + hsize2));
+ __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, NULL);
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ } else {
+ LOGE("Not support case of Stream header Caps");
+ }
+
+ /* Update gstbuffer's data ptr and size for using previous streamheader.*/
+ LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+ gst_buffer_remove_memory_range(buff->buffer, streamheader_size, -1);
+ gst_buffer_set_size(buff->buffer, buf_size - streamheader_size);
+ LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+
+ return ret;
}
int __mc_set_caps_codecdata(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, guint codecdata_size)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- void *buf_data = NULL;
- uint64_t buf_size = 0;
- GstBuffer *codecdata_buffer;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ GstBuffer *codecdata_buffer;
- ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return ret;
- }
+ ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
- ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return ret;
- }
+ ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
- LOGD("Set caps for codec_data in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
+ LOGD("Set caps for codec_data in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
- /* Add the codec_data attribute to caps, if we have it */
- codecdata_buffer = gst_buffer_new();
- gst_buffer_copy_into(codecdata_buffer, buff->buffer, GST_BUFFER_COPY_MEMORY,0, codecdata_size);
- gst_buffer_ref(codecdata_buffer);
- LOGD("setting codec_data from (packet) buf_data used codecdata_size (%d)", codecdata_size);
+ /* Add the codec_data attribute to caps, if we have it */
+ codecdata_buffer = gst_buffer_new();
+ gst_buffer_copy_into(codecdata_buffer, buff->buffer, GST_BUFFER_COPY_MEMORY, 0, codecdata_size);
+ gst_buffer_ref(codecdata_buffer);
+ LOGD("setting codec_data from (packet) buf_data used codecdata_size (%d)", codecdata_size);
- gst_caps_set_simple(*caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL);
- gst_buffer_unref(codecdata_buffer);
+ gst_caps_set_simple(*caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL);
+ gst_buffer_unref(codecdata_buffer);
- /* Update gstbuffer's data ptr and size for using previous codec_data..*/
- LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+ /* Update gstbuffer's data ptr and size for using previous codec_data..*/
+ LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
- gst_buffer_replace_memory(buff->buffer, 0,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data + codecdata_size , buf_size - codecdata_size, 0,
- buf_size - codecdata_size, buff, (GDestroyNotify)gst_mediacodec_buffer_finalize));
+ gst_buffer_replace_memory(buff->buffer, 0,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data + codecdata_size , buf_size - codecdata_size, 0,
+ buf_size - codecdata_size, buff, (GDestroyNotify)gst_mediacodec_buffer_finalize));
- LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+ LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
- return ret;
+ return ret;
}
int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime)
{
- if (media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE) {
- LOGE("media format create failed");
- return MC_ERROR;
- }
-
- if (encoder) {
- mc_encoder_info_t *info;
-
- info = (mc_encoder_info_t *)core->codec_info;
-
- if (video) {
- media_format_set_video_mime(core->output_fmt, out_mime);
- media_format_set_video_width(core->output_fmt, info->width);
- media_format_set_video_height(core->output_fmt, info->height);
- media_format_set_video_avg_bps(core->output_fmt, info->bitrate);
- } else {
- media_format_set_audio_mime(core->output_fmt, out_mime);
- media_format_set_audio_channel(core->output_fmt, info->channel);
- media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
- media_format_set_audio_bit(core->output_fmt, info->bit);
- media_format_set_audio_avg_bps(core->output_fmt, info->bitrate);
- }
- } else {
- mc_decoder_info_t *info;
-
- info = (mc_decoder_info_t *)core->codec_info;
-
- if (video) {
- media_format_set_video_mime(core->output_fmt, out_mime);
- media_format_set_video_width(core->output_fmt, info->width);
- media_format_set_video_height(core->output_fmt, info->height);
- } else {
- media_format_set_audio_mime(core->output_fmt, out_mime);
- media_format_set_audio_channel(core->output_fmt, info->channel);
- media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
- media_format_set_audio_bit(core->output_fmt, info->bit);
- }
- }
- return MC_ERROR_NONE;
+ if (media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE) {
+ LOGE("media format create failed");
+ return MC_ERROR;
+ }
+
+ if (encoder) {
+ mc_encoder_info_t *info;
+
+ info = (mc_encoder_info_t *)core->codec_info;
+
+ if (video) {
+ media_format_set_video_mime(core->output_fmt, out_mime);
+ media_format_set_video_width(core->output_fmt, info->width);
+ media_format_set_video_height(core->output_fmt, info->height);
+ media_format_set_video_avg_bps(core->output_fmt, info->bitrate);
+ } else {
+ media_format_set_audio_mime(core->output_fmt, out_mime);
+ media_format_set_audio_channel(core->output_fmt, info->channel);
+ media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
+ media_format_set_audio_bit(core->output_fmt, info->bit);
+ media_format_set_audio_avg_bps(core->output_fmt, info->bitrate);
+ }
+ } else {
+ mc_decoder_info_t *info;
+
+ info = (mc_decoder_info_t *)core->codec_info;
+
+ if (video) {
+ media_format_set_video_mime(core->output_fmt, out_mime);
+ media_format_set_video_width(core->output_fmt, info->width);
+ media_format_set_video_height(core->output_fmt, info->height);
+ } else {
+ media_format_set_audio_mime(core->output_fmt, out_mime);
+ media_format_set_audio_channel(core->output_fmt, info->channel);
+ media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
+ media_format_set_audio_bit(core->output_fmt, info->bit);
+ }
+ }
+ return MC_ERROR_NONE;
}
/*
* mc_gst_core functions
-*/
+ */
mc_gst_core_t *mc_gst_core_new()
{
- mc_gst_core_t *core;
+ mc_gst_core_t *core;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- core = g_new0(mc_gst_core_t, 1);
+ core = g_new0(mc_gst_core_t, 1);
- /* 0 : input, 1 : output */
- core->ports[0] = NULL;
- core->ports[1] = mc_gst_port_new(core);
- core->ports[1]->index = 1;
+ /* 0 : input, 1 : output */
+ core->ports[0] = NULL;
+ core->ports[1] = mc_gst_port_new(core);
+ core->ports[1]->index = 1;
- core->available_queue = g_new0(mc_aqueue_t, 1);
- core->available_queue->input = mc_async_queue_new();
+ core->available_queue = g_new0(mc_aqueue_t, 1);
+ core->available_queue->input = mc_async_queue_new();
- g_mutex_init(&core->eos_mutex);
- g_cond_init(&core->eos_cond);
- g_mutex_init(&core->prepare_lock);
- g_mutex_init(&core->drain_lock);
+ g_mutex_init(&core->eos_mutex);
+ g_cond_init(&core->eos_cond);
+ g_mutex_init(&core->prepare_lock);
+ g_mutex_init(&core->drain_lock);
- core->need_feed = false;
- core->eos = false;
- core->need_codec_data = false;
- core->need_sync_flag = false;
- core->unprepare_flag = false;
- core->prepare_count = 0;
- core->queued_count = 0;
- core->dequeued_count = 0;
+ core->need_feed = false;
+ core->eos = false;
+ core->need_codec_data = false;
+ core->need_sync_flag = false;
+ core->unprepare_flag = false;
+ core->prepare_count = 0;
+ core->queued_count = 0;
+ core->dequeued_count = 0;
- g_atomic_int_set(&core->available_queue->running, 1);
- core->available_queue->thread = g_thread_new("feed thread", &feed_task, core);
+ g_atomic_int_set(&core->available_queue->running, 1);
+ core->available_queue->thread = g_thread_new("feed thread", &feed_task, core);
- core->bufmgr = NULL;
- core->drm_fd = -1;
- LOGD("gst_core(%p) is created", core);
+ core->bufmgr = NULL;
+ core->drm_fd = -1;
+ LOGD("gst_core(%p) is created", core);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return core;
+ return core;
}
void mc_gst_core_free(mc_gst_core_t *core)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- mc_aqueue_t *async_queue;
+ mc_aqueue_t *async_queue;
- async_queue = core->available_queue;
+ async_queue = core->available_queue;
- mc_async_queue_disable(async_queue->input);
+ mc_async_queue_disable(async_queue->input);
- g_atomic_int_set(&async_queue->running, 0);
- g_thread_join(async_queue->thread);
+ g_atomic_int_set(&async_queue->running, 0);
+ g_thread_join(async_queue->thread);
- g_mutex_clear(&core->eos_mutex);
- g_mutex_clear(&core->prepare_lock);
- g_mutex_clear(&core->drain_lock);
- g_cond_clear(&core->eos_cond);
+ g_mutex_clear(&core->eos_mutex);
+ g_mutex_clear(&core->prepare_lock);
+ g_mutex_clear(&core->drain_lock);
+ g_cond_clear(&core->eos_cond);
- mc_async_queue_free(async_queue->input);
- g_free(async_queue);
+ mc_async_queue_free(async_queue->input);
+ g_free(async_queue);
- if (core->ports[1] != NULL) {
- mc_gst_port_free(core->ports[1]);
- core->ports[1] = NULL;
- }
+ if (core->ports[1] != NULL) {
+ mc_gst_port_free(core->ports[1]);
+ core->ports[1] = NULL;
+ }
- LOGD("gst_core(%p) is destroyed", core);
- g_free(core);
+ LOGD("gst_core(%p) is destroyed", core);
+ g_free(core);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
}
/*
*/
mc_gst_port_t *mc_gst_port_new(mc_gst_core_t *core)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- mc_gst_port_t *port;
+ mc_gst_port_t *port;
- port = g_new0(mc_gst_port_t, 1);
- port->core = core;
- port->num_buffers = -1;
- port->buffer_size = 0;
- port->is_allocated = 0;
- port->buffers = NULL;
+ port = g_new0(mc_gst_port_t, 1);
+ port->core = core;
+ port->num_buffers = -1;
+ port->buffer_size = 0;
+ port->is_allocated = 0;
+ port->buffers = NULL;
- g_mutex_init(&port->mutex);
- g_cond_init(&port->buffer_cond);
- port->queue = g_queue_new();
+ g_mutex_init(&port->mutex);
+ g_cond_init(&port->buffer_cond);
+ port->queue = g_queue_new();
- LOGD("gst_port(%p) is created", port);
+ LOGD("gst_port(%p) is created", port);
- MEDIACODEC_FLEAVE();
- return port;
+ MEDIACODEC_FLEAVE();
+ return port;
}
void mc_gst_port_free(mc_gst_port_t *port)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- g_mutex_clear(&port->mutex);
- g_cond_clear(&port->buffer_cond);
- g_queue_free(port->queue);
+ g_mutex_clear(&port->mutex);
+ g_cond_clear(&port->buffer_cond);
+ g_queue_free(port->queue);
- LOGD("gst_port(%p) is freed", port);
- g_free(port);
+ LOGD("gst_port(%p) is freed", port);
+ g_free(port);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return;
+ return;
}
static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- /*TODO remove is_hw param*/
- core->format = __mc_get_gst_input_format(pkt, core->is_hw);
+ /*TODO remove is_hw param*/
+ core->format = __mc_get_gst_input_format(pkt, core->is_hw);
+
+ GstPad *pad = NULL;
+ GstCaps *template_caps;
- GstPad *pad = NULL;
- GstCaps *template_caps;
+ pad = gst_element_get_static_pad(core->codec, "src");
+ template_caps = gst_pad_get_pad_template_caps(pad);
- pad = gst_element_get_static_pad(core->codec, "src");
- template_caps = gst_pad_get_pad_template_caps(pad);
+ __mc_create_caps(core, caps, buff, codec_config);
+ g_object_set(core->appsrc, "caps", *caps, NULL);
- __mc_create_caps(core, caps, buff, codec_config);
- g_object_set(core->appsrc, "caps", *caps, NULL);
+ if (gst_caps_is_subset(*caps, template_caps))
+ LOGD("new caps is subset of template caps");
- if (gst_caps_is_subset(*caps, template_caps)) {
- LOGD("new caps is subset of template caps");
- }
- gst_object_unref(pad);
+ gst_object_unref(pad);
}
static gpointer feed_task(gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t *)data;
- int ret = MC_ERROR_NONE;
- bool codec_config = FALSE;
- bool eos = FALSE;
- media_packet_h in_buf = NULL;
- GstMCBuffer *buff = NULL;
- GstCaps *new_caps = NULL;
- bool initiative = true;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
+ int ret = MC_ERROR_NONE;
+ bool codec_config = FALSE;
+ bool eos = FALSE;
+ media_packet_h in_buf = NULL;
+ GstMCBuffer *buff = NULL;
+ GstCaps *new_caps = NULL;
+ bool initiative = true;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- while (g_atomic_int_get(&core->available_queue->running)) {
- LOGD("waiting for next input....");
- in_buf = _mc_get_input_buffer(core);
+ while (g_atomic_int_get(&core->available_queue->running)) {
+ LOGD("waiting for next input....");
+ in_buf = _mc_get_input_buffer(core);
- if (!in_buf)
- goto LEAVE;
+ if (!in_buf)
+ goto LEAVE;
- if (media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("media_packet_is_codec_config failed");
- goto ERROR;
- }
+ if (media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("media_packet_is_codec_config failed");
+ goto ERROR;
+ }
- if (media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("media_packet_is_end_of_stream failed");
- goto ERROR;
- }
+ if (media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("media_packet_is_end_of_stream failed");
+ goto ERROR;
+ }
- buff = _mc_gst_media_packet_to_gstbuffer(core, &new_caps, in_buf, codec_config);
- if (!buff) {
- LOGW("gstbuffer can't make");
- goto ERROR;
- }
+ buff = _mc_gst_media_packet_to_gstbuffer(core, &new_caps, in_buf, codec_config);
+ if (!buff) {
+ LOGW("gstbuffer can't make");
+ goto ERROR;
+ }
- if (codec_config)
- initiative = true;
+ if (codec_config)
+ initiative = true;
- if (initiative) {
- GstPad *pad;
+ if (initiative) {
+ GstPad *pad;
- _mc_gst_update_caps(core, in_buf, &new_caps, buff, codec_config);
+ _mc_gst_update_caps(core, in_buf, &new_caps, buff, codec_config);
- pad = gst_element_get_static_pad(core->appsrc, "src");
- gst_pad_push_event(pad, gst_event_new_stream_start("sejun"));
- gst_object_unref(pad);
+ pad = gst_element_get_static_pad(core->appsrc, "src");
+ gst_pad_push_event(pad, gst_event_new_stream_start("sejun"));
+ gst_object_unref(pad);
- LOGD("caps updated");
- }
+ LOGD("caps updated");
+ }
- /* inject buffer */
- ret = _mc_gst_gstbuffer_to_appsrc(core, buff);
- if (ret != GST_FLOW_OK) {
- LOGE("Failed to push gst buffer");
- goto ERROR;
- }
+ /* inject buffer */
+ ret = _mc_gst_gstbuffer_to_appsrc(core, buff);
+ if (ret != GST_FLOW_OK) {
+ LOGE("Failed to push gst buffer");
+ goto ERROR;
+ }
- initiative = false;
+ initiative = false;
- if (eos) {
- LOGD("end of stream");
- gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc));
- _mc_wait_for_eos(core);
- initiative = true;
- }
+ if (eos) {
+ LOGD("end of stream");
+ gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc));
+ _mc_wait_for_eos(core);
+ initiative = true;
+ }
- continue;
+ continue;
ERROR:
- _mc_gst_set_flush_input(core);
+ _mc_gst_set_flush_input(core);
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
- ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
- (MC_INTERNAL_ERROR, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
+ ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
+ (MC_INTERNAL_ERROR, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
+ }
- continue;
+ continue;
LEAVE:
- /*LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);*/
- continue;
+ /*LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);*/
+ continue;
- }
+ }
- if (new_caps) {
- gst_caps_unref(new_caps);
- }
- LOGI("status : in_buf : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task",
- in_buf, codec_config, eos, core->video, core->encoder);
- LOGD("feed task finished %p v(%d)e(%d)", core, core->video, core->encoder);
+ if (new_caps)
+ gst_caps_unref(new_caps);
- MEDIACODEC_FLEAVE();
+ LOGI("status : in_buf : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task",
+ in_buf, codec_config, eos, core->video, core->encoder);
+ LOGD("feed task finished %p v(%d)e(%d)", core, core->video, core->encoder);
- return NULL;
+ MEDIACODEC_FLEAVE();
+
+ return NULL;
}
static void __mc_gst_stop_feed(GstElement *pipeline, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t *)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
- LOGI("stop_feed called");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
- ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- (MEDIACODEC_ENOUGH_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
- }
+ LOGI("stop_feed called");
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
+ ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
+ (MEDIACODEC_ENOUGH_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
+ }
}
static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t *)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
- LOGI("start_feed called");
+ LOGI("start_feed called");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
- ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- (MEDIACODEC_NEED_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
+ ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
+ (MEDIACODEC_NEED_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
+ }
}
static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboolean encoder, gboolean is_hw)
{
- MEDIACODEC_FENTER();
-
- g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
-
- switch (id) {
- case MEDIACODEC_AAC:
- {
- /* if set to 'CODEC_CONFIG', then It is also available case of MEDIA_FORMAT_AAC_LC (RAW) */
- LOGD("aac lc (adts) vtable");
- core->vtable = encoder ? aenc_aac_vtable : adec_aac_vtable;
- break;
- }
- case MEDIACODEC_AAC_HE:
- case MEDIACODEC_AAC_HE_PS:
- {
- LOGD("aac he v12 vtable");
- core->vtable = encoder ? aenc_aac_vtable : adec_aacv12_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_MP3:
- {
- LOGD("mp3 vtable - Only support decoder");
- core->vtable = encoder ? aenc_vtable : adec_mp3_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_AMR_NB:
- {
- LOGD("amrnb vtable");
- core->vtable = encoder ? aenc_amrnb_vtable : adec_amrnb_vtable;
- break;
- }
- case MEDIACODEC_AMR_WB:
- {
- LOGD("amrwb vtable - Only support decoder");
- core->vtable = encoder ? aenc_vtable : adec_amrwb_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] amr-wb encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_VORBIS:
- {
- LOGD("vorbis vtable");
- core->vtable = encoder ? aenc_vtable : adec_vorbis_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] vorbis encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_FLAC:
- {
- LOGD("flac vtable");
- core->vtable = encoder ? aenc_vtable : adec_flac_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] flac encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_WMAV1:
- case MEDIACODEC_WMAV2:
- case MEDIACODEC_WMAPRO:
- case MEDIACODEC_WMALSL:
- {
- LOGD("wma(V1 / V2 / LSL / PRO) vtable");
- core->vtable = encoder ? aenc_vtable : adec_wma_vtable;
- if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!");
- return MC_NOT_SUPPORTED;
- }
- break;
- }
- case MEDIACODEC_H263:
- {
- LOGD("h263 vtable");
- core->vtable = encoder ? (is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable) : is_hw ? vdec_h263_hw_vtable : vdec_h263_sw_vtable;
- break;
- }
- case MEDIACODEC_MPEG4:
- {
- LOGD("mpeg4 vtable");
- core->vtable = encoder ? (is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable) : is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable;
-
- break;
- }
- case MEDIACODEC_H264:
- {
- LOGD("h264 vtable");
- core->vtable = encoder ? (is_hw ? venc_h264_hw_vtable : venc_vtable) : is_hw ? vdec_h264_hw_vtable : vdec_h264_sw_vtable;
- break;
- }
- default:
- break;
- }
-
- return MC_ERROR_NONE;
+ MEDIACODEC_FENTER();
+
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ switch (id) {
+ case MEDIACODEC_AAC:
+ /* if set to 'CODEC_CONFIG', then It is also available case of MEDIA_FORMAT_AAC_LC (RAW) */
+ LOGD("aac lc (adts) vtable");
+ core->vtable = encoder ? aenc_aac_vtable : adec_aac_vtable;
+ break;
+ case MEDIACODEC_AAC_HE:
+ case MEDIACODEC_AAC_HE_PS:
+ LOGD("aac he v12 vtable");
+ core->vtable = encoder ? aenc_aac_vtable : adec_aacv12_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_MP3:
+ LOGD("mp3 vtable - Only support decoder");
+ core->vtable = encoder ? aenc_vtable : adec_mp3_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_AMR_NB:
+ LOGD("amrnb vtable");
+ core->vtable = encoder ? aenc_amrnb_vtable : adec_amrnb_vtable;
+ break;
+ case MEDIACODEC_AMR_WB:
+ LOGD("amrwb vtable - Only support decoder");
+ core->vtable = encoder ? aenc_vtable : adec_amrwb_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] amr-wb encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_VORBIS:
+ LOGD("vorbis vtable");
+ core->vtable = encoder ? aenc_vtable : adec_vorbis_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] vorbis encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_FLAC:
+ LOGD("flac vtable");
+ core->vtable = encoder ? aenc_vtable : adec_flac_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] flac encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_WMAV1:
+ case MEDIACODEC_WMAV2:
+ case MEDIACODEC_WMAPRO:
+ case MEDIACODEC_WMALSL:
+ LOGD("wma(V1 / V2 / LSL / PRO) vtable");
+ core->vtable = encoder ? aenc_vtable : adec_wma_vtable;
+ if (encoder) {
+ LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!");
+ return MC_NOT_SUPPORTED;
+ }
+ break;
+ case MEDIACODEC_H263:
+ LOGD("h263 vtable");
+ core->vtable = encoder ? (is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable) : is_hw ? vdec_h263_hw_vtable : vdec_h263_sw_vtable;
+ break;
+ case MEDIACODEC_MPEG4:
+ LOGD("mpeg4 vtable");
+ core->vtable = encoder ? (is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable) : is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable;
+
+ break;
+ case MEDIACODEC_H264:
+ LOGD("h264 vtable");
+ core->vtable = encoder ? (is_hw ? venc_h264_hw_vtable : venc_vtable) : is_hw ? vdec_h264_hw_vtable : vdec_h264_sw_vtable;
+ break;
+ default:
+ break;
+ }
+
+ return MC_ERROR_NONE;
}
static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- int ret = MC_ERROR_NONE;
+ int ret = MC_ERROR_NONE;
- LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "",
- buff->buffer, gst_buffer_get_size(buff->buffer));
+ LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "",
+ buff->buffer, gst_buffer_get_size(buff->buffer));
- ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), buff->buffer);
+ ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), buff->buffer);
- return ret;
+ return ret;
}
media_packet_h _mc_get_input_buffer(mc_gst_core_t *core)
{
- LOGD("waiting for input...");
- return mc_async_queue_pop(core->available_queue->input);
+ LOGD("waiting for input...");
+ return mc_async_queue_pop(core->available_queue->input);
}
mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
{
- MEDIACODEC_FENTER();
-
- int ret = MC_ERROR_NONE;
- media_format_mimetype_e out_mime;
- int num_supported_codec=0;
- int i = 0;
-
- if (!mc_handle)
- return MC_PARAM_ERROR;
-
- mediacodec_codec_type_e id;
- bool video;
- bool encoder;
- bool hardware;
- gchar *factory_name = NULL;
- mc_codec_map_t *codec_map;
-
- id = mc_handle->codec_id;
- video = mc_handle->is_video;
- encoder = mc_handle->is_encoder;
- hardware = mc_handle->is_hw;
- codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
- num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
-
- for (i = 0; i < num_supported_codec; i++){
- if ((id == codec_map[i].id) && (hardware == codec_map[i].hardware))
- break;
- }
-
- if (i == num_supported_codec)
- return MC_NOT_SUPPORTED;
-
- factory_name = codec_map[i].type.factory_name;
- out_mime = codec_map[i].type.out_format;
-
- /* gst_core create */
- mc_gst_core_t *new_core = mc_gst_core_new();
-
- new_core->mime = codec_map[i].type.mime;
- new_core->is_hw = hardware;
- new_core->eos = false;
- new_core->encoder = encoder;
- new_core->video = video;
- new_core->codec_info = encoder ? (void *)&mc_handle->info.encoder : (void *)&mc_handle->info.decoder;
- new_core->out_mime = codec_map[i].type.out_format;
- new_core->codec_id = id;
-
- new_core->bufmgr = tbm_bufmgr_init(new_core->drm_fd);
- if (new_core->bufmgr == NULL) {
- LOGE("TBM initialization failed");
- return MC_ERROR;
- }
-
- LOGD("@%p(%p) core is initializing...v(%d)e(%d)", mc_handle, new_core, new_core->video, new_core->encoder);
- LOGD("factory name : %s, output_fmt : %x", factory_name, out_mime);
-
- /* create media_packet for output fmt */
- if ((ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime)) != MC_ERROR_NONE) {
- LOGE("Failed to create output pakcet");
- return ret;
- }
-
- /* link vtable */
- if ((ret = _mc_link_vtable(new_core, id, encoder, hardware)) != MC_ERROR_NONE) {
- LOGE("vtable link failed");
- return ret;
- }
-
- for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++) {
- LOGD("copy cb function [%d]", i);
- if (mc_handle->user_cb[i]) {
- new_core->user_cb[i] = mc_handle->user_cb[i];
- new_core->user_data[i] = mc_handle->user_data[i];
- LOGD("user_cb[%d] %p, %p", i, new_core->user_cb[i], mc_handle->user_cb[i]);
- }
- }
-
- mc_handle->core = new_core;
-
- /* create basic core elements */
- ret = _mc_gst_create_pipeline(mc_handle->core, factory_name);
-
- LOGD("initialized... %d", ret);
- return ret;
+ MEDIACODEC_FENTER();
+
+ int ret = MC_ERROR_NONE;
+ media_format_mimetype_e out_mime;
+ int num_supported_codec = 0;
+ int i = 0;
+
+ if (!mc_handle)
+ return MC_PARAM_ERROR;
+
+ mediacodec_codec_type_e id;
+ bool video;
+ bool encoder;
+ bool hardware;
+ gchar *factory_name = NULL;
+ mc_codec_map_t *codec_map;
+
+ id = mc_handle->codec_id;
+ video = mc_handle->is_video;
+ encoder = mc_handle->is_encoder;
+ hardware = mc_handle->is_hw;
+ codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
+ num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
+
+ for (i = 0; i < num_supported_codec; i++) {
+ if ((id == codec_map[i].id) && (hardware == codec_map[i].hardware))
+ break;
+ }
+
+ if (i == num_supported_codec)
+ return MC_NOT_SUPPORTED;
+
+ factory_name = codec_map[i].type.factory_name;
+ out_mime = codec_map[i].type.out_format;
+
+ /* gst_core create */
+ mc_gst_core_t *new_core = mc_gst_core_new();
+
+ new_core->mime = codec_map[i].type.mime;
+ new_core->is_hw = hardware;
+ new_core->eos = false;
+ new_core->encoder = encoder;
+ new_core->video = video;
+ new_core->codec_info = encoder ? (void *)&mc_handle->info.encoder : (void *)&mc_handle->info.decoder;
+ new_core->out_mime = codec_map[i].type.out_format;
+ new_core->codec_id = id;
+
+ new_core->bufmgr = tbm_bufmgr_init(new_core->drm_fd);
+ if (new_core->bufmgr == NULL) {
+ LOGE("TBM initialization failed");
+ return MC_ERROR;
+ }
+
+ LOGD("@%p(%p) core is initializing...v(%d)e(%d)", mc_handle, new_core, new_core->video, new_core->encoder);
+ LOGD("factory name : %s, output_fmt : %x", factory_name, out_mime);
+
+ /* create media_packet for output fmt */
+ if ((ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime)) != MC_ERROR_NONE) {
+ LOGE("Failed to create output pakcet");
+ return ret;
+ }
+
+ /* link vtable */
+ if ((ret = _mc_link_vtable(new_core, id, encoder, hardware)) != MC_ERROR_NONE) {
+ LOGE("vtable link failed");
+ return ret;
+ }
+
+ for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++) {
+ LOGD("copy cb function [%d]", i);
+ if (mc_handle->user_cb[i]) {
+ new_core->user_cb[i] = mc_handle->user_cb[i];
+ new_core->user_data[i] = mc_handle->user_data[i];
+ LOGD("user_cb[%d] %p, %p", i, new_core->user_cb[i], mc_handle->user_cb[i]);
+ }
+ }
+
+ mc_handle->core = new_core;
+
+ /* create basic core elements */
+ ret = _mc_gst_create_pipeline(mc_handle->core, factory_name);
+
+ LOGD("initialized... %d", ret);
+ return ret;
}
mc_ret_e mc_gst_unprepare(mc_handle_t *mc_handle)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- int i;
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = NULL;
+ int i;
+ int ret = MC_ERROR_NONE;
+ mc_gst_core_t *core = NULL;
- if (!mc_handle)
- return MC_PARAM_ERROR;
+ if (!mc_handle)
+ return MC_PARAM_ERROR;
- core = (mc_gst_core_t *)mc_handle->core;
+ core = (mc_gst_core_t *)mc_handle->core;
- if (core) {
- LOGD("@%p(%p) core is uninitializing... v(%d)e(%d)", mc_handle, core, core->video, core->encoder);
+ if (core) {
+ LOGD("@%p(%p) core is uninitializing... v(%d)e(%d)", mc_handle, core, core->video, core->encoder);
- g_mutex_lock(&core->drain_lock);
- core->unprepare_flag = TRUE;
- g_mutex_unlock(&core->drain_lock);
+ g_mutex_lock(&core->drain_lock);
+ core->unprepare_flag = TRUE;
+ g_mutex_unlock(&core->drain_lock);
- if (core->eos) {
- _mc_send_eos_signal(core);
- }
+ if (core->eos)
+ _mc_send_eos_signal(core);
- _mc_gst_set_flush_input(core);
+ _mc_gst_set_flush_input(core);
- ret = _mc_gst_destroy_pipeline(core);
+ ret = _mc_gst_destroy_pipeline(core);
- /* unset callback */
- for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER; i++) {
- LOGD("unset cb function [%d]", i);
- if (mc_handle->user_cb[i]) {
- core->user_cb[i] = NULL;
- core->user_data[i] = NULL;
- LOGD("user_cb[%d] %p, %p", i, core->user_cb[i], mc_handle->user_cb[i]);
- }
- }
+ /* unset callback */
+ for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER; i++) {
+ LOGD("unset cb function [%d]", i);
+ if (mc_handle->user_cb[i]) {
+ core->user_cb[i] = NULL;
+ core->user_data[i] = NULL;
+ LOGD("user_cb[%d] %p, %p", i, core->user_cb[i], mc_handle->user_cb[i]);
+ }
+ }
- media_format_unref(core->output_fmt);
+ media_format_unref(core->output_fmt);
- if (core->bufmgr != NULL) {
- tbm_bufmgr_deinit(core->bufmgr);
- core->bufmgr = NULL;
- }
+ if (core->bufmgr != NULL) {
+ tbm_bufmgr_deinit(core->bufmgr);
+ core->bufmgr = NULL;
+ }
- if(core->drm_fd != -1) {
- close(core->drm_fd);
- LOGD("close drm_fd");
- }
+ if (core->drm_fd != -1) {
+ close(core->drm_fd);
+ LOGD("close drm_fd");
+ }
- if (core != NULL) {
- mc_gst_core_free(core);
- mc_handle->core = NULL;
- }
- }
+ if (core != NULL) {
+ mc_gst_core_free(core);
+ mc_handle->core = NULL;
+ }
+ }
- return ret;
+ return ret;
}
mc_ret_e mc_gst_process_input(mc_handle_t *mc_handle, media_packet_h inbuf, uint64_t timeOutUs)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = NULL;
- GTimeVal nowtv;
+ int ret = MC_ERROR_NONE;
+ mc_gst_core_t *core = NULL;
+ GTimeVal nowtv;
- if (!mc_handle)
- return MC_PARAM_ERROR;
+ if (!mc_handle)
+ return MC_PARAM_ERROR;
- core = (mc_gst_core_t *)mc_handle->core;
+ core = (mc_gst_core_t *)mc_handle->core;
- g_get_current_time(&nowtv);
- g_time_val_add(&nowtv, 500 * 1000); /* usec */
-/*
- if (!g_cond_timed_wait(&nowtv)) {
- }
-*/
+ g_get_current_time(&nowtv);
+ g_time_val_add(&nowtv, 500 * 1000); /* usec */
+ /*
+ if (!g_cond_timed_wait(&nowtv)) {
+ }
+ */
- if (core->prepare_count == 0)
- return MEDIACODEC_ERROR_INVALID_STATE;
+ if (core->prepare_count == 0)
+ return MEDIACODEC_ERROR_INVALID_STATE;
- g_mutex_lock(&core->drain_lock);
+ g_mutex_lock(&core->drain_lock);
- if (!core->eos || !core->unprepare_flag) {
- mc_async_queue_push(core->available_queue->input, inbuf);
+ if (!core->eos || !core->unprepare_flag) {
+ mc_async_queue_push(core->available_queue->input, inbuf);
- } else {
- ret = MC_INVALID_IN_BUF;
- g_mutex_unlock(&core->drain_lock);
- return ret;
- }
+ } else {
+ ret = MC_INVALID_IN_BUF;
+ g_mutex_unlock(&core->drain_lock);
+ return ret;
+ }
- g_mutex_unlock(&core->drain_lock);
- LOGI("@v(%d)e(%d)process_input(%d): %p", core->video, core->encoder, core->queued_count, inbuf);
- core->queued_count++;
+ g_mutex_unlock(&core->drain_lock);
+ LOGI("@v(%d)e(%d)process_input(%d): %p", core->video, core->encoder, core->queued_count, inbuf);
+ core->queued_count++;
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return ret;
+ return ret;
}
mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint64_t timeOutUs)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = NULL;
- media_packet_h out_pkt = NULL;
+ int ret = MC_ERROR_NONE;
+ mc_gst_core_t *core = NULL;
+ media_packet_h out_pkt = NULL;
- if (!mc_handle)
- return MC_PARAM_ERROR;
+ if (!mc_handle)
+ return MC_PARAM_ERROR;
- core = (mc_gst_core_t *)mc_handle->core;
- LOGI("@%p v(%d)e(%d) get_output", core, core->video, core->encoder);
+ core = (mc_gst_core_t *)mc_handle->core;
+ LOGI("@%p v(%d)e(%d) get_output", core, core->video, core->encoder);
- g_mutex_lock(&core->ports[1]->mutex);
+ g_mutex_lock(&core->ports[1]->mutex);
- if (!g_queue_is_empty(core->ports[1]->queue)) {
- out_pkt = g_queue_pop_head(core->ports[1]->queue);
- LOGD("pop from output_queue : %p", out_pkt);
- } else {
- ret = MC_OUTPUT_BUFFER_EMPTY;
- LOGD("output_queue is empty");
- }
- *outbuf = out_pkt;
+ if (!g_queue_is_empty(core->ports[1]->queue)) {
+ out_pkt = g_queue_pop_head(core->ports[1]->queue);
+ LOGD("pop from output_queue : %p", out_pkt);
+ } else {
+ ret = MC_OUTPUT_BUFFER_EMPTY;
+ LOGD("output_queue is empty");
+ }
+ *outbuf = out_pkt;
- g_mutex_unlock(&core->ports[1]->mutex);
+ g_mutex_unlock(&core->ports[1]->mutex);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return ret;
+ return ret;
}
mc_ret_e mc_gst_flush_buffers(mc_handle_t *mc_handle)
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = NULL;
+ int ret = MC_ERROR_NONE;
+ mc_gst_core_t *core = NULL;
- if (!mc_handle)
- return MC_PARAM_ERROR;
+ if (!mc_handle)
+ return MC_PARAM_ERROR;
- core = (mc_gst_core_t *)mc_handle->core;
- LOGI("@%p v(%d)e(%d) flush_buffers", core, core->video, core->encoder);
+ core = (mc_gst_core_t *)mc_handle->core;
+ LOGI("@%p v(%d)e(%d) flush_buffers", core, core->video, core->encoder);
- ret = _mc_gst_flush_buffers(core);
+ ret = _mc_gst_flush_buffers(core);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return ret;
+ return ret;
}
static gboolean __mc_gst_init_gstreamer()
{
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- static gboolean initialized = FALSE;
- static const int max_argc = 50;
- gint *argc = NULL;
- gchar **argv = NULL;
- gchar **argv2 = NULL;
- GError *err = NULL;
- int i = 0;
- int arg_count = 0;
+ static gboolean initialized = FALSE;
+ static const int max_argc = 50;
+ gint *argc = NULL;
+ gchar **argv = NULL;
+ gchar **argv2 = NULL;
+ GError *err = NULL;
+ int i = 0;
+ int arg_count = 0;
- if (initialized) {
- LOGD("gstreamer already initialized.\n");
- return TRUE;
- }
+ if (initialized) {
+ LOGD("gstreamer already initialized.\n");
+ return TRUE;
+ }
- /* alloc */
- argc = malloc(sizeof(int));
- argv = malloc(sizeof(gchar *) *max_argc);
- argv2 = malloc(sizeof(gchar *) *max_argc);
+ /* alloc */
+ argc = malloc(sizeof(int));
+ argv = malloc(sizeof(gchar *) *max_argc);
+ argv2 = malloc(sizeof(gchar *) *max_argc);
- if (!argc || !argv || !argv2)
- goto ERROR;
+ if (!argc || !argv || !argv2)
+ goto ERROR;
- memset(argv, 0, sizeof(gchar *) *max_argc);
- memset(argv2, 0, sizeof(gchar *) *max_argc);
+ memset(argv, 0, sizeof(gchar *) *max_argc);
+ memset(argv2, 0, sizeof(gchar *) *max_argc);
- /* add initial */
- *argc = 1;
- argv[0] = g_strdup("media codec");
+ /* add initial */
+ *argc = 1;
+ argv[0] = g_strdup("media codec");
- /* we would not do fork for scanning plugins */
- argv[*argc] = g_strdup("--gst-disable-registry-fork");
- (*argc)++;
+ /* we would not do fork for scanning plugins */
+ argv[*argc] = g_strdup("--gst-disable-registry-fork");
+ (*argc)++;
- /* check disable registry scan */
- argv[*argc] = g_strdup("--gst-disable-registry-update");
- (*argc)++;
+ /* check disable registry scan */
+ argv[*argc] = g_strdup("--gst-disable-registry-update");
+ (*argc)++;
- /* check disable segtrap */
- argv[*argc] = g_strdup("--gst-disable-segtrap");
- (*argc)++;
+ /* check disable segtrap */
+ argv[*argc] = g_strdup("--gst-disable-segtrap");
+ (*argc)++;
- LOGD("initializing gstreamer with following parameter\n");
- LOGD("argc : %d\n", *argc);
- arg_count = *argc;
+ LOGD("initializing gstreamer with following parameter\n");
+ LOGD("argc : %d\n", *argc);
+ arg_count = *argc;
- for (i = 0; i < arg_count; i++) {
- argv2[i] = argv[i];
- LOGD("argv[%d] : %s\n", i, argv2[i]);
- }
+ for (i = 0; i < arg_count; i++) {
+ argv2[i] = argv[i];
+ LOGD("argv[%d] : %s\n", i, argv2[i]);
+ }
- /* initializing gstreamer */
- if (!gst_init_check(argc, &argv, &err)) {
- LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
- if (err) {
- g_error_free(err);
- }
+ /* initializing gstreamer */
+ if (!gst_init_check(argc, &argv, &err)) {
+ LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
+ if (err)
+ g_error_free(err);
- goto ERROR;
- }
+ goto ERROR;
+ }
- /* release */
- for (i = 0; i < arg_count; i++) {
- MC_FREEIF(argv2[i]);
- }
+ /* release */
+ for (i = 0; i < arg_count; i++)
+ MC_FREEIF(argv2[i]);
- MC_FREEIF(argv);
- MC_FREEIF(argv2);
- MC_FREEIF(argc);
+ MC_FREEIF(argv);
+ MC_FREEIF(argv2);
+ MC_FREEIF(argc);
- /* done */
- initialized = TRUE;
+ /* done */
+ initialized = TRUE;
- MEDIACODEC_FLEAVE();
- return TRUE;
+ MEDIACODEC_FLEAVE();
+ return TRUE;
ERROR:
- /* release */
- for (i = 0; i < arg_count; i++) {
- LOGD("free[%d] : %s\n", i, argv2[i]);
- MC_FREEIF(argv2[i]);
- }
+ /* release */
+ for (i = 0; i < arg_count; i++) {
+ LOGD("free[%d] : %s\n", i, argv2[i]);
+ MC_FREEIF(argv2[i]);
+ }
- MC_FREEIF(argv);
- MC_FREEIF(argv2);
- MC_FREEIF(argc);
+ MC_FREEIF(argv);
+ MC_FREEIF(argv2);
+ MC_FREEIF(argc);
- return FALSE;
+ return FALSE;
}
mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name)
{
- GstBus *bus = NULL;
+ GstBus *bus = NULL;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- g_mutex_lock(&core->prepare_lock);
- if (core->prepare_count == 0) {
+ g_mutex_lock(&core->prepare_lock);
+ if (core->prepare_count == 0) {
- if (!__mc_gst_init_gstreamer()) {
- LOGE("gstreamer initialize fail");
- g_mutex_unlock(&core->prepare_lock);
- return MC_NOT_INITIALIZED;
- }
- core->codec = gst_element_factory_make(factory_name, NULL);
+ if (!__mc_gst_init_gstreamer()) {
+ LOGE("gstreamer initialize fail");
+ g_mutex_unlock(&core->prepare_lock);
+ return MC_NOT_INITIALIZED;
+ }
+ core->codec = gst_element_factory_make(factory_name, NULL);
- if (!core->codec) {
- LOGE("codec element create fail");
- goto ERROR;
- }
+ if (!core->codec) {
+ LOGE("codec element create fail");
+ goto ERROR;
+ }
- LOGD("@%p v(%d)e(%d) create_pipeline", core, core->video, core->encoder);
- MEDIACODEC_ELEMENT_SET_STATE(core->codec, GST_STATE_READY);
+ LOGD("@%p v(%d)e(%d) create_pipeline", core, core->video, core->encoder);
+ MEDIACODEC_ELEMENT_SET_STATE(core->codec, GST_STATE_READY);
- /* create common elements */
- core->pipeline = gst_pipeline_new(NULL);
+ /* create common elements */
+ core->pipeline = gst_pipeline_new(NULL);
- if (!core->pipeline) {
- LOGE("pipeline create fail");
- goto ERROR;
- }
+ if (!core->pipeline) {
+ LOGE("pipeline create fail");
+ goto ERROR;
+ }
- core->appsrc = gst_element_factory_make("appsrc", NULL);
+ core->appsrc = gst_element_factory_make("appsrc", NULL);
- if (!core->appsrc) {
- LOGE("appsrc can't create");
- goto ERROR;
- }
+ if (!core->appsrc) {
+ LOGE("appsrc can't create");
+ goto ERROR;
+ }
- core->capsfilter = gst_element_factory_make("capsfilter", NULL);
+ core->capsfilter = gst_element_factory_make("capsfilter", NULL);
- if (!core->capsfilter) {
- LOGE("capsfilter can't create");
- goto ERROR;
- }
+ if (!core->capsfilter) {
+ LOGE("capsfilter can't create");
+ goto ERROR;
+ }
- core->fakesink = gst_element_factory_make("fakesink", NULL);
+ core->fakesink = gst_element_factory_make("fakesink", NULL);
- if (!core->fakesink) {
- LOGE("fakesink create fail");
- goto ERROR;
- }
- g_object_set(core->fakesink, "enable-last-sample", FALSE, NULL);
+ if (!core->fakesink) {
+ LOGE("fakesink create fail");
+ goto ERROR;
+ }
+ g_object_set(core->fakesink, "enable-last-sample", FALSE, NULL);
- /*__mc_link_elements(core);*/
- gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
+ /*__mc_link_elements(core);*/
+ gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
- /* link elements */
- if (!(gst_element_link_many(core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL)))
- {
- LOGE("gst_element_link_many is failed");
- goto ERROR;
- }
+ /* link elements */
+ if (!(gst_element_link_many(core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL))) {
+ LOGE("gst_element_link_many is failed");
+ goto ERROR;
+ }
- /* connect signals, bus watcher */
- bus = gst_pipeline_get_bus(GST_PIPELINE(core->pipeline));
- core->bus_whatch_id = gst_bus_add_watch(bus, __mc_gst_bus_callback, core);
- core->thread_default = g_main_context_get_thread_default();
+ /* connect signals, bus watcher */
+ bus = gst_pipeline_get_bus(GST_PIPELINE(core->pipeline));
+ core->bus_whatch_id = gst_bus_add_watch(bus, __mc_gst_bus_callback, core);
+ core->thread_default = g_main_context_get_thread_default();
- /* set sync handler to get tag synchronously */
- gst_bus_set_sync_handler(bus, __mc_gst_bus_sync_callback, core, NULL);
- gst_object_unref(GST_OBJECT(bus));
+ /* set sync handler to get tag synchronously */
+ gst_bus_set_sync_handler(bus, __mc_gst_bus_sync_callback, core, NULL);
+ gst_object_unref(GST_OBJECT(bus));
- /* app src */
- g_signal_connect(core->appsrc, "need-data", G_CALLBACK(__mc_gst_start_feed), core);
- g_signal_connect(core->appsrc, "enough-data", G_CALLBACK(__mc_gst_stop_feed), core);
+ /* app src */
+ g_signal_connect(core->appsrc, "need-data", G_CALLBACK(__mc_gst_start_feed), core);
+ g_signal_connect(core->appsrc, "enough-data", G_CALLBACK(__mc_gst_stop_feed), core);
- /* connect handoff */
- g_object_set(GST_OBJECT(core->fakesink), "signal-handoffs", TRUE, NULL);
- core->signal_handoff = g_signal_connect(core->fakesink, "handoff", G_CALLBACK(__mc_gst_buffer_add), core);
+ /* connect handoff */
+ g_object_set(GST_OBJECT(core->fakesink), "signal-handoffs", TRUE, NULL);
+ core->signal_handoff = g_signal_connect(core->fakesink, "handoff", G_CALLBACK(__mc_gst_buffer_add), core);
- /* set state PLAYING */
- MEDIACODEC_ELEMENT_SET_STATE(GST_ELEMENT_CAST(core->pipeline), GST_STATE_PLAYING);
+ /* set state PLAYING */
+ MEDIACODEC_ELEMENT_SET_STATE(GST_ELEMENT_CAST(core->pipeline), GST_STATE_PLAYING);
- }
- core->prepare_count++;
- g_mutex_unlock(&core->prepare_lock);
+ }
+ core->prepare_count++;
+ g_mutex_unlock(&core->prepare_lock);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
STATE_CHANGE_FAILED:
ERROR:
- if (core->codec)
- gst_object_unref(GST_OBJECT(core->codec));
+ if (core->codec)
+ gst_object_unref(GST_OBJECT(core->codec));
- if (core->pipeline)
- gst_object_unref(GST_OBJECT(core->pipeline));
+ if (core->pipeline)
+ gst_object_unref(GST_OBJECT(core->pipeline));
- if (core->appsrc)
- gst_object_unref(GST_OBJECT(core->appsrc));
+ if (core->appsrc)
+ gst_object_unref(GST_OBJECT(core->appsrc));
- if (core->capsfilter)
- gst_object_unref(GST_OBJECT(core->capsfilter));
+ if (core->capsfilter)
+ gst_object_unref(GST_OBJECT(core->capsfilter));
- if (core->fakesink)
- gst_object_unref(GST_OBJECT(core->fakesink));
+ if (core->fakesink)
+ gst_object_unref(GST_OBJECT(core->fakesink));
- g_mutex_unlock(&core->prepare_lock);
+ g_mutex_unlock(&core->prepare_lock);
- return MC_ERROR;
+ return MC_ERROR;
}
mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core)
{
- int ret = MC_ERROR_NONE;
+ int ret = MC_ERROR_NONE;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- g_mutex_lock(&core->prepare_lock);
- core->prepare_count--;
- if (core->prepare_count == 0) {
+ g_mutex_lock(&core->prepare_lock);
+ core->prepare_count--;
+ if (core->prepare_count == 0) {
- if (core->pipeline) {
- /* disconnect signal */
- if (core->fakesink && GST_IS_ELEMENT(core->fakesink)) {
- if (g_signal_handler_is_connected(core->fakesink, core->signal_handoff)) {
- g_signal_handler_disconnect(core->fakesink, core->signal_handoff);
- LOGD("handoff signal destroy");
- }
- }
+ if (core->pipeline) {
+ /* disconnect signal */
+ if (core->fakesink && GST_IS_ELEMENT(core->fakesink)) {
+ if (g_signal_handler_is_connected(core->fakesink, core->signal_handoff)) {
+ g_signal_handler_disconnect(core->fakesink, core->signal_handoff);
+ LOGD("handoff signal destroy");
+ }
+ }
- if (core->bus_whatch_id) {
- GSource *source = NULL;
- source = g_main_context_find_source_by_id(core->thread_default, core->bus_whatch_id);
- g_source_destroy(source);
- LOGD("bus_whatch_id destroy");
- }
+ if (core->bus_whatch_id) {
+ GSource *source = NULL;
+ source = g_main_context_find_source_by_id(core->thread_default, core->bus_whatch_id);
+ g_source_destroy(source);
+ LOGD("bus_whatch_id destroy");
+ }
- MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL);
+ MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL);
- gst_object_unref(GST_OBJECT(core->pipeline));
- }
- }
+ gst_object_unref(GST_OBJECT(core->pipeline));
+ }
+ }
- LOGD("@%p v(%d)e(%d) destroy_pipeline : %d ", core, core->video, core->encoder, core->prepare_count);
- g_mutex_unlock(&core->prepare_lock);
+ LOGD("@%p v(%d)e(%d) destroy_pipeline : %d ", core, core->video, core->encoder, core->prepare_count);
+ g_mutex_unlock(&core->prepare_lock);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return ret;
+ return ret;
STATE_CHANGE_FAILED:
- if (core->pipeline)
- gst_object_unref(GST_OBJECT(core->pipeline));
+ if (core->pipeline)
+ gst_object_unref(GST_OBJECT(core->pipeline));
- LOGD("@%p v(%d)e(%d) destroy_pipeline failed", core, core->video, core->encoder);
- g_mutex_unlock(&core->prepare_lock);
+ LOGD("@%p v(%d)e(%d) destroy_pipeline failed", core, core->video, core->encoder);
+ g_mutex_unlock(&core->prepare_lock);
- return MC_ERROR;
+ return MC_ERROR;
}
void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- guint n;
- GstMemory *mem;
- GstMapInfo map = GST_MAP_INFO_INIT;
- media_packet_h out_pkt = NULL;
+ guint n;
+ GstMemory *mem;
+ GstMapInfo map = GST_MAP_INFO_INIT;
+ media_packet_h out_pkt = NULL;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- mc_gst_core_t *core = (mc_gst_core_t *)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
- gst_buffer_ref(buffer);
+ gst_buffer_ref(buffer);
- n = gst_buffer_n_memory(buffer);
+ n = gst_buffer_n_memory(buffer);
- mem = gst_buffer_peek_memory(buffer, n-1);
+ mem = gst_buffer_peek_memory(buffer, n-1);
- gst_memory_map(mem, &map, GST_MAP_READ);
- LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size);
+ gst_memory_map(mem, &map, GST_MAP_READ);
+ LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size);
- out_pkt = __mc_gst_make_media_packet(core, map.data, map.size);
+ out_pkt = __mc_gst_make_media_packet(core, map.data, map.size);
- LOGI("@%p(%d) out_pkt : %p", core, core->encoder, out_pkt);
- gst_memory_unmap(mem, &map);
+ LOGI("@%p(%d) out_pkt : %p", core, core->encoder, out_pkt);
+ gst_memory_unmap(mem, &map);
- if (out_pkt) {
- media_packet_set_extra(out_pkt, buffer);
- media_packet_set_pts(out_pkt, GST_BUFFER_TIMESTAMP(buffer));
+ if (out_pkt) {
+ media_packet_set_extra(out_pkt, buffer);
+ media_packet_set_pts(out_pkt, GST_BUFFER_TIMESTAMP(buffer));
- if (core->need_codec_data) {
- media_packet_set_flags(out_pkt, MEDIA_PACKET_CODEC_CONFIG);
- core->need_codec_data = false;
- }
+ if (core->need_codec_data) {
+ media_packet_set_flags(out_pkt, MEDIA_PACKET_CODEC_CONFIG);
+ core->need_codec_data = false;
+ }
- if (core->need_sync_flag) {
- media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME);
- core->need_sync_flag = false;
- }
+ if (core->need_sync_flag) {
+ media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME);
+ core->need_sync_flag = false;
+ }
- g_mutex_lock(&core->ports[1]->mutex);
- /* push it to output buffer queue */
- g_queue_push_tail(core->ports[1]->queue, out_pkt);
+ g_mutex_lock(&core->ports[1]->mutex);
+ /* push it to output buffer queue */
+ g_queue_push_tail(core->ports[1]->queue, out_pkt);
- core->dequeued_count++;
- LOGD("dequeued : %d", core->dequeued_count);
- LOGD("GST_BUFFER_TIMESTAMP = %"GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
+ core->dequeued_count++;
+ LOGD("dequeued : %d", core->dequeued_count);
+ LOGD("GST_BUFFER_TIMESTAMP = %"GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
- g_mutex_unlock(&core->ports[1]->mutex);
+ g_mutex_unlock(&core->ports[1]->mutex);
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
- ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER])
- (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]);
- }
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
+ ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER])
+ (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]);
+ }
+ }
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return;
+ return;
}
int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data)
{
- void *buffer = NULL;
- int i = 0;
- guint n;
- GstMemory *mem;
- GstMapInfo map = GST_MAP_INFO_INIT;
- MMVideoBuffer *mm_video_buf = NULL;
- mc_gst_core_t *core = NULL;
+ void *buffer = NULL;
+ int i = 0;
+ guint n;
+ GstMemory *mem;
+ GstMapInfo map = GST_MAP_INFO_INIT;
+ MMVideoBuffer *mm_video_buf = NULL;
+ mc_gst_core_t *core = NULL;
- core = (mc_gst_core_t*)user_data;
+ core = (mc_gst_core_t*)user_data;
- LOGD("packet finalized: %p", packet);
- media_packet_get_extra(packet, &buffer);
+ LOGD("packet finalized: %p", packet);
+ media_packet_get_extra(packet, &buffer);
- n = gst_buffer_n_memory(buffer);
+ n = gst_buffer_n_memory(buffer);
- if (n > 1) {
- mem = gst_buffer_peek_memory(buffer,n-1);
- gst_memory_map(mem, &map, GST_MAP_READ);
- mm_video_buf = (MMVideoBuffer *)map.data;
+ if (n > 1) {
+ mem = gst_buffer_peek_memory(buffer, n-1);
+ gst_memory_map(mem, &map, GST_MAP_READ);
+ mm_video_buf = (MMVideoBuffer *)map.data;
- if (!mm_video_buf) {
- LOGW("gstbuffer map.data is null");
- } else {
- for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
- if (mm_video_buf->handle.bo[i]) {
- tbm_bo_unref (mm_video_buf->handle.bo[i]);
- }
- }
- }
- gst_memory_unmap(mem, &map);
- }
- gst_buffer_unref((GstBuffer *)buffer);
+ if (!mm_video_buf) {
+ LOGW("gstbuffer map.data is null");
+ } else {
+ for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
+ if (mm_video_buf->handle.bo[i])
+ tbm_bo_unref(mm_video_buf->handle.bo[i]);
+ }
+ }
+ gst_memory_unmap(mem, &map);
+ }
+ gst_buffer_unref((GstBuffer *)buffer);
- return MEDIA_PACKET_FINALIZE;
+ return MEDIA_PACKET_FINALIZE;
}
gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw)
{
- gchar *format = NULL;
- media_format_h fmt = NULL;
- media_format_mimetype_e mimetype = 0;
-
- media_packet_get_format(packet, &fmt);
- media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL);
- media_format_unref(fmt);
- LOGD("input packet mimetype : %x", mimetype);
-
- switch (mimetype) {
- case MEDIA_FORMAT_I420:
- format = "I420";
- break;
- case MEDIA_FORMAT_NV12:
- if (is_hw)
- format = "SN12";
- else
- format = "NV12";
- break;
- case MEDIA_FORMAT_ARGB:
- format = "ARGB";
- break;
- default:
- break;
- }
- LOGD("input packet format : %s", format);
- return format;
+ gchar *format = NULL;
+ media_format_h fmt = NULL;
+ media_format_mimetype_e mimetype = 0;
+
+ media_packet_get_format(packet, &fmt);
+ media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL);
+ media_format_unref(fmt);
+ LOGD("input packet mimetype : %x", mimetype);
+
+ switch (mimetype) {
+ case MEDIA_FORMAT_I420:
+ format = "I420";
+ break;
+ case MEDIA_FORMAT_NV12:
+ if (is_hw)
+ format = "SN12";
+ else
+ format = "NV12";
+ break;
+ case MEDIA_FORMAT_ARGB:
+ format = "ARGB";
+ break;
+ default:
+ break;
+ }
+ LOGD("input packet format : %s", format);
+ return format;
}
GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, GstCaps **caps, media_packet_h pkt, bool codec_config)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- GstMCBuffer *mc_buffer = NULL;
- void *buf_data = NULL;
- uint64_t buf_size = 0;
- uint64_t pts = 0;
- uint64_t dur = 0;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+ GstMCBuffer *mc_buffer = NULL;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ uint64_t pts = 0;
+ uint64_t dur = 0;
- ret = media_packet_get_buffer_size(pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return NULL;
- }
+ ret = media_packet_get_buffer_size(pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return NULL;
+ }
- ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE) {
- LOGW("buffer size get fail");
- return NULL;
- }
+ ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return NULL;
+ }
- mc_buffer = gst_mediacodec_buffer_new(core, pkt, buf_size);
- if (mc_buffer == NULL) {
- LOGW("failed to create inbuf");
- return NULL;
- }
+ mc_buffer = gst_mediacodec_buffer_new(core, pkt, buf_size);
+ if (mc_buffer == NULL) {
+ LOGW("failed to create inbuf");
+ return NULL;
+ }
- LOGD("pkt : %p, buf_size : %d", pkt, (int)buf_size);
+ LOGD("pkt : %p, buf_size : %d", pkt, (int)buf_size);
- ret = __mc_fill_input_buffer(core, pkt, mc_buffer);
- if (ret != MC_ERROR_NONE) {
- LOGW("failed to fill inbuf");
- return NULL;
- }
+ ret = __mc_fill_input_buffer(core, pkt, mc_buffer);
+ if (ret != MC_ERROR_NONE) {
+ LOGW("failed to fill inbuf");
+ return NULL;
+ }
- /* pts */
- media_packet_get_pts(pkt, &pts);
- GST_BUFFER_PTS(mc_buffer->buffer) = pts;
+ /* pts */
+ media_packet_get_pts(pkt, &pts);
+ GST_BUFFER_PTS(mc_buffer->buffer) = pts;
- /* duration */
- media_packet_get_duration(pkt, &dur);
- GST_BUFFER_DURATION(mc_buffer->buffer) = dur;
+ /* duration */
+ media_packet_get_duration(pkt, &dur);
+ GST_BUFFER_DURATION(mc_buffer->buffer) = dur;
- return mc_buffer;
+ return mc_buffer;
}
media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size)
{
- media_packet_h pkt = NULL;
+ media_packet_h pkt = NULL;
- __mc_fill_output_buffer(core, data, size, &pkt);
+ __mc_fill_output_buffer(core, data, size, &pkt);
- return pkt;
+ return pkt;
}
gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data)
{
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = (mc_gst_core_t *)data;
- LOGD("@%p v(%d)e(%d)", core, core->video, core->encoder);
+ int ret = MC_ERROR_NONE;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
+ LOGD("@%p v(%d)e(%d)", core, core->video, core->encoder);
- switch (GST_MESSAGE_TYPE(msg)) {
+ switch (GST_MESSAGE_TYPE(msg)) {
- case GST_MESSAGE_EOS:
- {
- _mc_send_eos_signal(core);
+ case GST_MESSAGE_EOS:
+ _mc_send_eos_signal(core);
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
- LOGD("eos callback invoked");
- ((mc_eos_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])(core->user_data[_MEDIACODEC_EVENT_TYPE_EOS]);
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
+ LOGD("eos callback invoked");
+ ((mc_eos_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])(core->user_data[_MEDIACODEC_EVENT_TYPE_EOS]);
+ }
- LOGD("End of stream\n");
- }
- break;
+ LOGD("End of stream\n");
+ break;
- case GST_MESSAGE_ERROR:
- {
- GError *error = NULL;
+ case GST_MESSAGE_ERROR:
+ {
+ GError *error = NULL;
- gst_message_parse_error(msg, &error, NULL);
+ gst_message_parse_error(msg, &error, NULL);
- if (!error) {
- LOGW("GST error message parsing failed");
- break;
- }
+ if (!error) {
+ LOGW("GST error message parsing failed");
+ break;
+ }
- LOGW("Error: %s\n", error->message);
+ LOGW("Error: %s\n", error->message);
- if (error) {
- if (error->domain == GST_STREAM_ERROR) {
- ret = __gst_handle_stream_error(core, error, msg);
- } else if (error->domain == GST_RESOURCE_ERROR) {
- ret = __gst_handle_resource_error(core, error->code);
- } else if (error->domain == GST_LIBRARY_ERROR) {
- ret = __gst_handle_library_error(core, error->code);
- } else if (error->domain == GST_CORE_ERROR) {
- ret = __gst_handle_core_error(core, error->code);
- } else {
- LOGW("Unexpected error has occured");
- }
+ if (error) {
+ if (error->domain == GST_STREAM_ERROR)
+ ret = __gst_handle_stream_error(core, error, msg);
+ else if (error->domain == GST_RESOURCE_ERROR)
+ ret = __gst_handle_resource_error(core, error->code);
+ else if (error->domain == GST_LIBRARY_ERROR)
+ ret = __gst_handle_library_error(core, error->code);
+ else if (error->domain == GST_CORE_ERROR)
+ ret = __gst_handle_core_error(core, error->code);
+ else
+ LOGW("Unexpected error has occured");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
- ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
- (ret, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
- }
- }
- g_error_free(error);
- }
- break;
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
+ ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
+ (ret, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
+ }
+ }
+ g_error_free(error);
+ }
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return TRUE;
+ return TRUE;
}
static gboolean __mc_gst_check_useful_message(mc_gst_core_t *core, GstMessage *msg)
{
- gboolean retval = false;
+ gboolean retval = false;
- if (!core->pipeline) {
- LOGE("mediacodec pipeline handle is null");
- return true;
- }
+ if (!core->pipeline) {
+ LOGE("mediacodec pipeline handle is null");
+ return true;
+ }
- switch (GST_MESSAGE_TYPE(msg)) {
- case GST_MESSAGE_TAG:
- case GST_MESSAGE_EOS:
- case GST_MESSAGE_ERROR:
- case GST_MESSAGE_WARNING:
- retval = true;
- break;
- default:
- retval = false;
- break;
- }
+ switch (GST_MESSAGE_TYPE(msg)) {
+ case GST_MESSAGE_TAG:
+ case GST_MESSAGE_EOS:
+ case GST_MESSAGE_ERROR:
+ case GST_MESSAGE_WARNING:
+ retval = true;
+ break;
+ default:
+ retval = false;
+ break;
+ }
- return retval;
+ return retval;
}
static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t *)data;
- GstBusSyncReply reply = GST_BUS_DROP;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
+ GstBusSyncReply reply = GST_BUS_DROP;
- LOGD("__mc_gst_bus_sync_callback is called");
+ LOGD("__mc_gst_bus_sync_callback is called");
- if (!core->pipeline) {
- LOGE("mediacodec pipeline handle is null");
- return GST_BUS_PASS;
- }
+ if (!core->pipeline) {
+ LOGE("mediacodec pipeline handle is null");
+ return GST_BUS_PASS;
+ }
- if (!__mc_gst_check_useful_message(core, msg)) {
- gst_message_unref(msg);
- return GST_BUS_DROP;
- }
+ if (!__mc_gst_check_useful_message(core, msg)) {
+ gst_message_unref(msg);
+ return GST_BUS_DROP;
+ }
- switch (GST_MESSAGE_TYPE(msg)) {
- case GST_MESSAGE_EOS:
- case GST_MESSAGE_ERROR:
- __mc_gst_bus_callback(NULL, msg, core);
- reply = GST_BUS_DROP;
- break;
+ switch (GST_MESSAGE_TYPE(msg)) {
+ case GST_MESSAGE_EOS:
+ case GST_MESSAGE_ERROR:
+ __mc_gst_bus_callback(NULL, msg, core);
+ reply = GST_BUS_DROP;
+ break;
- default:
- reply = GST_BUS_PASS;
- break;
- }
+ default:
+ reply = GST_BUS_PASS;
+ break;
+ }
- if (reply == GST_BUS_DROP)
- gst_message_unref(msg);
+ if (reply == GST_BUS_DROP)
+ gst_message_unref(msg);
- return reply;
+ return reply;
}
static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt)
{
- int i;
- int num_bos;
- tbm_surface_h surface = NULL;
- tbm_surface_info_s surface_info;
- mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
- if (!pkt) {
- LOGE("output is null");
- return NULL;
- }
-
- MMVideoBuffer *mm_vbuffer = NULL;
- mm_vbuffer = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
- if (!mm_vbuffer) {
- LOGE("Failed to alloc MMVideoBuffer");
- return NULL;
- }
- memset(mm_vbuffer, 0x00, sizeof(MMVideoBuffer));
-
- media_packet_get_tbm_surface(pkt, &surface);
- num_bos = tbm_surface_internal_get_num_bos(surface);
- int err = tbm_surface_get_info((tbm_surface_h)surface, &surface_info);
- if (err != TBM_SURFACE_ERROR_NONE)
- {
- LOGE("get tbm surface is failed");
- free(mm_vbuffer);
- return NULL;
- }
-
- for (i = 0; i < num_bos; i++) {
- mm_vbuffer->handle.bo[i] = tbm_surface_internal_get_bo(surface, i);
- LOGE("mm_vbuffer->handle.bo[%d] : %p", i, mm_vbuffer->handle.bo[i]);
- }
-
- tbm_bo_handle handle = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_CPU);
+ int i;
+ int num_bos;
+ tbm_surface_h surface = NULL;
+ tbm_surface_info_s surface_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+
+ if (!pkt) {
+ LOGE("output is null");
+ return NULL;
+ }
+
+ MMVideoBuffer *mm_vbuffer = NULL;
+ mm_vbuffer = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
+ if (!mm_vbuffer) {
+ LOGE("Failed to alloc MMVideoBuffer");
+ return NULL;
+ }
+ memset(mm_vbuffer, 0x00, sizeof(MMVideoBuffer));
+
+ media_packet_get_tbm_surface(pkt, &surface);
+ num_bos = tbm_surface_internal_get_num_bos(surface);
+ int err = tbm_surface_get_info((tbm_surface_h)surface, &surface_info);
+ if (err != TBM_SURFACE_ERROR_NONE) {
+ LOGE("get tbm surface is failed");
+ free(mm_vbuffer);
+ return NULL;
+ }
+
+ for (i = 0; i < num_bos; i++) {
+ mm_vbuffer->handle.bo[i] = tbm_surface_internal_get_bo(surface, i);
+ LOGE("mm_vbuffer->handle.bo[%d] : %p", i, mm_vbuffer->handle.bo[i]);
+ }
+
+ tbm_bo_handle handle = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_CPU);
#ifdef TIZEN_PROFILE_LITE
- int phy_addr = 0;
- int phy_size = 0;
- tbm_bo_handle handle_fd = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM);
-
- if (__tbm_get_physical_addr_bo(handle_fd, &phy_addr, &phy_size) == 0) {
- mm_vbuffer->handle.paddr[0] = (void *)phy_addr;
- LOGD("mm_vbuffer->paddr : %p", mm_vbuffer->handle.paddr[0]);
- }
+ int phy_addr = 0;
+ int phy_size = 0;
+ tbm_bo_handle handle_fd = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM);
+
+ if (__tbm_get_physical_addr_bo(handle_fd, &phy_addr, &phy_size) == 0) {
+ mm_vbuffer->handle.paddr[0] = (void *)phy_addr;
+ LOGD("mm_vbuffer->paddr : %p", mm_vbuffer->handle.paddr[0]);
+ }
#endif
- mm_vbuffer->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
- mm_vbuffer->width[0] = surface_info.width;
- mm_vbuffer->height[0] = surface_info.height;
- mm_vbuffer->width[1] = surface_info.width;
- mm_vbuffer->height[1] = surface_info.height>>1;
- mm_vbuffer->stride_width[0] = surface_info.planes[0].stride;
- mm_vbuffer->stride_height[0] = surface_info.planes[0].size / surface_info.planes[0].stride;
- mm_vbuffer->stride_width[1] = surface_info.planes[1].stride;
- mm_vbuffer->stride_height[1] = surface_info.planes[1].size / surface_info.planes[1].stride;
- mm_vbuffer->plane_num = 2;
+ mm_vbuffer->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
+ mm_vbuffer->width[0] = surface_info.width;
+ mm_vbuffer->height[0] = surface_info.height;
+ mm_vbuffer->width[1] = surface_info.width;
+ mm_vbuffer->height[1] = surface_info.height>>1;
+ mm_vbuffer->stride_width[0] = surface_info.planes[0].stride;
+ mm_vbuffer->stride_height[0] = surface_info.planes[0].size / surface_info.planes[0].stride;
+ mm_vbuffer->stride_width[1] = surface_info.planes[1].stride;
+ mm_vbuffer->stride_height[1] = surface_info.planes[1].size / surface_info.planes[1].stride;
+ mm_vbuffer->plane_num = 2;
- LOGD("size[0] : %d, size[1] : %d, bo[0] :%p, bo[1] :%p", mm_vbuffer->size[0], mm_vbuffer->size[1], mm_vbuffer->handle.bo[0], mm_vbuffer->handle.bo[1]);
+ LOGD("size[0] : %d, size[1] : %d, bo[0] :%p, bo[1] :%p", mm_vbuffer->size[0], mm_vbuffer->size[1], mm_vbuffer->handle.bo[0], mm_vbuffer->handle.bo[1]);
- return mm_vbuffer;
+ return mm_vbuffer;
}
static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer)
{
- if (!mc_buffer)
- return;
+ if (!mc_buffer)
+ return;
- mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core;
+ mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core;
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
- ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
- (mc_buffer->pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
+ ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
+ (mc_buffer->pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
+ }
- LOGD("%p(%p) buffer finalized...", mc_buffer, mc_buffer->pkt);
- free(mc_buffer);
- mc_buffer = NULL;
+ LOGD("%p(%p) buffer finalized...", mc_buffer, mc_buffer->pkt);
+ free(mc_buffer);
+ mc_buffer = NULL;
- return;
+ return;
}
static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size)
{
- GstMCBuffer *mc_buffer = NULL;
+ GstMCBuffer *mc_buffer = NULL;
- mc_buffer = (GstMCBuffer *)malloc(sizeof(*mc_buffer));
+ mc_buffer = (GstMCBuffer *)malloc(sizeof(*mc_buffer));
- if (mc_buffer == NULL) {
- LOGE("malloc fail");
- return NULL;
- }
+ if (mc_buffer == NULL) {
+ LOGE("malloc fail");
+ return NULL;
+ }
- mc_buffer->buffer = gst_buffer_new();
- mc_buffer->buf_size = 0;
+ mc_buffer->buffer = gst_buffer_new();
+ mc_buffer->buf_size = 0;
- LOGD("creating buffer : %p, %p", mc_buffer, mc_buffer->buffer);
- mc_buffer->core = core;
- mc_buffer->pkt = pkt;
+ LOGD("creating buffer : %p, %p", mc_buffer, mc_buffer->buffer);
+ mc_buffer->core = core;
+ mc_buffer->pkt = pkt;
- return mc_buffer;
+ return mc_buffer;
}
static gint __gst_handle_core_error(mc_gst_core_t *core, int code)
{
- gint trans_err = MEDIACODEC_ERROR_NONE;
-
- g_return_val_if_fail(core, MC_PARAM_ERROR);
-
- switch (code) {
- case GST_CORE_ERROR_MISSING_PLUGIN:
- return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
- case GST_CORE_ERROR_STATE_CHANGE:
- case GST_CORE_ERROR_SEEK:
- case GST_CORE_ERROR_NOT_IMPLEMENTED:
- case GST_CORE_ERROR_FAILED:
- case GST_CORE_ERROR_TOO_LAZY:
- case GST_CORE_ERROR_PAD:
- case GST_CORE_ERROR_THREAD:
- case GST_CORE_ERROR_NEGOTIATION:
- case GST_CORE_ERROR_EVENT:
- case GST_CORE_ERROR_CAPS:
- case GST_CORE_ERROR_TAG:
- case GST_CORE_ERROR_CLOCK:
- case GST_CORE_ERROR_DISABLED:
- default:
- trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
- break;
- }
-
- return trans_err;
+ gint trans_err = MEDIACODEC_ERROR_NONE;
+
+ g_return_val_if_fail(core, MC_PARAM_ERROR);
+
+ switch (code) {
+ case GST_CORE_ERROR_MISSING_PLUGIN:
+ return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
+ case GST_CORE_ERROR_STATE_CHANGE:
+ case GST_CORE_ERROR_SEEK:
+ case GST_CORE_ERROR_NOT_IMPLEMENTED:
+ case GST_CORE_ERROR_FAILED:
+ case GST_CORE_ERROR_TOO_LAZY:
+ case GST_CORE_ERROR_PAD:
+ case GST_CORE_ERROR_THREAD:
+ case GST_CORE_ERROR_NEGOTIATION:
+ case GST_CORE_ERROR_EVENT:
+ case GST_CORE_ERROR_CAPS:
+ case GST_CORE_ERROR_TAG:
+ case GST_CORE_ERROR_CLOCK:
+ case GST_CORE_ERROR_DISABLED:
+ default:
+ trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
+ break;
+ }
+
+ return trans_err;
}
static gint __gst_handle_library_error(mc_gst_core_t *core, int code)
{
- gint trans_err = MEDIACODEC_ERROR_NONE;
+ gint trans_err = MEDIACODEC_ERROR_NONE;
- g_return_val_if_fail(core, MC_PARAM_ERROR);
+ g_return_val_if_fail(core, MC_PARAM_ERROR);
- switch (code) {
- case GST_LIBRARY_ERROR_FAILED:
- case GST_LIBRARY_ERROR_TOO_LAZY:
- case GST_LIBRARY_ERROR_INIT:
- case GST_LIBRARY_ERROR_SHUTDOWN:
- case GST_LIBRARY_ERROR_SETTINGS:
- case GST_LIBRARY_ERROR_ENCODE:
- default:
- trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
- break;
- }
+ switch (code) {
+ case GST_LIBRARY_ERROR_FAILED:
+ case GST_LIBRARY_ERROR_TOO_LAZY:
+ case GST_LIBRARY_ERROR_INIT:
+ case GST_LIBRARY_ERROR_SHUTDOWN:
+ case GST_LIBRARY_ERROR_SETTINGS:
+ case GST_LIBRARY_ERROR_ENCODE:
+ default:
+ trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
+ break;
+ }
- return trans_err;
+ return trans_err;
}
static gint __gst_handle_resource_error(mc_gst_core_t *core, int code)
{
- gint trans_err = MEDIACODEC_ERROR_NONE;
+ gint trans_err = MEDIACODEC_ERROR_NONE;
- g_return_val_if_fail(core, MC_PARAM_ERROR);
+ g_return_val_if_fail(core, MC_PARAM_ERROR);
- switch (code) {
- case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
- trans_err = MEDIACODEC_ERROR_NO_FREE_SPACE;
- break;
- case GST_RESOURCE_ERROR_WRITE:
- case GST_RESOURCE_ERROR_FAILED:
- case GST_RESOURCE_ERROR_SEEK:
- case GST_RESOURCE_ERROR_TOO_LAZY:
- case GST_RESOURCE_ERROR_BUSY:
- case GST_RESOURCE_ERROR_OPEN_WRITE:
- case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
- case GST_RESOURCE_ERROR_CLOSE:
- case GST_RESOURCE_ERROR_SYNC:
- case GST_RESOURCE_ERROR_SETTINGS:
- default:
- trans_err = MEDIACODEC_ERROR_INTERNAL;
- break;
- }
+ switch (code) {
+ case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
+ trans_err = MEDIACODEC_ERROR_NO_FREE_SPACE;
+ break;
+ case GST_RESOURCE_ERROR_WRITE:
+ case GST_RESOURCE_ERROR_FAILED:
+ case GST_RESOURCE_ERROR_SEEK:
+ case GST_RESOURCE_ERROR_TOO_LAZY:
+ case GST_RESOURCE_ERROR_BUSY:
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
+ case GST_RESOURCE_ERROR_CLOSE:
+ case GST_RESOURCE_ERROR_SYNC:
+ case GST_RESOURCE_ERROR_SETTINGS:
+ default:
+ trans_err = MEDIACODEC_ERROR_INTERNAL;
+ break;
+ }
- return trans_err;
+ return trans_err;
}
static gint __gst_handle_stream_error(mc_gst_core_t *core, GError* error, GstMessage * message)
{
- gint trans_err = MEDIACODEC_ERROR_NONE;
-
- g_return_val_if_fail(core, MC_PARAM_ERROR);
- g_return_val_if_fail(error, MC_PARAM_ERROR);
- g_return_val_if_fail(message, MC_PARAM_ERROR);
-
- switch (error->code) {
- case GST_STREAM_ERROR_FAILED:
- case GST_STREAM_ERROR_TYPE_NOT_FOUND:
- case GST_STREAM_ERROR_DECODE:
- case GST_STREAM_ERROR_WRONG_TYPE:
- case GST_STREAM_ERROR_DECRYPT:
- case GST_STREAM_ERROR_DECRYPT_NOKEY:
- case GST_STREAM_ERROR_CODEC_NOT_FOUND:
- trans_err = __gst_transform_gsterror(core, message, error);
- break;
-
- case GST_STREAM_ERROR_NOT_IMPLEMENTED:
- case GST_STREAM_ERROR_TOO_LAZY:
- case GST_STREAM_ERROR_ENCODE:
- case GST_STREAM_ERROR_DEMUX:
- case GST_STREAM_ERROR_MUX:
- case GST_STREAM_ERROR_FORMAT:
- default:
- trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
- break;
- }
-
- return trans_err;
+ gint trans_err = MEDIACODEC_ERROR_NONE;
+
+ g_return_val_if_fail(core, MC_PARAM_ERROR);
+ g_return_val_if_fail(error, MC_PARAM_ERROR);
+ g_return_val_if_fail(message, MC_PARAM_ERROR);
+
+ switch (error->code) {
+ case GST_STREAM_ERROR_FAILED:
+ case GST_STREAM_ERROR_TYPE_NOT_FOUND:
+ case GST_STREAM_ERROR_DECODE:
+ case GST_STREAM_ERROR_WRONG_TYPE:
+ case GST_STREAM_ERROR_DECRYPT:
+ case GST_STREAM_ERROR_DECRYPT_NOKEY:
+ case GST_STREAM_ERROR_CODEC_NOT_FOUND:
+ trans_err = __gst_transform_gsterror(core, message, error);
+ break;
+
+ case GST_STREAM_ERROR_NOT_IMPLEMENTED:
+ case GST_STREAM_ERROR_TOO_LAZY:
+ case GST_STREAM_ERROR_ENCODE:
+ case GST_STREAM_ERROR_DEMUX:
+ case GST_STREAM_ERROR_MUX:
+ case GST_STREAM_ERROR_FORMAT:
+ default:
+ trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
+ break;
+ }
+
+ return trans_err;
}
static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage * message, GError* error)
{
- gchar *src_element_name = NULL;
- GstElement *src_element = NULL;
- GstElementFactory *factory = NULL;
- const gchar *klass = NULL;
+ gchar *src_element_name = NULL;
+ GstElement *src_element = NULL;
+ GstElementFactory *factory = NULL;
+ const gchar *klass = NULL;
- src_element = GST_ELEMENT_CAST(message->src);
- if (!src_element)
- goto INTERNAL_ERROR;
+ src_element = GST_ELEMENT_CAST(message->src);
+ if (!src_element)
+ goto INTERNAL_ERROR;
- src_element_name = GST_ELEMENT_NAME(src_element);
- if (!src_element_name)
- goto INTERNAL_ERROR;
+ src_element_name = GST_ELEMENT_NAME(src_element);
+ if (!src_element_name)
+ goto INTERNAL_ERROR;
- factory = gst_element_get_factory(src_element);
- if (!factory)
- goto INTERNAL_ERROR;
+ factory = gst_element_get_factory(src_element);
+ if (!factory)
+ goto INTERNAL_ERROR;
- klass = gst_element_factory_get_klass(factory);
- if (!klass)
- goto INTERNAL_ERROR;
+ klass = gst_element_factory_get_klass(factory);
+ if (!klass)
+ goto INTERNAL_ERROR;
- LOGD("error code=%d, msg=%s, src element=%s, class=%s\n",
- error->code, error->message, src_element_name, klass);
+ LOGD("error code=%d, msg=%s, src element=%s, class=%s\n",
+ error->code, error->message, src_element_name, klass);
- switch (error->code) {
- case GST_STREAM_ERROR_DECODE:
- return MEDIACODEC_ERROR_INVALID_STREAM;
- break;
+ switch (error->code) {
+ case GST_STREAM_ERROR_DECODE:
+ return MEDIACODEC_ERROR_INVALID_STREAM;
+ break;
- case GST_STREAM_ERROR_CODEC_NOT_FOUND:
- case GST_STREAM_ERROR_TYPE_NOT_FOUND:
- case GST_STREAM_ERROR_WRONG_TYPE:
- return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
- break;
+ case GST_STREAM_ERROR_CODEC_NOT_FOUND:
+ case GST_STREAM_ERROR_TYPE_NOT_FOUND:
+ case GST_STREAM_ERROR_WRONG_TYPE:
+ return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
+ break;
- case GST_STREAM_ERROR_FAILED:
- return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
- break;
+ case GST_STREAM_ERROR_FAILED:
+ return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return MEDIACODEC_ERROR_INVALID_STREAM;
+ return MEDIACODEC_ERROR_INVALID_STREAM;
INTERNAL_ERROR:
- return MEDIACODEC_ERROR_INTERNAL;
+ return MEDIACODEC_ERROR_INTERNAL;
}
static int _mc_gst_flush_buffers(mc_gst_core_t *core)
{
- gboolean ret = FALSE;
- GstEvent *event = NULL;
+ gboolean ret = FALSE;
+ GstEvent *event = NULL;
- MEDIACODEC_FENTER();
+ MEDIACODEC_FENTER();
- _mc_gst_set_flush_input(core);
+ _mc_gst_set_flush_input(core);
- event = gst_event_new_seek(1.0, GST_FORMAT_BYTES, GST_SEEK_FLAG_FLUSH,
- GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1);
+ event = gst_event_new_seek(1.0, GST_FORMAT_BYTES, GST_SEEK_FLAG_FLUSH,
+ GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1);
- ret = gst_element_send_event(core->appsrc, event);
- if (ret != TRUE) {
- LOGE("failed to send seek event");
- return MC_ERROR;
- }
+ ret = gst_element_send_event(core->appsrc, event);
+ if (ret != TRUE) {
+ LOGE("failed to send seek event");
+ return MC_ERROR;
+ }
- _mc_gst_set_flush_output(core);
+ _mc_gst_set_flush_output(core);
- MEDIACODEC_FLEAVE();
+ MEDIACODEC_FLEAVE();
- return MC_ERROR_NONE;
+ return MC_ERROR_NONE;
}
static void _mc_gst_set_flush_input(mc_gst_core_t *core)
{
- media_packet_h pkt = NULL;
+ media_packet_h pkt = NULL;
- LOGI("_mc_gst_set_flush_input is called");
+ LOGI("_mc_gst_set_flush_input is called");
- while (!mc_async_queue_is_empty(core->available_queue->input))
- {
- pkt = mc_async_queue_pop_forced(core->available_queue->input);
+ while (!mc_async_queue_is_empty(core->available_queue->input)) {
+ pkt = mc_async_queue_pop_forced(core->available_queue->input);
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
- ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
- (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
- }
- }
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
+ ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
+ (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
+ }
+ }
- mc_async_queue_flush(core->available_queue->input);
- core->queued_count = 0;
+ mc_async_queue_flush(core->available_queue->input);
+ core->queued_count = 0;
}
static void _mc_gst_set_flush_output(mc_gst_core_t *core)
{
- media_packet_h pkt = NULL;
+ media_packet_h pkt = NULL;
- MEDIACODEC_FENTER();
- g_mutex_lock(&core->ports[1]->mutex);
+ MEDIACODEC_FENTER();
+ g_mutex_lock(&core->ports[1]->mutex);
- while(!g_queue_is_empty(core->ports[1]->queue))
- {
- pkt = g_queue_pop_head(core->ports[1]->queue);
- LOGD("outpkt in output_queue : %p", pkt);
- if (pkt) {
- media_packet_destroy(pkt);
- LOGD("outpkt destroyed");
- pkt = NULL;
- }
- }
- core->dequeued_count = 0;
- g_mutex_unlock(&core->ports[1]->mutex);
- MEDIACODEC_FLEAVE();
+ while (!g_queue_is_empty(core->ports[1]->queue)) {
+ pkt = g_queue_pop_head(core->ports[1]->queue);
+ LOGD("outpkt in output_queue : %p", pkt);
+ if (pkt) {
+ media_packet_destroy(pkt);
+ LOGD("outpkt destroyed");
+ pkt = NULL;
+ }
+ }
+ core->dequeued_count = 0;
+ g_mutex_unlock(&core->ports[1]->mutex);
+ MEDIACODEC_FLEAVE();
}
#ifdef TIZEN_PROFILE_LITE
int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int *phy_addr, int *phy_size)
{
- int tbm_bo_handle_fd;
+ int tbm_bo_handle_fd;
- int ret = 0;
+ int ret = 0;
- tbm_bo_handle_fd = tbm_bo_handle_fd_t.u32;
+ tbm_bo_handle_fd = tbm_bo_handle_fd_t.u32;
- int open_flags = O_RDWR;
- int ion_fd = -1;
+ int open_flags = O_RDWR;
+ int ion_fd = -1;
- struct ion_mmu_data mmu_data;
- struct ion_custom_data custom_data;
+ struct ion_mmu_data mmu_data;
+ struct ion_custom_data custom_data;
- mmu_data.fd_buffer = tbm_bo_handle_fd;
- custom_data.cmd = 4;
- custom_data.arg = (unsigned long)&mmu_data;
+ mmu_data.fd_buffer = tbm_bo_handle_fd;
+ custom_data.cmd = 4;
+ custom_data.arg = (unsigned long)&mmu_data;
- ion_fd = open("/dev/ion", open_flags);
- if (ion_fd < 0) {
- LOGE("[tbm_get_physical_addr_bo] ion_fd open device failed");
- }
+ ion_fd = open("/dev/ion", open_flags);
+ if (ion_fd < 0)
+ LOGE("[tbm_get_physical_addr_bo] ion_fd open device failed");
- if (ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
- LOGE("[tbm_get_physical_addr_bo] ION_IOC_CUSTOM failed");
- ret = -1;
- }
+ if (ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
+ LOGE("[tbm_get_physical_addr_bo] ION_IOC_CUSTOM failed");
+ ret = -1;
+ }
- if (!ret) {
- *phy_addr = mmu_data.iova_addr;
- *phy_size = mmu_data.iova_size;
- } else {
- *phy_addr = 0;
- *phy_size = 0;
- LOGW("[tbm_get_physical_addr_bo] getting physical address is failed. phy_addr = 0");
- }
+ if (!ret) {
+ *phy_addr = mmu_data.iova_addr;
+ *phy_size = mmu_data.iova_size;
+ } else {
+ *phy_addr = 0;
+ *phy_size = 0;
+ LOGW("[tbm_get_physical_addr_bo] getting physical address is failed. phy_addr = 0");
+ }
- if (ion_fd != -1) {
- close(ion_fd);
- ion_fd = -1;
- }
+ if (ion_fd != -1) {
+ close(ion_fd);
+ ion_fd = -1;
+ }
- return 0;
+ return 0;
}
#endif
*/
static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
{
- int pixel_x_m1, pixel_y_m1;
- int roundup_x;
- int linear_addr0, linear_addr1, bank_addr ;
- int x_addr;
- int trans_addr;
+ int pixel_x_m1, pixel_y_m1;
+ int roundup_x;
+ int linear_addr0, linear_addr1, bank_addr ;
+ int x_addr;
+ int trans_addr;
- pixel_x_m1 = x_size - 1;
- pixel_y_m1 = y_size - 1;
+ pixel_x_m1 = x_size - 1;
+ pixel_y_m1 = y_size - 1;
- roundup_x = ((pixel_x_m1 >> 7) + 1);
+ roundup_x = ((pixel_x_m1 >> 7) + 1);
- x_addr = x_pos >> 2;
+ x_addr = x_pos >> 2;
- if ((y_size <= y_pos+32) && (y_pos < y_size) &&
- (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
- linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
+ if ((y_size <= y_pos+32) && (y_pos < y_size) &&
+ (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
+ linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
+ linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- } else {
- linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
+ if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+ bank_addr = ((x_addr >> 4) & 0x1);
+ else
+ bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+ } else {
+ linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
+ linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- }
+ if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+ bank_addr = ((x_addr >> 4) & 0x1);
+ else
+ bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+ }
- linear_addr0 = linear_addr0 << 2;
- trans_addr = (linear_addr1 << 13) | (bank_addr << 11) | linear_addr0;
+ linear_addr0 = linear_addr0 << 2;
+ trans_addr = (linear_addr1 << 13) | (bank_addr << 11) | linear_addr0;
- return trans_addr;
+ return trans_addr;
}
/*
* Crop size of buttom
*/
static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src,
- int yuv420_width, int yuv420_height,
- int left, int top, int right, int buttom)
-{
- int i, j;
- int tiled_offset = 0, tiled_offset1 = 0;
- int linear_offset = 0;
- int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
-
- temp3 = yuv420_width-right;
- temp1 = temp3-left;
- /* real width is greater than or equal 256 */
- if (temp1 >= 256) {
- for (i = top; i < yuv420_height-buttom; i += 1) {
- j = left;
- temp3 = (j>>8)<<8;
- temp3 = temp3>>6;
- temp4 = i>>5;
- if (temp4 & 0x1) {
- /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
- tiled_offset = temp4-1;
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = tiled_offset*(temp1>>6);
- tiled_offset = tiled_offset+temp3;
- tiled_offset = tiled_offset+2;
- temp1 = (temp3>>2)<<2;
- tiled_offset = tiled_offset+temp1;
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*2;
- temp4 = 8;
- } else {
- temp2 = ((yuv420_height+31)>>5)<<5;
- if ((i + 32) < temp2) {
- /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
- temp1 = temp3+2;
- temp1 = (temp1>>2)<<2;
- tiled_offset = temp3+temp1;
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = tiled_offset+temp4*(temp1>>6);
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset + 2048 * 6;
- temp4 = 8;
- } else {
- /* even2 fomula: x+x_block_num*y */
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = temp4*(temp1>>6);
- tiled_offset = tiled_offset+temp3;
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*2;
- temp4 = 4;
- }
- }
-
- temp1 = i&0x1F;
- tiled_offset = tiled_offset+64*(temp1);
- tiled_offset1 = tiled_offset1+64*(temp1);
- temp2 = yuv420_width-left-right;
- linear_offset = temp2*(i-top);
- temp3 = ((j+256)>>8)<<8;
- temp3 = temp3-j;
- temp1 = left&0x3F;
- if (temp3 > 192) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+temp1, 64-temp1);
- temp2 = ((left+63)>>6)<<6;
- temp3 = ((yuv420_width-right)>>6)<<6;
- if (temp2 == temp3) {
- temp2 = yuv420_width-right-(64-temp1);
- }
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+192-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+256-temp1;
- } else if (temp3 > 128) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+2048+temp1, 64-temp1);
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+192-temp1;
- } else if (temp3 > 64) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+temp1, 64-temp1);
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+128-temp1;
- } else if (temp3 > 0) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+2048+temp1, 64-temp1);
- linear_offset = linear_offset+64-temp1;
- }
-
- tiled_offset = tiled_offset+temp4*2048;
- j = (left>>8)<<8;
- j = j + 256;
- temp2 = yuv420_width-right-256;
- for (; j <= temp2; j += 256) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- tiled_offset1 = tiled_offset1+temp4*2048;
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
- tiled_offset = tiled_offset+temp4*2048;
- memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+256;
- }
-
- tiled_offset1 = tiled_offset1+temp4*2048;
- temp2 = yuv420_width-right-j;
- if (temp2 > 192) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, temp2-192);
- } else if (temp2 > 128) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, temp2-128);
- } else if (temp2 > 64) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, temp2-64);
- } else {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- }
- }
- } else if (temp1 >= 64) {
- for (i = top; i < (yuv420_height-buttom); i += 1) {
- j = left;
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp2 = ((j+64)>>6)<<6;
- temp2 = temp2-j;
- linear_offset = temp1*(i-top);
- temp4 = j&0x3;
- tiled_offset = tiled_offset+temp4;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- linear_offset = linear_offset+temp2;
- j = j+temp2;
- if ((j+64) <= temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- linear_offset = linear_offset+64;
- j = j+64;
- }
- if ((j+64) <= temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- linear_offset = linear_offset+64;
- j = j+64;
- }
- if (j < temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp2 = temp3-j;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- }
- }
- } else {
- for (i = top; i < (yuv420_height-buttom); i += 1) {
- linear_offset = temp1*(i-top);
- for (j = left; j < (yuv420_width - right); j += 2) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp4 = j&0x3;
- tiled_offset = tiled_offset+temp4;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 2);
- linear_offset = linear_offset+2;
- }
- }
- }
+ int yuv420_width, int yuv420_height,
+ int left, int top, int right, int buttom)
+{
+ int i, j;
+ int tiled_offset = 0, tiled_offset1 = 0;
+ int linear_offset = 0;
+ int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
+
+ temp3 = yuv420_width-right;
+ temp1 = temp3-left;
+ /* real width is greater than or equal 256 */
+ if (temp1 >= 256) {
+ for (i = top; i < yuv420_height-buttom; i += 1) {
+ j = left;
+ temp3 = (j>>8)<<8;
+ temp3 = temp3>>6;
+ temp4 = i>>5;
+ if (temp4 & 0x1) {
+ /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+ tiled_offset = temp4-1;
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = tiled_offset*(temp1>>6);
+ tiled_offset = tiled_offset+temp3;
+ tiled_offset = tiled_offset+2;
+ temp1 = (temp3>>2)<<2;
+ tiled_offset = tiled_offset+temp1;
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset+2048*2;
+ temp4 = 8;
+ } else {
+ temp2 = ((yuv420_height+31)>>5)<<5;
+ if ((i + 32) < temp2) {
+ /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+ temp1 = temp3+2;
+ temp1 = (temp1>>2)<<2;
+ tiled_offset = temp3+temp1;
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = tiled_offset+temp4*(temp1>>6);
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset + 2048 * 6;
+ temp4 = 8;
+ } else {
+ /* even2 fomula: x+x_block_num*y */
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = temp4*(temp1>>6);
+ tiled_offset = tiled_offset+temp3;
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset+2048*2;
+ temp4 = 4;
+ }
+ }
+
+ temp1 = i&0x1F;
+ tiled_offset = tiled_offset+64*(temp1);
+ tiled_offset1 = tiled_offset1+64*(temp1);
+ temp2 = yuv420_width-left-right;
+ linear_offset = temp2*(i-top);
+ temp3 = ((j+256)>>8)<<8;
+ temp3 = temp3-j;
+ temp1 = left&0x3F;
+
+ if (temp3 > 192) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+temp1, 64-temp1);
+ temp2 = ((left+63)>>6)<<6;
+ temp3 = ((yuv420_width-right)>>6)<<6;
+
+ if (temp2 == temp3)
+ temp2 = yuv420_width-right-(64-temp1);
+
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+192-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+256-temp1;
+ } else if (temp3 > 128) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+2048+temp1, 64-temp1);
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+192-temp1;
+ } else if (temp3 > 64) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+temp1, 64-temp1);
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+128-temp1;
+ } else if (temp3 > 0) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+2048+temp1, 64-temp1);
+ linear_offset = linear_offset+64-temp1;
+ }
+
+ tiled_offset = tiled_offset+temp4*2048;
+ j = (left>>8)<<8;
+ j = j + 256;
+ temp2 = yuv420_width-right-256;
+ for (; j <= temp2; j += 256) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ tiled_offset1 = tiled_offset1+temp4*2048;
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
+ tiled_offset = tiled_offset+temp4*2048;
+ memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+256;
+ }
+
+ tiled_offset1 = tiled_offset1+temp4*2048;
+ temp2 = yuv420_width-right-j;
+ if (temp2 > 192) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, temp2-192);
+ } else if (temp2 > 128) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, temp2-128);
+ } else if (temp2 > 64) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, temp2-64);
+ } else {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ }
+ }
+ } else if (temp1 >= 64) {
+ for (i = top; i < (yuv420_height-buttom); i += 1) {
+ j = left;
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp2 = ((j+64)>>6)<<6;
+ temp2 = temp2-j;
+ linear_offset = temp1*(i-top);
+ temp4 = j&0x3;
+ tiled_offset = tiled_offset+temp4;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ linear_offset = linear_offset+temp2;
+ j = j+temp2;
+ if ((j+64) <= temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ linear_offset = linear_offset+64;
+ j = j+64;
+ }
+ if ((j+64) <= temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ linear_offset = linear_offset+64;
+ j = j+64;
+ }
+ if (j < temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp2 = temp3-j;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ }
+ }
+ } else {
+ for (i = top; i < (yuv420_height-buttom); i += 1) {
+ linear_offset = temp1*(i-top);
+ for (j = left; j < (yuv420_width - right); j += 2) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp4 = j&0x3;
+ tiled_offset = tiled_offset+temp4;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 2);
+ linear_offset = linear_offset+2;
+ }
+ }
+ }
}
void _mc_send_eos_signal(mc_gst_core_t *core)
{
- g_mutex_lock(&core->eos_mutex);
- core->eos = FALSE;
- g_cond_broadcast(&core->eos_cond);
- g_mutex_unlock(&core->eos_mutex);
- LOGD("send EOS signal");
+ g_mutex_lock(&core->eos_mutex);
+ core->eos = FALSE;
+ g_cond_broadcast(&core->eos_cond);
+ g_mutex_unlock(&core->eos_mutex);
+ LOGD("send EOS signal");
}
void _mc_wait_for_eos(mc_gst_core_t *core)
{
- g_mutex_lock(&core->eos_mutex);
- core->eos = TRUE;
- LOGD("waiting for EOS");
- while (core->eos) {
- g_cond_wait(&core->eos_cond, &core->eos_mutex);
- }
- LOGD("received EOS");
- g_mutex_unlock(&core->eos_mutex);
+ g_mutex_lock(&core->eos_mutex);
+ core->eos = TRUE;
+ LOGD("waiting for EOS");
+
+ while (core->eos)
+ g_cond_wait(&core->eos_cond, &core->eos_mutex);
+
+ LOGD("received EOS");
+ g_mutex_unlock(&core->eos_mutex);
}
async_queue_t *mc_async_queue_new(void)
{
- async_queue_t *async_queue;
+ async_queue_t *async_queue;
- async_queue = g_slice_new0(async_queue_t);
- if (async_queue == NULL) {
- LOGE("async_queue initialization failed");
- return NULL;
- }
+ async_queue = g_slice_new0(async_queue_t);
+ if (async_queue == NULL) {
+ LOGE("async_queue initialization failed");
+ return NULL;
+ }
- g_cond_init(&async_queue->condition);
- g_mutex_init(&async_queue->mutex);
- async_queue->enabled = TRUE;
+ g_cond_init(&async_queue->condition);
+ g_mutex_init(&async_queue->mutex);
+ async_queue->enabled = TRUE;
- return async_queue;
+ return async_queue;
}
void mc_async_queue_free(async_queue_t *async_queue)
{
- g_cond_clear(&async_queue->condition);
- g_mutex_clear(&async_queue->mutex);
+ g_cond_clear(&async_queue->condition);
+ g_mutex_clear(&async_queue->mutex);
- g_list_free(async_queue->head);
- g_slice_free(async_queue_t, async_queue);
+ g_list_free(async_queue->head);
+ g_slice_free(async_queue_t, async_queue);
}
void mc_async_queue_push(async_queue_t *async_queue, gpointer data)
{
- g_mutex_lock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
- async_queue->tail = g_list_append(async_queue->tail, data);
- if (async_queue->tail->next)
- async_queue->tail = async_queue->tail->next;
- else
- async_queue->head = async_queue->tail;
+ async_queue->tail = g_list_append(async_queue->tail, data);
+ if (async_queue->tail->next)
+ async_queue->tail = async_queue->tail->next;
+ else
+ async_queue->head = async_queue->tail;
- async_queue->length++;
+ async_queue->length++;
- g_cond_signal(&async_queue->condition);
- /*LOGD("queue pushed : %p, %d, %p",queue, async_queue->length, data);*/
+ g_cond_signal(&async_queue->condition);
+ /*LOGD("queue pushed : %p, %d, %p",queue, async_queue->length, data);*/
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
}
gpointer mc_async_queue_pop(async_queue_t *async_queue)
{
- gpointer data = NULL;
+ gpointer data = NULL;
- g_mutex_lock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
- if (!async_queue->enabled) {
- /* g_warning ("not enabled!"); */
- goto leave;
- }
+ if (!async_queue->enabled) {
+ /* g_warning ("not enabled!"); */
+ goto leave;
+ }
- if (!async_queue->head) {
- g_cond_wait(&async_queue->condition, &async_queue->mutex);
- }
+ if (!async_queue->head)
+ g_cond_wait(&async_queue->condition, &async_queue->mutex);
- if (async_queue->head) {
- GList *node = async_queue->head;
- data = node->data;
+ if (async_queue->head) {
+ GList *node = async_queue->head;
+ data = node->data;
- async_queue->head = node->next;
+ async_queue->head = node->next;
- if (async_queue->head)
- async_queue->head->prev = NULL;
- else
- async_queue->tail = NULL;
- async_queue->length--;
- /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
- g_list_free_1(node);
- }
+ if (async_queue->head)
+ async_queue->head->prev = NULL;
+ else
+ async_queue->tail = NULL;
+ async_queue->length--;
+ /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
+ g_list_free_1(node);
+ }
leave:
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
- return data;
+ return data;
}
gpointer mc_async_queue_pop_forced(async_queue_t *async_queue)
{
- gpointer data = NULL;
+ gpointer data = NULL;
- g_mutex_lock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
- if (async_queue->head) {
- GList *node = async_queue->head;
- data = node->data;
+ if (async_queue->head) {
+ GList *node = async_queue->head;
+ data = node->data;
- async_queue->head = node->next;
- if (async_queue->head)
- async_queue->head->prev = NULL;
- else
- async_queue->tail = NULL;
- async_queue->length--;
- /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
- g_list_free_1(node);
- }
+ async_queue->head = node->next;
+ if (async_queue->head)
+ async_queue->head->prev = NULL;
+ else
+ async_queue->tail = NULL;
+ async_queue->length--;
+ /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
+ g_list_free_1(node);
+ }
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
- return data;
+ return data;
}
void mc_async_queue_disable(async_queue_t *async_queue)
{
- g_mutex_lock(&async_queue->mutex);
- async_queue->enabled = FALSE;
- g_cond_broadcast(&async_queue->condition);
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
+ async_queue->enabled = FALSE;
+ g_cond_broadcast(&async_queue->condition);
+ g_mutex_unlock(&async_queue->mutex);
}
void mc_async_queue_enable(async_queue_t *async_queue)
{
- g_mutex_lock(&async_queue->mutex);
- async_queue->enabled = TRUE;
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
+ async_queue->enabled = TRUE;
+ g_mutex_unlock(&async_queue->mutex);
}
void mc_async_queue_flush(async_queue_t *async_queue)
{
- g_mutex_lock(&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
- g_list_free(async_queue->head);
- async_queue->head = async_queue->tail = NULL;
- async_queue->length = 0;
+ g_list_free(async_queue->head);
+ async_queue->head = async_queue->tail = NULL;
+ async_queue->length = 0;
- g_mutex_unlock(&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
}
gboolean mc_async_queue_is_empty(async_queue_t *async_queue)
{
- return async_queue->head == NULL;
+ return async_queue->head == NULL;
}
void *mc_aligned_malloc(int size, int alignment)
{
- unsigned char *pMem;
- unsigned char *tmp;
+ unsigned char *pMem;
+ unsigned char *tmp;
- if ((tmp = (unsigned char *)malloc(size + alignment)) != NULL) {
- pMem = (unsigned char *)((unsigned int)(tmp + alignment - 1) & (~(unsigned int)(alignment - 1)));
+ if ((tmp = (unsigned char *)malloc(size + alignment)) != NULL) {
+ pMem = (unsigned char *)((unsigned int)(tmp + alignment - 1) & (~(unsigned int)(alignment - 1)));
- if (pMem == tmp)
- pMem += alignment;
+ if (pMem == tmp)
+ pMem += alignment;
- *(pMem - 1) = (unsigned int)(pMem - tmp);
+ *(pMem - 1) = (unsigned int)(pMem - tmp);
- return ((void *) pMem);
- }
- return NULL;
+ return ((void *) pMem);
+ }
+ return NULL;
}
void mc_aligned_free(void *mem)
{
- unsigned char *ptr;
+ unsigned char *ptr;
- if (mem == NULL)
- return;
+ if (mem == NULL)
+ return;
- ptr = mem;
- ptr -= *(ptr-1);
+ ptr = mem;
+ ptr -= *(ptr-1);
- free(ptr);
+ free(ptr);
}
mc_sem_t *mc_sem_new()
{
- mc_sem_t *sem;
- sem = g_new(mc_sem_t, 1);
- g_cond_init(&sem->cond);
- g_mutex_init(&sem->mutex);
- sem->counter = 0;
+ mc_sem_t *sem;
+ sem = g_new(mc_sem_t, 1);
+ g_cond_init(&sem->cond);
+ g_mutex_init(&sem->mutex);
+ sem->counter = 0;
- return sem;
+ return sem;
}
void mc_sem_free(mc_sem_t *sem)
{
- g_cond_clear(&sem->cond);
- g_mutex_clear(&sem->mutex);
- g_free(sem);
+ g_cond_clear(&sem->cond);
+ g_mutex_clear(&sem->mutex);
+ g_free(sem);
}
void mc_sem_down(mc_sem_t *sem)
{
- g_mutex_lock(&sem->mutex);
+ g_mutex_lock(&sem->mutex);
- while (sem->counter == 0)
- g_cond_wait(&sem->cond, &sem->mutex);
- sem->counter--;
+ while (sem->counter == 0)
+ g_cond_wait(&sem->cond, &sem->mutex);
+ sem->counter--;
- g_mutex_unlock(&sem->mutex);
+ g_mutex_unlock(&sem->mutex);
}
void mc_sem_up(mc_sem_t *sem)
{
- g_mutex_lock(&sem->mutex);
+ g_mutex_lock(&sem->mutex);
- sem->counter++;
- g_cond_signal(&sem->cond);
+ sem->counter++;
+ g_cond_signal(&sem->cond);
- g_mutex_unlock(&sem->mutex);
+ g_mutex_unlock(&sem->mutex);
}
void mc_hex_dump(char *desc, void *addr, int len)
{
- int i;
- unsigned char buff[17];
- unsigned char *pc = (unsigned char *)addr;
+ int i;
+ unsigned char buff[17];
+ unsigned char *pc = (unsigned char *)addr;
- if (desc != NULL)
- printf("%s:\n", desc);
+ if (desc != NULL)
+ printf("%s:\n", desc);
- for (i = 0; i < len; i++) {
+ for (i = 0; i < len; i++) {
- if ((i % 16) == 0) {
- if (i != 0)
- printf(" %s\n", buff);
+ if ((i % 16) == 0) {
+ if (i != 0)
+ printf(" %s\n", buff);
- printf(" %04x ", i);
- }
+ printf(" %04x ", i);
+ }
- printf(" %02x", pc[i]);
+ printf(" %02x", pc[i]);
- if ((pc[i] < 0x20) || (pc[i] > 0x7e))
- buff[i % 16] = '.';
- else
- buff[i % 16] = pc[i];
- buff[(i % 16) + 1] = '\0';
- }
+ if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+ buff[i % 16] = '.';
+ else
+ buff[i % 16] = pc[i];
+ buff[(i % 16) + 1] = '\0';
+ }
- while ((i % 16) != 0) {
- printf(" ");
- i++;
- }
- printf(" %s\n", buff);
+ while ((i % 16) != 0) {
+ printf(" ");
+ i++;
+ }
+ printf(" %s\n", buff);
}
#define GET_IS_HW(x) CHECK_BIT(x, 2)
#define ES_DEFAULT_VIDEO_PTS_OFFSET 33000000
#define CHECK_VALID_PACKET(state, expected_state) \
- ((state & (expected_state)) == (expected_state))
+ ((state & (expected_state)) == (expected_state))
static int samplerate = DEFAULT_SAMPPLERATE;
static int channel = DEFAULT_CHANNEL;
static int samplebyte = DEFAULT_SAMPLEBYTE;
unsigned char buf_adts[ADTS_HEADER_SIZE];
-enum
-{
- MC_EXIST_SPS = 1 << 0,
- MC_EXIST_PPS = 1 << 1,
- MC_EXIST_IDR = 1 << 2,
- MC_EXIST_SLICE = 1 << 3,
+enum {
+ MC_EXIST_SPS = 1 << 0,
+ MC_EXIST_PPS = 1 << 1,
+ MC_EXIST_IDR = 1 << 2,
+ MC_EXIST_SLICE = 1 << 3,
- MC_VALID_HEADER = ( MC_EXIST_SPS | MC_EXIST_PPS ),
- MC_VALID_FIRST_SLICE = ( MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR )
+ MC_VALID_HEADER = (MC_EXIST_SPS | MC_EXIST_PPS),
+ MC_VALID_FIRST_SLICE = (MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR)
};
typedef struct _App App;
-enum
-{
- CURRENT_STATUS_MAINMENU,
- CURRENT_STATUS_FILENAME,
- CURRENT_STATUS_CREATE,
- CURRENT_STATUS_DESTROY,
- CURRENT_STATUS_SET_CODEC,
- CURRENT_STATUS_SET_VDEC_INFO,
- CURRENT_STATUS_SET_VENC_INFO,
- CURRENT_STATUS_SET_ADEC_INFO,
- CURRENT_STATUS_SET_AENC_INFO,
- CURRENT_STATUS_PREPARE,
- CURRENT_STATUS_UNPREPARE,
- CURRENT_STATUS_PROCESS_INPUT,
- CURRENT_STATUS_GET_OUTPUT,
- CURRENT_STATUS_RESET_OUTPUT_BUFFER,
- CURRENT_STATUS_SET_SIZE,
+enum {
+ CURRENT_STATUS_MAINMENU,
+ CURRENT_STATUS_FILENAME,
+ CURRENT_STATUS_CREATE,
+ CURRENT_STATUS_DESTROY,
+ CURRENT_STATUS_SET_CODEC,
+ CURRENT_STATUS_SET_VDEC_INFO,
+ CURRENT_STATUS_SET_VENC_INFO,
+ CURRENT_STATUS_SET_ADEC_INFO,
+ CURRENT_STATUS_SET_AENC_INFO,
+ CURRENT_STATUS_PREPARE,
+ CURRENT_STATUS_UNPREPARE,
+ CURRENT_STATUS_PROCESS_INPUT,
+ CURRENT_STATUS_GET_OUTPUT,
+ CURRENT_STATUS_RESET_OUTPUT_BUFFER,
+ CURRENT_STATUS_SET_SIZE,
};
-typedef enum
-{
- NAL_SLICE_NO_PARTITIONING = 1,
- NAL_SLICE_PART_A,
- NAL_SLICE_PART_B,
- NAL_SLICE_PART_C,
- NAL_SLICE_IDR,
- NAL_SEI,
- NAL_SEQUENCE_PARAMETER_SET,
- NAL_PICTURE_PARAMETER_SET,
- NAL_PICTURE_DELIMITER,
- NAL_END_OF_SEQUENCE,
- NAL_END_OF_STREAM,
- NAL_FILLER_DATA,
- NAL_PREFIX_SVC = 14
+typedef enum {
+ NAL_SLICE_NO_PARTITIONING = 1,
+ NAL_SLICE_PART_A,
+ NAL_SLICE_PART_B,
+ NAL_SLICE_PART_C,
+ NAL_SLICE_IDR,
+ NAL_SEI,
+ NAL_SEQUENCE_PARAMETER_SET,
+ NAL_PICTURE_PARAMETER_SET,
+ NAL_PICTURE_DELIMITER,
+ NAL_END_OF_SEQUENCE,
+ NAL_END_OF_STREAM,
+ NAL_FILLER_DATA,
+ NAL_PREFIX_SVC = 14
} nal_unit_type;
-typedef enum
-{
- VIDEO_DEC,
- VIDEO_ENC,
- AUDIO_DEC,
- AUDIO_ENC
-}type_e;
-
-
-struct _App
-{
- GMainLoop *loop;
- guint sourceid;
-
- GMappedFile *file;
- guint8 *data;
- gsize length;
- guint64 offset;
- guint obj;
-
- GTimer *timer;
- long start;
- long finish;
- long process_time;
- int frame_count;
-
- int codecid;
- int flag;
- bool is_video[MAX_HANDLE];
- bool is_encoder[MAX_HANDLE];
- bool hardware;
- type_e type;
- /* video */
- mediacodec_h mc_handle[MAX_HANDLE];
- guint width;
- guint height;
- guint fps;
- guint target_bits;
- media_format_mimetype_e mime;
-
- /* Audio */
- guint samplerate;
- guint channel;
- guint bit;
- guint bitrate;
- bool is_amr_nb;
-
-
- /* Render */
- guint w;
- guint h;
- Evas_Object *win;
- Evas_Object *img;
- media_packet_h packet;
- Ecore_Pipe *pipe;
- //camera_h camera_handle;
- GList *packet_list;
- GMutex lock;
+typedef enum {
+ VIDEO_DEC,
+ VIDEO_ENC,
+ AUDIO_DEC,
+ AUDIO_ENC
+} type_e;
+
+
+struct _App {
+ GMainLoop *loop;
+ guint sourceid;
+
+ GMappedFile *file;
+ guint8 *data;
+ gsize length;
+ guint64 offset;
+ guint obj;
+
+ GTimer *timer;
+ long start;
+ long finish;
+ long process_time;
+ int frame_count;
+
+ int codecid;
+ int flag;
+ bool is_video[MAX_HANDLE];
+ bool is_encoder[MAX_HANDLE];
+ bool hardware;
+ type_e type;
+ /* video */
+ mediacodec_h mc_handle[MAX_HANDLE];
+ guint width;
+ guint height;
+ guint fps;
+ guint target_bits;
+ media_format_mimetype_e mime;
+
+ /* Audio */
+ guint samplerate;
+ guint channel;
+ guint bit;
+ guint bitrate;
+ bool is_amr_nb;
+
+
+ /* Render */
+ guint w;
+ guint h;
+ Evas_Object *win;
+ Evas_Object *img;
+ media_packet_h packet;
+ Ecore_Pipe *pipe;
+ GList *packet_list;
+ GMutex lock;
};
App s_app;
static int _create_app(void *data)
{
- printf("My app is going alive!\n");
- App *app = (App*)data;
+ printf("My app is going alive!\n");
+ App *app = (App*)data;
- g_mutex_init(&app->lock);
- return 0;
+ g_mutex_init(&app->lock);
+ return 0;
}
static int _terminate_app(void *data)
{
- printf("My app is going gone!\n");
- App *app = (App*)data;
+ printf("My app is going gone!\n");
+ App *app = (App*)data;
- g_mutex_clear(&app->lock);
- return 0;
+ g_mutex_clear(&app->lock);
+ return 0;
}
struct appcore_ops ops = {
- .create = _create_app,
- .terminate = _terminate_app,
+ .create = _create_app,
+ .terminate = _terminate_app,
};
static const guint mp3types_bitrates[2][3][16] = {
-{
- {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
- {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
- {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
- },
-{
- {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
- {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
- {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
- },
+ {
+ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
+ },
+ {
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
+ },
};
static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
- {22050, 24000, 16000},
- {11025, 12000, 8000}
+ {22050, 24000, 16000},
+ {11025, 12000, 8000}
};
void h264_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int nal_length = 0;
- unsigned char val, zero_count;
- //unsigned char *pNal = data;
- unsigned char *pNal = app->data + app->offset;
- int max = app->length - app->offset;
- int i = 0;
- int index = 0;
- int nal_unit_type = 0;
- bool init;
- bool slice;
- bool idr;
- static int state;
- int read;
-
- zero_count = 0;
-
- val = pNal[index++];
- while (!val)
- {
- zero_count++;
- val = pNal[index++];
- }
-
- zero_count = 0;
-
- while (1)
- {
- if (index >= max) {
- read = (index - 1);
- goto DONE;
- }
-
- val = pNal[index++];
-
- if (!val)
- zero_count++;
- else {
- if ((zero_count >= 2) && (val == 1))
- break;
- else {
- zero_count = 0;
- }
- }
- }
-
- if( zero_count > 3 )
- zero_count = 3;
-
- read = ( index - zero_count - 1);
-
- nal_unit_type = *(app->data+app->offset+4) & 0x1F;
- g_print("nal_unit_type : %x\n", nal_unit_type);
-
- switch ( nal_unit_type )
- {
- case NAL_SEQUENCE_PARAMETER_SET:
- g_print("nal_unit_type : SPS\n");
- state |= MC_EXIST_SPS;
- break;
- case NAL_PICTURE_PARAMETER_SET:
- g_print("nal_unit_type : PPS\n");
- state |= MC_EXIST_PPS;
- break;
- case NAL_SLICE_IDR:
- case NAL_SEI:
- g_print ("nal_unit_type : IDR\n");
- state |= MC_EXIST_IDR;
- break;
- case NAL_SLICE_NO_PARTITIONING:
- case NAL_SLICE_PART_A:
- case NAL_SLICE_PART_B:
- case NAL_SLICE_PART_C:
- state |= MC_EXIST_SLICE;
- break;
- default:
- g_print ("nal_unit_type : %x", nal_unit_type);
- break;
- }
-
- init = CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE) ? 1 :0;
- slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 :0;
- idr = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
- g_print("status : %d, slice : %d, idr : %d\n", init, slice, idr);
-
- if (init || idr || slice) {
- *have_frame = TRUE;
- if (init) {
- *data = app->data;
- *size = app->offset + read;
- } else {
- *data = app->data+app->offset;
- *size = read;
- }
- state = 0;
- } else {
- *data = app->data+app->offset;
- *size = read;
- //app->offset += read;
- }
+ int nal_length = 0;
+ unsigned char val, zero_count;
+ unsigned char *pNal = app->data + app->offset;
+ int max = app->length - app->offset;
+ int i = 0;
+ int index = 0;
+ int nal_unit_type = 0;
+ bool init;
+ bool slice;
+ bool idr;
+ static int state;
+ int read;
+
+ zero_count = 0;
+
+ val = pNal[index++];
+ while (!val) {
+ zero_count++;
+ val = pNal[index++];
+ }
+
+ zero_count = 0;
+
+ while (1) {
+ if (index >= max) {
+ read = (index - 1);
+ goto DONE;
+ }
+
+ val = pNal[index++];
+
+ if (!val)
+ zero_count++;
+ else {
+ if ((zero_count >= 2) && (val == 1))
+ break;
+ else {
+ zero_count = 0;
+ }
+ }
+ }
+
+ if(zero_count > 3)
+ zero_count = 3;
+
+ read = (index - zero_count - 1);
+
+ nal_unit_type = *(app->data+app->offset+4) & 0x1F;
+ g_print("nal_unit_type : %x\n", nal_unit_type);
+
+ switch ( nal_unit_type )
+ {
+ case NAL_SEQUENCE_PARAMETER_SET:
+ g_print("nal_unit_type : SPS\n");
+ state |= MC_EXIST_SPS;
+ break;
+ case NAL_PICTURE_PARAMETER_SET:
+ g_print("nal_unit_type : PPS\n");
+ state |= MC_EXIST_PPS;
+ break;
+ case NAL_SLICE_IDR:
+ case NAL_SEI:
+ g_print ("nal_unit_type : IDR\n");
+ state |= MC_EXIST_IDR;
+ break;
+ case NAL_SLICE_NO_PARTITIONING:
+ case NAL_SLICE_PART_A:
+ case NAL_SLICE_PART_B:
+ case NAL_SLICE_PART_C:
+ state |= MC_EXIST_SLICE;
+ break;
+ default:
+ g_print ("nal_unit_type : %x", nal_unit_type);
+ break;
+ }
+
+ init = CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE) ? 1 :0;
+ slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 :0;
+ idr = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
+ g_print("status : %d, slice : %d, idr : %d\n", init, slice, idr);
+
+ if (init || idr || slice) {
+ *have_frame = TRUE;
+ if (init) {
+ *data = app->data;
+ *size = app->offset + read;
+ } else {
+ *data = app->data+app->offset;
+ *size = read;
+ }
+ state = 0;
+ } else {
+ *data = app->data+app->offset;
+ *size = read;
+ //app->offset += read;
+ }
DONE:
- app->offset += read;
+ app->offset += read;
}
void nv12_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int yuv_size;
- int offset = app->length - app->offset;
+ int yuv_size;
+ int offset = app->length - app->offset;
- yuv_size = app->width * app->height * 3 / 2;
+ yuv_size = app->width * app->height * 3 / 2;
- if (offset >= yuv_size)
- *size = offset;
+ if (offset >= yuv_size)
+ *size = offset;
- *have_frame = TRUE;
- *data = app->data + app->offset;
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- if (offset >= yuv_size)
- *size = offset;
- else
- *size = yuv_size;
+ if (offset >= yuv_size)
+ *size = offset;
+ else
+ *size = yuv_size;
}
void yuv_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int yuv_size;
- int offset = app->length - app->offset;
+ int yuv_size;
+ int offset = app->length - app->offset;
- yuv_size = app->width * app->height * 3 / 2;
+ yuv_size = app->width * app->height * 3 / 2;
- if (yuv_size >= offset)
- *size = offset;
+ if (yuv_size >= offset)
+ *size = offset;
- *have_frame = TRUE;
- *data = app->data + app->offset;
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- if (yuv_size >= offset)
- *size = offset;
- else
- *size = yuv_size;
+ if (yuv_size >= offset)
+ *size = offset;
+ else
+ *size = yuv_size;
- app->offset += *size;
+ app->offset += *size;
}
void aacenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int read_size;
- int offset = app->length - app->offset;
+ int read_size;
+ int offset = app->length - app->offset;
- read_size = ((samplebyte*app->channel)*(app->bit/8));
+ read_size = ((samplebyte*app->channel)*(app->bit/8));
- *have_frame = TRUE;
+ *have_frame = TRUE;
- if (offset >= read_size)
- *size = offset;
- else
- *size = read_size;
+ if (offset >= read_size)
+ *size = offset;
+ else
+ *size = read_size;
- app->offset += *size;
+ app->offset += *size;
}
void amrenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int read_size;
- int offset = app->length - app->offset;
+ int read_size;
+ int offset = app->length - app->offset;
- if(app->is_amr_nb)
- read_size = AMRNB_PCM_INPUT_SIZE;
- else
- read_size = AMRWB_PCM_INPUT_SIZE;
+ if(app->is_amr_nb)
+ read_size = AMRNB_PCM_INPUT_SIZE;
+ else
+ read_size = AMRWB_PCM_INPUT_SIZE;
- *have_frame = TRUE;
+ *have_frame = TRUE;
- if (offset >= read_size)
- *size = offset;
- else
- *size = read_size;
+ if (offset >= read_size)
+ *size = offset;
+ else
+ *size = read_size;
- app->offset += *size;
+ app->offset += *size;
}
/**
- * Extract Input data for AAC decoder
- * (case of (LC profile) ADTS format)
- * codec_data : Don't need
- **/
+ * Extract Input data for AAC decoder
+ * (case of (LC profile) ADTS format)
+ * codec_data : Don't need
+ **/
void aacdec_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int read_size;
- int offset = app->length - app->offset;
- unsigned char *pData = app->data + app->offset;
+ int read_size;
+ int offset = app->length - app->offset;
+ unsigned char *pData = app->data + app->offset;
- if ((pData != NULL) && (pData[0] == 0xff) && ((pData[1] & 0xf6) == 0xf0)) {
- read_size = ((pData[3] & 0x03) << 11) | (pData[4] << 3) | ((pData[5] & 0xe0) >> 5);
- } else {
- read_size = 0;
- g_print("[FAIL] Not found aac frame sync.....\n");
- }
+ if ((pData != NULL) && (pData[0] == 0xff) && ((pData[1] & 0xf6) == 0xf0)) {
+ read_size = ((pData[3] & 0x03) << 11) | (pData[4] << 3) | ((pData[5] & 0xe0) >> 5);
+ } else {
+ read_size = 0;
+ g_print("[FAIL] Not found aac frame sync.....\n");
+ }
- *have_frame = TRUE;
- *data = app->data + app->offset;
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- if (read_size >= offset)
- *size = offset;
- else
- *size = read_size;
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
- app->offset += *size;
+ app->offset += *size;
}
void mp3dec_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int read_size;
- guint header;
- guint padding, bitrate, lsf, layer, mpg25;
- guint hdr_bitrate, sf;
- int offset = app->length - app->offset;
- unsigned char *pData = app->data + app->offset;
-
- header = GST_READ_UINT32_BE(pData);
-
-
- if (header == 0) {
- g_print ("[ERROR] read header size is 0\n");
- *have_frame = FALSE;
- }
-
- /* if it's not a valid sync */
- if ((header & 0xffe00000) != 0xffe00000) {
- g_print ("[ERROR] invalid sync\n");
- *have_frame = FALSE;
- }
-
- if (((header >> 19) & 3) == 0x1) {
- g_print ("[ERROR] invalid MPEG version: %d\n", (header >> 19) & 3);
- *have_frame = FALSE;
- } else {
- if (header & (1 << 20)) {
- lsf = (header & (1 << 19)) ? 0 : 1;
- mpg25 = 0;
- } else {
- lsf = 1;
- mpg25 = 1;
- }
- }
-
- /* if it's an invalid layer */
- if (!((header >> 17) & 3)) {
- g_print("[ERROR] invalid layer: %d\n", (header >> 17) & 3);
- *have_frame = FALSE;
- } else {
- layer = 4 - ((header >> 17) & 0x3);
- }
-
- /* if it's an invalid bitrate */
- if (((header >> 12) & 0xf) == 0xf) {
- g_print ("[ERROR] invalid bitrate: %d\n", (header >> 12) & 0xf);
- *have_frame = FALSE;
- } else {
- bitrate = (header >> 12) & 0xF;
- hdr_bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
- /* The caller has ensured we have a valid header, so bitrate can't be zero here. */
- if(hdr_bitrate == 0)
- *have_frame = FALSE;
- }
-
- /* if it's an invalid samplerate */
- if (((header >> 10) & 0x3) == 0x3) {
- g_print ("[ERROR] invalid samplerate: %d\n", (header >> 10) & 0x3);
- *have_frame = FALSE;
- } else {
- sf = (header >> 10) & 0x3;
- sf = mp3types_freqs[lsf + mpg25][sf];
- }
-
- padding = (header >> 9) & 0x1;
-
- switch (layer) {
- case 1:
- read_size = 4 * ((hdr_bitrate * 12) / sf + padding);
- break;
- case 2:
- read_size = (hdr_bitrate * 144) / sf + padding;
- break;
- default:
- case 3:
- read_size = (hdr_bitrate * 144) / (sf << lsf) + padding;
- break;
- }
- g_print("header : %d, read : %d\n", header, read_size);
-
- *have_frame = TRUE;
- *data = app->data + app->offset;
-
- if (read_size >= offset)
- *size = offset;
- else
- *size = read_size;
-
- app->offset += *size;
+ int read_size;
+ guint header;
+ guint padding, bitrate, lsf, layer, mpg25;
+ guint hdr_bitrate, sf;
+ int offset = app->length - app->offset;
+ unsigned char *pData = app->data + app->offset;
+
+ header = GST_READ_UINT32_BE(pData);
+
+
+ if (header == 0) {
+ g_print ("[ERROR] read header size is 0\n");
+ *have_frame = FALSE;
+ }
+
+ /* if it's not a valid sync */
+ if ((header & 0xffe00000) != 0xffe00000) {
+ g_print ("[ERROR] invalid sync\n");
+ *have_frame = FALSE;
+ }
+
+ if (((header >> 19) & 3) == 0x1) {
+ g_print ("[ERROR] invalid MPEG version: %d\n", (header >> 19) & 3);
+ *have_frame = FALSE;
+ } else {
+ if (header & (1 << 20)) {
+ lsf = (header & (1 << 19)) ? 0 : 1;
+ mpg25 = 0;
+ } else {
+ lsf = 1;
+ mpg25 = 1;
+ }
+ }
+
+ /* if it's an invalid layer */
+ if (!((header >> 17) & 3)) {
+ g_print("[ERROR] invalid layer: %d\n", (header >> 17) & 3);
+ *have_frame = FALSE;
+ } else {
+ layer = 4 - ((header >> 17) & 0x3);
+ }
+
+ /* if it's an invalid bitrate */
+ if (((header >> 12) & 0xf) == 0xf) {
+ g_print ("[ERROR] invalid bitrate: %d\n", (header >> 12) & 0xf);
+ *have_frame = FALSE;
+ } else {
+ bitrate = (header >> 12) & 0xF;
+ hdr_bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
+ /* The caller has ensured we have a valid header, so bitrate can't be zero here. */
+ if(hdr_bitrate == 0)
+ *have_frame = FALSE;
+ }
+
+ /* if it's an invalid samplerate */
+ if (((header >> 10) & 0x3) == 0x3) {
+ g_print ("[ERROR] invalid samplerate: %d\n", (header >> 10) & 0x3);
+ *have_frame = FALSE;
+ } else {
+ sf = (header >> 10) & 0x3;
+ sf = mp3types_freqs[lsf + mpg25][sf];
+ }
+
+ padding = (header >> 9) & 0x1;
+
+ switch (layer) {
+ case 1:
+ read_size = 4 * ((hdr_bitrate * 12) / sf + padding);
+ break;
+ case 2:
+ read_size = (hdr_bitrate * 144) / sf + padding;
+ break;
+ default:
+ case 3:
+ read_size = (hdr_bitrate * 144) / (sf << lsf) + padding;
+ break;
+ }
+ g_print("header : %d, read : %d\n", header, read_size);
+
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
+
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
+
+ app->offset += *size;
}
#if 0
void extract_input_aacdec_m4a_test(App *app, unsigned char* data, int *size, bool *have_frame)
{
- int readsize = 0;
- size_t result;
- unsigned int header_size = ADTS_HEADER_SIZE;
- unsigned char buffer[1000000];
- unsigned char codecdata[AAC_CODECDATA_SIZE] = {0,};
-
- /*
- * It is not support full parsing MP4 container box.
- * So It MUST start as RAW valid frame sequence.
- * Testsuit that are not guaranteed to be available on functionality of all General DEMUXER/PARSER.
- */
-
- if (feof(fd))
- return 0;
-
- if (frame_count == 0)
- {
- /*
- * CAUTION : Codec data is needed only once in first time
- * Codec data is made(or extracted) by MP4 demuxer in 'esds' box.
- * So I use this data (byte) as hard coding for temporary our testing.
- */
+ int readsize = 0;
+ size_t result;
+ unsigned int header_size = ADTS_HEADER_SIZE;
+ unsigned char buffer[1000000];
+ unsigned char codecdata[AAC_CODECDATA_SIZE] = {0,};
+
+ /*
+ * It is not support full parsing MP4 container box.
+ * So It MUST start as RAW valid frame sequence.
+ * Testsuit that are not guaranteed to be available on functionality of all General DEMUXER/PARSER.
+ */
+
+ if (feof(fd))
+ return 0;
+
+ if (frame_count == 0)
+ {
+ /*
+ * CAUTION : Codec data is needed only once in first time
+ * Codec data is made(or extracted) by MP4 demuxer in 'esds' box.
+ * So I use this data (byte) as hard coding for temporary our testing.
+ */
#if 1
- /*
- * The codec_data data is according to AudioSpecificConfig,
- * ISO/IEC 14496-3, 1.6.2.1
- *
- * below example is test for using "test.aac" or "TestSample-AAC-LC.m4a"
- * case : M4A - LC profile
- * codec_data=(buffer)119056e5000000000000000000000000
- * savs aac decoder get codec_data. size: 16 (Tag size : 5 byte)
- * - codec data: profile : 2
- * - codec data: samplrate: 48000
- * - codec data: channels : 2
- */
- /* 2 bytes are mandatory */
- codecdata[0] = 0x11; //ex) (5bit) 2 (LC) / (4bit) 3 (48khz)
- codecdata[1] = 0x90; //ex) (4bit) 2 (2ch)
- /* othter bytes are (optional) epconfig information */
- codecdata[2] = 0x56;
- codecdata[3] = 0xE5;
- codecdata[4] = 0x00;
+ /*
+ * The codec_data data is according to AudioSpecificConfig,
+ * ISO/IEC 14496-3, 1.6.2.1
+ *
+ * below example is test for using "test.aac" or "TestSample-AAC-LC.m4a"
+ * case : M4A - LC profile
+ * codec_data=(buffer)119056e5000000000000000000000000
+ * savs aac decoder get codec_data. size: 16 (Tag size : 5 byte)
+ * - codec data: profile : 2
+ * - codec data: samplrate: 48000
+ * - codec data: channels : 2
+ */
+ /* 2 bytes are mandatory */
+ codecdata[0] = 0x11; //ex) (5bit) 2 (LC) / (4bit) 3 (48khz)
+ codecdata[1] = 0x90; //ex) (4bit) 2 (2ch)
+ /* othter bytes are (optional) epconfig information */
+ codecdata[2] = 0x56;
+ codecdata[3] = 0xE5;
+ codecdata[4] = 0x00;
#else
- /*
- * below example is test for using "TestSample-EAAC+.m4a"
- *
- * case : M4A - HE-AAC v1 and v2 profile
- * codec_data=(buffer)138856e5a54880000000000000000000
- * savs aac decoder get codec_data. size: 16 (Tag size : 7 byte)
- * - codec data: profile : 2
- * - codec data: samplrate: 22050
- * - codec data: channels : 1
- */
- /* 2 bytes are mandatory */
- codecdata[0] = 0x13; //ex) (5bit) 2 (LC) / (4bit) 9 (22khz)
- codecdata[1] = 0x88; //ex) (4bit) 1 (1ch)
- /* othter bytes are (optional) epconfig information */
- codecdata[2] = 0x56;
- codecdata[3] = 0xE5;
- codecdata[4] = 0xA5;
- codecdata[5] = 0x48;
- codecdata[6] = 0x80;
+ /*
+ * below example is test for using "TestSample-EAAC+.m4a"
+ *
+ * case : M4A - HE-AAC v1 and v2 profile
+ * codec_data=(buffer)138856e5a54880000000000000000000
+ * savs aac decoder get codec_data. size: 16 (Tag size : 7 byte)
+ * - codec data: profile : 2
+ * - codec data: samplrate: 22050
+ * - codec data: channels : 1
+ */
+ /* 2 bytes are mandatory */
+ codecdata[0] = 0x13; //ex) (5bit) 2 (LC) / (4bit) 9 (22khz)
+ codecdata[1] = 0x88; //ex) (4bit) 1 (1ch)
+ /* othter bytes are (optional) epconfig information */
+ codecdata[2] = 0x56;
+ codecdata[3] = 0xE5;
+ codecdata[4] = 0xA5;
+ codecdata[5] = 0x48;
+ codecdata[6] = 0x80;
#endif
- memcpy(aacdata, codecdata, AAC_CODECDATA_SIZE);
-
- result = fread(buffer, 1, header_size, fd); //adts header
- if(result != header_size)
- {
- return -1;
- }
-
- if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
- readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
- readsize = readsize -header_size;
- result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
- memcpy(aacdata+AAC_CODECDATA_SIZE, buffer, readsize);
- }
-
- g_print( "[example] Insert 'codec_data' in 1st frame buffer size (%d)\n", readsize+AAC_CODECDATA_SIZE);
- return (readsize + AAC_CODECDATA_SIZE); //return combination of (codec_data + raw_data)
- }
-
- result = fread(buffer, 1, header_size, fd); //adts header
- if(result != header_size)
- {
- exit(1);
- }
-
- if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
- readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
- readsize = readsize -header_size;
- result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
- memcpy(aacdata, buffer, readsize);
- } else {
- readsize = 0;
- g_print("[FAIL] Not found aac frame sync.....\n");
- }
-
- return readsize; //return only raw_data
+ memcpy(aacdata, codecdata, AAC_CODECDATA_SIZE);
+
+ result = fread(buffer, 1, header_size, fd); //adts header
+ if(result != header_size)
+ {
+ return -1;
+ }
+
+ if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
+ readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
+ readsize = readsize -header_size;
+ result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
+ memcpy(aacdata+AAC_CODECDATA_SIZE, buffer, readsize);
+ }
+
+ g_print( "[example] Insert 'codec_data' in 1st frame buffer size (%d)\n", readsize+AAC_CODECDATA_SIZE);
+ return (readsize + AAC_CODECDATA_SIZE); //return combination of (codec_data + raw_data)
+ }
+
+ result = fread(buffer, 1, header_size, fd); //adts header
+ if(result != header_size)
+ {
+ exit(1);
+ }
+
+ if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
+ readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
+ readsize = readsize -header_size;
+ result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
+ memcpy(aacdata, buffer, readsize);
+ } else {
+ readsize = 0;
+ g_print("[FAIL] Not found aac frame sync.....\n");
+ }
+
+ return readsize; //return only raw_data
}
#endif
/**
- * Extract Input data for AAC encoder
- **/
+ * Extract Input data for AAC encoder
+ **/
/*
-void aacenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
-{
- int read_size;
- int offset = app->length - app->offset;
+ void aacenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
+ {
+ int read_size;
+ int offset = app->length - app->offset;
- read_size = ((DEFAULT_SAMPLEBYTE*DEFAULT_CHANNEL)*(DEFAULT_BIT/8));
+ read_size = ((DEFAULT_SAMPLEBYTE*DEFAULT_CHANNEL)*(DEFAULT_BIT/8));
- if (read_size >= offset)
- *size = offset;
+ if (read_size >= offset)
+ *size = offset;
- *have_frame = TRUE;
- *data = app->data + app->offset;
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- if (read_size >= offset)
- *size = offset;
- else
- *size = read_size;
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
- app->offset += *size;
-}
-*/
+ app->offset += *size;
+ }
+ */
static void _mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
{
- if (pkt != NULL)
- {
- g_print("Used input buffer = %p\n", pkt);
- media_packet_destroy(pkt);
- }
- return;
+ if (pkt != NULL)
+ {
+ g_print("Used input buffer = %p\n", pkt);
+ media_packet_destroy(pkt);
+ }
+ return;
}
int _mediacodec_set_codec(int codecid, int flag, int *hardware)
{
- bool encoder;
- //bool hardware;
- media_format_mimetype_e mime;
- encoder = GET_IS_ENCODER(flag) ? 1 : 0;
- *hardware = GET_IS_HW(flag) ? 1 : 0;
-
- switch (codecid) {
- case MEDIACODEC_H264:
- if (encoder) {
- extractor = yuv_extractor;
- mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
- } else {
- extractor = h264_extractor;
- mime = MEDIA_FORMAT_H264_SP;
- }
- break;
- case MEDIACODEC_MPEG4:
- if (encoder) {
- extractor = yuv_extractor;
- mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
- } else {
- extractor = h264_extractor;
- mime = MEDIA_FORMAT_MPEG4_SP;
- }
- break;
- case MEDIACODEC_H263:
- if (encoder) {
- extractor = yuv_extractor;
- mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
- } else {
- extractor = h264_extractor;
- mime = MEDIA_FORMAT_H263P;
- }
- break;
- case MEDIACODEC_AAC:
- if (encoder) {
- extractor = aacenc_extractor;
- mime = MEDIA_FORMAT_PCM;
- } else {
- extractor = aacdec_extractor;
- mime = MEDIA_FORMAT_AAC;
- }
- break;
- case MEDIACODEC_AAC_HE:
- if (encoder) {
- extractor = aacenc_extractor;
- mime = MEDIA_FORMAT_PCM;
- } else {
- //extractor = aacdec_extractor;
- mime = MEDIA_FORMAT_AAC_HE;
- }
- break;
- case MEDIACODEC_AAC_HE_PS:
- break;
- case MEDIACODEC_MP3:
- extractor = mp3dec_extractor;
- mime = MEDIA_FORMAT_MP3;
- break;
- case MEDIACODEC_VORBIS:
- break;
- case MEDIACODEC_FLAC:
- break;
- case MEDIACODEC_WMAV1:
- break;
- case MEDIACODEC_WMAV2:
- break;
- case MEDIACODEC_WMAPRO:
- break;
- case MEDIACODEC_WMALSL:
- break;
- default:
- LOGE("NOT SUPPORTED!!!!");
- break;
- }
- //media_format_set_video_mime(vdec_fmt, mime);
- return mime;
+ bool encoder;
+ //bool hardware;
+ media_format_mimetype_e mime;
+ encoder = GET_IS_ENCODER(flag) ? 1 : 0;
+ *hardware = GET_IS_HW(flag) ? 1 : 0;
+
+ switch (codecid) {
+ case MEDIACODEC_H264:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_H264_SP;
+ }
+ break;
+ case MEDIACODEC_MPEG4:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_MPEG4_SP;
+ }
+ break;
+ case MEDIACODEC_H263:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_H263P;
+ }
+ break;
+ case MEDIACODEC_AAC:
+ if (encoder) {
+ extractor = aacenc_extractor;
+ mime = MEDIA_FORMAT_PCM;
+ } else {
+ extractor = aacdec_extractor;
+ mime = MEDIA_FORMAT_AAC;
+ }
+ break;
+ case MEDIACODEC_AAC_HE:
+ if (encoder) {
+ extractor = aacenc_extractor;
+ mime = MEDIA_FORMAT_PCM;
+ } else {
+ //extractor = aacdec_extractor;
+ mime = MEDIA_FORMAT_AAC_HE;
+ }
+ break;
+ case MEDIACODEC_AAC_HE_PS:
+ break;
+ case MEDIACODEC_MP3:
+ extractor = mp3dec_extractor;
+ mime = MEDIA_FORMAT_MP3;
+ break;
+ case MEDIACODEC_VORBIS:
+ break;
+ case MEDIACODEC_FLAC:
+ break;
+ case MEDIACODEC_WMAV1:
+ break;
+ case MEDIACODEC_WMAV2:
+ break;
+ case MEDIACODEC_WMAPRO:
+ break;
+ case MEDIACODEC_WMALSL:
+ break;
+ default:
+ LOGE("NOT SUPPORTED!!!!");
+ break;
+ }
+ //media_format_set_video_mime(vdec_fmt, mime);
+ return mime;
}
static gboolean read_data(App *app)
{
- guint len;
- bool have_frame = FALSE;
- int ret;
- static guint64 pts = 0L;
- void *buf_data_ptr = NULL;
- media_packet_h pkt = NULL;
- unsigned char *tmp;
- int read;
- int plane_num;
- int offset;
- int stride_width, stride_height;
-
- g_print("----------read data------------\n");
- //read = extractor(app, app->data + app->offset, app->length - app->offset );
- extractor(app, &tmp, &read, &have_frame);
-
- if ( app->offset >= app->length - 1 ) {
- /* EOS */
- //media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
- g_print("EOS\n");
- app->finish = clock();
- g_main_loop_quit (app->loop);
- return FALSE;
- }
- g_print("length : %d, offset : %d\n", app->length, app->offset);
-
- if ( app->offset + len > app->length )
- len = app->length - app->offset;
-
- g_print("%p, %d, have_frame :%d, read: %d\n", tmp, (int)read, have_frame, read);
-
- if (have_frame) {
- if (media_packet_create_alloc(vdec_fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) {
- fprintf(stderr, "media_packet_create_alloc failed\n");
- return FALSE;
- }
-
- if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) {
- fprintf(stderr, "media_packet_set_pts failed\n");
- return FALSE;
- }
-
- if (app->type != VIDEO_ENC) {
- media_packet_get_buffer_data_ptr(pkt, &buf_data_ptr);
- media_packet_set_buffer_size(pkt, (uint64_t)read);
-
- memcpy(buf_data_ptr, tmp, read);
- g_print("tmp:%p, read:%d\n",tmp, read);
- } else {
- /* Y */
- media_packet_get_video_plane_data_ptr(pkt, 0, &buf_data_ptr);
- media_packet_get_video_stride_width(pkt, 0, &stride_width);
- media_packet_get_video_stride_height(pkt, 0, &stride_height);
-
- offset = stride_width*stride_height;
-
- memcpy(buf_data_ptr, tmp, offset);
-
- /* UV or U*/
- media_packet_get_video_plane_data_ptr(pkt, 1, &buf_data_ptr);
- media_packet_get_video_stride_width(pkt, 1, &stride_width);
- media_packet_get_video_stride_height(pkt, 1, &stride_height);
- memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
-
- if (app->hardware == FALSE) {
- /* V */
- media_packet_get_video_plane_data_ptr(pkt, 2, &buf_data_ptr);
- media_packet_get_video_stride_width(pkt, 2, &stride_width);
- media_packet_get_video_stride_height(pkt, 2, &stride_height);
-
- offset += stride_width * stride_height;
-
-
- memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
- }
- }
- mc_hex_dump("inbuf", tmp, 48);
-
- ret = mediacodec_process_input(app->mc_handle[0], pkt, 0);
- if(ret != MEDIACODEC_ERROR_NONE) {
- return FALSE;
- }
- pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
- }
- //app->offset += read;
-
- return TRUE;
+ guint len;
+ bool have_frame = FALSE;
+ int ret;
+ static guint64 pts = 0L;
+ void *buf_data_ptr = NULL;
+ media_packet_h pkt = NULL;
+ unsigned char *tmp;
+ int read;
+ int plane_num;
+ int offset;
+ int stride_width, stride_height;
+
+ g_print("----------read data------------\n");
+ //read = extractor(app, app->data + app->offset, app->length - app->offset );
+ extractor(app, &tmp, &read, &have_frame);
+
+ if ( app->offset >= app->length - 1 ) {
+ /* EOS */
+ //media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
+ g_print("EOS\n");
+ app->finish = clock();
+ g_main_loop_quit (app->loop);
+ return FALSE;
+ }
+ g_print("length : %d, offset : %d\n", app->length, app->offset);
+
+ if ( app->offset + len > app->length )
+ len = app->length - app->offset;
+
+ g_print("%p, %d, have_frame :%d, read: %d\n", tmp, (int)read, have_frame, read);
+
+ if (have_frame) {
+ if (media_packet_create_alloc(vdec_fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) {
+ fprintf(stderr, "media_packet_create_alloc failed\n");
+ return FALSE;
+ }
+
+ if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) {
+ fprintf(stderr, "media_packet_set_pts failed\n");
+ return FALSE;
+ }
+
+ if (app->type != VIDEO_ENC) {
+ media_packet_get_buffer_data_ptr(pkt, &buf_data_ptr);
+ media_packet_set_buffer_size(pkt, (uint64_t)read);
+
+ memcpy(buf_data_ptr, tmp, read);
+ g_print("tmp:%p, read:%d\n",tmp, read);
+ } else {
+ /* Y */
+ media_packet_get_video_plane_data_ptr(pkt, 0, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ media_packet_get_video_stride_height(pkt, 0, &stride_height);
+
+ offset = stride_width*stride_height;
+
+ memcpy(buf_data_ptr, tmp, offset);
+
+ /* UV or U*/
+ media_packet_get_video_plane_data_ptr(pkt, 1, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ media_packet_get_video_stride_height(pkt, 1, &stride_height);
+ memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
+
+ if (app->hardware == FALSE) {
+ /* V */
+ media_packet_get_video_plane_data_ptr(pkt, 2, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 2, &stride_width);
+ media_packet_get_video_stride_height(pkt, 2, &stride_height);
+
+ offset += stride_width * stride_height;
+
+
+ memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
+ }
+ }
+ mc_hex_dump("inbuf", tmp, 48);
+
+ ret = mediacodec_process_input(app->mc_handle[0], pkt, 0);
+ if(ret != MEDIACODEC_ERROR_NONE) {
+ return FALSE;
+ }
+ pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
+ }
+ //app->offset += read;
+
+ return TRUE;
}
static void start_feed(App *app)
{
- if (app->sourceid == 0) {
- //start feeding
- app->sourceid = g_idle_add((GSourceFunc)read_data, app);
- g_print("start_feed\n");
- }
+ if (app->sourceid == 0) {
+ //start feeding
+ app->sourceid = g_idle_add((GSourceFunc)read_data, app);
+ g_print("start_feed\n");
+ }
}
static void stop_feed(App *app)
{
- if (app->sourceid != 0) {
- //stop feeding
- g_source_remove(app->sourceid);
- app->sourceid = 0;
- g_print("stop_feed\n");
- }
+ if (app->sourceid != 0) {
+ //stop feeding
+ g_source_remove(app->sourceid);
+ app->sourceid = 0;
+ g_print("stop_feed\n");
+ }
}
static bool _mediacodec_inbuf_used_cb(media_packet_h pkt, void *user_data)
{
- g_print("_mediacodec_inbuf_used_cb!!!\n");
- media_packet_destroy(pkt);
- return TRUE;
+ g_print("_mediacodec_inbuf_used_cb!!!\n");
+ media_packet_destroy(pkt);
+ return TRUE;
}
static bool _mediacodec_outbuf_available_cb(media_packet_h pkt, void *user_data)
{
- media_packet_h out_pkt = NULL;
- int ret;
+ media_packet_h out_pkt = NULL;
+ int ret;
- App *app = (App*)user_data;
+ App *app = (App*)user_data;
- g_print("_mediacodec_outbuf_available_cb\n");
+ g_print("_mediacodec_outbuf_available_cb\n");
- g_mutex_lock(&app->lock);
+ g_mutex_lock(&app->lock);
- ret = mediacodec_get_output(app->mc_handle[0], &out_pkt, 0);
- if (ret != MEDIACODEC_ERROR_NONE) {
- g_print("get_output failed\n");
- }
- decoder_output_dump(app, out_pkt);
+ ret = mediacodec_get_output(app->mc_handle[0], &out_pkt, 0);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("get_output failed\n");
+ }
+ decoder_output_dump(app, out_pkt);
#if DUMP_OUTBUF
- void *data;
- uint64_t buf_size;
- int stride_width, stride_height;
+ void *data;
+ uint64_t buf_size;
+ int stride_width, stride_height;
- media_packet_get_buffer_data_ptr(out_pkt, &data);
- media_packet_get_buffer_size(out_pkt, &buf_size);
- g_print("output data : %p, size %d\n",data, (int)buf_size);
+ media_packet_get_buffer_data_ptr(out_pkt, &data);
+ media_packet_get_buffer_size(out_pkt, &buf_size);
+ g_print("output data : %p, size %d\n",data, (int)buf_size);
- fwrite(data, 1, buf_size, fp_out);
+ fwrite(data, 1, buf_size, fp_out);
#endif
- app->frame_count++;
+ app->frame_count++;
- g_mutex_unlock(&app->lock);
+ g_mutex_unlock(&app->lock);
- media_packet_destroy(out_pkt);
- out_pkt = NULL;
- g_print("done\n");
+ media_packet_destroy(out_pkt);
+ out_pkt = NULL;
+ g_print("done\n");
- return TRUE;
+ return TRUE;
}
static bool _mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
{
- g_print("_mediacodec_buffer_status_cb %d\n", status);
+ g_print("_mediacodec_buffer_status_cb %d\n", status);
- App *app = (App*)user_data;
+ App *app = (App*)user_data;
- if (status == MEDIACODEC_NEED_DATA) {
- start_feed(app);
- } else if (status == MEDIACODEC_ENOUGH_DATA ){
- stop_feed(app);
- }
- return TRUE;
+ if (status == MEDIACODEC_NEED_DATA) {
+ start_feed(app);
+ } else if (status == MEDIACODEC_ENOUGH_DATA ){
+ stop_feed(app);
+ }
+ return TRUE;
}
static bool _mediacodec_error_cb(mediacodec_error_e error, void *user_data)
{
- return TRUE;
+ return TRUE;
}
static bool _mediacodec_eos_cb(void *user_data)
{
- return TRUE;
+ return TRUE;
}
static void _mediacodec_prepare(App *app)
{
- int ret;
- media_format_mimetype_e mime;
+ int ret;
+ media_format_mimetype_e mime;
#if DUMP_OUTBUF
- fp_out = fopen("/tmp/codec_dump.out", "wb");
+ fp_out = fopen("/tmp/codec_dump.out", "wb");
#endif
- /* create instance */
- ret = mediacodec_create(&app->mc_handle[0]);
- if (ret != MEDIACODEC_ERROR_NONE) {
- g_print("mediacodec_create failed\n");
- return;
- }
-
- /* set codec */
- ret = mediacodec_set_codec(app->mc_handle[0], app->codecid, app->flag);
- if (ret != MEDIACODEC_ERROR_NONE) {
- g_print("mediacodec_set_codec failed\n");
- return;
- }
-
-
- app->mime = _mediacodec_set_codec(app->codecid, app->flag, &app->hardware);
-
- /* set codec info */
- ret = media_format_create(&vdec_fmt);
-
- switch (app->type) {
- case VIDEO_DEC:
- ret = mediacodec_set_vdec_info(app->mc_handle[0], app->width, app->height);
- media_format_set_video_mime(vdec_fmt, app->mime);
- media_format_set_video_width(vdec_fmt, app->width);
- media_format_set_video_height(vdec_fmt, app->height);
- break;
- case VIDEO_ENC:
- ret = mediacodec_set_venc_info(app->mc_handle[0], app->width, app->height, app->fps, app->target_bits);
- media_format_set_video_mime(vdec_fmt, app->mime);
- media_format_set_video_width(vdec_fmt, app->width);
- media_format_set_video_height(vdec_fmt, app->height);
- media_format_set_video_avg_bps(vdec_fmt, app->target_bits);
- break;
- case AUDIO_DEC:
- ret = mediacodec_set_adec_info(app->mc_handle[0], app->samplerate, app->channel, app->bit);
- media_format_set_audio_mime(vdec_fmt, app->mime);
- media_format_set_audio_channel(vdec_fmt, app->channel);
- media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
- media_format_set_audio_bit(vdec_fmt, app->bit);
- break;
- case AUDIO_ENC:
- ret = mediacodec_set_aenc_info(app->mc_handle[0], app->samplerate, app->channel, app->bit, app->bitrate);
- media_format_set_audio_mime(vdec_fmt, app->mime);
- media_format_set_audio_channel(vdec_fmt, app->channel);
- media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
- media_format_set_audio_bit(vdec_fmt, app->bit);
- break;
- default:
- g_print("invaild type\n");
- break;
- }
- if (ret != MEDIACODEC_ERROR_NONE) {
- g_print("mediacodec_set_xxxc(%d)_info failed\n", app->type);
- return;
- }
-
-
- /* set callback */
- mediacodec_set_input_buffer_used_cb(app->mc_handle[0], _mediacodec_inbuf_used_cb, NULL);
- mediacodec_set_output_buffer_available_cb(app->mc_handle[0], _mediacodec_outbuf_available_cb, app);
- mediacodec_set_buffer_status_cb(app->mc_handle[0], _mediacodec_buffer_status_cb, app);
- mediacodec_set_eos_cb(app->mc_handle[0],_mediacodec_eos_cb, NULL);
- mediacodec_set_error_cb(app->mc_handle[0], _mediacodec_error_cb, NULL);
-
-
- /* prepare */
- ret = mediacodec_prepare(app->mc_handle[0]);
- if (ret != MEDIACODEC_ERROR_NONE) {
- g_print("mediacodec_prepare failed\n");
- return;
- }
-
- app->frame_count = 0;
- app->start = clock();
- g_main_loop_run(app->loop);
-
- g_print("Average FPS = %3.3f\n", ((double)app->frame_count*1000000/(app->finish - app->start)));
-
- g_print("---------------------------\n");
-
-
- return;
+ /* create instance */
+ ret = mediacodec_create(&app->mc_handle[0]);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_create failed\n");
+ return;
+ }
+
+ /* set codec */
+ ret = mediacodec_set_codec(app->mc_handle[0], app->codecid, app->flag);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_set_codec failed\n");
+ return;
+ }
+
+
+ app->mime = _mediacodec_set_codec(app->codecid, app->flag, &app->hardware);
+
+ /* set codec info */
+ ret = media_format_create(&vdec_fmt);
+
+ switch (app->type) {
+ case VIDEO_DEC:
+ ret = mediacodec_set_vdec_info(app->mc_handle[0], app->width, app->height);
+ media_format_set_video_mime(vdec_fmt, app->mime);
+ media_format_set_video_width(vdec_fmt, app->width);
+ media_format_set_video_height(vdec_fmt, app->height);
+ break;
+ case VIDEO_ENC:
+ ret = mediacodec_set_venc_info(app->mc_handle[0], app->width, app->height, app->fps, app->target_bits);
+ media_format_set_video_mime(vdec_fmt, app->mime);
+ media_format_set_video_width(vdec_fmt, app->width);
+ media_format_set_video_height(vdec_fmt, app->height);
+ media_format_set_video_avg_bps(vdec_fmt, app->target_bits);
+ break;
+ case AUDIO_DEC:
+ ret = mediacodec_set_adec_info(app->mc_handle[0], app->samplerate, app->channel, app->bit);
+ media_format_set_audio_mime(vdec_fmt, app->mime);
+ media_format_set_audio_channel(vdec_fmt, app->channel);
+ media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
+ media_format_set_audio_bit(vdec_fmt, app->bit);
+ break;
+ case AUDIO_ENC:
+ ret = mediacodec_set_aenc_info(app->mc_handle[0], app->samplerate, app->channel, app->bit, app->bitrate);
+ media_format_set_audio_mime(vdec_fmt, app->mime);
+ media_format_set_audio_channel(vdec_fmt, app->channel);
+ media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
+ media_format_set_audio_bit(vdec_fmt, app->bit);
+ break;
+ default:
+ g_print("invaild type\n");
+ break;
+ }
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_set_xxxc(%d)_info failed\n", app->type);
+ return;
+ }
+
+
+ /* set callback */
+ mediacodec_set_input_buffer_used_cb(app->mc_handle[0], _mediacodec_inbuf_used_cb, NULL);
+ mediacodec_set_output_buffer_available_cb(app->mc_handle[0], _mediacodec_outbuf_available_cb, app);
+ mediacodec_set_buffer_status_cb(app->mc_handle[0], _mediacodec_buffer_status_cb, app);
+ mediacodec_set_eos_cb(app->mc_handle[0],_mediacodec_eos_cb, NULL);
+ mediacodec_set_error_cb(app->mc_handle[0], _mediacodec_error_cb, NULL);
+
+
+ /* prepare */
+ ret = mediacodec_prepare(app->mc_handle[0]);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_prepare failed\n");
+ return;
+ }
+
+ app->frame_count = 0;
+ app->start = clock();
+ g_main_loop_run(app->loop);
+
+ g_print("Average FPS = %3.3f\n", ((double)app->frame_count*1000000/(app->finish - app->start)));
+
+ g_print("---------------------------\n");
+
+
+ return;
}
/**
*
*
-* @param filename
-*/
+ * @param filename
+ */
static void input_filepath(char *filename, App *app)
{
- GError *error = NULL;
-
- app->obj++;
- app->file = g_mapped_file_new (filename, FALSE, &error);
- if (error) {
- g_print ("failed to open file : %s\n", error->message);
- g_error_free(error);
- return -1;
- }
-
- app->length = g_mapped_file_get_length (app->file);
- app->data = (guint8 *) g_mapped_file_get_contents (app->file);
- app->offset = 0;
- g_print("len : %d, offset : %d, obj : %d", app->length, (int)app->offset, app->obj);
-
-/*
- if ( mediacodec_create(&app->mc_handle[app->obj]) != MEDIACODEC_ERROR_NONE) {
- g_print("mediacodec_create failed\n");
- }
-*/
+ GError *error = NULL;
+
+ app->obj++;
+ app->file = g_mapped_file_new (filename, FALSE, &error);
+ if (error) {
+ g_print ("failed to open file : %s\n", error->message);
+ g_error_free(error);
+ return -1;
+ }
+
+ app->length = g_mapped_file_get_length (app->file);
+ app->data = (guint8 *) g_mapped_file_get_contents (app->file);
+ app->offset = 0;
+ g_print("len : %d, offset : %d, obj : %d", app->length, (int)app->offset, app->obj);
+
+ /*
+ if ( mediacodec_create(&app->mc_handle[app->obj]) != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_create failed\n");
+ }
+ */
#if 0
- if(len < 0 || len > MAX_STRING_LEN)
- return;
-
- for(i = 0; i < g_handle_num; i++)
- {
- if(g_media_codec[i] != NULL)
- {
- mediacodec_unprepare(g_media_codec[i]);
- mediacodec_destroy(g_media_codec[i]);
- g_media_codec[i] = NULL;
- }
-
- if (mediacodec_create(&g_media_codec[i]) != MEDIACODEC_ERROR_NONE)
- {
- g_print("mediacodec create is failed\n");
- }
- }
- //input_fmt = (media_format_s *) malloc(sizeof(media_format_s));
- //memset(input_fmt, 0, sizeof(media_format_s));
- media_format_create(&input_fmt);
+ if(len < 0 || len > MAX_STRING_LEN)
+ return;
+
+ for(i = 0; i < g_handle_num; i++)
+ {
+ if(g_media_codec[i] != NULL)
+ {
+ mediacodec_unprepare(g_media_codec[i]);
+ mediacodec_destroy(g_media_codec[i]);
+ g_media_codec[i] = NULL;
+ }
+
+ if (mediacodec_create(&g_media_codec[i]) != MEDIACODEC_ERROR_NONE)
+ {
+ g_print("mediacodec create is failed\n");
+ }
+ }
+ //input_fmt = (media_format_s *) malloc(sizeof(media_format_s));
+ //memset(input_fmt, 0, sizeof(media_format_s));
+ media_format_create(&input_fmt);
#if DUMP_OUTBUF
- fp_out = fopen("/opt/usr/media/codec_dump.out", "wb");
+ fp_out = fopen("/opt/usr/media/codec_dump.out", "wb");
#endif
- strncpy (g_uri, filename, len);
+ strncpy (g_uri, filename, len);
#endif
- return;
+ return;
}
void quit_program()
{
- //g_main_loop_quit (app->loop);
+ //g_main_loop_quit (app->loop);
#if DUMP_OUTBUF
- if (fp_out)
- fclose(fp_out);
+ if (fp_out)
+ fclose(fp_out);
#endif
}
void reset_menu_state()
{
- g_menu_state = CURRENT_STATUS_MAINMENU;
- return;
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+ return;
}
void _interpret_main_menu(char *cmd, App *app)
{
- int len = strlen(cmd);
- if (len == 1)
- {
- if (strncmp(cmd, "a", 1) == 0) {
- g_menu_state = CURRENT_STATUS_FILENAME;
- } else if (strncmp(cmd, "o", 1) == 0) {
- g_menu_state = CURRENT_STATUS_GET_OUTPUT;
- } else if (strncmp(cmd, "q", 1) == 0)
- {
- quit_program();
- //g_main_loop_quit (app->loop);
- } else {
- g_print("unknown menu \n");
- }
- } else if (len == 2) {
- if (strncmp(cmd, "pr", 2) == 0) {
- _mediacodec_prepare(app);
- } else if (strncmp(cmd, "sc", 2) == 0) {
- g_menu_state = CURRENT_STATUS_SET_CODEC;
- } else if (strncmp(cmd, "vd", 2) == 0) {
- g_menu_state = CURRENT_STATUS_SET_VDEC_INFO;
- } else if (strncmp(cmd, "ve", 2) == 0) {
- g_menu_state = CURRENT_STATUS_SET_VENC_INFO;
- } else if (strncmp(cmd, "ad", 2) == 0) {
- g_menu_state = CURRENT_STATUS_SET_ADEC_INFO;
- } else if (strncmp(cmd, "ae", 2) == 0) {
- g_menu_state = CURRENT_STATUS_SET_AENC_INFO;
- } else if (strncmp(cmd, "pi", 2) == 0) {
- g_menu_state = CURRENT_STATUS_PROCESS_INPUT;
- } else if (strncmp(cmd, "rb", 2) == 0) {
- //_mediacodec_reset_output_buffer();
- } else if (strncmp(cmd, "pa", 2) == 0) {
- //_mediacodec_process_all();
- } else if (strncmp(cmd, "un", 2) == 0) {
- //_mediacodec_unprepare();
- } else if (strncmp(cmd, "dt", 2) == 0) {
- //_mediacodec_destroy();
- } else {
- //g_print("unknown menu \n");
- display_sub_basic();
- }
- } else {
- g_print("unknown menu \n");
- }
-
- return;
+ int len = strlen(cmd);
+ if (len == 1)
+ {
+ if (strncmp(cmd, "a", 1) == 0) {
+ g_menu_state = CURRENT_STATUS_FILENAME;
+ } else if (strncmp(cmd, "o", 1) == 0) {
+ g_menu_state = CURRENT_STATUS_GET_OUTPUT;
+ } else if (strncmp(cmd, "q", 1) == 0)
+ {
+ quit_program();
+ //g_main_loop_quit (app->loop);
+ } else {
+ g_print("unknown menu \n");
+ }
+ } else if (len == 2) {
+ if (strncmp(cmd, "pr", 2) == 0) {
+ _mediacodec_prepare(app);
+ } else if (strncmp(cmd, "sc", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_SET_CODEC;
+ } else if (strncmp(cmd, "vd", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_SET_VDEC_INFO;
+ } else if (strncmp(cmd, "ve", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_SET_VENC_INFO;
+ } else if (strncmp(cmd, "ad", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_SET_ADEC_INFO;
+ } else if (strncmp(cmd, "ae", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_SET_AENC_INFO;
+ } else if (strncmp(cmd, "pi", 2) == 0) {
+ g_menu_state = CURRENT_STATUS_PROCESS_INPUT;
+ } else if (strncmp(cmd, "rb", 2) == 0) {
+ //_mediacodec_reset_output_buffer();
+ } else if (strncmp(cmd, "pa", 2) == 0) {
+ //_mediacodec_process_all();
+ } else if (strncmp(cmd, "un", 2) == 0) {
+ //_mediacodec_unprepare();
+ } else if (strncmp(cmd, "dt", 2) == 0) {
+ //_mediacodec_destroy();
+ } else {
+ //g_print("unknown menu \n");
+ display_sub_basic();
+ }
+ } else {
+ g_print("unknown menu \n");
+ }
+
+ return;
}
static void displaymenu(void)
{
- if (g_menu_state == CURRENT_STATUS_MAINMENU)
- {
- display_sub_basic();
- }
- else if (g_menu_state == CURRENT_STATUS_FILENAME)
- {
- g_print("*** input mediapath.\n");
- }
- else if (g_menu_state == CURRENT_STATUS_SET_CODEC)
- {
- g_print("*** Codec id : Select Codec ID Numbe (e.g. AAC_LC = 96)\n");
- g_print(" L16 = 16 (0x10)\n");
- g_print(" ALAW = 32 (0x20)\n");
- g_print(" ULAW = 48 (0x30)\n");
- g_print(" AMR_NB = 64 (0x40)\n");
- g_print(" AMR_WB = 65 (0x41)\n");
- g_print(" G729 = 80 (0x50)\n");
- g_print(" AAC_LC = 96 (0x60)\n");
- g_print(" AAC_HE = 97 (0x61)\n");
- g_print(" AAC_PS = 98 (0x62)\n");
- g_print(" MP3 = 112 (0x70)\n");
- g_print(" VORBIS = 128 (0x80)\n");
- g_print(" FLAC = 144 (0x90)\n");
- g_print(" WMAV1 = 160 (0xA0)\n");
- g_print(" WMAV2 = 161 (0xA1)\n");
- g_print(" WMAPRO = 162 (0xA2)\n");
- g_print(" WMALSL = 163 (0xA3)\n");
- g_print(" -------------------\n");
- g_print(" H261 = 101\n");
- g_print(" H263 = 102\n");
- g_print(" H264 = 103\n");
- g_print(" MJPEG = 104\n");
- g_print(" MPEG1 = 105\n");
- g_print(" MPEG2 = 106\n");
- g_print(" MPEG4 = 107\n");
- g_print(" -------------------\n");
- g_print("*** Flags : Select Combination Number (e.g. DEOCDER + TYPE_SW = 10)\n");
- g_print(" CODEC : ENCODER = 1 DECODER = 2\n");
- g_print(" TYPE : HW = 4 SW = 8\n");
- g_print("*** input codec id, falgs.\n");
- }
- else if (g_menu_state == CURRENT_STATUS_SET_VDEC_INFO)
- {
- g_print("*** input video decode configure.(width, height)\n");
- }
- else if (g_menu_state == CURRENT_STATUS_SET_VENC_INFO)
- {
- g_print("*** input video encode configure.(width, height, fps, target_bits)\n");
- }
- else if (g_menu_state == CURRENT_STATUS_SET_ADEC_INFO)
- {
- g_print("*** input audio decode configure.(samplerate, channel, bit (e.g. 48000, 2, 16))\n");
- }
- else if (g_menu_state == CURRENT_STATUS_SET_AENC_INFO)
- {
- g_print("*** input audio encode configure.(samplerate, channel, bit, bitrate (e.g. 48000, 2, 16, 128000))\n");
- }
- else if (g_menu_state == CURRENT_STATUS_PROCESS_INPUT)
- {
- g_print("*** input dec process number\n");
- }
- else if (g_menu_state == CURRENT_STATUS_GET_OUTPUT)
- {
- g_print("*** input get output buffer number\n");
- }
- else
- {
- g_print("*** unknown status.\n");
- //quit_program(app);
- }
- g_print(" >>> ");
+ if (g_menu_state == CURRENT_STATUS_MAINMENU)
+ {
+ display_sub_basic();
+ }
+ else if (g_menu_state == CURRENT_STATUS_FILENAME)
+ {
+ g_print("*** input mediapath.\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_CODEC)
+ {
+ g_print("*** Codec id : Select Codec ID Numbe (e.g. AAC_LC = 96)\n");
+ g_print(" L16 = 16 (0x10)\n");
+ g_print(" ALAW = 32 (0x20)\n");
+ g_print(" ULAW = 48 (0x30)\n");
+ g_print(" AMR_NB = 64 (0x40)\n");
+ g_print(" AMR_WB = 65 (0x41)\n");
+ g_print(" G729 = 80 (0x50)\n");
+ g_print(" AAC_LC = 96 (0x60)\n");
+ g_print(" AAC_HE = 97 (0x61)\n");
+ g_print(" AAC_PS = 98 (0x62)\n");
+ g_print(" MP3 = 112 (0x70)\n");
+ g_print(" VORBIS = 128 (0x80)\n");
+ g_print(" FLAC = 144 (0x90)\n");
+ g_print(" WMAV1 = 160 (0xA0)\n");
+ g_print(" WMAV2 = 161 (0xA1)\n");
+ g_print(" WMAPRO = 162 (0xA2)\n");
+ g_print(" WMALSL = 163 (0xA3)\n");
+ g_print(" -------------------\n");
+ g_print(" H261 = 101\n");
+ g_print(" H263 = 102\n");
+ g_print(" H264 = 103\n");
+ g_print(" MJPEG = 104\n");
+ g_print(" MPEG1 = 105\n");
+ g_print(" MPEG2 = 106\n");
+ g_print(" MPEG4 = 107\n");
+ g_print(" -------------------\n");
+ g_print("*** Flags : Select Combination Number (e.g. DEOCDER + TYPE_SW = 10)\n");
+ g_print(" CODEC : ENCODER = 1 DECODER = 2\n");
+ g_print(" TYPE : HW = 4 SW = 8\n");
+ g_print("*** input codec id, falgs.\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_VDEC_INFO)
+ {
+ g_print("*** input video decode configure.(width, height)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_VENC_INFO)
+ {
+ g_print("*** input video encode configure.(width, height, fps, target_bits)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_ADEC_INFO)
+ {
+ g_print("*** input audio decode configure.(samplerate, channel, bit (e.g. 48000, 2, 16))\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_AENC_INFO)
+ {
+ g_print("*** input audio encode configure.(samplerate, channel, bit, bitrate (e.g. 48000, 2, 16, 128000))\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_PROCESS_INPUT)
+ {
+ g_print("*** input dec process number\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_OUTPUT)
+ {
+ g_print("*** input get output buffer number\n");
+ }
+ else
+ {
+ g_print("*** unknown status.\n");
+ //quit_program(app);
+ }
+ g_print(" >>> ");
}
gboolean timeout_menu_display(void* data)
{
- displaymenu();
- return FALSE;
+ displaymenu();
+ return FALSE;
}
static void interpret (char *cmd, App *app)
{
- switch (g_menu_state)
- {
- case CURRENT_STATUS_MAINMENU:
- {
- _interpret_main_menu(cmd, app);
- }
- break;
- case CURRENT_STATUS_FILENAME:
- {
- input_filepath(cmd, app);
- reset_menu_state();
- }
- break;
- case CURRENT_STATUS_SET_CODEC:
- {
- int tmp;
- static int cnt = 0;
- char **ptr = NULL;
- switch (cnt)
- {
- case 0:
- tmp = atoi(cmd);
-
- if(tmp > 100 &&
- (tmp != 112) &&
- (tmp != 128) &&
- (tmp != 144) &&
- (tmp != 160) && (tmp != 161) && (tmp != 162) && (tmp != 163)) //Temporary
- {
- tmp = strtol(cmd, ptr, 16);
- app->codecid = 0x2000 + ((tmp & 0xFF) << 4);
- } else {
- app->codecid = 0x1000 + tmp;
- }
- cnt++;
- break;
- case 1:
- app->flag = atoi(cmd);
- cnt = 0;
- reset_menu_state();
- break;
- default:
- break;
- }
- }
- break;
- case CURRENT_STATUS_SET_VDEC_INFO:
- {
- static int cnt = 0;
- switch (cnt)
- {
- case 0:
- app->width = atoi(cmd);
- cnt++;
- break;
- case 1:
- app->height = atoi(cmd);
- app->type = VIDEO_DEC;
-
- reset_menu_state();
- cnt = 0;
- break;
- default:
- break;
- }
- }break;
- case CURRENT_STATUS_SET_VENC_INFO:
- {
- static int cnt = 0;
- switch (cnt) {
- case 0:
- app->width = atoi(cmd);
- cnt++;
- break;
- case 1:
- app->height = atoi(cmd);
- cnt++;
- break;
- case 2:
- app->fps = atol(cmd);
- cnt++;
- break;
- case 3:
- app->target_bits = atoi(cmd);
- app->type = VIDEO_ENC;
-
- reset_menu_state();
- cnt = 0;
- break;
- default:
- break;
- }
- }
- break;
- case CURRENT_STATUS_SET_ADEC_INFO:
- {
- static int cnt = 0;
- switch (cnt)
- {
- case 0:
- app->samplerate = atoi(cmd);
- cnt++;
- break;
- case 1:
- app->channel = atoi(cmd);
- cnt++;
- break;
- case 2:
- app->bit = atoi(cmd);
- app->type = AUDIO_DEC;
-
- reset_menu_state();
- cnt = 0;
- break;
- default:
- break;
- }
- }break;
- case CURRENT_STATUS_SET_AENC_INFO:
- {
- static int cnt = 0;
- switch (cnt)
- {
- case 0:
- app->samplerate = atoi(cmd);
- cnt++;
- break;
- case 1:
- app->channel = atoi(cmd);
- cnt++;
- break;
- case 2:
- app->bit = atoi(cmd);
- cnt++;
- break;
- case 3:
- app->bitrate = atoi(cmd);
- app->type = AUDIO_ENC;
-
- reset_menu_state();
- cnt = 0;
- break;
- default:
- break;
- }
- }break;
- case CURRENT_STATUS_PROCESS_INPUT:
- {
- static int num = 0;
- num = atoi(cmd);
- //_mediacodec_process_input_n(num);
- reset_menu_state();
- }
- break;
- case CURRENT_STATUS_GET_OUTPUT:
- {
- static int num = 0;
- num = atoi(cmd);
- //_mediacodec_get_output_n(num);
- reset_menu_state();
- }
- break;
- default:
- break;
- }
-
- g_timeout_add(100, timeout_menu_display, 0);
+ switch (g_menu_state)
+ {
+ case CURRENT_STATUS_MAINMENU:
+ {
+ _interpret_main_menu(cmd, app);
+ }
+ break;
+ case CURRENT_STATUS_FILENAME:
+ {
+ input_filepath(cmd, app);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_CODEC:
+ {
+ int tmp;
+ static int cnt = 0;
+ char **ptr = NULL;
+ switch (cnt)
+ {
+ case 0:
+ tmp = atoi(cmd);
+
+ if(tmp > 100 &&
+ (tmp != 112) &&
+ (tmp != 128) &&
+ (tmp != 144) &&
+ (tmp != 160) && (tmp != 161) && (tmp != 162) && (tmp != 163)) //Temporary
+ {
+ tmp = strtol(cmd, ptr, 16);
+ app->codecid = 0x2000 + ((tmp & 0xFF) << 4);
+ } else {
+ app->codecid = 0x1000 + tmp;
+ }
+ cnt++;
+ break;
+ case 1:
+ app->flag = atoi(cmd);
+ cnt = 0;
+ reset_menu_state();
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case CURRENT_STATUS_SET_VDEC_INFO:
+ {
+ static int cnt = 0;
+ switch (cnt)
+ {
+ case 0:
+ app->width = atoi(cmd);
+ cnt++;
+ break;
+ case 1:
+ app->height = atoi(cmd);
+ app->type = VIDEO_DEC;
+
+ reset_menu_state();
+ cnt = 0;
+ break;
+ default:
+ break;
+ }
+ }break;
+ case CURRENT_STATUS_SET_VENC_INFO:
+ {
+ static int cnt = 0;
+ switch (cnt) {
+ case 0:
+ app->width = atoi(cmd);
+ cnt++;
+ break;
+ case 1:
+ app->height = atoi(cmd);
+ cnt++;
+ break;
+ case 2:
+ app->fps = atol(cmd);
+ cnt++;
+ break;
+ case 3:
+ app->target_bits = atoi(cmd);
+ app->type = VIDEO_ENC;
+
+ reset_menu_state();
+ cnt = 0;
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case CURRENT_STATUS_SET_ADEC_INFO:
+ {
+ static int cnt = 0;
+ switch (cnt)
+ {
+ case 0:
+ app->samplerate = atoi(cmd);
+ cnt++;
+ break;
+ case 1:
+ app->channel = atoi(cmd);
+ cnt++;
+ break;
+ case 2:
+ app->bit = atoi(cmd);
+ app->type = AUDIO_DEC;
+
+ reset_menu_state();
+ cnt = 0;
+ break;
+ default:
+ break;
+ }
+ }break;
+ case CURRENT_STATUS_SET_AENC_INFO:
+ {
+ static int cnt = 0;
+ switch (cnt)
+ {
+ case 0:
+ app->samplerate = atoi(cmd);
+ cnt++;
+ break;
+ case 1:
+ app->channel = atoi(cmd);
+ cnt++;
+ break;
+ case 2:
+ app->bit = atoi(cmd);
+ cnt++;
+ break;
+ case 3:
+ app->bitrate = atoi(cmd);
+ app->type = AUDIO_ENC;
+
+ reset_menu_state();
+ cnt = 0;
+ break;
+ default:
+ break;
+ }
+ }break;
+ case CURRENT_STATUS_PROCESS_INPUT:
+ {
+ static int num = 0;
+ num = atoi(cmd);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_OUTPUT:
+ {
+ static int num = 0;
+ num = atoi(cmd);
+ reset_menu_state();
+ }
+ break;
+ default:
+ break;
+ }
+
+ g_timeout_add(100, timeout_menu_display, 0);
}
static void display_sub_basic()
{
- g_print("\n");
- g_print("=========================================================================================\n");
- g_print(" media codec test\n");
- g_print("-----------------------------------------------------------------------------------------\n");
- g_print("a. Create \t\t");
- g_print("sc. Set codec \n");
- g_print("vd. Set vdec info \t");
- g_print("ve. Set venc info \n");
- g_print("ad. Set adec info \t");
- g_print("ae. Set aenc info \n");
- g_print("pr. Prepare \t\t");
- g_print("pi. Process input \n");
- g_print("o. Get output \t\t");
- g_print("rb. Reset output buffer \n");
- g_print("pa. Process all frames \n");
- g_print("un. Unprepare \t\t");
- g_print("dt. Destroy \t\t");
- g_print("q. quite test suite \t");
- g_print("\n");
- g_print("=========================================================================================\n");
+ g_print("\n");
+ g_print("=========================================================================================\n");
+ g_print(" media codec test\n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print("a. Create \t\t");
+ g_print("sc. Set codec \n");
+ g_print("vd. Set vdec info \t");
+ g_print("ve. Set venc info \n");
+ g_print("ad. Set adec info \t");
+ g_print("ae. Set aenc info \n");
+ g_print("pr. Prepare \t\t");
+ g_print("pi. Process input \n");
+ g_print("o. Get output \t\t");
+ g_print("rb. Reset output buffer \n");
+ g_print("pa. Process all frames \n");
+ g_print("un. Unprepare \t\t");
+ g_print("dt. Destroy \t\t");
+ g_print("q. quite test suite \t");
+ g_print("\n");
+ g_print("=========================================================================================\n");
}
-gboolean input (GIOChannel *channel, GIOCondition cond, gpointer data)
+gboolean input(GIOChannel *channel, GIOCondition cond, gpointer data)
{
- gchar buf[MAX_STRING_LEN];
- gsize read;
- GError *error = NULL;
- App *context = (App*)data;
+ gchar buf[MAX_STRING_LEN];
+ gsize read;
+ GError *error = NULL;
+ App *context = (App*)data;
- g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
- buf[read] = '\0';
- g_strstrip(buf);
- interpret (buf, context);
+ g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
+ buf[read] = '\0';
+ g_strstrip(buf);
+ interpret(buf, context);
- return TRUE;
+ return TRUE;
}
+
int main(int argc, char *argv[])
{
- App *app = &s_app;
- //app->obj = -1;
-
- GError *error = NULL;
- GIOChannel *stdin_channel;
- stdin_channel = g_io_channel_unix_new(0);
- g_io_channel_set_flags (stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
- g_io_add_watch (stdin_channel, G_IO_IN, (GIOFunc)input, app);
-
-
- app->loop = g_main_loop_new(NULL, TRUE);
- app->timer = g_timer_new();
- /*
- app->file = g_mapped_file_new ("/opt/usr/media/Simpsons.h264", FALSE, &error);
- if (error) {
- g_print ("failed to open file : %s\n", error->message);
- g_error_free(error);
- return -1;
- }
+ App *app = &s_app;
- app->length = g_mapped_file_get_length (app->file);
- app->data = (guint8 *) g_mapped_file_get_contents (app->file);
- app->offset = 0;
-*/
+ GError *error = NULL;
+ GIOChannel *stdin_channel;
+ stdin_channel = g_io_channel_unix_new(0);
+ g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, app);
- //g_print("len %d, offset %d", app->length, (int)app->offset);
- //g_main_loop_run(app->loop);
+ app->loop = g_main_loop_new(NULL, TRUE);
+ app->timer = g_timer_new();
- displaymenu();
+ displaymenu();
- ops.data = app;
+ ops.data = app;
- return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
+ return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
}
void mc_hex_dump(char *desc, void *addr, int len)
{
- int i;
- unsigned char buff[17];
- unsigned char *pc = (unsigned char *)addr;
+ int i;
+ unsigned char buff[17];
+ unsigned char *pc = (unsigned char *)addr;
- if (desc != NULL)
- printf("%s:\n", desc);
+ if (desc != NULL)
+ printf("%s:\n", desc);
- for (i = 0; i < len; i++) {
+ for (i = 0; i < len; i++) {
- if ((i % 16) == 0) {
- if (i != 0)
- printf(" %s\n", buff);
+ if ((i % 16) == 0) {
+ if (i != 0)
+ printf(" %s\n", buff);
- printf(" %04x ", i);
- }
+ printf(" %04x ", i);
+ }
- printf(" %02x", pc[i]);
+ printf(" %02x", pc[i]);
- if ((pc[i] < 0x20) || (pc[i] > 0x7e))
- buff[i % 16] = '.';
- else
- buff[i % 16] = pc[i];
- buff[(i % 16) + 1] = '\0';
- }
+ if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+ buff[i % 16] = '.';
+ else
+ buff[i % 16] = pc[i];
+ buff[(i % 16) + 1] = '\0';
+ }
- while ((i % 16) != 0) {
- printf(" ");
- i++;
- }
- printf(" %s\n", buff);
+ while ((i % 16) != 0) {
+ printf(" ");
+ i++;
+ }
+ printf(" %s\n", buff);
}
static void decoder_output_dump(App *app, media_packet_h pkt)
{
- unsigned char *temp;
- int i = 0;
- int stride_width, stride_height;
- char filename[100]={0};
- FILE *fp = NULL;
- int ret =0;
-
- sprintf(filename, "/tmp/dec_output_dump_%d_%d.yuv", app->width, app->height);
- fp = fopen(filename, "ab");
-
- media_packet_get_video_plane_data_ptr(pkt, 0, &temp);
- media_packet_get_video_stride_width(pkt, 0, &stride_width);
- media_packet_get_video_stride_height(pkt, 0, &stride_height);
-
- for (i = 0; i < app->height; i++) {
- ret = fwrite(temp, app->width, 1, fp);
- temp += stride_width;
- }
-
- if (app->hardware == TRUE) {
- media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
- media_packet_get_video_stride_width(pkt, 1, &stride_width);
- for (i = 0; i < app->height/2; i++) {
- ret = fwrite(temp, app->width, 1, fp);
- temp += stride_width;
- }
- } else {
- media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
- media_packet_get_video_stride_width(pkt, 1, &stride_width);
- for (i = 0; i < app->height/2; i++) {
- ret = fwrite(temp, app->width/2, 1, fp);
- temp += stride_width;
- }
-
- media_packet_get_video_plane_data_ptr(pkt, 2, &temp);
- media_packet_get_video_stride_width(pkt, 2, &stride_width);
- for (i = 0; i < app->height/2; i++) {
- ret = fwrite(temp, app->width/2, 1, fp);
- temp += stride_width;
- }
- }
-
- g_print("codec dec output dumped!!%d\n", ret);
- fclose(fp);
+ unsigned char *temp;
+ int i = 0;
+ int stride_width, stride_height;
+ char filename[100] = {0};
+ FILE *fp = NULL;
+ int ret = 0;
+
+ sprintf(filename, "/tmp/dec_output_dump_%d_%d.yuv", app->width, app->height);
+ fp = fopen(filename, "ab");
+
+ media_packet_get_video_plane_data_ptr(pkt, 0, &temp);
+ media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ media_packet_get_video_stride_height(pkt, 0, &stride_height);
+
+ for (i = 0; i < app->height; i++) {
+ ret = fwrite(temp, app->width, 1, fp);
+ temp += stride_width;
+ }
+
+ if (app->hardware == TRUE) {
+ media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width, 1, fp);
+ temp += stride_width;
+ }
+ } else {
+ media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width/2, 1, fp);
+ temp += stride_width;
+ }
+
+ media_packet_get_video_plane_data_ptr(pkt, 2, &temp);
+ media_packet_get_video_stride_width(pkt, 2, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width/2, 1, fp);
+ temp += stride_width;
+ }
+ }
+
+ g_print("codec dec output dumped!!%d\n", ret);
+ fclose(fp);
}
projects / platform / core / api / mediacodec.git / commitdiff