static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h packet, bool codec_config);
static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer);
static gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw);
-static media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size);
+static GstMCBuffer *__mc_gst_make_media_packet(mc_gst_core_t *core, GstBuffer *buffer);
static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data);
static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data);
static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h packet);
int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer)
{
- int ret = MC_ERROR_NONE;
-
+ gint ret = MC_ERROR_NONE;
+ uint64_t buf_size = 0;
MMVideoBuffer *mm_vbuffer = NULL;
void *buf_data = NULL;
- uint64_t buf_size = 0;
ret = media_packet_get_buffer_size(packet, &buf_size);
if (ret != MEDIA_PACKET_ERROR_NONE) {
int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer)
{
- int ret = MC_ERROR_NONE;
+ gint ret = MC_ERROR_NONE;
void *buf_data = NULL;
uint64_t buf_size = 0;
int __mc_fill_input_buffer_with_adec_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer)
{
- int ret = MC_ERROR_NONE;
- void *buf_data = NULL;
+ gint ret = MC_ERROR_NONE;
uint64_t buf_size = 0;
+ unsigned int codec_size = 0;
bool codec_config = FALSE;
+ void *buf_data = NULL;
void *codec_data = NULL;
- unsigned int codec_size = 0;
ret = media_packet_get_buffer_size(packet, &buf_size);
if (ret != MEDIA_PACKET_ERROR_NONE) {
int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer)
{
- 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;
+ gint ret = MC_ERROR_NONE;
+ gint i;
+ gint j;
+ gint stride = 0;
+ gint buf_size = 0;
+ gint stride_width;
+ gint stride_height;
+ gint width;
+ gint height;
uint32_t plane_num;
- int i;
- int j;
- int stride = 0;
+ void *planes[2];
mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
return MC_ERROR;
}
- ret = media_packet_get_video_plane_data_ptr(packet, 0, &y_ptr);
+ ret = media_packet_get_video_plane_data_ptr(packet, 0, &planes[0]);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("media_packet_get_video_plane_data_ptr failed");
return MC_ERROR;
mcbuffer->buf_size += stride_width * stride_height;
for (i = 1; i < plane_num; i++) {
- media_packet_get_video_plane_data_ptr(packet, i, &uv_ptr);
+ media_packet_get_video_plane_data_ptr(packet, i, &planes[1]);
media_packet_get_video_stride_width(packet, i, &stride_width);
media_packet_get_video_stride_height(packet, i, &stride_height);
buf_size = stride_width * stride_height;
- memcpy(y_ptr + mcbuffer->buf_size, uv_ptr, buf_size);
+ memcpy(planes[0] + mcbuffer->buf_size, planes[1], buf_size);
mcbuffer->buf_size += buf_size;
LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mcbuffer->buf_size);
}
} else {
for (j = 0; j < height; j++) {
- memcpy(y_ptr + mcbuffer->buf_size, y_ptr + stride, width);
+ memcpy(planes[0] + mcbuffer->buf_size, planes[0] + stride, width);
mcbuffer->buf_size += width;
stride += stride_width;
}
stride = 0;
for (i = 1; i < plane_num; i++) {
- media_packet_get_video_plane_data_ptr(packet, i, &uv_ptr);
+ media_packet_get_video_plane_data_ptr(packet, i, &planes[1]);
media_packet_get_video_stride_width(packet, i, &stride_width);
media_packet_get_video_stride_height(packet, i, &stride_height);
for (j = 0; j < height>>1; j++) {
- memcpy(y_ptr + mcbuffer->buf_size, uv_ptr + stride, width>>1);
+ memcpy(planes[0] + mcbuffer->buf_size, planes[1] + stride, width>>1);
mcbuffer->buf_size += width>>1;
stride += stride_width;
}
- memcpy(y_ptr + mcbuffer->buf_size, uv_ptr, buf_size);
+ memcpy(planes[0] + mcbuffer->buf_size, planes[1], buf_size);
LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mcbuffer->buf_size);
mcbuffer->buf_size += buf_size;
}
}
gst_buffer_prepend_memory(mcbuffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mcbuffer->buf_size, 0,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, planes[0], mcbuffer->buf_size, 0,
mcbuffer->buf_size, mcbuffer, (GDestroyNotify)__mc_input_buffer_finalize_cb));
return ret;
* fill_outbuf virtual functions
*/
-int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet)
+int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, GstMCBuffer *mcbuffer)
{
- return core->vtable[fill_outbuf](core, data, size, out_packet);
+ return core->vtable[fill_outbuf](core, data, size, mcbuffer);
}
-int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *packet)
+int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, GstMCBuffer *mcbuffer)
{
int i;
int stride_width;
uint32_t width;
uint32_t height;
uint32_t buf_size;
- tbm_surface_h tsurf = NULL;
tbm_surface_info_s tsurf_info;
tbm_bo bo[MM_VIDEO_BUFFER_PLANE_MAX];
tbm_bo_handle thandle;
+ tbm_surface_h tsurf = NULL;
+ media_packet_h packet = NULL;
g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
if (tsurf) {
media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
- (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, packet);
+ (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, mcbuffer, &packet);
+ mcbuffer->packet = packet;
}
return MC_ERROR_NONE;
}
-int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet)
+int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, GstMCBuffer *mcbuffer)
{
+ gint ret = MC_ERROR_NONE;
+ gchar *ext_mem = NULL;
+ gint mem_size = 0;
void *packet_data = NULL;
- int ret = MC_ERROR_NONE;
+ media_packet_h packet = NULL;
+
g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
if (core->encoder && core->codec_id == MEDIACODEC_AAC)
media_format_set_audio_aac_type(core->output_fmt, FALSE);
- ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_packet);
+ mem_size = GST_ROUND_UP_4(size);
+ ext_mem = g_malloc0(mem_size);
+
+ ret = media_packet_create_from_external_memory(core->output_fmt, ext_mem, mem_size, __mc_output_buffer_finalize_cb, mcbuffer, &packet);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("media_packet_create_alloc failed");
return MC_ERROR;
}
+ mcbuffer->packet = packet;
+ mcbuffer->ext_mem = ext_mem;
- media_packet_set_buffer_size(*out_packet, size);
- media_packet_get_buffer_data_ptr(*out_packet, &packet_data);
+ media_packet_set_buffer_size(packet, size);
+ media_packet_get_buffer_data_ptr(packet, &packet_data);
memcpy(packet_data, data, size);
return MC_ERROR_NONE;
}
-int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet)
+int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, GstMCBuffer *mcbuffer)
{
- void *packet_data = NULL;
+ gint ret = MC_ERROR_NONE;
bool codec_config = FALSE;
bool sync_flag = FALSE;
bool slice = FALSE;
- int ret = MC_ERROR_NONE;
+ gint mem_size = 0;
+ gchar *ext_mem = NULL;
+ void *packet_data = NULL;
+ media_packet_h packet = NULL;
g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
}
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_packet);
+ mem_size = GST_ROUND_UP_4(size);
+ ext_mem = g_malloc0(mem_size);
+
+ ret = media_packet_create_from_external_memory(core->output_fmt, ext_mem, mem_size, __mc_output_buffer_finalize_cb, mcbuffer, &packet);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("media_packet_create_alloc failed");
return MC_ERROR;
}
+ mcbuffer->packet = packet;
+ mcbuffer->ext_mem = ext_mem;
- media_packet_set_buffer_size(*out_packet, size);
- media_packet_get_buffer_data_ptr(*out_packet, &packet_data);
+ media_packet_set_buffer_size(packet, size);
+ media_packet_get_buffer_data_ptr(packet, &packet_data);
memcpy(packet_data, data, size);
core->need_sync_flag = sync_flag ? 1 : 0;
return ret;
}
-int __mc_fill_aenc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet)
+int __mc_fill_aenc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, GstMCBuffer *mcbuffer)
{
int ret = MC_ERROR_NONE;
+ gint mem_size = 0;
GstPad *pad;
GstCaps *peercaps;
- const GValue *codec_data = NULL;
- void *packet_data = NULL;
GstMapInfo map;
guint8 *ptr;
gsize len;
+ gchar *ext_mem = NULL;
+ const GValue *codec_data = NULL;
+ void *packet_data = NULL;
+ media_packet_h packet = NULL;
g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
if (core->encoder && core->codec_id == MEDIACODEC_AAC)
media_format_set_audio_aac_type(core->output_fmt, FALSE);
- ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_packet);
+ mem_size = GST_ROUND_UP_4(size);
+ ext_mem = g_malloc0(mem_size);
+
+ ret = media_packet_create_from_external_memory(core->output_fmt, ext_mem, mem_size, __mc_output_buffer_finalize_cb, mcbuffer, &packet);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("media_packet_create_alloc failed");
return MC_ERROR;
}
+ mcbuffer->packet = packet;
+ mcbuffer->ext_mem = ext_mem;
- media_packet_set_buffer_size(*out_packet, size);
- media_packet_get_buffer_data_ptr(*out_packet, &packet_data);
+ media_packet_set_buffer_size(packet, size);
+ media_packet_get_buffer_data_ptr(packet, &packet_data);
memcpy(packet_data, data, size);
if (!core->codec_data) {
gst_buffer_map(core->codec_data, &map, GST_MAP_READ);
ptr = map.data;
len = map.size;
- media_packet_set_codec_data(*out_packet, ptr, len);
+ media_packet_set_codec_data(packet, ptr, len);
gst_buffer_unmap(core->codec_data, &map);
}
int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint streamheader_size)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- void *buf_data = NULL;
+ gint ret = MEDIA_PACKET_ERROR_NONE;
uint64_t buf_size = 0;
GstBuffer *header1, *header2, *header3;
guint hsize1, hsize2, hsize3;
GstBuffer *tmp_header;
- guint8 *tmp_buf = NULL;
GstMapInfo map;
+ void *buf_data = NULL;
+ guint8 *tmp_buf = NULL;
ret = media_packet_get_buffer_size(mcbuffer->packet, &buf_size);
if (ret != MEDIA_PACKET_ERROR_NONE) {
int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint fixed_size)
{
- int ret = MC_ERROR_NONE;
- void *codec_data = NULL;
- unsigned int codec_data_size = 0;
+ gint ret = MC_ERROR_NONE;
+ uint32_t codec_data_size = 0;
+ GstMapInfo map;
GstBuffer *codecdata_buffer;
guint8 *data = NULL;
- GstMapInfo map;
+ void *codec_data = NULL;
media_packet_get_codec_data(mcbuffer->packet, &codec_data, &codec_data_size);
mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
if (core->video) {
- int width = 0;
- int height = 0;
- int bitrate = 0;
+ gint width = 0;
+ gint height = 0;
+ gint bitrate = 0;
media_format_get_video_info(fmt, NULL, &width, &height, &bitrate, NULL);
}
}
} else {
- int channel;
- int samplerate;
- int bit;
- int bitrate;
+ gint channel;
+ gint samplerate;
+ gint bit;
+ gint bitrate;
media_format_get_audio_info(fmt, NULL, &channel, &samplerate, &bit, &bitrate);
static gpointer feed_task(gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t *)data;
- int ret = MC_ERROR_NONE;
+ gint ret = MC_ERROR_NONE;
bool codec_config = FALSE;
bool eos = FALSE;
+ bool initiative = TRUE;
media_format_h fmt = NULL;
media_packet_h in_buf = NULL;
GstMCBuffer *mcbuffer = NULL;
- bool initiative = true;
MEDIACODEC_FENTER();
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
+
while (g_atomic_int_get(&core->available_queue->running)) {
LOGD("waiting for next input....");
in_buf = _mc_get_input_buffer(core);
/* set caps */
g_object_set(core->appsrc, "caps", core->caps, NULL);
+ MEDIACODEC_FLEAVE();
+
return MC_ERROR_NONE;
}
-static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer)
+static gint _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer)
{
- MEDIACODEC_FENTER();
+ gint ret = MC_ERROR_NONE;
- int ret = MC_ERROR_NONE;
+ MEDIACODEC_FENTER();
+ ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), mcbuffer->buffer);
LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "",
mcbuffer->buffer, gst_buffer_get_size(mcbuffer->buffer));
- ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), mcbuffer->buffer);
+ MEDIACODEC_FLEAVE();
return ret;
}
}
LOGD("initialized... %d", ret);
+ MEDIACODEC_FLEAVE();
+
return ret;
}
}
}
+ MEDIACODEC_FLEAVE();
+
return ret;
}
mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint64_t timeOutUs)
{
- MEDIACODEC_FENTER();
-
- int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = NULL;
- media_packet_h out_packet = NULL;
+ gint ret = MC_ERROR_NONE;
gint64 end_time = -1;
gboolean signalled;
+ mc_gst_core_t *core = NULL;
+ media_packet_h out_packet = NULL;
+ MEDIACODEC_FENTER();
end_time = g_get_monotonic_time() + timeOutUs;
if (!mc_handle)
mc_ret_e mc_gst_flush_buffers(mc_handle_t *mc_handle)
{
- MEDIACODEC_FENTER();
-
- int ret = MC_ERROR_NONE;
+ gint ret = MC_ERROR_NONE;
mc_gst_core_t *core = NULL;
+ MEDIACODEC_FENTER();
+
if (!mc_handle)
return MC_PARAM_ERROR;
{
MEDIACODEC_FENTER();
+ gint i = 0;
+ gint 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");
/* 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->bus_watch_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 */
}
}
- if (core->bus_whatch_id) {
+ if (core->bus_watch_id) {
GSource *source = NULL;
- source = g_main_context_find_source_by_id(core->thread_default, core->bus_whatch_id);
+ source = g_main_context_find_source_by_id(core->thread_default, core->bus_watch_id);
g_source_destroy(source);
- LOGD("bus_whatch_id destroy");
+ LOGD("bus_watch_id destroy");
}
MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL);
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_packet = NULL;
+ GstMCBuffer *mcbuffer = NULL;
MEDIACODEC_FENTER();
gst_buffer_ref(buffer);
- n = gst_buffer_n_memory(buffer);
-
- 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);
+ mcbuffer = __mc_gst_make_media_packet(core, buffer);
- out_packet = __mc_gst_make_media_packet(core, map.data, map.size);
+ LOGI("@%p(%d) out_packet : %p", core, core->encoder, mcbuffer->packet);
- LOGI("@%p(%d) out_packet : %p", core, core->encoder, out_packet);
- gst_memory_unmap(mem, &map);
-
- if (out_packet) {
- media_packet_set_extra(out_packet, buffer);
- media_packet_set_pts(out_packet, GST_BUFFER_TIMESTAMP(buffer));
- media_packet_set_duration(out_packet, GST_BUFFER_DURATION(buffer));
+ if (mcbuffer->packet) {
+ media_packet_set_pts(mcbuffer->packet, GST_BUFFER_TIMESTAMP(buffer));
+ media_packet_set_duration(mcbuffer->packet, GST_BUFFER_DURATION(buffer));
if (core->need_codec_data) {
- media_packet_set_flags(out_packet, MEDIA_PACKET_CODEC_CONFIG);
+ media_packet_set_flags(mcbuffer->packet, MEDIA_PACKET_CODEC_CONFIG);
core->need_codec_data = false;
}
if (core->need_sync_flag) {
- media_packet_set_flags(out_packet, MEDIA_PACKET_SYNC_FRAME);
+ media_packet_set_flags(mcbuffer->packet, MEDIA_PACKET_SYNC_FRAME);
core->need_sync_flag = false;
}
- __mc_push_output_to_queue(core, out_packet);
+ __mc_push_output_to_queue(core, mcbuffer->packet);
} else {
gst_buffer_unref(buffer);
LOGE("Failed to dequeue output packet");
MEDIACODEC_FENTER();
- mc_gst_core_t *core = (mc_gst_core_t *)user_data;
+ GstMCBuffer *mcbuffer = (GstMCBuffer *)user_data;
+ mc_gst_core_t *core = mcbuffer->core;
g_mutex_lock(&core->ports[1]->mutex);
g_mutex_unlock(&core->ports[1]->mutex);
g_atomic_int_dec_and_test(&core->ftb_count);
- media_packet_get_extra(packet, &buffer);
+
+ buffer = mcbuffer->buffer;
n = gst_buffer_n_memory(buffer);
}
gst_memory_unmap(mem, &map);
}
+
+ if (mcbuffer->ext_mem) {
+ g_free(mcbuffer->ext_mem);
+ LOGD("freed external memory");
+ mcbuffer->ext_mem = NULL;
+ }
+
gst_buffer_unref((GstBuffer *)buffer);
LOGD("@v(%d)e(%d)output port filled buffer(%d): %p", core->video, core->encoder, core->ftb_count, packet);
GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h packet, bool codec_config)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- GstMCBuffer *mcbuffer = NULL;
- void *buf_data = NULL;
+ gint ret = MEDIA_PACKET_ERROR_NONE;
uint64_t buf_size = 0;
uint64_t pts = 0;
uint64_t dur = 0;
+ void *buf_data = NULL;
+ GstMCBuffer *mcbuffer = NULL;
ret = media_packet_get_buffer_size(packet, &buf_size);
if (ret != MEDIA_PACKET_ERROR_NONE) {
return mcbuffer;
}
-media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size)
+GstMCBuffer *__mc_gst_make_media_packet(mc_gst_core_t *core, GstBuffer *buffer)
{
- int ret = MEDIA_PACKET_ERROR_NONE;
- media_packet_h packet = NULL;
+ gint ret = MEDIA_PACKET_ERROR_NONE;
+ guint n;
+ GstMemory *mem;
+ GstMapInfo map = GST_MAP_INFO_INIT;
+ GstMCBuffer *mcbuffer = NULL;
+
+ mcbuffer = (GstMCBuffer *)g_malloc0(sizeof(*mcbuffer));
+
+ if (mcbuffer == NULL) {
+ LOGE("malloc fail");
+ return NULL;
+ }
+
+ n = gst_buffer_n_memory(buffer);
- ret = __mc_fill_output_buffer(core, data, size, &packet);
+ mem = gst_buffer_peek_memory(buffer, n-1);
+
+ gst_memory_map(mem, &map, GST_MAP_READ);
+
+ mcbuffer->buffer = buffer;
+ mcbuffer->core = core;
+ mcbuffer->buf_size = map.size;
+
+ LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size);
+ ret = __mc_fill_output_buffer(core, map.data, map.size, mcbuffer);
if (ret != MC_ERROR_NONE) {
LOGW("failed to fill outbuf: %s (ox%08x)", _mc_error_to_string(ret), ret);
+ gst_memory_unmap(mem, &map);
return NULL;
}
+ gst_memory_unmap(mem, &map);
-
- return packet;
+ return mcbuffer;
}
int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_packet)
{
+ gint ret = MC_ERROR_NONE;
media_packet_h mediabuf = NULL;
- int ret = MC_ERROR_NONE;
MEDIACODEC_FENTER();
if (media_packet_create(fmt, NULL, NULL, &mediabuf)) {
gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data)
{
- int ret = MC_ERROR_NONE;
+ gint ret = MC_ERROR_NONE;
mc_gst_core_t *core = (mc_gst_core_t *)data;
LOGD("@%p v(%d)e(%d)bus message : %s", core, core->video, core->encoder, gst_message_type_get_name(GST_MESSAGE_TYPE(msg)));
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;
+ return TRUE;
}
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
case GST_MESSAGE_ERROR:
case GST_MESSAGE_WARNING:
- retval = true;
+ retval = TRUE;
break;
default:
- retval = false;
+ retval = FALSE;
break;
}
static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h packet)
{
- int i;
- int num_bos;
+ gint i;
+ gint num_bos;
tbm_surface_h surface = NULL;
tbm_surface_info_s surface_info;
tbm_bo_handle handle_bo;
media_packet_get_tbm_surface(packet, &surface);
num_bos = tbm_surface_internal_get_num_bos(surface);
- int err = tbm_surface_get_info((tbm_surface_h)surface, &surface_info);
+ gint 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);
}
#ifdef TIZEN_PROFILE_LITE
- int phy_addr = 0;
- int phy_size = 0;
+ gint phy_addr = 0;
+ gint phy_size = 0;
tbm_bo_handle handle_fd = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM);
if (handle_fd.ptr == NULL) {
LOGE("Invaild bo handle");
return MEDIACODEC_ERROR_INTERNAL;
}
-static int _mc_gst_flush_buffers(mc_gst_core_t *core)
+static gint _mc_gst_flush_buffers(mc_gst_core_t *core)
{
gboolean ret = FALSE;
GstEvent *event = NULL;
}
#ifdef TIZEN_PROFILE_LITE
-int __tbm_get_physical_addr_bo(tbm_bo_handle handle_bo, int *phy_addr, int *phy_size)
+gint __tbm_get_physical_addr_bo(tbm_bo_handle handle_bo, int *phy_addr, int *phy_size)
{
- int ret = 0;
- int open_flags = O_RDWR;
- int ion_fd = -1;
+ gint ret = 0;
+ gint open_flags = O_RDWR;
+ gint ion_fd = -1;
ion_mmu_data_t mmu_data;
struct ion_custom_data custom_data;
* @return
* address of tiled data
*/
-static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
+static gint __tile_4x2_read(gint x_size, gint y_size, gint x_pos, gint 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;
+ gint pixel_x_m1, pixel_y_m1;
+ gint roundup_x;
+ gint linear_addr0, linear_addr1, bank_addr ;
+ gint x_addr;
+ gint trans_addr;
pixel_x_m1 = x_size - 1;
pixel_y_m1 = y_size - 1;
* @param buttom
* 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)
+static void __csc_tiled_to_linear_crop(gchar *yuv420_dest, gchar *nv12t_src,
+ gint yuv420_width, gint yuv420_height,
+ gint left, int top, gint right, gint buttom)
{
- int i, j;
- int tiled_offset = 0, tiled_offset1 = 0;
- int linear_offset = 0;
- int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
+ gint i, j;
+ gint tiled_offset = 0, tiled_offset1 = 0;
+ gint linear_offset = 0;
+ gint temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
temp3 = yuv420_width-right;
temp1 = temp3-left;
int _mc_get_support_bit_from_format(media_format_mimetype_e format)
{
- int bit = 0;
+ gint bit = 0;
switch (format) {
case MEDIA_FORMAT_PCM_S16LE:
mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *packet_pool)
{
- int curr_size;
- int max_size, min_size;
+ gint ret = MC_ERROR_NONE;
+ gint curr_size;
+ gint max_size, min_size;
media_format_mimetype_e mime_format = MEDIA_FORMAT_MAX;
media_format_h fmt_handle = NULL;
media_packet_pool_h pool = NULL;
core = (mc_gst_core_t *)mc_handle->core;
- int ret = media_packet_pool_create(&pool);
-
+ ret = media_packet_pool_create(&pool);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGE("media_packet_pool_create failed");
return MC_ERROR;
projects / platform / core / api / mediacodec.git / commitdiff