Exemplo n.º 1
0
static void inline add_to_buffer(void* stream, unsigned int length){
	// This shouldn't lose any data and works for any size
	unsigned int stream_offset = 0;
	// Length calculations are in samples (stereo (short) sample pairs)
	unsigned int lengthi, rlengthi;
	unsigned int lengthLeft = length >> 2;
	unsigned int rlengthLeft = ceilf(lengthLeft / freq_ratio);
	while(1){
		rlengthi = (buffer_offset + (rlengthLeft << 2) <= buffer_size) ?
		            rlengthLeft : ((buffer_size - buffer_offset) >> 2);
		lengthi  = rlengthi * freq_ratio;

#ifdef THREADED_AUDIO
		// Wait for a buffer we can copy into
		LWP_SemWait(buffer_empty);
#endif
		copy_to_buffer(buffer[which_buffer] + buffer_offset,
		               stream + stream_offset, rlengthi);

		if(buffer_offset + (rlengthLeft << 2) < buffer_size){
			buffer_offset += rlengthi << 2;
#ifdef THREADED_AUDIO
			// This is a little weird, but we didn't fill this buffer.
			//   So it is still considered 'empty', but since we 'decremented'
			//   buffer_empty coming in here, we want to set it back how
			//   it was, so we don't cause a deadlock
			LWP_SemPost(buffer_empty);
#endif
			return;
		}

		lengthLeft    -= lengthi;
		stream_offset += lengthi << 2;
		rlengthLeft   -= rlengthi;

#ifdef THREADED_AUDIO
		// Start the thread if this is the first sample
		if(!thread_running){
			thread_running = 1;
			LWP_SemPost(first_audio);
		}
		
		// Let the audio thread know that we've filled a new buffer
		LWP_SemPost(buffer_full);
#else
		play_buffer();
#endif
#ifdef AIDUMP
		if(AIdump)
	    fwrite(&buffer[which_buffer][0],1,buffer_size,AIdump);
#endif
		NEXT(which_buffer);
		buffer_offset = 0;
	}
}
Exemplo n.º 2
0
void pauseAudio(void){
#ifdef THREADED_AUDIO
	// We just grab the audio_free 'lock' and don't let go
	//   when we have this lock, audio_thread must be waiting
	if(audioEnabled){
		LWP_SemWait(audio_free);
		audio_paused = 1;
	}
#endif
	AUDIO_StopDMA();
}
Exemplo n.º 3
0
void *
mem_realloc(void *rmem, mem_size_t newsize)
{
  mem_size_t size;
  mem_size_t ptr, ptr2;
  struct mem *mem, *mem2;

  /* Expand the size of the allocated memory region so that we can
     adjust for alignment. */
  if ((newsize % MEM_ALIGNMENT) != 0) {
   newsize += MEM_ALIGNMENT - ((newsize + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT);
  }
  
  if (newsize > MEM_SIZE) {
    return NULL;
  }
  
  LWP_SemWait(mem_sem);
  
  LWIP_ASSERT("mem_realloc: legal memory", (u8_t *)rmem >= (u8_t *)ram &&
   (u8_t *)rmem < (u8_t *)ram_end);
  
  if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) {
    LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_realloc: illegal memory\n"));
    return rmem;
  }
  mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM);

  ptr = (u8_t *)mem - ram;

  size = mem->next - ptr - SIZEOF_STRUCT_MEM;
#if MEM_STATS
  lwip_stats.mem.used -= (size - newsize);
#endif /* MEM_STATS */
  
  if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE < size) {
    ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize;
    mem2 = (struct mem *)&ram[ptr2];
    mem2->used = 0;
    mem2->next = mem->next;
    mem2->prev = ptr;
    mem->next = ptr2;
    if (mem2->next != MEM_SIZE) {
      ((struct mem *)&ram[mem2->next])->prev = ptr2;
    }

    plug_holes(mem2);
  }
  LWP_SemPost(mem_sem);
  return rmem;
}
Exemplo n.º 4
0
static void inline play_buffer(void){
#ifndef THREADED_AUDIO
	// We should wait for the other buffer to finish its DMA transfer first
	while( AUDIO_GetDMABytesLeft() );
	AUDIO_StopDMA();

#else // THREADED_AUDIO
	// Wait for a sample to actually be played to work around a deadlock
	LWP_SemWait(first_audio);
	
	// This thread will keep giving buffers to the audio as they come
	while(thread_running){

	// Wait for a buffer to be processed
	LWP_SemWait(buffer_full);
#endif

	// Make sure the buffer is in RAM, not the cache
	DCFlushRange(buffer[thread_buffer], buffer_size);

	// Actually send the buffer out to be played next
	AUDIO_InitDMA((unsigned int)&buffer[thread_buffer], buffer_size);

#ifdef THREADED_AUDIO
	// Wait for the audio interface to be free before playing
	LWP_SemWait(audio_free);
#endif

	// Start playing the buffer
	AUDIO_StartDMA();

#ifdef THREADED_AUDIO
	// Move the index to the next buffer
	NEXT(thread_buffer);
	}
#endif
}
Exemplo n.º 5
0
void
mem_free(void *rmem)
{
  struct mem *mem;

  if (rmem == NULL) {
    LWIP_DEBUGF(MEM_DEBUG | DBG_TRACE | 2, ("mem_free(p == NULL) was called.\n"));
    return;
  }
  
  LWP_SemWait(mem_sem);

  LWIP_ASSERT("mem_free: legal memory", (u8_t *)rmem >= (u8_t *)ram &&
    (u8_t *)rmem < (u8_t *)ram_end);
  
  if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) {
    LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_free: illegal memory\n"));
#if MEM_STATS
    ++lwip_stats.mem.err;
#endif /* MEM_STATS */
    LWP_SemPost(mem_sem);
    return;
  }
  mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM);

  LWIP_ASSERT("mem_free: mem->used", mem->used);
  
  mem->used = 0;

  if (mem < lfree) {
    lfree = mem;
  }
  
