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