/*!
* \brief Combine two path into a single one with the given operation
*
* This should (but does not) consider
* - holes within the path more explicitely
* - self intersections in a path
* - winding rule?
*/
GArray *
path_combine (const GArray *p1,
const GArray *p2,
PathCombineMode mode)
{
GArray *result = NULL;
GArray *crossing = NULL;
GArray *one, *two;
static int debug = 0;
g_return_val_if_fail (p1->len > 1 && p2->len > 1, NULL);
/* convert both paths to segment representation - TODO: self intersections */
one = _path_to_segments (p1);
two = _path_to_segments (p2);
crossing = _find_intersections (one, two);
if (crossing) {
/* Now crossing includes points in arbitrary order. Every point has four lines
* going in or out - two from p1, two from p2. Split one and two into segments
* at the crossing points.
*/
GArray *one_splits = _extract_splits (crossing, TRUE);
GArray *two_splits = _extract_splits (crossing, FALSE);
_split_segments (one, one_splits, p2);
_split_segments (two, two_splits, p1);
/* convert segments back to a single path */
if (one_splits->len < 2) { /* XXX: just joining again */
result = _make_path0 (one, one_splits, two, two_splits);
} else if (debug) {
result = _make_path1 (one, one_splits, two, two_splits);
} else {
if (mode == PATH_EXCLUSION) { /* most simple impl. */
GArray *res2;
result = _make_path (one, one_splits, two, two_splits, PATH_DIFFERENCE);
res2 = _make_path (two, two_splits, one, one_splits, PATH_DIFFERENCE);
g_array_append_vals (result, &g_array_index (res2, BezPoint, 0), res2->len);
g_array_free (res2, TRUE);
} else {
result = _make_path (one, one_splits, two, two_splits, mode);
}
}
_free_splits (one_splits);
_free_splits (two_splits);
g_array_free (crossing, TRUE);
}
g_array_free (one, TRUE);
g_array_free (two, TRUE);
if (!result || result->len < 2) {
if (result)
g_array_free (result, TRUE);
return NULL;
}
return result;
}
SNode* CTokens::add_symbol(SSymbol& symbol)
{
SNode* node = _make_path(symbol.label);
node->id = symbol.id;
return node;
}
int
main(int argc, char *argv[])
{
MPLS_PL *pl;
int opt;
int ii, pl_ii;
MPLS_PL *pl_list[1000];
struct stat st;
str_t path = {0,};
DIR *dir = NULL;
do {
opt = getopt(argc, argv, OPTS);
switch (opt) {
case -1:
break;
case 'v':
verbose = 1;
break;
case 'l':
clip_list = 1;
break;
case 'i':
playlist_info = 1;
break;
case 'c':
chapter_marks = 1;
break;
case 'd':
dups = 1;
break;
case 'r':
repeats = atoi(optarg);
break;
case 'f':
repeats = 2;
dups = 1;
seconds = 120;
break;
case 's':
seconds = atoi(optarg);
break;
default:
_usage(argv[0]);
break;
}
} while (opt != -1);
if (optind >= argc) {
_usage(argv[0]);
}
for (pl_ii = 0, ii = optind; pl_ii < 1000 && ii < argc; ii++) {
if (stat(argv[ii], &st)) {
continue;
}
dir = NULL;
if (S_ISDIR(st.st_mode)) {
printf("Directory: %s:\n", argv[ii]);
_make_path(&path, argv[ii], "PLAYLIST");
if (path.buf == NULL) {
fprintf(stderr, "Failed to find playlist path: %s\n", argv[ii]);
continue;
}
dir = opendir(path.buf);
if (dir == NULL) {
fprintf(stderr, "Failed to open dir: %s\n", path.buf);
str_free(&path);
continue;
}
}
if (dir != NULL) {
char **dirlist = calloc(10001, sizeof(char*));
struct dirent *ent;
int jj = 0;
for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
if (ent->d_name != NULL) {
dirlist[jj++] = strdup(ent->d_name);
}
}
qsort(dirlist, jj, sizeof(char*), _qsort_str_cmp);
for (jj = 0; dirlist[jj] != NULL; jj++) {
str_t name = {0,};
str_printf(&name, "%s/%s", path.buf, dirlist[jj]);
free(dirlist[jj]);
if (stat(name.buf, &st)) {
str_free(&name);
continue;
}
if (!S_ISREG(st.st_mode)) {
str_free(&name);
continue;
}
pl = _process_file(name.buf, pl_list, pl_ii);
str_free(&name);
if (pl != NULL) {
pl_list[pl_ii++] = pl;
}
} while (ent != NULL);
free(dirlist);
str_free(&path);
} else {
pl = _process_file(argv[ii], pl_list, pl_ii);
if (pl != NULL) {
pl_list[pl_ii++] = pl;
}
}
}
// Cleanup
for (ii = 0; ii < pl_ii; ii++) {
mpls_free(&pl_list[ii]);
}
return 0;
}
