#!/usr/bin/python3.7
# -*- coding: utf-8 -*-

"""
Skript mis loeb viimast kirjet kesksest andmebaasist ja kirjutab minu andmebaasi.
Loeb nii temperatuuri kui ka niiskus, kuid paneb mõlemad eraldi tabelisse.
"""

import subprocess   # Päringu käivitamiseks
import json         # tulemuse parsimise jaoks
import pymysql.cursors  # Andmebaasiga ühenduseks
import math         # floor funktsiooni jaoks

"""
Funktsioon, mis float tüüpi väärtusel võtab ilma ümardamata koma kohti.
1.456 kaks kohta on 1.45 (ei ümerdanud)
"""
def truncate(f, n):
    return math.floor(f * 10 ** n) / 10 ** n

# Enda andmebaasiga ühenduse tegemine
conn = pymysql.connect(host='SERVER', port=3306, user='USER', passwd='PAROOL', db='DATABASENAME', )

# Päring andmebaasist koos SQL lausega ja tulemuse kinni püüdmine
cmd = subprocess.Popen(['curl', '-X', 'POST', '-k', 'https://SERVER/FOLDER/query?u=USER&p=PAROOL&db=DATABASE', '--data-urlencode', 'q=SELECT * FROM TABEL ORDER BY time DESC LIMIT 1 tz(\'Europe/Tallinn\');' ], stdout=subprocess.PIPE,stderr=subprocess.PIPE)
output,error = cmd.communicate()

# Mängimine JSONiga
d = json.loads(output)

results = d['results']
series = results[0]['series']
values = series[0]['values'] # Siin on üks või mitu kirjet kuupäev ja väärtus

# Vaatame kui palju andmeid on ja hakkame neid kuidagi andmebaasi lisama.
if len(values) > 0:
    window = 'west'
    place = 'out'
    for x in range(len(values)):
        time = d['results'][0]['series'][0]['values'][x][0]
        tempTime = time[0:19]
        timeParts = tempTime.split("T")
        time = timeParts[0] + " " + timeParts[1]
        temp = d['results'][0]['series'][0]['values'][x][1]

        if temp is not None:
            print(time + " " + str(truncate(temp,1)) + " " + window + " " + place)
            cur = conn.cursor()
            cur.execute("INSERT INTO TABLENAME SET added = '" + time + "', celsius = " + str(temp) + ", window = '" + window  + "', place = '" + place + "'")
            conn.commit()

conn.close() # Sulgeme andmebaasi ühenduse
                        
                    

                        
#!/usr/bin/python3.7
# -*- coding: utf-8 -*-

import subprocess # Et käsureal saaks CPU temperatuuri kätte
import pymysql.cursors  # Andmebaasiga ühenduseks
from datetime import datetime

cmd = '/usr/bin/vcgencmd'
opt = 'measure_temp'

