bin/vidref main

light9/vidref/videorecorder.py capture frames and save them

light9/vidref/replay.py backend for vidref.js playback element- figures out which frames go with the current song and time

light9/vidref/index.html web ui for watching current stage and song playback

light9/vidref/setup.html web ui for setup of camera params and frame crop

light9/web/light9-vidref-live.js LitElement for live video frames

light9/web/light9-vidref-playback.js LitElement for video playback

"""

from run_local import log

import logging, optparse, json, base64, os, glob

from greplin import scales

from greplin.scales.cyclonehandler import StatsHandler

parser = optparse.OptionParser()

parser.add_option("-v", "--verbose", action="store_true", help="logging.DEBUG")

(options, args) = parser.parse_args()

log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

stats = scales.collection(

    '/webServer',

    scales.RecentFpsStat('liveWebsocketFrameFps'),

    scales.IntStat('liveClients'),

)

class Snapshot(cyclone.web.RequestHandler):

    @defer.inlineCallbacks

    def post(self):

        # save next pic

        # return /snapshot/path

        try:

            snapshotDir = 'todo'

            outputFilename = yield self.settings.gui.snapshot()

            assert outputFilename.startswith(snapshotDir)

            out = networking.vidref.path(

class Time(cyclone.web.RequestHandler):

    def put(self):

        body = json.loads(self.request.body)

        t = body['t']

        source = body['source']

        self.settings.gui.incomingTime(t, source)

        self.set_status(202)

class Clips(PrettyErrorHandler, cyclone.web.RequestHandler):

    def delete(self):

        clip = URIRef(self.get_argument('uri'))

        videorecorder.deleteClip(clip)

class ReplayMap(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        song = Song(self.get_argument('song'))

        clips = []

        for vid in videoPaths:

            pts = []

            for line in open(vid.replace(b'.mp4', b'.timing'), 'rb'):

                _v, vt, _eq, _song, st = line.split()

                pts.append([float(st), float(vt)])

            url = vid[len(os.path.dirname(os.path.dirname(showconfig.root()))

                         ):].decode('ascii')

            clips.append({

                'uri': videorecorder.takeUri(vid),

                'videoUrl': url,

            }),

            (r'/live', Live),

            (r'/clips', Clips),

            (r'/replayMap', ReplayMap),

            (r'/snapshot', Snapshot),

            (r'/snapshot/(.*)', SnapshotPic, {

                "path": 'todo',

            }),

            (r'/time', Time),

            (r'/stats/(.*)', StatsHandler, {

                'serverName': 'vidref'

            }),

        ],

        debug=True,

    ))

log.info("serving on %s" % port)

reactor.run()

from dataclasses import dataclass

from typing import Optional

import time, logging, os, traceback

import gi

gi.require_version('Gst', '1.0')

gi.require_version('GstBase', '1.0')

from gi.repository import Gst

from rx.subject import BehaviorSubject

from twisted.internet import threads

import moviepy.editor

import numpy

from light9.ascoltami.musictime_client import MusicTime

from light9.newtypes import Song

log = logging.getLogger()

stats = scales.collection(

    '/recorder',

    scales.PmfStat('jpegEncode', recalcPeriod=1),

    scales.IntStat('deletes'),

    scales.PmfStat('waitForNextImg', recalcPeriod=1),

    scales.PmfStat('crop', recalcPeriod=1),

    scales.RecentFpsStat('encodeFrameFps'),

    scales.RecentFpsStat('queueGstFrameFps'),

)

@dataclass

class CaptureFrame:

    img: PIL.Image

    song: Song

    t: float

    isPlaying: bool

    imgJpeg: Optional[bytes] = None

    @stats.jpegEncode.time()

    def asJpeg(self):

        if not self.imgJpeg:

            output = BytesIO()

            self.img.save(output, 'jpeg', quality=80)

            self.imgJpeg = output.getvalue()

        return self.imgJpeg

def songDir(song: Song) -> bytes:

    return os.path.join(

        showconfig.root(), b'video',

        song.replace('http://', '').replace('/', '_').encode('ascii'))

def takeUri(songPath: bytes) -> URIRef:

    p = songPath.decode('ascii').split('/')

    take = p[-1].replace('.mp4', '')

    song = p[-2].split('_')

    return URIRef('/'.join(

        ['http://light9.bigasterisk.com/show', song[-2], song[-1], take]))

def deleteClip(uri: URIRef):

    # uri http://light9.bigasterisk.com/show/dance2019/song6/take_155

    # path show/dance2019/video/light9.bigasterisk.com_show_dance2019_song6/take_155.*

    w = uri.split('/')[-4:]

    log.info(f'deleting {uri} {path}')

    stats.deletes += 1

    for fn in [path + '.mp4', path + '.timing']:

        os.remove(fn)

class FramesToVideoFiles:

    """

    nextWriteAction: 'ignore'

    currentOutputClip: None

    (frames come in for new video)

    nextWriteAction: 'saveFrame'

    currentOutputClip: new VideoClip

    (many frames)

    (music stops or song changes)

                                                   logger=None,

                                                   ffmpeg_params=['-g', '10'],

                                                   bitrate='150000')

        except (StopIteration, RuntimeError):

            self.frameMap.close()

        log.info('write_videofile done')

        self.currentOutputClip = None

        if self.currentClipFrameCount < 400:

            log.info('too small- deleting')

            deleteClip(takeUri(self.outMp4.encode('ascii')))

    def _bg_make_frame(self, video_time_secs):

        stats.encodeFrameFps.mark()

        if self.nextWriteAction == 'close':

            raise StopIteration  # the one in write_videofile

        elif self.nextWriteAction == 'notWritingClip':

            raise NotImplementedError

        elif self.nextWriteAction == 'saveFrames':

            pass

        else:

            raise NotImplementedError(self.nextWriteAction)

                self.liveImages.on_next(

                    CaptureFrame(img=img,

                                 song=Song(latest['song']),

                                 t=latest['t'],

                                 isPlaying=latest['playing']))

        except Exception:

            traceback.print_exc()

        return Gst.FlowReturn.OK

    @stats.crop.time()

    def crop(self, img):

        return img.crop((0, 100, 640, 380))

    def setupPipelineError(self, pipe, cb):

        bus = pipe.get_bus()

        def onBusMessage(bus, msg):

            print('nusmsg', msg)

            if msg.type == Gst.MessageType.ERROR:

                _, txt = msg.parse_error()

                cb(txt)

            return True

        # not working; use GST_DEBUG=4 to see errors