Example #1
0
 def __init__(self, debug=False, allowNone=False):
     """ Initialise the EncodingServer class """
     logger.log(9, 'EncodingServer.__init__(debug=%r, allowNone=%r)', debug,
                allowNone)
     self.debug = debug
     self.jobs = {}
     self.encodingopts = EncodingOptions()
     self.queue = EncodingQueue()
     logger.info('EncodingServer started...')
 def __init__(self, debug=False, allowNone=False):
     """ Initialise the EncodingServer class """
     _debug_('EncodingServer.__init__(debug=%r, allowNone=%r)' % (debug, allowNone), 2)
     try:
         xmlrpc.XMLRPC.__init__(self, allowNone)
     except TypeError:
         xmlrpc.XMLRPC.__init__(self)
     self.debug = debug
     self.jobs = {}
     self.encodingopts = EncodingOptions()
     self.queue = EncodingQueue()
     _debug_("EncodingServer started...", DINFO)
    def __init__(self, debug=False):
        self.jobs = {}

        #setup a logger
        #if debug: #when debugging, output everything to stdout using the root logging class
        #    self.log = logging
        #else: #normally, write nice formatted messages to a logfile)
        #    self.log = logging.getLogger("EncodingServer")
        #    self.log.setLevel(logging.INFO)
        #    FHandler = logging.FileHandler("encodingserver.log")
        #    FHandler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s %(message)s"))
        #    self.log.addHandler(FHandler)

        self.queue = EncodingQueue(log, DEBUG)

        _debug_("EncodingServer started...", 0)
Example #4
0
 def __init__(self, debug=False, allowNone=False):
     """ Initialise the EncodingServer class """
     logger.log( 9, 'EncodingServer.__init__(debug=%r, allowNone=%r)', debug, allowNone)
     self.debug = debug
     self.jobs = {}
     self.encodingopts = EncodingOptions()
     self.queue = EncodingQueue()
     logger.info('EncodingServer started...')
