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

int visual_hashlist_put (VisHashlist *hashlist, char *key, void *data){	VisHashlistEntry *hentry;	VisListEntry *le;	visual_return_val_if_fail (hashlist != NULL, -VISUAL_ERROR_HASHLIST_NULL);	visual_return_val_if_fail (key != NULL, -VISUAL_ERROR_NULL);	visual_return_val_if_fail (data != NULL, -VISUAL_ERROR_NULL);	le = visual_hashmap_get_string (hashlist->index, key);	if (le != NULL) {		hentry = le->data;		hentry->data = data;	} else {		hentry = visual_mem_new0 (VisHashlistEntry, 1);		hentry->key = key;		hentry->data = data;		visual_list_add (hashlist->list, hentry);		le = hashlist->list->tail;		visual_hashmap_put_string (hashlist->index, key, le);	}	return VISUAL_OK;}

static int act_infinite_render (VisPluginData *plugin, VisVideo *video, VisAudio *audio){	VisBuffer *buffer;	InfinitePrivate *priv;	visual_return_val_if_fail (plugin != NULL, -1);	visual_return_val_if_fail (video != NULL, -1);	visual_return_val_if_fail (audio != NULL, -1);	priv = visual_object_get_private (VISUAL_OBJECT (plugin));	buffer = visual_buffer_new ();	visual_buffer_set_data_pair (buffer, priv->pcm_data[0], sizeof (float) * 512);	visual_audio_get_sample (audio, buffer, VISUAL_AUDIO_CHANNEL_LEFT);	visual_buffer_set_data_pair (buffer, priv->pcm_data[1], sizeof (float) * 512);	visual_audio_get_sample (audio, buffer, VISUAL_AUDIO_CHANNEL_LEFT);	_inf_renderer (priv);	_inf_display (priv, (uint8_t *) visual_video_get_pixels (video), video->pitch);	visual_buffer_free (buffer);	return 0;}

int visual_transform_realize (VisTransform *transform){    visual_return_val_if_fail (transform != NULL, -VISUAL_ERROR_TRANSFORM_NULL);    visual_return_val_if_fail (transform->plugin != NULL, -VISUAL_ERROR_PLUGIN_NULL);    return visual_plugin_realize (transform->plugin);}

int visual_video_allocate_buffer (VisVideo *video){	visual_return_val_if_fail (video != NULL, -VISUAL_ERROR_VIDEO_NULL);	visual_return_val_if_fail (video->buffer != NULL, -VISUAL_ERROR_VIDEO_BUFFER_NULL);	if (visual_video_get_pixels (video) != NULL) {		if (visual_buffer_get_allocated (video->buffer)) {			visual_video_free_buffer (video);		} else {			visual_log (VISUAL_LOG_ERROR, _("Trying to allocate an screen buffer on "					"a VisVideo structure which points to an external screen buffer"));			return -VISUAL_ERROR_VIDEO_HAS_PIXELS;		}	}	if (visual_video_get_size (video) == 0) {		visual_buffer_set_data (video->buffer, NULL);		return VISUAL_OK;	}	visual_buffer_set_destroyer (video->buffer, visual_buffer_destroyer_free);	visual_buffer_set_size (video->buffer, visual_video_get_size (video));	visual_buffer_allocate_data (video->buffer);	video->pixel_rows = visual_mem_new0 (void *, video->height);	precompute_row_table (video);	return VISUAL_OK;}

