Esempio n. 1
0
def test_iter():
    timestamps = []
    pixels = []
    video = Mjpg(test_mjpg)
    if os.path.exists(index_file(test_mjpg)):
        os.unlink(index_file(test_mjpg))
    for i, img in enumerate(video):
        assert img.index == i
        timestamps.append(img.timestamp)
        assert img.timestamp == img.systime
        pixels.append(img[20,30,1])
    assert len(timestamps) == 16
    assert timestamps[1] == 1445859308.97
    assert pixels[:7] == [84, 83, 84, 86, 86, 84, 84]

    assert video[1].timestamp == 1445859308.97
    assert video[2].index == 2
    assert video[0][20,30,1] == 84

    video2 = Mjpg(test_mjpg)
    assert video[3][20,30,1] == 86

    assert len(video)== 16
    with raises(IndexError):
        video[100]
Esempio n. 2
0
def test_iter():
    timestamps = []
    pixels = []
    video = Mkv(test_mkv)
    if os.path.exists(index_file(test_mkv)):
        os.unlink(index_file(test_mkv))
    for i, img in enumerate(video):
        assert img.index == i
        timestamps.append(img.timestamp)
        pixels.append(img[20, 30, 1])
    assert len(timestamps) == 16
    assert timestamps[0] == 0.0  # FIXME: Use systeime
    assert timestamps[1] == 0.04
    assert pixels[:6] == [84, 85, 85, 84, 84, 86]

    pixels = [video[i][20, 30, 1] for i in range(6)]
    assert pixels == [84, 85, 85, 84, 84, 86]

    assert video[2].timestamp == 0.08
    assert video[1].timestamp == 0.04
    assert video[2].index == 2
    assert video[0][20, 30, 1] == 84

    video2 = Mkv(test_mkv)
    assert video[3][20, 30, 1] == 84

    assert len(video) == 16
    with raises(IndexError):
        video[100]
Esempio n. 3
0
def test_iter():
    timestamps = []
    pixels = []
    video = Mjpg(test_mjpg)
    if os.path.exists(index_file(test_mjpg)):
        os.unlink(index_file(test_mjpg))
    for i, img in enumerate(video):
        assert img.index == i
        timestamps.append(img.timestamp)
        assert img.timestamp == img.systime
        pixels.append(img[20, 30, 1])
    assert len(timestamps) == 16
    assert timestamps[1] == 1445859308.97
    assert pixels[:7] == [84, 83, 84, 86, 86, 84, 84]

    assert video[1].timestamp == 1445859308.97
    assert video[2].index == 2
    assert video[0][20, 30, 1] == 84

    video2 = Mjpg(test_mjpg)
    assert video[3][20, 30, 1] == 86

    assert len(video) == 16
    with raises(IndexError):
        video[100]
Esempio n. 4
0
def test_iter():
    timestamps = []
    pixels = []
    video = Mkv(test_mkv)
    if os.path.exists(index_file(test_mkv)):
        os.unlink(index_file(test_mkv))
    for i, img in enumerate(video):
        assert img.index == i
        timestamps.append(img.timestamp)
        pixels.append(img[20,30,1])
    assert len(timestamps) == 16
    assert timestamps[0] == 0.0 # FIXME: Use systeime
    assert timestamps[1] == 0.04
    assert pixels[:6] == [84, 85, 85, 84, 84, 86]

    pixels = [video[i][20,30,1] for i in range(6)]
    assert pixels == [84, 85, 85, 84, 84, 86]

    assert video[2].timestamp == 0.08
    assert video[1].timestamp == 0.04
    assert video[2].index == 2
    assert video[0][20,30,1] == 84

    video2 = Mkv(test_mkv)
    assert video[3][20,30,1] == 84

    assert len(video)== 16
    with raises(IndexError):
        video[100]
Esempio n. 5
0
    def __init__(self, filename, grey=False):
        if sys.version_info > (3,):
            filename = bytes(filename, "utf8")
        self.filename = filename
        self.grey = grey
        open(filename).close()
        self._myiter = None
        self._index = None
        self.systime_offset = 0

        idx = index_file(self.filename)
        if os.path.exists(idx):
            index = json.load(open(idx))
            assert index['version'] == 2
            self.frame = index['frame']
            self.systime_offset = index['systime_offset']
        else:
            self.frame = []
            m = lib.mkv_open(self.filename)
            frm = ffi.new('struct mkv_frame *')
            cluster_offsets = set()
            while lib.mkv_next(m, frm):
                if frm.key_frame:
                    if frm.offset in cluster_offsets:
                        print("FIXME: Multiple keyframes per cluster!")
                    cluster_offsets.add(frm.key_frame)
                self.frame.append([frm.pts, frm.offset, frm.key_frame])
            self.frame.sort()
            self.systime_offset = iter(self).estimate_systime_offset() # FIXME: This makes a second pass over the file parsing it
            lib.mkv_close(m)

            with open(idx, 'w') as fd:
                json.dump({'frame': self.frame,
                           'systime_offset': self.systime_offset,
                           'version': 2}, fd)
Esempio n. 6
0
 def offset(self):
     if self._index is None:
         idx = index_file(self.filename, self.grey)
         if os.path.exists(idx):
             self._index = json.load(open(idx))
         else:
             self._index = [self.myiter.m.start_position_in_file for img in self.myiter]
             with open(idx, 'w') as fd:
                 json.dump(self._index, fd)
     return self._index