class EncodingServer(xmlrpc.XMLRPC):

    def __init__(self, debug=False, allowNone=False):
        """ Initialise the EncodingServer class """
        _debug_('EncodingServer.__init__(debug=%r, allowNone=%r)' % (debug, allowNone), 2)
        try:
            xmlrpc.XMLRPC.__init__(self, allowNone)
        except TypeError:
            xmlrpc.XMLRPC.__init__(self)
        self.debug = debug
        self.jobs = {}
        self.encodingopts = EncodingOptions()
        self.queue = EncodingQueue()
        _debug_("EncodingServer started...", DINFO)

    def xmlrpc_echotest(self, blah):
        """ Using Twisted check the connection """
        _debug_('xmlrpc_echotest(blah=%r)' % (blah), 2)
        return (True, 'EncodingServer::echotest: %s' % blah)

    def xmlrpc_initEncodeJob(self, source, output, friendlyname="", chapter=None):
        """ Using Twisted initialise an encoding job """
        _debug_('xmlrpc_initEncodeJob(source=%r, output=%r, friendlyname=%r, chapter=%r)' % \
            (source, output, friendlyname, chapter), 1)
        #safety checks
        if not (source or output):
            return (False, 'EncodingServer::initEncodeJob:  no source or output given')

        # generate a "random" idnr based on the time in p2.3, int() can return long
        # int's, which is fine, except it makes XMLRPC fail somewhere along the way so we
        # devide or random number by 100 :)
        idnr = int((time.time() / random.random()) / 100)
        _debug_("idnr=%s" % (idnr), 2)
        self.jobs[idnr] = EncodingJob(source, output, friendlyname, idnr, chapter)

        #wait for the analyzing to end
        while not self.jobs[idnr].finishedanalyze:
            time.sleep(0.1)
        if self.jobs[idnr].finishedanalyze and self.jobs[idnr].failed:
            _debug_('Analysis failed')
            return (False,10)

        _debug_("Initialized job %s (idnr : %s)" % (friendlyname, idnr), DINFO)

        return (True, idnr)

    def xmlrpc_getContainerCAP(self):
        """ Using Twisted get the container capabilities """
        _debug_('xmlrpc_getContainerCAP()' , 2)
        return EncodingOptions.getContainerList( self.encodingopts)

    def xmlrpc_setContainer(self, idnr, container):
        """ Using Twisted set the container """
        _debug_('xmlrpc_setContainer(idnr=%r, container=%r)' % (idnr, container), 2)
        status = self.jobs[idnr].setContainer(container)

        if not status:
            return (True, "EncodingServer::setContainer: OK")
        else:
            return (False, "EncodingServer::setContainer: %s" % status)

    def xmlrpc_getVideoCodecCAP(self):
        """ Using Twisted get the video capabilities """
        _debug_('xmlrpc_getVideoCodecCAP()', 2)
        return EncodingOptions.getVideoCodecList(self.encodingopts)

    def xmlrpc_setVideoCodec(self, idnr, vcodec, tgtsize, multipass=False, vbitrate=0, altprofile=None):
        """ Using Twisted set the video codec """
        _debug_('xmlrpc_setVideoCodec(idnr=%r, vcodec=%r, tgtsize=%r, multipass=%r, vbitrate==%r)' % \
            (idnr, vcodec, tgtsize, multipass, vbitrate), 1)
        #safety checks
        if not (vcodec or (tgtsize and vbitrate)):
            return (False, 'EncodingServer::setVideoCodec:  no codec or target size given')

        status = self.jobs[idnr].setVideoCodec(vcodec, tgtsize, multipass, vbitrate, altprofile)

        if not status:
            return (True, "EncodingServer::setVideoCodec: OK")
        else:
            return (False, "EncodingServer::setVideoCodec: %s" % status)

    def xmlrpc_getAudioCodecCAP(self):
        """ Using Twisted get the audio capabilities """
        _debug_('xmlrpc_getAudioCodecCAP()', 2)
        return EncodingOptions.getAudioCodecList(self.encodingopts)

    def xmlrpc_setAudioCodec(self, idnr, acodec, abrate):
        """ Using Twisted set the audio codec """
        _debug_('xmlrpc_setAudioCodec(idnr=%r, acodec=%r, abrate=%r)' % (idnr, acodec, abrate), 2)
        #safety checks
        if not (acodec or abrate):
            return (False, 'EncodingServer::setAudioCodec:  no codec or bitrate given')

        status = self.jobs[idnr].setAudioCodec(acodec, abrate)

        if not status:
            return (True, "EncodingServer::setAudioCodec: OK")
        else:
            return (False, "EncodingServer::setAudioCodec: %s" % status)


    def xmlrpc_setVideoRes(self, idnr, videores ):
        """ Using Twisted set the video resolution """
        _debug_('xmlrpc_setAudioCodec(idnr=%r, videores=%r)' % (idnr, videores ), 2)
        #safety checks
        if not (videores):
            return (False, 'EncodingServer::setVideoRes:  no video resolution given')

        status = self.jobs[idnr].setVideoRes( videores)

        if not status:
            return (True, "EncodingServer::setVideoRes: OK")
        else:
            return (False, "EncodingServer::setVideoRes: %s" % status)


    def xmlrpc_setNumThreads(self, idnr, numthreads ):
        """ Using Twisted set the number of threads """
        _debug_('xmlrpc_setAudioCodec(idnr=%r, numthreads=%r)' % (idnr, numthreads ), 2)
        #safety checks
        if not (numthreads):
            return (False, 'EncodingServer::setNumThreads:  no number given')

        status = self.jobs[idnr].setNumThreads( numthreads)

        if not status:
            return (True, "EncodingServer::setNumThreads: OK")
        else:
            return (False, "EncodingServer::setNumThreads: %s" % status)


    def xmlrpc_getVideoFiltersCAP(self):
        """ Using Twisted get the video filter capabilities """
        _debug_('xmlrpc_getVideoFiltersCAP()', 2)
        return EncodingOptions.getVideoFiltersList(self.encodingopts)


    def xmlrpc_setVideoFilters(self, idnr, filters):
        """ Using Twisted set the video filter list """
        _debug_('xmlrpc_setVideoFilters(idnr, filters)', 2)
        #safety checks
        if not filters:
            return (False, 'EncodingServer::setAudioCodec:  no codec or bitrate given')

        status = self.jobs[idnr].setVideoFilters(unjam(filters))

        if not status:
            return (True, "EncodingServer::setVideoFilters: OK")
        else:
            return (False, "EncodingServer::setVideoFilters: %s" % status)

    def xmlrpc_queueIt(self, idnr, now=False):
        """ Using Twisted queue a job to run """
        _debug_('xmlrpc_queueIt(idnr=%r, now=%r)' % (idnr, now), 2)
        self.queue.addEncodingJob(self.jobs[idnr])
        del self.jobs[idnr]
        _debug_("Added job %s to the queue" % idnr, DINFO)
        if now:
            self.queue.startQueue()
        return (True, "EncodingServer::queueIt: OK")

    def xmlrpc_getProgress(self):
        """ Using Twisted get the progress status of the current job """
        _debug_('xmlrpc_getProgress()', 2)
        prog = self.queue.getProgress()
        if type(prog) is str:
            return (False, "EncodingServer::getProgress: %s" % prog)
        return (True, jam(prog))

    def xmlrpc_startQueue(self):
        """ Using Twisted start the job queue """
        _debug_('xmlrpc_startQueue()', 2)
        self.queue.startQueue()
        return (True, "EncodingServer::startqueue: OK")

    def xmlrpc_listJobs(self):
        """ List the current jobs """
        _debug_('xmlrpc_listJobs()', 2)
        jlist = self.queue.listJobs()
        return (True, jam(jlist))
