static int update_header(void)
{
    off_t save_point;
    int32 tmp;

    if(already_warning_lseek)
	return 0;

    save_point = lseek(dpm.fd, 0, SEEK_CUR);
    if(save_point == -1 || lseek(dpm.fd, 4, SEEK_SET) == -1)
    {
	ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
		  "Warning: %s: %s: Can't make valid header",
		  dpm.name, strerror(errno));
	already_warning_lseek = 1;
	return 0;
    }

    tmp = LE_LONG(bytes_output + 44 - 8);
    if(write(dpm.fd, &tmp, 4) == -1)
    {
	lseek(dpm.fd, save_point, SEEK_SET);
	return -1;
    }
    lseek(dpm.fd, 40, SEEK_SET);
    tmp = LE_LONG(bytes_output);
    write(dpm.fd, &tmp, 4);

    lseek(dpm.fd, save_point, SEEK_SET);
    ctl->cmsg(CMSG_INFO, VERB_DEBUG,
	      "%s: Update RIFF WAVE header (size=%d)", dpm.name, bytes_output);

    return 0;
}
Beispiel #2
0
int coff_syms(FILE *in)
{
	struct coff_header hdr;
	char *strtab;
	uint8_t *symtab;
	int strtab_len;
	int i;
	int ret = 0;

	if (read_header(in, &hdr) < 0)
		return -1;

	strtab_len = read_strtab(in, &hdr, &strtab);
	if (strtab_len < 0)
		return -1;

	if (read_symtab(in, &hdr, &symtab) < 0) {
		if (strtab)
			free(strtab);
		return -1;
	}

	for (i = 0; i < hdr.stab_count; i++) {
		uint8_t *entry = symtab + i * STAB_ENTRY_SIZE;
		uint32_t value = LE_LONG(entry, 8);
		int storage_class = entry[16];
		char namebuf[9];
		const char *name = NULL;

		if (LE_LONG(entry, 0)) {
			memcpy(namebuf, entry, 8);
			namebuf[8] = 0;
			name = namebuf;
		} else {
			uint32_t offset = LE_LONG(entry, 4);

			if (offset >= 4 && offset < strtab_len)
				name = strtab + offset;
		}

		if (name &&
		    (storage_class == C_EXT || storage_class == C_LABEL) &&
		    stab_set(name, value) < 0) {
			printc_err("coff: failed to insert symbol\n");
			ret = -1;
			break;
		}

		/* Skip auxiliary entries */
		i += entry[17];
	}

	if (symtab)
		free(symtab);
	if (strtab)
		free(strtab);

	return ret;
}
static void parse_header(const uint8_t *data, struct coff_header *hdr)
{
	hdr->version = LE_WORD(data, 0);
	hdr->sec_count = LE_WORD(data, 2);
	hdr->timestamp = LE_LONG(data, 4);
	hdr->stab_start = LE_LONG(data, 8);
	hdr->stab_count = LE_LONG(data, 12);
	hdr->opt_bytes = LE_WORD(data, 16);
	hdr->flags = LE_WORD(data, 18);
	hdr->target_id = LE_WORD(data, 20);
}
Beispiel #4
0
static int READDW(uint32_t *vp, struct timidity_file *tf)
{
	if (tf_read(vp, 4, 1, tf) != 1)
		return -1;
	*vp = LE_LONG(*vp);
	return 1;
}
Beispiel #5
0
static int READCHUNK(SFChunk *vp, struct timidity_file *tf)
{
	if (tf_read(vp, 8, 1, tf) != 1)
		return -1;
	vp->size = LE_LONG(vp->size);
	return 1;
}
Beispiel #6
0
static int parse_sym(Elf32_Sym *s, FILE *in)
{
	uint8_t data[16];

	if (fread(data, sizeof(data), 1, in) != 1)
		return -1;

	s->st_name = LE_LONG(data, 0);
	s->st_value = LE_LONG(data, 4);
	s->st_size = LE_LONG(data, 8);
	s->st_info = data[12];
	s->st_other = data[13];
	s->st_shndx = LE_WORD(data, 14);

	return 0;
}
Beispiel #7
0
static int acntl(int request, void *arg)
{
    int tmp, tmp1, samples;
    switch(request)
    {
      case PM_REQ_DISCARD: /* Discard stream */
	arts_close_stream(stream);
	stream=NULL;
	return 0;
      case PM_REQ_RATE: /* Change sample rate */
        arts_close_stream(stream);
        tmp = (dpm.encoding & PE_16BIT) ? 16 : 8;
        tmp1 = (dpm.encoding & PE_MONO) ? 1 : 2;
        stream = arts_play_stream(*(int*)arg,
		    LE_LONG(tmp),
		    tmp1,
		    "timidity");
        server_buffer = arts_stream_get(stream, ARTS_P_SERVER_LATENCY) * dpm.rate * (tmp/8) * tmp1 / 1000;
	return 0;
      case PM_REQ_GETQSIZ: /* Get maximum queue size */
	*(int*)arg = arts_stream_get(stream, ARTS_P_BUFFER_SIZE);
	return 0;
      case PM_REQ_SETQSIZ: /* Set queue size */
	*(int*)arg = arts_stream_set(stream, ARTS_P_BUFFER_SIZE, *(int*)arg);
	return 0;
      case PM_REQ_GETFRAGSIZ: /* Get device fragment size */
	*(int*)arg = arts_stream_get(stream, ARTS_P_PACKET_SIZE);
	return 0;
      case PM_REQ_GETSAMPLES: /* Get current play sample */
	tmp = arts_stream_get(stream, ARTS_P_BUFFER_SIZE) -
		         arts_stream_get(stream, ARTS_P_BUFFER_SPACE) +
			 server_buffer;
	samples = output_count - tmp;
	if(samples < 0)
	  samples = 0;
	if(!(dpm.encoding & PE_MONO)) samples >>= 1;
	if(dpm.encoding & PE_16BIT) samples >>= 1;
	*(int*)arg = samples;
	return 0;
      case PM_REQ_GETFILLABLE: /* Get fillable device queue size */
	*(int*)arg = arts_stream_get(stream, ARTS_P_BUFFER_SPACE);
	return 0;
      case PM_REQ_GETFILLED: /* Get filled device queue size */
	*(int*)arg = arts_stream_get(stream, ARTS_P_BUFFER_SIZE) - arts_stream_get(stream, ARTS_P_BUFFER_SPACE);
	return 0;
      /* The following are not (yet) implemented: */
      case PM_REQ_FLUSH: /* Wait until playback is complete */
      case PM_REQ_MIDI: /* Send MIDI event */
      case PM_REQ_INST_NAME: /* Get instrument name */
	return -1;
      case PM_REQ_OUTPUT_FINISH: /* Sent after last output_data */
      case PM_REQ_PLAY_START: /* Called just before playing */
      case PM_REQ_PLAY_END: /* Called just after playing */
	return 0;
    }
    return -1;
}
Beispiel #8
0
static int parse_shdr(Elf32_Shdr *s, FILE *in)
{
	uint8_t data[40];

	if (fread(data, sizeof(data), 1, in) != 1)
		return -1;

	s->sh_name = LE_LONG(data, 0);
	s->sh_type = LE_LONG(data, 4);
	s->sh_flags = LE_LONG(data, 8);
	s->sh_addr = LE_LONG(data, 12);
	s->sh_offset = LE_LONG(data, 16);
	s->sh_size = LE_LONG(data, 20);
	s->sh_link = LE_LONG(data, 24);
	s->sh_info = LE_LONG(data, 28);
	s->sh_addralign = LE_LONG(data, 32);
	s->sh_entsize = LE_LONG(data, 36);

	return 0;
}
int coff_extract(FILE *in, binfile_imgcb_t cb, void *user_data)
{
	struct coff_header hdr;
	uint8_t *shdrs;
	int ret = 0;
	int i;

	if (read_header(in, &hdr) < 0)
		return -1;

	if (read_sechdrs(in, &hdr, &shdrs) < 0)
		return -1;

	for (i = 0; i < hdr.sec_count; i++) {
		uint8_t *header = shdrs + SHDR_SIZE * i;
		uint32_t flags = LE_LONG(header, 40);

		if (((flags & STYP_TEXT) || (flags & STYP_DATA)) &&
		    !(flags & STYP_NOLOAD)) {
			uint32_t addr = LE_LONG(header, 8);
			uint32_t offset = LE_LONG(header, 20);
			uint32_t size = LE_LONG(header, 16);

			if (load_section(in, addr, offset, size,
					 cb, user_data) < 0) {
				printc_err("coff: error while loading "
					"section %d\n", i);
				ret = -1;
				break;
			}
		}
	}

	if (shdrs)
		free(shdrs);

	return ret;
}
Beispiel #10
0
static int parse_ehdr(Elf32_Ehdr *e, FILE *in)
{
	uint8_t data[52];

	if (fread(data, sizeof(data), 1, in) != 1)
		return -1;

	memcpy(e->e_ident, data, EI_NIDENT);
	e->e_type = LE_WORD(data, 16);
	e->e_machine = LE_WORD(data, 18);
	e->e_version = LE_LONG(data, 20);
	e->e_entry = LE_LONG(data, 24);
	e->e_phoff = LE_LONG(data, 28);
	e->e_shoff = LE_LONG(data, 32);
	e->e_flags = LE_LONG(data, 36);
	e->e_ehsize = LE_WORD(data, 40);
	e->e_phentsize = LE_WORD(data, 42);
	e->e_phnum = LE_WORD(data, 44);
	e->e_shentsize = LE_WORD(data, 46);
	e->e_shnum = LE_WORD(data, 48);
	e->e_shstrndx = LE_WORD(data, 50);

	return 0;
}
Beispiel #11
0
static int parse_phdr(Elf32_Phdr *p, FILE *in)
{
	uint8_t data[32];

	if (fread(data, sizeof(data), 1, in) != 1)
		return -1;

	p->p_type = LE_LONG(data, 0);
	p->p_offset = LE_LONG(data, 4);
	p->p_vaddr = LE_LONG(data, 8);
	p->p_paddr = LE_LONG(data, 12);
	p->p_filesz = LE_LONG(data, 16);
	p->p_memsz = LE_LONG(data, 20);
	p->p_flags = LE_LONG(data, 24);
	p->p_align = LE_LONG(data, 28);

	return 0;
}
int CWAVInputSource::AnalyzeSource()
{
	unsigned char *p = FULL_HEADER, *priff = NULL;

	// seek to the beginning (just in case)
	m_spIO->Seek(0, FILE_BEGIN);

	// get the file size
	m_nFileBytes = m_spIO->GetSize();

	// get the RIFF header
	RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(RIFF_HEADER)))

	// make sure the RIFF header is valid
	if (!(p[0] == 'R' && p[1] == 'I' && p[2] == 'F' && p[3] == 'F'))
		return ERROR_INVALID_INPUT_FILE;
	p += sizeof(RIFF_HEADER);

	// read the data type header
	RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(DATA_TYPE_ID_HEADER)))

	// make sure it's the right data type
	if (!(p[0] == 'W' && p[1] == 'A' && p[2] == 'V' && p[3] == 'E'))
		return ERROR_INVALID_INPUT_FILE;
	p += sizeof(DATA_TYPE_ID_HEADER);

	// find the 'fmt ' chunk
	RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(RIFF_CHUNK_HEADER)))

	while (!(p[0] == 'f' && p[1] == 'm' && p[2] == 't' && p[3] == ' '))
	{
		p += sizeof(RIFF_CHUNK_HEADER);

		// move the file pointer to the end of this chunk
		RETURN_ON_ERROR(ReadSafe(m_spIO, p, LE_LONG(p+4)))
		p += LE_LONG(p+4);

		// check again for the data chunk
		RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(RIFF_CHUNK_HEADER)))
    }

	priff = p+4;
	p += sizeof(RIFF_CHUNK_HEADER);

	// read the format info
	RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(WAV_FORMAT_HEADER)))

	// error check the header to see if we support it
	if (LE_SHORT(p) != 1)
		return ERROR_INVALID_INPUT_FILE;

	// copy the format information to the WAVEFORMATEX passed in
	FillWaveFormatEx(&m_wfeSource, LE_LONG(p+4), LE_SHORT(p+14), LE_SHORT(p+2));

	p += sizeof(WAV_FORMAT_HEADER);

	// skip over any extra data in the header
	int nWAVFormatHeaderExtra = LE_LONG(priff) - sizeof(WAV_FORMAT_HEADER);
	if (nWAVFormatHeaderExtra < 0)
		return ERROR_INVALID_INPUT_FILE;
	else {
		RETURN_ON_ERROR(ReadSafe(m_spIO, p, nWAVFormatHeaderExtra))
		p += nWAVFormatHeaderExtra;
	}

	// find the data chunk
	RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(RIFF_CHUNK_HEADER)))

	while (!(p[0] == 'd' && p[1] == 'a' && p[2] == 't' && p[3] == 'a'))
	{
		p += sizeof(RIFF_CHUNK_HEADER);

		// move the file pointer to the end of this chunk
		RETURN_ON_ERROR(ReadSafe(m_spIO, p, LE_LONG(p+4)))
		p += LE_LONG(p+4);

		// check again for the data chunk
		RETURN_ON_ERROR(ReadSafe(m_spIO, p, sizeof(RIFF_CHUNK_HEADER)))
	}

	// we're at the data block
	m_nDataBytes = LE_LONG(p+4);
	if (m_nDataBytes < 0)
		m_nDataBytes = m_nFileBytes - m_nHeaderBytes;

	p += sizeof(RIFF_CHUNK_HEADER);

	m_nHeaderBytes = p - FULL_HEADER;

	// make sure the data bytes is a whole number of blocks
	if ((m_nDataBytes % m_wfeSource.nBlockAlign) != 0)
		return ERROR_INVALID_INPUT_FILE;

	// calculate the terminating byts
	m_nTerminatingBytes = 0;

	// we made it this far, everything must be cool
	return ERROR_SUCCESS;
}
Beispiel #13
0
static int open_output(void)
{
    int i, include_enc, exclude_enc;
    int sample_width, channels;

    include_enc = 0;
    exclude_enc = PE_ULAW|PE_ALAW|PE_BYTESWAP; /* They can't mean these */
    if(dpm.encoding & PE_16BIT)
	include_enc |= PE_SIGNED;
    else
	exclude_enc |= PE_SIGNED;
    dpm.encoding = validate_encoding(dpm.encoding, include_enc, exclude_enc);
    sample_width = (dpm.encoding & PE_16BIT) ? 16 : 8;
    channels = (dpm.encoding & PE_MONO) ? 1 : 2;

    /* Open the audio device */
    switch (arts_init_state) {
    case 0:
	if((i = arts_init()) != 0)
	{
	    ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
		      dpm.name, arts_error_text(i));
	    return -1;
	}
	arts_init_state = 1;
	break;
    case 2:
	ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
	    "TiMidity aRts bug: open_output() after close_output() not supported");
	return -1;
    }
    stream = arts_play_stream(dpm.rate,
			      LE_LONG(sample_width),
			      channels,
			      "timidity");
    if(stream == NULL)
    {
	ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
		  dpm.name, strerror(errno));
	return -1;
    }
    arts_stream_set(stream, ARTS_P_BLOCKING, 1);

    server_buffer = arts_stream_get(stream, ARTS_P_SERVER_LATENCY) * dpm.rate * (sample_width/8) * channels / 1000;
    output_count = 0;
    return 0;
    /* "this aRts function isnot yet implemented"
     *
    if (dpm.extra_param[0]) {
        i = arts_stream_set(stream,
            ARTS_P_PACKET_COUNT,
            dpm.extra_param[0]);
	if (i < 0) {
            ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
              dpm.name, arts_error_text(i));
	    return 1;
        }
    }
    return 0;
     *
     */
}
Beispiel #14
0
int main(int argc, char **argv)
{
  int32
    note=DEFAULT_NOTE,
    root=DEFAULT_ROOT,
    verbosity=0,
    samplerate=-1,
    datasize=-1,
    junklength, c;

  int
    infd=STDIN_FILENO;

  unsigned char
    thing[4096],
    *point,
    modes=0;

#ifdef __MACOS__
  mac_main_wav2pat(&root, &note, &infd);
#else

  while ((c=getopt(argc, argv, "r:n:vh"))>0)
    switch(c)
      {
      case 'r': root=atol(optarg); break;
      case 'n': root=freq_table[atoi(optarg) & 127]; break;
      case 'u': note=atol(optarg); break;
      case 'v': verbosity++; break;
      case 'h': usage(); return 0;
      default: return 1;
      }

  if (optind==argc-1)
    {
      if ((infd=open(argv[optind], O_RDONLY))<0)
	{
	  perror("wav2pat: I can't open your WAVE");
	  return 3;
	}
    }
  else if (optind!=argc)
    {
	usage();
	return 1;
    }
#endif

  /* check out the putative RIFF WAVE on stdin */

  if (read(infd, thing, 12)<=0)
    {
      perror("wav2pat: I can't read your WAVE");
      return 3;
    }

  if (memcmp(thing, "RIFF", 4) || memcmp(thing+8, "WAVE", 4))
    {
      fprintf(stderr, "wav2pat: I want a RIFF WAVE on stdin!" NLS);
      return 2;
    }

  while (datasize==-1)
    {
      if (read(infd, thing, 8)!=8)
	{
	  perror("wav2pat: "
		 "Your WAVE ran out before I got to the interesting bits");
	  return 3;
	}
      junklength=LE_LONG(*((int32 *)(thing+4)));

      /* This Microsoft file format is designed to be impossible to
	 parse correctly if one doesn't have the full specification.
	 If you have a wave with an INFO "chunk", you lose. Thank you
	 for playing. */

      if (!memcmp(thing, "fmt ", 4))
	{
	  if (junklength > 4096)
	    {
	      fprintf(stderr, "wav2pat: "
		      "WAVEs with %ld-byte format blocks make me throw up!"
		      NLS,
		      junklength);
	      return 2;
	    }
	  if (read(infd, thing, junklength) != junklength)
	    {
	      perror("wav2pat: Your WAVE is mangled");
	      return 3;
	    }
	  if (LE_SHORT(*((int16 *)(thing))) != 1)
	    {
	      fprintf(stderr, "wav2pat: I don't understand your WAVE. "
		      "It has a type %d format chunk!" NLS,
		      LE_SHORT(*((int16 *)(thing))));
	      return 2;
	    }
	  if (LE_SHORT(*((int16 *)(thing + 2))) != 1)
	    {
	      fprintf(stderr, "wav2pat: This WAVE has %d channels! "
		      "There can be only one!" NLS,
		      LE_SHORT(*((int16 *)(thing + 2))));
	      return 2;
	    }
	  samplerate=LE_LONG(*((int32 *)(thing + 4)));
	  switch(LE_SHORT(*((int16 *)(thing + 14))))
	    {
	    case 8: modes |= MODES_UNSIGNED; break;
	    case 16: modes |= MODES_16BIT; break;
	    default:
	      fprintf(stderr, "wav2pat: Ack! Ppthbth! %d-bit samples!",
		      LE_SHORT(*((int16 *)(thing + 14))));
	      return 2;
	    }
	  if (verbosity)
	    fprintf(stderr, "wav2pat: This is a %d-bit, %ld Hz WAVE" NLS,
		    (LE_SHORT(*((int16 *)(thing + 14)))),
		    samplerate);
	}
      else if (!memcmp(thing, "data", 4))
	{
	  if (samplerate==-1)
	    {
	      fprintf(stderr, "wav2pat: Your WAVE has no format information before data!" NLS);
	      return 2;
	    }
	  if (verbosity)
	    fprintf(stderr, "wav2pat: It has %ld bytes of data" NLS, junklength);
	  datasize=junklength;
	}
      else
	{
	  if (verbosity)
	    fprintf(stderr, "wav2pat: "
		    "Your WAVE has a %ld-byte chunk called `%4.4s'" NLS,
		    junklength, thing);

	  /* It's cool to pad chunks with NULs to align them on
             half-word boundaries. */
	  if (junklength & 1)
	    junklength++;

	  while (junklength>0)
	    {
	      if ((c=read(infd, thing, (junklength>4096) ? 4096 : junklength))
		  <= 0)
		{
		  perror("wav2pat: Now your WAVE has run out of data");
		  return 3;
		}
	      junklength -= c;
	    }
	}
    }

  /* hammer together something that looks like a GUS patch header */

#define pound(a) *point++=(a);
#define pounds(a) { int16 x = (int16)LE_SHORT(a); memcpy(point, &x, 2); point+=2; }
#define poundl(a) { int32 x = LE_LONG(a);  memcpy(point, &x, 4); point+=4; }
#define bounce(a) point += a;

  memset(thing, 0, 335);
  point=thing;

  /* header */
  memcpy(point, "GF1PATCH110", 12);
  point += 12;

  /* Gravis ID */
  memcpy(point, "ID#000002", 10);
  point += 10;

  /* description */
  strcpy((char *)point, "Copyleft 1995 EWE&U Conductions and one Retreated Gravi\032");
  point += 60;

  pound(1); /* instruments */
  pound(14); /* voices */
  pound(0); /* channels */
  pounds(1); /* waveforms */
  pounds(127); /* master volume */
  poundl(datasize); /* data size */
  bounce(36); /* reserved */

  pounds(1); /* instrument # */
  strcpy((char *)point, "Bleahnoise"); /* instrument name */
  point += 16;
  poundl(datasize); /* instrument size */
  pound(1); /* layers */
  bounce(40); /* reserved */

  pound(0); /* layer duplicate */
  pound(0); /* layer */
  poundl(datasize); /* layer size */
  pound(1); /* samples */
  bounce(40); /* reserved */

  strcpy((char *)point, "bleah"); /* wave name */
  point += 7;
  pound(0); /* fractions */
  poundl(datasize); /* wave size */
  poundl(0); /* loop start */
  poundl(datasize); /* loop end */
  pounds(samplerate); /* sample rate */
  poundl(8176); /* low freq */
  poundl(12543854); /* high freq */
  poundl(root); /* root freq */
  pounds(512); /* tune */
  pound(7);  /* balance */

  pound(63); /* envelope rates */
  pound(63);
  pound(63);
  pound(63);
  pound(63);
  pound(63);

  pound(240); /* envelope offsets */
  pound(240);
  pound(240);
  pound(240);
  pound(240);
  pound(240);

  pound(0); /* tremolo sweep */
  pound(0); /* tremolo rate */
  pound(0); /* tremolo depth */
  pound(0); /* vibrato sweep */
  pound(0); /* vibrato rate */
  pound(0); /* vibrato depth */

  pound(modes); /* modes */

  pounds(note); /* scale freq */
  pounds(1024); /* scale factor */
  bounce(36); /* reserved */

  write(STDOUT_FILENO, thing, 335);

  /* wave data */

  while (datasize>0)
    {
      if ((c=read(infd, thing, (datasize>4096) ? 4096 : datasize))
	  <= 0)
	{
	  perror("wav2pat: I can't read data");
	  return 3;
	}
      write(STDOUT_FILENO, thing, c);
      datasize -= c;
    }

  /* be courteous */
  if (infd != STDIN_FILENO)
    close(infd);

  return 0;
}
Beispiel #15
0
static int wav_output_open(const char *fname)
{
  int t;
  char RIFFheader[44];
  int fd;

  if(strcmp(fname, "-") == 0)
    fd = 1; /* data to stdout */
  else {
    /* Open the audio file */
    fd = open(fname, FILE_OUTPUT_MODE);
    if(fd < 0) {
      ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
		fname, strerror(errno));
      return -1;
    }
  }

  /* Generate a (rather non-standard) RIFF header. We don't know yet
     what the block lengths will be. We'll fix that at close if this
     is a seekable file. */

  memcpy(RIFFheader, orig_RIFFheader, 44);

  if(dpm.encoding & PE_ALAW)
    RIFFheader[20] = WAVE_FORMAT_ALAW;
  else if(dpm.encoding & PE_ULAW)
    RIFFheader[20] = WAVE_FORMAT_MULAW;
  else
    RIFFheader[20] = WAVE_FORMAT_PCM;

  if(dpm.encoding & PE_MONO)
    RIFFheader[22] = 1;
  else
    RIFFheader[22] = 2;

  *((int *)(RIFFheader+24)) = LE_LONG(dpm.rate);

  t = dpm.rate;
  if(!(dpm.encoding & PE_MONO)) t *= 2;
  if(dpm.encoding & PE_16BIT)   t *= 2;
  *((int *)(RIFFheader+28)) = LE_LONG(t);

  /* Bug fixed from Masaaki Koyanagi <*****@*****.**> */
  if((dpm.encoding & (PE_MONO | PE_16BIT)) == PE_MONO)
    RIFFheader[32]='\001';
  else if (!(dpm.encoding & PE_MONO) && (dpm.encoding & PE_16BIT))
    RIFFheader[32]='\004';
  else
    RIFFheader[32]='\002';

  if(dpm.encoding & PE_16BIT)
    RIFFheader[34] = 16;
  else
    RIFFheader[34] = 8;

  if(write(fd, RIFFheader, 44) == -1) {
    ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: write: %s",
	      dpm.name, strerror(errno));
    close_output();
    return -1;
  }

  return fd;
}
Beispiel #16
0
int main()
{
	char	str[128];
	char	compiler[128];
	char	fpath[MAX_PATH+1];
	char*	path = ".";
	char*	glob_pattern = "*wrap*";
	int		i;
	int		ch;
	uint	u;
	time_t	t;
	glob_t	g;
	DIR*	dir;
	DIRENT*	dirent;
	thread_data_t thread_data;
	int	fd;
	int	fd2;
	int	canrelock=0;
	clock_t	ticks;

	/* Show platform details */
	DESCRIBE_COMPILER(compiler);
	printf("%-15s: %s\n","Platform",PLATFORM_DESC);
	printf("%-15s: %s\n","Version",os_version(str));
	printf("%-15s: %s\n","Compiler"	,compiler);
	printf("%-15s: %d\n","Random Number",xp_random(1000));

	for(i=0;i<3;i++) {
		if(_beginthread(
			  sopen_child_thread	/* entry point */
			 ,0  					/* stack size (0=auto) */
			 ,(void*)i				/* data */
			 )==(unsigned long)-1)
			printf("_beginthread failed\n");
		else
			SLEEP(1);
	}
	printf("Waiting for all sopen_child_threads to close...\n");
	SLEEP(5000);	/* wait for all threads to quit */

	/* Exclusive sopen test */
	printf("\nsopen() test\n");
	if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYRW,S_IREAD|S_IWRITE))==-1) {
		perror(LOCK_FNAME);
		return(errno);
	}
	printf("%s is opened with an exclusive (read/write) lock\n",LOCK_FNAME);
	getkey();
	if(_beginthread(
		  sopen_test_thread	/* entry point */
		 ,0  				/* stack size (0=auto) */
		 ,NULL				/* data */
		 )==(unsigned long)-1)
		printf("_beginthread failed\n");
	else
		SLEEP(1000);
	close(fd);

	/* sopen()/lock test */
	printf("\nlock() test\n");
	if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE))==-1) {
		perror(LOCK_FNAME);
		return(errno);
	}
	write(fd,"lock testing\n",LOCK_LEN);
	if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0)
		printf("lock() succeeds\n");
	else
		printf("!FAILURE: lock() non-functional (or file already locked)\n");
	if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0)  {
		printf("!FAILURE: Subsequent lock of region was allowed (will skip some tests)\n");
		canrelock=1;
	}
		
	if(_beginthread(
		  lock_test_thread	/* entry point */
		 ,0  				/* stack size (0=auto) */
		 ,NULL				/* data */
		 )==(unsigned long)-1)
		printf("_beginthread failed\n");
	else
		SLEEP(1000);
	if(canrelock)
		printf("?? Skipping some tests due to inability to detect own locks\n");
	else  {
		if(lock(fd,LOCK_OFFSET,LOCK_LEN))
			printf("Locks in first thread survive open()/close() in other thread\n");
		else
			printf("!FAILURE: lock() in first thread lost by open()/close() in other thread\n");
		if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN))
			printf("!FAILURE: file locking\n");
		else
			printf("Record locking\n");
	}
	if((fd2=sopen(LOCK_FNAME,O_RDWR,SH_DENYRW))==-1) {
		printf("Cannot reopen SH_DENYRW while lock is held\n");
		close(fd2);
	}
	else  {
		printf("!FAILURE: can reopen SH_DENYRW while lock is held\n");
	}
	if(unlock(fd,LOCK_OFFSET,LOCK_LEN))
		printf("!FAILURE: unlock() non-functional\n");
	if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN))
		printf("Cannot re-lock after non-overlapping unlock()\n");
	else
		printf("!FAILURE: can re-lock after non-overlappping unlock()\n");
	if(lock(fd,LOCK_OFFSET,LOCK_LEN))
		printf("!FAILURE: cannot re-lock unlocked area\n");
	close(fd);

	/* getch test */
	printf("\ngetch() test (ESC to continue)\n");
	do {
		ch=getch();
		printf("getch() returned %d\n",ch);
	} while(ch!=ESC);

	/* kbhit test */
	printf("\nkbhit() test (any key to continue)\n");
	while(!kbhit()) {
		printf(".");
		fflush(stdout);
		SLEEP(500);
	}
	getch();	/* remove character from keyboard buffer */

	/* BEEP test */
	printf("\nBEEP() test\n");
	getkey();
	for(i=750;i>250;i-=5)
		BEEP(i,15);
	for(;i<1000;i+=5)
		BEEP(i,15);

	/* SLEEP test */
	printf("\nSLEEP(5 second) test\n");
	getkey();
	t=time(NULL);
	printf("sleeping... ");
	fflush(stdout);
	ticks=msclock();
	SLEEP(5000);
	printf("slept %ld seconds (%ld according to msclock)\n",time(NULL)-t,(msclock()-ticks)/MSCLOCKS_PER_SEC);

	/* Thread SLEEP test */
	printf("\nThread SLEEP(5 second) test\n");
	getkey();
	i=0;
	if(_beginthread(
		  sleep_test_thread	/* entry point */
		 ,0					/* stack size (0=auto) */
		 ,&i				/* data */
		 )==(unsigned long)-1)
		printf("_beginthread failed\n");
	else {
		SLEEP(1);			/* yield to child thread */
		while(i==0) {
			printf(".");
			fflush(stdout);
			SLEEP(1000);
		}
	}

	/* glob test */
	printf("\nglob(%s) test\n",glob_pattern);
	getkey();
	i=glob(glob_pattern,GLOB_MARK,NULL,&g);
	if(i==0) {
		for(u=0;u<g.gl_pathc;u++)
			printf("%s\n",g.gl_pathv[u]);
		globfree(&g);
	} else
		printf("glob(%s) returned %d\n",glob_pattern,i);

	/* opendir (and other directory functions) test */
	printf("\nopendir(%s) test\n",path);
	getkey();
	printf("\nDirectory of %s\n\n",FULLPATH(fpath,path,sizeof(fpath)));
	dir=opendir(path);
	while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
		t=fdate(dirent->d_name);
		printf("%.24s %10lu  %06o  %s%c\n"
			,ctime(&t)
			,flength(dirent->d_name)
			,getfattr(dirent->d_name)
			,dirent->d_name
			,isdir(dirent->d_name) ? '/':0
			);
	}
	if(dir!=NULL)
		closedir(dir);
	printf("\nFree disk space: %lu kbytes\n",getfreediskspace(path,1024));

	/* Thread (and inter-process communication) test */
	printf("\nSemaphore test\n");
	getkey();
	if(sem_init(&thread_data.parent_sem
		,0 /* shared between processes */
		,0 /* initial count */
		)) {
		printf("sem_init failed\n");
	}
	if(sem_init(&thread_data.child_sem
		,0	/* shared between processes */
		,0	/* initial count */
		)) {
		printf("sem_init failed\n");
	}
	if(_beginthread(
		  sem_test_thread	/* entry point */
		 ,0					/* stack size (0=auto) */
		 ,&thread_data		/* data */
		 )==(unsigned long)-1)
		printf("_beginthread failed\n");
	else {
		sem_wait(&thread_data.child_sem);	/* wait for thread to begin */
		for(i=0;i<10;i++) {
			printf("<parent>");
			sem_post(&thread_data.parent_sem);
			sem_wait(&thread_data.child_sem);
		}
		sem_wait(&thread_data.child_sem);	/* wait for thread to end */
	}
	sem_destroy(&thread_data.parent_sem);
	sem_destroy(&thread_data.child_sem);

	printf("\nSemaphore blocking test\n");
	getkey();
	sem_init(&thread_data.parent_sem
		,0 /* shared between processes */
		,0 /* initial count */
		);
	sem_init(&thread_data.child_sem
		,0	/* shared between processes */
		,0	/* initial count */
		);
	if(_beginthread(
		  sem_test_thread_block	/* entry point */
		 ,0					/* stack size (0=auto) */
		 ,&thread_data		/* data */
		 )==(unsigned long)-1)
		printf("_beginthread failed\n");
	else {
		sem_wait(&thread_data.child_sem);	/* wait for thread to begin */
		for(i=0;i<10;i++) {
			printf("<parent>");
			SLEEP(5000);
			sem_post(&thread_data.parent_sem);
			sem_wait(&thread_data.child_sem);
		}
		sem_wait(&thread_data.child_sem);	/* wait for thread to end */
	}
	printf("\nsem_trywait_block test...");
	t=time(NULL);
	sem_trywait_block(&thread_data.parent_sem,5000);
	printf("\ntimed-out after %ld seconds (should be 5 seconds)\n",time(NULL)-t);
	sem_destroy(&thread_data.parent_sem);
	sem_destroy(&thread_data.child_sem);
	printf("\nendian check...");
	memcpy(&i,"\x01\x02\x03\x04",4);
	if(LE_LONG(i)==67305985) {
		printf("OK!\n");
	}
	else {
		printf("FAILED!\n");
	}
	return 0;
}