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