#if MEM_STATS
  lwip_stats.mem.used -= mem->next - ((u8_t *)mem - ram);
  
#endif /* MEM_STATS */
  plug_holes(mem);
  LWP_SemPost(mem_sem);
}
Exemplo n.º 6
0
static s32 DebugHelper_request( DebugHelper_t *helper, s32 code, s32 nargs, HelperParam_t *param )
{
	if ( code <= HELPER_CODE_NONE || code >= HELPER_CODE_END ) {
		return 0;
	}
	__db_req_count[ code ] ++;
	DEBUG_PRINT((NULL,0,"DebugHelper_request(%p), code=%d.\n", helper, code));

	  /* nargs is not used */
	helper->param = param;
	//if ( nargs > 0 ) {
	//	memcpy( helper->param, param, nargs * sizeof( HelperParam_t));
	//}

	helper->code = code;

 	  /* notify the helper thread */
	LWP_SemPost( helper->requestReadySema);

	  /* wait be notified until the helper thread complete the request */
	LWP_SemWait( helper->answerReadySema);

	return	helper->retvalue;
}
Exemplo n.º 7
0
void *
mem_malloc(mem_size_t size)
{
  mem_size_t ptr, ptr2;
  struct mem *mem, *mem2;

  if (size == 0) {
    return NULL;
  }

  /* Expand the size of the allocated memory region so that we can
     adjust for alignment. */
  if ((size % MEM_ALIGNMENT) != 0) {
    size += MEM_ALIGNMENT - ((size + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT);
  }
  
  if (size > MEM_SIZE) {
    return NULL;
  }
  
  LWP_SemWait(mem_sem);

  for (ptr = (u8_t *)lfree - ram; ptr < MEM_SIZE; ptr = ((struct mem *)&ram[ptr])->next) {
    mem = (struct mem *)&ram[ptr];
    if (!mem->used &&
       mem->next - (ptr + SIZEOF_STRUCT_MEM) >= size + SIZEOF_STRUCT_MEM) {
      ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
      mem2 = (struct mem *)&ram[ptr2];

      mem2->prev = ptr;      
      mem2->next = mem->next;
      mem->next = ptr2;      
      if (mem2->next != MEM_SIZE) {
        ((struct mem *)&ram[mem2->next])->prev = ptr2;
      }
      
      mem2->used = 0;      
      mem->used = 1;
#if MEM_STATS
      lwip_stats.mem.used += (size + SIZEOF_STRUCT_MEM);
      /*      if (lwip_stats.mem.max < lwip_stats.mem.used) {
        lwip_stats.mem.max = lwip_stats.mem.used;
  } */
      if (lwip_stats.mem.max < ptr2) {
        lwip_stats.mem.max = ptr2;
      }      
#endif /* MEM_STATS */

      if (mem == lfree) {
  /* Find next free block after mem */
        while (lfree->used && lfree != ram_end) {
    lfree = (struct mem *)&ram[lfree->next];
        }
        LWIP_ASSERT("mem_malloc: !lfree->used", !lfree->used);
      }
      LWP_SemPost(mem_sem);
      LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.",
       (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end);
      LWIP_ASSERT("mem_malloc: allocated memory properly aligned.",
       (unsigned long)((u8_t *)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0);
      return (u8_t *)mem + SIZEOF_STRUCT_MEM;
    }    
  }
  LWIP_DEBUGF(MEM_DEBUG | 2, ("mem_malloc: could not allocate %"S16_F" bytes\n", (s16_t)size));
#if MEM_STATS
  ++lwip_stats.mem.err;
#endif /* MEM_STATS */  
  LWP_SemPost(mem_sem);
  return NULL;
}
Exemplo n.º 8
0
static
void *DebugHelper_run( void *args)
{
	DebugHelper_t *helper = (DebugHelper_t*) args;
	s32 code = HELPER_CODE_NONE;
	s32 ret;

	DEBUG_PRINT((NULL,0,"Helper(%p) thread up and running ...\n", helper));

	while (1) {

		 /* wait be notified by gdb-runtime-core */
		LWP_SemWait( helper->requestReadySema);

		code=helper->code;

		DEBUG_PRINT((NULL,0,"Helper(%p) wakeup with code:%d\n", helper, helper->code));
		if ( code<= HELPER_CODE_NONE || code>= HELPER_CODE_END ) {
			continue;
		}
		__db_ack_count[ code]++;

		DEBUG_PRINT((NULL,0,"Helper(%p) working on code:%d\n", helper, code));

		switch( code) {
		case	HELPER_CODE_OPEN:
			ret = helper_opentcpip( helper);
			break;
		case	HELPER_CODE_CLOSE:
			ret = helper_closetcpip( helper);
			break;
		case	HELPER_CODE_READ:
			ret = helper_readtcpip( helper);
			break;
		case	HELPER_CODE_WRITE:
			ret = helper_writetcpip( helper);
			break;
		case	HELPER_CODE_WAIT:
			ret = helper_waittcpip( helper);
			break;
		case	HELPER_CODE_STOP:
			ret = 0;
			break;
		default:
			ret = 0;
			break;
		}
		helper->retvalue = ret;

		DEBUG_PRINT((NULL,0,"Helper(%p) completed with ret-code:%d\n", helper, ret));

		  /* just be safe */
		helper->code = HELPER_CODE_NONE;

		  /* notify the gdb-runtime-core */
		LWP_SemPost( helper->answerReadySema);

		if ( code==HELPER_CODE_STOP) {
			break ;
		}
	}
	return NULL;
}