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 <sys/vfs.h> /* struct statfs */
  28 #include <dbus/dbus.h>
  29 #include <sys/time.h> /* gettimeofday */
  30
  31 #include "mm_camcorder_internal.h"
  32 #include "mm_camcorder_util.h"
  33 #include "mm_camcorder_sound.h"
  34 #include <mm_util_imgp.h>
  35
  36 /*-----------------------------------------------------------------------
  37 |    GLOBAL VARIABLE DEFINITIONS for internal                           |
  38 -----------------------------------------------------------------------*/
  39
  40 /*-----------------------------------------------------------------------
  41 |    LOCAL VARIABLE DEFINITIONS for internal                            |
  42 -----------------------------------------------------------------------*/
  43 #define TIME_STRING_MAX_LEN     64
  44
  45 #define FPUTC_CHECK(x_char, x_file)\
  46 {\
  47         if (fputc(x_char, x_file) == EOF) \
  48         {\
  49                 _mmcam_dbg_err("[Critical] fputc() returns fail.\n");   \
  50                 return FALSE;\
  51         }\
  52 }
  53 #define FPUTS_CHECK(x_str, x_file)\
  54 {\
  55         if (fputs(x_str, x_file) == EOF) \
  56         {\
  57                 _mmcam_dbg_err("[Critical] fputs() returns fail.\n");\
  58                 SAFE_FREE(str); \
  59                 return FALSE;\
  60         }\
  61 }
  62
  63 /*---------------------------------------------------------------------------
  64 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
  65 ---------------------------------------------------------------------------*/
  66 /* STATIC INTERNAL FUNCTION */
  67
  68 //static gint           skip_mdat(FILE *f);
  69 static guint16           get_language_code(const char *str);
  70 static gchar*            str_to_utf8(const gchar *str);
  71 static inline gboolean   write_tag(FILE *f, const gchar *tag);
  72 static inline gboolean   write_to_32(FILE *f, guint val);
  73 static inline gboolean   write_to_16(FILE *f, guint val);
  74 static inline gboolean   write_to_24(FILE *f, guint val);
  75
  76 /*===========================================================================================
  77 |                                                                                                                                                                                       |
  78 |  FUNCTION DEFINITIONS                                                                                                                                         |
  79 |                                                                                                                                                                                       |
  80 ========================================================================================== */
  81 /*---------------------------------------------------------------------------
  82 |    GLOBAL FUNCTION DEFINITIONS:                                                                                       |
  83 ---------------------------------------------------------------------------*/
  84
  85 static int __append_variant(DBusMessageIter *iter, const char *sig, char *param[])
  86 {
  87         const char *ch;
  88         int i;
  89         int int_type;
  90         uint64_t int64_type;
  91
  92         if (!sig || !param)
  93                 return 0;
  94
  95         for (ch = sig, i = 0; *ch != '\0'; ++i, ++ch) {
  96                 switch (*ch) {
  97                 case 'i':
  98                         int_type = atoi(param[i]);
  99                         dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &int_type);
 100                         break;
 101                 case 'u':
 102                         int_type = atoi(param[i]);
 103                         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &int_type);
 104                         break;
 105                 case 't':
 106                         int64_type = atoi(param[i]);
 107                         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &int64_type);
 108                         break;
 109                 case 's':
 110                         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &param[i]);
 111                         break;
 112                 default:
 113                         return -1;
 114                 }
 115         }
 116
 117         return 0;
 118 }
 119
 120 #define DBUS_REPLY_TIMEOUT (120 * 1000)
 121 static DBusMessage *__invoke_dbus_method_sync(const char *dest, const char *path,
 122                 const char *interface, const char *method,
 123                 const char *sig, char *param[])
 124 {
 125         DBusConnection *conn;
 126         DBusMessage *msg;
 127         DBusMessageIter iter;
 128         DBusMessage *reply;
 129         DBusError err;
 130         int r;
 131
 132         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 133         if (!conn) {
 134                 _mmcam_dbg_err( "dbus_bus_get error");
 135                 return NULL;
 136         }
 137
 138         msg = dbus_message_new_method_call(dest, path, interface, method);
 139         if (!msg) {
 140                 _mmcam_dbg_err("dbus_message_new_method_call(%s:%s-%s)", path, interface, method);
 141                 return NULL;
 142         }
 143
 144         dbus_message_iter_init_append(msg, &iter);
 145         r = __append_variant(&iter, sig, param);
 146         if (r < 0) {
 147                 _mmcam_dbg_err("append_variant error(%d)", r);
 148                 return NULL;
 149         }
 150
 151         dbus_error_init(&err);
 152
 153         reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_REPLY_TIMEOUT, &err);
 154         if (!reply) {
 155                 _mmcam_dbg_err("dbus_connection_send error(No reply)");
 156         }
 157
 158         if (dbus_error_is_set(&err)) {
 159                 _mmcam_dbg_err("dbus_connection_send error(%s:%s)", err.name, err.message);
 160                 reply = NULL;
 161         }
 162
 163         dbus_message_unref(msg);
 164         dbus_error_free(&err);
 165
 166         return reply;
 167 }
 168
 169
 170 gint32 _mmcamcorder_double_to_fix(gdouble d_number)
 171 {
 172         return (gint32) (d_number * 65536.0);
 173 }
 174
 175 // find top level tag only, do not use this function for finding sub level tags
 176 gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 177 {
 178         size_t read_item = 0;
 179         guchar buf[8];
 180
 181         if (do_rewind) {
 182                 rewind(f);
 183         }
 184
 185         while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
 186                 unsigned long long buf_size = 0;
 187                 unsigned int buf_fourcc = 0;
 188
 189                 if (read_item < 8) {
 190                         _mmcam_dbg_err("fread failed : %d", read_item);
 191                         break;
 192                 }
 193
 194                 buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
 195
 196                 if (tag_fourcc == buf_fourcc) {
 197                         _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 198                         return TRUE;
 199                 } else {
 200                         _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
 201
 202                         buf_size = (unsigned long long)_mmcamcorder_get_container_size(buf);
 203                         buf_size = buf_size - 8; /* include tag */
 204
 205                         do {
 206                                 if (buf_size > _MMCAMCORDER_MAX_INT) {
 207                                         _mmcam_dbg_log("seek %d", _MMCAMCORDER_MAX_INT);
 208                                         if (fseek(f, _MMCAMCORDER_MAX_INT, SEEK_CUR) != 0) {
 209                                                 _mmcam_dbg_err("fseek() fail");
 210                                                 return FALSE;
 211                                         }
 212
 213                                         buf_size -= _MMCAMCORDER_MAX_INT;
 214                                 } else {
 215                                         _mmcam_dbg_log("seek %d", buf_size);
 216                                         if (fseek(f, buf_size, SEEK_CUR) != 0) {
 217                                                 _mmcam_dbg_err("fseek() fail");
 218                                                 return FALSE;
 219                                         }
 220                                         break;
 221                                 }
 222                         } while (TRUE);
 223                 }
 224         }
 225
 226         _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 227
 228         return FALSE;
 229 }
 230
 231 gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 232 {
 233         size_t read_item = 0;
 234         guchar buf[8];
 235
 236         if (do_rewind) {
 237                 rewind(f);
 238         }
 239
 240         while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
 241                 unsigned long long buf_size = 0;
 242                 unsigned int buf_fourcc = 0;
 243
 244                 if (read_item < 8) {
 245                         _mmcam_dbg_err("fread failed : %d", read_item);
 246                         break;
 247                 }
 248
 249                 buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
 250
 251                 if (tag_fourcc == buf_fourcc) {
 252                         _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 253                         return TRUE;
 254                 }
 255                 else if((buf_fourcc == MMCAM_FOURCC('m','o','o','v')) && (tag_fourcc != buf_fourcc)){
 256                         if(_mmcamcorder_find_fourcc(f,tag_fourcc,FALSE)){
 257                                 return TRUE;
 258                         }
 259                         else{
 260                                 continue;
 261                         }
 262                 } else {
 263                         _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
 264
 265                         buf_size = (unsigned long long)_mmcamcorder_get_container_size(buf);
 266                         buf_size = buf_size - 8; /* include tag */
 267
 268                         do {
 269                                 if (buf_size > _MMCAMCORDER_MAX_INT) {
 270                                         _mmcam_dbg_log("seek %d", _MMCAMCORDER_MAX_INT);
 271                                         if (fseek(f, _MMCAMCORDER_MAX_INT, SEEK_CUR) != 0) {
 272                                                 _mmcam_dbg_err("fseek() fail");
 273                                                 return FALSE;
 274                                         }
 275
 276                                         buf_size -= _MMCAMCORDER_MAX_INT;
 277                                 } else {
 278                                         _mmcam_dbg_log("seek %d", buf_size);
 279                                         if (fseek(f, buf_size, SEEK_CUR) != 0) {
 280                                                 _mmcam_dbg_err("fseek() fail");
 281                                                 return FALSE;
 282                                         }
 283                                         break;
 284                                 }
 285                         } while (TRUE);
 286                 }
 287         }
 288
 289         _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 290
 291         return FALSE;
 292 }
 293
 294 gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
 295 {
 296         _mmcam_dbg_log("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos);
 297         if(fseek(f, prev_pos, SEEK_SET) != 0)
 298         {
 299                 _mmcam_dbg_err("fseek() fail");
 300                 return FALSE;
 301         }
 302
 303         if (!write_to_32(f, curr_pos -prev_pos))
 304                 return FALSE;
 305
 306         if(fseek(f, curr_pos, SEEK_SET) != 0)
 307         {
 308                 _mmcam_dbg_err("fseek() fail");
 309                 return FALSE;
 310         }
 311
 312         return TRUE;
 313 }
 314 // VIDEO TAG - CAMCORDER
 315 gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info)
 316 {
 317         gint64 current_pos, pos;
 318         gchar *str = NULL;
 319
 320         _mmcam_dbg_log("");
 321
 322         if((pos = ftell(f))<0)
 323         {
 324                 _mmcam_dbg_err("ftell() returns negative value");
 325                 return FALSE;
 326         }
 327
 328         if(!write_to_32(f, 0)) //size
 329                 return FALSE;
 330
 331         if(!write_tag(f, "loci"))       // type
 332                 return FALSE;
 333
 334         FPUTC_CHECK(0, f);              // version
 335
 336         if(!write_to_24(f, 0))  // flags
 337                 return FALSE;
 338
 339         if(!write_to_16(f, get_language_code("eng"))) // language
 340                 return FALSE;
 341
 342         str = str_to_utf8("location_name");
 343
 344         FPUTS_CHECK(str, f); // name
 345         SAFE_FREE(str);
 346
 347         FPUTC_CHECK('\0', f);
 348         FPUTC_CHECK(0, f);              //role
 349
 350         if(!write_to_32(f, info.longitude))     // Longitude
 351                 return FALSE;
 352
 353         if(!write_to_32(f, info.latitude)) // Latitude
 354                 return FALSE;
 355
 356         if(! write_to_32(f, info.altitude))     // Altitude
 357                 return FALSE;
 358
 359         str = str_to_utf8("Astronomical_body");
 360         FPUTS_CHECK(str, f);//Astronomical_body
 361         SAFE_FREE(str);
 362
 363         FPUTC_CHECK('\0', f);
 364
 365         str = str_to_utf8("Additional_notes");
 366         FPUTS_CHECK(str, f); // Additional_notes
 367         SAFE_FREE(str);
 368
 369         FPUTC_CHECK('\0', f);
 370
 371         if((current_pos = ftell(f))<0)
 372         {
 373                 _mmcam_dbg_err("ftell() returns negative value");
 374                 return FALSE;
 375         }
 376
 377         if(! _mmcamcorder_update_size(f, pos, current_pos))
 378                 return FALSE;
 379
 380         return TRUE;
 381 }
 382
 383 void _mmcamcorder_write_Latitude(FILE *f,int value) {
 384         char s_latitude[9];
 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_latitude, 5, "-%.2d.", l_decimal);
 392                 } else {
 393                         snprintf(s_latitude, 5, "%.2d.", l_decimal);
 394                 }
 395         } else {
 396                 snprintf(s_latitude, 5, "+%.2d.", 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_latitude[4], 5, "%.4d", l_below_decimal);
 404
 405         write_tag(f, s_latitude);
 406 }
 407
 408 void _mmcamcorder_write_Longitude(FILE *f,int value) {
 409         char s_longitude[10];
 410         int l_decimal = 0;
 411         int l_below_decimal = 0;
 412
 413         l_decimal = value / 10000;
 414         if (value < 0) {
 415                 if( l_decimal == 0) {
 416                         snprintf(s_longitude, 6, "-%.3d.", l_decimal);
 417                 } else {
 418                         snprintf(s_longitude, 6, "%.3d.", l_decimal);
 419                 }
 420         } else {
 421                 snprintf(s_longitude, 6, "+%.3d.", l_decimal);
 422         }
 423
 424         l_below_decimal = value - (l_decimal * 10000);
 425         if (l_below_decimal < 0) {
 426                 l_below_decimal = -l_below_decimal;
 427         }
 428         snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal);
 429
 430         write_tag(f, s_longitude);
 431 }
 432
 433 #define D_GEOGRAPH "\xA9xyz"
 434 // 0x0012 -> latitude(8) + longitude(9) + seperator(1) = 18
 435 // 0x15c7 -> encode in english
 436 #define D_INFO_GEOGRAPH 0x001215c7
 437
 438 gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) {
 439
 440         gint64 current_pos, pos;
 441 //      gchar *str = NULL;
 442
 443         _mmcam_dbg_log("");
 444
 445         if((pos = ftell(f))<0)
 446         {
 447                 _mmcam_dbg_err("ftell() returns negative value");
 448                 return FALSE;
 449         }
 450
 451         if(!write_to_32(f, 0))  //size
 452                 return FALSE;
 453         // tag -> .xyz
 454         if(!write_tag(f, D_GEOGRAPH))   // type
 455                 return FALSE;
 456
 457         if(!write_to_32(f, D_INFO_GEOGRAPH))
 458                 return FALSE;
 459
 460         _mmcamcorder_write_Latitude(f,info.latitude);
 461         _mmcamcorder_write_Longitude(f,info.longitude);
 462
 463         FPUTC_CHECK(0x2F, f);
 464
 465         if((current_pos = ftell(f))<0)
 466         {
 467                 _mmcam_dbg_err("ftell() returns negative value");
 468                 return FALSE;
 469         }
 470
 471         if(! _mmcamcorder_update_size(f, pos, current_pos))
 472                 return FALSE;
 473
 474         return TRUE;
 475 }
 476
 477
 478 gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationInfo info, _MMCamcorderLocationInfo geotag)
 479 {
 480         gint64 current_pos, pos;
 481
 482         _mmcam_dbg_log("gps enable : %d", gps_enable);
 483         if (gps_enable == FALSE) {
 484                 _mmcam_dbg_log("no need to write udta");
 485                 return TRUE;
 486         }
 487
 488         if ((pos = ftell(f))<0) {
 489                 _mmcam_dbg_err("ftell() returns negative value");
 490                 return FALSE;
 491         }
 492
 493         /* size */
 494         if (!write_to_32(f, 0)) {
 495                 _mmcam_dbg_err("failed to write size");
 496                 return FALSE;
 497         }
 498
 499         /* type */
 500         if (!write_tag(f, "udta")) {
 501                 _mmcam_dbg_err("failed to write type udta");
 502                 return FALSE;
 503         }
 504
 505         if (gps_enable) {
 506                 if (!_mmcamcorder_write_loci(f, info)) {
 507                         _mmcam_dbg_err("failed to write loci");
 508                         return FALSE;
 509                 }
 510
 511                 if (!_mmcamcorder_write_geodata(f,geotag)) {
 512                         _mmcam_dbg_err("failed to write geodata");
 513                         return FALSE;
 514                 }
 515         }
 516
 517         if ((current_pos = ftell(f))<0) {
 518                 _mmcam_dbg_err("ftell() returns negative value");
 519                 return FALSE;
 520         }
 521
 522         if (!_mmcamcorder_update_size(f, pos, current_pos)) {
 523                 _mmcam_dbg_err("failed to update size");
 524                 return FALSE;
 525         }
 526
 527         _mmcam_dbg_log("done");
 528
 529         return TRUE;
 530 }
 531
 532
 533 guint64 _mmcamcorder_get_container_size(const guchar *size)
 534 {
 535         guint64 result = 0;
 536         guint64 temp = 0;
 537
 538         temp = size[0];
 539         result = temp << 24;
 540         temp = size[1];
 541         result = result | (temp << 16);
 542         temp = size[2];
 543         result = result | (temp << 8);
 544         result = result | size[3];
 545
 546         _mmcam_dbg_log("result : %lld", (unsigned long long)result);
 547
 548         return result;
 549 }
 550
 551
 552 gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation)
 553 {
 554         /* for 0 degree */
 555         guint32 a = 0x00010000;
 556         guint32 b = 0;
 557         guint32 c = 0;
 558         guint32 d = 0x00010000;
 559
 560         switch (orientation) {
 561         case MM_CAMCORDER_TAG_VIDEO_ORT_90:/* 90 degree */
 562                 a = 0;
 563                 b = 0x00010000;
 564                 c = 0xffff0000;
 565                 d = 0;
 566                 break;
 567         case MM_CAMCORDER_TAG_VIDEO_ORT_180:/* 180 degree */
 568                 a = 0xffff0000;
 569                 d = 0xffff0000;
 570                 break;
 571         case MM_CAMCORDER_TAG_VIDEO_ORT_270:/* 270 degree */
 572                 a = 0;
 573                 b = 0xffff0000;
 574                 c = 0x00010000;
 575                 d = 0;
 576                 break;
 577         case MM_CAMCORDER_TAG_VIDEO_ORT_NONE:/* 0 degree */
 578         default:
 579                 break;
 580         }
 581
 582         write_to_32(f, a);
 583         write_to_32(f, b);
 584         write_to_32(f, 0);
 585         write_to_32(f, c);
 586         write_to_32(f, d);
 587         write_to_32(f, 0);
 588         write_to_32(f, 0);
 589         write_to_32(f, 0);
 590         write_to_32(f, 0x40000000);
 591
 592         _mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x",
 593                        orientation, a, b, c, d);
 594
 595         return TRUE;
 596 }
 597
 598
 599 int _mmcamcorder_get_freespace(const gchar *path, guint64 *free_space)
 600 {
 601         struct statfs fs;
 602
 603         g_assert(path);
 604
 605         if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
 606                 _mmcam_dbg_log("File(%s) doesn't exist.", path);
 607                 return -2;
 608         }
 609
 610         if (-1 == statfs(path, &fs)) {
 611                 _mmcam_dbg_log("statfs failed.(%s)", path);
 612                 return -1;
 613         }
 614
 615         *free_space = (guint64)fs.f_bsize * fs.f_bavail;
 616         return 1;
 617 }
 618
 619
 620 int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type)
 621 {
 622         struct statfs fs;
 623
 624         g_assert(path);
 625
 626         if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
 627                 _mmcam_dbg_log("File(%s) doesn't exist.", path);
 628                 return -2;
 629         }
 630
 631         if (-1 == statfs(path, &fs)) {
 632                 _mmcam_dbg_log("statfs failed.(%s)", path);
 633                 return -1;
 634         }
 635
 636         *file_system_type = (int)fs.f_type;
 637
 638         return 0;
 639 }
 640
 641
 642 int _mmcamcorder_get_freespace_except_system(guint64 *free_space)
 643 {
 644         DBusError err;
 645         DBusMessage *msg;
 646         int ret;
 647         double total_space=0;
 648         double avail_space=0;
 649
 650         msg = __invoke_dbus_method_sync("org.tizen.system.deviced", "/Org/Tizen/System/DeviceD/Storage",
 651                         "org.tizen.system.deviced.storage", "getstorage", NULL, NULL);
 652         if (!msg) {
 653                 _mmcam_dbg_log("method_call failed");
 654                 return FALSE;
 655         }
 656
 657         dbus_error_init(&err);
 658
 659         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT64, &total_space, DBUS_TYPE_INT64, &avail_space, DBUS_TYPE_INVALID);
 660         if (!ret) {
 661                 _mmcam_dbg_log("no message : [%s:%s]", err.name, err.message);
 662                 return FALSE;
 663         }
 664
 665         dbus_message_unref(msg);
 666         dbus_error_free(&err);
 667
 668         *free_space = (guint64)avail_space;
 669         _mmcam_dbg_err(" free space [%" G_GUINT64_FORMAT "] ",*free_space);
 670
 671         return 1;
 672 }
 673
 674 int _mmcamcorder_get_file_size(const char *filename, guint64 *size)
 675 {
 676         struct stat buf;
 677
 678         if (stat(filename, &buf) != 0)
 679                 return -1;
 680         *size = (guint64)buf.st_size;
 681         return 1;
 682 }
 683
 684
 685 void _mmcamcorder_remove_buffer_probe(MMHandleType handle, _MMCamcorderHandlerCategory category)
 686 {
 687         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 688         GList *list = NULL;
 689         MMCamcorderHandlerItem *item = NULL;
 690
 691         mmf_return_if_fail(hcamcorder);
 692
 693         if (!hcamcorder->buffer_probes) {
 694                 _mmcam_dbg_warn("list for buffer probe is NULL");
 695                 return;
 696         }
 697
 698         _mmcam_dbg_log("start - category : 0x%x", category);
 699
 700         list = hcamcorder->buffer_probes;
 701         while (list) {
 702                 item = list->data;
 703                 if (!item) {
 704                         _mmcam_dbg_err("Remove buffer probe faild, the item is NULL");
 705                         list = g_list_next(list);
 706                         continue;
 707                 }
 708
 709                 if (item->category & category) {
 710                         if (item->object && GST_IS_PAD(item->object)) {
 711                                 _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
 712                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 713                                 gst_pad_remove_buffer_probe(GST_PAD(item->object), item->handler_id);
 714                         } else {
 715                                 _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
 716                         }
 717
 718                         list = g_list_next(list);
 719                         hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item);
 720                         SAFE_FREE(item);
 721                 } else {
 722                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 723                         list = g_list_next(list);
 724                 }
 725         }
 726
 727         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 728                 g_list_free(hcamcorder->buffer_probes);
 729                 hcamcorder->buffer_probes = NULL;
 730         }
 731
 732         _mmcam_dbg_log("done");
 733
 734         return;
 735 }
 736
 737
 738 void _mmcamcorder_remove_one_buffer_probe(MMHandleType handle, void *object)
 739 {
 740         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 741         GList *list = NULL;
 742         MMCamcorderHandlerItem *item = NULL;
 743
 744         mmf_return_if_fail(hcamcorder);
 745
 746         if (!hcamcorder->buffer_probes) {
 747                 _mmcam_dbg_warn("list for buffer probe is NULL");
 748                 return;
 749         }
 750
 751         _mmcam_dbg_log("start - object : %p", object);
 752
 753         list = hcamcorder->buffer_probes;
 754         while (list) {
 755                 item = list->data;
 756                 if (!item) {
 757                         _mmcam_dbg_err("Remove buffer probe faild, the item is NULL");
 758                         list = g_list_next(list);
 759                         continue;
 760                 }
 761
 762                 if (item->object && item->object == object) {
 763                         if (GST_IS_PAD(item->object)) {
 764                                 _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
 765                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 766                                 gst_pad_remove_buffer_probe(GST_PAD(item->object), item->handler_id);
 767                         } else {
 768                                 _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
 769                         }
 770
 771                         list = g_list_next(list);
 772                         hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item);
 773                         SAFE_FREE(item);
 774
 775                         break;
 776                 } else {
 777                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 778                         list = g_list_next(list);
 779                 }
 780         }
 781
 782         _mmcam_dbg_log("done");
 783
 784         return;
 785 }
 786
 787
 788 void _mmcamcorder_remove_event_probe(MMHandleType handle, _MMCamcorderHandlerCategory category)
 789 {
 790         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 791         GList *list = NULL;
 792         MMCamcorderHandlerItem *item = NULL;
 793
 794         mmf_return_if_fail(hcamcorder);
 795
 796         if (!hcamcorder->event_probes) {
 797                 _mmcam_dbg_warn("list for event probe is NULL");
 798                 return;
 799         }
 800
 801         _mmcam_dbg_log("start - category : 0x%x", category);
 802
 803         list = hcamcorder->event_probes;
 804         while (list) {
 805                 item = list->data;
 806                 if (!item) {
 807                         _mmcam_dbg_err("Remove event probe faild, the item is NULL");
 808                         list = g_list_next(list);
 809                         continue;
 810                 }
 811
 812                 if (item->category & category) {
 813                         if (item->object && GST_IS_PAD(item->object)) {
 814                                 _mmcam_dbg_log("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]",
 815                                                GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 816                                 gst_pad_remove_event_probe(GST_PAD(item->object), item->handler_id);
 817                         } else {
 818                                 _mmcam_dbg_warn("Remove event probe faild, the pad is null or not pad, just remove item from list and free it");
 819                         }
 820
 821                         list = g_list_next(list);
 822                         hcamcorder->event_probes = g_list_remove(hcamcorder->event_probes, item);
 823                         SAFE_FREE(item);
 824                 } else {
 825                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 826                         list = g_list_next(list);
 827                 }
 828         }
 829
 830         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 831                 g_list_free(hcamcorder->event_probes);
 832                 hcamcorder->event_probes = NULL;
 833         }
 834
 835         _mmcam_dbg_log("done");
 836
 837         return;
 838 }
 839
 840
 841 void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCategory category)
 842 {
 843         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 844         GList *list = NULL;
 845         MMCamcorderHandlerItem *item = NULL;
 846
 847         mmf_return_if_fail(hcamcorder);
 848
 849         if (!hcamcorder->signals) {
 850                 _mmcam_dbg_warn("list for signal is NULL");
 851                 return;
 852         }
 853
 854         _mmcam_dbg_log("start - category : 0x%x", category);
 855
 856         list = hcamcorder->signals;
 857         while (list) {
 858                 item = list->data;
 859                 if (!item) {
 860                         _mmcam_dbg_err("Fail to Disconnecting signal, the item is NULL");
 861                         list = g_list_next(list);
 862                         continue;
 863                 }
 864
 865                 if (item->category & category) {
 866                         if (item->object && GST_IS_ELEMENT(item->object)) {
 867                                 if (g_signal_handler_is_connected(item->object, item->handler_id)) {
 868                                         _mmcam_dbg_log("Disconnect signal from [%s] : [ID : %lu], [Category : %x]",
 869                                                        GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
 870                                         g_signal_handler_disconnect(item->object, item->handler_id);
 871                                 } else {
 872                                         _mmcam_dbg_warn("Signal was not connected, cannot disconnect it :  [%s]  [ID : %lu], [Category : %x]",
 873                                                         GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
 874                                 }
 875                         } else {
 876                                 _mmcam_dbg_err("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it");
 877                         }
 878
 879                         list = g_list_next(list);
 880                         hcamcorder->signals = g_list_remove(hcamcorder->signals, item);
 881                         SAFE_FREE(item);
 882                 } else {
 883                         _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category);
 884                         list = g_list_next(list);
 885                 }
 886         }
 887
 888         if (category == _MMCAMCORDER_HANDLER_CATEGORY_ALL) {
 889                 g_list_free(hcamcorder->signals);
 890                 hcamcorder->signals = NULL;
 891         }
 892
 893         _mmcam_dbg_log("done");
 894
 895         return;
 896 }
 897
 898
 899 void _mmcamcorder_remove_all_handlers(MMHandleType handle,  _MMCamcorderHandlerCategory category)
 900 {
 901         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
 902
 903         _mmcam_dbg_log("ENTER");
 904
 905         if(hcamcorder->signals)
 906                 _mmcamcorder_disconnect_signal((MMHandleType)hcamcorder, category);
 907         if(hcamcorder->event_probes)
 908                 _mmcamcorder_remove_event_probe((MMHandleType)hcamcorder, category);
 909         if(hcamcorder->buffer_probes)
 910                 _mmcamcorder_remove_buffer_probe((MMHandleType)hcamcorder, category);
 911
 912         _mmcam_dbg_log("LEAVE");
 913 }
 914
 915
 916 void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was)
 917 {
 918         int i=0;
 919         _MMCamcorderSubContext *sc = (_MMCamcorderSubContext *)data;
 920
 921         mmf_return_if_fail(sc);
 922         mmf_return_if_fail(sc->element);
 923
 924         for (i = 0 ; i < _MMCAMCORDER_PIPELINE_ELEMENT_NUM ; i++) {
 925                 if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) {
 926                         _mmcam_dbg_warn("The element[%d][%p] is finalized",
 927                                         sc->element[i].id, sc->element[i].gst);
 928                         sc->element[i].gst = NULL;
 929                         sc->element[i].id = _MMCAMCORDER_NONE;
 930                         return;
 931                 }
 932         }
 933
 934         mmf_return_if_fail(sc->encode_element);
 935
 936         for (i = 0 ; i < _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM ; i++) {
 937                 if (sc->encode_element[i].gst && (G_OBJECT(sc->encode_element[i].gst) == where_the_object_was)) {
 938                         _mmcam_dbg_warn("The encode element[%d][%p] is finalized",
 939                                         sc->encode_element[i].id, sc->encode_element[i].gst);
 940                         sc->encode_element[i].gst = NULL;
 941                         sc->encode_element[i].id = _MMCAMCORDER_ENCODE_NONE;
 942                         return;
 943                 }
 944         }
 945
 946         _mmcam_dbg_warn("there is no matching element %p", where_the_object_was);
 947
 948         return;
 949 }
 950
 951
 952 gboolean
 953 _mmcamcroder_msg_callback(void *data)
 954 {
 955         _MMCamcorderMsgItem *item = (_MMCamcorderMsgItem*)data;
 956         mmf_camcorder_t *hcamcorder = NULL;
 957         mmf_return_val_if_fail(item, FALSE);
 958
 959         g_mutex_lock(&item->lock);
 960
 961         hcamcorder = MMF_CAMCORDER(item->handle);
 962         if (hcamcorder == NULL) {
 963                 _mmcam_dbg_warn("msg id:%x, item:%p, handle is NULL", item->id, item);
 964                 goto MSG_CALLBACK_DONE;
 965         }
 966
 967
 968         /*_mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/
 969
 970         _MMCAMCORDER_LOCK((MMHandleType)hcamcorder);
 971
 972         /* remove item from msg data */
 973         if (hcamcorder->msg_data) {
 974                 hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
 975         } else {
 976                 _mmcam_dbg_warn("msg_data is NULL but item[%p] will be removed", item);
 977         }
 978
 979         _MMCAMCORDER_UNLOCK((MMHandleType)hcamcorder);
 980
 981         _MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
 982
 983         if ((hcamcorder) && (hcamcorder->msg_cb)) {
 984                 hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param);
 985         }
 986
 987         _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
 988
 989 MSG_CALLBACK_DONE:
 990         /* release allocated memory */
 991         if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
 992                 MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
 993                 if (cam_fd_info) {
 994                         SAFE_FREE(cam_fd_info->face_info);
 995                         free(cam_fd_info);
 996                         cam_fd_info = NULL;
 997                 }
 998
 999                 item->param.data = NULL;
