Esempio n. 1
0
void* server_thread (void* t)
{
/* shared memory segment id           */
int MyKey;
int reqMemSegID;             
int resMemSegID;
/* shared memory flags                */
int shmFlags;               
    
/*pointer to the queue			*/
struct queue *request_ring;
struct queue *response_ring;


/*Keys to request & response structures*/
int REQ_KEY,RES_KEY;     

/*Get the Thread ID */
int tid =  (int)(int*)t;
MyKey   =  (int)message_box->client[tid];  
printf("Servicing Client with Process ID %d, Thread ID %d\n",(int)MyKey,tid);

/*Get the keys for both rings*/
REQ_KEY = ftok(".", (int) MyKey * 0xAA );    
RES_KEY = ftok(".", (int) MyKey * 0x33 );

/*Should not happen*/
assert(REQ_KEY != RES_KEY);

#if 1
/*---------------------------------------*/
/* Create shared memory segment          */
/* Give everyone read/write permissions. */
/*---------------------------------------*/

shmFlags = IPC_CREAT | SHM_PERM;
/*Request ring creation*/
 if ( (reqMemSegID = 
  shmget(REQ_KEY, SHM_SIZE, shmFlags)) < 0 )
   {
       perror("SERVER: shmget");
       exit(EXIT_FAILURE);
   }
printf("Created shared location for request ring buffer\n");
/*Response ring creation*/
if ( (resMemSegID = 
  shmget(RES_KEY, SHM_SIZE, shmFlags)) < 0 )
   {
       perror("SERVER: shmget");
       exit(EXIT_FAILURE);
   }
printf("Created shared location for response ring buffer\n");

/*-------------------------------------------*/
/* Attach the segment to the process's data  */
/* space at an address                       */
/* selected by the system.                   */
/*-------------------------------------------*/
/*Changed by Pradeep*/
shmFlags = 0;
/*Get Request Ring*/
if ( (request_ring = 
      shmat(reqMemSegID, NULL, shmFlags)) == 
  (void *) -1 )
   {
       perror("SERVER: shmat");
       exit(EXIT_FAILURE);
   }
printf("Request Ring buffer attached to process\n");
/*Get Response Ring*/
if ( (response_ring = 
      shmat(resMemSegID, NULL, shmFlags)) == 
  (void *) -1 )
   {
       perror("SERVER: shmat");
       exit(EXIT_FAILURE);
   }
printf("Response Ring buffer attached to process\n");


while(1){
	if(is_empty(request_ring))
	{
		//pthread_cond_wait(&cond_thread, &mutex_thread);
		sleep(1);
	}
	else if(!is_empty(request_ring))
	{	
		printf("Got a request, Dequeuing it \n");	
		Task temp = dequeue(request_ring);
		compute_mod(&temp);
		printf("Computed Mod\n");
		
	        enqueue(response_ring,temp);
	}
}
/*------------------------------------------------*/
/* Call shmdt() to detach shared memory segment.  */
/*------------------------------------------------*/
   if ( shmdt(request_ring) < 0 )
   {
       perror("SERVER: shmdt");
       exit(EXIT_FAILURE);
   }

  if ( shmdt(response_ring) < 0 )
   {
       perror("SERVER: shmdt");
       exit(EXIT_FAILURE);
   }

    

/*--------------------------------------------------*/
/* Call shmctl to remove shared memory segment.     */
/*--------------------------------------------------*/
   if (shmctl(reqMemSegID, IPC_RMID, NULL) < 0)
   {
       perror("SERVER: shmctl");
       exit(EXIT_FAILURE);
   }

  if (shmctl(resMemSegID, IPC_RMID, NULL) < 0)
   {
       perror("SERVER: shmctl");
       exit(EXIT_FAILURE);
   }
 

   exit(EXIT_SUCCESS);
#endif
}  /* end of main() */
void CLS_DlgStreamPusher::audio_display(struct_stream_info *_pstrct_streaminfo)
{
	if (audio_callback_time == 0){
		TRACE("audio_callback_time == 0");
		return;
	}
	int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
	int ch, channels, h, h2, bgcolor, fgcolor;
	int16_t time_diff;
	int rdft_bits, nb_freq;

	for (rdft_bits = 1; (1 << rdft_bits) < 2 * _pstrct_streaminfo->m_height; rdft_bits++)
		;
	nb_freq = 1 << (rdft_bits - 1);

	/* compute display index : center on currently output samples */
	channels = _pstrct_streaminfo->m_audio_tgt.channels;
	nb_display_channels = channels;
	if (!_pstrct_streaminfo->m_paused) {
		int data_used = _pstrct_streaminfo->m_show_mode == SHOW_MODE_WAVES ? _pstrct_streaminfo->m_width : (2 * nb_freq);
		n = 2 * channels;
		delay = _pstrct_streaminfo->m_audio_write_buf_size;
		delay /= n;

		/* to be more precise, we take into account the time spent since
		the last buffer computation */
		if (audio_callback_time) {
			time_diff = av_gettime() - audio_callback_time;
			delay -= (time_diff * _pstrct_streaminfo->m_audio_tgt.freq) / 1000000;
		}

		delay += 2 * data_used;
		if (delay < data_used)
			delay = data_used;

		i_start = x = compute_mod(_pstrct_streaminfo->m_sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
		if (_pstrct_streaminfo->m_show_mode == SHOW_MODE_WAVES) {
			h = INT_MIN;
			for (i = 0; i < 1000; i += channels) {
				int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
				int a = _pstrct_streaminfo->m_sample_array[idx];
				int b = _pstrct_streaminfo->m_sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
				int c = _pstrct_streaminfo->m_sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
				int d = _pstrct_streaminfo->m_sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
				int score = a - d;
				if (h < score && (b ^ c) < 0) {
					h = score;
					i_start = idx;
				}
			}
		}

		_pstrct_streaminfo->m_audio_last_i_start = i_start;
	}


	//背景色
	bgcolor = SDL_MapRGB(_pstrct_streaminfo->m_screen_surface->format, 0x00, 0x00, 0x00);
	if (_pstrct_streaminfo->m_show_mode == SHOW_MODE_WAVES) {
		SDL_Rect sdl_rect;
		_pstrct_streaminfo->m_xleft = 0;
		_pstrct_streaminfo->m_ytop = 0;
		sdl_rect.x = _pstrct_streaminfo->m_xleft;
		sdl_rect.y = _pstrct_streaminfo->m_ytop;
		sdl_rect.w = _pstrct_streaminfo->m_width;
		sdl_rect.h = _pstrct_streaminfo->m_height;

		fill_rec(_pstrct_streaminfo->m_screen_surface, _pstrct_streaminfo->m_xleft, _pstrct_streaminfo->m_ytop, _pstrct_streaminfo->m_width, _pstrct_streaminfo->m_height,bgcolor);

		fgcolor = SDL_MapRGB(_pstrct_streaminfo->m_screen_surface->format, 0xff, 0xff, 0xff);

		/* total height for one channel */
		h = _pstrct_streaminfo->m_height / nb_display_channels;
		/* graph height / 2 */
		h2 = (h * 9) / 20;
		for (ch = 0; ch < nb_display_channels; ch++) {
			i = i_start + ch;
			y1 = _pstrct_streaminfo->m_ytop + ch * h + (h / 2); /* position of center line */
			for (x = 0; x < _pstrct_streaminfo->m_width; x++) {
				y = (_pstrct_streaminfo->m_sample_array[i] * h2) >> 15;
				if (y < 0) {
					y = -y;
					ys = y1 - y;
				}
				else {
					ys = y1;
				}

				fill_rec(_pstrct_streaminfo->m_screen_surface, _pstrct_streaminfo->m_xleft + x, ys, 1, y, fgcolor);

				i += channels;
				if (i >= SAMPLE_ARRAY_SIZE)
					i -= SAMPLE_ARRAY_SIZE;
			}
		}

		fgcolor = SDL_MapRGB(_pstrct_streaminfo->m_screen_surface->format, 0x00, 0x00, 0xff);

		for (ch = 1; ch < nb_display_channels; ch++) {
			y = _pstrct_streaminfo->m_ytop + ch * h;

			fill_rec(_pstrct_streaminfo->m_screen_surface, _pstrct_streaminfo->m_xleft, y, _pstrct_streaminfo->m_width, 1, fgcolor);
		}
		if (SDL_UpdateWindowSurface(_pstrct_streaminfo->m_show_screen) != 0){
			TRACE("SDL_UpdateWindowSurface ERR");
		}
		//SDL_CreateRGBSurface();
		SDL_UpdateTexture(_pstrct_streaminfo->m_sdlTexture, NULL, _pstrct_streaminfo->m_screen_surface->pixels, _pstrct_streaminfo->m_screen_surface->pitch);
		SDL_RenderClear(_pstrct_streaminfo->m_sdlRenderer);
		SDL_RenderCopy(_pstrct_streaminfo->m_sdlRenderer, _pstrct_streaminfo->m_sdlTexture, &sdl_rect, &sdl_rect);
		SDL_RenderPresent(_pstrct_streaminfo->m_sdlRenderer);
	}
Esempio n. 3
0
static xmlrpc_value *
calculate_modexp(xmlrpc_env *   const env,
           xmlrpc_value * const param_array,
           void *         const serverInfo,
           void *         const channelInfo) {

   int i = 0;
   Task temp;
   xmlrpc_value * retval;

   xmlrpc_value * arrayP;	
	
   xmlrpc_decompose_value(env, param_array, "(A)", &arrayP);

   size_t size = xmlrpc_array_size(env, arrayP);

	if (env->fault_occurred)
		retval = NULL;
	else 
	{

		for (i = 0; i < size && !env->fault_occurred; ++i) 
		{
			xmlrpc_value * strctP;
			strctP = xmlrpc_array_get_item(env, arrayP, i);
			if (!env->fault_occurred) 
			{
				if(i == 0)
				{
					const char * str1;
					size_t str1_len;
					xmlrpc_read_string_lp(env, strctP, &str1_len, &str1);				
	
					//xmlrpc_int32 curly;
					//xmlrpc_decompose_value(env, strctP, "(s)",&ip[0]);
					strcpy(temp._clientid, str1);
				}
				else
				{
					const char * str1;
					size_t str1_len;
					xmlrpc_read_string_lp(env, strctP, &str1_len, &str1);				
				
					if(i == 1)
					strcpy(temp.p,str1);
				
					else if(i == 2)
					strcpy(temp.m,str1);

				}
			}
		}
	}

    xmlrpc_DECREF(arrayP);

    if (env->fault_occurred)
        return NULL;

    printf("Received: %s %s %s\n",temp._clientid,temp.p,temp.m);

    /* Add our two numbers. */
   // z = x + y;

    /* Sometimes, make it look hard (so client can see what it's like
       to do an RPC that takes a while).
    */
    compute_mod(&temp);
  
    xmlrpc_value *arr = xmlrpc_array_new(env);
    xmlrpc_value *v1 = xmlrpc_build_value(env, "s", temp.response);
    xmlrpc_array_append_item (env,arr,v1);

    /* Return our result. */
    return xmlrpc_build_value(env,"(A)", arr);
}