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