class EncodingServer(xmlrpc.XMLRPC):
    def __init__(self, debug=False):
        self.jobs = {}

        #setup a logger
        #if debug: #when debugging, output everything to stdout using the root logging class
        #    self.log = logging
        #else: #normally, write nice formatted messages to a logfile)
        #    self.log = logging.getLogger("EncodingServer")
        #    self.log.setLevel(logging.INFO)
        #    FHandler = logging.FileHandler("encodingserver.log")
        #    FHandler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s %(message)s"))
        #    self.log.addHandler(FHandler)

        self.queue = EncodingQueue(log, DEBUG)

        _debug_("EncodingServer started...", 0)

    def xmlrpc_echotest(self, blah):
        _debug_("xmlrpc_echotest(self, blah)", 3)
        return (True, 'EncodingServer::echotest: %s' % blah)

    def xmlrpc_initEncodeJob(self,
                             source,
                             output,
                             friendlyname="",
                             chapter=None):
        _debug_(
            "xmlrpc_initEncodeJob(self, %s, %s, %s, %s)" %
            (source, output, friendlyname, chapter), 3)
        #safety checks
        if not (source or output):
            return (
                False,
                'EncodingServer::initEncodeJob:  no source or output given')
        #generate a "random" idnr based on the time
        #in p2.3 , int() can return long int's, wich is fine, except it makes XMLRPC fail somwhere along the way
        # so we devide or random number by 100 :)
        idnr = int((time.time() / random.random()) / 100)
        _debug_("idnr=%s" % (idnr), 2)
        self.jobs[idnr] = EncodingJob(source, output, friendlyname, idnr,
                                      chapter)

        #wait for the analyzing to end
        while not self.jobs[idnr].finishedanalyze:
            time.sleep(0.1)

        _debug_("Initialized job %s (idnr : %s)" % (friendlyname, idnr), 0)

        return (True, idnr)

    def xmlrpc_getContainerCAP(self, idnr):
        _debug_("xmlrpc_getContainerCAP(self, idnr)", 3)
        return (True, jam(self.jobs[idnr].getContainerList()))

    def xmlrpc_setContainer(self, idnr, container):
        _debug_("xmlrpc_setContainer(self, idnr, container)", 3)
        status = self.jobs[idnr].setContainer(container)

        if not status:
            return (True, "EncodingServer::setContainer: OK")
        else:
            return (False, "EncodingServer::setContainer: %s" % status)

    def xmlrpc_getVideoCodecCAP(self, idnr):
        _debug_("xmlrpc_getVideoCodecCAP(self, idnr)", 3)
        return (True, jam(self.jobs[idnr].getVideoCodecList()))

    def xmlrpc_setVideoCodec(self,
                             idnr,
                             vcodec,
                             tgtsize,
                             multipass=False,
                             vbitrate=0):
        _debug_("xmlrpc_setVideoCodec(self, %s, %s, %s, %s %s)" % \
            (idnr, vcodec, tgtsize, multipass, vbitrate), 3)
        #safety checks
        if not (vcodec or (tgtsize and vbitrate)):
            return (
                False,
                'EncodingServer::setVideoCodec:  no codec or target size given'
            )

        status = self.jobs[idnr].setVideoCodec(vcodec, tgtsize, multipass,
                                               vbitrate)

        if not status:
            return (True, "EncodingServer::setVideoCodec: OK")
        else:
            return (False, "EncodingServer::setVideoCodec: %s" % status)

    def xmlrpc_getAudioCodecCAP(self, idnr):
        _debug_("xmlrpc_getAudioCodecCAP(self, idnr)", 3)
        return (True, jam(self.jobs[idnr].getAudioCodecList()))

    def xmlrpc_setAudioCodec(self, idnr, acodec, abrate):
        _debug_("xmlrpc_setAudioCodec(self, idnr, acodec, abrate)", 3)
        #safety checks
        if not (acodec or abrate):
            return (
                False,
                'EncodingServer::setAudioCodec:  no codec or bitrate given')

        status = self.jobs[idnr].setAudioCodec(acodec, abrate)

        if not status:
            return (True, "EncodingServer::setAudioCodec: OK")
        else:
            return (False, "EncodingServer::setAudioCodec: %s" % status)

    def xmlrpc_getVideoFiltersCAP(self, idnr):
        _debug_("xmlrpc_getVideoFiltersCAP(self, idnr)", 3)
        return (True, jam(self.jobs[idnr].getVideoFiltersList()))

    def xmlrpc_setVideoFilters(self, idnr, filters):
        _debug_("xmlrpc_setVideoFilters(self, idnr, filters)", 3)
        #safety checks
        if not filters:
            return (
                False,
                'EncodingServer::setAudioCodec:  no codec or bitrate given')

        status = self.jobs[idnr].setVideoFilters(unjam(filters))

        if not status:
            return (True, "EncodingServer::setVideoFilters: OK")
        else:
            return (False, "EncodingServer::setVideoFilters: %s" % status)

    def xmlrpc_queueIt(self, idnr, now=False):
        _debug_("xmlrpc_queueIt(self, idnr, now=False)", 3)
        self.queue.addEncodingJob(self.jobs[idnr])
        del self.jobs[idnr]
        _debug_("Added job %s to the queue" % idnr, 0)
        if now:
            self.queue.startQueue()
        return (True, "EncodingServer::queueIt: OK")

    def xmlrpc_getProgress(self):
        _debug_("xmlrpc_getProgress(self)", 3)
        prog = self.queue.getProgress()
        if type(prog) is str:
            return (False, "EncodingServer::getProgress: %s" % prog)
        return (True, jam(prog))

    def xmlrpc_startQueue(self):
        _debug_("xmlrpc_startQueue(self)", 3)
        self.queue.startQueue()
        return (True, "EncodingServer::startqueue: OK")

    def xmlrpc_listJobs(self):
        _debug_("xmlrpc_listJobs(self)", 3)
        jlist = self.queue.listJobs()
        return (True, jam(jlist))
