Example #1
0
/* Function: al_ustr_find_set
 */
int al_ustr_find_set(const ALLEGRO_USTR *us, int start_pos,
   const ALLEGRO_USTR *accept)
{
   int rc;
   int32_t c, d;
   int pos;
   int set_pos;

   /* Fast path for ASCII characters. */
   if (all_ascii(accept)) {
      rc = _al_binchr(us, start_pos, accept);
      return (rc == _AL_BSTR_ERR) ? -1 : rc;
   }

   /* Non-ASCII. */
   pos = 0;
   while ((c = al_ustr_get(us, pos)) != -1) {
      if (c == -2) {
         /* Invalid byte sequence. */
         pos++;
         continue;
      }

      set_pos = 0;
      while ((d = al_ustr_get_next(accept, &set_pos)) != -1) {
         if (c == d)
            return pos;
      }

      pos += al_utf8_width(c);
   }

   return -1;
}
Example #2
0
File: id3.cpp Project: nu774/cafmux
    void build_comment_frame(const char *lang, const wchar_t *desc,
                             const wchar_t *value, std::vector<uint8_t> *res)
    {
        std::vector<uint8_t> vec(10), buf;
        std::memcpy(&vec[0], "COMM", 4);
        bool ascii = all_ascii(desc) && all_ascii(value);

        build_text_frame_value(desc, &buf, ascii);
        vec.push_back(buf[0]);
        std::copy(lang, lang + std::strlen(lang), std::back_inserter(vec));
        std::copy(buf.begin() + 1, buf.end(), std::back_inserter(vec));
        buf.clear();

        build_text_frame_value(value, &buf, ascii);
        std::copy(buf.begin() + 1, buf.end(), std::back_inserter(vec));

        uint32_t size = util::h2big32(vec.size() - 10);
        std::memcpy(&vec[4], &size, 4);
        res->swap(vec);
    }
Example #3
0
File: id3.cpp Project: nu774/cafmux
 void build_text_frame(const char *key, const wchar_t *value,
                  std::vector<uint8_t> *result)
 {
     std::vector<uint8_t> vec(10), buf;
     const char *name = get_id3name(key);
     if (!name)
         return;
     std::memcpy(&vec[0], name, 4);
     build_text_frame_value(value, &buf, all_ascii(value));
     uint32_t size = util::h2big32(buf.size());
     std::memcpy(&vec[4], &size, 4);
     std::copy(buf.begin(), buf.end(), std::back_inserter(vec));
     result->swap(vec);
 }
int main(int argc, char *argv[]) 
{
  char* data_buf;
  
  LimeReader *reader;
  FILE *fp;
  int status;
  n_uint64_t nbytes, read_bytes;
  int msg,rec,first;
  char *lime_type;
  size_t bytes_pad;
  int MB_flag, ME_flag;
  
  if( argc != 2 ) { 
    fprintf(stderr, "Usage: %s <lime_file>\n", argv[0]);
    return EXIT_FAILURE;
  }
  

  fp = DCAPL(fopen)(argv[1], "r");
  if(fp == (FILE *)NULL) { 
    fprintf(stderr,"Unable to open file %s for reading\n", argv[1]);
    return EXIT_FAILURE;
  }

  reader = limeCreateReader(fp);
  if( reader == (LimeReader *)NULL ) { 
    fprintf(stderr, "Unable to open LimeReader\n");
    return EXIT_FAILURE;
  }

  msg = 0; first = 1; rec = 0;
  while( (status = limeReaderNextRecord(reader)) != LIME_EOF ){
    
    if( status != LIME_SUCCESS ) { 
      fprintf(stderr, "limeReaderNextRecord returned status = %d\n", 
	      status);
      return EXIT_FAILURE;
    }

    nbytes    = limeReaderBytes(reader);
    lime_type = limeReaderType(reader);
    bytes_pad = limeReaderPadBytes(reader);
    MB_flag   = limeReaderMBFlag(reader);
    ME_flag   = limeReaderMEFlag(reader);
    
    if (MB_flag == 1 || first)
      {
	first = 0;
	rec = 0;
	msg++;
      }

    rec++;

    printf("\n\n");
    printf("Message:        %d\n", msg);
    printf("Record:         %d\n", rec);
    printf("Type:           %s\n", lime_type);
    printf("Data Length:    %llu\n", (unsigned long long)nbytes);
    printf("Padding Length: %lu\n", (unsigned long)bytes_pad);
    printf("MB flag:        %d\n", MB_flag);
    printf("ME flag:        %d\n", ME_flag);
    
    /* TO DO: Buffer the input */
    if(nbytes < MAX_BYTES){
      data_buf = (char *)malloc((size_t)nbytes+1);
      if( data_buf == (char *)NULL) { 
	fprintf(stderr, "Couldn't malloc data buf\n");
	return EXIT_FAILURE;
      }
      
      read_bytes = nbytes;
      status = limeReaderReadData((void *)data_buf, &read_bytes, reader);
      
      if( status < 0 ) { 
	if( status != LIME_EOR ) { 
	  fprintf(stderr, "LIME read error occurred: status= %d  %llu bytes wanted, %llu read\n", 
		  status, (unsigned long long)nbytes, 
		  (unsigned long long)read_bytes);
	  return EXIT_FAILURE;
	}
      }
      
      data_buf[nbytes]='\0';
      if(!all_ascii(data_buf, nbytes))
	printf("Data:           [Binary data]\n");
      else
	printf("Data:           \"%s\" \n", data_buf);
      
      free(data_buf);
    }
    else{
	printf("Data:           [Long record skipped]\n");
    }

  }

  limeDestroyReader(reader);
  DCAP(fclose)(fp);

  return EXIT_SUCCESS;

}