#if 0 # $Id: mpeginfo.py 398 2005-02-15 18:52:51Z dischi $ # $Log$ # Revision 1.33 2005/02/15 18:52:51 dischi # some strange bugfix (what is this doing?) # # Revision 1.32 2005/01/21 16:37:02 dischi # try to find bad timestamps # # Revision 1.31 2005/01/08 12:06:45 dischi # make sure the buffer is big enough # # Revision 1.30 2005/01/02 14:57:27 dischi # detect ac3 in normal mpeg2 # # Revision 1.29 2004/11/27 14:42:12 dischi # remove future warning # # Revision 1.28 2004/11/15 21:43:36 dischi # remove bad debugging stuff # # Revision 1.27 2004/11/12 18:10:45 dischi # add ac3 support in mpeg streams # # Revision 1.26 2004/10/04 18:06:54 dischi # test length of remaining buffer # # Revision 1.25 2004/07/11 19:37:25 dischi # o read more bytes on ts scan # o support for AC3 in private streams # # Revision 1.24 2004/07/03 09:01:32 dischi # o fix PES start detection inside TS # o try to find out if the stream is progressive or interlaced # # Revision 1.23 2004/06/23 19:44:10 dischi # better length detection, big cleanup # # Revision 1.22 2004/06/22 21:37:34 dischi # o PES support # o basic length detection for TS and PES # # Revision 1.21 2004/06/21 20:37:34 dischi # basic support for mpeg-ts # # Revision 1.20 2004/03/13 23:41:59 dischi # add AudioInfo to mpeg for all streams # # Revision 1.19 2004/02/11 20:11:54 dischi # Updated length calculation for mpeg files. This may not work for all files. # # # MMPython - Media Metadata for Python # Copyright (C) 2003 Thomas Schueppel # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of MER- # CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program; if not, write to the Free Software Foundation, Inc., # 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # ----------------------------------------------------------------------- #endif import re import os import struct import string import fourcc from mmpython import mediainfo import mmpython import stat ##------------------------------------------------------------------------ ## START_CODE ## ## Start Codes, with 'slice' occupying 0x01..0xAF ##------------------------------------------------------------------------ START_CODE = { 0x00 : 'picture_start_code', 0xB0 : 'reserved', 0xB1 : 'reserved', 0xB2 : 'user_data_start_code', 0xB3 : 'sequence_header_code', 0xB4 : 'sequence_error_code', 0xB5 : 'extension_start_code', 0xB6 : 'reserved', 0xB7 : 'sequence end', 0xB8 : 'group of pictures', } for i in range(0x01,0xAF): START_CODE[i] = 'slice_start_code' ##------------------------------------------------------------------------ ## START CODES ##------------------------------------------------------------------------ PICTURE = 0x00 USERDATA = 0xB2 SEQ_HEAD = 0xB3 SEQ_ERR = 0xB4 EXT_START = 0xB5 SEQ_END = 0xB7 GOP = 0xB8 SEQ_START_CODE = 0xB3 PACK_PKT = 0xBA SYS_PKT = 0xBB PADDING_PKT = 0xBE AUDIO_PKT = 0xC0 VIDEO_PKT = 0xE0 PRIVATE_STREAM1 = 0xBD PRIVATE_STREAM2 = 0xBf TS_PACKET_LENGTH = 188 TS_SYNC = 0x47 ##------------------------------------------------------------------------ ## FRAME_RATE ## ## A lookup table of all the standard frame rates. Some rates adhere to ## a particular profile that ensures compatibility with VLSI capabilities ## of the early to mid 1990s. ## ## CPB ## Constrained Parameters Bitstreams, an MPEG-1 set of sampling and ## bitstream parameters designed to normalize decoder computational ## complexity, buffer size, and memory bandwidth while still addressing ## the widest possible range of applications. ## ## Main Level ## MPEG-2 Video Main Profile and Main Level is analogous to MPEG-1's ## CPB, with sampling limits at CCIR 601 parameters (720x480x30 Hz or ## 720x576x24 Hz). ## ##------------------------------------------------------------------------ FRAME_RATE = [ 0, round(24000.0/1001*100)/100, ## 3-2 pulldown NTSC (CPB/Main Level) 24, ## Film (CPB/Main Level) 25, ## PAL/SECAM or 625/60 video round(30000.0/1001*100)/100, ## NTSC (CPB/Main Level) 30, ## drop-frame NTSC or component 525/60 (CPB/Main Level) 50, ## double-rate PAL round(60000.0/1001*100)/100, ## double-rate NTSC 60, ## double-rate, drop-frame NTSC/component 525/60 video ] ##------------------------------------------------------------------------ ## ASPECT_RATIO -- INCOMPLETE? ## ## This lookup table maps the header aspect ratio index to a common name. ## These are just the defined ratios for CPB I believe. As I understand ## it, a stream that doesn't adhere to one of these aspect ratios is ## technically considered non-compliant. ##------------------------------------------------------------------------ ASPECT_RATIO = [ 'Forbidden', '1/1 (VGA)', '4/3 (TV)', '16/9 (Large TV)', '2.21/1 (Cinema)', ] class MpegInfo(mediainfo.AVInfo): def __init__(self,file): mediainfo.AVInfo.__init__(self) self.context = 'video' self.sequence_header_offset = 0 # detect TS (fast scan) self.valid = self.isTS(file) if not self.valid: # detect system mpeg (many infos) self.valid = self.isMPEG(file) if not self.valid: # detect PES self.valid = self.isPES(file) if self.valid: self.mime = 'video/mpeg' if not self.video: self.video.append(mediainfo.VideoInfo()) if self.sequence_header_offset <= 0: return self.progressive(file) for vi in self.video: vi.width, vi.height = self.dxy(file) vi.fps, vi.aspect = self.framerate_aspect(file) vi.bitrate = self.bitrate(file) if self.length: vi.length = self.length if not self.type: if self.video[0].width == 480: self.type = 'MPEG2 video' # SVCD spec elif self.video[0].width == 352: self.type = 'MPEG1 video' # VCD spec else: self.type = 'MPEG video' if mediainfo.DEBUG > 2: self.__scan__() def dxy(self,file): """ get width and height of the video """ file.seek(self.sequence_header_offset+4,0) v = file.read(4) x = struct.unpack('>H',v[:2])[0] >> 4 y = struct.unpack('>H',v[1:3])[0] & 0x0FFF return (x,y) def framerate_aspect(self,file): """ read framerate and aspect ratio """ file.seek(self.sequence_header_offset+7,0) v = struct.unpack( '>B', file.read(1) )[0] try: fps = FRAME_RATE[v&0xf] except IndexError: fps = None try: aspect = ASPECT_RATIO[v>>4] except IndexError: if mediainfo.DEBUG: print 'Index error: %s' % (v>>4) aspect = None return (fps, aspect) def progressive(self, file): """ Try to find out with brute force if the mpeg is interlaced or not. Search for the Sequence_Extension in the extension header (01B5) """ file.seek(0) buffer = '' count = 0 while 1: if len(buffer) < 1000: count += 1 if count > 1000: break buffer += file.read(1024) if len(buffer) < 1000: break pos = buffer.find('\x00\x00\x01\xb5') if pos == -1 or len(buffer) - pos < 5: buffer = buffer[-10:] continue ext = (ord(buffer[pos+4]) >> 4) if ext == 8: pass elif ext == 1: if (ord(buffer[pos+5]) >> 3) & 1: self.keys.append('progressive') self.progressive = 1 else: self.keys.append('interlaced') self.interlaced = 1 return True else: print 'ext', ext buffer = buffer[pos+4:] return False ##------------------------------------------------------------------------ ## bitrate() ## ## From the MPEG-2.2 spec: ## ## bit_rate -- This is a 30-bit integer. The lower 18 bits of the ## integer are in bit_rate_value and the upper 12 bits are in ## bit_rate_extension. The 30-bit integer specifies the bitrate of the ## bitstream measured in units of 400 bits/second, rounded upwards. ## The value zero is forbidden. ## ## So ignoring all the variable bitrate stuff for now, this 30 bit integer ## multiplied times 400 bits/sec should give the rate in bits/sec. ## ## TODO: Variable bitrates? I need one that implements this. ## ## Continued from the MPEG-2.2 spec: ## ## If the bitstream is a constant bitrate stream, the bitrate specified ## is the actual rate of operation of the VBV specified in annex C. If ## the bitstream is a variable bitrate stream, the STD specifications in ## ISO/IEC 13818-1 supersede the VBV, and the bitrate specified here is ## used to dimension the transport stream STD (2.4.2 in ITU-T Rec. xxx | ## ISO/IEC 13818-1), or the program stream STD (2.4.5 in ITU-T Rec. xxx | ## ISO/IEC 13818-1). ## ## If the bitstream is not a constant rate bitstream the vbv_delay ## field shall have the value FFFF in hexadecimal. ## ## Given the value encoded in the bitrate field, the bitstream shall be ## generated so that the video encoding and the worst case multiplex ## jitter do not cause STD buffer overflow or underflow. ## ## ##------------------------------------------------------------------------ ## Some parts in the code are based on mpgtx (mpgtx.sf.net) def bitrate(self,file): """ read the bitrate (most of the time broken) """ file.seek(self.sequence_header_offset+8,0) t,b = struct.unpack( '>HB', file.read(3) ) vrate = t << 2 | b >> 6 return vrate * 400 def ReadSCRMpeg2(self, buffer): """ read SCR (timestamp) for MPEG2 at the buffer beginning (6 Bytes) """ highbit = (ord(buffer[0])&0x20)>>5 low4Bytes= ((long(ord(buffer[0])) & 0x18) >> 3) << 30 low4Bytes |= (ord(buffer[0]) & 0x03) << 28 low4Bytes |= ord(buffer[1]) << 20 low4Bytes |= (ord(buffer[2]) & 0xF8) << 12 low4Bytes |= (ord(buffer[2]) & 0x03) << 13 low4Bytes |= ord(buffer[3]) << 5 low4Bytes |= (ord(buffer[4])) >> 3 sys_clock_ref=(ord(buffer[4]) & 0x3) << 7 sys_clock_ref|=(ord(buffer[5]) >> 1) return (long(highbit * (1<<16) * (1<<16)) + low4Bytes) / 90000 def ReadSCRMpeg1(self, buffer): """ read SCR (timestamp) for MPEG1 at the buffer beginning (5 Bytes) """ highbit = (ord(buffer[0]) >> 3) & 0x01 low4Bytes = ((long(ord(buffer[0])) >> 1) & 0x03) << 30 low4Bytes |= ord(buffer[1]) << 22; low4Bytes |= (ord(buffer[2]) >> 1) << 15; low4Bytes |= ord(buffer[3]) << 7; low4Bytes |= ord(buffer[4]) >> 1; return (long(highbit) * (1<<16) * (1<<16) + low4Bytes) / 90000; def ReadPTS(self, buffer): """ read PTS (PES timestamp) at the buffer beginning (5 Bytes) """ high = ((ord(buffer[0]) & 0xF) >> 1) med = (ord(buffer[1]) << 7) + (ord(buffer[2]) >> 1) low = (ord(buffer[3]) << 7) + (ord(buffer[4]) >> 1) return ((long(high) << 30 ) + (med << 15) + low) / 90000 def ReadHeader(self, buffer, offset): """ Handle MPEG header in buffer on position offset Return -1 on error, new offset or 0 if the new offset can't be scanned """ if buffer[offset:offset+3] != '\x00\x00\x01': return -1 id = ord(buffer[offset+3]) if id == PADDING_PKT: return offset + (ord(buffer[offset+4]) << 8) + ord(buffer[offset+5]) + 6 if id == PACK_PKT: if ord(buffer[offset+4]) & 0xF0 == 0x20: self.type = 'MPEG1 video' self.get_time = self.ReadSCRMpeg1 return offset + 12 elif (ord(buffer[offset+4]) & 0xC0) == 0x40: self.type = 'MPEG2 video' self.get_time = self.ReadSCRMpeg2 return offset + (ord(buffer[offset+13]) & 0x07) + 14 else: # WTF? Very strange return -1 if 0xC0 <= id <= 0xDF: # code for audio stream for a in self.audio: if a.id == id: break else: self.audio.append(mediainfo.AudioInfo()) self.audio[-1].id = id self.audio[-1].keys.append('id') return 0 if 0xE0 <= id <= 0xEF: # code for video stream for v in self.video: if v.id == id: break else: self.video.append(mediainfo.VideoInfo()) self.video[-1].id = id self.video[-1].keys.append('id') return 0 if id == SEQ_HEAD: # sequence header, remember that position for later use self.sequence_header_offset = offset return 0 if id in (PRIVATE_STREAM1, PRIVATE_STREAM2): # private stream. we don't know, but maybe we can guess later add = ord(buffer[offset+8]) # if (ord(buffer[offset+6]) & 4) or 1: # id = ord(buffer[offset+10+add]) if buffer[offset+11+add:offset+15+add].find('\x0b\x77') != -1: # AC3 stream for a in self.audio: if a.id == id: break else: self.audio.append(mediainfo.AudioInfo()) self.audio[-1].id = id self.audio[-1].codec = 'AC3' self.audio[-1].keys.append('id') return 0 if id == SYS_PKT: return 0 if id == EXT_START: return 0 return 0 # Normal MPEG (VCD, SVCD) ======================================== def isMPEG(self, file): """ This MPEG starts with a sequence of 0x00 followed by a PACK Header http://dvd.sourceforge.net/dvdinfo/packhdr.html """ file.seek(0,0) buffer = file.read(10000) offset = 0 # seek until the 0 byte stop while buffer[offset] == '\0': offset += 1 offset -= 2 # test for mpeg header 0x00 0x00 0x01 if not buffer[offset:offset+4] == '\x00\x00\x01%s' % chr(PACK_PKT): return 0 # scan the 100000 bytes of data buffer += file.read(100000) # scan first header, to get basic info about # how to read a timestamp self.ReadHeader(buffer, offset) # store first timestamp self.start = self.get_time(buffer[offset+4:]) while len(buffer) > offset + 1000 and buffer[offset:offset+3] == '\x00\x00\x01': # read the mpeg header new_offset = self.ReadHeader(buffer, offset) # header scanning detected error, this is no mpeg if new_offset == -1: return 0 if new_offset: # we have a new offset offset = new_offset # skip padding 0 before a new header while len(buffer) > offset + 10 and \ not ord(buffer[offset+2]): offset += 1 else: # seek to new header by brute force offset += buffer[offset+4:].find('\x00\x00\x01') + 4 # fill in values for support functions: self.__seek_size__ = 1000000 self.__sample_size__ = 10000 self.__search__ = self._find_timer_ self.filename = file.name # get length of the file self.length = self.get_length() return 1 def _find_timer_(self, buffer): """ Return position of timer in buffer or -1 if not found. This function is valid for 'normal' mpeg files """ pos = buffer.find('\x00\x00\x01%s' % chr(PACK_PKT)) if pos == -1: return -1 return pos + 4 # PES ============================================================ def ReadPESHeader(self, offset, buffer, id=0): """ Parse a PES header. Since it starts with 0x00 0x00 0x01 like 'normal' mpegs, this function will return (0, -1) when it is no PES header or (packet length, timestamp position (maybe -1)) http://dvd.sourceforge.net/dvdinfo/pes-hdr.html """ if not buffer[0:3] == '\x00\x00\x01': return 0, -1 packet_length = (ord(buffer[4]) << 8) + ord(buffer[5]) + 6 align = ord(buffer[6]) & 4 header_length = ord(buffer[8]) # PES ID (starting with 001) if ord(buffer[3]) & 0xE0 == 0xC0: id = id or ord(buffer[3]) & 0x1F for a in self.audio: if a.id == id: break else: self.audio.append(mediainfo.AudioInfo()) self.audio[-1].id = id self.audio[-1].keys.append('id') elif ord(buffer[3]) & 0xF0 == 0xE0: id = id or ord(buffer[3]) & 0xF for v in self.video: if v.id == id: break else: self.video.append(mediainfo.VideoInfo()) self.video[-1].id = id self.video[-1].keys.append('id') # new mpeg starting if buffer[header_length+9:header_length+13] == \ '\x00\x00\x01\xB3' and not self.sequence_header_offset: # yes, remember offset for later use self.sequence_header_offset = offset + header_length+9 elif ord(buffer[3]) == 189 or ord(buffer[3]) == 191: # private stream. we don't know, but maybe we can guess later id = id or ord(buffer[3]) & 0xF if align and buffer[header_length+9:header_length+11] == '\x0b\x77': # AC3 stream for a in self.audio: if a.id == id: break else: self.audio.append(mediainfo.AudioInfo()) self.audio[-1].id = id self.audio[-1].codec = 'AC3' self.audio[-1].keys.append('id') else: # unknown content pass ptsdts = ord(buffer[7]) >> 6 if ptsdts and ptsdts == ord(buffer[9]) >> 4: if ord(buffer[9]) >> 4 != ptsdts: print 'WARNING: bad PTS/DTS, please contact us' return packet_length, -1 # timestamp = self.ReadPTS(buffer[9:14]) high = ((ord(buffer[9]) & 0xF) >> 1) med = (ord(buffer[10]) << 7) + (ord(buffer[11]) >> 1) low = (ord(buffer[12]) << 7) + (ord(buffer[13]) >> 1) return packet_length, 9 return packet_length, -1 def isPES(self, file): if mediainfo.DEBUG: print 'trying mpeg-pes scan' file.seek(0,0) buffer = file.read(3) # header (also valid for all mpegs) if not buffer == '\x00\x00\x01': return 0 self.sequence_header_offset = 0 buffer += file.read(10000) offset = 0 while offset + 1000 < len(buffer): pos, timestamp = self.ReadPESHeader(offset, buffer[offset:]) if not pos: return 0 if timestamp != -1 and not hasattr(self, 'start'): self.get_time = self.ReadPTS self.start = self.get_time(buffer[offset+timestamp:offset+timestamp+5]) if self.sequence_header_offset and hasattr(self, 'start'): # we have all informations we need break offset += pos if offset + 1000 < len(buffer) and len(buffer) < 1000000 or 1: # looks like a pes, read more buffer += file.read(10000) if not self.video and not self.audio: # no video and no audio? return 0 self.type = 'MPEG-PES' # fill in values for support functions: self.__seek_size__ = 10000000 # 10 MB self.__sample_size__ = 500000 # 500 k scanning self.__search__ = self._find_timer_PES_ self.filename = file.name # get length of the file self.length = self.get_length() return 1 def _find_timer_PES_(self, buffer): """ Return position of timer in buffer or -1 if not found. This function is valid for PES files """ pos = buffer.find('\x00\x00\x01') offset = 0 if pos == -1 or offset + 1000 >= len(buffer): return -1 retpos = -1 ackcount = 0 while offset + 1000 < len(buffer): pos, timestamp = self.ReadPESHeader(offset, buffer[offset:]) if timestamp != -1 and retpos == -1: retpos = offset + timestamp if pos == 0: # Oops, that was a mpeg header, no PES header offset += buffer[offset:].find('\x00\x00\x01') retpos = -1 ackcount = 0 else: offset += pos if retpos != -1: ackcount += 1 if ackcount > 10: # looks ok to me return retpos return -1 # Transport Stream =============================================== def isTS(self, file): file.seek(0,0) buffer = file.read(TS_PACKET_LENGTH * 2) c = 0 while c + TS_PACKET_LENGTH < len(buffer): if ord(buffer[c]) == ord(buffer[c+TS_PACKET_LENGTH]) == TS_SYNC: break c += 1 else: return 0 buffer += file.read(10000) self.type = 'MPEG-TS' while c + TS_PACKET_LENGTH < len(buffer): start = ord(buffer[c+1]) & 0x40 # maybe load more into the buffer if c + 2 * TS_PACKET_LENGTH > len(buffer) and c < 500000: buffer += file.read(10000) # wait until the ts payload contains a payload header if not start: c += TS_PACKET_LENGTH continue tsid = ((ord(buffer[c+1]) & 0x3F) << 8) + ord(buffer[c+2]) adapt = (ord(buffer[c+3]) & 0x30) >> 4 offset = 4 if adapt & 0x02: # meta info present, skip it for now adapt_len = ord(buffer[c+offset]) offset += adapt_len + 1 if not ord(buffer[c+1]) & 0x40: # no new pes or psi in stream payload starting pass elif adapt & 0x01: # PES timestamp = self.ReadPESHeader(c+offset, buffer[c+offset:], tsid)[1] if timestamp != -1: if not hasattr(self, 'start'): self.get_time = self.ReadPTS timestamp = c + offset + timestamp self.start = self.get_time(buffer[timestamp:timestamp+5]) elif not hasattr(self, 'audio_ok'): timestamp = c + offset + timestamp start = self.get_time(buffer[timestamp:timestamp+5]) if abs(start - self.start) < 10: # looks ok self.audio_ok = True else: # timestamp broken del self.start if mediainfo.DEBUG: print 'Timestamp error, correcting' if hasattr(self, 'start') and self.start and \ self.sequence_header_offset and self.video and self.audio: break c += TS_PACKET_LENGTH if not self.sequence_header_offset: return 0 if hasattr(self, 'start') and self.start: self.keys.append('start') # fill in values for support functions: self.__seek_size__ = 10000000 # 10 MB self.__sample_size__ = 100000 # 100 k scanning self.__search__ = self._find_timer_TS_ self.filename = file.name # get length of the file self.length = self.get_length() return 1 def _find_timer_TS_(self, buffer): c = 0 while c + TS_PACKET_LENGTH < len(buffer): if ord(buffer[c]) == ord(buffer[c+TS_PACKET_LENGTH]) == TS_SYNC: break c += 1 else: return -1 while c + TS_PACKET_LENGTH < len(buffer): start = ord(buffer[c+1]) & 0x40 if not start: c += TS_PACKET_LENGTH continue tsid = ((ord(buffer[c+1]) & 0x3F) << 8) + ord(buffer[c+2]) adapt = (ord(buffer[c+3]) & 0x30) >> 4 offset = 4 if adapt & 0x02: # meta info present, skip it for now offset += ord(buffer[c+offset]) + 1 if adapt & 0x01: timestamp = self.ReadPESHeader(c+offset, buffer[c+offset:], tsid)[1] return c + offset + timestamp c += TS_PACKET_LENGTH return -1 # Support functions ============================================== def get_endpos(self): """ get the last timestamp of the mpeg, return -1 if this is not possible """ if not hasattr(self, 'filename') or not hasattr(self, 'start'): return -1 file = open(self.filename) file.seek(os.stat(self.filename)[stat.ST_SIZE]-self.__sample_size__) buffer = file.read(self.__sample_size__) end = -1 while 1: pos = self.__search__(buffer) if pos == -1: break end = self.get_time(buffer[pos:]) buffer = buffer[pos+100:] file.close() return end def get_length(self): """ get the length in seconds, return -1 if this is not possible """ end = self.get_endpos() if end == -1: return -1 if self.start > end: return int(((long(1) << 33) - 1 ) / 90000) - self.start + end return end - self.start def seek(self, end_time): """ Return the byte position in the file where the time position is 'pos' seconds. Return 0 if this is not possible """ if not hasattr(self, 'filename') or not hasattr(self, 'start'): return 0 file = open(self.filename) seek_to = 0 while 1: file.seek(self.__seek_size__, 1) buffer = file.read(self.__sample_size__) if len(buffer) < 10000: break pos = self.__search__(buffer) if pos != -1: # found something if self.get_time(buffer[pos:]) >= end_time: # too much, break break # that wasn't enough seek_to = file.tell() file.close() return seek_to def __scan__(self): """ scan file for timestamps (may take a long time) """ if not hasattr(self, 'filename') or not hasattr(self, 'start'): return 0 file = open(self.filename) print 'scanning file...' while 1: file.seek(self.__seek_size__ * 10, 1) buffer = file.read(self.__sample_size__) if len(buffer) < 10000: break pos = self.__search__(buffer) if pos == -1: continue print self.get_time(buffer[pos:]) file.close() print 'done' print mmpython.registertype( 'video/mpeg', ('mpeg','mpg','mp4', 'ts'), mediainfo.TYPE_AV, MpegInfo )