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')