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