src/mm_camcorder_configure.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 <string.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29
  30 #include "mm_camcorder_internal.h"
  31 #include "mm_camcorder_configure.h"
  32
  33 /*-----------------------------------------------------------------------
  34 |    MACRO DEFINITIONS:                                                 |
  35 -----------------------------------------------------------------------*/
  36 #define CONFIGURE_PATH          "/usr/etc"
  37 #define CONFIGURE_PATH_RETRY    "/opt/etc"
  38
  39 /*-----------------------------------------------------------------------
  40 |    GLOBAL VARIABLE DEFINITIONS                                        |
  41 -----------------------------------------------------------------------*/
  42
  43 /*-----------------------------------------------------------------------
  44 |    LOCAL VARIABLE DEFINITIONS                                         |
  45 -----------------------------------------------------------------------*/
  46
  47 char *get_new_string(char* src_string)
  48 {
  49         return g_strdup(src_string);
  50 }
  51
  52 void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configure_info)
  53 {
  54         int i = 0;
  55         int info_table_size = sizeof(conf_info_table);
  56
  57         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
  58
  59         /* Videosrc element default value */
  60         static type_element _videosrc_element_default = {
  61                 "VideosrcElement",
  62                 "videotestsrc",
  63                 NULL,
  64                 0,
  65                 NULL,
  66                 0,
  67         };
  68
  69         /* Audiosrc element default value */
  70         static type_int  ___audiosrc_default_channel = { "Channel", 1 };
  71         static type_int  ___audiosrc_default_bitrate = { "BitRate", 8000 };
  72         static type_int  ___audiosrc_default_depth = { "Depth", 16 };
  73         static type_int  ___audiosrc_default_blocksize = { "BlockSize", 1280 };
  74         static type_int* __audiosrc_default_int_array[] = {
  75                 &___audiosrc_default_channel,
  76                 &___audiosrc_default_bitrate,
  77                 &___audiosrc_default_depth,
  78                 &___audiosrc_default_blocksize,
  79         };
  80         static type_string  ___audiosrc_default_device = { "Device", "default" };
  81         static type_string* __audiosrc_default_string_array[] = {
  82                 &___audiosrc_default_device,
  83         };
  84         static type_element _audiosrc_element_default = {
  85                 "AudiosrcElement",
  86                 "audiotestsrc",
  87                 __audiosrc_default_int_array,
  88                 sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
  89                 __audiosrc_default_string_array,
  90                 sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
  91         };
  92
  93         static type_element _audiomodemsrc_element_default = {
  94                 "AudiomodemsrcElement",
  95                 "audiotestsrc",
  96                 __audiosrc_default_int_array,
  97                 sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
  98                 __audiosrc_default_string_array,
  99                 sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
 100         };
 101
 102
 103         /* Videosink element default value */
 104         static type_int  ___videosink_default_display_id = { "display-id", 3 };
 105         static type_int  ___videosink_default_x = { "x", 0 };
 106         static type_int  ___videosink_default_y = { "y", 0 };
 107         static type_int  ___videosink_default_width = { "width", 800 };
 108         static type_int  ___videosink_default_height = { "height", 480 };
 109         static type_int  ___videosink_default_rotation = { "rotation", 1 };
 110         static type_int* __videosink_default_int_array[] = {
 111                 &___videosink_default_display_id,
 112                 &___videosink_default_x,
 113                 &___videosink_default_y,
 114                 &___videosink_default_width,
 115                 &___videosink_default_height,
 116                 &___videosink_default_rotation,
 117         };
 118         static type_string* __videosink_default_string_array[] = { NULL };
 119         static type_element _videosink_element_overlay_default = {
 120                 "VideosinkElementOverlay",
 121                 "waylandsink",
 122                 __videosink_default_int_array,
 123                 sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
 124                 __videosink_default_string_array,
 125                 sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
 126         };
 127         static type_element _videosink_element_evas_default = {
 128                 "VideosinkElementEvas",
 129                 "evasimagesink",
 130                 __videosink_default_int_array,
 131                 sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
 132                 __videosink_default_string_array,
 133                 sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
 134         };
 135         static type_element _videosink_element_gl_default = {
 136                 "VideosinkElementGL",
 137                 "glimagesink",
 138                 __videosink_default_int_array,
 139                 sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
 140                 __videosink_default_string_array,
 141                 sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
 142         };
 143         static type_element _videosink_element_remote_default = {
 144                 "VideosinkElementRemote",
 145                 "shmsink",
 146                 __videosink_default_int_array,
 147                 sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
 148                 __videosink_default_string_array,
 149                 sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
 150         };
 151         static type_element _videosink_element_null_default = {
 152                 "VideosinkElementNull",
 153                 "fakesink",
 154                 __videosink_default_int_array,
 155                 sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
 156                 __videosink_default_string_array,
 157                 sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
 158         };
 159
 160         /* Videoscale element default value */
 161         static type_element _videoscale_element_default = {
 162                 "VideoscaleElement",
 163                 "videoscale",
 164                 NULL,
 165                 0,
 166                 NULL,
 167                 0,
 168         };
 169
 170         /* Videoconvert element default value */
 171         static type_element _videoconvert_element_default = {
 172                 "VideoconvertElement",
 173                 "videoconvert",
 174                 NULL,
 175                 0,
 176                 NULL,
 177                 0,
 178         };
 179
 180         /* Record sink element default value */
 181         static type_element _recordsink_element_default = {
 182                 "RecordsinkElement",
 183                 "fakesink",
 184                 NULL,
 185                 0,
 186                 NULL,
 187                 0,
 188         };
 189
 190         /* H263 element default value */
 191         static type_element _h263_element_default = {
 192                 "H263",
 193                 "avenc_h263",
 194                 NULL,
 195                 0,
 196                 NULL,
 197                 0,
 198         };
 199
 200         /* H264 element default value */
 201         static type_element _h264_element_default = {
 202                 "H264",
 203                 NULL,
 204                 NULL,
 205                 0,
 206                 NULL,
 207                 0,
 208         };
 209
 210         /* H26L element default value */
 211         static type_element _h26l_element_default = {
 212                 "H26L",
 213                 NULL,
 214                 NULL,
 215                 0,
 216                 NULL,
 217                 0,
 218         };
 219
 220         /* MPEG4 element default value */
 221         static type_element _mpeg4_element_default = {
 222                 "MPEG4",
 223                 "avenc_mpeg4",
 224                 NULL,
 225                 0,
 226                 NULL,
 227                 0,
 228         };
 229
 230         /* MPEG1 element default value */
 231         static type_element _mpeg1_element_default = {
 232                 "MPEG1",
 233                 "avenc_mpeg1video",
 234                 NULL,
 235                 0,
 236                 NULL,
 237                 0,
 238         };
 239
 240         /* THEORA element default value */
 241         static type_element _theora_element_default = {
 242                 "THEORA",
 243                 "theoraenc",
 244                 NULL,
 245                 0,
 246                 NULL,
 247                 0,
 248         };
 249
 250         /* AMR element default value */
 251         static type_element _amr_element_default = {
 252                 "AMR",
 253                 "amrnbenc",
 254                 NULL,
 255                 0,
 256                 NULL,
 257                 0,
 258         };
 259
 260         /* G723_1 element default value */
 261         static type_element _g723_1_element_default = {
 262                 "G723_1",
 263                 NULL,
 264                 NULL,
 265                 0,
 266                 NULL,
 267                 0,
 268         };
 269
 270         /* MP3 element default value */
 271         static type_element _mp3_element_default = {
 272                 "MP3",
 273                 "lamemp3enc",
 274                 NULL,
 275                 0,
 276                 NULL,
 277                 0,
 278         };
 279
 280         /* AAC element default value */
 281         static type_element _aac_element_default = {
 282                 "AAC",
 283                 NULL,
 284                 NULL,
 285                 0,
 286                 NULL,
 287                 0,
 288         };
 289
 290         /* MMF element default value */
 291         static type_element _mmf_element_default = {
 292                 "MMF",
 293                 NULL,
 294                 NULL,
 295                 0,
 296                 NULL,
 297                 0,
 298         };
 299
 300         /* ADPCM element default value */
 301         static type_element _adpcm_element_default = {
 302                 "ADPCM",
 303                 "avenc_adpcm_ima_qt",
 304                 NULL,
 305                 0,
 306                 NULL,
 307                 0,
 308         };
 309
 310         /* WAVE element default value */
 311         static type_element _wave_element_default = {
 312                 "WAVE",
 313                 "wavenc",
 314                 NULL,
 315                 0,
 316                 NULL,
 317                 0,
 318         };
 319
 320         /* VORBIS element default value */
 321         static type_element _vorbis_element_default = {
 322                 "VORBIS",
 323                 "vorbisenc",
 324                 NULL,
 325                 0,
 326                 NULL,
 327                 0,
 328         };
 329
 330         /* MIDI element default value */
 331         static type_element _midi_element_default = {
 332                 "MIDI",
 333                 NULL,
 334                 NULL,
 335                 0,
 336                 NULL,
 337                 0,
 338         };
 339
 340         /* IMELODY element default value */
 341         static type_element _imelody_element_default = {
 342                 "IMELODY",
 343                 NULL,
 344                 NULL,
 345                 0,
 346                 NULL,
 347                 0,
 348         };
 349
 350         /* JPEG element default value */
 351         static type_element _jpeg_element_default = {
 352                 "JPEG",
 353                 "jpegenc",
 354                 NULL,
 355                 0,
 356                 NULL,
 357                 0,
 358         };
 359
 360         /* PNG element default value */
 361         static type_element _png_element_default = {
 362                 "PNG",
 363                 "pngenc",
 364                 NULL,
 365                 0,
 366                 NULL,
 367                 0,
 368         };
 369
 370         /* BMP element default value */
 371         static type_element _bmp_element_default = {
 372                 "BMP",
 373                 NULL,
 374                 NULL,
 375                 0,
 376                 NULL,
 377                 0,
 378         };
 379
 380         /* WBMP element default value */
 381         static type_element _wbmp_element_default = {
 382                 "WBMP",
 383                 NULL,
 384                 NULL,
 385                 0,
 386                 NULL,
 387                 0,
 388         };
 389
 390         /* TIFF element default value */
 391         static type_element _tiff_element_default = {
 392                 "TIFF",
 393                 NULL,
 394                 NULL,
 395                 0,
 396                 NULL,
 397                 0,
 398         };
 399
 400         /* PCX element default value */
 401         static type_element _pcx_element_default = {
 402                 "PCX",
 403                 NULL,
 404                 NULL,
 405                 0,
 406                 NULL,
 407                 0,
 408         };
 409
 410         /* GIF element default value */
 411         static type_element _gif_element_default = {
 412                 "GIF",
 413                 NULL,
 414                 NULL,
 415                 0,
 416                 NULL,
 417                 0,
 418         };
 419
 420         /* ICO element default value */
 421         static type_element _ico_element_default = {
 422                 "ICO",
 423                 NULL,
 424                 NULL,
 425                 0,
 426                 NULL,
 427                 0,
 428         };
 429
 430         /* RAS element default value */
 431         static type_element _ras_element_default = {
 432                 "RAS",
 433                 NULL,
 434                 NULL,
 435                 0,
 436                 NULL,
 437                 0,
 438         };
 439
 440         /* TGA element default value */
 441         static type_element _tga_element_default = {
 442                 "TGA",
 443                 NULL,
 444                 NULL,
 445                 0,
 446                 NULL,
 447                 0,
 448         };
 449
 450         /* XBM element default value */
 451         static type_element _xbm_element_default = {
 452                 "XBM",
 453                 NULL,
 454                 NULL,
 455                 0,
 456                 NULL,
 457                 0,
 458         };
 459
 460         /* XPM element default value */
 461         static type_element _xpm_element_default = {
 462                 "XPM",
 463                 NULL,
 464                 NULL,
 465                 0,
 466                 NULL,
 467                 0,
 468         };
 469
 470         /* 3GP element default value */
 471         static type_element _3gp_element_default = {
 472                 "3GP",
 473                 "avmux_3gp",
 474                 NULL,
 475                 0,
 476                 NULL,
 477                 0,
 478         };
 479
 480         /* AMR mux element default value */
 481         static type_element _amrmux_element_default = {
 482                 "AMR",
 483                 "avmux_amr",
 484                 NULL,
 485                 0,
 486                 NULL,
 487                 0,
 488         };
 489
 490         /* MP4 element default value */
 491         static type_element _mp4_element_default = {
 492                 "MP4",
 493                 "avmux_mp4",
 494                 NULL,
 495                 0,
 496                 NULL,
 497                 0,
 498         };
 499
 500         /* AAC mux element default value */
 501         static type_element _aacmux_element_default = {
 502                 "AAC",
 503                 NULL,
 504                 NULL,
 505                 0,
 506                 NULL,
 507                 0,
 508         };
 509
 510         /* MP3 mux element default value */
 511         static type_element _mp3mux_element_default = {
 512                 "MP3",
 513                 NULL,
 514                 NULL,
 515                 0,
 516                 NULL,
 517                 0,
 518         };
 519
 520         /* OGG element default value */
 521         static type_element _ogg_element_default = {
 522                 "OGG",
 523                 "oggmux",
 524                 NULL,
 525                 0,
 526                 NULL,
 527                 0,
 528         };
 529
 530         /* WAV element default value */
 531         static type_element _wav_element_default = {
 532                 "WAV",
 533                 NULL,
 534                 NULL,
 535                 0,
 536                 NULL,
 537                 0,
 538         };
 539
 540         /* AVI element default value */
 541         static type_element _avi_element_default = {
 542                 "AVI",
 543                 "avimux",
 544                 NULL,
 545                 0,
 546                 NULL,
 547                 0,
 548         };
 549
 550         /* WMA element default value */
 551         static type_element _wma_element_default = {
 552                 "WMA",
 553                 NULL,
 554                 NULL,
 555                 0,
 556                 NULL,
 557                 0,
 558         };
 559
 560         /* WMV element default value */
 561         static type_element _wmv_element_default = {
 562                 "WMV",
 563                 NULL,
 564                 NULL,
 565                 0,
 566                 NULL,
 567                 0,
 568         };
 569
 570         /* MID element default value */
 571         static type_element _mid_element_default = {
 572                 "MID",
 573                 NULL,
 574                 NULL,
 575                 0,
 576                 NULL,
 577                 0,
 578         };
 579
 580         /* MMF mux element default value */
 581         static type_element _mmfmux_element_default = {
 582                 "MMF",
 583                 "avmux_mmf",
 584                 NULL,
 585                 0,
 586                 NULL,
 587                 0,
 588         };
 589
 590         /* MATROSKA element default value */
 591         static type_element _matroska_element_default = {
 592                 "MATROSKA",
 593                 "matroskamux",
 594                 NULL,
 595                 0,
 596                 NULL,
 597                 0,
 598         };
 599
 600         /* M2TS element default value */
 601         static type_element _m2ts_element_default = {
 602                 "M2TS",
 603                 "mpegtsmux",
 604                 NULL,
 605                 0,
 606                 NULL,
 607                 0,
 608         };
 609
 610         /* [General] matching table */
 611         static conf_info_table conf_main_general_table[] = {
 612                 { "SyncStateChange", CONFIGURE_VALUE_INT,           {.value_int = 1} },
 613                 { "GSTInitOption",   CONFIGURE_VALUE_STRING_ARRAY,  {NULL} },
 614                 { "ModelName",       CONFIGURE_VALUE_STRING,        {NULL} },
 615                 { "DisabledAttributes", CONFIGURE_VALUE_STRING_ARRAY,  {NULL} },
 616         };
 617
 618         /* [VideoInput] matching table */
 619         static conf_info_table conf_main_video_input_table[] = {
 620                 { "UseConfCtrl",        CONFIGURE_VALUE_INT,            {.value_int = 1} },
 621                 { "ConfCtrlFile0",      CONFIGURE_VALUE_STRING,         {NULL} },
 622                 { "ConfCtrlFile1",      CONFIGURE_VALUE_STRING,         {NULL} },
 623                 { "VideosrcElement",    CONFIGURE_VALUE_ELEMENT,        {&_videosrc_element_default} },
 624                 { "UseVideoscale",      CONFIGURE_VALUE_INT,            {.value_int = 0} },
 625                 { "VideoscaleElement",  CONFIGURE_VALUE_ELEMENT,        {&_videoscale_element_default} },
 626                 { "UseZeroCopyFormat",  CONFIGURE_VALUE_INT,            {.value_int = 0} },
 627                 { "DeviceCount",        CONFIGURE_VALUE_INT,            {.value_int = MM_VIDEO_DEVICE_NUM} },
 628                 { "SupportMediaPacketPreviewCb",  CONFIGURE_VALUE_INT,  {.value_int = 0} },
 629         };
 630
 631         /* [AudioInput] matching table */
 632         static conf_info_table conf_main_audio_input_table[] = {
 633                 { "AudioDevice",          CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 634                 { "AudiosrcElement",      CONFIGURE_VALUE_ELEMENT, {&_audiosrc_element_default} },
 635                 { "AudiomodemsrcElement", CONFIGURE_VALUE_ELEMENT, {&_audiomodemsrc_element_default} },
 636         };
 637
 638         /* [VideoOutput] matching table */
 639         static conf_info_table conf_main_video_output_table[] = {
 640                 { "DisplayDevice",           CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 641                 { "DisplayMode",             CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 642                 { "Videosink",               CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 643                 { "VideosinkElementOverlay", CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_overlay_default} },
 644                 { "VideosinkElementEvas",    CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_evas_default} },
 645                 { "VideosinkElementGL",      CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_gl_default} },
 646                 { "VideosinkElementRemote",  CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_remote_default} },
 647                 { "VideosinkElementNull",    CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_null_default} },
 648                 { "UseVideoscale",           CONFIGURE_VALUE_INT,       {.value_int = 0} },
 649                 { "VideoscaleElement",       CONFIGURE_VALUE_ELEMENT,   {&_videoscale_element_default} },
 650                 { "VideoconvertElement",     CONFIGURE_VALUE_ELEMENT,   {&_videoconvert_element_default} },
 651         };
 652
 653         /* [Capture] matching table */
 654         static conf_info_table conf_main_capture_table[] = {
 655                 { "UseEncodebin",           CONFIGURE_VALUE_INT,     {.value_int = 0} },
 656                 { "UseCaptureMode",         CONFIGURE_VALUE_INT,     {.value_int = 0} },
 657                 { "VideoscaleElement",      CONFIGURE_VALUE_ELEMENT, {&_videoscale_element_default} },
 658                 { "PlayCaptureSound",       CONFIGURE_VALUE_INT,     {.value_int = 1} },
 659         };
 660
 661         /* [Record] matching table */
 662         static conf_info_table conf_main_record_table[] = {
 663                 { "UseAudioEncoderQueue",   CONFIGURE_VALUE_INT,     {.value_int = 1} },
 664                 { "UseVideoEncoderQueue",   CONFIGURE_VALUE_INT,     {.value_int = 1} },
 665                 { "VideoProfile",           CONFIGURE_VALUE_INT,     {.value_int = 0} },
 666                 { "VideoAutoAudioConvert",  CONFIGURE_VALUE_INT,     {.value_int = 0} },
 667                 { "VideoAutoAudioResample", CONFIGURE_VALUE_INT,     {.value_int = 0} },
 668                 { "VideoAutoColorSpace",    CONFIGURE_VALUE_INT,     {.value_int = 0} },
 669                 { "AudioProfile",           CONFIGURE_VALUE_INT,     {.value_int = 0} },
 670                 { "AudioAutoAudioConvert",  CONFIGURE_VALUE_INT,     {.value_int = 0} },
 671                 { "AudioAutoAudioResample", CONFIGURE_VALUE_INT,     {.value_int = 0} },
 672                 { "AudioAutoColorSpace",    CONFIGURE_VALUE_INT,     {.value_int = 0} },
 673                 { "ImageProfile",           CONFIGURE_VALUE_INT,     {.value_int = 0} },
 674                 { "ImageAutoAudioConvert",  CONFIGURE_VALUE_INT,     {.value_int = 0} },
 675                 { "ImageAutoAudioResample", CONFIGURE_VALUE_INT,     {.value_int = 0} },
 676                 { "ImageAutoColorSpace",    CONFIGURE_VALUE_INT,     {.value_int = 0} },
 677                 { "RecordsinkElement",      CONFIGURE_VALUE_ELEMENT, {&_recordsink_element_default} },
 678                 { "UseNoiseSuppressor",     CONFIGURE_VALUE_INT,     {.value_int = 0} },
 679                 { "DropVideoFrame",         CONFIGURE_VALUE_INT,     {.value_int = 0} },
 680                 { "PassFirstVideoFrame",    CONFIGURE_VALUE_INT,     {.value_int = 0} },
 681                 { "SupportDualStream",      CONFIGURE_VALUE_INT,     {.value_int = FALSE} },
 682         };
 683
 684         /* [VideoEncoder] matching table */
 685         static conf_info_table conf_main_video_encoder_table[] = {
 686                 { "H263",    CONFIGURE_VALUE_ELEMENT, {&_h263_element_default} },
 687                 { "H264",    CONFIGURE_VALUE_ELEMENT, {&_h264_element_default} },
 688                 { "H26L",    CONFIGURE_VALUE_ELEMENT, {&_h26l_element_default} },
 689                 { "MPEG4",   CONFIGURE_VALUE_ELEMENT, {&_mpeg4_element_default} },
 690                 { "MPEG1",   CONFIGURE_VALUE_ELEMENT, {&_mpeg1_element_default} },
 691                 { "THEORA",  CONFIGURE_VALUE_ELEMENT, {&_theora_element_default} },
 692         };
 693
 694         /* [AudioEncoder] matching table */
 695         static conf_info_table conf_main_audio_encoder_table[] = {
 696                 { "AMR",     CONFIGURE_VALUE_ELEMENT, {&_amr_element_default} },
 697                 { "G723_1",  CONFIGURE_VALUE_ELEMENT, {&_g723_1_element_default} },
 698                 { "MP3",     CONFIGURE_VALUE_ELEMENT, {&_mp3_element_default} },
 699                 { "AAC",     CONFIGURE_VALUE_ELEMENT, {&_aac_element_default} },
 700                 { "MMF",     CONFIGURE_VALUE_ELEMENT, {&_mmf_element_default} },
 701                 { "ADPCM",   CONFIGURE_VALUE_ELEMENT, {&_adpcm_element_default} },
 702                 { "WAVE",    CONFIGURE_VALUE_ELEMENT, {&_wave_element_default} },
 703                 { "MIDI",    CONFIGURE_VALUE_ELEMENT, {&_midi_element_default} },
 704                 { "IMELODY", CONFIGURE_VALUE_ELEMENT, {&_imelody_element_default} },
 705                 { "VORBIS",  CONFIGURE_VALUE_ELEMENT, {&_vorbis_element_default} },
 706         };
 707
 708         /* [ImageEncoder] matching table */
 709         static conf_info_table conf_main_image_encoder_table[] = {
 710                 { "JPEG", CONFIGURE_VALUE_ELEMENT, {&_jpeg_element_default} },
 711                 { "PNG",  CONFIGURE_VALUE_ELEMENT, {&_png_element_default} },
 712                 { "BMP",  CONFIGURE_VALUE_ELEMENT, {&_bmp_element_default} },
 713                 { "WBMP", CONFIGURE_VALUE_ELEMENT, {&_wbmp_element_default} },
 714                 { "TIFF", CONFIGURE_VALUE_ELEMENT, {&_tiff_element_default} },
 715                 { "PCX",  CONFIGURE_VALUE_ELEMENT, {&_pcx_element_default} },
 716                 { "GIF",  CONFIGURE_VALUE_ELEMENT, {&_gif_element_default} },
 717                 { "ICO",  CONFIGURE_VALUE_ELEMENT, {&_ico_element_default} },
 718                 { "RAS",  CONFIGURE_VALUE_ELEMENT, {&_ras_element_default} },
 719                 { "TGA",  CONFIGURE_VALUE_ELEMENT, {&_tga_element_default} },
 720                 { "XBM",  CONFIGURE_VALUE_ELEMENT, {&_xbm_element_default} },
 721                 { "XPM",  CONFIGURE_VALUE_ELEMENT, {&_xpm_element_default} },
 722         };
 723
 724         /* [Mux] matching table */
 725         static conf_info_table conf_main_mux_table[] = {
 726                 { "3GP",      CONFIGURE_VALUE_ELEMENT, {&_3gp_element_default} },
 727                 { "AMR",      CONFIGURE_VALUE_ELEMENT, {&_amrmux_element_default} },
 728                 { "MP4",      CONFIGURE_VALUE_ELEMENT, {&_mp4_element_default} },
 729                 { "AAC",      CONFIGURE_VALUE_ELEMENT, {&_aacmux_element_default} },
 730                 { "MP3",      CONFIGURE_VALUE_ELEMENT, {&_mp3mux_element_default} },
 731                 { "OGG",      CONFIGURE_VALUE_ELEMENT, {&_ogg_element_default} },
 732                 { "WAV",      CONFIGURE_VALUE_ELEMENT, {&_wav_element_default} },
 733                 { "AVI",      CONFIGURE_VALUE_ELEMENT, {&_avi_element_default} },
 734                 { "WMA",      CONFIGURE_VALUE_ELEMENT, {&_wma_element_default} },
 735                 { "WMV",      CONFIGURE_VALUE_ELEMENT, {&_wmv_element_default} },
 736                 { "MID",      CONFIGURE_VALUE_ELEMENT, {&_mid_element_default} },
 737                 { "MMF",      CONFIGURE_VALUE_ELEMENT, {&_mmfmux_element_default} },
 738                 { "MATROSKA", CONFIGURE_VALUE_ELEMENT, {&_matroska_element_default} },
 739                 { "M2TS",     CONFIGURE_VALUE_ELEMENT, {&_m2ts_element_default} },
 740         };
 741
 742
 743         /*******************
 744         *  Camera control *
 745         *******************/
 746
 747         /* [Camera] matching table */
 748         static conf_info_table conf_ctrl_camera_table[] = {
 749                 { "InputIndex",        CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 750                 { "DeviceName",        CONFIGURE_VALUE_STRING,         {NULL} },
 751                 { "PreviewResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
 752                 { "CaptureResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
 753                 { "VideoResolution",   CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
 754                 { "FPS0",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 755                 { "FPS1",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 756                 { "FPS2",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 757                 { "FPS3",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 758                 { "FPS4",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 759                 { "FPS5",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 760                 { "FPS6",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 761                 { "FPS7",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 762                 { "FPS8",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 763                 { "FPS9",              CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 764                 { "PictureFormat",     CONFIGURE_VALUE_INT_ARRAY,      {NULL} },
 765                 { "Overlay",           CONFIGURE_VALUE_INT_RANGE,      {NULL} },
 766                 { "RecommendDisplayRotation", CONFIGURE_VALUE_INT,     {.value_int = 3}    },
 767                 { "RecommendPreviewFormatCapture", CONFIGURE_VALUE_INT, {.value_int = MM_PIXEL_FORMAT_YUYV} },
 768                 { "RecommendPreviewFormatRecord",  CONFIGURE_VALUE_INT, {.value_int = MM_PIXEL_FORMAT_NV12} },
 769                 { "RecommendPreviewResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
 770                 { "FacingDirection", CONFIGURE_VALUE_INT, {.value_int = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR} },
 771         };
 772
 773         /* [Strobe] matching table */
 774         static conf_info_table conf_ctrl_strobe_table[] = {
 775                 { "StrobeControl",        CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 776                 { "StrobeMode",           CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 777                 { "StrobeEV",             CONFIGURE_VALUE_INT_RANGE, {NULL} },
 778         };
 779
 780         /* [Effect] matching table */
 781         static conf_info_table conf_ctrl_effect_table[] = {
 782                 { "Brightness",           CONFIGURE_VALUE_INT_RANGE, {NULL} },
 783                 { "BrightnessStepDenominator", CONFIGURE_VALUE_INT, {.value_int = 2} },
 784                 { "Contrast",             CONFIGURE_VALUE_INT_RANGE, {NULL} },
 785                 { "Saturation",           CONFIGURE_VALUE_INT_RANGE, {NULL} },
 786                 { "Sharpness",            CONFIGURE_VALUE_INT_RANGE, {NULL} },
 787                 { "WhiteBalance",         CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 788                 { "ColorTone",            CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 789                 { "Flip",                 CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 790                 { "Rotation",             CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 791                 { "WDR",                  CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 792                 { "PartColorMode",        CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 793                 { "PartColor",            CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 794         };
 795
 796         /* [Photograph] matching table */
 797         static conf_info_table conf_ctrl_photograph_table[] = {
 798                 { "LensInit",             CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 799                 { "DigitalZoom",          CONFIGURE_VALUE_INT_RANGE, {NULL} },
 800                 { "OpticalZoom",          CONFIGURE_VALUE_INT_RANGE, {NULL} },
 801                 { "FocusMode",            CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 802                 { "AFType",               CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 803                 { "AEType",               CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 804                 { "ExposureValue",        CONFIGURE_VALUE_INT_RANGE, {NULL} },
 805                 { "FNumber",              CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 806                 { "ShutterSpeed",         CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 807                 { "ISO",                  CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 808                 { "ProgramMode",          CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 809                 { "AntiHandshake",        CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 810                 { "VideoStabilization",   CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 811                 { "FaceZoomMode",         CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 812                 { "FaceZoomLevel",        CONFIGURE_VALUE_INT_RANGE, {NULL} },
 813         };
 814
 815         /* [Capture] matching table */
 816         static conf_info_table conf_ctrl_capture_table[] = {
 817                 { "OutputMode",           CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 818                 { "JpegQuality",          CONFIGURE_VALUE_INT_RANGE, {NULL} },
 819                 { "MultishotNumber",      CONFIGURE_VALUE_INT_RANGE, {NULL} },
 820                 { "SensorEncodedCapture", CONFIGURE_VALUE_INT,       {.value_int = 1} },
 821                 { "SupportHDR",           CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 822                 { "SupportZSL",           CONFIGURE_VALUE_INT,       {.value_int = FALSE} },
 823         };
 824
 825         /* [Detect] matching table */
 826         static conf_info_table conf_ctrl_detect_table[] = {
 827                 { "DetectMode",         CONFIGURE_VALUE_INT_ARRAY, {NULL} },
 828                 { "DetectNumber",       CONFIGURE_VALUE_INT_RANGE, {NULL} },
 829                 { "DetectSelect",       CONFIGURE_VALUE_INT_RANGE, {NULL} },
 830                 { "DetectSelectNumber", CONFIGURE_VALUE_INT_RANGE, {NULL} },
 831         };
 832
 833         if (hcamcorder == NULL) {
 834                 _mmcam_dbg_err("handle is NULL");
 835                 return;
 836         }
 837
 838         _mmcam_dbg_log("Entered...");
 839
 840         if (type == CONFIGURE_TYPE_MAIN) {
 841                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_GENERAL]       = conf_main_general_table;
 842                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT]   = conf_main_video_input_table;
 843                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT]   = conf_main_audio_input_table;
 844                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT]  = conf_main_video_output_table;
 845                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_CAPTURE]       = conf_main_capture_table;
 846                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_RECORD]        = conf_main_record_table;
 847                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = conf_main_video_encoder_table;
 848                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = conf_main_audio_encoder_table;
 849                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = conf_main_image_encoder_table;
 850                 hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_MUX]           = conf_main_mux_table;
 851
 852                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_GENERAL]       = sizeof( conf_main_general_table ) / info_table_size;
 853                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT]   = sizeof( conf_main_video_input_table ) / info_table_size;
 854                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT]   = sizeof( conf_main_audio_input_table ) / info_table_size;
 855                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT]  = sizeof( conf_main_video_output_table ) / info_table_size;
 856                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_CAPTURE]       = sizeof( conf_main_capture_table ) / info_table_size;
 857                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_RECORD]        = sizeof( conf_main_record_table ) / info_table_size;
 858                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = sizeof( conf_main_video_encoder_table ) / info_table_size;
 859                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = sizeof( conf_main_audio_encoder_table ) / info_table_size;
 860                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = sizeof( conf_main_image_encoder_table ) / info_table_size;
 861                 hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_MUX]           = sizeof( conf_main_mux_table ) / info_table_size;
 862
 863                 (*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_MAIN_NUM );
 864
 865                 for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++) {
 866                         (*configure_info)->info[i] = NULL;
 867                 }
 868         } else {
 869                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAMERA]     = conf_ctrl_camera_table;
 870                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_STROBE]     = conf_ctrl_strobe_table;
 871                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_EFFECT]     = conf_ctrl_effect_table;
 872                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = conf_ctrl_photograph_table;
 873                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAPTURE]    = conf_ctrl_capture_table;
 874                 hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_DETECT]     = conf_ctrl_detect_table;
 875
 876                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAMERA]     = sizeof( conf_ctrl_camera_table ) / info_table_size;
 877                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_STROBE]     = sizeof( conf_ctrl_strobe_table ) / info_table_size;
 878                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_EFFECT]     = sizeof( conf_ctrl_effect_table ) / info_table_size;
 879                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = sizeof( conf_ctrl_photograph_table ) / info_table_size;
 880                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAPTURE]    = sizeof( conf_ctrl_capture_table ) / info_table_size;
 881                 hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_DETECT]     = sizeof( conf_ctrl_detect_table ) / info_table_size;
 882
 883                 (*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_CTRL_NUM );
 884
 885                 for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++) {
 886                         (*configure_info)->info[i] = NULL;
 887                 }
 888         }
 889
 890         _mmcam_dbg_log("Done.");
 891
 892         return;
 893 }
 894
 895
 896 int _mmcamcorder_conf_get_info(MMHandleType handle, int type, const char* ConfFile, camera_conf** configure_info)
 897 {
 898         int ret         = MM_ERROR_NONE;
 899         FILE* fd        = NULL;
 900         char* conf_path = NULL;
 901
 902         _mmcam_dbg_log( "Opening...[%s]", ConfFile );
 903
 904         mmf_return_val_if_fail( ConfFile, FALSE );
 905
 906         conf_path = (char*)malloc( strlen(ConfFile)+strlen(CONFIGURE_PATH)+3 );
 907
 908         if( conf_path == NULL )
 909         {
 910                 _mmcam_dbg_err( "malloc failed." );
 911                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 912         }
 913
 914         snprintf( conf_path, strlen(ConfFile)+strlen(CONFIGURE_PATH)+2, "%s/%s", CONFIGURE_PATH, ConfFile );
 915         _mmcam_dbg_log( "Try open Configure File[%s]", conf_path );
 916
 917         fd = fopen( conf_path, "r" );
 918         if( fd == NULL )
 919         {
 920                 _mmcam_dbg_warn( "File open failed.[%s] retry...", conf_path );
 921                 snprintf( conf_path, strlen(ConfFile)+strlen(CONFIGURE_PATH_RETRY)+2, "%s/%s", CONFIGURE_PATH_RETRY, ConfFile );
 922                 _mmcam_dbg_log( "Try open Configure File[%s]", conf_path );
 923                 fd = fopen( conf_path, "r" );
 924                 if( fd == NULL )
 925                 {
 926                         _mmcam_dbg_warn("open failed.[%s] But keep going... Type[%d]", conf_path, type);
 927                 }
 928         }
 929
 930         if( fd != NULL )
 931         {
 932                 ret = _mmcamcorder_conf_parse_info( handle, type, fd, configure_info );
 933                 fclose( fd );
 934         }
 935         else
 936         {
 937                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 938         }
 939
 940         if( conf_path != NULL )
 941         {
 942                 free( conf_path );
 943                 conf_path = NULL;
 944         }
 945
 946         _mmcam_dbg_log( "Leave..." );
 947
 948         return ret;
 949 }
 950
 951 int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera_conf** configure_info)
 952 {
 953         const unsigned int BUFFER_NUM_DETAILS = 256;
 954         const unsigned int BUFFER_NUM_TOKEN = 20;
 955         size_t BUFFER_LENGTH_STRING = 256;
 956         const char* delimiters = " |=,\t\n";
 957
 958         int category = 0;
 959         int count_main_category = 0;
 960         int count_details = 0;
 961         int length_read = 0;
 962         int count_token = 0;
 963         int read_main = 0;
 964
 965         char *buffer_string = NULL;
 966         char *buffer_details[BUFFER_NUM_DETAILS];
 967         char *buffer_token[BUFFER_NUM_TOKEN];
 968         char *token = NULL;
 969         char *category_name = NULL;
 970         char *detail_string = NULL;
 971         char *user_ptr = NULL;
 972
 973         _mmcam_dbg_log( "" );
 974
 975         camera_conf* new_conf = (camera_conf *)g_malloc0(sizeof(camera_conf));
 976         if (new_conf == NULL) {
 977                 _mmcam_dbg_err("new_conf alloc failed : %d", sizeof(camera_conf));
 978                 *configure_info = NULL;
 979                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 980         }
 981
 982         buffer_string = (char*)g_malloc0(sizeof(char) * BUFFER_LENGTH_STRING);
 983         if (buffer_string == NULL) {
 984                 _mmcam_dbg_err("buffer_string alloc failed : %d", sizeof(char) * BUFFER_LENGTH_STRING);
 985                 *configure_info = NULL;
 986                 SAFE_G_FREE(new_conf);
 987                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 988         }
 989
 990         new_conf->type  = type;
 991         *configure_info = new_conf;
 992
 993         _mmcamcorder_conf_init(handle, type, &new_conf);
 994
 995         if (fd == NULL) {
 996                 _mmcam_dbg_err("failed file descriptor fail");
 997                 *configure_info = NULL;
 998                 SAFE_G_FREE(buffer_string);
 999                 SAFE_G_FREE(new_conf);
1000                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1001         }
1002
1003         read_main = 0;
1004         count_main_category = 0;
1005
1006         while( !feof( fd ) )
1007         {
1008                 if( read_main == 0 )
1009                 {
1010                         length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
1011                         /*_mmcam_dbg_log( "Read Line : [%s]", buffer_string );*/
1012
1013                         count_token = 0;
1014                         token = strtok_r( buffer_string, delimiters, &user_ptr );
1015
1016                         if ((token) && (token[0] == ';') && (length_read > -1))
1017                         {
1018                                 /*_mmcam_dbg_log( "Comment - Nothing to do" );*/
1019                                 continue;
1020                         }
1021
1022                         while( token )
1023                         {
1024                                 /*_mmcam_dbg_log( "token : [%s]", token );*/
1025                                 buffer_token[count_token] = token;
1026                                 count_token++;
1027                                 token = strtok_r( NULL, delimiters, &user_ptr );
1028                         }
1029
1030                         if( count_token == 0 )
1031                         {
1032                                 continue;
1033                         }
1034                 }
1035
1036                 read_main = 0;
1037
1038                 /* Comment */
1039                 if( *buffer_token[0] == ';' )
1040                 {
1041                         /*_mmcam_dbg_log( "Comment - Nothing to do" );*/
1042                 }
1043                 /* Main Category */
1044                 else if( *buffer_token[0] == '[' )
1045                 {
1046                         category_name = get_new_string( buffer_token[0] );
1047                         if (category_name == NULL) {
1048                                 _mmcam_dbg_err("strdup failed for [%s]", buffer_token[0]);
1049                                 continue;
1050                         }
1051
1052                         count_main_category++;
1053                         count_details = 0;
1054
1055                         while( !feof( fd ) )
1056                         {
1057                                 length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
1058                                 /*_mmcam_dbg_log( "Read Detail Line : [%s], read length : [%d]", buffer_string, length_read );*/
1059
1060                                 detail_string = get_new_string( buffer_string );
1061
1062                                 token = strtok_r( buffer_string, delimiters, &user_ptr );
1063
1064                                 if( token && token[0] != ';' && length_read > -1 )
1065                                 {
1066                                         /*_mmcam_dbg_log( "token : [%s]", token );*/
1067                                         if( token[0] == '[' )
1068                                         {
1069                                                 read_main = 1;
1070                                                 buffer_token[0] = token;
1071                                                 SAFE_G_FREE( detail_string );
1072                                                 break;
1073                                         }
1074
1075                                         buffer_details[count_details++] = detail_string;
1076                                 }
1077                                 else
1078                                 {
1079                                         SAFE_G_FREE( detail_string );
1080                                 }
1081                         }
1082
1083                         /*_mmcam_dbg_log( "type : %d, category_name : %s, count : [%d]", type, category_name, count_details );*/
1084
1085                         if( count_details == 0 )
1086                         {
1087                                 _mmcam_dbg_warn( "category %s has no detail value... skip this category...", category_name );
1088                                 SAFE_G_FREE(category_name);
1089                                 continue;
1090                         }
1091
1092                         category = -1;
1093
1094                         /* Details */
1095                         if( type == CONFIGURE_TYPE_MAIN )
1096                         {
1097                                 if( !strcmp( "[General]", category_name ) )
1098                                 {
1099                                         category = CONFIGURE_CATEGORY_MAIN_GENERAL;
1100                                 }
1101                                 else if( !strcmp( "[VideoInput]", category_name ) )
1102                                 {
1103                                         category = CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT;
1104                                 }
1105                                 else if( !strcmp( "[AudioInput]", category_name ) )
1106                                 {
1107                                         category = CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT;
1108                                 }
1109                                 else if( !strcmp( "[VideoOutput]", category_name ) )
1110                                 {
1111                                         category = CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT;
1112                                 }
1113                                 else if( !strcmp( "[Capture]", category_name ) )
1114                                 {
1115                                         category = CONFIGURE_CATEGORY_MAIN_CAPTURE;
1116                                 }
1117                                 else if( !strcmp( "[Record]", category_name ) )
1118                                 {
1119                                         category = CONFIGURE_CATEGORY_MAIN_RECORD;
1120                                 }
1121                                 else if( !strcmp( "[VideoEncoder]", category_name ) )
1122                                 {
1123                                         category = CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER;
1124                                 }
1125                                 else if( !strcmp( "[AudioEncoder]", category_name ) )
1126                                 {
1127                                         category = CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER;
1128                                 }
1129                                 else if( !strcmp( "[ImageEncoder]", category_name ) )
1130                                 {
1131                                         category = CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER;
1132                                 }
1133                                 else if( !strcmp( "[Mux]", category_name ) )
1134                                 {
1135                                         category = CONFIGURE_CATEGORY_MAIN_MUX;
1136                                 }
1137                         }
1138                         else
1139                         {
1140                                 if( !strcmp( "[Camera]", category_name ) )
1141                                 {
1142                                         category = CONFIGURE_CATEGORY_CTRL_CAMERA;
1143                                 }
1144                                 else if( !strcmp( "[Strobe]", category_name ) )
1145                                 {
1146                                         category = CONFIGURE_CATEGORY_CTRL_STROBE;
1147                                 }
1148                                 else if( !strcmp( "[Effect]", category_name ) )
1149                                 {
1150                                         category = CONFIGURE_CATEGORY_CTRL_EFFECT;
1151                                 }
1152                                 else if( !strcmp( "[Photograph]", category_name ) )
1153                                 {
1154                                         category = CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH;
1155                                 }
1156                                 else if( !strcmp( "[Capture]", category_name ) )
1157                                 {
1158                                         category = CONFIGURE_CATEGORY_CTRL_CAPTURE;
1159                                 }
1160                                 else if( !strcmp( "[Detect]", category_name ) )
1161                                 {
1162                                         category = CONFIGURE_CATEGORY_CTRL_DETECT;
1163                                 }
1164                         }
1165
1166                         if( category != -1 )
1167                         {
1168                                 _mmcamcorder_conf_add_info( handle, type, &(new_conf->info[category]),
1169                                                 buffer_details, category, count_details );
1170                         }
1171                         else
1172                         {
1173                                 _mmcam_dbg_warn( "No matched category[%s],type[%d]... check it.", category_name, type );
1174                         }
1175
1176                         // Free memory
1177                         {
1178                                 int i;
1179
1180                                 for( i = 0 ; i < count_details ; i++ )
1181                                 {
1182                                         SAFE_G_FREE( buffer_details[i] );
1183                                 }
1184                         }
1185                 }
1186
1187                 SAFE_G_FREE(category_name);
1188         }
1189
1190         //(*configure_info) = new_conf;
1191
1192         SAFE_G_FREE( buffer_string );
1193
1194         /*_mmcam_dbg_log( "Done." );*/
1195
1196         return MM_ERROR_NONE;
1197 }
1198
1199
1200 void _mmcamcorder_conf_release_info(MMHandleType handle, camera_conf **configure_info)
1201 {
1202         int i = 0;
1203         int j = 0;
1204         int k = 0;
1205         int type = CONFIGURE_VALUE_INT;
1206         int count = 0;
1207         int category_num = CONFIGURE_CATEGORY_MAIN_NUM;
1208         camera_conf *temp_conf = (*configure_info);
1209
1210         type_int2 *temp_int = NULL;
1211         type_int_range *temp_int_range = NULL;
1212         type_int_array *temp_int_array = NULL;
1213         type_int_pair_array *temp_int_pair_array = NULL;
1214         type_string2 *temp_string = NULL;
1215         type_string_array *temp_string_array = NULL;
1216         type_element2 *temp_element = NULL;
1217
1218         _mmcam_dbg_log("Entered...");
1219
1220         mmf_return_if_fail(temp_conf);
1221
1222         if ((*configure_info)->type == CONFIGURE_TYPE_MAIN) {
1223                 category_num = CONFIGURE_CATEGORY_MAIN_NUM;
1224         } else {
1225                 category_num = CONFIGURE_CATEGORY_CTRL_NUM;
1226         }
1227
1228         for (i = 0 ; i < category_num ; i++) {
1229                 if (temp_conf->info[i]) {
1230                         for (j = 0 ; j < temp_conf->info[i]->count ; j++) {
1231                                 if (temp_conf->info[i]->detail_info[j] == NULL) {
1232                                         continue;
1233                                 }
1234
1235                                 if (_mmcamcorder_conf_get_value_type(handle, temp_conf->type, i, ((type_element*)(temp_conf->info[i]->detail_info[j]))->name, &type)) {
1236                                         switch (type) {
1237                                         case CONFIGURE_VALUE_INT:
1238                                                 temp_int = (type_int2*)(temp_conf->info[i]->detail_info[j]);
1239                                                 SAFE_G_FREE(temp_int->name);
1240                                                 break;
1241                                         case CONFIGURE_VALUE_INT_RANGE:
1242                                                 temp_int_range = (type_int_range*)(temp_conf->info[i]->detail_info[j]);
1243                                                 SAFE_G_FREE(temp_int_range->name);
1244                                                 break;
1245                                         case CONFIGURE_VALUE_INT_ARRAY:
1246                                                 temp_int_array = (type_int_array*)(temp_conf->info[i]->detail_info[j]);
1247                                                 SAFE_G_FREE(temp_int_array->name);
1248                                                 SAFE_G_FREE(temp_int_array->value);
1249                                                 break;
1250                                         case CONFIGURE_VALUE_INT_PAIR_ARRAY:
1251                                                 temp_int_pair_array = (type_int_pair_array*)(temp_conf->info[i]->detail_info[j]);
1252                                                 SAFE_G_FREE(temp_int_pair_array->name);
1253                                                 SAFE_G_FREE(temp_int_pair_array->value[0]);
1254                                                 SAFE_G_FREE(temp_int_pair_array->value[1]);
1255                                                 break;
1256                                         case CONFIGURE_VALUE_STRING:
1257                                                 temp_string = (type_string2*)(temp_conf->info[i]->detail_info[j]);
1258                                                 SAFE_G_FREE(temp_string->name);
1259                                                 SAFE_G_FREE(temp_string->value);
1260                                                 break;
1261                                         case CONFIGURE_VALUE_STRING_ARRAY:
1262                                                 temp_string_array = (type_string_array*)(temp_conf->info[i]->detail_info[j]);
1263                                                 SAFE_G_FREE(temp_string_array->name);
1264                                                 if (temp_string_array->value) {
1265                                                         count = temp_string_array->count;
1266                                                         for (k = 0 ; k < count ; k++) {
1267                                                                 SAFE_G_FREE(temp_string_array->value[k]);
1268                                                         }
1269                                                         SAFE_G_FREE(temp_string_array->value);
1270                                                 }
1271                                                 SAFE_G_FREE(temp_string_array->default_value);
1272                                                 break;
1273                                         case CONFIGURE_VALUE_ELEMENT:
1274                                                 temp_element = (type_element2*)(temp_conf->info[i]->detail_info[j]);
1275                                                 SAFE_G_FREE(temp_element->name);
1276                                                 SAFE_G_FREE(temp_element->element_name);
1277
1278                                                 if (temp_element->value_int) {
1279                                                         count = temp_element->count_int;
1280                                                         for (k = 0 ; k < count ; k++) {
1281                                                                 SAFE_G_FREE(temp_element->value_int[k]->name);
1282                                                                 SAFE_G_FREE(temp_element->value_int[k]);
1283                                                         }
1284                                                         SAFE_G_FREE(temp_element->value_int);
1285                                                 }
1286
1287                                                 if (temp_element->value_string) {
1288                                                         count = temp_element->count_string;
1289                                                         for (k = 0 ; k < count ; k++) {
1290                                                                 SAFE_G_FREE(temp_element->value_string[k]->name);
1291                                                                 SAFE_G_FREE(temp_element->value_string[k]->value);
1292                                                                 SAFE_G_FREE(temp_element->value_string[k]);
1293                                                         }
1294                                                         SAFE_G_FREE(temp_element->value_string);
1295                                                 }
1296                                                 break;
1297                                         default:
1298                                                 _mmcam_dbg_warn("unknown type %d", type);
1299                                                 break;
1300                                         }
1301                                 }
1302
1303                                 SAFE_G_FREE(temp_conf->info[i]->detail_info[j]);
1304                         }
1305
1306                         SAFE_G_FREE(temp_conf->info[i]->detail_info);
1307
1308                         SAFE_G_FREE(temp_conf->info[i]);
1309                         temp_conf->info[i] = NULL;
1310                 }
1311         }
1312
1313         SAFE_G_FREE((*configure_info)->info);
1314         SAFE_G_FREE((*configure_info));
1315
1316         _mmcam_dbg_log("Done.");
1317 }
1318
1319 int _mmcamcorder_conf_get_value_type(MMHandleType handle, int type, int category, const char* name, int* value_type)
1320 {
1321         int i = 0;
1322         int count_value = 0;
1323
1324         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1325
1326         if (hcamcorder == NULL) {
1327                 _mmcam_dbg_err("handle is NULL");
1328                 return FALSE;
1329         }
1330
1331         /*_mmcam_dbg_log( "Entered..." );*/
1332
1333         mmf_return_val_if_fail( name, FALSE );
1334
1335         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
1336         {
1337                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
1338                 return FALSE;
1339         }
1340
1341         /*_mmcam_dbg_log( "Number of value : [%d]", count_value );*/
1342
1343         if( type == CONFIGURE_TYPE_MAIN )
1344         {
1345                 for( i = 0 ; i < count_value ; i++ )
1346                 {
1347                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
1348                         {
1349                                 *value_type = hcamcorder->conf_main_info_table[category][i].value_type;
1350                                 /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
1351                                 return TRUE;
1352                         }
1353                 }
1354         }
1355         else
1356         {
1357                 for( i = 0 ; i < count_value ; i++ )
1358                 {
1359                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
1360                         {
1361                                 *value_type = hcamcorder->conf_ctrl_info_table[category][i].value_type;
1362                                 /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
1363                                 return TRUE;
1364                         }
1365                 }
1366         }
1367
1368         return FALSE;
1369 }
1370
1371
1372 int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details )
1373 {
1374         const int BUFFER_NUM_TOKEN = 256;
1375
1376         int i = 0;
1377         int j = 0;
1378         int count_token;
1379         int value_type;
1380         char *token = NULL;
1381         char *buffer_token[BUFFER_NUM_TOKEN];
1382         char *user_ptr = NULL;
1383
1384         const char *delimiters     = " |=,\t\n";
1385         const char *delimiters_sub = " |\t\n";
1386         const char *delimiters_3rd = "|\n";
1387
1388         mmf_return_val_if_fail( buffer_details, FALSE );
1389
1390         (*info) = (conf_detail*)g_malloc0( sizeof(conf_detail) );
1391         if (*info == NULL) {
1392                 _mmcam_dbg_err("allocation failed");
1393                 return FALSE;
1394         }
1395         (*info)->detail_info = (void**)g_malloc0(sizeof(void*) * count_details);
1396         (*info)->count = count_details;
1397
1398         for ( i = 0 ; i < count_details ; i++ ) {
1399                 /*_mmcam_dbg_log("Read line\"%s\"", buffer_details[i]);*/
1400                 count_token = 0;
1401                 token = strtok_r( buffer_details[i], delimiters, &user_ptr );
1402
1403                 if (token) {
1404                         buffer_token[count_token] = token;
1405                         count_token++;
1406                 } else {
1407                         (*info)->detail_info[i] = NULL;
1408                         _mmcam_dbg_warn( "No token... check it.[%s]", buffer_details[i] );
1409                         continue;
1410                 }
1411
1412                 if (!_mmcamcorder_conf_get_value_type(handle, type, category, buffer_token[0], &value_type)) {
1413                         (*info)->detail_info[i] = NULL;
1414                         _mmcam_dbg_warn( "Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0] );
1415                         continue;
1416                 }
1417
1418                 if (value_type != CONFIGURE_VALUE_STRING && value_type != CONFIGURE_VALUE_STRING_ARRAY) {
1419                         token = strtok_r( NULL, delimiters, &user_ptr );
1420                         while (token) {
1421                                 buffer_token[count_token] = token;
1422                                 /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1423                                 count_token++;
1424                                 token = strtok_r( NULL, delimiters, &user_ptr );
1425                         }
1426
1427                         if (count_token < 2) {
1428                                 (*info)->detail_info[i] = NULL;
1429                                 _mmcam_dbg_warn( "Number of token is too small... check it.[%s]", buffer_details[i] );
1430                                 continue;
1431                         }
1432                 } else { /* CONFIGURE_VALUE_STRING or CONFIGURE_VALUE_STRING_ARRAY */
1433                         /* skip "=" */
1434                         strtok_r( NULL, delimiters_sub, &user_ptr );
1435
1436                         if (value_type == CONFIGURE_VALUE_STRING_ARRAY) {
1437                                 token = strtok_r( NULL, delimiters_sub, &user_ptr );
1438                                 while (token) {
1439                                         buffer_token[count_token] = token;
1440                                         /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1441                                         count_token++;
1442                                         token = strtok_r( NULL, delimiters_sub, &user_ptr );
1443                                 }
1444                         } else { /* CONFIGURE_VALUE_STRING */
1445                                 token = strtok_r( NULL, delimiters_3rd, &user_ptr );
1446                                 if (token) {
1447                                         g_strchug( token );
1448                                         buffer_token[count_token] = token;
1449                                         /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1450                                         count_token++;
1451                                 }
1452                         }
1453
1454                         if (count_token < 2) {
1455                                 (*info)->detail_info[i] = NULL;
1456                                 _mmcam_dbg_warn( "No string value... check it.[%s]", buffer_details[i] );
1457                                 continue;
1458                         }
1459                 }
1460
1461                 switch (value_type)
1462                 {
1463                         case CONFIGURE_VALUE_INT:
1464                         {
1465                                 type_int2* new_int;
1466
1467                                 new_int        = (type_int2*)g_malloc0( sizeof(type_int2) );
1468                                 if ( new_int == NULL ) {
1469                                         _mmcam_dbg_err("allocation failed");
1470                                         break;
1471                                 }
1472                                 new_int->name  = get_new_string( buffer_token[0] );
1473                                 new_int->value = atoi( buffer_token[1] );
1474                                 (*info)->detail_info[i] = (void*)new_int;
1475                                 /*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
1476                                 break;
1477                         }
1478                         case CONFIGURE_VALUE_INT_RANGE:
1479                         {
1480                                 type_int_range* new_int_range;
1481
1482                                 new_int_range                = (type_int_range*)g_malloc0( sizeof(type_int_range) );
1483                                 if ( new_int_range == NULL ) {
1484                                         _mmcam_dbg_err("allocation failed");
1485                                         break;
1486                                 }
1487                                 new_int_range->name          = get_new_string( buffer_token[0] );
1488                                 new_int_range->min           = atoi( buffer_token[1] );
1489                                 new_int_range->max           = atoi( buffer_token[2] );
1490                                 new_int_range->default_value = atoi( buffer_token[3] );
1491                                 (*info)->detail_info[i]      = (void*)new_int_range;
1492                                 /*
1493                                 _mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
1494                                                 new_int_range->name,
1495                                                 new_int_range->min,
1496                                                 new_int_range->max,
1497                                                 new_int_range->default_value);
1498                                 */
1499                                 break;
1500                         }
1501                         case CONFIGURE_VALUE_INT_ARRAY:
1502                         {
1503                                 int count_value = count_token - 2;
1504                                 type_int_array* new_int_array;
1505
1506                                 new_int_array = (type_int_array*)g_malloc0( sizeof(type_int_array) );
1507                                 if (new_int_array == NULL) {
1508                                         _mmcam_dbg_err("allocation failed");
1509                                         break;
1510                                 }
1511                                 new_int_array->name = get_new_string( buffer_token[0] );
1512                                 new_int_array->value = (int*)g_malloc0( sizeof(int)*count_value );
1513                                 if (new_int_array->value == NULL) {
1514                                         SAFE_G_FREE(new_int_array->name);
1515                                         SAFE_G_FREE(new_int_array);
1516                                         _mmcam_dbg_err("allocation failed");
1517                                         break;
1518                                 }
1519                                 new_int_array->count = count_value;
1520
1521                                 /*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
1522                                 for ( j = 0 ; j < count_value ; j++ ) {
1523                                         new_int_array->value[j] = atoi( buffer_token[j+1] );
1524                                         /*_mmcam_dbg_log("   index[%d] - value[%d]", j, new_int_array->value[j]);*/
1525                                 }
1526
1527                                 new_int_array->default_value = atoi( buffer_token[count_token-1] );
1528                                 /*_mmcam_dbg_log("   default value[%d]", new_int_array->default_value);*/
1529
1530                                 (*info)->detail_info[i] = (void*)new_int_array;
1531                                 break;
1532                         }
1533                         case CONFIGURE_VALUE_INT_PAIR_ARRAY:
1534                         {
1535                                 int count_value = ( count_token - 3 ) >> 1;
1536                                 type_int_pair_array* new_int_pair_array;
1537
1538                                 new_int_pair_array = (type_int_pair_array*)g_malloc0( sizeof(type_int_pair_array) );
1539                                 if ( new_int_pair_array == NULL ) {
1540                                         _mmcam_dbg_err("allocation failed");
1541                                         break;
1542                                 }
1543                                 new_int_pair_array->name     = get_new_string( buffer_token[0] );
1544                                 new_int_pair_array->value[0] = (int*)g_malloc0( sizeof(int)*(count_value) );
1545                                 if ( new_int_pair_array->value[0] == NULL ) {
1546                                         SAFE_G_FREE(new_int_pair_array->name);
1547                                         SAFE_G_FREE(new_int_pair_array);
1548                                         _mmcam_dbg_err("allocation failed");
1549                                         break;
1550                                 }
1551                                 new_int_pair_array->value[1] = (int*)g_malloc0( sizeof(int)*(count_value) );
1552                                 if ( new_int_pair_array->value[1] == NULL ) {
1553                                         SAFE_G_FREE(new_int_pair_array->value[0]);
1554                                         SAFE_G_FREE(new_int_pair_array->name);
1555                                         SAFE_G_FREE(new_int_pair_array);
1556                                         _mmcam_dbg_err("allocation failed");
1557                                         break;
1558                                 }
1559                                 new_int_pair_array->count    = count_value;
1560
1561                                 /*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
1562                                 for ( j = 0 ; j < count_value ; j++ ) {
1563                                         new_int_pair_array->value[0][j] = atoi( buffer_token[(j<<1)+1] );
1564                                         new_int_pair_array->value[1][j] = atoi( buffer_token[(j<<1)+2] );
1565                                         /*
1566                                         _mmcam_dbg_log("   index[%d] - value[%d,%d]", j,
1567                                                         new_int_pair_array->value[0][j],
1568                                                         new_int_pair_array->value[1][j]);
1569                                         */
1570                                 }
1571
1572                                 new_int_pair_array->default_value[0] = atoi( buffer_token[count_token-2] );
1573                                 new_int_pair_array->default_value[1] = atoi( buffer_token[count_token-1] );
1574                                 /*
1575                                 _mmcam_dbg_log("   default value[%d,%d]",
1576                                                 new_int_pair_array->default_value[0],
1577                                                 new_int_pair_array->default_value[1]);
1578                                 */
1579                                 (*info)->detail_info[i] = (void*)new_int_pair_array;
1580                                 break;
1581                         }
1582                         case CONFIGURE_VALUE_STRING:
1583                         {
1584                                 type_string2* new_string;
1585
1586                                 new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
1587                                 if (new_string == NULL) {
1588                                         _mmcam_dbg_err("allocation failed");
1589                                         break;
1590                                 }
1591                                 new_string->name  = get_new_string( buffer_token[0] );
1592                                 new_string->value = get_new_string( buffer_token[1] );
1593                                 (*info)->detail_info[i] = (void*)new_string;
1594
1595                                 /*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
1596                                 break;
1597                         }
1598                         case CONFIGURE_VALUE_STRING_ARRAY:
1599                         {
1600                                 int count_value = count_token - 2;
1601                                 type_string_array* new_string_array;
1602
1603                                 new_string_array = (type_string_array*)g_malloc0( sizeof(type_string_array) );
1604                                 if ( new_string_array == NULL ) {
1605                                         break;
1606                                 }
1607                                 new_string_array->name  = get_new_string( buffer_token[0] );
1608                                 new_string_array->count = count_value;
1609                                 new_string_array->value = (char**)g_malloc0( sizeof(char*)*count_value );
1610                                 if ( new_string_array->value == NULL ) {
1611                                         SAFE_G_FREE(new_string_array->name);
1612                                         SAFE_G_FREE(new_string_array);
1613                                         _mmcam_dbg_err("allocation failed");
1614                                         break;
1615                                 }
1616                                 /*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
1617                                 for ( j = 0 ; j < count_value ; j++ ) {
1618                                         new_string_array->value[j] = get_new_string( buffer_token[j+1] );
1619                                         /*_mmcam_dbg_log("   index[%d] - value[%s]", j, new_string_array->value[j]);*/
1620                                 }
1621
1622                                 new_string_array->default_value = get_new_string( buffer_token[count_token-1] );
1623                                 /*_mmcam_dbg_log("   default value[%s]", new_string_array->default_value);*/
1624                                 (*info)->detail_info[i] = (void*)new_string_array;
1625                                 break;
1626                         }
1627                         case CONFIGURE_VALUE_ELEMENT:
1628                         {
1629                                 type_element2* new_element;
1630
1631                                 new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
1632                                 if ( new_element == NULL ) {
1633                                         _mmcam_dbg_err("allocation failed");
1634                                         break;
1635                                 }
1636                                 new_element->name         = get_new_string( buffer_token[0] );
1637                                 new_element->element_name = get_new_string( buffer_token[1] );
1638                                 new_element->count_int    = atoi( buffer_token[2] );
1639                                 new_element->value_int    = NULL;
1640                                 new_element->count_string = atoi( buffer_token[3] );
1641                                 new_element->value_string = NULL;
1642                                 /*
1643                                 _mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
1644                                                new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
1645                                 */
1646
1647                                 /* add int values */
1648                                 if ( new_element->count_int > 0 && new_element->count_int <= 30 ) {
1649                                         new_element->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
1650                                         if ( new_element->value_int) {
1651                                                 for ( j = 0 ; j < new_element->count_int ; j++ ) {
1652                                                         new_element->value_int[j]        = (type_int2*)g_malloc0( sizeof(type_int2) );
1653                                                         if ( new_element->value_int[j] ) {
1654                                                                 new_element->value_int[j]->name  = get_new_string( buffer_token[4+(j<<1)] );
1655                                                                 new_element->value_int[j]->value = atoi( buffer_token[5+(j<<1)] );
1656                                                         } else {
1657                                                                 _mmcam_dbg_err("allocation failed");
1658                                                         }
1659                                                         /*
1660                                                         _mmcam_dbg_log("   Element INT[%d] - name[%s],value[%d]",
1661                                                                        j, new_element->value_int[j]->name, new_element->value_int[j]->value);
1662                                                         */
1663                                                 }
1664                                         } else {
1665                                                 _mmcam_dbg_err("allocation failed");
1666                                         }
1667                                 }
1668                                 else
1669                                 {
1670                                         _mmcam_dbg_err("invalid count - %d", new_element->count_int);
1671                                         new_element->value_int = NULL;
1672                                 }
1673
1674                                 /* add string values */
1675                                 if ( new_element->count_string > 0 && new_element->count_string <= 30 &&
1676                                      new_element->count_int >= 0 && new_element->count_int <= 30 ) {
1677                                         new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_string) );
1678                                         if (new_element->value_string) {
1679                                                 for ( ; j < new_element->count_string + new_element->count_int ; j++ ) {
1680                                                         new_element->value_string[j-new_element->count_int]     = (type_string2*)g_malloc0( sizeof(type_string2) );
1681                                                         if(new_element->value_string[j-new_element->count_int]) {
1682                                                                 new_element->value_string[j-new_element->count_int]->name       = get_new_string( buffer_token[4+(j<<1)] );
1683                                                                 new_element->value_string[j-new_element->count_int]->value      = get_new_string( buffer_token[5+(j<<1)] );
1684                                                                 /*
1685                                                                 _mmcam_dbg_log("   Element STRING[%d] - name[%s],value[%s]",
1686                                                                                j-new_element->count_int, new_element->value_string[j-new_element->count_int]->name, new_element->value_string[j-new_element->count_int]->value);
1687                                                                 */
1688                                                         } else {
1689                                                                 _mmcam_dbg_err("allocation failed");
1690                                                         }
1691                                                 }
1692                                         } else {
1693                                                 _mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
1694                                         }
1695                                 } else {
1696                                         _mmcam_dbg_err("invalid count - %d", new_element->count_string);
1697                                         new_element->value_string = NULL;
1698                                 }
1699
1700                                 (*info)->detail_info[i] = (void*)new_element;
1701                                 break;
1702                         }
1703                         default:
1704                                 break;
1705                 }
1706         }
1707
1708         return TRUE;
1709 }
1710
1711
1712 int _mmcamcorder_conf_get_value_int(MMHandleType handle, camera_conf* configure_info, int category, const char* name, int* value)
1713 {
1714         int i, count;
1715         conf_detail* info;
1716
1717         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1718
1719         mmf_return_val_if_fail( configure_info, FALSE );
1720         mmf_return_val_if_fail( name, FALSE );
1721
1722         if( configure_info->info[category] )
1723         {
1724                 count = configure_info->info[category]->count;
1725                 info = configure_info->info[category];
1726
1727                 for( i = 0 ; i < count ; i++ )
1728                 {
1729                         if( info->detail_info[i] == NULL )
1730                         {
1731                                 continue;
1732                         }
1733
1734                         if( !strcmp( ((type_int*)(info->detail_info[i]))->name , name ) )
1735                         {
1736                                 *value = ((type_int*)(info->detail_info[i]))->value;
1737                                 //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
1738                                 return TRUE;
1739                         }
1740                 }
1741         }
1742
1743         if( _mmcamcorder_conf_get_default_value_int( handle, configure_info->type, category, name, value ) )
1744         {
1745                 //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
1746                 return TRUE;
1747         }
1748
1749         _mmcam_dbg_warn( "Faild to get int... check it...Category[%d],Name[%s]", category, name );
1750
1751         return FALSE;
1752 }
1753
1754 int
1755 _mmcamcorder_conf_get_value_int_range( camera_conf* configure_info, int category, const char* name, type_int_range** value )
1756 {
1757         int i, count;
1758         conf_detail* info;
1759
1760         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1761
1762         mmf_return_val_if_fail( configure_info, FALSE );
1763         mmf_return_val_if_fail( name, FALSE );
1764
1765         if( configure_info->info[category] )
1766         {
1767                 count = configure_info->info[category]->count;
1768                 info = configure_info->info[category];
1769
1770                 for( i = 0 ; i < count ; i++ )
1771                 {
1772                         if( info->detail_info[i] == NULL )
1773                         {
1774                                 continue;
1775                         }
1776
1777                         if( !strcmp( ((type_int_range*)(info->detail_info[i]))->name , name ) )
1778                         {
1779                                 *value = (type_int_range*)(info->detail_info[i]);
1780                                 /*
1781                                 _mmcam_dbg_log( "Get[%s] int range - min[%d],max[%d],default[%d]",
1782                                                 name, (*value)->min, (*value)->max, (*value)->default_value );
1783                                 */
1784                                 return TRUE;
1785                         }
1786                 }
1787         }
1788
1789         *value = NULL;
1790
1791         /*_mmcam_dbg_warn( "Faild to get int range... check it...Category[%d],Name[%s]", category, name );*/
1792
1793         return FALSE;
1794 }
1795
1796 int
1797 _mmcamcorder_conf_get_value_int_array( camera_conf* configure_info, int category, const char* name, type_int_array** value )
1798 {
1799         int i, count;
1800         conf_detail* info;
1801
1802         /*_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );*/
1803
1804         mmf_return_val_if_fail( configure_info, FALSE );
1805         mmf_return_val_if_fail( name, FALSE );
1806
1807         if( configure_info->info[category] )
1808         {
1809                 count   = configure_info->info[category]->count;
1810                 info    = configure_info->info[category];
1811
1812                 for( i = 0 ; i < count ; i++ )
1813                 {
1814                         if( info->detail_info[i] == NULL )
1815                         {
1816                                 continue;
1817                         }
1818
1819                         if( !strcmp( ((type_int_array*)(info->detail_info[i]))->name , name ) )
1820                         {
1821                                 *value = (type_int_array*)(info->detail_info[i]);
1822                                 /*
1823                                 _mmcam_dbg_log( "Get[%s] int array - [%x],count[%d],default[%d]",
1824                                                 name, (*value)->value, (*value)->count, (*value)->default_value );
1825                                 */
1826                                 return TRUE;
1827                         }
1828                 }
1829         }
1830
1831         *value = NULL;
1832
1833         /*_mmcam_dbg_warn( "Faild to get int array... check it...Category[%d],Name[%s]", category, name );*/
1834
1835         return FALSE;
1836 }
1837
1838 int
1839 _mmcamcorder_conf_get_value_int_pair_array( camera_conf* configure_info, int category, const char* name, type_int_pair_array** value )
1840 {
1841         int i, count;
1842         conf_detail* info;
1843
1844         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1845
1846         mmf_return_val_if_fail( configure_info, FALSE );
1847         mmf_return_val_if_fail( name, FALSE );
1848
1849         if( configure_info->info[category] )
1850         {
1851                 count = configure_info->info[category]->count;
1852                 info = configure_info->info[category];
1853
1854                 for( i = 0 ; i < count ; i++ )
1855                 {
1856                         if( info->detail_info[i] == NULL )
1857                         {
1858                                 continue;
1859                         }
1860
1861                         if( !strcmp( ((type_int_pair_array*)(info->detail_info[i]))->name , name ) )
1862                         {
1863                                 *value = (type_int_pair_array*)(info->detail_info[i]);
1864                                 /*
1865                                 _mmcam_dbg_log( "Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
1866                                                 name, (*value)->value[0], (*value)->value[1], (*value)->count,
1867                                                 (*value)->default_value[0], (*value)->default_value[1] );
1868                                 */
1869                                 return TRUE;
1870                         }
1871                 }
1872         }
1873
1874         *value = NULL;
1875
1876         _mmcam_dbg_warn( "Faild to get int pair array... check it...Category[%d],Name[%s]", category, name );
1877
1878         return FALSE;
1879 }
1880
1881 int _mmcamcorder_conf_get_value_string(MMHandleType handle, camera_conf* configure_info, int category, const char* name, const char** value)
1882 {
1883         int i, count;
1884         conf_detail* info;
1885
1886         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1887
1888         mmf_return_val_if_fail( configure_info, FALSE );
1889         mmf_return_val_if_fail( name, FALSE );
1890
1891         if( configure_info->info[category] )
1892         {
1893                 count = configure_info->info[category]->count;
1894                 info = configure_info->info[category];
1895
1896                 for( i = 0 ; i < count ; i++ )
1897                 {
1898                         if( info->detail_info[i] == NULL )
1899                         {
1900                                 continue;
1901                         }
1902
1903                         if( !strcmp( ((type_string*)(info->detail_info[i]))->name , name ) )
1904                         {
1905                                 *value = ((type_string*)(info->detail_info[i]))->value;
1906                                 //_mmcam_dbg_log( "Get[%s] string[%s]", name, *value );
1907                                 return TRUE;
1908                         }
1909                 }
1910         }
1911
1912         if( _mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value ) )
1913         {
1914                 //_mmcam_dbg_log( "Get[%s]string[%s]", name, *value );
1915                 return TRUE;
1916         }
1917
1918         _mmcam_dbg_warn( "Faild to get string... check it...Category[%d],Name[%s]", category, name );
1919
1920         return FALSE;
1921 }
1922
1923 int
1924 _mmcamcorder_conf_get_value_string_array( camera_conf* configure_info, int category, const char* name, type_string_array** value )
1925 {
1926         int i, count;
1927         conf_detail* info;
1928
1929         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1930
1931         mmf_return_val_if_fail( configure_info, FALSE );
1932         mmf_return_val_if_fail( name, FALSE );
1933
1934         if( configure_info->info[category] )
1935         {
1936                 count = configure_info->info[category]->count;
1937                 info = configure_info->info[category];
1938
1939                 for( i = 0 ; i < count ; i++ )
1940                 {
1941                         if( info->detail_info[i] == NULL )
1942                         {
1943                                 continue;
1944                         }
1945
1946                         if( !strcmp( ((type_string_array*)(info->detail_info[i]))->name , name ) )
1947                         {
1948                                 *value = (type_string_array*)(info->detail_info[i]);
1949                                 /*
1950                                 _mmcam_dbg_log( "Get[%s] string array - [%x],count[%d],default[%s]",
1951                                                 name, (*value)->value, (*value)->count, (*value)->default_value );
1952                                 */
1953                                 return TRUE;
1954                         }
1955                 }
1956         }
1957
1958         *value = NULL;
1959
1960         /*_mmcam_dbg_warn( "Faild to get string array... check it...Category[%d],Name[%s]", category, name );*/
1961
1962         return FALSE;
1963 }
1964
1965 int _mmcamcorder_conf_get_element(MMHandleType handle, camera_conf* configure_info, int category, const char* name, type_element** element)
1966 {
1967         int i, count;
1968         conf_detail* info;
1969
1970         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1971
1972         mmf_return_val_if_fail( configure_info, FALSE );
1973         mmf_return_val_if_fail( name, FALSE );
1974
1975         if( configure_info->info[category] )
1976         {
1977                 count = configure_info->info[category]->count;
1978                 info = configure_info->info[category];
1979
1980                 for( i = 0 ; i < count ; i++ )
1981                 {
1982                         if( info->detail_info[i] == NULL )
1983                         {
1984                                 continue;
1985                         }
1986
1987                         if( !strcmp( ((type_element*)(info->detail_info[i]))->name , name ) )
1988                         {
1989                                 *element = (type_element*)(info->detail_info[i]);
1990                                 //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
1991                                 return TRUE;
1992                         }
1993                 }
1994         }
1995
1996         if( _mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element ) )
1997         {
1998                 //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
1999                 return TRUE;
2000         }
2001
2002         _mmcam_dbg_warn( "Faild to get element name... check it...Category[%d],Name[%s]", category, name );
2003
2004         return FALSE;
2005 }
2006
2007 int
2008 _mmcamcorder_conf_get_value_element_name( type_element* element, const char** value )
2009 {
2010         //_mmcam_dbg_log( "Entered..." );
2011
2012         mmf_return_val_if_fail( element, FALSE );
2013
2014         *value = element->element_name;
2015
2016         //_mmcam_dbg_log( "Get element name : [%s]", *value );
2017
2018         return TRUE;
2019 }
2020
2021 int
2022 _mmcamcorder_conf_get_value_element_int( type_element* element, const char* name, int* value )
2023 {
2024         int i;
2025
2026         //_mmcam_dbg_log( "Entered..." );
2027
2028         mmf_return_val_if_fail( element, FALSE );
2029         mmf_return_val_if_fail( name, FALSE );
2030
2031         for( i = 0 ; i < element->count_int ; i++ )
2032         {
2033                 if( !strcmp( element->value_int[i]->name , name ) )
2034                 {
2035                         *value = element->value_int[i]->value;
2036                         //_mmcam_dbg_log( "Get[%s] element int[%d]", name, *value );
2037                         return TRUE;
2038                 }
2039         }
2040
2041         _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
2042                 element->name, name, element->count_int );
2043
2044         return FALSE;
2045 }
2046
2047 int
2048 _mmcamcorder_conf_get_value_element_string( type_element* element, const char* name, const char** value )
2049 {
2050         int i;
2051
2052         //_mmcam_dbg_log( "Entered..." );
2053
2054         mmf_return_val_if_fail( element, FALSE );
2055         mmf_return_val_if_fail( name, FALSE );
2056
2057         for( i = 0 ; i < element->count_string ; i++ )
2058         {
2059                 if( !strcmp( element->value_string[i]->name , name ) )
2060                 {
2061                         *value = element->value_string[i]->value;
2062                         //_mmcam_dbg_log( "Get[%s] element string[%s]", name, *value );
2063                         return TRUE;
2064                 }
2065         }
2066
2067         _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
2068                 element->name, name, element->count_string );
2069
2070         return FALSE;
2071 }
2072
2073 int
2074 _mmcamcorder_conf_set_value_element_property( GstElement* gst, type_element* element )
2075 {
2076         int i;
2077
2078         //_mmcam_dbg_log( "Entered..." );
2079
2080         mmf_return_val_if_fail( gst, FALSE );
2081         mmf_return_val_if_fail( element, FALSE );
2082
2083         if( element->count_int == 0 )
2084         {
2085                 /*_mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );*/
2086         }
2087         else
2088         {
2089                 if( element->value_int == NULL )
2090                 {
2091                         _mmcam_dbg_warn( "count_int[%d] is NOT zero, but value_int is NULL", element->count_int );
2092                         return FALSE;
2093                 }
2094
2095                 for( i = 0 ; i < element->count_int ; i++ )
2096                 {
2097                         MMCAMCORDER_G_OBJECT_SET( gst, element->value_int[i]->name, element->value_int[i]->value );
2098
2099                         /*
2100                         _mmcam_dbg_log( "Element[%s] Set[%s] -> integer[%d]",
2101                                 element->element_name,
2102                                 element->value_int[i]->name,
2103                                 element->value_int[i]->value );
2104                                 */
2105                 }
2106         }
2107
2108         if( element->count_string == 0 )
2109         {
2110                 _mmcam_dbg_log( "There is no string property to set in INI file[%s].", element->name );
2111         }
2112         else
2113         {
2114                 if( element->value_string == NULL )
2115                 {
2116                         _mmcam_dbg_warn( "count_string[%d] is NOT zero, but value_string is NULL", element->count_string );
2117                         return FALSE;
2118                 }
2119
2120                 for( i = 0 ; i < element->count_string ; i++ )
2121                 {
2122                         MMCAMCORDER_G_OBJECT_SET_POINTER( gst, element->value_string[i]->name, element->value_string[i]->value );
2123
2124                         _mmcam_dbg_log( "Element[%s] Set[%s] -> string[%s]",
2125                                 element->element_name,
2126                                 element->value_string[i]->name,
2127                                 element->value_string[i]->value );
2128                 }
2129         }
2130
2131         //_mmcam_dbg_log( "Done." );
2132
2133         return TRUE;
2134 }
2135
2136 int
2137 _mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value )
2138 {
2139         int i = 0;
2140         int count_value = 0;
2141
2142         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2143
2144         if (hcamcorder == NULL) {
2145                 _mmcam_dbg_err("handle is NULL");
2146                 return FALSE;
2147         }
2148
2149         //_mmcam_dbg_log( "Entered..." );
2150
2151         mmf_return_val_if_fail( name, FALSE );
2152
2153         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2154         {
2155                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2156                 return FALSE;
2157         }
2158
2159         if( type == CONFIGURE_TYPE_MAIN )
2160         {
2161                 for( i = 0 ; i < count_value ; i++ )
2162                 {
2163                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2164                         {
2165                                 *value = hcamcorder->conf_main_info_table[category][i].value_int;
2166                                 return TRUE;
2167                         }
2168                 }
2169         }
2170         else
2171         {
2172                 for( i = 0 ; i < count_value ; i++ )
2173                 {
2174                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2175                         {
2176                                 *value = hcamcorder->conf_ctrl_info_table[category][i].value_int;
2177                                 return TRUE;
2178                         }
2179                 }
2180         }
2181
2182         _mmcam_dbg_warn( "Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2183
2184         return FALSE;
2185 }
2186
2187 int _mmcamcorder_conf_get_default_value_string(MMHandleType handle, int type, int category, const char* name, const char** value)
2188 {
2189         int i = 0;
2190         int count_value = 0;
2191
2192         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2193
2194         if (hcamcorder == NULL) {
2195                 _mmcam_dbg_err("handle is NULL");
2196                 return FALSE;
2197         }
2198
2199         //_mmcam_dbg_log( "Entered..." );
2200
2201         mmf_return_val_if_fail( name, FALSE );
2202
2203         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2204         {
2205                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2206                 return FALSE;
2207         }
2208
2209         if( type == CONFIGURE_TYPE_MAIN )
2210         {
2211                 for( i = 0 ; i < count_value ; i++ )
2212                 {
2213                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2214                         {
2215                                 *value = hcamcorder->conf_main_info_table[category][i].value_string;
2216                                 _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
2217                                 return TRUE;
2218                         }
2219                 }
2220         }
2221         else
2222         {
2223                 for( i = 0 ; i < count_value ; i++ )
2224                 {
2225                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2226                         {
2227                                 *value = hcamcorder->conf_ctrl_info_table[category][i].value_string;
2228                                 _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
2229                                 return TRUE;
2230                         }
2231                 }
2232         }
2233
2234         _mmcam_dbg_warn( "Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2235
2236         return FALSE;
2237 }
2238
2239 int _mmcamcorder_conf_get_default_element(MMHandleType handle, int type, int category, const char* name, type_element** element)
2240 {
2241         int i = 0;
2242         int count_value = 0;
2243
2244         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2245
2246         if (hcamcorder == NULL) {
2247                 _mmcam_dbg_err("handle is NULL");
2248                 return FALSE;
2249         }
2250
2251         //_mmcam_dbg_log( "Entered..." );
2252
2253         mmf_return_val_if_fail( name, FALSE );
2254
2255         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2256         {
2257                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2258                 return FALSE;
2259         }
2260
2261         if( type == CONFIGURE_TYPE_MAIN )
2262         {
2263                 for( i = 0 ; i < count_value ; i++ )
2264                 {
2265                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2266                         {
2267                                 *element = hcamcorder->conf_main_info_table[category][i].value_element;
2268                                 _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
2269                                 return TRUE;
2270                         }
2271                 }
2272         }
2273         else
2274         {
2275                 for( i = 0 ; i < count_value ; i++ )
2276                 {
2277                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2278                         {
2279                                 *element = hcamcorder->conf_ctrl_info_table[category][i].value_element;
2280                                 _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
2281                                 return TRUE;
2282                         }
2283                 }
2284         }
2285
2286         _mmcam_dbg_warn( "Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2287
2288         return FALSE;
2289 }
2290
2291 int _mmcamcorder_conf_get_category_size(MMHandleType handle, int type, int category, int* size)
2292 {
2293         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2294
2295         if (hcamcorder == NULL) {
2296                 _mmcam_dbg_err("handle is NULL");
2297                 return FALSE;
2298         }
2299
2300 //      mmf_return_val_if_fail( conf_main_category_size, FALSE );
2301 //      mmf_return_val_if_fail( conf_ctrl_category_size, FALSE );
2302
2303         if( type == CONFIGURE_TYPE_MAIN )
2304         {
2305                 mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE );
2306
2307                 *size = (int)hcamcorder->conf_main_category_size[category];
2308         }
2309         else
2310         {
2311                 mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE );
2312
2313                 *size = (int)hcamcorder->conf_ctrl_category_size[category];
2314         }
2315
2316         return TRUE;
2317 }
2318
2319 void
2320 _mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info )
2321 {
2322         int i, j, k, type, category_type;
2323
2324         type_int                *temp_int;
2325         type_int_range          *temp_int_range;
2326         type_int_array          *temp_int_array;
2327         type_int_pair_array     *temp_int_pair_array;
2328         type_string             *temp_string;
2329         type_element            *temp_element;
2330
2331         g_print( "[ConfigureInfoPrint] : Entered.\n" );
2332
2333         mmf_return_if_fail( *configure_info );
2334
2335         if( (*configure_info)->type == CONFIGURE_TYPE_MAIN )
2336         {
2337                 category_type = CONFIGURE_CATEGORY_MAIN_NUM;
2338         }
2339         else
2340         {
2341                 category_type = CONFIGURE_CATEGORY_CTRL_NUM;
2342         }
2343
2344         for( i = 0 ; i < category_type ; i++ )
2345         {
2346                 if( (*configure_info)->info[i] )
2347                 {
2348                         g_print( "[ConfigureInfo] : Category [%d]\n", i );
2349                         for( j = 0 ; j < (*configure_info)->info[i]->count ; j++ )
2350                         {
2351                                 if( _mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type ) )
2352                                 {
2353                                         switch( type )
2354                                         {
2355                                                 case CONFIGURE_VALUE_INT:
2356                                                         temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
2357                                                         g_print( "[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value );
2358                                                         break;
2359                                                 case CONFIGURE_VALUE_INT_RANGE:
2360                                                         temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
2361                                                         g_print( "[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
2362                                                                  temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value );
2363                                                         break;
2364                                                 case CONFIGURE_VALUE_INT_ARRAY:
2365                                                         temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
2366                                                         g_print( "[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n                            - ",
2367                                                                  temp_int_array->name, temp_int_array->default_value );
2368                                                         for( k = 0 ; k < temp_int_array->count ; k++ )
2369                                                         {
2370                                                                 g_print( "[%d] ", temp_int_array->value[k] );
2371                                                         }
2372                                                         g_print( "\n" );
2373                                                         break;
2374                                                 case CONFIGURE_VALUE_INT_PAIR_ARRAY:
2375                                                         temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
2376                                                         g_print( "[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n                            - ",
2377                                                                  temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0] );
2378                                                         for( k = 0 ; k < temp_int_pair_array->count ; k++ )
2379                                                         {
2380                                                                 g_print( "[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k] );
2381                                                         }
2382                                                         g_print( "\n" );
2383                                                         break;
2384                                                 case CONFIGURE_VALUE_STRING:
2385                                                         temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
2386                                                         g_print( "[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value );
2387                                                         break;
2388                                                 case CONFIGURE_VALUE_ELEMENT:
2389                                                         temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
2390                                                         g_print( "[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name );
2391                                                         for( k = 0 ; k < temp_element->count_int ; k++ )
2392                                                         {
2393                                                                 g_print( "                          - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value );
2394                                                         }
2395                                                         for( k = 0 ; k < temp_element->count_string ; k++ )
2396                                                         {
2397                                                                 g_print( "                          - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value );
2398                                                         }
2399                                                         break;
2400                                                 default:
2401                                                         g_print( "[ConfigureInfo] : Not matched value type... So can not print data... check it... Name[%s],type[%d]\n", ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, type );
2402                                                         break;
2403                                         }
2404                                 }
2405                                 else
2406                                 {
2407                                         g_print( "[ConfigureInfo] : Failed to get value type." );
2408                                 }
2409                         }
2410                 }
2411         }
2412
2413         g_print( "[ConfigureInfoPrint] : Done.\n" );
2414 }
2415
2416
2417 static type_element *
2418 __mmcamcorder_get_audio_codec_element(MMHandleType handle)
2419 {
2420         type_element *telement = NULL;
2421         const char *codec_type_str = NULL;
2422         int codec_type = MM_AUDIO_CODEC_INVALID;
2423         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2424         _MMCamcorderSubContext *sc = NULL;
2425
2426         mmf_return_val_if_fail(hcamcorder, NULL);
2427         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2428
2429         mmf_return_val_if_fail(sc, NULL);
2430
2431         _mmcam_dbg_log("");
2432
2433         /* Check element availability */
2434         mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &codec_type, NULL);
2435
2436         switch( codec_type )
2437         {
2438                 case MM_AUDIO_CODEC_AMR:
2439                         codec_type_str = "AMR";
2440                         break;
2441                 case MM_AUDIO_CODEC_G723_1:
2442                         codec_type_str = "G723_1";
2443                         break;
2444                 case MM_AUDIO_CODEC_MP3:
2445                         codec_type_str = "MP3";
2446                         break;
2447                 case MM_AUDIO_CODEC_AAC:
2448                         codec_type_str = "AAC";
2449                         break;
2450                 case MM_AUDIO_CODEC_MMF:
2451                         codec_type_str = "MMF";
2452                         break;
2453                 case MM_AUDIO_CODEC_ADPCM:
2454                         codec_type_str = "ADPCM";
2455                         break;
2456                 case MM_AUDIO_CODEC_WAVE:
2457                         codec_type_str = "WAVE";
2458                         break;
2459                 case MM_AUDIO_CODEC_MIDI:
2460                         codec_type_str = "MIDI";
2461                         break;
2462                 case MM_AUDIO_CODEC_IMELODY:
2463                         codec_type_str = "IMELODY";
2464                         break;
2465                 case MM_AUDIO_CODEC_VORBIS:
2466                         codec_type_str = "VORBIS";
2467                         break;
2468                 default:
2469                         _mmcam_dbg_err( "Not supported audio codec[%d]", codec_type );
2470                         return NULL;
2471         }
2472
2473         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2474                                       CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
2475                                       codec_type_str,
2476                                       &telement);
2477
2478         return telement;
2479 }
2480
2481
2482 static type_element *
2483 __mmcamcorder_get_video_codec_element(MMHandleType handle)
2484 {
2485         type_element *telement = NULL;
2486         const char *codec_type_str = NULL;
2487         int codec_type = MM_VIDEO_CODEC_INVALID;
2488         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2489         _MMCamcorderSubContext *sc = NULL;
2490
2491         mmf_return_val_if_fail(hcamcorder, NULL);
2492         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2493
2494         mmf_return_val_if_fail(sc, NULL);
2495
2496         _mmcam_dbg_log("");
2497
2498         /* Check element availability */
2499         mm_camcorder_get_attributes(handle, NULL, MMCAM_VIDEO_ENCODER, &codec_type, NULL);
2500
2501         switch( codec_type )
2502         {
2503                 case MM_VIDEO_CODEC_H263:
2504                         codec_type_str = "H263";
2505                         break;
2506                 case MM_VIDEO_CODEC_H264:
2507                         codec_type_str = "H264";
2508                         break;
2509                 case MM_VIDEO_CODEC_H26L:
2510                         codec_type_str = "H26L";
2511                         break;
2512                 case MM_VIDEO_CODEC_MPEG4:
2513                         codec_type_str = "MPEG4";
2514                         break;
2515                 case MM_VIDEO_CODEC_MPEG1:
2516                         codec_type_str = "MPEG1";
2517                         break;
2518                 case MM_VIDEO_CODEC_THEORA:
2519                         codec_type_str = "THEORA";
2520                         break;
2521                 default:
2522                         _mmcam_dbg_err( "Not supported video codec[%d]", codec_type );
2523                         return NULL;
2524         }
2525
2526         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2527                                       CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
2528                                       codec_type_str,
2529                                       &telement);
2530
2531         return telement;
2532 }
2533
2534
2535 static type_element *
2536 __mmcamcorder_get_image_codec_element(MMHandleType handle)
2537 {
2538         type_element *telement = NULL;
2539         const char *codec_type_str = NULL;
2540         int codec_type = MM_IMAGE_CODEC_INVALID;
2541         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2542         _MMCamcorderSubContext *sc = NULL;
2543
2544         mmf_return_val_if_fail(hcamcorder, NULL);
2545         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2546
2547         mmf_return_val_if_fail(sc, NULL);
2548
2549         _mmcam_dbg_log("");
2550
2551         /* Check element availability */
2552         mm_camcorder_get_attributes(handle, NULL, MMCAM_IMAGE_ENCODER, &codec_type, NULL);
2553
2554         switch( codec_type )
2555         {
2556                 case MM_IMAGE_CODEC_JPEG:
2557                         codec_type_str = "JPEG";
2558                         break;
2559                 case MM_IMAGE_CODEC_SRW:
2560                         codec_type_str = "SRW";
2561                         break;
2562                 case MM_IMAGE_CODEC_JPEG_SRW:
2563                         codec_type_str = "JPEG_SRW";
2564                         break;
2565                 case MM_IMAGE_CODEC_PNG:
2566                         codec_type_str = "PNG";
2567                         break;
2568                 case MM_IMAGE_CODEC_BMP:
2569                         codec_type_str = "BMP";
2570                         break;
2571                 case MM_IMAGE_CODEC_WBMP:
2572                         codec_type_str = "WBMP";
2573                         break;
2574                 case MM_IMAGE_CODEC_TIFF:
2575                         codec_type_str = "TIFF";
2576                         break;
2577                 case MM_IMAGE_CODEC_PCX:
2578                         codec_type_str = "PCX";
2579                         break;
2580                 case MM_IMAGE_CODEC_GIF:
2581                         codec_type_str = "GIF";
2582                         break;
2583                 case MM_IMAGE_CODEC_ICO:
2584                         codec_type_str = "ICO";
2585                         break;
2586                 case MM_IMAGE_CODEC_RAS:
2587                         codec_type_str = "RAS";
2588                         break;
2589                 case MM_IMAGE_CODEC_TGA:
2590                         codec_type_str = "TGA";
2591                         break;
2592                 case MM_IMAGE_CODEC_XBM:
2593                         codec_type_str = "XBM";
2594                         break;
2595                 case MM_IMAGE_CODEC_XPM:
2596                         codec_type_str = "XPM";
2597                         break;
2598                 default:
2599                         _mmcam_dbg_err( "Not supported image codec[%d]", codec_type );
2600                         return NULL;
2601         }
2602
2603         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2604                                       CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
2605                                       codec_type_str,
2606                                       &telement);
2607
2608         return telement;
2609 }
2610
2611
2612 static type_element *
2613 __mmcamcorder_get_file_format_element(MMHandleType handle)
2614 {
2615         type_element *telement = NULL;
2616         const char *mux_type_str = NULL;
2617         int file_type = MM_FILE_FORMAT_INVALID;
2618         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2619         _MMCamcorderSubContext *sc = NULL;
2620
2621         mmf_return_val_if_fail(hcamcorder, NULL);
2622         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2623
2624         mmf_return_val_if_fail(sc, NULL);
2625
2626         _mmcam_dbg_log("");
2627
2628         /* Check element availability */
2629         mm_camcorder_get_attributes(handle, NULL, MMCAM_FILE_FORMAT, &file_type, NULL);
2630
2631         switch( file_type )
2632         {
2633                 case MM_FILE_FORMAT_3GP:
2634                         mux_type_str = "3GP";
2635                         break;
2636                 case MM_FILE_FORMAT_AMR:
2637                         mux_type_str = "AMR";
2638                         break;
2639                 case MM_FILE_FORMAT_MP4:
2640                         mux_type_str = "MP4";
2641                         break;
2642                 case MM_FILE_FORMAT_AAC:
2643                         mux_type_str = "AAC";
2644                         break;
2645                 case MM_FILE_FORMAT_MP3:
2646                         mux_type_str = "MP3";
2647                         break;
2648                 case MM_FILE_FORMAT_OGG:
2649                         mux_type_str = "OGG";
2650                         break;
2651                 case MM_FILE_FORMAT_WAV:
2652                         mux_type_str = "WAV";
2653                         break;
2654                 case MM_FILE_FORMAT_AVI:
2655                         mux_type_str = "AVI";
2656                         break;
2657                 case MM_FILE_FORMAT_WMA:
2658                         mux_type_str = "WMA";
2659                         break;
2660                 case MM_FILE_FORMAT_WMV:
2661                         mux_type_str = "WMV";
2662                         break;
2663                 case MM_FILE_FORMAT_MID:
2664                         mux_type_str = "MID";
2665                         break;
2666                 case MM_FILE_FORMAT_MMF:
2667                         mux_type_str = "MMF";
2668                         break;
2669                 case MM_FILE_FORMAT_MATROSKA:
2670                         mux_type_str = "MATROSKA";
2671                         break;
2672                 case MM_FILE_FORMAT_M2TS:
2673                         mux_type_str = "M2TS";
2674                         break;
2675                 default:
2676                         _mmcam_dbg_err( "Not supported file format[%d]", file_type );
2677                         return NULL;
2678         }
2679
2680         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2681                                       CONFIGURE_CATEGORY_MAIN_MUX,
2682                                       mux_type_str,
2683                                       &telement);
2684
2685         return telement;
2686 }
2687
2688
2689 type_element *
2690 _mmcamcorder_get_type_element(MMHandleType handle, int type)
2691 {
2692         type_element *telement = NULL;
2693
2694         _mmcam_dbg_log("type:%d", type);
2695
2696         switch(type)
2697         {
2698                 case MM_CAM_AUDIO_ENCODER:
2699                         telement = __mmcamcorder_get_audio_codec_element(handle);
2700                         break;
2701                 case MM_CAM_VIDEO_ENCODER:
2702                         telement = __mmcamcorder_get_video_codec_element(handle);
2703                         break;
2704                 case MM_CAM_IMAGE_ENCODER:
2705                         telement = __mmcamcorder_get_image_codec_element(handle);
2706                         break;
2707                 case MM_CAM_FILE_FORMAT:
2708                         telement = __mmcamcorder_get_file_format_element(handle);
2709                         break;
2710                 default :
2711                         _mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
2712         }
2713
2714         return telement;
2715 }
2716
2717
2718 int _mmcamcorder_get_audio_codec_format(MMHandleType handle, const char *name)
2719 {
2720         int codec_index = MM_AUDIO_CODEC_INVALID;
2721
2722         if (!name) {
2723                 _mmcam_dbg_err("name is NULL");
2724                 return MM_AUDIO_CODEC_INVALID;
2725         }
2726
2727         if (!strcmp(name, "AMR")) {
2728                 codec_index = MM_AUDIO_CODEC_AMR;
2729         } else if (!strcmp(name, "G723_1")) {
2730                 codec_index = MM_AUDIO_CODEC_G723_1;
2731         } else if (!strcmp(name, "MP3")) {
2732                 codec_index = MM_AUDIO_CODEC_MP3;
2733         } else if (!strcmp(name, "AAC")) {
2734                 codec_index = MM_AUDIO_CODEC_AAC;
2735         } else if (!strcmp(name, "MMF")) {
2736                 codec_index = MM_AUDIO_CODEC_MMF;
2737         } else if (!strcmp(name, "ADPCM")) {
2738                 codec_index = MM_AUDIO_CODEC_ADPCM;
2739         } else if (!strcmp(name, "WAVE")) {
2740                 codec_index = MM_AUDIO_CODEC_WAVE;
2741         } else if (!strcmp(name, "MIDI")) {
2742                 codec_index = MM_AUDIO_CODEC_MIDI;
2743         } else if (!strcmp(name, "IMELODY")) {
2744                 codec_index = MM_AUDIO_CODEC_IMELODY;
2745         } else if (!strcmp(name, "VORBIS")) {
2746                 codec_index = MM_AUDIO_CODEC_VORBIS;
2747         }
2748
2749         /*_mmcam_dbg_log("audio codec index %d", codec_index);*/
2750
2751         return codec_index;
2752 }
2753
2754
2755
2756 int _mmcamcorder_get_video_codec_format(MMHandleType handle, const char *name)
2757 {
2758         int codec_index = MM_VIDEO_CODEC_INVALID;
2759
2760         if (!name) {
2761                 _mmcam_dbg_err("name is NULL");
2762                 return MM_VIDEO_CODEC_INVALID;
2763         }
2764
2765         if (!strcmp(name, "H263")) {
2766                 codec_index = MM_VIDEO_CODEC_H263;
2767         } else if (!strcmp(name, "H264")) {
2768                 codec_index = MM_VIDEO_CODEC_H264;
2769         } else if (!strcmp(name, "H26L")) {
2770                 codec_index = MM_VIDEO_CODEC_H26L;
2771         } else if (!strcmp(name, "MPEG4")) {
2772                 codec_index = MM_VIDEO_CODEC_MPEG4;
2773         } else if (!strcmp(name, "MPEG1")) {
2774                 codec_index = MM_VIDEO_CODEC_MPEG1;
2775         } else if (!strcmp(name, "THEORA")) {
2776                 codec_index = MM_VIDEO_CODEC_THEORA;
2777         }
2778
2779         /*_mmcam_dbg_log("video codec index %d", codec_index);*/
2780
2781         return codec_index;
2782 }
2783
2784
2785
2786 int _mmcamcorder_get_image_codec_format(MMHandleType handle, const char *name)
2787 {
2788         int codec_index = MM_IMAGE_CODEC_INVALID;
2789
2790         if (!name) {
2791                 _mmcam_dbg_err("name is NULL");
2792                 return MM_IMAGE_CODEC_INVALID;
2793         }
2794
2795         if (!strcmp(name, "JPEG")) {
2796                 codec_index = MM_IMAGE_CODEC_JPEG;
2797         } else if (!strcmp(name, "PNG")) {
2798                 codec_index = MM_IMAGE_CODEC_PNG;
2799         } else if (!strcmp(name, "BMP")) {
2800                 codec_index = MM_IMAGE_CODEC_BMP;
2801         } else if (!strcmp(name, "WBMP")) {
2802                 codec_index = MM_IMAGE_CODEC_WBMP;
2803         } else if (!strcmp(name, "TIFF")) {
2804                 codec_index = MM_IMAGE_CODEC_TIFF;
2805         } else if (!strcmp(name, "PCX")) {
2806                 codec_index = MM_IMAGE_CODEC_PCX;
2807         } else if (!strcmp(name, "GIF")) {
2808                 codec_index = MM_IMAGE_CODEC_GIF;
2809         } else if (!strcmp(name, "ICO")) {
2810                 codec_index = MM_IMAGE_CODEC_ICO;
2811         } else if (!strcmp(name, "RAS")) {
2812                 codec_index = MM_IMAGE_CODEC_RAS;
2813         } else if (!strcmp(name, "TGA")) {
2814                 codec_index = MM_IMAGE_CODEC_TGA;
2815         } else if (!strcmp(name, "XBM")) {
2816                 codec_index = MM_IMAGE_CODEC_XBM;
2817         } else if (!strcmp(name, "XPM")) {
2818                 codec_index = MM_IMAGE_CODEC_XPM;
2819         }
2820
2821         _mmcam_dbg_log("image codec index %d", codec_index);
2822
2823         return codec_index;
2824 }
2825
2826
2827 int _mmcamcorder_get_mux_format(MMHandleType handle, const char *name)
2828 {
2829         int mux_index = MM_FILE_FORMAT_INVALID;
2830
2831         if (!name) {
2832                 _mmcam_dbg_err("name is NULL");
2833                 return MM_FILE_FORMAT_INVALID;
2834         }
2835
2836         if (!strcmp(name, "3GP")) {
2837                 mux_index = MM_FILE_FORMAT_3GP;
2838         } else if (!strcmp(name, "AMR")) {
2839                 mux_index = MM_FILE_FORMAT_AMR;
2840         } else if (!strcmp(name, "MP4")) {
2841                 mux_index = MM_FILE_FORMAT_MP4;
2842         } else if (!strcmp(name, "AAC")) {
2843                 mux_index = MM_FILE_FORMAT_AAC;
2844         } else if (!strcmp(name, "MP3")) {
2845                 mux_index = MM_FILE_FORMAT_MP3;
2846         } else if (!strcmp(name, "OGG")) {
2847                 mux_index = MM_FILE_FORMAT_OGG;
2848         } else if (!strcmp(name, "WAV")) {
2849                 mux_index = MM_FILE_FORMAT_WAV;
2850         } else if (!strcmp(name, "AVI")) {
2851                 mux_index = MM_FILE_FORMAT_AVI;
2852         } else if (!strcmp(name, "WMA")) {
2853                 mux_index = MM_FILE_FORMAT_WMA;
2854         } else if (!strcmp(name, "WMV")) {
2855                 mux_index = MM_FILE_FORMAT_WMV;
2856         } else if (!strcmp(name, "MID")) {
2857                 mux_index = MM_FILE_FORMAT_MID;
2858         } else if (!strcmp(name, "MMF")) {
2859                 mux_index = MM_FILE_FORMAT_MMF;
2860         } else if (!strcmp(name, "MATROSKA")) {
2861                 mux_index = MM_FILE_FORMAT_MATROSKA;
2862         } else if (!strcmp(name, "M2TS")) {
2863                 mux_index = MM_FILE_FORMAT_M2TS;
2864
2865         }
2866
2867         /*_mmcam_dbg_log("mux index %d", mux_index);*/
2868
2869         return mux_index;
2870 }
2871
2872
2873 int
2874 _mmcamcorder_get_format(MMHandleType handle, int conf_category, const char *name)
2875 {
2876         int fmt = -1;
2877
2878         mmf_return_val_if_fail(name, -1);
2879
2880         switch(conf_category)
2881         {
2882                 case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
2883                         fmt = _mmcamcorder_get_audio_codec_format(handle, name);
2884                         break;
2885                 case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
2886                         fmt = _mmcamcorder_get_video_codec_format(handle, name);
2887                         break;
2888                 case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
2889                         fmt = _mmcamcorder_get_image_codec_format(handle, name);
2890                         break;
2891                 case CONFIGURE_CATEGORY_MAIN_MUX:
2892                         fmt = _mmcamcorder_get_mux_format(handle, name);
2893                         break;
2894                 default :
2895                         _mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
2896         }
2897
2898         return fmt;
2899 }
2900
2901 int
2902 _mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int ** format)
2903 {
2904         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2905         camera_conf* configure_info = NULL;
2906         int *arr = NULL;
2907         int total_count = 0;
2908
2909         mmf_return_val_if_fail(hcamcorder, 0);
2910
2911         /*_mmcam_dbg_log("conf_category:%d", conf_category);*/
2912
2913         configure_info = hcamcorder->conf_main;
2914
2915         if (configure_info->info[conf_category]) {
2916                 int i = 0;
2917                 int fmt = 0;
2918                 const char *name = NULL;
2919                 int count = configure_info->info[conf_category]->count;
2920                 conf_detail *info = configure_info->info[conf_category];
2921
2922                 /*_mmcam_dbg_log("count[%d], info[%p]", count, info);*/
2923
2924                 if (count <= 0 || !info) {
2925                         return total_count;
2926                 }
2927
2928                 arr = (int*) g_malloc0(count * sizeof(int));
2929                 if (arr == NULL) {
2930                         _mmcam_dbg_err("malloc failed : %d", count * sizeof(int));
2931                         return 0;
2932                 }
2933
2934                 for (i = 0 ; i < count ; i++) {
2935                         if (info->detail_info[i] == NULL) {
2936                                 continue;
2937                         }
2938
2939                         name = ((type_element*)(info->detail_info[i]))->name;
2940                         fmt = _mmcamcorder_get_format(handle, conf_category, name);
2941                         if (fmt >= 0) {
2942                                 arr[total_count++] = fmt;
2943                         }
2944
2945                         /*_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);*/
2946                 }
2947         }
2948
2949         *format = arr;
2950
2951         return total_count;
2952 }