1000                 item->param.size = 0;
1001         }
1002
1003         g_mutex_unlock(&item->lock);
1004         g_mutex_clear(&item->lock);
1005
1006         free(item);
1007         item = NULL;
1008
1009         /* For not being called again */
1010         return FALSE;
1011 }
1012
1013
1014 gboolean
1015 _mmcamcroder_send_message(MMHandleType handle, _MMCamcorderMsgItem *data)
1016 {
1017         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1018         _MMCamcorderMsgItem *item = NULL;
1019
1020         mmf_return_val_if_fail(hcamcorder, FALSE);
1021         mmf_return_val_if_fail(data, FALSE);
1022
1023         switch (data->id)
1024         {
1025                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
1026                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
1027                         data->param.union_type = MM_MSG_UNION_STATE;
1028                         break;
1029                 case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
1030                         data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
1031                         break;
1032                 case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
1033                         data->param.union_type = MM_MSG_UNION_FIRMWARE;
1034                         break;
1035                 case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
1036                         data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
1037                         break;
1038                 case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
1039                 case MM_MESSAGE_CAMCORDER_MAX_SIZE:
1040                 case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
1041                 case MM_MESSAGE_CAMCORDER_ERROR:
1042                 case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
1043                 case MM_MESSAGE_CAMCORDER_CAPTURED:
1044                 case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
1045                 case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
1046                 case MM_MESSAGE_READY_TO_RESUME:
1047                 default:
1048                         data->param.union_type = MM_MSG_UNION_CODE;
1049                         break;
1050         }
1051
1052         item = g_malloc(sizeof(_MMCamcorderMsgItem));
1053         if (item) {
1054                 memcpy(item, data, sizeof(_MMCamcorderMsgItem));
1055                 item->handle = handle;
1056                 g_mutex_init(&item->lock);
1057
1058                 _MMCAMCORDER_LOCK(handle);
1059                 hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item);
1060                 //_mmcam_dbg_log("item[%p]", item);
1061
1062                 /* Use DEFAULT priority */
1063                 g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcroder_msg_callback, item, NULL);
1064
1065                 _MMCAMCORDER_UNLOCK(handle);
1066         } else {
1067                 _mmcam_dbg_err("item malloc failed : %d", sizeof(_MMCamcorderMsgItem));
1068         }
1069
1070         return TRUE;
1071 }
1072
1073
1074 void
1075 _mmcamcroder_remove_message_all(MMHandleType handle)
1076 {
1077         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1078         _MMCamcorderMsgItem *item = NULL;
1079         gboolean ret = TRUE;
1080         GList *list = NULL;
1081
1082         mmf_return_if_fail(hcamcorder);
1083
1084         _MMCAMCORDER_LOCK(handle);
1085
1086         if (!hcamcorder->msg_data) {
1087                 _mmcam_dbg_log("No message data is remained.");
1088         } else {
1089                 list = hcamcorder->msg_data;
1090
1091                 while (list) {
1092                         item = list->data;
1093                         list = g_list_next(list);
1094
1095                         if (!item) {
1096                                 _mmcam_dbg_err("Fail to remove message. The item is NULL");
1097                         } else {
1098                                 if (g_mutex_trylock(&item->lock)) {
1099                                         ret = g_idle_remove_by_data (item);
1100                                         _mmcam_dbg_log("Remove item[%p]. ret[%d]", item, ret);
1101
1102                                         hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
1103
1104                                         if (ret ) {
1105                                                 /* release allocated memory */
1106                                                 if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
1107                                                         MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
1108                                                         if (cam_fd_info) {
1109                                                                 SAFE_FREE(cam_fd_info->face_info);
1110                                                                 free(cam_fd_info);
1111                                                                 cam_fd_info = NULL;
1112                                                         }
1113
1114                                                         item->param.data = NULL;
1115                                                         item->param.size = 0;
1116                                                 }
1117
1118                                                 g_mutex_unlock(&item->lock);
1119                                                 g_mutex_clear(&item->lock);
1120                                                 SAFE_FREE(item);
1121                                         } else {
1122                                                 item->handle = 0;
1123                                                 _mmcam_dbg_warn("Fail to remove item[%p]", item);
1124
1125                                                 g_mutex_unlock(&item->lock);
1126                                         }
1127                                 } else {
1128                                         _mmcam_dbg_warn("item lock failed. it's being called...");
1129                                 }
1130                         }
1131                 }
1132
1133                 g_list_free(hcamcorder->msg_data);
1134                 hcamcorder->msg_data = NULL;
1135         }
1136
1137         /* remove idle function for playing capture sound */
1138         do {
1139                 ret = g_idle_remove_by_data(hcamcorder);
1140                 _mmcam_dbg_log("remove idle function for playing capture sound. ret[%d]", ret);
1141         } while (ret);
1142
1143         _MMCAMCORDER_UNLOCK(handle);
1144
1145         return;
1146 }
1147
1148
1149 int _mmcamcorder_get_pixel_format(GstBuffer *buffer)
1150 {
1151         GstCaps *caps = NULL;
1152         const GstStructure *structure;
1153         const char *media_type;
1154         MMPixelFormatType type = 0;
1155         unsigned int fourcc = 0;
1156
1157         mmf_return_val_if_fail( buffer != NULL, MM_PIXEL_FORMAT_INVALID );
1158
1159         caps = gst_buffer_get_caps (buffer);
1160         structure = gst_caps_get_structure (caps, 0);
1161         media_type = gst_structure_get_name (structure);
1162         if (media_type == NULL) {
1163                 _mmcam_dbg_err("failed to get media_type");
1164                 return MM_PIXEL_FORMAT_INVALID;
1165         }
1166
1167         if (!strcmp (media_type, "image/jpeg") ) {
1168                 _mmcam_dbg_log("It is jpeg.");
1169                 type = MM_PIXEL_FORMAT_ENCODED;
1170         } else if (!strcmp (media_type, "video/x-raw-yuv")) {
1171                 _mmcam_dbg_log("It is yuv.");
1172                 gst_structure_get_fourcc (structure, "format", &fourcc);
1173                 type = _mmcamcorder_get_pixtype(fourcc);
1174         } else if (!strcmp (media_type, "video/x-raw-rgb")) {
1175                 _mmcam_dbg_log("It is rgb.");
1176                 type = MM_PIXEL_FORMAT_RGB888;
1177         } else {
1178                 _mmcam_dbg_err("Not supported format");
1179                 type = MM_PIXEL_FORMAT_INVALID;
1180         }
1181
1182         /*_mmcam_dbg_log( "Type [%d]", type );*/
1183
1184         gst_caps_unref( caps );
1185         caps = NULL;
1186
1187         return type;
1188 }
1189
1190 unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_copy_format)
1191 {
1192         unsigned int fourcc = 0;
1193
1194         /*_mmcam_dbg_log("pixtype(%d)", pixtype);*/
1195
1196         switch (pixtype) {
1197         case MM_PIXEL_FORMAT_NV12:
1198                 if (use_zero_copy_format) {
1199                         fourcc = GST_MAKE_FOURCC ('S', 'N', '1', '2');
1200                 } else {
1201                         fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
1202                 }
1203                 break;
1204         case MM_PIXEL_FORMAT_NV21:
1205                 if (use_zero_copy_format) {
1206                         fourcc = GST_MAKE_FOURCC ('S', 'N', '2', '1');
1207                 } else {
1208                         fourcc = GST_MAKE_FOURCC ('N', 'V', '2', '1');
1209                 }
1210                 break;
1211         case MM_PIXEL_FORMAT_YUYV:
1212                 if (use_zero_copy_format) {
1213                         fourcc = GST_MAKE_FOURCC ('S', 'U', 'Y', 'V');
1214                 } else {
1215                         fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
1216                 }
1217                 break;
1218         case MM_PIXEL_FORMAT_UYVY:
1219                 if (use_zero_copy_format) {
1220                         fourcc = GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y');
1221                 } else {
1222                         fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
1223                 }
1224                 break;
1225         case MM_PIXEL_FORMAT_I420:
1226                 if (use_zero_copy_format) {
1227                         fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
1228                 } else {
1229                         fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
1230                 }
1231                 break;
1232         case MM_PIXEL_FORMAT_YV12:
1233                 fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
1234                 break;
1235         case MM_PIXEL_FORMAT_422P:
1236                 fourcc = GST_MAKE_FOURCC ('4', '2', '2', 'P');
1237                 break;
1238         case MM_PIXEL_FORMAT_RGB565:
1239                 fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', 'P');
1240                 break;
1241         case MM_PIXEL_FORMAT_RGB888:
1242                 fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', ' ');
1243                 break;
1244         case MM_PIXEL_FORMAT_ENCODED:
1245                 if (codectype == MM_IMAGE_CODEC_JPEG) {
1246                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
1247                 } else if (codectype == MM_IMAGE_CODEC_JPEG_SRW) {
1248                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
1249                 } else if (codectype == MM_IMAGE_CODEC_SRW) {
1250                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
1251                 } else if (codectype == MM_IMAGE_CODEC_PNG) {
1252                         fourcc = GST_MAKE_FOURCC ('P', 'N', 'G', ' ');
1253                 } else {
1254                         /* Please let us know what other fourcces are. ex) BMP, GIF?*/
1255                         fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
1256                 }
1257                 break;
1258         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
1259                 fourcc = GST_MAKE_FOURCC('I','T','L','V');
1260                 break;
1261         default:
1262                 _mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype);
1263                 if (use_zero_copy_format) {
1264                         fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
1265                 } else {
1266                         fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
1267                 }
1268                 break;
1269         }
1270
1271         return fourcc;
1272 }
1273
1274
1275 int _mmcamcorder_get_pixtype(unsigned int fourcc)
1276 {
1277         int pixtype = MM_PIXEL_FORMAT_INVALID;
1278         /*
1279         char *pfourcc = (char*)&fourcc;
1280
1281         _mmcam_dbg_log("fourcc(%c%c%c%c)",
1282                          pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
1283         */
1284
1285         switch (fourcc) {
1286         case GST_MAKE_FOURCC ('S', 'N', '1', '2'):
1287         case GST_MAKE_FOURCC ('N', 'V', '1', '2'):
1288                 pixtype = MM_PIXEL_FORMAT_NV12;
1289                 break;
1290         case GST_MAKE_FOURCC ('S', 'N', '2', '1'):
1291         case GST_MAKE_FOURCC ('N', 'V', '2', '1'):
1292                 pixtype = MM_PIXEL_FORMAT_NV21;
1293                 break;
1294         case GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'):
1295         case GST_MAKE_FOURCC ('Y', 'U', 'Y', 'V'):
1296         case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
1297                 pixtype = MM_PIXEL_FORMAT_YUYV;
1298                 break;
1299         case GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'):
1300         case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
1301                 pixtype = MM_PIXEL_FORMAT_UYVY;
1302                 break;
1303         case GST_MAKE_FOURCC ('S', '4', '2', '0'):
1304         case GST_MAKE_FOURCC ('I', '4', '2', '0'):
1305                 pixtype = MM_PIXEL_FORMAT_I420;
1306                 break;
1307         case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
1308                 pixtype = MM_PIXEL_FORMAT_YV12;
1309                 break;
1310         case GST_MAKE_FOURCC ('4', '2', '2', 'P'):
1311                 pixtype = MM_PIXEL_FORMAT_422P;
1312                 break;
1313         case GST_MAKE_FOURCC ('R', 'G', 'B', 'P'):
1314                 pixtype = MM_PIXEL_FORMAT_RGB565;
1315                 break;
1316         case GST_MAKE_FOURCC ('R', 'G', 'B', '3'):
1317                 pixtype = MM_PIXEL_FORMAT_RGB888;
1318                 break;
1319         case GST_MAKE_FOURCC ('A', 'R', 'G', 'B'):
1320         case GST_MAKE_FOURCC ('x', 'R', 'G', 'B'):
1321                 pixtype = MM_PIXEL_FORMAT_ARGB;
1322                 break;
1323         case GST_MAKE_FOURCC ('B', 'G', 'R', 'A'):
1324         case GST_MAKE_FOURCC ('B', 'G', 'R', 'x'):
1325         case GST_MAKE_FOURCC ('S', 'R', '3', '2'):
1326                 pixtype = MM_PIXEL_FORMAT_RGBA;
1327                 break;
1328         case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'):
1329         case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
1330                 pixtype = MM_PIXEL_FORMAT_ENCODED;
1331                 break;
1332         /*FIXME*/
1333         case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'):
1334                 pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
1335                 break;
1336         default:
1337                 _mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)",
1338                                fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
1339                 pixtype = MM_PIXEL_FORMAT_INVALID;
1340                 break;
1341         }
1342
1343         return pixtype;
1344 }
1345
1346
1347 gboolean _mmcamcorder_add_elements_to_bin(GstBin *bin, GList *element_list)
1348 {
1349         GList *local_list = element_list;
1350         _MMCamcorderGstElement *element = NULL;
1351
1352         mmf_return_val_if_fail(bin && local_list, FALSE);
1353
1354         while (local_list) {
1355                 element = (_MMCamcorderGstElement*)local_list->data;
1356                 if (element && element->gst) {
1357                         if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
1358                                 _mmcam_dbg_err( "Add element [%s] to bin [%s] FAILED",
1359                                                 GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
1360                                                 GST_ELEMENT_NAME(GST_ELEMENT(bin)) );
1361                                 return FALSE;
1362                         } else {
1363                                 _mmcam_dbg_log("Add element [%s] to bin [%s] OK",
1364                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
1365                                                GST_ELEMENT_NAME(GST_ELEMENT(bin)));
1366                         }
1367                 }
1368                 local_list = local_list->next;
1369         }
1370
1371         return TRUE;
1372 }
1373
1374 gboolean _mmcamcorder_link_elements(GList *element_list)
1375 {
1376         GList                  *local_list  = element_list;
1377         _MMCamcorderGstElement *element     = NULL;
1378         _MMCamcorderGstElement *pre_element = NULL;
1379
1380         mmf_return_val_if_fail(local_list, FALSE);
1381
1382         pre_element = (_MMCamcorderGstElement*)local_list->data;
1383         local_list = local_list->next;
1384
1385         while (local_list) {
1386                 element = (_MMCamcorderGstElement*)local_list->data;
1387                 if (element && element->gst) {
1388                         if (_MM_GST_ELEMENT_LINK(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst))) {
1389                                 _mmcam_dbg_log("Link [%s] to [%s] OK",
1390                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1391                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1392                         } else {
1393                                 _mmcam_dbg_err("Link [%s] to [%s] FAILED",
1394                                                GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
1395                                                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
1396                                 return FALSE;
1397                         }
1398                 }
1399
1400                 pre_element = element;
1401                 local_list = local_list->next;
1402         }
1403
1404         return TRUE;
1405 }
1406
1407
1408 gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format,
1409                                    unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length)
1410 {
1411         int ret = TRUE;
1412         int mm_ret = MM_ERROR_NONE;
1413         int input_format = MM_UTIL_IMG_FMT_YUV420;
1414         unsigned char *dst_tmp_data = NULL;
1415
1416         if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) {
1417                 _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p",
1418                                src_data, dst_data, dst_width, dst_height, dst_length);
1419                 return FALSE;
1420         }
1421
1422         /* set input format for mm-util */
1423         switch (src_format) {
1424         case MM_PIXEL_FORMAT_I420:
1425                 input_format = MM_UTIL_IMG_FMT_I420;
1426                 break;
1427         case MM_PIXEL_FORMAT_YV12:
1428                 input_format = MM_UTIL_IMG_FMT_YUV420;
1429                 break;
1430         case MM_PIXEL_FORMAT_NV12:
1431                 input_format = MM_UTIL_IMG_FMT_NV12;
1432                 break;
1433         case MM_PIXEL_FORMAT_YUYV:
1434                 input_format = MM_UTIL_IMG_FMT_YUYV;
1435                 break;
1436         case MM_PIXEL_FORMAT_UYVY:
1437                 input_format = MM_UTIL_IMG_FMT_UYVY;
1438                 break;
1439         case MM_PIXEL_FORMAT_RGB888:
1440                 input_format = MM_UTIL_IMG_FMT_RGB888;
1441                 break;
1442         default:
1443                 _mmcam_dbg_err("NOT supported format", src_format);
1444                 return FALSE;
1445         }
1446
1447         _mmcam_dbg_log("src size %dx%d -> dst size %dx%d",
1448                         src_width, src_height, *dst_width, *dst_height);
1449
1450         /* get length of resized image */
1451         mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length);
1452         if (mm_ret != MM_ERROR_NONE) {
1453                 GST_ERROR("mm_util_get_image_size failed 0x%x", ret);
1454                 return FALSE;
1455         }
1456
1457         _mmcam_dbg_log("dst_length : %d", *dst_length);
1458
1459         dst_tmp_data = (unsigned char *)malloc(*dst_length);
1460         if (dst_tmp_data == NULL) {
1461                 _mmcam_dbg_err("failed to alloc dst_thumb_size(size %d)", *dst_length);
1462                 return FALSE;
1463         }
1464
1465         mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format,
1466                                       dst_tmp_data, dst_width, dst_height);
1467         if (mm_ret != MM_ERROR_NONE) {
1468                 GST_ERROR("mm_util_resize_image failed 0x%x", ret);
1469                 free(dst_tmp_data);
1470                 return FALSE;
1471         }
1472
1473         *dst_data = dst_tmp_data;
1474
1475         _mmcam_dbg_log("resize done %p, %dx%d", *dst_data, *dst_width, *dst_height);
1476
1477         return TRUE;
1478 }
1479
1480
1481 gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
1482                                   int src_format, unsigned int src_length, unsigned int jpeg_quality,
1483                                   void **result_data, unsigned int *result_length, int enc_type)
1484 {
1485         int ret = 0;
1486         int i = 0;
1487         guint32 src_fourcc = 0;
1488         gboolean do_encode = FALSE;
1489         jpegenc_parameter enc_param;
1490         jpegenc_info enc_info;
1491
1492         _mmcam_dbg_log("START - enc_type [%d]", enc_type);
1493
1494         mmf_return_val_if_fail(src_data && result_data && result_length, FALSE);
1495
1496         CLEAR(enc_param);
1497         CLEAR(enc_info);
1498
1499         camsrcjpegenc_get_info(&enc_info);
1500
1501         src_fourcc = _mmcamcorder_get_fourcc(src_format, 0, FALSE);
1502         camsrcjpegenc_get_src_fmt(src_fourcc, &(enc_param.src_fmt));
1503
1504         if (enc_param.src_fmt == COLOR_FORMAT_NOT_SUPPORT) {
1505                 _mmcam_dbg_err("Not Supported FOURCC(format:%d)", src_format);
1506                 return FALSE;
1507         }
1508
1509         /* check H/W encoder */
1510         if (enc_info.hw_support && enc_type == JPEG_ENCODER_HARDWARE) {
1511                 _mmcam_dbg_log("check H/W encoder supported format list");
1512                 /* Check supported format */
1513                 for (i = 0 ; i < enc_info.hw_enc.input_fmt_num ; i++) {
1514                         if (enc_param.src_fmt == enc_info.hw_enc.input_fmt_list[i]) {
1515                                 do_encode = TRUE;
1516                                 break;
1517                         }
1518                 }
1519
1520                 if (do_encode) {
1521                         enc_type = JPEG_ENCODER_HARDWARE;
1522                 }
1523         }
1524
1525         /* check S/W encoder */
1526         if (!do_encode && enc_info.sw_support) {
1527                 _mmcam_dbg_log("check S/W encoder supported format list");
1528                 /* Check supported format */
1529                 for (i = 0 ; i < enc_info.sw_enc.input_fmt_num ; i++) {
1530                         if (enc_param.src_fmt == enc_info.sw_enc.input_fmt_list[i]) {
1531                                 do_encode = TRUE;
1532                                 break;
1533                         }
1534                 }
1535
1536                 if (do_encode) {
1537                         enc_type = JPEG_ENCODER_SOFTWARE;
1538                 }
1539         }
1540
1541         if (do_encode) {
1542                 enc_param.src_data = src_data;
1543                 enc_param.width = src_width;
1544                 enc_param.height = src_height;
1545                 enc_param.src_len = src_length;
1546                 enc_param.jpeg_mode = JPEG_MODE_BASELINE;
1547                 enc_param.jpeg_quality = jpeg_quality;
1548
1549                 _mmcam_dbg_log("%ux%u, size %u, quality %u, type %d",
1550                                src_width, src_height, src_length,
1551                                jpeg_quality, enc_type);
1552
1553                 ret = camsrcjpegenc_encode(&enc_info, enc_type, &enc_param );
1554                 if (ret == CAMSRC_JPEGENC_ERROR_NONE) {
1555                         *result_data = enc_param.result_data;
1556                         *result_length = enc_param.result_len;
1557
1558                         _mmcam_dbg_log("JPEG encode length(%d)", *result_length);
1559
1560                         return TRUE;
1561                 } else {
1562                         _mmcam_dbg_err("camsrcjpegenc_encode failed(%x)", ret);
1563                         return FALSE;
1564                 }
1565         }
1566
1567         _mmcam_dbg_err("No encoder supports %d format", src_format);
1568
1569         return FALSE;
1570 }
1571
1572
1573 /* make UYVY smaller as multiple size. ex: 640x480 -> 320x240 or 160x120 ... */
1574 gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_width, unsigned int src_height,
1575                                            unsigned char **dst, unsigned int dst_width, unsigned int dst_height)
1576 {
1577         unsigned int i = 0;
1578         int j = 0;
1579         int k = 0;
1580         int src_index = 0;
1581         int ratio_width = 0;
1582         int ratio_height = 0;
1583         int line_base = 0;
1584         int line_width = 0;
1585         int jump_width = 0;
1586         unsigned char *result = NULL;
1587
1588         if (src == NULL || dst == NULL) {
1589                 _mmcam_dbg_err("src[%p] or dst[%p] is NULL", src, dst);
1590                 return FALSE;
1591         }
1592
1593         result = (unsigned char *)malloc((dst_width * dst_height)<<1);
1594         if (!result) {
1595                 _mmcam_dbg_err("failed to alloc dst data");
1596                 return FALSE;
1597         }
1598
1599         ratio_width = src_width / dst_width;
1600         ratio_height = src_height / dst_height;
1601         line_width = src_width << 1;
1602         jump_width = ratio_width << 1;
1603
1604         _mmcam_dbg_warn("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]",
1605                         src_width, src_height, dst_width, dst_height,
1606                         line_width, ratio_width, ratio_height);
1607
1608         for (i = 0 ; i < src_height ; i += ratio_height) {
1609                 line_base = i * line_width;
1610                 for (j = 0 ; j < line_width ; j += jump_width) {
1611                         src_index = line_base + j;
1612                         result[k++] = src[src_index];
1613                         result[k++] = src[src_index+1];
1614
1615                         j += jump_width;
1616                         src_index = line_base + j;
1617                         if (src_index % 4 == 0) {
1618                                 result[k++] = src[src_index+2];
1619                         } else {
1620                                 result[k++] = src[src_index];
1621                         }
1622                         result[k++] = src[src_index+1];
1623                 }
1624         }
1625
1626         *dst = result;
1627
1628         _mmcam_dbg_warn("converting done - result %p", result);
1629
1630         return TRUE;
1631 }
1632
1633 gboolean _mmcamcorder_check_file_path(const gchar *path)
1634 {
1635         if(strstr(path, "/opt/usr") != NULL) {
1636                 return TRUE;
1637         }
1638         return FALSE;
1639 }
1640
1641 static guint16 get_language_code(const char *str)
1642 {
1643     return (guint16) (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
1644 }
1645
1646 static gchar * str_to_utf8(const gchar *str)
1647 {
1648         return g_convert (str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
1649 }
1650
1651 static inline gboolean write_tag(FILE *f, const gchar *tag)
1652 {
1653         while(*tag)
1654                 FPUTC_CHECK(*tag++, f);
1655
1656         return TRUE;
1657 }
1658
1659 static inline gboolean write_to_32(FILE *f, guint val)
1660 {
1661         FPUTC_CHECK(val >> 24, f);
1662         FPUTC_CHECK(val >> 16, f);
1663         FPUTC_CHECK(val >> 8, f);
1664         FPUTC_CHECK(val, f);
1665         return TRUE;
1666 }
1667
1668 static inline gboolean write_to_16(FILE *f, guint val)
1669 {
1670         FPUTC_CHECK(val >> 8, f);
1671         FPUTC_CHECK(val, f);
1672         return TRUE;
1673 }
1674
1675 static inline gboolean write_to_24(FILE *f, guint val)
1676 {
1677         write_to_16(f, val >> 8);
1678         FPUTC_CHECK(val, f);
1679         return TRUE;
1680 }
1681
1682 void *_mmcamcorder_util_task_thread_func(void *data)
1683 {
1684         int ret = MM_ERROR_NONE;
1685         mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
1686
1687         if (!hcamcorder) {
1688                 _mmcam_dbg_err("handle is NULL");
1689                 return NULL;
1690         }
1691
1692         _mmcam_dbg_warn("start thread");
1693
1694         pthread_mutex_lock(&(hcamcorder->task_thread_lock));
1695
1696         while (hcamcorder->task_thread_state != _MMCAMCORDER_TASK_THREAD_STATE_EXIT) {
1697                 switch (hcamcorder->task_thread_state) {
1698                 case _MMCAMCORDER_TASK_THREAD_STATE_NONE:
1699                         _mmcam_dbg_warn("wait for task signal");
1700                         pthread_cond_wait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock));
1701                         _mmcam_dbg_warn("task signal received : state %d", hcamcorder->task_thread_state);
1702                         break;
1703                 case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_PLAY_START:
1704                         _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE, FALSE);
1705                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
1706                         break;
1707                 case _MMCAMCORDER_TASK_THREAD_STATE_ENCODE_PIPE_CREATE:
1708                         ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder);
1709
1710                         /* Play record start sound */
1711                         _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_REC_START_SND, FALSE);
1712
1713                         _mmcam_dbg_log("_mmcamcorder_video_prepare_record return 0x%x", ret);
1714                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
1715                         break;
1716                 default:
1717                         _mmcam_dbg_warn("invalid task thread state %d", hcamcorder->task_thread_state);
1718                         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
1719                         break;
1720                 }
1721         }
1722
1723         pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
1724
1725         _mmcam_dbg_warn("exit thread");
1726
1727         return NULL;
1728 }