X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sound%2Fcore%2Fpcm_lib.c;h=eedc6cb038bb172e36c3643dbf7d77031fafc0b0;hb=43bc926fffd92024b46cafaf7350d669ba9ca884;hp=fc05089ca348489a8b7586554ecc9a5d773d101d;hpb=6a77f38946aaee1cd85eeec6cf4229b204c15071;p=linux-2.6.git diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index fc05089ca..eedc6cb03 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -39,9 +39,9 @@ * * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately */ -void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr) +void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames, ofs, transfer; if (runtime->silence_size < runtime->boundary) { @@ -56,9 +56,8 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t runtime->silence_filled = 0; runtime->silence_start = runtime->control->appl_ptr; } - if (runtime->silence_filled == runtime->buffer_size) + if (runtime->silence_filled >= runtime->buffer_size) return; - snd_assert(runtime->silence_filled <= runtime->buffer_size, return); noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) return; @@ -128,10 +127,10 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t } } -static void xrun(snd_pcm_substream_t *substream) +static void xrun(struct snd_pcm_substream *substream) { snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); -#ifdef CONFIG_SND_DEBUG +#ifdef CONFIG_SND_PCM_XRUN_DEBUG if (substream->pstr->xrun_debug) { snd_printd(KERN_DEBUG "XRUN: pcmC%dD%d%c\n", substream->pcm->card->number, @@ -143,8 +142,8 @@ static void xrun(snd_pcm_substream_t *substream) #endif } -static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t pos; @@ -152,19 +151,18 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *s if (pos == SNDRV_PCM_POS_XRUN) return pos; /* XRUN */ if (runtime->tstamp_mode & SNDRV_PCM_TSTAMP_MMAP) - snd_timestamp_now((snd_timestamp_t*)&runtime->status->tstamp, runtime->tstamp_timespec); + getnstimeofday((struct timespec *)&runtime->status->tstamp); #ifdef CONFIG_SND_DEBUG if (pos >= runtime->buffer_size) { snd_printk(KERN_ERR "BUG: stream = %i, pos = 0x%lx, buffer size = 0x%lx, period size = 0x%lx\n", substream->stream, pos, runtime->buffer_size, runtime->period_size); - } else + } #endif - snd_runtime_check(pos < runtime->buffer_size, return 0); pos -= pos % runtime->min_align; return pos; } -static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t avail; @@ -186,9 +184,9 @@ static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, return 0; } -static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream) +static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt; snd_pcm_sframes_t delta; @@ -206,7 +204,7 @@ static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream delta = hw_ptr_interrupt - new_hw_ptr; if (delta > 0) { if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) { -#ifdef CONFIG_SND_DEBUG +#ifdef CONFIG_SND_PCM_XRUN_DEBUG if (runtime->periods > 1 && substream->pstr->xrun_debug) { snd_printd(KERN_ERR "Unexpected hw_pointer value [1] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2); if (substream->pstr->xrun_debug > 1) @@ -233,9 +231,9 @@ static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream } /* CAUTION: call it with irq disabled */ -int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) +int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t old_hw_ptr, new_hw_ptr; snd_pcm_sframes_t delta; @@ -251,7 +249,7 @@ int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) delta = old_hw_ptr - new_hw_ptr; if (delta > 0) { if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) { -#ifdef CONFIG_SND_DEBUG +#ifdef CONFIG_SND_PCM_XRUN_DEBUG if (runtime->periods > 2 && substream->pstr->xrun_debug) { snd_printd(KERN_ERR "Unexpected hw_pointer value [2] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2); if (substream->pstr->xrun_debug > 1) @@ -282,10 +280,10 @@ int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) * * Sets the given PCM operators to the pcm instance. */ -void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) +void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops) { - snd_pcm_str_t *stream = &pcm->streams[direction]; - snd_pcm_substream_t *substream; + struct snd_pcm_str *stream = &pcm->streams[direction]; + struct snd_pcm_substream *substream; for (substream = stream->substream; substream != NULL; substream = substream->next) substream->ops = ops; @@ -298,9 +296,9 @@ void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) * * Sets the PCM sync identifier for the card. */ -void snd_pcm_set_sync(snd_pcm_substream_t * substream) +void snd_pcm_set_sync(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->sync.id32[0] = substream->pcm->card->number; runtime->sync.id32[1] = -1; @@ -371,7 +369,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b, return n; } -static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin) +static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin) { int changed = 0; assert(!snd_interval_empty(i)); @@ -396,7 +394,7 @@ static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int open return changed; } -static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax) +static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax) { int changed = 0; assert(!snd_interval_empty(i)); @@ -432,7 +430,7 @@ static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int open * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) +int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) { int changed = 0; assert(!snd_interval_empty(i)); @@ -474,7 +472,7 @@ int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) return changed; } -static int snd_interval_refine_first(snd_interval_t *i) +static int snd_interval_refine_first(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -486,7 +484,7 @@ static int snd_interval_refine_first(snd_interval_t *i) return 1; } -static int snd_interval_refine_last(snd_interval_t *i) +static int snd_interval_refine_last(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -498,9 +496,9 @@ static int snd_interval_refine_last(snd_interval_t *i) return 1; } -static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) +static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) { - snd_interval_t t; + struct snd_interval t; t.empty = 0; t.min = t.max = val; t.openmin = t.openmax = 0; @@ -508,7 +506,7 @@ static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) return snd_interval_refine(i, &t); } -void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { if (a->empty || b->empty) { snd_interval_none(c); @@ -524,12 +522,15 @@ void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_inte /** * snd_interval_div - refine the interval value with division + * @a: dividend + * @b: divisor + * @c: quotient * * c = a / b * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -555,13 +556,17 @@ void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_inte /** * snd_interval_muldivk - refine the interval value - * + * @a: dividend 1 + * @b: dividend 2 + * @k: divisor (as integer) + * @c: result + * * c = a * b / k * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, - unsigned int k, snd_interval_t *c) +void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, + unsigned int k, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -582,13 +587,17 @@ void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, /** * snd_interval_mulkdiv - refine the interval value + * @a: dividend 1 + * @k: dividend 2 (as integer) + * @b: divisor + * @c: result * * c = a * k / b * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, - const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, + const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -618,16 +627,21 @@ void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, /** * snd_interval_ratnum - refine the interval value + * @i: interval to refine + * @rats_count: number of ratnum_t + * @rats: ratnum_t array + * @nump: pointer to store the resultant numerator + * @denp: pointer to store the resultant denominator * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_ratnum(snd_interval_t *i, - unsigned int rats_count, ratnum_t *rats, - unsigned int *nump, unsigned int *denp) +int snd_interval_ratnum(struct snd_interval *i, + unsigned int rats_count, struct snd_ratnum *rats, + unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -715,16 +729,21 @@ int snd_interval_ratnum(snd_interval_t *i, /** * snd_interval_ratden - refine the interval value + * @i: interval to refine + * @rats_count: number of struct ratden + * @rats: struct ratden array + * @nump: pointer to store the resultant numerator + * @denp: pointer to store the resultant denominator * * Returns non-zero if the value is changed, zero if not changed. */ -static int snd_interval_ratden(snd_interval_t *i, - unsigned int rats_count, ratden_t *rats, +static int snd_interval_ratden(struct snd_interval *i, + unsigned int rats_count, struct snd_ratden *rats, unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -817,7 +836,7 @@ static int snd_interval_ratden(snd_interval_t *i, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask) +int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask) { unsigned int k; int changed = 0; @@ -858,7 +877,7 @@ int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, return changed; } -static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int step) +static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step) { unsigned int n; int changed = 0; @@ -892,18 +911,18 @@ static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int s * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, +int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, int dep, ...) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_pcm_hw_rule_t *c; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_rule *c; unsigned int k; va_list args; va_start(args, dep); if (constrs->rules_num >= constrs->rules_all) { - snd_pcm_hw_rule_t *new; + struct snd_pcm_hw_rule *new; unsigned int new_rules = constrs->rules_all + 16; new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL); if (!new) @@ -936,12 +955,17 @@ int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, /** * snd_pcm_hw_constraint_mask + * @runtime: PCM runtime instance + * @var: hw_params variable to apply the mask + * @mask: the bitmap mask + * + * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int32_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); *maskp->bits &= mask; memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ if (*maskp->bits == 0) @@ -951,12 +975,17 @@ int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t va /** * snd_pcm_hw_constraint_mask64 + * @runtime: PCM runtime instance + * @var: hw_params variable to apply the mask + * @mask: the 64bit bitmap mask + * + * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int64_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); maskp->bits[0] &= (u_int32_t)mask; maskp->bits[1] &= (u_int32_t)(mask >> 32); memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ @@ -967,21 +996,31 @@ int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t /** * snd_pcm_hw_constraint_integer + * @runtime: PCM runtime instance + * @var: hw_params variable to apply the integer constraint + * + * Apply the constraint of integer to an interval parameter. */ -int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var) +int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; return snd_interval_setinteger(constrs_interval(constrs, var)); } /** * snd_pcm_hw_constraint_minmax + * @runtime: PCM runtime instance + * @var: hw_params variable to apply the range + * @min: the minimal value + * @max: the maximal value + * + * Apply the min/max range constraint to an interval parameter. */ -int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_interval_t t; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_interval t; t.min = min; t.max = max; t.openmin = t.openmax = 0; @@ -989,31 +1028,37 @@ int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t return snd_interval_refine(constrs_interval(constrs, var), &t); } -static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_list_t *list = rule->private; + struct snd_pcm_hw_constraint_list *list = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask); } /** * snd_pcm_hw_constraint_list + * @runtime: PCM runtime instance + * @cond: condition bits + * @var: hw_params variable to apply the list constraint + * @l: list + * + * Apply the list of constraints to an interval parameter. */ -int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_list_t *l) + struct snd_pcm_hw_constraint_list *l) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_list, l, var, -1); } -static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratnums_t *r = rule->private; + struct snd_pcm_hw_constraint_ratnums *r = rule->private; unsigned int num = 0, den = 0; int err; err = snd_interval_ratnum(hw_param_interval(params, rule->var), @@ -1027,21 +1072,25 @@ static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_constraint_ratnums + * @runtime: PCM runtime instance + * @cond: condition bits + * @var: hw_params variable to apply the ratnums constraint + * @r: struct snd_ratnums constriants */ -int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratnums_t *r) + struct snd_pcm_hw_constraint_ratnums *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratnums, r, var, -1); } -static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratdens_t *r = rule->private; + struct snd_pcm_hw_constraint_ratdens *r = rule->private; unsigned int num = 0, den = 0; int err = snd_interval_ratden(hw_param_interval(params, rule->var), r->nrats, r->rats, &num, &den); @@ -1054,24 +1103,28 @@ static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_constraint_ratdens + * @runtime: PCM runtime instance + * @cond: condition bits + * @var: hw_params variable to apply the ratdens constraint + * @r: struct snd_ratdens constriants */ -int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratdens_t *r) + struct snd_pcm_hw_constraint_ratdens *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratdens, r, var, -1); } -static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned int l = (unsigned long) rule->private; int width = l & 0xffff; unsigned int msbits = l >> 16; - snd_interval_t *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); + struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); if (snd_interval_single(i) && snd_interval_value(i) == width) params->msbits = msbits; return 0; @@ -1079,8 +1132,12 @@ static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_constraint_msbits + * @runtime: PCM runtime instance + * @cond: condition bits + * @width: sample bits width + * @msbits: msbits width */ -int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, unsigned int cond, unsigned int width, unsigned int msbits) @@ -1092,8 +1149,8 @@ int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); } -static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned long step = (unsigned long) rule->private; return snd_interval_step(hw_param_interval(params, rule->var), 0, step); @@ -1101,8 +1158,12 @@ static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_constraint_step + * @runtime: PCM runtime instance + * @cond: condition bits + * @var: hw_params variable to apply the step constraint + * @step: step size */ -int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step) @@ -1112,7 +1173,7 @@ int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, var, -1); } -static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { static int pow2_sizes[] = { 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, @@ -1126,8 +1187,11 @@ static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t * /** * snd_pcm_hw_constraint_pow2 + * @runtime: PCM runtime instance + * @cond: condition bits + * @var: hw_params variable to apply the power-of-2 constraint */ -int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var) { @@ -1137,13 +1201,13 @@ int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, } /* To use the same code we have in alsa-lib */ -#define snd_pcm_t snd_pcm_substream_t #define assert(i) snd_assert((i), return -EINVAL) #ifndef INT_MIN #define INT_MIN ((int)((unsigned int)INT_MAX+1)) #endif -void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) +static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { snd_mask_any(hw_param_mask(params, var)); @@ -1160,17 +1224,19 @@ void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) snd_BUG(); } -/** +#if 0 +/* * snd_pcm_hw_param_any */ -int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { _snd_pcm_hw_param_any(params, var); return snd_pcm_hw_refine(pcm, params); } +#endif /* 0 */ -void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) +void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) { unsigned int k; memset(params, 0, sizeof(*params)); @@ -1181,28 +1247,33 @@ void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) params->info = ~0U; } -/** +#if 0 +/* * snd_pcm_hw_params_any * * Fill PARAMS with full configuration space boundaries */ -int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { _snd_pcm_hw_params_any(params); return snd_pcm_hw_refine(pcm, params); } +#endif /* 0 */ /** * snd_pcm_hw_param_value + * @params: the hw_params instance + * @var: parameter to retrieve + * @dir: pointer to the direction (-1,0,1) or NULL * * Return the value for field PAR if it's fixed in configuration space * defined by PARAMS. Return -EINVAL otherwise */ -int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, int *dir) +static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { - const snd_mask_t *mask = hw_param_mask_c(params, var); + const struct snd_mask *mask = hw_param_mask_c(params, var); if (!snd_mask_single(mask)) return -EINVAL; if (dir) @@ -1210,7 +1281,7 @@ int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, return snd_mask_value(mask); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (!snd_interval_single(i)) return -EINVAL; if (dir) @@ -1223,10 +1294,13 @@ int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_value_min + * @params: the hw_params instance + * @var: parameter to retrieve + * @dir: pointer to the direction (-1,0,1) or NULL * * Return the minimum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1235,7 +1309,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, return snd_mask_min(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = i->openmin; return snd_interval_min(i); @@ -1246,10 +1320,13 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_value_max + * @params: the hw_params instance + * @var: parameter to retrieve + * @dir: pointer to the direction (-1,0,1) or NULL * * Return the maximum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1258,7 +1335,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return snd_mask_max(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = - (int) i->openmax; return snd_interval_max(i); @@ -1267,7 +1344,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return -EINVAL; } -void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, +void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1283,7 +1360,7 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, } } -int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1296,15 +1373,16 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, return changed; } -/** +#if 0 +/* * snd_pcm_hw_param_setinteger * * Inside configuration space defined by PARAMS remove from PAR all * non integer values. Reduce configuration space accordingly. * Return -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed = _snd_pcm_hw_param_setinteger(params, var); @@ -1317,9 +1395,10 @@ int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, } return 0; } +#endif /* 0 */ -int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var) +static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var) { int changed; if (hw_is_mask(var)) @@ -1340,14 +1419,18 @@ int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_first + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS remove from PAR all * values > minimum. Reduce configuration space accordingly. * Return the minimum. */ -int snd_pcm_hw_param_first(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, int *dir) +static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_first(params, var); if (changed < 0) @@ -1359,8 +1442,8 @@ int snd_pcm_hw_param_first(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var) +static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var) { int changed; if (hw_is_mask(var)) @@ -1381,14 +1464,18 @@ int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_last + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS remove from PAR all * values < maximum. Reduce configuration space accordingly. * Return the maximum. */ -int snd_pcm_hw_param_last(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, int *dir) +static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_last(params, var); if (changed < 0) @@ -1400,7 +1487,7 @@ int snd_pcm_hw_param_last(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; @@ -1432,13 +1519,19 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_min + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @val: minimal value + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS remove from PAR all * values < VAL. Reduce configuration space accordingly. * Return new minimum or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, unsigned int val, int *dir) +static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, unsigned int val, + int *dir) { int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0); if (changed < 0) @@ -1451,8 +1544,9 @@ int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_min(params, var, dir); } -int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, unsigned int val, int dir) +static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, unsigned int val, + int dir) { int changed; int open = 0; @@ -1485,13 +1579,19 @@ int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_max + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @val: maximal value + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS remove from PAR all * values >= VAL + 1. Reduce configuration space accordingly. * Return new maximum or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, unsigned int val, int *dir) +static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, unsigned int val, + int *dir) { int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0); if (changed < 0) @@ -1504,12 +1604,12 @@ int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_max(params, var, dir); } -int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; if (hw_is_mask(var)) { - snd_mask_t *m = hw_param_mask(params, var); + struct snd_mask *m = hw_param_mask(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_mask_none(m); @@ -1521,14 +1621,14 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, changed = snd_mask_refine_set(hw_param_mask(params, var), val); } } else if (hw_is_interval(var)) { - snd_interval_t *i = hw_param_interval(params, var); + struct snd_interval *i = hw_param_interval(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_interval_none(i); } else if (dir == 0) changed = snd_interval_refine_set(i, val); else { - snd_interval_t t; + struct snd_interval t; t.openmin = 1; t.openmax = 1; t.empty = 0; @@ -1555,12 +1655,17 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_set + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @val: value to set + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS remove from PAR all * values != VAL. Reduce configuration space accordingly. * Return VAL or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed = _snd_pcm_hw_param_set(params, var, val, dir); @@ -1574,8 +1679,8 @@ int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value(params, var, NULL); } -int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed; assert(hw_is_mask(var)); @@ -1589,6 +1694,10 @@ int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_mask + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @val: mask to apply * * Inside configuration space defined by PARAMS remove from PAR all values * not contained in MASK. Reduce configuration space accordingly. @@ -1597,8 +1706,8 @@ int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, * Return 0 on success or -EINVAL * if the configuration space is empty */ -int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed = _snd_pcm_hw_param_mask(params, var, val); if (changed < 0) @@ -1661,6 +1770,11 @@ static int boundary_nearer(int min, int mindir, /** * snd_pcm_hw_param_near + * @pcm: PCM instance + * @params: the hw_params instance + * @var: parameter to retrieve + * @best: value to set + * @dir: pointer to the direction (-1,0,1) or NULL * * Inside configuration space defined by PARAMS set PAR to the available value * nearest to VAL. Reduce configuration space accordingly. @@ -1668,10 +1782,10 @@ static int boundary_nearer(int min, int mindir, * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT. * Return the value found. */ -int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int best, int *dir) { - snd_pcm_hw_params_t *save = NULL; + struct snd_pcm_hw_params *save = NULL; int v; unsigned int saved_min; int last = 0; @@ -1698,7 +1812,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, saved_min = min; min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir); if (min >= 0) { - snd_pcm_hw_params_t *params1; + struct snd_pcm_hw_params *params1; if (max < 0) goto _end; if ((unsigned int)min == saved_min && mindir == valdir) @@ -1737,13 +1851,15 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, /** * snd_pcm_hw_param_choose + * @pcm: PCM instance + * @params: the hw_params instance * * Choose one configuration from configuration space defined by PARAMS * The configuration chosen is that obtained fixing in this order: * first access, first format, first subformat, min channels, * min rate, min period time, max buffer size, min tick time */ -int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { int err; @@ -1774,13 +1890,12 @@ int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) return 0; } -#undef snd_pcm_t #undef assert -static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; unsigned long flags; snd_pcm_stream_lock_irqsave(substream, flags); if (snd_pcm_running(substream) && @@ -1792,11 +1907,11 @@ static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_channel_info_t *info = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_channel_info *info = arg; + struct snd_pcm_runtime *runtime = substream->runtime; int width; if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { info->offset = -1; @@ -1838,7 +1953,7 @@ static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -1856,29 +1971,28 @@ int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, * Conditions */ -static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, +static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (ticks == 0) del_timer(&runtime->tick_timer); else { + ticks += (1000000 / HZ) - 1; ticks /= (1000000 / HZ); - if (ticks % (1000000 / HZ)) - ticks++; mod_timer(&runtime->tick_timer, jiffies + ticks); } } /* Temporary alias */ -void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks) +void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { snd_pcm_system_tick_set(substream, ticks); } -void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) +void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames = ULONG_MAX; snd_pcm_uframes_t avail, dist; unsigned int ticks; @@ -1891,8 +2005,8 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) runtime->silence_filled < runtime->buffer_size) { snd_pcm_sframes_t noise_dist; noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; - snd_assert(noise_dist <= (snd_pcm_sframes_t)runtime->silence_threshold, ); - frames = noise_dist - runtime->silence_threshold; + if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold) + frames = noise_dist - runtime->silence_threshold; } avail = snd_pcm_playback_avail(runtime); } else { @@ -1929,9 +2043,9 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) snd_pcm_tick_set(substream, (unsigned long) ticks); } -void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -1959,9 +2073,9 @@ void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) * Even if more than one periods have elapsed since the last call, you * have to call this only once. */ -void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -1987,12 +2101,12 @@ void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) kill_fasync(&runtime->fasync, SIGIO, POLL_IN); } -static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2007,17 +2121,17 @@ static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, return 0; } -typedef int (*transfer_f)(snd_pcm_substream_t *substream, unsigned int hwoff, +typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t size); -static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2054,7 +2168,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, if (((avail < runtime->control->avail_min && size > avail) || (size >= runtime->xfer_align && avail < runtime->xfer_align))) { wait_queue_t wait; - enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED } state; + enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state; long tout; if (nonblock) { @@ -2088,6 +2202,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, case SNDRV_PCM_STATE_SUSPENDED: state = SUSPENDED; goto _end_loop; + case SNDRV_PCM_STATE_SETUP: + state = DROPPED; + goto _end_loop; default: break; } @@ -2114,6 +2231,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, snd_printd("playback write error (DMA or IRQ trouble?)\n"); err = -EIO; goto _end_unlock; + case DROPPED: + err = -EBADFD; + goto _end_unlock; default: break; } @@ -2142,11 +2262,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, break; } appl_ptr += frames; - if (appl_ptr >= runtime->boundary) { - runtime->control->appl_ptr = 0; - } else { - runtime->control->appl_ptr = appl_ptr; - } + if (appl_ptr >= runtime->boundary) + appl_ptr -= runtime->boundary; + runtime->control->appl_ptr = appl_ptr; if (substream->ops->ack) substream->ops->ack(substream); @@ -2169,9 +2287,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2181,19 +2299,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; - snd_assert(substream->ffile != NULL, return -ENXIO); nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); -#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; - if (setup != NULL) { - if (setup->nonblock) - nonblock = 1; - else if (setup->block) - nonblock = 0; - } - } -#endif if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && runtime->channels > 1) @@ -2202,12 +2308,12 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ snd_pcm_lib_write_transfer); } -static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2242,11 +2348,11 @@ static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2256,19 +2362,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; - snd_assert(substream->ffile != NULL, return -ENXIO); nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); -#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; - if (setup != NULL) { - if (setup->nonblock) - nonblock = 1; - else if (setup->block) - nonblock = 0; - } - } -#endif if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) return -EINVAL; @@ -2276,12 +2370,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, nonblock, snd_pcm_lib_writev_transfer); } -static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2296,13 +2390,13 @@ static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, return 0; } -static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2352,7 +2446,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, } else if ((avail < runtime->control->avail_min && size > avail) || (size >= runtime->xfer_align && avail < runtime->xfer_align)) { wait_queue_t wait; - enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED } state; + enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state; long tout; if (nonblock) { @@ -2387,6 +2481,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, goto _end_loop; case SNDRV_PCM_STATE_DRAINING: goto __draining; + case SNDRV_PCM_STATE_SETUP: + state = DROPPED; + goto _end_loop; default: break; } @@ -2413,6 +2510,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, snd_printd("capture read error (DMA or IRQ trouble?)\n"); err = -EIO; goto _end_unlock; + case DROPPED: + err = -EBADFD; + goto _end_unlock; default: break; } @@ -2441,11 +2541,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, break; } appl_ptr += frames; - if (appl_ptr >= runtime->boundary) { - runtime->control->appl_ptr = 0; - } else { - runtime->control->appl_ptr = appl_ptr; - } + if (appl_ptr >= runtime->boundary) + appl_ptr -= runtime->boundary; + runtime->control->appl_ptr = appl_ptr; if (substream->ops->ack) substream->ops->ack(substream); @@ -2462,9 +2560,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2474,30 +2572,18 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user * if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; - snd_assert(substream->ffile != NULL, return -ENXIO); nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); -#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; - if (setup != NULL) { - if (setup->nonblock) - nonblock = 1; - else if (setup->block) - nonblock = 0; - } - } -#endif if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED) return -EINVAL; return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); } -static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2529,11 +2615,11 @@ static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2543,20 +2629,7 @@ snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; - snd_assert(substream->ffile != NULL, return -ENXIO); nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); -#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; - if (setup != NULL) { - if (setup->nonblock) - nonblock = 1; - else if (setup->block) - nonblock = 0; - } - } -#endif - if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) return -EINVAL; return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer); @@ -2569,9 +2642,6 @@ snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, EXPORT_SYMBOL(snd_interval_refine); EXPORT_SYMBOL(snd_interval_list); EXPORT_SYMBOL(snd_interval_ratnum); -EXPORT_SYMBOL(snd_interval_muldivk); -EXPORT_SYMBOL(snd_interval_mulkdiv); -EXPORT_SYMBOL(snd_interval_div); EXPORT_SYMBOL(_snd_pcm_hw_params_any); EXPORT_SYMBOL(_snd_pcm_hw_param_min); EXPORT_SYMBOL(_snd_pcm_hw_param_set); @@ -2585,7 +2655,6 @@ EXPORT_SYMBOL(snd_pcm_hw_param_last); EXPORT_SYMBOL(snd_pcm_hw_param_near); EXPORT_SYMBOL(snd_pcm_hw_param_set); EXPORT_SYMBOL(snd_pcm_hw_refine); -EXPORT_SYMBOL(snd_pcm_hw_params); EXPORT_SYMBOL(snd_pcm_hw_constraints_init); EXPORT_SYMBOL(snd_pcm_hw_constraints_complete); EXPORT_SYMBOL(snd_pcm_hw_constraint_list);