1/*
2 INTEL CONFIDENTIAL
3 Copyright 2009 Intel Corporation All Rights Reserved.
4 The source code contained or described herein and all documents related to the source code ("Material") are owned by Intel Corporation or its suppliers or licensors. Title to the Material remains with Intel Corporation or its suppliers and licensors. The Material contains trade secrets and proprietary and confidential information of Intel or its suppliers and licensors. The Material is protected by worldwide copyright and trade secret laws and treaty provisions. No part of the Material may be used, copied, reproduced, modified, published, uploaded, posted, transmitted, distributed, or disclosed in any way without Intel’s prior express written permission.
5
6 No license under any patent, copyright, trade secret or other intellectual property right is granted to or conferred upon you by disclosure or delivery of the Materials, either expressly, by implication, inducement, estoppel or otherwise. Any license under such intellectual property rights must be express and approved by Intel in writing.
7 */
8
9/**
10 * SECTION:mixvideoconfigparamsenc
11 * @short_description: VideoConfig parameters
12 *
13 * A data object which stores videoconfig specific parameters.
14 */
15
16#include <string.h>
17#include "mixvideolog.h"
18#include "mixvideoconfigparamsenc.h"
19
20static GType _mix_videoconfigparamsenc_type = 0;
21static MixParamsClass *parent_class = NULL;
22
23#define MDEBUG
24
25#define _do_init { _mix_videoconfigparamsenc_type = g_define_type_id; }
26
27gboolean mix_videoconfigparamsenc_copy(MixParams * target, const MixParams * src);
28MixParams *mix_videoconfigparamsenc_dup(const MixParams * obj);
29gboolean mix_videoconfigparamsenc_equal(MixParams * first, MixParams * second);
30static void mix_videoconfigparamsenc_finalize(MixParams * obj);
31
32G_DEFINE_TYPE_WITH_CODE (MixVideoConfigParamsEnc, mix_videoconfigparamsenc,
33		MIX_TYPE_VIDEOCONFIGPARAMS, _do_init);
34
35static void mix_videoconfigparamsenc_init(MixVideoConfigParamsEnc * self) {
36    /* initialize properties here */
37	self->bitrate = 0;
38	self->frame_rate_num = 30;
39	self->frame_rate_denom = 1;
40	self->initial_qp = 15;
41	self->min_qp = 0;
42
43	self->picture_width = 0;
44	self->picture_height = 0;
45
46	self->mime_type = NULL;
47	self->encode_format = 0;
48	self->intra_period = 30;
49
50	self->mixbuffer_pool_size = 0;
51
52	self->share_buf_mode = FALSE;
53
54	self->ci_frame_id = NULL;
55	self->ci_frame_num = 0;
56
57	self->need_display = TRUE;
58
59	self->rate_control = MIX_RATE_CONTROL_NONE;
60	self->raw_format = MIX_RAW_TARGET_FORMAT_YUV420;
61	self->profile = MIX_PROFILE_H264BASELINE;
62
63	/* TODO: initialize other properties */
64	self->reserved1 = NULL;
65	self->reserved2 = NULL;
66	self->reserved3 = NULL;
67	self->reserved4 = NULL;
68}
69
70static void mix_videoconfigparamsenc_class_init(MixVideoConfigParamsEncClass * klass) {
71    MixParamsClass *mixparams_class = MIX_PARAMS_CLASS(klass);
72
73    /* setup static parent class */
74    parent_class = (MixParamsClass *) g_type_class_peek_parent(klass);
75
76    mixparams_class->finalize = mix_videoconfigparamsenc_finalize;
77    mixparams_class->copy = (MixParamsCopyFunction) mix_videoconfigparamsenc_copy;
78    mixparams_class->dup = (MixParamsDupFunction) mix_videoconfigparamsenc_dup;
79    mixparams_class->equal
80        = (MixParamsEqualFunction) mix_videoconfigparamsenc_equal;
81}
82
83MixVideoConfigParamsEnc *
84mix_videoconfigparamsenc_new(void) {
85    MixVideoConfigParamsEnc *ret =
86        (MixVideoConfigParamsEnc *) g_type_create_instance(
87                MIX_TYPE_VIDEOCONFIGPARAMSENC);
88
89    return ret;
90}
91
92void mix_videoconfigparamsenc_finalize(MixParams * obj) {
93
94	/* clean up here. */
95	MixVideoConfigParamsEnc *self = MIX_VIDEOCONFIGPARAMSENC(obj);
96
97	/* free mime_type */
98	if (self->mime_type->str)
99		g_string_free(self->mime_type, TRUE);
100	else
101		g_string_free(self->mime_type, FALSE);
102
103	if (self->ci_frame_id)
104		g_free (self->ci_frame_id);
105
106	/* Chain up parent */
107	if (parent_class->finalize) {
108		parent_class->finalize(obj);
109	}
110}
111
112MixVideoConfigParamsEnc *
113mix_videoconfigparamsenc_ref(MixVideoConfigParamsEnc * mix) {
114    return (MixVideoConfigParamsEnc *) mix_params_ref(MIX_PARAMS(mix));
115}
116
117/**
118 * mix_videoconfigparamsenc_dup:
119 * @obj: a #MixVideoConfigParamsEnc object
120 * @returns: a newly allocated duplicate of the object.
121 *
122 * Copy duplicate of the object.
123 */
124MixParams *
125mix_videoconfigparamsenc_dup(const MixParams * obj) {
126    MixParams *ret = NULL;
127
128    LOG_V( "Begin\n");
129
130    if (MIX_IS_VIDEOCONFIGPARAMSENC(obj)) {
131        MixVideoConfigParamsEnc *duplicate = mix_videoconfigparamsenc_new();
132        if (mix_videoconfigparamsenc_copy(MIX_PARAMS(duplicate), MIX_PARAMS(obj))) {
133
134			ret = MIX_PARAMS(duplicate);
135		} else {
136			mix_videoconfigparamsenc_unref(duplicate);
137		}
138	}
139	return ret;
140}
141
142/**
143 * mix_videoconfigparamsenc_copy:
144 * @target: copy to target
145 * @src: copy from src
146 * @returns: boolean indicates if copy is successful.
147 *
148 * Copy instance data from @src to @target.
149 */
150gboolean mix_videoconfigparamsenc_copy(MixParams * target, const MixParams * src) {
151
152	MixVideoConfigParamsEnc *this_target, *this_src;
153	MIX_RESULT mix_result = MIX_RESULT_FAIL;
154
155    LOG_V( "Begin\n");
156
157	if (MIX_IS_VIDEOCONFIGPARAMSENC(target) && MIX_IS_VIDEOCONFIGPARAMSENC(src)) {
158
159		/* Cast the base object to this child object */
160		this_target = MIX_VIDEOCONFIGPARAMSENC(target);
161		this_src = MIX_VIDEOCONFIGPARAMSENC(src);
162
163		/* copy properties of primitive type */
164
165		this_target->bitrate   = this_src->bitrate;
166		this_target->frame_rate_num = this_src->frame_rate_num;
167		this_target->frame_rate_denom = this_src->frame_rate_denom;
168		this_target->initial_qp = this_src->initial_qp;
169		this_target->min_qp = this_src->min_qp;
170		this_target->intra_period    = this_src->intra_period;
171		this_target->picture_width    = this_src->picture_width;
172		this_target->picture_height   = this_src->picture_height;
173		this_target->mixbuffer_pool_size = this_src->mixbuffer_pool_size;
174		this_target->share_buf_mode = this_src->share_buf_mode;
175		this_target->encode_format = this_src->encode_format;
176		this_target->ci_frame_num = this_src->ci_frame_num;
177		this_target->draw= this_src->draw;
178		this_target->need_display = this_src->need_display;
179	       this_target->rate_control = this_src->rate_control;
180	       this_target->raw_format = this_src->raw_format;
181	       this_target->profile = this_src->profile;
182
183		/* copy properties of non-primitive */
184
185		/* copy mime_type */
186
187		if (this_src->mime_type) {
188#ifdef MDEBUG
189            if (this_src->mime_type->str) {
190
191                LOG_I( "this_src->mime_type->str = %s  %x\n",
192                        this_src->mime_type->str, (unsigned int)this_src->mime_type->str);
193            }
194#endif
195
196            mix_result = mix_videoconfigparamsenc_set_mime_type(this_target,
197                    this_src->mime_type->str);
198        } else {
199
200            LOG_I( "this_src->mime_type = NULL\n");
201
202            mix_result = mix_videoconfigparamsenc_set_mime_type(this_target, NULL);
203        }
204
205        if (mix_result != MIX_RESULT_SUCCESS) {
206
207            LOG_E( "Failed to mix_videoconfigparamsenc_set_mime_type\n");
208            return FALSE;
209        }
210
211        mix_result = mix_videoconfigparamsenc_set_ci_frame_info (this_target, this_src->ci_frame_id,
212                this_src->ci_frame_num);
213
214        /* TODO: copy other properties if there's any */
215
216		/* Now chainup base class */
217		if (parent_class->copy) {
218            return parent_class->copy(MIX_PARAMS_CAST(target), MIX_PARAMS_CAST(
219                        src));
220        } else {
221            return TRUE;
222        }
223    }
224
225    return FALSE;
226}
227
228
229/**
230 * mix_videoconfigparamsenc_:
231 * @first: first object to compare
232 * @second: seond object to compare
233 * @returns: boolean indicates if instance are equal.
234 *
235 * Copy instance data from @src to @target.
236 */
237gboolean mix_videoconfigparamsenc_equal(MixParams * first, MixParams * second) {
238
239	gboolean ret = FALSE;
240
241	MixVideoConfigParamsEnc *this_first, *this_second;
242
243	if (MIX_IS_VIDEOCONFIGPARAMSENC(first) && MIX_IS_VIDEOCONFIGPARAMSENC(second)) {
244
245		// Deep compare
246		// Cast the base object to this child object
247		this_first = MIX_VIDEOCONFIGPARAMSENC(first);
248		this_second = MIX_VIDEOCONFIGPARAMSENC(second);
249
250		/* check the equalitiy of the primitive type properties */
251		if (this_first->bitrate != this_second->bitrate) {
252			goto not_equal;
253		}
254
255		if (this_first->frame_rate_num != this_second->frame_rate_num) {
256			goto not_equal;
257		}
258
259		if (this_first->frame_rate_denom != this_second->frame_rate_denom) {
260			goto not_equal;
261		}
262
263		if (this_first->initial_qp != this_second->initial_qp) {
264			goto not_equal;
265		}
266
267		if (this_first->min_qp != this_second->min_qp) {
268			goto not_equal;
269		}
270
271		if (this_first->intra_period != this_second->intra_period) {
272			goto not_equal;
273		}
274
275		if (this_first->picture_width != this_second->picture_width
276				&& this_first->picture_height != this_second->picture_height) {
277			goto not_equal;
278		}
279
280		if (this_first->encode_format != this_second->encode_format) {
281			goto not_equal;
282		}
283
284		if (this_first->mixbuffer_pool_size != this_second->mixbuffer_pool_size) {
285			goto not_equal;
286		}
287
288		if (this_first->share_buf_mode != this_second->share_buf_mode) {
289			goto not_equal;
290		}
291
292		if (this_first->ci_frame_id != this_second->ci_frame_id) {
293			goto not_equal;
294		}
295
296		if (this_first->ci_frame_num != this_second->ci_frame_num) {
297			goto not_equal;
298		}
299
300		if (this_first->draw != this_second->draw) {
301			goto not_equal;
302		}
303
304		if (this_first->need_display!= this_second->need_display) {
305			goto not_equal;
306		}
307
308	      if (this_first->rate_control != this_second->rate_control) {
309		  	goto not_equal;
310		}
311
312	      if (this_first->raw_format != this_second->raw_format) {
313		  	goto not_equal;
314		}
315
316	      if (this_first->profile != this_second->profile) {
317		  	goto not_equal;
318		}
319
320		/* check the equalitiy of the none-primitive type properties */
321
322		/* compare mime_type */
323
324		if (this_first->mime_type && this_second->mime_type) {
325			if (g_string_equal(this_first->mime_type, this_second->mime_type)
326					!= TRUE) {
327				goto not_equal;
328			}
329		} else if (!(!this_first->mime_type && !this_second->mime_type)) {
330			goto not_equal;
331		}
332
333		ret = TRUE;
334
335		not_equal:
336
337		if (ret != TRUE) {
338			return ret;
339		}
340
341		/* chaining up. */
342		MixParamsClass *klass = MIX_PARAMS_CLASS(parent_class);
343		if (klass->equal)
344			ret = parent_class->equal(first, second);
345		else
346			ret = TRUE;
347	}
348
349	return ret;
350}
351
352#define MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT(obj) \
353	if(!obj) return MIX_RESULT_NULL_PTR; \
354	if(!MIX_IS_VIDEOCONFIGPARAMSENC(obj)) return MIX_RESULT_FAIL; \
355
356#define MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT(obj, prop) \
357	if(!obj || !prop) return MIX_RESULT_NULL_PTR; \
358	if(!MIX_IS_VIDEOCONFIGPARAMSENC(obj)) return MIX_RESULT_FAIL; \
359
360#define MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT_PAIR(obj, prop, prop2) \
361	if(!obj || !prop || !prop2 ) return MIX_RESULT_NULL_PTR; \
362	if(!MIX_IS_VIDEOCONFIGPARAMSENC(obj)) return MIX_RESULT_FAIL; \
363
364/* TODO: Add getters and setters for other properties. The following is incomplete */
365
366
367MIX_RESULT mix_videoconfigparamsenc_set_mime_type(MixVideoConfigParamsEnc * obj,
368		const gchar * mime_type) {
369
370	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
371
372	if (!mime_type) {
373		return MIX_RESULT_NULL_PTR;
374	}
375
376	LOG_I( "mime_type = %s  %x\n",
377		mime_type, (unsigned int)mime_type);
378
379	if (obj->mime_type) {
380		if (obj->mime_type->str)
381			g_string_free(obj->mime_type, TRUE);
382		else
383			g_string_free(obj->mime_type, FALSE);
384	}
385
386
387	LOG_I( "mime_type = %s  %x\n",
388		mime_type, (unsigned int)mime_type);
389
390	obj->mime_type = g_string_new(mime_type);
391	if (!obj->mime_type) {
392		return MIX_RESULT_NO_MEMORY;
393	}
394
395
396	LOG_I( "mime_type = %s obj->mime_type->str = %s\n",
397			mime_type, obj->mime_type->str);
398
399	return MIX_RESULT_SUCCESS;
400}
401
402MIX_RESULT mix_videoconfigparamsenc_get_mime_type(MixVideoConfigParamsEnc * obj,
403		gchar ** mime_type) {
404	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, mime_type);
405
406	if (!obj->mime_type) {
407		*mime_type = NULL;
408		return MIX_RESULT_SUCCESS;
409	}
410	*mime_type = g_strdup(obj->mime_type->str);
411	if (!*mime_type) {
412		return MIX_RESULT_NO_MEMORY;
413	}
414
415	return MIX_RESULT_SUCCESS;
416}
417
418MIX_RESULT mix_videoconfigparamsenc_set_frame_rate(MixVideoConfigParamsEnc * obj,
419		guint frame_rate_num, guint frame_rate_denom) {
420	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
421	obj->frame_rate_num = frame_rate_num;
422	obj->frame_rate_denom = frame_rate_denom;
423	return MIX_RESULT_SUCCESS;
424}
425
426MIX_RESULT mix_videoconfigparamsenc_get_frame_rate(MixVideoConfigParamsEnc * obj,
427		guint * frame_rate_num, guint * frame_rate_denom) {
428	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT_PAIR (obj, frame_rate_num, frame_rate_denom);
429	*frame_rate_num = obj->frame_rate_num;
430	*frame_rate_denom = obj->frame_rate_denom;
431	return MIX_RESULT_SUCCESS;
432}
433
434MIX_RESULT mix_videoconfigparamsenc_set_picture_res(MixVideoConfigParamsEnc * obj,
435		guint picture_width, guint picture_height) {
436	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
437	obj->picture_width = picture_width;
438	obj->picture_height = picture_height;
439	return MIX_RESULT_SUCCESS;
440}
441
442MIX_RESULT mix_videoconfigparamsenc_get_picture_res(MixVideoConfigParamsEnc * obj,
443        guint * picture_width, guint * picture_height) {
444	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT_PAIR (obj, picture_width, picture_height);
445	*picture_width = obj->picture_width;
446	*picture_height = obj->picture_height;
447	return MIX_RESULT_SUCCESS;
448}
449
450MIX_RESULT mix_videoconfigparamsenc_set_encode_format(MixVideoConfigParamsEnc * obj,
451		MixEncodeTargetFormat encode_format) {
452	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
453	obj->encode_format = encode_format;
454	return MIX_RESULT_SUCCESS;
455}
456
457MIX_RESULT mix_videoconfigparamsenc_get_encode_format (MixVideoConfigParamsEnc * obj,
458		MixEncodeTargetFormat* encode_format) {
459	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, encode_format);
460       *encode_format = obj->encode_format;
461	return MIX_RESULT_SUCCESS;
462}
463
464MIX_RESULT mix_videoconfigparamsenc_set_bit_rate (MixVideoConfigParamsEnc * obj,
465        guint bitrate) {
466	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
467	obj->bitrate= bitrate;
468	return MIX_RESULT_SUCCESS;
469
470}
471
472MIX_RESULT mix_videoconfigparamsenc_get_bit_rate (MixVideoConfigParamsEnc * obj,
473        guint *bitrate) {
474	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, bitrate);
475	*bitrate = obj->bitrate;
476	return MIX_RESULT_SUCCESS;
477}
478
479MIX_RESULT mix_videoconfigparamsenc_set_init_qp (MixVideoConfigParamsEnc * obj,
480        guint initial_qp) {
481	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
482	obj->initial_qp = initial_qp;
483	return MIX_RESULT_SUCCESS;
484}
485
486MIX_RESULT mix_videoconfigparamsenc_get_init_qp (MixVideoConfigParamsEnc * obj,
487        guint *initial_qp) {
488	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, initial_qp);
489	*initial_qp = obj->initial_qp;
490	return MIX_RESULT_SUCCESS;
491
492}
493
494MIX_RESULT mix_videoconfigparamsenc_set_min_qp (MixVideoConfigParamsEnc * obj,
495        guint min_qp) {
496	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
497	obj->min_qp = min_qp;
498	return MIX_RESULT_SUCCESS;
499}
500
501MIX_RESULT mix_videoconfigparamsenc_get_min_qp(MixVideoConfigParamsEnc * obj,
502        guint *min_qp) {
503    MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, min_qp);
504    *min_qp = obj->min_qp;
505
506    return MIX_RESULT_SUCCESS;
507}
508
509MIX_RESULT mix_videoconfigparamsenc_set_intra_period (MixVideoConfigParamsEnc * obj,
510        guint intra_period) {
511	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
512	obj->intra_period = intra_period;
513
514	return MIX_RESULT_SUCCESS;
515}
516
517MIX_RESULT mix_videoconfigparamsenc_get_intra_period (MixVideoConfigParamsEnc * obj,
518        guint *intra_period) {
519	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, intra_period);
520	*intra_period = obj->intra_period;
521
522	return MIX_RESULT_SUCCESS;
523}
524
525MIX_RESULT mix_videoconfigparamsenc_set_buffer_pool_size(
526		MixVideoConfigParamsEnc * obj, guint bufpoolsize) {
527
528	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
529
530	obj->mixbuffer_pool_size = bufpoolsize;
531	return MIX_RESULT_SUCCESS;
532
533}
534
535MIX_RESULT mix_videoconfigparamsenc_get_buffer_pool_size(
536		MixVideoConfigParamsEnc * obj, guint *bufpoolsize) {
537
538	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, bufpoolsize);
539	*bufpoolsize = obj->mixbuffer_pool_size;
540	return MIX_RESULT_SUCCESS;
541}
542
543MIX_RESULT mix_videoconfigparamsenc_set_share_buf_mode (
544	MixVideoConfigParamsEnc * obj, gboolean share_buf_mod) {
545	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
546
547	obj->share_buf_mode = share_buf_mod;
548	return MIX_RESULT_SUCCESS;
549}
550
551MIX_RESULT mix_videoconfigparamsenc_get_share_buf_mode(MixVideoConfigParamsEnc * obj,
552		gboolean *share_buf_mod) {
553	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, share_buf_mod);
554
555	*share_buf_mod = obj->share_buf_mode;
556	return MIX_RESULT_SUCCESS;
557}
558
559MIX_RESULT mix_videoconfigparamsenc_set_ci_frame_info(MixVideoConfigParamsEnc * obj,
560        gulong * ci_frame_id, guint ci_frame_num) {
561	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
562
563
564	if (!ci_frame_id || !ci_frame_num) {
565		obj->ci_frame_id = NULL;
566		obj->ci_frame_num = 0;
567		return MIX_RESULT_SUCCESS;
568	}
569
570	if (obj->ci_frame_id)
571		g_free (obj->ci_frame_id);
572
573	guint size = ci_frame_num * sizeof (gulong);
574	obj->ci_frame_num = ci_frame_num;
575
576	obj->ci_frame_id = g_malloc (ci_frame_num * sizeof (gulong));
577	if (!(obj->ci_frame_id)) {
578		return MIX_RESULT_NO_MEMORY;
579	}
580
581	memcpy (obj->ci_frame_id, ci_frame_id, size);
582
583	return MIX_RESULT_SUCCESS;
584}
585
586MIX_RESULT mix_videoconfigparamsenc_get_ci_frame_info (MixVideoConfigParamsEnc * obj,
587        gulong * *ci_frame_id, guint *ci_frame_num) {
588    MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT_PAIR (obj, ci_frame_id, ci_frame_num);
589
590	*ci_frame_num = obj->ci_frame_num;
591
592	if (!obj->ci_frame_id) {
593		*ci_frame_id = NULL;
594		return MIX_RESULT_SUCCESS;
595	}
596
597	if (obj->ci_frame_num) {
598		*ci_frame_id = g_malloc (obj->ci_frame_num * sizeof (gulong));
599
600		if (!*ci_frame_id) {
601			return MIX_RESULT_NO_MEMORY;
602		}
603
604		memcpy (*ci_frame_id, obj->ci_frame_id, obj->ci_frame_num * sizeof (gulong));
605
606	} else {
607		*ci_frame_id = NULL;
608	}
609
610	return MIX_RESULT_SUCCESS;
611}
612
613
614MIX_RESULT mix_videoconfigparamsenc_set_drawable (MixVideoConfigParamsEnc * obj,
615        gulong draw) {
616
617	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
618	obj->draw = draw;
619	return MIX_RESULT_SUCCESS;
620
621}
622
623MIX_RESULT mix_videoconfigparamsenc_get_drawable (MixVideoConfigParamsEnc * obj,
624        gulong *draw) {
625
626	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, draw);
627	*draw = obj->draw;
628	return MIX_RESULT_SUCCESS;
629}
630
631MIX_RESULT mix_videoconfigparamsenc_set_need_display (
632	MixVideoConfigParamsEnc * obj, gboolean need_display) {
633	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
634
635	obj->need_display = need_display;
636	return MIX_RESULT_SUCCESS;
637}
638
639MIX_RESULT mix_videoconfigparamsenc_get_need_display(MixVideoConfigParamsEnc * obj,
640		gboolean *need_display) {
641	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, need_display);
642
643	*need_display = obj->need_display;
644	return MIX_RESULT_SUCCESS;
645}
646
647MIX_RESULT mix_videoconfigparamsenc_set_rate_control(MixVideoConfigParamsEnc * obj,
648		MixRateControl rate_control) {
649	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
650	obj->rate_control = rate_control;
651	return MIX_RESULT_SUCCESS;
652}
653
654MIX_RESULT mix_videoconfigparamsenc_get_rate_control(MixVideoConfigParamsEnc * obj,
655		MixRateControl * rate_control) {
656	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, rate_control);
657	*rate_control = obj->rate_control;
658	return MIX_RESULT_SUCCESS;
659}
660
661MIX_RESULT mix_videoconfigparamsenc_set_raw_format (MixVideoConfigParamsEnc * obj,
662		MixRawTargetFormat raw_format) {
663	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
664	obj->raw_format = raw_format;
665	return MIX_RESULT_SUCCESS;
666}
667
668MIX_RESULT mix_videoconfigparamsenc_get_raw_format (MixVideoConfigParamsEnc * obj,
669		MixRawTargetFormat * raw_format) {
670	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, raw_format);
671	*raw_format = obj->raw_format;
672	return MIX_RESULT_SUCCESS;
673}
674
675MIX_RESULT mix_videoconfigparamsenc_set_profile (MixVideoConfigParamsEnc * obj,
676		MixProfile profile) {
677	MIX_VIDEOCONFIGPARAMSENC_SETTER_CHECK_INPUT (obj);
678	obj->profile = profile;
679	return MIX_RESULT_SUCCESS;
680}
681
682MIX_RESULT mix_videoconfigparamsenc_get_profile (MixVideoConfigParamsEnc * obj,
683		MixProfile * profile) {
684	MIX_VIDEOCONFIGPARAMSENC_GETTER_CHECK_INPUT (obj, profile);
685	*profile = obj->profile;
686	return MIX_RESULT_SUCCESS;
687}
688
689