14 from plugin
import GetPlugin
16 logger
= logging
.getLogger('pyTivo.video.transcode')
18 info_cache
= lrucache
.LRUCache(1000)
19 videotest
= os
.path
.join(os
.path
.dirname(__file__
), 'videotest.mpg')
21 BAD_MPEG_FPS
= ['15.00']
24 return config
.get('Server', 'ffmpeg')
27 # subprocess is broken for me on windows so super hack
28 def patchSubprocess():
29 o
= subprocess
.Popen
._make
_inheritable
31 def _make_inheritable(self
, handle
):
32 if not handle
: return subprocess
.GetCurrentProcess()
33 return o(self
, handle
)
35 subprocess
.Popen
._make
_inheritable
= _make_inheritable
36 mswindows
= (sys
.platform
== "win32")
40 def output_video(inFile
, outFile
, tsn
=''):
41 if tivo_compatible(inFile
, tsn
)[0]:
42 logger
.debug('%s is tivo compatible' % inFile
)
43 f
= file(inFile
, 'rb')
44 shutil
.copyfileobj(f
, outFile
)
47 logger
.debug('%s is not tivo compatible' % inFile
)
48 transcode(False, inFile
, outFile
, tsn
)
50 def transcode(isQuery
, inFile
, outFile
, tsn
=''):
51 settings
= {'video_codec': select_videocodec(tsn
),
52 'video_br': select_videobr(inFile
, tsn
),
53 'video_fps': select_videofps(inFile
, tsn
),
54 'max_video_br': select_maxvideobr(),
55 'buff_size': select_buffsize(tsn
),
56 'aspect_ratio': ' '.join(select_aspect(inFile
, tsn
)),
57 'audio_br': select_audiobr(tsn
),
58 'audio_fr': select_audiofr(inFile
, tsn
),
59 'audio_ch': select_audioch(tsn
),
60 'audio_codec': select_audiocodec(isQuery
, inFile
, tsn
),
61 'audio_lang': select_audiolang(inFile
, tsn
),
62 'ffmpeg_pram': select_ffmpegprams(tsn
),
63 'format': select_format(tsn
)}
68 cmd_string
= config
.getFFmpegTemplate(tsn
) % settings
70 cmd
= [ffmpeg_path(), '-i', inFile
] + cmd_string
.split()
71 logging
.debug('transcoding to tivo model ' + tsn
[:3] +
72 ' using ffmpeg command:')
73 logging
.debug(' '.join(cmd
))
74 ffmpeg
= subprocess
.Popen(cmd
, bufsize
=(512 * 1024),
75 stdout
=subprocess
.PIPE
)
77 shutil
.copyfileobj(ffmpeg
.stdout
, outFile
)
81 def select_audiocodec(isQuery
, inFile
, tsn
= ''):
82 # Default, compatible with all TiVo's
84 vInfo
= video_info(inFile
)
85 codectype
= vInfo
['vCodec']
86 if config
.getAudioCodec(tsn
) == None:
87 if vInfo
['aCodec'] in ('ac3', 'liba52', 'mp2'):
88 if vInfo
['aKbps'] == None:
90 cmd_string
= ('-y -vcodec mpeg2video -r 29.97 ' +
91 '-b 1000k -acodec copy ' +
92 select_audiolang(inFile
, tsn
) +
93 ' -t 00:00:01 -f vob -')
94 if video_check(inFile
, cmd_string
):
95 vInfo
= video_info(videotest
)
98 if (not vInfo
['aKbps'] == None and
99 int(vInfo
['aKbps']) <= config
.getMaxAudioBR(tsn
)):
100 # compatible codec and bitrate, do not reencode audio
103 codec
= config
.getAudioCodec(tsn
)
105 if ((codec
== 'copy' and config
.getCopyTS(tsn
).lower() == 'none'
106 and codectype
== 'mpeg2video') or
107 config
.getCopyTS(tsn
).lower() == 'false'):
109 return '-acodec ' + codec
+ copyts
111 def select_audiofr(inFile
, tsn
):
112 freq
= '48000' #default
113 vInfo
= video_info(inFile
)
114 if not vInfo
['aFreq'] == None and vInfo
['aFreq'] in ('44100', '48000'):
115 # compatible frequency
116 freq
= vInfo
['aFreq']
117 if config
.getAudioFR(tsn
) != None:
118 freq
= config
.getAudioFR(tsn
)
121 def select_audioch(tsn
):
122 if config
.getAudioCH(tsn
) != None:
123 return '-ac '+config
.getAudioCH(tsn
)
126 def select_audiolang(inFile
, tsn
):
127 vInfo
= video_info(inFile
)
128 if config
.getAudioLang(tsn
) != None and vInfo
['mapVideo'] != None:
129 stream
= vInfo
['mapAudio'][0][0]
131 for lang
in config
.getAudioLang(tsn
).replace(' ','').lower().split(','):
132 for s
, l
in vInfo
['mapAudio']:
133 if lang
in s
+ l
.replace(' ','').lower():
139 return '-map ' + vInfo
['mapVideo'] + ' -map ' + stream
142 def select_videofps(inFile
, tsn
):
143 vInfo
= video_info(inFile
)
144 fps
= '-r 29.97' #default
145 if config
.isHDtivo(tsn
) and vInfo
['vFps'] not in BAD_MPEG_FPS
:
147 if config
.getVideoFPS(tsn
) != None:
148 fps
= '-r '+config
.getVideoFPS(tsn
)
151 def select_videocodec(tsn
):
152 codec
= 'mpeg2video' #default
153 if config
.getVideoCodec(tsn
) != None:
154 codec
= config
.getVideoCodec(tsn
)
155 return '-vcodec '+codec
157 def select_videobr(inFile
, tsn
):
158 return '-b ' + str(select_videostr(inFile
, tsn
) / 1000) + 'k'
160 def select_videostr(inFile
, tsn
):
161 video_str
= config
.strtod(config
.getVideoBR(tsn
))
162 if config
.isHDtivo(tsn
):
163 vInfo
= video_info(inFile
)
164 if vInfo
['kbps'] != None and config
.getVideoPCT() > 0:
165 video_percent
= int(vInfo
['kbps']) * 10 * config
.getVideoPCT()
166 video_str
= max(video_str
, video_percent
)
167 video_str
= int(min(config
.strtod(config
.getMaxVideoBR()) * 0.95,
171 def select_audiobr(tsn
):
172 return '-ab ' + config
.getAudioBR(tsn
)
174 def select_maxvideobr():
175 return '-maxrate ' + config
.getMaxVideoBR()
177 def select_buffsize(tsn
):
178 return '-bufsize ' + config
.getBuffSize(tsn
)
180 def select_ffmpegprams(tsn
):
181 if config
.getFFmpegPrams(tsn
) != None:
182 return config
.getFFmpegPrams(tsn
)
185 def select_format(tsn
):
187 if config
.getFormat(tsn
) != None:
188 fmt
= config
.getFormat(tsn
)
189 return '-f ' + fmt
+ ' -'
191 def select_aspect(inFile
, tsn
= ''):
192 TIVO_WIDTH
= config
.getTivoWidth(tsn
)
193 TIVO_HEIGHT
= config
.getTivoHeight(tsn
)
195 vInfo
= video_info(inFile
)
197 logging
.debug('tsn: %s' % tsn
)
199 aspect169
= config
.get169Setting(tsn
)
201 logging
.debug('aspect169:%s' % aspect169
)
203 optres
= config
.getOptres(tsn
)
205 logging
.debug('optres:%s' % optres
)
208 optHeight
= config
.nearestTivoHeight(vInfo
['vHeight'])
209 optWidth
= config
.nearestTivoWidth(vInfo
['vWidth'])
210 if optHeight
< TIVO_HEIGHT
:
211 TIVO_HEIGHT
= optHeight
212 if optWidth
< TIVO_WIDTH
:
213 TIVO_WIDTH
= optWidth
215 d
= gcd(vInfo
['vHeight'], vInfo
['vWidth'])
216 ratio
= (vInfo
['vWidth'] * 100) / vInfo
['vHeight']
217 rheight
, rwidth
= vInfo
['vHeight'] / d
, vInfo
['vWidth'] / d
219 logger
.debug(('File=%s vCodec=%s vWidth=%s vHeight=%s vFps=%s ' +
220 'millisecs=%s ratio=%s rheight=%s rwidth=%s ' +
221 'TIVO_HEIGHT=%s TIVO_WIDTH=%s') % (inFile
,
222 vInfo
['vCodec'], vInfo
['vWidth'], vInfo
['vHeight'],
223 vInfo
['vFps'], vInfo
['millisecs'], ratio
, rheight
,
224 rwidth
, TIVO_HEIGHT
, TIVO_WIDTH
))
226 multiplier16by9
= (16.0 * TIVO_HEIGHT
) / (9.0 * TIVO_WIDTH
)
227 multiplier4by3
= (4.0 * TIVO_HEIGHT
) / (3.0 * TIVO_WIDTH
)
229 if config
.isHDtivo(tsn
) and not optres
:
230 if config
.getPixelAR(0):
231 if vInfo
['par2'] == None:
232 npar
= config
.getPixelAR(1)
236 # adjust for pixel aspect ratio, if set, because TiVo
237 # expects square pixels
240 return ['-s', str(vInfo
['vWidth']) + 'x' +
241 str(int(math
.ceil(vInfo
['vHeight'] / npar
)))]
243 # FFMPEG expects width to be a multiple of two
245 return ['-s', str(int(math
.ceil(vInfo
['vWidth'] * npar
/
246 2.0) * 2)) + 'x' + str(vInfo
['vHeight'])]
248 if vInfo
['vHeight'] <= TIVO_HEIGHT
:
249 # pass all resolutions to S3, except heights greater than
252 # else, resize video.
254 if (rwidth
, rheight
) in [(1, 1)] and vInfo
['par1'] == '8:9':
255 logger
.debug('File + PAR is within 4:3.')
256 return ['-aspect', '4:3', '-s', '%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
)]
258 elif ((rwidth
, rheight
) in [(4, 3), (10, 11), (15, 11), (59, 54),
259 (59, 72), (59, 36), (59, 54)] or
260 vInfo
['dar1'] == '4:3'):
261 logger
.debug('File is within 4:3 list.')
262 return ['-aspect', '4:3', '-s', '%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
)]
264 elif (((rwidth
, rheight
) in [(16, 9), (20, 11), (40, 33), (118, 81),
265 (59, 27)] or vInfo
['dar1'] == '16:9')
266 and (aspect169
or config
.get169Letterbox(tsn
))):
267 logger
.debug('File is within 16:9 list and 16:9 allowed.')
269 if config
.get169Blacklist(tsn
) or (aspect169
and
270 config
.get169Letterbox(tsn
)):
271 return ['-aspect', '4:3', '-s', '%sx%s' %
272 (TIVO_WIDTH
, TIVO_HEIGHT
)]
274 return ['-aspect', '16:9', '-s', '%sx%s' %
275 (TIVO_WIDTH
, TIVO_HEIGHT
)]
279 # If video is wider than 4:3 add top and bottom padding
281 if (ratio
> 133): # Might be 16:9 file, or just need padding on
284 if aspect169
and (ratio
> 135): # If file would fall in 4:3
285 # assume it is supposed to be 4:3
287 if (ratio
> 177): # too short needs padding top and bottom
288 endHeight
= int(((TIVO_WIDTH
* vInfo
['vHeight']) /
289 vInfo
['vWidth']) * multiplier16by9
)
290 settings
.append('-aspect')
291 if (config
.get169Blacklist(tsn
) or
292 config
.get169Letterbox(tsn
)):
293 settings
.append('4:3')
295 settings
.append('16:9')
298 if endHeight
< TIVO_HEIGHT
* 0.99:
299 settings
.append('-s')
300 settings
.append('%sx%s' % (TIVO_WIDTH
, endHeight
))
302 topPadding
= ((TIVO_HEIGHT
- endHeight
) / 2)
306 settings
.append('-padtop')
307 settings
.append(str(topPadding
))
308 bottomPadding
= (TIVO_HEIGHT
- endHeight
) - topPadding
309 settings
.append('-padbottom')
310 settings
.append(str(bottomPadding
))
311 else: # if only very small amount of padding
312 # needed, then just stretch it
313 settings
.append('-s')
314 settings
.append('%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
))
316 logger
.debug(('16:9 aspect allowed, file is wider ' +
317 'than 16:9 padding top and bottom\n%s') %
320 else: # too skinny needs padding on left and right.
321 endWidth
= int((TIVO_HEIGHT
* vInfo
['vWidth']) /
322 (vInfo
['vHeight'] * multiplier16by9
))
323 settings
.append('-aspect')
324 if (config
.get169Blacklist(tsn
) or
325 config
.get169Letterbox(tsn
)):
326 settings
.append('4:3')
328 settings
.append('16:9')
331 if endWidth
< (TIVO_WIDTH
- 10):
332 settings
.append('-s')
333 settings
.append('%sx%s' % (endWidth
, TIVO_HEIGHT
))
335 leftPadding
= ((TIVO_WIDTH
- endWidth
) / 2)
339 settings
.append('-padleft')
340 settings
.append(str(leftPadding
))
341 rightPadding
= (TIVO_WIDTH
- endWidth
) - leftPadding
342 settings
.append('-padright')
343 settings
.append(str(rightPadding
))
344 else: # if only very small amount of padding needed,
345 # then just stretch it
346 settings
.append('-s')
347 settings
.append('%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
))
348 logger
.debug(('16:9 aspect allowed, file is narrower ' +
349 'than 16:9 padding left and right\n%s') %
351 else: # this is a 4:3 file or 16:9 output not allowed
352 multiplier
= multiplier4by3
353 settings
.append('-aspect')
354 if ratio
> 135 and config
.get169Letterbox(tsn
):
355 settings
.append('16:9')
356 multiplier
= multiplier16by9
358 settings
.append('4:3')
359 endHeight
= int(((TIVO_WIDTH
* vInfo
['vHeight']) /
360 vInfo
['vWidth']) * multiplier
)
363 if endHeight
< TIVO_HEIGHT
* 0.99:
364 settings
.append('-s')
365 settings
.append('%sx%s' % (TIVO_WIDTH
, endHeight
))
367 topPadding
= ((TIVO_HEIGHT
- endHeight
)/2)
371 settings
.append('-padtop')
372 settings
.append(str(topPadding
))
373 bottomPadding
= (TIVO_HEIGHT
- endHeight
) - topPadding
374 settings
.append('-padbottom')
375 settings
.append(str(bottomPadding
))
376 else: # if only very small amount of padding needed,
377 # then just stretch it
378 settings
.append('-s')
379 settings
.append('%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
))
380 logging
.debug(('File is wider than 4:3 padding ' +
381 'top and bottom\n%s') % ' '.join(settings
))
385 # If video is taller than 4:3 add left and right padding, this
386 # is rare. All of these files will always be sent in an aspect
387 # ratio of 4:3 since they are so narrow.
390 endWidth
= int((TIVO_HEIGHT
* vInfo
['vWidth']) /
391 (vInfo
['vHeight'] * multiplier4by3
))
392 settings
.append('-aspect')
393 settings
.append('4:3')
396 if endWidth
< (TIVO_WIDTH
* 0.99):
397 settings
.append('-s')
398 settings
.append('%sx%s' % (endWidth
, TIVO_HEIGHT
))
400 leftPadding
= ((TIVO_WIDTH
- endWidth
) / 2)
404 settings
.append('-padleft')
405 settings
.append(str(leftPadding
))
406 rightPadding
= (TIVO_WIDTH
- endWidth
) - leftPadding
407 settings
.append('-padright')
408 settings
.append(str(rightPadding
))
409 else: # if only very small amount of padding needed, then
411 settings
.append('-s')
412 settings
.append('%sx%s' % (TIVO_WIDTH
, TIVO_HEIGHT
))
414 logger
.debug('File is taller than 4:3 padding left and right\n%s'
415 % ' '.join(settings
))
419 def tivo_compatible(inFile
, tsn
= ''):
420 supportedModes
= [[720, 480], [704, 480], [544, 480], [528, 480],
421 [480, 480], [352, 480]]
422 vInfo
= video_info(inFile
)
425 if (inFile
[-5:]).lower() == '.tivo':
426 message
= (True, 'TRANSCODE=NO, ends with .tivo.')
429 if not vInfo
['vCodec'] == 'mpeg2video':
430 #print 'Not Tivo Codec'
431 message
= (False, 'TRANSCODE=YES, vCodec %s not compatible.' %
435 if os
.path
.splitext(inFile
)[-1].lower() in ('.ts', '.mpv',
437 message
= (False, 'TRANSCODE=YES, ext %s not compatible.' %
438 os
.path
.splitext(inFile
)[-1])
441 if vInfo
['aCodec'] == 'dca':
442 message
= (False, 'TRANSCODE=YES, aCodec %s not compatible.' %
446 if vInfo
['aCodec'] != None:
447 if (not vInfo
['aKbps'] or
448 int(vInfo
['aKbps']) > config
.getMaxAudioBR(tsn
)):
449 message
= (False, ('TRANSCODE=YES, %s kbps exceeds max ' +
450 'audio bitrate.') % vInfo
['aKbps'])
453 if vInfo
['kbps'] != None:
454 abit
= max('0', vInfo
['aKbps'])
455 if (int(vInfo
['kbps']) - int(abit
) >
456 config
.strtod(config
.getMaxVideoBR()) / 1000):
457 message
= (False, ('TRANSCODE=YES, %s kbps exceeds max ' +
458 'video bitrate.') % vInfo
['kbps'])
461 message
= (False, 'TRANSCODE=YES, %s kbps not supported.' %
465 if config
.getAudioLang(tsn
) is not None:
466 if vInfo
['mapAudio'][0][0] != select_audiolang(inFile
, tsn
)[-3:]:
467 message
= (False, ('TRANSCODE=YES, %s preferred audio ' +
468 'track exists.') % config
.getAudioLang(tsn
))
471 if config
.isHDtivo(tsn
):
472 if vInfo
['par2'] != 1.0:
473 if config
.getPixelAR(0):
474 if vInfo
['par2'] != None or config
.getPixelAR(1) != 1.0:
475 message
= (False, 'TRANSCODE=YES, %s not correct PAR.'
478 message
= (True, 'TRANSCODE=NO, HD Tivo detected, skipping ' +
482 if not vInfo
['vFps'] == '29.97':
483 #print 'Not Tivo fps'
484 message
= (False, 'TRANSCODE=YES, %s vFps, should be 29.97.' %
488 if ((config
.get169Blacklist(tsn
) and not config
.get169Setting(tsn
))
489 or (config
.get169Letterbox(tsn
) and config
.get169Setting(tsn
))):
490 if vInfo
['dar1'] == None or not vInfo
['dar1'] in ('4:3', '8:9'):
491 message
= (False, ('TRANSCODE=YES, DAR %s not supported ' +
492 'by BLACKLIST_169 tivos.') % vInfo
['dar1'])
495 for mode
in supportedModes
:
496 if (mode
[0], mode
[1]) == (vInfo
['vWidth'], vInfo
['vHeight']):
497 message
= (True, 'TRANSCODE=NO, %s x %s is valid.' %
498 (vInfo
['vWidth'], vInfo
['vHeight']))
500 #print 'Not Tivo dimensions'
501 message
= (False, 'TRANSCODE=YES, %s x %s not in supported modes.'
502 % (vInfo
['vWidth'], vInfo
['vHeight']))
505 logger
.debug('%s, %s' % (message
, inFile
))
509 def video_info(inFile
):
511 mtime
= os
.stat(inFile
).st_mtime
512 if inFile
!= videotest
:
513 if inFile
in info_cache
and info_cache
[inFile
][0] == mtime
:
514 logging
.debug('CACHE HIT! %s' % inFile
)
515 return info_cache
[inFile
][1]
517 vInfo
['Supported'] = True
519 if (inFile
[-5:]).lower() == '.tivo':
520 vInfo
['millisecs'] = 0
521 info_cache
[inFile
] = (mtime
, vInfo
)
522 logger
.debug('VALID, ends in .tivo. %s' % inFile
)
525 cmd
= [ffmpeg_path(), '-i', inFile
]
526 # Windows and other OS buffer 4096 and ffmpeg can output more than that.
527 err_tmp
= tempfile
.TemporaryFile()
528 ffmpeg
= subprocess
.Popen(cmd
, stderr
=err_tmp
, stdout
=subprocess
.PIPE
,
529 stdin
=subprocess
.PIPE
)
531 # wait 10 sec if ffmpeg is not back give up
532 for i
in xrange(200):
534 if not ffmpeg
.poll() == None:
537 if ffmpeg
.poll() == None:
539 vInfo
['Supported'] = False
540 info_cache
[inFile
] = (mtime
, vInfo
)
544 output
= err_tmp
.read()
546 logging
.debug('ffmpeg output=%s' % output
)
548 rezre
= re
.compile(r
'.*Video: ([^,]+),.*')
549 x
= rezre
.search(output
)
551 vInfo
['vCodec'] = x
.group(1)
554 vInfo
['Supported'] = False
555 logger
.debug('failed at vCodec')
557 rezre
= re
.compile(r
'.*Video: .+, (\d+)x(\d+)[, ].*')
558 x
= rezre
.search(output
)
560 vInfo
['vWidth'] = int(x
.group(1))
561 vInfo
['vHeight'] = int(x
.group(2))
564 vInfo
['vHeight'] = ''
565 vInfo
['Supported'] = False
566 logger
.debug('failed at vWidth/vHeight')
568 rezre
= re
.compile(r
'.*Video: .+, (.+) (?:fps|tb).*')
569 x
= rezre
.search(output
)
571 vInfo
['vFps'] = x
.group(1)
573 # Allow override only if it is mpeg2 and frame rate was doubled
576 if (not vInfo
['vFps'] == '29.97') and (vInfo
['vCodec'] == 'mpeg2video'):
577 # First look for the build 7215 version
578 rezre
= re
.compile(r
'.*film source: 29.97.*')
579 x
= rezre
.search(output
.lower() )
581 logger
.debug('film source: 29.97 setting vFps to 29.97')
582 vInfo
['vFps'] = '29.97'
585 rezre
= re
.compile(r
'.*frame rate differs from container ' +
586 r
'frame rate: 29.97.*')
587 logger
.debug('Bug in VideoReDo')
588 x
= rezre
.search(output
.lower() )
590 vInfo
['vFps'] = '29.97'
593 vInfo
['Supported'] = False
594 logger
.debug('failed at vFps')
596 durre
= re
.compile(r
'.*Duration: ([0-9]+):([0-9]+):([0-9]+)\.([0-9]+),')
597 d
= durre
.search(output
)
600 vInfo
['millisecs'] = ((int(d
.group(1)) * 3600 +
601 int(d
.group(2)) * 60 +
602 int(d
.group(3))) * 1000 +
603 int(d
.group(4)) * (10 ** (3 - len(d
.group(4)))))
605 vInfo
['millisecs'] = 0
607 #get bitrate of source for tivo compatibility test.
608 rezre
= re
.compile(r
'.*bitrate: (.+) (?:kb/s).*')
609 x
= rezre
.search(output
)
611 vInfo
['kbps'] = x
.group(1)
614 logger
.debug('failed at kbps')
616 #get audio bitrate of source for tivo compatibility test.
617 rezre
= re
.compile(r
'.*Audio: .+, (.+) (?:kb/s).*')
618 x
= rezre
.search(output
)
620 vInfo
['aKbps'] = x
.group(1)
622 vInfo
['aKbps'] = None
623 logger
.debug('failed at aKbps')
625 #get audio codec of source for tivo compatibility test.
626 rezre
= re
.compile(r
'.*Audio: ([^,]+),.*')
627 x
= rezre
.search(output
)
629 vInfo
['aCodec'] = x
.group(1)
631 vInfo
['aCodec'] = None
632 logger
.debug('failed at aCodec')
634 #get audio frequency of source for tivo compatibility test.
635 rezre
= re
.compile(r
'.*Audio: .+, (.+) (?:Hz).*')
636 x
= rezre
.search(output
)
638 vInfo
['aFreq'] = x
.group(1)
640 vInfo
['aFreq'] = None
641 logger
.debug('failed at aFreq')
644 rezre
= re
.compile(r
'.*Video: .+PAR ([0-9]+):([0-9]+) DAR [0-9:]+.*')
645 x
= rezre
.search(output
)
646 if x
and x
.group(1) != "0" and x
.group(2) != "0":
647 vInfo
['par1'] = x
.group(1) + ':' + x
.group(2)
648 vInfo
['par2'] = float(x
.group(1)) / float(x
.group(2))
650 vInfo
['par1'], vInfo
['par2'] = None, None
653 rezre
= re
.compile(r
'.*Video: .+DAR ([0-9]+):([0-9]+).*')
654 x
= rezre
.search(output
)
655 if x
and x
.group(1) != "0" and x
.group(2) != "0":
656 vInfo
['dar1'] = x
.group(1) + ':' + x
.group(2)
657 vInfo
['dar2'] = float(x
.group(1)) / float(x
.group(2))
659 vInfo
['dar1'], vInfo
['dar2'] = None, None
661 #get Video Stream mapping.
662 rezre
= re
.compile(r
'([0-9]+\.[0-9]+).*: Video:.*')
663 x
= rezre
.search(output
)
665 vInfo
['mapVideo'] = x
.group(1)
667 vInfo
['mapVideo'] = None
668 logger
.debug('failed at mapVideo')
671 #get Audio Stream mapping.
672 rezre
= re
.compile(r
'([0-9]+\.[0-9]+)(.*): Audio:.*')
673 x
= rezre
.search(output
)
676 for x
in rezre
.finditer(output
):
677 amap
.append(x
.groups())
679 amap
.append(('', ''))
680 logger
.debug('failed at mapAudio')
681 vInfo
['mapAudio'] = amap
684 videoPlugin
= GetPlugin('video')
685 metadata
= videoPlugin
.getMetadataFromTxt(inFile
)
688 if key
.startswith('Override_'):
689 vInfo
['Supported'] = True
690 if key
.startswith('Override_mapAudio'):
691 audiomap
= dict(vInfo
['mapAudio'])
692 stream
= key
.replace('Override_mapAudio', '').strip()
693 if audiomap
.has_key(stream
):
694 newaudiomap
= (stream
, metadata
[key
])
695 audiomap
.update([newaudiomap
])
696 vInfo
['mapAudio'] = sorted(audiomap
.items(),
697 key
=lambda (k
,v
): (k
,v
))
698 elif key
.startswith('Override_millisecs'):
699 vInfo
[key
.replace('Override_', '')] = int(metadata
[key
])
701 vInfo
[key
.replace('Override_', '')] = metadata
[key
]
703 info_cache
[inFile
] = (mtime
, vInfo
)
704 logger
.debug("; ".join(["%s=%s" % (k
, v
) for k
, v
in vInfo
.items()]))
707 def video_check(inFile
, cmd_string
):
708 cmd
= [ffmpeg_path(), '-i', inFile
] + cmd_string
.split()
709 ffmpeg
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
)
711 shutil
.copyfileobj(ffmpeg
.stdout
, open(videotest
, 'wb'))
717 def supported_format(inFile
):
718 if video_info(inFile
)['Supported']:
721 logger
.debug('FALSE, file not supported %s' % inFile
)
725 logger
.debug('killing pid=%s' % str(pid
))
730 os
.kill(pid
, signal
.SIGTERM
)
734 handle
= ctypes
.windll
.kernel32
.OpenProcess(1, False, pid
)
735 ctypes
.windll
.kernel32
.TerminateProcess(handle
, -1)
736 ctypes
.windll
.kernel32
.CloseHandle(handle
)