result = subprocess.Popen([cmd, opt], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, error = result.communicate()
# b"temp=47.8'C\n"
correct = output.strip().decode('ascii')
parts = correct.strip().split('=')

temp = parts[1][0:4]
time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

#print(temp + " " + time)

conn = pymysql.connect(host='LAN_SERVER', port=3306, user='USERNAME', passwd='PASSWORD', db='DATABASE', )
cur = conn.cursor()
cur.execute("INSERT INTO TABLENAME SET added = '" + time + "', celsius = " + str(temp))
conn.commit()
conn.close()

                        
                    

                        
#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Name:     CreateMotionMovie.py
# Version:  2.1
# Date:     24.11.2018
# Author:   (c) Marko Livental

""" 
Description:

Teeb raspberry pi "motion" piltidest etteantud parameetritega video. Video saab teha minutite kui liikumiste baasil tehtud piltidest. Videole saab 
määrata FPS'i. Lisaks saab määrata milliste kellaaegade pilte kasutada. Kõige olulisem ja mitte viimane on see et võimaldab teha aasta video, kui 
pilte on ikka piisavalt. Loe: kuupäevi on piisavalt. Aasta video pole muud kui modifitseeritud minutite baasil tehtud video.
Vajadusel saab lugeda kokku kui palju pilte mingil kuupäeval on tehtud. NÜÜD arvutatakse MIN ja MOV pildid eraldi kokku, kuid päeva piltide
mahtu näidatakse ühiselt.

Versioon 2.1 UUENDUS: Minuti baasil videol kahe päeva puhul arvestab nüüd kellaaega (kuu liikumine üle keskköö)

"""

# IMPORDID
import argparse                     # Käsureal majandamiseks
import time                         # time.strptime jaoks ja time.strftime jaoks
import glob, os, re, shutil, sys    # Skripti töö lõpetamiseks (sys) ja failidega majandamiseks
import subprocess                   # Vajalik välise programmi käivitamiseks (shell)
from datetime import datetime       # Et saaksime kuupäeva soovitud kujul
from datetime import timedelta      # päeva kaupa toimetamine

# SEADED
srcPath = '/home/pi/cameraImages/'  # Siin on pildid
dstPath = '/home/pi/nice/'          # Siia kopeeritakse pildid ja tehkse video
warning = 'Pole'
scriptStop = False                  # Kas eelkontrollitud vea pärast tuleb skripti töö lõpetada
daysTotal = 1                       # Päevi kokku 1 või mitu
fileMP4 = ''                        # See on failinime vastavalt parameetritele

# Iga minuti tagant tehtavad ja liikumise pildid
minMatch = re.compile('^[0-9]{4}-[0-9]{2}-[0-9]{2}\_[0-9]{6}\.jpg$')
movMatch = re.compile('^[0-9]{4}-[0-9]{2}-[0-9]{2}\_[0-9]{6}\_[0-9]{2}\.jpg$')

minutid = []
movies = []

counter = 0

# Värvid
RED = '\033[1;31m'
GRN = '\033[1;32m'
END = '\033[0;0m'


# FUNKTSIOONID
def showTimeStamp():
    return (datetime.now().strftime("%H:%M:%S"))

def parseCommandLine():
    parser = argparse.ArgumentParser(prog='createMotionMovie.py', formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=100, width=100), description='Teeb video faili motion failidest. Pildid pannakse kokku nii minuti baasil piltidest, kui liikumise peale piltidest.')
    # Kohustuslik parameeter
    parser.add_argument('-s', '--startDate', type=lambda s: time.strptime(s, '%Y-%m-%d'), help='Algus kuupäev on KOHUSTUSLIK. Kuupäeva vorming on AAAA-KK-PP. Sellest kuupäevast alustatakse või tehakse selle kuupäeva video.', required=True)
    # Valikuleine parameeter
    parser.add_argument('-e', '--endDate', type=lambda e: time.strptime(e, '%Y-%m-%d'), nargs='?', help='Valikuline. Lõpu kuupäev, kui mitme päeva videod kokku miksida. Kuupäeva vorming on AAAA-KK-PP')
    # Valikuline minuti või liikumise baasil default min
    parser.add_argument('-m', '--movie', type=str, nargs='?', const='min', default='min', help='Vaikimisi tehakse iga minuti video. Väärtuse mov puhul liikumiste video. Väärtused on min või mov')
    # Valikuline fps. Vaikimisi on 60
    parser.add_argument('-f', '--fps', type=int, nargs='?', const=60, default=60, help='Vaikimisi tehakse video 60 FPSi. Lubatud täisarvud.')
    # Valikuline vaikimisi videot ei tehtua
    parser.add_argument('-c', '--count', type=bool, nargs='?', const=False, default=False, help='Mõõdetakse kaustade suurust (maht ja faile kokku) kuupäevade kaupa. Vaikimisi False. MP4 faili ei tehta.')
    # Teha aasta video
    parser.add_argument('-y', '--year', type=bool, nargs='?', const=False, default=False, help='Tehakse aasta video True. Vaikimisi False. Lisaks tuleks määrata ka võti -t mis valib kellaaja. Vaikimisi on ajaks kell 12:00 (failinimes 1200).')
    # Kui on määratud, siis tehakse selles kellaaja vahemikus olevatest piltidest video (Võimaldab teha talivseal ajal ainult valges videod)
    parser.add_argument('-t', '--time', type=str, nargs='?', default='0000:2359', help='Võimaldab määrata kellaajad mis vahemikus pildid valitakse. Vaikimisi 0000:2359. Video. Sobib aasta videoks või talviste pimeda aja asemel teha päevased klipid, mitte kogu päev.')

    args = parser.parse_args()
    return args

def days_between(d1, d2):
    d1 = datetime.strptime(d1, "%Y-%m-%d")
    d2 = datetime.strptime(d2, "%Y-%m-%d")
    return abs((d2 - d1).days)

