1 import subprocess
, shutil
, os
, re
, sys
, ConfigParser
, time
, lrucache
, math
3 from debug
import debug_write
, fn_attr
5 info_cache
= lrucache
.LRUCache(1000)
6 videotest
= os
.path
.join(os
.path
.dirname(__file__
), 'videotest.mpg')
9 return config
.get('Server', 'ffmpeg')
12 # subprocess is broken for me on windows so super hack
13 def patchSubprocess():
14 o
= subprocess
.Popen
._make
_inheritable
16 def _make_inheritable(self
, handle
):
17 if not handle
: return subprocess
.GetCurrentProcess()
18 return o(self
, handle
)
20 subprocess
.Popen
._make
_inheritable
= _make_inheritable
21 mswindows
= (sys
.platform
== "win32")
25 def output_video(inFile
, outFile
, tsn
=''):
26 if tivo_compatable(inFile
, tsn
):
27 debug_write(__name__
, fn_attr(), [inFile
, ' is tivo compatible'])
28 f
= file(inFile
, 'rb')
29 shutil
.copyfileobj(f
, outFile
)
32 debug_write(__name__
, fn_attr(), [inFile
, ' is not tivo compatible'])
33 transcode(inFile
, outFile
, tsn
)
35 def transcode(inFile
, outFile
, tsn
=''):
38 settings
['video_codec'] = select_videocodec(tsn
)
39 settings
['video_br'] = select_videobr(tsn
)
40 settings
['video_fps'] = select_videofps(tsn
)
41 settings
['max_video_br'] = select_maxvideobr()
42 settings
['buff_size'] = select_buffsize()
43 settings
['aspect_ratio'] = ' '.join(select_aspect(inFile
, tsn
))
44 settings
['audio_br'] = select_audiobr(tsn
)
45 settings
['audio_fr'] = select_audiofr(inFile
, tsn
)
46 settings
['audio_ch'] = select_audioch(tsn
)
47 settings
['audio_codec'] = select_audiocodec(inFile
, tsn
)
48 settings
['copy_ts'] = select_copyts(tsn
)
49 settings
['ffmpeg_pram'] = select_ffmpegprams(tsn
)
50 settings
['format'] = select_format(tsn
)
52 cmd_string
= config
.getFFmpegTemplate(tsn
) % settings
54 cmd
= [ffmpeg_path(), '-i', inFile
] + cmd_string
.split()
55 print 'transcoding to tivo model '+tsn
[:3]+' using ffmpeg command:'
57 debug_write(__name__
, fn_attr(), ['ffmpeg command is ', ' '.join(cmd
)])
58 ffmpeg
= subprocess
.Popen(cmd
, bufsize
=512*1024, stdout
=subprocess
.PIPE
)
60 shutil
.copyfileobj(ffmpeg
.stdout
, outFile
)
64 def select_audiocodec(inFile
, tsn
= ''):
65 # Default, compatible with all TiVo's
67 if config
.getAudioCodec(tsn
) == None:
68 type, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
= video_info(inFile
)
69 if acodec
in ('ac3', 'liba52', 'mp2'):
71 cmd_string
= '-y -vcodec mpeg2video -r 29.97 -b 1000k -acodec copy -t 00:00:01 -f vob -'
72 if video_check(inFile
, cmd_string
):
73 type, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
= video_info(videotest
)
74 if not akbps
== None and int(akbps
) <= config
.getMaxAudioBR(tsn
):
75 # compatible codec and bitrate, do not reencode audio
78 codec
= config
.getAudioCodec(tsn
)
79 return '-acodec '+codec
81 def select_audiofr(inFile
, tsn
):
82 freq
= '48000' #default
83 type, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
= video_info(inFile
)
84 if not afreq
== None and afreq
in ('44100', '48000'):
85 # compatible frequency
87 if config
.getAudioFR(tsn
) != None:
88 freq
= config
.getAudioFR(tsn
)
91 def select_audioch(tsn
):
92 if config
.getAudioCH(tsn
) != None:
93 return '-ac '+config
.getAudioCH(tsn
)
96 def select_copyts(tsn
):
97 if config
.getCopyTS(tsn
):
101 def select_videofps(tsn
):
102 vfps
= '-r 29.97' #default
103 if config
.isHDtivo(tsn
):
105 if config
.getVideoFPS(tsn
) != None:
106 vfps
= '-r '+config
.getVideoFPS(tsn
)
109 def select_videocodec(tsn
):
110 vcodec
= 'mpeg2video' #default
111 if config
.getVideoCodec(tsn
) != None:
112 vcodec
= config
.getVideoCodec(tsn
)
113 return '-vcodec '+vcodec
115 def select_videobr(tsn
):
116 return '-b '+config
.getVideoBR(tsn
)
118 def select_audiobr(tsn
):
119 return '-ab '+config
.getAudioBR(tsn
)
121 def select_maxvideobr():
122 return '-maxrate '+config
.getMaxVideoBR()
124 def select_buffsize():
125 return '-bufsize '+config
.getBuffSize()
127 def select_ffmpegprams(tsn
):
128 if config
.getFFmpegPrams(tsn
) != None:
129 return config
.getFFmpegPrams(tsn
)
132 def select_format(tsn
):
134 if config
.getFormat(tsn
) != None:
135 fmt
= config
.getFormat(tsn
)
136 return '-f '+fmt
+' -'
138 def select_aspect(inFile
, tsn
= ''):
139 TIVO_WIDTH
= config
.getTivoWidth(tsn
)
140 TIVO_HEIGHT
= config
.getTivoHeight(tsn
)
142 type, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
= video_info(inFile
)
144 debug_write(__name__
, fn_attr(), ['tsn:', tsn
])
146 aspect169
= config
.get169Setting(tsn
)
148 debug_write(__name__
, fn_attr(), ['aspect169:', aspect169
])
150 optres
= config
.getOptres(tsn
)
152 debug_write(__name__
, fn_attr(), ['optres:', optres
])
155 optHeight
= config
.nearestTivoHeight(height
)
156 optWidth
= config
.nearestTivoWidth(width
)
157 if optHeight
< TIVO_HEIGHT
:
158 TIVO_HEIGHT
= optHeight
159 if optWidth
< TIVO_WIDTH
:
160 TIVO_WIDTH
= optWidth
162 d
= gcd(height
,width
)
163 ratio
= (width
*100)/height
164 rheight
, rwidth
= height
/d
, width
/d
166 debug_write(__name__
, fn_attr(), ['File=', inFile
, ' Type=', type, ' width=', width
, ' height=', height
, ' fps=', fps
, ' millisecs=', millisecs
, ' ratio=', ratio
, ' rheight=', rheight
, ' rwidth=', rwidth
, ' TIVO_HEIGHT=', TIVO_HEIGHT
, 'TIVO_WIDTH=', TIVO_WIDTH
])
168 multiplier16by9
= (16.0 * TIVO_HEIGHT
) / (9.0 * TIVO_WIDTH
)
169 multiplier4by3
= (4.0 * TIVO_HEIGHT
) / (3.0 * TIVO_WIDTH
)
171 if config
.isHDtivo(tsn
) and not optres
:
172 if config
.getPixelAR(0):
174 npar
= config
.getPixelAR(1)
177 # adjust for pixel aspect ratio, if set, because TiVo expects square pixels
179 return ['-s', str(width
) + 'x' + str(int(math
.ceil(height
/npar
)))]
181 # FFMPEG expects width to be a multiple of two
182 return ['-s', str(int(math
.ceil(width
*npar
/2.0)*2)) + 'x' + str(height
)]
183 if height
<= TIVO_HEIGHT
:
184 # pass all resolutions to S3, except heights greater than conf height
186 # else, resize video.
187 if (rwidth
, rheight
) in [(1, 1)] and vpar
== 8.0/9.0:
188 debug_write(__name__
, fn_attr(), ['File + PAR is within 4:3.'])
189 return ['-aspect', '4:3', '-s', str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
)]
190 elif (rwidth
, rheight
) in [(4, 3), (10, 11), (15, 11), (59, 54), (59, 72), (59, 36), (59, 54)]:
191 debug_write(__name__
, fn_attr(), ['File is within 4:3 list.'])
192 return ['-aspect', '4:3', '-s', str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
)]
193 elif ((rwidth
, rheight
) in [(16, 9), (20, 11), (40, 33), (118, 81), (59, 27)]) and aspect169
:
194 debug_write(__name__
, fn_attr(), ['File is within 16:9 list and 16:9 allowed.'])
195 return ['-aspect', '16:9', '-s', str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
)]
198 #If video is wider than 4:3 add top and bottom padding
199 if (ratio
> 133): #Might be 16:9 file, or just need padding on top and bottom
200 if aspect169
and (ratio
> 135): #If file would fall in 4:3 assume it is supposed to be 4:3
201 if (ratio
> 177):#too short needs padding top and bottom
202 endHeight
= int(((TIVO_WIDTH
*height
)/width
) * multiplier16by9
)
203 settings
.append('-aspect')
204 settings
.append('16:9')
207 if endHeight
< TIVO_HEIGHT
* 0.99:
208 settings
.append('-s')
209 settings
.append(str(TIVO_WIDTH
) + 'x' + str(endHeight
))
211 topPadding
= ((TIVO_HEIGHT
- endHeight
)/2)
215 settings
.append('-padtop')
216 settings
.append(str(topPadding
))
217 bottomPadding
= (TIVO_HEIGHT
- endHeight
) - topPadding
218 settings
.append('-padbottom')
219 settings
.append(str(bottomPadding
))
220 else: #if only very small amount of padding needed, then just stretch it
221 settings
.append('-s')
222 settings
.append(str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
))
223 debug_write(__name__
, fn_attr(), ['16:9 aspect allowed, file is wider than 16:9 padding top and bottom', ' '.join(settings
)])
224 else: #too skinny needs padding on left and right.
225 endWidth
= int((TIVO_HEIGHT
*width
)/(height
*multiplier16by9
))
226 settings
.append('-aspect')
227 settings
.append('16:9')
230 if endWidth
< (TIVO_WIDTH
-10):
231 settings
.append('-s')
232 settings
.append(str(endWidth
) + 'x' + str(TIVO_HEIGHT
))
234 leftPadding
= ((TIVO_WIDTH
- endWidth
)/2)
238 settings
.append('-padleft')
239 settings
.append(str(leftPadding
))
240 rightPadding
= (TIVO_WIDTH
- endWidth
) - leftPadding
241 settings
.append('-padright')
242 settings
.append(str(rightPadding
))
243 else: #if only very small amount of padding needed, then just stretch it
244 settings
.append('-s')
245 settings
.append(str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
))
246 debug_write(__name__
, fn_attr(), ['16:9 aspect allowed, file is narrower than 16:9 padding left and right\n', ' '.join(settings
)])
247 else: #this is a 4:3 file or 16:9 output not allowed
248 settings
.append('-aspect')
249 settings
.append('4:3')
250 endHeight
= int(((TIVO_WIDTH
*height
)/width
) * multiplier4by3
)
253 if endHeight
< TIVO_HEIGHT
* 0.99:
254 settings
.append('-s')
255 settings
.append(str(TIVO_WIDTH
) + 'x' + str(endHeight
))
257 topPadding
= ((TIVO_HEIGHT
- endHeight
)/2)
261 settings
.append('-padtop')
262 settings
.append(str(topPadding
))
263 bottomPadding
= (TIVO_HEIGHT
- endHeight
) - topPadding
264 settings
.append('-padbottom')
265 settings
.append(str(bottomPadding
))
266 else: #if only very small amount of padding needed, then just stretch it
267 settings
.append('-s')
268 settings
.append(str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
))
269 debug_write(__name__
, fn_attr(), ['File is wider than 4:3 padding top and bottom\n', ' '.join(settings
)])
272 #If video is taller than 4:3 add left and right padding, this is rare. All of these files will always be sent in
273 #an aspect ratio of 4:3 since they are so narrow.
275 endWidth
= int((TIVO_HEIGHT
*width
)/(height
*multiplier4by3
))
276 settings
.append('-aspect')
277 settings
.append('4:3')
280 if endWidth
< (TIVO_WIDTH
* 0.99):
281 settings
.append('-s')
282 settings
.append(str(endWidth
) + 'x' + str(TIVO_HEIGHT
))
284 leftPadding
= ((TIVO_WIDTH
- endWidth
)/2)
288 settings
.append('-padleft')
289 settings
.append(str(leftPadding
))
290 rightPadding
= (TIVO_WIDTH
- endWidth
) - leftPadding
291 settings
.append('-padright')
292 settings
.append(str(rightPadding
))
293 else: #if only very small amount of padding needed, then just stretch it
294 settings
.append('-s')
295 settings
.append(str(TIVO_WIDTH
) + 'x' + str(TIVO_HEIGHT
))
297 debug_write(__name__
, fn_attr(), ['File is taller than 4:3 padding left and right\n', ' '.join(settings
)])
301 def tivo_compatable(inFile
, tsn
= ''):
302 supportedModes
= [[720, 480], [704, 480], [544, 480], [480, 480], [352, 480]]
303 type, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
= video_info(inFile
)
304 #print type, width, height, fps, millisecs, kbps, akbps, acodec
306 if (inFile
[-5:]).lower() == '.tivo':
307 debug_write(__name__
, fn_attr(), ['TRUE, ends with .tivo.', inFile
])
310 if not type == 'mpeg2video':
311 #print 'Not Tivo Codec'
312 debug_write(__name__
, fn_attr(), ['FALSE, type', type, 'not mpeg2video.', inFile
])
315 if os
.path
.splitext(inFile
)[-1].lower() in ('.ts', '.mpv'):
316 debug_write(__name__
, fn_attr(), ['FALSE, ext', os
.path
.splitext(inFile
)[-1],\
317 'not tivo compatible.', inFile
])
321 debug_write(__name__
, fn_attr(), ['FALSE, acodec', acodec
, ', not supported.', inFile
])
325 if not akbps
or int(akbps
) > config
.getMaxAudioBR(tsn
):
326 debug_write(__name__
, fn_attr(), ['FALSE,', akbps
, 'kbps exceeds max audio bitrate.', inFile
])
330 abit
= max('0', akbps
)
331 if int(kbps
)-int(abit
) > config
.strtod(config
.getMaxVideoBR())/1000:
332 debug_write(__name__
, fn_attr(), ['FALSE,', kbps
, 'kbps exceeds max video bitrate.', inFile
])
335 debug_write(__name__
, fn_attr(), ['FALSE,', kbps
, 'kbps not supported.', inFile
])
338 if config
.isHDtivo(tsn
):
340 if config
.getPixelAR(0):
341 if vpar
!= None or config
.getPixelAR(1) != 1.0:
342 debug_write(__name__
, fn_attr(), ['FALSE,', vpar
, 'not correct PAR,', inFile
])
344 debug_write(__name__
, fn_attr(), ['TRUE, HD Tivo detected, skipping remaining tests', inFile
])
347 if not fps
== '29.97':
348 #print 'Not Tivo fps'
349 debug_write(__name__
, fn_attr(), ['FALSE,', fps
, 'fps, should be 29.97.', inFile
])
353 if vdar
== None or not vdar
in (float(4)/float(3), float(8)/float(9)):
354 debug_write(__name__
, fn_attr(), ['FALSE, ratio', vdar
, 'not supported by 540 tivo.', inFile
])
357 for mode
in supportedModes
:
358 if (mode
[0], mode
[1]) == (width
, height
):
360 debug_write(__name__
, fn_attr(), ['TRUE,', width
, 'x', height
, 'is valid.', inFile
])
362 #print 'Not Tivo dimensions'
363 debug_write(__name__
, fn_attr(), ['FALSE,', width
, 'x', height
, 'not in supported modes.', inFile
])
366 def video_info(inFile
):
367 mtime
= os
.stat(inFile
).st_mtime
368 if inFile
!= videotest
:
369 if inFile
in info_cache
and info_cache
[inFile
][0] == mtime
:
370 debug_write(__name__
, fn_attr(), ['CACHE HIT!', inFile
])
371 return info_cache
[inFile
][1]
373 if (inFile
[-5:]).lower() == '.tivo':
374 info_cache
[inFile
] = (mtime
, (True, True, True, True, True, True, True, True, True, True, True))
375 debug_write(__name__
, fn_attr(), ['VALID, ends in .tivo.', inFile
])
376 return True, True, True, True, True, True, True, True, True, True, True
378 cmd
= [ffmpeg_path(), '-i', inFile
]
379 ffmpeg
= subprocess
.Popen(cmd
, stderr
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
, stdin
=subprocess
.PIPE
)
381 # wait 10 sec if ffmpeg is not back give up
382 for i
in xrange(200):
384 if not ffmpeg
.poll() == None:
387 if ffmpeg
.poll() == None:
389 info_cache
[inFile
] = (mtime
, (None, None, None, None, None, None, None, None, None, None, None))
390 return None, None, None, None, None, None, None, None, None, None, None
392 output
= ffmpeg
.stderr
.read()
393 debug_write(__name__
, fn_attr(), ['ffmpeg output=', output
])
395 rezre
= re
.compile(r
'.*Video: ([^,]+),.*')
396 x
= rezre
.search(output
)
400 info_cache
[inFile
] = (mtime
, (None, None, None, None, None, None, None, None, None, None, None))
401 debug_write(__name__
, fn_attr(), ['failed at video codec'])
402 return None, None, None, None, None, None, None, None, None, None, None
404 rezre
= re
.compile(r
'.*Video: .+, (\d+)x(\d+)[, ].*')
405 x
= rezre
.search(output
)
407 width
= int(x
.group(1))
408 height
= int(x
.group(2))
410 info_cache
[inFile
] = (mtime
, (None, None, None, None, None, None, None, None, None, None, None))
411 debug_write(__name__
, fn_attr(), ['failed at width/height'])
412 return None, None, None, None, None, None, None, None, None, None, None
414 rezre
= re
.compile(r
'.*Video: .+, (.+) (?:fps|tb).*')
415 x
= rezre
.search(output
)
419 info_cache
[inFile
] = (mtime
, (None, None, None, None, None, None, None, None, None, None, None))
420 debug_write(__name__
, fn_attr(), ['failed at fps'])
421 return None, None, None, None, None, None, None, None, None, None, None
423 # Allow override only if it is mpeg2 and frame rate was doubled to 59.94
424 if (not fps
== '29.97') and (codec
== 'mpeg2video'):
425 # First look for the build 7215 version
426 rezre
= re
.compile(r
'.*film source: 29.97.*')
427 x
= rezre
.search(output
.lower() )
429 debug_write(__name__
, fn_attr(), ['film source: 29.97 setting fps to 29.97'])
433 rezre
= re
.compile(r
'.*frame rate differs from container frame rate: 29.97.*')
434 debug_write(__name__
, fn_attr(), ['Bug in VideoReDo'])
435 x
= rezre
.search(output
.lower() )
439 durre
= re
.compile(r
'.*Duration: (.{2}):(.{2}):(.{2})\.(.),')
440 d
= durre
.search(output
)
442 millisecs
= ((int(d
.group(1))*3600) + (int(d
.group(2))*60) + int(d
.group(3)))*1000 + (int(d
.group(4))*100)
446 #get bitrate of source for tivo compatibility test.
447 rezre
= re
.compile(r
'.*bitrate: (.+) (?:kb/s).*')
448 x
= rezre
.search(output
)
453 debug_write(__name__
, fn_attr(), ['failed at kbps'])
455 #get audio bitrate of source for tivo compatibility test.
456 rezre
= re
.compile(r
'.*Audio: .+, (.+) (?:kb/s).*')
457 x
= rezre
.search(output
)
462 debug_write(__name__
, fn_attr(), ['failed at akbps'])
464 #get audio codec of source for tivo compatibility test.
465 rezre
= re
.compile(r
'.*Audio: ([^,]+),.*')
466 x
= rezre
.search(output
)
471 debug_write(__name__
, fn_attr(), ['failed at acodec'])
473 #get audio frequency of source for tivo compatibility test.
474 rezre
= re
.compile(r
'.*Audio: .+, (.+) (?:Hz).*')
475 x
= rezre
.search(output
)
480 debug_write(__name__
, fn_attr(), ['failed at afreq'])
483 rezre
= re
.compile(r
'.*Video: .+PAR ([0-9]+):([0-9]+) DAR [0-9:]+.*')
484 x
= rezre
.search(output
)
485 if x
and x
.group(1)!="0" and x
.group(2)!="0":
486 vpar
= float(x
.group(1))/float(x
.group(2))
491 rezre
= re
.compile(r
'.*Video: .+DAR ([0-9]+):([0-9]+).*')
492 x
= rezre
.search(output
)
493 if x
and x
.group(1)!="0" and x
.group(2)!="0":
494 vdar
= float(x
.group(1))/float(x
.group(2))
499 info_cache
[inFile
] = (mtime
, (codec
, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
))
500 debug_write(__name__
, fn_attr(), ['Codec=', codec
, ' width=', width
, ' height=', height
, ' fps=', fps
, ' millisecs=', millisecs
, ' kbps=', kbps
, ' akbps=', akbps
, ' acodec=', acodec
, ' afreq=', afreq
, ' par=', vpar
, ' dar=', vdar
])
501 return codec
, width
, height
, fps
, millisecs
, kbps
, akbps
, acodec
, afreq
, vpar
, vdar
503 def video_check(inFile
, cmd_string
):
504 cmd
= [ffmpeg_path(), '-i', inFile
] + cmd_string
.split()
505 ffmpeg
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
)
507 shutil
.copyfileobj(ffmpeg
.stdout
, open(videotest
, 'wb'))
513 def supported_format(inFile
):
514 if video_info(inFile
)[0]:
517 debug_write(__name__
, fn_attr(), ['FALSE, file not supported', inFile
])
521 debug_write(__name__
, fn_attr(), ['killing pid=', str(pid
)])
526 os
.kill(pid
, signal
.SIGTERM
)
530 handle
= ctypes
.windll
.kernel32
.OpenProcess(1, False, pid
)
531 ctypes
.windll
.kernel32
.TerminateProcess(handle
, -1)
532 ctypes
.windll
.kernel32
.CloseHandle(handle
)