Example #7
0
class EncodingServer:
    def __init__(self, debug=False, allowNone=False):
        """ Initialise the EncodingServer class """
        logger.log(9, 'EncodingServer.__init__(debug=%r, allowNone=%r)', debug,
                   allowNone)
        self.debug = debug
        self.jobs = {}
        self.encodingopts = EncodingOptions()
        self.queue = EncodingQueue()
        logger.info('EncodingServer started...')

    @kaa.rpc.expose('ping')
    def _pingtest(self):
        logger.log(9, 'pingtest()')
        return True

    @kaa.rpc.expose('getContainerCAP')
    def _getContainerCAP(self):
        """ get the container capabilities """
        return (True, EncodingOptions.getContainerList(self.encodingopts))

    @kaa.rpc.expose('getVideoCodecCAP')
    def _getVideoCodecCAP(self):
        """ get the video capabilities """
        return (True, EncodingOptions.getVideoCodecList(self.encodingopts))

    @kaa.rpc.expose('getAudioCodecCAP')
    def _getAudioCodecCAP(self):
        """ get the audio capabilities """
        return (True, EncodingOptions.getAudioCodecList(self.encodingopts))

    @kaa.rpc.expose('getVideoFiltersCAP')
    def _getVideoFiltersCAP(self):
        """ get the video filter capabilities """
        return (True, EncodingOptions.getVideoFiltersList(self.encodingopts))

    @kaa.rpc.expose('initEncodingJob')
    def _initEncodingJob(self,
                         source,
                         output,
                         friendlyname='',
                         chapter=None,
                         rmsource=False):
        """
        Initialise an encoding job
        @param source: source file to encode
        @param output: output file to encode
        @param friendlyname: encoding job title
        @param chapter: chapter number to encode
        @param rmsource: remove the source after successful encoding
        @returns: tuple of success status and job identifier
        """
        #safety checks
        if not (source or output):
            return (False, '%s.initEncodingJob: no source or output given' %
                    (self.__class__, ))

        # generate a 'random' idnr based on the time in p2.3, int() can return long
        # int's, which is fine, except it makes XMLRPC fail somewhere along the way so we
        # devide or random number by 100 :)
        idnr = int((time.time() / random.random()) / 100)
        logger.log(9, 'idnr=%s', idnr)
        self.jobs[idnr] = EncodingJob(source, output, friendlyname, idnr,
                                      chapter, rmsource)
        logger.info('Initialized job %s (idnr: %s)', friendlyname, idnr)
        if self.jobs[idnr].failed:
            return (False, 0)
        return (True, idnr)

    @kaa.rpc.expose('waitCropDetect')
    def _waitCropDetect(self, idnr):
        #wait for the analyzing to end
        status = self.jobs[idnr]._cropdetect()
        while not self.jobs[idnr].finishedanalyze:
            time.sleep(0.1)
        if self.jobs[idnr].finishedanalyze and self.jobs[idnr].failed:
            logger.debug('Crop detection failed')
            return (False, 'Crop detection failed')
        return (True, 'Ended successfully crop detection.')

    @kaa.rpc.expose('setContainer')
    def _setContainer(self, idnr, container):
        """ set the container """
        status = self.jobs[idnr].setContainer(container)
        if not status:
            return (True, 'EncodingServer::setContainer: OK')
        return (False, 'EncodingServer::setContainer: %s' % status)

    @kaa.rpc.expose('setVideoCodec')
    def _setVideoCodec(self,
                       idnr,
                       vcodec,
                       tgtsize,
                       multipass=False,
                       vbitrate=0,
                       altprofile=None):
        """ set the video codec """
        logger.debug(
            '_setVideoCodec(idnr=%r, vcodec=%r, tgtsize=%r, multipass=%r, vbitrate==%r)',
            idnr, vcodec, tgtsize, multipass, vbitrate)

        if not (vcodec or (tgtsize and vbitrate)):
            return (
                False,
                'EncodingServer::setVideoCodec: no codec or target size given')

        status = self.jobs[idnr].setVideoCodec(vcodec, tgtsize, multipass,
                                               vbitrate, altprofile)
        if not status:
            return (True, 'EncodingServer::setVideoCodec: OK')
        return (False, 'EncodingServer::setVideoCodec: %s' % status)

    @kaa.rpc.expose('setAudioCodec')
    def _setAudioCodec(self, idnr, acodec, abrate):
        """ set the audio codec """
        logger.log(9, '_setAudioCodec(idnr=%r, acodec=%r, abrate=%r)', idnr,
                   acodec, abrate)
        if not (acodec or abrate):
            return (
                False,
                'EncodingServer::setAudioCodec: no codec or bit rate given')

        status = self.jobs[idnr].setAudioCodec(acodec, abrate)
        if not status:
            return (True, 'EncodingServer::setAudioCodec: OK')
        return (False, 'EncodingServer::setAudioCodec: %s' % status)

    @kaa.rpc.expose('setVideoFilters')
    def _setVideoFilters(self, idnr, filters):
        """ set the video filter list """
        if not filters:
            return (False, 'EncodingServer::setVideoFilters: no filter given')

        status = self.jobs[idnr].setVideoFilters(filters)
        if not status:
            return (True, 'EncodingServer::setVideoFilters: OK')
        return (False, 'EncodingServer::setVideoFilters: %s' % status)

    @kaa.rpc.expose('setTimeslice')
    def _setTimeslice(self, idnr, timeslice):
        logger.log(8, '_setTimeslice(self, %s, %s)', idnr, timeslice)
        status = self.jobs[idnr].setTimeslice(timeslice)
        if not status:
            return (True, 'EncodingServer::setTimeslice: OK')
        return (False, 'EncodingServer::setTimeslice: %s' % status)

    @kaa.rpc.expose('setVideoRes')
    def _setVideoRes(self, idnr, videores):
        """ set the video resolution """
        logger.log(9, '_setAudioCodec(idnr=%r, videores=%r)', idnr, videores)
        if not (videores):
            return (False,
                    'EncodingServer::setVideoRes: no video resolution given')

        status = self.jobs[idnr].setVideoRes(videores)
        if not status:
            return (True, 'EncodingServer::setVideoRes: OK')
        return (False, 'EncodingServer::setVideoRes: %s' % status)

    @kaa.rpc.expose('setNumThreads')
    def _setNumThreads(self, idnr, numthreads):
        """ set the number of threads """
        logger.log(9, '_setAudioCodec(idnr=%r, numthreads=%r)', idnr,
                   numthreads)
        #safety checks
        if not (numthreads):
            return (False, 'EncodingServer::setNumThreads: no number given')

        status = self.jobs[idnr].setNumThreads(numthreads)
        if not status:
            return (True, 'EncodingServer::setNumThreads: OK')
        return (False, 'EncodingServer::setNumThreads: %s' % status)

    @kaa.rpc.expose('listJobs')
    def _listJobs(self):
        """ List the current jobs """
        logger.log(9, '_listJobs()')
        jlist = self.queue.listJobs()
        return (True, jlist)

    @kaa.rpc.expose('queueIt')
    def _queueIt(self, idnr, now=False):
        """ queue a job to run """
        logger.log(9, '_queueIt(idnr=%r, now=%r)', idnr, now)
        self.queue.addEncodingJob(self.jobs[idnr])
        del self.jobs[idnr]
        logger.info('Added job %s to the queue', idnr)
        if now:
            self.queue.startQueue()
        return (True, 'EncodingServer::queueIt: OK')

    @kaa.rpc.expose('startQueue')
    def _startQueue(self):
        """ start the job queue """
        logger.log(9, '_startQueue()')
        self.queue.startQueue()
        return (True, 'EncodingServer::startqueue: OK')

    @kaa.rpc.expose('getProgress')
    def _getProgress(self):
        """ get the progress status of the current job """
        logger.log(9, '_getProgress()')
        prog = self.queue.getProgress()
        if type(prog) is str:
            return (False, 'EncodingServer::getProgress: %s' % prog)
        return (True, prog)
