2 * This file is part of MPlayer.
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.
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.
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.
36 play_tree_is_valid(play_tree_t
* pt
);
40 play_tree_t
* r
= calloc(1,sizeof(play_tree_t
));
42 mp_msg(MSGT_PLAYTREE
,MSGL_ERR
,"Can't allocate %d bytes of memory\n",(int)sizeof(play_tree_t
));
45 r
->entry_type
= PLAY_TREE_ENTRY_NODE
;
50 play_tree_free(play_tree_t
* pt
, int children
) {
58 for(iter
= pt
->child
; iter
!= NULL
; ) {
59 play_tree_t
* nxt
=iter
->next
;
60 play_tree_free(iter
,1);
66 play_tree_remove(pt
,0,0);
68 for(iter
= pt
->child
; iter
!= NULL
; iter
= iter
->next
)
74 for(i
= 0 ; pt
->files
[i
] != NULL
; i
++)
83 play_tree_free_list(play_tree_t
* pt
, int children
) {
90 for(iter
= pt
; iter
->prev
!= NULL
; iter
= iter
->prev
)
94 play_tree_t
* nxt
= iter
->next
;
95 play_tree_free(iter
, children
);
103 play_tree_append_entry(play_tree_t
* pt
, play_tree_t
* entry
) {
108 assert(entry
!= NULL
);
114 for(iter
= pt
; iter
->next
!= NULL
; iter
= iter
->next
)
117 entry
->parent
= iter
->parent
;
124 play_tree_prepend_entry(play_tree_t
* pt
, play_tree_t
* entry
) {
129 assert(entry
!= NULL
);
132 for(iter
= pt
; iter
->prev
!= NULL
; iter
= iter
->prev
)
137 entry
->parent
= iter
->parent
;
142 assert(entry
->parent
->child
== iter
);
144 entry
->parent
->child
= entry
;
149 play_tree_insert_entry(play_tree_t
* pt
, play_tree_t
* entry
) {
153 assert(entry
!= NULL
);
156 entry
->parent
= pt
->parent
;
160 assert(pt
->next
->prev
== pt
);
162 entry
->next
= pt
->next
;
163 entry
->next
->prev
= entry
;
171 play_tree_remove(play_tree_t
* pt
, int free_it
, int with_children
) {
178 if(pt
->prev
&& pt
->next
) {
180 assert(pt
->prev
->next
== pt
);
181 assert(pt
->next
->prev
== pt
);
183 pt
->prev
->next
= pt
->next
;
184 pt
->next
->prev
= pt
->prev
;
188 assert(pt
->prev
->next
== pt
);
190 pt
->prev
->next
= NULL
;
191 } // Beginning of list
194 assert(pt
->next
->prev
== pt
);
196 pt
->next
->prev
= NULL
;
199 assert(pt
->parent
->child
== pt
);
201 pt
->parent
->child
= pt
->next
;
204 else if(pt
->parent
) {
206 assert(pt
->parent
->child
== pt
);
208 pt
->parent
->child
= NULL
;
211 pt
->prev
= pt
->next
= pt
->parent
= NULL
;
213 play_tree_free(pt
,with_children
);
218 play_tree_set_child(play_tree_t
* pt
, play_tree_t
* child
) {
221 /* Roughly validate input data. Both, pt and child are going to be
222 * dereferenced, hence assure they're not NULL.
225 mp_msg(MSGT_PLAYTREE
, MSGL_ERR
, "Internal error, attempt to add an empty child or use empty playlist\n");
230 assert(pt
->entry_type
== PLAY_TREE_ENTRY_NODE
);
233 //DEBUG_FF: Where are the children freed?
234 // Attention in using this function!
235 for(iter
= pt
->child
; iter
!= NULL
; iter
= iter
->next
)
238 // Go back to first one
239 for(iter
= child
; iter
->prev
!= NULL
; iter
= iter
->prev
)
244 for( ; iter
!= NULL
; iter
= iter
->next
)
250 play_tree_set_parent(play_tree_t
* pt
, play_tree_t
* parent
) {
258 pt
->parent
->child
= NULL
;
260 for(iter
= pt
; iter
!= NULL
; iter
= iter
->next
)
261 iter
->parent
= parent
;
264 for(iter
= pt
->prev
; iter
->prev
!= NULL
; iter
= iter
->prev
)
265 iter
->parent
= parent
;
266 iter
->parent
= parent
;
267 parent
->child
= iter
;
275 play_tree_add_file(play_tree_t
* pt
,char* file
) {
280 assert(pt
->child
== NULL
);
281 assert(file
!= NULL
);
284 if(pt
->entry_type
!= PLAY_TREE_ENTRY_NODE
&&
285 pt
->entry_type
!= PLAY_TREE_ENTRY_FILE
)
289 for(n
= 0 ; pt
->files
[n
] != NULL
; n
++)
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*));
298 pt
->files
[n
] = strdup(file
);
299 pt
->files
[n
+1] = NULL
;
301 pt
->entry_type
= PLAY_TREE_ENTRY_FILE
;
306 play_tree_remove_file(play_tree_t
* pt
,char* file
) {
311 assert(file
!= NULL
);
312 assert(pt
->entry_type
!= PLAY_TREE_ENTRY_NODE
);
315 for(n
=0 ; pt
->files
[n
] != NULL
; n
++) {
316 if(strcmp(file
,pt
->files
[n
]) == 0)
320 if(f
< 0) // Not found
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*));
345 play_tree_set_param(play_tree_t
* pt
, char* name
, char* val
) {
350 assert(name
!= NULL
);
354 for ( ; pt
->params
[n
].name
!= NULL
; n
++ ) { }
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
));
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
));
369 play_tree_unset_param(play_tree_t
* pt
, char* name
) {
374 assert(name
!= NULL
);
375 assert(pt
->params
!= NULL
);
378 for(n
= 0 ; pt
->params
[n
].name
!= NULL
; n
++) {
379 if(strcasecmp(pt
->params
[n
].name
,name
) == 0)
386 free(pt
->params
[ni
].name
);
387 free(pt
->params
[ni
].value
);
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
));
405 play_tree_set_params_from(play_tree_t
* dest
,play_tree_t
* src
) {
409 assert(dest
!= NULL
);
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
;
424 play_tree_unset_flag(play_tree_t
* pt
, int flags
, int deep
) {
429 if(deep
&& pt
->child
) {
431 for(i
= pt
->child
; i
; i
= i
->next
)
432 play_tree_unset_flag(i
,flags
,deep
);
437 //////////////////////////////////// ITERATOR //////////////////////////////////////
440 play_tree_iter_push_params(play_tree_iter_t
* iter
) {
444 assert(iter
!= NULL
);
445 assert(iter
->config
!= NULL
);
446 assert(iter
->tree
!= NULL
);
451 // We always push a config because we can set some option
453 m_config_push(iter
->config
);
455 if(pt
->params
== NULL
)
459 for(n
= 0; pt
->params
[n
].name
!= NULL
; n
++) {
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
);
468 iter
->entry_pushed
= 1;
473 play_tree_iter_new(play_tree_t
* pt
,m_config_t
* config
) {
474 play_tree_iter_t
* iter
;
478 assert(config
!= NULL
);
481 if( ! play_tree_is_valid(pt
))
484 iter
= calloc(1,sizeof(play_tree_iter_t
));
486 mp_msg(MSGT_PLAYTREE
,MSGL_ERR
,"Can't allocate new iterator (%d bytes of memory)\n",(int)sizeof(play_tree_iter_t
));
491 iter
->config
= config
;
494 iter
->loop
= pt
->parent
->loop
;
500 play_tree_iter_free(play_tree_iter_t
* iter
) {
503 assert(iter
!= NULL
);
506 if(iter
->status_stack
) {
508 assert(iter
->stack_size
> 0);
510 free(iter
->status_stack
);
517 play_tree_rnd_step(play_tree_t
* pt
) {
520 play_tree_t
*i
,*head
;
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
++;
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
++;
530 if(!count
) return NULL
;
532 r
= (int)((float)(count
) * rand() / (RAND_MAX
+ 1.0));
534 for(i
= head
; i
; i
=i
->next
) {
535 if(!(i
->flags
& PLAY_TREE_RND_PLAYED
)) r
--;
539 mp_msg(MSGT_PLAYTREE
,MSGL_ERR
,"Random stepping error\n");
545 play_tree_iter_step(play_tree_iter_t
* iter
, int d
,int with_nodes
) {
548 if ( !iter
) return PLAY_TREE_ITER_ENTRY
;
549 if ( !iter
->root
) return PLAY_TREE_ITER_ENTRY
;
552 assert(iter
!= NULL
);
553 assert(iter
->root
!= NULL
);
554 //printf("PT : Stepping = %d\n",d);
557 if(iter
->tree
== NULL
) {
558 iter
->tree
= iter
->root
;
559 return play_tree_iter_step(iter
,0,with_nodes
);
562 if(iter
->config
&& iter
->entry_pushed
> 0) {
563 iter
->entry_pushed
= 0;
564 m_config_pop(iter
->config
);
567 if(iter
->tree
->parent
&& (iter
->tree
->parent
->flags
& PLAY_TREE_RND
))
568 iter
->mode
= PLAY_TREE_ITER_RND
;
570 iter
->mode
= PLAY_TREE_ITER_NORMAL
;
573 if(iter
->mode
== PLAY_TREE_ITER_RND
)
574 pt
= play_tree_rnd_step(iter
->tree
);
578 for(i
= d
; i
> 0 && pt
; i
--)
584 for(i
= d
; i
< 0 && pt
; i
++)
590 if(pt
== NULL
) { // No next
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
--;
598 return play_tree_iter_step(iter
, 0, with_nodes
);
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
)
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
)
608 if(iter
->loop
>= 0 && iter
->loop
< iter
->tree
->parent
->loop
) iter
->loop
++;
611 return play_tree_iter_step(iter
,0,with_nodes
);
614 return play_tree_iter_up_step(iter
,d
,with_nodes
);
618 // Is there any valid child?
619 if(pt
->child
&& play_tree_is_valid(pt
->child
)) {
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
);
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
);
637 assert(pt
->files
!= NULL
);
642 for(d
= 0 ; iter
->tree
->files
[d
] != NULL
; d
++)
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
;
653 return PLAY_TREE_ITER_ENTRY
;
658 play_tree_is_valid(play_tree_t
* pt
) {
665 if(pt
->entry_type
!= PLAY_TREE_ENTRY_NODE
) {
667 assert(pt
->child
== NULL
);
671 else if (pt
->child
!= NULL
) {
672 for(iter
= pt
->child
; iter
!= NULL
; iter
= iter
->next
) {
673 if(play_tree_is_valid(iter
))
681 play_tree_iter_up_step(play_tree_iter_t
* iter
, int d
,int with_nodes
) {
684 assert(iter
!= NULL
);
685 assert(iter
->tree
!= NULL
);
686 //printf("PT : Go UP\n");
690 if(iter
->tree
->parent
== iter
->root
->parent
)
691 return PLAY_TREE_ITER_END
;
694 assert(iter
->tree
->parent
!= NULL
);
695 assert(iter
->stack_size
> 0);
696 assert(iter
->status_stack
!= NULL
);
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));
704 free(iter
->status_stack
);
705 iter
->status_stack
= NULL
;
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
;
711 iter
->tree
= iter
->tree
->parent
;
713 // Pop subtree params
715 m_config_pop(iter
->config
);
716 if(iter
->mode
== PLAY_TREE_ITER_RND
)
717 iter
->tree
->flags
|= PLAY_TREE_RND_PLAYED
;
720 return play_tree_iter_step(iter
,d
,with_nodes
);
724 play_tree_iter_down_step(play_tree_iter_t
* iter
, int d
,int with_nodes
) {
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");
735 // Push subtree params
737 play_tree_iter_push_params(iter
);
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
;
745 iter
->status_stack
[iter
->stack_size
-1] = iter
->loop
;
747 iter
->loop
= iter
->tree
->loop
-1;
749 iter
->tree
= iter
->tree
->child
;
752 for(pt
= iter
->tree
->child
; pt
->next
!= NULL
; pt
= pt
->next
)
757 return play_tree_iter_step(iter
,0,with_nodes
);
761 play_tree_iter_get_file(play_tree_iter_t
* iter
, int d
) {
763 assert(iter
!= NULL
);
764 assert(iter
->tree
->child
== NULL
);
767 if(iter
->tree
->files
== NULL
)
771 assert(iter
->num_files
> 0);
774 if(iter
->file
>= iter
->num_files
-1 || iter
->file
< -1)
778 if(iter
->file
>= iter
->num_files
- 1)
784 iter
->file
= iter
->num_files
- 1;
788 return iter
->tree
->files
[iter
->file
];
792 play_tree_cleanup(play_tree_t
* pt
) {
793 play_tree_t
* iter
, *tmp
, *first
;
799 if( ! play_tree_is_valid(pt
)) {
800 play_tree_remove(pt
,1,1);
806 for(iter
= pt
->child
; iter
!= NULL
; ) {
809 if(! play_tree_is_valid(tmp
)) {
810 play_tree_remove(tmp
,1,1);
811 if(tmp
== first
) first
= iter
;
815 for(iter
= first
; iter
!= NULL
; ) {
818 play_tree_cleanup(tmp
);
826 play_tree_iter_new_copy(play_tree_iter_t
* old
) {
827 play_tree_iter_t
* iter
;
833 iter
= malloc(sizeof(play_tree_iter_t
));
835 mp_msg(MSGT_PLAYTREE
,MSGL_ERR
,"Can't allocate %d bytes of memory\n",(int)sizeof(play_tree_iter_t
));
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));
847 memcpy(iter
->status_stack
,old
->status_stack
,iter
->stack_size
*sizeof(int));
854 // HIGH Level API, by Fabian Franz (mplayer@fabian-franz.de)
856 play_tree_iter_t
* pt_iter_create(play_tree_t
** ppt
, m_config_t
* config
)
858 play_tree_iter_t
* r
=NULL
;
863 *ppt
=play_tree_cleanup(*ppt
);
866 r
= play_tree_iter_new(*ppt
,config
);
867 if (r
&& play_tree_iter_step(r
,0,0) != PLAY_TREE_ITER_ENTRY
)
869 play_tree_iter_free(r
);
877 void pt_iter_destroy(play_tree_iter_t
** iter
)
886 char* pt_iter_get_file(play_tree_iter_t
* iter
, int d
)
894 r
= play_tree_iter_get_file(iter
,d
);
898 if (play_tree_iter_step(iter
,d
,0) != PLAY_TREE_ITER_ENTRY
)
900 r
=play_tree_iter_get_file(iter
,d
);
907 void pt_iter_insert_entry(play_tree_iter_t
* iter
, play_tree_t
* entry
)
909 play_tree_t
*pt
= iter
->tree
;
916 play_tree_insert_entry(pt
, entry
);
917 play_tree_set_params_from(entry
,pt
);
920 void pt_iter_replace_entry(play_tree_iter_t
* iter
, play_tree_t
* entry
)
922 play_tree_t
*pt
= iter
->tree
;
924 pt_iter_insert_entry(iter
, entry
);
925 play_tree_remove(pt
, 1, 1);
929 //Add a new file as a new entry
930 void pt_add_file(play_tree_t
** ppt
, char* filename
)
932 play_tree_t
*pt
= *ppt
, *entry
= play_tree_new();
937 play_tree_add_file(entry
, filename
);
939 play_tree_append_entry(pt
, entry
);
945 play_tree_set_params_from(entry
,pt
);
948 void pt_iter_goto_head(play_tree_iter_t
* iter
)
950 iter
->tree
=iter
->root
;
951 play_tree_iter_step(iter
, 0, 0);