src/mm_streamrecorder_attribute.c

   1 /*
   2  * libmm-streamrecorder
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyuntae Kim <ht1211.kim@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 <mm_error.h>
  26
  27 #include "mm_streamrecorder_util.h"
  28 #include "mm_streamrecorder_attribute.h"
  29 #include "mm_streamrecorder_gstdispatch.h"
  30
  31 /*-----------------------------------------------------------------------
  32 |    MACRO DEFINITIONS:                                                 |
  33 -----------------------------------------------------------------------*/
  34 #define MM_STREAMRECORDER_ATTRIBUTE_MAX_VALUE  15
  35 #define MM_STREAMRECORDER_RESOLUTION_MAX_VALUE 4080
  36
  37 /*---------------------------------------------------------------------------------------
  38 |    GLOBAL VARIABLE DEFINITIONS for internal                                           |
  39 ---------------------------------------------------------------------------------------*/
  40
  41 /* basic attributes' info */
  42 mm_streamrecorder_attr_construct_info stream_attrs_const_info[] = {
  43         /* 0 */
  44         {
  45          MM_STR_VIDEO_BUFFER_TYPE,      /* ID */
  46          (char *)"videobuffer-type",            /* Name */
  47          MMF_VALUE_TYPE_INT,            /* Type */
  48          MM_ATTRS_FLAG_RW,                      /* Flag */
  49          {(void *)MM_STREAMRECORDER_VIDEO_TYPE_TBM_BO}, /* Default value */
  50          MM_ATTRS_VALID_TYPE_INT_RANGE, /* Validity type */
  51          MM_STREAMRECORDER_VIDEO_TYPE_TBM_BO,   /* Validity val1 (min, *array,...) */
  52          MM_STREAMRECORDER_VIDEO_TYPE_NORMAL_BUFFER,    /* Validity val2 (max, count, ...) */
  53          NULL,                                          /* Runtime setting function of the attribute */
  54          },
  55         /* 1  */
  56         {MM_STR_VIDEO_FORMAT,
  57          (char *)"videosource-format",
  58          MMF_VALUE_TYPE_INT,
  59          MM_ATTRS_FLAG_RW,
  60          {(void *)MM_STREAMRECORDER_INPUT_FORMAT_NV12},
  61          MM_ATTRS_VALID_TYPE_INT_RANGE,
  62          MM_STREAMRECORDER_INPUT_FORMAT_INVALID,
  63          MM_STREAMRECORDER_INPUT_FORMAT_NUM,
  64          NULL,
  65          },
  66         /* 2  */
  67         {
  68          MM_STR_VIDEO_FRAMERATE,
  69          (char *)"video-framerate",
  70          MMF_VALUE_TYPE_INT,
  71          MM_ATTRS_FLAG_RW,
  72          {(void *)0},
  73          MM_ATTRS_VALID_TYPE_INT_RANGE,
  74          0,
  75          _MMSTREAMRECORDER_MAX_INT,
  76          NULL,
  77          },
  78         /* 3  */
  79         {
  80          MM_STR_VIDEO_ENCODER_BITRATE,
  81          (char *)"video-bitrate",
  82          MMF_VALUE_TYPE_INT,
  83          MM_ATTRS_FLAG_RW,
  84          {(void *)0},
  85          MM_ATTRS_VALID_TYPE_INT_RANGE,
  86          0,
  87          _MMSTREAMRECORDER_MAX_INT,
  88          NULL,    /*_mmstreamrecorder_commit_video_bitrate, */
  89          },
  90         /* 4  */
  91         {
  92          MM_STR_VIDEO_RESOLUTION_WIDTH,
  93          (char *)"video-resolution-width",
  94          MMF_VALUE_TYPE_INT,
  95          MM_ATTRS_FLAG_RW,
  96          {(void *)0},
  97          MM_ATTRS_VALID_TYPE_INT_ARRAY,
  98          0,
  99          0,
 100          NULL,
 101          },
 102         /* 5  */
 103         {
 104          MM_STR_VIDEO_RESOLUTION_HEIGHT,
 105          (char *)"video-resolution-height",
 106          MMF_VALUE_TYPE_INT,
 107          MM_ATTRS_FLAG_RW,
 108          {(void *)0},
 109          MM_ATTRS_VALID_TYPE_INT_ARRAY,
 110          0,
 111          0,
 112          NULL,
 113          },
 114         /* 6  */
 115         {
 116          MM_STR_AUDIO_FORMAT,
 117          (char *)"audio-source-format",
 118          MMF_VALUE_TYPE_INT,
 119          MM_ATTRS_FLAG_RW,
 120          {(void *)MM_STREAMRECORDER_AUDIO_FORMAT_PCM_S16_LE},
 121          MMF_VALUE_TYPE_INT,
 122          MM_STREAMRECORDER_AUDIO_FORMAT_PCM_U8,
 123          MM_STREAMRECORDER_AUDIO_FORMAT_PCM_S16_LE,
 124          _mmstreamrecorder_commit_audio_bitformat,
 125          },
 126         /* 7  */
 127         {
 128          MM_STR_AUDIO_ENCODER_BITRATE,
 129          (char *)"audio-bitrate",
 130          MMF_VALUE_TYPE_INT,
 131          MM_ATTRS_FLAG_RW,
 132          {(void *)128000},
 133          MM_ATTRS_VALID_TYPE_INT_RANGE,
 134          0,
 135          _MMSTREAMRECORDER_MAX_INT,
 136          _mmstreamrecorder_commit_audio_bitrate,
 137          },
 138         /* 8  */
 139         {
 140          MM_STR_AUDIO_SAMPLERATE,
 141          (char *)"audio-samplerate",
 142          MMF_VALUE_TYPE_INT,
 143          MM_ATTRS_FLAG_RW,
 144          {(void *)0},
 145          MM_ATTRS_VALID_TYPE_INT_RANGE,
 146          0,
 147          _MMSTREAMRECORDER_MAX_INT,
 148          _mmstreamrecorder_commit_audio_samplingrate,
 149          },
 150         /* 9  */
 151         {
 152          MM_STR_VIDEO_ENCODER,
 153          (char *)"video-encoder",
 154          MMF_VALUE_TYPE_INT,
 155          MM_ATTRS_FLAG_RW,
 156          {(void *)0},
 157          MM_ATTRS_VALID_TYPE_INT_ARRAY,
 158          0,
 159          0,
 160          _mmstreamrecorder_commit_video_encoder,
 161          },
 162         /* 10  */
 163         {
 164          MM_STR_AUDIO_ENCODER,
 165          (char *)"audio-encoder",
 166          MMF_VALUE_TYPE_INT,
 167          MM_ATTRS_FLAG_RW,
 168          {(void *)0},
 169          MM_ATTRS_VALID_TYPE_INT_ARRAY,
 170          0,
 171          0,
 172          _mmstreamrecorder_commit_audio_encoder,
 173          },
 174         /* 11  */
 175         {
 176          MM_STR_AUDIO_CHENNEL_COUNT,
 177          (char *)"audio-channel-count",
 178          MMF_VALUE_TYPE_INT,
 179          MM_ATTRS_FLAG_RW,
 180          {(void *)2},
 181          MM_ATTRS_VALID_TYPE_INT_RANGE,
 182          0,
 183          _MMSTREAMRECORDER_MAX_INT,
 184          _mmstreamrecorder_commit_audio_channel,
 185          },
 186         /* 12  */
 187         {
 188          MM_STR_FILE_FORMAT,
 189          (char *)"file-format",
 190          MMF_VALUE_TYPE_INT,
 191          MM_ATTRS_FLAG_RW,
 192          {(void *)0},
 193          MM_ATTRS_VALID_TYPE_INT_ARRAY,
 194          0,
 195          0,
 196          NULL,
 197          },
 198         /* 13  */
 199         {
 200          MM_STR_TARGET_FILE_NAME,
 201          (char *)"filename",
 202          MMF_VALUE_TYPE_STRING,
 203          MM_ATTRS_FLAG_RW,
 204          {NULL},
 205          MM_ATTRS_VALID_TYPE_NONE,
 206          0,
 207          0,
 208          NULL,
 209          },
 210         /* 14  */
 211         {
 212          MM_STR_VIDEO_ENABLE,
 213          (char *)"video-enable",
 214          MMF_VALUE_TYPE_INT,
 215          MM_ATTRS_FLAG_RW,
 216          {(void *)FALSE},
 217          MM_ATTRS_VALID_TYPE_NONE,
 218          0,
 219          _MMSTREAMRECORDER_MAX_INT,
 220          _mmstreamrecorder_commit_video_enable,
 221          },
 222         /* 15  */
 223         {
 224          MM_STR_AUDIO_ENABLE,
 225          (char *)"audio-enable",
 226          MMF_VALUE_TYPE_INT,
 227          MM_ATTRS_FLAG_RW,
 228          {(void *)FALSE},
 229          MM_ATTRS_VALID_TYPE_NONE,
 230          0,
 231          _MMSTREAMRECORDER_MAX_INT,
 232          _mmstreamrecorder_commit_audio_enable,
 233          },
 234         /* 16 */
 235         {
 236          MM_STR_MODE,
 237          (char *)"recorder-mode",
 238          MMF_VALUE_TYPE_INT,
 239          MM_ATTRS_FLAG_RW,
 240          {(void *)MM_STREAMRECORDER_MODE_MEDIABUFFER},
 241          MM_ATTRS_VALID_TYPE_NONE,
 242          0,
 243          _MMSTREAMRECORDER_MAX_INT,
 244          NULL,
 245          },
 246         /*17*/
 247         {
 248          MM_STR_TARGET_MAX_SIZE,
 249          (char *)"target-max-size",
 250          MMF_VALUE_TYPE_INT,
 251          MM_ATTRS_FLAG_RW,
 252          {(void *)0},
 253          MM_ATTRS_VALID_TYPE_INT_RANGE,
 254          0,
 255          _MMSTREAMRECORDER_MAX_INT,
 256          NULL,
 257         },
 258         /*18*/
 259         {
 260          MM_STR_TARGET_TIME_LIMIT,
 261          (char *)"target-time-limit",
 262          MMF_VALUE_TYPE_INT,
 263          MM_ATTRS_FLAG_RW,
 264          {(void *)0},
 265          MM_ATTRS_VALID_TYPE_INT_RANGE,
 266          0,
 267          _MMSTREAMRECORDER_MAX_INT,
 268          NULL,
 269         },
 270
 271 };
 272
 273 /*-----------------------------------------------------------------------
 274 |    LOCAL VARIABLE DEFINITIONS for internal                            |
 275 -----------------------------------------------------------------------*/
 276
 277 /*-----------------------------------------------------------------------
 278 |    LOCAL FUNCTION PROTOTYPES:                                         |
 279 -----------------------------------------------------------------------*/
 280 int _mmstreamrecorder_get_available_format(MMHandleType handle, int type, int ** format);
 281
 282
 283 /* STATIC INTERNAL FUNCTION */
 284 static int __mmstreamrecorder_set_conf_to_valid_info(MMHandleType handle)
 285 {
 286         int *format = NULL;
 287         int total_count = 0;
 288
 289         /* Video width */
 290         total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_WIDTH, &format);
 291         stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1 = (int)format;
 292         stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value2 = (int)total_count;
 293
 294         /* Video height */
 295         total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_HEIGHT,  &format);
 296         stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1 = (int)format;
 297         stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value2 = (int)total_count;
 298
 299         /* Audio encoder */
 300         total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_AUDIO_ENCODERS, &format);
 301         stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1 = (int)format;
 302         stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value2 = (int)total_count;
 303
 304         /*Video encoder*/
 305         total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_ENCODERS, &format);
 306         stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1 = (int)format;
 307         stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value2 = (int)total_count;
 308
 309         /* File Format */
 310         total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_FILE_FORMATS, &format);
 311         stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1 = (int)format;
 312         stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value2 = (int)total_count;
 313
 314         return MM_ERROR_NONE;
 315 }
 316
 317 static int __mmstreamrecorder_release_conf_valid_info(MMHandleType handle)
 318 {
 319         int *allocated_memory = NULL;
 320
 321         _mmstreamrec_dbg_log("START");
 322
 323         allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1);
 324         if (allocated_memory) {
 325                 free(allocated_memory);
 326                 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1 = (int)NULL;
 327                 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value2 = (int)0;
 328         }
 329
 330         allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1);
 331         if (allocated_memory) {
 332                 free(allocated_memory);
 333                 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1 = (int)NULL;
 334                 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value2 = (int)0;
 335         }
 336
 337         allocated_memory = (int *)(stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1);
 338         if (allocated_memory) {
 339                 free(allocated_memory);
 340                 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1 = (int)NULL;
 341                 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value2 = (int)0;
 342         }
 343
 344         allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1);
 345         if (allocated_memory) {
 346                 free(allocated_memory);
 347                 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1 = (int)NULL;
 348                 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value2 = (int)0;
 349         }
 350
 351         allocated_memory = (int *)(stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1);
 352         if (allocated_memory) {
 353                 free(allocated_memory);
 354                 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1 = (int)NULL;
 355                 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value2 = (int)0;
 356         }
 357         _mmstreamrec_dbg_log("DONE");
 358
 359         return MM_ERROR_NONE;
 360 }
 361
 362 #if 0
 363 static bool __mmstreamrecorder_attrs_is_supported(MMHandleType handle, int idx)
 364 {
 365         mmf_attrs_t *attr = (mmf_attrs_t *) handle;
 366         int flag;
 367
 368         if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
 369                 if (flag == MM_ATTRS_FLAG_NONE)
 370                         return FALSE;
 371         } else {
 372                 return FALSE;
 373         }
 374
 375         if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
 376                 int min, max;
 377                 mm_attrs_get_valid_range((MMHandleType) attr, idx, &min, &max);
 378                 if (max < min)
 379                         return FALSE;
 380         } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
 381                 int count;
 382                 int *array;
 383                 mm_attrs_get_valid_array((MMHandleType) attr, idx, &count, &array);
 384                 if (count == 0)
 385                         return FALSE;
 386         }
 387
 388         return TRUE;
 389 }
 390 #endif
 391 static int __mmstreamrecorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
 392 {
 393 #define INIT_VALUE            -1
 394 #define CHECK_COUNT           2
 395 #define CAPTURE_RESOLUTION    1
 396
 397         mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
 398         MMHandleType attrs = 0;
 399
 400         int ret = MM_ERROR_NONE;
 401         int i = 0, j = 0;
 402         const char *name = NULL;
 403         const char *check_pair_name[2][3] = {
 404                 {MMSTR_VIDEO_RESOLUTION_WIDTH, MMSTR_VIDEO_RESOLUTION_HEIGHT, "MMSTR_VIDEO_RESOLUTION_WIDTH and HEIGHT"},
 405                 {NULL, NULL, NULL}
 406         };
 407
 408         int check_pair_value[2][2] = {
 409                 {INIT_VALUE, INIT_VALUE},
 410                 {INIT_VALUE, INIT_VALUE},
 411         };
 412
 413         if (hstreamrecorder == NULL || attribute_name == NULL) {
 414                 _mmstreamrec_dbg_warn("handle[%p] or attribute_name[%p] is NULL.", hstreamrecorder, attribute_name);
 415                 return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
 416         }
 417
 418         if (err_attr_name)
 419                 *err_attr_name = NULL;
 420
 421         /* _mmstreamrec_dbg_log( "ENTER" ); */
 422
 423         attrs = MMF_STREAMRECORDER_ATTRS(handle);
 424
 425         name = attribute_name;
 426
 427         while (name) {
 428                 int idx = -1;
 429                 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
 430
 431                 /*_mmstreamrec_dbg_log( "NAME : %s", name );*/
 432
 433                 /* attribute name check */
 434                 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
 435                         if (err_attr_name)
 436                                 *err_attr_name = strdup(name);
 437
 438                         if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY)
 439                                 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
 440                         else
 441                                 return ret;
 442                 }
 443
 444                 /* type check */
 445                 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
 446                         return ret;
 447
 448                 switch (attr_type) {
 449                 case MM_ATTRS_TYPE_INT:
 450                         {
 451                                 va_arg((var_args), int);
 452                                 break;
 453                         }
 454                 case MM_ATTRS_TYPE_DOUBLE:
 455                         va_arg((var_args), double);
 456                         break;
 457                 case MM_ATTRS_TYPE_STRING:
 458                         va_arg((var_args), char *);     /* string */
 459                         va_arg((var_args), int);        /* size */
 460                         break;
 461                 case MM_ATTRS_TYPE_DATA:
 462                         va_arg((var_args), void *);     /* data */
 463                         va_arg((var_args), int);        /* size */
 464                         break;
 465                 case MM_ATTRS_TYPE_INVALID:
 466                 default:
 467                         _mmstreamrec_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
 468                         if (err_attr_name)
 469                                 *err_attr_name = strdup(name);
 470                         return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
 471                 }
 472
 473                 /* next name */
 474                 name = va_arg(var_args, char *);
 475         }
 476
 477         for (i = 0; i < CHECK_COUNT; i++) {
 478                 if (check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE) {
 479                         gboolean check_result = FALSE;
 480                         char *err_name = NULL;
 481                         MMStreamRecorderAttrsInfo attr_info_0, attr_info_1;
 482
 483                         if (check_pair_value[i][0] == INIT_VALUE) {
 484                                 mm_attrs_get_int_by_name(attrs, check_pair_name[i][0], &check_pair_value[i][0]);
 485                                 err_name = strdup(check_pair_name[i][1]);
 486                         } else if (check_pair_value[i][1] == INIT_VALUE) {
 487                                 mm_attrs_get_int_by_name(attrs, check_pair_name[i][1], &check_pair_value[i][1]);
 488                                 err_name = strdup(check_pair_name[i][0]);
 489                         } else {
 490                                 err_name = strdup(check_pair_name[i][2]);
 491                         }
 492
 493                         mm_streamrecorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
 494                         mm_streamrecorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
 495
 496                         check_result = FALSE;
 497
 498                         for (j = 0; j < attr_info_0.int_array.count; j++) {
 499                                 if (attr_info_0.int_array.array[j] == check_pair_value[i][0]
 500                                         && attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
 501                                         _mmstreamrec_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]", check_pair_name[i][0], check_pair_name[i][1], check_pair_value[i][0], check_pair_value[i][1], i);
 502                                         check_result = TRUE;
 503                                         break;
 504                                 }
 505                         }
 506
 507                         if (check_result == FALSE) {
 508                                 _mmstreamrec_dbg_err("INVALID pair[%s,%s] %dx%d", check_pair_name[i][0], check_pair_name[i][1], check_pair_value[i][0], check_pair_value[i][1]);
 509                                 if (err_attr_name)
 510                                         *err_attr_name = err_name;
 511
 512                                 return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
 513                         }
 514
 515                         if (err_name) {
 516                                 free(err_name);
 517                                 err_name = NULL;
 518                         }
 519                 }
 520         }
 521
 522         /*_mmstreamrec_dbg_log("DONE");*/
 523
 524         return MM_ERROR_NONE;
 525 }
 526
 527 /* attribute commiter */
 528 void __mmstreamrecorder_print_attrs(const char *attr_name, const mmf_value_t * value, const char *cmt_way)
 529 {
 530         switch (value->type) {
 531         case MMF_VALUE_TYPE_INT:
 532                 _mmstreamrec_dbg_log("%s :(%s:%d)", cmt_way, attr_name, value->value.i_val);
 533                 break;
 534         case MMF_VALUE_TYPE_DOUBLE:
 535                 _mmstreamrec_dbg_log("%s :(%s:%f)", cmt_way, attr_name, value->value.d_val);
 536                 break;
 537         case MMF_VALUE_TYPE_STRING:
 538                 _mmstreamrec_dbg_log("%s :(%s:%s)", cmt_way, attr_name, value->value.s_val);
 539                 break;
 540         case MMF_VALUE_TYPE_DATA:
 541                 _mmstreamrec_dbg_log("%s :(%s:%p)", cmt_way, attr_name, value->value.p_val);
 542                 break;
 543         default:
 544                 break;
 545         }
 546
 547         return;
 548 }
 549
 550 int _mmstreamrecorder_get_audio_codec_format(MMHandleType handle, const char *name)
 551 {
 552         int codec_index = MM_AUDIO_CODEC_INVALID;
 553
 554         if (!name) {
 555                 _mmstreamrec_dbg_err("name is NULL");
 556                 return MM_AUDIO_CODEC_INVALID;
 557         }
 558
 559         if (!strcmp(name, "AMR"))
 560                 codec_index = MM_AUDIO_CODEC_AMR;
 561         else if (!strcmp(name, "AAC"))
 562                 codec_index = MM_AUDIO_CODEC_AAC;
 563         else if (!strcmp(name, "PCM"))
 564                 codec_index = MM_AUDIO_CODEC_WAVE;
 565         else if (!strcmp(name, "VORBIS"))
 566                 codec_index = MM_AUDIO_CODEC_VORBIS;
 567
 568         return codec_index;
 569 }
 570
 571 int _mmstreamrecorder_get_video_codec_format(MMHandleType handle, const char *name)
 572 {
 573         int codec_index = MM_VIDEO_CODEC_INVALID;
 574
 575         if (!name) {
 576                 _mmstreamrec_dbg_err("name is NULL");
 577                 return MM_VIDEO_CODEC_INVALID;
 578         }
 579
 580         if (!strcmp(name, "H263"))
 581                 codec_index = MM_VIDEO_CODEC_H263;
 582         else if (!strcmp(name, "H264"))
 583                 codec_index = MM_VIDEO_CODEC_H264;
 584         else if (!strcmp(name, "MPEG4"))
 585                 codec_index = MM_VIDEO_CODEC_MPEG4;
 586
 587         return codec_index;
 588 }
 589
 590
 591 int _mmstreamrecorder_get_mux_format(MMHandleType handle, const char *name)
 592 {
 593         int mux_index = MM_FILE_FORMAT_INVALID;
 594
 595         if (!name) {
 596                 _mmstreamrec_dbg_err("name is NULL");
 597                 return MM_FILE_FORMAT_INVALID;
 598         }
 599
 600         if (!strcmp(name, "3GP"))
 601                 mux_index = MM_FILE_FORMAT_3GP;
 602         else if (!strcmp(name, "AMR"))
 603                 mux_index = MM_FILE_FORMAT_AMR;
 604         else if (!strcmp(name, "MP4"))
 605                 mux_index = MM_FILE_FORMAT_MP4;
 606         else if (!strcmp(name, "WAV"))
 607                 mux_index = MM_FILE_FORMAT_WAV;
 608         return mux_index;
 609 }
 610
 611
 612 int _mmstreamrecorder_get_format(MMHandleType handle , int category, const char *name)
 613 {
 614         int fmt = -1;
 615
 616         mmf_return_val_if_fail(name, -1);
 617
 618         switch (category) {
 619         case KEYWORD_AUDIO_ENCODERS:
 620                 fmt = _mmstreamrecorder_get_audio_codec_format(handle, name);
 621                 break;
 622         case KEYWORD_VIDEO_ENCODERS:
 623                 fmt = _mmstreamrecorder_get_video_codec_format(handle, name);
 624                 break;
 625         case KEYWORD_FILE_FORMATS:
 626                 fmt = _mmstreamrecorder_get_mux_format(handle, name);
 627                 break;
 628         default:
 629                 break;
 630         }
 631         return fmt;
 632 }
 633
 634 int _mmstreamrecorder_get_type_count(MMHandleType handle, int type)
 635 {
 636         mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
 637
 638         int count = 0;
 639         int i = 0;
 640         if (type == KEYWORD_VIDEO_WIDTH) {
 641                 while (hstreamrecorder->ini.supported_video_width[i++])
 642                         count++;
 643         } else if (type == KEYWORD_VIDEO_HEIGHT) {
 644                 while (hstreamrecorder->ini.supported_video_height[i++])
 645                         count++;
 646         } else if (type == KEYWORD_AUDIO_ENCODERS) {
 647                 while (hstreamrecorder->ini.supported_audio_encoders[i++][0])
 648                         count++;
 649         } else if (type == KEYWORD_VIDEO_ENCODERS) {
 650                 while (hstreamrecorder->ini.supported_video_encoders[i++][0])
 651                         count++;
 652         } else if (type == KEYWORD_FILE_FORMATS) {
 653                 while (hstreamrecorder->ini.supported_file_formats[i++][0])
 654                         count++;
 655         }
 656         return count;
 657 }
 658
 659 void __mmstreamrecorder_get_supported_name(MMHandleType handle, int type , char **str, int i)
 660 {
 661         mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
 662         if (type == KEYWORD_AUDIO_ENCODERS) {
 663                 *str = hstreamrecorder->ini.supported_audio_encoders[i];
 664                 return;
 665         } else if (type == KEYWORD_VIDEO_ENCODERS) {
 666                 *str = hstreamrecorder->ini.supported_video_encoders[i];
 667                 return;
 668         } else if (type == KEYWORD_FILE_FORMATS) {
 669                 *str = hstreamrecorder->ini.supported_file_formats[i];
 670                 return;
 671         } else {
 672                 *str = NULL;
 673                 return;
 674         }
 675 }
 676
 677 int __mmstreamrecorder_get_supported_value(MMHandleType handle, int type, int i)
 678 {
 679         mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
 680
 681         if (type == KEYWORD_VIDEO_WIDTH)
 682                 return hstreamrecorder->ini.supported_video_width[i];
 683         else if (type == KEYWORD_VIDEO_HEIGHT)
 684                 return hstreamrecorder->ini.supported_video_height[i];
 685         else
 686                 return -1;
 687 }
 688
 689 int
 690 _mmstreamrecorder_get_available_format(MMHandleType handle, int type, int ** format)
 691 {
 692         mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
 693         int *arr = NULL;
 694         int total_count = 0;
 695         int count = 0;
 696         int i = 0;
 697         int fmt = 0;
 698         char *name = NULL;
 699
 700         mmf_return_val_if_fail(hstreamrecorder, 0);
 701
 702         count = _mmstreamrecorder_get_type_count(handle, type);
 703
 704         if (count <= 0)
 705                 return -1;
 706
 707         arr = (int*) g_malloc0(count * sizeof(int));
 708         if (arr == NULL) {
 709                 _mmstreamrec_dbg_err("malloc failed : %d", count * sizeof(int));
 710                 return -1;
 711         }
 712
 713         if (type == KEYWORD_VIDEO_WIDTH || type == KEYWORD_VIDEO_HEIGHT) {
 714                 for (i = 0 ; i < count ; i++) {
 715                         fmt = __mmstreamrecorder_get_supported_value(handle, type, i);
 716                         if (fmt >= 0)
 717                                 arr[total_count++] = fmt;
 718                 }
 719         } else {
 720                 for (i = 0 ; i < count ; i++) {
 721                         __mmstreamrecorder_get_supported_name(handle, type, &name, i);
 722                         fmt = _mmstreamrecorder_get_format(handle, type, name);
 723                         if (fmt >= 0)
 724                                 arr[total_count++] = fmt;
 725                 }
 726         }
 727         *format = arr;
 728         return total_count;
 729 }
 730
 731 /*=======================================================================
 732 |  FUNCTION DEFINITIONS                                                 |
 733 =======================================================================*/
 734 /*-----------------------------------------------------------------------
 735 |    GLOBAL FUNCTION DEFINITIONS:                                       |
 736 -----------------------------------------------------------------------*/
 737 MMHandleType _mmstreamrecorder_alloc_attribute(MMHandleType handle)
 738 {
 739         _mmstreamrec_dbg_log("");
 740
 741         MMHandleType attrs = 0;
 742         mmf_attrs_construct_info_t *attrs_const_info = NULL;
 743         unsigned int attr_count = 0;
 744         unsigned int idx;
 745
 746         /* Create attribute constructor */
 747         _mmstreamrec_dbg_log("start");
 748
 749         /* alloc 'mmf_attrs_construct_info_t' */
 750         attr_count = ARRAY_SIZE(stream_attrs_const_info);
 751         attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
 752
 753         if (!attrs_const_info) {
 754                 _mmstreamrec_dbg_err("Fail to alloc constructor.");
 755                 return 0;
 756         }
 757
 758         for (idx = 0; idx < attr_count; idx++) {
 759                 /* attribute order check. This should be same. */
 760                 if (idx != stream_attrs_const_info[idx].attrid) {
 761                         _mmstreamrec_dbg_err("Please check attributes order. Is the idx same with enum val?");
 762                         free(attrs_const_info);
 763                         attrs_const_info = NULL;
 764                         return 0;
 765                 }
 766
 767                 attrs_const_info[idx].name = stream_attrs_const_info[idx].name;
 768                 attrs_const_info[idx].value_type = stream_attrs_const_info[idx].value_type;
 769                 attrs_const_info[idx].flags = stream_attrs_const_info[idx].flags;
 770                 attrs_const_info[idx].default_value = stream_attrs_const_info[idx].default_value.value_void;
 771         }
 772
 773         _mmstreamrec_dbg_log("Create Streamrecorder Attributes[%p, %d]", attrs_const_info, attr_count);
 774
 775         attrs = mmf_attrs_new_from_data("Streamrecorder_Attributes", attrs_const_info, attr_count, _mmstreamrecorder_commit_streamrecorder_attrs, (void *)handle);
 776
 777         free(attrs_const_info);
 778         attrs_const_info = NULL;
 779
 780         if (attrs == 0) {
 781                 _mmstreamrec_dbg_err("Fail to alloc attribute handle");
 782                 return 0;
 783         }
 784
 785         __mmstreamrecorder_set_conf_to_valid_info(handle);
 786
 787         for (idx = 0; idx < attr_count; idx++) {
 788                 mmf_attrs_set_valid_type(attrs, idx, stream_attrs_const_info[idx].validity_type);
 789
 790                 switch (stream_attrs_const_info[idx].validity_type) {
 791                 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
 792                         if (stream_attrs_const_info[idx].validity_value1 && stream_attrs_const_info[idx].validity_value2 > 0)
 793                                 mmf_attrs_set_valid_array(attrs, idx, (const int *)(stream_attrs_const_info[idx].validity_value1), stream_attrs_const_info[idx].validity_value2, (int)(stream_attrs_const_info[idx].default_value.value_int));
 794                         break;
 795                 case MM_ATTRS_VALID_TYPE_INT_RANGE:
 796                         mmf_attrs_set_valid_range(attrs, idx, stream_attrs_const_info[idx].validity_value1, stream_attrs_const_info[idx].validity_value2, (int)(stream_attrs_const_info[idx].default_value.value_int));
 797                         break;
 798                 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
 799                         if (stream_attrs_const_info[idx].validity_value1 && stream_attrs_const_info[idx].validity_value2 > 0)
 800                                 mmf_attrs_set_valid_double_array(attrs, idx, (const double *)(stream_attrs_const_info[idx].validity_value1), stream_attrs_const_info[idx].validity_value2, (double)(stream_attrs_const_info[idx].default_value.value_double));
 801                         break;
 802                 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
 803                         mmf_attrs_set_valid_double_range(attrs, idx, (double)(stream_attrs_const_info[idx].validity_value1), (double)(stream_attrs_const_info[idx].validity_value2), (double)(stream_attrs_const_info[idx].default_value.value_double));
 804                         break;
 805                 case MM_ATTRS_VALID_TYPE_NONE:
 806                         break;
 807                 case MM_ATTRS_VALID_TYPE_INVALID:
 808                 default:
 809                         _mmstreamrec_dbg_err("Valid type error.");
 810                         break;
 811                 }
 812         }
 813
 814         __mmstreamrecorder_release_conf_valid_info(handle);
 815
 816         return attrs;
 817 }
 818
 819 void _mmstreamrecorder_dealloc_attribute(MMHandleType attrs)
 820 {
 821         _mmstreamrec_dbg_log("");
 822
 823         if (attrs) {
 824                 mmf_attrs_free(attrs);
 825
 826                 _mmstreamrec_dbg_log("released attribute");
 827         }
 828 }
 829
 830 int _mmstreamrecorder_get_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
 831 {
 832         MMHandleType attrs = 0;
 833         int ret = MM_ERROR_NONE;
 834
 835         mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 836
 837         attrs = MMF_STREAMRECORDER_ATTRS(handle);
 838         mmf_return_val_if_fail(attrs, MM_ERROR_STREAMRECORDER_NOT_INITIALIZED);
 839
 840         ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
 841
 842         return ret;
 843 }
 844
 845 int _mmstreamrecorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
 846 {
 847         MMHandleType attrs = 0;
 848         int ret = MM_ERROR_NONE;
 849         va_list var_args_copy;
 850
 851         mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 852
 853         /* copy var_args to keep original var_args */
 854         va_copy(var_args_copy, var_args);
 855
 856         attrs = MMF_STREAMRECORDER_ATTRS(handle);
 857         if (!attrs) {
 858                 _mmstreamrec_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
 859                 return MM_ERROR_STREAMRECORDER_NOT_INITIALIZED;
 860         }
 861
 862         ret = __mmstreamrecorder_check_valid_pair(handle, err_attr_name, attribute_name, var_args);
 863
 864         _mmstreamrec_dbg_err("__mmstreamrecorder_check_valid_pair handle 0x%x, attr name [%s] , ret = %d", handle, attribute_name, ret);
 865
 866         if (ret == MM_ERROR_NONE) {
 867                 /* In 64bit environment, unexpected result is returned if var_args is used again. */
 868                 ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args_copy);
 869         }
 870         va_end(var_args_copy);
 871
 872         _mmstreamrec_dbg_err("mm_attrs_set_valist handle 0x%x, attr name [%s] , ret = %d", handle, attribute_name, ret);
 873         return ret;
 874 }
 875
 876 int _mmstreamrecorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMStreamRecorderAttrsInfo * info)
 877 {
 878         MMHandleType attrs = 0;
 879         MMAttrsInfo attrinfo;
 880         int ret = MM_ERROR_NONE;
 881
 882         mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 883         mmf_return_val_if_fail(attr_name, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 884         mmf_return_val_if_fail(info, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 885
 886         attrs = MMF_STREAMRECORDER_ATTRS(handle);
 887         mmf_return_val_if_fail(attrs, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
 888
 889         ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo *) & attrinfo);
 890
 891         if (ret == MM_ERROR_NONE) {
 892                 memset(info, 0x00, sizeof(MMStreamRecorderAttrsInfo));
 893                 info->type = attrinfo.type;
 894                 info->flag = attrinfo.flag;
 895                 info->validity_type = attrinfo.validity_type;
 896
 897                 switch (attrinfo.validity_type) {
 898                 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
 899                         info->int_array.array = attrinfo.int_array.array;
 900                         info->int_array.count = attrinfo.int_array.count;
 901                         info->int_array.def = attrinfo.int_array.dval;
 902                         break;
 903                 case MM_ATTRS_VALID_TYPE_INT_RANGE:
 904                         info->int_range.min = attrinfo.int_range.min;
 905                         info->int_range.max = attrinfo.int_range.max;
 906                         info->int_range.def = attrinfo.int_range.dval;
 907                         break;
 908                 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
 909                         info->double_array.array = attrinfo.double_array.array;
 910                         info->double_array.count = attrinfo.double_array.count;
 911                         info->double_array.def = attrinfo.double_array.dval;
 912                         break;
 913                 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
 914                         info->double_range.min = attrinfo.double_range.min;
 915                         info->double_range.max = attrinfo.double_range.max;
 916                         info->double_range.def = attrinfo.double_range.dval;
 917                         break;
 918                 case MM_ATTRS_VALID_TYPE_NONE:
 919                         break;
 920                 case MM_ATTRS_VALID_TYPE_INVALID:
 921                 default:
 922                         break;
 923                 }
 924         }
 925
 926         return ret;
 927 }
 928
 929 bool _mmstreamrecorder_commit_streamrecorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t * value, void *commit_param)
 930 {
 931         bool bret = FALSE;
 932
 933         mmf_return_val_if_fail(commit_param, FALSE);
 934         mmf_return_val_if_fail(attr_idx >= 0, FALSE);
 935         mmf_return_val_if_fail(attr_name, FALSE);
 936         mmf_return_val_if_fail(value, FALSE);
 937
 938         if (stream_attrs_const_info[attr_idx].attr_commit) {
 939                 /* _mmstreamrec_dbg_log("Dynamic commit:(%s)", attr_name); */
 940                 __mmstreamrecorder_print_attrs(attr_name, value, "Dynamic");
 941                 bret = stream_attrs_const_info[attr_idx].attr_commit((MMHandleType) commit_param, attr_idx, value);
 942         } else {
 943                 /* _mmstreamrec_dbg_log("Static commit:(%s)", attr_name); */
 944                 __mmstreamrecorder_print_attrs(attr_name, value, "Static");
 945                 bret = TRUE;
 946         }
 947
 948         return bret;
 949 }
 950
 951 bool _mmstreamrecorder_commit_video_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 952 {
 953         MMHandleType attr = 0;
 954         /* mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle); */
 955         _MMStreamRecorderSubContext *sc = NULL;
 956         _MMStreamRecorderVideoInfo *info = NULL;
 957
 958         mmf_return_val_if_fail(handle, FALSE);
 959         attr = MMF_STREAMRECORDER_ATTRS(handle);
 960         mmf_return_val_if_fail(attr, FALSE);
 961         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
 962
 963         _mmstreamrec_dbg_log("(%d)", attr_idx);
 964
 965         mmf_return_val_if_fail(sc, FALSE);
 966
 967         info = (_MMStreamRecorderVideoInfo *) sc->info_video;
 968
 969         if (info == NULL && value->value.i_val != 0) {
 970                 if (_mmstreamrecorder_alloc_subcontext_videoinfo(handle))
 971                         return FALSE;
 972         }
 973
 974         return TRUE;
 975 }
 976
 977 bool _mmstreamrecorder_commit_video_encoder(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 978 {
 979         MMHandleType attr = 0;
 980         _MMStreamRecorderSubContext *sc = NULL;
 981         _MMStreamRecorderVideoInfo *info = NULL;
 982
 983         mmf_return_val_if_fail(handle, FALSE);
 984         attr = MMF_STREAMRECORDER_ATTRS(handle);
 985         mmf_return_val_if_fail(attr, FALSE);
 986         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
 987         mmf_return_val_if_fail(sc, FALSE);
 988
 989         info = (_MMStreamRecorderVideoInfo *) sc->info_video;
 990         mmf_return_val_if_fail(info, FALSE);
 991
 992         _mmstreamrec_dbg_log("(%d)", attr_idx);
 993
 994         info->iVideoEncoder = value->value.i_val;
 995
 996         return TRUE;
 997 }
 998
 999 bool _mmstreamrecorder_commit_audio_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1000 {
1001         MMHandleType attr = 0;
1002         /* mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle); */
1003         _MMStreamRecorderSubContext *sc = NULL;
1004         _MMStreamRecorderAudioInfo *info = NULL;
1005
1006         mmf_return_val_if_fail(handle, FALSE);
1007         attr = MMF_STREAMRECORDER_ATTRS(handle);
1008         mmf_return_val_if_fail(attr, FALSE);
1009         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1010         mmf_return_val_if_fail(sc, FALSE);
1011
1012         _mmstreamrec_dbg_log("(%d)", attr_idx);
1013
1014         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1015
1016         if (info == NULL && value->value.i_val != 0) {
1017                 if (_mmstreamrecorder_alloc_subcontext_audioinfo(handle))
1018                         return FALSE;
1019         }
1020
1021         return TRUE;
1022 }
1023
1024 bool _mmstreamrecorder_commit_audio_encoder(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1025 {
1026         MMHandleType attr = 0;
1027         _MMStreamRecorderSubContext *sc = NULL;
1028         _MMStreamRecorderAudioInfo *info = NULL;
1029
1030         mmf_return_val_if_fail(handle, FALSE);
1031         attr = MMF_STREAMRECORDER_ATTRS(handle);
1032         mmf_return_val_if_fail(attr, FALSE);
1033         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1034         mmf_return_val_if_fail(sc, FALSE);
1035
1036         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1037         mmf_return_val_if_fail(info, FALSE);
1038
1039         _mmstreamrec_dbg_log("(%d)", attr_idx);
1040
1041         info->iAudioEncoder = value->value.i_val;
1042
1043         return TRUE;
1044 }
1045
1046 bool _mmstreamrecorder_commit_audio_samplingrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1047 {
1048         MMHandleType attr = 0;
1049         _MMStreamRecorderSubContext *sc = NULL;
1050         _MMStreamRecorderAudioInfo *info = NULL;
1051
1052         mmf_return_val_if_fail(handle, FALSE);
1053         attr = MMF_STREAMRECORDER_ATTRS(handle);
1054         mmf_return_val_if_fail(attr, FALSE);
1055         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1056         mmf_return_val_if_fail(sc, FALSE);
1057
1058         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1059         mmf_return_val_if_fail(info, FALSE);
1060
1061         _mmstreamrec_dbg_log("(%d)", attr_idx);
1062
1063         info->iSamplingRate = value->value.i_val;
1064
1065         return TRUE;
1066 }
1067
1068 bool _mmstreamrecorder_commit_audio_bitformat(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1069 {
1070         MMHandleType attr = 0;
1071         _MMStreamRecorderSubContext *sc = NULL;
1072         _MMStreamRecorderAudioInfo *info = NULL;
1073
1074         mmf_return_val_if_fail(handle, FALSE);
1075         attr = MMF_STREAMRECORDER_ATTRS(handle);
1076         mmf_return_val_if_fail(attr, FALSE);
1077         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1078         mmf_return_val_if_fail(sc, FALSE);
1079
1080         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1081         mmf_return_val_if_fail(info, FALSE);
1082
1083         _mmstreamrec_dbg_log("(%d)", attr_idx);
1084
1085         if (value->value.i_val == MM_STREAMRECORDER_AUDIO_FORMAT_PCM_U8)
1086                 info->audio_encode_depth = 16;
1087         else
1088                 info->audio_encode_depth = 8;
1089
1090         return TRUE;
1091 }
1092
1093 bool _mmstreamrecorder_commit_video_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1094 {
1095         MMHandleType attr = 0;
1096         _MMStreamRecorderSubContext *sc = NULL;
1097         int v_bitrate;
1098
1099         mmf_return_val_if_fail(handle, FALSE);
1100         attr = MMF_STREAMRECORDER_ATTRS(handle);
1101         mmf_return_val_if_fail(attr, FALSE);
1102         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1103         mmf_return_val_if_fail(sc, FALSE);
1104
1105         v_bitrate = value->value.i_val;
1106
1107         if (sc->encode_element[_MMSTREAMRECORDER_ENCSINK_VENC].gst) {
1108                 MMSTREAMRECORDER_G_OBJECT_SET(sc->encode_element[_MMSTREAMRECORDER_ENCSINK_VENC].gst, "bitrate", v_bitrate);
1109                 _mmstreamrec_dbg_log("video bitrate set to encoder success = %d", v_bitrate);
1110         } else {
1111                 _mmstreamrec_dbg_log("_MMSTREAMRECORDER_ENCSINK_VENC is null %d", attr_idx);
1112         }
1113         return TRUE;
1114 }
1115
1116 bool _mmstreamrecorder_commit_audio_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1117 {
1118         MMHandleType attr = 0;
1119         _MMStreamRecorderSubContext *sc = NULL;
1120         _MMStreamRecorderAudioInfo *info = NULL;
1121
1122         mmf_return_val_if_fail(handle, FALSE);
1123         attr = MMF_STREAMRECORDER_ATTRS(handle);
1124         mmf_return_val_if_fail(attr, FALSE);
1125         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1126         mmf_return_val_if_fail(sc, FALSE);
1127
1128         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1129         mmf_return_val_if_fail(info, FALSE);
1130
1131         _mmstreamrec_dbg_log("(%d)", attr_idx);
1132
1133         info->iBitrate = value->value.i_val;
1134
1135         return TRUE;
1136 }
1137
1138 bool _mmstreamrecorder_commit_audio_channel(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1139 {
1140         MMHandleType attr = 0;
1141         _MMStreamRecorderSubContext *sc = NULL;
1142         _MMStreamRecorderAudioInfo *info = NULL;
1143
1144         mmf_return_val_if_fail(handle, FALSE);
1145         attr = MMF_STREAMRECORDER_ATTRS(handle);
1146         mmf_return_val_if_fail(attr, FALSE);
1147         sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1148         mmf_return_val_if_fail(sc, FALSE);
1149
1150         info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1151         mmf_return_val_if_fail(info, FALSE);
1152
1153         _mmstreamrec_dbg_log("(%d)", attr_idx);
1154
1155         info->iChannels = value->value.i_val;
1156
1157         return TRUE;
1158 }