// FIXME: This function is entirely broken from the looks of it.int visual_audio_get_sample_mixed_category (VisAudio *audio, VisBuffer *buffer, const char *category, int divide){	VisListEntry *le = NULL;	VisAudioSamplePool *samplepool;	VisAudioSamplePoolChannel *channel;	VisBuffer temp;	int first = TRUE;	visual_return_val_if_fail (audio != NULL, -VISUAL_ERROR_AUDIO_NULL);	visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_AUDIO_SAMPLEPOOL_NULL);	visual_return_val_if_fail (category != NULL, -VISUAL_ERROR_NULL);	visual_buffer_init_allocate (&temp, visual_buffer_get_size (buffer), visual_buffer_destroyer_free);	samplepool = visual_audio_samplepool_new (); // this function's broken. This line was added to get rid of a compile warning. Not sure what samplepool's supposed to be, because it appears the below code expects an already existing VisAudioSamplePool. Dunno.	while ((channel = visual_list_next (samplepool->channels, &le)) != NULL) {		if (strstr (channel->channelid, category) != NULL) {			if (visual_audio_get_sample (audio, &temp, channel->channelid) == VISUAL_OK) {				if (first == TRUE) {					visual_audio_sample_buffer_mix (buffer, &temp, FALSE, 1.0);					first = FALSE;				} else {					visual_audio_sample_buffer_mix (buffer, &temp, divide, 1.0);				}			}		}	}	visual_object_unref (VISUAL_OBJECT (&temp));	return VISUAL_OK;}

  int visual_color_compare (VisColor* src1, VisColor* src2)  {      visual_return_val_if_fail (src1 != nullptr, FALSE);      visual_return_val_if_fail (src2 != nullptr, FALSE);      return ( *src1 == *src2 );  }

  int visual_color_compare (VisColor* src1, VisColor* src2)  {      visual_return_val_if_fail (src1 != NULL, -VISUAL_ERROR_COLOR_NULL);      visual_return_val_if_fail (src2 != NULL, -VISUAL_ERROR_COLOR_NULL);      return ( *src1 == *src2 );  }

int visual_morph_run (VisMorph *morph, VisAudio *audio, VisVideo *src1, VisVideo *src2){    VisMorphPlugin *morphplugin;    visual_return_val_if_fail (morph != NULL, -VISUAL_ERROR_MORPH_NULL);    visual_return_val_if_fail (audio != NULL, -VISUAL_ERROR_AUDIO_NULL);    visual_return_val_if_fail (src1 != NULL, -VISUAL_ERROR_VIDEO_NULL);    visual_return_val_if_fail (src2 != NULL, -VISUAL_ERROR_VIDEO_NULL);    morphplugin = get_morph_plugin (morph);    if (morphplugin == NULL) {        visual_log (VISUAL_LOG_ERROR,            _("The given morph does not reference any plugin"));        return -VISUAL_ERROR_MORPH_PLUGIN_NULL;    }    /* If we're morphing using the timer, start the timer. */    if (!visual_timer_is_active (morph->timer))        visual_timer_start (morph->timer);    if (morphplugin->palette != NULL)        morphplugin->palette (morph->plugin, morph->rate, audio, morph->morphpal, src1, src2);    else {        if (src1->pal != NULL && src2->pal != NULL)            visual_palette_blend (morph->morphpal, src1->pal, src2->pal, morph->rate);    }    morphplugin->apply (morph->plugin, morph->rate, audio, morph->dest, src1, src2);    visual_video_set_palette (morph->dest, visual_morph_get_palette (morph));    /* On automatic morphing increase the rate. */    if (morph->mode == VISUAL_MORPH_MODE_STEPS) {        morph->rate += (1.000 / morph->steps);        morph->stepsdone++;        if (morph->rate > 1.0)            morph->rate = 1;    } else if (morph->mode == VISUAL_MORPH_MODE_TIME) {        /**         * @todo: We might want to have a bigger type here, but long longs aren't atomic         * on most architectures, so that won't do for now, maybe when we can lock (for threading)         * we can look into that         */        double usec_elapsed = visual_timer_elapsed_usecs (morph->timer);        double usec_morph = visual_time_to_usecs (morph->morphtime);        morph->rate = usec_elapsed / usec_morph;        if (morph->rate > 1.0)            morph->rate = 1;    }    return VISUAL_OK;}

