playtree.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 /// \file
  20 /// \ingroup Playtree
  21
  22 #include "config.h"
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #ifdef MP_DEBUG
  29 #include <assert.h>
  30 #endif
  31 #include "m_config.h"
  32 #include "playtree.h"
  33 #include "mp_msg.h"
  34
  35 static int
  36 play_tree_is_valid(play_tree_t* pt);
  37
  38 play_tree_t*
  39 play_tree_new(void) {
  40   play_tree_t* r = calloc(1,sizeof(play_tree_t));
  41   if(r == NULL) {
  42     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(int)sizeof(play_tree_t));
  43     return NULL;
  44   }
  45   r->entry_type = PLAY_TREE_ENTRY_NODE;
  46   return r;
  47 }
  48
  49 void
  50 play_tree_free(play_tree_t* pt, int children) {
  51   play_tree_t* iter;
  52
  53 #ifdef MP_DEBUG
  54   assert(pt != NULL);
  55 #endif
  56
  57   if(children) {
  58     for(iter = pt->child; iter != NULL; ) {
  59       play_tree_t* nxt=iter->next;
  60       play_tree_free(iter,1);
  61       iter = nxt;
  62     }
  63     pt->child = NULL;
  64   }
  65
  66   play_tree_remove(pt,0,0);
  67
  68   for(iter = pt->child ; iter != NULL ; iter = iter->next)
  69     iter->parent = NULL;
  70
  71   if (pt->params) {
  72     int i;
  73     for(i = 0 ; pt->params[i].name != NULL ; i++) {
  74       free(pt->params[i].name);
  75       free(pt->params[i].value);
  76     }
  77     free(pt->params);
  78   }
  79   if(pt->files) {
  80     int i;
  81     for(i = 0 ; pt->files[i] != NULL ; i++)
  82       free(pt->files[i]);
  83     free(pt->files);
  84   }
  85
  86   free(pt);
  87 }
  88
  89 void
  90 play_tree_free_list(play_tree_t* pt, int children) {
  91   play_tree_t* iter;
  92
  93 #ifdef MP_DEBUG
  94   assert(pt != NULL);
  95 #endif
  96
  97   for(iter = pt ; iter->prev != NULL ; iter = iter->prev)
  98     /* NOTHING */;
  99
 100   while(iter) {
 101     play_tree_t* nxt = iter->next;
 102     play_tree_free(iter, children);
 103     iter = nxt;
 104   }
 105
 106
 107 }
 108
 109 void
 110 play_tree_append_entry(play_tree_t* pt, play_tree_t* entry) {
 111   play_tree_t* iter;
 112
 113 #ifdef MP_DEBUG
 114   assert(pt != NULL);
 115   assert(entry != NULL);
 116 #endif
 117
 118   if(pt == entry)
 119     return;
 120
 121   for(iter = pt ; iter->next != NULL ; iter = iter->next)
 122     /* NOTHING */;
 123
 124   entry->parent = iter->parent;
 125   entry->prev = iter;
 126   entry->next = NULL;
 127   iter->next = entry;
 128 }
 129
 130 void
 131 play_tree_prepend_entry(play_tree_t* pt, play_tree_t* entry) {
 132   play_tree_t* iter;
 133
 134 #ifdef MP_DEBUG
 135   assert(pt != NULL);
 136   assert(entry != NULL);
 137 #endif
 138
 139   for(iter = pt ; iter->prev != NULL; iter = iter->prev)
 140     /* NOTHING */;
 141
 142   entry->prev = NULL;
 143   entry->next = iter;
 144   entry->parent = iter->parent;
 145
 146   iter->prev = entry;
 147   if(entry->parent) {
 148 #ifdef MP_DEBUG
 149     assert(entry->parent->child == iter);
 150 #endif
 151     entry->parent->child = entry;
 152   }
 153 }
 154
 155 void
 156 play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry) {
 157
 158 #ifdef MP_DEBUG
 159   assert(pt != NULL);
 160   assert(entry != NULL);
 161 #endif
 162
 163   entry->parent = pt->parent;
 164   entry->prev = pt;
 165   if(pt->next) {
 166 #ifdef MP_DEBUG
 167     assert(pt->next->prev == pt);
 168 #endif
 169     entry->next = pt->next;
 170     entry->next->prev = entry;
 171   } else
 172     entry->next = NULL;
 173   pt->next = entry;
 174
 175 }
 176
 177 void
 178 play_tree_remove(play_tree_t* pt, int free_it, int with_children) {
 179
 180 #ifdef MP_DEBUG
 181   assert(pt != NULL);
 182 #endif
 183
 184   // Middle of list
 185   if(pt->prev && pt->next) {
 186 #ifdef MP_DEBUG
 187     assert(pt->prev->next == pt);
 188     assert(pt->next->prev == pt);
 189 #endif
 190     pt->prev->next = pt->next;
 191     pt->next->prev = pt->prev;
 192   } // End of list
 193   else if(pt->prev) {
 194 #ifdef MP_DEBUG
 195     assert(pt->prev->next == pt);
 196 #endif
 197     pt->prev->next = NULL;
 198   } // Beginning of list
 199   else if(pt->next) {
 200 #ifdef MP_DEBUG
 201     assert(pt->next->prev == pt);
 202 #endif
 203     pt->next->prev = NULL;
 204     if(pt->parent) {
 205 #ifdef MP_DEBUG
 206       assert(pt->parent->child == pt);
 207 #endif
 208       pt->parent->child = pt->next;
 209     }
 210   } // The only one
 211   else if(pt->parent) {
 212 #ifdef MP_DEBUG
 213     assert(pt->parent->child == pt);
 214 #endif
 215     pt->parent->child = NULL;
 216   }
 217
 218   pt->prev = pt->next = pt->parent = NULL;
 219   if(free_it)
 220     play_tree_free(pt,with_children);
 221
 222 }
 223
 224 void
 225 play_tree_set_child(play_tree_t* pt, play_tree_t* child) {
 226   play_tree_t* iter;
 227
 228   /* Roughly validate input data. Both, pt and child are going to be
 229    * dereferenced, hence assure they're not NULL.
 230    */
 231   if (!pt || !child) {
 232     mp_msg(MSGT_PLAYTREE, MSGL_ERR, "Internal error, attempt to add an empty child or use empty playlist\n");
 233     return;
 234   }
 235
 236 #ifdef MP_DEBUG
 237   assert(pt->entry_type == PLAY_TREE_ENTRY_NODE);
 238 #endif
 239
 240   //DEBUG_FF: Where are the children freed?
 241   // Attention in using this function!
 242   for(iter = pt->child ; iter != NULL ; iter = iter->next)
 243     iter->parent = NULL;
 244
 245   // Go back to first one
 246   for(iter = child ; iter->prev != NULL ; iter = iter->prev)
 247     /* NOTHING */;
 248
 249   pt->child = iter;
 250
 251   for( ; iter != NULL ; iter= iter->next)
 252     iter->parent = pt;
 253
 254 }
 255
 256 void
 257 play_tree_set_parent(play_tree_t* pt, play_tree_t* parent) {
 258   play_tree_t* iter;
 259
 260 #ifdef MP_DEBUG
 261   assert(pt != NULL);
 262 #endif
 263
 264   if(pt->parent)
 265     pt->parent->child = NULL;
 266
 267   for(iter = pt ; iter != NULL ; iter = iter->next)
 268     iter->parent = parent;
 269
 270   if(pt->prev) {
 271     for(iter = pt->prev ; iter->prev != NULL ; iter = iter->prev)
 272       iter->parent = parent;
 273     iter->parent = parent;
 274     parent->child = iter;
 275   } else
 276     parent->child = pt;
 277
 278 }
 279
 280
 281 void
 282 play_tree_add_file(play_tree_t* pt,const char* file) {
 283   int n = 0;
 284
 285 #ifdef MP_DEBUG
 286   assert(pt != NULL);
 287   assert(pt->child == NULL);
 288   assert(file != NULL);
 289 #endif
 290
 291   if(pt->entry_type != PLAY_TREE_ENTRY_NODE &&
 292      pt->entry_type != PLAY_TREE_ENTRY_FILE)
 293     return;
 294
 295   if(pt->files) {
 296     for(n = 0 ; pt->files[n] != NULL ; n++)
 297       /* NOTHING */;
 298   }
 299   pt->files = realloc(pt->files, (n + 2) * sizeof(char*));
 300   if(pt->files ==NULL) {
 301     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(n+2)*(int)sizeof(char*));
 302     return;
 303   }
 304
 305   pt->files[n]   = strdup(file);
 306   pt->files[n+1] = NULL;
 307
 308   pt->entry_type = PLAY_TREE_ENTRY_FILE;
 309
 310 }
 311
 312 int
 313 play_tree_remove_file(play_tree_t* pt,const char* file) {
 314   int n,f = -1;
 315
 316 #ifdef MP_DEBUG
 317   assert(pt != NULL);
 318   assert(file != NULL);
 319   assert(pt->entry_type != PLAY_TREE_ENTRY_NODE);
 320 #endif
 321
 322   for(n=0 ; pt->files[n] != NULL ; n++) {
 323     if(strcmp(file,pt->files[n]) == 0)
 324       f = n;
 325   }
 326
 327   if(f < 0) // Not found
 328     return 0;
 329
 330 #ifdef MP_DEBUG
 331   assert(n > f);
 332 #endif
 333
 334   free(pt->files[f]);
 335
 336   if(n > 1) {
 337     memmove(&pt->files[f],&pt->files[f+1],(n-f)*sizeof(char*));
 338     pt->files = realloc(pt->files, n * sizeof(char*));
 339     if(pt->files == NULL) {
 340       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(n+2)*(int)sizeof(char*));
 341       return -1;
 342     }
 343   } else {
 344     free(pt->files);
 345     pt->files = NULL;
 346   }
 347
 348   return 1;
 349 }
 350
 351 void
 352 play_tree_set_param(play_tree_t* pt, const char* name, const char* val) {
 353   int n = 0;
 354
 355 #ifdef MP_DEBUG
 356   assert(pt != NULL);
 357   assert(name != NULL);
 358 #endif
 359
 360   if(pt->params)
 361     for ( ; pt->params[n].name != NULL ; n++ ) { }
 362
 363   pt->params = realloc(pt->params, (n + 2) * sizeof(play_tree_param_t));
 364   if(pt->params == NULL) {
 365       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't realloc params (%d bytes of memory)\n",(n+2)*(int)sizeof(play_tree_param_t));
 366       return;
 367   }
 368   pt->params[n].name = strdup(name);
 369   pt->params[n].value = val != NULL ? strdup(val) : NULL;
 370   memset(&pt->params[n+1],0,sizeof(play_tree_param_t));
 371
 372   return;
 373 }
 374
 375 int
 376 play_tree_unset_param(play_tree_t* pt, const char* name) {
 377   int n,ni = -1;
 378
 379 #ifdef MP_DEBUG
 380   assert(pt != NULL);
 381   assert(name != NULL);
 382   assert(pt->params != NULL);
 383 #endif
 384
 385   for(n = 0 ; pt->params[n].name != NULL ; n++) {
 386     if(strcasecmp(pt->params[n].name,name) == 0)
 387       ni = n;
 388   }
 389
 390   if(ni < 0)
 391     return 0;
 392
 393   free(pt->params[ni].name);
 394   free(pt->params[ni].value);
 395
 396   if(n > 1) {
 397     memmove(&pt->params[ni],&pt->params[ni+1],(n-ni)*sizeof(play_tree_param_t));
 398     pt->params = realloc(pt->params, n * sizeof(play_tree_param_t));
 399     if(pt->params == NULL) {
 400       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",n*(int)sizeof(play_tree_param_t));
 401       return -1;
 402     }
 403   } else {
 404     free(pt->params);
 405     pt->params = NULL;
 406   }
 407
 408   return 1;
 409 }
 410
 411 void
 412 play_tree_set_params_from(play_tree_t* dest,play_tree_t* src) {
 413   int i;
 414
 415 #ifdef MP_DEBUG
 416   assert(dest != NULL);
 417   assert(src != NULL);
 418 #endif
 419
 420   if(!src->params)
 421     return;
 422
 423   for(i = 0; src->params[i].name != NULL ; i++)
 424     play_tree_set_param(dest,src->params[i].name,src->params[i].value);
 425   if(src->flags & PLAY_TREE_RND) // pass the random flag too
 426     dest->flags |= PLAY_TREE_RND;
 427
 428 }
 429
 430 static void
 431 play_tree_unset_flag(play_tree_t* pt, int flags , int deep) {
 432   play_tree_t*  i;
 433
 434   pt->flags &= ~flags;
 435
 436   if(deep && pt->child) {
 437     if(deep > 0) deep--;
 438     for(i = pt->child ; i ; i = i->next)
 439       play_tree_unset_flag(i,flags,deep);
 440   }
 441 }
 442
 443
 444 //////////////////////////////////// ITERATOR //////////////////////////////////////
 445
 446 static void
 447 play_tree_iter_push_params(play_tree_iter_t* iter) {
 448   int n;
 449   play_tree_t* pt;
 450 #ifdef MP_DEBUG
 451   assert(iter != NULL);
 452   assert(iter->config != NULL);
 453   assert(iter->tree != NULL);
 454 #endif
 455
 456   pt = iter->tree;
 457
 458   // We always push a config because we can set some option
 459   // while playing
 460   m_config_push(iter->config);
 461
 462   if(pt->params == NULL)
 463     return;
 464
 465
 466   for(n = 0; pt->params[n].name != NULL ; n++) {
 467     int e;
 468     if((e = m_config_set_option(iter->config,pt->params[n].name,pt->params[n].value)) < 0) {
 469       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error %d while setting option '%s' with value '%s'\n",e,
 470              pt->params[n].name,pt->params[n].value);
 471     }
 472   }
 473
 474   if(!pt->child)
 475     iter->entry_pushed = 1;
 476 }
 477
 478 play_tree_iter_t*
 479 play_tree_iter_new(play_tree_t* pt,m_config_t* config) {
 480   play_tree_iter_t* iter;
 481
 482 #ifdef MP_DEBUG
 483   assert(pt != NULL);
 484   assert(config != NULL);
 485 #endif
 486
 487   if( ! play_tree_is_valid(pt))
 488     return NULL;
 489
 490   iter = calloc(1,sizeof(play_tree_iter_t));
 491   if(! iter) {
 492       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate new iterator (%d bytes of memory)\n",(int)sizeof(play_tree_iter_t));
 493       return NULL;
 494   }
 495   iter->root = pt;
 496   iter->tree = NULL;
 497   iter->config = config;
 498
 499   if(pt->parent)
 500     iter->loop = pt->parent->loop;
 501
 502   return iter;
 503 }
 504
 505 void
 506 play_tree_iter_free(play_tree_iter_t* iter) {
 507
 508 #ifdef MP_DEBUG
 509   assert(iter != NULL);
 510 #endif
 511
 512   if(iter->status_stack) {
 513 #ifdef MP_DEBUG
 514     assert(iter->stack_size > 0);
 515 #endif
 516     free(iter->status_stack);
 517   }
 518
 519   free(iter);
 520 }
 521
 522 static play_tree_t*
 523 play_tree_rnd_step(play_tree_t* pt) {
 524   int count = 0;
 525   int r;
 526   play_tree_t *i,*head;
 527
 528   // Count how many free choice we have
 529   for(i = pt ; i->prev ; i = i->prev)
 530     if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
 531   head = i;
 532   if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
 533   for(i = pt->next ; i ; i = i->next)
 534     if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
 535
 536   if(!count) return NULL;
 537
 538   r = (int)((float)(count) * rand() / (RAND_MAX + 1.0));
 539
 540   for(i = head ; i  ; i=i->next) {
 541     if(!(i->flags & PLAY_TREE_RND_PLAYED)) r--;
 542     if(r < 0) return i;
 543   }
 544
 545   mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Random stepping error\n");
 546   return NULL;
 547 }
 548
 549
 550 int
 551 play_tree_iter_step(play_tree_iter_t* iter, int d,int with_nodes) {
 552   play_tree_t* pt;
 553
 554   if ( !iter ) return PLAY_TREE_ITER_ENTRY;
 555   if ( !iter->root ) return PLAY_TREE_ITER_ENTRY;
 556
 557 #ifdef MP_DEBUG
 558   assert(iter != NULL);
 559   assert(iter->root != NULL);
 560   //printf("PT : Stepping = %d\n",d);
 561 #endif
 562
 563   if(iter->tree == NULL) {
 564     iter->tree = iter->root;
 565     return play_tree_iter_step(iter,0,with_nodes);
 566   }
 567
 568   if(iter->config && iter->entry_pushed > 0) {
 569     iter->entry_pushed = 0;
 570     m_config_pop(iter->config);
 571   }
 572
 573   if(iter->tree->parent && (iter->tree->parent->flags & PLAY_TREE_RND))
 574     iter->mode = PLAY_TREE_ITER_RND;
 575   else
 576     iter->mode = PLAY_TREE_ITER_NORMAL;
 577
 578   iter->file = -1;
 579   if(iter->mode == PLAY_TREE_ITER_RND)
 580     pt = play_tree_rnd_step(iter->tree);
 581   else if( d > 0 ) {
 582     int i;
 583     pt = iter->tree;
 584     for(i = d ; i > 0 && pt ; i--)
 585       pt = pt->next;
 586     d = i ? i : 1;
 587   } else if(d < 0) {
 588     int i;
 589     pt = iter->tree;
 590     for(i = d ; i < 0 && pt ; i++)
 591       pt = pt->prev;
 592     d = i ? i : -1;
 593   } else
 594     pt = iter->tree;
 595
 596   if(pt == NULL) { // No next
 597     // Must we loop?
 598     if (iter->mode == PLAY_TREE_ITER_RND) {
 599       if (iter->root->loop == 0)
 600         return PLAY_TREE_ITER_END;
 601       play_tree_unset_flag(iter->root, PLAY_TREE_RND_PLAYED, -1);
 602       if (iter->root->loop > 0) iter->root->loop--;
 603       // try again
 604       return play_tree_iter_step(iter, 0, with_nodes);
 605     } else
 606     if(iter->tree->parent && iter->tree->parent->loop != 0 && ((d > 0 && iter->loop != 0) || ( d < 0 && (iter->loop < 0 || iter->loop < iter->tree->parent->loop) ) ) ) {
 607       if(d > 0) { // Go back to the first one
 608         for(pt = iter->tree ; pt->prev != NULL; pt = pt->prev)
 609           /* NOTHNG */;
 610         if(iter->loop > 0) iter->loop--;
 611       } else if( d < 0 ) { // Or the last one
 612         for(pt = iter->tree ; pt->next != NULL; pt = pt->next)
 613           /* NOTHNG */;
 614         if(iter->loop >= 0 && iter->loop < iter->tree->parent->loop) iter->loop++;
 615       }
 616       iter->tree = pt;
 617       return play_tree_iter_step(iter,0,with_nodes);
 618     }
 619     // Go up one level
 620     return play_tree_iter_up_step(iter,d,with_nodes);
 621
 622   }
 623
 624   // Is there any valid child?
 625   if(pt->child && play_tree_is_valid(pt->child)) {
 626     iter->tree = pt;
 627     if(with_nodes) { // Stop on the node
 628       return PLAY_TREE_ITER_NODE;
 629     } else      // Or follow it
 630       return play_tree_iter_down_step(iter,d,with_nodes);
 631   }
 632
 633   // Is it a valid entry?
 634   if(! play_tree_is_valid(pt)) {
 635     if(d == 0) { // Can this happen ? FF: Yes!
 636       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"What to do now ???? Infinite loop if we continue\n");
 637       return PLAY_TREE_ITER_ERROR;
 638     } // Not a valid entry : go to next one
 639     return play_tree_iter_step(iter,d,with_nodes);
 640   }
 641
 642 #ifdef MP_DEBUG
 643   assert(pt->files != NULL);
 644 #endif
 645
 646   iter->tree = pt;
 647
 648   for(d = 0 ; iter->tree->files[d] != NULL ; d++)
 649     /* NOTHING */;
 650   iter->num_files = d;
 651
 652   if(iter->config) {
 653     play_tree_iter_push_params(iter);
 654     iter->entry_pushed = 1;
 655     if(iter->mode == PLAY_TREE_ITER_RND)
 656       pt->flags |= PLAY_TREE_RND_PLAYED;
 657   }
 658
 659   return PLAY_TREE_ITER_ENTRY;
 660
 661 }
 662
 663 static int
 664 play_tree_is_valid(play_tree_t* pt) {
 665   play_tree_t* iter;
 666
 667 #ifdef MP_DEBUG
 668   assert(pt != NULL);
 669 #endif
 670
 671   if(pt->entry_type != PLAY_TREE_ENTRY_NODE) {
 672 #ifdef MP_DEBUG
 673     assert(pt->child == NULL);
 674 #endif
 675     return 1;
 676   }
 677   else if (pt->child != NULL) {
 678     for(iter = pt->child ; iter != NULL ; iter = iter->next) {
 679       if(play_tree_is_valid(iter))
 680         return 1;
 681     }
 682   }
 683   return 0;
 684 }
 685
 686 int
 687 play_tree_iter_up_step(play_tree_iter_t* iter, int d,int with_nodes) {
 688
 689 #ifdef MP_DEBUG
 690   assert(iter != NULL);
 691   assert(iter->tree != NULL);
 692   //printf("PT : Go UP\n");
 693 #endif
 694
 695   iter->file = -1;
 696   if(iter->tree->parent == iter->root->parent)
 697     return PLAY_TREE_ITER_END;
 698
 699 #ifdef MP_DEBUG
 700   assert(iter->tree->parent != NULL);
 701   assert(iter->stack_size > 0);
 702   assert(iter->status_stack != NULL);
 703 #endif
 704
 705   iter->stack_size--;
 706   iter->loop = iter->status_stack[iter->stack_size];
 707   if(iter->stack_size > 0)
 708     iter->status_stack = realloc(iter->status_stack, iter->stack_size * sizeof(int));
 709   else {
 710     free(iter->status_stack);
 711     iter->status_stack = NULL;
 712   }
 713   if(iter->stack_size > 0 && iter->status_stack == NULL) {
 714     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",iter->stack_size*(int)sizeof(char*));
 715     return PLAY_TREE_ITER_ERROR;
 716   }
 717   iter->tree = iter->tree->parent;
 718
 719   // Pop subtree params
 720   if(iter->config) {
 721     m_config_pop(iter->config);
 722     if(iter->mode == PLAY_TREE_ITER_RND)
 723       iter->tree->flags |= PLAY_TREE_RND_PLAYED;
 724   }
 725
 726   return play_tree_iter_step(iter,d,with_nodes);
 727 }
 728
 729 int
 730 play_tree_iter_down_step(play_tree_iter_t* iter, int d,int with_nodes) {
 731
 732 #ifdef MP_DEBUG
 733   assert(iter->tree->files == NULL);
 734   assert(iter->tree->child != NULL);
 735   assert(iter->tree->child->parent == iter->tree);
 736   //printf("PT : Go DOWN\n");
 737 #endif
 738
 739   iter->file = -1;
 740
 741   //  Push subtree params
 742   if(iter->config)
 743     play_tree_iter_push_params(iter);
 744
 745   iter->stack_size++;
 746   iter->status_stack = realloc(iter->status_stack, iter->stack_size * sizeof(int));
 747   if(iter->status_stack == NULL) {
 748     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",iter->stack_size*(int)sizeof(int));
 749     return PLAY_TREE_ITER_ERROR;
 750   }
 751   iter->status_stack[iter->stack_size-1] = iter->loop;
 752   // Set new status
 753   iter->loop = iter->tree->loop-1;
 754   if(d >= 0)
 755     iter->tree = iter->tree->child;
 756   else {
 757     play_tree_t* pt;
 758     for(pt = iter->tree->child ; pt->next != NULL ; pt = pt->next)
 759       /*NOTING*/;
 760     iter->tree = pt;
 761   }
 762
 763   return play_tree_iter_step(iter,0,with_nodes);
 764 }
 765
 766 char*
 767 play_tree_iter_get_file(play_tree_iter_t* iter, int d) {
 768 #ifdef MP_DEBUG
 769   assert(iter != NULL);
 770   assert(iter->tree->child == NULL);
 771 #endif
 772
 773   if(iter->tree->files == NULL)
 774     return NULL;
 775
 776 #ifdef MP_DEBUG
 777   assert(iter->num_files > 0);
 778 #endif
 779
 780   if(iter->file >= iter->num_files-1 || iter->file < -1)
 781     return NULL;
 782
 783   if(d > 0) {
 784     if(iter->file >= iter->num_files - 1)
 785       iter->file = 0;
 786     else
 787       iter->file++;
 788   } else if(d < 0) {
 789     if(iter->file <= 0)
 790       iter->file = iter->num_files - 1;
 791     else
 792       iter->file--;
 793   }
 794   return iter->tree->files[iter->file];
 795 }
 796
 797 play_tree_t*
 798 play_tree_cleanup(play_tree_t* pt) {
 799   play_tree_t* iter, *tmp, *first;
 800
 801 #ifdef MP_DEBUG
 802   assert(pt != NULL);
 803 #endif
 804
 805   if( ! play_tree_is_valid(pt)) {
 806     play_tree_remove(pt,1,1);
 807     return NULL;
 808   }
 809
 810   first = pt->child;
 811
 812   for(iter = pt->child ; iter != NULL ; ) {
 813     tmp = iter;
 814     iter = iter->next;
 815     if(! play_tree_is_valid(tmp)) {
 816       play_tree_remove(tmp,1,1);
 817       if(tmp == first) first = iter;
 818     }
 819   }
 820
 821   for(iter = first ; iter != NULL ; ) {
 822     tmp = iter;
 823     iter = iter->next;
 824     play_tree_cleanup(tmp);
 825   }
 826
 827   return pt;
 828
 829 }
 830
 831 play_tree_iter_t*
 832 play_tree_iter_new_copy(play_tree_iter_t* old) {
 833   play_tree_iter_t* iter;
 834
 835 #ifdef MP_DEBUG
 836   assert(old != NULL);
 837 #endif
 838
 839   iter = malloc(sizeof(play_tree_iter_t));
 840   if(iter == NULL) {
 841     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(int)sizeof(play_tree_iter_t));
 842     return NULL;
 843   }
 844 ;
 845   memcpy(iter,old,sizeof(play_tree_iter_t));
 846   if(old->status_stack) {
 847     iter->status_stack = malloc(old->stack_size * sizeof(int));
 848     if(iter->status_stack == NULL) {
 849       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",old->stack_size * (int)sizeof(int));
 850       free(iter);
 851       return NULL;
 852     }
 853     memcpy(iter->status_stack,old->status_stack,iter->stack_size*sizeof(int));
 854   }
 855   iter->config = NULL;
 856
 857   return iter;
 858 }
 859
 860 // HIGH Level API, by Fabian Franz (mplayer@fabian-franz.de)
 861 //
 862 play_tree_iter_t* pt_iter_create(play_tree_t** ppt, m_config_t* config)
 863 {
 864   play_tree_iter_t* r=NULL;
 865 #ifdef MP_DEBUG
 866   assert(*ppt!=NULL);
 867 #endif
 868
 869   *ppt=play_tree_cleanup(*ppt);
 870
 871   if(*ppt) {
 872     r = play_tree_iter_new(*ppt,config);
 873     if (r && play_tree_iter_step(r,0,0) != PLAY_TREE_ITER_ENTRY)
 874     {
 875       play_tree_iter_free(r);
 876       r = NULL;
 877     }
 878   }
 879
 880   return r;
 881 }
 882
 883 void pt_iter_destroy(play_tree_iter_t** iter)
 884 {
 885   if (iter && *iter)
 886   {
 887     free(*iter);
 888     iter=NULL;
 889   }
 890 }
 891
 892 char* pt_iter_get_file(play_tree_iter_t* iter, int d)
 893 {
 894   int i=0;
 895   char* r;
 896
 897   if (iter==NULL)
 898     return NULL;
 899
 900   r = play_tree_iter_get_file(iter,d);
 901
 902   while (!r && d!=0)
 903   {
 904     if (play_tree_iter_step(iter,d,0) != PLAY_TREE_ITER_ENTRY)
 905         break;
 906     r=play_tree_iter_get_file(iter,d);
 907     i++;
 908   }
 909
 910   return r;
 911 }
 912
 913 void pt_iter_insert_entry(play_tree_iter_t* iter, play_tree_t* entry)
 914 {
 915   play_tree_t *pt = iter->tree;
 916 #ifdef MP_DEBUG
 917   assert(pt!=NULL);
 918   assert(entry!=NULL);
 919   assert(entry!=pt);
 920 #endif
 921
 922   play_tree_insert_entry(pt, entry);
 923   play_tree_set_params_from(entry,pt);
 924 }
 925
 926 void pt_iter_replace_entry(play_tree_iter_t* iter, play_tree_t* entry)
 927 {
 928   play_tree_t *pt = iter->tree;
 929
 930   pt_iter_insert_entry(iter, entry);
 931   play_tree_remove(pt, 1, 1);
 932   iter->tree=entry;
 933 }
 934
 935 //Add a new file as a new entry
 936 void pt_add_file(play_tree_t** ppt, const char* filename)
 937 {
 938   play_tree_t *pt = *ppt, *entry = play_tree_new();
 939 #ifdef MP_DEBUG
 940   assert(entry!=NULL);
 941 #endif
 942
 943   play_tree_add_file(entry, filename);
 944   if (pt)
 945     play_tree_append_entry(pt, entry);
 946   else
 947   {
 948     pt=entry;
 949     *ppt=pt;
 950   }
 951   play_tree_set_params_from(entry,pt);
 952 }
 953
 954 void pt_iter_goto_head(play_tree_iter_t* iter)
 955 {
 956   iter->tree=iter->root;
 957   play_tree_iter_step(iter, 0, 0);
 958 }