コード例 #1
0
static void
convert_path(String *cap, char *s, Config *c, int maxlen, int reserve)
{
  static char delimiters[] = { '/', '#', '\0' };
  char *part, **parts, *used_delim;
  int i, n;

  if ((parts = misc_str_split_delimiters(s, delimiters, &used_delim)) == NULL) {
    err_message_fnc("No enough memory.\n");
    return;
  }

  n = 0;
  while (parts[n])
    n++;

  i = 0;
  while ((part = parts[i])) {
    int over = RESERVE_LEN + string_length(cap) + strlen(part) + strlen(REPLACE_STR) + reserve / n - maxlen;
    if (maxlen > 0 && over > 0) {
      convert_cat(cap, part, c, strlen(part) - over);
      string_cat(cap, REPLACE_STR);
    } else {
      convert_cat(cap, part, c, 0);
    }
    if (used_delim[i] != '\0')
      string_cat_ch(cap, used_delim[i]);
    i++;
  }
  misc_free_str_array(parts);
  free(used_delim);
}
コード例 #2
0
static int
get_buffer(AVCodecContext *vcodec_ctx, AVFrame *vcodec_picture)
{
  VideoDecoder *vdec = (VideoDecoder *)vcodec_ctx->opaque;
  struct videodecoder_avcodec *vdm = (struct videodecoder_avcodec *)vdec->opaque;
  int width, height;
  Picture_buffer *buf;

  /* alignment */
  width  = (vcodec_ctx->width  + 15) & ~15;
  height = (vcodec_ctx->height + 15) & ~15;

  if (vcodec_ctx->pix_fmt != PIX_FMT_YUV420P ||
      width != vcodec_ctx->width || height != vcodec_ctx->height) {
    debug_message_fnc("avcodec: unsupported frame format, DR1 disabled.\n");
    vdm->vcodec_ctx->get_buffer = avcodec_default_get_buffer;
    vdm->vcodec_ctx->reget_buffer = avcodec_default_reget_buffer;
    vdm->vcodec_ctx->release_buffer = avcodec_default_release_buffer;
    return avcodec_default_get_buffer(vcodec_ctx, vcodec_picture);
  }

  buf = &vdm->picture_buffer[vdm->picture_buffer_count];
  if (buf->base == NULL) {
    int datasize = image_bpl(vdm->p) * image_height(vdm->p);
    int size = sizeof(struct pic_buf) + datasize;
    struct pic_buf *pb;

    if ((buf->base = memory_create()) == NULL) {
      err_message_fnc("No enough memory for Memory object buf->base.\n");
      return -1;
    }

    if ((pb = memory_alloc(buf->base, size)) == NULL) {
      err_message_fnc("Cannot allocate %d bytes.  No enough memory for pic_buf.\n", size);
      return -1;
    }
    pb->idx = vdm->picture_buffer_count;
    pb->mem = buf->base;
    memset(pb->data, 128, datasize);

    buf->pb = pb;
    buf->linesize[0] = image_width(vdm->p);
    buf->linesize[1] = image_width(vdm->p) >> 1;
    buf->linesize[2] = image_width(vdm->p) >> 1;
  }
コード例 #3
0
ファイル: lzma_decode.c プロジェクト: sina-ht/lib7z
void *
lzma_decoder_create(I7z_stream *st, unsigned char *prop, unsigned int propsize)
{
  ReadStream *rs;
  LZMA_Decoder *dec;

  if ((dec = calloc(1, sizeof(*dec))) == NULL) {
    err_message_fnc("No enough memory.\n");
    return NULL;
  }

  /* Decode LZMA properties and allocate memory */
  if (LzmaDecodeProperties(&dec->state.Properties, prop, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK) {
    err_message_fnc("Incorrect stream properties.\n");
    return NULL;
  }
  if ((dec->state.Probs = (CProb *)malloc(LzmaGetNumProbs(&dec->state.Properties) * sizeof(CProb))) == NULL) {
    free(dec);
    err_message_fnc("No enough memory.\n");
    return NULL;
  }
  if ((dec->state.Dictionary = (unsigned char *)malloc(dec->state.Properties.DictionarySize)) == NULL) {
    free(dec->state.Probs);
    free(dec);
    err_message_fnc("No enough memory.\n");
    return NULL;
  }

  if ((rs = calloc(1, sizeof(*rs))) == NULL) {
    err_message_fnc("No enough memory.\n");
    return NULL;
  }
  rs->InCallback.Read = read_stream;
  rs->st = st;

  LzmaDecoderInit(&dec->state);

  dec->offset = 0;
  dec->rs = rs;

  return dec;
}
コード例 #4
0
ファイル: lzma_decode.c プロジェクト: sina-ht/lib7z
int
lzma_decode(void *_dec, unsigned char *output, UINT64 *outsize)
{
  LZMA_Decoder *dec = _dec;
  UINT64 decoded;
  UINT32 kBlockSize = 0x100000;
  int result;

  decoded = 0;
  while (decoded < *outsize) {
    SizeT blocksize = *outsize - decoded;
    SizeT processed;

    if (blocksize > kBlockSize)
      blocksize = kBlockSize;
    processed = 0;
    result = LzmaDecode(&dec->state, &dec->rs->InCallback,
			output + decoded, blocksize,
			&processed);
    switch (result) {
    case 0:
      break;
    case LZMA_RESULT_DATA_ERROR:
      err_message_fnc("Data error.\n");
      return LZMA_DATA_ERROR;
    default:
      err_message_fnc("LzmaDecode returned %d.\n", result);
      return UNKNOWN_ERROR;
    }
    if (processed == 0) {
      *outsize = decoded;
      break;
    }
    debug_message_fnc("LzmaDecode() returned %d, processed = %d.\n", result, processed);
    decoded += processed;
    dec->offset += processed;
  }

  return 0;
}
コード例 #5
0
ファイル: copy_decode.c プロジェクト: sina-ht/lib7z
void *
copy_decoder_create(I7z_stream *st, unsigned char *prop, unsigned int propsize)
{
  COPY_Decoder *dec;

  if ((dec = calloc(1, sizeof(*dec))) == NULL) {
    err_message_fnc("No enough memory.\n");
    return NULL;
  }
  dec->st = st;
  dec->offset = 0;

  return dec;
}
コード例 #6
0
ファイル: multiskkserv.c プロジェクト: sina-ht/multiskkserv
static Dictionary *
open_dictionary(char *path)
{
  Dictionary *dic;

  if ((dic = calloc(1, sizeof(Dictionary))) == NULL) {
    err_message_fnc("No enough memory.\n");
    return NULL;
  }

  if ((dic->path = strdup(path)) == NULL)
    return NULL;

  if ((dic->fd = open(path, O_RDONLY)) == -1) {
    perror(PROGNAME ": open");
    return NULL;
  }

  cdb_init(&dic->cdb, dic->fd);
  pthread_mutex_init(&dic->mutex, NULL);

  return dic;
}
コード例 #7
0
static void
translate(char *remote, int port, int family, char *yomi)
{
  int sock;
  char *sstr;
  char rbuf[SKKSERV_REQUEST_SIZE];
  int read_size;

  if ((sock = socket_connect(remote, &sstr, port, (char *)SKKSERV_SERVICE, family)) < 0) {
    err_message_fnc("Cannot make a connection.\n");
    return;
  }

  snprintf(rbuf, sizeof(rbuf), "1%s ", yomi);
  write(sock, rbuf, strlen(rbuf));
  if ((read_size = read(sock, rbuf, sizeof(rbuf))) > 0) {
    rbuf[read_size] = '\0';
    printf("%s", rbuf);
  }

  free(sstr);
  close(sock);
}
コード例 #8
0
static void
show_stat(char *remote, int port, int family)
{
  int sock;
  char *sstr;
  char rbuf[SKKSERV_REQUEST_SIZE];

  if ((sock = socket_connect(remote, &sstr, port, (char *)SKKSERV_SERVICE, family)) < 0) {
    err_message_fnc("Cannot make a connection.\n");
    return;
  }

  snprintf(rbuf, sizeof(rbuf), "S\n");
  write(sock, rbuf, strlen(rbuf));
  if (read(sock, rbuf, sizeof(rbuf)) > 0) {
    int nconns, nactives;

    sscanf(rbuf, "S%d:%d", &nconns, &nactives);
    printf("%d total connections, %d connections active.\n", nconns, nactives);
  }

  free(sstr);
  close(sock);
}
コード例 #9
0
ファイル: multiskkserv.c プロジェクト: sina-ht/multiskkserv
static void
search_dictionaries(int out, Dlist *dic_list, char *rbuf)
{
  Dlist_data *dd;
  Hash *word_hash;
  char word[SKKSERV_WORD_SIZE];
  char result[SKKSERV_RESULT_SIZE];
  char tmpresult[SKKSERV_RESULT_SIZE];
  char *end;
  int i, p, r, len, rlen, ncandidates;

  if ((end = strchr(rbuf + 1, ' ')) == NULL) {
    rbuf[0] = SKKSERV_S_ERROR;
    write(out, rbuf, strlen(rbuf));
    return;
  }
  len = end - (rbuf + 1);
  memcpy(word, rbuf + 1, len);
  word[len] = '\0';

  word_hash = hash_create(HASH_SIZE);
  rlen = 1;
  ncandidates = 0;
  result[0] = SKKSERV_S_FOUND;
  dlist_iter(dic_list, dd) {
    Dictionary *dic = dlist_data(dd);

    pthread_mutex_lock(&dic->mutex);
    __cdb_findstart(dic);
    if ((r = __cdb_findnext(dic, word, len)) == -1) {
      err_message_fnc("cdb_findnext() failed.\n");
      if (!ncandidates) {
	rbuf[0] = SKKSERV_S_ERROR;
	write(out, rbuf, strlen(rbuf));
      }
      pthread_mutex_unlock(&dic->mutex);
      hash_destroy(word_hash);
      return;
    }
    debug_message_fnc("word %s, len %d, r = %d\n", word, len, r);
    if (r) {
      int dpos = cdb_datapos(&dic->cdb);
      int dlen = cdb_datalen(&dic->cdb);
      debug_message_fnc("%s found, r = %d, dpos = %d, dlen = %d.\n", word, r, dpos, dlen);
      if (rlen + dlen + 2 > SKKSERV_RESULT_SIZE) {
	err_message_fnc("Truncated: %s\n", word);
	r = SKKSERV_RESULT_SIZE - rlen - 2;
      } else {
	r = dlen;
      }
      debug_message_fnc("read %d bytes\n", r);
      if (cdb_read(&dic->cdb, tmpresult, r, dpos) == -1) {
	if (!ncandidates) {
	  err_message_fnc("cdb_read() failed.\n");
	  rbuf[0] = SKKSERV_S_ERROR;
	  write(out, rbuf, strlen(rbuf));
	  pthread_mutex_unlock(&dic->mutex);
	  hash_destroy(word_hash);
	  return;
	} else {
	  result[rlen] = '\0';
	  continue;
	}
      }

      /* Merge */
      p = 0;
      i = 1;
      while (i < r) {
	if (tmpresult[i] == '/') {
	  if (i - p - 1 > 0 &&
	      hash_define_value(word_hash, tmpresult + p + 1, i - p - 1, (void *)1) == 1) {
	    memcpy(result + rlen, tmpresult + p, i - p);
	    rlen += i - p;
	    ncandidates++;
	  }
	  p = i;
	}
	i++;
      }
    }
    pthread_mutex_unlock(&dic->mutex);
  }
コード例 #10
0
ファイル: multiskkserv.c プロジェクト: sina-ht/multiskkserv
static int
prepare_listen(char *sname, char **sstr, int port, char *service, int nbacklogs, int family)
{
  String *s;
  struct addrinfo hints, *res0, *res;
  int gs = 0;
  int opt, gaierr;
  int try_default_portnum;
  char *servername;
  char sbuf[NI_MAXSERV];
  char ipbuf[INET6_ADDRSTRLEN];
  char selfname[MAXHOSTNAMELEN + 1];

  s = string_create();

  servername = sname ? sname : strdup("localhost");

  gethostname(selfname, MAXHOSTNAMELEN);
  selfname[MAXHOSTNAMELEN] = '\0';
  string_cat(s, selfname);
  string_cat(s, ":");

  if (port > -1) {
    snprintf(sbuf, sizeof(sbuf), "%d", port);
    sbuf[sizeof(sbuf) - 1] = '\0';
    try_default_portnum = 0;
  } else {
    strncpy(sbuf, service, sizeof(sbuf));
    try_default_portnum = 1;
  }

  for (;;) {
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = family;
    hints.ai_socktype = SOCK_STREAM;
    res0 = NULL;
    if ((gaierr = getaddrinfo(servername, sbuf, &hints, &res0))) {
      if (gaierr == EAI_SERVICE && try_default_portnum) {
	snprintf(sbuf, sizeof(sbuf), "%d", SKKSERV_PORT);
	sbuf[sizeof(sbuf) - 1] = '\0';
	try_default_portnum = 0;
	continue;
      }
#ifdef HAVE_GETADDRINFO
      err_message_fnc("getaddrinfo(): %s(gaierr = %d)\n", gai_strerror(gaierr), gaierr);
#endif
      return -2;
    }
    for (res = res0; res; res = res->ai_next) {
      if (res->ai_family != AF_INET && res->ai_family != AF_INET6)
	continue;
      if ((gs = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) < 0)
	continue;
      ipbuf[0] = '\0';
#ifdef HAVE_GETNAMEINFO
      if ((gaierr = getnameinfo(res->ai_addr, res->ai_addrlen, ipbuf, sizeof(ipbuf),
				NULL, 0, NI_NUMERICHOST))) {
	err_message_fnc("getnameinfo(): %s\n", gai_strerror(gaierr));
	if (res0)
	  freeaddrinfo(res0);
	close(gs);
	return -3;
      }
#else
      {
	struct sockaddr_in *sp_v4 = (struct sockaddr_in *)&res->ai_addr;
	strncpy(ipbuf, inet_ntoa(sp_v4->sin_addr), sizeof(ipbuf));
      }
#endif
      ipbuf[sizeof(ipbuf) - 1] = '\0';
      opt = 1;
      setsockopt(gs, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
      if (bind(gs, res->ai_addr, res->ai_addrlen)) {
	perror(PROGNAME ": bind");
	close(gs);
	gs = -1;
	continue;
      }
      if (listen(gs, nbacklogs)) {
	perror(PROGNAME ": listen");
	close(gs);
	gs = -1;
	continue;
      }
      string_cat(s, ipbuf);
      string_cat(s, ":");
      break;
    }
    if (res0)
      freeaddrinfo(res0);
    break;
  }

  string_cat(s, " ");
  *sstr = strdup(string_get(s));
  string_destroy(s);

  return gs;
}
コード例 #11
0
ファイル: jasper.c プロジェクト: sina-ht/enfle
DEFINE_LOADER_PLUGIN_LOAD(p, st, vw
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, c
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, priv
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
)
{
  jas_image_t *ji;
  jas_stream_t *js;
  unsigned char *d;
  char *buf = NULL;
  int k, cmp[3];
  unsigned int i, j;
  int tlx, tly;
  int vs, hs;

  //debug_message("JasPer: load() called\n");

#ifdef IDENTIFY_BEFORE_LOAD
  {
    LoaderStatus status;

    if ((status = identify(p, st, vw, c, priv)) != LOAD_OK)
      return status;
    stream_rewind(st);
  }
#endif

  /* Read whole stream into buffer... */
  {
    char *tmp;
    int size = 0, len;
    int bufsize = 65536;

    for (;;) {
      if ((tmp = realloc(buf, bufsize)) == NULL) {
	free(buf);
	return LOAD_ERROR;
      }
      buf = tmp;
      len = stream_read(st, (unsigned char *)(buf + size), bufsize - size);
      size += len;
      if (len < bufsize - size)
	break;
      bufsize += 65536;
    }
    if ((js = jas_stream_memopen(buf, size)) == NULL) {
      free(buf);
      return LOAD_ERROR;
    }
  }

  /* loading... */
  if ((ji = jas_image_decode(js, -1, 0)) == NULL) {
    err_message_fnc("jas_image_decode() failed.\n");
    goto error_clear;
  }

  /* colorspace conversion */
  {
    jas_cmprof_t *jc;
    jas_image_t *new_ji;
    if ((jc = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)) == NULL)
      goto error_destroy_free;
    if ((new_ji = jas_image_chclrspc(ji, jc, JAS_CMXFORM_INTENT_PER)) == NULL)
      goto error_destroy_free;
    jas_image_destroy(ji);
    ji = new_ji;
  }

  jas_stream_close(js);
  free(buf);
  debug_message("JasPer: jas_image_decode() OK: (%ld,%ld)\n", jas_image_cmptwidth(ji, 0), jas_image_cmptheight(ji, 0));

  /* convert to enfle format */

  p->bits_per_pixel = 24;
  p->type = _RGB24;
  p->depth = 24;
  cmp[0] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
  cmp[1] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
  cmp[2] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
  /* dimension */
  image_width(p)  = jas_image_cmptwidth(ji, cmp[0]);
  image_height(p) = jas_image_cmptheight(ji, cmp[0]);
  image_left(p) = 0;
  image_top(p) = 0;
  image_bpl(p) = image_width(p) * 3;
  tlx = jas_image_cmpttlx(ji, cmp[0]);
  tly = jas_image_cmpttly(ji, cmp[0]);
  vs = jas_image_cmptvstep(ji, cmp[0]);
  hs = jas_image_cmpthstep(ji, cmp[0]);
  debug_message("JasPer: tlx %d tly %d vs %d hs %d ncomponents %d\n", tlx, tly, vs, hs, jas_image_numcmpts(ji));
  /* memory allocation */
  if ((d = memory_alloc(image_image(p), image_bpl(p) * image_height(p))) == NULL) {
    err_message("No enough memory (%d bytes)\n", image_bpl(p) * image_height(p));
    goto error_destroy_free;
  }

  for (i = 0; i < image_height(p); i++) {
    for (j = 0; j < image_width(p); j++) {
      for (k = 0; k < 3; k++)
	*d++ = jas_image_readcmptsample(ji, cmp[k], j, i);
    }
  }

  jas_image_destroy(ji);

  return LOAD_OK;

 error_destroy_free:
  jas_image_destroy(ji);
 error_clear:

  return LOAD_ERROR;
}
コード例 #12
0
static int
load_image(Image *p, Stream *st)
{
  unsigned char buf[BUFSIZE], *pp, *d;
  unsigned int file_size, header_size, image_size, offset_to_image;
  unsigned short int biPlanes;
  unsigned int bytes_per_pal;
  int i, c, c2, y, compress_method;

  if (stream_read(st, buf, 12) != 12)
    return 0;

  file_size = utils_get_little_uint32(&buf[0]);
  offset_to_image = utils_get_little_uint32(&buf[8]);
  if (file_size < offset_to_image)
    return 0;

  if (!stream_read_little_uint32(st, &header_size))
    return 0;
  if (header_size > 64)
    return 0;
  if (stream_read(st, buf, header_size - 4) != (int)(header_size - 4))
    return 0;

  if (header_size >= WIN_BMP_HEADER_SIZE) {
    image_width(p) = utils_get_little_uint32(&buf[0]);
    image_height(p) = utils_get_little_uint32(&buf[4]);
    biPlanes = utils_get_little_uint16(&buf[8]);
    p->bits_per_pixel = utils_get_little_uint16(&buf[10]);
  } else {
    image_width(p) = utils_get_little_uint16(&buf[0]);
    image_height(p) = utils_get_little_uint16(&buf[2]);
    biPlanes = utils_get_little_uint16(&buf[4]);
    p->bits_per_pixel = utils_get_little_uint16(&buf[6]);
  }

  if (biPlanes != 1)
    return 0;
  if (image_width(p) > 10000 || image_height(p) > 10000)
    return 0;

  switch (p->bits_per_pixel) {
  case 1:
    p->type = _BITMAP_MSBFirst; /* XXX: check order */
    p->depth = p->bits_per_pixel;
    break;
  case 4:
    p->type = _INDEX44;
    p->depth = 4;
    break;
  case 8:
    p->type = _INDEX;
    p->depth = 8;
    break;
  case 16:
    p->type = _RGB555;
    p->depth = 16;
    break;
  case 24:
    p->type = _BGR24;
    p->depth = 24;
    break;
  case 32:
    p->type = _BGRA32;
    p->depth = 24;
    break;
  default:
    show_message("bmp: read_header: unknown bpp %d detected.\n", p->bits_per_pixel);
    return 0;
  }

  compress_method = 0;
  if (header_size >= WIN_BMP_HEADER_SIZE) {
    compress_method = utils_get_little_uint16(&buf[12]);
    image_size = utils_get_little_uint32(&buf[16]);
    image_size = image_size; // dummy
  }
  /* other header informations are intentionally ignored */

  if (p->depth <= 8) {
    p->ncolors = 1 << p->depth;
    bytes_per_pal = (header_size >= WIN_BMP_HEADER_SIZE) ? 4 : 3;
    if (p->ncolors * bytes_per_pal > BUFSIZE) {
      err_message_fnc("BUFSIZE is too small.  It must be greater than %d.\n", p->ncolors * bytes_per_pal);
      return 0;
    }
    if (stream_read(st, buf, p->ncolors * bytes_per_pal) != (int)(p->ncolors * bytes_per_pal))
      return 0;
    for (i = 0; i < (int)p->ncolors; i++) {
      p->colormap[i][0] = buf[bytes_per_pal * i + 2];
      p->colormap[i][1] = buf[bytes_per_pal * i + 1];
      p->colormap[i][2] = buf[bytes_per_pal * i + 0];
    }
  } else if (p->depth == 16 && compress_method == 3) {
    /* Read bitmasks */
    if (stream_read(st, buf, 3 * 4) != 3 * 4)
      return 0;
    unsigned int rm = utils_get_little_uint32(buf);
    unsigned int gm = utils_get_little_uint32(buf + 4);
    unsigned int bm = utils_get_little_uint32(buf + 8);
    if (rm == 0xf800)
      p->type = _RGB565;
    else if (rm == 0x7c00)
      p->type = _RGB555;
    else
      warning_fnc("Mask: R %X G %X B %X is not supported\n", rm, gm, bm);
    compress_method = 0;
  }

  image_bpl(p) = (image_width(p) * p->bits_per_pixel) >> 3;
  image_bpl(p) += (4 - (image_bpl(p) % 4)) % 4;

  debug_message_fnc("(%d, %d): bpp %d depth %d compress %d\n", image_width(p), image_height(p), p->bits_per_pixel, p->depth, compress_method);

  if ((d = memory_alloc(image_image(p), image_bpl(p) * image_height(p))) == NULL)
    return 0;

  stream_seek(st, offset_to_image, _SET);
  pp = d + image_bpl(p) * (image_height(p) - 1);

  switch (compress_method) {
  case BI_RGB:
    for (i = (int)(image_height(p) - 1); i >= 0; i--) {
      stream_read(st, pp, image_bpl(p));
      pp -= image_bpl(p);
    }
    break;
  case BI_RLE4:
    if (p->depth != 4)
      show_message("Compressed RI_BLE4 bitmap with depth %d != 4.\n", p->depth);
    /* RLE compressed data */
    /* Not complete. */
    y = image_height(p);
    while ((c = stream_getc(st)) != -1 && y >= 0) {
      if (c != 0) {
        /* code mode */
        c2 = stream_getc(st);
	show_message_fnc("len %d data %d\n", c, c2);
        for (i = 0; i < c; i += 2) {
	  *pp++ = (unsigned char)c2;
        }
      } else {
	if ((c = stream_getc(st)) == 0) {
	  /* line end */
	  show_message_fnc("line end %d\n", y);
	  pp = d + image_bpl(p) * (y - 1);
	  y--;
	} else if (c == 1) {
	  /* image end */
	  break;
	} else if (c == 2) {
	  /* offset */
	  c = stream_getc(st);
	  c2 = stream_getc(st);
	  show_message_fnc("offset %d, %d\n", c, c2);
	  pp += (c - c2 * image_width(p)) / 2;
	} else {
	  /* absolute mode */
	  show_message_fnc("abs len %d\n", c);
	  for (i = 0; i < c; i += 2)
	    *pp++ = (unsigned char)stream_getc(st);
	  if (c % 2 != 0)
	    /* read dummy */
	    c = stream_getc(st);
	}
      }
    }
    break;
  case BI_RLE8:
    if (p->depth != 8)
      show_message("Compressed RI_BLE8 bitmap with depth %d != 8.\n", p->depth);
    /* RLE compressed data */
    y = image_height(p);
    while ((c = stream_getc(st)) != -1 && y >= 0) {
      if (c != 0) {
	/* code mode */
	c2 = stream_getc(st);
	for (i = 0; i < c; i++) {
	  *pp++ = (unsigned char)c2;
	}
      } else {
	if ((c = stream_getc(st)) == 0) {
	  /* line end */
	  pp = d + image_bpl(p) * (y - 1);
	  y--;
	} else if (c == 1) {
	  /* image end */
	  break;
	} else if (c == 2) {
	  /* offset */
	  c = stream_getc(st);
	  c2 = stream_getc(st);
	  pp += (c - c2 * image_width(p));
	} else {
	  /* absolute mode */
	  for (i = 0; i < c; i++)
	    *pp++ = (unsigned char)stream_getc(st);
	  if (c % 2 != 0)
	    /* read dummy */
	    c = stream_getc(st);
	}
      }
    }
    break;
  default:
    show_message("Compressed bitmap (method = %d) not supported.\n", compress_method);
    return 0;
  }

  return 1;
}
コード例 #13
0
int
main(int argc, char **argv)
{
  extern char *optarg;
  extern int optind;
  char *optstr;
  char *servername = NULL;
  char *yomi = NULL;
  int ch;
  int port = -1;
  int family = AF_INET;

  optstr = gen_optstring(options);
  while ((ch = getopt(argc, argv, optstr)) != -1) {
    switch (ch) {
    case 'h':
      usage();
      return 0;
    case 's':
      servername = strdup(optarg);
      break;
    case 'p':
      port = atoi(optarg);
      if (port < 0 || port > 65535) {
	err_message_fnc("Invalid port number(%d).\n", port);
	return INVALID_PORT_ERROR;
      }
      break;
    case 'f':
      if (strcasecmp("INET", optarg) == 0)
	family = AF_INET;
      else if (strcasecmp("INET6", optarg) == 0)
	family = AF_INET6;
      else if (strcasecmp("UNSPEC", optarg) == 0)
	family = AF_UNSPEC;
      else if (strcasecmp("4", optarg) == 0)
	family = AF_INET;
      else if (strcasecmp("6", optarg) == 0)
	family = AF_INET6;
      else if (strcasecmp("IPv4", optarg) == 0)
	family = AF_INET;
      else if (strcasecmp("IPv6", optarg) == 0)
	family = AF_INET6;
      else {
	err_message_fnc("Invalid family(%s).\n", optarg);
	return INVALID_FAMILY_ERROR;
      }
      break;
    case 'y':
      yomi = strdup(optarg);
      break;
    default:
      usage();
      return 0;
    }
  }
  free(optstr);

  if (optind == argc) {
    usage();
    return 0;
  }

  if (strcasecmp(argv[optind], "help") == 0) {
    usage();
  } else if (strcasecmp(argv[optind], "stat") == 0) {
    if (!servername)
      servername = strdup("localhost");
    show_stat(servername, port, family);
    free(servername);
  } else if (strcasecmp(argv[optind], "tran") == 0 && yomi) {
    if (!servername)
      servername = strdup("localhost");
    translate(servername, port, family, yomi);
    free(servername);
  } else {
    usage();
    return 1;
  }

  return 0;
}
コード例 #14
0
static int
set_params(AudioDevice *ad, AudioFormat *format_p, int *ch_p, unsigned int *rate_p)
{
  ALSA_data *alsa = (ALSA_data *)ad->private_data;
  int r, err;
  snd_pcm_format_t f;
  AudioFormat format = *format_p;
  snd_pcm_hw_params_t *hwparams;
  snd_pcm_sw_params_t *swparams;
  int ch = *ch_p;
  unsigned int rate = *rate_p;
  unsigned int buffer, period;

  snd_pcm_hw_params_alloca(&hwparams);
  snd_pcm_sw_params_alloca(&swparams);

  ad->format = _AUDIO_FORMAT_UNSET;
  *format_p = _AUDIO_FORMAT_UNSET;
  *ch_p = 0;
  *rate_p = 0;

  /* format part */
  switch (format) {
  case _AUDIO_FORMAT_MU_LAW:
    f = SND_PCM_FORMAT_MU_LAW;
    break;
  case _AUDIO_FORMAT_A_LAW:
    f = SND_PCM_FORMAT_A_LAW;
    break;
  case _AUDIO_FORMAT_ADPCM:
    f = SND_PCM_FORMAT_IMA_ADPCM;
    break;
  case _AUDIO_FORMAT_U8:
    f = SND_PCM_FORMAT_U8;
    break;
  case _AUDIO_FORMAT_S8:
    f = SND_PCM_FORMAT_S8;
    break;
  case _AUDIO_FORMAT_U16_LE:
    f = SND_PCM_FORMAT_U16_LE;
    break;
  case _AUDIO_FORMAT_U16_BE:
    f = SND_PCM_FORMAT_U16_BE;
    break;
  case _AUDIO_FORMAT_S16_LE:
    f = SND_PCM_FORMAT_S16_LE;
    break;
  case _AUDIO_FORMAT_S16_BE:
    f = SND_PCM_FORMAT_S16_BE;
    break;
#if 0
  case _AUDIO_FORMAT_S32_LE:
    f = SND_PCM_FORMAT_U32_LE;
    break;
  case _AUDIO_FORMAT_S32_BE:
    f = SND_PCM_FORMAT_S32_BE;
    break;
#endif
  default:
    show_message_fnc("format %d is invalid.\n", format);
    return 0;
  }

  if ((err = snd_pcm_hw_params_any(alsa->fd, hwparams)) < 0) {
    show_message_fnc("snd_pcm_hw_params_any() failed.\n");
    return 0;
  }

  if ((err = snd_pcm_hw_params_set_access(alsa->fd, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_access() failed.\n");
    return 0;
  }

  if ((err = snd_pcm_hw_params_set_format(alsa->fd, hwparams, f)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_format() failed.\n");
    return 0;
  }
  ad->format = format;
  *format_p = format;

  /* channel part */
  if ((err = snd_pcm_hw_params_set_channels(alsa->fd, hwparams, ch)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_channels() failed.\n");
    return 0;
  }
  *ch_p = ch;

  /* rate part */
  if ((err = snd_pcm_hw_params_set_rate_near(alsa->fd, hwparams, &rate, 0)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_rate_near() failed.\n");
    return 0;
  }
  *rate_p = rate;

  /* buffer & period */
  buffer = 500000;
  period = 500000 / 4;
  if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa->fd, hwparams, &buffer, 0)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_buffer_near() failed.\n");
    return 0;
  }
  r = snd_pcm_hw_params_get_buffer_size(hwparams, &alsa->buffer_size);
  if ((err = snd_pcm_hw_params_set_period_time_near(alsa->fd, hwparams, &period, 0)) < 0) {
    show_message_fnc("snd_pcm_hw_params_set_period_near() failed.\n");
    return 0;
  }
  r = snd_pcm_hw_params_get_period_size(hwparams, &alsa->period_size, 0);

  if ((err = snd_pcm_hw_params(alsa->fd, hwparams)) < 0) {
    perror("snd_pcm_hw_params");
    err_message_fnc("snd_pcm_hw_params() failed.\n");
    snd_pcm_hw_params_dump(hwparams, alsa->log);
    return 0;
  }

  r = snd_pcm_hw_params_get_channels(hwparams, &ad->channels);
  r = snd_pcm_hw_params_get_rate(hwparams, &ad->speed, 0);
  r = r; // dummy

#ifdef DEBUG
  {
    snd_pcm_format_t form;

    debug_message_fnc("format ");
    r = snd_pcm_hw_params_get_format(hwparams, &form);
    switch (form) {
    case SND_PCM_FORMAT_MU_LAW:    debug_message("MU_LAW "); break;
    case SND_PCM_FORMAT_A_LAW:     debug_message("A_LAW "); break;
    case SND_PCM_FORMAT_IMA_ADPCM: debug_message("ADPCM "); break;
    case SND_PCM_FORMAT_U8:        debug_message("U8 "); break;
    case SND_PCM_FORMAT_S8:        debug_message("S8 "); break;
    case SND_PCM_FORMAT_U16_LE:    debug_message("U16LE "); break;
    case SND_PCM_FORMAT_U16_BE:    debug_message("U16BE "); break;
    case SND_PCM_FORMAT_S16_LE:    debug_message("S16LE "); break;
    case SND_PCM_FORMAT_S16_BE:    debug_message("S16BE "); break;
#if 0
    case SND_PCM_FORMAT_U32_LE:    debug_message("U32LE "); break;
    case SND_PCM_FORMAT_S32_BE:    debug_message("S32BE "); break;
#endif
    default:                       debug_message("UNKNOWN "); break;
    }

    debug_message("%d ch %d Hz buffer %ld period %ld OK\n", ad->channels, ad->speed, alsa->buffer_size, alsa->period_size);
  }
#endif

  /* sw_params */
  if ((err = snd_pcm_sw_params_current(alsa->fd, swparams)) < 0) {
    show_message_fnc("snd_pcm_sw_params_any() failed.\n");
    return 0;
  }
  if ((err = snd_pcm_sw_params(alsa->fd, swparams)) < 0) {
    show_message_fnc("snd_pcm_sw_params() failed.\n");
    return 0;
  }

  debug_message_fnc("1 sample -> %ld bytes\n", snd_pcm_samples_to_bytes(alsa->fd, 1));

  return 1;
}