示例#1
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     self.copy = True
     
     # Set stsc metadat
     self._set_attr('entry_count', read32(self.file))
     
     # Verify that stsc exists
     if (self.get_attribute('entry_count') == 0):
         raise MalformedMP4()
         
     entries = []
     while self.file.tell() < (offset+size):
         chunk = read32(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         samples = read32(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         id = read32(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         entries.append((chunk, samples, id))
     if self.get_attribute('entry_count') != len(entries):
         raise MalformedMP4()
     else:
         self._set_attr('entries', entries)
示例#2
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
        self.copy = True

        # Set stsc metadat
        self._set_attr('entry_count', read32(self.file))

        # Verify that stsc exists
        if (self.get_attribute('entry_count') == 0):
            raise MalformedMP4()

        entries = []
        while self.file.tell() < (offset + size):
            chunk = read32(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            samples = read32(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            id = read32(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            entries.append((chunk, samples, id))
        if self.get_attribute('entry_count') != len(entries):
            raise MalformedMP4()
        else:
            self._set_attr('entries', entries)
示例#3
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     
     # Obtain necessary metadata
     if (self.version == 1):
         self.file.seek(24, os.SEEK_CUR)
         self._set_attr('duration', read64(self.file))
     else:
         self.file.seek(16, os.SEEK_CUR)
         self._set_attr('duration', read32(self.file))
     self.copy = True
示例#4
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)

        # Obtain necessary metadata
        if (self.version == 1):
            self.file.seek(24, os.SEEK_CUR)
            self._set_attr('duration', read64(self.file))
        else:
            self.file.seek(16, os.SEEK_CUR)
            self._set_attr('duration', read32(self.file))
        self.copy = True
示例#5
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     self.copy = True
     
     # Obtain metadata
     self._set_attr('chunk_count', read32(self.file))
     entries = []
     while self.file.tell() < (offset+size):
         chunk_offset = read64(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         entries.append(chunk_offset)
     if self.get_attribute('chunk_count') != len(entries):
         raise MalformedMP4()
     else:
         self._set_attr('entries', entries)
示例#6
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
        self.copy = True

        # Obtain metadata
        self._set_attr('chunk_count', read32(self.file))
        entries = []
        while self.file.tell() < (offset + size):
            chunk_offset = read64(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            entries.append(chunk_offset)
        if self.get_attribute('chunk_count') != len(entries):
            raise MalformedMP4()
        else:
            self._set_attr('entries', entries)
示例#7
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     self.copy = True
     
     # Set ctts metadat
     self._set_attr('entry_count', read32(self.file))
     entries = []
     while self.file.tell() < (offset+size):
         count = read32(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         soffset = read32(self.file)
         if self.file.tell() > (offset+size):
             raise MalformedMP4()
         entries.append((count, soffset))
     if self.get_attribute('entry_count') != len(entries):
         raise MalformedMP4()
     else:
         self._set_attr('entries', entries)
示例#8
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
        self.copy = True

        # Set ctts metadat
        self._set_attr('entry_count', read32(self.file))
        entries = []
        while self.file.tell() < (offset + size):
            count = read32(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            soffset = read32(self.file)
            if self.file.tell() > (offset + size):
                raise MalformedMP4()
            entries.append((count, soffset))
        if self.get_attribute('entry_count') != len(entries):
            raise MalformedMP4()
        else:
            self._set_attr('entries', entries)
示例#9
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     self.copy = True
     
     # Set stsz metadata
     self._set_attr('uniform_size', read32(self.file))
     self._set_attr('entry_count', read32(self.file))
     self.uniform = True
     
     if self.get_attribute('uniform_size') == 0:
         self.uniform = False
         entries = []
         while self.file.tell() < (offset+size):
             entry = read32(self.file)
             if self.file.tell() > (offset+size):
                 raise MalformedMP4()
             entries.append(entry)
         if self.get_attribute('entry_count') != len(entries):
             raise MalformedMP4()
         else:
             self._set_attr('entries', entries)
示例#10
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
        self.copy = True

        # Set stsz metadata
        self._set_attr('uniform_size', read32(self.file))
        self._set_attr('entry_count', read32(self.file))
        self.uniform = True

        if self.get_attribute('uniform_size') == 0:
            self.uniform = False
            entries = []
            while self.file.tell() < (offset + size):
                entry = read32(self.file)
                if self.file.tell() > (offset + size):
                    raise MalformedMP4()
                entries.append(entry)
            if self.get_attribute('entry_count') != len(entries):
                raise MalformedMP4()
            else:
                self._set_attr('entries', entries)
示例#11
0
 def __init__(self, file, offset, size, type, is_64, start):
     StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)
     
     # Obtain necessary metadata
     if (self.version == 1):
         self.file.seek(16, os.SEEK_CUR)
         self._set_attr('timescale', read32(self.file))
         self._set_attr('duration', read64(self.file))
     else:
         self.file.seek(8, os.SEEK_CUR)
         self._set_attr('timescale', read32(self.file))
         self._set_attr('duration', read32(self.file))
         
     # As an optimization, verify that given start is less than duration
     duration = self.get_attribute('duration')
     timescale = self.get_attribute('timescale')
     stream_duration = duration - (int(self.start) * timescale / 1000)
     if stream_duration < 0:
         raise StartOutOfRange()
     else:
         # Save timescale to global for use in tkhd update
         self.timescale = timescale
     self.copy = True
示例#12
0
    def __init__(self, file, offset, size, type, is_64, start):
        StreamFullAtom.__init__(self, file, offset, size, type, is_64, start)

        # Obtain necessary metadata
        if (self.version == 1):
            self.file.seek(16, os.SEEK_CUR)
            self._set_attr('timescale', read32(self.file))
            self._set_attr('duration', read64(self.file))
        else:
            self.file.seek(8, os.SEEK_CUR)
            self._set_attr('timescale', read32(self.file))
            self._set_attr('duration', read32(self.file))

        # As an optimization, verify that given start is less than duration
        duration = self.get_attribute('duration')
        timescale = self.get_attribute('timescale')
        stream_duration = duration - (int(self.start) * timescale / 1000)
        if stream_duration < 0:
            raise StartOutOfRange()
        else:
            # Save timescale to global for use in tkhd update
            self.timescale = timescale
        self.copy = True