C++ write_uint32函数代码示例

void dC23()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_23");
		__CrossProcess(X2,X3,CHUNK_SIZE,result);
		write_uint32("result_dc_23", result);
	}
}

void dC33()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_33");
		__CrossProcess(X3,X3,0,result);
		write_uint32("result_dc_33", result);
	}
}

void dC12()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_12");
		__CrossProcess(X1,X2,CHUNK_SIZE,result);
		write_uint32("result_dc_12", result);
	}
}

void dC22()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_22");
		__CrossProcess(X2,X2,0,result);
		write_uint32("result_dc_22", result);
	}
}

void dC01()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_01");
		__CrossProcess(X0,X1,CHUNK_SIZE,result);
		write_uint32("result_dc_01", result);
	}
}

void dC11()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_11");
		__CrossProcess(X1,X1,0,result);
		write_uint32("result_dc_11", result);
	}
}

int foo(int a)
{
	int b;
      

	write_uint32(&(p1[0].id[0]),a);
	b = read_uint32("pipe2");

	return(b);
}

// calculate all pairwise errors.
void dC00()
{
	uint32_t result;
	while(1)
	{
		uint8_t s = read_uint8("start_dc_00");
		__CrossProcess(X0,X0,0,result);
		write_uint32("result_dc_00", result);
	}
}

static int writer_uint32(lua_State* L)
{
	writer_t* writer 	= lua_touserdata(L, 1);
	lua_Integer integer = luaL_checkinteger(L, 2);

	if(integer < 0 || integer > UINT32_MAX)
		luaL_error(L, "unsigned overflow");
	
	write_uint32(writer, (uint32_t)integer);
	return 0;
}

int main(int argc, char* argv[])
{
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

	write_uint32("in_data", 16);
	uint32_t v = read_uint32("out_data");	
	if(v != 16)
		fprintf(stderr,"Error: received %d, expected %d\n", v, 16);
	return(0);
}

void slave_0()
{
	while(1)
	{
		uint8_t s = read_uint8("start_slave_0");
		float bc;
		int bi;

#ifdef USE2
		__correlatorBase(ref_vector_0, check_vectors_0, bc, bi, NUM_VECS_BY_2);
		write_float32("best_correlation_0_pipe",bc);
		write_uint32("best_index_0_pipe",bi);
#else
		__correlatorBase(ref_vector, check_vectors, bc, bi, NUM_VECS);
		write_float32("best_correlation_0_pipe",bc);
		write_uint32("best_index_0_pipe",bi);
#endif

	}
}

int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len)
{
   int i;
   Packet p;
   unsigned char ch;

   p.data = packet;
   p.maxlen = len;
   p.pos = 0;
   if (len<19)return 0;
   if (!write_chars(&p, (const unsigned char*)"OpusHead", 8))
      return 0;
   /* Version is 1 */
   ch = 1;
   if (!write_chars(&p, &ch, 1))
      return 0;

   ch = h->channels;
   if (!write_chars(&p, &ch, 1))
      return 0;

   if (!write_uint16(&p, h->preskip))
      return 0;

   if (!write_uint32(&p, h->input_sample_rate))
      return 0;

   if (!write_uint16(&p, h->gain))
      return 0;

   ch = h->channel_mapping;
   if (!write_chars(&p, &ch, 1))
      return 0;

   if (h->channel_mapping != 0)
   {
      ch = h->nb_streams;
      if (!write_chars(&p, &ch, 1))
         return 0;

      ch = h->nb_coupled;
      if (!write_chars(&p, &ch, 1))
         return 0;

      /* Multi-stream support */
      for (i=0;i<h->channels;i++)
      {
         if (!write_chars(&p, &h->stream_map[i], 1))
            return 0;
      }
   }

   return p.pos;
}

static int fill_command
(stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
    struct stlink_libusb * const slu = sl->backend_data;
    unsigned char* const cmd = sl->c_buf;
    int i = 0;
    memset(cmd, 0, sizeof (sl->c_buf));
    if(slu->protocoll == 1) {
        fprintf(stderr, "This is never used....\n");
        cmd[i++] = 'U';
        cmd[i++] = 'S';
        cmd[i++] = 'B';
        cmd[i++] = 'C';
        write_uint32(&cmd[i], slu->sg_transfer_idx);
        write_uint32(&cmd[i + 4], len);
        i += 8;
        cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;
        cmd[i++] = 0; /* Logical unit */
        cmd[i++] = 0xa; /* Command length */
    }
    return i;
}

void sendConstants()
{
	int I;
	for(I = 0; I < 256; I++)
		write_uint8("byte_constants_pipe", __E[I]);
	for(I = 0; I < 256; I++)
		write_uint8("byte_constants_pipe", __L[I]);
	for(I = 0; I < 256; I++)
		write_uint8("byte_constants_pipe", __fbsub[I]);
	for(I = 0; I < 15; I++)
		write_uint32("word_constants_pipe", __Rcon[I]);
}

int key_value_write_lines(FILE *f, struct key_value_specification *kvs, void *base_address[])
{
	struct key_value_specification *k;
	int rc;
	int errs = 0;

	for (k = kvs; k->key; k++) {
		switch (k->type) {
		case KVS_STRING:
			rc = write_string(f, k, base_address);
			break;
		case KVS_INT64:
			rc = write_int64(f, k, base_address);
			break;
		case KVS_INT32:
			rc = write_int32(f, k, base_address);
			break;
		case KVS_INT16:
			rc = write_int16(f, k, base_address);
			break;
		case KVS_INT8:
			rc = write_int8(f, k, base_address);
			break;
		case KVS_UINT64:
			rc = write_uint64(f, k, base_address);
			break;
		case KVS_UINT32:
			rc = write_uint32(f, k, base_address);
			break;
		case KVS_UINT16:
			rc = write_uint16(f, k, base_address);
			break;
		case KVS_UINT8:
			rc = write_uint8(f, k, base_address);
			break;
		case KVS_DOUBLE:
			rc = write_double(f, k, base_address);
			break;
		case KVS_FLOAT:
			rc = write_float(f, k, base_address);
			break;
		default:
			fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'\n",
				__func__, __LINE__, k->type, k->key);
			rc = -1;
			break;
		}
		if (rc)
			errs++;
	}
	return errs;
}