示例#1
0
文件: io_jpeg.py 项目: yoya/misc
 def parse(self, jpegdata):
      self._jpegdata = jpegdata
      reader = IO_Bit()
      reader.input(jpegdata)
      while reader.hasNextData(2):
          chunk = self._parseChunk(reader)
          self.chunks.append(chunk)
示例#2
0
 def build(self, opts = {}):
     writer = IO_Bit()
     self._buildChunk(writer, self.header, opts)
     for track in self.tracks: 
         self._buildChunk(writer, track, opts)
     if self.xfinfo:
         self._buildChunk(writer, self.xfinfo, opts)
     if self.xfkaraoke:
         self._buildChunk(writer, self.xfkaraoke, opts)
     
     return writer.output()
示例#3
0
 def parse(self, mididata):
     self._mididata = mididata
     reader = IO_Bit()
     reader.input(mididata)
     while reader.hasNextData(4):
         chunk = self._parseChunk(reader)
         if chunk['type'] == b'MThd':
             self.header = chunk
         elif chunk['type'] == b'MTrk':
             self.tracks.append(chunk)
         elif chunk['type'] == b'XFIH':
             self.xfinfo = chunk
         elif chunk['type'] == b'XFKM':
             self.xfkaraoke = chunk
         else:
             sys.stderr.write("Can't parse chunk.")
             break
示例#4
0
 def _buildChunk(self, writer, chunk, opts):
     type = chunk['type']
     writerChunk = IO_Bit()
     if type == 'MThd':
           self._buildChunkHeader(writerChunk, chunk['header'], opts)
     elif type == 'MTrk':
           self._buildChunkTrack(writerChunk, chunk['track'], opts)
     elif type ==  'XFIH':
           self._buildChunkXFInfo(writerChunk, chunk['xfinfo'], opts)
     elif type == 'XFKM':
           self._buildChunkXFKaraoke(writerChunk, chunk['xfkaraoke'], opts)
     else:
           raise Exception("Unknown chunk (type=type)\n")
     chunkData = writerChunk.output()
     length = len(chunkData)
     writer.putData(type , 4)
     writer.putUI32BE(length)
     writer.putData(chunkData, length)
示例#5
0
 def dump(self, fp = sys.stdout, opts = {}):
     if ('hexdump' in opts) and opts['hexdump']:
         bitio = IO_Bit()
         bitio.input(self._mididata)
     fp.write("HEADER:\n")
     for key, value in self.header['header'].items(): 
         fp.write("  {0}: {1}\n".format(key, value))
     if ('hexdump' in opts) and opts['hexdump']:
         bitio.hexdump(0, self.header['length'] + 8)
     xfkaraoke_with_track = {}
     for idx, value in enumerate(self.tracks):
         xfkaraoke_with_track["{0}".format(idx)] = value;
     if not self.xfkaraoke is None:
         xfkaraoke_with_track["karaoke"] = self.xfkaraoke
         xfkaraoke_with_track["karaoke"]["track"] = self.xfkaraoke["xfkaraoke"]
     for idx, track in xfkaraoke_with_track.items():
         scaleCharactors = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
         fp.write("TRACK[{0}]:\n".format(idx))
         if ('hexdump' in opts) and opts['hexdump']:
             bitio.hexdump(track['_offset'], 8)
         for idx2, chunk in enumerate(track['track']):
             fp.write("  [{0}:".format(idx2))
             meta_event_type = -1
             for key, value in chunk.items():
                 if key == 'EventType':
                     if value < 0xFF: 
                         eventname = self.event_name[value]
                     else:
                         eventname = "Meta Event"
                     fp.write(" {0}:{1}({2}),".format(key, value, eventname))
                 elif key == 'MetaEventType':
                     meta_event_type = value
                     if value in self.meta_event_name:
                         eventname = self.meta_event_name[value]
                         fp.write(" {0}:{1}({2}),".format(key, value, eventname))
                     else:
                         fp.write(" {0}:{1},".format(key, value))
                     
                 elif key == 'ControllerType':
                     typename = self.controller_type_name[value]
                     fp.write(" {0}:{1}({2}),".format(key, value, typename))
                 elif key ==  'SystemEx' or key ==  'SystemExCont' or key ==  'MetaEventData':
                     fp.write(" {0}:".format(key))
                     dataLen = len(value)
                     if key == 'MetaEventData':
                         if meta_event_type == 0x05:
                             fp.write(value.decode('SJIS'))
                         elif meta_event_type == 0x07:
                             fp.write(value)
                     fp.write("(")
                     i = 0
                     while i < dataLen:
                        fp.write("{:02x}".format(ord(value[i:i+1])))
                        i += 1
                     fp.write(")")
                 elif key ==  'NoteNumber':
                         noteoct = math.floor(value / 12)
                         notekey = scaleCharactors[value % 12]
                         fp.write(" {:s}:{:d}({:s}{:.0f}),".format(key, value, notekey, noteoct))
                 else:
                     if (key[0:1] != '_') or (('verbose' in opts) and opts['verbose']): 
                         fp.write(" {0}:{1},".format(key, value))
             fp.write("\n")
             if ('hexdump' in opts) and opts['hexdump']:
                 bitio.hexdump(chunk['_offset'], chunk['_length'])