/**
* Returns the size of a file.
*/
size_t BLI_file_size(const char *path)
{
BLI_stat_t stats;
if (BLI_stat(path, &stats) == -1)
return -1;
return stats.st_size;
}
int imb_get_anim_type(const char *name)
{
int type;
struct stat st;
if (UTIL_DEBUG) printf("in getanimtype: %s\n", name);
#ifndef _WIN32
# ifdef WITH_QUICKTIME
if (isqtime(name)) return (ANIM_QTIME);
# endif
# ifdef WITH_FFMPEG
/* stat test below fails on large files > 4GB */
if (isffmpeg(name)) return (ANIM_FFMPEG);
# endif
if (BLI_stat(name, &st) == -1) return(0);
if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
if (isavi(name)) return (ANIM_AVI);
if (ismovie(name)) return (ANIM_MOVIE);
#else
if (BLI_stat(name, &st) == -1) return(0);
if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
if (ismovie(name)) return (ANIM_MOVIE);
# ifdef WITH_QUICKTIME
if (isqtime(name)) return (ANIM_QTIME);
# endif
# ifdef WITH_FFMPEG
if (isffmpeg(name)) return (ANIM_FFMPEG);
# endif
if (isavi(name)) return (ANIM_AVI);
#endif
#ifdef WITH_REDCODE
if (isredcode(name)) return (ANIM_REDCODE);
#endif
type = IMB_ispic(name);
if (type) {
return ANIM_SEQUENCE;
}
return ANIM_NONE;
}
int autocomplete_directory(struct bContext *C, char *str, void *UNUSED(arg_v))
{
SpaceFile *sfile = CTX_wm_space_file(C);
int match = AUTOCOMPLETE_NO_MATCH;
/* search if str matches the beginning of name */
if (str[0] && sfile->files) {
char dirname[FILE_MAX];
DIR *dir;
struct dirent *de;
BLI_split_dir_part(str, dirname, sizeof(dirname));
dir = opendir(dirname);
if (dir) {
AutoComplete *autocpl = autocomplete_begin(str, FILE_MAX);
while ((de = readdir(dir)) != NULL) {
if (strcmp(".", de->d_name) == 0 || strcmp("..", de->d_name) == 0) {
/* pass */
}
else {
char path[FILE_MAX];
BLI_stat_t status;
BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
if (BLI_stat(path, &status) == 0) {
if (S_ISDIR(status.st_mode)) { /* is subdir */
autocomplete_do_name(autocpl, path);
}
}
}
}
closedir(dir);
match = autocomplete_end(autocpl, str);
if (match) {
if (match == AUTOCOMPLETE_FULL_MATCH) {
BLI_add_slash(str);
}
else {
BLI_strncpy(sfile->params->dir, str, sizeof(sfile->params->dir));
}
}
}
}
return match;
}
int IMB_ispic_type(const char *name)
{
/* increased from 32 to 64 because of the bitmaps header size */
#define HEADER_SIZE 64
unsigned char buf[HEADER_SIZE];
const ImFileType *type;
BLI_stat_t st;
int fp;
BLI_assert(!BLI_path_is_rel(name));
if (UTIL_DEBUG) printf("%s: loading %s\n", __func__, name);
if (BLI_stat(name, &st) == -1)
return false;
if (((st.st_mode) & S_IFMT) != S_IFREG)
return false;
if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) == -1)
return false;
memset(buf, 0, sizeof(buf));
if (read(fp, buf, HEADER_SIZE) <= 0) {
close(fp);
return false;
}
close(fp);
/* XXX move this exception */
if ((BIG_LONG(((int *)buf)[0]) & 0xfffffff0) == 0xffd8ffe0)
return IMB_FTYPE_JPG;
for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
if (type->is_a) {
if (type->is_a(buf)) {
return type->filetype;
}
}
else if (type->is_a_filepath) {
if (type->is_a_filepath(name)) {
return type->filetype;
}
}
}
return 0;
#undef HEADER_SIZE
}
int checkPackedFile(const char *filename, PackedFile *pf)
{
BLI_stat_t st;
int ret_val, i, len, file;
char buf[4096];
char name[FILE_MAX];
BLI_strncpy(name, filename, sizeof(name));
BLI_path_abs(name, G.main->name);
if (BLI_stat(name, &st) == -1) {
ret_val = PF_NOFILE;
}
else if (st.st_size != pf->size) {
ret_val = PF_DIFFERS;
}
else {
/* we'll have to compare the two... */
file = BLI_open(name, O_BINARY | O_RDONLY, 0);
if (file == -1) {
ret_val = PF_NOFILE;
}
else {
ret_val = PF_EQUAL;
for (i = 0; i < pf->size; i += sizeof(buf)) {
len = pf->size - i;
if (len > sizeof(buf)) {
len = sizeof(buf);
}
if (read(file, buf, len) != len) {
/* read error ... */
ret_val = PF_DIFFERS;
break;
}
else {
if (memcmp(buf, ((char *)pf->data) + i, len)) {
ret_val = PF_DIFFERS;
break;
}
}
}
close(file);
}
}
return(ret_val);
}
/**
* Scans the directory named *dirname and appends entries for its contents to files.
*/
static void bli_builddir(struct BuildDirCtx *dir_ctx, const char *dirname)
{
struct ListBase dirbase = {NULL, NULL};
int newnum = 0;
DIR *dir;
if ((dir = opendir(dirname)) != NULL) {
const struct dirent *fname;
while ((fname = readdir(dir)) != NULL) {
struct dirlink * const dlink = (struct dirlink *)malloc(sizeof(struct dirlink));
if (dlink != NULL) {
dlink->name = BLI_strdup(fname->d_name);
BLI_addhead(&dirbase, dlink);
newnum++;
}
}
if (newnum) {
if (dir_ctx->files) {
void * const tmp = MEM_reallocN(dir_ctx->files, (dir_ctx->nrfiles + newnum) * sizeof(struct direntry));
if (tmp) {
dir_ctx->files = (struct direntry *)tmp;
}
else { /* realloc fail */
MEM_freeN(dir_ctx->files);
dir_ctx->files = NULL;
}
}
if (dir_ctx->files == NULL)
dir_ctx->files = (struct direntry *)MEM_mallocN(newnum * sizeof(struct direntry), __func__);
if (dir_ctx->files) {
struct dirlink * dlink = (struct dirlink *) dirbase.first;
struct direntry *file = &dir_ctx->files[dir_ctx->nrfiles];
while (dlink) {
char fullname[PATH_MAX];
memset(file, 0, sizeof(struct direntry));
file->relname = dlink->name;
file->path = BLI_strdupcat(dirname, dlink->name);
BLI_join_dirfile(fullname, sizeof(fullname), dirname, dlink->name);
if (BLI_stat(fullname, &file->s) != -1) {
file->type = file->s.st_mode;
}
file->flags = 0;
dir_ctx->nrfiles++;
file++;
dlink = dlink->next;
}
}
else {
printf("Couldn't get memory for dir\n");
exit(1);
}
BLI_freelist(&dirbase);
if (dir_ctx->files) {
qsort(dir_ctx->files, dir_ctx->nrfiles, sizeof(struct direntry), (int (*)(const void *, const void *))bli_compare);
}
}
else {
printf("%s empty directory\n", dirname);
}
closedir(dir);
}
else {
printf("%s non-existent directory\n", dirname);
}
}
