def test_LinearRegressionDifference(self):
fileobject = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
fileset = optimizer.FileAndRateSet()
fileset.AddFilesAndRates([fileobject.filename],
fileset_picker.ChooseRates(fileobject.width,
fileobject.framerate))
context1 = encoder.Context(FakeCodec1(), encoder.EncodingDiskCache)
encoder1 = context1.codec.StartEncoder(context1)
# Produce two straight lines, one using 50% more bits than the others.
for rate in fileset.AllRatesForFile(fileobject.filename):
encoding = encoder1.Encoding(rate, fileobject)
encoding.result = {'bitrate': rate, 'psnr': rate / 10}
encoding.Store()
context2 = encoder.Context(FakeCodec2(), encoder.EncodingDiskCache)
encoder2 = context2.codec.StartEncoder(context2)
for rate in fileset.AllRatesForFile(fileobject.filename):
encoding = encoder2.Encoding(rate, fileobject)
encoding.result = {'bitrate': rate * 1.5, 'psnr': rate / 10}
encoding.Store()
score = graph_metrics.BdRateAnalysis(fileobject.filename,
(FakeCodec1(), FakeCodec2()),
score_tools.ScorePsnrBitrate)
self.assertEqual('mock2', score.score()[0][0])
self.assertAlmostEqual(50.0, score.score()[0][1]['difference'])
def testPickLocalVideoDirectory(self):
os.mkdir(os.path.join(os.getenv('WORKDIR'), 'video'))
os.mkdir(os.path.join(os.getenv('WORKDIR'), 'video', 'local'))
test_tools.MakeYuvFileWithOneBlankFrame(
'video/local/one_black_frame_1024_768_30.yuv')
fileset = fileset_picker.PickFileset('local')
self.assertEquals(4, len(fileset.AllFilesAndRates()))
def test_EmptyDirectory(self):
fileobject = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
with self.assertRaises(graph_metrics.NotEnoughDataError):
graph_metrics.BdRateAnalysis(fileobject.filename,
(FakeCodec1(), FakeCodec2()),
score_tools.ScorePsnrBitrate)
def test_AddPresentFile(self):
the_set = optimizer.FileAndRateSet()
file_name = 'file_1024_768_30.yuv'
test_tools.MakeYuvFileWithOneBlankFrame(file_name)
the_set.AddFilesAndRates([file_name], [100],
basedir=os.getenv('CODEC_WORKDIR'))
self.assertTrue(the_set.AllFilesAndRates())
self.assertTrue(the_set.set_is_complete)
def test_VerifyCorruptedFile(self):
codec = CorruptingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
self.assertFalse(encoding.VerifyEncode())
def test_OneBlackFrame(self):
codec = CopyingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
self.assertTrue(encoding.Result())
def test_AddPresentFile(self):
the_set = optimizer.FileAndRateSet()
file_name = 'file_1024_768_30.yuv'
test_tools.MakeYuvFileWithOneBlankFrame(file_name)
the_set.AddFilesAndRates([file_name], [100],
basedir=encoder_configuration.conf.workdir())
self.assertTrue(the_set.AllFilesAndRates())
self.assertTrue(the_set.set_is_complete)
def test_OneBlackFrame(self):
codec = mjpeg.MotionJpegCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
# Motion JPEG generates a massive file, so give it a large target bitrate.
encoding = my_optimizer.BestEncoding(5000, videofile)
encoding.Execute()
self.assertLess(50.0, my_optimizer.Score(encoding))
def test_OneBlackFrame(self):
codec = vp8_mpeg.Vp8CodecMpegMode()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Most codecs should be good at this.
self.assertLess(50.0, my_optimizer.Score(encoding))
def test_HasBaselineFlag(self):
codec = x264_baseline.X264BaselineCodec()
context = encoder.Context(codec)
my_encoder = codec.StartEncoder(context)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_encoder.Encoding(1000, videofile)
commandline = encoding.EncodeCommandLine()
self.assertRegexpMatches(commandline, '--profile baseline ')
def test_OneBlackFrame(self):
codec = h261.H261Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# H.261 does badly at generating a black frame. Bug?
self.assertLess(48.0, my_optimizer.Score(encoding))
def test_SuggestedTweakRefersToSameContext(self):
codec = vp8_mpeg.Vp8CodecMpegMode()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
# Fake result.
encoding.result = {'psnr': 42.0, 'bitrate': 1000}
next_encoding = codec.SuggestTweak(encoding)
self.assertEqual(encoding.context, next_encoding.context)
def test_VerifyMd5Varies(self):
codec = CorruptingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
first_md5 = encoding.Result()['yuv_md5']
encoding.Execute()
self.assertNotEqual(first_md5, encoding.Result()['yuv_md5'])
def test_VerifyMatroskaFile(self):
codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Matroska files will be identical if generated within the same
# clock second. So wait a bit.
time.sleep(1)
self.assertTrue(encoding.VerifyEncode())
def test_ParametersSet(self):
codec = mjpeg.MotionJpegCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
my_encoder = encoder.Encoder(
my_optimizer.context,
encoder.OptionValueSet(codec.option_set,
'-qmin 1 -qmax 1',
formatter=codec.option_formatter))
encoding = my_encoder.Encoding(5000, videofile)
encoding.Execute()
self.assertLess(50.0, my_optimizer.Score(encoding))
def test_FfmpegFrameInfo(self):
codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# This line comes from file_codec.Execute()
encodedfile = '%s/%s.%s' % (encoding.Workdir(), videofile.basename,
codec.extension)
frameinfo = file_codec.FfmpegFrameInfo(encodedfile)
self.assertEquals(len(frameinfo), 1)
self.assertGreater(
os.path.getsize(encodedfile) * 8, frameinfo[0]['size'])
def test_OneBlackFrame(self):
codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Most codecs should be good at this.
self.assertLess(50.0, my_optimizer.Score(encoding))
self.assertEqual(1, len(encoding.result['frame']))
# Check that expected results are present and "reasonable".
print encoding.result
self.assertTrue(0.01 < encoding.result['encode_cputime'] < 0.7)
self.assertTrue(400 < encoding.result['bitrate'] < 500)
self.assertTrue(10000 < encoding.result['frame'][0]['size'] < 12000)
def test_Threading(self):
codec = x264.X264Codec()
context = encoder.Context(codec, encoder.EncodingDiskCache)
one_thread_encoder = codec.StartEncoder(context).ChangeValue(
'threads', 1)
two_thread_encoder = codec.StartEncoder(context).ChangeValue(
'threads', 2)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
one_encoding = one_thread_encoder.Encoding(1000, videofile)
one_encoding.Execute()
two_encoding = two_thread_encoder.Encoding(1000, videofile)
two_encoding.Execute()
self.assertAlmostEquals(float(one_encoding.Result()['psnr']),
float(two_encoding.Result()['psnr']))
def test_Passes(self):
"""This test checks that both 1-pass and 2-pass encoding works."""
codec = vp9.Vp9Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
start_encoder = codec.StartEncoder(my_optimizer.context)
encoder1 = encoder.Encoder(
my_optimizer.context,
start_encoder.parameters.ChangeValue('passes', 1))
encoding1 = encoder1.Encoding(1000, videofile)
encoder2 = encoder.Encoder(
my_optimizer.context,
start_encoder.parameters.ChangeValue('passes', 2))
encoding2 = encoder2.Encoding(1000, videofile)
encoding1.Execute()
encoding2.Execute()
self.assertTrue(encoding1.result)
self.assertTrue(encoding2.result)
def test_VbvMaxrateFlag(self):
codec = x264.X264Codec()
context = encoder.Context(codec)
my_encoder = codec.StartEncoder(context)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_encoder.Encoding(1000, videofile)
# The start encoder should have no bitrate.
commandline = encoding.EncodeCommandLine()
self.assertNotRegexpMatches(commandline, 'vbv-maxrate')
# Add in the use-vbv-maxrate parameter.
new_encoder = encoder.Encoder(
context,
my_encoder.parameters.ChangeValue('use-vbv-maxrate',
'use-vbv-maxrate'))
encoding = new_encoder.Encoding(1000, videofile)
commandline = encoding.EncodeCommandLine()
# vbv-maxrate should occur, but not use-vbv-maxrate.
self.assertRegexpMatches(commandline, '--vbv-maxrate 1000 ')
self.assertNotRegexpMatches(commandline, 'use-vbv-maxrate')