int visual_ringbuffer_add_entry (VisRingBuffer *ringbuffer, VisRingBufferEntry *entry){    visual_return_val_if_fail (ringbuffer != NULL, -VISUAL_ERROR_RINGBUFFER_NULL);    visual_return_val_if_fail (entry != NULL, -VISUAL_ERROR_RINGBUFFER_ENTRY_NULL);    visual_list_add (ringbuffer->entries, entry);    return VISUAL_OK;}

int visual_audio_samplepool_add_channel (VisAudioSamplePool *samplepool, VisAudioSamplePoolChannel *channel){	visual_return_val_if_fail (samplepool != NULL, -VISUAL_ERROR_AUDIO_SAMPLEPOOL_NULL);	visual_return_val_if_fail (channel != NULL, -VISUAL_ERROR_AUDIO_SAMPLEPOOL_CHANNEL_NULL);	visual_list_add (samplepool->channels, channel);	return VISUAL_OK;}

int visual_morph_set_video (VisMorph *morph, VisVideo *video){    visual_return_val_if_fail (morph != NULL, -VISUAL_ERROR_MORPH_NULL);    visual_return_val_if_fail (video != NULL, -VISUAL_ERROR_VIDEO_NULL);    morph->dest = video;    return VISUAL_OK;}

int visual_morph_set_time (VisMorph *morph, VisTime *time){    visual_return_val_if_fail (morph != NULL, -VISUAL_ERROR_MORPH_NULL);    visual_return_val_if_fail (time != NULL, -VISUAL_ERROR_TIME_NULL);    visual_time_copy (morph->morphtime, time);    return VISUAL_OK;}

int visual_morph_run (VisMorph *self, VisAudio *audio, VisVideo *src1, VisVideo *src2){    visual_return_val_if_fail (self  != nullptr, FALSE);    visual_return_val_if_fail (audio != nullptr, FALSE);    visual_return_val_if_fail (src1  != nullptr, FALSE);    visual_return_val_if_fail (src2  != nullptr, FALSE);    return self->run (*audio, src1, src2);}

  int visual_color_copy (VisColor* dest, VisColor* src)  {      visual_return_val_if_fail (dest != NULL, -VISUAL_ERROR_COLOR_NULL);      visual_return_val_if_fail (src  != NULL, -VISUAL_ERROR_COLOR_NULL);      *dest = *src;      return VISUAL_OK;  }

int visual_video_copy_attrs (VisVideo *dest, VisVideo *src){	visual_return_val_if_fail (dest != NULL, -VISUAL_ERROR_VIDEO_NULL);	visual_return_val_if_fail (src != NULL, -VISUAL_ERROR_VIDEO_NULL);	visual_video_set_depth (dest, src->depth);	visual_video_set_dimension (dest, src->width, src->height);	visual_video_set_pitch (dest, src->pitch);	return VISUAL_OK;}

static VisTransformPlugin *get_transform_plugin (VisTransform *transform){    VisTransformPlugin *transplugin;    visual_return_val_if_fail (transform != NULL, NULL);    visual_return_val_if_fail (transform->plugin != NULL, NULL);    transplugin = VISUAL_TRANSFORM_PLUGIN (transform->plugin->info->plugin);    return transplugin;}

int visual_ringbuffer_add_buffer_by_data (VisRingBuffer *ringbuffer, void *data, int nbytes){    VisBuffer *buffer;    visual_return_val_if_fail (ringbuffer != NULL, -VISUAL_ERROR_RINGBUFFER_NULL);    visual_return_val_if_fail (data != NULL, -VISUAL_ERROR_NULL);    buffer = visual_buffer_new_wrap_data (data, nbytes);    return visual_ringbuffer_add_buffer (ringbuffer, buffer);}

static VisMorphPlugin *get_morph_plugin (VisMorph *morph){    VisMorphPlugin *morphplugin;    visual_return_val_if_fail (morph != NULL, NULL);    visual_return_val_if_fail (morph->plugin != NULL, NULL);    morphplugin = VISUAL_MORPH_PLUGIN (morph->plugin->info->plugin);    return morphplugin;}