Esempio n. 7
0
 def offset(self):
     if self._index is None:
         idx = index_file(self.filename, self.grey)
         if os.path.exists(idx):
             self._index = json.load(open(idx))
         else:
             self._index = [
                 self.myiter.m.start_position_in_file for img in self.myiter
             ]
             with open(idx, 'w') as fd:
                 json.dump(self._index, fd)
     return self._index
Esempio n. 8
0
    def __init__(self, filename, grey=False, reindex=False):
        # Be compatible with pathlib.Path filenames
        filename = str(filename).encode('utf-8')
        self.filename = filename
        self.grey = grey
        open(filename).close()
        self._myiter = None
        self.systime_offset = 0

        need_index = True
        idx = index_file(self.filename)
        if os.path.exists(idx):
            try:
                index = json.load(open(idx))
            except Exception:
                pass
            else:
                if index['version'] == INDEX_VERSION:
                    self.frame = index['frame']
                    self.systime_offset = index['systime_offset']
                    self.mjpg_mode = index['mjpg_mode']
                    need_index = False

        if need_index or reindex:
            self.frame = []
            m = lib.mkv_open(self.filename)
            frm = ffi.new('struct mkv_frame *')
            cluster_offsets = set()
            while lib.mkv_next(m, frm):
                if frm.key_frame:
                    if frm.offset in cluster_offsets:
                        print("FIXME: Multiple keyframes per cluster!")
                    cluster_offsets.add(frm.key_frame)
                self.frame.append([frm.pts, frm.offset, frm.key_frame])
            self.frame.sort()
            self.systime_offset = iter(self).estimate_systime_offset() # FIXME: This makes a second pass over the file parsing it
            self.mjpg_mode = (ffi.string(m.codec_id) == b'V_MS/VFW/FOURCC')
            lib.mkv_close(m)

            tmp = idx + '.tmp.%d' % os.getpid()
            with open(tmp, 'w') as fd:
                json.dump({'frame': self.frame,
                           'systime_offset': self.systime_offset,
                           'mjpg_mode': self.mjpg_mode,
                           'version': INDEX_VERSION}, fd)
            try:
                os.link(tmp, idx)
            except FileExistsError:
                pass
            os.unlink(tmp)
Esempio n. 9
0
    def __init__(self, filename, grey=False, reindex=False):
        if sys.version_info > (3, ):
            filename = bytes(filename, "utf8")
        self.filename = filename
        self.grey = grey
        open(filename).close()
        self._myiter = None
        self.systime_offset = 0

        need_index = True
        idx = index_file(self.filename)
        if os.path.exists(idx):
            index = json.load(open(idx))
            if index['version'] == INDEX_VERSION:
                self.frame = index['frame']
                self.systime_offset = index['systime_offset']
                self.mjpg_mode = index['mjpg_mode']
                need_index = False

        if need_index or reindex:
            self.frame = []
            m = lib.mkv_open(self.filename)
            frm = ffi.new('struct mkv_frame *')
            cluster_offsets = set()
            while lib.mkv_next(m, frm):
                if frm.key_frame:
                    if frm.offset in cluster_offsets:
                        print("FIXME: Multiple keyframes per cluster!")
                    cluster_offsets.add(frm.key_frame)
                self.frame.append([frm.pts, frm.offset, frm.key_frame])
            self.frame.sort()
            self.systime_offset = iter(self).estimate_systime_offset(
            )  # FIXME: This makes a second pass over the file parsing it
            self.mjpg_mode = (ffi.string(m.codec_id) == b'V_MS/VFW/FOURCC')
            lib.mkv_close(m)

            with open(idx, 'w') as fd:
                json.dump(
                    {
                        'frame': self.frame,
                        'systime_offset': self.systime_offset,
                        'mjpg_mode': self.mjpg_mode,
                        'version': INDEX_VERSION
                    }, fd)
Esempio n. 10
0
    def __init__(self, filename, grey=False):
        if sys.version_info > (3, ):
            filename = bytes(filename, "utf8")
        self.filename = filename
        self.grey = grey
        open(filename).close()
        self._myiter = None
        self._index = None
        self.systime_offset = 0

        idx = index_file(self.filename)
        if os.path.exists(idx):
            index = json.load(open(idx))
            assert index['version'] == 2
            self.frame = index['frame']
            self.systime_offset = index['systime_offset']
        else:
            self.frame = []
            m = lib.mkv_open(self.filename)
            frm = ffi.new('struct mkv_frame *')
            cluster_offsets = set()
            while lib.mkv_next(m, frm):
                if frm.key_frame:
                    if frm.offset in cluster_offsets:
                        print("FIXME: Multiple keyframes per cluster!")
                    cluster_offsets.add(frm.key_frame)
                self.frame.append([frm.pts, frm.offset, frm.key_frame])
            self.frame.sort()
            self.systime_offset = iter(self).estimate_systime_offset(
            )  # FIXME: This makes a second pass over the file parsing it
            lib.mkv_close(m)

            with open(idx, 'w') as fd:
                json.dump(
                    {
                        'frame': self.frame,
                        'systime_offset': self.systime_offset,
                        'version': 2
                    }, fd)
Esempio n. 11
0
def test_idx():
    if os.path.exists(index_file(test_mkv)):
        os.unlink(index_file(test_mkv))
    test_iter()
    test_iter()
Esempio n. 12
0
def test_idx():
    if os.path.exists(index_file(test_mjpg)):
        os.unlink(index_file(test_mjpg))
    test_iter()
    test_iter()