private void WritePage()
{
if (_packetList.Count == 0)
{
return;
}
FlushPage(false);
WriteToPage(BitConverterBE.GetBytes(0x4F676753U), 0, 4); // "OggS"
WriteToPage((byte)0); // Stream structure version
WriteToPage((byte)(_pageSequenceNumber == 0 ? 0x02 : 0)); // Page flags
WriteToPage((ulong)_packetList[_packetList.Count - 1].GranulePosition); // Position in samples
WriteToPage((uint)_serialNumber); // Stream serial number
WriteToPage((uint)_pageSequenceNumber); // Page sequence number
WriteToPage((uint)0); // Checksum
WriteToPage((byte)_packetList.Count); // Page segment count
foreach (var packet in _packetList)
{
WriteToPage((byte)packet.Data.Length);
}
foreach (var packet in _packetList)
{
WriteToPage(packet.Data, 0, packet.Data.Length);
}
_packetList.Clear();
_packetListDataSize = 0;
_pageSequenceNumber++;
}
private uint ReadUInt32()
{
var x = new byte[4];
_fs.Read(x, 0, 4);
_fileOffset += 4;
return(BitConverterBE.ToUInt32(x, 0));
}
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 bitrate 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((uint)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((uint)_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);
}
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;
}
int offset, spsCount, ppsCount;
offset = 8;
_nalLengthSize = (chunk[offset++] & 0x03) + 1;
spsCount = chunk[offset++] & 0x1F;
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 ?
(int)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;
}
}
}
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)
{
ulong header;
int mpegVersion, layer, bitRate, sampleRate, padding, channelMode;
int frameLen;
header = (ulong)BitConverterBE.ToUInt32(buff, offset) << 32;
if (BitHelper.Read(ref header, 11) != 0x7FF)
{
break;
}
mpegVersion = BitHelper.Read(ref header, 2);
layer = BitHelper.Read(ref header, 2);
BitHelper.Read(ref header, 1);
bitRate = BitHelper.Read(ref header, 4);
sampleRate = BitHelper.Read(ref header, 2);
padding = BitHelper.Read(ref header, 1);
BitHelper.Read(ref header, 1);
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];
}
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 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);
}
}
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);
int format;
if (BitHelper.Read(ref x, 1) != 1)
{
return;
}
BitHelper.Read(ref x, 5);
BitHelper.Read(ref x, 8);
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);
var quant = BitHelper.Read(ref x, 6);
var separatedCoeffFlag = BitHelper.Read(ref x, 1);
var subVersion = BitHelper.Read(ref x, 5);
var filterHeader = BitHelper.Read(ref x, 2);
var interlacedFlag = BitHelper.Read(ref x, 1);
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(String.Format("Suggested cropping: {0} pixels from right, {1} pixels from bottom.", cropX, cropY));
}
}
}
}
public void WriteChunk(byte[] chunk, uint timeStamp, int frameType)
{
int offset, len;
offset = 0;
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 ? (uint)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++;
if (_alphaWriter != null)
{
_alphaWriter.WriteChunk(chunk, timeStamp, frameType);
}
}