def manageFolders():
    uniqueFilenames = set(getUniqueFilenames(srcPath))      # Eemaldab duplikaadid (ei ole kaustateed) set unordered
    result = list(uniqueFilenames)                          # Unikaalsed kuupäevad (ei ole kaustateed)
    result.sort()                                           # Sorteerimi tulemuse
    count = 0                                               # Loeme kopeeritud failid kokku
    # Käib kogu massiivi ükshaaval läbi
    for i in range(0, len(result)):
        # Teeme kausta, kui seda pole
        if srcPath + result[i] != srcPath + 'lastsnap.jpg':
            createNewFolder(srcPath + result[i])    # Teeme kausta kui seda pole
            count += moveFilesNewFolder(result[i])  # Tõsatme failid uude kausta ja loendame need samas kokku
    return count

def getUniqueFilenames(source):
    files = glob.glob(srcPath + '*.jpg')
    allFiles = list()
    for file in files:
        if file.endswith('.jpg'):
            (filepath, filename) = os.path.split(file)
            allFiles.append(filename.split('_')[0])
    return allFiles

# Uue kasuta tegemine
def createNewFolder(folderName): # Kasutanimi koos kasutateega
    if not os.path.exists(folderName):
        os.makedirs(folderName)

def moveFilesNewFolder(startFilename):
    files = glob.glob(srcPath + startFilename + '_*.jpg') # Kõik sobivad päeva failid
    count = 0
    for file in files:
        count += 1
        shutil.move(file, srcPath + startFilename)
    return count

# Kustutab failid dstPath kaustas, kui see pole tühi. Eelnevalt kontrollib,
# kas see on olemas või mitte. Kui pole, siis teeb selle
def DelFilesIfNecessarry():
    if not os.path.exists(dstPath):
        os.makedirs(dstPath)
        print(showTimeStamp() + " - tehti kaust: " + dstPath)
    else:
        # Failide kokku lugemiseks
        i = 0
        # Kas kaust, kuhu kopeerida uued failid on tühi
        if os.listdir(dstPath) != []:
            fileList = os.listdir(dstPath)
            for fileName in fileList:
                os.remove(dstPath + fileName)
                i += 1
            print(showTimeStamp() + ' - kaustas ' + GRN + dstPath + END + ' oli ' + str(i) + ' fail(i) ja need kustutati!')
        else:
            print(showTimeStamp() + ' - kaust ' + RED + dstPath + END + ' oli tühi!')

# Loetakse ainult minuti failid etteantud kuupäeva kaustast
def minutiFailid(files, kuupaev):
    global minutid, startDate, endDate
    for filename in files:
        fileDate = filename.split("_")[0] # Failinime osa
        fileTime = int((filename.split('_')[1])[0:4]) # Siit võetakse tunnid ja minutid failinimest ja tehakse integeriks
        if daysTotal == 2: # Arvestab kahe päeva puhul kellaaegasid õigesti minuti baasil
            if minMatch.match(filename) and fileDate == kuupaev and fileDate == startDate and fileTime >= int(startTime):
                minutid.append(srcPath + kuupaev + '/' + filename)
            elif minMatch.match(filename) and fileDate == kuupaev and fileDate == endDate and fileTime <= int(endTime):
                minutid.append(srcPath + kuupaev + '/' + filename)
        elif minMatch.match(filename) and fileDate == kuupaev and (fileTime >= int(startTime) and fileTime <= int(endTime)):
            """ Arvestab vaikimisi varianti """
            minutid.append(srcPath + kuupaev + '/' + filename)
    minutid.sort()

# Loetakse ainult movie failid
def movieFailid(files, kuupaev):
    global movies
    for filename in files:
        fileTime = int((filename.split('_')[1])[0:4])
        if movMatch.match(filename) and (fileTime >= int(startTime) and fileTime <= int(endTime)):
            movies.append(srcPath + kuupaev + '/' + filename)
    movies.sort()