Example #8
0
class EncodingServer:
    def __init__(self, debug=False, allowNone=False):
        """ Initialise the EncodingServer class """
        logger.log( 9, 'EncodingServer.__init__(debug=%r, allowNone=%r)', debug, allowNone)
        self.debug = debug
        self.jobs = {}
        self.encodingopts = EncodingOptions()
        self.queue = EncodingQueue()
        logger.info('EncodingServer started...')


    @kaa.rpc.expose('ping')
    def _pingtest(self):
        logger.log( 9, 'pingtest()')
        return True

    @kaa.rpc.expose('getContainerCAP')
    def _getContainerCAP(self):
        """ get the container capabilities """
        return (True, EncodingOptions.getContainerList(self.encodingopts))


    @kaa.rpc.expose('getVideoCodecCAP')
    def _getVideoCodecCAP(self):
        """ get the video capabilities """
        return (True, EncodingOptions.getVideoCodecList(self.encodingopts))


    @kaa.rpc.expose('getAudioCodecCAP')
    def _getAudioCodecCAP(self):
        """ get the audio capabilities """
        return (True, EncodingOptions.getAudioCodecList(self.encodingopts))


    @kaa.rpc.expose('getVideoFiltersCAP')
    def _getVideoFiltersCAP(self):
        """ get the video filter capabilities """
        return (True, EncodingOptions.getVideoFiltersList(self.encodingopts))


    @kaa.rpc.expose('initEncodingJob')
    def _initEncodingJob(self, source, output, friendlyname='', chapter=None, rmsource=False):
        """
        Initialise an encoding job
        @param source: source file to encode
        @param output: output file to encode
        @param friendlyname: encoding job title
        @param chapter: chapter number to encode
        @param rmsource: remove the source after successful encoding
        @returns: tuple of success status and job identifier
        """
        #safety checks
        if not (source or output):
            return (False, '%s.initEncodingJob: no source or output given' % (self.__class__,))

        # generate a 'random' idnr based on the time in p2.3, int() can return long
        # int's, which is fine, except it makes XMLRPC fail somewhere along the way so we
        # devide or random number by 100 :)
        idnr = int((time.time() / random.random()) / 100)
        logger.log( 9, 'idnr=%s', idnr)
        self.jobs[idnr] = EncodingJob(source, output, friendlyname, idnr, chapter, rmsource)
        logger.info('Initialized job %s (idnr: %s)', friendlyname, idnr)
        if self.jobs[idnr].failed:
            return (False, 0)
        return (True, idnr)


    @kaa.rpc.expose('waitCropDetect')
    def _waitCropDetect(self, idnr):
        #wait for the analyzing to end
        status = self.jobs[idnr]._cropdetect()
        while not self.jobs[idnr].finishedanalyze:
            time.sleep(0.1)
        if self.jobs[idnr].finishedanalyze and self.jobs[idnr].failed:
            logger.debug('Crop detection failed')
            return (False, 'Crop detection failed')
        return (True, 'Ended successfully crop detection.')


    @kaa.rpc.expose('setContainer')
    def _setContainer(self, idnr, container):
        """ set the container """
        status = self.jobs[idnr].setContainer(container)
        if not status:
            return (True, 'EncodingServer::setContainer: OK')
        return (False, 'EncodingServer::setContainer: %s' % status)


    @kaa.rpc.expose('setVideoCodec')
    def _setVideoCodec(self, idnr, vcodec, tgtsize, multipass=False, vbitrate=0, altprofile=None):
        """ set the video codec """
        logger.debug('_setVideoCodec(idnr=%r, vcodec=%r, tgtsize=%r, multipass=%r, vbitrate==%r)', idnr, vcodec, tgtsize, multipass, vbitrate)

        if not (vcodec or (tgtsize and vbitrate)):
            return (False, 'EncodingServer::setVideoCodec: no codec or target size given')

        status = self.jobs[idnr].setVideoCodec(vcodec, tgtsize, multipass, vbitrate, altprofile)
        if not status:
            return (True, 'EncodingServer::setVideoCodec: OK')
        return (False, 'EncodingServer::setVideoCodec: %s' % status)


    @kaa.rpc.expose('setAudioCodec')
    def _setAudioCodec(self, idnr, acodec, abrate):
        """ set the audio codec """
        logger.log( 9, '_setAudioCodec(idnr=%r, acodec=%r, abrate=%r)', idnr, acodec, abrate)
        if not (acodec or abrate):
            return (False, 'EncodingServer::setAudioCodec: no codec or bit rate given')

        status = self.jobs[idnr].setAudioCodec(acodec, abrate)
        if not status:
            return (True, 'EncodingServer::setAudioCodec: OK')
        return (False, 'EncodingServer::setAudioCodec: %s' % status)


    @kaa.rpc.expose('setVideoFilters')
    def _setVideoFilters(self, idnr, filters):
        """ set the video filter list """
        if not filters:
            return (False, 'EncodingServer::setVideoFilters: no filter given')

        status = self.jobs[idnr].setVideoFilters(filters)
        if not status:
            return (True, 'EncodingServer::setVideoFilters: OK')
        return (False, 'EncodingServer::setVideoFilters: %s' % status)


    @kaa.rpc.expose('setTimeslice')
    def _setTimeslice(self,idnr,timeslice):
        logger.log( 8, '_setTimeslice(self, %s, %s)', idnr, timeslice)
        status = self.jobs[idnr].setTimeslice(timeslice)
        if not status:
            return (True, 'EncodingServer::setTimeslice: OK')
        return (False, 'EncodingServer::setTimeslice: %s' % status)


    @kaa.rpc.expose('setVideoRes')
    def _setVideoRes(self, idnr, videores ):
        """ set the video resolution """
        logger.log( 9, '_setAudioCodec(idnr=%r, videores=%r)', idnr, videores)
        if not (videores):
            return (False, 'EncodingServer::setVideoRes: no video resolution given')

        status = self.jobs[idnr].setVideoRes( videores)
        if not status:
            return (True, 'EncodingServer::setVideoRes: OK')
        return (False, 'EncodingServer::setVideoRes: %s' % status)


    @kaa.rpc.expose('setNumThreads')
    def _setNumThreads(self, idnr, numthreads ):
        """ set the number of threads """
        logger.log( 9, '_setAudioCodec(idnr=%r, numthreads=%r)', idnr, numthreads)
        #safety checks
        if not (numthreads):
            return (False, 'EncodingServer::setNumThreads: no number given')

        status = self.jobs[idnr].setNumThreads( numthreads)
        if not status:
            return (True, 'EncodingServer::setNumThreads: OK')
        return (False, 'EncodingServer::setNumThreads: %s' % status)


    @kaa.rpc.expose('listJobs')
    def _listJobs(self):
        """ List the current jobs """
        logger.log( 9, '_listJobs()')
        jlist = self.queue.listJobs()
        return (True, jlist)


    @kaa.rpc.expose('queueIt')
    def _queueIt(self, idnr, now=False):
        """ queue a job to run """
        logger.log( 9, '_queueIt(idnr=%r, now=%r)', idnr, now)
        self.queue.addEncodingJob(self.jobs[idnr])
        del self.jobs[idnr]
        logger.info('Added job %s to the queue', idnr)
        if now:
            self.queue.startQueue()
        return (True, 'EncodingServer::queueIt: OK')


    @kaa.rpc.expose('startQueue')
    def _startQueue(self):
        """ start the job queue """
        logger.log( 9, '_startQueue()')
        self.queue.startQueue()
        return (True, 'EncodingServer::startqueue: OK')


    @kaa.rpc.expose('getProgress')
    def _getProgress(self):
        """ get the progress status of the current job """
        logger.log( 9, '_getProgress()')
        prog = self.queue.getProgress()
        if type(prog) is str:
            return (False, 'EncodingServer::getProgress: %s' % prog)
        return (True, prog)