void qsort2(long int **V, long int l, long int r) { if (r <= l) return; long int p = partition(V, l, r); qsort2(V, l, p - 1); qsort2(V, p + 1, r); }
// 改进版快速排序,随机选取枢纽元 static void qsort2(int data[], int left, int right) { if (left < right) { // int pos = rand() % (right - left + 1) + left; // swap2(data, left, pos); int i = partition2(data, left, right); qsort2(data, left, i - 1); qsort2(data, i + 1, right); } }
void matrix_sort_rows_with_sat(pk_internal_t* pk, matrix_t* mat, satmat_t* sat) { size_t i; qsort_t* qsort_tab; qsort_man_t qsort_man; if (!mat->_sorted) { qsort_man.pk = pk; qsort_man.size = mat->nbcolumns; qsort_tab = (qsort_t*)malloc(mat->nbrows * sizeof(qsort_t)); for (i=0; i<mat->nbrows; i++) { qsort_tab[i].p = mat->p[i]; qsort_tab[i].satp = sat->p[i]; } qsort2(qsort_tab, mat->nbrows, sizeof(qsort_t), qsort_rows_with_sat_compar, &qsort_man); for (i=0; i<mat->nbrows; i++) { mat->p[i] = qsort_tab[i].p; sat->p[i] = qsort_tab[i].satp; } free(qsort_tab); mat->_sorted = true; } }
int main(int argc, char *argv[]){ char numeric = 0; char reverse = 0; char caseInsensitive = 0; int nlines; char lines[MAXLINES*MAXLEN]; int arg = 1; while(arg < argc){ if(strcmp(argv[arg], "-n") == 0){ numeric = 1; } else if(strcmp(argv[arg], "-r") == 0){ reverse = 1; } else if(strcmp(argv[arg], "-f") == 0){ caseInsensitive = 1; } arg++; } if((nlines = readlines(linesptr, lines, MAXLINES)) >= 0){ qsort2((void **) linesptr, 0, nlines-1, (numeric ? numcmp : caseInsensitive ? strcasecmp : strcmp)); writelines(linesptr, nlines, reverse); return 0; } else { printf("input too big to sort\n"); return 1; } }
signed short median (signed short *a, int n) { /* a: pointer to start of array */ qsort2 (a, n); /* n: # elements in array */ return a[((n + 1) / 2) - 1]; /* (10+1)/2 = 5 (11+1)/2 = 6 */ }
void qsort2(void *linesptr[], int left, int right, int (*comp)(const char *, const char *)){ int i,indPivot; if(left >= right) return; indPivot=left; for(i=indPivot+1; i<=right; i++){ if((*comp)(linesptr[i], linesptr[indPivot]) < 0){ swap(linesptr, indPivot, i); } qsort2(linesptr,left,indPivot-1, comp); qsort2(linesptr, indPivot+1,right, comp); } }
void qsort(void *base, long n, long size, int (*cmp)(const void *,const void *)) { qsort2(base, 0, n-1, size, cmp); }
/* qsort2: sort v[left]...v[right] into increasing order */ void qsort2(char *v[], int left, int right) { int i, last; void swap(char *v[], int i, int j); if (left >= right) /* do nothing if array contains */ return; /* fewer than two elements */ swap(v, left, (left + right)/2); last = left; for (i = left+1; i <= right; i++) if (strcmp(v[i], v[left]) < 0) swap(v, ++last, i); swap(v, left, last); qsort2(v, left, last-1); qsort2(v, last+1, right); }
/* qsort: sort v[left]...v[right] into increasing order */ void qsort2(struct employee * v[], int left, int right) { int i, last; void swap(struct employee * v[], int i, int j); if (left >= right) /* do nothing if array contains */ return; /* fewer than two elements */ swap(v, left, (left + right)/2); /* move partition elem */ last = left; /* to v[0] */ for (i = left + 1; i <= right; i++) /* partition */ if (strncmp(v[i]->name, v[left]->name, 4) < 0) swap(v, ++last, i); swap(v, left, last); /* restore partition elem */ qsort2(v, left, last-1); qsort2(v, last+1, right); }
void qsort2 (register int l, register int r, char *a[], off_t * siz,MPEG_HEAD * inf) { register int i, j; char *w; char x[256]; off_t s; MPEG_HEAD mh; strncpy (x, a[(l + r) / 2], 254); i = l; j = r; while (i <= j) { while (my_strcmp (a[i], x) < 0) i++; while (my_strcmp (a[j], x) > 0) j--; if (i <= j) { w = a[i]; a[i] = a[j]; a[j] = w; s = siz[i]; siz[i] = siz[j]; siz[j] = s; if (inf) { mh = inf[i]; inf[i] = inf[j]; inf[j] = mh; } i++; j--; } } if (l < j) qsort2 (l, j, a, siz, inf); if (i < r) qsort2 (i, r, a, siz, inf); } //qsort2
template < typename RandomAccessIterator, typename Predicate > inline static void qsort2(RandomAccessIterator left, RandomAccessIterator right, const int min_size, const Predicate pred) { if (left >= right) return; auto pivot = left + std::distance(left, right) / 2; auto store = partition(left, right, pivot, pred); if (std::distance(left, store - 1) <= min_size) { insertion_sort(left, store, pred); } else { qsort2(left, store - 1, min_size, pred); } if (std::distance(store + 1, right) <= min_size) { insertion_sort(store + 1, right + 1, pred); } else { qsort2(store + 1, right, min_size, pred); } }
//Modified from K&R static void qsort2(void *base, long left, long right, long size, int (*cmp)(const void *,const void *)) { int i, last; char *base2=(char*)base, *pivot; if(left >= right) return; QsortSwap(base2, left, (left + right)/2, size); last = left; pivot = &base2[left*size]; for(i = left + 1; i <= right; ++i) { if(cmp(&base2[i*size], pivot) < 0) QsortSwap(base2, ++last, i, size); } QsortSwap(base2, left, last, size); qsort2(base, left, last-1, size, cmp); qsort2(base, last+1, right, size, cmp); }
void qsort2(void *v[], int left, int right, int (*comp)(void *, void *)) { int i, last; if(left >= right) return; swap(v, left, (left+right)/2); last = left; for(i = left + 1; i <= right; ++i){ if((*comp)(v[i], v[left]) < 0) swap(v, ++last, i); } swap(v, left, last); qsort2(v, left, last - 1, comp); qsort2(v, last + 1, right, comp); return; }
void qsort2 (signed short *a, int n) /* a: pointer to start of array */ { /* n: # elements in array */ int i, j; signed short x, w; do { i = 0; j = n - 1; x = a[j / 2]; do { while (a[i] < x) i++; while (a[j] > x) j--; if (i > j) break; w = a[i]; a[i] = a[j]; a[j] = w; } while (++i <= --j); if (j + 1 < n - i) { if (j > 0) qsort2 (a, j + 1); a += i; n -= i; } else { if (i < n - 1) qsort2 (a + i, n - i); n = j + 1; } } while (n > 1); }
/* sort input lines */ int main() { int nlines; /* number of input lines read */ if ((nlines = readlines(lineptr, MAXLINES)) >= 0) { qsort2(lineptr, 0, nlines-1); writelines(lineptr, nlines); return 0; } else { printf("error: input too big to sort\n"); return 1; } }
int main() { int a[] = {3,1,3,2,5,2}; int b[] = {3,1,3,2,5,2}; qsort(a, sizeof(a)/sizeof(a[0])); qsort2(b, sizeof(b)/sizeof(b[0])); for(int i = 0; i < sizeof(a)/sizeof(a[0]); ++i) printf("%d\t", a[i]); printf("\n"); for(int i = 0; i < sizeof(b)/sizeof(b[0]); ++i) printf("%d\t", b[i]); printf("\n"); return 0; }
void matrix_sort_rows(pk_internal_t* pk, matrix_t* mat) { qsort_man_t qsort_man; if (!mat->_sorted) { qsort_man.pk = pk; qsort_man.size = mat->nbcolumns; qsort2(mat->p, mat->nbrows, sizeof(numint_t*), qsort_rows_compar, &qsort_man); mat->_sorted = true; } }
void sort(int argc, char *argv[]) { int nlines = 0; int numberic = 0; char *pargv; int i; if(argc >= 2){ for(i = 1; i < argc; ++i){ pargv = argv[i]; if(strcmp(pargv, "-n") == 0) numberic = 1; else if(strcmp(pargv, "-d") == 0) g_directory_sort = 1; else if(strcmp(pargv, "-r") == 0) g_reverse_flag = 1; else if(strcmp(pargv, "-f") == 0) g_ignore_case = 1; else if(strncmp(pargv, "-F", 2) == 0){ g_field_sort = atof(pargv+2); } else if(strncmp(pargv, "-df", 2) == 0){ g_directory_sort = 1; g_ignore_case = 1; } else ; } } printf("numberic:%d, g_directory_sort:%d, g_reverse_flag:%d, g_ignore_case:%d, g_field_sort:%d\n", numberic, g_directory_sort,g_reverse_flag,g_ignore_case,g_field_sort); if((nlines = readlines2(lineptr, MAXLINES)) > 0){ qsort2(lineptr, 0, nlines - 1, (int (*)(void *, void *))(numberic ? numcmp : strcmp2)); writelines(lineptr, nlines); }else{ printf("input too big to sort!\n"); } return; }
int write_nemesis(std::string &nemI_out_file, Machine_Description* machine, Problem_Description* problem, Mesh_Description<INT>* mesh, LB_Description<INT>* lb, Sphere_Info* sphere) { int exoid; char title[MAX_LINE_LENGTH+1], method1[MAX_LINE_LENGTH+1]; char method2[MAX_LINE_LENGTH+1]; int cpu_ws = sizeof(float); int io_ws = sizeof(float); printf("Outputting load balance to file %s\n", nemI_out_file.c_str()); /* Create the load balance file */ /* Attempt to create a netcdf4-format file; if it fails, then assume that the netcdf library does not support that mode and fall back to classic netcdf3 format. If that fails, issue an error and return failure. */ int mode3 = EX_CLOBBER; int mode4 = mode3|EX_NETCDF4|EX_NOCLASSIC|problem->int64db|problem->int64api; ex_opts(EX_DEFAULT); // Eliminate misleading error if the first ex_create fails, but the second succeeds. if((exoid=ex_create(nemI_out_file.c_str(), mode4, &cpu_ws, &io_ws)) < 0) { /* If int64api or int64db non-zero, then netcdf-4 format is required, so fail now... */ if (problem->int64db|problem->int64api) { Gen_Error(0, "fatal: failed to create Nemesis netcdf-4 file"); return 0; } if((exoid=ex_create(nemI_out_file.c_str(), mode3, &cpu_ws, &io_ws)) < 0) { Gen_Error(0, "fatal: failed to create Nemesis file"); return 0; } } ON_BLOCK_EXIT(ex_close, exoid); /* Set the error reporting value */ if (error_lev > 1) ex_opts(EX_VERBOSE | EX_DEBUG); else ex_opts(EX_VERBOSE); /* Enable compression (if netcdf-4) */ ex_set_option(exoid, EX_OPT_COMPRESSION_LEVEL, 1); ex_set_option(exoid, EX_OPT_COMPRESSION_SHUFFLE, 1); /* Create the title */ if(problem->type == NODAL) strcpy(method1, "nodal"); else strcpy(method1, "elemental"); sprintf(title, "nem_slice %s load balance file", method1); strcpy(method1, "method1: "); strcpy(method2, "method2: "); switch(lb->type) { case MULTIKL: strcat(method1, "Multilevel-KL decomposition"); strcat(method2, "With Kernighan-Lin refinement"); break; case SPECTRAL: strcat(method1, "Spectral decomposition"); break; case INERTIAL: strcat(method1, "Inertial decomposition"); break; case ZPINCH: strcat(method1, "ZPINCH decomposition"); break; case BRICK: strcat(method1, "BRICK decomposition"); break; case ZOLTAN_RCB: strcat(method1, "RCB decomposition"); break; case ZOLTAN_RIB: strcat(method1, "RIB decomposition"); break; case ZOLTAN_HSFC: strcat(method1, "HSFC decomposition"); break; case LINEAR: strcat(method1, "Linear decomposition"); break; case RANDOM: strcat(method1, "Random decomposition"); break; case SCATTERED: strcat(method1, "Scattered decomposition"); break; } if(lb->refine == KL_REFINE && lb->type != MULTIKL) strcat(method2, "with Kernighan-Lin refinement"); else if(lb->type != MULTIKL) strcat(method2, "no refinement"); switch(lb->num_sects) { case 1: strcat(method1, " via bisection"); break; case 2: strcat(method1, " via quadrasection"); break; case 3: strcat(method1, " via octasection"); break; } /* Do some sorting */ for(int proc=0; proc < machine->num_procs; proc++) { /* Sort node maps */ gds_qsort(TOPTR(lb->int_nodes[proc]), lb->int_nodes[proc].size()); if(problem->type == NODAL) { sort2(lb->ext_nodes[proc].size(), TOPTR(lb->ext_nodes[proc]), TOPTR(lb->ext_procs[proc])); } /* Sort element maps */ gds_qsort(TOPTR(lb->int_elems[proc]), lb->int_elems[proc].size()); } /* Output the info records */ char *info[3]; info[0] = title; info[1] = method1; info[2] = method2; if(ex_put_info(exoid, 3, info) < 0) Gen_Error(0, "warning: output of info records failed"); /* Generate a QA record for the utility */ time_t time_val = time(nullptr); char *ct_ptr = asctime(localtime(&time_val)); char tm_date[30]; strcpy(tm_date, ct_ptr); /* Break string with null characters */ tm_date[3] = '\0'; tm_date[7] = '\0'; tm_date[10] = '\0'; tm_date[19] = '\0'; char qa_date[15], qa_time[10], qa_name[MAX_STR_LENGTH]; char qa_vers[10]; sprintf(qa_date, "%s %s %s", &tm_date[8], &tm_date[4], &tm_date[20]); sprintf(qa_time, "%s", &tm_date[11]); strcpy(qa_name, UTIL_NAME); strcpy(qa_vers, ELB_VERSION); if(qa_date[strlen(qa_date)-1] == '\n') qa_date[strlen(qa_date)-1] = '\0'; char **lqa_record = (char **)array_alloc(1, 4, sizeof(char *)); for(int i2=0; i2 < 4; i2++) lqa_record[i2] = (char *)array_alloc(1, MAX_STR_LENGTH+1, sizeof(char)); strcpy(lqa_record[0], qa_name); strcpy(lqa_record[1], qa_vers); strcpy(lqa_record[2], qa_date); strcpy(lqa_record[3], qa_time); printf("QA Record:\n"); for(int i2=0; i2 < 4; i2++) { printf("\t%s\n", lqa_record[i2]); } if(ex_put_qa(exoid, 1, (char *(*)[4]) &lqa_record[0]) < 0) { Gen_Error(0, "fatal: unable to output QA records"); return 0; } /* free up memory */ for(int i2=0; i2 < 4; i2++) free(lqa_record[i2]); free(lqa_record); /* Output the the initial Nemesis global information */ if(ex_put_init_global(exoid, mesh->num_nodes, mesh->num_elems, mesh->num_el_blks, 0, 0) < 0) { Gen_Error(0, "fatal: failed to output initial Nemesis parameters"); return 0; } /* Set up dummy arrays for ouput */ std::vector<INT> num_nmap_cnts(machine->num_procs); std::vector<INT> num_emap_cnts(machine->num_procs); if(problem->type == NODAL) { /* need to check and make sure that there really are comm maps */ for(int cnt=0; cnt < machine->num_procs; cnt++) { if (!lb->bor_nodes[cnt].empty()) num_nmap_cnts[cnt] = 1; } } else { /* Elemental load balance */ if(((problem->num_vertices)-(sphere->num)) > 0) { /* need to check and make sure that there really are comm maps */ for(int cnt=0; cnt < machine->num_procs; cnt++) { if (!lb->bor_nodes[cnt].empty()) num_nmap_cnts[cnt] = 1; } for(int cnt=0; cnt < machine->num_procs; cnt++) { if (!lb->bor_elems[cnt].empty()) num_emap_cnts[cnt] = 1; } } } if(ex_put_init_info(exoid, machine->num_procs, machine->num_procs, (char*)"s") < 0) { Gen_Error(0, "fatal: unable to output init info"); return 0; } // Need to create 5 arrays with the sizes of lb->int_nodes[i].size()... { std::vector<INT> ins(machine->num_procs); std::vector<INT> bns(machine->num_procs); std::vector<INT> ens(machine->num_procs); std::vector<INT> ies(machine->num_procs); std::vector<INT> bes(machine->num_procs); for (int iproc = 0; iproc < machine->num_procs; iproc++) { ins[iproc] = lb->int_nodes[iproc].size(); bns[iproc] = lb->bor_nodes[iproc].size(); ens[iproc] = lb->ext_nodes[iproc].size(); ies[iproc] = lb->int_elems[iproc].size(); bes[iproc] = lb->bor_elems[iproc].size(); } if(ex_put_loadbal_param_cc(exoid, TOPTR(ins), TOPTR(bns), TOPTR(ens), TOPTR(ies), TOPTR(bes), TOPTR(num_nmap_cnts), TOPTR(num_emap_cnts)) < 0) { Gen_Error(0, "fatal: unable to output load-balance parameters"); return 0; } } if(problem->type == NODAL) /* Nodal load balance output */ { /* Set up for the concatenated communication map parameters */ std::vector<INT> node_proc_ptr(machine->num_procs+1); std::vector<INT> node_cmap_ids_cc(machine->num_procs); std::vector<INT> node_cmap_cnts_cc(machine->num_procs); node_proc_ptr[0] = 0; for(int proc=0; proc < machine->num_procs; proc++) { node_proc_ptr[proc+1] = node_proc_ptr[proc] + 1; node_cmap_cnts_cc[proc] = lb->ext_nodes[proc].size(); node_cmap_ids_cc[proc] = 1; } /* Output the communication map parameters */ if(ex_put_cmap_params_cc(exoid, TOPTR(node_cmap_ids_cc), TOPTR(node_cmap_cnts_cc), TOPTR(node_proc_ptr), nullptr, nullptr, nullptr) < 0) { Gen_Error(0, "fatal: unable to output communication map parameters"); return 0; } /* Output the node and element maps */ for(int proc=0; proc < machine->num_procs; proc++) { /* Output the nodal map */ if(ex_put_processor_node_maps(exoid, TOPTR(lb->int_nodes[proc]), TOPTR(lb->bor_nodes[proc]), TOPTR(lb->ext_nodes[proc]), proc) < 0) { Gen_Error(0, "fatal: failed to output node map"); return 0; } /* Output the elemental map */ if(ex_put_processor_elem_maps(exoid, TOPTR(lb->int_elems[proc]), nullptr, proc) < 0) { Gen_Error(0, "fatal: failed to output element map"); return 0; } /* * Reorder the nodal communication maps so that they are ordered * by processor and then by global ID. */ /* This is a 2-key sort */ qsort2(TOPTR(lb->ext_procs[proc]), TOPTR(lb->ext_nodes[proc]), lb->ext_nodes[proc].size()); /* Output the nodal communication map */ if(ex_put_node_cmap(exoid, 1, TOPTR(lb->ext_nodes[proc]), TOPTR(lb->ext_procs[proc]), proc) < 0) { Gen_Error(0, "fatal: failed to output nodal communication map"); return 0; } } /* End "for(proc=0; proc < machine->num_procs; proc++)" */ } else if(problem->type == ELEMENTAL) /* Elemental load balance output */ { std::vector<INT> node_proc_ptr(machine->num_procs+1); std::vector<INT> node_cmap_ids_cc(machine->num_procs); std::vector<INT> node_cmap_cnts_cc(machine->num_procs); node_proc_ptr[0] = 0; for(int proc=0; proc < machine->num_procs; proc++) { node_proc_ptr[proc+1] = node_proc_ptr[proc] + 1; node_cmap_cnts_cc[proc] = 0; for(size_t cnt=0; cnt < lb->bor_nodes[proc].size(); cnt++) node_cmap_cnts_cc[proc] += lb->born_procs[proc][cnt].size(); node_cmap_ids_cc[proc] = 1; } std::vector<INT> elem_proc_ptr(machine->num_procs+1); std::vector<INT> elem_cmap_ids_cc(machine->num_procs); std::vector<INT> elem_cmap_cnts_cc(machine->num_procs); elem_proc_ptr[0] = 0; for(int proc=0; proc < machine->num_procs; proc++) { elem_proc_ptr[proc+1] = elem_proc_ptr[proc] + 1; elem_cmap_cnts_cc[proc] = lb->e_cmap_elems[proc].size(); elem_cmap_ids_cc[proc] = 1; } /* Output the communication map parameters */ if(ex_put_cmap_params_cc(exoid, TOPTR(node_cmap_ids_cc), TOPTR(node_cmap_cnts_cc), TOPTR(node_proc_ptr), TOPTR(elem_cmap_ids_cc), TOPTR(elem_cmap_cnts_cc), TOPTR(elem_proc_ptr)) < 0) { Gen_Error(0, "fatal: unable to output communication map parameters"); return 0; } /* Output the node and element maps */ for(int proc=0; proc < machine->num_procs; proc++) { /* Output the nodal map */ if(ex_put_processor_node_maps(exoid, TOPTR(lb->int_nodes[proc]), TOPTR(lb->bor_nodes[proc]), nullptr, proc) < 0) { Gen_Error(0, "fatal: failed to output node map"); return 0; } /* Output the elemental map */ if(ex_put_processor_elem_maps(exoid, TOPTR(lb->int_elems[proc]), TOPTR(lb->bor_elems[proc]), proc) < 0) { Gen_Error(0, "fatal: failed to output element map"); return 0; } /* * Build a nodal communication map from the list of border nodes * and their associated processors and side IDs. */ size_t nsize = 0; for(size_t cnt=0; cnt < lb->bor_nodes[proc].size(); cnt++) nsize += lb->born_procs[proc][cnt].size(); if (nsize > 0) { std::vector<INT> n_cmap_nodes(nsize); std::vector<INT> n_cmap_procs(nsize); size_t cnt3 = 0; for(size_t cnt=0; cnt < lb->bor_nodes[proc].size(); cnt++) { for(size_t cnt2=0; cnt2 < lb->born_procs[proc][cnt].size(); cnt2++) { n_cmap_nodes[cnt3] = lb->bor_nodes[proc][cnt]; n_cmap_procs[cnt3++] = lb->born_procs[proc][cnt][cnt2]; } } /* * Reorder the nodal communication maps so that they are ordered * by processor and then by global ID. */ /* This is a 2-key sort */ qsort2(TOPTR(n_cmap_procs), TOPTR(n_cmap_nodes), cnt3); /* Output the nodal communication map */ if(ex_put_node_cmap(exoid, 1, TOPTR(n_cmap_nodes), TOPTR(n_cmap_procs), proc) < 0) { Gen_Error(0, "fatal: unable to output nodal communication map"); return 0; } } /* End "if (nsize > 0)" */ /* Output the elemental communication map */ if(!lb->e_cmap_elems[proc].empty()) { if(ex_put_elem_cmap(exoid, 1, TOPTR(lb->e_cmap_elems[proc]), TOPTR(lb->e_cmap_sides[proc]), TOPTR(lb->e_cmap_procs[proc]), proc) < 0) { Gen_Error(0, "fatal: unable to output elemental communication map"); return 0; } } } /* End "for(proc=0; proc < machine->num_procs; proc++)" */ } return 1; } /*------------------------End write_nemesis()------------------------------*/
void quicksort2(int *data, int n) { qsort2(data, 0, n - 1); }
void quicksort(long int **V, long int n) { qsort2(V, 0, n - 1); }
void sort_tab_name() { qsort2(tab_pt, 0, maxst - 1); }
int main(int argc,char **argv) { struct dirent *dp; struct stat stp; DIR *dirp; char dir[512]; char argdir[512]; char buf[1024]; char str[128]; char *files[2048],*dirs[2048]; long ffsize=0,ddsize=0, i; off_t fsize[2048]; MPEG_HEAD finfo[2048]; int audioenc=0,fd=0; strcpy(argdir,"."); if (argc==2) strcpy(argdir,argv[1]); dirp = opendir (argdir); if (dirp == 0) { fprintf (stderr,"opendir \"%s\": %s\n", argdir, strerror (errno)); exit (errno); } ffsize=0; /* Read directory contents and mp3 file infos*/ while ((dp = readdir (dirp)) != NULL) { strcpy (dir, argdir); strcat (dir, "/"); strcat (dir, dp->d_name); if (strstr (dir, ".mp3")) audioenc = 1; else if (strstr (dir, ".ogg")) audioenc = 2; else audioenc = 0; //printf("DIR:%s\n",dir); lstat (dir, &stp); finfo[ffsize].fmode = stp.st_mode; if (S_ISLNK (finfo[ffsize].fmode)) { stat (dir, &stp); if (S_ISDIR (stp.st_mode)) finfo[ffsize].fmode = stp.st_mode; } if (!S_ISDIR (stp.st_mode)) { files[ffsize] = (char *) realloc ((char *) files[ffsize], strlen (dp->d_name) + 2); strcpy (files[ffsize], dp->d_name); fsize[ffsize] = stp.st_size; if (audioenc==1) { //mp3 if (!S_ISREG (stp.st_mode)) { finfo[ffsize].valid = 0; fd = -1; } else fd = open (dir, O_RDONLY); if (fd < 0) { finfo[ffsize].valid = 0; } else if (S_ISREG (stp.st_mode)) { get_mp3header (&finfo[ffsize], stp.st_size, fd); close (fd); } } if (audioenc==2) { //ogg if (!S_ISREG (stp.st_mode)) { finfo[ffsize].valid = 0; fd = -1; } else fd = open (dir, O_RDONLY); if (fd < 0) { finfo[ffsize].valid = 0; } else if (S_ISREG (stp.st_mode)) { oggnfo (&finfo[ffsize], stp.st_size, fd); finfo[ffsize].valid = 1; finfo[ffsize].enctype = 2; //ogg close (fd); } } else if (audioenc==0) // non-audio file finfo[ffsize].valid = 0; ffsize++; } else { dirs[ddsize] = (char *) realloc ((char *) dirs[ddsize], strlen (dp->d_name) + 2); strcpy (dirs[ddsize], dp->d_name); ddsize++; } } closedir (dirp); /*Sort dirs */ if ((ddsize - 1) > 1) qsort1 (0, ddsize - 1, dirs); /*Sort files */ if ((ffsize - 1) > 0) { qsort2 (0, ffsize - 1, files, fsize, finfo); } //print dirs for (i = 0; i < ddsize; i++) { printf ("d//////%s\n",dirs[i]); } //print files for (i = 0; i < ffsize; i++) { if (strstr (files[i], ".mp3")) { if (finfo[i].vbr) { strcpy(str,"VBR"); //printf("I:%ld\n",i); if ((finfo[i].mins+finfo[i].secs)) finfo[i].bitrate=fsize[i]*8/(60*finfo[i].mins+finfo[i].secs)/1000; else finfo[i].bitrate=0; } else strcpy(str,"Kbps"); sprintf (buf,"fmp3/%08ld/%02d/%02d/%03d/%3s/%s\n", fsize[i],finfo[i].mins,finfo[i].secs, finfo[i].bitrate,str,files[i]); } else if (strstr (files[i], ".ogg")) { //sprintf(buf,"%s\n",files[i]); strcpy(str,"VBR"); sprintf (buf,"fmp3/%08ld/%02d/%02d/%03d/%3s/%s\n", fsize[i],finfo[i].mins,finfo[i].secs, finfo[i].bitrate,str,files[i]); } else sprintf (buf,"f/%ld/////%s\n",fsize[i],files[i]); printf("%s",buf); } return 0; }