src/media_codec_port_gst.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 #include <glib.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <dlog.h>
  22 #include <media_codec_queue.h>
  23 #include <media_codec_port_gst.h>
  24 #include <media_codec_util.h>
  25
  26 #include <gst/gst.h>
  27 #include <gst/gstelement.h>
  28 #include <gst/app/gstappsrc.h>
  29
  30 #ifdef TIZEN_PROFILE_LITE
  31 #include <fcntl.h>
  32 #include <sys/ioctl.h>
  33 #include <linux/ion.h>
  34 #endif
  35
  36 /*
  37  * Internal Implementation
  38  */
  39 static gpointer feed_task(gpointer data);
  40 static void __mc_gst_stop_feed(GstElement *pipeline, gpointer data);
  41 static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data);
  42 static media_packet_h _mc_get_input_buffer(mc_gst_core_t *core);
  43
  44 static gboolean __mc_gst_init_gstreamer();
  45 static int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime);
  46 static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name);
  47 static mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core);
  48 static void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data);
  49 static int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data);
  50 static int  _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config);
  51 static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt);
  52 static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config);
  53 static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff);
  54 static gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw);
  55 static media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size);
  56 static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data);
  57 static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data);
  58 static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt);
  59 static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size);
  60 static void gst_mediacodec_buffer_finalize(GstMCBuffer *buffer);
  61 static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size);
  62 static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer*buff, guint codecdata_size);
  63 static void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt);
  64 static int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt);
  65
  66 static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message);
  67 static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error);
  68 static gint __gst_handle_resource_error(mc_gst_core_t *core, int code);
  69 static gint __gst_handle_library_error(mc_gst_core_t *core, int code);
  70 static gint __gst_handle_core_error(mc_gst_core_t *core, int code);
  71 static const gchar * _mc_error_to_string(mc_ret_e err);
  72
  73 static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboolean is_encoder, gboolean is_hw);
  74 #ifdef TIZEN_PROFILE_LITE
  75 static int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int *phy_addr, int *phy_size);
  76 #endif
  77 static int _mc_gst_flush_buffers(mc_gst_core_t *core);
  78 static void _mc_gst_set_flush_input(mc_gst_core_t *core);
  79 static void _mc_gst_set_flush_output(mc_gst_core_t *core);
  80
  81 #ifdef TIZEN_EXYNOS_SPECIFIC
  82 static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos);
  83 static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest,
  84                 unsigned char *nv12t_src, int yuv420_width, int yuv420_height,
  85                 int left, int top, int right, int buttom);
  86 #endif
  87
  88 static void _mc_send_eos_signal(mc_gst_core_t *core);
  89 static void _mc_wait_for_eos(mc_gst_core_t *core);
  90 static int _mediacodec_get_mime(mc_gst_core_t *core);
  91
  92 /* video vtable */
  93 int(*vdec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer};
  94 int(*venc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer};
  95
  96
  97 int(*vdec_h264_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                   /* S/W H.264 Decoder Vtable */
  98                                                                 &__mc_fill_vdec_packet_with_output_buffer};
  99
 100 int(*vdec_mpeg4_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                  /* S/W MPEG4 Decoder Vtable */
 101                                                                 &__mc_fill_vdec_packet_with_output_buffer};
 102
 103 int(*vdec_h263_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                   /* S/W MPEG4 Decoder Vtable */
 104                                                                 &__mc_fill_vdec_packet_with_output_buffer};
 105
 106 int(*vdec_h264_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                   /* H/W H.264 Decoder Vtable */
 107                                                                 &__mc_fill_vdec_packet_with_output_buffer};
 108
 109 int(*vdec_mpeg4_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                  /* H/W MPEG4 Decoder Vtable */
 110                                                                 &__mc_fill_vdec_packet_with_output_buffer};
 111
 112 int(*vdec_h263_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet,                   /* H/W MPEG4 Decoder Vtable */
 113                                                                 &__mc_fill_vdec_packet_with_output_buffer};
 114
 115 int(*venc_mpeg4_sw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet,             /* S/W MPEG4 Encoder Vtable */
 116                                                                 &__mc_fill_venc_packet_with_output_buffer};
 117
 118 int(*venc_h263_sw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet,              /* S/W MPEG4 Encoder Vtable */
 119                                                                 &__mc_fill_venc_packet_with_output_buffer};
 120
 121 int(*venc_h264_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet,              /* H/W H.264 Encoder Vtable */
 122                                                                 &__mc_fill_venc_packet_with_output_buffer};
 123
 124 int(*venc_mpeg4_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet,             /* H/W MPEG4 Encoder Vtable */
 125                                                                 &__mc_fill_venc_packet_with_output_buffer};
 126
 127 int(*venc_h263_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet,              /* H/W MPEG4 Encoder Vtable */
 128                                                                 &__mc_fill_venc_packet_with_output_buffer};
 129
 130 int(*aenc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer};
 131 int(*adec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer};
 132
 133 int(*aenc_aac_vtable[])() = {&__mc_fill_input_buffer_with_packet,                    /* AAC LC Encoder vtable */
 134                                                         &__mc_fill_packet_with_output_buffer};
 135
 136 int(*adec_aac_vtable[])() = {&__mc_fill_input_buffer_with_packet,                    /* AAC LC Decoder Vtable */
 137                                                         &__mc_fill_packet_with_output_buffer};
 138
 139 int(*adec_aacv12_vtable[])() = {&__mc_fill_input_buffer_with_packet,                 /* AAC HE Decoder Vtable */
 140                                                         &__mc_fill_packet_with_output_buffer};
 141
 142 int(*adec_mp3_vtable[])() = {&__mc_fill_input_buffer_with_packet,                    /* MP3 Decoder Vtable */
 143                                                         &__mc_fill_packet_with_output_buffer};
 144
 145 int(*adec_amrnb_vtable[])() = {&__mc_fill_input_buffer_with_packet,                  /* AMR-NB Decoder Vtable */
 146                                                         &__mc_fill_packet_with_output_buffer};
 147
 148 int(*adec_amrwb_vtable[])() = {&__mc_fill_input_buffer_with_packet,                  /* AMR-WB Decoder Vtable */
 149                                                         &__mc_fill_packet_with_output_buffer};
 150
 151 int(*aenc_amrnb_vtable[])() = {&__mc_fill_input_buffer_with_packet,                  /* AMR-NB Encoder Vtable */
 152                                                         &__mc_fill_packet_with_output_buffer};
 153
 154 int(*adec_vorbis_vtable[])() = {&__mc_fill_input_buffer_with_packet,                 /* VORBIS Decoder Vtable */
 155                                                         &__mc_fill_packet_with_output_buffer};
 156
 157 int(*adec_flac_vtable[])() = {&__mc_fill_input_buffer_with_packet,                   /* FLAC Decoder Vtable */
 158                                                         &__mc_fill_packet_with_output_buffer};
 159
 160 int(*adec_wma_vtable[])() = {&__mc_fill_input_buffer_with_packet,                    /* WMA Decoder Vtable */
 161                                                         &__mc_fill_packet_with_output_buffer};
 162
 163
 164 /*
 165  * fill_inbuf virtual functions
 166  */
 167 int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff)
 168 {
 169         return core->vtable[fill_inbuf](core, pkt, buff);
 170 }
 171
 172 int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
 173 {
 174         int ret = MC_ERROR_NONE;
 175
 176         MMVideoBuffer *mm_vbuffer = NULL;
 177         void *buf_data = NULL;
 178         uint64_t buf_size = 0;
 179
 180         ret = media_packet_get_buffer_size(pkt, &buf_size);
 181         if (ret != MEDIA_PACKET_ERROR_NONE) {
 182                 LOGW("buffer size get fail");
 183                 return MC_ERROR;
 184         }
 185
 186         ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
 187         if (ret != MEDIA_PACKET_ERROR_NONE) {
 188                 LOGW("buffer size get fail");
 189                 return MC_ERROR;
 190         }
 191
 192         mm_vbuffer = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt);
 193
 194         if (mm_vbuffer != NULL) {
 195                 gst_buffer_prepend_memory(mc_buffer->buffer,
 196                                 gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_vbuffer, sizeof(*mm_vbuffer), 0,
 197                                         sizeof(*mm_vbuffer), mm_vbuffer, free));
 198                 LOGD("scmn_mm_vbuffer is appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mc_buffer->buffer));
 199         }
 200
 201         if (buf_data != NULL) {
 202                 gst_buffer_prepend_memory(mc_buffer->buffer,
 203                                 gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
 204                                         buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
 205                 LOGD("packet data apended, %d, %d", buf_size, gst_buffer_n_memory(mc_buffer->buffer));
 206         }
 207         return ret;
 208 }
 209
 210 int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
 211 {
 212         int ret = MC_ERROR_NONE;
 213         void *buf_data = NULL;
 214         uint64_t buf_size = 0;
 215
 216         ret = media_packet_get_buffer_size(pkt, &buf_size);
 217         if (ret != MEDIA_PACKET_ERROR_NONE) {
 218                 LOGW("buffer size get fail");
 219                 return MC_ERROR;
 220         }
 221
 222         ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
 223         if (ret != MEDIA_PACKET_ERROR_NONE) {
 224                 LOGW("buffer size get fail");
 225                 return MC_ERROR;
 226         }
 227
 228         if (buf_data != NULL) {
 229                 gst_buffer_append_memory(mc_buffer->buffer,
 230                                 gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
 231                                         buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
 232                 LOGD("packet data apended");
 233         }
 234
 235         return ret;
 236 }
 237
 238 int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
 239 {
 240         int ret = MC_ERROR_NONE;
 241         void *uv_ptr = NULL;
 242         void *y_ptr = NULL;
 243         int buf_size = 0;
 244         int stride_width;
 245         int stride_height;
 246         int width;
 247         int height;
 248         uint32_t plane_num;
 249         int i;
 250         int j;
 251         int stride = 0;
 252
 253         mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
 254
 255         width = enc_info->width;
 256         height = enc_info->height;
 257
 258         ret = media_packet_get_number_of_video_planes(pkt, &plane_num);
 259         if (ret != MEDIA_PACKET_ERROR_NONE) {
 260                 LOGW("media_packet_get_number_of_video_planes failed");
 261                 return MC_ERROR;
 262         }
 263
 264         ret = media_packet_get_video_plane_data_ptr(pkt, 0, &y_ptr);
 265         if (ret != MEDIA_PACKET_ERROR_NONE) {
 266                 LOGW("media_packet_get_video_plane_data_ptr failed");
 267                 return MC_ERROR;
 268         }
 269
 270         ret = media_packet_get_video_stride_width(pkt, 0, &stride_width);
 271         if (ret != MEDIA_PACKET_ERROR_NONE) {
 272                 LOGW("media_packet_get_video_stride_width failed");
 273                 return MC_ERROR;
 274         }
 275
 276         ret = media_packet_get_video_stride_height(pkt, 0, &stride_height);
 277         if (ret != MEDIA_PACKET_ERROR_NONE) {
 278                 LOGW("media_packet_get_video_stride_width failed");
 279                 return MC_ERROR;
 280         }
 281
 282         if (!core->is_hw) {
 283
 284                 if (width == stride_width) {
 285                         mc_buffer->buf_size += stride_width * stride_height;
 286
 287                         for (i = 1; i < plane_num; i++) {
 288                                 media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
 289                                 media_packet_get_video_stride_width(pkt, i, &stride_width);
 290                                 media_packet_get_video_stride_height(pkt, i, &stride_height);
 291
 292                                 buf_size = stride_width * stride_height;
 293
 294                                 memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
 295                                 mc_buffer->buf_size += buf_size;
 296                                 LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
 297
 298                         }
 299                 } else {
 300
 301                         for (j = 0; j < height; j++) {
 302                                 memcpy(y_ptr + mc_buffer->buf_size, y_ptr + stride, width);
 303                                 mc_buffer->buf_size += width;
 304                                 stride += stride_width;
 305                         }
 306
 307                         stride = 0;
 308
 309                         for (i = 1; i < plane_num; i++) {
 310                                 media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
 311                                 media_packet_get_video_stride_width(pkt, i, &stride_width);
 312                                 media_packet_get_video_stride_height(pkt, i, &stride_height);
 313
 314                                 for (j = 0; j < height>>1; j++) {
 315                                         memcpy(y_ptr + mc_buffer->buf_size, uv_ptr + stride, width>>1);
 316                                         mc_buffer->buf_size += width>>1;
 317                                         stride += stride_width;
 318                                 }
 319
 320                                 memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
 321                                 LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
 322                                 mc_buffer->buf_size += buf_size;
 323                         }
 324                 }
 325         } else {
 326                 MMVideoBuffer *mm_video_buffer = NULL;
 327
 328                 mm_video_buffer = __mc_gst_make_tbm_buffer(core, pkt);
 329
 330                 gst_buffer_prepend_memory(mc_buffer->buffer,
 331                                 gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_video_buffer, sizeof(MMVideoBuffer), 0,
 332                                         sizeof(MMVideoBuffer), mm_video_buffer, free));
 333
 334                 LOGD("mm_video_buffer is appended, %d, %d", sizeof(MMVideoBuffer), gst_buffer_n_memory(mc_buffer->buffer));
 335         }
 336
 337         gst_buffer_prepend_memory(mc_buffer->buffer,
 338                         gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mc_buffer->buf_size, 0,
 339                                 mc_buffer->buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
 340
 341         return ret;
 342 }
 343
 344
 345 /*
 346  * fill_outbuf virtual functions
 347  */
 348
 349 int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
 350 {
 351         return core->vtable[fill_outbuf](core, data, size, out_pkt);
 352 }
 353
 354 int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt)
 355 {
 356         int i;
 357         int stride_width;
 358         int stride_height;
 359         uint32_t width;
 360         uint32_t height;
 361         uint32_t buf_size;
 362         tbm_surface_h tsurf = NULL;
 363         tbm_surface_info_s tsurf_info;
 364         tbm_bo bo[MM_VIDEO_BUFFER_PLANE_MAX];
 365         tbm_bo_handle thandle;
 366
 367         g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
 368
 369         mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
 370
 371         if (!core->is_hw) {
 372                 width = dec_info->width;
 373                 height = dec_info->height;
 374                 stride_width = GST_ROUND_UP_4(width);
 375                 stride_height = height;
 376                 buf_size = stride_width * stride_height * 3 / 2;
 377
 378                 memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
 379
 380                 bo[0] = tbm_bo_alloc(core->bufmgr, buf_size, TBM_BO_WC);
 381                 if (!bo[0]) {
 382                         LOGE("bo allocation failed");
 383                         return MC_ERROR;
 384                 }
 385
 386                 tsurf_info.width = dec_info->width;
 387                 tsurf_info.height = dec_info->height;
 388                 tsurf_info.format = TBM_FORMAT_YVU420;
 389                 tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YVU420);
 390                 tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_YVU420);
 391                 tsurf_info.size = 0;
 392
 393                 for (i = 0; i < tsurf_info.num_planes; i++) {
 394                         if (i == 0) {
 395                                 tsurf_info.planes[i].stride = stride_width;
 396                                 tsurf_info.planes[i].size = stride_width * stride_height;
 397                                 tsurf_info.planes[i].offset = 0;
 398                                 tsurf_info.size = tsurf_info.planes[i].size;
 399                         } else {
 400                                 tsurf_info.planes[i].stride = GST_ROUND_UP_4(GST_ROUND_UP_2(width) / 2);
 401                                 tsurf_info.planes[i].size = GST_ROUND_UP_4(GST_ROUND_UP_2(width) / 2) * (height / 2);
 402                                 tsurf_info.planes[i].offset = (tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size);
 403                                 tsurf_info.size += tsurf_info.planes[i].size;
 404                         }
 405                 }
 406
 407                 thandle = tbm_bo_map(bo[0], TBM_DEVICE_CPU, TBM_OPTION_WRITE);
 408                 memcpy(thandle.ptr, data, tsurf_info.size);
 409                 tbm_bo_unmap(bo[0]);
 410
 411                 tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, bo, 1);
 412         } else {
 413                 int bo_num = 0;
 414                 MMVideoBuffer *mm_vbuffer = NULL;
 415                 mm_vbuffer = (MMVideoBuffer *)data;
 416
 417                 if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
 418                         tbm_surface_info_s tsurf_info;
 419                         memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
 420
 421                         /* create tbm surface */
 422                         for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
 423                                 if (mm_vbuffer->handle.bo[i]) {
 424                                         bo_num++;
 425                                         tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
 426                                 }
 427                         }
 428
 429                         if (bo_num > 0) {
 430                                 tsurf_info.width = dec_info->width;
 431                                 tsurf_info.height = dec_info->height;
 432                                 tsurf_info.format = TBM_FORMAT_NV12;        /* bo_format */
 433                                 tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
 434                                 tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
 435                                 tsurf_info.size = 0;
 436
 437                                 for (i = 0; i < tsurf_info.num_planes; i++) {
 438                                         tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
 439                                         tsurf_info.planes[i].size = mm_vbuffer->stride_width[i] * mm_vbuffer->stride_height[i];
 440
 441                                         if (i < bo_num)
 442                                                 tsurf_info.planes[i].offset = 0;
 443                                         else
 444                                                 tsurf_info.planes[i].offset = tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size;
 445
 446                                         tsurf_info.size += tsurf_info.planes[i].size;
 447                                         LOGD("%d plane stride : %d, size : %d", i, tsurf_info.planes[i].stride, tsurf_info.planes[i].size);
 448                                 }
 449                                 tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, (tbm_bo *)mm_vbuffer->handle.bo, bo_num);
 450                         }
 451                 }
 452         }
 453
 454         if (tsurf) {
 455                 media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
 456                                 (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, pkt);
 457         }
 458
 459         return MC_ERROR_NONE;
 460 }
 461
 462 int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
 463 {
 464         void *pkt_data = NULL;
 465         int ret = MC_ERROR_NONE;
 466         g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
 467
 468         if (core->encoder && core->codec_id == MEDIACODEC_AAC)
 469                 media_format_set_audio_aac_type(core->output_fmt, FALSE);
 470
 471         ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
 472         if (ret != MEDIA_PACKET_ERROR_NONE) {
 473                 LOGW("media_packet_create_alloc failed");
 474                 return MC_ERROR;
 475         }
 476
 477         media_packet_set_buffer_size(*out_pkt, size);
 478         media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
 479         memcpy(pkt_data, data, size);
 480
 481         return MC_ERROR_NONE;
 482 }
 483
 484 int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
 485 {
 486         void *pkt_data = NULL;
 487         bool codec_config = FALSE;
 488         bool sync_flag = FALSE;
 489         bool slice = FALSE;
 490         int ret = MC_ERROR_NONE;
 491
 492         g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
 493
 494         switch (core->out_mime) {
 495         case MEDIA_FORMAT_H264_SP:
 496         case MEDIA_FORMAT_H264_MP:
 497         case MEDIA_FORMAT_H264_HP:
 498                 ret = _mc_check_h264_bytestream((unsigned char *)data, size, 1, &codec_config, &sync_flag, &slice);
 499                 break;
 500         case MEDIA_FORMAT_MPEG4_SP:
 501         case MEDIA_FORMAT_MPEG4_ASP:
 502                 _mc_check_mpeg4_out_bytestream((unsigned char *)data, size, &codec_config, &sync_flag);
 503                 break;
 504         case MEDIA_FORMAT_H263:
 505         case MEDIA_FORMAT_H263P:
 506                 if (!_mc_check_h263_out_bytestream((unsigned char *)data, size, &sync_flag))
 507                         return MC_INVALID_IN_BUF;
 508                 break;
 509         default:
 510                 return MC_INVALID_IN_BUF;
 511         }
 512         LOGD("codec_config : %d, sync_flag : %d, slice : %d", codec_config, sync_flag, slice);
 513
 514         ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
 515         if (ret != MEDIA_PACKET_ERROR_NONE) {
 516                 LOGW("media_packet_create_alloc failed");
 517                 return MC_ERROR;
 518         }
 519
 520         media_packet_set_buffer_size(*out_pkt, size);
 521         media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
 522         memcpy(pkt_data, data, size);
 523
 524         core->need_sync_flag = sync_flag ? 1 : 0;
 525         core->need_codec_data = codec_config ? 1 : 0;
 526
 527         return ret;
 528 }
 529
 530
 531 static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * name, GstBuffer * buf, ...)
 532 {
 533         GstStructure *struc = NULL;
 534         va_list va;
 535         GValue arr_val = { 0 };
 536         GValue buf_val = { 0 };
 537
 538         g_return_val_if_fail(name != NULL, NULL);
 539         g_return_val_if_fail(caps != NULL, NULL);
 540         g_return_val_if_fail(gst_caps_is_fixed(caps), NULL);
 541         caps = gst_caps_make_writable(caps);
 542
 543         struc = gst_caps_get_structure(caps, 0);
 544         if (!struc)
 545                 LOGW("cannot get structure from caps.\n");
 546
 547         g_value_init(&arr_val, GST_TYPE_ARRAY);
 548
 549         va_start(va, buf);
 550         while (buf) {
 551                 g_value_init(&buf_val, GST_TYPE_BUFFER);
 552                 gst_value_set_buffer(&buf_val, buf);
 553                 gst_value_array_append_value(&arr_val, &buf_val);
 554                 g_value_unset(&buf_val);
 555
 556                 buf = va_arg(va, GstBuffer *);
 557         }
 558         va_end(va);
 559
 560         gst_structure_take_value(struc, name, &arr_val);
 561
 562         return caps;
 563 }
 564
 565 int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size)
 566 {
 567         int ret = MEDIA_PACKET_ERROR_NONE;
 568         void *buf_data = NULL;
 569         uint64_t buf_size = 0;
 570         GstBuffer *header1, *header2, *header3;
 571         guint hsize1, hsize2, hsize3;
 572         GstBuffer *tmp_header;
 573         guint8 *tmp_buf = NULL;
 574         GstMapInfo map;
 575
 576         ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
 577         if (ret != MEDIA_PACKET_ERROR_NONE) {
 578                 LOGW("buffer size get fail");
 579                 return ret;
 580         }
 581
 582         ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
 583         if (ret != MEDIA_PACKET_ERROR_NONE) {
 584                 LOGW("buffer size get fail");
 585                 return ret;
 586         }
 587
 588         LOGD("Set caps for streamheader in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
 589
 590         if (core->codec_id == MEDIACODEC_VORBIS) {
 591                 /*
 592                  * hsize1 : Identification Header (packet type 1) - fixed 30 byte
 593                  * hsize2 : Comment Header (packet type 3) - variable byte (need calculate)
 594                  * hsize3 : Setup Header (packet type 5) - variable byte (Used remained bytes)
 595                  */
 596
 597                 /* First of all, Need to fins and calculate size of hsize2 */
 598                 tmp_header = gst_buffer_new_and_alloc(streamheader_size);
 599                 gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
 600                 gst_buffer_map(tmp_header, &map, GST_MAP_READ);
 601                 tmp_buf = map.data;
 602                 tmp_buf += (30 + 7);                /* hsize1 + '0x03' + 'vorbis'*/
 603                 hsize2 = (7 + 4);
 604                 hsize2 += GST_READ_UINT32_LE(tmp_buf);
 605                 hsize2 += (4 + 1);
 606                 LOGD("Find streamheader hsize2(%d)", hsize2);
 607                 gst_buffer_unmap(tmp_header, &map);
 608                 gst_buffer_unref(tmp_header);
 609
 610                 /*  hsize1 : Identification Header (packet type 1) - fixed 30 byte */
 611                 hsize1 = 30;
 612                 header1 = gst_buffer_new_and_alloc(hsize1);
 613                 gst_buffer_fill(header1, 0, buf_data, hsize1);
 614                 gst_buffer_map(header1, &map, GST_MAP_READ);
 615                 tmp_buf = map.data;
 616                 /* '0x01' + 'vorbis' */
 617                 if (*tmp_buf != 0x01) {
 618                         LOGE("[ERROR] Invalid Caps of Stream header1");
 619                         gst_buffer_unmap(header1, &map);
 620                         return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
 621                 }
 622                 gst_buffer_unmap(header1, &map);
 623
 624                 /* hsize2 : Comment Header (packet type 3) - variable byte */
 625                 header2 = gst_buffer_new_and_alloc(hsize2);
 626                 gst_buffer_fill(header2, 0,  (buf_data + (hsize1)), hsize2);
 627                 gst_buffer_map(header2, &map, GST_MAP_READ);
 628                 tmp_buf = map.data;
 629                 /* '0x03' + 'vorbis' */
 630                 if (*tmp_buf != 0x03) {
 631                         LOGE("[ERROR] Invalid Caps of Stream header2");
 632                         gst_buffer_unmap(header2, &map);
 633                         return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
 634                 }
 635                 gst_buffer_unmap(header2, &map);
 636
 637                 /* hsize3 : Setup Header (packet type 5) - variable byte */
 638                 hsize3 = streamheader_size - (hsize1 + hsize2);
 639                 header3 = gst_buffer_new_and_alloc(hsize3);
 640                 gst_buffer_fill(header3, 0,  (buf_data + (hsize1 + hsize2)), hsize3);
 641                 gst_buffer_map(header3, &map, GST_MAP_READ);
 642                 tmp_buf = map.data;
 643                 /* '0x05' + 'vorbis' */
 644                 if (*tmp_buf != 0x05) {
 645                         LOGE("[ERROR] Invalid Caps of Stream header3");
 646                         gst_buffer_unmap(header3, &map);
 647                         return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
 648                 }
 649                 gst_buffer_unmap(header3, &map);
 650
 651                 LOGD("[vorbis] streamheader hsize1 (%d) + hsize2 (%d) + hsize3 (%d) = Total (%d)",
 652                                 hsize1, hsize2, hsize3, (hsize1 + hsize2 + hsize3));
 653
 654                 __mc_gst_caps_set_buffer_array(core->caps, "streamheader", header1, header2, header3, NULL);
 655
 656                 gst_buffer_unref(header1);
 657                 gst_buffer_unref(header2);
 658                 gst_buffer_unref(header3);
 659         } else if (core->codec_id == MEDIACODEC_FLAC) {
 660                 /*
 661                  * hsize1 : Stream Info (type 0) - fixed 51 byte
 662                  * hsize2 : Stream Comment (type 4) - variable byte (need calculate)
 663                  */
 664
 665                 /* First of all, Need to fins and calculate size of hsize2 */
 666                 tmp_header = gst_buffer_new_and_alloc(streamheader_size);
 667                 gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
 668                 gst_buffer_map(tmp_header, &map, GST_MAP_READ);
 669                 tmp_buf = map.data;
 670                 hsize2 = 4 + ((tmp_buf[52] << 16) | (tmp_buf[53] << 8) | (tmp_buf[54]));
 671                 LOGD("Find streamheader hsize2(%d)", hsize2);
 672                 gst_buffer_unmap(tmp_header, &map);
 673                 gst_buffer_unref(tmp_header);
 674
 675                 /*  hsize1 :  Stream Info (type 0) - fixed 51 byte */
 676                 hsize1 = 51;
 677                 header1 = gst_buffer_new_and_alloc(hsize1);
 678                 gst_buffer_fill(header1, 0, buf_data, hsize1);
 679                 gst_buffer_map(header1, &map, GST_MAP_READ);
 680                 tmp_buf = map.data;
 681                 /* '0x7f' + 'FLAC' */
 682                 if (*tmp_buf != 0x07f) {
 683                         LOGE("[ERROR] Invalid Caps of Stream header1 (Info)");
 684                         gst_buffer_unmap(header1, &map);
 685                         gst_buffer_unref(header1);
 686                         return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
 687                 }
 688                 gst_buffer_unmap(header1, &map);
 689
 690                 /* hsize2 : Stream Comment (type 4) - variable byte (need calculate) */
 691                 header2 = gst_buffer_new_and_alloc(hsize2);
 692                 gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
 693                 gst_buffer_map(header2, &map, GST_MAP_READ);
 694                 tmp_buf = map.data;
 695                 /* '0x84' */
 696                 if (*tmp_buf != 0x84) {
 697                         LOGE("[ERROR] Invalid Caps of Stream header2 (Comment)");
 698                         gst_buffer_unmap(header2, &map);
 699                         gst_buffer_unref(header1);
 700                         gst_buffer_unref(header2);
 701                         return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
 702                 }
 703                 gst_buffer_unmap(header2, &map);
 704
 705                 LOGD("[flac] streamheader hsize1 (%d) + hsize2 (%d)  = Total (%d)", hsize1, hsize2, (hsize1 + hsize2));
 706                 __mc_gst_caps_set_buffer_array(core->caps, "streamheader", header1, header2, NULL);
 707                 gst_buffer_unref(header1);
 708                 gst_buffer_unref(header2);
 709         } else {
 710                 LOGE("Not support case of Stream header Caps");
 711         }
 712
 713         /* Update gstbuffer's data ptr and size for using previous streamheader.*/
 714         LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
 715         gst_buffer_remove_memory_range(buff->buffer, streamheader_size, -1);
 716         gst_buffer_set_size(buff->buffer, buf_size - streamheader_size);
 717         LOGD("AFTER  : buff->buffer of size %" G_GSIZE_FORMAT "",  gst_buffer_get_size(buff->buffer));
 718
 719         return ret;
 720 }
 721
 722 int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *buff, unsigned int *size)
 723 {
 724         void *data = NULL;
 725         uint64_t data_size = 0;
 726         uint64_t codec_size = 0;
 727         int ret = MC_ERROR_NONE;
 728
 729         media_packet_get_buffer_size(buff->pkt, &data_size);
 730         media_packet_get_buffer_data_ptr(buff->pkt, &data);
 731
 732         switch (core->codec_id) {
 733         case MEDIACODEC_H264:
 734                 codec_size = _mc_get_h264_codecdata_size(data, data_size);
 735                 break;
 736         case MEDIACODEC_H263:
 737                 /* Not need codec data */
 738                 codec_size = 0;
 739                 break;
 740         case MEDIACODEC_MPEG4:
 741                 codec_size = _mc_check_mpeg4_out_bytestream(data, data_size, NULL, NULL);
 742                 break;
 743         default:
 744                 LOGE("Current not support yet (0x%x) !", core->codec_id);
 745                 return MC_NOT_SUPPORTED;
 746                 break;
 747         }
 748
 749         if (codec_size < 0) {
 750                 LOGE("No valid codec data!");
 751                 ret = MC_INVALID_IN_BUF;
 752         }
 753
 754         *size = codec_size;
 755
 756         return ret;
 757 }
 758
 759 int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_size)
 760 {
 761         int ret = MC_ERROR_NONE;
 762         void *codec_data = NULL;
 763         unsigned int codec_data_size = 0;
 764         GstBuffer *codecdata_buffer;
 765         guint8 *data = NULL;
 766         GstMapInfo map;
 767
 768         media_packet_get_codec_data(buff->pkt, &codec_data, &codec_data_size);
 769
 770         if (codec_data != NULL) {               /* get the codec data from media_packet_get_codec_data() */
 771                 data = g_malloc0(codec_data_size);
 772                 memcpy(data, codec_data, codec_data_size);
 773                 codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size);
 774                 gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL);
 775                 LOGD("set codec data : %" G_GSIZE_FORMAT "", gst_buffer_get_size(codecdata_buffer));
 776                 gst_buffer_unref(codecdata_buffer);
 777         } else {                                        /* get the codec data from media_packet_get_buffer_data_ptr() */
 778                 uint64_t buffer_size = 0;
 779                 void *buff_data = NULL;
 780
 781                 media_packet_get_buffer_size(buff->pkt, &buffer_size);
 782                 media_packet_get_buffer_data_ptr(buff->pkt, &buff_data);
 783
 784                 ret = __mc_get_codecdata_size(core, buff, &codec_data_size);
 785                 LOGD("First Frame contains codec_data_size= %d", codec_data_size);
 786
 787                 if ((ret == MC_ERROR_NONE) && (codec_data_size > 0)) {
 788                         data = g_malloc0(codec_data_size);
 789                         gst_buffer_map(buff->buffer, &map, GST_MAP_READ);
 790                         memcpy(data, map.data, codec_data_size);
 791                         codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size);
 792                         gst_buffer_unmap(buff->buffer, &map);
 793                         gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL);
 794                         gst_buffer_unref(codecdata_buffer);
 795
 796                         GstMemory *memory = NULL;
 797                         memory = gst_buffer_peek_memory(buff->buffer, 0);
 798                         gst_memory_resize(memory, codec_data_size, buffer_size - codec_data_size);
 799                         LOGD("First frame remained size : %d", gst_buffer_get_size(buff->buffer));
 800                 } else {
 801                         if (ret != MC_ERROR_NONE) {
 802                                 LOGE("No valid codec data in the packet!");
 803                         }
 804                 }
 805         }
 806         return ret;
 807 }
 808
 809 int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime)
 810 {
 811         if (media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE) {
 812                 LOGE("media format create failed");
 813                 return MC_ERROR;
 814         }
 815
 816         if (encoder) {
 817                 mc_encoder_info_t *info;
 818
 819                 info = (mc_encoder_info_t *)core->codec_info;
 820
 821                 if (video) {
 822                         media_format_set_video_mime(core->output_fmt, out_mime);
 823                         media_format_set_video_width(core->output_fmt, info->width);
 824                         media_format_set_video_height(core->output_fmt, info->height);
 825                         media_format_set_video_avg_bps(core->output_fmt, info->bitrate);
 826                 } else {
 827                         media_format_set_audio_mime(core->output_fmt, out_mime);
 828                         media_format_set_audio_channel(core->output_fmt, info->channel);
 829                         media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
 830                         media_format_set_audio_bit(core->output_fmt, info->bit);
 831                         media_format_set_audio_avg_bps(core->output_fmt, info->bitrate);
 832                 }
 833         } else {
 834                 mc_decoder_info_t *info;
 835
 836                 info = (mc_decoder_info_t *)core->codec_info;
 837
 838                 if (video) {
 839                         media_format_set_video_mime(core->output_fmt, out_mime);
 840                         media_format_set_video_width(core->output_fmt, info->width);
 841                         media_format_set_video_height(core->output_fmt, info->height);
 842                 } else {
 843                         media_format_set_audio_mime(core->output_fmt, out_mime);
 844                         media_format_set_audio_channel(core->output_fmt, info->channel);
 845                         media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
 846                         media_format_set_audio_bit(core->output_fmt, info->bit);
 847                 }
 848         }
 849         return MC_ERROR_NONE;
 850 }
 851
 852 /*
 853  * mc_gst_core functions
 854  */
 855 mc_gst_core_t *mc_gst_core_new()
 856 {
 857         mc_gst_core_t *core;
 858
 859         MEDIACODEC_FENTER();
 860
 861         core = g_new0(mc_gst_core_t, 1);
 862
 863         /* 0 : input, 1 : output */
 864         core->ports[0] = NULL;
 865         core->ports[1] = mc_gst_port_new(core);
 866         core->ports[1]->index = 1;
 867
 868         core->available_queue = g_new0(mc_aqueue_t, 1);
 869         core->available_queue->input = mc_async_queue_new();
 870
 871         g_mutex_init(&core->eos_mutex);
 872         g_cond_init(&core->eos_cond);
 873         g_cond_init(&core->buffer_cond);
 874         g_cond_init(&core->out_buffer_cond);
 875         g_mutex_init(&core->prepare_lock);
 876         g_mutex_init(&core->drain_lock);
 877
 878         core->need_feed = false;
 879         core->eos = false;
 880         core->need_codec_data = false;
 881         core->need_sync_flag = false;
 882         core->unprepare_flag = false;
 883         core->prepare_count = 0;
 884         core->etb_count = 0;
 885         core->ftb_count = 0;
 886
 887         g_atomic_int_set(&core->available_queue->running, 1);
 888         core->available_queue->thread = g_thread_new("feed thread", &feed_task, core);
 889
 890         core->bufmgr = NULL;
 891         core->drm_fd = -1;
 892         LOGD("gst_core(%p) is created", core);
 893
 894         MEDIACODEC_FLEAVE();
 895
 896         return core;
 897 }
 898
 899 void mc_gst_core_free(mc_gst_core_t *core)
 900 {
 901         MEDIACODEC_FENTER();
 902
 903         mc_aqueue_t *async_queue;
 904
 905         async_queue = core->available_queue;
 906
 907         mc_async_queue_disable(async_queue->input);
 908
 909         g_atomic_int_set(&async_queue->running, 0);
 910         g_thread_join(async_queue->thread);
 911
 912         g_mutex_clear(&core->eos_mutex);
 913         g_mutex_clear(&core->prepare_lock);
 914         g_mutex_clear(&core->drain_lock);
 915         g_cond_clear(&core->eos_cond);
 916         g_cond_clear(&core->buffer_cond);
 917         g_cond_clear(&core->out_buffer_cond);
 918
 919         mc_async_queue_free(async_queue->input);
 920         g_free(async_queue);
 921
 922         if (core->ports[1] != NULL) {
 923                 mc_gst_port_free(core->ports[1]);
 924                 core->ports[1] = NULL;
 925         }
 926
 927         LOGD("gst_core(%p) is destroyed", core);
 928         g_free(core);
 929
 930         MEDIACODEC_FLEAVE();
 931 }
 932
 933 /*
 934  * mc_gst_port functions
 935  */
 936 mc_gst_port_t *mc_gst_port_new(mc_gst_core_t *core)
 937 {
 938         MEDIACODEC_FENTER();
 939
 940         mc_gst_port_t *port;
 941
 942         port = g_new0(mc_gst_port_t, 1);
 943         port->core = core;
 944         port->num_buffers = -1;
 945         port->buffer_size = 0;
 946         port->is_allocated = 0;
 947         port->buffers = NULL;
 948
 949         g_mutex_init(&port->mutex);
 950         port->queue = g_queue_new();
 951
 952         LOGD("gst_port(%p) is created", port);
 953
 954         MEDIACODEC_FLEAVE();
 955         return port;
 956 }
 957
 958 void mc_gst_port_free(mc_gst_port_t *port)
 959 {
 960         MEDIACODEC_FENTER();
 961
 962         g_mutex_clear(&port->mutex);
 963         g_queue_free(port->queue);
 964
 965         LOGD("gst_port(%p) is freed", port);
 966         g_free(port);
 967
 968         MEDIACODEC_FLEAVE();
 969
 970         return;
 971 }
 972
 973 gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt)
 974 {
 975         gboolean is_updated = FALSE;
 976
 977         mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
 978
 979         if (core->video) {
 980                 int width = 0;
 981                 int height = 0;
 982                 int bitrate = 0;
 983
 984                 media_format_get_video_info(fmt, NULL, &width, &height, &bitrate, NULL);
 985
 986                 if ((codec_info->width != width) || (codec_info->height != height)) {
 987                         LOGD("Resolution changed : %dx%d -> %dx%d", codec_info->width, codec_info->height, width, height);
 988                         codec_info->width = width;
 989                         codec_info->height = height;
 990                         is_updated = TRUE;
 991                 }
 992
 993                 if (core->encoder) {
 994                         mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
 995
 996                         if (bitrate != 0 && enc_info->bitrate != bitrate * 1000) {
 997                                 LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate);
 998                                 enc_info->bitrate = bitrate * 1000;
 999                                 is_updated = TRUE;
1000                         }
1001                 }
1002         } else {
1003                 int channel;
1004                 int samplerate;
1005                 int bit;
1006                 int bitrate;
1007
1008                 media_format_get_audio_info(fmt, NULL, &channel, &samplerate, &bit, &bitrate);
1009
1010                 if ((codec_info->channel != channel) || (codec_info->samplerate != samplerate) || (codec_info->bit != bit)) {
1011                         LOGD("Audio info. changed : %d -> %d, %d -> %d, %d -> %d", codec_info->channel, channel, codec_info->samplerate, samplerate, codec_info->bit, bit);
1012                         codec_info->channel = channel;
1013                         codec_info->samplerate = samplerate;
1014                         codec_info->bit = bit;
1015                         is_updated = TRUE;
1016                 }
1017
1018                 if (core->encoder) {
1019                         mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
1020
1021                         if (bitrate != 0 && enc_info->bitrate != bitrate * 1000) {
1022                                 LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate);
1023                                 enc_info->bitrate = bitrate * 1000;
1024                                 is_updated = TRUE;
1025                         }
1026                 }
1027         }
1028
1029         return is_updated;
1030 }
1031
1032 static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config)
1033 {
1034         MEDIACODEC_FENTER();
1035
1036         g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
1037
1038         int ret = MC_ERROR_NONE;
1039
1040         if (core->video) {
1041                 if (core->encoder) {
1042                         mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
1043
1044                         core->format = __mc_get_gst_input_format(pkt, core->is_hw);
1045                         gst_caps_set_simple(core->caps,
1046                                         "format", G_TYPE_STRING, core->format,
1047                                         "width", G_TYPE_INT, enc_info->width,
1048                                         "height", G_TYPE_INT, enc_info->height,
1049                                         "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
1050                                         NULL);
1051
1052                         if (g_object_class_find_property(G_OBJECT_GET_CLASS(core->codec), "bitrate"))
1053                                 g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL);
1054                         else
1055                                 g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate, NULL);
1056
1057                 } else {
1058                         mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
1059
1060                         gst_caps_set_simple(core->caps,
1061                                         "width", G_TYPE_INT, dec_info->width,
1062                                         "height", G_TYPE_INT, dec_info->height,
1063                                         NULL);
1064
1065                         ret = __mc_set_caps_codecdata(core, buff, CODECDATA_NOT_USE);
1066                         if (ret != MC_ERROR_NONE) {
1067                                 LOGW("__mc_set_caps_codecdata failed");
1068                         }
1069                 }
1070         } else {
1071                 if (core->encoder) {
1072                         mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
1073
1074                         gst_caps_set_simple(core->caps,
1075                                         "rate", G_TYPE_INT, enc_info->samplerate,
1076                                         "channels", G_TYPE_INT, enc_info->channel,
1077                                         NULL);
1078                         g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL);
1079                 } else {
1080                         mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
1081
1082                         gst_caps_set_simple(core->caps,
1083                                         "rate", G_TYPE_INT, dec_info->samplerate,
1084                                         "channels", G_TYPE_INT, dec_info->channel,
1085                                         NULL);
1086
1087                         if (codec_config) {
1088                                 switch (core->codec_id) {
1089                                 case MEDIACODEC_AAC:
1090                                 case MEDIACODEC_AAC_HE:
1091                                 case MEDIACODEC_AAC_HE_PS:
1092                                         ret = __mc_set_caps_codecdata(core, buff, AAC_CODECDATA_SIZE);
1093                                         if (ret != MC_ERROR_NONE) {
1094                                                 LOGW("__mc_set_caps_codecdata failed");
1095                                         }
1096                                         break;
1097                                 case MEDIACODEC_WMAV1:
1098                                 case MEDIACODEC_WMAV2:
1099                                 case MEDIACODEC_WMAPRO:
1100                                 case MEDIACODEC_WMALSL:
1101                                         ret = __mc_set_caps_codecdata(core, buff, WMA_CODECDATA_SIZE);
1102                                         if (ret != MC_ERROR_NONE) {
1103                                                 LOGW("__mc_set_caps_codecdata failed");
1104                                         }
1105                                         break;
1106                                 case MEDIACODEC_VORBIS:
1107                                 case MEDIACODEC_FLAC:
1108                                         ret = __mc_set_caps_streamheader(core, buff, VORBIS_CODECDATA_SIZE);
1109                                         if (ret != MC_ERROR_NONE) {
1110                                                 LOGW("__mc_set_caps_streamheader failed");
1111                                         }
1112                                         break;
1113                                 default:
1114                                         LOGD("doesn't need to set codecdata");
1115                                         break;
1116
1117                                 }
1118                         }
1119                 }
1120         }
1121         g_object_set(core->appsrc, "caps", core->caps, NULL);
1122
1123         MEDIACODEC_FLEAVE();
1124         return ret;
1125 }
1126
1127 static gpointer feed_task(gpointer data)
1128 {
1129         mc_gst_core_t *core = (mc_gst_core_t *)data;
1130         int ret = MC_ERROR_NONE;
1131         bool codec_config = FALSE;
1132         bool eos = FALSE;
1133         media_format_h fmt = NULL;
1134         media_packet_h in_buf = NULL;
1135         GstMCBuffer *buff = NULL;
1136         bool initiative = true;
1137
1138         MEDIACODEC_FENTER();
1139
1140         while (g_atomic_int_get(&core->available_queue->running)) {
1141                 LOGD("waiting for next input....");
1142                 in_buf = _mc_get_input_buffer(core);
1143
1144                 if (!in_buf)
1145                         goto LEAVE;
1146
1147                 media_packet_get_format(in_buf,  &fmt);
1148                 if (fmt) {
1149                         if (_mc_update_packet_info(core, fmt))
1150                                 initiative = TRUE;
1151                         media_format_unref(fmt);
1152                 }
1153
1154                 if (media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
1155                         LOGE("media_packet_is_codec_config failed");
1156                         goto ERROR;
1157                 }
1158
1159                 if (media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE) {
1160                         LOGE("media_packet_is_end_of_stream failed");
1161                         goto ERROR;
1162                 }
1163
1164                 buff = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config);
1165                 if (!buff) {
1166                         LOGW("gstbuffer can't make");
1167                         goto ERROR;
1168                 }
1169
1170                 if (codec_config)
1171                         initiative = TRUE;
1172
1173                 if (initiative) {
1174                         GstPad *pad;
1175
1176                         ret = _mc_gst_update_caps(core, in_buf, buff, codec_config);
1177                         if (ret != MC_ERROR_NONE) {
1178                                 LOGE("failed to update caps");
1179                                 goto ERROR;
1180                         }
1181
1182                         pad = gst_element_get_static_pad(core->appsrc, "src");
1183                         gst_pad_push_event(pad, gst_event_new_stream_start("start"));
1184                         gst_object_unref(pad);
1185
1186                         LOGD("caps updated");
1187                 }
1188
1189                 /* inject buffer */
1190                 ret = _mc_gst_gstbuffer_to_appsrc(core, buff);
1191                 if (ret != GST_FLOW_OK) {
1192                         LOGE("Failed to push gst buffer");
1193                         goto ERROR;
1194                 }
1195
1196                 initiative = false;
1197
1198                 if (eos) {
1199                         LOGD("end of stream");
1200                         gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc));
1201                         _mc_wait_for_eos(core);
1202                         initiative = true;
1203                 }
1204
1205
1206                 continue;
1207 ERROR:
1208                 _mc_gst_set_flush_input(core);
1209
1210                 if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
1211                         ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
1212                                 (MC_INTERNAL_ERROR, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
1213                 }
1214
1215                 continue;
1216 LEAVE:
1217                 /*LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);*/
1218                 continue;
1219
1220         }
1221
1222         LOGI("status : in_buf : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task",
1223                         in_buf, codec_config, eos, core->video, core->encoder);
1224         LOGD("feed task finished %p v(%d)e(%d)", core, core->video, core->encoder);
1225
1226         MEDIACODEC_FLEAVE();
1227
1228         return NULL;
1229 }
1230
1231 static void __mc_gst_stop_feed(GstElement *pipeline, gpointer data)
1232 {
1233         mc_gst_core_t *core = (mc_gst_core_t *)data;
1234
1235         LOGI("stop_feed called");
1236         if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
1237                 ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
1238                         (MEDIACODEC_ENOUGH_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
1239         }
1240 }
1241
1242 static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data)
1243 {
1244         mc_gst_core_t *core = (mc_gst_core_t *)data;
1245
1246         LOGI("start_feed called");
1247
1248         if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
1249                 ((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
1250                         (MEDIACODEC_NEED_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
1251         }
1252 }
1253
1254 static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboolean encoder, gboolean is_hw)
1255 {
1256         MEDIACODEC_FENTER();
1257
1258         g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
1259
1260         switch (id) {
1261         case MEDIACODEC_AAC:
1262                 /* if set to 'CODEC_CONFIG', then It is also available case of  MEDIA_FORMAT_AAC_LC (RAW) */
1263                 LOGD("aac lc (adts) vtable");
1264                 if (encoder) {
1265                         core->vtable = aenc_aac_vtable;
1266                         core->caps = gst_caps_new_simple(core->mime,
1267                                         "format", G_TYPE_STRING, "F32LE",
1268                                         "layout", G_TYPE_STRING, "interleaved", NULL);
1269                         g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
1270                 } else {
1271                         LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
1272
1273                         core->vtable = adec_aac_vtable;
1274                         core->caps = gst_caps_new_simple(core->mime,
1275                                         "framed", G_TYPE_BOOLEAN, TRUE,
1276                                         "mpegversion", G_TYPE_INT, 4,
1277                                         "stream-format", G_TYPE_STRING, "adts",
1278                                         NULL);
1279                 }
1280                 break;
1281         case MEDIACODEC_AAC_HE:
1282         case MEDIACODEC_AAC_HE_PS:
1283                 LOGD("aac he v12 vtable");
1284                 if (encoder) {
1285                         LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
1286                         return MC_NOT_SUPPORTED;
1287                 } else {
1288                         LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)");
1289                         core->vtable = adec_aacv12_vtable;
1290                         core->caps = gst_caps_new_simple(core->mime,
1291                                         "mpegversion", G_TYPE_INT, 4,     /*TODO : need adding version /profile*/
1292                                         "framed", G_TYPE_BOOLEAN, TRUE,
1293                                         "stream-format", G_TYPE_STRING, "raw",
1294                                         NULL);
1295                 }
1296                 break;
1297         case MEDIACODEC_MP3:
1298                 LOGD("mp3 vtable - Only support decoder");
1299                 if (encoder) {
1300                         LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
1301                         return MC_NOT_SUPPORTED;
1302                 } else {
1303                         core->vtable = adec_mp3_vtable;
1304                         core->caps = gst_caps_new_simple(core->mime,
1305                                         "framed", G_TYPE_BOOLEAN, TRUE,
1306                                         "mpegversion", G_TYPE_INT, 1,       /* To-Do : plz check */
1307                                         "mpegaudioversion", G_TYPE_INT, 1,  /* To-Do : plz check */
1308                                         "layer", G_TYPE_INT, 3,             /* To-Do : plz check */
1309                                         NULL);
1310                 }
1311                 break;
1312         case MEDIACODEC_AMR_NB:
1313                 LOGD("amrnb vtable");
1314                 if (encoder) {
1315                         core->vtable = aenc_amrnb_vtable;
1316                         core->caps = gst_caps_new_simple(core->mime,
1317                                         "format", G_TYPE_STRING, "S16LE",
1318                                         "layout", G_TYPE_STRING, "interleaved",
1319                                         NULL);
1320
1321                 } else {
1322                         core->vtable = adec_amrnb_vtable;
1323                         core->caps = gst_caps_new_simple(core->mime,
1324                                         "rate", G_TYPE_INT, 8000,
1325                                         NULL);
1326                 }
1327                 break;
1328         case MEDIACODEC_AMR_WB:
1329                 LOGD("amrwb vtable - Only support decoder");
1330                 if (encoder) {
1331                         LOGD("[MC_NOT_SUPPORTED] amr-wb encoder is not supported yet!!!");
1332                         return MC_NOT_SUPPORTED;
1333                 } else {
1334                         core->vtable = adec_amrwb_vtable;
1335                         core->caps = gst_caps_new_simple(core->mime,
1336                                         "rate", G_TYPE_INT, 16000,
1337                                         NULL);
1338                 }
1339                 break;
1340         case MEDIACODEC_VORBIS:
1341                 LOGD("vorbis vtable");
1342                 if (encoder) {
1343                         LOGD("[MC_NOT_SUPPORTED] vorbis encoder is not supported yet!!!");
1344                         return MC_NOT_SUPPORTED;
1345                 } else {
1346                         core->vtable = adec_vorbis_vtable;
1347                         core->caps = gst_caps_new_empty_simple("audio/x-vorbis");
1348                 }
1349                 break;
1350         case MEDIACODEC_FLAC:
1351                 LOGD("flac vtable");
1352                 if (encoder) {
1353                         LOGD("[MC_NOT_SUPPORTED] flac encoder is not supported yet!!!");
1354                         return MC_NOT_SUPPORTED;
1355                 } else {
1356                         core->vtable = adec_flac_vtable;
1357                         core->caps = gst_caps_new_simple(core->mime,
1358                                         "framed", G_TYPE_BOOLEAN, TRUE,
1359                                         /* FIXME - Insert More Info */
1360                                         NULL);
1361                 }
1362                 break;
1363         case MEDIACODEC_WMAV1:
1364         case MEDIACODEC_WMAV2:
1365         case MEDIACODEC_WMAPRO:
1366         case MEDIACODEC_WMALSL:
1367                 LOGD("wma(V1 / V2 / LSL / PRO) vtable");
1368                 if (encoder) {
1369                         LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!");
1370                         return MC_NOT_SUPPORTED;
1371                 } else {
1372                         mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
1373
1374                         core->vtable = adec_wma_vtable;
1375
1376                         /*
1377                          * Need to extract from Stream Type Specific ... or
1378                          * Need to get Demuxer's Caps from Stream Type Specific
1379                          */
1380                         guint16 format_tag = 0;
1381                         gint wma_version = 0;
1382                         gint block_align = 1024;      /*FIXME : Need checking */
1383                         gint bitrate = 128000;        /*FIXME : Need checking */
1384
1385                         LOGD(" ----- WMA Need Additional Caps -----------");
1386                         if (core->codec_id == MEDIACODEC_WMAV1) {
1387                                 format_tag = 352;       /* 0x160 */
1388                                 wma_version = 1;
1389                         } else if (core->codec_id == MEDIACODEC_WMAV2) {
1390                                 format_tag = 353;       /* 0x161 */
1391                                 wma_version = 2;
1392                         } else if (core->codec_id == MEDIACODEC_WMAPRO) {
1393                                 format_tag = 354;       /* 0x162 */
1394                                 wma_version = 3;
1395                         } else if (core->codec_id == MEDIACODEC_WMALSL) {
1396                                 format_tag = 355;       /* 0x163 */
1397                                 wma_version = 3;
1398                         } else {
1399                                 LOGE("Not support WMA format");
1400                         }
1401
1402                         core->caps = gst_caps_new_simple(core->mime,
1403                                         "bitrate", G_TYPE_INT, bitrate,
1404                                         "depth", G_TYPE_INT, dec_info->bit,
1405                                         /* FIXME - Need More Info */
1406                                         "wmaversion", G_TYPE_INT, wma_version,
1407                                         "format_tag", G_TYPE_INT, format_tag,
1408                                         "block_align", G_TYPE_INT, block_align,
1409                                         NULL);
1410                 }
1411                 break;
1412         case MEDIACODEC_H263:
1413                 LOGD("h263 vtable");
1414                 if (encoder) {
1415                         core->vtable = is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable;
1416                         core->caps = gst_caps_new_empty_simple("video/x-raw");
1417                 } else {
1418                         if (is_hw) {
1419                                 core->vtable = vdec_h263_hw_vtable;
1420                                 core->caps = gst_caps_new_simple(core->mime,
1421                                                 "mpegversion", G_TYPE_INT, 4,
1422                                                 "framerate", GST_TYPE_FRACTION, 30, 1,
1423                                                 NULL);
1424                         } else {
1425                                 core->vtable = vdec_h263_sw_vtable;
1426                                 core->caps = gst_caps_new_simple(core->mime,
1427                                                 "variant", G_TYPE_STRING, "itu",
1428                                                 "framerate", GST_TYPE_FRACTION, 30, 1,
1429                                                 NULL);
1430                         }
1431                 }
1432                 break;
1433         case MEDIACODEC_MPEG4:
1434                 LOGD("mpeg4 vtable");
1435                 if (encoder) {
1436                         core->vtable = is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable;
1437                         core->caps = gst_caps_new_empty_simple("video/x-raw");
1438                 } else {
1439                         core->vtable = is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable;
1440                         core->caps = gst_caps_new_simple(core->mime,
1441                                         "mpegversion", G_TYPE_INT, 4,
1442                                         "systemstream", G_TYPE_BOOLEAN, false,
1443                                         "parsed", G_TYPE_BOOLEAN, TRUE,
1444                                         "framerate", GST_TYPE_FRACTION, 30, 1,
1445                                         NULL);
1446                 }
1447                 break;
1448         case MEDIACODEC_H264:
1449                 LOGD("h264 vtable");
1450                 if (encoder) {
1451                         core->vtable = is_hw ? venc_h264_hw_vtable : venc_vtable;
1452                         core->caps = gst_caps_new_empty_simple("video/x-raw");
1453 #ifdef TIZEN_PROFILE_LITE
1454                         g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
1455 #endif
1456                 } else {
1457                         if (is_hw) {
1458                                 core->vtable = vdec_h264_hw_vtable;
1459                                 core->caps = gst_caps_new_simple(core->mime,
1460                                                 "parsed", G_TYPE_BOOLEAN, TRUE,
1461                                                 "alignment", G_TYPE_STRING, "au",
1462                                                 "stream-format", G_TYPE_STRING, "byte-stream",
1463                                                 "framerate", GST_TYPE_FRACTION, 30, 1,
1464                                                 NULL);
1465                         } else {
1466                                 core->vtable = vdec_h264_sw_vtable;
1467                                 core->caps = gst_caps_new_simple(core->mime,
1468                                                 "alignment", G_TYPE_STRING, "au",
1469                                                 "stream-format", G_TYPE_STRING, "byte-stream",
1470                                                 "framerate", GST_TYPE_FRACTION, 30, 1,
1471                                                 NULL);
1472                         }
1473                 }
1474                 break;
1475         default:
1476                 break;
1477         }
1478                 /* set caps */
1479                 g_object_set(core->appsrc, "caps", core->caps, NULL);
1480
1481         return MC_ERROR_NONE;
1482 }
1483
1484 static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff)
1485 {
1486         MEDIACODEC_FENTER();
1487
1488         int ret = MC_ERROR_NONE;
1489
1490         LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "",
1491                         buff->buffer, gst_buffer_get_size(buff->buffer));
1492
1493         ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), buff->buffer);
1494
1495         return ret;
1496 }
1497
1498 media_packet_h _mc_get_input_buffer(mc_gst_core_t *core)
1499 {
1500         LOGD("waiting for input...");
1501         return mc_async_queue_pop(core->available_queue->input);
1502 }
1503
1504 mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
1505 {
1506         MEDIACODEC_FENTER();
1507
1508         int ret = MC_ERROR_NONE;
1509         media_format_mimetype_e out_mime;
1510         int num_supported_codec = 0;
1511         int i = 0;
1512
1513         if (!mc_handle)
1514                 return MC_PARAM_ERROR;
1515
1516         mediacodec_codec_type_e id;
1517         bool video;
1518         bool encoder;
1519         bool hardware;
1520         gchar *factory_name = NULL;
1521         mc_codec_map_t *codec_map;
1522
1523         id = mc_handle->codec_id;
1524         video = mc_handle->is_video;
1525         encoder = mc_handle->is_encoder;
1526         hardware = mc_handle->is_hw;
1527         codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
1528         num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
1529
1530         for (i = 0; i < num_supported_codec; i++) {
1531                 if ((id == codec_map[i].id) && (hardware == codec_map[i].hardware))
1532                         break;
1533         }
1534
1535         if (i == num_supported_codec)
1536                 return MC_NOT_SUPPORTED;
1537
1538         factory_name = codec_map[i].type.factory_name;
1539         out_mime = codec_map[i].type.out_format;
1540
1541         /* gst_core create */
1542         mc_gst_core_t *new_core = mc_gst_core_new();
1543
1544         new_core->mime = codec_map[i].type.mime;
1545         new_core->is_hw = hardware;
1546         new_core->eos = false;
1547         new_core->encoder = encoder;
1548         new_core->video = video;
1549         new_core->codec_info = encoder ? (void *)&mc_handle->info.encoder : (void *)&mc_handle->info.decoder;
1550         new_core->out_mime = codec_map[i].type.out_format;
1551         new_core->codec_id = id;
1552
1553         new_core->bufmgr = tbm_bufmgr_init(new_core->drm_fd);
1554         if (new_core->bufmgr == NULL) {
1555                 LOGE("TBM initialization failed");
1556                 return MC_ERROR;
1557         }
1558
1559         LOGD("@%p(%p) core is initializing...v(%d)e(%d)", mc_handle, new_core, new_core->video, new_core->encoder);
1560         LOGD("factory name : %s, output_fmt : %x", factory_name, out_mime);
1561
1562         /* create media_packet for output fmt */
1563         if ((ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime)) != MC_ERROR_NONE) {
1564                 LOGE("Failed to create output pakcet");
1565                 return ret;
1566         }
1567
1568         for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++) {
1569                 LOGD("copy cb function [%d]", i);
1570                 if (mc_handle->user_cb[i]) {
1571                         new_core->user_cb[i] = mc_handle->user_cb[i];
1572                         new_core->user_data[i] = mc_handle->user_data[i];
1573                         LOGD("user_cb[%d] %p, %p", i, new_core->user_cb[i], mc_handle->user_cb[i]);
1574                 }
1575         }
1576
1577         mc_handle->core = new_core;
1578
1579         /* create basic core elements */
1580         if ((ret = _mc_gst_create_pipeline(mc_handle->core, factory_name) != MC_ERROR_NONE)) {
1581                 LOGE("failed to create pipeline");
1582                 return ret;
1583         }
1584
1585         /* link vtable */
1586         if ((ret = _mc_link_vtable(mc_handle->core, id, encoder, hardware)) != MC_ERROR_NONE) {
1587                 LOGE("vtable link failed");
1588                 return ret;
1589         }
1590
1591         LOGD("initialized... %d", ret);
1592         return ret;
1593 }
1594
1595 mc_ret_e mc_gst_unprepare(mc_handle_t *mc_handle)
1596 {
1597         MEDIACODEC_FENTER();
1598
1599         int i;
1600         int ret = MC_ERROR_NONE;
1601         mc_gst_core_t *core = NULL;
1602
1603         if (!mc_handle)
1604                 return MC_PARAM_ERROR;
1605
1606         core = (mc_gst_core_t *)mc_handle->core;
1607
1608         if (core) {
1609                 LOGD("@%p(%p) core is uninitializing... v(%d)e(%d)", mc_handle, core, core->video, core->encoder);
1610
1611                 g_mutex_lock(&core->drain_lock);
1612                 core->unprepare_flag = TRUE;
1613                 g_mutex_unlock(&core->drain_lock);
1614
1615                 if (core->eos)
1616                         _mc_send_eos_signal(core);
1617
1618                 _mc_gst_set_flush_input(core);
1619
1620                 ret = _mc_gst_destroy_pipeline(core);
1621
1622                 /* unset callback */
1623                 for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER; i++) {
1624                         LOGD("unset cb function [%d]", i);
1625                         if (mc_handle->user_cb[i]) {
1626                                 core->user_cb[i] = NULL;
1627                                 core->user_data[i] = NULL;
1628                                 LOGD("user_cb[%d] %p, %p", i, core->user_cb[i], mc_handle->user_cb[i]);
1629                         }
1630                 }
1631
1632                 media_format_unref(core->output_fmt);
1633
1634                 if (core->bufmgr != NULL) {
1635                         tbm_bufmgr_deinit(core->bufmgr);
1636                         core->bufmgr = NULL;
1637                 }
1638
1639                 if (core->drm_fd != -1) {
1640                         close(core->drm_fd);
1641                         LOGD("close drm_fd");
1642                 }
1643
1644                 if (core != NULL) {
1645                         mc_gst_core_free(core);
1646                         mc_handle->core = NULL;
1647                 }
1648         }
1649
1650         return ret;
1651 }
1652
1653 mc_ret_e mc_gst_process_input(mc_handle_t *mc_handle, media_packet_h inbuf, uint64_t timeOutUs)
1654 {
1655         MEDIACODEC_FENTER();
1656
1657         int ret = MC_ERROR_NONE;
1658         mc_gst_core_t *core = NULL;
1659         gint64 end_time;
1660
1661         if (!mc_handle)
1662                 return MC_PARAM_ERROR;
1663
1664         core = (mc_gst_core_t *)mc_handle->core;
1665
1666         g_mutex_lock(&core->drain_lock);
1667
1668         while (g_atomic_int_get(&core->etb_count) > MAXINUM_QNUM) {
1669                 end_time = g_get_monotonic_time() + timeOutUs;
1670                 LOGD("Waiting until packets are drained..");
1671
1672                 if (!g_cond_wait_until(&core->buffer_cond, &core->drain_lock, end_time)) {
1673                         LOGD("time out...");
1674                         break;
1675                 }
1676         }
1677         g_mutex_unlock(&core->drain_lock);
1678
1679         if (core->prepare_count == 0)
1680                 return MC_INVALID_STATUS;
1681
1682         g_mutex_lock(&core->drain_lock);
1683
1684         if (!core->eos || !core->unprepare_flag) {
1685                 mc_async_queue_push(core->available_queue->input, inbuf);
1686
1687         } else {
1688                 ret = MC_INVALID_IN_BUF;
1689                 g_mutex_unlock(&core->drain_lock);
1690                 return ret;
1691         }
1692
1693         g_mutex_unlock(&core->drain_lock);
1694         g_atomic_int_inc(&core->etb_count);
1695         LOGI("@v(%d)e(%d)process_input(%d): %p", core->video, core->encoder, core->etb_count, inbuf);
1696
1697         MEDIACODEC_FLEAVE();
1698
1699         return ret;
1700 }
1701
1702 mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint64_t timeOutUs)
1703 {
1704         MEDIACODEC_FENTER();
1705
1706         int ret = MC_ERROR_NONE;
1707         mc_gst_core_t *core = NULL;
1708         media_packet_h out_pkt = NULL;
1709         gint64 end_time = -1;
1710         gboolean signalled;
1711
1712         end_time = g_get_monotonic_time() + timeOutUs;
1713
1714         if (!mc_handle)
1715                 return MC_PARAM_ERROR;
1716
1717         core = (mc_gst_core_t *)mc_handle->core;
1718
1719         g_mutex_lock(&core->ports[1]->mutex);
1720
1721         if (!g_queue_is_empty(core->ports[1]->queue))
1722                 signalled = TRUE;
1723         else {
1724                 LOGD("no buffer, wait for signal");
1725                 signalled = g_cond_wait_until(&core->out_buffer_cond, &core->ports[1]->mutex, end_time);
1726         }
1727
1728         if (signalled)
1729                 out_pkt = g_queue_pop_head(core->ports[1]->queue);
1730         else {
1731                 LOGW("Failed to get buffer");
1732                 ret = MC_OUTPUT_BUFFER_EMPTY;
1733         }
1734
1735         *outbuf = out_pkt;
1736         LOGI("@%p v(%d)e(%d) got buffer :%p", core, core->video, core->encoder, out_pkt);
1737
1738         g_mutex_unlock(&core->ports[1]->mutex);
1739
1740         MEDIACODEC_FLEAVE();
1741
1742         return ret;
1743 }
1744
1745 mc_ret_e mc_gst_flush_buffers(mc_handle_t *mc_handle)
1746 {
1747         MEDIACODEC_FENTER();
1748
1749         int ret = MC_ERROR_NONE;
1750         mc_gst_core_t *core = NULL;
1751
1752         if (!mc_handle)
1753                 return MC_PARAM_ERROR;
1754
1755         core = (mc_gst_core_t *)mc_handle->core;
1756         LOGI("@%p v(%d)e(%d) flush_buffers", core, core->video, core->encoder);
1757
1758         ret = _mc_gst_flush_buffers(core);
1759
1760         MEDIACODEC_FLEAVE();
1761
1762         return ret;
1763 }
1764
1765 static gboolean __mc_gst_init_gstreamer()
1766 {
1767         MEDIACODEC_FENTER();
1768
1769         static gboolean initialized = FALSE;
1770         static const int max_argc = 50;
1771         gint *argc = NULL;
1772         gchar **argv = NULL;
1773         gchar **argv2 = NULL;
1774         GError *err = NULL;
1775         int i = 0;
1776         int arg_count = 0;
1777
1778         if (initialized) {
1779                 LOGD("gstreamer already initialized.\n");
1780                 return TRUE;
1781         }
1782
1783         /* alloc */
1784         argc = malloc(sizeof(int));
1785         argv = malloc(sizeof(gchar *) *max_argc);
1786         argv2 = malloc(sizeof(gchar *) *max_argc);
1787
1788         if (!argc || !argv || !argv2)
1789                 goto ERROR;
1790
1791         memset(argv, 0, sizeof(gchar *) *max_argc);
1792         memset(argv2, 0, sizeof(gchar *) *max_argc);
1793
1794         /* add initial */
1795         *argc = 1;
1796         argv[0] = g_strdup("media codec");
1797
1798         /* we would not do fork for scanning plugins */
1799         argv[*argc] = g_strdup("--gst-disable-registry-fork");
1800         (*argc)++;
1801
1802         /* check disable registry scan */
1803         argv[*argc] = g_strdup("--gst-disable-registry-update");
1804         (*argc)++;
1805
1806         /* check disable segtrap */
1807         argv[*argc] = g_strdup("--gst-disable-segtrap");
1808         (*argc)++;
1809
1810         LOGD("initializing gstreamer with following parameter\n");
1811         LOGD("argc : %d\n", *argc);
1812         arg_count = *argc;
1813
1814         for (i = 0; i < arg_count; i++) {
1815                 argv2[i] = argv[i];
1816                 LOGD("argv[%d] : %s\n", i, argv2[i]);
1817         }
1818
1819         /* initializing gstreamer */
1820         if (!gst_init_check(argc, &argv, &err)) {
1821                 LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
1822                 if (err)
1823                         g_error_free(err);
1824
1825                 goto ERROR;
1826         }
1827
1828         /* release */
1829         for (i = 0; i < arg_count; i++)
1830                 MC_FREEIF(argv2[i]);
1831
1832         MC_FREEIF(argv);
1833         MC_FREEIF(argv2);
1834         MC_FREEIF(argc);
1835
1836         /* done */
1837         initialized = TRUE;
1838
1839         MEDIACODEC_FLEAVE();
1840         return TRUE;
1841
1842 ERROR:
1843
1844         /* release */
1845         for (i = 0; i < arg_count; i++) {
1846                 LOGD("free[%d] : %s\n", i, argv2[i]);
1847                 MC_FREEIF(argv2[i]);
1848         }
1849
1850         MC_FREEIF(argv);
1851         MC_FREEIF(argv2);
1852         MC_FREEIF(argc);
1853
1854         return FALSE;
1855 }
1856
1857 mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name)
1858 {
1859         GstBus *bus = NULL;
1860
1861         MEDIACODEC_FENTER();
1862
1863         g_mutex_lock(&core->prepare_lock);
1864         if (core->prepare_count == 0) {
1865
1866                 if (!__mc_gst_init_gstreamer()) {
1867                         LOGE("gstreamer initialize fail");
1868                         g_mutex_unlock(&core->prepare_lock);
1869                         return MC_NOT_INITIALIZED;
1870                 }
1871                 core->codec = gst_element_factory_make(factory_name, NULL);
1872
1873                 if (!core->codec) {
1874                         LOGE("codec element create fail");
1875                         goto ERROR;
1876                 }
1877
1878                 LOGD("@%p v(%d)e(%d) create_pipeline", core, core->video, core->encoder);
1879                 MEDIACODEC_ELEMENT_SET_STATE(core->codec, GST_STATE_READY);
1880
1881                 /* create common elements */
1882                 core->pipeline = gst_pipeline_new(NULL);
1883
1884                 if (!core->pipeline) {
1885                         LOGE("pipeline create fail");
1886                         goto ERROR;
1887                 }
1888
1889                 core->appsrc = gst_element_factory_make("appsrc", NULL);
1890
1891                 if (!core->appsrc) {
1892                         LOGE("appsrc can't create");
1893                         goto ERROR;
1894                 }
1895
1896                 core->capsfilter = gst_element_factory_make("capsfilter", NULL);
1897
1898                 if (!core->capsfilter) {
1899                         LOGE("capsfilter can't create");
1900                         goto ERROR;
1901                 }
1902
1903                 core->fakesink = gst_element_factory_make("fakesink", NULL);
1904
1905                 if (!core->fakesink) {
1906                         LOGE("fakesink create fail");
1907                         goto ERROR;
1908                 }
1909                 g_object_set(core->fakesink, "enable-last-sample", FALSE, NULL);
1910
1911                 /*__mc_link_elements(core);*/
1912                 gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
1913
1914                 /* link elements */
1915                 if (!(gst_element_link_many(core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL))) {
1916                         LOGE("gst_element_link_many is failed");
1917                         goto ERROR;
1918                 }
1919
1920                 /* connect signals, bus watcher */
1921                 bus = gst_pipeline_get_bus(GST_PIPELINE(core->pipeline));
1922                 core->bus_whatch_id = gst_bus_add_watch(bus, __mc_gst_bus_callback, core);
1923                 core->thread_default = g_main_context_get_thread_default();
1924
1925                 /* set sync handler to get tag synchronously */
1926                 gst_bus_set_sync_handler(bus, __mc_gst_bus_sync_callback, core, NULL);
1927                 gst_object_unref(GST_OBJECT(bus));
1928
1929                 /* app src */
1930                 g_signal_connect(core->appsrc, "need-data", G_CALLBACK(__mc_gst_start_feed), core);
1931                 g_signal_connect(core->appsrc, "enough-data", G_CALLBACK(__mc_gst_stop_feed), core);
1932
1933                 /* connect handoff */
1934                 g_object_set(GST_OBJECT(core->fakesink), "signal-handoffs", TRUE, NULL);
1935                 core->signal_handoff = g_signal_connect(core->fakesink, "handoff", G_CALLBACK(__mc_gst_buffer_add), core);
1936
1937                 /* set state PLAYING */
1938                 MEDIACODEC_ELEMENT_SET_STATE(GST_ELEMENT_CAST(core->pipeline), GST_STATE_PLAYING);
1939
1940
1941         }
1942         core->prepare_count++;
1943         g_mutex_unlock(&core->prepare_lock);
1944
1945         MEDIACODEC_FLEAVE();
1946
1947         return MC_ERROR_NONE;
1948
1949 STATE_CHANGE_FAILED:
1950 ERROR:
1951
1952         if (core->codec)
1953                 gst_object_unref(GST_OBJECT(core->codec));
1954
1955         if (core->pipeline)
1956                 gst_object_unref(GST_OBJECT(core->pipeline));
1957
1958         if (core->appsrc)
1959                 gst_object_unref(GST_OBJECT(core->appsrc));
1960
1961         if (core->capsfilter)
1962                 gst_object_unref(GST_OBJECT(core->capsfilter));
1963
1964         if (core->fakesink)
1965                 gst_object_unref(GST_OBJECT(core->fakesink));
1966
1967         g_mutex_unlock(&core->prepare_lock);
1968
1969         return MC_ERROR;
1970 }
1971
1972 mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core)
1973 {
1974         int ret = MC_ERROR_NONE;
1975
1976         MEDIACODEC_FENTER();
1977
1978         g_mutex_lock(&core->prepare_lock);
1979         core->prepare_count--;
1980         if (core->prepare_count == 0) {
1981
1982                 if (core->pipeline) {
1983                         /* disconnect signal */
1984                         if (core->fakesink && GST_IS_ELEMENT(core->fakesink)) {
1985                                 if (g_signal_handler_is_connected(core->fakesink, core->signal_handoff)) {
1986                                         g_signal_handler_disconnect(core->fakesink, core->signal_handoff);
1987                                         LOGD("handoff signal destroy");
1988                                 }
1989                         }
1990
1991                         if (core->bus_whatch_id) {
1992                                 GSource *source = NULL;
1993                                 source = g_main_context_find_source_by_id(core->thread_default, core->bus_whatch_id);
1994                                 g_source_destroy(source);
1995                                 LOGD("bus_whatch_id destroy");
1996                         }
1997
1998                         MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL);
1999
2000                         gst_object_unref(GST_OBJECT(core->pipeline));
2001                         if (core->caps) {
2002                                 gst_caps_unref(core->caps);
2003                                 core->caps = NULL;
2004                         }
2005                 }
2006         }
2007
2008         LOGD("@%p v(%d)e(%d) destroy_pipeline : %d ", core, core->video, core->encoder, core->prepare_count);
2009         g_mutex_unlock(&core->prepare_lock);
2010
2011         MEDIACODEC_FLEAVE();
2012
2013         return ret;
2014
2015 STATE_CHANGE_FAILED:
2016         if (core->pipeline)
2017                 gst_object_unref(GST_OBJECT(core->pipeline));
2018
2019         LOGD("@%p v(%d)e(%d) destroy_pipeline failed", core, core->video, core->encoder);
2020         g_mutex_unlock(&core->prepare_lock);
2021
2022         return MC_ERROR;
2023 }
2024
2025 void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt)
2026 {
2027         g_mutex_lock(&core->ports[1]->mutex);
2028
2029         /* push it to output buffer queue */
2030         g_queue_push_tail(core->ports[1]->queue, out_pkt);
2031         g_cond_broadcast(&core->out_buffer_cond);
2032         g_atomic_int_inc(&core->ftb_count);
2033
2034         GstBuffer *buffer = NULL;
2035         media_packet_get_extra(out_pkt, (void**)&buffer);
2036         if (buffer) {
2037                 LOGD("dq : %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT,
2038                         core->ftb_count, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), GST_TIME_ARGS(GST_BUFFER_DURATION(buffer)));
2039         } else {
2040                 LOGD("dq : %d ", core->ftb_count);
2041         }
2042
2043         g_mutex_unlock(&core->ports[1]->mutex);
2044
2045         if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
2046                 ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER])
2047                         (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]);
2048         }
2049 }
2050
2051 void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data)
2052 {
2053         guint n;
2054         GstMemory *mem;
2055         GstMapInfo map = GST_MAP_INFO_INIT;
2056         media_packet_h out_pkt = NULL;
2057
2058         MEDIACODEC_FENTER();
2059
2060         mc_gst_core_t *core = (mc_gst_core_t *)data;
2061
2062         gst_buffer_ref(buffer);
2063
2064         n = gst_buffer_n_memory(buffer);
2065
2066         mem = gst_buffer_peek_memory(buffer, n-1);
2067
2068         gst_memory_map(mem, &map, GST_MAP_READ);
2069         LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size);
2070
2071         out_pkt = __mc_gst_make_media_packet(core, map.data, map.size);
2072
2073         LOGI("@%p(%d) out_pkt : %p", core, core->encoder, out_pkt);
2074         gst_memory_unmap(mem, &map);
2075
2076         if (out_pkt) {
2077                 media_packet_set_extra(out_pkt, buffer);
2078                 media_packet_set_pts(out_pkt, GST_BUFFER_TIMESTAMP(buffer));
2079                 media_packet_set_duration(out_pkt, GST_BUFFER_DURATION(buffer));
2080
2081                 if (core->need_codec_data) {
2082                         media_packet_set_flags(out_pkt, MEDIA_PACKET_CODEC_CONFIG);
2083                         core->need_codec_data = false;
2084                 }
2085
2086                 if (core->need_sync_flag) {
2087                         media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME);
2088                         core->need_sync_flag = false;
2089                 }
2090
2091                 __mc_push_output_to_queue(core, out_pkt);
2092         } else {
2093                 gst_buffer_unref(buffer);
2094                 LOGE("Failed to dequeue output packet");
2095         }
2096
2097         MEDIACODEC_FLEAVE();
2098
2099         return;
2100 }
2101
2102 int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data)
2103 {
2104         void *buffer = NULL;
2105         int i = 0;
2106         guint n;
2107         GstMemory *mem;
2108         GstMapInfo map = GST_MAP_INFO_INIT;
2109         MMVideoBuffer *mm_video_buf = NULL;
2110         GList *find;
2111
2112         MEDIACODEC_FENTER();
2113
2114         mc_gst_core_t *core = (mc_gst_core_t *)user_data;
2115
2116         g_mutex_lock(&core->ports[1]->mutex);
2117
2118         if ((find = g_queue_find(core->ports[1]->queue, packet))) {
2119                 LOGD("remove packet from queue");
2120                 g_queue_remove(core->ports[1]->queue, packet);
2121         }
2122
2123         g_mutex_unlock(&core->ports[1]->mutex);
2124
2125         g_atomic_int_dec_and_test(&core->ftb_count);
2126         media_packet_get_extra(packet, &buffer);
2127
2128         n = gst_buffer_n_memory(buffer);
2129
2130         if (n > 1) {
2131                 mem = gst_buffer_peek_memory(buffer, n-1);
2132                 gst_memory_map(mem, &map, GST_MAP_READ);
2133                 mm_video_buf = (MMVideoBuffer *)map.data;
2134
2135                 if (!mm_video_buf) {
2136                         LOGW("gstbuffer map.data is null");
2137                 } else {
2138                         for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
2139                                 if (mm_video_buf->handle.bo[i])
2140                                         tbm_bo_unref(mm_video_buf->handle.bo[i]);
2141                         }
2142                 }
2143                 gst_memory_unmap(mem, &map);
2144         }
2145         gst_buffer_unref((GstBuffer *)buffer);
2146         LOGD("@v(%d)e(%d)output port filled buffer(%d): %p", core->video, core->encoder, core->ftb_count, packet);
2147
2148         MEDIACODEC_FLEAVE();
2149
2150         return MEDIA_PACKET_FINALIZE;
2151 }
2152
2153 gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw)
2154 {
2155         gchar *format = NULL;
2156         media_format_h fmt = NULL;
2157         media_format_mimetype_e mimetype = 0;
2158
2159         media_packet_get_format(packet, &fmt);
2160         media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL);
2161         media_format_unref(fmt);
2162         LOGD("input packet mimetype : %x", mimetype);
2163
2164         switch (mimetype) {
2165         case MEDIA_FORMAT_I420:
2166                 format = "I420";
2167                 break;
2168         case MEDIA_FORMAT_NV12:
2169                 if (is_hw)
2170                         format = "SN12";
2171                 else
2172                         format = "NV12";
2173                 break;
2174         case MEDIA_FORMAT_ARGB:
2175                 format = "ARGB";
2176                 break;
2177         default:
2178                 break;
2179         }
2180         LOGD("input packet format : %s", format);
2181         return format;
2182 }
2183
2184 GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, media_packet_h pkt, bool codec_config)
2185 {
2186         int ret = MEDIA_PACKET_ERROR_NONE;
2187         GstMCBuffer *mc_buffer = NULL;
2188         void *buf_data = NULL;
2189         uint64_t buf_size = 0;
2190         uint64_t pts = 0;
2191         uint64_t dur = 0;
2192
2193         ret = media_packet_get_buffer_size(pkt, &buf_size);
2194         if (ret != MEDIA_PACKET_ERROR_NONE) {
2195                 LOGW("buffer size get fail");
2196                 return NULL;
2197         }
2198
2199         ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
2200         if (ret != MEDIA_PACKET_ERROR_NONE) {
2201                 LOGW("buffer size get fail");
2202                 return NULL;
2203         }
2204
2205         mc_buffer = gst_mediacodec_buffer_new(core, pkt, buf_size);
2206         if (mc_buffer == NULL) {
2207                 LOGW("failed to create inbuf");
2208                 return NULL;
2209         }
2210
2211         LOGD("pkt : %p, buf_size : %d", pkt, (int)buf_size);
2212
2213         ret = __mc_fill_input_buffer(core, pkt, mc_buffer);
2214         if (ret != MC_ERROR_NONE) {
2215                 LOGW("failed to fill inbuf: %s (ox%08x)", _mc_error_to_string(ret), ret);
2216                 return NULL;
2217         }
2218
2219         /* pts */
2220         media_packet_get_pts(pkt, &pts);
2221         GST_BUFFER_PTS(mc_buffer->buffer) = pts;
2222
2223         /* duration */
2224         media_packet_get_duration(pkt, &dur);
2225         GST_BUFFER_DURATION(mc_buffer->buffer) = dur;
2226
2227         return mc_buffer;
2228 }
2229
2230 media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size)
2231 {
2232         int ret = MEDIA_PACKET_ERROR_NONE;
2233         media_packet_h pkt = NULL;
2234
2235         ret = __mc_fill_output_buffer(core, data, size,  &pkt);
2236         if (ret != MC_ERROR_NONE) {
2237                 LOGW("failed to fill outbuf: %s (ox%08x)", _mc_error_to_string(ret), ret);
2238                 return NULL;
2239         }
2240
2241
2242         return pkt;
2243 }
2244
2245 int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt)
2246 {
2247         media_packet_h mediabuf = NULL;
2248         int ret = MC_ERROR_NONE;
2249
2250         MEDIACODEC_FENTER();
2251         if (media_packet_create_alloc(fmt, NULL, NULL, &mediabuf)) {
2252                 LOGE("media_packet_create_alloc failed\n");
2253                 ret = MC_ERROR;
2254                 goto ERROR;
2255         }
2256
2257         if (media_packet_set_flags(mediabuf, MEDIA_PACKET_END_OF_STREAM)) {
2258                 LOGE("unable to set EOS flag\n");
2259                 ret = MC_ERROR;
2260                 goto ERROR;
2261         }
2262
2263         *out_pkt = mediabuf;
2264         MEDIACODEC_FLEAVE();
2265
2266         return ret;
2267 ERROR:
2268         if (mediabuf)
2269                 media_packet_destroy(mediabuf);
2270         *out_pkt = NULL;
2271         MEDIACODEC_FLEAVE();
2272         return ret;
2273 }
2274
2275 gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data)
2276 {
2277         int ret  = MC_ERROR_NONE;
2278         mc_gst_core_t *core = (mc_gst_core_t *)data;
2279         LOGD("@%p v(%d)e(%d)", core, core->video, core->encoder);
2280
2281         switch (GST_MESSAGE_TYPE(msg)) {
2282
2283         case GST_MESSAGE_EOS:
2284                 _mc_send_eos_signal(core);
2285
2286                 media_packet_h out_pkt = NULL;
2287                 if (MC_ERROR_NONE == __mc_gst_create_eos_packet(core->output_fmt, &out_pkt)) {
2288                         __mc_push_output_to_queue(core, out_pkt);
2289                         LOGD("send eos packet.");
2290                 } else {
2291                         LOGE("failed to create eos packet.");
2292                 }
2293
2294                 if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
2295                         LOGD("eos callback invoked");
2296                         ((mc_eos_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])(core->user_data[_MEDIACODEC_EVENT_TYPE_EOS]);
2297                 }
2298
2299                 LOGD("End of stream\n");
2300                 break;
2301
2302         case GST_MESSAGE_ERROR:
2303         {
2304                 GError *error = NULL;
2305
2306                 gst_message_parse_error(msg, &error, NULL);
2307
2308                 if (!error) {
2309                         LOGW("GST error message parsing failed");
2310                         break;
2311                 }
2312
2313                 if (error) {
2314                         if (error->domain == GST_STREAM_ERROR)
2315                                 ret = __gst_handle_stream_error(core, error, msg);
2316                         else if (error->domain == GST_RESOURCE_ERROR)
2317                                 ret = __gst_handle_resource_error(core, error->code);
2318                         else if (error->domain == GST_LIBRARY_ERROR)
2319                                 ret = __gst_handle_library_error(core, error->code);
2320                         else if (error->domain == GST_CORE_ERROR)
2321                                 ret = __gst_handle_core_error(core, error->code);
2322                         else
2323                                 LOGW("Unexpected error has occured");
2324
2325                         if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
2326                                 ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
2327                                         (ret, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
2328                                         LOGW("Error : %s (ox%08x)", _mc_error_to_string(ret), ret);
2329                         }
2330                 }
2331                 g_error_free(error);
2332         }
2333                 break;
2334
2335         default:
2336                 break;
2337         }
2338
2339         return TRUE;
2340 }
2341
2342 static gboolean __mc_gst_check_useful_message(mc_gst_core_t *core, GstMessage *msg)
2343 {
2344         gboolean retval = false;
2345
2346         if (!core->pipeline) {
2347                 LOGE("mediacodec pipeline handle is null");
2348                 return true;
2349         }
2350
2351         switch (GST_MESSAGE_TYPE(msg)) {
2352         case GST_MESSAGE_TAG:
2353         case GST_MESSAGE_EOS:
2354         case GST_MESSAGE_ERROR:
2355         case GST_MESSAGE_WARNING:
2356                 retval = true;
2357                 break;
2358         default:
2359                 retval = false;
2360                 break;
2361         }
2362
2363         return retval;
2364 }
2365
2366 static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data)
2367 {
2368         mc_gst_core_t *core = (mc_gst_core_t *)data;
2369         GstBusSyncReply reply = GST_BUS_DROP;
2370
2371         LOGD("__mc_gst_bus_sync_callback is called");
2372
2373         if (!core->pipeline) {
2374                 LOGE("mediacodec pipeline handle is null");
2375                 return GST_BUS_PASS;
2376         }
2377
2378         if (!__mc_gst_check_useful_message(core, msg)) {
2379                 gst_message_unref(msg);
2380                 return GST_BUS_DROP;
2381         }
2382
2383         switch (GST_MESSAGE_TYPE(msg)) {
2384         case GST_MESSAGE_EOS:
2385         case GST_MESSAGE_ERROR:
2386                 __mc_gst_bus_callback(NULL, msg, core);
2387                 reply = GST_BUS_DROP;
2388                 break;
2389
2390         default:
2391                 reply = GST_BUS_PASS;
2392                 break;
2393         }
2394
2395         if (reply == GST_BUS_DROP)
2396                 gst_message_unref(msg);
2397
2398         return reply;
2399 }
2400
2401 static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt)
2402 {
2403         int i;
2404         int num_bos;
2405         tbm_surface_h surface = NULL;
2406         tbm_surface_info_s surface_info;
2407         tbm_bo_handle handle_bo;
2408
2409         if (!pkt) {
2410                 LOGE("output is null");
2411                 return NULL;
2412         }
2413
2414         MMVideoBuffer *mm_vbuffer = NULL;
2415         mm_vbuffer = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
2416         if (!mm_vbuffer) {
2417                 LOGE("Failed to alloc MMVideoBuffer");
2418                 return NULL;
2419         }
2420         memset(mm_vbuffer, 0x00, sizeof(MMVideoBuffer));
2421
2422         media_packet_get_tbm_surface(pkt, &surface);
2423         num_bos = tbm_surface_internal_get_num_bos(surface);
2424         int err = tbm_surface_get_info((tbm_surface_h)surface, &surface_info);
2425         if (err != TBM_SURFACE_ERROR_NONE) {
2426                 LOGE("get tbm surface is failed");
2427                 free(mm_vbuffer);
2428                 return NULL;
2429         }
2430
2431         for (i = 0; i < num_bos; i++) {
2432                 mm_vbuffer->handle.bo[i] = tbm_surface_internal_get_bo(surface, i);
2433                 LOGD("mm_vbuffer->handle.bo[%d] : %p", i, mm_vbuffer->handle.bo[i]);
2434         }
2435
2436 #ifdef TIZEN_PROFILE_LITE
2437         int phy_addr = 0;
2438         int phy_size = 0;
2439         tbm_bo_handle handle_fd = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM);
2440         if (__tbm_get_physical_addr_bo(handle_fd, &phy_addr, &phy_size) == 0) {
2441                 mm_vbuffer->handle.paddr[0] = (void *)phy_addr;
2442                 LOGD("mm_vbuffer->paddr : %p", mm_vbuffer->handle.paddr[0]);
2443         }
2444 #endif
2445
2446         mm_vbuffer->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
2447         mm_vbuffer->width[0] = surface_info.width;
2448         mm_vbuffer->height[0] = surface_info.height;
2449         mm_vbuffer->width[1] = surface_info.width;
2450         mm_vbuffer->height[1] = surface_info.height>>1;
2451         mm_vbuffer->size[0] = surface_info.planes[0].size;
2452         mm_vbuffer->size[1] = surface_info.planes[1].size;
2453         mm_vbuffer->stride_width[0] = surface_info.planes[0].stride;
2454         mm_vbuffer->stride_height[0] = surface_info.planes[0].size / surface_info.planes[0].stride;
2455         mm_vbuffer->stride_width[1] = surface_info.planes[1].stride;
2456         mm_vbuffer->stride_height[1] = surface_info.planes[1].size / surface_info.planes[1].stride;
2457
2458         if (mm_vbuffer->handle.bo[0]) {
2459                 handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_CPU);
2460                 mm_vbuffer->data[0] = handle_bo.ptr;
2461
2462                 handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM);
2463                 mm_vbuffer->handle.dmabuf_fd[0] = handle_bo.u32;
2464         }
2465
2466         if (mm_vbuffer->handle.bo[1]) {
2467                 handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_CPU);
2468                 mm_vbuffer->data[1] = handle_bo.ptr;
2469
2470                 handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_MM);
2471                 mm_vbuffer->handle.dmabuf_fd[1] = handle_bo.u32;
2472         } else {
2473                 mm_vbuffer->data[1] = mm_vbuffer->data[0] + mm_vbuffer->stride_width[0] * mm_vbuffer->stride_height[0];
2474         }
2475         mm_vbuffer->plane_num = 2;
2476
2477         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]);
2478
2479         return mm_vbuffer;
2480 }
2481
2482 static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer)
2483 {
2484         MEDIACODEC_FENTER();
2485
2486         if (!mc_buffer)
2487                 return;
2488
2489         mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core;
2490
2491         g_atomic_int_dec_and_test(&core->etb_count);
2492         if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
2493                 ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
2494                         (mc_buffer->pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
2495         }
2496
2497         LOGD("@v(%d)e(%d)input port emptied buffer(%d): %p", core->video, core->encoder, core->etb_count, mc_buffer->pkt);
2498         free(mc_buffer);
2499         mc_buffer = NULL;
2500
2501         MEDIACODEC_FLEAVE();
2502
2503         return;
2504 }
2505
2506 static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size)
2507 {
2508         GstMCBuffer *mc_buffer = NULL;
2509
2510         mc_buffer = (GstMCBuffer *)malloc(sizeof(*mc_buffer));
2511
2512         if (mc_buffer == NULL) {
2513                 LOGE("malloc fail");
2514                 return NULL;
2515         }
2516
2517         mc_buffer->buffer = gst_buffer_new();
2518         mc_buffer->buf_size = 0;
2519
2520         LOGD("creating buffer : %p, %p", mc_buffer, mc_buffer->buffer);
2521         mc_buffer->core = core;
2522         mc_buffer->pkt = pkt;
2523
2524         return mc_buffer;
2525 }
2526
2527 static gint __gst_handle_core_error(mc_gst_core_t *core, int code)
2528 {
2529         gint trans_err = MEDIACODEC_ERROR_NONE;
2530
2531         g_return_val_if_fail(core, MC_PARAM_ERROR);
2532
2533         switch (code) {
2534         case GST_CORE_ERROR_MISSING_PLUGIN:
2535                 return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
2536         case GST_CORE_ERROR_STATE_CHANGE:
2537         case GST_CORE_ERROR_SEEK:
2538         case GST_CORE_ERROR_NOT_IMPLEMENTED:
2539         case GST_CORE_ERROR_FAILED:
2540         case GST_CORE_ERROR_TOO_LAZY:
2541         case GST_CORE_ERROR_PAD:
2542         case GST_CORE_ERROR_THREAD:
2543         case GST_CORE_ERROR_NEGOTIATION:
2544         case GST_CORE_ERROR_EVENT:
2545         case GST_CORE_ERROR_CAPS:
2546         case GST_CORE_ERROR_TAG:
2547         case GST_CORE_ERROR_CLOCK:
2548         case GST_CORE_ERROR_DISABLED:
2549         default:
2550                 trans_err =  MEDIACODEC_ERROR_INVALID_STREAM;
2551                 break;
2552         }
2553
2554         return trans_err;
2555 }
2556
2557 static gint __gst_handle_library_error(mc_gst_core_t *core, int code)
2558 {
2559         gint trans_err = MEDIACODEC_ERROR_NONE;
2560
2561         g_return_val_if_fail(core, MC_PARAM_ERROR);
2562
2563         switch (code) {
2564         case GST_LIBRARY_ERROR_FAILED:
2565         case GST_LIBRARY_ERROR_TOO_LAZY:
2566         case GST_LIBRARY_ERROR_INIT:
2567         case GST_LIBRARY_ERROR_SHUTDOWN:
2568         case GST_LIBRARY_ERROR_SETTINGS:
2569         case GST_LIBRARY_ERROR_ENCODE:
2570         default:
2571                 trans_err =  MEDIACODEC_ERROR_INVALID_STREAM;
2572                 break;
2573         }
2574
2575         return trans_err;
2576 }
2577
2578
2579 static gint __gst_handle_resource_error(mc_gst_core_t *core, int code)
2580 {
2581         gint trans_err = MEDIACODEC_ERROR_NONE;
2582
2583         g_return_val_if_fail(core, MC_PARAM_ERROR);
2584
2585         switch (code) {
2586         case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
2587                 trans_err = MEDIACODEC_ERROR_NO_FREE_SPACE;
2588                 break;
2589         case GST_RESOURCE_ERROR_WRITE:
2590         case GST_RESOURCE_ERROR_FAILED:
2591         case GST_RESOURCE_ERROR_SEEK:
2592         case GST_RESOURCE_ERROR_TOO_LAZY:
2593         case GST_RESOURCE_ERROR_BUSY:
2594         case GST_RESOURCE_ERROR_OPEN_WRITE:
2595         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
2596         case GST_RESOURCE_ERROR_CLOSE:
2597         case GST_RESOURCE_ERROR_SYNC:
2598         case GST_RESOURCE_ERROR_SETTINGS:
2599         default:
2600                 trans_err = MEDIACODEC_ERROR_INTERNAL;
2601                 break;
2602         }
2603
2604         return trans_err;
2605 }
2606
2607 static gint __gst_handle_stream_error(mc_gst_core_t *core, GError* error, GstMessage * message)
2608 {
2609         gint trans_err = MEDIACODEC_ERROR_NONE;
2610
2611         g_return_val_if_fail(core, MC_PARAM_ERROR);
2612         g_return_val_if_fail(error, MC_PARAM_ERROR);
2613         g_return_val_if_fail(message, MC_PARAM_ERROR);
2614
2615         switch (error->code) {
2616         case GST_STREAM_ERROR_FAILED:
2617         case GST_STREAM_ERROR_TYPE_NOT_FOUND:
2618         case GST_STREAM_ERROR_DECODE:
2619         case GST_STREAM_ERROR_WRONG_TYPE:
2620         case GST_STREAM_ERROR_DECRYPT:
2621         case GST_STREAM_ERROR_DECRYPT_NOKEY:
2622         case GST_STREAM_ERROR_CODEC_NOT_FOUND:
2623                 trans_err = __gst_transform_gsterror(core, message, error);
2624                 break;
2625
2626         case GST_STREAM_ERROR_NOT_IMPLEMENTED:
2627         case GST_STREAM_ERROR_TOO_LAZY:
2628         case GST_STREAM_ERROR_ENCODE:
2629         case GST_STREAM_ERROR_DEMUX:
2630         case GST_STREAM_ERROR_MUX:
2631         case GST_STREAM_ERROR_FORMAT:
2632         default:
2633                 trans_err = MEDIACODEC_ERROR_INVALID_STREAM;
2634                 break;
2635         }
2636
2637         return trans_err;
2638 }
2639
2640 static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage * message, GError* error)
2641 {
2642         gchar *src_element_name = NULL;
2643         GstElement *src_element = NULL;
2644         GstElementFactory *factory = NULL;
2645         const gchar *klass = NULL;
2646
2647
2648         src_element = GST_ELEMENT_CAST(message->src);
2649         if (!src_element)
2650                 goto INTERNAL_ERROR;
2651
2652         src_element_name = GST_ELEMENT_NAME(src_element);
2653         if (!src_element_name)
2654                 goto INTERNAL_ERROR;
2655
2656         factory = gst_element_get_factory(src_element);
2657         if (!factory)
2658                 goto INTERNAL_ERROR;
2659
2660         klass = gst_element_factory_get_klass(factory);
2661         if (!klass)
2662                 goto INTERNAL_ERROR;
2663
2664         LOGD("error code=%d, msg=%s, src element=%s, class=%s\n",
2665                         error->code, error->message, src_element_name, klass);
2666
2667         switch (error->code) {
2668         case GST_STREAM_ERROR_DECODE:
2669         case GST_STREAM_ERROR_FAILED:
2670                 return MEDIACODEC_ERROR_INVALID_STREAM;
2671                 break;
2672
2673         case GST_STREAM_ERROR_CODEC_NOT_FOUND:
2674         case GST_STREAM_ERROR_TYPE_NOT_FOUND:
2675         case GST_STREAM_ERROR_WRONG_TYPE:
2676                 return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
2677                 break;
2678
2679         default:
2680                 return MEDIACODEC_ERROR_INTERNAL;
2681                 break;
2682         }
2683
2684         return MEDIACODEC_ERROR_INVALID_STREAM;
2685
2686 INTERNAL_ERROR:
2687         return MEDIACODEC_ERROR_INTERNAL;
2688 }
2689
2690 static int _mc_gst_flush_buffers(mc_gst_core_t *core)
2691 {
2692         gboolean ret = FALSE;
2693         GstEvent *event = NULL;
2694
2695         MEDIACODEC_FENTER();
2696
2697         _mc_gst_set_flush_input(core);
2698
2699         event = gst_event_new_seek(1.0, GST_FORMAT_BYTES, GST_SEEK_FLAG_FLUSH,
2700                         GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1);
2701
2702         ret = gst_element_send_event(core->appsrc, event);
2703         if (ret != TRUE) {
2704                 LOGE("failed to send seek event");
2705                 return MC_ERROR;
2706         }
2707
2708         _mc_gst_set_flush_output(core);
2709
2710         MEDIACODEC_FLEAVE();
2711
2712         return MC_ERROR_NONE;
2713 }
2714
2715
2716 static void _mc_gst_set_flush_input(mc_gst_core_t *core)
2717 {
2718         media_packet_h pkt = NULL;
2719
2720         MEDIACODEC_FENTER();
2721         LOGI("_mc_gst_set_flush_input is called");
2722
2723         while (!mc_async_queue_is_empty(core->available_queue->input)) {
2724                 pkt = mc_async_queue_pop_forced(core->available_queue->input);
2725                 g_atomic_int_dec_and_test(&core->etb_count);
2726                 LOGD("%p poped(%d)", pkt, core->etb_count);
2727
2728                 if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
2729                         ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
2730                                 (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
2731                 }
2732         }
2733
2734         mc_async_queue_flush(core->available_queue->input);
2735         MEDIACODEC_FLEAVE();
2736 }
2737
2738 static void _mc_gst_set_flush_output(mc_gst_core_t *core)
2739 {
2740         media_packet_h pkt = NULL;
2741
2742         MEDIACODEC_FENTER();
2743         g_mutex_lock(&core->ports[1]->mutex);
2744
2745         while (!g_queue_is_empty(core->ports[1]->queue)) {
2746                 pkt = g_queue_pop_head(core->ports[1]->queue);
2747                 g_atomic_int_dec_and_test(&core->ftb_count);
2748                 LOGD("%p poped(%d)", pkt, core->ftb_count);
2749                 if (pkt) {
2750                         media_packet_destroy(pkt);
2751                         LOGD("outpkt destroyed");
2752                         pkt = NULL;
2753                 }
2754         }
2755         g_mutex_unlock(&core->ports[1]->mutex);
2756         MEDIACODEC_FLEAVE();
2757 }
2758
2759 #ifdef TIZEN_PROFILE_LITE
2760 int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int *phy_addr, int *phy_size)
2761 {
2762         int tbm_bo_handle_fd;
2763
2764         int ret = 0;
2765
2766         tbm_bo_handle_fd = tbm_bo_handle_fd_t.u32;
2767
2768         int open_flags = O_RDWR;
2769         int ion_fd = -1;
2770
2771         struct ion_mmu_data mmu_data;
2772         struct ion_custom_data  custom_data;
2773
2774         mmu_data.fd_buffer = tbm_bo_handle_fd;
2775         custom_data.cmd = 4;
2776         custom_data.arg = (unsigned long)&mmu_data;
2777
2778         ion_fd = open("/dev/ion", open_flags);
2779         if (ion_fd < 0)
2780                 LOGE("[tbm_get_physical_addr_bo] ion_fd open device failed");
2781
2782         if (ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
2783                 LOGE("[tbm_get_physical_addr_bo] ION_IOC_CUSTOM failed");
2784                 ret = -1;
2785         }
2786
2787         if (!ret) {
2788                 *phy_addr = mmu_data.iova_addr;
2789                 *phy_size = mmu_data.iova_size;
2790         } else {
2791                 *phy_addr = 0;
2792                 *phy_size = 0;
2793                 LOGW("[tbm_get_physical_addr_bo] getting physical address is failed. phy_addr = 0");
2794         }
2795
2796         if (ion_fd != -1) {
2797                 close(ion_fd);
2798                 ion_fd = -1;
2799         }
2800
2801         return 0;
2802 }
2803 #endif
2804
2805 #if TIZEN_EXYNOS_SPECIFIC
2806 /*
2807  * Get tiled address of position(x,y)
2808  *
2809  * @param x_size
2810  *   width of tiled[in]
2811  *
2812  * @param y_size
2813  *   height of tiled[in]
2814  *
2815  * @param x_pos
2816  *   x position of tield[in]
2817  *
2818  * @param src_size
2819  *   y position of tield[in]
2820  *
2821  * @return
2822  *   address of tiled data
2823  */
2824 static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
2825 {
2826         int pixel_x_m1, pixel_y_m1;
2827         int roundup_x;
2828         int linear_addr0, linear_addr1, bank_addr ;
2829         int x_addr;
2830         int trans_addr;
2831
2832         pixel_x_m1 = x_size - 1;
2833         pixel_y_m1 = y_size - 1;
2834
2835         roundup_x = ((pixel_x_m1 >> 7) + 1);
2836
2837         x_addr = x_pos >> 2;
2838
2839         if ((y_size <= y_pos+32) && (y_pos < y_size) &&
2840                         (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
2841                 linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
2842                 linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
2843
2844                 if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
2845                         bank_addr = ((x_addr >> 4) & 0x1);
2846                 else
2847                         bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
2848         } else {
2849                 linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
2850                 linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
2851
2852                 if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
2853                         bank_addr = ((x_addr >> 4) & 0x1);
2854                 else
2855                         bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
2856         }
2857
2858         linear_addr0 = linear_addr0 << 2;
2859         trans_addr = (linear_addr1 << 13) | (bank_addr << 11) | linear_addr0;
2860
2861         return trans_addr;
2862 }
2863
2864 /*
2865  * Converts tiled data to linear
2866  * Crops left, top, right, buttom
2867  * 1. Y of NV12T to Y of YUV420P
2868  * 2. Y of NV12T to Y of YUV420S
2869  * 3. UV of NV12T to UV of YUV420S
2870  *
2871  * @param yuv420_dest
2872  *   Y or UV plane address of YUV420[out]
2873  *
2874  * @param nv12t_src
2875  *   Y or UV plane address of NV12T[in]
2876  *
2877  * @param yuv420_width
2878  *   Width of YUV420[in]
2879  *
2880  * @param yuv420_height
2881  *   Y: Height of YUV420, UV: Height/2 of YUV420[in]
2882  *
2883  * @param left
2884  *   Crop size of left
2885  *
2886  * @param top
2887  *   Crop size of top
2888  *
2889  * @param right
2890  *   Crop size of right
2891  *
2892  * @param buttom
2893  *   Crop size of buttom
2894  */
2895 static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src,
2896                 int yuv420_width, int yuv420_height,
2897                 int left, int top, int right, int buttom)
2898 {
2899         int i, j;
2900         int tiled_offset = 0, tiled_offset1 = 0;
2901         int linear_offset = 0;
2902         int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
2903
2904         temp3 = yuv420_width-right;
2905         temp1 = temp3-left;
2906         /* real width is greater than or equal 256 */
2907         if (temp1 >= 256) {
2908                 for (i = top; i < yuv420_height-buttom; i += 1) {
2909                         j = left;
2910                         temp3 = (j>>8)<<8;
2911                         temp3 = temp3>>6;
2912                         temp4 = i>>5;
2913                         if (temp4 & 0x1) {
2914                                 /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
2915                                 tiled_offset = temp4-1;
2916                                 temp1 = ((yuv420_width+127)>>7)<<7;
2917                                 tiled_offset = tiled_offset*(temp1>>6);
2918                                 tiled_offset = tiled_offset+temp3;
2919                                 tiled_offset = tiled_offset+2;
2920                                 temp1 = (temp3>>2)<<2;
2921                                 tiled_offset = tiled_offset+temp1;
2922                                 tiled_offset = tiled_offset<<11;
2923                                 tiled_offset1 = tiled_offset+2048*2;
2924                                 temp4 = 8;
2925                         } else {
2926                                 temp2 = ((yuv420_height+31)>>5)<<5;
2927                                 if ((i + 32) < temp2) {
2928                                         /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
2929                                         temp1 = temp3+2;
2930                                         temp1 = (temp1>>2)<<2;
2931                                         tiled_offset = temp3+temp1;
2932                                         temp1 = ((yuv420_width+127)>>7)<<7;
2933                                         tiled_offset = tiled_offset+temp4*(temp1>>6);
2934                                         tiled_offset = tiled_offset<<11;
2935                                         tiled_offset1 = tiled_offset + 2048 * 6;
2936                                         temp4 = 8;
2937                                 } else {
2938                                         /* even2 fomula: x+x_block_num*y */
2939                                         temp1 = ((yuv420_width+127)>>7)<<7;
2940                                         tiled_offset = temp4*(temp1>>6);
2941                                         tiled_offset = tiled_offset+temp3;
2942                                         tiled_offset = tiled_offset<<11;
2943                                         tiled_offset1 = tiled_offset+2048*2;
2944                                         temp4 = 4;
2945                                 }
2946                         }
2947
2948                         temp1 = i&0x1F;
2949                         tiled_offset = tiled_offset+64*(temp1);
2950                         tiled_offset1 = tiled_offset1+64*(temp1);
2951                         temp2 = yuv420_width-left-right;
2952                         linear_offset = temp2*(i-top);
2953                         temp3 = ((j+256)>>8)<<8;
2954                         temp3 = temp3-j;
2955                         temp1 = left&0x3F;
2956
2957                         if (temp3 > 192) {
2958                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+temp1, 64-temp1);
2959                                 temp2 = ((left+63)>>6)<<6;
2960                                 temp3 = ((yuv420_width-right)>>6)<<6;
2961
2962                                 if (temp2 == temp3)
2963                                         temp2 = yuv420_width-right-(64-temp1);
2964
2965                                 memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset+2048, 64);
2966                                 memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1, 64);
2967                                 memcpy(yuv420_dest+linear_offset+192-temp1, nv12t_src+tiled_offset1+2048, 64);
2968                                 linear_offset = linear_offset+256-temp1;
2969                         } else if (temp3 > 128) {
2970                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+2048+temp1, 64-temp1);
2971                                 memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1, 64);
2972                                 memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1+2048, 64);
2973                                 linear_offset = linear_offset+192-temp1;
2974                         } else if (temp3 > 64) {
2975                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+temp1, 64-temp1);
2976                                 memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1+2048, 64);
2977                                 linear_offset = linear_offset+128-temp1;
2978                         } else if (temp3 > 0) {
2979                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+2048+temp1, 64-temp1);
2980                                 linear_offset = linear_offset+64-temp1;
2981                         }
2982
2983                         tiled_offset = tiled_offset+temp4*2048;
2984                         j = (left>>8)<<8;
2985                         j = j + 256;
2986                         temp2 = yuv420_width-right-256;
2987                         for (; j <= temp2; j += 256) {
2988                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
2989                                 tiled_offset1 = tiled_offset1+temp4*2048;
2990                                 memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
2991                                 memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
2992                                 tiled_offset = tiled_offset+temp4*2048;
2993                                 memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, 64);
2994                                 linear_offset = linear_offset+256;
2995                         }
2996
2997                         tiled_offset1 = tiled_offset1+temp4*2048;
2998                         temp2 = yuv420_width-right-j;
2999                         if (temp2 > 192) {
3000                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
3001                                 memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
3002                                 memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
3003                                 memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, temp2-192);
3004                         } else if (temp2 > 128) {
3005                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
3006                                 memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
3007                                 memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, temp2-128);
3008                         } else if (temp2 > 64) {
3009                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
3010                                 memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, temp2-64);
3011                         } else {
3012                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
3013                         }
3014                 }
3015         } else if (temp1 >= 64) {
3016                 for (i = top; i < (yuv420_height-buttom); i += 1) {
3017                         j = left;
3018                         tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
3019                         temp2 = ((j+64)>>6)<<6;
3020                         temp2 = temp2-j;
3021                         linear_offset = temp1*(i-top);
3022                         temp4 = j&0x3;
3023                         tiled_offset = tiled_offset+temp4;
3024                         memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
3025                         linear_offset = linear_offset+temp2;
3026                         j = j+temp2;
3027                         if ((j+64) <= temp3) {
3028                                 tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
3029                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
3030                                 linear_offset = linear_offset+64;
3031                                 j = j+64;
3032                         }
3033                         if ((j+64) <= temp3) {
3034                                 tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
3035                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
3036                                 linear_offset = linear_offset+64;
3037                                 j = j+64;
3038                         }
3039                         if (j < temp3) {
3040                                 tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
3041                                 temp2 = temp3-j;
3042                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
3043                         }
3044                 }
3045         } else {
3046                 for (i = top; i < (yuv420_height-buttom); i += 1) {
3047                         linear_offset = temp1*(i-top);
3048                         for (j = left; j < (yuv420_width - right); j += 2) {
3049                                 tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
3050                                 temp4 = j&0x3;
3051                                 tiled_offset = tiled_offset+temp4;
3052                                 memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 2);
3053                                 linear_offset = linear_offset+2;
3054                         }
3055                 }
3056         }
3057 }
3058 #endif
3059
3060 void _mc_send_eos_signal(mc_gst_core_t *core)
3061 {
3062         g_mutex_lock(&core->eos_mutex);
3063         core->eos = FALSE;
3064         g_cond_broadcast(&core->eos_cond);
3065         g_mutex_unlock(&core->eos_mutex);
3066         LOGD("send EOS signal");
3067 }
3068
3069 void _mc_wait_for_eos(mc_gst_core_t *core)
3070 {
3071         g_mutex_lock(&core->eos_mutex);
3072         core->eos = TRUE;
3073         LOGD("waiting for EOS");
3074
3075         while (core->eos)
3076                 g_cond_wait(&core->eos_cond, &core->eos_mutex);
3077
3078         LOGD("received EOS");
3079         g_mutex_unlock(&core->eos_mutex);
3080 }
3081
3082 const gchar * _mc_error_to_string(mc_ret_e err)
3083 {
3084         guint err_u = (guint) err;
3085
3086         switch (err_u) {
3087         case MC_ERROR:
3088                 return "Error";
3089         case MC_PARAM_ERROR:
3090                 return "Parameter error";
3091         case MC_INVALID_ARG:
3092                 return "Invailid argument";
3093         case MC_PERMISSION_DENIED:
3094                 return "Permission denied";
3095         case MC_INVALID_STATUS:
3096                 return "Invalid status";
3097         case MC_NOT_SUPPORTED:
3098                 return "Not supported";
3099         case MC_INVALID_IN_BUF:
3100                 return "Invalid inputbuffer";
3101         case MC_INVALID_OUT_BUF:
3102                 return "Invalid outputbuffer";
3103         case MC_INTERNAL_ERROR:
3104                 return "Internal error";
3105         case MC_HW_ERROR:
3106                 return "Hardware error";
3107         case MC_NOT_INITIALIZED:
3108                 return "Not initialized";
3109         case MC_INVALID_STREAM:
3110                 return "Invalid stream";
3111         case MC_CODEC_NOT_FOUND:
3112                 return "Codec not found";
3113         case MC_ERROR_DECODE:
3114                 return "Decode error";
3115         case MC_OUTPUT_BUFFER_EMPTY:
3116                 return "Outputbuffer empty";
3117         case MC_OUTPUT_BUFFER_OVERFLOW:
3118                 return "Outputbuffer overflow";
3119         case MC_MEMORY_ALLOCED:
3120                 return "Memory allocated";
3121         case MC_COURRPTED_INI:
3122                 return "Courrpted ini";
3123         default:
3124                 return "Unknown error";
3125
3126         }
3127 }
3128
3129 int _mediacodec_get_mime(mc_gst_core_t *core)
3130 {
3131         media_format_mimetype_e mime = MEDIA_FORMAT_MAX;
3132
3133         switch (core->codec_id) {
3134         case MEDIACODEC_H264:
3135                 if (core->encoder)
3136                         mime = (core->is_hw) ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
3137                 else
3138                         mime = MEDIA_FORMAT_H264_SP;
3139                 break;
3140         case MEDIACODEC_MPEG4:
3141                 if (core->encoder)
3142                         mime = (core->is_hw) ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
3143                 else
3144                         mime = MEDIA_FORMAT_MPEG4_SP;
3145
3146                 break;
3147         case MEDIACODEC_H263:
3148                 if (core->encoder)
3149                         mime = (core->is_hw) ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
3150                 else
3151                         mime = MEDIA_FORMAT_H263P;
3152
3153                 break;
3154         case MEDIACODEC_AAC:
3155                 if (core->encoder)
3156                         mime = MEDIA_FORMAT_PCM;
3157                 else
3158                         mime = MEDIA_FORMAT_AAC;
3159
3160                 break;
3161         case MEDIACODEC_AAC_HE:
3162                 if (core->encoder)
3163                         mime = MEDIA_FORMAT_PCM;
3164                 else
3165                         mime = MEDIA_FORMAT_AAC_HE;
3166
3167                 break;
3168         case MEDIACODEC_AAC_HE_PS:
3169                 break;
3170         case MEDIACODEC_MP3:
3171                 mime = MEDIA_FORMAT_MP3;
3172                 break;
3173         case MEDIACODEC_VORBIS:
3174                 break;
3175         case MEDIACODEC_FLAC:
3176                 break;
3177         case MEDIACODEC_WMAV1:
3178                 break;
3179         case MEDIACODEC_WMAV2:
3180                 break;
3181         case MEDIACODEC_WMAPRO:
3182                 break;
3183         case MEDIACODEC_WMALSL:
3184                 break;
3185         case MEDIACODEC_AMR_NB:
3186                 mime = MEDIA_FORMAT_AMR_NB;
3187                 break;
3188         case MEDIACODEC_AMR_WB:
3189                 mime = MEDIA_FORMAT_AMR_WB;
3190                 break;
3191         default:
3192                 LOGE("NOT SUPPORTED!!!!");
3193                 break;
3194         }
3195         return mime;
3196 }
3197
3198 mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *pkt_pool)
3199 {
3200         int curr_size;
3201         int max_size, min_size;
3202         media_format_mimetype_e mime_format = MEDIA_FORMAT_MAX;
3203         media_format_h fmt_handle = NULL;
3204         media_packet_pool_h pool = NULL;
3205         mc_gst_core_t *core = NULL;
3206
3207         if (!mc_handle)
3208                 return MC_PARAM_ERROR;
3209
3210         core = (mc_gst_core_t *)mc_handle->core;
3211
3212         int ret = media_packet_pool_create(&pool);
3213
3214         if (ret != MEDIA_PACKET_ERROR_NONE) {
3215                 LOGE("media_packet_pool_create failed");
3216                 return MC_ERROR;
3217         }
3218
3219         if (media_format_create(&fmt_handle) != MEDIA_FORMAT_ERROR_NONE) {
3220                 LOGE("media format create failed");
3221                 return MC_ERROR;
3222         }
3223
3224         mime_format = _mediacodec_get_mime(core);
3225
3226         if (core->video) {
3227                 if (core->encoder) {
3228                         media_format_set_video_mime(fmt_handle, mime_format);
3229                         media_format_set_video_width(fmt_handle, mc_handle->info.encoder.width);
3230                         media_format_set_video_height(fmt_handle, mc_handle->info.encoder.height);
3231                         media_format_set_video_avg_bps(fmt_handle, mc_handle->info.encoder.bitrate);
3232                 } else {
3233                         media_format_set_video_mime(fmt_handle, mime_format);
3234                         media_format_set_video_width(fmt_handle, mc_handle->info.decoder.width);
3235                         media_format_set_video_height(fmt_handle, mc_handle->info.decoder.height);
3236                 }
3237
3238         } else {
3239                 if (core->encoder) {
3240                         media_format_set_audio_mime(fmt_handle, mime_format);
3241                         media_format_set_audio_channel(fmt_handle, mc_handle->info.encoder.channel);
3242                         media_format_set_audio_samplerate(fmt_handle, mc_handle->info.encoder.samplerate);
3243                         media_format_set_audio_bit(fmt_handle, mc_handle->info.encoder.bit);
3244                 } else {
3245                         media_format_set_audio_mime(fmt_handle, mime_format);
3246                         media_format_set_audio_channel(fmt_handle, mc_handle->info.decoder.channel);
3247                         media_format_set_audio_samplerate(fmt_handle, mc_handle->info.decoder.samplerate);
3248                         media_format_set_audio_bit(fmt_handle, mc_handle->info.decoder.bit);
3249                 }
3250         }
3251
3252         ret = media_packet_pool_set_media_format(pool, fmt_handle);
3253         if (ret != MEDIA_PACKET_ERROR_NONE) {
3254                 LOGE("media_packet_pool_set_media_format failed");
3255                 return MC_ERROR;
3256         }
3257
3258         /* will use default size temporarily */
3259         max_size = core->encoder ? DEFAULT_ENC_POOL_SIZE : DEFAULT_DEC_POOL_SIZE;
3260
3261         min_size = max_size;
3262         ret = media_packet_pool_set_size(pool, min_size, max_size);
3263         if (ret != MEDIA_PACKET_ERROR_NONE) {
3264                 LOGE("media_packet_pool_set_size failed");
3265                 return MC_ERROR;
3266         }
3267
3268         ret = media_packet_pool_allocate(pool);
3269         if (ret != MEDIA_PACKET_ERROR_NONE) {
3270                 LOGE("media_packet_pool_allocate failed");
3271                 return MC_OUT_OF_MEMORY;
3272         }
3273         media_packet_pool_get_size(pool, &min_size, &max_size, &curr_size);
3274         LOGD("curr_size is  %d min_size is %d and max_size is %d \n", curr_size, min_size, max_size);
3275
3276         *pkt_pool = pool;
3277         return MC_ERROR_NONE;
3278 }