4 * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hyuntae Kim <ht1211.kim@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 /*=======================================================================================
24 =======================================================================================*/
27 #include "mm_streamrecorder_util.h"
28 #include "mm_streamrecorder_attribute.h"
29 #include "mm_streamrecorder_gstdispatch.h"
31 /*-----------------------------------------------------------------------
32 | MACRO DEFINITIONS: |
33 -----------------------------------------------------------------------*/
34 #define MM_STREAMRECORDER_ATTRIBUTE_MAX_VALUE 15
35 #define MM_STREAMRECORDER_RESOLUTION_MAX_VALUE 4080
37 /*---------------------------------------------------------------------------------------
38 | GLOBAL VARIABLE DEFINITIONS for internal |
39 ---------------------------------------------------------------------------------------*/
41 /* basic attributes' info */
42 mm_streamrecorder_attr_construct_info stream_attrs_const_info[] = {
45 MM_STR_VIDEO_BUFFER_TYPE, /* ID */
46 "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 */
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,
68 MM_STR_VIDEO_FRAMERATE,
73 MM_ATTRS_VALID_TYPE_INT_RANGE,
75 _MMSTREAMRECORDER_MAX_INT,
80 MM_STR_VIDEO_ENCODER_BITRATE,
85 MM_ATTRS_VALID_TYPE_INT_RANGE,
87 _MMSTREAMRECORDER_MAX_INT,
88 NULL, /*_mmstreamrecorder_commit_video_bitrate, */
92 MM_STR_VIDEO_RESOLUTION_WIDTH,
93 "video-resolution-width",
97 MM_ATTRS_VALID_TYPE_INT_ARRAY,
104 MM_STR_VIDEO_RESOLUTION_HEIGHT,
105 "video-resolution-height",
109 MM_ATTRS_VALID_TYPE_INT_ARRAY,
117 "audio-source-format",
120 {(void *)MM_STREAMRECORDER_AUDIO_FORMAT_PCM_S16_LE},
122 MM_STREAMRECORDER_AUDIO_FORMAT_PCM_U8,
123 MM_STREAMRECORDER_AUDIO_FORMAT_PCM_S16_LE,
124 _mmstreamrecorder_commit_audio_bitformat,
128 MM_STR_AUDIO_ENCODER_BITRATE,
133 MM_ATTRS_VALID_TYPE_INT_RANGE,
135 _MMSTREAMRECORDER_MAX_INT,
136 _mmstreamrecorder_commit_audio_bitrate,
140 MM_STR_AUDIO_SAMPLERATE,
145 MM_ATTRS_VALID_TYPE_INT_RANGE,
147 _MMSTREAMRECORDER_MAX_INT,
148 _mmstreamrecorder_commit_audio_samplingrate,
152 MM_STR_VIDEO_ENCODER,
157 MM_ATTRS_VALID_TYPE_INT_ARRAY,
160 _mmstreamrecorder_commit_video_encoder,
164 MM_STR_AUDIO_ENCODER,
169 MM_ATTRS_VALID_TYPE_INT_ARRAY,
172 _mmstreamrecorder_commit_audio_encoder,
176 MM_STR_AUDIO_CHENNEL_COUNT,
177 "audio-channel-count",
181 MM_ATTRS_VALID_TYPE_INT_RANGE,
183 _MMSTREAMRECORDER_MAX_INT,
184 _mmstreamrecorder_commit_audio_channel,
193 MM_ATTRS_VALID_TYPE_INT_ARRAY,
200 MM_STR_TARGET_FILE_NAME,
202 MMF_VALUE_TYPE_STRING,
205 MM_ATTRS_VALID_TYPE_NONE,
217 MM_ATTRS_VALID_TYPE_NONE,
219 _MMSTREAMRECORDER_MAX_INT,
220 _mmstreamrecorder_commit_video_enable,
229 MM_ATTRS_VALID_TYPE_NONE,
231 _MMSTREAMRECORDER_MAX_INT,
232 _mmstreamrecorder_commit_audio_enable,
240 {(void *)MM_STREAMRECORDER_MODE_MEDIABUFFER},
241 MM_ATTRS_VALID_TYPE_NONE,
243 _MMSTREAMRECORDER_MAX_INT,
248 MM_STR_TARGET_MAX_SIZE,
253 MM_ATTRS_VALID_TYPE_INT_RANGE,
255 _MMSTREAMRECORDER_MAX_INT,
260 MM_STR_TARGET_TIME_LIMIT,
265 MM_ATTRS_VALID_TYPE_INT_RANGE,
267 _MMSTREAMRECORDER_MAX_INT,
273 /*-----------------------------------------------------------------------
274 | LOCAL VARIABLE DEFINITIONS for internal |
275 -----------------------------------------------------------------------*/
277 /*-----------------------------------------------------------------------
278 | LOCAL FUNCTION PROTOTYPES: |
279 -----------------------------------------------------------------------*/
280 /* STATIC INTERNAL FUNCTION */
281 static int __mmstreamrecorder_set_conf_to_valid_info(MMHandleType handle)
287 total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_WIDTH, &format);
288 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1 = (int)format;
289 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value2 = (int)total_count;
292 total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_HEIGHT, &format);
293 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1 = (int)format;
294 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value2 = (int)total_count;
297 total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_AUDIO_ENCODERS, &format);
298 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1 = (int)format;
299 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value2 = (int)total_count;
302 total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_VIDEO_ENCODERS, &format);
303 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1 = (int)format;
304 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value2 = (int)total_count;
307 total_count = _mmstreamrecorder_get_available_format(handle, KEYWORD_FILE_FORMATS, &format);
308 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1 = (int)format;
309 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value2 = (int)total_count;
311 return MM_ERROR_NONE;
314 static int __mmstreamrecorder_release_conf_valid_info(MMHandleType handle)
316 int *allocated_memory = NULL;
318 _mmstreamrec_dbg_log("START");
320 allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1);
321 if (allocated_memory) {
322 free(allocated_memory);
323 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value1 = (int)NULL;
324 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_WIDTH].validity_value2 = (int)0;
327 allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1);
328 if (allocated_memory) {
329 free(allocated_memory);
330 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value1 = (int)NULL;
331 stream_attrs_const_info[MM_STR_VIDEO_RESOLUTION_HEIGHT].validity_value2 = (int)0;
334 allocated_memory = (int *)(stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1);
335 if (allocated_memory) {
336 free(allocated_memory);
337 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value1 = (int)NULL;
338 stream_attrs_const_info[MM_STR_AUDIO_ENCODER].validity_value2 = (int)0;
341 allocated_memory = (int *)(stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1);
342 if (allocated_memory) {
343 free(allocated_memory);
344 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value1 = (int)NULL;
345 stream_attrs_const_info[MM_STR_VIDEO_ENCODER].validity_value2 = (int)0;
348 allocated_memory = (int *)(stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1);
349 if (allocated_memory) {
350 free(allocated_memory);
351 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value1 = (int)NULL;
352 stream_attrs_const_info[MM_STR_FILE_FORMAT].validity_value2 = (int)0;
354 _mmstreamrec_dbg_log("DONE");
356 return MM_ERROR_NONE;
360 static bool __mmstreamrecorder_attrs_is_supported(MMHandleType handle, int idx)
362 mmf_attrs_t *attr = (mmf_attrs_t *) handle;
365 if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
366 if (flag == MM_ATTRS_FLAG_NONE)
372 if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
374 mm_attrs_get_valid_range((MMHandleType) attr, idx, &min, &max);
377 } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
380 mm_attrs_get_valid_array((MMHandleType) attr, idx, &count, &array);
388 static int __mmstreamrecorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
390 #define INIT_VALUE -1
391 #define CHECK_COUNT 2
392 #define CAPTURE_RESOLUTION 1
394 mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
395 MMHandleType attrs = 0;
397 int ret = MM_ERROR_NONE;
399 const char *name = NULL;
400 const char *check_pair_name[2][3] = {
401 {MMSTR_VIDEO_RESOLUTION_WIDTH, MMSTR_VIDEO_RESOLUTION_HEIGHT, "MMSTR_VIDEO_RESOLUTION_WIDTH and HEIGHT"},
405 int check_pair_value[2][2] = {
406 {INIT_VALUE, INIT_VALUE},
407 {INIT_VALUE, INIT_VALUE},
410 if (hstreamrecorder == NULL || attribute_name == NULL) {
411 _mmstreamrec_dbg_warn("handle[%p] or attribute_name[%p] is NULL.", hstreamrecorder, attribute_name);
412 return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
416 *err_attr_name = NULL;
418 /* _mmstreamrec_dbg_log( "ENTER" ); */
420 attrs = MMF_STREAMRECORDER_ATTRS(handle);
422 name = attribute_name;
426 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
428 /*_mmstreamrec_dbg_log( "NAME : %s", name );*/
430 /* attribute name check */
431 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
433 *err_attr_name = strdup(name);
435 if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY)
436 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
442 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
446 case MM_ATTRS_TYPE_INT:
448 va_arg((var_args), int);
451 case MM_ATTRS_TYPE_DOUBLE:
452 va_arg((var_args), double);
454 case MM_ATTRS_TYPE_STRING:
455 va_arg((var_args), char *); /* string */
456 va_arg((var_args), int); /* size */
458 case MM_ATTRS_TYPE_DATA:
459 va_arg((var_args), void *); /* data */
460 va_arg((var_args), int); /* size */
462 case MM_ATTRS_TYPE_INVALID:
464 _mmstreamrec_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
466 *err_attr_name = strdup(name);
467 return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
471 name = va_arg(var_args, char *);
474 for (i = 0; i < CHECK_COUNT; i++) {
475 if (check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE) {
476 gboolean check_result = FALSE;
477 char *err_name = NULL;
478 MMStreamRecorderAttrsInfo attr_info_0, attr_info_1;
480 if (check_pair_value[i][0] == INIT_VALUE) {
481 mm_attrs_get_int_by_name(attrs, check_pair_name[i][0], &check_pair_value[i][0]);
482 err_name = strdup(check_pair_name[i][1]);
483 } else if (check_pair_value[i][1] == INIT_VALUE) {
484 mm_attrs_get_int_by_name(attrs, check_pair_name[i][1], &check_pair_value[i][1]);
485 err_name = strdup(check_pair_name[i][0]);
487 err_name = strdup(check_pair_name[i][2]);
490 mm_streamrecorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
491 mm_streamrecorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
493 check_result = FALSE;
495 for (j = 0; j < attr_info_0.int_array.count; j++) {
496 if (attr_info_0.int_array.array[j] == check_pair_value[i][0]
497 && attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
498 _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);
504 if (check_result == FALSE) {
505 _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]);
507 *err_attr_name = err_name;
509 return MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT;
519 /*_mmstreamrec_dbg_log("DONE");*/
521 return MM_ERROR_NONE;
524 /* attribute commiter */
525 void __mmstreamrecorder_print_attrs(const char *attr_name, const mmf_value_t * value, const char *cmt_way)
527 switch (value->type) {
528 case MMF_VALUE_TYPE_INT:
529 _mmstreamrec_dbg_log("%s :(%s:%d)", cmt_way, attr_name, value->value.i_val);
531 case MMF_VALUE_TYPE_DOUBLE:
532 _mmstreamrec_dbg_log("%s :(%s:%f)", cmt_way, attr_name, value->value.d_val);
534 case MMF_VALUE_TYPE_STRING:
535 _mmstreamrec_dbg_log("%s :(%s:%s)", cmt_way, attr_name, value->value.s_val);
537 case MMF_VALUE_TYPE_DATA:
538 _mmstreamrec_dbg_log("%s :(%s:%p)", cmt_way, attr_name, value->value.p_val);
547 int _mmstreamrecorder_get_audio_codec_format(MMHandleType handle, const char *name)
549 int codec_index = MM_AUDIO_CODEC_INVALID;
552 _mmstreamrec_dbg_err("name is NULL");
553 return MM_AUDIO_CODEC_INVALID;
556 if (!strcmp(name, "AMR"))
557 codec_index = MM_AUDIO_CODEC_AMR;
558 else if (!strcmp(name, "AAC"))
559 codec_index = MM_AUDIO_CODEC_AAC;
560 else if (!strcmp(name, "PCM"))
561 codec_index = MM_AUDIO_CODEC_WAVE;
562 else if (!strcmp(name, "VORBIS"))
563 codec_index = MM_AUDIO_CODEC_VORBIS;
568 int _mmstreamrecorder_get_video_codec_format(MMHandleType handle, const char *name)
570 int codec_index = MM_VIDEO_CODEC_INVALID;
573 _mmstreamrec_dbg_err("name is NULL");
574 return MM_VIDEO_CODEC_INVALID;
577 if (!strcmp(name, "H263"))
578 codec_index = MM_VIDEO_CODEC_H263;
579 else if (!strcmp(name, "H264"))
580 codec_index = MM_VIDEO_CODEC_H264;
581 else if (!strcmp(name, "MPEG4"))
582 codec_index = MM_VIDEO_CODEC_MPEG4;
588 int _mmstreamrecorder_get_mux_format(MMHandleType handle, const char *name)
590 int mux_index = MM_FILE_FORMAT_INVALID;
593 _mmstreamrec_dbg_err("name is NULL");
594 return MM_FILE_FORMAT_INVALID;
597 if (!strcmp(name, "3GP"))
598 mux_index = MM_FILE_FORMAT_3GP;
599 else if (!strcmp(name, "AMR"))
600 mux_index = MM_FILE_FORMAT_AMR;
601 else if (!strcmp(name, "MP4"))
602 mux_index = MM_FILE_FORMAT_MP4;
603 else if (!strcmp(name, "WAV"))
604 mux_index = MM_FILE_FORMAT_WAV;
609 int _mmstreamrecorder_get_format(MMHandleType handle , int category, const char *name)
613 mmf_return_val_if_fail(name, -1);
616 case KEYWORD_AUDIO_ENCODERS:
617 fmt = _mmstreamrecorder_get_audio_codec_format(handle, name);
619 case KEYWORD_VIDEO_ENCODERS:
620 fmt = _mmstreamrecorder_get_video_codec_format(handle, name);
622 case KEYWORD_FILE_FORMATS:
623 fmt = _mmstreamrecorder_get_mux_format(handle, name);
631 int _mmstreamrecorder_get_type_count(MMHandleType handle, int type)
633 mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
637 if (type == KEYWORD_VIDEO_WIDTH) {
638 while (hstreamrecorder->ini.supported_video_width[i++])
640 } else if (type == KEYWORD_VIDEO_HEIGHT) {
641 while (hstreamrecorder->ini.supported_video_height[i++])
643 } else if (type == KEYWORD_AUDIO_ENCODERS) {
644 while (hstreamrecorder->ini.supported_audio_encoders[i++][0])
646 } else if (type == KEYWORD_VIDEO_ENCODERS) {
647 while (hstreamrecorder->ini.supported_video_encoders[i++][0])
649 } else if (type == KEYWORD_FILE_FORMATS) {
650 while (hstreamrecorder->ini.supported_file_formats[i++][0])
656 void __mmstreamrecorder_get_supported_name(MMHandleType handle, int type , char **str, int i)
658 mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
659 if (type == KEYWORD_AUDIO_ENCODERS) {
660 *str = hstreamrecorder->ini.supported_audio_encoders[i];
662 } else if (type == KEYWORD_VIDEO_ENCODERS) {
663 *str = hstreamrecorder->ini.supported_video_encoders[i];
665 } else if (type == KEYWORD_FILE_FORMATS) {
666 *str = hstreamrecorder->ini.supported_file_formats[i];
674 int __mmstreamrecorder_get_supported_value(MMHandleType handle, int type, int i)
676 mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
678 if (type == KEYWORD_VIDEO_WIDTH)
679 return hstreamrecorder->ini.supported_video_width[i];
680 else if (type == KEYWORD_VIDEO_HEIGHT)
681 return hstreamrecorder->ini.supported_video_height[i];
687 _mmstreamrecorder_get_available_format(MMHandleType handle, int type, int ** format)
689 mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle);
695 const char *name = NULL;
697 mmf_return_val_if_fail(hstreamrecorder, 0);
699 count = _mmstreamrecorder_get_type_count(handle, type);
704 arr = (int*) g_malloc0(count * sizeof(int));
706 _mmstreamrec_dbg_err("malloc failed : %d", count * sizeof(int));
710 if (type == KEYWORD_VIDEO_WIDTH || type == KEYWORD_VIDEO_HEIGHT) {
711 for (i = 0 ; i < count ; i++) {
712 fmt = __mmstreamrecorder_get_supported_value(handle, type, i);
714 arr[total_count++] = fmt;
717 for (i = 0 ; i < count ; i++) {
718 __mmstreamrecorder_get_supported_name(handle, type, &name, i);
719 fmt = _mmstreamrecorder_get_format(handle, type, name);
721 arr[total_count++] = fmt;
728 /*=======================================================================
729 | FUNCTION DEFINITIONS |
730 =======================================================================*/
731 /*-----------------------------------------------------------------------
732 | GLOBAL FUNCTION DEFINITIONS: |
733 -----------------------------------------------------------------------*/
734 MMHandleType _mmstreamrecorder_alloc_attribute(MMHandleType handle)
736 _mmstreamrec_dbg_log("");
738 MMHandleType attrs = 0;
739 mmf_attrs_construct_info_t *attrs_const_info = NULL;
740 unsigned int attr_count = 0;
743 /* Create attribute constructor */
744 _mmstreamrec_dbg_log("start");
746 /* alloc 'mmf_attrs_construct_info_t' */
747 attr_count = ARRAY_SIZE(stream_attrs_const_info);
748 attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
750 if (!attrs_const_info) {
751 _mmstreamrec_dbg_err("Fail to alloc constructor.");
755 for (idx = 0; idx < attr_count; idx++) {
756 /* attribute order check. This should be same. */
757 if (idx != stream_attrs_const_info[idx].attrid) {
758 _mmstreamrec_dbg_err("Please check attributes order. Is the idx same with enum val?");
759 free(attrs_const_info);
760 attrs_const_info = NULL;
764 attrs_const_info[idx].name = stream_attrs_const_info[idx].name;
765 attrs_const_info[idx].value_type = stream_attrs_const_info[idx].value_type;
766 attrs_const_info[idx].flags = stream_attrs_const_info[idx].flags;
767 attrs_const_info[idx].default_value = stream_attrs_const_info[idx].default_value.value_void;
770 _mmstreamrec_dbg_log("Create Streamrecorder Attributes[%p, %d]", attrs_const_info, attr_count);
772 attrs = mmf_attrs_new_from_data("Streamrecorder_Attributes", attrs_const_info, attr_count, _mmstreamrecorder_commit_streamrecorder_attrs, (void *)handle);
774 free(attrs_const_info);
775 attrs_const_info = NULL;
778 _mmstreamrec_dbg_err("Fail to alloc attribute handle");
782 __mmstreamrecorder_set_conf_to_valid_info(handle);
784 for (idx = 0; idx < attr_count; idx++) {
785 mmf_attrs_set_valid_type(attrs, idx, stream_attrs_const_info[idx].validity_type);
787 switch (stream_attrs_const_info[idx].validity_type) {
788 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
789 if (stream_attrs_const_info[idx].validity_value1 && stream_attrs_const_info[idx].validity_value2 > 0)
790 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));
792 case MM_ATTRS_VALID_TYPE_INT_RANGE:
793 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));
795 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
796 if (stream_attrs_const_info[idx].validity_value1 && stream_attrs_const_info[idx].validity_value2 > 0)
797 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));
799 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
800 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));
802 case MM_ATTRS_VALID_TYPE_NONE:
804 case MM_ATTRS_VALID_TYPE_INVALID:
806 _mmstreamrec_dbg_err("Valid type error.");
811 __mmstreamrecorder_release_conf_valid_info(handle);
816 void _mmstreamrecorder_dealloc_attribute(MMHandleType attrs)
818 _mmstreamrec_dbg_log("");
821 mmf_attrs_free(attrs);
823 _mmstreamrec_dbg_log("released attribute");
827 int _mmstreamrecorder_get_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
829 MMHandleType attrs = 0;
830 int ret = MM_ERROR_NONE;
832 mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
834 attrs = MMF_STREAMRECORDER_ATTRS(handle);
835 mmf_return_val_if_fail(attrs, MM_ERROR_STREAMRECORDER_NOT_INITIALIZED);
837 ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
842 int _mmstreamrecorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
844 MMHandleType attrs = 0;
845 int ret = MM_ERROR_NONE;
847 mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
849 attrs = MMF_STREAMRECORDER_ATTRS(handle);
851 _mmstreamrec_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
852 return MM_ERROR_STREAMRECORDER_NOT_INITIALIZED;
855 ret = __mmstreamrecorder_check_valid_pair(handle, err_attr_name, attribute_name, var_args);
857 _mmstreamrec_dbg_err("__mmstreamrecorder_check_valid_pair handle 0x%x, attr name [%s] , ret = %d", handle, attribute_name, ret);
859 if (ret == MM_ERROR_NONE)
860 ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
862 _mmstreamrec_dbg_err("mm_attrs_set_valist handle 0x%x, attr name [%s] , ret = %d", handle, attribute_name, ret);
866 int _mmstreamrecorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMStreamRecorderAttrsInfo * info)
868 MMHandleType attrs = 0;
869 MMAttrsInfo attrinfo;
870 int ret = MM_ERROR_NONE;
872 mmf_return_val_if_fail(handle, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
873 mmf_return_val_if_fail(attr_name, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
874 mmf_return_val_if_fail(info, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
876 attrs = MMF_STREAMRECORDER_ATTRS(handle);
877 mmf_return_val_if_fail(attrs, MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT);
879 ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo *) & attrinfo);
881 if (ret == MM_ERROR_NONE) {
882 memset(info, 0x00, sizeof(MMStreamRecorderAttrsInfo));
883 info->type = attrinfo.type;
884 info->flag = attrinfo.flag;
885 info->validity_type = attrinfo.validity_type;
887 switch (attrinfo.validity_type) {
888 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
889 info->int_array.array = attrinfo.int_array.array;
890 info->int_array.count = attrinfo.int_array.count;
891 info->int_array.def = attrinfo.int_array.dval;
893 case MM_ATTRS_VALID_TYPE_INT_RANGE:
894 info->int_range.min = attrinfo.int_range.min;
895 info->int_range.max = attrinfo.int_range.max;
896 info->int_range.def = attrinfo.int_range.dval;
898 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
899 info->double_array.array = attrinfo.double_array.array;
900 info->double_array.count = attrinfo.double_array.count;
901 info->double_array.def = attrinfo.double_array.dval;
903 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
904 info->double_range.min = attrinfo.double_range.min;
905 info->double_range.max = attrinfo.double_range.max;
906 info->double_range.def = attrinfo.double_range.dval;
908 case MM_ATTRS_VALID_TYPE_NONE:
910 case MM_ATTRS_VALID_TYPE_INVALID:
919 bool _mmstreamrecorder_commit_streamrecorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t * value, void *commit_param)
923 mmf_return_val_if_fail(commit_param, FALSE);
924 mmf_return_val_if_fail(attr_idx >= 0, FALSE);
925 mmf_return_val_if_fail(attr_name, FALSE);
926 mmf_return_val_if_fail(value, FALSE);
928 if (stream_attrs_const_info[attr_idx].attr_commit) {
929 /* _mmstreamrec_dbg_log("Dynamic commit:(%s)", attr_name); */
930 __mmstreamrecorder_print_attrs(attr_name, value, "Dynamic");
931 bret = stream_attrs_const_info[attr_idx].attr_commit((MMHandleType) commit_param, attr_idx, value);
933 /* _mmstreamrec_dbg_log("Static commit:(%s)", attr_name); */
934 __mmstreamrecorder_print_attrs(attr_name, value, "Static");
941 bool _mmstreamrecorder_commit_video_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
943 MMHandleType attr = 0;
944 /* mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle); */
945 _MMStreamRecorderSubContext *sc = NULL;
946 _MMStreamRecorderVideoInfo *info = NULL;
948 mmf_return_val_if_fail(handle, FALSE);
949 attr = MMF_STREAMRECORDER_ATTRS(handle);
950 mmf_return_val_if_fail(attr, FALSE);
951 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
953 _mmstreamrec_dbg_log("(%d)", attr_idx);
955 mmf_return_val_if_fail(sc, FALSE);
957 info = (_MMStreamRecorderVideoInfo *) sc->info_video;
959 if (info == NULL && value->value.i_val != 0) {
960 if (_mmstreamrecorder_alloc_subcontext_videoinfo(handle))
967 bool _mmstreamrecorder_commit_video_encoder(MMHandleType handle, int attr_idx, const mmf_value_t *value)
969 MMHandleType attr = 0;
970 _MMStreamRecorderSubContext *sc = NULL;
971 _MMStreamRecorderVideoInfo *info = NULL;
973 mmf_return_val_if_fail(handle, FALSE);
974 attr = MMF_STREAMRECORDER_ATTRS(handle);
975 mmf_return_val_if_fail(attr, FALSE);
976 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
977 mmf_return_val_if_fail(sc, FALSE);
979 info = (_MMStreamRecorderVideoInfo *) sc->info_video;
980 mmf_return_val_if_fail(info, FALSE);
982 _mmstreamrec_dbg_log("(%d)", attr_idx);
984 info->iVideoEncoder = value->value.i_val;
989 bool _mmstreamrecorder_commit_audio_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
991 MMHandleType attr = 0;
992 /* mmf_streamrecorder_t *hstreamrecorder = MMF_STREAMRECORDER(handle); */
993 _MMStreamRecorderSubContext *sc = NULL;
994 _MMStreamRecorderAudioInfo *info = NULL;
996 mmf_return_val_if_fail(handle, FALSE);
997 attr = MMF_STREAMRECORDER_ATTRS(handle);
998 mmf_return_val_if_fail(attr, FALSE);
999 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1000 mmf_return_val_if_fail(sc, FALSE);
1002 _mmstreamrec_dbg_log("(%d)", attr_idx);
1004 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1006 if (info == NULL && value->value.i_val != 0) {
1007 if (_mmstreamrecorder_alloc_subcontext_audioinfo(handle))
1014 bool _mmstreamrecorder_commit_audio_encoder(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1016 MMHandleType attr = 0;
1017 _MMStreamRecorderSubContext *sc = NULL;
1018 _MMStreamRecorderAudioInfo *info = NULL;
1020 mmf_return_val_if_fail(handle, FALSE);
1021 attr = MMF_STREAMRECORDER_ATTRS(handle);
1022 mmf_return_val_if_fail(attr, FALSE);
1023 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1024 mmf_return_val_if_fail(sc, FALSE);
1026 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1027 mmf_return_val_if_fail(info, FALSE);
1029 _mmstreamrec_dbg_log("(%d)", attr_idx);
1031 info->iAudioEncoder = value->value.i_val;
1036 bool _mmstreamrecorder_commit_audio_samplingrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1038 MMHandleType attr = 0;
1039 _MMStreamRecorderSubContext *sc = NULL;
1040 _MMStreamRecorderAudioInfo *info = NULL;
1042 mmf_return_val_if_fail(handle, FALSE);
1043 attr = MMF_STREAMRECORDER_ATTRS(handle);
1044 mmf_return_val_if_fail(attr, FALSE);
1045 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1046 mmf_return_val_if_fail(sc, FALSE);
1048 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1049 mmf_return_val_if_fail(info, FALSE);
1051 _mmstreamrec_dbg_log("(%d)", attr_idx);
1053 info->iSamplingRate = value->value.i_val;
1058 bool _mmstreamrecorder_commit_audio_bitformat(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1060 MMHandleType attr = 0;
1061 _MMStreamRecorderSubContext *sc = NULL;
1062 _MMStreamRecorderAudioInfo *info = NULL;
1064 mmf_return_val_if_fail(handle, FALSE);
1065 attr = MMF_STREAMRECORDER_ATTRS(handle);
1066 mmf_return_val_if_fail(attr, FALSE);
1067 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1068 mmf_return_val_if_fail(sc, FALSE);
1070 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1071 mmf_return_val_if_fail(info, FALSE);
1073 _mmstreamrec_dbg_log("(%d)", attr_idx);
1075 if (value->value.i_val == MM_STREAMRECORDER_AUDIO_FORMAT_PCM_U8)
1076 info->audio_encode_depth = 16;
1078 info->audio_encode_depth = 8;
1083 bool _mmstreamrecorder_commit_video_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1085 MMHandleType attr = 0;
1086 _MMStreamRecorderSubContext *sc = NULL;
1089 mmf_return_val_if_fail(handle, FALSE);
1090 attr = MMF_STREAMRECORDER_ATTRS(handle);
1091 mmf_return_val_if_fail(attr, FALSE);
1092 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1093 mmf_return_val_if_fail(sc, FALSE);
1095 v_bitrate = value->value.i_val;
1097 if (sc->encode_element[_MMSTREAMRECORDER_ENCSINK_VENC].gst) {
1098 MMSTREAMRECORDER_G_OBJECT_SET(sc->encode_element[_MMSTREAMRECORDER_ENCSINK_VENC].gst, "bitrate", v_bitrate);
1099 _mmstreamrec_dbg_log("video bitrate set to encoder success = %d", v_bitrate);
1101 _mmstreamrec_dbg_log("_MMSTREAMRECORDER_ENCSINK_VENC is null %d", attr_idx);
1106 bool _mmstreamrecorder_commit_audio_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1108 MMHandleType attr = 0;
1109 _MMStreamRecorderSubContext *sc = NULL;
1110 _MMStreamRecorderAudioInfo *info = NULL;
1112 mmf_return_val_if_fail(handle, FALSE);
1113 attr = MMF_STREAMRECORDER_ATTRS(handle);
1114 mmf_return_val_if_fail(attr, FALSE);
1115 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1116 mmf_return_val_if_fail(sc, FALSE);
1118 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1119 mmf_return_val_if_fail(info, FALSE);
1121 _mmstreamrec_dbg_log("(%d)", attr_idx);
1123 info->iBitrate = value->value.i_val;
1128 bool _mmstreamrecorder_commit_audio_channel(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1130 MMHandleType attr = 0;
1131 _MMStreamRecorderSubContext *sc = NULL;
1132 _MMStreamRecorderAudioInfo *info = NULL;
1134 mmf_return_val_if_fail(handle, FALSE);
1135 attr = MMF_STREAMRECORDER_ATTRS(handle);
1136 mmf_return_val_if_fail(attr, FALSE);
1137 sc = MMF_STREAMRECORDER_SUBCONTEXT(handle);
1138 mmf_return_val_if_fail(sc, FALSE);
1140 info = (_MMStreamRecorderAudioInfo *) sc->info_audio;
1141 mmf_return_val_if_fail(info, FALSE);
1143 _mmstreamrec_dbg_log("(%d)", attr_idx);
1145 info->iChannels = value->value.i_val;
1150 int mm_streamrecorder_get_attribute_info(MMHandleType streamrecorder, const char *attribute_name, MMStreamRecorderAttrsInfo * info)
1152 return _mmstreamrecorder_get_attribute_info(streamrecorder, attribute_name, info);