29 files changed, 164 insertions, 121 deletions

diff --git a/deadbeef.h b/deadbeef.h
index aed3e999..26eb3e11 100644
--- a/deadbeef.h
+++ b/deadbeef.h
@@ -421,7 +421,6 @@ typedef struct {
     DB_playItem_t * (*plt_load) (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
     int (*plt_save) (ddb_playlist_t *plt, DB_playItem_t *first, DB_playItem_t *last, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
 
-    // getting and working with a handle must be guarded using plt_lock/unlock
     ddb_playlist_t *(*plt_get_for_idx) (int idx);
     int (*plt_get_title) (ddb_playlist_t *plt, char *buffer, int bufsize);
     int (*plt_set_title) (ddb_playlist_t *plt, const char *title);
@@ -433,6 +432,9 @@ typedef struct {
     // the index is incremented by 1 every time playlist changes
     int (*plt_get_modification_idx) (ddb_playlist_t *handle);
 
+    // return index of an item in specified playlist, or -1 if not found
+    int (*plt_get_item_idx) (ddb_playlist_t *plt, DB_playItem_t *it, int iter);
+
     // playlist metadata
     // this kind of metadata is stored in playlist (dbpl) files
     void (*plt_add_meta) (ddb_playlist_t *handle, const char *key, const char *value);
@@ -450,6 +452,7 @@ typedef struct {
     // operating on playlist items
     DB_playItem_t * (*plt_insert_item) (ddb_playlist_t *playlist, DB_playItem_t *after, DB_playItem_t *it);
     DB_playItem_t * (*plt_insert_file) (ddb_playlist_t *playlist, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+    DB_playItem_t *(*plt_insert_dir) (ddb_playlist_t *plt, DB_playItem_t *after, const char *dirname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
     void (*plt_set_item_duration) (ddb_playlist_t *plt, DB_playItem_t *it, float duration);
 
     // playlist locking
@@ -464,8 +467,8 @@ typedef struct {
     void (*pl_item_copy) (DB_playItem_t *out, DB_playItem_t *in);
 
     // add files and folders to current playlist
-    int (*pl_add_file) (const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
-    int (*pl_add_dir) (const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+    int (*plt_add_file) (ddb_playlist_t *plt, const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+    int (*plt_add_dir) (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
 
     // this function may return -1 if it is not possible to add files right now.
     // caller must cancel operation in this case, or wait until previous add
@@ -480,8 +483,6 @@ typedef struct {
     // NOTE: many of pl_* functions, especially the ones that operate on current
     // playlist, are going to be nuked somewhere around 0.6 release, in favor of
     // more explicit plt_* family
-    DB_playItem_t *(*pl_insert_dir) (DB_playItem_t *after, const char *dirname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
-    DB_playItem_t *(*pl_insert_file) (DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
     int (*pl_get_idx_of) (DB_playItem_t *it);
     int (*pl_get_idx_of_iter) (DB_playItem_t *it, int iter);
     DB_playItem_t * (*pl_get_for_idx) (int idx);
@@ -538,6 +539,9 @@ typedef struct {
     void (*pl_search_reset) (void);
     void (*pl_search_process) (const char *text);
 
+    // find which playlist the specified item belongs to, returns NULL if none
+    ddb_playlist_t * (*pl_get_playlist) (DB_playItem_t *it);
+
     // direct access to metadata structures
     // not thread-safe, make sure to wrap with pl_lock/pl_unlock
     DB_metaInfo_t * (*pl_get_metadata_head) (DB_playItem_t *it); // returns head of metadata linked list
@@ -559,7 +563,6 @@ typedef struct {
     float (*pl_find_meta_float) (DB_playItem_t *it, const char *key, float def);
     void (*pl_replace_meta) (DB_playItem_t *it, const char *key, const char *value);
     void (*pl_delete_all_meta) (DB_playItem_t *it);
-    void (*pl_set_item_duration) (DB_playItem_t *it, float duration);
     float (*pl_get_item_duration) (DB_playItem_t *it);
     uint32_t (*pl_get_item_flags) (DB_playItem_t *it);
     void (*pl_set_item_flags) (DB_playItem_t *it, uint32_t flags);
diff --git a/main.c b/main.c
index f398aaa6..c671a58f 100644
--- a/main.c
+++ b/main.c
@@ -264,8 +264,8 @@ server_exec_command_line (const char *cmdline, int len, char *sendback, int sbsi
                 else {
                     pname = parg;
                 }
-                if (deadbeef->pl_add_dir (pname, NULL, NULL) < 0) {
-                    if (deadbeef->pl_add_file (pname, NULL, NULL) < 0) {
+                if (deadbeef->plt_add_dir ((ddb_playlist_t*)curr_plt, pname, NULL, NULL) < 0) {
+                    if (deadbeef->plt_add_file ((ddb_playlist_t*)curr_plt, pname, NULL, NULL) < 0) {
                         fprintf (stderr, "failed to add file or folder %s\n", pname);
                     }
                 }
@@ -273,6 +273,7 @@ server_exec_command_line (const char *cmdline, int len, char *sendback, int sbsi
                 parg++;
             }
             deadbeef->pl_add_files_end ();
+            plt_unref (curr_plt);
         }
         messagepump_push (DB_EV_PLAYLIST_REFRESH, 0, 0, 0);
         if (!queue) {
diff --git a/playlist.c b/playlist.c
index 79bff1a9..87c9d354 100644
--- a/playlist.c
+++ b/playlist.c
@@ -844,7 +844,7 @@ pl_cue_parse_time (const char *p) {
 }
 
 static playItem_t *
-pl_process_cue_track (playItem_t *after, const char *fname, playItem_t **prev, char *track, char *index00, char *index01, char *pregap, char *title, char *albumperformer, char *performer, char *albumtitle, char *genre, char *date, char *replaygain_album_gain, char *replaygain_album_peak, char *replaygain_track_gain, char *replaygain_track_peak, const char *decoder_id, const char *ftype, int samplerate) {
+plt_process_cue_track (playlist_t *playlist, playItem_t *after, const char *fname, playItem_t **prev, char *track, char *index00, char *index01, char *pregap, char *title, char *albumperformer, char *performer, char *albumtitle, char *genre, char *date, char *replaygain_album_gain, char *replaygain_album_peak, char *replaygain_track_gain, char *replaygain_track_peak, const char *decoder_id, const char *ftype, int samplerate) {
     if (!track[0]) {
         trace ("pl_process_cue_track: invalid track (file=%s, title=%s)\n", fname, title);
         return after;
@@ -888,7 +888,7 @@ pl_process_cue_track (playItem_t *after, const char *fname, playItem_t **prev, c
             return after;
         }
         (*prev)->endsample = (prevtime * samplerate) - 1;
-        pl_set_item_duration (*prev, (float)((*prev)->endsample - (*prev)->startsample + 1) / samplerate);
+        plt_set_item_duration (playlist, *prev, (float)((*prev)->endsample - (*prev)->startsample + 1) / samplerate);
         if (pl_get_item_duration (*prev) < 0) {
             // might be bad cuesheet file, try to fix
             trace ("cuesheet seems to be corrupted, trying workaround\n");
@@ -896,7 +896,7 @@ pl_process_cue_track (playItem_t *after, const char *fname, playItem_t **prev, c
             prevtime = f_index01;
             (*prev)->endsample = (prevtime * samplerate) - 1;
             float dur = (float)((*prev)->endsample - (*prev)->startsample + 1) / samplerate;
-            pl_set_item_duration (*prev, dur);
+            plt_set_item_duration (playlist, *prev, dur);
             if (dur > 0) {
                 trace ("success :-D\n");
             }
@@ -1032,7 +1032,7 @@ plt_insert_cue_from_buffer (playlist_t *playlist, playItem_t *after, playItem_t
             if (title[0]) {
                 // add previous track
                 const char *filetype = pl_find_meta (origin, ":FILETYPE");
-                after = pl_process_cue_track (after, pl_find_meta (origin, ":URI"), &prev, track, index00, index01, pregap, title, albumperformer, performer, albumtitle, genre, date, replaygain_album_gain, replaygain_album_peak, replaygain_track_gain, replaygain_track_peak, pl_find_meta (origin, ":DECODER"), filetype, samplerate);
+                after = plt_process_cue_track (playlist, after, pl_find_meta (origin, ":URI"), &prev, track, index00, index01, pregap, title, albumperformer, performer, albumtitle, genre, date, replaygain_album_gain, replaygain_album_peak, replaygain_track_gain, replaygain_track_peak, pl_find_meta (origin, ":DECODER"), filetype, samplerate);
                 trace ("cue: added %p (%p)\n", after);
             }
 
@@ -1077,11 +1077,11 @@ plt_insert_cue_from_buffer (playlist_t *playlist, playItem_t *after, playItem_t
         return NULL;
     }
     const char *filetype = pl_find_meta (origin, ":FILETYPE");
-    after = pl_process_cue_track (after, pl_find_meta (origin, ":URI"), &prev, track, index00, index01, pregap, title, albumperformer, performer, albumtitle, genre, date, replaygain_album_gain, replaygain_album_peak, replaygain_track_gain, replaygain_track_peak, pl_find_meta (origin, ":DECODER"), filetype, samplerate);
+    after = plt_process_cue_track (playlist, after, pl_find_meta (origin, ":URI"), &prev, track, index00, index01, pregap, title, albumperformer, performer, albumtitle, genre, date, replaygain_album_gain, replaygain_album_peak, replaygain_track_gain, replaygain_track_peak, pl_find_meta (origin, ":DECODER"), filetype, samplerate);
     if (after) {
         trace ("last track endsample: %d\n", numsamples-1);
         after->endsample = numsamples-1;
-        pl_set_item_duration (after, (float)(after->endsample - after->startsample + 1) / samplerate);
+        plt_set_item_duration (playlist, after, (float)(after->endsample - after->startsample + 1) / samplerate);
     }
     // add caller ref
     if (after && after != ins) {
@@ -1137,7 +1137,7 @@ plt_insert_cue (playlist_t *plt, playItem_t *after, playItem_t *origin, int nums
 }
 
 playItem_t *
-pl_insert_m3u (playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
+plt_insert_m3u (playlist_t *plt, playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
     trace ("enter pl_insert_m3u\n");
     // skip all empty lines and comments
     DB_FILE *fp = vfs_fopen (fname);
@@ -1180,7 +1180,7 @@ pl_insert_m3u (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
         memcpy (nm, p, n);
         nm[n] = 0;
         trace ("pl_insert_m3u: adding file %s\n", nm);
-        playItem_t *it = pl_insert_file (after, nm, pabort, cb, user_data);
+        playItem_t *it = plt_insert_file (plt, after, nm, pabort, cb, user_data);
         if (it) {
             after = it;
         }
@@ -1198,8 +1198,8 @@ pl_insert_m3u (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
 
 // that has to be opened with vfs functions to allow loading from http, as
 // referenced from M3U.
-playItem_t *
-pl_insert_pls (playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
+static playItem_t *
+plt_insert_pls (playlist_t *playlist, playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
     DB_FILE *fp = vfs_fopen (fname);
     if (!fp) {
         trace ("failed to open file %s\n", fname);
@@ -1258,10 +1258,10 @@ pl_insert_pls (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
             int idx = atoi (p + 4);
             if (url[0] && idx != lastidx && lastidx != -1) {
                 // add track
-                playItem_t *it = pl_insert_file (after, url, pabort, cb, user_data);
+                playItem_t *it = plt_insert_file (playlist, after, url, pabort, cb, user_data);
                 if (it) {
                     after = it;
-                    pl_set_item_duration (it, atoi (length));
+                    plt_set_item_duration (playlist, it, atoi (length));
                     if (title[0]) {
                         pl_delete_all_meta (it);
                         pl_add_meta (it, "title", title);
@@ -1298,10 +1298,10 @@ pl_insert_pls (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
             int idx = atoi (p + 5);
             if (url[0] && idx != lastidx && lastidx != -1) {
                 // add track
-                playItem_t *it = pl_insert_file (after, url, pabort, cb, user_data);
+                playItem_t *it = plt_insert_file (playlist, after, url, pabort, cb, user_data);
                 if (it) {
                     after = it;
-                    pl_set_item_duration (it, atoi (length));
+                    plt_set_item_duration (playlist, it, atoi (length));
                     if (title[0]) {
                         pl_delete_all_meta (it);
                         pl_add_meta (it, "title", title);
@@ -1338,7 +1338,7 @@ pl_insert_pls (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
             int idx = atoi (p + 6);
             if (url[0] && idx != lastidx && lastidx != -1) {
                 // add track
-                playItem_t *it = pl_insert_file (after, url, pabort, cb, user_data);
+                playItem_t *it = plt_insert_file (playlist, after, url, pabort, cb, user_data);
                 if (it) {
                     after = it;
                     if (title[0]) {
@@ -1381,7 +1381,7 @@ pl_insert_pls (playItem_t *after, const char *fname, int *pabort, int (*cb)(play
         p = e;
     }
     if (url[0]) {
-        playItem_t *it = pl_insert_file (after, url, pabort, cb, user_data);
+        playItem_t *it = plt_insert_file (playlist, after, url, pabort, cb, user_data);
         if (it) {
             after = it;
             if (title[0]) {
@@ -1400,9 +1400,6 @@ playItem_t *
 plt_insert_dir_int (playlist_t *playlist, DB_vfs_t *vfs, playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
 
 playItem_t *
-pl_insert_dir_int (DB_vfs_t *vfs, playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
-
-playItem_t *
 plt_insert_file (playlist_t *playlist, playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
     trace ("count: %d\n", playlist->count[PL_MAIN]);
     trace ("pl_insert_file %s\n", fname);
@@ -1418,7 +1415,7 @@ plt_insert_file (playlist_t *playlist, playItem_t *after, const char *fname, int
                 trace ("%s cont test\n", fname);
                 if (vfsplugs[i]->is_container (fname)) {
                     trace ("inserting %s via vfs %s\n", fname, vfsplugs[i]->plugin.id);
-                    playItem_t *it = pl_insert_dir_int (vfsplugs[i], after, fname, pabort, cb, user_data);
+                    playItem_t *it = plt_insert_dir_int (playlist, vfsplugs[i], after, fname, pabort, cb, user_data);
                     if (it) {
                         return it;
                     }
@@ -1447,11 +1444,11 @@ plt_insert_file (playlist_t *playlist, playItem_t *after, const char *fname, int
     // so that remote playlist files referenced from other playlist files could
     // be loaded correctly
     if (!strncmp (eol, "m3u", 3) || !strncmp (eol, "m3u8", 4)) {
-        return pl_insert_m3u (after, fname, pabort, cb, user_data);
+        return plt_insert_m3u (playlist, after, fname, pabort, cb, user_data);
     }
     else if (!strncmp (eol, "pls", 3)) {
 
-        return pl_insert_pls (after, fname, pabort, cb, user_data);
+        return plt_insert_pls (playlist, after, fname, pabort, cb, user_data);
     }
 
     // add all posible streams as special-case:
@@ -1554,11 +1551,6 @@ plt_insert_file (playlist_t *playlist, playItem_t *after, const char *fname, int
     return NULL;
 }
 
-playItem_t *
-pl_insert_file (playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
-    return plt_insert_file (playlist, after, fname, pabort, cb, user_data);
-}
-
 static int dirent_alphasort (const struct dirent **a, const struct dirent **b) {
     return strcmp ((*a)->d_name, (*b)->d_name);
 }
@@ -1624,18 +1616,12 @@ plt_insert_dir_int (playlist_t *playlist, DB_vfs_t *vfs, playItem_t *after, cons
     return after;
 }
 
-
-playItem_t *
-pl_insert_dir_int (DB_vfs_t *vfs, playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
-    return plt_insert_dir_int (playlist, vfs, after, dirname, pabort, cb, user_data);
-}
-
 playItem_t *
-pl_insert_dir (playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
+plt_insert_dir (playlist_t *playlist, playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data) {
     follow_symlinks = conf_get_int ("add_folders_follow_symlinks", 0);
     ignore_archives = conf_get_int ("ignore_archives", 1);
 
-    playItem_t *ret = pl_insert_dir_int (NULL, after, dirname, pabort, cb, user_data);
+    playItem_t *ret = plt_insert_dir_int (playlist, NULL, after, dirname, pabort, cb, user_data);
 
     ignore_archives = 0;
 
@@ -1643,9 +1629,9 @@ pl_insert_dir (playItem_t *after, const char *dirname, int *pabort, int (*cb)(pl
 }
 
 int
-pl_add_file (const char *fname, int (*cb)(playItem_t *it, void *data), void *user_data) {
+plt_add_file (playlist_t *plt, const char *fname, int (*cb)(playItem_t *it, void *data), void *user_data) {
     int abort = 0;
-    playItem_t *it = pl_insert_file (addfiles_playlist->tail[PL_MAIN], fname, &abort, cb, user_data);
+    playItem_t *it = plt_insert_file (plt, plt->tail[PL_MAIN], fname, &abort, cb, user_data);
     if (it) {
         // pl_insert_file doesn't hold reference, don't unref here
         return 0;
@@ -1654,9 +1640,9 @@ pl_add_file (const char *fname, int (*cb)(playItem_t *it, void *data), void *use
 }
 
 int
-pl_add_dir (const char *dirname, int (*cb)(playItem_t *it, void *data), void *user_data) {
+plt_add_dir (playlist_t *plt, const char *dirname, int (*cb)(playItem_t *it, void *data), void *user_data) {
     int abort = 0;
-    playItem_t *it = pl_insert_dir (addfiles_playlist->tail[PL_MAIN], dirname, &abort, cb, user_data);
+    playItem_t *it = plt_insert_dir (plt, plt->tail[PL_MAIN], dirname, &abort, cb, user_data);
     if (it) {
         // pl_insert_file doesn't hold reference, don't unref here
         return 0;
@@ -2672,13 +2658,6 @@ plt_set_item_duration (playlist_t *playlist, playItem_t *it, float duration) {
     UNLOCK;
 }
 
-void
-pl_set_item_duration (playItem_t *it, float duration) {
-    LOCK;
-    plt_set_item_duration (playlist, it, duration);
-    UNLOCK;
-}
-
 float
 pl_get_item_duration (playItem_t *it) {
     return it->_duration;
@@ -3800,3 +3779,37 @@ pl_set_item_flags (playItem_t *it, uint32_t flags) {
     pl_replace_meta (it, ":HAS_EMBEDDED_CUESHEET", (flags & DDB_HAS_EMBEDDED_CUESHEET) ? _("Yes") : _("No"));
     UNLOCK;
 }
+
+int
+plt_get_item_idx (playlist_t *plt, playItem_t *it, int iter) {
+    LOCK;
+    playItem_t *c = plt->head[iter];
+    int idx = 0;
+    while (c && c != it) {
+        c = c->next[iter];
+        idx++;
+    }
+    if (!c) {
+        UNLOCK;
+        return -1;
+    }
+    UNLOCK;
+    return idx;
+}
+
+playlist_t *
+pl_get_playlist (playItem_t *it) {
+    LOCK;
+    playlist_t *p = playlists_head;
+    while (p) {
+        int idx = plt_get_item_idx (p, it, PL_MAIN);
+        if (idx != -1) {
+            plt_ref (p);
+            UNLOCK;
+            return p;
+        }
+        p = p->next;
+    }
+    UNLOCK;
+    return NULL;
+}
diff --git a/playlist.h b/playlist.h
index d114c9a8..a21c6937 100644
--- a/playlist.h
+++ b/playlist.h
@@ -155,10 +155,10 @@ void
 plt_clear (playlist_t *plt);
 
 int
-pl_add_dir (const char *dirname, int (*cb)(playItem_t *it, void *data), void *user_data);
+plt_add_dir (playlist_t *plt, const char *dirname, int (*cb)(playItem_t *it, void *data), void *user_data);
 
 int
-pl_add_file (const char *fname, int (*cb)(playItem_t *it, void *data), void *user_data);
+plt_add_file (playlist_t *plt, const char *fname, int (*cb)(playItem_t *it, void *data), void *user_data);
 
 int
 pl_add_files_begin (playlist_t *plt);
@@ -167,10 +167,7 @@ void
 pl_add_files_end (void);
 
 playItem_t *
-pl_insert_dir (playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
-
-playItem_t *
-pl_insert_file (playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
+plt_insert_dir (playlist_t *plt, playItem_t *after, const char *dirname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
 
 playItem_t *
 plt_insert_file (playlist_t *playlist, playItem_t *after, const char *fname, int *pabort, int (*cb)(playItem_t *it, void *data), void *user_data);
@@ -293,9 +290,6 @@ pl_reshuffle (playItem_t **ppmin, playItem_t **ppmax);
 void
 plt_set_item_duration (playlist_t *playlist, playItem_t *it, float duration);
 
-void
-pl_set_item_duration (playItem_t *it, float duration);
-
 float
 pl_get_item_duration (playItem_t *it);
 
@@ -404,4 +398,10 @@ pl_set_order (int order);
 int
 pl_get_order (void);
 
+int
+plt_get_item_idx (playlist_t *plt, playItem_t *it, int iter);
+
+playlist_t *
+pl_get_playlist (playItem_t *it);
+
 #endif // __PLAYLIST_H
diff --git a/plugins.c b/plugins.c
index 58af000e..44f83039 100644
--- a/plugins.c
+++ b/plugins.c
@@ -127,6 +127,7 @@ static DB_functions_t deadbeef_api = {
     .plt_set_title = (int (*)(ddb_playlist_t *handle, const char *buffer))plt_set_title,
     .plt_modified = (void (*) (ddb_playlist_t *handle))plt_modified,
     .plt_get_modification_idx = (int (*) (ddb_playlist_t *handle))plt_get_modification_idx,
+    .plt_get_item_idx = (int (*) (ddb_playlist_t *plt, DB_playItem_t *it, int iter))plt_get_item_idx,
 
     // playlist metadata
     .plt_add_meta = (void (*) (ddb_playlist_t *handle, const char *key, const char *value))plt_add_meta,
@@ -144,6 +145,7 @@ static DB_functions_t deadbeef_api = {
     // operating on playlist items
     .plt_insert_item = (DB_playItem_t *(*) (ddb_playlist_t *playlist, DB_playItem_t *after, DB_playItem_t *it))plt_insert_item,
     .plt_insert_file = (DB_playItem_t *(*) (ddb_playlist_t *playlist, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data))plt_insert_file,
+    .plt_insert_dir = (DB_playItem_t *(*) (ddb_playlist_t *plt, DB_playItem_t *after, const char *dirname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data))plt_insert_dir,
     .plt_set_item_duration = (void (*) (ddb_playlist_t *plt, DB_playItem_t *it, float duration))plt_set_item_duration,
 
     // playlist access
@@ -156,18 +158,14 @@ static DB_functions_t deadbeef_api = {
     .pl_item_ref = (void (*)(DB_playItem_t *))pl_item_ref,
     .pl_item_unref = (void (*)(DB_playItem_t *))pl_item_unref,
     .pl_item_copy = (void (*)(DB_playItem_t *, DB_playItem_t *))pl_item_copy,
-    .pl_add_file = (int (*) (const char *, int (*cb)(DB_playItem_t *it, void *data), void *))pl_add_file,
-    .pl_add_dir = (int (*) (const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data))pl_add_dir,
+    .plt_add_file = (int (*) (ddb_playlist_t *plt, const char *, int (*cb)(DB_playItem_t *it, void *data), void *))plt_add_file,
+    .plt_add_dir = (int (*) (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data))plt_add_dir,
     .pl_add_files_begin = (int (*) (ddb_playlist_t *plt))pl_add_files_begin,
     .pl_add_files_end = pl_add_files_end,
-//    .pl_insert_item = (DB_playItem_t *(*) (DB_playItem_t *after, DB_playItem_t *it))pl_insert_item,
-    .pl_insert_dir = (DB_playItem_t *(*) (DB_playItem_t *after, const char *dirname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data))pl_insert_dir,
-    .pl_insert_file = (DB_playItem_t *(*) (DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data))pl_insert_file,
     .pl_get_idx_of = (int (*) (DB_playItem_t *it))pl_get_idx_of,
     .pl_get_idx_of_iter = (int (*) (DB_playItem_t *it, int iter))pl_get_idx_of_iter,
     .pl_get_for_idx = (DB_playItem_t * (*)(int))pl_get_for_idx,
     .pl_get_for_idx_and_iter = (DB_playItem_t * (*) (int idx, int iter))pl_get_for_idx_and_iter,
-    .pl_set_item_duration = (void (*) (DB_playItem_t *it, float duration))pl_set_item_duration,
     .pl_get_item_duration = (float (*) (DB_playItem_t *it))pl_get_item_duration,
     .pl_get_item_flags = (uint32_t (*) (DB_playItem_t *it))pl_get_item_flags,
     .pl_set_item_flags = (void (*) (DB_playItem_t *it, uint32_t flags))pl_set_item_flags,
@@ -199,6 +197,7 @@ static DB_functions_t deadbeef_api = {
     .pl_copy_items = (void (*) (int iter, int plt_from, DB_playItem_t *before, uint32_t *indices, int cnt))pl_copy_items,
     .pl_search_reset = pl_search_reset,
     .pl_search_process = pl_search_process,
+    .pl_get_playlist = (ddb_playlist_t * (*) (DB_playItem_t *it))pl_get_playlist,
     // metainfo
     .pl_add_meta = (void (*) (DB_playItem_t *, const char *, const char *))pl_add_meta,
     .pl_append_meta = (void (*) (DB_playItem_t *, const char *, const char *))pl_append_meta,
diff --git a/plugins/aac/aac.c b/plugins/aac/aac.c
index c751135d..6dfecdfd 100644
--- a/plugins/aac/aac.c
+++ b/plugins/aac/aac.c
@@ -1216,7 +1216,7 @@ aac_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
-    deadbeef->pl_set_item_duration (it, duration);
+    deadbeef->plt_set_item_duration (plt, it, duration);
     trace ("duration: %f sec\n", duration);
 
     // read tags
diff --git a/plugins/adplug/adplug-db.cpp b/plugins/adplug/adplug-db.cpp
index 4b461ff1..98005298 100644
--- a/plugins/adplug/adplug-db.cpp
+++ b/plugins/adplug/adplug-db.cpp
@@ -267,7 +267,7 @@ adplug_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
         DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, adplug_plugin.plugin.id);
         deadbeef->pl_add_meta (it, ":FILETYPE", adplug_get_extension (fname));
         deadbeef->pl_set_meta_int (it, ":TRACKNUM", i);
-        deadbeef->pl_set_item_duration (it, dur);
+        deadbeef->plt_set_item_duration (plt, it, dur);
 #if 0
         // add metainfo
         if (p->gettitle()[0]) {
diff --git a/plugins/ao/plugin.c b/plugins/ao/plugin.c
index 6be17c1e..6d7c1b1d 100644
--- a/plugins/ao/plugin.c
+++ b/plugins/ao/plugin.c
@@ -18,7 +18,7 @@
 */
 #include <stdlib.h>
 #include <string.h>
-#include <deadbeef/deadbeef.h>
+#include "../../deadbeef.h"
 #include "ao.h"
 #include "eng_protos.h"
 
@@ -326,7 +326,7 @@ aoplug_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
             }
         }
     }
-    deadbeef->pl_set_item_duration (it, duration+fade);
+    deadbeef->plt_set_item_duration (plt, it, duration+fade);
     deadbeef->pl_add_meta (it, "title", NULL);
     after = deadbeef->plt_insert_item (plt, after, it);
     deadbeef->pl_item_unref (it);
diff --git a/plugins/cdda/cdda.c b/plugins/cdda/cdda.c
index 6c4d6af7..79f11323 100644
--- a/plugins/cdda/cdda.c
+++ b/plugins/cdda/cdda.c
@@ -321,7 +321,7 @@ insert_single_track (CdIo_t* cdio, ddb_playlist_t *plt, DB_playItem_t *after, co
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (tmp, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "cdda");
-    deadbeef->pl_set_item_duration (it, (float)sector_count / 75.0);
+    deadbeef->plt_set_item_duration (plt, it, (float)sector_count / 75.0);
 
     snprintf (tmp, sizeof (tmp), "CD Track %02d", track_nr);
     deadbeef->pl_add_meta (it, "title", tmp);
@@ -591,7 +591,7 @@ cda_action_add_cd (DB_plugin_action_t *act, DB_playItem_t *it)
     ddb_playlist_t *plt = deadbeef->plt_get_curr ();
     if (plt) {
         deadbeef->pl_add_files_begin (plt);
-        deadbeef->pl_add_file ("all.cda", NULL, NULL);
+        deadbeef->plt_add_file (plt, "all.cda", NULL, NULL);
         deadbeef->pl_add_files_end ();
         deadbeef->plt_modified (plt);
         deadbeef->plt_unref (plt);
diff --git a/plugins/dca/dcaplug.c b/plugins/dca/dcaplug.c
index 29f572e3..63a8e2fd 100644
--- a/plugins/dca/dcaplug.c
+++ b/plugins/dca/dcaplug.c
@@ -684,7 +684,7 @@ dts_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", filetype);
-    deadbeef->pl_set_item_duration (it, dur);
+    deadbeef->plt_set_item_duration (plt, it, dur);
 
     deadbeef->fclose (fp);
 
diff --git a/plugins/dumb/cdumb.c b/plugins/dumb/cdumb.c
index e85ce37a..59eec4ef 100644
--- a/plugins/dumb/cdumb.c
+++ b/plugins/dumb/cdumb.c
@@ -814,7 +814,7 @@ cdumb_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     read_metadata_internal (it, itsd);
 
     dumb_it_do_initial_runthrough (duh);
-    deadbeef->pl_set_item_duration (it, duh_get_length (duh)/65536.0f);
+    deadbeef->plt_set_item_duration (plt, it, duh_get_length (duh)/65536.0f);
     deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
 //    printf ("duration: %f\n", _info->duration);
     after = deadbeef->plt_insert_item (plt, after, it);
diff --git a/plugins/ffap/ffap.c b/plugins/ffap/ffap.c
index 99d965e2..d2fe5d2d 100644
--- a/plugins/ffap/ffap.c
+++ b/plugins/ffap/ffap.c
@@ -1766,7 +1766,7 @@ ffap_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     DB_playItem_t *it = NULL;
     it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "APE");
-    deadbeef->pl_set_item_duration (it, duration);
+    deadbeef->plt_set_item_duration (plt, it, duration);
  
     /*int v2err = */deadbeef->junk_id3v2_read (it, fp);
     int v1err = deadbeef->junk_id3v1_read (it, fp);
diff --git a/plugins/ffmpeg/ffmpeg.c b/plugins/ffmpeg/ffmpeg.c
index e79a06d7..742fc928 100644
--- a/plugins/ffmpeg/ffmpeg.c
+++ b/plugins/ffmpeg/ffmpeg.c
@@ -530,10 +530,10 @@ ffmpeg_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     deadbeef->pl_replace_meta (it, ":FILETYPE", codec->name);
 
     if (!deadbeef->is_local_file (deadbeef->pl_find_meta (it, ":URI"))) {
-        deadbeef->pl_set_item_duration (it, -1);
+        deadbeef->plt_set_item_duration (plt, it, -1);
     }
     else {
-        deadbeef->pl_set_item_duration (it, duration);
+        deadbeef->plt_set_item_duration (plt, it, duration);
     }
 
     // add metainfo
diff --git a/plugins/flac/flac.c b/plugins/flac/flac.c
index 4e52cee2..6485f1a4 100644
--- a/plugins/flac/flac.c
+++ b/plugins/flac/flac.c
@@ -49,6 +49,7 @@ typedef struct {
     DB_FILE *file;
 
     // used only on insert
+    ddb_playlist_t *plt;
     DB_playItem_t *after;
     DB_playItem_t *last;
     DB_playItem_t *it;
@@ -583,7 +584,7 @@ cflac_init_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__Str
         _info->fmt.channels = metadata->data.stream_info.channels;
         _info->fmt.bps = metadata->data.stream_info.bits_per_sample;
         info->totalsamples = metadata->data.stream_info.total_samples;
-        deadbeef->pl_set_item_duration (it, metadata->data.stream_info.total_samples / (float)metadata->data.stream_info.sample_rate);
+        deadbeef->plt_set_item_duration (info->plt, it, metadata->data.stream_info.total_samples / (float)metadata->data.stream_info.sample_rate);
     }
     else if (metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
         const FLAC__StreamMetadata_VorbisComment *vc = &metadata->data.vorbis_comment;
@@ -614,6 +615,7 @@ cflac_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     info.fname = fname;
     info.after = after;
     info.last = after;
+    info.plt = plt;
     info.file = deadbeef->fopen (fname);
     if (!info.file) {
         goto cflac_insert_fail;
diff --git a/plugins/gme/cgme.c b/plugins/gme/cgme.c
index 35070d7c..57788851 100644
--- a/plugins/gme/cgme.c
+++ b/plugins/gme/cgme.c
@@ -333,10 +333,10 @@ cgme_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
                 cgme_add_meta (it, "track", trk);
                 if (inf->length == -1 || inf->length == 0) {
                     float songlength = deadbeef->conf_get_float ("gme.songlength", 3);
-                    deadbeef->pl_set_item_duration (it, songlength * 60.f);
+                    deadbeef->plt_set_item_duration (plt, it, songlength * 60.f);
                 }
                 else {
-                    deadbeef->pl_set_item_duration (it, (float)inf->length/1000.f);
+                    deadbeef->plt_set_item_duration (plt, it, (float)inf->length/1000.f);
                 }
                 const char *ext = fname + strlen (fname) - 1;
                 while (ext >= fname && *ext != '.') {
diff --git a/plugins/gtkui/fileman.c b/plugins/gtkui/fileman.c
index d7353d82..8947c821 100644
--- a/plugins/gtkui/fileman.c
+++ b/plugins/gtkui/fileman.c
@@ -10,13 +10,17 @@
 
 void
 gtkpl_add_dir (DdbListview *ps, char *folder) {
-    gtkui_original_pl_add_dir (folder, gtkui_add_file_info_cb, NULL);
+    ddb_playlist_t *plt = deadbeef->plt_get_curr ();
+    gtkui_original_plt_add_dir (plt, folder, gtkui_add_file_info_cb, NULL);
+    deadbeef->plt_unref (plt);
     g_free (folder);
 }
 
 static void
 gtkpl_adddir_cb (gpointer data, gpointer userdata) {
-    gtkui_original_pl_add_dir (data, gtkui_add_file_info_cb, userdata);
+    ddb_playlist_t *plt = deadbeef->plt_get_curr ();
+    gtkui_original_plt_add_dir (plt, data, gtkui_add_file_info_cb, userdata);
+    deadbeef->plt_unref (plt);
     g_free (data);
 }
 
@@ -52,7 +56,9 @@ gtkpl_add_dirs (GSList *lst) {
 
 static void
 gtkpl_addfile_cb (gpointer data, gpointer userdata) {
-    gtkui_original_pl_add_file (data, gtkui_add_file_info_cb, userdata);
+    ddb_playlist_t *plt = deadbeef->plt_get_curr ();
+    gtkui_original_plt_add_file (plt, data, gtkui_add_file_info_cb, userdata);
+    deadbeef->plt_unref (plt);
     g_free (data);
 }
 
@@ -170,8 +176,10 @@ set_dnd_cursor_idle (gpointer data) {
 
 void
 gtkpl_add_fm_dropped_files (DB_playItem_t *drop_before, char *ptr, int length) {
-    if (deadbeef->pl_add_files_begin (deadbeef->plt_get_curr ()) < 0) {
+    ddb_playlist_t *plt = deadbeef->plt_get_curr ();
+    if (deadbeef->pl_add_files_begin (plt) < 0) {
         free (ptr);
+        deadbeef->plt_unref (plt);
         return;
     }
     DdbListview *pl = DDB_LISTVIEW (lookup_widget (mainwin, "playlist"));
@@ -196,9 +204,9 @@ gtkpl_add_fm_dropped_files (DB_playItem_t *drop_before, char *ptr, int length) {
             //strncpy (fname, p, pe - p);
             //fname[pe - p] = 0;
             int abort = 0;
-            DdbListviewIter inserted = deadbeef->pl_insert_dir (after, fname, &abort, gtkui_add_file_info_cb, NULL);
+            DdbListviewIter inserted = deadbeef->plt_insert_dir (plt, after, fname, &abort, gtkui_add_file_info_cb, NULL);
             if (!inserted && !abort) {
-                inserted = deadbeef->pl_insert_file (after, fname, &abort, gtkui_add_file_info_cb, NULL);
+                inserted = deadbeef->plt_insert_file (plt, after, fname, &abort, gtkui_add_file_info_cb, NULL);
             }
             if (inserted) {
                 if (!first) {
@@ -223,6 +231,7 @@ gtkpl_add_fm_dropped_files (DB_playItem_t *drop_before, char *ptr, int length) {
     free (ptr);
 
     deadbeef->pl_add_files_end ();
+    deadbeef->plt_unref (plt);
     g_idle_add (set_dnd_cursor_idle, first);
 }
 
diff --git a/plugins/gtkui/gtkui.c b/plugins/gtkui/gtkui.c
index 8967e2ac..8699706d 100644
--- a/plugins/gtkui/gtkui.c
+++ b/plugins/gtkui/gtkui.c
@@ -806,11 +806,15 @@ on_add_location_activate               (GtkMenuItem     *menuitem,
         if (entry) {
             const char *text = gtk_entry_get_text (entry);
             if (text) {
-                if (!deadbeef->pl_add_files_begin (deadbeef->plt_get_curr ())) {
-                    deadbeef->pl_add_file (text, NULL, NULL);
+                ddb_playlist_t *plt = deadbeef->plt_get_curr ();
+                if (!deadbeef->pl_add_files_begin (plt)) {
+                    deadbeef->plt_add_file (plt, text, NULL, NULL);
                     deadbeef->pl_add_files_end ();
                     playlist_refresh ();
                 }
+                if (plt) {
+                    deadbeef->plt_unref (plt);
+                }
             }
         }
     }
@@ -1132,22 +1136,22 @@ gtkui_add_file_info_cb (DB_playItem_t *it, void *data) {
     return 0;
 }
 
-int (*gtkui_original_pl_add_dir) (const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
-int (*gtkui_original_pl_add_file) (const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+int (*gtkui_original_plt_add_dir) (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+int (*gtkui_original_plt_add_file) (ddb_playlist_t *plt, const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
 int (*gtkui_original_pl_add_files_begin) (ddb_playlist_t *plt);
 void (*gtkui_original_pl_add_files_end) (void);
 
 DB_playItem_t * (*gtkui_original_plt_load) (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
 
 int
-gtkui_pl_add_dir (const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data) {
-    int res = gtkui_original_pl_add_dir (dirname, gtkui_add_file_info_cb, NULL);
+gtkui_plt_add_dir (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data) {
+    int res = gtkui_original_plt_add_dir (plt, dirname, gtkui_add_file_info_cb, NULL);
     return res;
 }
 
 int
-gtkui_pl_add_file (const char *filename, int (*cb)(DB_playItem_t *it, void *data), void *user_data) {
-    int res = gtkui_original_pl_add_file (filename, gtkui_add_file_info_cb, NULL);
+gtkui_plt_add_file (ddb_playlist_t *plt, const char *filename, int (*cb)(DB_playItem_t *it, void *data), void *user_data) {
+    int res = gtkui_original_plt_add_file (plt, filename, gtkui_add_file_info_cb, NULL);
     return res;
 }
 
@@ -1211,11 +1215,11 @@ gtkui_start (void) {
     }
 
     // override default file adding APIs to show progress bar
-    gtkui_original_pl_add_dir = deadbeef->pl_add_dir;
-    deadbeef->pl_add_dir = gtkui_pl_add_dir;
+    gtkui_original_plt_add_dir = deadbeef->plt_add_dir;
+    deadbeef->plt_add_dir = gtkui_plt_add_dir;
 
-    gtkui_original_pl_add_file = deadbeef->pl_add_file;
-    deadbeef->pl_add_file = gtkui_pl_add_file;
+    gtkui_original_plt_add_file = deadbeef->plt_add_file;
+    deadbeef->plt_add_file = gtkui_plt_add_file;
 
     gtkui_original_pl_add_files_begin = deadbeef->pl_add_files_begin;
     deadbeef->pl_add_files_begin = gtkui_pl_add_files_begin;
diff --git a/plugins/gtkui/gtkui.h b/plugins/gtkui/gtkui.h
index dfc73455..073262c5 100644
--- a/plugins/gtkui/gtkui.h
+++ b/plugins/gtkui/gtkui.h
@@ -154,8 +154,8 @@ gtkui_set_progress_text_idle (gpointer data);
 int
 gtkui_add_file_info_cb (DB_playItem_t *it, void *data);
 
-extern int (*gtkui_original_pl_add_dir) (const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
-extern int (*gtkui_original_pl_add_file) (const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+extern int (*gtkui_original_plt_add_dir) (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
+extern int (*gtkui_original_plt_add_file) (ddb_playlist_t *plt, const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data);
 
 void
 gtkui_focus_on_playing_track (void);
diff --git a/plugins/m3u/m3u.c b/plugins/m3u/m3u.c
index fae1f6c6..e293dc2a 100644
--- a/plugins/m3u/m3u.c
+++ b/plugins/m3u/m3u.c
@@ -87,7 +87,7 @@ load_m3u (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pab
         DB_playItem_t *it = NULL;
         if (strrchr (nm, '/')) {
             trace ("pl_insert_m3u: adding file %s\n", nm);
-            it = deadbeef->pl_insert_file (after, nm, pabort, cb, user_data);
+            it = deadbeef->plt_insert_file (plt, after, nm, pabort, cb, user_data);
         }
         else {
             int l = strlen (nm);
@@ -95,7 +95,7 @@ load_m3u (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pab
             memcpy (fullpath, fname, slash - fname + 1);
             strcpy (fullpath + (slash - fname + 1), nm);
             trace ("pl_insert_m3u: adding file %s\n", fullpath);
-            it = deadbeef->pl_insert_file (after, fullpath, pabort, cb, user_data);
+            it = deadbeef->plt_insert_file (plt, after, fullpath, pabort, cb, user_data);
         }
         if (it) {
             after = it;
diff --git a/plugins/mpgmad/mpgmad.c b/plugins/mpgmad/mpgmad.c
index 3b7c23b5..adda106c 100644
--- a/plugins/mpgmad/mpgmad.c
+++ b/plugins/mpgmad/mpgmad.c
@@ -823,7 +823,11 @@ cmp3_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
             trace ("mp3 totalsamples: %d\n", info->buffer.endsample-info->buffer.startsample+1);
         }
         else {
-            deadbeef->pl_set_item_duration (it, info->buffer.duration);
+            ddb_playlist_t *plt = deadbeef->pl_get_playlist (it);
+            deadbeef->plt_set_item_duration (plt, it, info->buffer.duration);
+            if (plt) {
+                deadbeef->plt_unref (plt);
+            }
             info->buffer.startsample = info->buffer.delay;
             info->buffer.endsample = info->buffer.totalsamples-info->buffer.padding-1;
             trace ("mp3 totalsamples: %d (%d, %d, %d | %d %d)\n", info->buffer.endsample-info->buffer.startsample+1, info->buffer.totalsamples, info->buffer.delay, info->buffer.padding, info->buffer.startsample, info->buffer.endsample);
@@ -854,7 +858,11 @@ cmp3_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
 
         cmp3_set_extra_properties (&info->buffer);
 
-        deadbeef->pl_set_item_duration (it, info->buffer.duration);
+        ddb_playlist_t *plt = deadbeef->pl_get_playlist (it);
+        deadbeef->plt_set_item_duration (plt, it, info->buffer.duration);
+        if (plt) {
+            deadbeef->plt_unref (plt);
+        }
         if (info->buffer.duration >= 0) {
             info->buffer.endsample = info->buffer.totalsamples - 1;
         }
@@ -1310,7 +1318,7 @@ cmp3_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
         DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
         deadbeef->fclose (fp);
         deadbeef->pl_add_meta (it, "title", NULL);
-        deadbeef->pl_set_item_duration (it, -1);
+        deadbeef->plt_set_item_duration (plt, it, -1);
         after = deadbeef->plt_insert_item (plt, after, it);
         deadbeef->pl_item_unref (it);
         return after;
diff --git a/plugins/musepack/musepack.c b/plugins/musepack/musepack.c
index 68f93013..2a5d9766 100644
--- a/plugins/musepack/musepack.c
+++ b/plugins/musepack/musepack.c
@@ -401,11 +401,11 @@ musepack_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
             else {
                 prev->endsample = it->startsample-1;
                 float dur = (prev->endsample - prev->startsample) / (float)si.sample_freq;
-                deadbeef->pl_set_item_duration (prev, dur);
+                deadbeef->plt_set_item_duration (plt, prev, dur);
             }
             if (i == nchapters - 1) {
                 float dur = (it->endsample - it->startsample) / (float)si.sample_freq;
-                deadbeef->pl_set_item_duration (it, dur);
+                deadbeef->plt_set_item_duration (plt, it, dur);
             }
             if (ch->tag_size > 0) {
                 uint8_t *tag = ch->tag;
@@ -432,7 +432,7 @@ musepack_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "MusePack");
-    deadbeef->pl_set_item_duration (it, dur);
+    deadbeef->plt_set_item_duration (plt, it, dur);
 
     /*int apeerr = */deadbeef->junk_apev2_read (it, fp);
     deadbeef->pl_set_item_replaygain (it, DDB_REPLAYGAIN_ALBUMGAIN, gain_album);
diff --git a/plugins/shn/shn.c b/plugins/shn/shn.c
index c8e0a773..c7f20149 100644
--- a/plugins/shn/shn.c
+++ b/plugins/shn/shn.c
@@ -896,7 +896,7 @@ shn_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
 	DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "Shorten");
-    deadbeef->pl_set_item_duration (it, tmp_file->wave_header.length);
+    deadbeef->plt_set_item_duration (plt, it, tmp_file->wave_header.length);
 
     int apeerr = deadbeef->junk_apev2_read (it, tmp_file->vars.fd);
     int v2err = deadbeef->junk_id3v2_read (it, tmp_file->vars.fd);
diff --git a/plugins/sid/csid.cpp b/plugins/sid/csid.cpp
index 569c1083..b82491e7 100644
--- a/plugins/sid/csid.cpp
+++ b/plugins/sid/csid.cpp
@@ -566,7 +566,7 @@ csid_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
                 //            trace ("\n");
                 //        }
             }
-            deadbeef->pl_set_item_duration (it, length);
+            deadbeef->plt_set_item_duration (plt, it, length);
             deadbeef->pl_add_meta (it, ":FILETYPE", "SID");
 
             after = deadbeef->plt_insert_item (plt, after, it);
diff --git a/plugins/sndfile/sndfile.c b/plugins/sndfile/sndfile.c
index 259fdfd6..f5db72d6 100644
--- a/plugins/sndfile/sndfile.c
+++ b/plugins/sndfile/sndfile.c
@@ -318,7 +318,7 @@ sndfile_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     float duration = (float)totalsamples / samplerate;
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "wav");
-    deadbeef->pl_set_item_duration (it, duration);
+    deadbeef->plt_set_item_duration (plt, it, duration);
 
     trace ("sndfile: totalsamples=%d, samplerate=%d, duration=%f\n", totalsamples, samplerate, duration);
 
diff --git a/plugins/tta/ttaplug.c b/plugins/tta/ttaplug.c
index 30f7fc38..3c44003d 100644
--- a/plugins/tta/ttaplug.c
+++ b/plugins/tta/ttaplug.c
@@ -195,7 +195,7 @@ tta_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "TTA");
-    deadbeef->pl_set_item_duration (it, dur);
+    deadbeef->plt_set_item_duration (plt, it, dur);
 
     close_tta_file (&tta);
     DB_FILE *fp = deadbeef->fopen (fname);
diff --git a/plugins/vorbis/vorbis.c b/plugins/vorbis/vorbis.c
index ad95d649..f64645df 100644
--- a/plugins/vorbis/vorbis.c
+++ b/plugins/vorbis/vorbis.c
@@ -220,7 +220,11 @@ cvorbis_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
             trace ("ov_open_callbacks returned %d\n", err);
             return -1;
         }
-        deadbeef->pl_set_item_duration (it, -1);
+        ddb_playlist_t *plt = deadbeef->pl_get_playlist (it);
+        deadbeef->plt_set_item_duration (plt, it, -1);
+        if (plt) {
+            deadbeef->plt_unref (plt);
+        }
         deadbeef->pl_replace_meta (it, ":FILETYPE", "OggVorbis");
     }
     else
@@ -463,7 +467,7 @@ cvorbis_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     if (fp->vfs->is_streaming ()) {
         DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
         deadbeef->pl_add_meta (it, ":FILETYPE", "OggVorbis");
-        deadbeef->pl_set_item_duration (it, -1);
+        deadbeef->plt_set_item_duration (plt, it, -1);
         deadbeef->pl_add_meta (it, "title", NULL);
         after = deadbeef->plt_insert_item (plt, after, it);
         deadbeef->pl_item_unref (it);
@@ -500,7 +504,7 @@ cvorbis_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
         DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
         deadbeef->pl_add_meta (it, ":FILETYPE", "OggVorbis");
         deadbeef->pl_set_meta_int (it, ":TRACKNUM", stream);
-        deadbeef->pl_set_item_duration (it, duration);
+        deadbeef->plt_set_item_duration (plt, it, duration);
         if (nstreams > 1) {
             it->startsample = currentsample;
             it->endsample = currentsample + totalsamples;
diff --git a/plugins/vtx/vtx.c b/plugins/vtx/vtx.c
index a24da110..ffb14c7e 100644
--- a/plugins/vtx/vtx.c
+++ b/plugins/vtx/vtx.c
@@ -263,7 +263,7 @@ vtx_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     int numframes = hdr->regdata_size / AY_FRAME_SIZE;
 //    int totalsamples = numframes * hdr->playerFreq;
     trace ("vtx: numframes=%d, playerFreq=%d\n", numframes, hdr->playerFreq);
-    deadbeef->pl_set_item_duration (it, (float)numframes / hdr->playerFreq);
+    deadbeef->plt_set_item_duration (plt, it, (float)numframes / hdr->playerFreq);
 
     // add metadata
     deadbeef->pl_add_meta (it, "title", hdr->title);
diff --git a/plugins/wavpack/wavpack.c b/plugins/wavpack/wavpack.c
index 01f218f2..75f1d47b 100644
--- a/plugins/wavpack/wavpack.c
+++ b/plugins/wavpack/wavpack.c
@@ -297,7 +297,7 @@ wv_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
 
     DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
     deadbeef->pl_add_meta (it, ":FILETYPE", "wv");
-    deadbeef->pl_set_item_duration (it, duration);
+    deadbeef->plt_set_item_duration (plt, it, duration);
     trace ("wv: totalsamples=%d, samplerate=%d, duration=%f\n", totalsamples, samplerate, duration);
 
 #if 0
diff --git a/plugins/wildmidi/wildmidiplug.c b/plugins/wildmidi/wildmidiplug.c
index 0db8b525..d989c695 100644
--- a/plugins/wildmidi/wildmidiplug.c
+++ b/plugins/wildmidi/wildmidiplug.c
@@ -119,7 +119,7 @@ wmidi_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
     struct _WM_Info *inf = WildMidi_GetInfo (m);
     it = deadbeef->pl_item_alloc_init (fname, wmidi_plugin.plugin.id);
     deadbeef->pl_add_meta (it, "title", NULL);
-    deadbeef->pl_set_item_duration (it, inf->approx_total_samples / 44100.f);
+    deadbeef->plt_set_item_duration (plt, it, inf->approx_total_samples / 44100.f);
     deadbeef->pl_add_meta (it, ":FILETYPE", "MID");
     after = deadbeef->plt_insert_item (plt, after, it);
     deadbeef->pl_item_unref (it);