daemon

#!/bin/sh
set -e
# this daemon will manage all m3u8 files

# source env
. /tmp/livebox.env

echo "[$(date)] deamon started"
cat /tmp/livebox.env

rounded() {
    local DURATION="$1"
    local ROUNDED="$(echo ${DURATION} | cut -d. -f1)"
    if [ "$(echo ${DURATION} | cut -d. -f2)" -gt "0" ]; then
        ROUNDED="$(expr 1 + ${ROUNDED})"
    fi
    echo "${ROUNDED}"
}

generate_m3u8() {
    local CSV="$1" SCRATCH="$2" OUTPUT="$3"

    # no point in dealing with empty list
    [ -s "${CSV}" ] || return

    # now assemble the m3u8 file
    # if total number of segment output is not changed, then we can skip
    local TOTAL="$(wc -l "${CSV}" | awk '{print $1}')"
    if [ -s "${OUTPUT}" ] && [ "$(expr `grep '^#EXT-X-MEDIA-SEQUENCE:' ${OUTPUT} | cut -d: -f2` + `grep '.ts$' ${OUTPUT} | wc -l`)" = "${TOTAL}" ]; then
        return
    fi

    # write header
    mkdir -p "$(dirname ${SCRATCH})"
    echo "#EXTM3U" > "${SCRATCH}"
    echo "#EXT-X-VERSION:3" >> "${SCRATCH}"

    # figure out duration
    local TARGETDURATION="0"
    tail -q -n ${HLS_LIST_SIZE} "${CSV}" | while read LINE; do
        local DURATION="$(rounded $(echo ${LINE} | cut -d, -f3))"
        if [ "${DURATION}" -gt "${TARGETDURATION}" ]; then
            TARGETDURATION="${DURATION}"
            echo "#EXT-X-TARGETDURATION:${TARGETDURATION}"
        fi
    done | tail -q -n 1 >> "${SCRATCH}"

    # figure out the sequence number
    local SEQUENCE="$(expr ${TOTAL} - ${HLS_LIST_SIZE})"
    if [ "${SEQUENCE}" -lt "0" ]; then
        SEQUENCE="0"
    fi
    echo "#EXT-X-MEDIA-SEQUENCE:${SEQUENCE}" >> "${SCRATCH}"

    # write each segment
    local LASTSESSION="$(tail -q -n `expr 1 + ${HLS_LIST_SIZE}` "${CSV}" | head -n 1 | cut -d, -f2)"
    tail -q -n ${HLS_LIST_SIZE} "${CSV}" | while read LINE; do
        local SESSION="$(echo ${LINE} | cut -d, -f2)"
        local DURATION="$(echo ${LINE} | cut -d, -f3)"
        local TS="$(echo ${LINE} | cut -d, -f4)"

        # if session changes, we need to inject discontinuity
        if [ "${SESSION}" != "${LASTSESSION}" ]; then
            echo "#EXT-X-DISCONTINUITY" >> "${SCRATCH}"
        fi
        LASTSESSION="${SESSION}"

        # output segment
        echo "#EXTINF:${DURATION}," >> "${SCRATCH}"
        echo "${TS}" >> "${SCRATCH}"
    done

    # publish
    mv -f "${SCRATCH}" "${OUTPUT}"
}

