def MpegFiles():
the_set = optimizer.FileAndRateSet()
my_directory = 'video/mpeg_video'
# Class A
the_set.AddFilesAndRates(["Kimono1_1920x1080_24.yuv",
"ParkScene_1920x1080_24.yuv"],
[1600, 2500, 4000, 6000],
my_directory)
# Class B
the_set.AddFilesAndRates(["Cactus_1920x1080_50.yuv",
"BasketballDrive_1920x1080_50.yuv"],
[3000, 4500, 7000, 10000],
my_directory)
# Class C
the_set.AddFilesAndRates(["BasketballDrill_832x480_50.yuv",
"BQMall_832x480_60.yuv",
"PartyScene_832x480_50.yuv",
"RaceHorses_832x480_30.yuv"],
[512, 768, 1200, 2000],
my_directory)
# Class D
the_set.AddFilesAndRates(["FourPeople_1280x720_60.yuv",
"Johnny_1280x720_60.yuv",
"KristenAndSara_1280x720_60.yuv"],
[384, 512, 850, 1500],
my_directory)
return the_set
def test_BestOverallConfiguration(self):
self.file_set = optimizer.FileAndRateSet(verify_files_present=False)
self.file_set.AddFilesAndRates([self.videofile.filename], [100, 200])
my_optimizer = self.StdOptimizer()
# When there is nothing in the database, None should be returned.
best_encoder = my_optimizer.BestOverallEncoder()
self.assertIsNone(best_encoder)
# Fill in the database with all the files and rates.
my_encoder = self.EncoderFromParameterString('--score=7')
for rate, filename in self.file_set.AllFilesAndRates():
my_encoder.Encoding(rate,
encoder.Videofile(filename)).Execute().Store()
best_encoder = my_optimizer.BestOverallEncoder()
self.assertTrue(best_encoder)
self.assertEquals(my_encoder.parameters.ToString(),
best_encoder.parameters.ToString())
# Add an incomplete encode. This should be ignored.
(self.EncoderFromParameterString('--score=9').Encoding(
100, self.videofile).Execute().Store())
best_encoder = my_optimizer.BestOverallEncoder()
self.assertTrue(best_encoder)
self.assertEquals(my_encoder.parameters.ToString(),
best_encoder.parameters.ToString())
# Complete the set for 'score=9'. This should cause a change.
(self.EncoderFromParameterString('--score=9').Encoding(
200, self.videofile).Execute().Store())
best_encoder = my_optimizer.BestOverallEncoder()
self.assertTrue(best_encoder)
self.assertEquals('--score=9', best_encoder.parameters.ToString())
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 OldMpegFiles():
the_set = optimizer.FileAndRateSet()
my_directory = 'video/mpeg_video'
# Class A
the_set.AddFilesAndRates([
"Traffic_2560x1600_30_crop.yuv", "PeopleOnStreet_2560x1600_30_crop.yuv"
], [2500, 3500, 5000, 8000, 14000], my_directory)
# Class B1
the_set.AddFilesAndRates(
["Kimono1_1920x1080_24.yuv", "ParkScene_1920x1080_24.yuv"],
[1000, 1600, 2500, 4000, 6000], my_directory)
# Class B2
the_set.AddFilesAndRates(
["Cactus_1920x1080_50.yuv", "BasketballDrive_1920x1080_50.yuv"],
[2000, 3000, 4500, 7000, 10000], my_directory)
# Class C
the_set.AddFilesAndRates([
"BasketballDrill_832x480_50.yuv", "BQMall_832x480_60.yuv",
"PartyScene_832x480_50.yuv", "RaceHorses_832x480_30.yuv"
], [384, 512, 768, 1200, 2000], my_directory)
# Class D
the_set.AddFilesAndRates([
"BasketballPass_416x240_50.yuv", "BlowingBubbles_416x240_50.yuv",
"RaceHorses_416x240_30.yuv"
], [256, 384, 512, 850, 1500], my_directory)
# Class E
the_set.AddFilesAndRates([
"FourPeople_1280x720_60.yuv", "Johnny_1280x720_60.yuv",
"KristenAndSara_1280x720_60.yuv"
], [256, 384, 512, 850, 1500], my_directory)
return the_set
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 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_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_TwoAddCalls(self):
the_set = optimizer.FileAndRateSet()
the_set.AddFilesAndRates(['filename'], [100, 200], 'dirname')
the_set.AddFilesAndRates(['otherfilename'], [200, 300], 'dirname')
self.assertEqual(set([(100, 'dirname/filename'),
(200, 'dirname/filename'),
(200, 'dirname/otherfilename'),
(300, 'dirname/otherfilename')]),
set(the_set.AllFilesAndRates()))
def GenerateFilesetFromDirectory(name):
"""Returns a FileAndRateSet containing all the YUV files in the directory."""
yuvfiles = glob.glob(os.path.join(os.getenv('WORKDIR'),
'video', name, '*.yuv'))
my_set = optimizer.FileAndRateSet()
for yuvfile in yuvfiles:
videofile = encoder.Videofile(yuvfile)
my_set.AddFilesAndRates([videofile.filename],
ChooseRates(videofile.width, videofile.framerate))
return my_set
def TestFileSet():
"""Returns a file set containing a file with one black frame.
Creates the file as a side effect."""
the_set = optimizer.FileAndRateSet()
filename = 'one_black_frame_1024_768_30.yuv'
MakeYuvFileWithOneBlankFrame(filename)
my_directory = encoder_configuration.conf.workdir()
the_set.AddFilesAndRates([filename], [300, 1000, 3000], my_directory)
return the_set
def TestFileSet():
"""Returns a file set containing a file with one black frame.
Creates the file as a side effect."""
the_set = optimizer.FileAndRateSet()
filename = 'one_black_frame_1024_768_30.yuv'
MakeYuvFileWithOneBlankFrame(filename)
my_directory = os.environ['CODEC_WORKDIR']
the_set.AddFilesAndRates([filename],
[300, 1000, 3000],
my_directory)
return the_set
def test_EncodingGoodOnOtherRate(self):
self.file_set = optimizer.FileAndRateSet(verify_files_present=False)
self.file_set.AddFilesAndRates([self.videofile.filename], [100, 200])
my_optimizer = self.StdOptimizer()
my_encoder = self.EncoderFromParameterString('--score=7')
my_encoder.Encoding(100, self.videofile).Execute().Store()
first_encoder = self.EncoderFromParameterString('--score=8')
first_encoding = first_encoder.Encoding(200, self.videofile)
first_encoding.Execute().Store()
# pylint: disable=W0212
next_encoding = my_optimizer._EncodingGoodOnOtherRate(
first_encoding, 200, self.videofile, None)
self.assertTrue(next_encoding)
self.assertEqual('--score=7',
next_encoding.encoder.parameters.ToString())
def __init__(self, filename, codec, score_function):
self.name = codec.name
self.videofile = encoder.Videofile(filename)
self.fileset = optimizer.FileAndRateSet()
self.fileset.AddFilesAndRates([filename],
fileset_picker.ChooseRates(
self.videofile.width,
self.videofile.framerate))
self.my_optimizer = optimizer.Optimizer(codec,
file_set=self.fileset,
score_function=score_function)
self.filename = filename
self.encoder = self.my_optimizer.BestOverallEncoder()
if not self.encoder:
raise NotEnoughDataError('No overall encoder for %s on %s' %
(codec.name, filename))
self.points = None
def test_RatesForFile(self):
the_set = optimizer.FileAndRateSet()
the_set.AddFilesAndRates(['filename'], [100, 200])
the_set.AddFilesAndRates(['otherfilename'], [200, 300])
self.assertEqual(set([100, 200]),
set(the_set.AllRatesForFile('filename')))
def test_OneFileMultipleRates(self):
the_set = optimizer.FileAndRateSet()
the_set.AddFilesAndRates(['filename'], [100, 200], 'dirname')
self.assertEqual(set([(100, 'dirname/filename'),
(200, 'dirname/filename')]),
set(the_set.AllFilesAndRates()))
def test_NoDirName(self): the_set = optimizer.FileAndRateSet() the_set.AddFilesAndRates(['filename'], [100]) self.assertEqual([(100, 'filename')], the_set.AllFilesAndRates())
def test_OneFileAddedAndReturned(self): the_set = optimizer.FileAndRateSet() the_set.AddFilesAndRates(['filename'], [100], 'dirname') self.assertEqual([(100, 'dirname/filename')], the_set.AllFilesAndRates())
def test_AddMissingFile(self):
the_set = optimizer.FileAndRateSet()
the_set.AddFilesAndRates(['nosuchfile'], [100])
self.assertFalse(the_set.AllFilesAndRates())
self.assertFalse(the_set.set_is_complete)