# Otsib kõik minuti failid ülesse
def getNeededMinFiles():
    fileCounter = 0
    if endDate != '':
        start = datetime.strptime(startDate, '%Y-%m-%d')    # Kuupäev koos ajaga aga aeg on 0
        end = datetime.strptime(endDate, '%Y-%m-%d')        # Kuupäev koos ajaga aga aeg on 0
        step = timedelta(days=1)
        #sTime = int(startTime)  # Algus kellaaeg
        #eTime = int(endTime)    # Lõpu kellaaeg
        while start <= end:
            currentDate = start.date()
            start += step
            filePath = os.path.join(srcPath + str(currentDate) + '/')
            if os.path.isdir(filePath):
                files = os.listdir(filePath)
                minutiFailid(files, str(currentDate))
                result = CopySpecificFiles(minutid, str(currentDate))
                fileCounter += result
            else:
                print(showTimeStamp() + ' - kausta ' + RED + filePath + END + ' ei leitud!')
                #sys.exit()
        return fileCounter
    else:
        filePath = os.path.join(srcPath + startDate + '/')
        if os.path.isdir(filePath):
            files = os.listdir(filePath)
            minutiFailid(files, startDate)
            result = CopySpecificFiles(minutid, startDate)
            fileCounter += result
            return fileCounter
        else:
            print(showTimeStamp() + ' - kausta ' + RED + filePath + END + ' ei leitud!')
            #sys.exit()

def getNeededMovFiles():
    filesCounter = 0
    if endDate != '':
        start = datetime.strptime(startDate, '%Y-%m-%d')    # Kuupäev koos ajaga aga aeg on 0
        end = datetime.strptime(endDate, '%Y-%m-%d')        # Kuupäev koos ajaga aga aeg on 0
        step = timedelta(days=1)
        while start <= end:
            currentDate = start.date()
            start += step
            filePath = os.path.join(srcPath + str(currentDate) + '/')
            if os.path.isdir(filePath):
                files = os.listdir(filePath)
                movieFailid(files, str(currentDate))
                result = CopySpecificFiles(movies, str(currentDate))
                filesCounter += result
            else:
                print(showTimeStamp() + ' - kausta ' + RED + filePath + END + ' ei leitud!')
                #sys.exit()
        return filesCounter
    else:
        filePath = os.path.join(srcPath + startDate + '/')
        if os.path.isdir(filePath):
            files = os.listdir(filePath)
            movieFailid(files, startDate)
            result = CopySpecificFiles(movies, startDate)
            filesCounter += result
            return filesCounter
        else:
            print(showTimeStamp() + ' - kausta ' + RED + filePath + END + ' ei leitud!')
            #sys.exit()

# Kopeeritakse kõik etteantud failid uude kausta uue nimega
def CopySpecificFiles(files, kuupaev):
    filesCounter = 0
    filesTotal = 0
    # Milliste failidega on tegemist
    fromSrc = srcPath + kuupaev + '/*'
    # Käib kogu sorteeritud massiivi failikaupa läbi
    for file in sorted(files):
        # Näitab failinime ilma kaustata
        filename = os.path.basename(file)
        fileDate = filename.split("_")[0]
        if fileDate == kuupaev:
            newFileName = ChangeFileName(filename, kuupaev)
            dstPathWithFile = os.path.join(dstPath + newFileName)
            # Kontrolli kas on fail ja ja õige päevaga, siis kopeeri
            if os.path.isfile(file):
                shutil.copy2(file, dstPathWithFile)
                filesCounter += 1
    #print(showTimeStamp() + ' - kopeeritud ja ümbernimetatud ' + GRN + str(filesCounter) + END + ' faili. Kuupäev: ' + kuupaev)
    return filesCounter

# Failinime muutmine
def ChangeFileName(filename, kuupaev):
    global counter
    filenameparts = filename.split('_')
    # Vormindame numbri kuuekohaliseks ja tühik täidetakse nullidega 000000 kuni 999999
    newFileName = 'image_' + '{0:06d}'.format(counter) + '.jpg'
    counter += 1
    return newFileName

def showHeader():
    print('')
    print('  Kaust    Maht  Min   Mov')
    print('--------------------------')

# Arvutab kasuta mahu kokku
def du(path):
    """disk usage in human readable format (e.g. '2,1GB')"""
    return subprocess.check_output(['du','-sh', path]).split()[0].decode('utf-8')

# Loendame failid kokku ja mõõdame kasuta suurust
def countFilesAndSize():
    if endDate != '':   # Kui on mitu kausta
        start = datetime.strptime(startDate, '%Y-%m-%d')
        end = datetime.strptime(endDate, '%Y-%m-%d')
        step = timedelta(days=1)
        showHeader()
        while start <= end:
            currentDate = start.date()
            start += step
            thisPath = os.path.join(srcPath + str(currentDate) + '/')
            if os.path.isdir(thisPath):
                files = os.listdir(thisPath)
                mins = 0
                movs = 0
                for file in files:
                    if minMatch.match(file):
                        mins += 1
                    elif movMatch.match(file):
                        movs += 1
                print(str(currentDate) + ' ' + str(du(thisPath)).rjust(4) + ' ' + str(mins).zfill(4) + ' ' + str(movs).rjust(5))
            else:
                print(str(currentDate) + RED + ' kausta pole.' + END)

    else:               # Ühe kasuta kokku lugemine
        thisPath = os.path.join(srcPath + startDate + '/')
        if os.path.isdir(thisPath):
            showHeader()
            files = os.listdir(thisPath)
            mins = 0
            movs = 0
            for file in files:
                if minMatch.match(file):
                    mins += 1
                elif movMatch.match(file):
                    movs += 1
            print(startDate + ' ' + str(du(thisPath)) + ' ' + str(mins) + ' ' + str(movs))
        else:
            print(showTimeStamp() + ' - kausta ' + RED + thisPath + END + ' ei leitud.')
