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 int
  44 __mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name);
  45
  46 /*===========================================================================================
  47 |                                                                                                                                                                                                               |
  48 |  FUNCTION DEFINITIONS                                                                                                                                                                 |
  49 |                                                                                                                                                                                                               |
  50 ========================================================================================== */
  51
  52 int
  53 _mmplayer_get_attribute(MMHandleType handle,  char **err_attr_name, const char *attribute_name, va_list args_list)
  54 {
  55         int result = MM_ERROR_NONE;
  56         MMHandleType attrs = 0;
  57
  58         /* NOTE : Don't need to check err_attr_name because it can be set NULL */
  59         /* if it's not want to know it. */
  60         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
  61         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
  62
  63         attrs = MM_PLAYER_GET_ATTRS(handle);
  64
  65         result = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, args_list);
  66
  67         if (result != MM_ERROR_NONE)
  68                 LOGE("failed to get %s attribute", attribute_name);
  69
  70         return result;
  71 }
  72
  73 int
  74 _mmplayer_set_attribute(MMHandleType handle,  char **err_attr_name, const char *attribute_name, va_list args_list)
  75 {
  76         int result = MM_ERROR_NONE;
  77         MMHandleType attrs = 0;
  78
  79         /* NOTE : Don't need to check err_attr_name because it can be set NULL */
  80         /* if it's not want to know it. */
  81         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
  82         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
  83
  84         attrs = MM_PLAYER_GET_ATTRS(handle);
  85
  86         /* set attributes and commit them */
  87         result = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, args_list);
  88
  89         if (result != MM_ERROR_NONE) {
  90                 LOGE("failed to set %s attribute", attribute_name);
  91                 return result;
  92         }
  93
  94         result = __mmplayer_apply_attribute(handle, attribute_name);
  95         if (result != MM_ERROR_NONE) {
  96                 LOGE("failed to apply attributes");
  97                 return result;
  98         }
  99
 100         return result;
 101 }
 102
 103 int
 104 _mmplayer_get_attributes_info(MMHandleType handle,  const char *attribute_name, mmplayer_attrs_info_t *dst_info)
 105 {
 106         int result = MM_ERROR_NONE;
 107         MMHandleType attrs = 0;
 108         MMAttrsInfo src_info = {0, };
 109
 110         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 111         MMPLAYER_RETURN_VAL_IF_FAIL(dst_info, MM_ERROR_COMMON_INVALID_ARGUMENT);
 112         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
 113
 114         attrs = MM_PLAYER_GET_ATTRS(handle);
 115
 116         result = mm_attrs_get_info_by_name(attrs, attribute_name, &src_info);
 117
 118         if (result != MM_ERROR_NONE) {
 119                 LOGE("failed to get attribute info");
 120                 return result;
 121         }
 122
 123         memset(dst_info, 0x00, sizeof(mmplayer_attrs_info_t));
 124
 125         dst_info->type = src_info.type;
 126         dst_info->flag = src_info.flag;
 127         dst_info->validity_type = src_info.validity_type;
 128
 129         switch (src_info.validity_type) {
 130         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
 131                 dst_info->int_array.array = src_info.int_array.array;
 132                 dst_info->int_array.count = src_info.int_array.count;
 133                 dst_info->int_array.d_val = src_info.int_array.dval;
 134                 break;
 135
 136         case MM_ATTRS_VALID_TYPE_INT_RANGE:
 137                 dst_info->int_range.min = src_info.int_range.min;
 138                 dst_info->int_range.max = src_info.int_range.max;
 139                 dst_info->int_range.d_val = src_info.int_range.dval;
 140                 break;
 141
 142         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
 143                 dst_info->double_array.array = src_info.double_array.array;
 144                 dst_info->double_array.count = src_info.double_array.count;
 145                 dst_info->double_array.d_val = src_info.double_array.dval;
 146                 break;
 147
 148         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
 149                 dst_info->double_range.min = src_info.double_range.min;
 150                 dst_info->double_range.max = src_info.double_range.max;
 151                 dst_info->double_range.d_val = src_info.double_range.dval;
 152                 break;
 153
 154         default:
 155                 break;
 156         }
 157
 158         return result;
 159 }
 160
 161 int
 162 __mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name)
 163 {
 164         mmplayer_t *player = 0;
 165
 166         MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
 167         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 168
 169         player = MM_PLAYER_CAST(handle);
 170         mmplayer_pipeline_info_t *pipeline = player->pipeline;
 171
 172         /* before preparing, just keep the attr value */
 173         MMPLAYER_RETURN_VAL_IF_FAIL(pipeline && pipeline->mainbin, MM_ERROR_NONE);
 174
 175         if (g_strrstr(attribute_name, MM_PLAYER_PITCH_VALUE)) {
 176                 int pitch_control = 0;
 177                 double pitch_value = 0;
 178
 179                 mm_attrs_multiple_get(player->attrs, NULL,
 180                                         MM_PLAYER_PITCH_CONTROL, &pitch_control,
 181                                         MM_PLAYER_PITCH_VALUE, &pitch_value,
 182                                         NULL);
 183
 184                 if (!pitch_control || !pipeline->audiobin[MMPLAYER_A_PITCH].gst)
 185                         return MM_ERROR_PLAYER_NO_OP;
 186
 187                 LOGD("set pitch value to %1.3f", pitch_value);
 188                 g_object_set(pipeline->audiobin[MMPLAYER_A_PITCH].gst, "pitch", (gdouble)pitch_value, NULL);
 189         }
 190
 191         /* Currently, there are only display related implementation at below */
 192         if (!pipeline->videobin ||
 193                 !pipeline->videobin[MMPLAYER_V_SINK].gst) {
 194                 /*
 195                  * The attribute should be committed even though videobin is not created yet.
 196                  * So, true should be returned here.
 197                  * Otherwise, video can be diaplayed abnormal.
 198                  */
 199                 return MM_ERROR_NONE;
 200         }
 201
 202         if (g_strrstr(attribute_name, "display")) {
 203                 char *param_name = NULL;
 204                 int str_len = strlen(attribute_name);
 205                 param_name = g_malloc0(str_len + 1);
 206                 if (!param_name) {
 207                         LOGE("failed to alloc param_name");
 208                         return MM_ERROR_PLAYER_INTERNAL;
 209                 }
 210                 strncpy(param_name, attribute_name, str_len);
 211                 param_name[str_len] = '\0';
 212                 LOGD(" param_name: %s", param_name);
 213                 if (MM_ERROR_NONE != _mmplayer_update_video_param(player, param_name)) {
 214                         MMPLAYER_FREEIF(param_name);
 215                         LOGE("failed to update video param");
 216                         return MM_ERROR_PLAYER_INTERNAL;
 217                 }
 218                 MMPLAYER_FREEIF(param_name);
 219         }
 220
 221         if (g_strrstr(attribute_name, MM_PLAYER_GAPLESS_MODE)) {
 222                 int gapless = 0;
 223
 224                 mm_attrs_get_int_by_name(player->attrs, "gapless_mode", &gapless);
 225                 if (gapless > 0) {
 226                         LOGD("disable last-sample at videosink");
 227                         g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
 228                 }
 229         }
 230
 231         if (g_strrstr(attribute_name, MM_PLAYER_ENABLE_VIDEO_DECODED_CB)) {
 232                 if (!player->set_mode.video_export) {
 233                         LOGE("there is no callback to export video");
 234                         return MM_ERROR_PLAYER_INTERNAL;
 235                 }
 236                 int enable = 0;
 237                 mm_attrs_get_int_by_name(player->attrs, "enable_video_decoded_cb", &enable);
 238                 g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "signal-handoffs", enable ? TRUE : FALSE, NULL);
 239         }
 240
 241         return MM_ERROR_NONE;
 242 }
 243
 244 MMHandleType
 245 _mmplayer_construct_attribute(MMHandleType handle)
 246 {
 247         int result = MM_ERROR_NONE;
 248         int idx = 0;
 249         MMHandleType attrs = 0;
 250         int num_of_attrs = 0;
 251         MMAttrsConstructInfo *base = NULL;
 252
 253         MMPLAYER_RETURN_VAL_IF_FAIL(handle, 0);
 254
 255         mmplayer_attrs_spec_t player_attrs[] = {
 256                 {
 257                         "profile_uri",                                  // name
 258                         MM_ATTRS_TYPE_STRING,           // type
 259                         MM_ATTRS_FLAG_RW,                       // flag
 260                         (void *)NULL,                           // default value
 261                         MM_ATTRS_VALID_TYPE_NONE,       // validity type
 262                         0,                                                      // validity min value
 263                         0                                                       // validity max value
 264                 },
 265                 {
 266                         "profile_user_param",
 267                         MM_ATTRS_TYPE_DATA,
 268                         MM_ATTRS_FLAG_RW,
 269                         (void *)NULL,
 270                         MM_ATTRS_VALID_TYPE_NONE,
 271                         0,
 272                         0
 273                 },
 274                 {
 275                         "profile_play_count",
 276                         MM_ATTRS_TYPE_INT,
 277                         MM_ATTRS_FLAG_RW,
 278                         (void *)1,                      /* -1 : repeat continually */
 279                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 280                         -1,
 281                         1
 282                 },
 283                 {
 284                         "profile_prepare_async",
 285                         MM_ATTRS_TYPE_INT,
 286                         MM_ATTRS_FLAG_RW,
 287                         (void *)0,
 288                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 289                         0,
 290                         1
 291                 },
 292                 {
 293                         "streaming_user_agent",
 294                         MM_ATTRS_TYPE_STRING,
 295                         MM_ATTRS_FLAG_RW,
 296                         (void *)NULL,
 297                         MM_ATTRS_VALID_TYPE_NONE,
 298                         0,
 299                         0
 300                 },
 301                 {
 302                         "streaming_cookie",
 303                         MM_ATTRS_TYPE_STRING,
 304                         MM_ATTRS_FLAG_RW,
 305                         (void *)NULL,
 306                         MM_ATTRS_VALID_TYPE_NONE,
 307                         0,
 308                         0
 309                 },
 310                 {
 311                         "subtitle_uri",
 312                         MM_ATTRS_TYPE_STRING,
 313                         MM_ATTRS_FLAG_RW,
 314                         (void *)NULL,
 315                         MM_ATTRS_VALID_TYPE_NONE,
 316                         0,
 317                         0
 318                 },
 319                 {
 320                         "content_bitrate",
 321                         MM_ATTRS_TYPE_INT,
 322                         MM_ATTRS_FLAG_RW,
 323                         (void *)0,
 324                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 325                         0,
 326                         MMPLAYER_MAX_INT
 327                 },
 328                 {
 329                         "content_max_bitrate",
 330                         MM_ATTRS_TYPE_INT,
 331                         MM_ATTRS_FLAG_RW,
 332                         (void *)0,
 333                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 334                         0,
 335                         MMPLAYER_MAX_INT
 336                 },
 337                 {
 338                         "content_video_found",
 339                         MM_ATTRS_TYPE_INT,
 340                         MM_ATTRS_FLAG_RW,
 341                         (void *)0,
 342                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 343                         0,
 344                         1
 345                 },
 346                 {
 347                         "content_video_codec",
 348                         MM_ATTRS_TYPE_STRING,
 349                         MM_ATTRS_FLAG_RW,
 350                         (void *)NULL,
 351                         MM_ATTRS_VALID_TYPE_NONE,
 352                         0,
 353                         0
 354                 },
 355                 {
 356                         "content_video_bitrate",
 357                         MM_ATTRS_TYPE_INT,
 358                         MM_ATTRS_FLAG_RW,
 359                         (void *)0,
 360                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 361                         0,
 362                         MMPLAYER_MAX_INT
 363                 },
 364                 {
 365                         "content_video_fps",
 366                         MM_ATTRS_TYPE_INT,
 367                         MM_ATTRS_FLAG_RW,
 368                         (void *)0,
 369                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 370                         0,
 371                         MMPLAYER_MAX_INT
 372                 },
 373                 {
 374                         "content_video_width",
 375                         MM_ATTRS_TYPE_INT,
 376                         MM_ATTRS_FLAG_RW,
 377                         (void *)0,
 378                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 379                         0,
 380                         MMPLAYER_MAX_INT
 381                 },
 382                 {
 383                         "content_video_height",
 384                         MM_ATTRS_TYPE_INT,
 385                         MM_ATTRS_FLAG_RW,
 386                         (void *)0,
 387                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 388                         0,
 389                         MMPLAYER_MAX_INT
 390                 },
 391                 {
 392                         "content_audio_codec",
 393                         MM_ATTRS_TYPE_STRING,
 394                         MM_ATTRS_FLAG_RW,
 395                         (void *)NULL,
 396                         MM_ATTRS_VALID_TYPE_NONE,
 397                         0,
 398                         0
 399                 },
 400                 {
 401                         "content_audio_bitrate",
 402                         MM_ATTRS_TYPE_INT,
 403                         MM_ATTRS_FLAG_RW,
 404                         (void *)0,
 405                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 406                         0,
 407                         MMPLAYER_MAX_INT
 408                 },
 409                 {
 410                         "content_audio_channels",
 411                         MM_ATTRS_TYPE_INT,
 412                         MM_ATTRS_FLAG_RW,
 413                         (void *)0,
 414                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 415                         0,
 416                         MMPLAYER_MAX_INT
 417                 },
 418                 {
 419                         "content_audio_samplerate",
 420                         MM_ATTRS_TYPE_INT,
 421                         MM_ATTRS_FLAG_RW,
 422                         (void *)0,
 423                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 424                         0,
 425                         MMPLAYER_MAX_INT
 426                 },
 427                 {
 428                         "content_audio_format",
 429                         MM_ATTRS_TYPE_STRING,
 430                         MM_ATTRS_FLAG_RW,
 431                         (void *)NULL,
 432                         MM_ATTRS_VALID_TYPE_NONE,
 433                         0,
 434                         0
 435                 },
 436                 {
 437                         "content_text_track_num",
 438                         MM_ATTRS_TYPE_INT,
 439                         MM_ATTRS_FLAG_RW,
 440                         (void *)0,
 441                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 442                         0,
 443                         MMPLAYER_MAX_INT
 444                 },
 445                 {
 446                         "current_text_track_index",
 447                         MM_ATTRS_TYPE_INT,
 448                         MM_ATTRS_FLAG_RW,
 449                         (void *)-1,
 450                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 451                         -1,
 452                         MMPLAYER_MAX_INT
 453                 },
 454                 {
 455                         "tag_artist",
 456                         MM_ATTRS_TYPE_STRING,
 457                         MM_ATTRS_FLAG_RW,
 458                         (void *)NULL,
 459                         MM_ATTRS_VALID_TYPE_NONE,
 460                         0,
 461                         0
 462                 },
 463                 {
 464                         "tag_title",
 465                         MM_ATTRS_TYPE_STRING,
 466                         MM_ATTRS_FLAG_RW,
 467                         (void *)NULL,
 468                         MM_ATTRS_VALID_TYPE_NONE,
 469                         0,
 470                         0
 471                 },
 472                 {
 473                         "tag_album",
 474                         MM_ATTRS_TYPE_STRING,
 475                         MM_ATTRS_FLAG_RW,
 476                         (void *)NULL
 477                 },
 478                 {
 479                         "tag_genre",
 480                         MM_ATTRS_TYPE_STRING,
 481                         MM_ATTRS_FLAG_RW,
 482                         (void *)NULL,
 483                         MM_ATTRS_VALID_TYPE_NONE,
 484                         0,
 485                         0
 486                 },
 487                 {
 488                         "tag_author",
 489                         MM_ATTRS_TYPE_STRING,
 490                         MM_ATTRS_FLAG_RW,
 491                         (void *)NULL,
 492                         MM_ATTRS_VALID_TYPE_NONE,
 493                         0,
 494                         0
 495                 },
 496                 {
 497                         "tag_copyright",
 498                         MM_ATTRS_TYPE_STRING,
 499                         MM_ATTRS_FLAG_RW,
 500                         (void *)NULL,
 501                         MM_ATTRS_VALID_TYPE_NONE,
 502                         0,
 503                         0
 504                 },
 505                 {
 506                         "tag_date",
 507                         MM_ATTRS_TYPE_STRING,
 508                         MM_ATTRS_FLAG_RW,
 509                         (void *)NULL,
 510                         MM_ATTRS_VALID_TYPE_NONE,
 511                         0,
 512                         0
 513                 },
 514                 {
 515                         "tag_description",
 516                         MM_ATTRS_TYPE_STRING,
 517                         MM_ATTRS_FLAG_RW,
 518                         (void *)NULL,
 519                         MM_ATTRS_VALID_TYPE_NONE,
 520                         0,
 521                         0
 522                 },
 523                 {
 524                         "tag_track_num",
 525                         MM_ATTRS_TYPE_INT,
 526                         MM_ATTRS_FLAG_RW,
 527                         (void *)0,
 528                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 529                         0,
 530                         MMPLAYER_MAX_INT
 531                 },
 532                 {
 533                         "tag_album_cover",
 534                         MM_ATTRS_TYPE_DATA,
 535                         MM_ATTRS_FLAG_RW,
 536                         (void *)NULL,
 537                         MM_ATTRS_VALID_TYPE_NONE,
 538                         0,
 539                         0
 540                 },
 541                 {
 542                         "display_rotation",
 543                         MM_ATTRS_TYPE_INT,
 544                         MM_ATTRS_FLAG_RW,
 545                         (void *)MM_DISPLAY_ROTATION_NONE,
 546                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 547                         MM_DISPLAY_ROTATION_NONE,
 548                         MM_DISPLAY_ROTATION_270
 549                 },
 550                 {
 551                         "display_visible",
 552                         MM_ATTRS_TYPE_INT,
 553                         MM_ATTRS_FLAG_RW,
 554                         (void *)FALSE,
 555                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 556                         0,
 557                         1
 558                 },
 559                 {
 560                         "display_method",
 561                         MM_ATTRS_TYPE_INT,
 562                         MM_ATTRS_FLAG_RW,
 563                         (void *)MM_DISPLAY_METHOD_LETTER_BOX,
 564                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 565                         MM_DISPLAY_METHOD_LETTER_BOX,
 566                         MM_DISPLAY_METHOD_CUSTOM_ROI
 567                 },
 568                 {
 569                         "display_overlay",
 570                         MM_ATTRS_TYPE_DATA,
 571                         MM_ATTRS_FLAG_RW,
 572                         (void *)NULL,
 573                         MM_ATTRS_VALID_TYPE_NONE,
 574                         0,
 575                         0
 576                 },
 577                 {
 578                         "display_win_roi_x",
 579                         MM_ATTRS_TYPE_INT,
 580                         MM_ATTRS_FLAG_RW,
 581                         (void *)0,
 582                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 583                         MMPLAYER_MIN_INT,
 584                         MMPLAYER_MAX_INT
 585                 },
 586                 {
 587                         "display_win_roi_y",
 588                         MM_ATTRS_TYPE_INT,
 589                         MM_ATTRS_FLAG_RW,
 590                         (void *)0,
 591                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 592                         MMPLAYER_MIN_INT,
 593                         MMPLAYER_MAX_INT
 594                 },
 595                 {
 596                         "display_win_roi_width",
 597                         MM_ATTRS_TYPE_INT,
 598                         MM_ATTRS_FLAG_RW,
 599                         (void *)0,
 600                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 601                         0,
 602                         MMPLAYER_MAX_INT
 603                 },
 604                 {
 605                         "display_win_roi_height",
 606                         MM_ATTRS_TYPE_INT,
 607                         MM_ATTRS_FLAG_RW,
 608                         (void *)0,
 609                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 610                         0,
 611                         MMPLAYER_MAX_INT
 612                 },
 613                 {
 614                         "display_surface_type",
 615                         MM_ATTRS_TYPE_INT,
 616                         MM_ATTRS_FLAG_RW,
 617                         (void *)MM_DISPLAY_SURFACE_NULL,
 618                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 619                         MM_DISPLAY_SURFACE_OVERLAY,
 620                         MM_DISPLAY_SURFACE_NUM - 1
 621                 },
 622                 {
 623                         "sound_stream_type",
 624                         MM_ATTRS_TYPE_STRING,
 625                         MM_ATTRS_FLAG_RW,
 626                         (void *)NULL,
 627                         MM_ATTRS_VALID_TYPE_NONE,
 628                         0,
 629                         0
 630                 },
 631                 {
 632                         "sound_stream_index",
 633                         MM_ATTRS_TYPE_INT,
 634                         MM_ATTRS_FLAG_RW,
 635                         0,
 636                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 637                         -1,
 638                         MMPLAYER_MAX_INT
 639                 },
 640                 {
 641                         "sound_latency_mode",
 642                         MM_ATTRS_TYPE_INT,
 643                         MM_ATTRS_FLAG_RW,
 644                         (void *)1,                      // 0: low latency, 1: middle latency 2: high latency
 645                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 646                         0,
 647                         2
 648                 },
 649                 {
 650                         "pcm_extraction_samplerate",    // set samplerate for pcm extraction
 651                         MM_ATTRS_TYPE_INT,
 652                         MM_ATTRS_FLAG_RW,
 653                         (void *)44100,                          // hz
 654                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 655                         0,
 656                         MMPLAYER_MAX_INT
 657                 },
 658                 {
 659                         "pcm_extraction_channels",      // set channels for pcm extraction
 660                         MM_ATTRS_TYPE_INT,
 661                         MM_ATTRS_FLAG_RW,
 662                         (void *)1,
 663                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 664                         0,
 665                         MMPLAYER_MAX_INT
 666                 },
 667                 {
 668                         "accurate_seek",
 669                         MM_ATTRS_TYPE_INT,
 670                         MM_ATTRS_FLAG_RW,
 671                         (void *)0,
 672                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 673                         0,
 674                         1
 675                 },
 676                 {
 677                         "content_video_orientation",    // orientation of video content
 678                         MM_ATTRS_TYPE_STRING,
 679                         MM_ATTRS_FLAG_RW,
 680                         (void *)NULL,
 681                         MM_ATTRS_VALID_TYPE_NONE,
 682                         0,
 683                         0
 684                 },
 685                 {
 686                         "pcm_audioformat",
 687                         MM_ATTRS_TYPE_STRING,
 688                         MM_ATTRS_FLAG_RW,
 689                         (void *)NULL,
 690                         MM_ATTRS_VALID_TYPE_NONE,
 691                         0,
 692                         0
 693                 },
 694                 {
 695                         "drc_mode",
 696                         MM_ATTRS_TYPE_INT,
 697                         MM_ATTRS_FLAG_RW,
 698                         (void *)FALSE,
 699                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 700                         FALSE,
 701                         TRUE
 702                 },
 703                 {
 704                         "gapless_mode",
 705                         MM_ATTRS_TYPE_INT,
 706                         MM_ATTRS_FLAG_RW,
 707                         (void *)FALSE,
 708                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 709                         FALSE,
 710                         TRUE
 711                 },
 712                 {
 713                         "enable_video_decoded_cb",
 714                         MM_ATTRS_TYPE_INT,
 715                         MM_ATTRS_FLAG_RW,
 716                         (void *)FALSE,
 717                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 718                         FALSE,
 719                         TRUE
 720                 },
 721                 {
 722                         "content_video_is_spherical",
 723                         MM_ATTRS_TYPE_INT,
 724                         MM_ATTRS_FLAG_RW,
 725                         (void *)-1,
 726                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 727                         -1,
 728                         MMPLAYER_MAX_INT
 729                 },
 730                 {
 731                         "video_codec_type",
 732                         MM_ATTRS_TYPE_INT,
 733                         MM_ATTRS_FLAG_RW,
 734                         (void *)MM_PLAYER_CODEC_TYPE_DEFAULT,
 735                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 736                         MM_PLAYER_CODEC_TYPE_DEFAULT,
 737                         MM_PLAYER_CODEC_TYPE_SW
 738                 },
 739                 {
 740                         "audio_codec_type",
 741                         MM_ATTRS_TYPE_INT,
 742                         MM_ATTRS_FLAG_RW,
 743                         (void *)MM_PLAYER_CODEC_TYPE_DEFAULT,
 744                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 745                         MM_PLAYER_CODEC_TYPE_DEFAULT,
 746                         MM_PLAYER_CODEC_TYPE_SW
 747                 },
 748                 {
 749                         "video_buffer_total_size",
 750                         MM_ATTRS_TYPE_INT,
 751                         MM_ATTRS_FLAG_RW,
 752                         (void *)DEFAULT_NUM_OF_V_OUT_BUFFER,
 753                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 754                         MMPLAYER_MIN_INT,
 755                         MMPLAYER_MAX_INT
 756                 },
 757                 {
 758                         "video_buffer_extra_size",
 759                         MM_ATTRS_TYPE_INT,
 760                         MM_ATTRS_FLAG_RW,
 761                         (void *)DEFAULT_NUM_OF_V_OUT_BUFFER,
 762                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 763                         MMPLAYER_MIN_INT,
 764                         MMPLAYER_MAX_INT
 765                 },
 766                 {
 767                         "prebuffer_ms", /* user setting */
 768                         MM_ATTRS_TYPE_INT,
 769                         MM_ATTRS_FLAG_RW,
 770                         (void *) MIN_BUFFERING_TIME,
 771                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 772                         MIN_BUFFERING_TIME,
 773                         MMPLAYER_MAX_INT
 774                 },
 775                 {
 776                         "rebuffer_ms", /* user setting */
 777                         MM_ATTRS_TYPE_INT,
 778                         MM_ATTRS_FLAG_RW,
 779                         (void *) MIN_BUFFERING_TIME,
 780                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 781                         MIN_BUFFERING_TIME,
 782                         MMPLAYER_MAX_INT
 783                 },
 784                 {
 785                         "audio_offload",        /* MM_PLAYER_AUDIO_OFFLOAD */
 786                         MM_ATTRS_TYPE_INT,
 787                         MM_ATTRS_FLAG_RW,
 788                         (void *)FALSE,
 789                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 790                         FALSE,
 791                         TRUE
 792                 },
 793                 {
 794                         "pitch_control",        /* MM_PLAYER_PITCH_CONTROL */
 795                         MM_ATTRS_TYPE_INT,
 796                         MM_ATTRS_FLAG_RW,
 797                         (void *)FALSE,
 798                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 799                         FALSE,
 800                         TRUE
 801                 },
 802                 {
 803                         "pitch_value",          /* MM_PLAYER_PITCH_VALUE */
 804                         MM_ATTRS_TYPE_DOUBLE,
 805                         MM_ATTRS_FLAG_RW,
 806                         (void *)1,
 807                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 808                         0.5,
 809                         2
 810                 },
 811         };
 812
 813         num_of_attrs = ARRAY_SIZE(player_attrs);
 814
 815         base = g_try_new(MMAttrsConstructInfo, num_of_attrs);
 816         if (!base) {
 817                 LOGE("failed to alloc attrs constructor");
 818                 return 0;
 819         }
 820
 821         /* initialize values of attributes */
 822         for (idx = 0; idx < num_of_attrs; idx++) {
 823                 base[idx].name = player_attrs[idx].name;
 824                 base[idx].value_type = player_attrs[idx].value_type;
 825                 base[idx].flags = player_attrs[idx].flags;
 826                 base[idx].default_value = player_attrs[idx].default_value;
 827         }
 828
 829         result = mm_attrs_new(base, num_of_attrs, "mmplayer_attrs",
 830                                                         NULL, NULL, &attrs);
 831
 832         /* clean */
 833         MMPLAYER_FREEIF(base);
 834
 835         if (result) {
 836                 LOGE("failed to create player attrs");
 837                 return 0;
 838         }
 839
 840         /* set validity type and range */
 841         for (idx = 0; idx < num_of_attrs; idx++) {
 842                 switch (player_attrs[idx].valid_type) {
 843                 case MM_ATTRS_VALID_TYPE_INT_RANGE:
 844                 {
 845                         mm_attrs_set_valid_type(attrs, idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
 846                         mm_attrs_set_valid_range(attrs, idx,
 847                                         player_attrs[idx].value_min,
 848                                         player_attrs[idx].value_max,
 849                                         (int)(intptr_t)(player_attrs[idx].default_value));
 850                 }
 851                         break;
 852
 853                 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
 854                 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
 855                 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
 856                 default:
 857                         break;
 858                 }
 859         }
 860
 861         /* commit */
 862         if (mm_attrs_commit_all(attrs)) {
 863                 LOGE("failed to update attributes");
 864                 mm_attrs_free(attrs);
 865                 return 0;
 866         }
 867
 868         return attrs;
 869 }
 870
 871 bool
 872 _mmplayer_deconstruct_attribute(MMHandleType handle) // @
 873 {
 874         mmplayer_t *player = MM_PLAYER_CAST(handle);
 875
 876         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 877
 878         if (player->attrs) {
 879                 mm_attrs_free(player->attrs);
 880                 player->attrs = 0;
 881         }
 882
 883         return TRUE;
 884 }