src/mm_player_attrs.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
   7  * YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 /*===========================================================================================
  24 |                                                                                                                                                                                       |
  25 |  INCLUDE FILES                                                                                                                                                        |
  26 |                                                                                                                                                                                       |
  27 ========================================================================================== */
  28 #include <dlog.h>
  29 #include <mm_attrs.h>
  30 #include "mm_player_utils.h"
  31 #include "mm_player_priv.h"
  32 #include "mm_player_attrs.h"
  33
  34 /*===========================================================================================
  35 |                                                                                                                                                                                       |
  36 |  LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE                                                                                        |
  37 |                                                                                                                                                                                       |
  38 ========================================================================================== */
  39
  40 /*-----------------------------------------------------------------------
  41 |    LOCAL FUNCTION PROTOTYPES:                                         |
  42 -----------------------------------------------------------------------*/
  43 static bool __mmplayer_commit_gapless_mode(MMHandleType handle, int attr_idx, const MMAttrsValue *value);
  44 static bool __mmplayer_commit_enable_video_decoded_cb(MMHandleType handle, int attr_idx, const MMAttrsValue *value);
  45 static bool __mmplayer_commit_audio_pitch_value(MMHandleType handle, int attr_idx, const MMAttrsValue *value);
  46
  47 /*-----------------------------------------------------------------------
  48 |    LOCAL VARIABLE DEFINITIONS for internal                            |
  49 -----------------------------------------------------------------------*/
  50 mmplayer_attrs_spec_t player_attrs[] = {
  51         {
  52                 MMPLAYER_ATTRS_PROFILE_URI,            /* ID */
  53                 (char *)"profile_uri",                 /* Name */
  54                 MM_ATTRS_TYPE_STRING,                  /* Value Type */
  55                 MM_ATTRS_FLAG_RW,                      /* Flag */
  56                 {(void *)NULL},                        /* default value */
  57                 MM_ATTRS_VALID_TYPE_NONE,              /* validity type */
  58                 {0},                                   /* validity min value */
  59                 {0},                                   /* validity max value */
  60                 NULL,                                  /* Runtime setting function of the attribute */
  61         },
  62         {
  63                 MMPLAYER_ATTRS_PROFILE_USER_PARAM,
  64                 (char *)"profile_user_param",
  65                 MM_ATTRS_TYPE_DATA,
  66                 MM_ATTRS_FLAG_RW,
  67                 {(void *)NULL},
  68                 MM_ATTRS_VALID_TYPE_NONE,
  69                 {0},
  70                 {0},
  71                 NULL,
  72         },
  73         {
  74                 MMPLAYER_ATTRS_PROFILE_PLAY_COUNT,
  75                 (char *)"profile_play_count",
  76                 MM_ATTRS_TYPE_INT,
  77                 MM_ATTRS_FLAG_RW,
  78                 {(void *)1},                        /* -1 : repeat continually */
  79                 MM_ATTRS_VALID_TYPE_INT_RANGE,
  80                 {.int_min = -1},
  81                 {.int_max = 1},
  82                 NULL,
  83         },
  84         {
  85                 MMPLAYER_ATTRS_PROFILE_PREPARE_ASYNC,
  86                 (char *)"profile_prepare_async",
  87                 MM_ATTRS_TYPE_INT,
  88                 MM_ATTRS_FLAG_RW,
  89                 {(void *)0},
  90                 MM_ATTRS_VALID_TYPE_INT_RANGE,
  91                 {.int_min = 0},
  92                 {.int_max = 1},
  93                 NULL,
  94         },
  95         {
  96                 MMPLAYER_ATTRS_STREAMING_USER_AGENT,
  97                 (char *)"streaming_user_agent",
  98                 MM_ATTRS_TYPE_STRING,
  99                 MM_ATTRS_FLAG_RW,
 100                 {(void *)NULL},
 101                 MM_ATTRS_VALID_TYPE_NONE,
 102                 {0},
 103                 {0},
 104                 NULL,
 105         },
 106         {
 107                 MMPLAYER_ATTRS_STREAMING_COOKIE,
 108                 (char *)"streaming_cookie",
 109                 MM_ATTRS_TYPE_STRING,
 110                 MM_ATTRS_FLAG_RW,
 111                 {(void *)NULL},
 112                 MM_ATTRS_VALID_TYPE_NONE,
 113                 {0},
 114                 {0},
 115                 NULL,
 116         },
 117         {
 118                 MMPLAYER_ATTRS_SUBTITLE_URI,
 119                 (char *)"subtitle_uri",
 120                 MM_ATTRS_TYPE_STRING,
 121                 MM_ATTRS_FLAG_RW,
 122                 {(void *)NULL},
 123                 MM_ATTRS_VALID_TYPE_NONE,
 124                 {0},
 125                 {0},
 126                 NULL,
 127         },
 128         {
 129                 MMPLAYER_ATTRS_CONTENT_BITRATE,
 130                 (char *)"content_bitrate",
 131                 MM_ATTRS_TYPE_INT,
 132                 MM_ATTRS_FLAG_RW,
 133                 {(void *)0},
 134                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 135                 {.int_min = 0},
 136                 {.int_max = MMPLAYER_MAX_INT},
 137                 NULL,
 138         },
 139         {
 140                 MMPLAYER_ATTRS_CONTENT_MAX_BITRATE,
 141                 (char *)"content_max_bitrate",
 142                 MM_ATTRS_TYPE_INT,
 143                 MM_ATTRS_FLAG_RW,
 144                 {(void *)0},
 145                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 146                 {.int_min = 0},
 147                 {.int_max = MMPLAYER_MAX_INT},
 148                 NULL,
 149         },
 150         {
 151                 MMPLAYER_ATTRS_CONTENT_VIDEO_FOUND,
 152                 (char *)"content_video_found",
 153                 MM_ATTRS_TYPE_INT,
 154                 MM_ATTRS_FLAG_RW,
 155                 {(void *)0},
 156                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 157                 {.int_min = 0},
 158                 {.int_max = 1},
 159                 NULL,
 160         },
 161         {
 162                 MMPLAYER_ATTRS_CONTENT_VIDEO_CODEC,
 163                 (char *)"content_video_codec",
 164                 MM_ATTRS_TYPE_STRING,
 165                 MM_ATTRS_FLAG_RW,
 166                 {(void *)NULL},
 167                 MM_ATTRS_VALID_TYPE_NONE,
 168                 {0},
 169                 {0},
 170                 NULL,
 171         },
 172         {
 173                 MMPLAYER_ATTRS_CONTENT_VIDEO_BITRATE,
 174                 (char *)"content_video_bitrate",
 175                 MM_ATTRS_TYPE_INT,
 176                 MM_ATTRS_FLAG_RW,
 177                 {(void *)0},
 178                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 179                 {.int_min = 0},
 180                 {.int_max = MMPLAYER_MAX_INT},
 181                 NULL,
 182         },
 183         {
 184                 MMPLAYER_ATTRS_CONTENT_VIDEO_FPS,
 185                 (char *)"content_video_fps",
 186                 MM_ATTRS_TYPE_INT,
 187                 MM_ATTRS_FLAG_RW,
 188                 {(void *)0},
 189                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 190                 {.int_min = 0},
 191                 {.int_max = MMPLAYER_MAX_INT},
 192                 NULL,
 193         },
 194         {
 195                 MMPLAYER_ATTRS_CONTENT_VIDEO_WIDTH,
 196                 (char *)"content_video_width",
 197                 MM_ATTRS_TYPE_INT,
 198                 MM_ATTRS_FLAG_RW,
 199                 {(void *)0},
 200                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 201                 {.int_min = 0},
 202                 {.int_max = MMPLAYER_MAX_INT},
 203                 NULL,
 204         },
 205         {
 206                 MMPLAYER_ATTRS_CONTENT_VIDEO_HEIGHT,
 207                 (char *)"content_video_height",
 208                 MM_ATTRS_TYPE_INT,
 209                 MM_ATTRS_FLAG_RW,
 210                 {(void *)0},
 211                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 212                 {.int_min = 0},
 213                 {.int_max = MMPLAYER_MAX_INT},
 214                 NULL,
 215         },
 216         {
 217                 MMPLAYER_ATTRS_CONTENT_VIDEO_ORIENTATION,
 218                 (char *)"content_video_orientation",   /* orientation of video content */
 219                 MM_ATTRS_TYPE_STRING,
 220                 MM_ATTRS_FLAG_RW,
 221                 {(void *)NULL},
 222                 MM_ATTRS_VALID_TYPE_NONE,
 223                 {0},
 224                 {0},
 225                 NULL,
 226         },
 227         {
 228                 MMPLAYER_ATTRS_CONTENT_VIDEO_IS_SPHERICAL,
 229                 (char *)"content_video_is_spherical",
 230                 MM_ATTRS_TYPE_INT,
 231                 MM_ATTRS_FLAG_RW,
 232                 {(void *)-1},
 233                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 234                 {.int_min = -1},
 235                 {.int_max = MMPLAYER_MAX_INT},
 236                 NULL,
 237         },
 238         {
 239                 MMPLAYER_ATTRS_CONTENT_AUDIO_CODEC,
 240                 (char *)"content_audio_codec",
 241                 MM_ATTRS_TYPE_STRING,
 242                 MM_ATTRS_FLAG_RW,
 243                 {(void *)NULL},
 244                 MM_ATTRS_VALID_TYPE_NONE,
 245                 {0},
 246                 {0},
 247                 NULL,
 248         },
 249         {
 250                 MMPLAYER_ATTRS_CONTENT_AUDIO_BITRATE,
 251                 (char *)"content_audio_bitrate",
 252                 MM_ATTRS_TYPE_INT,
 253                 MM_ATTRS_FLAG_RW,
 254                 {(void *)0},
 255                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 256                 {.int_min = 0},
 257                 {.int_max = MMPLAYER_MAX_INT},
 258                 NULL,
 259         },
 260         {
 261                 MMPLAYER_ATTRS_CONTENT_AUDIO_CHANNELS,
 262                 (char *)"content_audio_channels",
 263                 MM_ATTRS_TYPE_INT,
 264                 MM_ATTRS_FLAG_RW,
 265                 {(void *)0},
 266                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 267                 {.int_min = 0},
 268                 {.int_max = MMPLAYER_MAX_INT},
 269                 NULL,
 270         },
 271         {
 272                 MMPLAYER_ATTRS_CONTENT_AUDIO_SAMPLERATE,
 273                 (char *)"content_audio_samplerate",
 274                 MM_ATTRS_TYPE_INT,
 275                 MM_ATTRS_FLAG_RW,
 276                 {(void *)0},
 277                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 278                 {.int_min = 0},
 279                 {.int_max = MMPLAYER_MAX_INT},
 280                 NULL,
 281         },
 282         {
 283                 MMPLAYER_ATTRS_CONTENT_AUDIO_FORMAT,
 284                 (char *)"content_audio_format",
 285                 MM_ATTRS_TYPE_STRING,
 286                 MM_ATTRS_FLAG_RW,
 287                 {(void *)NULL},
 288                 MM_ATTRS_VALID_TYPE_NONE,
 289                 {0},
 290                 {0},
 291                 NULL,
 292         },
 293         {
 294                 MMPLAYER_ATTRS_CONTENT_TEXT_TRACK_NUM,
 295                 (char *)"content_text_track_num",
 296                 MM_ATTRS_TYPE_INT,
 297                 MM_ATTRS_FLAG_RW,
 298                 {(void *)0},
 299                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 300                 {.int_min = 0},
 301                 {.int_max = MMPLAYER_MAX_INT},
 302                 NULL,
 303         },
 304         {
 305                 MMPLAYER_ATTRS_CONTENT_TEXT_TRACK_INDEX,
 306                 (char *)"current_text_track_index",
 307                 MM_ATTRS_TYPE_INT,
 308                 MM_ATTRS_FLAG_RW,
 309                 {(void *)-1},
 310                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 311                 {.int_min = -1},
 312                 {.int_max = MMPLAYER_MAX_INT},
 313                 NULL,
 314         },
 315         {
 316                 MMPLAYER_ATTRS_TAG_ARTIST,
 317                 (char *)"tag_artist",
 318                 MM_ATTRS_TYPE_STRING,
 319                 MM_ATTRS_FLAG_RW,
 320                 {(void *)NULL},
 321                 MM_ATTRS_VALID_TYPE_NONE,
 322                 {0},
 323                 {0},
 324                 NULL,
 325         },
 326         {
 327                 MMPLAYER_ATTRS_TAG_TITLE,
 328                 (char *)"tag_title",
 329                 MM_ATTRS_TYPE_STRING,
 330                 MM_ATTRS_FLAG_RW,
 331                 {(void *)NULL},
 332                 MM_ATTRS_VALID_TYPE_NONE,
 333                 {0},
 334                 {0},
 335                 NULL,
 336         },
 337         {
 338                 MMPLAYER_ATTRS_TAG_ALBUM,
 339                 (char *)"tag_album",
 340                 MM_ATTRS_TYPE_STRING,
 341                 MM_ATTRS_FLAG_RW,
 342                 {(void *)NULL},
 343                 MM_ATTRS_VALID_TYPE_NONE,
 344                 {0},
 345                 {0},
 346                 NULL,
 347         },
 348         {
 349                 MMPLAYER_ATTRS_TAG_GENRE,
 350                 (char *)"tag_genre",
 351                 MM_ATTRS_TYPE_STRING,
 352                 MM_ATTRS_FLAG_RW,
 353                 {(void *)NULL},
 354                 MM_ATTRS_VALID_TYPE_NONE,
 355                 {0},
 356                 {0},
 357                 NULL,
 358         },
 359         {
 360                 MMPLAYER_ATTRS_TAG_AUTHOR,
 361                 (char *)"tag_author",
 362                 MM_ATTRS_TYPE_STRING,
 363                 MM_ATTRS_FLAG_RW,
 364                 {(void *)NULL},
 365                 MM_ATTRS_VALID_TYPE_NONE,
 366                 {0},
 367                 {0},
 368                 NULL,
 369         },
 370         {
 371                 MMPLAYER_ATTRS_TAG_COPYRIGHT,
 372                 (char *)"tag_copyright",
 373                 MM_ATTRS_TYPE_STRING,
 374                 MM_ATTRS_FLAG_RW,
 375                 {(void *)NULL},
 376                 MM_ATTRS_VALID_TYPE_NONE,
 377                 {0},
 378                 {0},
 379                 NULL,
 380         },
 381         {
 382                 MMPLAYER_ATTRS_TAG_DATE,
 383                 (char *)"tag_date",
 384                 MM_ATTRS_TYPE_STRING,
 385                 MM_ATTRS_FLAG_RW,
 386                 {(void *)NULL},
 387                 MM_ATTRS_VALID_TYPE_NONE,
 388                 {0},
 389                 {0},
 390                 NULL,
 391         },
 392         {
 393                 MMPLAYER_ATTRS_TAG_DESCRIPTION,
 394                 (char *)"tag_description",
 395                 MM_ATTRS_TYPE_STRING,
 396                 MM_ATTRS_FLAG_RW,
 397                 {(void *)NULL},
 398                 MM_ATTRS_VALID_TYPE_NONE,
 399                 {0},
 400                 {0},
 401                 NULL,
 402         },
 403         {
 404                 MMPLAYER_ATTRS_TAG_TRACK_NUM,
 405                 (char *)"tag_track_num",
 406                 MM_ATTRS_TYPE_INT,
 407                 MM_ATTRS_FLAG_RW,
 408                 {(void *)0},
 409                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 410                 {.int_min = 0},
 411                 {.int_max = MMPLAYER_MAX_INT},
 412                 NULL,
 413         },
 414         {
 415                 MMPLAYER_ATTRS_TAG_ALBUM_COVER,
 416                 (char *)"tag_album_cover",
 417                 MM_ATTRS_TYPE_DATA,
 418                 MM_ATTRS_FLAG_RW,
 419                 {(void *)NULL},
 420                 MM_ATTRS_VALID_TYPE_NONE,
 421                 {0},
 422                 {0},
 423                 NULL,
 424         },
 425         {
 426                 MMPLAYER_ATTRS_DISPLAY_ROTATION,
 427                 (char *)"display_rotation",
 428                 MM_ATTRS_TYPE_INT,
 429                 MM_ATTRS_FLAG_RW,
 430                 {(void *)MM_DISPLAY_ROTATION_NONE},
 431                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 432                 {.int_min = MM_DISPLAY_ROTATION_NONE},
 433                 {.int_max = MM_DISPLAY_ROTATION_270},
 434                 NULL,
 435         },
 436         {
 437                 MMPLAYER_ATTRS_DISPLAY_VISIBLE,
 438                 (char *)"display_visible",
 439                 MM_ATTRS_TYPE_INT,
 440                 MM_ATTRS_FLAG_RW,
 441                 {(void *)FALSE},
 442                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 443                 {.int_min = FALSE},
 444                 {.int_max = TRUE},
 445                 NULL,
 446         },
 447         {
 448                 MMPLAYER_ATTRS_DISPLAY_METHOD,
 449                 (char *)"display_method",
 450                 MM_ATTRS_TYPE_INT,
 451                 MM_ATTRS_FLAG_RW,
 452                 {(void *)MM_DISPLAY_METHOD_LETTER_BOX},
 453                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 454                 {.int_min = MM_DISPLAY_METHOD_LETTER_BOX},
 455                 {.int_max = MM_DISPLAY_METHOD_CUSTOM_ROI},
 456                 NULL,
 457         },
 458         {
 459                 MMPLAYER_ATTRS_DISPLAY_OVERLAY,
 460                 (char *)"display_overlay",
 461                 MM_ATTRS_TYPE_INT,
 462                 MM_ATTRS_FLAG_RW,
 463                 {(void *)0},
 464                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 465                 {.int_min = 0},
 466                 {.int_max = MMPLAYER_MAX_INT},
 467                 NULL,
 468         },
 469         {
 470                 MMPLAYER_ATTRS_DISPLAY_WIN_ROI_X,
 471                 (char *)"display_win_roi_x",
 472                 MM_ATTRS_TYPE_INT,
 473                 MM_ATTRS_FLAG_RW,
 474                 {(void *)0},
 475                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 476                 {.int_min = MMPLAYER_MIN_INT},
 477                 {.int_max = MMPLAYER_MAX_INT},
 478                 NULL,
 479         },
 480         {
 481                 MMPLAYER_ATTRS_DISPLAY_WIN_ROI_Y,
 482                 (char *)"display_win_roi_y",
 483                 MM_ATTRS_TYPE_INT,
 484                 MM_ATTRS_FLAG_RW,
 485                 {(void *)0},
 486                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 487                 {.int_min = MMPLAYER_MIN_INT},
 488                 {.int_max = MMPLAYER_MAX_INT},
 489                 NULL,
 490         },
 491         {
 492                 MMPLAYER_ATTRS_DISPLAY_WIN_ROI_WIDTH,
 493                 (char *)"display_win_roi_width",
 494                 MM_ATTRS_TYPE_INT,
 495                 MM_ATTRS_FLAG_RW,
 496                 {(void *)0},
 497                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 498                 {.int_min = 0},
 499                 {.int_max = MMPLAYER_MAX_INT},
 500                 NULL,
 501         },
 502         {
 503                 MMPLAYER_ATTRS_DISPLAY_WIN_ROI_HEIGHT,
 504                 (char *)"display_win_roi_height",
 505                 MM_ATTRS_TYPE_INT,
 506                 MM_ATTRS_FLAG_RW,
 507                 {(void *)0},
 508                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 509                 {.int_min = 0},
 510                 {.int_max = MMPLAYER_MAX_INT},
 511                 NULL,
 512         },
 513         {
 514                 MMPLAYER_ATTRS_DISPLAY_SURFACE_TYPE,
 515                 (char *)"display_surface_type",
 516                 MM_ATTRS_TYPE_INT,
 517                 MM_ATTRS_FLAG_RW,
 518                 {(void *)MM_DISPLAY_SURFACE_NULL},
 519                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 520                 {.int_min = MM_DISPLAY_SURFACE_OVERLAY},
 521                 {.int_max = MM_DISPLAY_SURFACE_NUM - 1},
 522                 NULL,
 523         },
 524         {
 525                 MMPLAYER_ATTRS_SOUND_STREAM_TYPE,
 526                 (char *)"sound_stream_type",
 527                 MM_ATTRS_TYPE_STRING,
 528                 MM_ATTRS_FLAG_RW,
 529                 {(void *)NULL},
 530                 MM_ATTRS_VALID_TYPE_NONE,
 531                 {0},
 532                 {0},
 533                 NULL,
 534         },
 535         {
 536                 MMPLAYER_ATTRS_SOUND_STREAM_INDEX,
 537                 (char *)"sound_stream_index",
 538                 MM_ATTRS_TYPE_INT,
 539                 MM_ATTRS_FLAG_RW,
 540                 {(void *)0},
 541                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 542                 {.int_min = -1},
 543                 {.int_max = MMPLAYER_MAX_INT},
 544                 NULL,
 545         },
 546         {
 547                 MMPLAYER_ATTRS_SOUND_LATENCY_MODE,
 548                 (char *)"sound_latency_mode",
 549                 MM_ATTRS_TYPE_INT,
 550                 MM_ATTRS_FLAG_RW,
 551                 {(void *)1},                         /* 0: low latency, 1: middle latency 2: high latency */
 552                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 553                 {.int_min = 0},
 554                 {.int_max = 2},
 555                 NULL,
 556         },
 557         {
 558                 MMPLAYER_ATTRS_PCM_EXTRACTION_SAMPLERATE,
 559                 (char *)"pcm_extraction_samplerate", /* set samplerate for pcm extraction */
 560                 MM_ATTRS_TYPE_INT,
 561                 MM_ATTRS_FLAG_RW,
 562                 {(void *)44100},
 563                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 564                 {.int_min = 0},
 565                 {.int_max = MMPLAYER_MAX_INT},
 566                 NULL,
 567         },
 568         {
 569                 MMPLAYER_ATTRS_PCM_EXTRACTION_CHANNELS,
 570                 (char *)"pcm_extraction_channels",   /* set channels for pcm extraction */
 571                 MM_ATTRS_TYPE_INT,
 572                 MM_ATTRS_FLAG_RW,
 573                 {(void *)1},
 574                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 575                 {.int_min = 0},
 576                 {.int_max = MMPLAYER_MAX_INT},
 577                 NULL,
 578         },
 579         {
 580                 MMPLAYER_ATTRS_ACCURATE_SEEK,
 581                 (char *)"accurate_seek",
 582                 MM_ATTRS_TYPE_INT,
 583                 MM_ATTRS_FLAG_RW,
 584                 {(void *)0},
 585                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 586                 {.int_min = 0},
 587                 {.int_max = 1},
 588                 NULL,
 589         },
 590         {
 591                 MMPLAYER_ATTRS_PCM_EXTRACTION_FORMAT,
 592                 (char *)"pcm_extraction_format",
 593                 MM_ATTRS_TYPE_STRING,
 594                 MM_ATTRS_FLAG_RW,
 595                 {(void *)NULL},
 596                 MM_ATTRS_VALID_TYPE_NONE,
 597                 {0},
 598                 {0},
 599                 NULL,
 600         },
 601         {
 602                 MMPLAYER_ATTRS_DRC_MODE,
 603                 (char *)"drc_mode",
 604                 MM_ATTRS_TYPE_INT,
 605                 MM_ATTRS_FLAG_RW,
 606                 {(void *)FALSE},
 607                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 608                 {.int_min = FALSE},
 609                 {.int_max = TRUE},
 610                 NULL,
 611         },
 612         {
 613                 MMPLAYER_ATTRS_GAPLESS_MODE,
 614                 (char *)"gapless_mode",
 615                 MM_ATTRS_TYPE_INT,
 616                 MM_ATTRS_FLAG_RW,
 617                 {(void *)FALSE},
 618                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 619                 {.int_min = FALSE},
 620                 {.int_max = TRUE},
 621                 __mmplayer_commit_gapless_mode,
 622         },
 623         {
 624                 MMPLAYER_ATTRS_ENABLE_VIDEO_DECODED_CB,
 625                 (char *)"enable_video_decoded_cb",
 626                 MM_ATTRS_TYPE_INT,
 627                 MM_ATTRS_FLAG_RW,
 628                 {(void *)FALSE},
 629                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 630                 {.int_min = FALSE},
 631                 {.int_max = TRUE},
 632                 __mmplayer_commit_enable_video_decoded_cb,
 633         },
 634         {
 635                 MMPLAYER_ATTRS_VIDEO_CODEC_TYPE,
 636                 (char *)"video_codec_type",
 637                 MM_ATTRS_TYPE_INT,
 638                 MM_ATTRS_FLAG_RW,
 639                 {(void *)MM_PLAYER_CODEC_TYPE_DEFAULT},
 640                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 641                 {.int_min = MM_PLAYER_CODEC_TYPE_DEFAULT},
 642                 {.int_max = MM_PLAYER_CODEC_TYPE_SW},
 643                 NULL,
 644         },
 645         {
 646                 MMPLAYER_ATTRS_AUDIO_CODEC_TYPE,
 647                 (char *)"audio_codec_type",
 648                 MM_ATTRS_TYPE_INT,
 649                 MM_ATTRS_FLAG_RW,
 650                 {(void *)MM_PLAYER_CODEC_TYPE_DEFAULT},
 651                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 652                 {.int_min = MM_PLAYER_CODEC_TYPE_DEFAULT},
 653                 {.int_max = MM_PLAYER_CODEC_TYPE_SW},
 654                 NULL,
 655         },
 656         {
 657                 MMPLAYER_ATTRS_VIDEO_BUFFER_TOTAL_SIZE,
 658                 (char *)"video_buffer_total_size",
 659                 MM_ATTRS_TYPE_INT,
 660                 MM_ATTRS_FLAG_RW,
 661                 {(void *)DEFAULT_NUM_OF_V_OUT_BUFFER},
 662                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 663                 {.int_min = MMPLAYER_MIN_INT},
 664                 {.int_max = MMPLAYER_MAX_INT},
 665                 NULL,
 666         },
 667         {
 668                 MMPLAYER_ATTRS_VIDEO_BUFFER_EXTRA_SIZE,
 669                 (char *)"video_buffer_extra_size",
 670                 MM_ATTRS_TYPE_INT,
 671                 MM_ATTRS_FLAG_RW,
 672                 {(void *)DEFAULT_NUM_OF_V_OUT_BUFFER},
 673                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 674                 {.int_min = MMPLAYER_MIN_INT},
 675                 {.int_max = MMPLAYER_MAX_INT},
 676                 NULL,
 677         },
 678         {
 679                 MMPLAYER_ATTRS_PREBUFFER_MS,
 680                 (char *)"prebuffer_ms", /* user setting */
 681                 MM_ATTRS_TYPE_INT,
 682                 MM_ATTRS_FLAG_RW,
 683                 {(void *) MIN_BUFFERING_TIME},
 684                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 685                 {.int_min = MIN_BUFFERING_TIME},
 686                 {.int_max = MMPLAYER_MAX_INT},
 687                 NULL,
 688         },
 689         {
 690                 MMPLAYER_ATTRS_REBUFFER_MS,
 691                 (char *)"rebuffer_ms", /* user setting */
 692                 MM_ATTRS_TYPE_INT,
 693                 MM_ATTRS_FLAG_RW,
 694                 {(void *) MIN_BUFFERING_TIME},
 695                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 696                 {.int_min = MIN_BUFFERING_TIME},
 697                 {.int_max = MMPLAYER_MAX_INT},
 698                 NULL,
 699         },
 700         {
 701                 MMPLAYER_ATTRS_PITCH_CONTROL,
 702                 (char *)"pitch_control",        /* MM_PLAYER_PITCH_CONTROL */
 703                 MM_ATTRS_TYPE_INT,
 704                 MM_ATTRS_FLAG_RW,
 705                 {(void *)FALSE},
 706                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 707                 {.int_min = FALSE},
 708                 {.int_max = TRUE},
 709                 NULL,
 710         },
 711         {
 712                 MMPLAYER_ATTRS_PITCH_VALUE,
 713                 (char *)"pitch_value",          /* MM_PLAYER_PITCH_VALUE */
 714                 MM_ATTRS_TYPE_DOUBLE,
 715                 MM_ATTRS_FLAG_RW,
 716                 {.value_double = 1.0},
 717                 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 718                 {.double_min = 0.5},
 719                 {.double_max = 2},
 720                 __mmplayer_commit_audio_pitch_value,
 721         },
 722         {
 723                 MMPLAYER_ATTRS_AUDIO_OFFLOAD,
 724                 (char *)"audio_offload",        /* MM_PLAYER_AUDIO_OFFLOAD */
 725                 MM_ATTRS_TYPE_INT,
 726                 MM_ATTRS_FLAG_RW,
 727                 {(void *)FALSE},
 728                 MM_ATTRS_VALID_TYPE_INT_RANGE,
 729                 {.int_min = FALSE},
 730                 {.int_max = TRUE},
 731                 NULL,
 732         },
 733         {
 734                 MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT,
 735                 (char *)"audio_offload_format", /* MM_PLAYER_AUDIO_OFFLOAD_FORMAT, array of media_format_mimetype_e */
 736                 MM_ATTRS_TYPE_INT,
 737                 MM_ATTRS_FLAG_RW,
 738                 {(void *)NULL},
 739                 MM_ATTRS_VALID_TYPE_INT_ARRAY,
 740                 {.int_array = NULL},
 741                 {.count = 0},
 742                 NULL,
 743         },
 744         {
 745                 MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT, /* MM_PLAYER_MEDIA_STREAM_INPUT_FORMAT */
 746                 (char *)"media_stream_input_format",
 747                 MM_ATTRS_TYPE_INT,
 748                 MM_ATTRS_FLAG_RW,
 749                 {(void *)NULL},
 750                 MM_ATTRS_VALID_TYPE_INT_ARRAY,
 751                 {.int_array = NULL},
 752                 {.count = 0},
 753                 NULL,
 754         },
 755 };
 756
 757 /*===========================================================================================
 758 |                                                                                                                                                                                                               |
 759 |  FUNCTION DEFINITIONS                                                                                                                                                                 |
 760 |                                                                                                                                                                                                               |
 761 ========================================================================================== */
 762
 763 static bool __mmplayer_commit_enable_video_decoded_cb(MMHandleType handle, int attr_idx, const MMAttrsValue *value)
 764 {
 765         mmplayer_t *player = MM_PLAYER_CAST(handle);
 766         mmplayer_gst_element_t *videobin = NULL;
 767
 768         MMPLAYER_FENTER();
 769         MMPLAYER_RETURN_VAL_IF_FAIL(player && value, false);
 770
 771         if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_NUM)) {
 772                 LOGD("will be applied when videosink is ready");
 773                 return true;
 774         }
 775
 776         if (!player->set_mode.video_export) {
 777                 LOGW("there is no callback for enabling");
 778                 return true;
 779         }
 780
 781         videobin = player->pipeline->videobin;
 782
 783         LOGD("[update plugin][videosink] handoff %d", value->value.i_val);
 784
 785         g_object_set(videobin[MMPLAYER_V_SINK].gst,
 786                                 "signal-handoffs", (value->value.i_val) ? TRUE : FALSE, NULL);
 787
 788         return true;
 789 }
 790
 791 static bool __mmplayer_commit_gapless_mode(MMHandleType handle, int attr_idx, const MMAttrsValue *value)
 792 {
 793         mmplayer_t *player = MM_PLAYER_CAST(handle);
 794         mmplayer_gst_element_t *videobin = NULL;
 795
 796         MMPLAYER_FENTER();
 797         MMPLAYER_RETURN_VAL_IF_FAIL(player && value, false);
 798
 799         if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_NUM)) {
 800                 LOGD("will be applied when videosink is ready");
 801                 return true;
 802         }
 803
 804         videobin = player->pipeline->videobin;
 805
 806         if (value->value.i_val > 0) {
 807                 LOGD("[update plugin][videosink] disable last sample for gapless");
 808                 g_object_set(videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
 809         }
 810
 811         return true;
 812 }
 813
 814 static bool __mmplayer_commit_audio_pitch_value(MMHandleType handle, int attr_idx, const MMAttrsValue *value)
 815 {
 816         mmplayer_t *player = MM_PLAYER_CAST(handle);
 817         mmplayer_pipeline_info_t *pipeline;
 818         int pitch_control = 0;
 819
 820         MMPLAYER_FENTER();
 821         MMPLAYER_RETURN_VAL_IF_FAIL(player && value, false);
 822         MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline && player->pipeline->mainbin, true);
 823
 824         pipeline = player->pipeline;
 825         mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_PITCH_CONTROL, &pitch_control);
 826
 827         if (!pitch_control || !pipeline->audiobin[MMPLAYER_A_PITCH].gst) {
 828                 LOGW("audio pitch is disabled");
 829                 return true;
 830         }
 831
 832         LOGD("[update plugin][pitch] value to %1.3f", value->value.d_val);
 833         g_object_set(pipeline->audiobin[MMPLAYER_A_PITCH].gst, "pitch", (value->value.d_val), NULL);
 834
 835         return true;
 836 }
 837
 838 static int __mmplayer_get_array_count(MMHandleType handle, int type)
 839 {
 840         mmplayer_t *player = (mmplayer_t *)handle;
 841
 842         int count = 0;
 843         int i = 0;
 844
 845         if (type == KEYWORD_A_OFFLOAD_MEDIA_FORMAT) {
 846                 while (player->ini.audio_offload_media_format[i++][0])
 847                         count++;
 848         } else if (type == KEYWORD_MEDIA_STREAM_IN_FORMAT) {
 849                 while (player->ini.media_stream_input_format[i++][0])
 850                         count++;
 851         }
 852         return count;
 853 }
 854
 855 static media_format_mimetype_e __mmplayer_get_supported_format_mimetype(MMHandleType handle, int type, int i)
 856 {
 857         char *name = NULL;
 858         media_format_mimetype_e format = MEDIA_FORMAT_MAX;
 859
 860         mmplayer_t *player = (mmplayer_t *)handle;
 861
 862         if (type == KEYWORD_A_OFFLOAD_MEDIA_FORMAT) {
 863                 name = player->ini.audio_offload_media_format[i];
 864         } else if (type == KEYWORD_MEDIA_STREAM_IN_FORMAT) {
 865                 name = player->ini.media_stream_input_format[i];
 866         } else {
 867                 LOGE("invalid ini type");
 868                 goto EXIT;
 869         }
 870
 871         if (!strcmp(name, "MP3"))
 872                 format = MEDIA_FORMAT_MP3;
 873         else if (!strcmp(name, "AAC"))
 874                 format = MEDIA_FORMAT_AAC;
 875         else if (!strcmp(name, "H264_SP"))
 876                 format = MEDIA_FORMAT_H264_SP;
 877         else if (!strcmp(name, "H264_MP"))
 878                 format = MEDIA_FORMAT_H264_MP;
 879         else if (!strcmp(name, "H264_HP"))
 880                 format = MEDIA_FORMAT_H264_HP;
 881         else if (!strcmp(name, "PCM"))
 882                 format = MEDIA_FORMAT_PCM;
 883         else if (!strcmp(name, "PCM_S16LE"))
 884                 format = MEDIA_FORMAT_PCM_S16LE;
 885         else if (!strcmp(name, "PCM_S24LE"))
 886                 format = MEDIA_FORMAT_PCM_S24LE;
 887         else if (!strcmp(name, "PCM_S32LE"))
 888                 format = MEDIA_FORMAT_PCM_S32LE;
 889         else if (!strcmp(name, "PCM_S16BE"))
 890                 format = MEDIA_FORMAT_PCM_S16BE;
 891         else if (!strcmp(name, "PCM_S24BE"))
 892                 format = MEDIA_FORMAT_PCM_S24BE;
 893         else if (!strcmp(name, "PCM_S32BE"))
 894                 format = MEDIA_FORMAT_PCM_S32BE;
 895         else if (!strcmp(name, "PCM_F32LE"))
 896                 format = MEDIA_FORMAT_PCM_F32LE;
 897         else if (!strcmp(name, "PCM_F32BE"))
 898                 format = MEDIA_FORMAT_PCM_F32BE;
 899         else if (!strcmp(name, "PCM_S16LE"))
 900                 format = MEDIA_FORMAT_PCM_U16LE;
 901         else if (!strcmp(name, "PCM_U24LE"))
 902                 format = MEDIA_FORMAT_PCM_U24LE;
 903         else if (!strcmp(name, "PCM_U32LE"))
 904                 format = MEDIA_FORMAT_PCM_U32LE;
 905         else if (!strcmp(name, "PCM_U16BE"))
 906                 format = MEDIA_FORMAT_PCM_U16BE;
 907         else if (!strcmp(name, "PCM_U24BE"))
 908                 format = MEDIA_FORMAT_PCM_U24BE;
 909         else if (!strcmp(name, "PCM_U32BE"))
 910                 format = MEDIA_FORMAT_PCM_U32BE;
 911         else
 912                 LOGE("FIXME: need to modify function to support more format");
 913
 914 EXIT:
 915         LOGD("[%d type] supported format 0x%X(%s)", type, format, name);
 916
 917         return format;
 918 }
 919
 920 static int __mmplayer_get_available_format(MMHandleType handle, int type, int **format)
 921 {
 922         int *arr = NULL;
 923         int total_count = 0;
 924         int count = 0;
 925         int i = 0;
 926         int fmt = 0;
 927
 928         MMPLAYER_RETURN_VAL_IF_FAIL(handle, -1);
 929
 930         count = __mmplayer_get_array_count(handle, type);
 931
 932         if (count <= 0)
 933                 return -1;
 934
 935         arr = (int *) g_malloc0(count * sizeof(int));
 936         for (i = 0 ; i < count ; i++) {
 937                 fmt = __mmplayer_get_supported_format_mimetype(handle, type, i);
 938                 if (fmt != MEDIA_FORMAT_MAX)
 939                         arr[total_count++] = fmt;
 940         }
 941
 942         if (total_count <= 0) {
 943                 g_free(arr);
 944                 return -1;
 945         }
 946
 947         LOGD("[%d type] num of supported codec %d", type, total_count);
 948
 949         *format = arr;
 950         return total_count;
 951 }
 952
 953 static int __mmplayer_set_ini_to_valid_info(MMHandleType handle)
 954 {
 955         int *format = NULL;
 956         int total_count = 0;
 957
 958         /* supported format of audio offload */
 959         total_count = __mmplayer_get_available_format(handle, KEYWORD_A_OFFLOAD_MEDIA_FORMAT, &format);
 960         if (format && total_count > 0) {
 961                 player_attrs[MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT].validity_value_1.int_array = format;
 962                 player_attrs[MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT].validity_value_2.count = total_count;
 963         }
 964
 965         /* supported format of media stream input */
 966         total_count = __mmplayer_get_available_format(handle, KEYWORD_MEDIA_STREAM_IN_FORMAT, &format);
 967         if (format && total_count > 0) {
 968                 player_attrs[MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT].validity_value_1.int_array = format;
 969                 player_attrs[MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT].validity_value_2.count = total_count;
 970         }
 971
 972         return MM_ERROR_NONE;
 973 }
 974
 975 static int __mmplayer_release_ini_info(void)
 976 {
 977         int *mem = NULL;
 978
 979         MMPLAYER_FENTER();
 980
 981         mem = (int *)(player_attrs[MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT].validity_value_1.int_array);
 982         g_free(mem);
 983         player_attrs[MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT].validity_value_1.int_array = NULL;
 984         player_attrs[MMPLAYER_ATTRS_AUDIO_OFFLOAD_FORMAT].validity_value_2.count = 0;
 985
 986         mem = (int *)(player_attrs[MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT].validity_value_1.int_array);
 987         g_free(mem);
 988         player_attrs[MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT].validity_value_1.int_array = NULL;
 989         player_attrs[MMPLAYER_ATTRS_MEDIA_STREAM_INPUT_FORMAT].validity_value_2.count = 0;
 990
 991         MMPLAYER_FLEAVE();
 992         return MM_ERROR_NONE;
 993 }
 994
 995 static void __mmplayer_print_attrs(const char *attr_name, const MMAttrsValue * value, const char *prefix)
 996 {
 997         switch (value->type) {
 998         case MM_ATTRS_TYPE_INT:
 999                 LOGD("[ %s : %s : %d ]", prefix, attr_name, value->value.i_val);
1000                 break;
1001         case MM_ATTRS_TYPE_DOUBLE:
1002                 LOGD("[ %s : %s : %f ]", prefix, attr_name, value->value.d_val);
1003                 break;
1004         case MM_ATTRS_TYPE_STRING:
1005                 LOGD("[ %s : %s : %s ]", prefix, attr_name, value->value.s_val);
1006                 break;
1007         case MM_ATTRS_TYPE_DATA:
1008                 LOGD("[ %s : %s : %p ]", prefix, attr_name, value->value.p_val);
1009                 break;
1010         default:
1011                 break;
1012         }
1013
1014         return;
1015 }
1016
1017 bool _mmplayer_commit_attribute(int attr_idx, const char *attr_name, const MMAttrsValue *value, void *user_data)
1018 {
1019         bool ret = false;
1020         mmplayer_t *player = MM_PLAYER_CAST(user_data);
1021
1022         MMPLAYER_RETURN_VAL_IF_FAIL(player && (attr_idx >= 0) && attr_name && value, false);
1023
1024         if (player_attrs[attr_idx].attr_commit) {
1025                 __mmplayer_print_attrs(attr_name, value, "Dynamic");
1026                 ret = player_attrs[attr_idx].attr_commit((MMHandleType)user_data, attr_idx, value);
1027         } else {
1028                 __mmplayer_print_attrs(attr_name, value, "Static");
1029                 ret = true;
1030         }
1031
1032         return ret;
1033 }
1034
1035 int _mmplayer_get_attribute(MMHandleType handle,  char **err_attr_name, const char *attribute_name, va_list args_list)
1036 {
1037         int result = MM_ERROR_NONE;
1038         MMHandleType attrs = NULL;
1039
1040         /* NOTE : Don't need to check err_attr_name because it can be set NULL */
1041         /* if it's not want to know it. */
1042         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
1043         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
1044
1045         attrs = MM_PLAYER_GET_ATTRS(handle);
1046
1047         result = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, args_list);
1048
1049         if (result != MM_ERROR_NONE)
1050                 LOGE("failed to get %s attribute", attribute_name);
1051
1052         return result;
1053 }
1054
1055 int __mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name)
1056 {
1057         mmplayer_t *player = NULL;
1058
1059         MMPLAYER_FENTER();
1060         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
1061         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
1062
1063         player = MM_PLAYER_CAST(handle);
1064
1065         /* apply display attr value to player handle */
1066         if (!g_strrstr(attribute_name, "display"))
1067                 return MM_ERROR_NONE;
1068
1069         if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_NUM)) {
1070                 LOGD("will be applied when videosink is ready");
1071                 return MM_ERROR_NONE;
1072         }
1073
1074         if (_mmplayer_update_video_overlay_param(player, attribute_name) != MM_ERROR_NONE) {
1075                 LOGW("not supported video param %s", attribute_name);
1076                 return MM_ERROR_NONE;
1077         }
1078
1079         return MM_ERROR_NONE;
1080 }
1081
1082 int _mmplayer_set_attribute(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list args_list)
1083 {
1084         int result = MM_ERROR_NONE;
1085         MMHandleType attrs = NULL;
1086
1087         /* NOTE : Don't need to check err_attr_name because it can be set NULL */
1088         /* if it's not want to know it. */
1089         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
1090         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
1091
1092         attrs = MM_PLAYER_GET_ATTRS(handle);
1093
1094         /* set attributes and commit them */
1095         result = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, args_list);
1096         if (result != MM_ERROR_NONE) {
1097                 LOGE("failed to set %s attribute", attribute_name);
1098                 return result;
1099         }
1100
1101         /* Note: 'attr_commit' function is called before committing the new value to attr struct.
1102                  so if there is a value to apply after committing, it should be added below function. */
1103         result = __mmplayer_apply_attribute(handle, attribute_name);
1104         if (result != MM_ERROR_NONE) {
1105                 LOGE("failed to apply attributes");
1106                 return result;
1107         }
1108
1109         return MM_ERROR_NONE;
1110 }
1111
1112 int _mmplayer_get_attributes_info(MMHandleType handle,  const char *attribute_name, mmplayer_attrs_info_t *dst_info)
1113 {
1114         int result = MM_ERROR_NONE;
1115         MMHandleType attrs = NULL;
1116         MMAttrsInfo src_info = {0, };
1117
1118         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
1119         MMPLAYER_RETURN_VAL_IF_FAIL(dst_info, MM_ERROR_COMMON_INVALID_ARGUMENT);
1120         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
1121
1122         attrs = MM_PLAYER_GET_ATTRS(handle);
1123
1124         result = mm_attrs_get_info_by_name(attrs, attribute_name, &src_info);
1125
1126         if (result != MM_ERROR_NONE) {
1127                 LOGE("failed to get attribute info");
1128                 return result;
1129         }
1130
1131         memset(dst_info, 0x00, sizeof(mmplayer_attrs_info_t));
1132
1133         dst_info->type = src_info.type;
1134         dst_info->flag = src_info.flag;
1135         dst_info->validity_type = src_info.validity_type;
1136
1137         switch (src_info.validity_type) {
1138         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1139                 dst_info->int_array.array = src_info.int_array.array;
1140                 dst_info->int_array.count = src_info.int_array.count;
1141                 dst_info->int_array.d_val = src_info.int_array.dval;
1142                 break;
1143
1144         case MM_ATTRS_VALID_TYPE_INT_RANGE:
1145                 dst_info->int_range.min = src_info.int_range.min;
1146                 dst_info->int_range.max = src_info.int_range.max;
1147                 dst_info->int_range.d_val = src_info.int_range.dval;
1148                 break;
1149
1150         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1151                 dst_info->double_array.array = src_info.double_array.array;
1152                 dst_info->double_array.count = src_info.double_array.count;
1153                 dst_info->double_array.d_val = src_info.double_array.dval;
1154                 break;
1155
1156         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1157                 dst_info->double_range.min = src_info.double_range.min;
1158                 dst_info->double_range.max = src_info.double_range.max;
1159                 dst_info->double_range.d_val = src_info.double_range.dval;
1160                 break;
1161
1162         default:
1163                 break;
1164         }
1165
1166         return result;
1167 }
1168
1169 MMHandleType _mmplayer_construct_attribute(MMHandleType handle)
1170 {
1171         int result = MM_ERROR_NONE;
1172         int idx = 0;
1173         MMHandleType attrs = NULL;
1174         int num_of_attrs = 0;
1175         MMAttrsConstructInfo *base = NULL;
1176
1177         MMPLAYER_RETURN_VAL_IF_FAIL(handle, 0);
1178
1179         num_of_attrs = ARRAY_SIZE(player_attrs);
1180
1181         base = g_try_new(MMAttrsConstructInfo, num_of_attrs);
1182         if (!base) {
1183                 LOGE("failed to alloc attrs constructor");
1184                 return NULL;
1185         }
1186
1187         /* initialize values of attributes */
1188         for (idx = 0; idx < num_of_attrs; idx++) {
1189                 base[idx].name = player_attrs[idx].name;
1190                 base[idx].value_type = player_attrs[idx].value_type;
1191                 base[idx].flags = player_attrs[idx].flags;
1192                 base[idx].default_value = player_attrs[idx].default_value.value_void; /* FIXME: need to consider the double data type */
1193         }
1194
1195         result = mm_attrs_new(base, num_of_attrs, "mmplayer_attrs",
1196                                                         _mmplayer_commit_attribute, (void *)handle, &attrs);
1197
1198         /* clean */
1199         MMPLAYER_FREEIF(base);
1200
1201         if (result) {
1202                 LOGE("failed to create player attrs");
1203                 return NULL;
1204         }
1205
1206         __mmplayer_set_ini_to_valid_info(handle);
1207
1208         /* set validity type and range */
1209         for (idx = 0; idx < num_of_attrs; idx++) {
1210                 mm_attrs_set_valid_type(attrs, idx, player_attrs[idx].valid_type);
1211                 switch (player_attrs[idx].valid_type) {
1212                 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1213                         mm_attrs_set_valid_range(attrs, idx,
1214                                         player_attrs[idx].validity_value_1.int_min,
1215                                         player_attrs[idx].validity_value_2.int_max,
1216                                         player_attrs[idx].default_value.value_int);
1217                         break;
1218                 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1219                         if (player_attrs[idx].validity_value_1.int_array &&
1220                                         player_attrs[idx].validity_value_2.count > 0)
1221                                 mm_attrs_set_valid_array(attrs, idx,
1222                                                 (const int *)(player_attrs[idx].validity_value_1.int_array),
1223                                                 player_attrs[idx].validity_value_2.count,
1224                                                 player_attrs[idx].default_value.value_int);
1225                         break;
1226                 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1227                         mm_attrs_set_valid_double_range(attrs, idx,
1228                                         player_attrs[idx].validity_value_1.double_min,
1229                                         player_attrs[idx].validity_value_2.double_max,
1230                                         player_attrs[idx].default_value.value_double);
1231                         break;
1232                 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1233                         LOGW("FIXME: need to set range value if required.");
1234                 case MM_ATTRS_VALID_TYPE_NONE:
1235                 case MM_ATTRS_VALID_TYPE_INVALID:
1236                 default:
1237                         break;
1238                 }
1239         }
1240
1241         /* commit */
1242         if (mm_attrs_commit_all(attrs)) {
1243                 LOGE("failed to update attributes");
1244                 mm_attrs_free(attrs);
1245                 return NULL;
1246         }
1247
1248         __mmplayer_release_ini_info();
1249
1250         return attrs;
1251 }
1252
1253 bool _mmplayer_deconstruct_attribute(MMHandleType handle)
1254 {
1255         mmplayer_t *player = MM_PLAYER_CAST(handle);
1256
1257         MMPLAYER_RETURN_VAL_IF_FAIL(player, false);
1258
1259         if (player->attrs) {
1260                 mm_attrs_free(player->attrs);
1261                 player->attrs = NULL;
1262         }
1263
1264         return true;
1265 }