src/mm_camcorder_util.c

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23 |  INCLUDE FILES                                                                        |
  24 =======================================================================================*/
  25 #include <stdio.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <sys/vfs.h> /* struct statfs */
  29 #include <sys/time.h> /* gettimeofday */
  30 #include <sys/stat.h>
  31 #include <gst/video/video-info.h>
  32 #include <gio/gio.h>
  33
  34 #include "mm_camcorder_internal.h"
  35 #include "mm_camcorder_util.h"
  36 #include "mm_camcorder_sound.h"
  37 #include <mm_util_imgp.h>
  38 #include <mm_util_jpeg.h>
  39
  40 /*-----------------------------------------------------------------------
  41 |    GLOBAL VARIABLE DEFINITIONS for internal                           |
  42 -----------------------------------------------------------------------*/
  43
  44 /*-----------------------------------------------------------------------
  45 |    LOCAL VARIABLE DEFINITIONS for internal                            |
  46 -----------------------------------------------------------------------*/
  47 #define TIME_STRING_MAX_LEN     64
  48
  49 #define FPUTC_CHECK(x_char, x_file)\
  50 {\
  51         if (fputc(x_char, x_file) == EOF) \
  52         {\
  53                 _mmcam_dbg_err("[Critical] fputc() returns fail.\n");   \
  54                 return FALSE;\
  55         }\
  56 }
  57 #define FPUTS_CHECK(x_str, x_file)\
  58 {\
  59         if (fputs(x_str, x_file) == EOF) \
  60         {\
  61                 _mmcam_dbg_err("[Critical] fputs() returns fail.\n");\
  62                 SAFE_FREE(str); \
  63                 return FALSE;\
  64         }\
  65 }
  66
  67 /*---------------------------------------------------------------------------
  68 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
  69 ---------------------------------------------------------------------------*/
  70 /* STATIC INTERNAL FUNCTION */
  71
  72 //static gint           skip_mdat(FILE *f);
  73 static guint16           get_language_code(const char *str);
  74 static gchar*            str_to_utf8(const gchar *str);
  75 static inline gboolean   write_tag(FILE *f, const gchar *tag);
  76 static inline gboolean   write_to_32(FILE *f, guint val);
  77 static inline gboolean   write_to_16(FILE *f, guint val);
  78 static inline gboolean   write_to_24(FILE *f, guint val);
  79 #ifdef _USE_YUV_TO_RGB888_
  80 static gboolean _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
  81 #endif /* _USE_YUV_TO_RGB888_ */
  82 static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
  83 static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
  84 static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
  85
  86
  87 /*===========================================================================================
  88 |                                                                                                                                                                                       |
  89 |  FUNCTION DEFINITIONS                                                                                                                                         |
  90 |                                                                                                                                                                                       |
  91 ========================================================================================== */
  92 /*---------------------------------------------------------------------------
  93 |    GLOBAL FUNCTION DEFINITIONS:                                                                                       |
  94 ---------------------------------------------------------------------------*/
  95
  96 static int __gdbus_method_call_sync(const char* bus_name, const char* object, const char* iface,
  97                                                         const char* method, GVariant* args, GVariant** result, bool is_sync)
  98 {
  99         int ret = MM_ERROR_NONE;
 100         GError *err = NULL;
 101         GVariant* dbus_reply = NULL;
 102         GDBusConnection *conn = NULL;
 103
 104         if (!object || !iface || !method) {
 105                 _mmcam_dbg_err("Invalid Argument");
 106                 if (!object)
 107                         _mmcam_dbg_err("object null");
 108                 if (!iface)
 109                         _mmcam_dbg_err("iface null");
 110                 if (!method)
 111                         _mmcam_dbg_err("method null");
 112                 return MM_ERROR_INVALID_ARGUMENT;
 113         }
 114
 115         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 116         if (conn == NULL) {
 117                 _mmcam_dbg_err("get connection failed");
 118                 return MM_ERROR_CAMCORDER_INTERNAL;
 119         }
 120
 121         _mmcam_dbg_log("Dbus call with obj : '%s' iface : '%s' method : '%s'", object, iface, method);
 122
 123         if (is_sync) {
 124                 dbus_reply = g_dbus_connection_call_sync(conn, bus_name, object, iface,
 125                                                          method, args, NULL, G_DBUS_CALL_FLAGS_NONE,
 126                                                          G_DBUS_REPLY_TIMEOUT, NULL, &err);
 127                 if (dbus_reply) {
 128                         _mmcam_dbg_log("Method Call '%s.%s' Success", iface, method);
 129                         *result = dbus_reply;
 130                 } else {
 131                         _mmcam_dbg_err("dbus method call sync reply failed");
 132                         ret = MM_ERROR_CAMCORDER_INTERNAL;
 133                 }
 134         } else {
 135                 g_dbus_connection_call(conn, bus_name, object, iface, \
 136                                                              method, args, \
 137                                                              NULL, G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, \
 138                                                              NULL, NULL, NULL);
 139         }
 140         g_object_unref(conn);
 141         return ret;
 142 }
 143
 144 gint32 _mmcamcorder_double_to_fix(gdouble d_number)
 145 {
 146         return (gint32) (d_number * 65536.0);
 147 }
 148
 149 // find top level tag only, do not use this function for finding sub level tags
 150 gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 151 {
 152         size_t read_item = 0;
 153         guchar buf[8];
 154
 155         if (do_rewind) {
 156                 rewind(f);
 157         }
 158
 159         while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
 160                 uint64_t buf_size = 0;
 161                 uint32_t buf_fourcc = 0;
 162
 163                 if (read_item < 8) {
 164                         _mmcam_dbg_err("fread failed : %d", read_item);
 165                         break;
 166                 }
 167
 168                 buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
 169
 170                 if (tag_fourcc == buf_fourcc) {
 171                         _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 172                         return TRUE;
 173                 } else {
 174                         _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
 175
 176                         buf_size = _mmcamcorder_get_container_size(buf);
 177
 178                         /* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
 179                         if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
 180                             buf_size == 1) {
 181                                 read_item = fread(&buf, sizeof(guchar), 8, f);
 182                                 if (read_item < 8) {
 183                                         _mmcam_dbg_err("fread failed");
 184                                         return FALSE;
 185                                 }
 186
 187                                 buf_size = _mmcamcorder_get_container_size64(buf);
 188                                 buf_size = buf_size - 16; /* include tag and large file flag(size 1) */
 189                         } else {
 190                                 buf_size = buf_size - 8; /* include tag */
 191                         }
 192
 193                         _mmcam_dbg_log("seek %llu", buf_size);
 194                         if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) {
 195                                 _mmcam_dbg_err("fseeko() fail");
 196                                 return FALSE;
 197                         }
 198                 }
 199         }
 200
 201         _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 202
 203         return FALSE;
 204 }
 205
 206 gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 207 {
 208         size_t read_item = 0;
 209         guchar buf[8];
 210
 211         if (do_rewind) {
 212                 rewind(f);
 213         }
 214
 215         while ((read_item = fread(&buf, sizeof(guchar), 8, f))  > 0) {
 216                 uint64_t buf_size = 0;
 217                 uint32_t buf_fourcc = 0;
 218
 219                 if (read_item < 8) {
 220                         _mmcam_dbg_err("fread failed : %d", read_item);
 221                         break;
 222                 }
 223
 224                 buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
 225
 226                 if (tag_fourcc == buf_fourcc) {
 227                         _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 228                         return TRUE;
 229                 } else if (buf_fourcc == MMCAM_FOURCC('m','o','o','v') &&
 230                            tag_fourcc != buf_fourcc) {
 231                         if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE)) {
 232                                 return TRUE;
 233                         } else {
 234                                 continue;
 235                         }
 236                 } else {
 237                         _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
 238
 239                         buf_size = _mmcamcorder_get_container_size(buf);
 240
 241                         /* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
 242                         if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
 243                             buf_size == 1) {
 244                                 read_item = fread(&buf, sizeof(guchar), 8, f);
 245                                 if (read_item < 8) {
 246                                         _mmcam_dbg_err("fread failed");
 247                                         return FALSE;
 248                                 }
 249
 250                                 buf_size = _mmcamcorder_get_container_size64(buf);
 251                                 buf_size = buf_size - 16; /* include tag and large file flag(size 1) */
 252                         } else {
 253                                 buf_size = buf_size - 8; /* include tag */
 254                         }
 255
 256                         _mmcam_dbg_log("seek %llu", buf_size);
 257                         if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) {
 258                                 _mmcam_dbg_err("fseeko() fail");
 259                                 return FALSE;
 260                         }
 261                 }
 262         }
 263
 264         _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 265
 266         return FALSE;
 267 }
 268
 269 gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
 270 {
 271         _mmcam_dbg_log("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos);
 272         if(fseeko(f, prev_pos, SEEK_SET) != 0)
 273         {
 274                 _mmcam_dbg_err("fseeko() fail");
 275                 return FALSE;
 276         }
 277
 278         if (!write_to_32(f, curr_pos -prev_pos))
 279                 return FALSE;
 280
 281         if(fseeko(f, curr_pos, SEEK_SET) != 0)
 282         {
 283                 _mmcam_dbg_err("fseeko() fail");
 284                 return FALSE;
 285         }
 286
 287         return TRUE;
 288 }
 289
 290 gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info)
 291 {
 292         gint64 current_pos, pos;
 293         gchar *str = NULL;
 294
 295         _mmcam_dbg_log("");
 296
 297         if((pos = ftello(f))<0)
 298         {
 299                 _mmcam_dbg_err("ftello() returns negative value");
 300                 return FALSE;
 301         }
 302
 303         if(!write_to_32(f, 0)) //size
 304                 return FALSE;
 305
 306         if(!write_tag(f, "loci"))       // type
 307                 return FALSE;
 308
 309         FPUTC_CHECK(0, f);              // version
 310
 311         if(!write_to_24(f, 0))  // flags
 312                 return FALSE;
 313
 314         if(!write_to_16(f, get_language_code("eng"))) // language
 315                 return FALSE;
 316
 317         str = str_to_utf8("location_name");
 318
 319         FPUTS_CHECK(str, f); // name
 320         SAFE_FREE(str);
 321
 322         FPUTC_CHECK('\0', f);
 323         FPUTC_CHECK(0, f);              //role
 324
 325         if(!write_to_32(f, info.longitude))     // Longitude
 326                 return FALSE;
 327
 328         if(!write_to_32(f, info.latitude)) // Latitude
 329                 return FALSE;
 330
 331         if(! write_to_32(f, info.altitude))     // Altitude
 332                 return FALSE;
 333
 334         str = str_to_utf8("Astronomical_body");
 335         FPUTS_CHECK(str, f);//Astronomical_body
 336         SAFE_FREE(str);
 337
 338         FPUTC_CHECK('\0', f);
 339
 340         str = str_to_utf8("Additional_notes");
 341         FPUTS_CHECK(str, f); // Additional_notes
 342         SAFE_FREE(str);
 343
 344         FPUTC_CHECK('\0', f);
 345
 346         if((current_pos = ftello(f))<0)
 347         {
 348                 _mmcam_dbg_err("ftello() returns negative value");
 349                 return FALSE;
 350         }
 351
 352         if(! _mmcamcorder_update_size(f, pos, current_pos))
 353                 return FALSE;
 354
 355         return TRUE;
 356 }
 357
 358 void _mmcamcorder_write_Latitude(FILE *f,int value) {
 359         char s_latitude[9];
 360         int l_decimal = 0;
 361         int l_below_decimal = 0;
 362
 363         l_decimal = value / 10000;
 364         if (value < 0) {
 365                 if( l_decimal == 0) {
 366                         snprintf(s_latitude, 5, "-%.2d.", l_decimal);
 367                 } else {
 368                         snprintf(s_latitude, 5, "%.2d.", l_decimal);
 369                 }
 370         } else {
 371                 snprintf(s_latitude, 5, "+%.2d.", l_decimal);
 372         }
 373
 374         l_below_decimal = value - (l_decimal * 10000);
 375         if (l_below_decimal < 0) {
 376                 l_below_decimal = -l_below_decimal;
 377         }
 378         snprintf(&s_latitude[4], 5, "%.4d", l_below_decimal);
 379
 380         write_tag(f, s_latitude);
 381 }
 382
 383 void _mmcamcorder_write_Longitude(FILE *f,int value) {
 384         char s_longitude[10];
 385         int l_decimal = 0;
 386         int l_below_decimal = 0;
 387
 388         l_decimal = value / 10000;
 389         if (value < 0) {
 390                 if( l_decimal == 0) {
 391                         snprintf(s_longitude, 6, "-%.3d.", l_decimal);
 392                 } else {
 393                         snprintf(s_longitude, 6, "%.3d.", l_decimal);
 394                 }
 395         } else {
 396                 snprintf(s_longitude, 6, "+%.3d.", l_decimal);
 397         }
 398
 399         l_below_decimal = value - (l_decimal * 10000);
 400         if (l_below_decimal < 0) {
 401                 l_below_decimal = -l_below_decimal;
 402         }
 403         snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal);
 404
 405         write_tag(f, s_longitude);
 406 }
 407
 408 #define D_GEOGRAPH "\xA9xyz"
 409 // 0x0012 -> latitude(8) + longitude(9) + seperator(1) = 18
 410 // 0x15c7 -> encode in english
 411 #define D_INFO_GEOGRAPH 0x001215c7
 412
 413 gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) {
 414
 415         gint64 current_pos, pos;
 416
 417         _mmcam_dbg_log("");
 418
 419         if((pos = ftello(f))<0)
 420         {
 421                 _mmcam_dbg_err("ftello() returns negative value");
 422                 return FALSE;
 423         }
 424
 425         if(!write_to_32(f, 0))  //size
 426                 return FALSE;
 427         // tag -> .xyz
 428         if(!write_tag(f, D_GEOGRAPH))   // type
 429                 return FALSE;
 430
 431         if(!write_to_32(f, D_INFO_GEOGRAPH))
 432                 return FALSE;
 433
 434         _mmcamcorder_write_Latitude(f,info.latitude);
 435         _mmcamcorder_write_Longitude(f,info.longitude);
 436
 437         FPUTC_CHECK(0x2F, f);
 438
 439         if((current_pos = ftello(f))<0)
 440         {
 441                 _mmcam_dbg_err("ftello() returns negative value");
 442                 return FALSE;
 443         }
 444
 445         if(! _mmcamcorder_update_size(f, pos, current_pos))
 446                 return FALSE;
 447
 448         return TRUE;
 449 }
 450
 451
 452 gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationInfo info, _MMCamcorderLocationInfo geotag)
 453 {
 454         gint64 current_pos, pos;
 455
 456         _mmcam_dbg_log("gps enable : %d", gps_enable);
 457         if (gps_enable == FALSE) {
 458                 _mmcam_dbg_log("no need to write udta");
 459                 return TRUE;
 460         }
 461
 462         if ((pos = ftello(f))<0) {
 463                 _mmcam_dbg_err("ftello() returns negative value");
 464                 return FALSE;
 465         }
 466
 467         /* size */
 468         if (!write_to_32(f, 0)) {
 469                 _mmcam_dbg_err("failed to write size");
 470                 return FALSE;
 471         }
 472
 473         /* type */
 474         if (!write_tag(f, "udta")) {
 475                 _mmcam_dbg_err("failed to write type udta");
 476                 return FALSE;
 477         }
 478
 479         if (gps_enable) {
 480                 if (!_mmcamcorder_write_loci(f, info)) {
 481                         _mmcam_dbg_err("failed to write loci");
 482                         return FALSE;
 483                 }
 484
 485                 if (!_mmcamcorder_write_geodata(f,geotag)) {
 486                         _mmcam_dbg_err("failed to write geodata");
 487                         return FALSE;
 488                 }
 489         }
 490
 491         if ((current_pos = ftello(f))<0) {
 492                 _mmcam_dbg_err("ftello() returns negative value");
 493                 return FALSE;
 494         }
 495
 496         if (!_mmcamcorder_update_size(f, pos, current_pos)) {
 497                 _mmcam_dbg_err("failed to update size");
 498                 return FALSE;
 499         }
 500
 501         _mmcam_dbg_log("done");
 502
 503         return TRUE;
 504 }
 505
 506
 507 guint64 _mmcamcorder_get_container_size(const guchar *size)
 508 {
 509         guint64 result = 0;
 510         guint64 temp = 0;
 511
 512         temp = size[0];
 513         result = temp << 24;
 514         temp = size[1];
 515         result = result | (temp << 16);
 516         temp = size[2];
 517         result = result | (temp << 8);
 518         result = result | size[3];
 519
 520         _mmcam_dbg_log("result : %llu", result);
 521
 522         return result;
 523 }
 524
 525
 526 guint64 _mmcamcorder_get_container_size64(const guchar *size)
 527 {
 528         guint64 result = 0;
 529         guint64 temp = 0;
 530
 531         temp = size[0];
 532         result = temp << 56;
 533         temp = size[1];
 534         result = result | (temp << 48);
 535         temp = size[2];
 536         result = result | (temp << 40);
 537         temp = size[3];
 538         result = result | (temp << 32);
 539         temp = size[4];
 540         result = result | (temp << 24);
 541         temp = size[5];
 542         result = result | (temp << 16);
 543         temp = size[6];
 544         result = result | (temp << 8);
 545         result = result | size[7];
 546
 547         _mmcam_dbg_log("result : %llu", result);
 548
 549         return result;
 550 }
 551
 552
 553 gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation)
 554 {
 555         /* for 0 degree */
 556         guint32 a = 0x00010000;
 557         guint32 b = 0;
 558         guint32 c = 0;
 559         guint32 d = 0x00010000;
 560
 561         switch (orientation) {
 562         case MM_CAMCORDER_TAG_VIDEO_ORT_90:/* 90 degree */
 563                 a = 0;
 564                 b = 0x00010000;
 565                 c = 0xffff0000;
 566                 d = 0;
 567                 break;
 568         case MM_CAMCORDER_TAG_VIDEO_ORT_180:/* 180 degree */
 569                 a = 0xffff0000;
 570                 d = 0xffff0000;
 571                 break;
 572         case MM_CAMCORDER_TAG_VIDEO_ORT_270:/* 270 degree */
 573                 a = 0;
 574                 b = 0xffff0000;
 575                 c = 0x00010000;
 576                 d = 0;
 577                 break;
 578         case MM_CAMCORDER_TAG_VIDEO_ORT_NONE:/* 0 degree */
 579         default:
 580                 break;
 581         }
 582
 583         write_to_32(f, a);
 584         write_to_32(f, b);
 585         write_to_32(f, 0);
 586         write_to_32(f, c);
 587         write_to_32(f, d);
 588         write_to_32(f, 0);
 589         write_to_32(f, 0);
 590         write_to_32(f, 0);
 591         write_to_32(f, 0x40000000);
 592
 593         _mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x",
 594                        orientation, a, b, c, d);
 595
 596         return TRUE;
 597 }
 598
 599
 600 int _mmcamcorder_get_freespace(const gchar *path, guint64 *free_space)
 601 {
 602         struct statfs fs;
 603
 604         g_assert(path);
 605
 606         if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
 607                 _mmcam_dbg_log("File(%s) doesn't exist.", path);
 608                 return -2;
 609         }
 610
 611         if (-1 == statfs(path, &fs)) {
 612                 _mmcam_dbg_log("statfs failed.(%s)", path);
 613                 return -1;
 614         }
 615
 616         *free_space = (guint64)fs.f_bsize * fs.f_bavail;
 617         return 1;
 618 }
 619
 620
 621 int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type)
 622 {
 623         struct statfs fs;
 624
 625         g_assert(path);
 626
 627         if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
 628                 _mmcam_dbg_log("File(%s) doesn't exist.", path);
 629                 return -2;
 630         }
 631
 632         if (-1 == statfs(path, &fs)) {
 633                 _mmcam_dbg_log("statfs failed.(%s)", path);
 634                 return -1;
 635         }
 636
 637         *file_system_type = (int)fs.f_type;
 638
 639         return 0;
 640 }
 641
 642 int _mmcamcorder_get_freespace_except_system(guint64 *free_space)
 643 {
 644         double total_space=0;
 645         double avail_space=0;
 646
 647         int ret = MM_ERROR_NONE;
 648         GVariant *params = NULL, *result = NULL;
 649         const char *param_type = "(xx)";
 650
 651         if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced",
 652                                             "/Org/Tizen/System/DeviceD/Storage",
 653                                             "org.tizen.system.deviced.storage",
 654                                             "getstorage",
 655                                             params,
 656                                             &result,
 657                                             TRUE)) != MM_ERROR_NONE) {
 658                 _mmcam_dbg_err("Dbus Call on Client Error");
 659                 return ret;
 660         }
 661
 662         if (result) {
 663                 g_variant_get(result, param_type, &total_space, &avail_space);
 664                 *free_space = (guint64)avail_space;
 665                 _mmcam_dbg_log("free space [%" G_GUINT64_FORMAT "] ", *free_space);
 666         } else {
 667                 _mmcam_dbg_err("replied result is null");
 668                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 669         }
 670         return ret;
 671 }
 672
 673 int _mmcamcorder_get_device_flash_brightness(int *brightness)
 674 {
 675         int get_value = 0;
 676         int ret = MM_ERROR_NONE;
 677         GVariant *params = NULL, *result = NULL;
 678         const char *param_type = "(i)";
 679
 680         if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced",
 681                                             "/Org/Tizen/System/DeviceD/Led",
 682                                             "org.tizen.system.deviced.Led",
 683                                             "GetBrightnessForCamera",
 684                                             params,
 685                                             &result,
 686                                             TRUE)) != MM_ERROR_NONE) {
 687                 _mmcam_dbg_err("Dbus Call on Client Error");
 688                 return ret;
 689         }
 690
 691         if (result) {
 692                 g_variant_get(result, param_type, &get_value);
 693                 *brightness = get_value;
 694                 _mmcam_dbg_log("flash brightness : %d", *brightness);
 695         } else {
 696                 _mmcam_dbg_err("replied result is null");
 697                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 698         }
 699
 700         return ret;
 701 }
 702
 703 int _mmcamcorder_get_file_size(const char *filename, guint64 *size)
 704 {
 705         struct stat buf;
 706
 707         if (stat(filename, &buf) != 0)
 708                 return -1;
 709         *size = (guint64)buf.st_size;
 710         return 1;
 711 }
 712
 713
 714 void _mmcamcorder_remove_buffer_probe(MMHandleType handle, _MMCamcorderHandlerCategory category)
 715 {
 716         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 717         GList *list = NULL;
 718         MMCamcorderHandlerItem *item = NULL;
 719
 720         mmf_return_if_fail(hcamcorder);
 721
 722         if (!hcamcorder->buffer_probes) {
 723                 _mmcam_dbg_warn("list for buffer probe is NULL");
 724                 return;
 725         }
 726
 727         _mmcam_dbg_log("start - category : 0x%x", category);
 728
 729         list = hcamcorder->buffer_probes;
 730         while (list) {
 731                 item = list->data;
 732                 if (!item) {
 733                         _mmcam_dbg_err("Remove buffer probe faild, the item is NULL");
 734                         list = g_list_next(list);
 735                         continue;
 736                 }
 737
 738                 if (item->category & category) {
 739                         if (item->object && GST_IS_PAD(item->object)) {
 740                                 _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
 741                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 742                                 gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 743                         } else {
 744                                 _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
 745                         }
 746
 747                         list = g_list_next(list);
 748                         hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item);
 749                         SAFE_FREE(item);
 750                 } else {
 751                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 752                         list = g_list_next(list);
 753                 }
 754         }
 755
 756         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 757                 g_list_free(hcamcorder->buffer_probes);
 758                 hcamcorder->buffer_probes = NULL;
 759         }
 760
 761         _mmcam_dbg_log("done");
 762
 763         return;
 764 }
 765
 766
 767 void _mmcamcorder_remove_one_buffer_probe(MMHandleType handle, void *object)
 768 {
 769         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 770         GList *list = NULL;
 771         MMCamcorderHandlerItem *item = NULL;
 772
 773         mmf_return_if_fail(hcamcorder);
 774
 775         if (!hcamcorder->buffer_probes) {
 776                 _mmcam_dbg_warn("list for buffer probe is NULL");
 777                 return;
 778         }
 779
 780         _mmcam_dbg_log("start - object : %p", object);
 781
 782         list = hcamcorder->buffer_probes;
 783         while (list) {
 784                 item = list->data;
 785                 if (!item) {
 786                         _mmcam_dbg_err("Remove buffer probe faild, the item is NULL");
 787                         list = g_list_next(list);
 788                         continue;
 789                 }
 790
 791                 if (item->object && item->object == object) {
 792                         if (GST_IS_PAD(item->object)) {
 793                                 _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
 794                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 795                                 gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 796                         } else {
 797                                 _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
 798                         }
 799
 800                         list = g_list_next(list);
 801                         hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item);
 802                         SAFE_FREE(item);
 803
 804                         break;
 805                 } else {
 806                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 807                         list = g_list_next(list);
 808                 }
 809         }
 810
 811         _mmcam_dbg_log("done");
 812
 813         return;
 814 }
 815
 816
 817 void _mmcamcorder_remove_event_probe(MMHandleType handle, _MMCamcorderHandlerCategory category)
 818 {
 819         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 820         GList *list = NULL;
 821         MMCamcorderHandlerItem *item = NULL;
 822
 823         mmf_return_if_fail(hcamcorder);
 824
 825         if (!hcamcorder->event_probes) {
 826                 _mmcam_dbg_warn("list for event probe is NULL");
 827                 return;
 828         }
 829
 830         _mmcam_dbg_log("start - category : 0x%x", category);
 831
 832         list = hcamcorder->event_probes;
 833         while (list) {
 834                 item = list->data;
 835                 if (!item) {
 836                         _mmcam_dbg_err("Remove event probe faild, the item is NULL");
 837                         list = g_list_next(list);
 838                         continue;
 839                 }
 840
 841                 if (item->category & category) {
 842                         if (item->object && GST_IS_PAD(item->object)) {
 843                                 _mmcam_dbg_log("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]",
 844                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 845                                 gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 846                         } else {
 847                                 _mmcam_dbg_warn("Remove event probe faild, the pad is null or not pad, just remove item from list and free it");
 848                         }
 849
 850                         list = g_list_next(list);
 851                         hcamcorder->event_probes = g_list_remove(hcamcorder->event_probes, item);
 852                         SAFE_FREE(item);
 853                 } else {
 854                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 855                         list = g_list_next(list);
 856                 }
 857         }
 858
 859         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 860                 g_list_free(hcamcorder->event_probes);
 861                 hcamcorder->event_probes = NULL;
 862         }
 863
 864         _mmcam_dbg_log("done");
 865
 866         return;
 867 }
 868
 869
 870 void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCategory category)
 871 {
 872         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 873         GList *list = NULL;
 874         MMCamcorderHandlerItem *item = NULL;
 875
 876         mmf_return_if_fail(hcamcorder);
 877
 878         if (!hcamcorder->signals) {
 879                 _mmcam_dbg_warn("list for signal is NULL");
 880                 return;
 881         }
 882
 883         _mmcam_dbg_log("start - category : 0x%x", category);
 884
 885         list = hcamcorder->signals;
 886         while (list) {
 887                 item = list->data;
 888                 if (!item) {
 889                         _mmcam_dbg_err("Fail to Disconnecting signal, the item is NULL");
 890                         list = g_list_next(list);
 891                         continue;
 892                 }
 893
 894                 if (item->category & category) {
 895                         if (item->object && GST_IS_ELEMENT(item->object)) {
 896                                 if (g_signal_handler_is_connected(item->object, item->handler_id)) {
 897                                         _mmcam_dbg_log("Disconnect signal from [%s] : [ID : %lu], [Category : %x]",
 898                                                        GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
 899                                         g_signal_handler_disconnect(item->object, item->handler_id);
 900                                 } else {
 901                                         _mmcam_dbg_warn("Signal was not connected, cannot disconnect it :  [%s]  [ID : %lu], [Category : %x]",
 902                                                         GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
 903                                 }
 904                         } else {
 905                                 _mmcam_dbg_err("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it");
 906                         }
 907
 908                         list = g_list_next(list);
 909                         hcamcorder->signals = g_list_remove(hcamcorder->signals, item);
 910                         SAFE_FREE(item);
 911                 } else {
 912                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 913                         list = g_list_next(list);
 914                 }
 915         }
 916
 917         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 918                 g_list_free(hcamcorder->signals);
 919                 hcamcorder->signals = NULL;
 920         }
 921
 922         _mmcam_dbg_log("done");
 923
 924         return;
 925 }
 926
 927
 928 void _mmcamcorder_remove_all_handlers(MMHandleType handle,  _MMCamcorderHandlerCategory category)
 929 {
 930         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 931
 932         _mmcam_dbg_log("ENTER");
 933
 934         if(hcamcorder->signals)
 935                 _mmcamcorder_disconnect_signal((MMHandleType)hcamcorder, category);
 936         if(hcamcorder->event_probes)
 937                 _mmcamcorder_remove_event_probe((MMHandleType)hcamcorder, category);
 938         if(hcamcorder->buffer_probes)
 939                 _mmcamcorder_remove_buffer_probe((MMHandleType)hcamcorder, category);
 940
 941         _mmcam_dbg_log("LEAVE");
 942 }
 943
 944
 945 void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was)
 946 {
 947         int i=0;
 948         _MMCamcorderSubContext *sc = (_MMCamcorderSubContext *)data;
 949
 950         mmf_return_if_fail(sc);
 951         mmf_return_if_fail(sc->element);
 952
 953         for (i = 0 ; i < _MMCAMCORDER_PIPELINE_ELEMENT_NUM ; i++) {
 954                 if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) {
 955                         _mmcam_dbg_warn("The element[%d][%p] is finalized",
 956                                         sc->element[i].id, sc->element[i].gst);
 957                         sc->element[i].gst = NULL;
 958                         sc->element[i].id = _MMCAMCORDER_NONE;
 959                         return;
 960                 }
 961         }
 962
 963         mmf_return_if_fail(sc->encode_element);
 964
 965         for (i = 0 ; i < _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM ; i++) {
 966                 if (sc->encode_element[i].gst && (G_OBJECT(sc->encode_element[i].gst) == where_the_object_was)) {
 967                         _mmcam_dbg_warn("The encode element[%d][%p] is finalized",
 968                                         sc->encode_element[i].id, sc->encode_element[i].gst);
 969                         sc->encode_element[i].gst = NULL;
 970                         sc->encode_element[i].id = _MMCAMCORDER_ENCODE_NONE;
 971                         return;
 972                 }
 973         }
 974
 975         _mmcam_dbg_warn("there is no matching element %p", where_the_object_was);
 976
 977         return;
 978 }
 979
 980
 981 gboolean _mmcamcorder_msg_callback(void *data)
 982 {
 983         _MMCamcorderMsgItem *item = (_MMCamcorderMsgItem*)data;
 984         mmf_camcorder_t *hcamcorder = NULL;
 985         mmf_return_val_if_fail(item, FALSE);
 986
 987         pthread_mutex_lock(&(item->lock));
 988
 989         hcamcorder = MMF_CAMCORDER(item->handle);
 990         if (hcamcorder == NULL) {
 991                 _mmcam_dbg_warn("msg id:0x%x, item:%p, handle is NULL", item->id, item);
 992                 goto MSG_CALLBACK_DONE;
 993         }
 994
 995         /*_mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/
 996
 997         _MMCAMCORDER_LOCK((MMHandleType)hcamcorder);
 998
 999         /* remove item from msg data */
1000         if (hcamcorder->msg_data) {
1001                 hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
1002         } else {
1003                 _mmcam_dbg_warn("msg_data is NULL but item[%p] will be removed", item);
1004         }
1005
1006         _MMCAMCORDER_UNLOCK((MMHandleType)hcamcorder);
1007
1008         _MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
1009
1010         if ((hcamcorder) && (hcamcorder->msg_cb)) {
1011                 hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param);
1012         }
1013
1014         _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
1015
1016         _MMCAMCORDER_SIGNAL(hcamcorder);
1017
1018 MSG_CALLBACK_DONE:
1019         /* release allocated memory */
1020         if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
1021                 MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
1022                 if (cam_fd_info) {
1023                         SAFE_FREE(cam_fd_info->face_info);
1024                         free(cam_fd_info);
1025                         cam_fd_info = NULL;
1026                 }
1027
1028                 item->param.data = NULL;
1029                 item->param.size = 0;
1030         }
1031
1032         pthread_mutex_unlock(&(item->lock));
1033         pthread_mutex_destroy(&(item->lock));
1034
1035         free(item);
1036         item = NULL;
1037
1038         /* For not being called again */
1039         return FALSE;
1040 }
1041
1042
1043 gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *data)
1044 {
1045         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1046         _MMCamcorderMsgItem *item = NULL;
1047
1048         mmf_return_val_if_fail(hcamcorder, FALSE);
1049         mmf_return_val_if_fail(data, FALSE);
1050
1051         switch (data->id)
1052         {
1053                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
1054                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
1055                         data->param.union_type = MM_MSG_UNION_STATE;
1056                         break;
1057                 case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
1058                         data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
1059                         break;
1060                 case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
1061                         data->param.union_type = MM_MSG_UNION_FIRMWARE;
1062                         break;
1063                 case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
1064                         data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
1065                         break;
1066                 case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
1067                 case MM_MESSAGE_CAMCORDER_MAX_SIZE:
1068                 case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
1069                 case MM_MESSAGE_CAMCORDER_ERROR:
1070                 case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
1071                 case MM_MESSAGE_CAMCORDER_CAPTURED:
1072                 case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
1073                 case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
1074                 case MM_MESSAGE_READY_TO_RESUME:
1075                 default:
1076                         data->param.union_type = MM_MSG_UNION_CODE;
1077                         break;
1078         }
1079
1080         item = g_malloc(sizeof(_MMCamcorderMsgItem));
1081         if (item) {
1082                 memcpy(item, data, sizeof(_MMCamcorderMsgItem));
1083                 item->handle = handle;
1084                 pthread_mutex_init(&(item->lock), NULL);
1085
1086                 _MMCAMCORDER_LOCK(handle);
1087                 hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item);
1088 //              _mmcam_dbg_log("item[%p]", item);
1089
1090                 /* Use DEFAULT priority */
1091                 g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcorder_msg_callback, item, NULL);
1092
1093                 _MMCAMCORDER_UNLOCK(handle);
1094         } else {
1095                 _mmcam_dbg_err("item[id:0x%x] malloc failed : %d", data->id, sizeof(_MMCamcorderMsgItem));
1096         }
1097
1098         return TRUE;
1099 }
1100
1101
1102 void _mmcamcorder_remove_message_all(MMHandleType handle)
1103 {
1104         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1105         _MMCamcorderMsgItem *item = NULL;
1106         gboolean ret = TRUE;
1107         GList *list = NULL;
1108         struct timespec timeout;
1109         struct timeval tv;
1110         struct timeval tv_to_add;
1111         struct timeval tv_result;
1112
1113         mmf_return_if_fail(hcamcorder);
1114
1115         _MMCAMCORDER_LOCK(handle);
1116
1117         if (!hcamcorder->msg_data) {
1118                 _mmcam_dbg_log("No message data is remained.");
1119         } else {
1120                 tv_to_add.tv_sec = 0;
1121                 tv_to_add.tv_usec = 1000 * 100; /* 100 ms */
1122
1123                 list = hcamcorder->msg_data;
1124
1125                 while (list) {
1126                         item = list->data;
1127                         list = g_list_next(list);
1128
1129                         if (!item) {
1130                                 _mmcam_dbg_err("Fail to remove message. The item is NULL");
1131                         } else {
1132                                 if (pthread_mutex_trylock(&(item->lock))) {
1133                                         ret = g_idle_remove_by_data(item);
1134
1135                                         _mmcam_dbg_log("remove msg item[%p], ret[%d]", item, ret);
1136
1137                                         if (ret == FALSE) {
1138                                                 item->handle = 0;
1139                                                 _mmcam_dbg_warn("failed to remove msg cb for item %p, it will be called later with NULL handle", item);
1140                                         }
1141
1142                                         /* release allocated memory */
1143                                         if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
1144                                                 MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
1145                                                 if (cam_fd_info) {
1146                                                         SAFE_FREE(cam_fd_info->face_info);
1147                                                         free(cam_fd_info);
1148                                                         cam_fd_info = NULL;
1149                                                 }
1150
1151                                                 item->param.data = NULL;
1152                                                 item->param.size = 0;
1153                                         }
1154
1155                                         hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
1156
1157                                         pthread_mutex_unlock(&(item->lock));
1158
1159                                         if (ret == TRUE) {
1160                                                 pthread_mutex_destroy(&(item->lock));
1161
1162                                                 free(item);
1163                                                 item = NULL;
1164
1165                                                 _mmcam_dbg_log("remove msg done");
1166                                         }
1167                                 } else {
1168                                         _mmcam_dbg_warn("item lock failed. it's being called...");
1169
1170                                         gettimeofday(&tv, NULL);
1171                                         timeradd(&tv, &tv_to_add, &tv_result);
1172                                         timeout.tv_sec = tv_result.tv_sec;
1173                                         timeout.tv_nsec = tv_result.tv_usec * 1000;
1174
1175                                         if (_MMCAMCORDER_TIMED_WAIT(handle, timeout)) {
1176                                                 _mmcam_dbg_warn("signal received");
1177                                         } else {
1178                                                 _mmcam_dbg_warn("timeout");
1179                                         }
1180                                 }
1181                         }
1182                 }
1183
1184                 g_list_free(hcamcorder->msg_data);
1185                 hcamcorder->msg_data = NULL;
1186         }
1187
1188         /* remove idle function for playing capture sound */
1189         do {
1190                 ret = g_idle_remove_by_data(hcamcorder);
1191                 _mmcam_dbg_log("remove idle function for playing capture sound. ret[%d]", ret);
1192         } while (ret);
1193
1194         _MMCAMCORDER_UNLOCK(handle);
1195
1196         return;
1197 }
1198
1199
1200 int _mmcamcorder_get_pixel_format(GstCaps *caps)
1201 {
1202         const GstStructure *structure;
1203         const char *media_type;
1204         GstVideoInfo media_info;
1205         MMPixelFormatType type = 0;
1206         unsigned int fourcc = 0;
1207
1208         mmf_return_val_if_fail( caps != NULL, MM_PIXEL_FORMAT_INVALID );
1209
1210         structure = gst_caps_get_structure (caps, 0);
1211         media_type = gst_structure_get_name (structure);
1212         if (media_type == NULL) {
1213                 _mmcam_dbg_err("failed to get media_type");
1214                 return MM_PIXEL_FORMAT_INVALID;
1215         }
1216
1217         gst_video_info_init (&media_info);
1218
1219         if (!strcmp (media_type, "image/jpeg") ) {
1220                 _mmcam_dbg_log("It is jpeg.");
1221                 type = MM_PIXEL_FORMAT_ENCODED;
1222         } else if (!strcmp (media_type, "video/x-raw") &&
1223                    gst_video_info_from_caps(&media_info, caps) &&
1224                    GST_VIDEO_INFO_IS_YUV(&media_info)) {
1225                 _mmcam_dbg_log("It is yuv.");
1226                 fourcc = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(&media_info));
1227                 type = _mmcamcorder_get_pixtype(fourcc);
1228         } else if (!strcmp (media_type, "video/x-raw") &&
1229                    gst_video_info_from_caps(&media_info, caps) &&
1230                    GST_VIDEO_INFO_IS_RGB(&media_info)) {
1231                 _mmcam_dbg_log("It is rgb.");
1232                 type = MM_PIXEL_FORMAT_RGB888;
1233         } else if (!strcmp (media_type, "video/x-h264")) {
1234                 _mmcam_dbg_log("It is H264");
1235                 type = MM_PIXEL_FORMAT_ENCODED_H264;
1236         } else {
1237                 _mmcam_dbg_err("Not supported format [%s]",media_type);
1238                 type = MM_PIXEL_FORMAT_INVALID;
1239         }
1240
1241         /*_mmcam_dbg_log( "Type [%d]", type );*/
1242
1243         return type;
1244 }
1245
1246 unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_copy_format)
1247 {
1248         unsigned int fourcc = 0;
1249
1250         /*_mmcam_dbg_log("pixtype(%d)", pixtype);*/
1251
1252         switch (pixtype) {
1253         case MM_PIXEL_FORMAT_NV12:
1254                 if (use_zero_copy_format) {
1255                         fourcc = GST_MAKE_FOURCC ('S', 'N', '1', '2');
1256                 } else {
1257                         fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
1258                 }
1259                 break;
1260         case MM_PIXEL_FORMAT_NV21:
1261                 if (use_zero_copy_format) {
1262                         fourcc = GST_MAKE_FOURCC ('S', 'N', '2', '1');
1263                 } else {
1264                         fourcc = GST_MAKE_FOURCC ('N', 'V', '2', '1');
1265                 }
1266                 break;
1267         case MM_PIXEL_FORMAT_YUYV:
1268                 if (use_zero_copy_format) {
1269                         fourcc = GST_MAKE_FOURCC ('S', 'U', 'Y', 'V');
1270                 } else {
1271                         fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
1272                 }
1273                 break;
1274         case MM_PIXEL_FORMAT_UYVY:
1275                 if (use_zero_copy_format) {
1276                         fourcc = GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y');
1277                 } else {
1278                         fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
1279                 }
1280                 break;
1281         case MM_PIXEL_FORMAT_I420:
1282                 if (use_zero_copy_format) {
1283                         fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
1284                 } else {
1285                         fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
1286                 }
1287                 break;
1288         case MM_PIXEL_FORMAT_YV12:
1289                 fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
1290                 break;
1291         case MM_PIXEL_FORMAT_422P:
1292                 fourcc = GST_MAKE_FOURCC ('4', '2', '2', 'P');
1293                 break;
1294         case MM_PIXEL_FORMAT_RGB565:
1295                 fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', 'P');
1296                 break;
1297         case MM_PIXEL_FORMAT_RGB888:
1298                 fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', ' ');
1299                 break;
1300         case MM_PIXEL_FORMAT_ENCODED:
1301                 if (codectype == MM_IMAGE_CODEC_JPEG) {
1302                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
1303                 } else if (codectype == MM_IMAGE_CODEC_JPEG_SRW) {
1304                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
1305                 } else if (codectype == MM_IMAGE_CODEC_SRW) {
1306                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
1307                 } else if (codectype == MM_IMAGE_CODEC_PNG) {
1308                         fourcc = GST_MAKE_FOURCC ('P', 'N', 'G', ' ');
1309                 } else {
1310                         /* Please let us know what other fourcces are. ex) BMP, GIF?*/
1311                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
1312                 }
1313                 break;
1314         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
1315                 fourcc = GST_MAKE_FOURCC('I','T','L','V');
1316                 break;
1317         case MM_PIXEL_FORMAT_ENCODED_H264:
1318                 fourcc = GST_MAKE_FOURCC('H','2','6','4');
1319                 break;
1320         default:
1321                 _mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype);
1322                 if (use_zero_copy_format) {
1323                         fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
1324                 } else {
1325                         fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
1326                 }
1327                 break;
1328         }
1329
1330         return fourcc;
1331 }
1332
1333
1334 int _mmcamcorder_get_pixtype(unsigned int fourcc)
1335 {
1336         int pixtype = MM_PIXEL_FORMAT_INVALID;
1337         /*
1338         char *pfourcc = (char*)&fourcc;
1339
1340         _mmcam_dbg_log("fourcc(%c%c%c%c)",
1341                          pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
1342         */
1343
1344         switch (fourcc) {
1345         case GST_MAKE_FOURCC ('S', 'N', '1', '2'):
1346         case GST_MAKE_FOURCC ('N', 'V', '1', '2'):
1347                 pixtype = MM_PIXEL_FORMAT_NV12;
1348                 break;
1349         case GST_MAKE_FOURCC ('S', 'N', '2', '1'):
1350         case GST_MAKE_FOURCC ('N', 'V', '2', '1'):
1351                 pixtype = MM_PIXEL_FORMAT_NV21;
1352                 break;
1353         case GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'):
1354         case GST_MAKE_FOURCC ('Y', 'U', 'Y', 'V'):
1355         case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
1356                 pixtype = MM_PIXEL_FORMAT_YUYV;
1357                 break;
1358         case GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'):
1359         case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
1360                 pixtype = MM_PIXEL_FORMAT_UYVY;
1361                 break;
1362         case GST_MAKE_FOURCC ('S', '4', '2', '0'):
1363         case GST_MAKE_FOURCC ('I', '4', '2', '0'):
1364                 pixtype = MM_PIXEL_FORMAT_I420;
1365                 break;
1366         case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
1367                 pixtype = MM_PIXEL_FORMAT_YV12;
1368                 break;
1369         case GST_MAKE_FOURCC ('4', '2', '2', 'P'):
1370                 pixtype = MM_PIXEL_FORMAT_422P;
1371                 break;
1372         case GST_MAKE_FOURCC ('R', 'G', 'B', 'P'):
1373                 pixtype = MM_PIXEL_FORMAT_RGB565;
1374                 break;
1375         case GST_MAKE_FOURCC ('R', 'G', 'B', '3'):
1376                 pixtype = MM_PIXEL_FORMAT_RGB888;
1377                 break;
1378         case GST_MAKE_FOURCC ('A', 'R', 'G', 'B'):
1379         case GST_MAKE_FOURCC ('x', 'R', 'G', 'B'):
1380                 pixtype = MM_PIXEL_FORMAT_ARGB;
1381                 break;
1382         case GST_MAKE_FOURCC ('B', 'G', 'R', 'A'):
1383         case GST_MAKE_FOURCC ('B', 'G', 'R', 'x'):
1384         case GST_MAKE_FOURCC ('S', 'R', '3', '2'):
1385                 pixtype = MM_PIXEL_FORMAT_RGBA;
1386                 break;
1387         case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'):
1388         case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
1389                 pixtype = MM_PIXEL_FORMAT_ENCODED;
1390                 break;
1391         /*FIXME*/
1392         case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'):
1393                 pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
1394                 break;
1395         case GST_MAKE_FOURCC ('H', '2', '6', '4'):
1396                 pixtype = MM_PIXEL_FORMAT_ENCODED_H264;
1397                 break;
1398         default:
1399                 _mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)",
1400                                fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
1401                 pixtype = MM_PIXEL_FORMAT_INVALID;
1402                 break;
1403         }
1404
1405         return pixtype;
1406 }
1407
1408
1409 gboolean _mmcamcorder_add_elements_to_bin(GstBin *bin, GList *element_list)
1410 {
1411         GList *local_list = element_list;
1412         _MMCamcorderGstElement *element = NULL;
1413
1414         mmf_return_val_if_fail(bin && local_list, FALSE);
1415
1416         while (local_list) {
1417                 element = (_MMCamcorderGstElement*)local_list->data;
1418                 if (element && element->gst) {
1419                         if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
1420                                 _mmcam_dbg_err( "Add element [%s] to bin [%s] FAILED",
1421                                                 GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
1422                                                 GST_ELEMENT_NAME(GST_ELEMENT(bin)) );
1423                                 return FALSE;
1424                         } else {
1425                                 _mmcam_dbg_log("Add element [%s] to bin [%s] OK",
1426                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
1427                                                GST_ELEMENT_NAME(GST_ELEMENT(bin)));
1428                         }
1429                 }
1430                 local_list = local_list->next;
1431         }
1432
1433         return TRUE;
1434 }
1435
1436 gboolean _mmcamcorder_link_elements(GList *element_list)
1437 {
1438         GList                  *local_list  = element_list;
1439         _MMCamcorderGstElement *element     = NULL;
1440         _MMCamcorderGstElement *pre_element = NULL;
1441
1442         mmf_return_val_if_fail(local_list, FALSE);
1443
1444         pre_element = (_MMCamcorderGstElement*)local_list->data;
1445         local_list = local_list->next;
1446
1447         while (local_list) {
1448                 element = (_MMCamcorderGstElement*)local_list->data;
1449                 if (element && element->gst) {
1450                         if (_MM_GST_ELEMENT_LINK(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst))) {
1451                                 _mmcam_dbg_log("Link [%s] to [%s] OK",
1452                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1453                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1454                         } else {
1455                                 _mmcam_dbg_err("Link [%s] to [%s] FAILED",
1456                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1457                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1458                                 return FALSE;
1459                         }
1460                 }
1461
1462                 pre_element = element;
1463                 local_list = local_list->next;
1464         }
1465
1466         return TRUE;
1467 }
1468
1469 gboolean _mmcamcorder_filtered_link_elements(GList *element_list, GstCaps *caps)
1470 {
1471         GList                  *local_list  = element_list;
1472         _MMCamcorderGstElement *element     = NULL;
1473         _MMCamcorderGstElement *pre_element = NULL;
1474
1475         mmf_return_val_if_fail(local_list, FALSE);
1476
1477         pre_element = (_MMCamcorderGstElement*)local_list->data;
1478         local_list = local_list->next;
1479
1480         while (local_list) {
1481                 element = (_MMCamcorderGstElement*)local_list->data;
1482                 if (element && element->gst) {
1483                         if (_MM_GST_ELEMENT_LINK_FILTERED(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst), caps)) {
1484                                 _mmcam_dbg_log("Link [%s] to [%s] OK",
1485                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1486                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1487                         } else {
1488                                 _mmcam_dbg_err("Link [%s] to [%s] FAILED",
1489                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1490                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1491                                 return FALSE;
1492                         }
1493                 }
1494
1495                 pre_element = element;
1496                 local_list = local_list->next;
1497         }
1498
1499         return TRUE;
1500 }
1501
1502 gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format,
1503                                    unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length)
1504 {
1505         int ret = TRUE;
1506         int mm_ret = MM_ERROR_NONE;
1507         int input_format = MM_UTIL_IMG_FMT_YUV420;
1508         unsigned char *dst_tmp_data = NULL;
1509
1510         if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) {
1511                 _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p",
1512                                src_data, dst_data, dst_width, dst_height, dst_length);
1513                 return FALSE;
1514         }
1515
1516         /* set input format for mm-util */
1517         switch (src_format) {
1518         case MM_PIXEL_FORMAT_I420:
1519                 input_format = MM_UTIL_IMG_FMT_I420;
1520                 break;
1521         case MM_PIXEL_FORMAT_YV12:
1522                 input_format = MM_UTIL_IMG_FMT_YUV420;
1523                 break;
1524         case MM_PIXEL_FORMAT_NV12:
1525                 input_format = MM_UTIL_IMG_FMT_NV12;
1526                 break;
1527         case MM_PIXEL_FORMAT_YUYV:
1528                 input_format = MM_UTIL_IMG_FMT_YUYV;
1529                 break;
1530         case MM_PIXEL_FORMAT_UYVY:
1531                 input_format = MM_UTIL_IMG_FMT_UYVY;
1532                 break;
1533         case MM_PIXEL_FORMAT_RGB888:
1534                 input_format = MM_UTIL_IMG_FMT_RGB888;
1535                 break;
1536         default:
1537                 _mmcam_dbg_err("NOT supported format", src_format);
1538                 return FALSE;
1539         }
1540
1541         _mmcam_dbg_log("src size %dx%d -> dst size %dx%d",
1542                         src_width, src_height, *dst_width, *dst_height);
1543
1544         /* get length of resized image */
1545         mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length);
1546         if (mm_ret != MM_ERROR_NONE) {
1547                 GST_ERROR("mm_util_get_image_size failed 0x%x", ret);
1548                 return FALSE;
1549         }
1550
1551         _mmcam_dbg_log("dst_length : %d", *dst_length);
1552
1553         dst_tmp_data = (unsigned char *)malloc(*dst_length);
1554         if (dst_tmp_data == NULL) {
1555                 _mmcam_dbg_err("failed to alloc dst_thumb_size(size %d)", *dst_length);
1556                 return FALSE;
1557         }
1558
1559         mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format,
1560                                       dst_tmp_data, dst_width, dst_height);
1561         if (mm_ret != MM_ERROR_NONE) {
1562                 GST_ERROR("mm_util_resize_image failed 0x%x", ret);
1563                 free(dst_tmp_data);
1564                 return FALSE;
1565         }
1566
1567         *dst_data = dst_tmp_data;
1568
1569         _mmcam_dbg_log("resize done %p, %dx%d", *dst_data, *dst_width, *dst_height);
1570
1571         return TRUE;
1572 }
1573
1574
1575 gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
1576                                   int src_format, unsigned int src_length, unsigned int jpeg_quality,
1577                                   void **result_data, unsigned int *result_length)
1578 {
1579         int ret = 0;
1580         gboolean ret_conv = TRUE;
1581         guint32 src_fourcc = 0;
1582         int jpeg_format = 0;
1583         unsigned char *converted_src = NULL;
1584         unsigned int converted_src_size = 0;
1585
1586         mmf_return_val_if_fail(src_data && result_data && result_length, FALSE);
1587
1588         src_fourcc = _mmcamcorder_get_fourcc(src_format, 0, FALSE);
1589
1590         switch (src_format) {
1591                 case MM_PIXEL_FORMAT_NV12:
1592                         //jpeg_format = MM_UTIL_JPEG_FMT_NV12;
1593                         ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
1594                         jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
1595                         break;
1596                 case MM_PIXEL_FORMAT_NV16:
1597                         jpeg_format = MM_UTIL_JPEG_FMT_NV16;
1598                         converted_src = src_data;
1599                         break;
1600                 case MM_PIXEL_FORMAT_NV21:
1601                         jpeg_format = MM_UTIL_JPEG_FMT_NV21;
1602                         converted_src = src_data;
1603                         break;
1604                 case MM_PIXEL_FORMAT_YUYV:
1605                         //jpeg_format = MM_UTIL_JPEG_FMT_YUYV;
1606                         ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
1607                         jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
1608                         break;
1609                 case MM_PIXEL_FORMAT_UYVY:
1610                         //jpeg_format = MM_UTIL_JPEG_FMT_UYVY;
1611                         ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
1612                         jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
1613                         break;
1614                 case MM_PIXEL_FORMAT_I420:
1615                         jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
1616                         converted_src = src_data;
1617                         break;
1618                 case MM_PIXEL_FORMAT_RGB888:
1619                         jpeg_format = MM_UTIL_JPEG_FMT_RGB888;
1620                         converted_src = src_data;
1621                         break;
1622                 case MM_PIXEL_FORMAT_RGBA:
1623                         jpeg_format = MM_UTIL_JPEG_FMT_RGBA8888;
1624                         converted_src = src_data;
1625                         break;
1626                 case MM_PIXEL_FORMAT_ARGB:
1627                         jpeg_format = MM_UTIL_JPEG_FMT_ARGB8888;
1628                         converted_src = src_data;
1629                         break;
1630                 case MM_PIXEL_FORMAT_422P:
1631                         jpeg_format = MM_UTIL_JPEG_FMT_YUV422;  // not supported
1632                         return FALSE;
1633                 case MM_PIXEL_FORMAT_NV12T:
1634                 case MM_PIXEL_FORMAT_YV12:
1635                 case MM_PIXEL_FORMAT_RGB565:
1636                 case MM_PIXEL_FORMAT_ENCODED:
1637                 case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
1638                 default:
1639                         return FALSE;
1640
1641         }
1642
1643         if (ret_conv == FALSE) {
1644                 if (converted_src &&
1645                     converted_src != src_data) {
1646                         free(converted_src);
1647                         converted_src = NULL;
1648                 }
1649                 _mmcam_dbg_err("color convert error source format[%d], jpeg format[%d]", src_format, jpeg_format);
1650                 return FALSE;
1651         }
1652
1653         ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length,
1654                                             converted_src, src_width, src_height,
1655                                             jpeg_format, jpeg_quality);
1656
1657         if (converted_src && (converted_src != src_data)) {
1658                 free(converted_src);
1659                 converted_src = NULL;
1660         }
1661
1662         if (ret != MM_ERROR_NONE) {
1663                 _mmcam_dbg_err("No encoder supports %d format, error code %x", src_format, ret);
1664                 return FALSE;
1665         }
1666
1667         return TRUE;
1668 }
1669
1670
1671 /* make UYVY smaller as multiple size. ex: 640x480 -> 320x240 or 160x120 ... */
1672 gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_width, unsigned int src_height,
1673                                            unsigned char **dst, unsigned int dst_width, unsigned int dst_height)
1674 {
1675         unsigned int i = 0;
1676         int j = 0;
1677         int k = 0;
1678         int src_index = 0;
1679         int ratio_width = 0;
1680         int ratio_height = 0;
1681         int line_base = 0;
1682         int line_width = 0;
1683         int jump_width = 0;
1684         unsigned char *result = NULL;
1685
1686         if (src == NULL || dst == NULL) {
1687                 _mmcam_dbg_err("src[%p] or dst[%p] is NULL", src, dst);
1688                 return FALSE;
1689         }
1690
1691         result = (unsigned char *)malloc((dst_width * dst_height)<<1);
1692         if (!result) {
1693                 _mmcam_dbg_err("failed to alloc dst data");
1694                 return FALSE;
1695         }
1696
1697         ratio_width = src_width / dst_width;
1698         ratio_height = src_height / dst_height;
1699         line_width = src_width << 1;
1700         jump_width = ratio_width << 1;
1701
1702         _mmcam_dbg_warn("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]",
1703                         src_width, src_height, dst_width, dst_height,
1704                         line_width, ratio_width, ratio_height);
1705
1706         for (i = 0 ; i < src_height ; i += ratio_height) {
1707                 line_base = i * line_width;
1708                 for (j = 0 ; j < line_width ; j += jump_width) {
1709                         src_index = line_base + j;
1710                         result[k++] = src[src_index];
1711                         result[k++] = src[src_index+1];
1712
1713                         j += jump_width;
1714                         src_index = line_base + j;
1715                         if (src_index % 4 == 0) {
1716                                 result[k++] = src[src_index+2];
1717                         } else {
1718                                 result[k++] = src[src_index];
1719                         }
1720                         result[k++] = src[src_index+1];
1721                 }
1722         }
1723
1724         *dst = result;
1725
1726         _mmcam_dbg_warn("converting done - result %p", result);
1727
1728         return TRUE;
1729 }
1730
1731 gboolean _mmcamcorder_check_file_path(const gchar *path)
1732 {
1733         if(strstr(path, "/opt/usr") != NULL) {
1734                 return TRUE;
1735         }
1736         return FALSE;
1737 }
1738
1739 static guint16 get_language_code(const char *str)
1740 {
1741     return (guint16) (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
1742 }
1743
1744 static gchar * str_to_utf8(const gchar *str)
1745 {
1746         return g_convert (str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
1747 }
1748
1749 static inline gboolean write_tag(FILE *f, const gchar *tag)
1750 {
1751         while(*tag)
1752                 FPUTC_CHECK(*tag++, f);
1753
1754         return TRUE;
1755 }
1756
1757 static inline gboolean write_to_32(FILE *f, guint val)
1758 {
1759         FPUTC_CHECK(val >> 24, f);
1760         FPUTC_CHECK(val >> 16, f);
1761         FPUTC_CHECK(val >> 8, f);
1762         FPUTC_CHECK(val, f);
1763         return TRUE;
1764 }
1765
1766 static inline gboolean write_to_16(FILE *f, guint val)
1767 {
1768         FPUTC_CHECK(val >> 8, f);
1769         FPUTC_CHECK(val, f);
1770         return TRUE;
1771 }
1772
1773 static inline gboolean write_to_24(FILE *f, guint val)
1774 {
1775         write_to_16(f, val >> 8);
1776         FPUTC_CHECK(val, f);
1777         return TRUE;
1778 }
1779
1780 void *_mmcamcorder_util_task_thread_func(void *data)
1781 {
1782         int ret = MM_ERROR_NONE;
1783         mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
1784
1785         if (!hcamcorder) {
1786                 _mmcam_dbg_err("handle is NULL");
1787                 return NULL;
1788         }
1789
1790         _mmcam_dbg_warn("start thread");
1791
1792         pthread_mutex_lock(&(hcamcorder->task_thread_lock));
1793
1794         while (hcamcorder->task_thread_state != _MMCAMCORDER_TASK_THREAD_STATE_EXIT) {
1795                 switch (hcamcorder->task_thread_state) {
1796                 case _MMCAMCORDER_TASK_THREAD_STATE_NONE:
1797                         _mmcam_dbg_warn("wait for task signal");
1798                         pthread_cond_wait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock));
1799                         _mmcam_dbg_warn("task signal received : state %d", hcamcorder->task_thread_state);
1800                         break;
1801                 case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_PLAY_START:
1802                         _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE, FALSE);
1803                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
1804                         break;
1805                 case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_SOLO_PLAY_START:
1806                         _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
1807                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
1808                         break;
1809                 case _MMCAMCORDER_TASK_THREAD_STATE_ENCODE_PIPE_CREATE:
1810                         ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder);
1811
1812                         /* Play record start sound */
1813                         _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_REC_START_SND, FALSE);
1814
1815                         _mmcam_dbg_log("_mmcamcorder_video_prepare_record return 0x%x", ret);
1816                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
1817                         break;
1818                 default:
1819                         _mmcam_dbg_warn("invalid task thread state %d", hcamcorder->task_thread_state);
1820                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
1821                         break;
1822                 }
1823         }
1824
1825         pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
1826
1827         _mmcam_dbg_warn("exit thread");
1828
1829         return NULL;
1830 }
1831
1832 #ifdef _USE_YUV_TO_RGB888_
1833 static gboolean
1834 _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
1835 {
1836         int ret = 0;
1837         int src_cs = MM_UTIL_IMG_FMT_UYVY;
1838         int dst_cs = MM_UTIL_IMG_FMT_RGB888;
1839         unsigned int dst_size = 0;
1840
1841         if (src_fmt == COLOR_FORMAT_YUYV)
1842         {
1843                 _mmcam_dbg_log("Convert YUYV to RGB888\n");
1844                 src_cs = MM_UTIL_IMG_FMT_YUYV;
1845         }
1846         else if (src_fmt == COLOR_FORMAT_UYVY)
1847         {
1848                 _mmcam_dbg_log("Convert UYVY to RGB888\n");
1849                 src_cs = MM_UTIL_IMG_FMT_UYVY;
1850         }
1851         else if (src_fmt == COLOR_FORMAT_NV12)
1852         {
1853                 _mmcam_dbg_log("Convert NV12 to RGB888\n");
1854                 src_cs = MM_UTIL_IMG_FMT_NV12;
1855         }
1856         else
1857         {
1858                 _mmcam_dbg_err("NOT supported format [%d]\n", src_fmt);
1859                 return FALSE;
1860         }
1861
1862         ret = mm_util_get_image_size(dst_cs, width, height, &dst_size);
1863         if (ret != 0) {
1864                 _mmcam_dbg_err("mm_util_get_image_size failed [%x]\n", ret);
1865                 return FALSE;
1866         }
1867
1868         *dst = malloc(dst_size);
1869         if (*dst == NULL)
1870         {
1871                 _mmcam_dbg_err("malloc failed\n");
1872                 return FALSE;
1873         }
1874
1875         *dst_len = dst_size;
1876         ret = mm_util_convert_colorspace(src, width, height, src_cs, *dst, dst_cs);
1877         if(ret == 0)
1878         {
1879                 _mmcam_dbg_log("Convert [dst_size:%d] OK.\n", dst_size);
1880                 return TRUE;
1881         }
1882         else
1883         {
1884                 free(*dst);
1885                 *dst = NULL;
1886
1887                 _mmcam_dbg_err("Convert [size:%d] FAILED.\n", dst_size);
1888                 return FALSE;
1889         }
1890 }
1891 #endif /* _USE_YUV_TO_RGB888_ */
1892
1893
1894 static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
1895 {
1896         unsigned int i = 0;
1897         int j = 0;
1898         int src_offset = 0;
1899         int dst_y_offset = 0;
1900         int dst_u_offset = 0;
1901         int dst_v_offset = 0;
1902         int loop_length = 0;
1903         unsigned int dst_size = 0;
1904         unsigned char *dst_data = NULL;
1905
1906         if (!src || !dst || !dst_len) {
1907                 _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
1908                 return FALSE;
1909         }
1910
1911         dst_size = (width * height * 3) >> 1;
1912
1913         _mmcam_dbg_log("YUVY -> I420 : %dx%d, dst size %d", width, height, dst_size);
1914
1915         dst_data = (unsigned char *)malloc(dst_size);
1916         if (!dst_data) {
1917                 _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
1918                 return FALSE;
1919         }
1920
1921         loop_length = width << 1;
1922         dst_u_offset = width * height;
1923         dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
1924
1925         _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
1926
1927         for (i = 0 ; i < height ; i++) {
1928                 for (j = 0 ; j < loop_length ; j += 2) {
1929                         dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
1930
1931                         if (i % 2 == 0) {
1932                                 if (j % 4 == 0) {
1933                                         dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
1934                                 } else {
1935                                         dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
1936                                 }
1937                         } else {
1938                                 src_offset++;
1939                         }
1940                 }
1941         }
1942
1943         *dst = dst_data;
1944         *dst_len = dst_size;
1945
1946         _mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d",
1947                                 width, height, *dst, dst_size);
1948
1949         return TRUE;
1950 }
1951
1952
1953 static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
1954 {
1955         unsigned int i = 0;
1956         int j = 0;
1957         int src_offset = 0;
1958         int dst_y_offset = 0;
1959         int dst_u_offset = 0;
1960         int dst_v_offset = 0;
1961         int loop_length = 0;
1962         unsigned int dst_size = 0;
1963         unsigned char *dst_data = NULL;
1964
1965         if (!src || !dst || !dst_len) {
1966                 _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
1967                 return FALSE;
1968         }
1969
1970         dst_size = (width * height * 3) >> 1;
1971
1972         _mmcam_dbg_log("UYVY -> I420 : %dx%d, dst size %d", width, height, dst_size);
1973
1974         dst_data = (unsigned char *)malloc(dst_size);
1975         if (!dst_data) {
1976                 _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
1977                 return FALSE;
1978         }
1979
1980         loop_length = width << 1;
1981         dst_u_offset = width * height;
1982         dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
1983
1984         _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
1985
1986         for (i = 0 ; i < height ; i++) {
1987                 for (j = 0 ; j < loop_length ; j += 2) {
1988                         if (i % 2 == 0) {
1989                                 if (j % 4 == 0) {
1990                                         dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
1991                                 } else {
1992                                         dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
1993                                 }
1994                         } else {
1995                                 src_offset++;
1996                         }
1997
1998                         dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
1999                 }
2000         }
2001
2002         *dst = dst_data;
2003         *dst_len = dst_size;
2004
2005         _mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d",
2006                                 width, height, *dst, dst_size);
2007
2008         return TRUE;
2009 }
2010
2011
2012 static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
2013 {
2014         int i = 0;
2015         int src_offset = 0;
2016         int dst_y_offset = 0;
2017         int dst_u_offset = 0;
2018         int dst_v_offset = 0;
2019         int loop_length = 0;
2020         unsigned int dst_size = 0;
2021         unsigned char *dst_data = NULL;
2022
2023         if (!src || !dst || !dst_len) {
2024                 _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
2025                 return FALSE;
2026         }
2027
2028         dst_size = (width * height * 3) >> 1;
2029
2030         _mmcam_dbg_log("NV12 -> I420 : %dx%d, dst size %d", width, height, dst_size);
2031
2032         dst_data = (unsigned char *)malloc(dst_size);
2033         if (!dst_data) {
2034                 _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
2035                 return FALSE;
2036         }
2037
2038         loop_length = width << 1;
2039         dst_u_offset = width * height;
2040         dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
2041
2042         _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
2043
2044         /* memcpy Y */
2045         memcpy(dst_data, src, dst_u_offset);
2046
2047         loop_length = dst_u_offset >> 1;
2048         src_offset = dst_u_offset;
2049
2050         /* set U and V */
2051         for (i = 0 ; i < loop_length ; i++) {
2052                 if (i % 2 == 0) {
2053                         dst_data[dst_u_offset++] = src[src_offset++];
2054                 } else {
2055                         dst_data[dst_v_offset++] = src[src_offset++];
2056                 }
2057         }
2058
2059         *dst = dst_data;
2060         *dst_len = dst_size;
2061
2062         _mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d",
2063                                 width, height, *dst, dst_size);
2064
2065         return TRUE;
2066 }
2067