update_csv() {
    local SOURCE="$1" CSV="$2" PREFIX="$3" DIR="$4" AFTER="$5"

    # create csv if needed
    [ -f "${CSV}" ] || touch "${CSV}"

    # find the latest timestamp unless it is media
    local LASTTIMESTAMP="0"
    if [ "${PREFIX#media/}" = "${PREFIX}" ]; then
        LASTTIMESTAMP="$(tail -q -n 1 ${CSV} | cut -d, -f1)"
        if [ -z "${LASTTIMESTAMP}" ]; then
            LASTTIMESTAMP="0"
        fi
    fi

    # compare source and list and fill missing segments
    local DURATION="0"
    cat "${SOURCE}" | while read LINE; do
        if [ "${LINE#\#EXTINF:}" != "${LINE}" ]; then
            # parse duration
            DURATION="${LINE}"
            DURATION="${DURATION#\#EXTINF:}"
            DURATION="${DURATION%,}"
            continue
        fi
        if [ "${LINE%.ts}" != "${LINE}" ]; then
            local TS="${LINE}"
            if [ ! -z "${AFTER}" ]; then
                if [ "${TS}" = "${AFTER}" ]; then
                    # found the matching segment, will deal with the next one
                    AFTER=""
                fi
                continue
            fi

            # if playing media, we just need one segment
            if [ "${PREFIX#media/}" != "${PREFIX}" ]; then
                local SESSION="$(echo ${TS} | cut -d. -f1)"
                echo "$(date -u +%s),${PREFIX}/${SESSION},${DURATION},${DIR}/${TS}" >> "${CSV}"
                break
            fi
            
            # for segments, check if timestamp is greater then last
            local TIMESTAMP="$(echo ${TS} | cut -d. -f3)"
            if [ "${TIMESTAMP}" -gt "${LASTTIMESTAMP}" ]; then
                LASTTIMESTAMP="${TIMESTAMP}"

                # append new segment to the list
                local SESSION="$(echo ${TS} | cut -d. -f1)"
                echo "${TIMESTAMP},${PREFIX}/${SESSION},${DURATION},${DIR}/${TS}" >> "${CSV}"
            fi
        fi
    done
}

list_substreams() {
    local STREAM="$1"

    echo ${SUBSTREAMS}
}

try_stream() {
    local APP="$1"
    local STREAM="$2"
    local DIR="${ROOT}/${STREAM}/${APP}"

    for SUBSTREAM in `list_substreams "${STREAM}"`; do
        # detect if stream has not yet started
        if [ ! -s "${DIR}/${SUBSTREAM}.m3u8" ]; then
            return 1
        fi

        # detect end of stream
        if [ "$(tail -q -n 1 ${DIR}/${SUBSTREAM}.m3u8)" = "#EXT-X-ENDLIST" ]; then
            return 1
        fi

        # detect stalling
        LASTTIMESTAMP="$(tail -q -n 1 ${DIR}/${SUBSTREAM}.m3u8 | cut -d. -f3)"
        if [ -z "${LASTTIMESTAMP}" ]; then
            return 1
        fi
        if [ "${LASTTIMESTAMP}" -lt "$(expr $(date -u +%s) - $(expr 3 \* ${HLS_TIME}))" ]; then
            return 1
        fi
    done

    for SUBSTREAM in `list_substreams "${STREAM}"`; do
        update_csv "${DIR}/${SUBSTREAM}.m3u8" "${ROOT}/${STREAM}/${SUBSTREAM}.csv" "${APP}" "${APP}"
    done

    return 0
}