# MAIN
print(showTimeStamp() + ' - Skript käivitati.\n')
args = parseCommandLine()
#print(args)
# Omistame käsurealt saadud muutujatele väärtused
# Algus kuupäev
startDate = time.strftime('%Y-%m-%d', args.startDate)   # Algus Kuupäev kujule YYYY-MM-DD
fileMP4 += startDate + '_'

# Lõpu kuupäev
if args.endDate != None:
    endDate = time.strftime('%Y-%m-%d', args.endDate)
    if args.startDate > args.endDate: # Kui algus kuupäev on suurem kui lõpu kuupäev, vahetame päevad ringi
        tmp = startDate
        tmpFull = args.startDate
        args.startDate = args.endDate
        args.endDate = tmpFull
        startDate = endDate             # Mulle vajalik (str)
        endDate = tmp                   # Mulle vajalik (str)
    daysTotal = days_between(startDate, endDate) + 1
    fileMP4 += endDate + '_'
else:
    endDate = ''

# Lisame failinimele resolutsiooni ja FPSi
movie = args.movie.lower()      # Kas MOV või MIN (default MIN)
fps = args.fps          # FPS täisarvuna (default 60)
count = args.count      # Failide loendamine (default False)
year = args.year        # Aasta video True või False
fileMP4 += '1280x720_' + str(fps)+'fps_'

if not year:
    fileMP4 += movie + '_'
else:
    movie = 'year'
    fileMP4 += movie + '_'

# Kontrollime aastat ja sellega seotud kellaaega
time = args.time
if year:
    if args.time == '0000:2359':
        startTime = '1200'
        endTime = '1200'
    else:
        if args.time.split(':')[0] != args.time.split(':')[1]:  # Kui pole sama number, siis on asi katki
            warning = 'Aasta videol peab olema algus- ja lõpu kellaaeg sama.'
            scriptStop = True
            startTime = args.time.split(':')[0] # See ei lähe kasutusse
            endTime = args.time.split(':')[1]   # See ei lähe kasutusse
        else:
            startTime = args.time.split(':')[0]
            endTime = args.time.split(':')[1]
    if endDate == '': # Aasta videole on vaja lõpukuupäeva ka!
        warning = 'Aasta videol tuleb määrata nii algus kui lõpukuupäev.'
        scriptStop = True
else:
    # Kontrollime kellaaega
    if args.time != '0000:2359':
        startTime = args.time.split(':')[0]
        endTime = args.time.split(':')[1]
    else:
        startTime = '0000'
        endTime = '2359'

fileMP4 += startTime + '-' + endTime + '.mp4'

# Kontrollime aasta ja failide lugemise sõltuvust
if count and year:
    warning = 'Samaaegselt ei saa teha aasta videot ja loendada faile.'
    scriptStop = True

if count:
    fileMP4 = 'Pole'

# VÄLJASTAME ALGINFO
print('Algus kuupäev:    ' + startDate)
print('Lõpu kuupäev:     ' + endDate)
print('Päevi kokku:      ' + str(daysTotal))
print('Kellaajad:        ' + time)
print('Algusaeg:         ' + startTime)
print('Lõpuaeg:          ' + endTime)
print('Video tüüp:       ' + movie)
print('Video FPS:        ' + str(fps))
print('Aasta video:      ' + str(year))
print('Failide lugemine: ' + str(count))
print('Failinimi:        ' + fileMP4)
if scriptStop:
    print('Hoiatused:        ' + RED + warning + END + '\n')
else:
    print('Hoiatused:        ' + GRN + warning + END +'\n')

