Plugin to auto-increment playCount when a song *finishes* rather than when it starts playing

[rmunn]

The rmpcd documentation includes a plugin to increment a playCount sticker on songs when they start playing. I prefer incrementing playCount when a song finishes playing, so I wrote a plugin to do that.

Instructions

To use this plugin:

1. Make sure you have sticker_file configured in your MPD settings. This plugin will not work if you don't have an MPD sticker file.
2. Install rmpcd and run rmpcd init to get an init.lua file.
3. Go to the place where init.lua was saved (probably $HOME/.config/rmpcd/) and create a plugins folder if it doesn't already exist.
4. Save the script below (in the discussion comment below, Plugin to auto-increment playCount when a song *finishes* rather than when it starts playing #998 (comment)) to that plugins folder, i.e. in $HOME/.config/rmpcd/plugins/
   • I suggest naming it playcount.lua, but if you use a different name then make sure you use the correct name in step 5 (and step 6 if you do that).
5. Add the line rmpcd.install("plugins.playcount") to your init.lua file.
6. (Optional) If you want to change the defaults, for example to allow just 10 seconds of padding instead of the default of 15 seconds, then change that rmpcd.install line to:

   rmpcd.install('plugins.playcount'):setup({
     padding_factor_seconds = 10,
   })

   You can also use padding_factor_milliseconds instead of padding_factor_seconds if you like, e.g. padding_factor_milliseconds=2500 for 2.5 seconds of padding. (I recommend at least 5 seconds of padding, but I haven't tested it). Another option you can change is the sticker_name, though you should use the sticker name playCount (the default) if you want to be able to interoperate with other MPD clients. (See https://github.com/jcorporation/mpd-stickers for a useful list of what stickers are used by what MPD clients).

License

BSD 3-Clause open-source license; see #998 (comment) for complete copyright and license statement.

How it works

The way this plugin works is that whenever a new song starts playing, it sets a timer for (length of song - padding factor), i.e. 15 seconds before the end of the song if you use the default settings. When you pause or stop playback, the timer is stopped. (If you unpause playback, the timer will resume, still aimed at 15 seconds before the end of the song). When the timer expires, it will increment the playCount sticker for the current song. Any songs that are shorter than the padding factor (by default, 15 seconds) will instead have their playCount incremented when they start playing.

The plugin ensures that only one timer will run at once. So if the song changes before the timer has expired (i.e., you skipped to the next song in the queue without letting the current one play to the end, or you used seeking to skip parts of the current song that added up to more than 15 seconds, so that a new song starts before the (song duration - 15 seconds) timer has elapsed), then the old song's timer will be canceled and its playCount will not be incremented.

Weirdness

There are two corner cases where the plugin's behavior might not be what you expect:

1. If you skip over parts of a song by seeking, but then pause playback, when you unpause, the fact that you skipped over parts of the song will be "lost", and the plugin will behave as if you had played through the entirety of the song so far. That's because when MPD reports the "time elapsed in current song" value, it's reporting the current position in the song, which is usually the same as "how long has this song been playing?". But if you skipped through the song with seek features, the "elapsed" time will not be the same as "how long has this song been playing?". When you unpause playback, this plugin uses the time elapsed reported by MPD in order to calculate how long to set the timer for.
   • There's not much I can do about this one. There's no way to tell, when MPD playback is unpaused, whether it had previously been "seeked".
2. If you set MPD to "repeat" mode AND "single" mode (which causes it to repeat one single song on loop, over and over), the plugin will only increment playCount ONCE, no matter how often the song is looped. This is because the song_change event, which the plugin depends on, only triggers when a new song is played, and not when the current song is repeated.
   • If you have the same song queued up multiple times in a row, the playCount WILL increment for each of them. It's only when you loop a single song over and over that it will increment only once. This is because MPD stores an internal song_id value for each instance of a queued song, and the plugin uses that to keep track. If you just played song ID 233 and song ID 234 is the same file ("My Favorite Song.flac"), then the playCount sticker for My Favorite Song.flac will be incremented twice, once for ID 233 and once for ID 234. But if you loop the song, then the plugin will see ID 233 looping over and over and will say "I already incremented the playCount for ID 233 once, I won't do it again".
   • The reason the plugin works that way is because if you pause and unpause playback, it looks at the time elapsed of the current song to decide how to set the timer. And if the current song has less than 15 seconds (or whatever you configured) left, it will check whether the song's playCount has already been incremented, and if it hasn't been incremented yet, it will assume that something malfunctioned earlier and increment the playCount. (This can happen, for example, if you start the plugin while a song is currently playing: if the first time the plugin finds out about the 4-minute song currently playing is at the 3:52 time marker, it will say "Hey, that song has been playing for long enough to qualify, and I haven't added to its playCount yet; let me fix that right now".
   • If you actually WANT to increment the playCount sticker by 50 for your favorite song that you looped 50 times, you can do that manually by opening up your sticker database with SQLite (e.g., sqlite3 ~/.cache/mpd/sticker.sql) and running update sticker set value = value + 50 where uri = 'My Favorite Song.mp3' and name = 'playCount' ;
   • In theory, I could do something about this one: after incrementing the playCount, I could set a timer for (remaining song length + 5 seconds) and see if the same song_id is still playing. In practice, I will probably leave the logic as-is, because that's a complicated bit of logic for a not-much-in-demand corner case. But if you actually want this feature (and actually read that far), drop a comment in this discussion and I'll see what I can do.

Enough jabbering, where's the code?

In the first comment of this discussion (#998 (comment)). This post was long enough already so I split out the code into its own comment.

[rmunn]

---@class PlayCountPluginArgs
---@field enabled? boolean
---@field padding_factor_milliseconds? integer
---@field padding_factor_seconds? integer
---@field sticker_name? string

---@class PlayCountPlugin : RmpcdPlugin<PlayCountPluginArgs>
---@field enabled boolean
---@field timeout_handle table|nil
---@field last_incremented_song_id integer|nil
---@field padding_factor_ms integer
---@field sticker_name string

local DEFAULT_PADDING_FACTOR_MS = 15000 -- 15 seconds
local DEFAULT_STICKER_NAME = "playCount";

---@class PlayCountPlugin
local M = {
    enabled = true;
    timeout_handle = nil;
    last_incremented_song_id = nil;
    padding_factor_ms = DEFAULT_PADDING_FACTOR_MS;
    sticker_name = DEFAULT_STICKER_NAME
}

-- Sometimes MPD has sond durations in ms, others in a { secs, nanos } structure. Here we handle both.
local function duration_in_ms(song_duration)
    if type(song_duration) == "number" then return song_duration end
    return song_duration.secs * 1000 + song_duration.nanos / 1000000
end

-- Will be called when new song starts playing, and in other situations where the existing timeout
-- should be canceled (usually because it's being replaced by a new one)
M.cancel_timeout = function(self)
    if self.timeout_handle then
        self.timeout_handle.cancel()
        self.timeout_handle = nil
    end
end

--- @param file string
--- @param song_id number
M.increment_playcount = function(self, file, song_id)
    -- Do this first to ensure we won't be called again and possibly double-increment
    self.cancel_timeout(self)
    if song_id == self.last_incremented_song_id then
        -- This can happen if you pause and resume a song repeatedly within its last 15 seconds
        -- If that happens, we still only want to count a single play of the song
        return
    end
    self.last_incremented_song_id = song_id
    local oldsticker, err = mpd.get_song_sticker(file, self.sticker_name)
    if err then
        log.error("Could not increment play count for " .. file .. " because of an error while trying to look up the " .. self.sticker_name .. " sticker: " .. err)
    else
        local oldcount = tonumber(oldsticker) or 0
        mpd.set_song_sticker(file, self.sticker_name, tostring(oldcount + 1))
        log.info(file .. " has now been played " .. (oldcount + 1) .. " times.")
    end
end

-- Set up the timeout for N (configurable, default 15) seconds before the end of the song
-- Once the timeout fires, we will increment the song's playCount sticker
-- We use the song's id (a unique value assigned by MPD) to ensure we never double-increment for a single play
-- If we used the song's file for this, we might only add a single play count when the song gets played repeatedly
-- We also need to know how much time has elapsed in the song so far (which can happen when unpausing), since that
-- will change the calculation for how long the tieout needs to be so that it triggers N seconds before the song ends
---@param song QueuedSong
---@param already_elapsed_ms number
M.setup_timeout = function(self, song, already_elapsed_ms)
    self.cancel_timeout(self)
    already_elapsed_ms = already_elapsed_ms or 0
    local remaining_play_time_ms = duration_in_ms(song.duration) - already_elapsed_ms
    if remaining_play_time_ms < self.padding_factor_ms then
        -- Short songs get play count incremented right away, no waiting
        self.increment_playcount(self, song.file, song.id)
    else
        -- Longer songs wait until song has 15 seconds (or less) to go, then increment play count
        local wait_ms = remaining_play_time_ms - self.padding_factor_ms
        self.timeout_handle = sync.set_timeout(wait_ms, function ()
            self.increment_playcount(self, song.file, song.id)
        end)
    end
end

-- Will be called when we unpause *or* when plugin starts up
-- In both cases, we want to check whether a song is already playing,
-- because the song's elapsed time needs to be taken into account when setting up the timeout
M.resume_after_pause = function(self)
    local status = mpd.get_status()
    if status and status.state == "play" then
        local song = mpd.get_current_song()
        if song then
            self.setup_timeout(self, song, status.elapsed)
        end
    end
end

--- @param _old_song QueuedSong
--- @param new_song QueuedSong
-- Will be called when a song changes.
-- Interestingly, in repeat+single mode (where one song loops repeatedly) this will only get called once,
-- when the song is first played. Repeating the same song isn't a "change" so this event doesn't get called.
-- I prefer that behavior, so I'm not going to try to add extra complexity to detect whether a song is
-- being looped forever. If you want your playCount sticker to be incremented by 50 when a song loops 50 times,
-- you can do `rmpc sticker get MySong.mp3 playCount` and then `rmpc sticker set mySong.mp3 playCount N`
-- (where N = old value + 50) yourself, in a bash script or something.
M.song_change = function(self, _old_song, new_song)
    if not self.enabled or new_song == nil or not new_song.file then
        self.cancel_timeout(self)
        return
    end

    self.setup_timeout(self, new_song, 0)
end

-- Will be called when playback is started, stopped or paused. A few cases need to be handled:
-- Stopping playback = cancel the timeout if it hasn't fired yet, because the song didn't play for long enough
-- Pausing playback = ditto, but when playback resumes the song's time elapsed so far will be counted
-- Unpausing playback = the timeout (which was canceled when playback was paused) can should be restarted now
-- Starting playback = 
M.state_change = function(self, old, new)
    if not self.enabled then
        self.cancel_timeout(self)
        return
    end

    if new == "pause" or new == "stop" then self.cancel_timeout(self) end
    if new == "play" then self.resume_after_pause(self) end
end

M.setup = function(self, args)
    self.enabled = (args.enabled ~= nil) and args.enabled or true
    if args.padding_factor_milliseconds ~= nil and args.padding_factor_seconds ~= nil then
        log.warn("Both milliseconds and seconds were set for padding_factor. Using milliseconds and *IGNORING* seconds. Padding factor will be set to " .. args.padding_factor_milliseconds .. " ms, which is " .. args.padding_factor_milliseconds / 1000 .. " seconds.")
    end
    if args.padding_factor_seconds ~= nil then
        self.padding_factor_ms = args.padding_factor_seconds * 1000
    end
    if args.padding_factor_milliseconds ~= nil then
        self.padding_factor_ms = args.padding_factor_milliseconds
    end
    if (args.sticker_name) then
        self.sticker_name = args.sticker_name
    end

    -- Same logic for resiming after pause (check times elapsed, etc) works here too, so just reuse it
    -- However, resume_after_pause needs to call mpd.get_status(), and during plugin setup, rmpcd isn't running yet
    -- But by setting a timeout of 0, we ensure we get queued up to run immediately after rmpcd setup completes
    -- This neatly solves the chicken-and-egg problem
    sync.set_timeout(0, function ()
      self.resume_after_pause(self)
    end)
end

-- We subscribe to both playCount and playcount channels in case someone mistypes the name
M.subscribed_channels = { "rmpcd.playcount", "rmpcd.playCount" }

-- We can ignore the channel here because we're only subscribed to our own comm channels
M.message = function(self, _channel, message)
    -- Turning plugin on/off
    if message == "enable" then
        log.info("Enabling playcount plugin")
        self.enabled = true
    elseif message == "disable" then
        log.info("Disabling playcount plugin")
        self.enabled = false
    elseif message == "toggle" then
        local newstate = not self.enabled
        local first_word = newstate and "Enabling" or "Disabling"
        log.info(first_word .. " playcount plugin")
        self.enabled = newstate

    -- Changing parameters on-the-fly: padding factor
    -- Syntax: send either "padding_factor_seconds:15" or "padding_factor_milliseconds:15000"
    elseif string.find(message, "padding_factor_seconds:") == 1 then
        local len = string.len("padding_factor_seconds:")
        local seconds = tonumber(string.sub(message, len))
        if seconds ~= nil then
            self.padding_factor_ms = seconds * 1000
        end
    elseif string.find(message, "padding_factor_milliseconds:") == 1 then
        local len = string.len("padding_factor_milliseconds:")
        local ms = tonumber(string.sub(message, len))
        if ms ~= nil then
            self.padding_factor_ms = ms
        end

    -- Changing parameters on-the-fly: sticker name
    -- CAUTION: No attempt is made to validate the new name. Make sure you spelled it the way you want it to be spelled!
    -- Note also that no attempt is made to search the sticker database and rename anything from the old name to the new name
    -- So changing this while the plugin is running is almost never useful, but we include the option for completeness' sake
    elseif string.find(message, "sticker_name:") == 1 then
        local len = string.len("sticker_name:")
        local new_name = string.sub(message, len)
        if new_name ~= nil then
            self.sticker_name = new_name
        end
    end
end

return M

[rmunn]

In case anyone is concerned about copyright: I am the author of all of the code above, except for one small snippet (the first 11 lines of the M.message function) which was copied from one of the sample rmpcd plugins (and then slightly modified). No AI tools were used in creating it; it was entirely human-created, and thus can be copyrighted and licensed. I hereby release it under the following open-source license (the "BSD 3-Clause" license, same one that rmpc is licensed under):

BSD 3-Clause License

Copyright (c) 2026, Robin Munn <rmunn@pobox.com>

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
   contributors may be used to endorse or promote products derived from
   this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

[mierak]

Let's start collecting the plugins. Would you mind creating a repo with the plugin with everything you posted here(readme, license, the plugin itself) and shooting a PR at https://github.com/rmpc-org/rmpcd-plugins with link to your repo in the readme?

Don't worry about any specific format, just name and link or optionally very short description is fine. I'll link the repo from the docs a bit later.

[rmunn]

Will do, but not today. Have some higher-priority items I need to tackle. I should have time over the weekend to take care of it, though.

[rmunn]

Done: rmpc-org/rmpcd-plugins#1

[mierak]

Thanks!

[v-Nyo]

Looks awesome much better than what ever this #969 (comment) is. But I did try to minimize mpd calls

For Suggestions: variable in the init.lua to reverse the behavior so it does not wait until 15s of the end but instead 15s after the beginning. Fractions would also be nice so it increments after 1/3, 2/3

[rmunn]

Also, if you want to open a PR implementing either one of those, I'd be happy to merge it.

[v-Nyo]

Well, this is slop, so you probably don't want to touch it, but I did some superficial testing and it seems fine.

diff --git a/playcount.lua b/playcount.lua
index 8ee5ee6..1b9340b 100644
--- a/playcount.lua
+++ b/playcount.lua
@@ -3,6 +3,8 @@
 ---@field padding_factor_milliseconds? integer
 ---@field padding_factor_seconds? integer
 ---@field sticker_name? string
+---@field trigger_mode? string  -- "end" (original) | "start" (reversed) | "fraction" (new)
+---@field trigger_fraction? number  -- e.g., 0.33 for 1/3, 0.66 for 2/3
 
 ---@class PlayCountPlugin : RmpcdPlugin<PlayCountPluginArgs>
 ---@field enabled boolean
@@ -10,9 +12,12 @@
 ---@field last_incremented_song_id integer|nil
 ---@field padding_factor_ms integer
 ---@field sticker_name string
+---@field trigger_mode string
+---@field trigger_fraction number|nil
 
 local DEFAULT_PADDING_FACTOR_MS = 15000 -- 15 seconds
 local DEFAULT_STICKER_NAME = "playCount";
+local DEFAULT_TRIGGER_MODE = "end" -- "end" | "start" | "fraction"
 
 ---@class PlayCountPlugin
 local M = {
@@ -20,13 +25,19 @@ local M = {
     timeout_handle = nil;
     last_incremented_song_id = nil;
     padding_factor_ms = DEFAULT_PADDING_FACTOR_MS;
-    sticker_name = DEFAULT_STICKER_NAME
+    sticker_name = DEFAULT_STICKER_NAME;
+    trigger_mode = DEFAULT_TRIGGER_MODE;
+    trigger_fraction = nil;
 }
 
--- Sometimes MPD has sond durations in ms, others in a { secs, nanos } structure. Here we handle both.
+-- Sometimes MPD has song durations in ms, others in a { secs, nanos } structure. Here we handle both.
 local function duration_in_ms(song_duration)
+    if not song_duration then return 0 end
     if type(song_duration) == "number" then return song_duration end
-    return song_duration.secs * 1000 + song_duration.nanos / 1000000
+    if type(song_duration) == "table" and song_duration.secs then
+        return song_duration.secs * 1000 + (song_duration.nanos or 0) / 1000000
+    end
+    return 0
 end
 
 -- Will be called when new song starts playing, and in other situations where the existing timeout
@@ -51,36 +62,72 @@ M.increment_playcount = function(self, file, song_id)
     self.last_incremented_song_id = song_id
     local oldsticker, err = mpd.get_song_sticker(file, self.sticker_name)
     if err then
-        log.error("Could not increment play count for " .. file .. " because of an error while trying to look up the " .. self.sticker_name .. " sticker: " .. err)
+        log.error("Could not increment play count for " .. tostring(file) .. " because of an error while trying to look up the " .. tostring(self.sticker_name) .. " sticker: " .. tostring(err))
     else
         local oldcount = tonumber(oldsticker) or 0
         mpd.set_song_sticker(file, self.sticker_name, tostring(oldcount + 1))
-        log.info(file .. " has now been played " .. (oldcount + 1) .. " times.")
+        log.info(tostring(file) .. " has now been played " .. tostring(oldcount + 1) .. " times.")
     end
 end
 
--- Set up the timeout for N (configurable, default 15) seconds before the end of the song
--- Once the timeout fires, we will increment the song's playCount sticker
--- We use the song's id (a unique value assigned by MPD) to ensure we never double-increment for a single play
--- If we used the song's file for this, we might only add a single play count when the song gets played repeatedly
--- We also need to know how much time has elapsed in the song so far (which can happen when unpausing), since that
--- will change the calculation for how long the tieout needs to be so that it triggers N seconds before the song ends
+-- Set up the timeout based on the selected trigger mode
+-- Modes:
+--   "end" - Wait until N seconds remain before song ends (original behavior)
+--   "start" - Wait N seconds after song begins (reversed behavior)
+--   "fraction" - Wait until fraction of song has passed (e.g., 1/3, 2/3)
 ---@param song QueuedSong
 ---@param already_elapsed_ms number
 M.setup_timeout = function(self, song, already_elapsed_ms)
     self.cancel_timeout(self)
     already_elapsed_ms = already_elapsed_ms or 0
-    local remaining_play_time_ms = duration_in_ms(song.duration) - already_elapsed_ms
-    if remaining_play_time_ms < self.padding_factor_ms then
-        -- Short songs get play count incremented right away, no waiting
-        self.increment_playcount(self, song.file, song.id)
+    local song_duration_ms = duration_in_ms(song.duration)
+
+    local wait_ms = nil
+
+    if self.trigger_mode == "fraction" and self.trigger_fraction then
+        -- Fractional mode: trigger at a specific fraction of song length
+        local trigger_point_ms = song_duration_ms * self.trigger_fraction
+        wait_ms = trigger_point_ms - already_elapsed_ms
+
+        -- If we've already passed the trigger point, increment immediately
+        if wait_ms <= 0 then
+            self.increment_playcount(self, song.file, song.id)
+            return
+        end
+
+    elseif self.trigger_mode == "start" then
+        -- Start mode: wait a fixed time from the beginning
+        wait_ms = self.padding_factor_ms - already_elapsed_ms
+
+        -- If we've already passed the trigger point (e.g., resumed after 20s with 15s padding), increment immediately
+        if wait_ms <= 0 then
+            self.increment_playcount(self, song.file, song.id)
+            return
+        end
+
     else
-        -- Longer songs wait until song has 15 seconds (or less) to go, then increment play count
-        local wait_ms = remaining_play_time_ms - self.padding_factor_ms
-        self.timeout_handle = sync.set_timeout(wait_ms, function ()
+        -- End mode (original): wait until N seconds remain before song ends
+        local remaining_play_time_ms = song_duration_ms - already_elapsed_ms
+        if remaining_play_time_ms < self.padding_factor_ms then
+            -- Short songs get play count incremented right away, no waiting
             self.increment_playcount(self, song.file, song.id)
-        end)
+            return
+        else
+            -- Longer songs wait until song has N seconds (or less) to go, then increment play count
+            wait_ms = remaining_play_time_ms - self.padding_factor_ms
+        end
     end
+
+    -- Defensive guard: ensure wait_ms is positive before scheduling
+    if not wait_ms or wait_ms <= 0 then
+        self.increment_playcount(self, song.file, song.id)
+        return
+    end
+
+    -- Set the timeout (this runs for ALL modes now)
+    self.timeout_handle = sync.set_timeout(wait_ms, function ()
+        self.increment_playcount(self, song.file, song.id)
+    end)
 end
 
 -- Will be called when we unpause *or* when plugin starts up
@@ -91,7 +138,7 @@ M.resume_after_pause = function(self)
     if status and status.state == "play" then
         local song = mpd.get_current_song()
         if song then
-            self.setup_timeout(self, song, status.elapsed)
+            self.setup_timeout(self, song, (status.elapsed or 0) * 1000) -- Convert seconds to ms
         end
     end
 end
@@ -111,6 +158,9 @@ M.song_change = function(self, _old_song, new_song)
         return
     end
 
+    -- Reset last increment when a new song starts to allow counting it later
+    self.last_incremented_song_id = nil
+
     self.setup_timeout(self, new_song, 0)
 end
 
@@ -118,7 +168,7 @@ end
 -- Stopping playback = cancel the timeout if it hasn't fired yet, because the song didn't play for long enough
 -- Pausing playback = ditto, but when playback resumes the song's time elapsed so far will be counted
 -- Unpausing playback = the timeout (which was canceled when playback was paused) can should be restarted now
--- Starting playback = 
+-- Starting playback =
 M.state_change = function(self, old, new)
     if not self.enabled then
         self.cancel_timeout(self)
@@ -130,9 +180,12 @@ M.state_change = function(self, old, new)
 end
 
 M.setup = function(self, args)
+    args = args or {}
     self.enabled = (args.enabled ~= nil) and args.enabled or true
+
+    -- Handle padding factor (seconds or milliseconds)
     if args.padding_factor_milliseconds ~= nil and args.padding_factor_seconds ~= nil then
-        log.warn("Both milliseconds and seconds were set for padding_factor. Using milliseconds and *IGNORING* seconds. Padding factor will be set to " .. args.padding_factor_milliseconds .. " ms, which is " .. args.padding_factor_milliseconds / 1000 .. " seconds.")
+        log.warn("Both milliseconds and seconds were set for padding_factor. Using milliseconds and *IGNORING* seconds. Padding factor will be set to " .. tostring(args.padding_factor_milliseconds) .. " ms, which is " .. tostring(args.padding_factor_milliseconds / 1000) .. " seconds.")
     end
     if args.padding_factor_seconds ~= nil then
         self.padding_factor_ms = args.padding_factor_seconds * 1000
@@ -140,11 +193,30 @@ M.setup = function(self, args)
     if args.padding_factor_milliseconds ~= nil then
         self.padding_factor_ms = args.padding_factor_milliseconds
     end
+
+    -- NEW: Handle trigger mode
+    if args.trigger_mode then
+        if args.trigger_mode == "end" or args.trigger_mode == "start" or args.trigger_mode == "fraction" then
+            self.trigger_mode = args.trigger_mode
+        else
+            log.warn("Invalid trigger_mode '" .. tostring(args.trigger_mode) .. "'. Valid options: 'end', 'start', 'fraction'. Using default 'end'.")
+        end
+    end
+
+    -- NEW: Handle trigger fraction (only relevant for "fraction" mode)
+    if args.trigger_fraction ~= nil then
+        if type(args.trigger_fraction) == "number" and args.trigger_fraction > 0 and args.trigger_fraction <= 1 then
+            self.trigger_fraction = args.trigger_fraction
+        else
+            log.warn("trigger_fraction must be between 0 and 1 (exclusive of 0). Ignoring invalid value: " .. tostring(args.trigger_fraction))
+        end
+    end
+
     if (args.sticker_name) then
         self.sticker_name = args.sticker_name
     end
 
-    -- Same logic for resiming after pause (check times elapsed, etc) works here too, so just reuse it
+    -- Same logic for resuming after pause (check times elapsed, etc) works here too, so just reuse it
     -- However, resume_after_pause needs to call mpd.get_status(), and during plugin setup, rmpcd isn't running yet
     -- But by setting a timeout of 0, we ensure we get queued up to run immediately after rmpcd setup completes
     -- This neatly solves the chicken-and-egg problem
@@ -158,42 +230,58 @@ M.subscribed_channels = { "rmpcd.playcount", "rmpcd.playCount" }
 
 -- We can ignore the channel here because we're only subscribed to our own comm channels
 M.message = function(self, _channel, message)
-    -- Turning plugin on/off
     if message == "enable" then
         log.info("Enabling playcount plugin")
         self.enabled = true
+
     elseif message == "disable" then
         log.info("Disabling playcount plugin")
         self.enabled = false
+
     elseif message == "toggle" then
         local newstate = not self.enabled
         local first_word = newstate and "Enabling" or "Disabling"
         log.info(first_word .. " playcount plugin")
         self.enabled = newstate
 
-    -- Changing parameters on-the-fly: padding factor
-    -- Syntax: send either "padding_factor_seconds:15" or "padding_factor_milliseconds:15000"
     elseif string.find(message, "padding_factor_seconds:") == 1 then
-        local len = string.len("padding_factor_seconds:")
-        local seconds = tonumber(string.sub(message, len))
+        local prefix_len = #("padding_factor_seconds:")
+        local seconds = tonumber(string.sub(message, prefix_len + 1))
         if seconds ~= nil then
             self.padding_factor_ms = seconds * 1000
         end
+
     elseif string.find(message, "padding_factor_milliseconds:") == 1 then
-        local len = string.len("padding_factor_milliseconds:")
-        local ms = tonumber(string.sub(message, len))
+        local prefix_len = #("padding_factor_milliseconds:")
+        local ms = tonumber(string.sub(message, prefix_len + 1))
         if ms ~= nil then
             self.padding_factor_ms = ms
         end
 
-    -- Changing parameters on-the-fly: sticker name
-    -- CAUTION: No attempt is made to validate the new name. Make sure you spelled it the way you want it to be spelled!
-    -- Note also that no attempt is made to search the sticker database and rename anything from the old name to the new name
-    -- So changing this while the plugin is running is almost never useful, but we include the option for completeness' sake
+    elseif string.find(message, "trigger_mode:") == 1 then
+        local prefix_len = #("trigger_mode:")
+        local mode = string.sub(message, prefix_len + 1)
+        if mode == "end" or mode == "start" or mode == "fraction" then
+            self.trigger_mode = mode
+            log.info("Trigger mode changed to: " .. mode)
+        else
+            log.warn("Invalid trigger_mode: " .. tostring(mode) .. ". Valid options: 'end', 'start', 'fraction'")
+        end
+
+    elseif string.find(message, "trigger_fraction:") == 1 then
+        local prefix_len = #("trigger_fraction:")
+        local fraction = tonumber(string.sub(message, prefix_len + 1))
+        if fraction ~= nil and fraction > 0 and fraction <= 1 then
+            self.trigger_fraction = fraction
+            log.info("Trigger fraction changed to: " .. tostring(fraction))
+        else
+            log.warn("Invalid trigger_fraction: " .. tostring(fraction) .. ". Must be between 0 and 1 (exclusive of 0)")
+        end
+
     elseif string.find(message, "sticker_name:") == 1 then
-        local len = string.len("sticker_name:")
-        local new_name = string.sub(message, len)
-        if new_name ~= nil then
+        local prefix_len = #("sticker_name:")
+        local new_name = string.sub(message, prefix_len + 1)
+        if new_name ~= nil and new_name ~= "" then
             self.sticker_name = new_name
         end
     end

[rmunn]

I've actually been working on implementing this over the weekend, I just wasn't satisfied enough with my code yet to open a PR in the repo. But I'll go ahead and push the code I wrote.

Part of why I wasn't satisfied is because initially, I thought that people might want to say "when the song is 9/10 done" by making the fraction be 1/10 and setting from="end". But then I realized that that's going to cause confusion. Especially since from="end" is the default if you don't specify a from. People will expect fraction=9/10 or percent=90 to mean when there's just 1/10th of the song remaining, and would have been surprised if I implemented it as meaning "90% from the end, meaning 10% from the start".

So I'm going to edit what I wrote to always calculate fractions from the beginning of the song, and just use from="start" or from="end" when the user specified a fixed number of seconds, not a fraction. Then I'll open a PR in my repo, let it sit for a few days so I can review my code with a fresh mind (a useful trick when you're solo programming, let the code sit until you don't remember writing it and then you can do a code review as if reading someone else's code), and then merge it if it still looks good.

[rmunn]

@v-Nyo - I've pushed my work to a PR. There's one change I want to make before I merge it, pulling out a bit of logic into its own function so I can test it more easily. If you want to test it before I merge, clone https://github.com/rmunn/rmpcd-plugin-playcount and check out the feat/from-start-or-end branch (code is in rmunn/rmpcd-plugin-playcount#3 if you want to look at it before checking it out). Short version: there's now a from parameter that can be "start" or "end" so you can increment all songs after (say) 1 minute of play time if you want. There are also target_fraction (should be between 0 and 1) and target_percent (between 0 and 100) parameters that calculate the increment point based on each song's duration: doing setup({ target_fraction = 2/3 }) will increment the playCount for each song once it reaches two-thirds of that song's total length. The from parameter is ignored if you use target_fraction or target_percent: if you want to do something like target_fraction = 1/10, from = "end" then you should just do target_fraction = 9/10 instead.

I'll be doing a bit of testing before I merge that PR, but you can use it now if you want. If you find any bugs in it, please open an issue in my plugin repo to tell me about the bug(s) you found (I'll see issues in that repo way sooner than I see any comments in this discussion thread).

[rmunn]

@v-Nyo - I've released v0.0.2 of my plugin with the target_fraction and target_percent parameters. If you pulled code from the PR, you'll want to replace it with the code from v0.0.2, as there was a bug in the target_fraction handling that I've just fixed.