public VideoFile Convert(string filename, string format) { var file = new VideoFile(filename); var sourceCodec = new CodecFactory().Extract(file); ICodec destinationCodec; if (format == "mp4") { destinationCodec = new Mpeg4CompressionCodec(); } else { destinationCodec = new OggCompressionCodec(); } var buffer = BitrateReader.Read(filename, sourceCodec); var result = BitrateReader.Convert(buffer, destinationCodec); result = new AudioMixer().Fix(result); return(new VideoFile(result)); }
public static void LoadAll(IHost host, ModelLoadContext ctx, int infoLim, out VBuffer <ReadOnlyMemory <char> >[] keyValues, out ColumnType[] kvTypes) { Contracts.AssertValue(host); host.AssertValue(ctx); using (var ch = host.Start("LoadTextValues")) { // Try to find the key names. VBuffer <ReadOnlyMemory <char> >[] keyValuesLocal = null; ColumnType[] kvTypesLocal = null; CodecFactory factory = null; const string dirFormat = "Vocabulary_{0:000}"; for (int iinfo = 0; iinfo < infoLim; iinfo++) { ctx.TryProcessSubModel(string.Format(dirFormat, iinfo), c => { // Load the lazily initialized structures, if needed. if (keyValuesLocal == null) { keyValuesLocal = new VBuffer <ReadOnlyMemory <char> > [infoLim]; kvTypesLocal = new ColumnType[infoLim]; factory = new CodecFactory(host); } Load(ch, c, factory, ref keyValuesLocal[iinfo]); kvTypesLocal[iinfo] = new VectorType(TextType.Instance, keyValuesLocal[iinfo].Length); }); } keyValues = keyValuesLocal; kvTypes = kvTypesLocal; ch.Done(); } }
public static void SaveAll(IHost host, ModelSaveContext ctx, int infoLim, VBuffer <ReadOnlyMemory <char> >[] keyValues) { Contracts.AssertValue(host); host.AssertValue(ctx); host.AssertValueOrNull(keyValues); if (keyValues == null) { return; } using (var ch = host.Start("SaveTextValues")) { // Save the key names as separate submodels. const string dirFormat = "Vocabulary_{0:000}"; CodecFactory factory = new CodecFactory(host); for (int iinfo = 0; iinfo < infoLim; iinfo++) { if (keyValues[iinfo].Length == 0) { continue; } ctx.SaveSubModel(string.Format(dirFormat, iinfo), c => Save(ch, c, factory, ref keyValues[iinfo])); } ch.Done(); } }
public virtual ActionResult Input() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = bodyStream.ReadToEndAsync().GetAwaiter().GetResult(); dynamic json = JsonConvert.DeserializeObject(bodyText); var action = CodecFactory.GetCodecAction((string)json.Action); // if action not found if (action == null) { return(Json(ReturnResult <string> .Fail("Action not found"))); } //TODO: add parameters var tile = Tile.FromStrings(new Triplet <string>( json.Inputs.X, json.Inputs.Y, json.Inputs.Z), new IntegerTileSerializer()); var result = action.DoAction(tile); return(Json(result.GetStrings(TileSerializerFactory.GetDefaultSerizlizer()))); } } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }
private ICodecFactory BuildFactory() { ICodecFactory codecFactory = new CodecFactory(); codecFactory.RegisterCodec(OpusDefaults.CodecId, new OpusSettings(), s => new OpusEncoder(s), s => new OpusDecoder(s)); return(codecFactory); }
static MusicFile() { soundOut = new DirectSoundOut(); codecFactory = CodecFactory.Instance; soundOut.Stopped += (sender, args) => { FileFinishedPlaying?.Invoke(LastFilePlayed); }; }
public void Container_GenericWriterUsingCodecFactoryWithNullCodecName() { const string WriterSchema = @"{ ""name"":""RecordContainingArray"", ""type"":""record"", ""fields"": [ {""name"":""IntField"", ""type"":""int""}, ] }"; var codecFactory = new CodecFactory(); using (AvroContainer.CreateGenericWriter(WriterSchema, this.resultStream, codecFactory.Create(null))) { } }
private void Initalize() { m_serializerFactory = new Ch.Elca.Iiop.Marshalling.SerializerFactory(); m_codecFactory = new CodecFactoryImpl(m_serializerFactory); m_argSerializerFactory = new Ch.Elca.Iiop.Marshalling.ArgumentsSerializerFactory(m_serializerFactory); Codec iiopUrlUtilCodec = m_codecFactory.create_codec( new Encoding(ENCODING_CDR_ENCAPS.ConstVal, 1, 2)); m_iiopUrlUtil = IiopUrlUtil.Create(iiopUrlUtilCodec, new object[] { Ch.Elca.Iiop.Services.CodeSetService.CreateDefaultCodesetComponent(iiopUrlUtilCodec) }); m_serializerFactory.Initalize(m_serializerFactoryConfig, m_iiopUrlUtil); }
public MKVFileSource(Document document) { _Document = document; _Segment = document.Segments[0]; //활성화된 트랙에서 필요한 코덱리스트를 생성 var codecs = CodecFactory.Create(_Segment.Tracks[0].TrackEntry.Where(x => x.FlagEnabled == 1).ToList()); //사용가능한 모든 코덱 추가 UsableCodecs = codecs.Where(x => x.IsSupported).Cast <KnownCodec>(); //사용가능한 미디어 코덱만 추가 UsableMediaCodecs = UsableCodecs.Where(x => x.CodecType == TrackTypes.Video || x.CodecType == TrackTypes.Audio); //사용가능한 자막 코덱 리스트를 생성 UsableSubtitleCodecs = UsableCodecs.Where(x => x.CodecType == TrackTypes.Subtitle); //디폴트 비디오 트랙의 코덱 var videoCodec = UsableMediaCodecs.FirstOrDefault(x => x.CodecType == TrackTypes.Video && x.TrackEntry.FlagDefault == 1); if (videoCodec == null) { videoCodec = UsableMediaCodecs.FirstOrDefault(x => x.CodecType == TrackTypes.Video); } var audioCodec = UsableMediaCodecs.FirstOrDefault(x => x.CodecType == TrackTypes.Audio && x.TrackEntry.FlagDefault == 1); if (audioCodec == null) { audioCodec = UsableMediaCodecs.FirstOrDefault(x => x.CodecType == TrackTypes.Audio); } //비디오나 오디오코덱을 사용할 수 없는 경우만 사용 불가능 코덱을 저장 if (videoCodec == null || audioCodec == null) { //사용 불가능한 미디어 코덱 저장 UnusableMediaCodecs = codecs.Where(x => !x.IsSupported && (x.CodecType == TrackTypes.Video || x.CodecType == TrackTypes.Audio)); } else { UnusableMediaCodecs = new List <ICodec>(); //디폴트 비디오/오디오 트랙으로 미디어 디스크립터 생성 CreateMediaStreamSource(audioCodec); } }
private static void Load(IChannel ch, ModelLoadContext ctx, CodecFactory factory, ref VBuffer <ReadOnlyMemory <char> > values) { Contracts.AssertValue(ch); ch.CheckValue(ctx, nameof(ctx)); ctx.CheckAtModel(GetVersionInfo()); // *** Binary format *** // Codec parameterization: A codec parameterization that should be a ReadOnlyMemory codec // int: n, the number of bytes used to write the values // byte[n]: As encoded using the codec // Get the codec from the factory, and from the stream. We have to // attempt to read the codec from the stream, since codecs can potentially // be versioned based on their parameterization. IValueCodec codec; // This *could* happen if we have an old version attempt to read a new version. // Enabling this sort of binary classification is why we also need to write the // codec specification. if (!factory.TryReadCodec(ctx.Reader.BaseStream, out codec)) { throw ch.ExceptDecode(); } ch.AssertValue(codec); ch.CheckDecode(codec.Type.IsVector); ch.CheckDecode(codec.Type.ItemType.IsText); var textCodec = (IValueCodec <VBuffer <ReadOnlyMemory <char> > >)codec; var bufferLen = ctx.Reader.ReadInt32(); ch.CheckDecode(bufferLen >= 0); using (var stream = new SubsetStream(ctx.Reader.BaseStream, bufferLen)) { using (var reader = textCodec.OpenReader(stream, 1)) { reader.MoveNext(); values = default(VBuffer <ReadOnlyMemory <char> >); reader.Get(ref values); } ch.CheckDecode(stream.ReadByte() == -1); } }
public virtual ActionResult Input() { dynamic json = GetJsonObject(Request.InputStream); var action = CodecFactory.GetCodecAction((string)json.Action); // if action not found if (action == null) { return(new HttpStatusCodeResult(HttpStatusCode.NotFound)); } //TODO: add parameters var tile = Tile.FromStrings(new Triplet <string>( json.Inputs.X, json.Inputs.Y, json.Inputs.Z), new IntegerTileSerializer()); var result = action.DoAction(tile); return(Json(result.GetStrings(TileSerializerFactory.GetDefaultSerizlizer()))); }
public FileInfo Convert(string fileName, string format) { var file = new VideoFile(fileName); var extractFile = new CodecFactory().ExtractFile(file); FileInfo fileInfo = new FileInfo(fileName); byte[] buff = new byte[] { Buffer.GetByte(new char[] { }, 0) }; var d = ToDouble(buff, 0); if (format == "mp4") { StreamWriter wr = StreamWriter.Null; wr.WriteLine(buff.ToString()); } else { buff = new[] { Buffer.GetByte(new byte[] { }, 0) }; StreamWriter wr = StreamWriter.Null; wr.WriteLine(buff.ToString()); } return(fileInfo); }
public AudioFile Convert(string fileName, string format) { var file = new AudioFile(fileName); var sourceCode = CodecFactory.Extract(file); Console.WriteLine(sourceCode); // you could implement switch case for different formats if (format == "mp3") { var destinationCodec = new MP3CompressionCodec(); var buffer = BitrateReader.read(fileName, sourceCode); Console.WriteLine(buffer); var result = BitrateReader.convert(buffer, destinationCodec); Console.WriteLine(result); result = (new AudioMixer()).fix(result); Console.WriteLine(result); Console.WriteLine("finishing your Audio convertor"); return(new AudioFile(result)); } Console.WriteLine("can't convert undefined format"); return(file); }
public void Container_GenericWriterUsingCodecFactoryWithInvalidCodecName() { Assert.Throws <ArgumentException>(() => { const string WriterSchema = @"{ ""name"":""RecordContainingArray"", ""type"":""record"", ""fields"": [ {""name"":""IntField"", ""type"":""int""}, ] }"; var codecFactory = new CodecFactory(); using (AvroContainer.CreateGenericWriter(WriterSchema, this.resultStream, codecFactory.Create("InvalidName"))) { } } ); }
static void Main(string[] args) { Cdr d = new Cdr(); d.setString(codecBinding.MessageType, "A"); d.setString(codecBinding.UserName, "username"); d.setString(codecBinding.Password, "password"); d.setString(codecBinding.NewPassword, "password1"); d.setInteger(codecBinding.MessageVersion, 0); Console.WriteLine(d.toString()); CodecFactory cf = new CodecFactory(); Codec lseCodec = cf.getCodec("lse"); Neueda.Codecs.Buffer b = lseCodec.encode(d); Console.WriteLine(b); Cdr decoded = lseCodec.decodeBuffer(b).getCdr(); Console.WriteLine(decoded.toString()); }
public FileInfo ConvertVideo(String fileName, String format) { Console.WriteLine("VideoConversionFacade: conversion started."); VideoFile file = new VideoFile(fileName); ICodec sourceCodec = CodecFactory.Extract(file); ICodec destinationCodec; if (format.Equals("mp4")) { destinationCodec = new OggCompressionCodec(); } else { destinationCodec = new MPEG4CompressionCodec(); } VideoFile buffer = BitrateReader.Read(file, sourceCodec); VideoFile intermediateResult = BitrateReader.Convert(buffer, destinationCodec); FileInfo result = (new AudioMixer()).Fix(intermediateResult); Console.WriteLine("VideoConversionFacade: conversion completed."); Console.ReadKey(); return(result); }
private bool read(int codecType, sceAtrac3plus.AtracFileInfo atracFileInfo) { codec = CodecFactory.getCodec(codecType); if (codec == null) { return(false); } int result = codec.init(atracFileInfo.atracBytesPerFrame, atracFileInfo.atracChannels, atracFileInfo.atracChannels, atracFileInfo.atracCodingMode); if (result < 0) { return(false); } AudioFormat audioFormat = new AudioFormat(44100, 16, atracFileInfo.atracChannels, true, false); DataLine.Info info = new DataLine.Info(typeof(SourceDataLine), audioFormat); try { mLine = (SourceDataLine)AudioSystem.getLine(info); mLine.open(audioFormat); } catch (LineUnavailableException) { return(false); } mLine.start(); inputOffset = atracFileInfo.inputFileDataOffset; inputPosition = inputOffset; inputBytesPerFrame = atracFileInfo.atracBytesPerFrame; channels = atracFileInfo.atracChannels; return(true); }
internal ORBInitInfoImpl(OrbServices orb) { m_orb = orb; m_manager = orb.InterceptorManager; m_codecFactory = orb.CodecFactory; }
private static void Save(IChannel ch, ModelSaveContext ctx, CodecFactory factory, ref VBuffer <ReadOnlyMemory <char> > values) { Contracts.AssertValue(ch); ch.CheckValue(ctx, nameof(ctx)); ctx.CheckAtModel(); ctx.SetVersionInfo(GetVersionInfo()); // *** Binary format *** // Codec parameterization: A codec parameterization that should be a ReadOnlyMemory codec // int: n, the number of bytes used to write the values // byte[n]: As encoded using the codec // Get the codec from the factory IValueCodec codec; var result = factory.TryGetCodec(new VectorType(TextType.Instance), out codec); ch.Assert(result); ch.Assert(codec.Type.IsVector); ch.Assert(codec.Type.VectorSize == 0); ch.Assert(codec.Type.ItemType.RawType == typeof(ReadOnlyMemory <char>)); IValueCodec <VBuffer <ReadOnlyMemory <char> > > textCodec = (IValueCodec <VBuffer <ReadOnlyMemory <char> > >)codec; factory.WriteCodec(ctx.Writer.BaseStream, codec); using (var mem = new MemoryStream()) { using (var writer = textCodec.OpenWriter(mem)) { writer.Write(ref values); writer.Commit(); } ctx.Writer.WriteByteArray(mem.ToArray()); } // Make this resemble, more or less, the auxiliary output from the TermTransform. // It will differ somewhat due to the vector being possibly sparse. To distinguish // between missing and empty, empties are not written at all, while missings are. var v = values; char[] buffer = null; ctx.SaveTextStream("Terms.txt", writer => { writer.WriteLine("# Number of terms = {0} of length {1}", v.Count, v.Length); foreach (var pair in v.Items()) { var text = pair.Value; if (text.IsEmpty) { continue; } writer.Write("{0}\t", pair.Key); // REVIEW: What about escaping this, *especially* for linebreaks? // Do C# and .NET really have no equivalent to Python's "repr"? :( if (text.IsEmpty) { writer.WriteLine(); continue; } Utils.EnsureSize(ref buffer, text.Length); var span = text.Span; for (int i = 0; i < text.Length; i++) { buffer[i] = span[i]; } writer.WriteLine(buffer, 0, text.Length); } }); }
internal GiopMessageBodySerialiser(ArgumentsSerializerFactory argSerFactory) { m_serFactory = argSerFactory.SerializerFactory; m_argSerFactory = argSerFactory; m_codecFactory = new CodecFactoryImpl(m_serFactory); }
protected virtual void RegisterFactory(CodecFactory factory) { this.factories.Add(factory); }
private void Initalize() { m_serializerFactory = new Ch.Elca.Iiop.Marshalling.SerializerFactory(); m_codecFactory = new CodecFactoryImpl(m_serializerFactory); m_argSerializerFactory = new Ch.Elca.Iiop.Marshalling.ArgumentsSerializerFactory(m_serializerFactory); Codec iiopUrlUtilCodec = m_codecFactory.create_codec( new Encoding(ENCODING_CDR_ENCAPS.ConstVal, 1, 2)); m_iiopUrlUtil = IiopUrlUtil.Create(iiopUrlUtilCodec, new object[] { Ch.Elca.Iiop.Services.CodeSetService.CreateDefaultCodesetComponent(iiopUrlUtilCodec)}); m_serializerFactory.Initalize(m_serializerFactoryConfig, m_iiopUrlUtil); }
public virtual void initCodec(int codecType) { codec = CodecFactory.getCodec(codecType); CodecInitialized = false; }
public ChoAvroReader <T> WithCodecFactory(CodecFactory cf) { Configuration.CodecFactory = cf; return(this); }
public static object Read(string filename, CodecFactory sourceCodec) { throw new System.NotImplementedException(); }