def test_scale_convert(self):
config = ConvertConfig(scale=480)
with create_test_video(length=4, video_def=VideoDefinition(resolution=Resolution.HIGH_DEF)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.resolution, Resolution.STANDARD_DEF)
def test_video_remux(self):
config = convert_config_from_ns({'video_codec': 'copy'})
with create_test_video(length=3, video_def=VideoDefinition(codec=VideoCodec.MPEG2)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.video_streams[0].codec, VideoCodec.MPEG2.ffmpeg_codec_name)
def test_h265_1080p_5_1(self):
length = 3
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H265,
VideoFileContainer.MKV),
audio_defs=[
AudioDefition(AudioCodec.AAC,
AudioChannelName.SURROUND_5_1)
]) as file:
metadata = create_metadata_extractor().extract(file.name)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(1, len(metadata.audio_streams))
v = metadata.video_streams[0]
a = metadata.audio_streams[0]
self.assertEqual(VideoCodec.H265.ffmpeg_codec_name, v.codec)
self.assertEqual(length, v.duration)
self.assertEqual(Resolution.HIGH_DEF.width, v.width)
self.assertEqual(Resolution.HIGH_DEF.height, v.height)
self.assertEqual(AudioCodec.AAC.ffmpeg_codec_name, a.codec)
assertAudioLength(length, a.duration)
self.assertEqual(6, a.channels)
def test_not_h264(self):
with create_test_video(length=5, video_def=VideoDefinition(Resolution.LOW_DEF, VideoCodec.MPEG2,
VideoFileContainer.MP4)) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second:
with NamedTemporaryFile(suffix='.mp4') as output:
with self.assertRaises(expected_exception=Exception):
concat_mp4(output.name,
files=[first.name, second.name],
overwrite=True)
def test_defaults_convert(self):
config = convert_config_from_ns({})
with create_test_video(length=3, video_def=VideoDefinition(resolution=Resolution.LOW_DEF,
codec=VideoCodec.MPEG2),
audio_defs=[AudioDefition(codec=AudioCodec.AC3)]) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.resolution, Resolution.LOW_DEF)
self.assertEqual(metadata.video_streams[0].codec, VideoCodec.H264.ffmpeg_codec_name)
self.assertEqual(metadata.audio_streams[0].codec, AudioCodec.AAC.ffmpeg_codec_name)
def test_metadata_in_file(self):
meta = {'TestKey': 'test_value'}
length = 2
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H264,
VideoFileContainer.WTV),
metadata=meta) as file:
metadata = create_metadata_extractor().extract(file.name)
print(metadata.tags)
self.assertTrue('TestKey' in metadata.tags)
self.assertEqual('test_value', metadata.tags['TestKey'])
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H264,
VideoFileContainer.MKV),
metadata=meta) as file:
metadata = create_metadata_extractor().extract(file.name)
print(metadata.tags)
# MKV stores as uppercase
self.assertTrue('TESTKEY' in metadata.tags)
self.assertEqual('test_value', metadata.tags['TESTKEY'])
def test_mpeg2(self):
length = 5
with create_test_video(
length=length,
video_def=VideoDefinition(codec=VideoCodec.MPEG2)) as file:
metadata = create_metadata_extractor().extract(file.name, True)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(1, len(metadata.audio_streams))
self.assertFalse(metadata.interlace_report.is_interlaced())
v = metadata.video_streams[0]
a = metadata.audio_streams[0]
self.assertEqual(VideoCodec.MPEG2.ffmpeg_codec_name, v.codec)
self.assertEqual(length, v.duration)
self.assertEqual(Resolution.LOW_DEF.width, v.width)
self.assertEqual(Resolution.LOW_DEF.height, v.height)
self.assertEqual(AudioCodec.AAC.ffmpeg_codec_name, a.codec)
assertAudioLength(length, a.duration)
self.assertEqual(2, a.channels)
from media_management_scripts.support.encoding import VideoCodec, VideoFileContainer, Resolution, AudioCodec
from tests import create_test_video, VideoDefinition, assertAudioLength, AudioDefition
from media_management_scripts.support.concat_mp4 import concat_mp4
from media_management_scripts.utils import create_metadata_extractor
import unittest
from tempfile import NamedTemporaryFile
MP4_VIDEO_DEF = VideoDefinition(Resolution.LOW_DEF, VideoCodec.H264,
VideoFileContainer.MP4)
class ConcatMp4TestCase(unittest.TestCase):
def test_2_files(self):
with create_test_video(length=5, video_def=MP4_VIDEO_DEF) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second:
with NamedTemporaryFile(suffix='.mp4') as output:
concat_mp4(output.name,
files=[first.name, second.name],
overwrite=True)
metadata = create_metadata_extractor().extract(output.name)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(10, int(metadata.video_streams[0].duration))
self.assertEqual(1, len(metadata.audio_streams))
self.assertEqual('aac', metadata.audio_streams[0].codec)
self.assertEqual(2, metadata.audio_streams[0].channels)
assertAudioLength(10, metadata.audio_streams[0].duration)
def test_3_files(self):
with create_test_video(length=5, video_def=MP4_VIDEO_DEF) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second, \
import unittest
from tempfile import TemporaryDirectory, NamedTemporaryFile
import configparser
from media_management_scripts.support.encoding import DEFAULT_CRF, DEFAULT_PRESET
from media_management_scripts.support.executables import ccextractor, comskip
import os
from media_management_scripts.support.encoding import Resolution, VideoCodec, VideoFileContainer, AudioCodec, \
AudioChannelName
from tests import create_test_video, VideoDefinition, LOG_FILE
from unittest import mock
from media_management_scripts.silver_tube.processing import Configuration
from media_management_scripts.tvdb_api import TVDB
WTV_VIDEO_DEF = VideoDefinition(resolution=Resolution.STANDARD_DEF,
codec=VideoCodec.MPEG2,
container=VideoFileContainer.WTV)
class SilverTubeTestCase(unittest.TestCase):
def setUp(self):
self.files = []
self.dirs = []
self.config_file = NamedTemporaryFile(suffix='.ini', delete=False, mode='w')
db_file = NamedTemporaryFile(suffix='.sqlite3')
config = configparser.ConfigParser()
config['main'] = {
'debug': False,
'database.file': db_file.name,
'log.config': LOG_FILE
}
def test_deinterlace_convert(self):
config = ConvertConfig(deinterlace=True)
with create_test_video(length=10, video_def=VideoDefinition(codec=VideoCodec.MPEG2,
interlaced=True)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)