Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
cpython/Lib/chunk.py /
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| """Simple class to read IFF chunks. | |
| An IFF chunk (used in formats such as AIFF, TIFF, RMFF (RealMedia File | |
| Format)) has the following structure: | |
| +----------------+ | |
| | ID (4 bytes) | | |
| +----------------+ | |
| | size (4 bytes) | | |
| +----------------+ | |
| | data | | |
| | ... | | |
| +----------------+ | |
| The ID is a 4-byte string which identifies the type of chunk. | |
| The size field (a 32-bit value, encoded using big-endian byte order) | |
| gives the size of the whole chunk, including the 8-byte header. | |
| Usually an IFF-type file consists of one or more chunks. The proposed | |
| usage of the Chunk class defined here is to instantiate an instance at | |
| the start of each chunk and read from the instance until it reaches | |
| the end, after which a new instance can be instantiated. At the end | |
| of the file, creating a new instance will fail with an EOFError | |
| exception. | |
| Usage: | |
| while True: | |
| try: | |
| chunk = Chunk(file) | |
| except EOFError: | |
| break | |
| chunktype = chunk.getname() | |
| while True: | |
| data = chunk.read(nbytes) | |
| if not data: | |
| pass | |
| # do something with data | |
| The interface is file-like. The implemented methods are: | |
| read, close, seek, tell, isatty. | |
| Extra methods are: skip() (called by close, skips to the end of the chunk), | |
| getname() (returns the name (ID) of the chunk) | |
| The __init__ method has one required argument, a file-like object | |
| (including a chunk instance), and one optional argument, a flag which | |
| specifies whether or not chunks are aligned on 2-byte boundaries. The | |
| default is 1, i.e. aligned. | |
| """ | |
| import warnings | |
| warnings._deprecated(__name__, remove=(3, 13)) | |
| class Chunk: | |
| def __init__(self, file, align=True, bigendian=True, inclheader=False): | |
| import struct | |
| self.closed = False | |
| self.align = align # whether to align to word (2-byte) boundaries | |
| if bigendian: | |
| strflag = '>' | |
| else: | |
| strflag = '<' | |
| self.file = file | |
| self.chunkname = file.read(4) | |
| if len(self.chunkname) < 4: | |
| raise EOFError | |
| try: | |
| self.chunksize = struct.unpack_from(strflag+'L', file.read(4))[0] | |
| except struct.error: | |
| raise EOFError from None | |
| if inclheader: | |
| self.chunksize = self.chunksize - 8 # subtract header | |
| self.size_read = 0 | |
| try: | |
| self.offset = self.file.tell() | |
| except (AttributeError, OSError): | |
| self.seekable = False | |
| else: | |
| self.seekable = True | |
| def getname(self): | |
| """Return the name (ID) of the current chunk.""" | |
| return self.chunkname | |
| def getsize(self): | |
| """Return the size of the current chunk.""" | |
| return self.chunksize | |
| def close(self): | |
| if not self.closed: | |
| try: | |
| self.skip() | |
| finally: | |
| self.closed = True | |
| def isatty(self): | |
| if self.closed: | |
| raise ValueError("I/O operation on closed file") | |
| return False | |
| def seek(self, pos, whence=0): | |
| """Seek to specified position into the chunk. | |
| Default position is 0 (start of chunk). | |
| If the file is not seekable, this will result in an error. | |
| """ | |
| if self.closed: | |
| raise ValueError("I/O operation on closed file") | |
| if not self.seekable: | |
| raise OSError("cannot seek") | |
| if whence == 1: | |
| pos = pos + self.size_read | |
| elif whence == 2: | |
| pos = pos + self.chunksize | |
| if pos < 0 or pos > self.chunksize: | |
| raise RuntimeError | |
| self.file.seek(self.offset + pos, 0) | |
| self.size_read = pos | |
| def tell(self): | |
| if self.closed: | |
| raise ValueError("I/O operation on closed file") | |
| return self.size_read | |
| def read(self, size=-1): | |
| """Read at most size bytes from the chunk. | |
| If size is omitted or negative, read until the end | |
| of the chunk. | |
| """ | |
| if self.closed: | |
| raise ValueError("I/O operation on closed file") | |
| if self.size_read >= self.chunksize: | |
| return b'' | |
| if size < 0: | |
| size = self.chunksize - self.size_read | |
| if size > self.chunksize - self.size_read: | |
| size = self.chunksize - self.size_read | |
| data = self.file.read(size) | |
| self.size_read = self.size_read + len(data) | |
| if self.size_read == self.chunksize and \ | |
| self.align and \ | |
| (self.chunksize & 1): | |
| dummy = self.file.read(1) | |
| self.size_read = self.size_read + len(dummy) | |
| return data | |
| def skip(self): | |
| """Skip the rest of the chunk. | |
| If you are not interested in the contents of the chunk, | |
| this method should be called so that the file points to | |
| the start of the next chunk. | |
| """ | |
| if self.closed: | |
| raise ValueError("I/O operation on closed file") | |
| if self.seekable: | |
| try: | |
| n = self.chunksize - self.size_read | |
| # maybe fix alignment | |
| if self.align and (self.chunksize & 1): | |
| n = n + 1 | |
| self.file.seek(n, 1) | |
| self.size_read = self.size_read + n | |
| return | |
| except OSError: | |
| pass | |
| while self.size_read < self.chunksize: | |
| n = min(8192, self.chunksize - self.size_read) | |
| dummy = self.read(n) | |
| if not dummy: | |
| raise EOFError |