自学教程：C++ snd_pcm_sw_params_set_start_threshold函数代码示例

static void *alsa_init(const char *device, unsigned rate, unsigned latency){   alsa_t *alsa = (alsa_t*)calloc(1, sizeof(alsa_t));   if (!alsa)      return NULL;   snd_pcm_hw_params_t *params = NULL;   snd_pcm_sw_params_t *sw_params = NULL;   unsigned latency_usec = latency * 1000;   unsigned channels = 2;   unsigned periods = 4;   snd_pcm_format_t format;   const char *alsa_dev = "default";   if (device)      alsa_dev = device;   snd_pcm_uframes_t buffer_size;   TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK));   TRY_ALSA(snd_pcm_hw_params_malloc(&params));   alsa->has_float = find_float_format(alsa->pcm, params);   format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;   TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));   TRY_ALSA(snd_pcm_hw_params_set_access(alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));   TRY_ALSA(snd_pcm_hw_params_set_format(alsa->pcm, params, format));   TRY_ALSA(snd_pcm_hw_params_set_channels(alsa->pcm, params, channels));   TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));   TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(alsa->pcm, params, &latency_usec, NULL));   TRY_ALSA(snd_pcm_hw_params_set_periods_near(alsa->pcm, params, &periods, NULL));   TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));   snd_pcm_hw_params_get_period_size(params, &buffer_size, NULL);   RARCH_LOG("ALSA: Period size: %d frames/n", (int)buffer_size);   snd_pcm_hw_params_get_buffer_size(params, &buffer_size);   RARCH_LOG("ALSA: Buffer size: %d frames/n", (int)buffer_size);   alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);   alsa->can_pause = snd_pcm_hw_params_can_pause(params);   RARCH_LOG("ALSA: Can pause: %s./n", alsa->can_pause ? "yes" : "no");   TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));   TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));   TRY_ALSA(snd_pcm_sw_params_set_start_threshold(alsa->pcm, sw_params, buffer_size / 2));   TRY_ALSA(snd_pcm_sw_params(alsa->pcm, sw_params));   snd_pcm_hw_params_free(params);   snd_pcm_sw_params_free(sw_params);   return alsa;error:   RARCH_ERR("ALSA: Failed to initialize.../n");   if (params)      snd_pcm_hw_params_free(params);   if (sw_params)      snd_pcm_sw_params_free(sw_params);   if (alsa)   {      if (alsa->pcm)         snd_pcm_close(alsa->pcm);      free(alsa);   }   return NULL;}