int visual_audio_samplepool_channel_add (VisAudioSamplePoolChannel *channel, VisAudioSample *sample){	visual_return_val_if_fail (channel != NULL, -VISUAL_ERROR_AUDIO_SAMPLEPOOL_CHANNEL_NULL);	visual_return_val_if_fail (sample != NULL, -VISUAL_ERROR_AUDIO_SAMPLE_NULL);	visual_ringbuffer_add_function (channel->samples,			sample_data_func,			sample_destroy_func,			sample_size_func, sample);	return VISUAL_OK;}

static int lv_nebulus_render (VisPluginData *plugin, VisVideo *video, VisAudio *audio){	NebulusPrivate *priv = visual_object_get_private (VISUAL_OBJECT (plugin));	visual_return_val_if_fail (plugin != NULL, -1);	visual_return_val_if_fail (video != NULL, -1);	visual_return_val_if_fail (audio != NULL, -1);	nebulus_sound (priv, audio);	nebulus_draw (priv, video);	return 0;}

int visual_audio_samplepool_input (VisAudioSamplePool *samplepool, VisBuffer *buffer,		VisAudioSampleRateType rate,		VisAudioSampleFormatType format,		VisAudioSampleChannelType channeltype){	visual_return_val_if_fail (samplepool != NULL, -VISUAL_ERROR_AUDIO_SAMPLEPOOL_NULL);	visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);	if (channeltype == VISUAL_AUDIO_SAMPLE_CHANNEL_STEREO)		input_interleaved_stereo (samplepool, buffer, format, rate);	return VISUAL_OK;}

