public DataFormat(CodecID dataFormat, bool isH264AVCC) { _name = dataFormat.GetName(); _descriptiveName = dataFormat.GetDescriptiveName(); _outputFileExtension = dataFormat.GetOutputFileExtension(); _isH264AVCC = isH264AVCC; }
private void defaultCodecHeaderManager_CodecHeaderChanged(CodecID changedCodecId, EventArgs e) { if (_currentThumbSource != null && _currentThumbSource.Length > 0 && _currentThumbSource[0].DataFormat == changedCodecId) { ReloadAllThumbs(); } }
static MockConfigurableDetector() { _supportedFormats = new CodecID[] { }; Configurable = new Configurable <ConfigurationKey>(); Configurable.Add(ConfigurationKey.Key1, 123); }
private static IntPtr Create(Context context, CodecID codecID, ProductionNode initializer) { IntPtr nodeHandle; UInt32 status = OpenNIImporter.xnCreateCodec(context.InternalObject, codecID.InternalValue, initializer.InternalObject, out nodeHandle); WrapperUtils.CheckStatus(status); return nodeHandle; }
internal DataBlock(DataBlockBuilder builder) { _appendDataPackets = builder._appendDataPackets; _dataFormat = builder.DataFormat; _detectors = builder.Detectors; _inputFile = builder.InputFile; _startOffset = builder.StartOffset; _endOffset = builder.EndOffset; _isFullFile = builder.IsFullFile; _referenceHeaderOffset = builder.ReferenceHeaderOffset; _referenceHeader = builder.ReferenceHeader; _codecStreams = builder.BuildCodecStreams(this); IsFragmented = builder.IsFragmented; // Check for previous fragment and connect if one exists IFragment previousFragment = builder.PreviousFragment; if ((previousFragment != null) && previousFragment.IsFragmented) { if (previousFragment.FragmentContainer == null) { previousFragment.FragmentContainer = new FragmentContainer(); previousFragment.FragmentContainer.Add(previousFragment); } FragmentContainer = previousFragment.FragmentContainer; FragmentContainer.Add(this); FragmentIndex = previousFragment.FragmentIndex + 1; } }
private void UpdateFileList() { listAvailableReferenceFiles.DataSource = null; if (_projectManager.Project == null) { return; } DataGridViewSelectedRowCollection rows = selectProjectDefaultCodecHeaders.SelectedRows; if (rows.Count == 1) { CodecID selectedCodec = (CodecID)rows[0].Cells[0].Value; List <FileListItem> possibleFileList = new List <FileListItem>(); IEnumerable <IInputFile> detectedFiles = _projectManager.Project.GetInputFiles().Sort("Name", ListSortDirection.Ascending);; foreach (InputFile detectedFile in detectedFiles) { if (CheckCodecDetectorResultForFile(detectedFile, selectedCodec)) { possibleFileList.Add(new FileListItem(detectedFile)); } } listAvailableReferenceFiles.DataSource = possibleFileList; } }
private static IntPtr Create(Context context, CodecID codecID, ProductionNode initializer) { IntPtr nodeHandle; int status = SafeNativeMethods.xnCreateCodec(context.InternalObject, codecID.InternalValue, initializer.InternalObject, out nodeHandle); WrapperUtils.ThrowOnError(status); return nodeHandle; }
public IResultNode GetHeaderSourceForCodec(CodecID codecId) { IResultNode headerNode; _codecHeaderSource.TryGetValue(codecId, out headerNode); return(headerNode); }
private void defaultCodecHeaderManager_CodecHeaderChanged(CodecID changedCodecId, EventArgs e) { if (_activeFrameSourceNode != null && _activeFrameSourceNode.DataFormat == changedCodecId) { ReloadFramePreview(); } }
internal CodecStream(CodecStreamBuilder builder) { _dataFormat = builder.DataFormat; _detector = builder.Detector; _dataPacket = builder.Data; _streamNumber = builder.StreamNumber; _name = RemoveIllegalCharatersForXml(builder.Name); _dataBlock = builder.DataBlock; _absoluteStartOffset = builder.AbsoluteStartOffset; _referenceHeaderOffset = builder.ReferenceHeaderOffset; _referenceHeader = builder.ReferenceHeader; IsFragmented = builder.IsFragmented; // Check for previous fragment and connect if one exists IFragment previousFragment = builder.PreviousFragment; if ((previousFragment != null) && previousFragment.IsFragmented) { FragmentContainer = previousFragment.FragmentContainer; if (FragmentContainer == null) { FragmentContainer = new FragmentContainer(); FragmentContainer.Add(previousFragment); previousFragment.FragmentContainer = FragmentContainer; } FragmentContainer.Add(this); FragmentIndex = previousFragment.FragmentIndex + 1; } }
public bool RunSearchHeader(IInputFile inputFile, CodecID codecId) { IProject project = inputFile.Project; IList <IDataBlock> dataBlocks = project.GetDataBlocks(inputFile); if (dataBlocks.Count > 0) { foreach (IDataBlock dataBlock in dataBlocks) { if (DataBlockHasCodec(dataBlock, codecId)) { if (dataBlock.CodecStreams.Count > 0) { return(SearchBlockOrStream(dataBlock.CodecStreams, SearchMode.CodecStream)); } else { return(SearchBlockOrStream(dataBlock, SearchMode.DataBlock)); } } } MessageBox.Show(this, "Selected codec stream was not found in file. Please select a different header source.", "Couldn't find detector.", MessageBoxButtons.OK, MessageBoxIcon.Error); Close(); } else { MessageBox.Show(this, "No datablocks are available. Please select a different header source.", "Couldn't detect keyframe.", MessageBoxButtons.OK, MessageBoxIcon.Error); Close(); } return(false); }
private static bool CheckCodecDetectorResultForFile(IInputFile detectedFile, CodecID selectedCodec) { IList <IDataBlock> dataBlocks = detectedFile.Project.GetDataBlocks(detectedFile); foreach (IDataBlock fileDataBlock in dataBlocks) { if (fileDataBlock.CodecStreams.Count > 0) { foreach (ICodecStream codecStream in fileDataBlock.CodecStreams) { if (codecStream.DataFormat != CodecID.Unknown) { if (CheckDetectors(codecStream.Detectors, selectedCodec)) { return(true); } } } } else if (fileDataBlock.DataFormat != CodecID.Unknown) { if (CheckDetectors(fileDataBlock.Detectors, selectedCodec)) { return(true); } } } return(false); }
public ResultNode(string name, CodecID dataFormat, bool isH264AVCC, long offset, long length, RangeList dataRanges) { _name = name; _dataFormat = new DataFormat(dataFormat, isH264AVCC); _offset = offset; _length = length; _dataRanges = dataRanges; }
internal CodecParameters(CodecParametersBuilder builder) { _codec = builder.Codec; _width = builder.Width; _height = builder.Height; _frameRate = builder.FrameRate; _parameters = new Dictionary <string, object>(builder._values); }
private static IDataPacket CreateReferenceHeader(CodecID codec, IDataPacket videoObject, IResultNode videoObjectLayer, ICodecParametersSpec codecParameters) { // Report codec parameters for reference header codecParameters.Codec = codec; codecParameters.Width = GetAttribute <uint>(videoObjectLayer, VideoObjectLayer.Attribute.Width); codecParameters.Height = GetAttribute <uint>(videoObjectLayer, VideoObjectLayer.Attribute.Height); codecParameters["VTIRate"] = GetAttributeStringValue(videoObjectLayer, VideoObjectLayer.Attribute.VopTimeIncrementResolution); return(videoObject.Append(videoObjectLayer)); }
/// <summary>Static data initialization.</summary> static MockDetectorReaderWriter() { _columns["correct type 1"] = new string[4] { "General first", "Type1 specific second", "General third", "General fourth" }; _columns["correct type 2"] = new string[4] { "General first", "Type2 specific second", "General third", "General fourth" }; _supportedFormats = new CodecID[] {}; }
/// <summary> /// Gets the description for the given <paramref name="codecId"/>. /// </summary> /// <param name="codecId">the codec identifier</param> /// <returns>the description for the given codec identifier</returns> /// <exception cref="ArgumentException">if the codec identifier is invalid</exception> private static Description GetDescription(this CodecID codecId) { Description description; if (!_descriptions.TryGetValue(codecId, out description)) { throw new ArgumentException("Invalid codec.", "codecId"); } return(description); }
public void SetMpegFormat(CodecID format) { if (State.MpegFormat == CodecID.Unknown) { State.MpegFormat = format; } else if (State.MpegFormat != format) { _readerState.Invalidate(); } }
private void buttonResetDefaultCodecHeader_Click(object sender, EventArgs e) { DataGridViewSelectedRowCollection rows = selectProjectDefaultCodecHeaders.SelectedRows; if (rows.Count == 1) { CodecID codec = (CodecID)rows[0].Cells[0].Value; _defaultCodecHeaderManager.RemoveDefaultCodecHeader(codec); UpdateCodecList(); } }
private void UpdateCodecList() { CodecID selectedCodecId = (selectProjectDefaultCodecHeaders.SelectedRows.Count > 0) ? ((CodecID)selectProjectDefaultCodecHeaders.SelectedRows[0].Cells[0].Value) : CodecID.Unknown; selectProjectDefaultCodecHeaders.DataSource = _defaultCodecHeaderManager.GetCodecList(); if (selectedCodecId != CodecID.Unknown) { SelectCodec(selectedCodecId); } }
/// <summary> /// Lists the detectors that can handle <paramref name="codecId"/>. /// </summary> /// <remarks>this function might be called <c>WhoCanDo()</c></remarks> /// <param name="codecId">the codec identifier</param> /// <returns>the codec detectors</returns> public IList <IDetector> GetDetectorsForCodec(CodecID codecId) { List <IDetector> codecDetectors = new List <IDetector>(); foreach (IDetector detector in CodecDetectors) { if (detector.SupportedFormats.Contains(codecId)) { codecDetectors.Add(detector); } } return(codecDetectors); }
private static bool CheckDetectors(IEnumerable <IDetector> detectors, CodecID selectedCodec) { foreach (IDetector detector in detectors) { foreach (CodecID codec in detector.SupportedFormats) { if (codec == selectedCodec) { return(true); } } } return(false); }
private DataBlock(DataBlock dataBlock, long startOffset, long endOffset) { _appendDataPackets = dataBlock._appendDataPackets; _dataFormat = dataBlock.DataFormat; Debug.Assert(dataBlock.Detectors.Count() <= 2); _detectors = dataBlock.Detectors; _inputFile = dataBlock.InputFile; _isFullFile = dataBlock.IsFullFile; _referenceHeader = dataBlock.ReferenceHeader; _codecStreams = new ICodecStream[0]; _startOffset = startOffset; _endOffset = endOffset; }
private static bool DataBlockHasCodec(IDataBlock dataBlock, CodecID codecId) { if (dataBlock.DataFormat == codecId) { return(true); } foreach (ICodecStream codecStream in dataBlock.CodecStreams) { if (codecStream.DataFormat == codecId) { return(true); } } return(false); }
private void listBoxCodec_ItemCheck(object sender, ItemCheckEventArgs e) { IList<CodecID> selectedCodecs = GetSelectedCodecs(); // Update the list of selected codecs according to the new state of the check box CodecID codecId = CodecForDescriptiveName(listBoxCodecs.Items[e.Index] as string); if (e.NewValue == CheckState.Unchecked) { selectedCodecs.Remove(codecId); } else if ((e.NewValue == CheckState.Checked) && !selectedCodecs.Contains(codecId)) { selectedCodecs.Add(codecId); } UpdateReferenceHeaderList(selectedCodecs); }
public override Stream LoadTagData(Stream stream) { var MediaInfo = stream.ReadUInt8(); //#1 this.Type = (FrameType)(MediaInfo >> 4); //Keyframe:1 this.Codec = (CodecID)(MediaInfo & 0x0F); //AVC:7 //=== Data === var pos = stream.Position; var wtf = stream.ReadBytes(4); //#1 var buf = stream.ReadBytes((int)this.DataSize - 1 - 4); //#n //===Packet=== DataStream = new MemoryStream(); DataStream.Write(buf, 0, buf.Length); return(DataStream); }
/// <summary> /// If the current detector is compatible with the data format /// </summary> /// <returns></returns> private static bool IsCompatibleCodec(IDetector detector, CodecID dataFormat) { if (detector == null) { return(true); } if (dataFormat == CodecID.Unknown) { return(true); } if (detector.DetectorType == typeof(UnknownFormatDetector)) { return(true); } if (detector.SupportedFormats.Contains(dataFormat)) { return(true); } return(false); }
private static IDataPacket CreateReferenceHeader(CodecID codec, IResultNode sequenceHeader, ICodecParametersSpec codecParameters) { IDataPacket data = sequenceHeader; // Include sequence extensions foreach (IResultNode childResultNode in sequenceHeader.Children) { if (!IsSequenceExtension(childResultNode.Name)) { break; } data = data.Append(childResultNode); } // Report codec parameters for reference header var width = GetAttribute <uint>(sequenceHeader, SequenceHeader.Attribute.HorizontalSizeValue); var height = GetAttribute <uint>(sequenceHeader, SequenceHeader.Attribute.VerticalSizeValue); if (sequenceHeader.HasChildren()) { IResult sequenceExtension = sequenceHeader.GetFirstChild(); if (sequenceExtension.Name == SequenceExtension.Name) { width |= GetAttribute <uint>(sequenceExtension, SequenceExtension.Attribute.HorizontalSizeExtension) << 12; height |= GetAttribute <uint>(sequenceExtension, SequenceExtension.Attribute.VerticalSizeExtension) << 12; } } codecParameters.Codec = codec; codecParameters.Width = width; codecParameters.Height = height; codecParameters.FrameRate = GetAttributeStringValue(sequenceHeader, SequenceHeader.Attribute.FrameRateCode); return(data); }
public void SelectCodec(CodecID codecId) { List <DefaultCodecHeaderManager.CodecListItem> codecList = selectProjectDefaultCodecHeaders.DataSource as List <DefaultCodecHeaderManager.CodecListItem>; if (codecList == null) { return; } int row = 0; foreach (DefaultCodecHeaderManager.CodecListItem item in codecList) { if (item.Codec == codecId) { selectProjectDefaultCodecHeaders.FirstDisplayedScrollingRowIndex = row; selectProjectDefaultCodecHeaders.Refresh(); selectProjectDefaultCodecHeaders.CurrentCell = selectProjectDefaultCodecHeaders.Rows[row].Cells[0]; selectProjectDefaultCodecHeaders.Rows[row].Selected = true; return; } row++; } }
static MockDetector() { _supportedFormats = new CodecID[] {}; }
public static extern AVCodec* avcodec_find_encoder(CodecID id);
public static extern IntPtr avcodec_find_encoder(CodecID id);
public static extern int av_get_bits_per_sample(CodecID codec_id);
public static extern AVCodecParserContext* av_parser_init(CodecID codec_id);
public AudioCodec(string ShortName, CodecID ID) { m_shortname = ShortName; m_id = ID; }
public CodecStreamNode(IDataBlock block, CodecID dataFormat, bool isH264AVCC, KeyFrameList keyFrameList, RangeList dataRanges) : this(block.DataFormat.GetName(), dataFormat, isH264AVCC, block.StartOffset, block.EndOffset - block.StartOffset, keyFrameList, dataRanges) { }
public static string GetStringForCodecID(CodecID codecID) { switch (codecID) { case CodecID.V_AVC: { return "V_MPEG4/ISO/AVC"; } case CodecID.V_MS: { return "V_MS/VFW/FOURCC"; } case CodecID.A_AAC: { return "A_AAC"; } case CodecID.A_MS: { return "A_MS/ACM"; } default: { throw new Exception(string.Format("CodecID '{0}' is invalid!", codecID)); } } }
public void AddNodeToRecording(ProductionNode node, CodecID codec) { UInt32 status = OpenNIImporter.xnAddNodeToRecording(this.InternalObject, node.InternalObject, codec.InternalValue); WrapperUtils.CheckStatus(status); }
public Codec(Context context, CodecID codecID, ProductionNode initializer) : this(context, Create(context, codecID, initializer), false) { }
/** * Get the name of a codec. * @return a static string identifying the codec; never NULL */ static public string avcodec_get_name(CodecID id) { throw(new NotImplementedException()); }
public void AddNodeToRecording(ProductionNode node, CodecID codec) { int status = SafeNativeMethods.xnAddNodeToRecording(this.InternalObject, node.InternalObject, codec.InternalValue); WrapperUtils.ThrowOnError(status); }
/// <summary> /// Parses this object out of a stream /// </summary> protected override void Parse() { BinaryReader br = new BinaryReader(this._dataStream); this._characterID = br.ReadUInt16(); this._numberOfFrames = br.ReadUInt16(); this._width = br.ReadUInt16(); this._height = br.ReadUInt16(); BitStream bits = new BitStream(this._dataStream); UInt32 reserved = bits.GetBits(4); // muste be 0 if (0 != reserved) { SwfFormatException e = new SwfFormatException("Reserved bits havae been set"); Log.Error(this, e.Message); throw e; } this._videoFlagsDeblocking = (VideoFlagsDeblocking)bits.GetBits(3); this._videoFlagsSmoothing = (0 != bits.GetBits(1) ? true : false); this._codecID = (CodecID)this._dataStream.ReadByte(); }
public TrackEntry(TrackType trackType, byte[] infoBytes, CodecID codecID, byte[] codecPrivate) { this.TrackType = trackType; this.InfoBytes = infoBytes; this.CodecID = codecID; this.CodecPrivate = codecPrivate; }