Lines Matching refs:params
28 static void dump_hw_params(snd_pcm_hw_params_t *params, const char *type,
55 snd_pcm_hw_params_dump(params, out);
59 static inline void dump_hw_params(snd_pcm_hw_params_t *params, const char *type,
81 #define hw_param_mask(params,var) \
82 &((params)->masks[(var) - SND_PCM_HW_PARAM_FIRST_MASK])
84 #define hw_param_interval(params,var) \
85 &((params)->intervals[(var) - SND_PCM_HW_PARAM_FIRST_INTERVAL])
90 static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var)
93 snd_mask_any(hw_param_mask(params, var));
94 params->cmask |= 1 << var;
95 params->rmask |= 1 << var;
99 snd_interval_any(hw_param_interval(params, var));
100 params->cmask |= 1 << var;
101 params->rmask |= 1 << var;
107 int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
110 _snd_pcm_hw_param_any(params, var);
111 return snd_pcm_hw_refine(pcm, params);
114 void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params)
117 memset(params, 0, sizeof(*params));
119 _snd_pcm_hw_param_any(params, k);
121 _snd_pcm_hw_param_any(params, k);
122 params->rmask = ~0U;
123 params->cmask = 0;
124 params->info = ~0U;
130 int snd_pcm_hw_param_get(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
134 const snd_mask_t *mask = hw_param_mask_c(params, var);
143 const snd_interval_t *i = hw_param_interval_c(params, var);
157 int snd_pcm_hw_param_get_min(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
161 const snd_mask_t *m = hw_param_mask_c(params, var);
169 const snd_interval_t *i = hw_param_interval_c(params, var);
182 int snd_pcm_hw_param_get_max(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
186 const snd_mask_t *m = hw_param_mask_c(params, var);
194 const snd_interval_t *i = hw_param_interval_c(params, var);
209 const snd_mask_t *snd_pcm_hw_param_get_mask(const snd_pcm_hw_params_t *params,
213 return hw_param_mask_c(params, var);
219 const snd_interval_t *snd_pcm_hw_param_get_interval(const snd_pcm_hw_params_t *params,
223 return hw_param_interval_c(params, var);
228 int _snd_pcm_hw_param_set_interval(snd_pcm_hw_params_t *params,
234 changed = snd_interval_refine(hw_param_interval(params, var), val);
236 params->cmask |= 1 << var;
237 params->rmask |= 1 << var;
242 void _snd_pcm_hw_param_set_empty(snd_pcm_hw_params_t *params,
246 snd_mask_none(hw_param_mask(params, var));
247 params->cmask |= 1 << var;
248 params->rmask |= 1 << var;
250 snd_interval_none(hw_param_interval(params, var));
251 params->cmask |= 1 << var;
252 params->rmask |= 1 << var;
258 static int _snd_pcm_hw_param_set_integer(snd_pcm_hw_params_t *params,
263 changed = snd_interval_setinteger(hw_param_interval(params, var));
265 params->cmask |= 1 << var;
266 params->rmask |= 1 << var;
276 snd_pcm_hw_params_t *params,
286 save = *params;
289 save = *params;
290 params = &save;
296 err = _snd_pcm_hw_param_set_integer(params, var);
299 if (params->rmask) {
300 err = snd_pcm_hw_refine(pcm, params);
307 *params = save;
311 static int _snd_pcm_hw_param_set_first(snd_pcm_hw_params_t *params,
316 changed = snd_mask_refine_first(hw_param_mask(params, var));
318 changed = snd_interval_refine_first(hw_param_interval(params, var));
324 params->cmask |= 1 << var;
325 params->rmask |= 1 << var;
336 snd_pcm_hw_params_t *params,
342 err = _snd_pcm_hw_param_set_first(params, var);
345 if (params->rmask) {
346 err = snd_pcm_hw_refine(pcm, params);
350 return snd_pcm_hw_param_get(params, var, rval, dir);
353 static int _snd_pcm_hw_param_set_last(snd_pcm_hw_params_t *params,
358 changed = snd_mask_refine_last(hw_param_mask(params, var));
360 changed = snd_interval_refine_last(hw_param_interval(params, var));
366 params->cmask |= 1 << var;
367 params->rmask |= 1 << var;
378 snd_pcm_hw_params_t *params,
384 err = _snd_pcm_hw_param_set_last(params, var);
387 if (params->rmask) {
388 err = snd_pcm_hw_refine(pcm, params);
392 return snd_pcm_hw_param_get(params, var, rval, dir);
395 int _snd_pcm_hw_param_set_min(snd_pcm_hw_params_t *params,
411 changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!openmin);
413 changed = snd_interval_refine_min(hw_param_interval(params, var), val, openmin);
419 params->cmask |= 1 << var;
420 params->rmask |= 1 << var;
429 int snd_pcm_hw_param_set_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
439 save = *params;
442 save = *params;
443 params = &save;
449 err = _snd_pcm_hw_param_set_min(params, var, *val, dir ? *dir : 0);
452 if ((mode != SND_TEST || hw_is_interval(var)) && params->rmask) {
453 err = snd_pcm_hw_refine(pcm, params);
456 if (snd_pcm_hw_param_empty(params, var)) {
461 return snd_pcm_hw_param_get_min(params, var, val, dir);
464 *params = save;
466 dump_hw_params(params, "set_min", var, *val, err);
470 int _snd_pcm_hw_param_set_max(snd_pcm_hw_params_t *params,
485 snd_mask_none(hw_param_mask(params, var));
488 changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!openmax);
490 changed = snd_interval_refine_max(hw_param_interval(params, var), val, openmax);
496 params->cmask |= 1 << var;
497 params->rmask |= 1 << var;
506 int snd_pcm_hw_param_set_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
516 save = *params;
519 save = *params;
520 params = &save;
526 err = _snd_pcm_hw_param_set_max(params, var, *val, dir ? *dir : 0);
529 if ((mode != SND_TEST || hw_is_interval(var)) && params->rmask) {
530 err = snd_pcm_hw_refine(pcm, params);
533 if (snd_pcm_hw_param_empty(params, var)) {
538 return snd_pcm_hw_param_get_max(params, var, val, dir);
541 *params = save;
543 dump_hw_params(params, "set_max", var, *val, err);
547 int _snd_pcm_hw_param_set_minmax(snd_pcm_hw_params_t *params,
573 snd_mask_t *mask = hw_param_mask(params, var);
591 snd_interval_t *i = hw_param_interval(params, var);
607 params->cmask |= 1 << var;
608 params->rmask |= 1 << var;
617 int snd_pcm_hw_param_set_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
629 save = *params;
632 save = *params;
633 params = &save;
639 err = _snd_pcm_hw_param_set_minmax(params, var,
644 if ((mode != SND_TEST || hw_is_interval(var)) && params->rmask) {
645 err = snd_pcm_hw_refine(pcm, params);
649 err = snd_pcm_hw_param_get_min(params, var, min, mindir);
652 return snd_pcm_hw_param_get_max(params, var, max, maxdir);
655 *params = save;
657 dump_hw_params(params, "set_minmax", var, *min, err);
661 int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
666 snd_mask_t *m = hw_param_mask(params, var);
675 changed = snd_mask_refine_set(hw_param_mask(params, var), val);
678 snd_interval_t *i = hw_param_interval(params, var);
704 params->cmask |= 1 << var;
705 params->rmask |= 1 << var;
714 int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
724 save = *params;
727 save = *params;
728 params = &save;
734 err = _snd_pcm_hw_param_set(params, var, val, dir);
737 if ((mode != SND_TEST || hw_is_interval(var)) && params->rmask) {
738 err = snd_pcm_hw_refine(pcm, params);
745 *params = save;
747 dump_hw_params(params, "set", var, val, err);
751 int _snd_pcm_hw_param_set_mask(snd_pcm_hw_params_t *params,
756 changed = snd_mask_refine(hw_param_mask(params, var), val);
758 params->cmask |= 1 << var;
759 params->rmask |= 1 << var;
771 int snd_pcm_hw_param_set_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
781 save = *params;
784 save = *params;
785 params = &save;
791 err = _snd_pcm_hw_param_set_mask(params, var, val);
794 if (mode != SND_TEST && params->rmask) {
795 err = snd_pcm_hw_refine(pcm, params);
802 *params = save;
812 int snd_pcm_hw_param_set_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
837 save = *params;
839 err = snd_pcm_hw_param_set_min(pcm, params, SND_CHANGE, var, &min, &mindir);
841 i = hw_param_interval(params, var);
843 err = snd_pcm_hw_param_get_min(params, var, val, dir);
845 dump_hw_params(params, "set_near", var, *val, err);
858 *params = params1;
862 *params = save;
863 err = snd_pcm_hw_param_set_max(pcm, params, SND_CHANGE, var, &max, &maxdir);
865 dump_hw_params(params, "set_near", var, *val, err);
872 err = snd_pcm_hw_param_set_last(pcm, params, var, val, dir);
874 err = snd_pcm_hw_param_set_first(pcm, params, var, val, dir);
876 dump_hw_params(params, "set_near", var, *val, err);
889 int snd_pcm_hw_param_set_next(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
920 save = *params;
922 (err = snd_pcm_hw_param_set_min(pcm, params, SND_CHANGE, var, &min, &mindir)) >= 0) {
931 *params = params1;
937 *params = save;
938 err = snd_pcm_hw_param_set_max(pcm, params, SND_CHANGE, var, &max, &maxdir);
945 v = snd_pcm_hw_param_set_last(pcm, params, var, dir);
947 v = snd_pcm_hw_param_set_first(pcm, params, var, dir);
954 snd_pcm_hw_params_t *params,
962 return snd_pcm_hw_param_set_near(pcm, params, var, &min, mindir);
963 tmp = *params;
968 tmp = *params;
974 err = snd_pcm_hw_param_set_minmax(pcm, params, SND_CHANGE, var, &min, mindir,
982 snd_pcm_hw_params_t *params,
993 if ((err = snd_pcm_hw_param_set_near_minmax(pcm, params, var,
1000 snd_pcm_hw_params_t *params,
1005 const snd_interval_t *st = hw_param_interval_c(params, var);
1013 if (! snd_pcm_hw_param_set(pcm, params, SND_TRY, var, cur, 0))
1022 return snd_pcm_hw_param_refine_near(pcm, params, var, src);
1027 int snd_pcm_hw_param_empty(const snd_pcm_hw_params_t *params,
1031 return snd_mask_empty(hw_param_mask_c(params, var));
1033 return snd_interval_empty(hw_param_interval_c(params, var));
1038 int snd_pcm_hw_param_always_eq(const snd_pcm_hw_params_t *params,
1043 return snd_mask_always_eq(hw_param_mask_c(params, var),
1046 return snd_interval_always_eq(hw_param_interval_c(params, var),
1052 int snd_pcm_hw_param_never_eq(const snd_pcm_hw_params_t *params,
1057 return snd_mask_never_eq(hw_param_mask_c(params, var),
1060 return snd_interval_never_eq(hw_param_interval_c(params, var),
1081 static int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
1088 snd_pcm_hw_params_dump(params, log);
1091 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_ACCESS, NULL, 0);
1094 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_FORMAT, NULL, 0);
1097 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_SUBFORMAT, NULL, 0);
1100 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_CHANNELS, NULL, 0);
1103 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_RATE, NULL, 0);
1109 err = snd_pcm_hw_param_get_min(params, SND_PCM_HW_PARAM_PERIOD_TIME, &min, &dir);
1111 err = snd_pcm_hw_param_get_max(params, SND_PCM_HW_PARAM_PERIOD_TIME, &max, &dir);
1115 snd_pcm_hw_param_set_min(pcm, params, SND_CHANGE, SND_PCM_HW_PARAM_PERIOD_TIME, &min, &dir);
1120 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_PERIOD_TIME, NULL, 0);
1123 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_PERIOD_SIZE, NULL, 0);
1126 err = snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_BUFFER_SIZE, NULL, 0);
1131 err = snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_BUFFER_SIZE, NULL, 0);
1134 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_PERIOD_SIZE, NULL, 0);
1137 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_PERIOD_TIME, NULL, 0);
1141 err = snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_TICK_TIME, NULL, 0);
1146 snd_pcm_hw_params_dump(params, log);
1153 static unsigned int snd_pcm_hw_param_count(const snd_pcm_hw_params_t *params,
1157 const snd_mask_t *mask = hw_param_mask_c(params, var);
1161 const snd_interval_t *i = hw_param_interval_c(params, var);
1169 int _snd_pcm_hw_param_refine(snd_pcm_hw_params_t *params,
1175 snd_mask_t *d = hw_param_mask(params, var);
1179 snd_interval_t *d = hw_param_interval(params, var);
1185 params->cmask |= 1 << var;
1186 params->rmask |= 1 << var;
1192 static void _snd_pcm_hw_param_copy(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
1196 snd_mask_t *d = hw_param_mask(params, var);
1199 params->cmask |= 1 << var;
1200 params->rmask |= 1 << var;
1204 snd_interval_t *d = hw_param_interval(params, var);
1207 params->cmask |= 1 << var;
1208 params->rmask |= 1 << var;
1215 void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
1219 const snd_mask_t *mask = hw_param_mask_c(params, var);
1253 snd_interval_print(hw_param_interval_c(params, var), out);
1290 int (*choose_param)(const snd_pcm_hw_params_t *params,
1293 int (*next_value)(snd_pcm_hw_params_t *params,
1298 int (*min_badness)(const snd_pcm_hw_params_t *params,
1312 int (*next_value)(snd_pcm_hw_params_t *params,
1317 unsigned int (*min_badness)(const snd_pcm_hw_params_t *params,
1336 int snd_pcm_hw_params_strategy(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
1345 int badness = strategy->min_badness(params, badness_max, pcm, strategy);
1349 snd_pcm_hw_params_dump(params, stdout);
1355 var = strategy->choose_param(params, pcm, strategy);
1361 params1 = *params;
1368 *params = params1;
1379 *params = best_params;
1394 int snd_pcm_hw_strategy_simple_choose_param(const snd_pcm_hw_params_t *params,
1408 choices = snd_pcm_hw_param_count(params, var);
1423 int snd_pcm_hw_strategy_simple_next_value(snd_pcm_hw_params_t *params,
1431 return pars[var].next_value(params, var, value, dir, pcm, &pars[var]);
1435 int snd_pcm_hw_strategy_simple_min_badness(const snd_pcm_hw_params_t *params,
1447 b = pars[var].min_badness(params, var, pcm, &pars[var]);
1462 unsigned int snd_pcm_hw_strategy_simple_near_min_badness(const snd_pcm_hw_params_t *params,
1468 snd_pcm_hw_params_t params1 = *params;
1478 int snd_pcm_hw_strategy_simple_near_next_value(snd_pcm_hw_params_t *params,
1487 return snd_pcm_hw_param_set_near(pcm, params, var, p->best, dir);
1489 return snd_pcm_hw_param_set_next(pcm, params, var, p->best, 0, value, dir);
1499 unsigned int snd_pcm_hw_strategy_simple_choices_min_badness(const snd_pcm_hw_params_t *params,
1507 if (snd_pcm_hw_param_set(pcm, (snd_pcm_hw_params_t *) params, SND_TEST, var, p->choices[k].value, 0))
1514 int snd_pcm_hw_strategy_simple_choices_next_value(snd_pcm_hw_params_t *params,
1532 int err = snd_pcm_hw_param_set(pcm, params, SND_TRY, var, v, 0);
1688 typedef int (*snd_pcm_hw_rule_func_t)(snd_pcm_hw_params_t *params,
1698 static int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params,
1702 snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
1703 hw_param_interval_c(params, rule->deps[1]), &t);
1704 return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1707 static int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params,
1711 snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
1712 hw_param_interval_c(params, rule->deps[1]), &t);
1713 return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1716 static int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params,
1720 snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
1721 hw_param_interval_c(params, rule->deps[1]),
1723 return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1726 static int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params,
1730 snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
1732 hw_param_interval_c(params, rule->deps[1]), &t);
1733 return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1736 static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
1741 snd_mask_t *mask = hw_param_mask(params, rule->var);
1742 snd_interval_t *i = hw_param_interval(params, rule->deps[0]);
1761 static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
1766 snd_interval_t *i = hw_param_interval(params, rule->var);
1767 snd_mask_t *mask = hw_param_mask(params, rule->deps[0]);
2074 int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
2087 snd_pcm_hw_params_dump(params, log);
2091 if (!(params->rmask & (1 << k)))
2093 changed = snd_mask_refine(hw_param_mask(params, k),
2096 params->cmask |= 1 << k;
2102 if (!(params->rmask & (1 << k)))
2104 changed = snd_interval_refine(hw_param_interval(params, k),
2107 params->cmask |= 1 << k;
2115 vstamps[k] = (params->rmask & (1 << k)) ? 1 : 0;
2134 snd_pcm_hw_param_dump(params, r->var, log);
2138 changed = r->func(params, r);
2141 snd_pcm_hw_param_dump(params, r->var, log);
2144 snd_pcm_hw_param_dump(params, r->deps[d], log);
2150 params->cmask |= 1 << r->var;
2159 if (!params->msbits) {
2160 i = hw_param_interval(params, SND_PCM_HW_PARAM_SAMPLE_BITS);
2162 params->msbits = snd_interval_value(i);
2163 m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT);
2166 params->msbits = snd_pcm_format_width(format);
2170 if (!params->rate_den) {
2171 i = hw_param_interval(params, SND_PCM_HW_PARAM_RATE);
2173 params->rate_num = snd_interval_value(i);
2174 params->rate_den = 1;
2177 params->rmask = 0;
2182 snd_pcm_hw_params_dump(params, log);
2188 int _snd_pcm_hw_params_refine(snd_pcm_hw_params_t *params,
2197 changed = _snd_pcm_hw_param_refine(params, k, src);
2201 params->info &= src->info;
2202 params->flags = src->flags; /* propagate all flags to slave */
2206 int snd_pcm_hw_refine_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
2208 snd_pcm_hw_params_t *params),
2210 snd_pcm_hw_params_t *params,
2213 snd_pcm_hw_params_t *params),
2215 snd_pcm_hw_params_t *params,
2230 err = cprepare(pcm, params);
2242 cmask = params->cmask;
2243 params->cmask = 0;
2246 snd_pcm_hw_params_dump(params, log);
2250 err = schange(pcm, params, &sparams);
2254 snd_pcm_hw_params_dump(params, log);
2262 snd_pcm_hw_params_dump(params, log);
2266 cchange(pcm, params, &sparams);
2272 snd_pcm_hw_params_dump(params, log);
2276 cchange(pcm, params, &sparams);
2282 err = cchange(pcm, params, &sparams);
2288 err = snd_pcm_hw_refine_soft(pcm, params);
2289 changed = params->cmask;
2290 params->cmask |= cmask;
2304 int snd_pcm_hw_params_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
2306 snd_pcm_hw_params_t *params,
2309 snd_pcm_hw_params_t *params),
2311 snd_pcm_hw_params_t *params,
2322 err = schange(pcm, params, &slave_params);
2327 cchange(pcm, params, &slave_params);
2331 static int snd_pcm_sw_params_default(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
2333 assert(pcm && params);
2335 params->proto = SNDRV_PCM_VERSION;
2336 params->tstamp_mode = SND_PCM_TSTAMP_NONE;
2337 params->tstamp_type = pcm->tstamp_type;
2338 params->period_step = 1;
2339 params->sleep_min = 0;
2340 params->avail_min = pcm->period_size;
2341 params->xfer_align = 1;
2342 params->start_threshold = 1;
2343 params->stop_threshold = pcm->buffer_size;
2344 params->silence_threshold = 0;
2345 params->silence_size = 0;
2346 params->boundary = pcm->buffer_size;
2348 if (params->boundary == 0)
2350 while (params->boundary * 2 <= LONG_MAX - pcm->buffer_size)
2351 params->boundary *= 2;
2359 int snd_pcm_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
2366 assert(pcm && params);
2369 snd_pcm_hw_params_dump(params, log);
2372 res = pcm->ops->hw_refine(pcm->op_arg, params);
2377 snd_pcm_hw_params_dump(params, log);
2395 int _snd_pcm_hw_params_internal(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
2400 err = snd_pcm_hw_refine(pcm, params);
2403 snd_pcm_hw_params_choose(pcm, params);
2410 err = pcm->ops->hw_params(pcm->op_arg, params);
2417 INTERNAL(snd_pcm_hw_params_get_access)(params, &pcm->access);
2418 INTERNAL(snd_pcm_hw_params_get_format)(params, &pcm->format);
2419 INTERNAL(snd_pcm_hw_params_get_subformat)(params, &pcm->subformat);
2420 INTERNAL(snd_pcm_hw_params_get_channels)(params, &pcm->channels);
2421 INTERNAL(snd_pcm_hw_params_get_rate)(params, &pcm->rate, 0);
2422 snd_interval_copy(&pcm->periods, ¶ms->intervals[SND_PCM_HW_PARAM_PERIODS - SND_PCM_HW_PARAM_FIRST_INTERVAL]);
2423 snd_interval_copy(&pcm->buffer_time, ¶ms->intervals[SND_PCM_HW_PARAM_BUFFER_TIME - SND_PCM_HW_PARAM_FIRST_INTERVAL]);
2424 INTERNAL(snd_pcm_hw_params_get_period_time)(params, &pcm->period_time, 0);
2425 INTERNAL(snd_pcm_hw_params_get_period_size)(params, &pcm->period_size, 0);
2426 INTERNAL(snd_pcm_hw_params_get_buffer_size)(params, &pcm->buffer_size);
2437 pcm->hw_flags = params->flags;
2438 pcm->info = params->info;
2439 pcm->msbits = params->msbits;
2440 pcm->rate_num = params->rate_num;
2441 pcm->rate_den = params->rate_den;
2442 pcm->fifo_size = params->fifo_size;
2444 /* Default sw params */