static voidalsa_configure (struct sound_device *sd){  int val, err, dir;  unsigned uval;  struct alsa_params *p = (struct alsa_params *) sd->data;  snd_pcm_uframes_t buffer_size;  xassert (p->handle != 0);  err = snd_pcm_hw_params_malloc (&p->hwparams);  if (err < 0)    alsa_sound_perror ("Could not allocate hardware parameter structure", err);  err = snd_pcm_sw_params_malloc (&p->swparams);  if (err < 0)    alsa_sound_perror ("Could not allocate software parameter structure", err);  err = snd_pcm_hw_params_any (p->handle, p->hwparams);  if (err < 0)    alsa_sound_perror ("Could not initialize hardware parameter structure", err);  err = snd_pcm_hw_params_set_access (p->handle, p->hwparams,                                      SND_PCM_ACCESS_RW_INTERLEAVED);  if (err < 0)    alsa_sound_perror ("Could not set access type", err);  val = sd->format;  err = snd_pcm_hw_params_set_format (p->handle, p->hwparams, val);  if (err < 0)    alsa_sound_perror ("Could not set sound format", err);  uval = sd->sample_rate;  err = snd_pcm_hw_params_set_rate_near (p->handle, p->hwparams, &uval, 0);  if (err < 0)    alsa_sound_perror ("Could not set sample rate", err);  val = sd->channels;  err = snd_pcm_hw_params_set_channels (p->handle, p->hwparams, val);  if (err < 0)    alsa_sound_perror ("Could not set channel count", err);  err = snd_pcm_hw_params (p->handle, p->hwparams);  if (err < 0)    alsa_sound_perror ("Could not set parameters", err);  err = snd_pcm_hw_params_get_period_size (p->hwparams, &p->period_size, &dir);  if (err < 0)    alsa_sound_perror ("Unable to get period size for playback", err);  err = snd_pcm_hw_params_get_buffer_size (p->hwparams, &buffer_size);  if (err < 0)    alsa_sound_perror ("Unable to get buffer size for playback", err);  err = snd_pcm_sw_params_current (p->handle, p->swparams);  if (err < 0)    alsa_sound_perror ("Unable to determine current swparams for playback",                       err);  /* Start the transfer when the buffer is almost full */  err = snd_pcm_sw_params_set_start_threshold (p->handle, p->swparams,                                               (buffer_size / p->period_size)                                               * p->period_size);  if (err < 0)    alsa_sound_perror ("Unable to set start threshold mode for playback", err);  /* Allow the transfer when at least period_size samples can be processed */  err = snd_pcm_sw_params_set_avail_min (p->handle, p->swparams, p->period_size);  if (err < 0)    alsa_sound_perror ("Unable to set avail min for playback", err);  err = snd_pcm_sw_params (p->handle, p->swparams);  if (err < 0)    alsa_sound_perror ("Unable to set sw params for playback/n", err);  snd_pcm_hw_params_free (p->hwparams);  p->hwparams = NULL;  snd_pcm_sw_params_free (p->swparams);  p->swparams = NULL;  err = snd_pcm_prepare (p->handle);  if (err < 0)    alsa_sound_perror ("Could not prepare audio interface for use", err);  if (sd->volume > 0)    {      int chn;      snd_mixer_t *handle;      snd_mixer_elem_t *e;      const char *file = sd->file ? sd->file : DEFAULT_ALSA_SOUND_DEVICE;      if (snd_mixer_open (&handle, 0) >= 0)        {          if (snd_mixer_attach (handle, file) >= 0              && snd_mixer_load (handle) >= 0              && snd_mixer_selem_register (handle, NULL, NULL) >= 0)            for (e = snd_mixer_first_elem (handle);                 e;                 e = snd_mixer_elem_next (e))//.........这里部分代码省略.........

Error AudioDriverALSA::init() {	active=false;	thread_exited=false;	exit_thread=false;	pcm_open = false;	samples_in = NULL;	samples_out = NULL;	mix_rate = GLOBAL_DEF("audio/mix_rate",44100);	output_format = OUTPUT_STEREO;	channels = 2;	int                  status;	snd_pcm_hw_params_t *hwparams;	snd_pcm_sw_params_t *swparams;#define CHECK_FAIL(m_cond)/	if (m_cond) {/		fprintf(stderr,"ALSA ERR: %s/n",snd_strerror(status));/		snd_pcm_close(pcm_handle);/		ERR_FAIL_COND_V(m_cond,ERR_CANT_OPEN);/	}	//todo, add	//6 chans - "plug:surround51"	//4 chans - "plug:surround40";	status = snd_pcm_open(&pcm_handle, "default", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);	ERR_FAIL_COND_V( status<0, ERR_CANT_OPEN );	snd_pcm_hw_params_alloca(&hwparams);	status = snd_pcm_hw_params_any(pcm_handle, hwparams);	CHECK_FAIL( status<0 );	status = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);	CHECK_FAIL( status<0 );	//not interested in anything else	status = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE);	CHECK_FAIL( status<0 );	//todo: support 4 and 6	status = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, 2);	CHECK_FAIL( status<0 );	status = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &mix_rate, NULL);	CHECK_FAIL( status<0 );	int latency = GLOBAL_DEF("audio/output_latency",25);	buffer_size = nearest_power_of_2( latency * mix_rate / 1000 );	// set buffer size from project settings	status = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size);	CHECK_FAIL( status<0 );	// make period size 1/8 	period_size = buffer_size >> 3;	status = snd_pcm_hw_params_set_period_size_near(pcm_handle, hwparams, &period_size, NULL);	CHECK_FAIL( status<0 );	unsigned int periods=2;	status = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &periods, NULL);	CHECK_FAIL( status<0 );	status = snd_pcm_hw_params(pcm_handle,hwparams);	CHECK_FAIL( status<0 );	//snd_pcm_hw_params_free(&hwparams);	snd_pcm_sw_params_alloca(&swparams);	status = snd_pcm_sw_params_current(pcm_handle, swparams);	CHECK_FAIL( status<0 );	status = snd_pcm_sw_params_set_avail_min(pcm_handle, swparams, period_size);	CHECK_FAIL( status<0 );	status = snd_pcm_sw_params_set_start_threshold(pcm_handle, swparams, 1);	CHECK_FAIL( status<0 );	status = snd_pcm_sw_params(pcm_handle, swparams);	CHECK_FAIL( status<0 );	samples_in = memnew_arr(int32_t, period_size*channels);	samples_out = memnew_arr(int16_t, period_size*channels);	snd_pcm_nonblock(pcm_handle, 0);	mutex=Mutex::create();	thread = Thread::create(AudioDriverALSA::thread_func, this);	return OK;};

/* setup alsa data transfer behavior */static inline int alsa_set_swparams(ao_device *device){	ao_alsa_internal *internal  = (ao_alsa_internal *) device->internal;	snd_pcm_sw_params_t *params;        snd_pcm_uframes_t boundary;	int err;	/* allocate the software parameter structure */	snd_pcm_sw_params_alloca(&params);	/* fetch the current software parameters */	err = snd_pcm_sw_params_current(internal->pcm_handle, params);	if (err < 0){          adebug("snd_pcm_sw_params_current() failed./n");          return err;        }#if 0 /* the below causes more trouble than it cures */	/* allow transfers to start when there is one period */	err = snd_pcm_sw_params_set_start_threshold(internal->pcm_handle,                                                    params, internal->period_size);	if (err < 0){          adebug("snd_pcm_sw_params_set_start_threshold() failed./n");          //return err;        }	/* require a minimum of one full transfer in the buffer */	err = snd_pcm_sw_params_set_avail_min(internal->pcm_handle, params,                                              internal->period_size);	if (err < 0){          adebug("snd_pcm_sw_params_set_avail_min() failed./n");          //return err;        }#endif	/* do not align transfers; this is obsolete/deprecated in ALSA           1.x where the transfer alignemnt is always 1 (except for           buggy drivers like VIA 82xx which still demand aligned           transfers regardless of setting, in violation of the ALSA           API docs) */	err = snd_pcm_sw_params_set_xfer_align(internal->pcm_handle, params, 1);	if (err < 0){          adebug("snd_pcm_sw_params_set_xfer_align() failed./n");          //return err;        }        /* get the boundary size */        err = snd_pcm_sw_params_get_boundary(params,&boundary);	if (err < 0){          adebug("snd_pcm_sw_params_get_boundary() failed./n");        }else{          /* force a work-ahead silence buffer; this is a fix, again for             VIA 82xx, where non-MMIO transfers will buffer into             period-size transfers, but the last transfer is usually             undersized and playback falls off the end of the submitted             data. */          err = snd_pcm_sw_params_set_silence_size(internal->pcm_handle, params, boundary);          if (err < 0){            adebug("snd_pcm_sw_params_set_silence_size() failed./n");            //return err;          }        }	/* commit the params structure to ALSA */	err = snd_pcm_sw_params(internal->pcm_handle, params);	if (err < 0){          adebug("snd_pcm_sw_params() failed./n");          return err;        }	return 1;}

//.........这里部分代码省略.........        			case 24: pcm_format_id = SND_PCM_FORMAT_U24_3BE; break;        			case 32: pcm_format_id = SND_PCM_FORMAT_U32_BE;  break;        		}        		break;        	case BLT_PCM_SAMPLE_FORMAT_FLOAT_BE:                ATX_LOG_FINE("sample format is BLT_PCM_SAMPLE_FORMAT_FLOAT_LE");        		switch (format->bits_per_sample) {        			case 32: pcm_format_id = SND_PCM_FORMAT_FLOAT_BE; break;        		}        		break;        }        if (pcm_format_id == SND_PCM_FORMAT_UNKNOWN) {            return BLT_ERROR_INVALID_MEDIA_TYPE;        }        ior = snd_pcm_hw_params_set_format(self->device_handle,                                            hw_params,                                           pcm_format_id);        if (ior != 0) {            ATX_LOG_WARNING_2("snd_pcm_hw_params_set_format() failed (%d:%s)", ior, snd_strerror(ior));            return BLT_FAILURE;        }        /* set the period size */        ior = snd_pcm_hw_params_set_period_size_near(self->device_handle,                                                      hw_params,                                                     &period_size,                                                     NULL);        if (ior != 0) {            ATX_LOG_WARNING_2("snd_pcm_hw_params_set_period_size_near() failed (%d:%s)", ior, snd_strerror(ior));            return BLT_FAILURE;        }                                                                /* set the buffer time (duration) */        ior = snd_pcm_hw_params_set_buffer_time_near(self->device_handle,                                                     hw_params,                                                      &buffer_time,                                                     NULL);        if (ior != 0) {            ATX_LOG_WARNING_2("snd_pcm_hw_params_set_buffer_time_near() failed (%d:%s)", ior, snd_strerror(ior));            return BLT_FAILURE;        }        /* get the actual buffer size */        snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);        /* activate this configuration */        ior = snd_pcm_hw_params(self->device_handle, hw_params);        if (ior != 0) {            ATX_LOG_WARNING_2("snd_pcm_hw_params() failed (%d:%s)", ior, snd_strerror(ior));            return BLT_FAILURE;        }        /* configure the software parameters */        snd_pcm_sw_params_alloca_no_assert(&sw_params);        snd_pcm_sw_params_current(self->device_handle, sw_params);        /* set the start threshold to 1/2 the buffer size */        snd_pcm_sw_params_set_start_threshold(self->device_handle,                                               sw_params,                                               buffer_size/2);        /* set the buffer alignment */        /* NOTE: this call is now obsolete */        /* snd_pcm_sw_params_set_xfer_align(self->device_handle, sw_params, 1); */        /* activate the sofware parameters */        ior = snd_pcm_sw_params(self->device_handle, sw_params);        if (ior != 0) {            ATX_LOG_SEVERE_2("snd_pcm_sw_params() failed (%d:%s)", ior, snd_strerror(ior));            return BLT_FAILURE;        }        /* print status info */        {            snd_pcm_uframes_t val;            ATX_LOG_FINER_1("sample type = %x", pcm_format_id);            if (rate != format->sample_rate) {                ATX_LOG_FINER_1("actual sample = %d", rate);            }            ATX_LOG_FINER_1("actual buffer time = %d", (int)buffer_time);            ATX_LOG_FINER_1("buffer size = %d", (int)buffer_size);             snd_pcm_sw_params_get_start_threshold(sw_params, &val);            ATX_LOG_FINER_1("start threshold = %d", (int)val);             snd_pcm_sw_params_get_stop_threshold(sw_params, &val);            ATX_LOG_FINER_1("stop threshold = %d", (int)val);             snd_pcm_hw_params_get_period_size(hw_params, &val, NULL);            ATX_LOG_FINER_1("period size = %d", (int)val);        }        break;    }    /* update the state */    AlsaOutput_SetState(self, BLT_ALSA_OUTPUT_STATE_CONFIGURED);    return BLT_SUCCESS;}

static intset_swparams (GstAlsaSrc * alsa){  int err;  snd_pcm_sw_params_t *params;  snd_pcm_sw_params_malloc (&params);  /* get the current swparams */  CHECK (snd_pcm_sw_params_current (alsa->handle, params), no_config);  /* allow the transfer when at least period_size samples can be processed */  CHECK (snd_pcm_sw_params_set_avail_min (alsa->handle, params,          alsa->period_size), set_avail);  /* start the transfer on first read */  CHECK (snd_pcm_sw_params_set_start_threshold (alsa->handle, params,          0), start_threshold);  /* use monotonic timestamping */  CHECK (snd_pcm_sw_params_set_tstamp_mode (alsa->handle, params,          SND_PCM_TSTAMP_MMAP), tstamp_mode);#if GST_CHECK_ALSA_VERSION(1,0,16)  /* snd_pcm_sw_params_set_xfer_align() is deprecated, alignment is always 1 */#else  /* align all transfers to 1 sample */  CHECK (snd_pcm_sw_params_set_xfer_align (alsa->handle, params, 1), set_align);#endif  /* write the parameters to the recording device */  CHECK (snd_pcm_sw_params (alsa->handle, params), set_sw_params);  snd_pcm_sw_params_free (params);  return 0;  /* ERRORS */no_config:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to determine current swparams for playback: %s",            snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }start_threshold:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set start threshold mode for playback: %s",            snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }set_avail:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set avail min for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }tstamp_mode:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set tstamp mode for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }#if !GST_CHECK_ALSA_VERSION(1,0,16)set_align:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set transfer align for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }#endifset_sw_params:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set sw params for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }}

//.........这里部分代码省略.........    if (rc < 0) {        printf("Failed to set PCM device to mono: %s/n",                snd_strerror(rc));        exit(1);    }    /* 44100 bits/second sampling rate (CD quality) */    val = rate;    rc = snd_pcm_hw_params_set_rate_near(this->m_pHandle, this->m_pParams,                    &val, 0);    if (rc < 0) {        printf("Failed to set PCM device to sample rate =%d: %s/n",                rate,snd_strerror(rc));        exit(1);    }	if(val != rate){		printf("Rate doesn't match (request %iHz, get %iHz/n",rate,val);		exit(1);	}	rc = snd_pcm_hw_params_set_buffer_time_near(this->m_pHandle, this->m_pParams, &buffer_time, &dir);    if (rc < 0) {        fprintf(stderr, "Failed to set PCM device to buffer time=%d: %s/n",                    val,snd_strerror(rc));        exit(1);    }	rc = snd_pcm_hw_params_set_period_time_near(this->m_pHandle, this->m_pParams, &period_time, &dir);	if (rc < 0) {        fprintf(stderr, "Failed to set PCM device to period time=%d: %s/n",                    val,snd_strerror(rc));        exit(1);    }		//chunk size	rc = snd_pcm_hw_params_get_period_size(this->m_pParams, &period_size, &dir);	if(rc < 0){		fprintf(stderr, "Failed to get period size for capture: %s/n", snd_strerror(rc));		exit(1);	}	this->m_frames = period_size;	rc = snd_pcm_hw_params_get_buffer_size(this->m_pParams, &buffer_size);	if(rc < 0){		fprintf(stderr, "Failed to get buffer size for capture: %s/n", snd_strerror(rc));		exit(1);	}#ifdef DEBUG	printf("Recorder alsa driver hw params setting/n");	printf("period size =%d frames/n", (int)period_size);	printf("buffer size =%d frames/n", (int)buffer_size);	snd_pcm_hw_params_get_period_time(this->m_pParams,&val, &dir);	printf("period time =%d us/n",val);	snd_pcm_hw_params_get_buffer_time(this->m_pParams,&val, &dir);	printf("buffer time =%d us/n", val);	snd_pcm_hw_params_get_periods(this->m_pParams, &val, &dir);	printf("period per buffer =%d frames/n", val);#endif	   /* Write the parameters to the driver */    rc = snd_pcm_hw_params(this->m_pHandle, this->m_pParams);    if (rc < 0) {        printf("unable to set hw parameters: %s/n",                    snd_strerror(rc));        exit(1);    }    #ifdef ALSA_OPT	snd_pcm_sw_params_t *swparams;	snd_pcm_sw_params_alloca(&swparams);    /* get the current swparams */    rc = snd_pcm_sw_params_current(this->m_pHandle, swparams);    if (rc < 0) {            printf("Unable to determine current swparams for playback: %s/n", snd_strerror(rc));            exit(1);    }    /* start the transfer when the buffer is almost full: */    /* (buffer_size / avail_min) * avail_min */    rc = snd_pcm_sw_params_set_start_threshold(this->m_pHandle, swparams, (buffer_size / period_size) * period_size);    if (rc < 0) {            printf("Unable to set start threshold mode for playback: %s/n", snd_strerror(rc));            exit(1);    }    rc = snd_pcm_sw_params_set_avail_min(this->m_pHandle, swparams, period_size);    if (rc < 0) {            printf("Unable to set avail min for playback: %s/n", snd_strerror(rc));            exit(1);    }    /* write the parameters to the playback device */    rc = snd_pcm_sw_params(this->m_pHandle, swparams);    if (rc < 0) {            printf("Unable to set sw params for playback: %s/n", snd_strerror(rc));            exit(1);    }#endif}

//.........这里部分代码省略.........	if (err < 0) {		printf("Access type not available");		exit(EXIT_FAILURE);	}    printf("format = %s, channels = %d, rate = %d/n",            snd_pcm_format_name(hwparams.format),hwparams.channels,hwparams.rate);	//err = snd_pcm_hw_params_set_format(handle, params, hwparams.format);    err = snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);	if (err < 0) {		printf("Sample format non available");		exit(EXIT_FAILURE);	}	//err = snd_pcm_hw_params_set_channels(handle, params, hwparams.channels);    err = snd_pcm_hw_params_set_channels(handle, params, 2);	if (err < 0) {		printf("Channels count non available");		exit(EXIT_FAILURE);	}#if 0	//add by yjc 2012/08/21	err = set_audio_clk_freq(hwparams.rate);	if (err < 0){		printf("set_audio_clk_freq fail........../n");		exit(EXIT_FAILURE);	}#endif	err = snd_pcm_hw_params_set_rate(handle, params, hwparams.rate, 0);    if (err < 0) {		printf("Rate non available");		exit(EXIT_FAILURE);	}	err = snd_pcm_hw_params_get_buffer_time_max(params,						    &buffer_time, 0);	assert(err >= 0);	if (buffer_time > 500000)		buffer_time = 500000;	period_time = buffer_time / 4;	err = snd_pcm_hw_params_set_period_time_near(handle, params,		                        &period_time, 0);	assert(err >= 0);	err = snd_pcm_hw_params_set_buffer_time_near(handle, params,							     &buffer_time, 0);	assert(err >= 0);	err = snd_pcm_hw_params(handle, params);	if (err < 0) {		printf("Unable to install hw params:");		exit(EXIT_FAILURE);	}	snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);	snd_pcm_hw_params_get_buffer_size(params, &buffer_size);	if (chunk_size == buffer_size) {		printf("Can't use period equal to buffer size (%lu == %lu)",		      chunk_size, buffer_size);		exit(EXIT_FAILURE);	}	snd_pcm_sw_params_current(handle, swparams);	err = snd_pcm_sw_params_set_avail_min(handle, swparams, chunk_size);	if(stream == SND_PCM_STREAM_PLAYBACK)		start_threshold = (buffer_size / chunk_size) * chunk_size;	else		start_threshold = 1;	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);	assert(err >= 0);	err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, buffer_size);	assert(err >= 0);	if (snd_pcm_sw_params(handle, swparams) < 0) {		printf("unable to install sw params:");		exit(EXIT_FAILURE);	}	//bits_per_sample = snd_pcm_format_physical_width(hwparams.format);    bits_per_sample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);	//bits_per_frame = bits_per_sample * hwparams.channels;	bits_per_frame = bits_per_sample * 2;	chunk_bytes = chunk_size * bits_per_frame / 8;    printf("chunk_size = %d,chunk_bytes = %d,buffer_size = %d/n/n",        (int)chunk_size,chunk_bytes,(int)buffer_size);	return chunk_size;}

//.........这里部分代码省略.........    ui_error( UI_ERROR_ERROR, "couldn't set period size %d on '%s'.",                              (int)sound_periodsize, pcm_name );    snd_pcm_close( pcm_handle );    init_running = 0;    return 1;  }  if( first_init && ( exact_periodsize < sound_periodsize / 1.5 ||		      exact_periodsize > sound_periodsize * 1.5    ) ) {    fprintf( stderr,              "The period size %d is not supported by your hardware. "              "Using %d instead./n", (int)sound_periodsize,              (int)exact_periodsize );  }  periods = nperiods;/* Set number of periods. Periods used to be called fragments. */  if( snd_pcm_hw_params_set_periods_near( pcm_handle, hw_params, &periods,                                          NULL ) < 0 ) {    settings_current.sound = 0;    ui_error( UI_ERROR_ERROR, "couldn't set periods on '%s'.", pcm_name );    snd_pcm_close( pcm_handle );    init_running = 0;    return 1;  }  if( first_init && periods != nperiods ) {    fprintf( stderr, "%d periods is not supported by your hardware. "                    	     "Using %d instead./n", nperiods, periods );  }  snd_pcm_hw_params_get_buffer_size( hw_params, &exact_bsize );  /* Apply HW parameter settings to */  /* PCM device and prepare device  */  if( snd_pcm_hw_params( pcm_handle, hw_params ) < 0 ) {    settings_current.sound = 0;    ui_error( UI_ERROR_ERROR,"couldn't set hw_params on %s", pcm_name );    snd_pcm_close( pcm_handle );    init_running = 0;    return 1;  }  snd_pcm_sw_params_alloca( &sw_params );  if( ( err = snd_pcm_sw_params_current( pcm_handle, sw_params ) ) < 0 ) {    ui_error( UI_ERROR_ERROR,"couldn't get sw_params from %s: %s", pcm_name,              snd_strerror ( err ) );    snd_pcm_close( pcm_handle );    init_running = 0;    return 1;  }  if( ( err = snd_pcm_sw_params_set_start_threshold( pcm_handle,		     sw_params, exact_periodsize * ( nperiods - 1 ) ) ) < 0 ) {    ui_error( UI_ERROR_ERROR,"couldn't set start_treshold on %s: %s", pcm_name,              snd_strerror ( err ) );    snd_pcm_close( pcm_handle );    init_running = 0;    return 1;  }  if( !avail_min )    avail_min = exact_periodsize >> 1;  if( snd_pcm_sw_params_set_avail_min( pcm_handle,		    sw_params, avail_min ) < 0 ) {#if SND_LIB_VERSION < 0x10010    if( ( err = snd_pcm_sw_params_set_sleep_min( pcm_handle,    		    sw_params, 1 ) ) < 0 ) {	fprintf( stderr, "Unable to set minimal sleep 1 for %s: %s/n", pcm_name,              snd_strerror ( err ) );    }#else    fprintf( stderr, "Unable to set avail min %s: %s/n", pcm_name,    	     snd_strerror( err ) );#endif  }#if SND_LIB_VERSION < 0x10010  if( ( err = snd_pcm_sw_params_set_xfer_align( pcm_handle, sw_params, 1 ) ) < 0 ) {    ui_error( UI_ERROR_ERROR,"couldn't set xfer_allign on %s: %s", pcm_name,              snd_strerror ( err ) );    init_running = 0;    return 1;  }#endif    if( ( err = snd_pcm_sw_params( pcm_handle, sw_params ) ) < 0 ) {    ui_error( UI_ERROR_ERROR,"couldn't set sw_params on %s: %s", pcm_name,              snd_strerror ( err ) );    init_running = 0;    return 1;  }  if( first_init ) snd_output_stdio_attach(&output, stdout, 0);  first_init = 0;  init_running = 0;  return 0;	/* success */}

//.........这里部分代码省略.........        }        qLog(QAudioInput) << "channels = " << vval;        snd_pcm_hw_params_get_rate(hwparams, &vval, &dir);        if ( (int)vval != (int)frequency ) {            qLog(QAudioInput) << QString("frequency type not set, want %1 got %2").arg(frequency).arg(vval);            frequency = vval;        }        qLog(QAudioInput) << "rate =" <<  vval << " bps";        snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);        qLog(QAudioInput) << "period time =" << period_time << " us";        snd_pcm_hw_params_get_period_size(hwparams,&period_size, &dir);        qLog(QAudioInput) << "period size =" << (int)period_size;        snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);        qLog(QAudioInput) << "buffer time =" << buffer_time;        snd_pcm_hw_params_get_buffer_size(hwparams,(snd_pcm_uframes_t *) &buffer_size);        qLog(QAudioInput) << "buffer size =" << (int)buffer_size;        snd_pcm_hw_params_get_periods(hwparams, &vval, &dir);        qLog(QAudioInput) << "periods per buffer =" << vval;        snd_pcm_hw_params_get_rate_numden(hwparams, &vval, &vval2);        qLog(QAudioInput) << QString("exact rate = %1/%2 bps").arg(vval).arg(vval2).toLatin1().constData();        vval = snd_pcm_hw_params_get_sbits(hwparams);        qLog(QAudioInput) << "significant bits =" << vval;        snd_pcm_hw_params_get_tick_time(hwparams,&vval, &dir);        qLog(QAudioInput) << "tick time =" << vval;        vval = snd_pcm_hw_params_is_batch(hwparams);        qLog(QAudioInput) << "is batch =" << vval;        vval = snd_pcm_hw_params_is_block_transfer(hwparams);        qLog(QAudioInput) << "is block transfer =" << vval;        vval = snd_pcm_hw_params_is_double(hwparams);        qLog(QAudioInput) << "is double =" << vval;        vval = snd_pcm_hw_params_is_half_duplex(hwparams);        qLog(QAudioInput) << "is half duplex =" << vval;        vval = snd_pcm_hw_params_is_joint_duplex(hwparams);        qLog(QAudioInput) << "is joint duplex =" << vval;        vval = snd_pcm_hw_params_can_overrange(hwparams);        qLog(QAudioInput) << "can overrange =" << vval;        vval = snd_pcm_hw_params_can_mmap_sample_resolution(hwparams);        qLog(QAudioInput) << "can mmap =" << vval;        vval = snd_pcm_hw_params_can_pause(hwparams);        qLog(QAudioInput) << "can pause =" << vval;        vval = snd_pcm_hw_params_can_resume(hwparams);        qLog(QAudioInput) << "can resume =" << vval;        vval = snd_pcm_hw_params_can_sync_start(hwparams);        qLog(QAudioInput) << "can sync start =" << vval;        snd_pcm_sw_params_t *swparams;        snd_pcm_sw_params_alloca(&swparams);        err = snd_pcm_sw_params_current(handle, swparams);        if ( err < 0 ) {            qWarning( "QAudioInput: snd_pcm_sw_params_current: err %d",err);        }        err = snd_pcm_sw_params_set_start_threshold(handle,swparams,period_size);        if ( err < 0 ) {            qWarning( "QAudioInput: snd_pcm_sw_params_set_start_threshold: err %d",err);        }        err = snd_pcm_sw_params_set_avail_min(handle, swparams,period_size);        if ( err < 0 ) {            qWarning( "QAudioInput: snd_pcm_sw_params_set_avail_min: err %d",err);        }        err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);        if ( err < 0 ) {            qWarning( "QAudioInput: snd_pcm_sw_params_set_xfer_align: err %d",err);        }        err = snd_pcm_sw_params(handle, swparams);        if ( err < 0 ) {            qWarning( "QAudioInput: snd_pcm_sw_params: err %d",err);        }        snd_pcm_prepare(handle);        snd_pcm_start(handle);        int     count = snd_pcm_poll_descriptors_count(handle);        pollfd  *pfds = new pollfd[count];        snd_pcm_poll_descriptors(handle, pfds, count);        for (int i = 0; i < count; ++i)        {            if ((pfds[i].events & POLLIN) != 0) {                notifier = new QSocketNotifier(pfds[i].fd, QSocketNotifier::Read);                QObject::connect(notifier,                                 SIGNAL(activated(int)),                                 input,                                 SIGNAL(readyRead()));                break;            }        }        if (notifier == NULL) {            rc = false;        }        delete pfds;    }    return rc;}

static int sndo_pcm_initialize(sndo_pcm_t *pcm){	int err;	snd_pcm_uframes_t boundary;	snd_pcm_uframes_t p_period_size = ~0UL, c_period_size = ~0UL;	snd_pcm_uframes_t p_buffer_size = ~0UL, c_buffer_size = ~0UL;	if (pcm->playback) {		err = snd_pcm_hw_params(pcm->playback, pcm->p_hw_params);		if (err < 0)			return err;		err = snd_pcm_hw_params_get_period_size(pcm->p_hw_params, &p_period_size, NULL);		if (err < 0)			return err;		err = snd_pcm_hw_params_get_buffer_size(pcm->p_hw_params, &p_buffer_size);		if (err < 0)			return err;	}	if (pcm->capture) {		err = snd_pcm_hw_params(pcm->capture, pcm->c_hw_params);		if (err < 0)			return err;		err = snd_pcm_hw_params_get_period_size(pcm->c_hw_params, &c_period_size, NULL);		if (err < 0)			return err;		err = snd_pcm_hw_params_get_buffer_size(pcm->c_hw_params, &c_buffer_size);		if (err < 0)			return err;	}	if (p_period_size < c_period_size)		pcm->transfer_block = p_period_size;	else		pcm->transfer_block = c_period_size;	if (p_buffer_size < c_buffer_size)		pcm->ring_size = p_buffer_size;	else		pcm->ring_size = c_buffer_size;	if (pcm->playback) {		err = snd_pcm_sw_params_get_boundary(pcm->p_sw_params, &boundary);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_start_threshold(pcm->playback, pcm->p_sw_params, boundary);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_stop_threshold(pcm->playback, pcm->p_sw_params, pcm->xrun == SNDO_PCM_XRUN_IGNORE ? boundary : pcm->ring_size);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_xfer_align(pcm->playback, pcm->p_sw_params, 1);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_avail_min(pcm->playback, pcm->p_sw_params, pcm->transfer_block);		if (err < 0)			return err;		err = snd_pcm_sw_params(pcm->playback, pcm->p_sw_params);		if (err < 0)			return err;	}	if (pcm->capture) {		err = snd_pcm_sw_params_get_boundary(pcm->c_sw_params, &boundary);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_start_threshold(pcm->capture, pcm->c_sw_params, boundary);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_stop_threshold(pcm->capture, pcm->c_sw_params, pcm->xrun == SNDO_PCM_XRUN_IGNORE ? boundary : pcm->ring_size);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_xfer_align(pcm->capture, pcm->c_sw_params, 1);		if (err < 0)			return err;		err = snd_pcm_sw_params_set_avail_min(pcm->capture, pcm->c_sw_params, pcm->transfer_block);		if (err < 0)			return err;		err = snd_pcm_sw_params(pcm->capture, pcm->c_sw_params);		if (err < 0)			return err;	}	pcm->initialized = 1;	return 0;}

static int pcm_open(pcm_handle_t* pcm, const pcm_desc_t* desc){  const snd_pcm_format_t fmt = SND_PCM_FORMAT_S16_LE;  snd_pcm_stream_t stm;  int err;  if (desc->flags & PCM_FLAG_IN) stm = SND_PCM_STREAM_CAPTURE;  else stm = SND_PCM_STREAM_PLAYBACK;  err = snd_pcm_open    (&pcm->pcm, desc->name, stm, SND_PCM_NONBLOCK);  if (err) PERROR_GOTO(snd_strerror(err), on_error_0);  err = snd_pcm_hw_params_malloc(&pcm->hw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_1);  err = snd_pcm_hw_params_any(pcm->pcm, pcm->hw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  err = snd_pcm_hw_params_set_access    (pcm->pcm, pcm->hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  err = snd_pcm_hw_params_set_format(pcm->pcm, pcm->hw_params, fmt);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  err = snd_pcm_hw_params_set_rate    (pcm->pcm, pcm->hw_params, desc->fsampl, 0);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  pcm->nchan = desc->nchan;  pcm->wchan = (size_t)snd_pcm_format_physical_width(fmt) / 8;  pcm->scale = pcm->nchan * pcm->wchan;  err = snd_pcm_hw_params_set_channels    (pcm->pcm, pcm->hw_params, desc->nchan);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);    err = snd_pcm_hw_params(pcm->pcm, pcm->hw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  err = snd_pcm_sw_params_malloc(&pcm->sw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_2);  err = snd_pcm_sw_params_current(pcm->pcm, pcm->sw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_3);#if 1  err = snd_pcm_sw_params_set_avail_min    (pcm->pcm, pcm->sw_params, 1024);  if (err) PERROR_GOTO(snd_strerror(err), on_error_3);#endif#if 1  err = snd_pcm_sw_params_set_start_threshold    (pcm->pcm, pcm->sw_params, 0U);  if (err) PERROR_GOTO(snd_strerror(err), on_error_3);#endif  err = snd_pcm_sw_params(pcm->pcm, pcm->sw_params);  if (err) PERROR_GOTO(snd_strerror(err), on_error_3);    err = snd_pcm_prepare(pcm->pcm);  if (err) PERROR_GOTO(snd_strerror(err), on_error_3);  pcm->rpos = 0;  pcm->wpos = 0;  pcm->nsampl = (size_t)desc->fsampl * 10;  pcm->buf = malloc(pcm->nsampl * pcm->scale);  if (pcm->buf == NULL) goto on_error_3;  return 0; on_error_3:  snd_pcm_sw_params_free(pcm->sw_params); on_error_2:  snd_pcm_hw_params_free(pcm->hw_params); on_error_1:  snd_pcm_close(pcm->pcm); on_error_0:  return -1;  }

//.........这里部分代码省略.........    /* Set up the information for recording from the audio channelport.  This     will include data specified by the user, such as data in     aTIesrFAInstance->encoding, etc.   If setup fails, then the audio channel     should be shut down and failure reported. */    /* Setup hardware parameters of the ALSA pcm */    rtnStatus = snd_pcm_hw_params_malloc( &hw_params );    if( rtnStatus < 0 )        goto openExit;    rtnStatus = snd_pcm_hw_params_any( ALSAData->alsa_handle, hw_params );    if( rtnStatus < 0 )        goto openExit;    /* There will only be a single channel */    rtnStatus = snd_pcm_hw_params_set_channels( ALSAData->alsa_handle,            hw_params, 1 );    if( rtnStatus < 0 )        goto openExit;    /* Even though only one channel, must specify type of read. */    rtnStatus = snd_pcm_hw_params_set_access( ALSAData->alsa_handle,            hw_params,            SND_PCM_ACCESS_RW_INTERLEAVED );    if( rtnStatus < 0 )        goto openExit;    /* Format type - only 16 bit linear for now */    rtnStatus = snd_pcm_hw_params_set_format( ALSAData->alsa_handle,            hw_params,            SND_PCM_FORMAT_S16 );    if( rtnStatus < 0 )        goto openExit;    /* Set sample rate, it must be exactly supported */    rtnStatus = snd_pcm_hw_params_set_rate( ALSAData->alsa_handle,            hw_params,            aTIesrFAInstance->sample_rate, 0 );    if( rtnStatus < 0 )        goto openExit;    /* Size of ALSA PCM ring buffer is set to approximately the desired      number of multiples of read_samples in the buffer */    numSamples = aTIesrFAInstance->num_audio_buffer_frames *            ALSAData->read_samples;    rtnStatus = snd_pcm_hw_params_set_buffer_size_near( ALSAData->alsa_handle,            hw_params, &numSamples );    if( rtnStatus < 0 )        goto openExit;    /* Set the hardware parameters in the PCM*/    rtnStatus = snd_pcm_hw_params( ALSAData->alsa_handle, hw_params );    if( rtnStatus < 0 )        goto openExit;    /* Set software parameters to interrupt at the end of an audio buffer      number of samples and to start-up manually */    rtnStatus = snd_pcm_sw_params_malloc( &sw_params );    if( rtnStatus < 0 )        goto openExit;    rtnStatus = snd_pcm_sw_params_current( ALSAData->alsa_handle, sw_params );    if( rtnStatus < 0 )        goto openExit;    /* Number of samples needed in PCM buffer prior to interrupt */    rtnStatus = snd_pcm_sw_params_set_avail_min( ALSAData->alsa_handle,            sw_params, ALSAData->read_samples );    if( rtnStatus < 0 )        goto openExit;    /* Set start threshold so startup is done manually */    rtnStatus = snd_pcm_sw_params_set_start_threshold( ALSAData->alsa_handle,            sw_params, ULONG_MAX );    if( rtnStatus < 0 )        goto openExit;    /* Channel opened successfully */    openSuccess = 1;openExit:    if( hw_params != NULL )        snd_pcm_hw_params_free( hw_params );    if( sw_params != NULL )        snd_pcm_sw_params_free( sw_params );    if( openSuccess )        return TIesrFA_ALSAErrNone;    return TIesrFA_ALSAErrFail;}

int setparams_set(snd_pcm_t *handle,		  snd_pcm_hw_params_t *params,		  snd_pcm_sw_params_t *swparams,		  const char *id){	int err;	snd_pcm_uframes_t val;	unsigned int sleep_min = 0;	err = snd_pcm_hw_params(handle, params);	if (err < 0) {		printf("Unable to set hw params for %s: %s/n", id, snd_strerror(err));		return err;	}	err = snd_pcm_sw_params_current(handle, swparams);	if (err < 0) {		printf("Unable to determine current swparams for %s: %s/n", id, snd_strerror(err));		return err;	}	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);	if (err < 0) {		printf("Unable to set start threshold mode for %s: %s/n", id, snd_strerror(err));		return err;	}	tick_time_ok = 0;	if (tick_time > 0) {		int time, ttime;		snd_pcm_hw_params_get_period_time(params, &time, NULL);		 snd_pcm_hw_params_get_tick_time(params, &ttime, NULL);		if (time < ttime) {			printf("Skipping to set minimal sleep: period time < tick time/n");		} else if (ttime <= 0) {			printf("Skipping to set minimal sleep: tick time <= 0 (%i)/n", ttime);		} else {			sleep_min = tick_time / ttime;			if (sleep_min <= 0)				sleep_min = 1;			err = snd_pcm_sw_params_set_sleep_min(handle, swparams, sleep_min);			if (err < 0) {				printf("Unable to set minimal sleep %i for %s: %s/n", sleep_min, id, snd_strerror(err));				return err;			}			tick_time_ok = sleep_min * ttime;		}	}	if (!block)		val = 4;	else		snd_pcm_hw_params_get_period_size(params, &val, NULL);	if (tick_time_ok > 0)		val = 16;	err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);	if (err < 0) {		printf("Unable to set avail min for %s: %s/n", id, snd_strerror(err));		return err;	}	val = !block ? 4 : 1;	err = snd_pcm_sw_params_set_xfer_align(handle, swparams, val);	if (err < 0) {		printf("Unable to set transfer align for %s: %s/n", id, snd_strerror(err));		return err;	}	err = snd_pcm_sw_params(handle, swparams);	if (err < 0) {		printf("Unable to set sw params for %s: %s/n", id, snd_strerror(err));		return err;	}	return 0;}

//.........这里部分代码省略.........	{		oss << "cannot set access type : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Set Sample format: Signed 16bit little endian. */	if ((err = snd_pcm_hw_params_set_format (playback_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0)	{		oss << "cannot set sample format : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Set the Sample rate. */	if ((err = snd_pcm_hw_params_set_rate (playback_handle, hw_params, 22050, 0)) < 0)	{		oss << "cannot set sample rate : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Set Channel number (MONO). */	if ((err = snd_pcm_hw_params_set_channels (playback_handle, hw_params, 1)) < 0)	{		oss << "cannot set channel count : " << snd_strerror (err) << endl;		throw oss.str();	}	if ((err = snd_pcm_hw_params_set_buffer_size(playback_handle, hw_params, 2048)) < 0)	{		oss << "cannot set channel buffer size : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Apply these parameters. */	if ((err = snd_pcm_hw_params (playback_handle, hw_params)) < 0)	{		oss << "cannot apply parameters : " << snd_strerror (err) << endl;		throw oss.str();	}	snd_pcm_uframes_t bufferSize;	snd_pcm_hw_params_get_buffer_size( hw_params, &bufferSize );	//cout << "initAlsa: Buffer size = " << bufferSize << " frames." << endl;	/* Free memoray allocated for snd_pcm_hw_params_t */	snd_pcm_hw_params_free (hw_params);	/* tell ALSA to wake us up whenever 4096 or more frames	   of playback data can be delivered. Also, tell	   ALSA that we'll start the device ourselves.	*/	/* Allocate snd_pcm_sw_params_t structure. */	if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0)	{		oss << "cannot allocate software parameters structure : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Get the current software configuration*/	if ((err = snd_pcm_sw_params_current (playback_handle, sw_params)) < 0)	{		oss << "cannot initialize software parameters structure : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Set the wake up point to 2048 (92.9 ms). The minimum data available before asking*/	/* for new ones. */	if ((err = snd_pcm_sw_params_set_avail_min (playback_handle, sw_params, 2048U)) < 0)	{		oss << "cannot set minimum available count : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Set when ALSA starts to play. */	if ((err = snd_pcm_sw_params_set_start_threshold (playback_handle, sw_params, 1024U)) < 0)	{		oss << "cannot set start mode : " << snd_strerror (err) << endl;		throw oss.str();	}	/* Apply parameters. */	if ((err = snd_pcm_sw_params (playback_handle, sw_params)) < 0)	{		oss << "cannot apply software parameters : " << snd_strerror (err) << endl;		throw oss.str();	}	/* the interface will interrupt the kernel every 4096 frames, and ALSA	   will wake up this program very soon after that.	*/	if ((err = snd_pcm_prepare (playback_handle)) < 0)	{		oss << "cannot prepare audio interface for use : " << snd_strerror (err) << endl;		throw oss.str();	}}

static boolean tsmf_alsa_set_format(ITSMFAudioDevice* audio,	uint32 sample_rate, uint32 channels, uint32 bits_per_sample){	int error;	snd_pcm_uframes_t frames;	snd_pcm_hw_params_t* hw_params;	snd_pcm_sw_params_t* sw_params;	TSMFALSAAudioDevice* alsa = (TSMFALSAAudioDevice*) audio;	if (!alsa->out_handle)		return false;	snd_pcm_drop(alsa->out_handle);	alsa->actual_rate = alsa->source_rate = sample_rate;	alsa->actual_channels = alsa->source_channels = channels;	alsa->bytes_per_sample = bits_per_sample / 8;	error = snd_pcm_hw_params_malloc(&hw_params);	if (error < 0)	{		DEBUG_WARN("snd_pcm_hw_params_malloc failed");		return false;	}	snd_pcm_hw_params_any(alsa->out_handle, hw_params);	snd_pcm_hw_params_set_access(alsa->out_handle, hw_params,		SND_PCM_ACCESS_RW_INTERLEAVED);	snd_pcm_hw_params_set_format(alsa->out_handle, hw_params,		SND_PCM_FORMAT_S16_LE);	snd_pcm_hw_params_set_rate_near(alsa->out_handle, hw_params,		&alsa->actual_rate, NULL);	snd_pcm_hw_params_set_channels_near(alsa->out_handle, hw_params,		&alsa->actual_channels);	frames = sample_rate;	snd_pcm_hw_params_set_buffer_size_near(alsa->out_handle, hw_params,		&frames);	snd_pcm_hw_params(alsa->out_handle, hw_params);	snd_pcm_hw_params_free(hw_params);	error = snd_pcm_sw_params_malloc(&sw_params);	if (error < 0)	{		DEBUG_WARN("snd_pcm_sw_params_malloc");		return false;	}	snd_pcm_sw_params_current(alsa->out_handle, sw_params);	snd_pcm_sw_params_set_start_threshold(alsa->out_handle, sw_params,		frames / 2);	snd_pcm_sw_params(alsa->out_handle, sw_params);	snd_pcm_sw_params_free(sw_params);	snd_pcm_prepare(alsa->out_handle);	DEBUG_DVC("sample_rate %d channels %d bits_per_sample %d",		sample_rate, channels, bits_per_sample);	DEBUG_DVC("hardware buffer %d frames", (int)frames);	if ((alsa->actual_rate != alsa->source_rate) ||		(alsa->actual_channels != alsa->source_channels))	{		DEBUG_DVC("actual rate %d / channel %d is different "			"from source rate %d / channel %d, resampling required.",			alsa->actual_rate, alsa->actual_channels,			alsa->source_rate, alsa->source_channels);	}	return true;}

//.........这里部分代码省略.........   }   /*fprintf (stderr, "rate = %d/n", rate);*/   if ((err = snd_pcm_hw_params_set_channels (dev->playback_handle, hw_params, channels)) < 0) {      fprintf (stderr, "cannot set channel count (%s)/n",               snd_strerror (err));      assert(0);   }      period_size = period;   dir = 0;   if ((err = snd_pcm_hw_params_set_period_size_near (dev->playback_handle, hw_params, &period_size, &dir)) < 0) {      fprintf (stderr, "cannot set period size (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_hw_params_set_periods (dev->playback_handle, hw_params, PERIODS, 0)) < 0) {      fprintf (stderr, "cannot set number of periods (%s)/n",               snd_strerror (err));      assert(0);   }   buffer_size = period_size * PERIODS;   dir=0;   if ((err = snd_pcm_hw_params_set_buffer_size_near (dev->playback_handle, hw_params, &buffer_size)) < 0) {      fprintf (stderr, "cannot set buffer time (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_hw_params (dev->playback_handle, hw_params)) < 0) {      fprintf (stderr, "cannot set playback parameters (%s)/n",               snd_strerror (err));      assert(0);   }   /*snd_pcm_dump_setup(dev->playback_handle, jcd_out);*/   snd_pcm_hw_params_free (hw_params);      if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {      fprintf (stderr, "cannot allocate software parameters structure (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_sw_params_current (dev->playback_handle, sw_params)) < 0) {      fprintf (stderr, "cannot initialize software parameters structure (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_sw_params_set_avail_min (dev->playback_handle, sw_params, period)) < 0) {      fprintf (stderr, "cannot set minimum available count (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_sw_params_set_start_threshold (dev->playback_handle, sw_params, period)) < 0) {      fprintf (stderr, "cannot set start mode (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_sw_params (dev->playback_handle, sw_params)) < 0) {      fprintf (stderr, "cannot set software parameters (%s)/n",               snd_strerror (err));      assert(0);   }        snd_pcm_link(dev->capture_handle, dev->playback_handle);   if ((err = snd_pcm_prepare (dev->capture_handle)) < 0) {      fprintf (stderr, "cannot prepare audio interface for use (%s)/n",               snd_strerror (err));      assert(0);   }   if ((err = snd_pcm_prepare (dev->playback_handle)) < 0) {      fprintf (stderr, "cannot prepare audio interface for use (%s)/n",               snd_strerror (err));      assert(0);   }      dev->readN = snd_pcm_poll_descriptors_count(dev->capture_handle);   dev->writeN = snd_pcm_poll_descriptors_count(dev->playback_handle);   dev->read_fd = malloc(dev->readN*sizeof(*dev->read_fd));   /*printf ("descriptors: %d %d/n", dev->readN, dev->writeN);*/   if (snd_pcm_poll_descriptors(dev->capture_handle, dev->read_fd, dev->readN) != dev->readN)   {      fprintf (stderr, "cannot obtain capture file descriptors (%s)/n",               snd_strerror (err));      assert(0);   }      dev->write_fd = malloc(dev->writeN*sizeof(*dev->read_fd));   if (snd_pcm_poll_descriptors(dev->playback_handle, dev->write_fd, dev->writeN) != dev->writeN)   {      fprintf (stderr, "cannot obtain playback file descriptors (%s)/n",               snd_strerror (err));      assert(0);   }   return dev;}

//.........这里部分代码省略.........  err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);  if (err < 0) {    printf("Access type not available for playback: %s/n", snd_strerror(err));    return;  }  /* set the sample format */  err = snd_pcm_hw_params_set_format(handle, hwparams, format);  if (err < 0) {    printf("Sample format not available for playback: %s/n", snd_strerror(err));    return;  }  /* set the count of channels */  channels = devout->dsp_channels;  err = snd_pcm_hw_params_set_channels(handle, hwparams, channels);  if (err < 0) {    printf("Channels count (%i) not available for playbacks: %s/n", channels, snd_strerror(err));    return;  }  /* set the stream rate */  rate = devout->frequency;  rrate = rate;  err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &rrate, 0);  if (err < 0) {    printf("Rate %iHz not available for playback: %s/n", rate, snd_strerror(err));    return;  }  if (rrate != rate) {    printf("Rate doesn't match (requested %iHz, get %iHz)/n", rate, err);    exit(-EINVAL);  }  /* set the buffer size */  size = devout->buffer_size;  err = snd_pcm_hw_params_set_buffer_size(handle, hwparams, size);  if (err < 0) {    printf("Unable to set buffer size %i for playback: %s/n", size, snd_strerror(err));    return;  }  buffer_size = size;  /* set the period time */  err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, &dir);  if (err < 0) {    printf("Unable to set period time %i for playback: %s/n", period_time, snd_strerror(err));    return;  }  err = snd_pcm_hw_params_get_period_size(hwparams, &size, &dir);  if (err < 0) {    printf("Unable to get period size for playback: %s/n", snd_strerror(err));    return;  }  period_size = size;  /* write the parameters to device */  err = snd_pcm_hw_params(handle, hwparams);  if (err < 0) {    printf("Unable to set hw params for playback: %s/n", snd_strerror(err));    return;  }  /* get the current swparams */  err = snd_pcm_sw_params_current(handle, swparams);  if (err < 0) {    printf("Unable to determine current swparams for playback: %s/n", snd_strerror(err));    return;  }  /* start the transfer when the buffer is almost full: */  /* (buffer_size / avail_min) * avail_min */  err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);  if (err < 0) {    printf("Unable to set start threshold mode for playback: %s/n", snd_strerror(err));    return;  }  /* allow the transfer when at least period_size samples can be processed */  /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */  err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_event ? buffer_size : period_size);  if (err < 0) {    printf("Unable to set avail min for playback: %s/n", snd_strerror(err));    return;  }  /* write the parameters to the playback device */  err = snd_pcm_sw_params(handle, swparams);  if (err < 0) {    printf("Unable to set sw params for playback: %s/n", snd_strerror(err));    return;  }  /*  */  devout->out.alsa.handle = handle;  devout->delay_counter = 0;}

static intset_swparams (GstAlsaSink * alsa){  int err;  snd_pcm_sw_params_t *params;  snd_pcm_sw_params_malloc (&params);  /* get the current swparams */  CHECK (snd_pcm_sw_params_current (alsa->handle, params), no_config);  /* start the transfer when the buffer is almost full: */  /* (buffer_size / avail_min) * avail_min */  CHECK (snd_pcm_sw_params_set_start_threshold (alsa->handle, params,          (alsa->buffer_size / alsa->period_size) * alsa->period_size),      start_threshold);  /* allow the transfer when at least period_size samples can be processed */  CHECK (snd_pcm_sw_params_set_avail_min (alsa->handle, params,          alsa->period_size), set_avail);#if GST_CHECK_ALSA_VERSION(1,0,16)  /* snd_pcm_sw_params_set_xfer_align() is deprecated, alignment is always 1 */#else  /* align all transfers to 1 sample */  CHECK (snd_pcm_sw_params_set_xfer_align (alsa->handle, params, 1), set_align);#endif  /* write the parameters to the playback device */  CHECK (snd_pcm_sw_params (alsa->handle, params), set_sw_params);  snd_pcm_sw_params_free (params);  return 0;  /* ERRORS */no_config:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to determine current swparams for playback: %s",            snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }start_threshold:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set start threshold mode for playback: %s",            snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }set_avail:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set avail min for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }#if !GST_CHECK_ALSA_VERSION(1,0,16)set_align:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set transfer align for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }#endifset_sw_params:  {    GST_ELEMENT_ERROR (alsa, RESOURCE, SETTINGS, (NULL),        ("Unable to set sw params for playback: %s", snd_strerror (err)));    snd_pcm_sw_params_free (params);    return err;  }}

bool WaveRecorder::init(uint32_t samples_per_sec,                        uint32_t bits_per_sample,                        uint32_t channels,                        uint32_t frame_size){    const char* pcm_device = "default";    snd_pcm_format_t format;    int err;    _frame_size = frame_size;    switch (bits_per_sample) {    case 8:        format = SND_PCM_FORMAT_S8;        break;    case 16:        format = SND_PCM_FORMAT_S16_LE;        break;    default:        return false;    }    if ((err = snd_pcm_open(&_pcm, pcm_device, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0) {        LOG_ERROR("cannot open audio record device %s %s", pcm_device, snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_malloc(&_hw_params)) < 0) {        LOG_ERROR("cannot allocate hardware parameter structure %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_sw_params_malloc(&_sw_params)) < 0) {        LOG_ERROR("cannot allocate software parameter structure %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_any(_pcm, _hw_params)) < 0) {        LOG_ERROR("cannot initialize hardware parameter structure %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_set_rate_resample(_pcm, _hw_params, 1)) < 0) {        LOG_ERROR("cannot set rate resample %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_set_access(_pcm, _hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {        LOG_ERROR("cannot set access type %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_set_rate(_pcm, _hw_params, samples_per_sec, 0)) < 0) {        LOG_ERROR("cannot set sample rate %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_set_channels(_pcm, _hw_params, channels)) < 0) {        LOG_ERROR("cannot set channel count %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params_set_format(_pcm, _hw_params, format)) < 0) {        LOG_ERROR("cannot set sample format %s", snd_strerror(err));        return false;    }    int direction = 0;    snd_pcm_uframes_t buffer_size = (samples_per_sec * 160 / 1000) / frame_size * frame_size;    if ((err = snd_pcm_hw_params_set_buffer_size_near(_pcm, _hw_params, &buffer_size)) < 0) {        LOG_ERROR("cannot set buffer size %s", snd_strerror(err));        return false;    }    snd_pcm_uframes_t period_size = frame_size;    if ((err = snd_pcm_hw_params_set_period_size_near(_pcm, _hw_params, &period_size,                                                      &direction)) < 0) {        LOG_ERROR("cannot set period size near %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_hw_params(_pcm, _hw_params)) < 0) {        LOG_ERROR("cannot set parameters %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_sw_params_current(_pcm, _sw_params)) < 0) {        LOG_ERROR("cannot get current sw parameters %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_sw_params_set_start_threshold(_pcm, _sw_params, frame_size)) < 0) {        LOG_ERROR("cannot set start threshold %s", snd_strerror(err));        return false;    }    if ((err = snd_pcm_sw_params(_pcm, _sw_params)) < 0) {        LOG_ERROR("cannot set sw parameters %s", snd_strerror(err));        return false;//.........这里部分代码省略.........

int ai_alsa_setup(audio_in_t *ai){    snd_pcm_hw_params_t *params;    snd_pcm_sw_params_t *swparams;    int buffer_size;    int err;    unsigned int rate;    snd_pcm_hw_params_alloca(&params);    snd_pcm_sw_params_alloca(&swparams);    err = snd_pcm_hw_params_any(ai->alsa.handle, params);    if (err < 0) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_PcmBrokenConfig);	return -1;    }    err = snd_pcm_hw_params_set_access(ai->alsa.handle, params,				       SND_PCM_ACCESS_RW_INTERLEAVED);    if (err < 0) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_UnavailableAccessType);	return -1;    }    err = snd_pcm_hw_params_set_format(ai->alsa.handle, params, SND_PCM_FORMAT_S16_LE);    if (err < 0) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_UnavailableSampleFmt);	return -1;    }    err = snd_pcm_hw_params_set_channels(ai->alsa.handle, params, ai->req_channels);    if (err < 0) {	ai->channels = snd_pcm_hw_params_get_channels(params);	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_UnavailableChanCount,	       ai->channels);    } else {	ai->channels = ai->req_channels;    }    err = snd_pcm_hw_params_set_rate_near(ai->alsa.handle, params, ai->req_samplerate, 0);    assert(err >= 0);    rate = err;    ai->samplerate = rate;    ai->alsa.buffer_time = 1000000;    ai->alsa.buffer_time = snd_pcm_hw_params_set_buffer_time_near(ai->alsa.handle, params,							       ai->alsa.buffer_time, 0);    assert(ai->alsa.buffer_time >= 0);    ai->alsa.period_time = ai->alsa.buffer_time / 4;    ai->alsa.period_time = snd_pcm_hw_params_set_period_time_near(ai->alsa.handle, params,							       ai->alsa.period_time, 0);    assert(ai->alsa.period_time >= 0);    err = snd_pcm_hw_params(ai->alsa.handle, params);    if (err < 0) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_CannotInstallHWParams);	snd_pcm_hw_params_dump(params, ai->alsa.log);	return -1;    }    ai->alsa.chunk_size = snd_pcm_hw_params_get_period_size(params, 0);    buffer_size = snd_pcm_hw_params_get_buffer_size(params);    if (ai->alsa.chunk_size == buffer_size) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_PeriodEqualsBufferSize, ai->alsa.chunk_size, (long)buffer_size);	return -1;    }    snd_pcm_sw_params_current(ai->alsa.handle, swparams);    err = snd_pcm_sw_params_set_sleep_min(ai->alsa.handle, swparams,0);    assert(err >= 0);    err = snd_pcm_sw_params_set_avail_min(ai->alsa.handle, swparams, ai->alsa.chunk_size);    assert(err >= 0);    err = snd_pcm_sw_params_set_start_threshold(ai->alsa.handle, swparams, 0);    assert(err >= 0);    err = snd_pcm_sw_params_set_stop_threshold(ai->alsa.handle, swparams, buffer_size);    assert(err >= 0);    assert(err >= 0);    if (snd_pcm_sw_params(ai->alsa.handle, swparams) < 0) {	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_CannotInstallSWParams);	snd_pcm_sw_params_dump(swparams, ai->alsa.log);	return -1;    }    if (mp_msg_test(MSGT_TV, MSGL_V)) {	snd_pcm_dump(ai->alsa.handle, ai->alsa.log);    }    ai->alsa.bits_per_sample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);    ai->alsa.bits_per_frame = ai->alsa.bits_per_sample * ai->channels;    ai->blocksize = ai->alsa.chunk_size * ai->alsa.bits_per_frame / 8;    ai->samplesize = ai->alsa.bits_per_sample;    ai->bytes_per_sample = ai->alsa.bits_per_sample/8;    return 0;}

static void *alsa_init(const char *device, unsigned rate, unsigned latency){   alsa_t *alsa = (alsa_t*)calloc(1, sizeof(alsa_t));   if (!alsa)      return NULL;   snd_pcm_hw_params_t *params = NULL;   snd_pcm_sw_params_t *sw_params = NULL;   const char *alsa_dev = "default";   if (device)      alsa_dev = device;   unsigned latency_usec = latency * 1000 / 2;   unsigned channels = 2;   unsigned periods = 4;   snd_pcm_uframes_t buffer_size;   snd_pcm_format_t format;   TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, 0));   TRY_ALSA(snd_pcm_hw_params_malloc(&params));   alsa->has_float = find_float_format(alsa->pcm, params);   format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;   TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));   TRY_ALSA(snd_pcm_hw_params_set_access(alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));   TRY_ALSA(snd_pcm_hw_params_set_format(alsa->pcm, params, format));   TRY_ALSA(snd_pcm_hw_params_set_channels(alsa->pcm, params, channels));   TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));   TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(alsa->pcm, params, &latency_usec, NULL));   TRY_ALSA(snd_pcm_hw_params_set_periods_near(alsa->pcm, params, &periods, NULL));   TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));   snd_pcm_hw_params_get_period_size(params, &alsa->period_frames, NULL);   RARCH_LOG("ALSA: Period size: %d frames/n", (int)alsa->period_frames);   snd_pcm_hw_params_get_buffer_size(params, &buffer_size);   RARCH_LOG("ALSA: Buffer size: %d frames/n", (int)buffer_size);   alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);   alsa->period_size = snd_pcm_frames_to_bytes(alsa->pcm, alsa->period_frames);   TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));   TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));   TRY_ALSA(snd_pcm_sw_params_set_start_threshold(alsa->pcm, sw_params, buffer_size / 2));   TRY_ALSA(snd_pcm_sw_params(alsa->pcm, sw_params));   snd_pcm_hw_params_free(params);   snd_pcm_sw_params_free(sw_params);   alsa->fifo_lock = slock_new();   alsa->cond_lock = slock_new();   alsa->cond = scond_new();   alsa->buffer = fifo_new(alsa->buffer_size);   if (!alsa->fifo_lock || !alsa->cond_lock || !alsa->cond || !alsa->buffer)      goto error;   alsa->worker_thread = sthread_create(alsa_worker_thread, alsa);   if (!alsa->worker_thread)   {      RARCH_ERR("error initializing worker thread");      goto error;   }   return alsa;error:   RARCH_ERR("ALSA: Failed to initialize.../n");   if (params)      snd_pcm_hw_params_free(params);   if (sw_params)      snd_pcm_sw_params_free(sw_params);   alsa_free(alsa);   return NULL;}

