c# - Manipular un Adaptive IInputStream(MPEG-DASH) sobre la marcha

uwp binaryreader

Question

Esta es la primera vez que hago una pregunta aquí y no pude encontrar nada en la función de búsqueda.

El problema:

Estoy recibiendo (a través de HttpClient ) un IInputStream (Segmentos MP4). El problema es que mi MediaPlayer no lo reproduce porque estos segmentos MP4 contienen un solo átomo que causa un error ERR_FILETYPE_NOT_SUPPORTED .

Entonces, si UUID | Position: moov -> trak -> mdia -> minf -> stbl -> stsd -> encv -> sinf -> schi -> uui manualmente este Atom ( UUID | Position: moov -> trak -> mdia -> minf -> stbl -> stsd -> encv -> sinf -> schi -> uui ) funciona perfectamente bien.

El problema es que, como tengo un flujo adaptable, tengo que modificar esos segmentos (aproximadamente 1250 por película) sobre la marcha antes de enviarlo a AdaptiveMediaSource, y no puedo hacer que esto funcione correctamente.

Código:

 using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Threading.Tasks;
using Windows.Storage.Streams;
using static System.Diagnostics.Debug;
namespace BlackMagic
{
public class EvilVoodooClass
{
private static readonly bool _commitFlag = false;
/// <summary>
/// MP4 File parser
/// </summary>
/// <param name="awsInputStream"></param>
public static async Task<Stream> ParseFile(IInputStream awsInputStream)
{
int moovPos = 0, moovSize = 0;
int trakPos = 0, trakSize = 0;
int mdiaPos = 0, mdiaSize = 0;
int minfPos = 0, minfSize = 0;
int stblPos = 0, stblSize = 0;
int stsdPos = 0, stsdSize = 0;
int encvPos = 0, encvSize = 0;
int sinfPos = 0, sinfSize = 0;
int schiPos = 0, schiSize = 0;
int uuidPos = 0, uuidSize = 0;
var bufferSize = new Windows.Storage.Streams.Buffer(200000);
var readBuffer = await awsInputStream.ReadAsync(bufferSize, 200000, InputStreamOptions.ReadAhead);
var tempInputStream = readBuffer.AsStream();
var tempOutStream = readBuffer.AsStream();
WriteLine("Parsing segment... ");
using (var br = new BinaryReader(tempInputStream))
{
var originalFilelength = (int)br.BaseStream.Length;
WriteLine($"original File length: {originalFilelength}");
br.BaseStream.Seek(4, SeekOrigin.Begin);
if ("ftypiso6" == Encoding.ASCII.GetString(br.ReadBytes(8)))
{
FindAtom(br, 0, "moov", ref moovPos, ref moovSize);
WriteLine($"found moov at position: {moovPos} / size: {moovSize}");
FindAtom(br, moovPos + 8, "trak", ref trakPos, ref trakSize);
WriteLine($"found trak at position: {trakPos} / size: {trakSize}");
FindAtom(br, trakPos + 8, "mdia", ref mdiaPos, ref mdiaSize);
WriteLine($"found mdiaPos at position: {mdiaPos} / size: {mdiaSize}");
FindAtom(br, moovPos + 8, "minf", ref minfPos, ref minfSize);
WriteLine($"found minfPos at position: {minfPos} / size: {minfSize}");
FindAtom(br, minfPos + 8, "stbl", ref stblPos, ref stblSize);
WriteLine($"found stblPos at position: {stblPos} / size: {stblSize}");
FindAtom(br, stblPos + 8, "stsd", ref stsdPos, ref stsdSize);
WriteLine($"found stsdSize at position: {stsdPos} / size: {stsdSize}");
// Breakpoint
FindAtom(br, stsdPos + 8, "encv", ref encvPos, ref encvSize);
WriteLine($"found encvSize at position: {encvPos} / size: {encvSize}");
FindAtom(br, encvPos + 8, "sinf", ref sinfPos, ref sinfSize);
WriteLine($"found sinfPos at position: {sinfPos} / size: {sinfSize}");
FindAtom(br, sinfPos + 8, "schi", ref schiPos, ref schiSize);
WriteLine($"found schiSize at position: {schiPos} / size: {schiSize}");
FindAtom(br, schiPos, "uuid", ref uuidPos, ref uuidSize);
WriteLine($"found UU--ID at position: {uuidPos} / size: {uuidSize}");
br.BaseStream.Seek(0, SeekOrigin.Begin);
if (uuidPos == 0)
{
WriteLine(" [No UUID Atom found]");
return tempOutStream;
}
WriteLine("[UUID Atom found]");
if (!_commitFlag) return tempOutStream;
WriteLine("Rewriting segments... ");
try
{
br.BaseStream.Seek(moovPos, SeekOrigin.Begin);
var uuidBuffer = br.ReadBytes(moovSize);
if (BufferArrayFindTag(ref uuidBuffer, "uuid", ref uuidPos, ref uuidSize))
CleanUuid(ref uuidBuffer, uuidPos, uuidSize);
UpdateUuidSize(ref uuidBuffer);
using (var binWri = new BinaryWriter(tempOutStream))
{
br.BaseStream.Seek(0, SeekOrigin.Begin);
BufferedBinaryCopy(br, binWri, moovPos);
if (uuidBuffer.Length > 8) binWri.Write(uuidBuffer);
br.BaseStream.Seek(moovSize, SeekOrigin.Current);
BufferedBinaryCopy(br, binWri, originalFilelength - (moovPos + moovSize));
}
WriteLine("FIXED!");
return tempOutStream;
}
catch
{
WriteLine(" --FAILED--");
return tempOutStream;
}
}
else
{
WriteLine("[No MP4 Segment] ");
return tempOutStream;
}
}
}
public static bool BufferedBinaryCopy(BinaryReader source, BinaryWriter destination, int length)
{
const int iobufferSize = 32 * 1024 * 1024;
var bytesLeft = length;
while (bytesLeft > 0)
{
var bytesToRead = Math.Min(iobufferSize, bytesLeft);
var buffer = source.ReadBytes(bytesToRead);
bytesLeft -= buffer.Length;
destination.Write(buffer);
}
return true;
}
public static bool FindAtom(BinaryReader br, int offset, string tag, ref int pos, ref int size)
{
try
{
br.BaseStream.Seek(offset, SeekOrigin.Begin);
while (br.BaseStream.Position < br.BaseStream.Length - 8)
{
var tagdata = br.ReadBytes(4);
Array.Reverse(tagdata);
var tagsize = (int)BitConverter.ToUInt32(tagdata, 0);
if (tagsize == 1)
{
var exdata = br.ReadBytes(4);
Array.Reverse(exdata);
tagsize = (tagsize << 32) + (int)BitConverter.ToUInt32(exdata, 0);
}
tagdata = br.ReadBytes(4);
var tagname = Encoding.ASCII.GetString(tagdata);
if (tagname == tag)
{
pos = (int)br.BaseStream.Position - 8;
size = tagsize;
return true;
}
if (tagsize == 0)
return false;
br.BaseStream.Seek(tagsize - 8, SeekOrigin.Current);
}
}
catch (Exception ex)
{
WriteLine(ex.ToString());
}
return false;
}
public static void CleanUuid(ref byte[] buffer, int pos, int size)
{
var lb = buffer.ToList();
lb.RemoveRange(pos, size);
buffer = lb.ToArray();
}
public static void UpdateUuidSize(ref byte[] buffer)
{
var bufferLength = buffer.Length;
var tagsize = BitConverter.GetBytes(bufferLength);
Array.Reverse(tagsize);
var lb = buffer.ToList();
lb.RemoveRange(0, 4);
lb.InsertRange(0, tagsize);
buffer = lb.ToArray();
}
public static bool RewriteFile(ref BinaryReader input, long udtaPos, long udtaSize, long metaPos, long metaSize,
long xtraPos, long xtraSize)
{
var tempname = string.Format(@"{0}.txt", Guid.NewGuid());
using (var b = new BinaryWriter(File.Open("tempname", FileMode.Create, FileAccess.Read)))
{
//throw new NotImplementedException();
}
return true;
}
public static bool BufferArrayFindTag(ref byte[] bb, string tag, ref int tagPos, ref int tagSize)
{
var pattern = Encoding.UTF8.GetBytes(tag);
var byteIndex = BufferArrayIndexOf(bb, pattern);
if (byteIndex < 0) return false;
tagPos = byteIndex - 4;
tagSize = (bb[byteIndex - 4] << 24) | (bb[byteIndex - 3] << 16) | (bb[byteIndex - 2] << 8) | bb[byteIndex - 1];
return true;
}
public static int BufferArrayIndexOf(byte[] data, byte[] pattern)
{
if (pattern.Length > data.Length) return -1;
for (var i = 0; i < data.Length - pattern.Length; i++)
{
var found = !pattern.Where((t, j) => data[i + j] != t).Any();
if (found) return i;
}
return -1;
}
}

}

hm ... ¿Cómo podría resolver este problema? ¿alguna pista?

Answer 1

Creo que puedes implementar una clase Stream tú mismo. Cuando alguien lee su transmisión, lee el IInputStream original y lo manipula y devuelve el resultado a la persona que llama.

Por cierto, si agrega "using System.IO", será muy fácil convertir .NET Streams ao desde Windows Streams.