# Siin vastavalt valikutele tegevused
if not scriptStop:
    # Kui skript jääb tööle, siis esmalt teeme kindlad liigutused
    print(showTimeStamp() + ' - tõstame failid õigetesse kaustadesse.')
    result = manageFolders()    # Kui palju faile ümber tõsteti
    print(showTimeStamp() + ' - tõsteti ' + GRN + str(result) + END + ' fail(i) õigetesse kaustadesse.')
    DelFilesIfNecessarry()      # Kustutab dstPath kaustast failid kui on või teeb kasuta kui pole
    # Siit algab tegevus vastavalt käsurea parameetritele
    if count:   # Failide loendamine
        print(showTimeStamp() + ' - LOENDAME FAILE')
        countFilesAndSize()
    elif year:  # Aasta video. Nüüd nagu MIN video
        print(showTimeStamp() + ' - AASTA VIDEO')
        result = getNeededMinFiles() # Vajalikud failid on listis minutid
        print(showTimeStamp() + ' - kokku kopeeriti ja nimetati ümber ' + GRN + str(result) + END + ' faili.')
        print(showTimeStamp() + ' - Palun oota, teen MP4 faili...')
        #cmd = '/usr/bin/avconv -r ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg -r ' + str(fps) + ' -vcodec libx264 -crf 20 -g 15 -vf scale=w=1280:h=720 -v quiet ' +  dstPath + fileMP4
        cmd = '/usr/bin/ffmpeg -loglevel quiet -framerate ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg ' + dstPath + fileMP4
	subprocess.call(cmd, shell=True)
        print(showTimeStamp() + ' - Failiasukoht: ' + GRN + (dstPath + fileMP4) + END)
        fileSize = os.path.getsize(dstPath + fileMP4)
        print(showTimeStamp() + ' - Faili suurus baitides: ' + RED + '{:,}'.format(fileSize).replace(',',' ') + END) # iga tuhande vahel on tühik default ,
    elif movie == 'min':    # Minutite video
        print(showTimeStamp() + ' - MINUTITE VIDEO')
        result = getNeededMinFiles() # Vajalikud failid on listis minutid
        print(showTimeStamp() + ' - kokku kopeeriti ja nimetati ümber ' + GRN + str(result) + END + ' faili.')
        print(showTimeStamp() + ' - Palun oota, teen MP4 faili...')
        #cmd = '/usr/bin/avconv -r ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg -r ' + str(fps) + ' -vcodec libx264 -crf 20 -g 15 -vf scale=w=1280:h=720 -v quiet ' +  dstPath + fileMP4
        cmd = '/usr/bin/ffmpeg -loglevel quiet -framerate ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg ' + dstPath + fileMP4
	subprocess.call(cmd, shell=True)
        print(showTimeStamp() + ' - Failiasukoht: ' + GRN + (dstPath + fileMP4) + END)
        fileSize = os.path.getsize(dstPath + fileMP4)
        print(showTimeStamp() + ' - Faili suurus baitides: ' + RED + '{:,}'.format(fileSize).replace(',',' ') + END) # iga tuhande vahel on tühik default ,
    elif movie == 'mov':    # Liikumiste vide
        print(showTimeStamp() + ' - LIIKUMISTE VIDEO')
        result = getNeededMovFiles() # Vajalikud liikumiste failid
        print(showTimeStamp() + ' - kokku kopeeriti ja nimetati ümber ' + GRN + str(result) + END + ' faili.')
        print(showTimeStamp() + ' - Palun oota, teen MP4 faili...')
        #cmd = '/usr/bin/avconv -r ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg -r ' + str(fps) + ' -vcodec libx264 -crf 20 -g 15 -vf scale=w=1280:h=720 -v quiet ' +  dstPath + fileMP4
	cmd = '/usr/bin/ffmpeg -loglevel quiet -framerate ' + str(fps) + ' -i ' + dstPath + 'image_%06d.jpg ' + dstPath + fileMP4
        subprocess.call(cmd, shell=True)
        print(showTimeStamp() + ' - Failiasukoht: ' + GRN + (dstPath + fileMP4) + END)
        fileSize = os.path.getsize(dstPath + fileMP4)
        print(showTimeStamp() + ' - Faili suurus baitides: ' + RED + '{:,}'.format(fileSize).replace(',',' ') + END) # iga tuhande vahel on tühik default ,
    else:
        print('Midagi ei tehta. Kuidas see juhtus?')
else:
    print(showTimeStamp() + ' - ' + RED + 'Leiti viga või mitu!' + END)

print(showTimeStamp() + ' - Skript lõpetas töö')