FilesExpand file tree

python-stdlib

/

chunk.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

167 lines (147 loc) · 5.25 KB

python-stdlib

/

chunk.py

Copy path

Top

File metadata and controls

• Code
• Blame

167 lines (147 loc) · 5.25 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

"""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 a 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.

"""

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

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:

self.skip()

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 ''

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