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 testReadResultWithoutFrameData(self):
context = encoder.Context(DummyCodec())
my_encoder = context.codec.StartEncoder(context)
videofile = DummyVideofile('foofile_640_480_30.yuv', clip_time=1)
encoding = my_encoder.Encoding(1000, videofile)
encoding.result = {'foo': 5, 'frame': ['first', 'second']}
self.assertEqual({'foo': 5}, encoding.ResultWithoutFrameData())
def test_BestOverallConfigurationNotInWorkDirectory(self):
other_dir = os.path.join(encoder_configuration.conf.sysdir(),
'multirepo_test')
os.mkdir(other_dir)
encoder_configuration.conf.override_scorepath_for_test([other_dir])
self.file_set = optimizer.FileAndRateSet(verify_files_present=False)
self.file_set.AddFilesAndRates([self.videofile.filename], [100, 200])
self.optimizer = optimizer.Optimizer(self.codec, self.file_set)
# When there is nothing in the database, None should be returned.
best_encoder = self.optimizer.BestOverallEncoder()
self.assertIsNone(best_encoder)
# Fill in the database with all the files and rates.
other_context = encoder.Context(self.codec,
encoder.EncodingDiskCache,
scoredir='multirepo_test')
my_encoder = self.EncoderFromParameterString('--score=7')
other_context.cache.StoreEncoder(my_encoder)
my_encoder.context.cache.StoreEncoder(my_encoder)
for rate, filename in self.file_set.AllFilesAndRates():
my_encoding = my_encoder.Encoding(rate,
encoder.Videofile(filename))
my_encoding.Execute()
other_context.cache.StoreEncoding(my_encoding)
# The best encoder should now be from the workdir, but the results are
# all fetched from the searchpath.
best_encoder = self.optimizer.BestOverallEncoder()
self.assertTrue(best_encoder)
self.assertEquals(my_encoder.parameters.ToString(),
best_encoder.parameters.ToString())
one_encoding = best_encoder.Encoding(100, self.videofile)
one_encoding.Recover()
self.assertTrue(one_encoding.Result())
def test_Changevalue(self):
config = encoder.OptionValueSet(
encoder.OptionSet(encoder.Option('foo', ['foo', 'bar'])),
'--foo=foo')
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(context, config)
next_encoder = my_encoder.ChangeValue('foo', 'bar')
self.assertEquals(next_encoder.parameters, '--foo=bar')
def test_ParametersCanChangeMayReturnTrue(self):
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(
context,
encoder.OptionValueSet(
encoder.OptionSet(encoder.Option('key', ['value1', 'value2'])),
'--parameters'))
self.assertTrue(my_encoder.ParametersCanChange())
def testInitFromFile(self):
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(
context, encoder.OptionValueSet(encoder.OptionSet(),
'--parameters'))
my_encoder.Store()
new_encoder = encoder.Encoder(context, filename=my_encoder.Hashname())
self.assertEquals(new_encoder.parameters, my_encoder.parameters)
def __init__(self, codec, file_set=None,
cache_class=None, score_function=None,
scoredir=None):
# pylint: disable=too-many-arguments
self.context = encoder.Context(codec,
cache_class or encoder.EncodingDiskCache,
scoredir=scoredir)
self.file_set = file_set
self.score_function = score_function or score_tools.ScorePsnrBitrate
def __init__(self,
codec,
file_set=None,
cache_class=None,
score_function=None):
self.context = encoder.Context(
codec, cache_class or encoder.EncodingDiskCache)
self.file_set = file_set
self.score_function = score_function or score_tools.ScorePsnrBitrate
def testGenerateSomeUntriedVariants(self):
context = encoder.Context(DummyCodec())
my_encoder = context.codec.StartEncoder(context)
videofile = DummyVideofile('foofile_640_480_30.yuv', clip_time=1)
encoding = my_encoder.Encoding(1000, videofile)
# The dummy codec has a parameter with multiple possible values,
# so at least some variants should be returned.
variants = encoding.SomeUntriedVariants()
self.assertTrue(variants)
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_ParametersCanBeStoredAndRetrieved(self):
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(
context, encoder.OptionValueSet(encoder.OptionSet(),
'--parameters'))
my_encoder.Store()
filename = my_encoder.Hashname()
next_encoder = encoder.Encoder(context, filename=filename)
self.assertEqual(my_encoder.parameters, next_encoder.parameters)
def test_OptionValues(self):
codec = DummyCodec()
my_encoder = encoder.Encoder(
encoder.Context(codec),
encoder.OptionValueSet(
encoder.OptionSet(encoder.IntegerOption('score', 0, 100)),
'--score=77'))
self.assertEqual(repr(my_encoder.OptionValues()), "{'score': '77'}")
self.assertEqual(my_encoder.DisplayValues(), '77')
def test_DistinctWorkdirs(self):
seen_dirs = set()
for codec_name in pick_codec.AllCodecNames():
codec = pick_codec.PickCodec(codec_name)
context = encoder.Context(codec)
workdir = os.path.abspath(context.cache.WorkDir())
self.assertNotIn(
workdir, seen_dirs,
'Duplicate workdir %s for codec %s' % (workdir, codec_name))
seen_dirs.add(workdir)
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 testInitFromBrokenFile(self):
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(
context, encoder.OptionValueSet(encoder.OptionSet(),
'--parameters'))
my_encoder.Store()
# Break stored object. Note: This uses knowledge of the memory cache.
old_filename = my_encoder.Hashname()
parameters = context.cache.encoders[old_filename].parameters
parameters.other_parts.append('--extra-stuff')
# Now Hashname() should return a different value.
with self.assertRaisesRegexp(encoder.Error,
'contains wrong arguments'):
# pylint: disable=W0612
new_encoder = encoder.Encoder(context, filename=old_filename)
def testGenerateUntriedVariantsUntilNoneFound(self):
context = encoder.Context(DummyCodec())
my_encoder = context.codec.StartEncoder(context)
videofile = DummyVideofile('foofile_640_480_30.yuv', clip_time=1)
encoding = my_encoder.Encoding(1000, videofile)
variants = encoding.SomeUntriedVariants()
# Keep generating variants until we run out. This should happen
# after 3 variants for the Dummy codec.
variant_count = 0
while variants:
for variant in variants:
variant.Execute().Store()
variant_count += 1
variants = encoding.SomeUntriedVariants()
# We cannot guarantee that all 3 are found, since the process
# is random, but no more than 3 should be found.
self.assertGreaterEqual(3, variant_count)
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')
def test_ParametersCanChangeMayReturnFalse(self):
context = encoder.Context(DummyCodec())
my_encoder = encoder.Encoder(
context, encoder.OptionValueSet(encoder.OptionSet(),
'--parameters'))
self.assertFalse(my_encoder.ParametersCanChange())