static void rdpsnd_alsa_set_params(rdpsndAlsaPlugin* alsa){    snd_pcm_hw_params_t* hw_params;    snd_pcm_sw_params_t* sw_params;    int error;    snd_pcm_uframes_t frames;    snd_pcm_uframes_t start_threshold;    snd_pcm_drop(alsa->out_handle);    error = snd_pcm_hw_params_malloc(&hw_params);    if (error < 0)    {        DEBUG_WARN("snd_pcm_hw_params_malloc failed");        return;    }    snd_pcm_hw_params_any(alsa->out_handle, hw_params);    snd_pcm_hw_params_set_access(alsa->out_handle, hw_params,                                 SND_PCM_ACCESS_RW_INTERLEAVED);    snd_pcm_hw_params_set_format(alsa->out_handle, hw_params,                                 alsa->format);    snd_pcm_hw_params_set_rate_near(alsa->out_handle, hw_params,                                    &alsa->actual_rate, NULL);    snd_pcm_hw_params_set_channels_near(alsa->out_handle, hw_params,                                        &alsa->actual_channels);    if (alsa->latency < 0)        frames = alsa->actual_rate * 4; /* Default to 4-second buffer */    else        frames = alsa->latency * alsa->actual_rate * 2 / 1000; /* Double of the latency */    if (frames < alsa->actual_rate / 2)        frames = alsa->actual_rate / 2; /* Minimum 0.5-second buffer */    snd_pcm_hw_params_set_buffer_size_near(alsa->out_handle, hw_params,                                           &frames);    snd_pcm_hw_params(alsa->out_handle, hw_params);    snd_pcm_hw_params_free(hw_params);    error = snd_pcm_sw_params_malloc(&sw_params);    if (error < 0)    {        DEBUG_WARN("snd_pcm_sw_params_malloc failed");        return;    }    snd_pcm_sw_params_current(alsa->out_handle, sw_params);    if (alsa->latency == 0)        start_threshold = 0;    else        start_threshold = frames / 2;    snd_pcm_sw_params_set_start_threshold(alsa->out_handle, sw_params, start_threshold);    snd_pcm_sw_params(alsa->out_handle, sw_params);    snd_pcm_sw_params_free(sw_params);    snd_pcm_prepare(alsa->out_handle);    DEBUG_SVC("hardware buffer %d frames, playback buffer %.2g seconds",              (int)frames, (double)frames / 2.0 / (double)alsa->actual_rate);    if ((alsa->actual_rate != alsa->source_rate) ||            (alsa->actual_channels != alsa->source_channels))    {        DEBUG_SVC("actual rate %d / channel %d is different from source rate %d / channel %d, resampling required.",                  alsa->actual_rate, alsa->actual_channels, alsa->source_rate, alsa->source_channels);    }}

	main (int argc, char *argv[])	{			snd_pcm_hw_params_t *hw_params;		snd_pcm_sw_params_t *sw_params;		snd_pcm_sframes_t frames_to_deliver;		int nfds;		int err;		struct pollfd *pfds;			if ((err = snd_pcm_open (&playback_handle, argv[1], SND_PCM_STREAM_PLAYBACK, 0)) < 0) {			fprintf (stderr, "cannot open audio device %s (%s)/n", 				 argv[1],				 snd_strerror (err));			exit (1);		}		   		if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {			fprintf (stderr, "cannot allocate hardware parameter structure (%s)/n",				 snd_strerror (err));			exit (1);		}				 		if ((err = snd_pcm_hw_params_any (playback_handle, hw_params)) < 0) {			fprintf (stderr, "cannot initialize hardware parameter structure (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_hw_params_set_access (playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {			fprintf (stderr, "cannot set access type (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_hw_params_set_format (playback_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {			fprintf (stderr, "cannot set sample format (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_hw_params_set_rate_near (playback_handle, hw_params, 44100, 0)) < 0) {			fprintf (stderr, "cannot set sample rate (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_hw_params_set_channels (playback_handle, hw_params, 2)) < 0) {			fprintf (stderr, "cannot set channel count (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_hw_params (playback_handle, hw_params)) < 0) {			fprintf (stderr, "cannot set parameters (%s)/n",				 snd_strerror (err));			exit (1);		}			snd_pcm_hw_params_free (hw_params);			if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {			fprintf (stderr, "cannot allocate software parameters structure (%s)/n",				 snd_strerror (err));			exit (1);		}		if ((err = snd_pcm_sw_params_current (playback_handle, sw_params)) < 0) {			fprintf (stderr, "cannot initialize software parameters structure (%s)/n",				 snd_strerror (err));			exit (1);		}		if ((err = snd_pcm_sw_params_set_avail_min (playback_handle, sw_params, 4096)) < 0) {			fprintf (stderr, "cannot set minimum available count (%s)/n",				 snd_strerror (err));			exit (1);		}		if ((err = snd_pcm_sw_params_set_start_threshold (playback_handle, sw_params, 0U)) < 0) {			fprintf (stderr, "cannot set start mode (%s)/n",				 snd_strerror (err));			exit (1);		}		if ((err = snd_pcm_sw_params (playback_handle, sw_params)) < 0) {			fprintf (stderr, "cannot set software parameters (%s)/n",				 snd_strerror (err));			exit (1);		}			if ((err = snd_pcm_prepare (playback_handle)) < 0) {			fprintf (stderr, "cannot prepare audio interface for use (%s)/n",				 snd_strerror (err));			exit (1);		}			while (1) {				if ((err = snd_pcm_wait (playback_handle, 1000)) < 0) {			        fprintf (stderr, "poll failed (%s)/n", strerror (errno));			        break;			}	           	//.........这里部分代码省略.........

//.........这里部分代码省略.........        }      bytes_per_sample = af_fmt2bits(ao_data.format) / 8;      bytes_per_sample *= ao_data.channels;      ao_data.bps = ao_data.samplerate * bytes_per_sample;	if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams,							  &alsa_buffer_time, NULL)) < 0)	  {	    mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetBufferTimeNear,		   snd_strerror(err));	    return 0;	  }	if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams,						      &alsa_fragcount, NULL)) < 0) {	  mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriods,		 snd_strerror(err));	  return 0;	}      /* finally install hardware parameters */      if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0)	{	  mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetHwParameters,		 snd_strerror(err));	  return 0;	}      // end setting hw-params      // gets buffersize for control      if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0)	{	  mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBufferSize, snd_strerror(err));	  return 0;	}      else {	ao_data.buffersize = bufsize * bytes_per_sample;	  mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i/n", ao_data.buffersize);      }      if ((err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &chunk_size, NULL)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetPeriodSize, snd_strerror(err));	return 0;      } else {	mp_msg(MSGT_AO,MSGL_V,"alsa-init: got period size %li/n", chunk_size);      }      ao_data.outburst = chunk_size * bytes_per_sample;      /* setting software parameters */      if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,	       snd_strerror(err));	return 0;      }#if SND_LIB_VERSION >= 0x000901      if ((err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBoundary,	       snd_strerror(err));	return 0;      }#else      boundary = 0x7fffffff;#endif      /* start playing when one period has been written */      if ((err = snd_pcm_sw_params_set_start_threshold(alsa_handler, alsa_swparams, chunk_size)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStartThreshold,	       snd_strerror(err));	return 0;      }      /* disable underrun reporting */      if ((err = snd_pcm_sw_params_set_stop_threshold(alsa_handler, alsa_swparams, boundary)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStopThreshold,	       snd_strerror(err));	return 0;      }#if SND_LIB_VERSION >= 0x000901      /* play silence when there is an underrun */      if ((err = snd_pcm_sw_params_set_silence_size(alsa_handler, alsa_swparams, boundary)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSilenceSize,	       snd_strerror(err));	return 0;      }#endif      if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) {	mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,	       snd_strerror(err));	return 0;      }      /* end setting sw-params */      mp_msg(MSGT_AO,MSGL_V,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s/n",	     ao_data.samplerate, ao_data.channels, (int)bytes_per_sample, ao_data.buffersize,	     snd_pcm_format_description(alsa_format));    } // end switch alsa_handler (spdif)    alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams);    return 1;} // end init

status_t setSoftwareParams(alsa_handle_t *handle){    snd_pcm_sw_params_t * softwareParams;    int err;    snd_pcm_uframes_t bufferSize = 0;    snd_pcm_uframes_t periodSize = 0;    snd_pcm_uframes_t startThreshold, stopThreshold;    if (snd_pcm_sw_params_malloc(&softwareParams) < 0) {        LOG_ALWAYS_FATAL("Failed to allocate ALSA software parameters!");        return NO_INIT;    }    // Get the current software parameters    err = snd_pcm_sw_params_current(handle->handle, softwareParams);    if (err < 0) {        LOGE("Unable to get software parameters: %s", snd_strerror(err));        goto done;    }    // Configure ALSA to start the transfer when the buffer is almost full.    snd_pcm_get_params(handle->handle, &bufferSize, &periodSize);    if (handle->devices & AudioSystem::DEVICE_OUT_ALL) {        // For playback, configure ALSA to start the transfer when the        // buffer is full.        startThreshold = bufferSize - 1;        stopThreshold = bufferSize;    } else {        // For recording, configure ALSA to start the transfer on the        // first frame.        startThreshold = 1;        stopThreshold = bufferSize;    }    err = snd_pcm_sw_params_set_start_threshold(handle->handle, softwareParams,            startThreshold);    if (err < 0) {        LOGE("Unable to set start threshold to %lu frames: %s",                startThreshold, snd_strerror(err));        goto done;    }    err = snd_pcm_sw_params_set_stop_threshold(handle->handle, softwareParams,            stopThreshold);    if (err < 0) {        LOGE("Unable to set stop threshold to %lu frames: %s",                stopThreshold, snd_strerror(err));        goto done;    }    // Allow the transfer to start when at least periodSize samples can be    // processed.    err = snd_pcm_sw_params_set_avail_min(handle->handle, softwareParams,            periodSize);    if (err < 0) {        LOGE("Unable to configure available minimum to %lu: %s",                periodSize, snd_strerror(err));        goto done;    }    // Commit the software parameters back to the device.    err = snd_pcm_sw_params(handle->handle, softwareParams);    if (err < 0) LOGE("Unable to configure software parameters: %s",            snd_strerror(err));    done:    snd_pcm_sw_params_free(softwareParams);    return err;}

//.........这里部分代码省略.........        if ( err < 0 ) {            fatal = true;            errMessage = QString::fromLatin1("QAudioOutput: buffer/period min and max: err = %1").arg(err);        } else {            if (maxBufferTime < buffer_time || buffer_time < minBufferTime || maxPeriodTime < period_time || minPeriodTime > period_time) {#ifdef DEBUG_AUDIO                qDebug()<<"defaults out of range";                qDebug()<<"pmin="<<minPeriodTime<<", pmax="<<maxPeriodTime<<", bmin="<<minBufferTime<<", bmax="<<maxBufferTime;#endif                period_time = minPeriodTime;                if (period_time*4 <= maxBufferTime) {                    // Use 4 periods if possible                    buffer_time = period_time*4;                    chunks = 4;                } else if (period_time*2 <= maxBufferTime) {                    // Use 2 periods if possible                    buffer_time = period_time*2;                    chunks = 2;                } else {                    qWarning()<<"QAudioOutput: alsa only supports single period!";                    fatal = true;                }#ifdef DEBUG_AUDIO                qDebug()<<"used: buffer_time="<<buffer_time<<", period_time="<<period_time;#endif            }        }    }    if ( !fatal ) {        err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, &dir);        if ( err < 0 ) {            fatal = true;            errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_buffer_time_near: err = %1").arg(err);        }    }    if ( !fatal ) {        err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, &dir);        if ( err < 0 ) {            fatal = true;            errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_period_time_near: err = %1").arg(err);        }    }    if ( !fatal ) {        err = snd_pcm_hw_params_set_periods_near(handle, hwparams, &chunks, &dir);        if ( err < 0 ) {            fatal = true;            errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_periods_near: err = %1").arg(err);        }    }    if ( !fatal ) {        err = snd_pcm_hw_params(handle, hwparams);        if ( err < 0 ) {            fatal = true;            errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params: err = %1").arg(err);        }    }    if( err < 0) {        qWarning()<<errMessage;        errorState = QAudio::OpenError;        deviceState = QAudio::StoppedState;        return false;    }    snd_pcm_hw_params_get_buffer_size(hwparams,&buffer_frames);    buffer_size = snd_pcm_frames_to_bytes(handle,buffer_frames);    snd_pcm_hw_params_get_period_size(hwparams,&period_frames, &dir);    period_size = snd_pcm_frames_to_bytes(handle,period_frames);    snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);    snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);    // Step 3: Set the desired SW parameters.    snd_pcm_sw_params_t *swparams;    snd_pcm_sw_params_alloca(&swparams);    snd_pcm_sw_params_current(handle, swparams);    snd_pcm_sw_params_set_start_threshold(handle,swparams,period_frames);    snd_pcm_sw_params_set_stop_threshold(handle,swparams,buffer_frames);    snd_pcm_sw_params_set_avail_min(handle, swparams,period_frames);    snd_pcm_sw_params(handle, swparams);    // Step 4: Prepare audio    if(audioBuffer == 0)        audioBuffer = new char[snd_pcm_frames_to_bytes(handle,buffer_frames)];    snd_pcm_prepare( handle );    snd_pcm_start(handle);    // Step 5: Setup callback and timer fallback    snd_async_add_pcm_handler(&ahandler, handle, async_callback, this);    bytesAvailable = bytesFree();    // Step 6: Start audio processing    timer->start(period_time/1000);    clockStamp.restart();    timeStamp.restart();    elapsedTimeOffset = 0;    errorState  = QAudio::NoError;    totalTimeValue = 0;    opened = true;    return true;}