public override ushort Write(byte[] buffer, int offset)
{
int idx = offset + HandshakeHeaderLength;
idx += BitConverterBE.WriteUInt16((ushort)_version, buffer, idx);
Buffer.BlockCopy(_random, 0, buffer, idx, _random.Length);
idx += _random.Length;
buffer[idx++] = (byte)_sessionID.Length;
Buffer.BlockCopy(_sessionID, 0, buffer, idx, _sessionID.Length);
idx += _sessionID.Length;
idx += BitConverterBE.WriteUInt16((ushort)_cipherSuite, buffer, idx);
buffer[idx++] = (byte)_compression;
if (_version >= ProtocolVersion.TLS10 && _extensions != null && _extensions.Length > 0)
{
int idx_backup = idx;
// Skip
idx += 2;
for (int i = 0; i < _extensions.Length; i++)
{
idx += BitConverterBE.WriteUInt16((ushort)_extensions[i].Type, buffer, idx);
idx += BitConverterBE.WriteUInt16((ushort)_extensions[i].Data.Length, buffer, idx);
Buffer.BlockCopy(_extensions[i].Data, 0, buffer, idx, _extensions[i].Data.Length);
idx += _extensions[i].Data.Length;
}
ushort extBytes = (ushort)(idx - idx_backup - 2);
BitConverterBE.WriteUInt16(extBytes, buffer, idx_backup);
}
_length = (uint)(idx - offset - HandshakeHeaderLength);
WriteHandshakeHeader(buffer, offset);
return((ushort)(idx - offset));
}
public override ushort Write(byte[] buffer, int offset)
{
int certBytes = 0;
// ハンドシェイクヘッダと全certのバイト量を書き込むエリアをスキップ
int idx = offset + HandshakeHeaderLength + 3;
for (int i = 0; i < _certs.Length; i++)
{
byte[] raw = _certs[0].GetRawCertData();
idx += BitConverterBE.WriteUInt24((uint)raw.Length, buffer, idx);
Buffer.BlockCopy(raw, 0, buffer, idx, raw.Length);
idx += raw.Length;
certBytes += 3 + raw.Length;
}
// 全certバイト数を書き込む
BitConverterBE.WriteUInt24((uint)certBytes, buffer, offset + HandshakeHeaderLength);
// ハンドシェイクメッセージサイズを更新し、ヘッダを書き込む
_length = (uint)(certBytes + 3);
WriteHandshakeHeader(buffer, offset);
return((ushort)(idx - offset));
}
public void ComputeServerMasterSecret(SecurityParameters sparams, byte[] raw, int offset, int length)
{
ushort len = BitConverterBE.ReadUInt16AndMoveOffset(raw, ref offset);
byte[] premaster = _dh.PerformKeyAgreement(raw, offset, len);
sparams.SetupMasterSecret(premaster);
}
public static ClientHello CreateFromSSL2CompatibleData(ProtocolVersion ver, byte[] buffer, int offset, uint length)
{
ClientHello msg = new ClientHello(ver);
int cipherLen = BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref offset) / 3;
ushort sessionIdLen = BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref offset);
if (sessionIdLen != 0 && sessionIdLen != 16)
{
throw new Exception();
}
ushort challengeLen = BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref offset);
if (challengeLen < 16)
{
throw new Exception();
}
if (challengeLen > RandomData.Size)
{
challengeLen = RandomData.Size;
}
msg._cipherSuites = new CipherSuite[cipherLen];
for (int i = 0; i < cipherLen; i++)
{
msg._cipherSuites[i] = (CipherSuite)BitConverterBE.ReadUInt24AndMoveOffset(buffer, ref offset);
}
msg._sessionId = new byte[sessionIdLen];
Buffer.BlockCopy(buffer, offset, msg._sessionId, 0, sessionIdLen);
offset += sessionIdLen;
msg._random = new byte[RandomData.Size];
Buffer.BlockCopy(buffer, offset, msg._random, 0, challengeLen);
return(msg);
}
private uint ReadUInt32()
{
var x = new byte[4];
_fs.Read(x, 0, 4);
_fileOffset += 4;
return(BitConverterBE.ToUInt32(x, 0));
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
ushort NameIndex = BitConverterBE.ToUInt16(Data, 0);
ushort DescriptorIndex = BitConverterBE.ToUInt16(Data, 2);
Name = ((Utf8)Reader.GetFilledConstant(NameIndex)).Value;
Descriptor = ((Utf8)Reader.GetFilledConstant(DescriptorIndex)).Value;
}
public void WriteChunk(byte[] chunk, uint timeStamp, int frameType)
{
var offset = 0;
var len = chunk.Length;
if (_codecID == 4)
{
offset = 1;
len -= 1;
}
if (_codecID == 5)
{
offset = 4;
if (len >= 4)
{
var alphaOffset = (int)BitConverterBE.ToUInt32(chunk, 0) & 0xFFFFFF;
if (!_isAlphaWriter)
{
len = alphaOffset;
}
else
{
offset += alphaOffset;
len -= offset;
}
}
else
{
len = 0;
}
}
len = Math.Max(len, 0);
len = Math.Min(len, chunk.Length - offset);
_index.Add(frameType == 1 ? 0x10 : (uint)0);
_index.Add(_moviDataSize + 4);
_index.Add((uint)len);
if (_width == 0 && _height == 0)
{
GetFrameSize(chunk);
}
WriteFourCC("00dc");
_bw.Write(len);
_bw.Write(chunk, offset, len);
if (len % 2 != 0)
{
_bw.Write((byte)0);
++len;
}
_moviDataSize += (uint)len + 8;
++_frameCount;
_alphaWriter?.WriteChunk(chunk, timeStamp, frameType);
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
BootstrapMethodAttrIndex = BitConverterBE.ToUInt16(Data, 0);
NameAndType N = (NameAndType)Reader.GetFilledConstant(BitConverterBE.ToUInt16(Data, 2));
Name = N.Name;
Descriptor = N.Descriptor;
}
public int CreateServerKeyExchangeParams(byte[] params_buffer, int offset)
{
int baseOffset = offset;
byte[] pub = _ecdh.Parameters.ExportPublicKey(false);
params_buffer[offset++] = (byte)ECCurveType.NamedCurve;
offset += BitConverterBE.WriteUInt16((ushort)NamedCurve.secp256r1, params_buffer, offset);
params_buffer[offset++] = (byte)pub.Length;
Buffer.BlockCopy(pub, 0, params_buffer, offset, pub.Length);
return(offset - baseOffset + pub.Length);
}
public override ushort Write(byte[] buffer, int offset)
{
int idx = offset + HandshakeHeaderLength;
int paramSize = _sparams.KeyExchanger.CreateServerKeyExchangeParams(buffer, idx);
int signSize = _sparams.KeyExchanger.CreateServerKeyExchangeSign(_sparams, buffer, idx, paramSize, buffer, idx + paramSize + 2);
BitConverterBE.WriteUInt16((ushort)signSize, buffer, idx + paramSize);
_length = (uint)(paramSize + signSize + 2);
WriteHandshakeHeader(buffer, offset);
return((ushort)(_length + HandshakeHeaderLength));
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
ushort ClassIndex = BitConverterBE.ToUInt16(Data, 0);
ushort NameAndTypeIndex = BitConverterBE.ToUInt16(Data, 2);
Class ClassConst = (Class)Reader.GetFilledConstant(ClassIndex);
NameAndType NameAndTypeConst = (NameAndType)Reader.GetFilledConstant(NameAndTypeIndex);
this.Class = ClassConst.Value;
this.Name = NameAndTypeConst.Name;
this.Descriptor = NameAndTypeConst.Descriptor;
}
public ClientHello(byte[] buffer, int offset, uint length) : base(HandshakeType.ClientHello)
{
int idx = offset, end = (int)(offset + length);
_version = (ProtocolVersion)BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref idx);
_random = RandomData.ReadRandomData(buffer, idx);
idx += RandomData.Size;
if (buffer[idx] > 32)
{
throw new FormatException();
}
_sessionId = new byte[buffer[idx]];
Buffer.BlockCopy(buffer, idx + 1, _sessionId, 0, _sessionId.Length);
idx += 1 + _sessionId.Length;
_cipherSuites = new CipherSuite[BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref idx) >> 1];
for (int i = 0; i < _cipherSuites.Length; i++)
{
_cipherSuites[i] = (CipherSuite)BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref idx);
}
_compressions = new CompressionMethod[buffer[idx]];
for (int i = 0; i < _compressions.Length; i++)
{
_compressions[i] = (CompressionMethod)buffer[idx + 1 + i];
}
idx += 1 + _compressions.Length;
if (idx < end)
{
int extBytes = BitConverterBE.ReadUInt16AndMoveOffset(buffer, ref idx);
List <Extension> list = new List <Extension> ();
while (idx < end)
{
ExtensionType etype = (ExtensionType)BitConverterBE.ReadUInt16(buffer, idx);
int esize = BitConverterBE.ReadUInt16(buffer, idx + 2);
byte[] edata = new byte[esize];
Buffer.BlockCopy(buffer, idx + 4, edata, 0, esize);
list.Add(new Extension(etype, edata));
idx += 4 + esize;
}
_extensions = list.ToArray();
}
else
{
_extensions = Utility.EmptyExtensionArray;
}
}
public void ComputeServerMasterSecret(SecurityParameters sparams, byte[] raw, int offset, int length)
{
ushort encryptedLength = BitConverterBE.ReadUInt16(raw, offset);
if (encryptedLength > length - 2)
{
encryptedLength = (ushort)length;
}
else
{
offset += 2;
}
byte[] encrypted = new byte[encryptedLength];
Buffer.BlockCopy(raw, offset, encrypted, 0, encryptedLength);
byte[] decrypted = _rsa.Decrypt(encrypted, false);
sparams.SetupMasterSecret(decrypted);
}
public FlvTagPointer(Stream stream, ref long offset)
{
//시작 위치 저장
this.Offset = offset;
var tagType = (TagType)stream.ReadUInt8(ref offset);
var dataSize = stream.ReadUInt24(ref offset);
var value = stream.ReadUInt24(ref offset);
value |= stream.ReadUInt8(ref offset) << 24;
//시간 저장
this.Timestamp = TimeSpan.FromMilliseconds(value).Ticks;
//this.StreamID = stream.ReadUInt24(ref offset);
offset += 3;
var mediaInfo = stream.ReadUInt8(ref offset);
var count = dataSize - 1;
if (tagType == TagType.Video)
{
//byte[] bytes = stream.ReadBytes(ref offset, (int)count);
byte[] buffer = stream.ReadBytes(ref offset, 4);
offset -= 4;
//비디오 인경우만 키프레임을 셋팅함 (비디오 키프레임이 아니면 담을 필요가 없다.)
this.IsKeyFrame = (FrameType)(mediaInfo >> 4) == FrameType.Keyframe;
byte[] x = new byte[4];
x[1] = buffer[1];
x[2] = buffer[2];
x[3] = buffer[3];
if ((AVCPacketType)buffer[0] == AVCPacketType.AVCNALU)
{
//P / B 프레임의 경우 시간 추가
this.Timestamp += TimeSpan.FromMilliseconds((int)BitConverterBE.ToUInt32(x, 0)).Ticks;
}
}
//데이터를 읽은것을 간주
offset += count;
//this.TagSize = stream.ReadUInt32(ref offset);
offset += 4;
}
public int CreateServerKeyExchangeParams(byte[] params_buffer, int offset)
{
ushort keySize = (ushort)(_dh.KeySize >> 3);
int idx = offset;
idx += BitConverterBE.WriteUInt16(keySize, params_buffer, idx);
_dh.ModulusCopyTo(params_buffer, idx);
idx += keySize;
idx += BitConverterBE.WriteUInt16(keySize, params_buffer, idx);
_dh.GeneratorCopyTo(params_buffer, idx);
idx += keySize;
idx += BitConverterBE.WriteUInt16(keySize, params_buffer, idx);
_dh.PublicKeyCopyTo(params_buffer, idx);
idx += keySize;
return(idx - offset);
}
public AVCVideoPacket(byte[] buffer)
{
this.AVCPacketType = (AVCPacketType)buffer[0];
byte[] x = new byte[4];
x[1] = buffer[1];
x[2] = buffer[2];
x[3] = buffer[3];
this.CompositionTime = (int)BitConverterBE.ToUInt32(x, 0);
byte[] data = new byte[buffer.Length - 4];
Buffer.BlockCopy(buffer, 4, data, 0, data.Length);
if (this.AVCPacketType == AVCPacketType.AVCSequenceHeader)
{
AVCDecoderConfigurationRecord = data;
}
else
{
NALUs = data;
}
}
private void WriteVBRHeader(bool isPlaceholder)
{
var buff = new byte[GetFrameLength(_mpegVersion, 64000, _sampleRate, 0)];
if (!isPlaceholder)
{
var header = _firstFrameHeader;
var dataOffset = GetFrameDataOffset(_mpegVersion, _channelMode);
header &= 0xFFFF0DFF; // Clear bit rate and padding fields
header |= 0x00010000; // Set protection bit (indicates that CRC is NOT present)
header |= (uint)(_mpegVersion == 3 ? 5 : 8) << 12; // 64 kbit/sec
General.CopyBytes(buff, 0, BitConverterBE.GetBytes(header));
General.CopyBytes(buff, dataOffset, BitConverterBE.GetBytes(0x58696E67)); // "Xing"
General.CopyBytes(buff, dataOffset + 4, BitConverterBE.GetBytes((uint)0x7)); // Flags
General.CopyBytes(buff, dataOffset + 8, BitConverterBE.GetBytes((uint)_frameOffsets.Count)); // Frame count
General.CopyBytes(buff, dataOffset + 12, BitConverterBE.GetBytes(_totalFrameLength)); // File length
for (var i = 0; i < 100; i++)
{
var frameIndex = (int)(i / 100.0 * _frameOffsets.Count);
buff[dataOffset + 16 + i] = (byte)(_frameOffsets[frameIndex] / (double)_totalFrameLength * 256.0);
}
}
_fs.Write(buff, 0, buff.Length);
}
private bool CheckTiffHeader(byte[] data, out bool isLittleEndian, out int ifdOffset)
{
isLittleEndian = false;
ifdOffset = 0;
string byteAlign = Encoding.ASCII.GetString(data, 6, 2);
if (byteAlign == "II")
{
if (data[8] != 0x2A || data[9] != 0x0)
{
return(false);
}
isLittleEndian = true;
ifdOffset = BitConverter.ToInt32(data, 10);
return(true);
}
else if (byteAlign == "MM")
{
if (data[8] != 0x00 || data[9] != 0x2A)
{
return(false);
}
isLittleEndian = false;
ifdOffset = BitConverterBE.ToInt32(data, 10);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// ハンドシェイクヘッダを書き込みます
/// </summary>
/// <param name="buffer">書き込み先バッファ</param>
/// <param name="offset">書き込み先バッファの開始位置</param>
/// <returns>書き込んだバイト数</returns>
protected int WriteHandshakeHeader (byte[] buffer, int offset)
{
buffer[offset] = (byte)_type;
BitConverterBE.WriteUInt24 (_length, buffer, offset + 1);
return HandshakeHeaderLength;
}
private void GetFrameSize(byte[] chunk)
{
if (_codecID == 2)
{
// Reference: flv_h263_decode_picture_header from libavcodec's h263.c
if (chunk.Length < 10)
{
return;
}
if (chunk[0] != 0 || chunk[1] != 0)
{
return;
}
var x = BitConverterBE.ToUInt64(chunk, 2);
if (BitHelper.Read(ref x, 1) != 1)
{
return;
}
BitHelper.Read(ref x, 5);
BitHelper.Read(ref x, 8);
var format = BitHelper.Read(ref x, 3);
switch (format)
{
case 0:
_width = BitHelper.Read(ref x, 8);
_height = BitHelper.Read(ref x, 8);
break;
case 1:
_width = BitHelper.Read(ref x, 16);
_height = BitHelper.Read(ref x, 16);
break;
case 2:
_width = 352;
_height = 288;
break;
case 3:
_width = 176;
_height = 144;
break;
case 4:
_width = 128;
_height = 96;
break;
case 5:
_width = 320;
_height = 240;
break;
case 6:
_width = 160;
_height = 120;
break;
default:
return;
}
}
else if (_codecID == 4 || _codecID == 5)
{
// Reference: vp6_parse_header from libavcodec's vp6.c
var skip = _codecID == 4 ? 1 : 4;
if (chunk.Length < skip + 8)
{
return;
}
var x = BitConverterBE.ToUInt64(chunk, skip);
var deltaFrameFlag = BitHelper.Read(ref x, 1);
BitHelper.Read(ref x, 6); //quant
var separatedCoeffFlag = BitHelper.Read(ref x, 1);
BitHelper.Read(ref x, 5); //subVersion
var filterHeader = BitHelper.Read(ref x, 2);
BitHelper.Read(ref x, 1); //interlacedFlag
if (deltaFrameFlag != 0)
{
return;
}
if (separatedCoeffFlag != 0 || filterHeader == 0)
{
BitHelper.Read(ref x, 16);
}
_height = BitHelper.Read(ref x, 8) * 16;
_width = BitHelper.Read(ref x, 8) * 16;
// chunk[0] contains the width and height (4 bits each, respectively) that should
// be cropped off during playback, which will be non-zero if the encoder padded
// the frames to a macroblock boundary. But if you use this adjusted size in the
// AVI header, DirectShow seems to ignore it, and it can cause stride or chroma
// alignment problems with VFW if the width/height aren't multiples of 4.
if (!_isAlphaWriter)
{
var cropX = chunk[0] >> 4;
var cropY = chunk[0] & 0x0F;
if ((cropX != 0 || cropY != 0) && !_isAlphaWriter)
{
_warnings.Add($@"Suggested cropping: {cropX} pixels from right, {cropY} pixels from bottom.");
}
}
}
}
private bool ProcessApp1Data(byte[] data, out DateTime dateTaken)
{
dateTaken = DateTime.MinValue;
if (CheckTiffHeader(data, out bool isLittleEndian, out int ifdOffset) == false || ifdOffset <= 0)
{
return(false);
}
int workOffset = ifdOffset;
bool isSubstituteFound = false;
DateTime substituteDateTaken = DateTime.MinValue;
while (workOffset > 0)
{
workOffset += 6; // 6 is exif header size
// exif spec says all offsets start from tiff header, but current buffer starts from exif header
int directoryCount;
if (isLittleEndian)
{
directoryCount = BitConverter.ToInt16(data, workOffset);
}
else
{
directoryCount = BitConverterBE.ToInt16(data, workOffset);
}
workOffset += 2;
bool subIFDFound = false;
for (int i = 0; i < directoryCount; i++)
{
var ifd = ImageFileDirectory.Read(isLittleEndian, data, workOffset);
if (ifd.Tag == SUBIFD)
{
if (isLittleEndian)
{
workOffset = BitConverter.ToInt32(ifd.Value.Array, ifd.Value.Offset);
}
else
{
workOffset = BitConverterBE.ToInt32(ifd.Value.Array, ifd.Value.Offset);
}
subIFDFound = true;
break;
}
if (ifd.Tag == 306)
{
if (ifd.Type != 2 || ifd.Value.Count != 20)
{
continue;
}
isSubstituteFound = TryParseDateTime(ifd.Value.Array, ifd.Value.Offset, ifd.Value.Count, out substituteDateTaken);
}
else if (ifd.Tag == 0x9003 || ifd.Tag == 0x9004)
{
if (ifd.Type != 2 || ifd.Value.Count != 20)
{
return(false);
}
if (TryParseDateTime(ifd.Value.Array, ifd.Value.Offset, ifd.Value.Count, out dateTaken))
{
return(true);
}
}
workOffset += 12;
}
if (subIFDFound)
{
continue;
}
if (isLittleEndian)
{
workOffset = BitConverter.ToInt32(data, workOffset);
}
else
{
workOffset = BitConverterBE.ToInt32(data, workOffset);
}
}
if (isSubstituteFound)
{
dateTaken = substituteDateTaken;
return(true);
}
return(false);
}
internal static ImageFileDirectory Read(bool isLittleEndian, byte[] data, int offset)
{
var ifd = new ImageFileDirectory();
if (isLittleEndian)
{
ifd.Tag = BitConverter.ToUInt16(data, offset);
}
else
{
ifd.Tag = BitConverterBE.ToUInt16(data, offset);
}
if (isLittleEndian)
{
ifd.Type = BitConverter.ToUInt16(data, offset + 2);
}
else
{
ifd.Type = BitConverterBE.ToUInt16(data, offset + 2);
}
uint components;
uint dataOffset;
if (isLittleEndian)
{
components = BitConverter.ToUInt32(data, offset + 4);
}
else
{
components = BitConverterBE.ToUInt32(data, offset + 4);
}
if (isLittleEndian)
{
dataOffset = BitConverter.ToUInt32(data, offset + 8) + 6;
}
else
{
dataOffset = BitConverterBE.ToUInt32(data, offset + 8) + 6;
}
uint componentSize = 1;
if (ifd.Type == 3 || ifd.Type == 8)
{
componentSize = 2;
}
else if (ifd.Type == 4 || ifd.Type == 9 || ifd.Type == 11)
{
componentSize = 4;
}
else if (ifd.Type == 5 || ifd.Type == 10 || ifd.Type == 12)
{
componentSize = 8;
}
uint totalByteLength = componentSize * components;
if (totalByteLength <= 4)
{
ifd.Value = new ArraySegment <byte>(data, offset + 8, (int)totalByteLength);
}
else
{
ifd.Value = new ArraySegment <byte>(data, (int)dataOffset, (int)totalByteLength);
}
return(ifd);
}
public static PropertySet GetFontName(Stream stream)
{
System.Globalization.CultureInfo enCI = new System.Globalization.CultureInfo("en-US");
PropertySet namePropSet = new PropertySet();
SortedDictionary <ushort, string> fontNameDict = new SortedDictionary <ushort, string>();
long pos = 0;
UInt32 ttcNumFonts = 0;
UInt32[] ttcOffsetTables = null;
var checkTTC = stream.ReadBytes(ref pos, 4);
if (Encoding.UTF8.GetString(checkTTC, 0, 4) == "ttcf")
{
//TTC Header
var ttcVersion = stream.ReadBytes(ref pos, 4);
ttcNumFonts = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
ttcOffsetTables = new UInt32[ttcNumFonts];
for (UInt32 i = 0; i < ttcNumFonts; i++)
{
ttcOffsetTables[i] = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
}
if (ttcVersion[1] == 2)
{
var ulDsigTag = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
var ulDsigLength = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);;
var ulDsigOffset = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
}
}
else
{
ttcNumFonts = 1;
ttcOffsetTables = new UInt32[ttcNumFonts];
ttcOffsetTables[0] = 0;
}
for (UInt32 idx = 0; idx < ttcNumFonts; idx++)
{
pos = ttcOffsetTables[idx];
var sfntVersion = stream.ReadBytes(ref pos, 4);
var numTables = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
var searchRange = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
var entrySelector = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
var rangeShift = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
List <NameRecord> nameTable = new List <NameRecord>();
while (true)
{
var tag = Encoding.UTF8.GetString(stream.ReadBytes(ref pos, 4), 0, 4);
var checkSum = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
var offset = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
var length = BitConverterBE.ToUInt32(stream.ReadBytes(ref pos, 4), 0);
//var sum = CalcTableChecksum(12, length);
if (tag == "name") //필수 테이블중 name만 처리하고 break
{
pos = offset;
ushort format = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
ushort count = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
ushort stringOffset = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
//Name Record [count]
for (int i = 0; i < count; i++)
{
var record = new NameRecord()
{
PlatformID = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0),
EncodingID = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0),
LanguageID = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0),
NameID = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0)
};
//Unicode플랫폼 및 윈도우플랫폼만 처리 (다른 인코딩은 CodePage로 매핑을 할 수가 없음)
if (!(record.PlatformID == 0 || record.PlatformID == 3))
{
continue;
}
nameTable.Add(record);
ushort nameRecordLength = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
ushort nameRecordOffset = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
if ((record.PlatformID == 0 || record.PlatformID == 3) && (record.NameID == 1 || record.NameID == 2)) //폰트 패밀리 이름
{
byte[] buff = new byte[nameRecordLength];
stream.Position = offset + stringOffset + nameRecordOffset;
stream.Read(buff, 0, buff.Length);
string name = UnicodeEncoding.BigEndianUnicode.GetString(buff, 0, buff.Length);
record.Name = name.Trim();
}
}
if (format == 1)
{
ushort langTagCount = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
for (int i = 0; i < langTagCount; i++)
{
ushort langTagLength = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
ushort langTagOffset = BitConverterBE.ToUInt16(stream.ReadBytes(ref pos, 2), 0);
}
}
NameRecord rec = nameTable.FirstOrDefault(x =>
{
if (LcidMap.ContainsKey(x.LanguageID) && x.NameID == 1)
{
System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo(LcidMap[x.LanguageID].Key);
//return (ci.TwoLetterISOLanguageName == System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName
// || ci.TwoLetterISOLanguageName == System.Globalization.CultureInfo.CurrentCulture.TwoLetterISOLanguageName);
return((ci.TwoLetterISOLanguageName != enCI.TwoLetterISOLanguageName) && !string.IsNullOrEmpty(x.Name));
}
return(false);
});
if (rec == null)
{
rec = nameTable.FirstOrDefault(x => x.NameID == 1 && !string.IsNullOrEmpty(x.Name));
}
if (rec == null)
{
break;
}
string fontName = rec.Name;
var subNameRec = nameTable.FirstOrDefault(x => x.LanguageID == rec.LanguageID && x.NameID == 2 && x.Name.Trim().ToLower() != "regular" && x.Name.Trim().ToLower() != "untitle");
if (subNameRec != null)
{
fontName += " ";
fontName += subNameRec.Name;
}
namePropSet.Add(fontName, rec.Name);
//ttc의 경우 다시 루프를 돌기 때문에 초기화
nameTable.Clear();
break;
}
if (pos >= stream.Length)
{
break;
}
}
}
return(namePropSet);
}
private void ParseMP3Frames(byte[] buff)
{
var MPEG1BitRate = new[] { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 };
var MPEG2XBitRate = new[] { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 };
var MPEG1SampleRate = new[] { 44100, 48000, 32000, 0 };
var MPEG20SampleRate = new[] { 22050, 24000, 16000, 0 };
var MPEG25SampleRate = new[] { 11025, 12000, 8000, 0 };
var offset = 0;
var length = buff.Length;
while (length >= 4)
{
var header = (ulong)BitConverterBE.ToUInt32(buff, offset) << 32;
if (BitHelper.Read(ref header, 11) != 0x7FF)
{
break;
}
var mpegVersion = BitHelper.Read(ref header, 2);
var layer = BitHelper.Read(ref header, 2);
BitHelper.Read(ref header, 1);
var bitRate = BitHelper.Read(ref header, 4);
var sampleRate = BitHelper.Read(ref header, 2);
var padding = BitHelper.Read(ref header, 1);
BitHelper.Read(ref header, 1);
var channelMode = BitHelper.Read(ref header, 2);
if (mpegVersion == 1 || layer != 1 || bitRate == 0 || bitRate == 15 || sampleRate == 3)
{
break;
}
bitRate = (mpegVersion == 3 ? MPEG1BitRate[bitRate] : MPEG2XBitRate[bitRate]) * 1000;
if (mpegVersion == 3)
{
sampleRate = MPEG1SampleRate[sampleRate];
}
else if (mpegVersion == 2)
{
sampleRate = MPEG20SampleRate[sampleRate];
}
else
{
sampleRate = MPEG25SampleRate[sampleRate];
}
var frameLen = GetFrameLength(mpegVersion, bitRate, sampleRate, padding);
if (frameLen > length)
{
break;
}
var isVBRHeaderFrame = false;
if (_frameOffsets.Count == 0)
{
// Check for an existing VBR header just to be safe (I haven't seen any in FLVs)
var o = offset + GetFrameDataOffset(mpegVersion, channelMode);
if (BitConverterBE.ToUInt32(buff, o) == 0x58696E67)
{ // "Xing"
isVBRHeaderFrame = true;
_delayWrite = false;
_hasVBRHeader = true;
}
}
if (isVBRHeaderFrame)
{
}
else if (_firstBitRate == 0)
{
_firstBitRate = bitRate;
_mpegVersion = mpegVersion;
_sampleRate = sampleRate;
_channelMode = channelMode;
_firstFrameHeader = BitConverterBE.ToUInt32(buff, offset);
}
else if (!_isVBR && bitRate != _firstBitRate)
{
_isVBR = true;
if (_hasVBRHeader)
{
}
else if (_delayWrite)
{
WriteVBRHeader(true);
_writeVBRHeader = true;
_delayWrite = false;
}
else
{
_warnings.Add("Detected VBR too late, cannot add VBR header.");
}
}
_frameOffsets.Add(_totalFrameLength + (uint)offset);
offset += frameLen;
length -= frameLen;
}
_totalFrameLength += (uint)buff.Length;
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
Value = ((Utf8)Reader.GetFilledConstant(BitConverterBE.ToUInt16(Data, 0))).Value;
}
public void WriteChunk(byte[] chunk, uint timeStamp)
{
if (chunk.Length < 1)
{
return;
}
if (chunk[0] == 0)
{ // Header
if (chunk.Length < 3)
{
return;
}
var bits = (ulong)BitConverterBE.ToUInt16(chunk, 1) << 48;
_aacProfile = BitHelper.Read(ref bits, 5) - 1;
_sampleRateIndex = BitHelper.Read(ref bits, 4);
_channelConfig = BitHelper.Read(ref bits, 4);
if (_aacProfile == 4) // HE-AAC
{
_aacProfile = 1; // Uses LC profile + SBR
}
if (_aacProfile < 0 || _aacProfile > 3)
{
throw new Exception("Unsupported AAC profile.");
}
if (_sampleRateIndex > 12)
{
throw new Exception("Invalid AAC sample rate index.");
}
if (_channelConfig > 6)
{
throw new Exception("Invalid AAC channel configuration.");
}
}
else
{ // Audio data
var dataSize = chunk.Length - 1;
ulong bits = 0;
// Reference: WriteADTSHeader from FAAC's bitstream.c
BitHelper.Write(ref bits, 12, 0xFFF);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 2, 0);
BitHelper.Write(ref bits, 1, 1);
BitHelper.Write(ref bits, 2, _aacProfile);
BitHelper.Write(ref bits, 4, _sampleRateIndex);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 3, _channelConfig);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 1, 0);
BitHelper.Write(ref bits, 13, 7 + dataSize);
BitHelper.Write(ref bits, 11, 0x7FF);
BitHelper.Write(ref bits, 2, 0);
_fs.Write(BitConverterBE.GetBytes(bits), 1, 7);
_fs.Write(chunk, 1, dataSize);
}
}
public void WriteChunk(byte[] chunk, uint timeStamp, int frameType)
{
if (chunk.Length < 4)
{
return;
}
// Reference: decode_frame from libavcodec's h264.c
if (chunk[0] == 0)
{ // Headers
if (chunk.Length < 10)
{
return;
}
var offset = 8;
_nalLengthSize = (chunk[offset++] & 0x03) + 1;
var spsCount = chunk[offset++] & 0x1F;
var ppsCount = -1;
while (offset <= chunk.Length - 2)
{
if (spsCount == 0 && ppsCount == -1)
{
ppsCount = chunk[offset++];
continue;
}
if (spsCount > 0)
{
spsCount--;
}
else if (ppsCount > 0)
{
ppsCount--;
}
else
{
break;
}
var len = (int)BitConverterBE.ToUInt16(chunk, offset);
offset += 2;
if (offset + len > chunk.Length)
{
break;
}
_fs.Write(StartCode, 0, StartCode.Length);
_fs.Write(chunk, offset, len);
offset += len;
}
}
else
{ // Video data
var offset = 4;
if (_nalLengthSize != 2)
{
_nalLengthSize = 4;
}
while (offset <= chunk.Length - _nalLengthSize)
{
var len = _nalLengthSize == 2 ?
BitConverterBE.ToUInt16(chunk, offset) :
(int)BitConverterBE.ToUInt32(chunk, offset);
offset += _nalLengthSize;
if (offset + len > chunk.Length)
{
break;
}
_fs.Write(StartCode, 0, StartCode.Length);
_fs.Write(chunk, offset, len);
offset += len;
}
}
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
Kind = (ReferenceKind)Data[0];
Reference = Reader.GetFilledConstant(BitConverterBE.ToUInt16(Data, 1));
}
public override void FillData(byte[] Data, ConstantPoolReader Reader)
{
Value = BitConverterBE.ToSingle(Data, 0);
}
private static void Disasm(Attributes.Code codeAttr, ConstantPool pool, CountingStreamWriter writer, string[] sourceFile)
{
byte[] code = codeAttr.CodeBytes;
int i = 0;
bool lastWide = false;
Attributes.LineNumberTable lnt = codeAttr.Attributes.Where(A => A is Attributes.LineNumberTable).FirstOrDefault() as Attributes.LineNumberTable;
Attributes.LineNumberTable newLnt = new Attributes.LineNumberTable();
int lastLine = 0;
while (i < code.Length)
{
if ((lnt != null) && (sourceFile != null))
{
try
{
var lns = lnt.Table.Where(ln => ln.StartPC <= i);
if (lns.Count() > 0)
{
int currLine = lns.Aggregate((i1, i2) => i1.StartPC > i2.StartPC ? i1 : i2).LineNumberInFile;
if (lastLine != currLine)
{
writer.WriteLine(" ## {0}", sourceFile[currLine]);
}
lastLine = currLine;
}
}
catch (Exception)
{
}
}
newLnt.Table.Add(new Attributes.LineNumberTable.LineNumber((ushort)i, (ushort)writer.CurrLine));
OpCodes op = (OpCodes)code[i];
if (!lastWide)
{
writer.Write(" {0,4:X} : ", i);
}
if (op == OpCodes.wide)
{
writer.Write("wide ");
i++;
lastWide = true;
continue;
}
string opStr = op.ToString();
string operandStr = "";
if (opStr[0] == '_')
{
opStr = opStr.Substring(1);
}
writer.Write(opStr);
ByteCode.JavaInstructionDescption descr = ByteCode.JavaInstructions[op];
int operandSize = descr.Size - 1;
if (lastWide)
{
operandSize *= 2;
lastWide = false;
}
switch (descr.OpType)
{
case ByteCode.JavaOperandType.ConstPool:
ushort index = (ushort)BitConverterBE.ReadAsInt32(code, i + 1, operandSize);
operandStr = pool[index].ToString();
break;
case ByteCode.JavaOperandType.ConstValue:
case ByteCode.JavaOperandType.LocalVar:
operandStr = BitConverterBE.ReadAsInt32(code, i + 1, operandSize).ToString();
break;
case ByteCode.JavaOperandType.Offset:
short offset = (short)BitConverterBE.ReadAsInt32(code, i + 1, operandSize);
operandStr = String.Format("{0,4:X}", (i + offset));
break;
case ByteCode.JavaOperandType.Special:
switch (op)
{
case OpCodes.iinc:
int op1 = BitConverterBE.ReadAsInt32(code, i + 1, operandSize / 2);
int op2 = BitConverterBE.ReadAsInt32(code, i + 1 + operandSize / 2, operandSize / 2);
operandStr = String.Format("{0}, {1}", op1, op2);
break;
case OpCodes.lookupswitch:
int paddingLength = (4 - ((i + 1) % 4)) % 4;
int _default = BitConverterBE.ReadAsInt32(code, i + paddingLength + 1, 4);
int npairs = BitConverterBE.ReadAsInt32(code, i + paddingLength + 5, 4);
int pairsStart = i + paddingLength + 9;
operandSize = npairs * 8 + 8 + paddingLength;
writer.WriteLine(" default: {0,4:X}, npairs: {1}", _default, npairs);
for (int pair = 0; pair < npairs; pair++)
{
int pairValue = BitConverterBE.ReadAsInt32(code, pairsStart + (pair * 8), 4);
int pairOffset = BitConverterBE.ReadAsInt32(code, pairsStart + (pair * 8) + 4, 4);
writer.WriteLine(" {0,4:X} : {1}", pairOffset, pairValue);
}
break;
case OpCodes.tableswitch:
paddingLength = (4 - ((i + 1) % 4)) % 4;
_default = BitConverterBE.ReadAsInt32(code, i + paddingLength + 1, 4);
int low = BitConverterBE.ReadAsInt32(code, i + paddingLength + 5, 4);
int hight = BitConverterBE.ReadAsInt32(code, i + paddingLength + 9, 4);
writer.WriteLine(" default: {0,4:X}, low: {1}, hight: {2}", _default, low, hight);
int jmpCount = hight - low + 1;
int jmpStart = i + paddingLength + 13;
operandSize = jmpCount * 4 + 13 + paddingLength;
for (int jmp = 0; jmp < jmpCount; jmp++)
{
writer.WriteLine(" {0,4:X} : {1}", BitConverterBE.ReadAsInt32(code, jmpStart + jmp * 4, 4), low + jmp);
}
break;
case OpCodes.invokeinterface:
case OpCodes.invokedynamic:
index = (ushort)BitConverterBE.ReadAsInt32(code, i + 1, 2);
operandStr = pool[index].ToString();
break;
case OpCodes.newarray:
operandStr = ArrayTypes[code[i + 1]];
break;
case OpCodes.multianewarray:
index = (ushort)BitConverterBE.ReadAsInt32(code, i + 1, 2);
byte dismensions = code[i + 3];
operandStr = String.Format("{0}, {1}", dismensions, pool[index].ToString());
break;
}
;
break;
}
writer.WriteLine(" {0}", operandStr);
i += 1 + operandSize;
}
if (Program.DebugBytecode)
{
if (lnt != null)
{
codeAttr.Attributes.Remove(lnt);
}
codeAttr.Attributes.Add(newLnt);
}
}
