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 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_x_default = {
 120                 "VideosinkElementX",
 121                 "xvimagesink",
 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                 { "VideosinkElementX",     CONFIGURE_VALUE_ELEMENT,   {&_videosink_element_x_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                 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                 g_free(buffer_string);
 999                 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_FREE( detail_string );
1072                                                 break;
1073                                         }
1074
1075                                         buffer_details[count_details++] = detail_string;
1076                                 }
1077                                 else
1078                                 {
1079                                         SAFE_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_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_FREE( buffer_details[i] );
1183                                 }
1184                         }
1185                 }
1186
1187                 SAFE_FREE(category_name);
1188         }
1189
1190         //(*configure_info) = new_conf;
1191
1192         SAFE_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_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_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_FREE(temp_int_array->name);
1248                                                 SAFE_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_FREE(temp_int_pair_array->name);
1253                                                 SAFE_FREE(temp_int_pair_array->value[0]);
1254                                                 SAFE_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_FREE(temp_string->name);
1259                                                 SAFE_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_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_FREE(temp_string_array->value[k]);
1268                                                         }
1269                                                         g_free(temp_string_array->value);
1270                                                         temp_string_array->value = NULL;
1271                                                 }
1272                                                 SAFE_FREE(temp_string_array->default_value);
1273                                                 break;
1274                                         case CONFIGURE_VALUE_ELEMENT:
1275                                                 temp_element = (type_element2*)(temp_conf->info[i]->detail_info[j]);
1276                                                 SAFE_FREE(temp_element->name);
1277                                                 SAFE_FREE(temp_element->element_name);
1278
1279                                                 if (temp_element->value_int) {
1280                                                         count = temp_element->count_int;
1281                                                         for (k = 0 ; k < count ; k++) {
1282                                                                 SAFE_FREE(temp_element->value_int[k]->name);
1283                                                                 SAFE_FREE(temp_element->value_int[k]);
1284                                                         }
1285                                                         g_free(temp_element->value_int);
1286                                                 }
1287
1288                                                 if (temp_element->value_string) {
1289                                                         count = temp_element->count_string;
1290                                                         for (k = 0 ; k < count ; k++) {
1291                                                                 SAFE_FREE(temp_element->value_string[k]->name);
1292                                                                 SAFE_FREE(temp_element->value_string[k]->value);
1293                                                                 SAFE_FREE(temp_element->value_string[k]);
1294                                                         }
1295                                                         g_free(temp_element->value_string);
1296                                                 }
1297                                                 break;
1298                                         default:
1299                                                 _mmcam_dbg_warn("unknown type %d", type);
1300                                                 break;
1301                                         }
1302                                 }
1303
1304                                 SAFE_FREE(temp_conf->info[i]->detail_info[j]);
1305                                 temp_conf->info[i]->detail_info[j] = NULL;
1306                         }
1307
1308                         SAFE_FREE(temp_conf->info[i]->detail_info);
1309                         temp_conf->info[i]->detail_info = NULL;
1310
1311                         SAFE_FREE(temp_conf->info[i]);
1312                         temp_conf->info[i] = NULL;
1313                 }
1314         }
1315
1316         SAFE_FREE((*configure_info)->info);
1317         SAFE_FREE((*configure_info));
1318
1319         _mmcam_dbg_log("Done.");
1320 }
1321
1322 int _mmcamcorder_conf_get_value_type(MMHandleType handle, int type, int category, const char* name, int* value_type)
1323 {
1324         int i = 0;
1325         int count_value = 0;
1326
1327         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1328
1329         if (hcamcorder == NULL) {
1330                 _mmcam_dbg_err("handle is NULL");
1331                 return FALSE;
1332         }
1333
1334         /*_mmcam_dbg_log( "Entered..." );*/
1335
1336         mmf_return_val_if_fail( name, FALSE );
1337
1338         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
1339         {
1340                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
1341                 return FALSE;
1342         }
1343
1344         /*_mmcam_dbg_log( "Number of value : [%d]", count_value );*/
1345
1346         if( type == CONFIGURE_TYPE_MAIN )
1347         {
1348                 for( i = 0 ; i < count_value ; i++ )
1349                 {
1350                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
1351                         {
1352                                 *value_type = hcamcorder->conf_main_info_table[category][i].value_type;
1353                                 /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
1354                                 return TRUE;
1355                         }
1356                 }
1357         }
1358         else
1359         {
1360                 for( i = 0 ; i < count_value ; i++ )
1361                 {
1362                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
1363                         {
1364                                 *value_type = hcamcorder->conf_ctrl_info_table[category][i].value_type;
1365                                 /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
1366                                 return TRUE;
1367                         }
1368                 }
1369         }
1370
1371         return FALSE;
1372 }
1373
1374
1375 int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details )
1376 {
1377         const int BUFFER_NUM_TOKEN = 256;
1378
1379         int i = 0;
1380         int j = 0;
1381         int count_token;
1382         int value_type;
1383         char *token = NULL;
1384         char *buffer_token[BUFFER_NUM_TOKEN];
1385         char *user_ptr = NULL;
1386
1387         const char *delimiters     = " |=,\t\n";
1388         const char *delimiters_sub = " |\t\n";
1389         const char *delimiters_3rd = "|\n";
1390
1391         mmf_return_val_if_fail( buffer_details, FALSE );
1392
1393         (*info) = (conf_detail*)g_malloc0( sizeof(conf_detail) );
1394         if (*info == NULL) {
1395                 _mmcam_dbg_err("allocation failed");
1396                 return FALSE;
1397         }
1398         (*info)->detail_info = (void**)g_malloc0(sizeof(void*) * count_details);
1399         (*info)->count = count_details;
1400
1401         for ( i = 0 ; i < count_details ; i++ ) {
1402                 /*_mmcam_dbg_log("Read line\"%s\"", buffer_details[i]);*/
1403                 count_token = 0;
1404                 token = strtok_r( buffer_details[i], delimiters, &user_ptr );
1405
1406                 if (token) {
1407                         buffer_token[count_token] = token;
1408                         count_token++;
1409                 } else {
1410                         (*info)->detail_info[i] = NULL;
1411                         _mmcam_dbg_warn( "No token... check it.[%s]", buffer_details[i] );
1412                         continue;
1413                 }
1414
1415                 if (!_mmcamcorder_conf_get_value_type(handle, type, category, buffer_token[0], &value_type)) {
1416                         (*info)->detail_info[i] = NULL;
1417                         _mmcam_dbg_warn( "Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0] );
1418                         continue;
1419                 }
1420
1421                 if (value_type != CONFIGURE_VALUE_STRING && value_type != CONFIGURE_VALUE_STRING_ARRAY) {
1422                         token = strtok_r( NULL, delimiters, &user_ptr );
1423                         while (token) {
1424                                 buffer_token[count_token] = token;
1425                                 /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1426                                 count_token++;
1427                                 token = strtok_r( NULL, delimiters, &user_ptr );
1428                         }
1429
1430                         if (count_token < 2) {
1431                                 (*info)->detail_info[i] = NULL;
1432                                 _mmcam_dbg_warn( "Number of token is too small... check it.[%s]", buffer_details[i] );
1433                                 continue;
1434                         }
1435                 } else { /* CONFIGURE_VALUE_STRING or CONFIGURE_VALUE_STRING_ARRAY */
1436                         /* skip "=" */
1437                         strtok_r( NULL, delimiters_sub, &user_ptr );
1438
1439                         if (value_type == CONFIGURE_VALUE_STRING_ARRAY) {
1440                                 token = strtok_r( NULL, delimiters_sub, &user_ptr );
1441                                 while (token) {
1442                                         buffer_token[count_token] = token;
1443                                         /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1444                                         count_token++;
1445                                         token = strtok_r( NULL, delimiters_sub, &user_ptr );
1446                                 }
1447                         } else { /* CONFIGURE_VALUE_STRING */
1448                                 token = strtok_r( NULL, delimiters_3rd, &user_ptr );
1449                                 if (token) {
1450                                         g_strchug( token );
1451                                         buffer_token[count_token] = token;
1452                                         /*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
1453                                         count_token++;
1454                                 }
1455                         }
1456
1457                         if (count_token < 2) {
1458                                 (*info)->detail_info[i] = NULL;
1459                                 _mmcam_dbg_warn( "No string value... check it.[%s]", buffer_details[i] );
1460                                 continue;
1461                         }
1462                 }
1463
1464                 switch (value_type)
1465                 {
1466                         case CONFIGURE_VALUE_INT:
1467                         {
1468                                 type_int2* new_int;
1469
1470                                 new_int        = (type_int2*)g_malloc0( sizeof(type_int2) );
1471                                 if ( new_int == NULL ) {
1472                                         _mmcam_dbg_err("allocation failed");
1473                                         break;
1474                                 }
1475                                 new_int->name  = get_new_string( buffer_token[0] );
1476                                 new_int->value = atoi( buffer_token[1] );
1477                                 (*info)->detail_info[i] = (void*)new_int;
1478                                 /*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
1479                                 break;
1480                         }
1481                         case CONFIGURE_VALUE_INT_RANGE:
1482                         {
1483                                 type_int_range* new_int_range;
1484
1485                                 new_int_range                = (type_int_range*)g_malloc0( sizeof(type_int_range) );
1486                                 if ( new_int_range == NULL ) {
1487                                         _mmcam_dbg_err("allocation failed");
1488                                         break;
1489                                 }
1490                                 new_int_range->name          = get_new_string( buffer_token[0] );
1491                                 new_int_range->min           = atoi( buffer_token[1] );
1492                                 new_int_range->max           = atoi( buffer_token[2] );
1493                                 new_int_range->default_value = atoi( buffer_token[3] );
1494                                 (*info)->detail_info[i]      = (void*)new_int_range;
1495                                 /*
1496                                 _mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
1497                                                 new_int_range->name,
1498                                                 new_int_range->min,
1499                                                 new_int_range->max,
1500                                                 new_int_range->default_value);
1501                                 */
1502                                 break;
1503                         }
1504                         case CONFIGURE_VALUE_INT_ARRAY:
1505                         {
1506                                 int count_value = count_token - 2;
1507                                 type_int_array* new_int_array;
1508
1509                                 new_int_array = (type_int_array*)g_malloc0( sizeof(type_int_array) );
1510                                 if (new_int_array == NULL) {
1511                                         _mmcam_dbg_err("allocation failed");
1512                                         break;
1513                                 }
1514                                 new_int_array->name = get_new_string( buffer_token[0] );
1515                                 new_int_array->value = (int*)g_malloc0( sizeof(int)*count_value );
1516                                 if (new_int_array->value == NULL) {
1517                                         if (new_int_array->name) {
1518                                                 free(new_int_array->name);
1519                                                 new_int_array->name = NULL;
1520                                         }
1521                                         free(new_int_array);
1522                                         new_int_array = NULL;
1523                                         _mmcam_dbg_err("allocation failed");
1524                                         break;
1525                                 }
1526                                 new_int_array->count = count_value;
1527
1528                                 /*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
1529                                 for ( j = 0 ; j < count_value ; j++ ) {
1530                                         new_int_array->value[j] = atoi( buffer_token[j+1] );
1531                                         /*_mmcam_dbg_log("   index[%d] - value[%d]", j, new_int_array->value[j]);*/
1532                                 }
1533
1534                                 new_int_array->default_value = atoi( buffer_token[count_token-1] );
1535                                 /*_mmcam_dbg_log("   default value[%d]", new_int_array->default_value);*/
1536
1537                                 (*info)->detail_info[i] = (void*)new_int_array;
1538                                 break;
1539                         }
1540                         case CONFIGURE_VALUE_INT_PAIR_ARRAY:
1541                         {
1542                                 int count_value = ( count_token - 3 ) >> 1;
1543                                 type_int_pair_array* new_int_pair_array;
1544
1545                                 new_int_pair_array = (type_int_pair_array*)g_malloc0( sizeof(type_int_pair_array) );
1546                                 if ( new_int_pair_array == NULL ) {
1547                                         _mmcam_dbg_err("allocation failed");
1548                                         break;
1549                                 }
1550                                 new_int_pair_array->name     = get_new_string( buffer_token[0] );
1551                                 new_int_pair_array->value[0] = (int*)g_malloc( sizeof(int)*(count_value) );
1552                                 if ( new_int_pair_array->value[0] == NULL ) {
1553                                         if (new_int_pair_array->name) {
1554                                                 free( new_int_pair_array->name );
1555                                                 new_int_pair_array->name = NULL;
1556                                         }
1557                                         g_free( new_int_pair_array );
1558                                         new_int_pair_array = NULL;
1559                                         _mmcam_dbg_err("allocation failed");
1560                                         break;
1561                                 }
1562                                 new_int_pair_array->value[1] = (int*)g_malloc( sizeof(int)*(count_value) );
1563                                 if ( new_int_pair_array->value[1] == NULL ) {
1564                                         g_free( new_int_pair_array->value[0] );
1565                                         new_int_pair_array->value[0] = NULL;
1566                                         if (new_int_pair_array->name) {
1567                                                 free( new_int_pair_array->name );
1568                                                 new_int_pair_array->name = NULL;
1569                                         }
1570                                         g_free( new_int_pair_array );
1571                                         new_int_pair_array = NULL;
1572                                         _mmcam_dbg_err("allocation failed");
1573                                         break;
1574                                 }
1575                                 new_int_pair_array->count    = count_value;
1576
1577                                 /*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
1578                                 for ( j = 0 ; j < count_value ; j++ ) {
1579                                         new_int_pair_array->value[0][j] = atoi( buffer_token[(j<<1)+1] );
1580                                         new_int_pair_array->value[1][j] = atoi( buffer_token[(j<<1)+2] );
1581                                         /*
1582                                         _mmcam_dbg_log("   index[%d] - value[%d,%d]", j,
1583                                                         new_int_pair_array->value[0][j],
1584                                                         new_int_pair_array->value[1][j]);
1585                                         */
1586                                 }
1587
1588                                 new_int_pair_array->default_value[0] = atoi( buffer_token[count_token-2] );
1589                                 new_int_pair_array->default_value[1] = atoi( buffer_token[count_token-1] );
1590                                 /*
1591                                 _mmcam_dbg_log("   default value[%d,%d]",
1592                                                 new_int_pair_array->default_value[0],
1593                                                 new_int_pair_array->default_value[1]);
1594                                 */
1595                                 (*info)->detail_info[i] = (void*)new_int_pair_array;
1596                                 break;
1597                         }
1598                         case CONFIGURE_VALUE_STRING:
1599                         {
1600                                 type_string2* new_string;
1601
1602                                 new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
1603                                 if (new_string == NULL) {
1604                                         _mmcam_dbg_err("allocation failed");
1605                                         break;
1606                                 }
1607                                 new_string->name  = get_new_string( buffer_token[0] );
1608                                 new_string->value = get_new_string( buffer_token[1] );
1609                                 (*info)->detail_info[i] = (void*)new_string;
1610
1611                                 /*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
1612                                 break;
1613                         }
1614                         case CONFIGURE_VALUE_STRING_ARRAY:
1615                         {
1616                                 int count_value = count_token - 2;
1617                                 type_string_array* new_string_array;
1618
1619                                 new_string_array = (type_string_array*)g_malloc0( sizeof(type_string_array) );
1620                                 if ( new_string_array == NULL ) {
1621                                         break;
1622                                 }
1623                                 new_string_array->name  = get_new_string( buffer_token[0] );
1624                                 new_string_array->count = count_value;
1625                                 new_string_array->value = (char**)g_malloc0( sizeof(char*)*count_value );
1626                                 if ( new_string_array->value == NULL ) {
1627                                         if (new_string_array->name) {
1628                                                 free(new_string_array->name);
1629                                                 new_string_array->name = NULL;
1630                                         }
1631                                         free(new_string_array);
1632                                         new_string_array = NULL;
1633                                         _mmcam_dbg_err("allocation failed");
1634                                         break;
1635                                 }
1636                                 /*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
1637                                 for ( j = 0 ; j < count_value ; j++ ) {
1638                                         new_string_array->value[j] = get_new_string( buffer_token[j+1] );
1639                                         /*_mmcam_dbg_log("   index[%d] - value[%s]", j, new_string_array->value[j]);*/
1640                                 }
1641
1642                                 new_string_array->default_value = get_new_string( buffer_token[count_token-1] );
1643                                 /*_mmcam_dbg_log("   default value[%s]", new_string_array->default_value);*/
1644                                 (*info)->detail_info[i] = (void*)new_string_array;
1645                                 break;
1646                         }
1647                         case CONFIGURE_VALUE_ELEMENT:
1648                         {
1649                                 type_element2* new_element;
1650
1651                                 new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
1652                                 if ( new_element == NULL ) {
1653                                         _mmcam_dbg_err("allocation failed");
1654                                         break;
1655                                 }
1656                                 new_element->name         = get_new_string( buffer_token[0] );
1657                                 new_element->element_name = get_new_string( buffer_token[1] );
1658                                 new_element->count_int    = atoi( buffer_token[2] );
1659                                 new_element->value_int    = NULL;
1660                                 new_element->count_string = atoi( buffer_token[3] );
1661                                 new_element->value_string = NULL;
1662                                 /*
1663                                 _mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
1664                                                new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
1665                                 */
1666
1667                                 /* add int values */
1668                                 if ( new_element->count_int > 0 && new_element->count_int <= 30 ) {
1669                                         new_element->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
1670                                         if ( new_element->value_int) {
1671                                                 for ( j = 0 ; j < new_element->count_int ; j++ ) {
1672                                                         new_element->value_int[j]        = (type_int2*)g_malloc( sizeof(type_int2) );
1673                                                         if ( new_element->value_int[j] ) {
1674                                                                 new_element->value_int[j]->name  = get_new_string( buffer_token[4+(j<<1)] );
1675                                                                 new_element->value_int[j]->value = atoi( buffer_token[5+(j<<1)] );
1676                                                         } else {
1677                                                                 _mmcam_dbg_err("allocation failed");
1678                                                         }
1679                                                         /*
1680                                                         _mmcam_dbg_log("   Element INT[%d] - name[%s],value[%d]",
1681                                                                        j, new_element->value_int[j]->name, new_element->value_int[j]->value);
1682                                                         */
1683                                                 }
1684                                         } else {
1685                                                 _mmcam_dbg_err("allocation failed");
1686                                         }
1687                                 }
1688                                 else
1689                                 {
1690                                         _mmcam_dbg_err("invalid count - %d", new_element->count_int);
1691                                         new_element->value_int = NULL;
1692                                 }
1693
1694                                 /* add string values */
1695                                 if ( new_element->count_string > 0 && new_element->count_string <= 30 &&
1696                                      new_element->count_int >= 0 && new_element->count_int <= 30 ) {
1697                                         new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_string) );
1698                                         if (new_element->value_string) {
1699                                                 for ( ; j < new_element->count_string + new_element->count_int ; j++ ) {
1700                                                         new_element->value_string[j-new_element->count_int]     = (type_string2*)g_malloc0( sizeof(type_string2) );
1701                                                         if(new_element->value_string[j-new_element->count_int]) {
1702                                                                 new_element->value_string[j-new_element->count_int]->name       = get_new_string( buffer_token[4+(j<<1)] );
1703                                                                 new_element->value_string[j-new_element->count_int]->value      = get_new_string( buffer_token[5+(j<<1)] );
1704                                                                 /*
1705                                                                 _mmcam_dbg_log("   Element STRING[%d] - name[%s],value[%s]",
1706                                                                                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);
1707                                                                 */
1708                                                         } else {
1709                                                                 _mmcam_dbg_err("allocation failed");
1710                                                         }
1711                                                 }
1712                                         } else {
1713                                                 _mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
1714                                         }
1715                                 } else {
1716                                         _mmcam_dbg_err("invalid count - %d", new_element->count_string);
1717                                         new_element->value_string = NULL;
1718                                 }
1719
1720                                 (*info)->detail_info[i] = (void*)new_element;
1721                                 break;
1722                         }
1723                         default:
1724                                 break;
1725                 }
1726         }
1727
1728         return TRUE;
1729 }
1730
1731
1732 int _mmcamcorder_conf_get_value_int(MMHandleType handle, camera_conf* configure_info, int category, const char* name, int* value)
1733 {
1734         int i, count;
1735         conf_detail* info;
1736
1737         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1738
1739         mmf_return_val_if_fail( configure_info, FALSE );
1740         mmf_return_val_if_fail( name, FALSE );
1741
1742         if( configure_info->info[category] )
1743         {
1744                 count = configure_info->info[category]->count;
1745                 info = configure_info->info[category];
1746
1747                 for( i = 0 ; i < count ; i++ )
1748                 {
1749                         if( info->detail_info[i] == NULL )
1750                         {
1751                                 continue;
1752                         }
1753
1754                         if( !strcmp( ((type_int*)(info->detail_info[i]))->name , name ) )
1755                         {
1756                                 *value = ((type_int*)(info->detail_info[i]))->value;
1757                                 //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
1758                                 return TRUE;
1759                         }
1760                 }
1761         }
1762
1763         if( _mmcamcorder_conf_get_default_value_int( handle, configure_info->type, category, name, value ) )
1764         {
1765                 //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
1766                 return TRUE;
1767         }
1768
1769         _mmcam_dbg_warn( "Faild to get int... check it...Category[%d],Name[%s]", category, name );
1770
1771         return FALSE;
1772 }
1773
1774 int
1775 _mmcamcorder_conf_get_value_int_range( camera_conf* configure_info, int category, const char* name, type_int_range** value )
1776 {
1777         int i, count;
1778         conf_detail* info;
1779
1780         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1781
1782         mmf_return_val_if_fail( configure_info, FALSE );
1783         mmf_return_val_if_fail( name, FALSE );
1784
1785         if( configure_info->info[category] )
1786         {
1787                 count = configure_info->info[category]->count;
1788                 info = configure_info->info[category];
1789
1790                 for( i = 0 ; i < count ; i++ )
1791                 {
1792                         if( info->detail_info[i] == NULL )
1793                         {
1794                                 continue;
1795                         }
1796
1797                         if( !strcmp( ((type_int_range*)(info->detail_info[i]))->name , name ) )
1798                         {
1799                                 *value = (type_int_range*)(info->detail_info[i]);
1800                                 /*
1801                                 _mmcam_dbg_log( "Get[%s] int range - min[%d],max[%d],default[%d]",
1802                                                 name, (*value)->min, (*value)->max, (*value)->default_value );
1803                                 */
1804                                 return TRUE;
1805                         }
1806                 }
1807         }
1808
1809         *value = NULL;
1810
1811         /*_mmcam_dbg_warn( "Faild to get int range... check it...Category[%d],Name[%s]", category, name );*/
1812
1813         return FALSE;
1814 }
1815
1816 int
1817 _mmcamcorder_conf_get_value_int_array( camera_conf* configure_info, int category, const char* name, type_int_array** value )
1818 {
1819         int i, count;
1820         conf_detail* info;
1821
1822         /*_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );*/
1823
1824         mmf_return_val_if_fail( configure_info, FALSE );
1825         mmf_return_val_if_fail( name, FALSE );
1826
1827         if( configure_info->info[category] )
1828         {
1829                 count   = configure_info->info[category]->count;
1830                 info    = configure_info->info[category];
1831
1832                 for( i = 0 ; i < count ; i++ )
1833                 {
1834                         if( info->detail_info[i] == NULL )
1835                         {
1836                                 continue;
1837                         }
1838
1839                         if( !strcmp( ((type_int_array*)(info->detail_info[i]))->name , name ) )
1840                         {
1841                                 *value = (type_int_array*)(info->detail_info[i]);
1842                                 /*
1843                                 _mmcam_dbg_log( "Get[%s] int array - [%x],count[%d],default[%d]",
1844                                                 name, (*value)->value, (*value)->count, (*value)->default_value );
1845                                 */
1846                                 return TRUE;
1847                         }
1848                 }
1849         }
1850
1851         *value = NULL;
1852
1853         /*_mmcam_dbg_warn( "Faild to get int array... check it...Category[%d],Name[%s]", category, name );*/
1854
1855         return FALSE;
1856 }
1857
1858 int
1859 _mmcamcorder_conf_get_value_int_pair_array( camera_conf* configure_info, int category, const char* name, type_int_pair_array** value )
1860 {
1861         int i, count;
1862         conf_detail* info;
1863
1864         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1865
1866         mmf_return_val_if_fail( configure_info, FALSE );
1867         mmf_return_val_if_fail( name, FALSE );
1868
1869         if( configure_info->info[category] )
1870         {
1871                 count = configure_info->info[category]->count;
1872                 info = configure_info->info[category];
1873
1874                 for( i = 0 ; i < count ; i++ )
1875                 {
1876                         if( info->detail_info[i] == NULL )
1877                         {
1878                                 continue;
1879                         }
1880
1881                         if( !strcmp( ((type_int_pair_array*)(info->detail_info[i]))->name , name ) )
1882                         {
1883                                 *value = (type_int_pair_array*)(info->detail_info[i]);
1884                                 /*
1885                                 _mmcam_dbg_log( "Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
1886                                                 name, (*value)->value[0], (*value)->value[1], (*value)->count,
1887                                                 (*value)->default_value[0], (*value)->default_value[1] );
1888                                 */
1889                                 return TRUE;
1890                         }
1891                 }
1892         }
1893
1894         *value = NULL;
1895
1896         _mmcam_dbg_warn( "Faild to get int pair array... check it...Category[%d],Name[%s]", category, name );
1897
1898         return FALSE;
1899 }
1900
1901 int _mmcamcorder_conf_get_value_string(MMHandleType handle, camera_conf* configure_info, int category, const char* name, const char** value)
1902 {
1903         int i, count;
1904         conf_detail* info;
1905
1906         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1907
1908         mmf_return_val_if_fail( configure_info, FALSE );
1909         mmf_return_val_if_fail( name, FALSE );
1910
1911         if( configure_info->info[category] )
1912         {
1913                 count = configure_info->info[category]->count;
1914                 info = configure_info->info[category];
1915
1916                 for( i = 0 ; i < count ; i++ )
1917                 {
1918                         if( info->detail_info[i] == NULL )
1919                         {
1920                                 continue;
1921                         }
1922
1923                         if( !strcmp( ((type_string*)(info->detail_info[i]))->name , name ) )
1924                         {
1925                                 *value = ((type_string*)(info->detail_info[i]))->value;
1926                                 //_mmcam_dbg_log( "Get[%s] string[%s]", name, *value );
1927                                 return TRUE;
1928                         }
1929                 }
1930         }
1931
1932         if( _mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value ) )
1933         {
1934                 //_mmcam_dbg_log( "Get[%s]string[%s]", name, *value );
1935                 return TRUE;
1936         }
1937
1938         _mmcam_dbg_warn( "Faild to get string... check it...Category[%d],Name[%s]", category, name );
1939
1940         return FALSE;
1941 }
1942
1943 int
1944 _mmcamcorder_conf_get_value_string_array( camera_conf* configure_info, int category, const char* name, type_string_array** value )
1945 {
1946         int i, count;
1947         conf_detail* info;
1948
1949         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1950
1951         mmf_return_val_if_fail( configure_info, FALSE );
1952         mmf_return_val_if_fail( name, FALSE );
1953
1954         if( configure_info->info[category] )
1955         {
1956                 count = configure_info->info[category]->count;
1957                 info = configure_info->info[category];
1958
1959                 for( i = 0 ; i < count ; i++ )
1960                 {
1961                         if( info->detail_info[i] == NULL )
1962                         {
1963                                 continue;
1964                         }
1965
1966                         if( !strcmp( ((type_string_array*)(info->detail_info[i]))->name , name ) )
1967                         {
1968                                 *value = (type_string_array*)(info->detail_info[i]);
1969                                 /*
1970                                 _mmcam_dbg_log( "Get[%s] string array - [%x],count[%d],default[%s]",
1971                                                 name, (*value)->value, (*value)->count, (*value)->default_value );
1972                                 */
1973                                 return TRUE;
1974                         }
1975                 }
1976         }
1977
1978         *value = NULL;
1979
1980         /*_mmcam_dbg_warn( "Faild to get string array... check it...Category[%d],Name[%s]", category, name );*/
1981
1982         return FALSE;
1983 }
1984
1985 int _mmcamcorder_conf_get_element(MMHandleType handle, camera_conf* configure_info, int category, const char* name, type_element** element)
1986 {
1987         int i, count;
1988         conf_detail* info;
1989
1990         //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
1991
1992         mmf_return_val_if_fail( configure_info, FALSE );
1993         mmf_return_val_if_fail( name, FALSE );
1994
1995         if( configure_info->info[category] )
1996         {
1997                 count = configure_info->info[category]->count;
1998                 info = configure_info->info[category];
1999
2000                 for( i = 0 ; i < count ; i++ )
2001                 {
2002                         if( info->detail_info[i] == NULL )
2003                         {
2004                                 continue;
2005                         }
2006
2007                         if( !strcmp( ((type_element*)(info->detail_info[i]))->name , name ) )
2008                         {
2009                                 *element = (type_element*)(info->detail_info[i]);
2010                                 //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
2011                                 return TRUE;
2012                         }
2013                 }
2014         }
2015
2016         if( _mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element ) )
2017         {
2018                 //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
2019                 return TRUE;
2020         }
2021
2022         _mmcam_dbg_warn( "Faild to get element name... check it...Category[%d],Name[%s]", category, name );
2023
2024         return FALSE;
2025 }
2026
2027 int
2028 _mmcamcorder_conf_get_value_element_name( type_element* element, const char** value )
2029 {
2030         //_mmcam_dbg_log( "Entered..." );
2031
2032         mmf_return_val_if_fail( element, FALSE );
2033
2034         *value = element->element_name;
2035
2036         //_mmcam_dbg_log( "Get element name : [%s]", *value );
2037
2038         return TRUE;
2039 }
2040
2041 int
2042 _mmcamcorder_conf_get_value_element_int( type_element* element, const char* name, int* value )
2043 {
2044         int i;
2045
2046         //_mmcam_dbg_log( "Entered..." );
2047
2048         mmf_return_val_if_fail( element, FALSE );
2049         mmf_return_val_if_fail( name, FALSE );
2050
2051         for( i = 0 ; i < element->count_int ; i++ )
2052         {
2053                 if( !strcmp( element->value_int[i]->name , name ) )
2054                 {
2055                         *value = element->value_int[i]->value;
2056                         //_mmcam_dbg_log( "Get[%s] element int[%d]", name, *value );
2057                         return TRUE;
2058                 }
2059         }
2060
2061         _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
2062                 element->name, name, element->count_int );
2063
2064         return FALSE;
2065 }
2066
2067 int
2068 _mmcamcorder_conf_get_value_element_string( type_element* element, const char* name, const char** value )
2069 {
2070         int i;
2071
2072         //_mmcam_dbg_log( "Entered..." );
2073
2074         mmf_return_val_if_fail( element, FALSE );
2075         mmf_return_val_if_fail( name, FALSE );
2076
2077         for( i = 0 ; i < element->count_string ; i++ )
2078         {
2079                 if( !strcmp( element->value_string[i]->name , name ) )
2080                 {
2081                         *value = element->value_string[i]->value;
2082                         //_mmcam_dbg_log( "Get[%s] element string[%s]", name, *value );
2083                         return TRUE;
2084                 }
2085         }
2086
2087         _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
2088                 element->name, name, element->count_string );
2089
2090         return FALSE;
2091 }
2092
2093 int
2094 _mmcamcorder_conf_set_value_element_property( GstElement* gst, type_element* element )
2095 {
2096         int i;
2097
2098         //_mmcam_dbg_log( "Entered..." );
2099
2100         mmf_return_val_if_fail( gst, FALSE );
2101         mmf_return_val_if_fail( element, FALSE );
2102
2103         if( element->count_int == 0 )
2104         {
2105                 /*_mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );*/
2106         }
2107         else
2108         {
2109                 if( element->value_int == NULL )
2110                 {
2111                         _mmcam_dbg_warn( "count_int[%d] is NOT zero, but value_int is NULL", element->count_int );
2112                         return FALSE;
2113                 }
2114
2115                 for( i = 0 ; i < element->count_int ; i++ )
2116                 {
2117                         MMCAMCORDER_G_OBJECT_SET( gst, element->value_int[i]->name, element->value_int[i]->value );
2118
2119                         /*
2120                         _mmcam_dbg_log( "Element[%s] Set[%s] -> integer[%d]",
2121                                 element->element_name,
2122                                 element->value_int[i]->name,
2123                                 element->value_int[i]->value );
2124                                 */
2125                 }
2126         }
2127
2128         if( element->count_string == 0 )
2129         {
2130                 _mmcam_dbg_log( "There is no string property to set in INI file[%s].", element->name );
2131         }
2132         else
2133         {
2134                 if( element->value_string == NULL )
2135                 {
2136                         _mmcam_dbg_warn( "count_string[%d] is NOT zero, but value_string is NULL", element->count_string );
2137                         return FALSE;
2138                 }
2139
2140                 for( i = 0 ; i < element->count_string ; i++ )
2141                 {
2142                         MMCAMCORDER_G_OBJECT_SET_POINTER( gst, element->value_string[i]->name, element->value_string[i]->value );
2143
2144                         _mmcam_dbg_log( "Element[%s] Set[%s] -> string[%s]",
2145                                 element->element_name,
2146                                 element->value_string[i]->name,
2147                                 element->value_string[i]->value );
2148                 }
2149         }
2150
2151         //_mmcam_dbg_log( "Done." );
2152
2153         return TRUE;
2154 }
2155
2156 int
2157 _mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value )
2158 {
2159         int i = 0;
2160         int count_value = 0;
2161
2162         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2163
2164         if (hcamcorder == NULL) {
2165                 _mmcam_dbg_err("handle is NULL");
2166                 return FALSE;
2167         }
2168
2169         //_mmcam_dbg_log( "Entered..." );
2170
2171         mmf_return_val_if_fail( name, FALSE );
2172
2173         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2174         {
2175                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2176                 return FALSE;
2177         }
2178
2179         if( type == CONFIGURE_TYPE_MAIN )
2180         {
2181                 for( i = 0 ; i < count_value ; i++ )
2182                 {
2183                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2184                         {
2185                                 *value = hcamcorder->conf_main_info_table[category][i].value_int;
2186                                 return TRUE;
2187                         }
2188                 }
2189         }
2190         else
2191         {
2192                 for( i = 0 ; i < count_value ; i++ )
2193                 {
2194                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2195                         {
2196                                 *value = hcamcorder->conf_ctrl_info_table[category][i].value_int;
2197                                 return TRUE;
2198                         }
2199                 }
2200         }
2201
2202         _mmcam_dbg_warn( "Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2203
2204         return FALSE;
2205 }
2206
2207 int _mmcamcorder_conf_get_default_value_string(MMHandleType handle, int type, int category, const char* name, const char** value)
2208 {
2209         int i = 0;
2210         int count_value = 0;
2211
2212         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2213
2214         if (hcamcorder == NULL) {
2215                 _mmcam_dbg_err("handle is NULL");
2216                 return FALSE;
2217         }
2218
2219         //_mmcam_dbg_log( "Entered..." );
2220
2221         mmf_return_val_if_fail( name, FALSE );
2222
2223         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2224         {
2225                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2226                 return FALSE;
2227         }
2228
2229         if( type == CONFIGURE_TYPE_MAIN )
2230         {
2231                 for( i = 0 ; i < count_value ; i++ )
2232                 {
2233                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2234                         {
2235                                 *value = hcamcorder->conf_main_info_table[category][i].value_string;
2236                                 _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
2237                                 return TRUE;
2238                         }
2239                 }
2240         }
2241         else
2242         {
2243                 for( i = 0 ; i < count_value ; i++ )
2244                 {
2245                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2246                         {
2247                                 *value = hcamcorder->conf_ctrl_info_table[category][i].value_string;
2248                                 _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
2249                                 return TRUE;
2250                         }
2251                 }
2252         }
2253
2254         _mmcam_dbg_warn( "Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2255
2256         return FALSE;
2257 }
2258
2259 int _mmcamcorder_conf_get_default_element(MMHandleType handle, int type, int category, const char* name, type_element** element)
2260 {
2261         int i = 0;
2262         int count_value = 0;
2263
2264         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2265
2266         if (hcamcorder == NULL) {
2267                 _mmcam_dbg_err("handle is NULL");
2268                 return FALSE;
2269         }
2270
2271         //_mmcam_dbg_log( "Entered..." );
2272
2273         mmf_return_val_if_fail( name, FALSE );
2274
2275         if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
2276         {
2277                 _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
2278                 return FALSE;
2279         }
2280
2281         if( type == CONFIGURE_TYPE_MAIN )
2282         {
2283                 for( i = 0 ; i < count_value ; i++ )
2284                 {
2285                         if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
2286                         {
2287                                 *element = hcamcorder->conf_main_info_table[category][i].value_element;
2288                                 _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
2289                                 return TRUE;
2290                         }
2291                 }
2292         }
2293         else
2294         {
2295                 for( i = 0 ; i < count_value ; i++ )
2296                 {
2297                         if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
2298                         {
2299                                 *element = hcamcorder->conf_ctrl_info_table[category][i].value_element;
2300                                 _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
2301                                 return TRUE;
2302                         }
2303                 }
2304         }
2305
2306         _mmcam_dbg_warn( "Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
2307
2308         return FALSE;
2309 }
2310
2311 int _mmcamcorder_conf_get_category_size(MMHandleType handle, int type, int category, int* size)
2312 {
2313         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2314
2315         if (hcamcorder == NULL) {
2316                 _mmcam_dbg_err("handle is NULL");
2317                 return FALSE;
2318         }
2319
2320 //      mmf_return_val_if_fail( conf_main_category_size, FALSE );
2321 //      mmf_return_val_if_fail( conf_ctrl_category_size, FALSE );
2322
2323         if( type == CONFIGURE_TYPE_MAIN )
2324         {
2325                 mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE );
2326
2327                 *size = (int)hcamcorder->conf_main_category_size[category];
2328         }
2329         else
2330         {
2331                 mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE );
2332
2333                 *size = (int)hcamcorder->conf_ctrl_category_size[category];
2334         }
2335
2336         return TRUE;
2337 }
2338
2339 void
2340 _mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info )
2341 {
2342         int i, j, k, type, category_type;
2343
2344         type_int                *temp_int;
2345         type_int_range          *temp_int_range;
2346         type_int_array          *temp_int_array;
2347         type_int_pair_array     *temp_int_pair_array;
2348         type_string             *temp_string;
2349         type_element            *temp_element;
2350
2351         g_print( "[ConfigureInfoPrint] : Entered.\n" );
2352
2353         mmf_return_if_fail( *configure_info );
2354
2355         if( (*configure_info)->type == CONFIGURE_TYPE_MAIN )
2356         {
2357                 category_type = CONFIGURE_CATEGORY_MAIN_NUM;
2358         }
2359         else
2360         {
2361                 category_type = CONFIGURE_CATEGORY_CTRL_NUM;
2362         }
2363
2364         for( i = 0 ; i < category_type ; i++ )
2365         {
2366                 if( (*configure_info)->info[i] )
2367                 {
2368                         g_print( "[ConfigureInfo] : Category [%d]\n", i );
2369                         for( j = 0 ; j < (*configure_info)->info[i]->count ; j++ )
2370                         {
2371                                 if( _mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type ) )
2372                                 {
2373                                         switch( type )
2374                                         {
2375                                                 case CONFIGURE_VALUE_INT:
2376                                                         temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
2377                                                         g_print( "[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value );
2378                                                         break;
2379                                                 case CONFIGURE_VALUE_INT_RANGE:
2380                                                         temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
2381                                                         g_print( "[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
2382                                                                  temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value );
2383                                                         break;
2384                                                 case CONFIGURE_VALUE_INT_ARRAY:
2385                                                         temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
2386                                                         g_print( "[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n                            - ",
2387                                                                  temp_int_array->name, temp_int_array->default_value );
2388                                                         for( k = 0 ; k < temp_int_array->count ; k++ )
2389                                                         {
2390                                                                 g_print( "[%d] ", temp_int_array->value[k] );
2391                                                         }
2392                                                         g_print( "\n" );
2393                                                         break;
2394                                                 case CONFIGURE_VALUE_INT_PAIR_ARRAY:
2395                                                         temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
2396                                                         g_print( "[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n                            - ",
2397                                                                  temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0] );
2398                                                         for( k = 0 ; k < temp_int_pair_array->count ; k++ )
2399                                                         {
2400                                                                 g_print( "[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k] );
2401                                                         }
2402                                                         g_print( "\n" );
2403                                                         break;
2404                                                 case CONFIGURE_VALUE_STRING:
2405                                                         temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
2406                                                         g_print( "[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value );
2407                                                         break;
2408                                                 case CONFIGURE_VALUE_ELEMENT:
2409                                                         temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
2410                                                         g_print( "[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name );
2411                                                         for( k = 0 ; k < temp_element->count_int ; k++ )
2412                                                         {
2413                                                                 g_print( "                          - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value );
2414                                                         }
2415                                                         for( k = 0 ; k < temp_element->count_string ; k++ )
2416                                                         {
2417                                                                 g_print( "                          - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value );
2418                                                         }
2419                                                         break;
2420                                                 default:
2421                                                         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 );
2422                                                         break;
2423                                         }
2424                                 }
2425                                 else
2426                                 {
2427                                         g_print( "[ConfigureInfo] : Failed to get value type." );
2428                                 }
2429                         }
2430                 }
2431         }
2432
2433         g_print( "[ConfigureInfoPrint] : Done.\n" );
2434 }
2435
2436
2437 static type_element *
2438 __mmcamcorder_get_audio_codec_element(MMHandleType handle)
2439 {
2440         type_element *telement = NULL;
2441         const char *codec_type_str = NULL;
2442         int codec_type = MM_AUDIO_CODEC_INVALID;
2443         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2444         _MMCamcorderSubContext *sc = NULL;
2445
2446         mmf_return_val_if_fail(hcamcorder, NULL);
2447         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2448
2449         mmf_return_val_if_fail(sc, NULL);
2450
2451         _mmcam_dbg_log("");
2452
2453         /* Check element availability */
2454         mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &codec_type, NULL);
2455
2456         switch( codec_type )
2457         {
2458                 case MM_AUDIO_CODEC_AMR:
2459                         codec_type_str = "AMR";
2460                         break;
2461                 case MM_AUDIO_CODEC_G723_1:
2462                         codec_type_str = "G723_1";
2463                         break;
2464                 case MM_AUDIO_CODEC_MP3:
2465                         codec_type_str = "MP3";
2466                         break;
2467                 case MM_AUDIO_CODEC_AAC:
2468                         codec_type_str = "AAC";
2469                         break;
2470                 case MM_AUDIO_CODEC_MMF:
2471                         codec_type_str = "MMF";
2472                         break;
2473                 case MM_AUDIO_CODEC_ADPCM:
2474                         codec_type_str = "ADPCM";
2475                         break;
2476                 case MM_AUDIO_CODEC_WAVE:
2477                         codec_type_str = "WAVE";
2478                         break;
2479                 case MM_AUDIO_CODEC_MIDI:
2480                         codec_type_str = "MIDI";
2481                         break;
2482                 case MM_AUDIO_CODEC_IMELODY:
2483                         codec_type_str = "IMELODY";
2484                         break;
2485                 case MM_AUDIO_CODEC_VORBIS:
2486                         codec_type_str = "VORBIS";
2487                         break;
2488                 default:
2489                         _mmcam_dbg_err( "Not supported audio codec[%d]", codec_type );
2490                         return NULL;
2491         }
2492
2493         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2494                                       CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
2495                                       codec_type_str,
2496                                       &telement);
2497
2498         return telement;
2499 }
2500
2501
2502 static type_element *
2503 __mmcamcorder_get_video_codec_element(MMHandleType handle)
2504 {
2505         type_element *telement = NULL;
2506         const char *codec_type_str = NULL;
2507         int codec_type = MM_VIDEO_CODEC_INVALID;
2508         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2509         _MMCamcorderSubContext *sc = NULL;
2510
2511         mmf_return_val_if_fail(hcamcorder, NULL);
2512         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2513
2514         mmf_return_val_if_fail(sc, NULL);
2515
2516         _mmcam_dbg_log("");
2517
2518         /* Check element availability */
2519         mm_camcorder_get_attributes(handle, NULL, MMCAM_VIDEO_ENCODER, &codec_type, NULL);
2520
2521         switch( codec_type )
2522         {
2523                 case MM_VIDEO_CODEC_H263:
2524                         codec_type_str = "H263";
2525                         break;
2526                 case MM_VIDEO_CODEC_H264:
2527                         codec_type_str = "H264";
2528                         break;
2529                 case MM_VIDEO_CODEC_H26L:
2530                         codec_type_str = "H26L";
2531                         break;
2532                 case MM_VIDEO_CODEC_MPEG4:
2533                         codec_type_str = "MPEG4";
2534                         break;
2535                 case MM_VIDEO_CODEC_MPEG1:
2536                         codec_type_str = "MPEG1";
2537                         break;
2538                 case MM_VIDEO_CODEC_THEORA:
2539                         codec_type_str = "THEORA";
2540                         break;
2541                 default:
2542                         _mmcam_dbg_err( "Not supported video codec[%d]", codec_type );
2543                         return NULL;
2544         }
2545
2546         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2547                                       CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
2548                                       codec_type_str,
2549                                       &telement);
2550
2551         return telement;
2552 }
2553
2554
2555 static type_element *
2556 __mmcamcorder_get_image_codec_element(MMHandleType handle)
2557 {
2558         type_element *telement = NULL;
2559         const char *codec_type_str = NULL;
2560         int codec_type = MM_IMAGE_CODEC_INVALID;
2561         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2562         _MMCamcorderSubContext *sc = NULL;
2563
2564         mmf_return_val_if_fail(hcamcorder, NULL);
2565         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2566
2567         mmf_return_val_if_fail(sc, NULL);
2568
2569         _mmcam_dbg_log("");
2570
2571         /* Check element availability */
2572         mm_camcorder_get_attributes(handle, NULL, MMCAM_IMAGE_ENCODER, &codec_type, NULL);
2573
2574         switch( codec_type )
2575         {
2576                 case MM_IMAGE_CODEC_JPEG:
2577                         codec_type_str = "JPEG";
2578                         break;
2579                 case MM_IMAGE_CODEC_SRW:
2580                         codec_type_str = "SRW";
2581                         break;
2582                 case MM_IMAGE_CODEC_JPEG_SRW:
2583                         codec_type_str = "JPEG_SRW";
2584                         break;
2585                 case MM_IMAGE_CODEC_PNG:
2586                         codec_type_str = "PNG";
2587                         break;
2588                 case MM_IMAGE_CODEC_BMP:
2589                         codec_type_str = "BMP";
2590                         break;
2591                 case MM_IMAGE_CODEC_WBMP:
2592                         codec_type_str = "WBMP";
2593                         break;
2594                 case MM_IMAGE_CODEC_TIFF:
2595                         codec_type_str = "TIFF";
2596                         break;
2597                 case MM_IMAGE_CODEC_PCX:
2598                         codec_type_str = "PCX";
2599                         break;
2600                 case MM_IMAGE_CODEC_GIF:
2601                         codec_type_str = "GIF";
2602                         break;
2603                 case MM_IMAGE_CODEC_ICO:
2604                         codec_type_str = "ICO";
2605                         break;
2606                 case MM_IMAGE_CODEC_RAS:
2607                         codec_type_str = "RAS";
2608                         break;
2609                 case MM_IMAGE_CODEC_TGA:
2610                         codec_type_str = "TGA";
2611                         break;
2612                 case MM_IMAGE_CODEC_XBM:
2613                         codec_type_str = "XBM";
2614                         break;
2615                 case MM_IMAGE_CODEC_XPM:
2616                         codec_type_str = "XPM";
2617                         break;
2618                 default:
2619                         _mmcam_dbg_err( "Not supported image codec[%d]", codec_type );
2620                         return NULL;
2621         }
2622
2623         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2624                                       CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
2625                                       codec_type_str,
2626                                       &telement);
2627
2628         return telement;
2629 }
2630
2631
2632 static type_element *
2633 __mmcamcorder_get_file_format_element(MMHandleType handle)
2634 {
2635         type_element *telement = NULL;
2636         const char *mux_type_str = NULL;
2637         int file_type = MM_FILE_FORMAT_INVALID;
2638         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2639         _MMCamcorderSubContext *sc = NULL;
2640
2641         mmf_return_val_if_fail(hcamcorder, NULL);
2642         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2643
2644         mmf_return_val_if_fail(sc, NULL);
2645
2646         _mmcam_dbg_log("");
2647
2648         /* Check element availability */
2649         mm_camcorder_get_attributes(handle, NULL, MMCAM_FILE_FORMAT, &file_type, NULL);
2650
2651         switch( file_type )
2652         {
2653                 case MM_FILE_FORMAT_3GP:
2654                         mux_type_str = "3GP";
2655                         break;
2656                 case MM_FILE_FORMAT_AMR:
2657                         mux_type_str = "AMR";
2658                         break;
2659                 case MM_FILE_FORMAT_MP4:
2660                         mux_type_str = "MP4";
2661                         break;
2662                 case MM_FILE_FORMAT_AAC:
2663                         mux_type_str = "AAC";
2664                         break;
2665                 case MM_FILE_FORMAT_MP3:
2666                         mux_type_str = "MP3";
2667                         break;
2668                 case MM_FILE_FORMAT_OGG:
2669                         mux_type_str = "OGG";
2670                         break;
2671                 case MM_FILE_FORMAT_WAV:
2672                         mux_type_str = "WAV";
2673                         break;
2674                 case MM_FILE_FORMAT_AVI:
2675                         mux_type_str = "AVI";
2676                         break;
2677                 case MM_FILE_FORMAT_WMA:
2678                         mux_type_str = "WMA";
2679                         break;
2680                 case MM_FILE_FORMAT_WMV:
2681                         mux_type_str = "WMV";
2682                         break;
2683                 case MM_FILE_FORMAT_MID:
2684                         mux_type_str = "MID";
2685                         break;
2686                 case MM_FILE_FORMAT_MMF:
2687                         mux_type_str = "MMF";
2688                         break;
2689                 case MM_FILE_FORMAT_MATROSKA:
2690                         mux_type_str = "MATROSKA";
2691                         break;
2692                 case MM_FILE_FORMAT_M2TS:
2693                         mux_type_str = "M2TS";
2694                         break;
2695                 default:
2696                         _mmcam_dbg_err( "Not supported file format[%d]", file_type );
2697                         return NULL;
2698         }
2699
2700         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2701                                       CONFIGURE_CATEGORY_MAIN_MUX,
2702                                       mux_type_str,
2703                                       &telement);
2704
2705         return telement;
2706 }
2707
2708
2709 type_element *
2710 _mmcamcorder_get_type_element(MMHandleType handle, int type)
2711 {
2712         type_element *telement = NULL;
2713
2714         _mmcam_dbg_log("type:%d", type);
2715
2716         switch(type)
2717         {
2718                 case MM_CAM_AUDIO_ENCODER:
2719                         telement = __mmcamcorder_get_audio_codec_element(handle);
2720                         break;
2721                 case MM_CAM_VIDEO_ENCODER:
2722                         telement = __mmcamcorder_get_video_codec_element(handle);
2723                         break;
2724                 case MM_CAM_IMAGE_ENCODER:
2725                         telement = __mmcamcorder_get_image_codec_element(handle);
2726                         break;
2727                 case MM_CAM_FILE_FORMAT:
2728                         telement = __mmcamcorder_get_file_format_element(handle);
2729                         break;
2730                 default :
2731                         _mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
2732         }
2733
2734         return telement;
2735 }
2736
2737
2738 int _mmcamcorder_get_audio_codec_format(MMHandleType handle, const char *name)
2739 {
2740         int codec_index = MM_AUDIO_CODEC_INVALID;
2741
2742         if (!name) {
2743                 _mmcam_dbg_err("name is NULL");
2744                 return MM_AUDIO_CODEC_INVALID;
2745         }
2746
2747         if (!strcmp(name, "AMR")) {
2748                 codec_index = MM_AUDIO_CODEC_AMR;
2749         } else if (!strcmp(name, "G723_1")) {
2750                 codec_index = MM_AUDIO_CODEC_G723_1;
2751         } else if (!strcmp(name, "MP3")) {
2752                 codec_index = MM_AUDIO_CODEC_MP3;
2753         } else if (!strcmp(name, "AAC")) {
2754                 codec_index = MM_AUDIO_CODEC_AAC;
2755         } else if (!strcmp(name, "MMF")) {
2756                 codec_index = MM_AUDIO_CODEC_MMF;
2757         } else if (!strcmp(name, "ADPCM")) {
2758                 codec_index = MM_AUDIO_CODEC_ADPCM;
2759         } else if (!strcmp(name, "WAVE")) {
2760                 codec_index = MM_AUDIO_CODEC_WAVE;
2761         } else if (!strcmp(name, "MIDI")) {
2762                 codec_index = MM_AUDIO_CODEC_MIDI;
2763         } else if (!strcmp(name, "IMELODY")) {
2764                 codec_index = MM_AUDIO_CODEC_IMELODY;
2765         } else if (!strcmp(name, "VORBIS")) {
2766                 codec_index = MM_AUDIO_CODEC_VORBIS;
2767         }
2768
2769         /*_mmcam_dbg_log("audio codec index %d", codec_index);*/
2770
2771         return codec_index;
2772 }
2773
2774
2775
2776 int _mmcamcorder_get_video_codec_format(MMHandleType handle, const char *name)
2777 {
2778         int codec_index = MM_VIDEO_CODEC_INVALID;
2779
2780         if (!name) {
2781                 _mmcam_dbg_err("name is NULL");
2782                 return MM_VIDEO_CODEC_INVALID;
2783         }
2784
2785         if (!strcmp(name, "H263")) {
2786                 codec_index = MM_VIDEO_CODEC_H263;
2787         } else if (!strcmp(name, "H264")) {
2788                 codec_index = MM_VIDEO_CODEC_H264;
2789         } else if (!strcmp(name, "H26L")) {
2790                 codec_index = MM_VIDEO_CODEC_H26L;
2791         } else if (!strcmp(name, "MPEG4")) {
2792                 codec_index = MM_VIDEO_CODEC_MPEG4;
2793         } else if (!strcmp(name, "MPEG1")) {
2794                 codec_index = MM_VIDEO_CODEC_MPEG1;
2795         } else if (!strcmp(name, "THEORA")) {
2796                 codec_index = MM_VIDEO_CODEC_THEORA;
2797         }
2798
2799         /*_mmcam_dbg_log("video codec index %d", codec_index);*/
2800
2801         return codec_index;
2802 }
2803
2804
2805
2806 int _mmcamcorder_get_image_codec_format(MMHandleType handle, const char *name)
2807 {
2808         int codec_index = MM_IMAGE_CODEC_INVALID;
2809
2810         if (!name) {
2811                 _mmcam_dbg_err("name is NULL");
2812                 return MM_IMAGE_CODEC_INVALID;
2813         }
2814
2815         if (!strcmp(name, "JPEG")) {
2816                 codec_index = MM_IMAGE_CODEC_JPEG;
2817         } else if (!strcmp(name, "PNG")) {
2818                 codec_index = MM_IMAGE_CODEC_PNG;
2819         } else if (!strcmp(name, "BMP")) {
2820                 codec_index = MM_IMAGE_CODEC_BMP;
2821         } else if (!strcmp(name, "WBMP")) {
2822                 codec_index = MM_IMAGE_CODEC_WBMP;
2823         } else if (!strcmp(name, "TIFF")) {
2824                 codec_index = MM_IMAGE_CODEC_TIFF;
2825         } else if (!strcmp(name, "PCX")) {
2826                 codec_index = MM_IMAGE_CODEC_PCX;
2827         } else if (!strcmp(name, "GIF")) {
2828                 codec_index = MM_IMAGE_CODEC_GIF;
2829         } else if (!strcmp(name, "ICO")) {
2830                 codec_index = MM_IMAGE_CODEC_ICO;
2831         } else if (!strcmp(name, "RAS")) {
2832                 codec_index = MM_IMAGE_CODEC_RAS;
2833         } else if (!strcmp(name, "TGA")) {
2834                 codec_index = MM_IMAGE_CODEC_TGA;
2835         } else if (!strcmp(name, "XBM")) {
2836                 codec_index = MM_IMAGE_CODEC_XBM;
2837         } else if (!strcmp(name, "XPM")) {
2838                 codec_index = MM_IMAGE_CODEC_XPM;
2839         }
2840
2841         _mmcam_dbg_log("image codec index %d", codec_index);
2842
2843         return codec_index;
2844 }
2845
2846
2847 int _mmcamcorder_get_mux_format(MMHandleType handle, const char *name)
2848 {
2849         int mux_index = MM_FILE_FORMAT_INVALID;
2850
2851         if (!name) {
2852                 _mmcam_dbg_err("name is NULL");
2853                 return MM_FILE_FORMAT_INVALID;
2854         }
2855
2856         if (!strcmp(name, "3GP")) {
2857                 mux_index = MM_FILE_FORMAT_3GP;
2858         } else if (!strcmp(name, "AMR")) {
2859                 mux_index = MM_FILE_FORMAT_AMR;
2860         } else if (!strcmp(name, "MP4")) {
2861                 mux_index = MM_FILE_FORMAT_MP4;
2862         } else if (!strcmp(name, "AAC")) {
2863                 mux_index = MM_FILE_FORMAT_AAC;
2864         } else if (!strcmp(name, "MP3")) {
2865                 mux_index = MM_FILE_FORMAT_MP3;
2866         } else if (!strcmp(name, "OGG")) {
2867                 mux_index = MM_FILE_FORMAT_OGG;
2868         } else if (!strcmp(name, "WAV")) {
2869                 mux_index = MM_FILE_FORMAT_WAV;
2870         } else if (!strcmp(name, "AVI")) {
2871                 mux_index = MM_FILE_FORMAT_AVI;
2872         } else if (!strcmp(name, "WMA")) {
2873                 mux_index = MM_FILE_FORMAT_WMA;
2874         } else if (!strcmp(name, "WMV")) {
2875                 mux_index = MM_FILE_FORMAT_WMV;
2876         } else if (!strcmp(name, "MID")) {
2877                 mux_index = MM_FILE_FORMAT_MID;
2878         } else if (!strcmp(name, "MMF")) {
2879                 mux_index = MM_FILE_FORMAT_MMF;
2880         } else if (!strcmp(name, "MATROSKA")) {
2881                 mux_index = MM_FILE_FORMAT_MATROSKA;
2882         } else if (!strcmp(name, "M2TS")) {
2883                 mux_index = MM_FILE_FORMAT_M2TS;
2884
2885         }
2886
2887         /*_mmcam_dbg_log("mux index %d", mux_index);*/
2888
2889         return mux_index;
2890 }
2891
2892
2893 int
2894 _mmcamcorder_get_format(MMHandleType handle, int conf_category, const char *name)
2895 {
2896         int fmt = -1;
2897
2898         mmf_return_val_if_fail(name, -1);
2899
2900         switch(conf_category)
2901         {
2902                 case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
2903                         fmt = _mmcamcorder_get_audio_codec_format(handle, name);
2904                         break;
2905                 case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
2906                         fmt = _mmcamcorder_get_video_codec_format(handle, name);
2907                         break;
2908                 case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
2909                         fmt = _mmcamcorder_get_image_codec_format(handle, name);
2910                         break;
2911                 case CONFIGURE_CATEGORY_MAIN_MUX:
2912                         fmt = _mmcamcorder_get_mux_format(handle, name);
2913                         break;
2914                 default :
2915                         _mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
2916         }
2917
2918         return fmt;
2919 }
2920
2921 int
2922 _mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int ** format)
2923 {
2924         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
2925         camera_conf* configure_info = NULL;
2926         int *arr = NULL;
2927         int total_count = 0;
2928
2929         mmf_return_val_if_fail(hcamcorder, 0);
2930
2931         /*_mmcam_dbg_log("conf_category:%d", conf_category);*/
2932
2933         configure_info = hcamcorder->conf_main;
2934
2935         if (configure_info->info[conf_category]) {
2936                 int i = 0;
2937                 int fmt = 0;
2938                 const char *name = NULL;
2939                 int count = configure_info->info[conf_category]->count;
2940                 conf_detail *info = configure_info->info[conf_category];
2941
2942                 /*_mmcam_dbg_log("count[%d], info[%p]", count, info);*/
2943
2944                 if (count <= 0 || !info) {
2945                         return total_count;
2946                 }
2947
2948                 arr = (int*) g_malloc0(count * sizeof(int));
2949                 if (arr == NULL) {
2950                         _mmcam_dbg_err("malloc failed : %d", count * sizeof(int));
2951                         return 0;
2952                 }
2953
2954                 for (i = 0 ; i < count ; i++) {
2955                         if (info->detail_info[i] == NULL) {
2956                                 continue;
2957                         }
2958
2959                         name = ((type_element*)(info->detail_info[i]))->name;
2960                         fmt = _mmcamcorder_get_format(handle, conf_category, name);
2961                         if (fmt >= 0) {
2962                                 arr[total_count++] = fmt;
2963                         }
2964
2965                         /*_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);*/
2966                 }
2967         }
2968
2969         *format = arr;
2970
2971         return total_count;
2972 }