int inp_alsa_upload (VisPluginData *plugin, VisAudio *audio){	int16_t data[PCM_BUF_SIZE];	alsaPrivate *priv = NULL;	int rcnt;	visual_return_val_if_fail(audio != NULL, -1);	visual_return_val_if_fail(plugin != NULL, -1);	priv = visual_object_get_private (VISUAL_OBJECT (plugin));	visual_return_val_if_fail(priv != NULL, -1);#if 0	{	/* DEBUG STUFF, REMOVE IN RELEASE FIXME FIXME XXX TODO WHATEVER */		VisBuffer buffer;		visual_buffer_init (&buffer, data, 512, NULL);		for (i = 0; i < 16; i++) {			visual_audio_samplepool_input (audio->samplepool, &buffer, VISUAL_AUDIO_SAMPLE_RATE_44100,					VISUAL_AUDIO_SAMPLE_FORMAT_S16, VISUAL_AUDIO_SAMPLE_CHANNEL_STEREO);		}		return 0;	}#endif	do {		rcnt = snd_pcm_readi(priv->chandle, data, PCM_BUF_SIZE / 2);		if (rcnt > 0) {			VisBuffer buffer;			visual_buffer_init (&buffer, data, rcnt, NULL);			visual_audio_samplepool_input (audio->samplepool, &buffer, VISUAL_AUDIO_SAMPLE_RATE_44100,					VISUAL_AUDIO_SAMPLE_FORMAT_S16, VISUAL_AUDIO_SAMPLE_CHANNEL_STEREO);		}		if (rcnt < 0) {			if (rcnt == -EPIPE) {				visual_log(VISUAL_LOG_WARNING, _("ALSA: Buffer Overrun"));				if (snd_pcm_prepare(priv->chandle) < 0) {					visual_log(VISUAL_LOG_ERROR,							_("Failed to prepare interface"));					return(-1);				}			}		}	} while (rcnt > 0);	return 0;}

int visual_video_compare_attrs (VisVideo *src1, VisVideo *src2){	visual_return_val_if_fail (src1 != NULL, -VISUAL_ERROR_VIDEO_NULL);	visual_return_val_if_fail (src2 != NULL, -VISUAL_ERROR_VIDEO_NULL);	if (!visual_video_compare_attrs_ignore_pitch (src1, src2))		return FALSE;	if (src1->pitch != src2->pitch)		return FALSE;	/* We made it to the end, the VisVideos are likewise in depth, pitch, dimensions */	return TRUE;}

int visual_transform_get_supported_depth (VisTransform *transform){    VisTransformPlugin *transplugin;    visual_return_val_if_fail (transform != NULL, -VISUAL_ERROR_TRANSFORM_NULL);    visual_return_val_if_fail (transform->plugin != NULL, -VISUAL_ERROR_PLUGIN_NULL);    transplugin = get_transform_plugin (transform);    if (transplugin == NULL)        return -VISUAL_ERROR_TRANSFORM_PLUGIN_NULL;    return transplugin->vidoptions.depth;}

int visual_morph_get_supported_depth (VisMorph *morph){    VisMorphPlugin *morphplugin;    visual_return_val_if_fail (morph != NULL, -VISUAL_ERROR_MORPH_NULL);    visual_return_val_if_fail (morph->plugin != NULL, -VISUAL_ERROR_PLUGIN_NULL);    morphplugin = get_morph_plugin (morph);    if (morphplugin == NULL)        return -VISUAL_ERROR_MORPH_PLUGIN_NULL;    return morphplugin->vidoptions.depth;}

int visual_hashlist_remove (VisHashlist *hashlist, char *key){	VisListEntry *le;	visual_return_val_if_fail (hashlist != NULL, -VISUAL_ERROR_HASHLIST_NULL);	visual_return_val_if_fail (key != NULL, -VISUAL_ERROR_NULL);	le = visual_hashmap_get_string (hashlist->index, key);	if (le != NULL)		visual_hashlist_remove_list_entry (hashlist, le);	return VISUAL_OK;}

int visual_audio_get_sample_mixed (VisAudio *audio, VisBuffer *buffer, int divide, int channels, ...){	VisBuffer temp;	char **chanids;	double *chanmuls;	va_list ap;	int i;	int first = TRUE;	visual_return_val_if_fail (audio != NULL, -VISUAL_ERROR_AUDIO_NULL);	visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);	visual_buffer_init_allocate (&temp, visual_buffer_get_size (buffer), visual_buffer_destroyer_free);	chanids = visual_mem_malloc (channels * sizeof (char *));	chanmuls = visual_mem_malloc (channels * sizeof (double));	va_start (ap, channels);	/* Retrieving mixing data from valist */	for (i = 0; i < channels; i++)		chanids[i] = va_arg (ap, char *);	for (i = 0; i < channels; i++)		chanmuls[i] = va_arg (ap, double);	visual_buffer_fill (buffer, 0);	/* The mixing loop */	for (i = 0; i < channels; i++) {		if (visual_audio_get_sample (audio, &temp, chanids[i]) == VISUAL_OK) {			if (first == TRUE) {				visual_audio_sample_buffer_mix (buffer, &temp, FALSE, chanmuls[i]);				first = FALSE;			} else {				visual_audio_sample_buffer_mix (buffer, &temp, divide, chanmuls[i]);			}		}	}	va_end (ap);	visual_object_unref (VISUAL_OBJECT (&temp));	visual_mem_free (chanids);	visual_mem_free (chanmuls);	return VISUAL_OK;}

VisAudioSamplePoolChannel *visual_audio_samplepool_get_channel (VisAudioSamplePool *samplepool, const char *channelid){	VisListEntry *le = NULL;	VisAudioSamplePoolChannel *channel;	visual_return_val_if_fail (samplepool != NULL, NULL);	visual_return_val_if_fail (channelid != NULL, NULL);	while ((channel = visual_list_next (samplepool->channels, &le)) != NULL) {		if (strcmp (channel->channelid, channelid) == 0)			return channel;	}	return NULL;}