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);
}
public AudioCodec(string ShortName, CodecID ID)
{
m_shortname = ShortName;
m_id = ID;
}
/// <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;
}