try_media() {
    local STREAM="$1"
    local DIR="${ROOT}/${STREAM}/media"

    # the directory needs to be there
    if [ ! -d "${DIR}" ]; then
        return 1
    fi

    # first need to know the previous playing media is still available for all substreams
    local LASTMEDIA="" LASTSESSION="" NEXTMEDIA="" NEXTSESSION=""
    for SUBSTREAM in `list_substreams "${STREAM}"`; do
        CSV="${ROOT}/${STREAM}/${SUBSTREAM}.csv"

        # create csv if needed
        [ -f "${CSV}" ] || touch "${CSV}"

        # find last media playback
        LINE="$(tail -q -n 1 ${CSV})"
        if [ "$(echo ${LINE} | cut -d, -f2 | cut -d/ -f1)" != "media" ]; then
            LINE="$(grep ',media/' ${CSV} | tail -q -n 1)"
            if [ -z "${LINE}" ]; then
                # no media playing
                NEXTMEDIA=""
                NEXTSESSION=""
                break
            fi
        fi

        TIMESTAMP="$(echo ${LINE} | cut -d, -f1)"
        DURATION="$(rounded $(echo ${LINE} | cut -d, -f3))"
        if [ "$(expr ${TIMESTAMP} + ${DURATION})" -gt "$(date -u +%s)" ]; then
            # wait until it is time to write the next segment
            return 0
        fi

        MEDIA="$(echo ${LINE} | cut -d, -f2 | cut -d/ -f2)"
        SESSION="$(echo ${LINE} | cut -d, -f2 | cut -d/ -f3)"
        if [ ! -z "${LASTMEDIA}" ] && [ "${LASTMEDIA}/${LASTSESSION}" != "${MEDIA}/${SESSION}" ]; then
            # disagreement amount different substream about what media is playing
            NEXTMEDIA=""
            NEXTSESSION=""
            break
        fi
        LASTMEDIA="${MEDIA}"
        LASTSESSION="${SESSION}"

        if [ ! -s "${DIR}/${MEDIA}/${SUBSTREAM}.m3u8" ]; then
            # can no longer find the media, need new media
            NEXTMEDIA=""
            NEXTSESSION=""
            break
        fi

        TS="$(echo ${LINE} | cut -d, -f4 | cut -d/ -f3)"
        NEXT="$(grep -A 1 ^${TS}\$ ${DIR}/${MEDIA}/${SUBSTREAM}.m3u8 | tail -q -n 1)"
        if [ -z "${NEXT}" ] || [ "${NEXT}" = "#EXT-X-ENDLIST" ]; then
            # next segment is not available
            NEXTMEDIA=""
            NEXTSESSION=""
            break
        fi

        NEXTMEDIA="${MEDIA}"
        NEXTSESSION="${SESSION}"
    done

    # figure out what is next
    if [ -z "${NEXTMEDIA}" ]; then
        for MEDIA in $(ls -1 ${DIR}); do
            # skip over last media first
            if [ ! -z "${LASTMEDIA}" ]; then
                if [ "${MEDIA}" = "${LASTMEDIA}" ]; then
                    LASTMEDIA=""
                fi
                continue
            fi
            # TODO: check media suitable
            NEXTMEDIA="${MEDIA}"
            NEXTSESSION="$(date -u +%s)"
            break
        done
    fi

    # if the last media was not found or the last media was the last one
    # start from the first media
    if [ -z "${NEXTMEDIA}" ]; then
        for MEDIA in $(ls -1 ${DIR}); do
            # TODO: check media suitable
            NEXTMEDIA="${MEDIA}"
            NEXTSESSION="$(date -u +%s)"
            break
        done
    fi

    # nothing to play
    if [ -z "${NEXTMEDIA}" ]; then
        return 1
    fi

    # now update the csv
    for SUBSTREAM in `list_substreams "${STREAM}"`; do
        CSV="${ROOT}/${STREAM}/${SUBSTREAM}.csv"
        AFTER=""

        # create csv if needed
        [ -f "${CSV}" ] || touch "${CSV}"
        
        LINE="$(tail -q -n 1 ${CSV})"
        if [ "$(echo ${LINE} | cut -d, -f2 | cut -d/ -f1)" != "media" ]; then
            LINE="$(grep ',media/' ${CSV} | tail -q -n 1)"
        fi
        if [ ! -z "${LINE}" ]; then
            MEDIASESSION="$(echo ${LINE} | cut -d, -f2 | cut -d/ -f2,3)"
            if [ "${MEDIASESSION}" = "${NEXTMEDIA}/${NEXTSESSION}" ]; then
                # continue previous playback
                AFTER="$(echo ${LINE} | cut -d, -f4 | cut -d/ -f3)"
            fi
        fi
        update_csv "${DIR}/${NEXTMEDIA}/${SUBSTREAM}.m3u8" "${CSV}" "media/${NEXTMEDIA}/${NEXTSESSION}" "media/${NEXTMEDIA}" "${AFTER}"
    done

    return 0
}

do_stream() {
    local STREAM="$1"

    # write the csv files first
    for APP in ad live backup media; do
        if [ "${APP}" != "media" ]; then
            if try_stream "${APP}" "${STREAM}"; then
                break
            fi
        else
            if try_media "${STREAM}"; then
                break
            fi
        fi
    done

    # write the m3u8 file
    for SUBSTREAM in `list_substreams "${STREAM}"`; do
        generate_m3u8 "${ROOT}/${STREAM}/${SUBSTREAM}.csv" "${TMP}/${STREAM}.${SUBSTREAM}.m3u8" "${ROOT}/${STREAM}/${SUBSTREAM}.m3u8"
    done
}

list_streams() {
    find "${ROOT}" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; 2>/dev/null || true
}


run_once() {
    if [ ! -d "${ROOT}" ]; then
        return
    fi

    for STREAM in `list_streams`; do
        do_stream "${STREAM}"
    done
}

while true; do
    sleep 0.2
    run_once
done

echo "[$(date)] deamon stopped"