Problème de Décoder de la vidéo H264 sur RTP avec ffmpeg (libavcodec)

Dans RTP tous H264 I-Frames (Idr) sont généralement fragmentés. Lorsque vous recevez RTP, vous devez d'abord ignorer l'en-tête (généralement 12 premiers octets) et puis se rendre à la dernière unité (premier octet de la charge utile). Si la NALE est de 28 (1C), alors cela signifie que, à la suite de la charge utile représente un H264 IDR (I-Frame) fragment et que vous avez besoin de collecter tous d'entre eux pour reconstruire H264 IDR (I-Frame).

La Fragmentation se produit parce que le MTU, et beaucoup plus IDR. Un fragment peut ressembler à ceci:

Fragment qui a un DÉBUT BIT = 1:

First byte:  [ 3 NAL UNIT BITS | 5 FRAGMENT TYPE BITS] 
Second byte: [ START BIT | END BIT | RESERVED BIT | 5 NAL UNIT BITS] 
Other bytes: [... IDR FRAGMENT DATA...]

D'autres fragments:

First byte:  [ 3 NAL UNIT BITS | 5 FRAGMENT TYPE BITS]  
Other bytes: [... IDR FRAGMENT DATA...]

De reconstruire IDR vous devez collecter cette info:

int fragment_type = Data[0] & 0x1F;
int nal_type = Data[1] & 0x1F;
int start_bit = Data[1] & 0x80;
int end_bit = Data[1] & 0x40;

Si fragment_type == 28 puis charge la suite c'est un fragment de l'IDR. Prochain contrôle est start_bit ensemble, si elle l'est, alors que le fragment est le premier d'une séquence. Vous pouvez l'utiliser pour reconstruire IDR dernier octet en prenant les 3 premiers bits du premier octet de la charge utile (3 NAL UNIT BITS) et les combiner avec les 5 derniers bits du deuxième octet de la charge utile (5 NAL UNIT BITS) donc, vous obtiendrez un octet comme ce [3 NAL UNIT BITS | 5 NAL UNIT BITS]. Puis écrire que NAL octet d'abord dans un effacer la mémoire avec tous les autres suite d'octets à partir de ce fragment. N'oubliez pas de sauter le premier octet d'une séquence puisqu'il n'est pas une partie de l'IDR, mais identifie uniquement le fragment.

Si start_bit et end_bit sont 0, alors il suffit d'écrire la charge utile (en ignorant premier octet de la charge utile qui identifie le fragment) de la mémoire tampon.

Si start_bit est 0 et end_bit est de 1, ce qui signifie qu'il est le dernier fragment, et vous venez d'écrire, sa charge utile (en ignorant le premier octet qui identifie le fragment) de la mémoire tampon, et maintenant vous avez votre IDR reconstruit.

Si vous avez besoin d'un code, il suffit de demander dans un commentaire, je vais poster ça, mais je pense que c'est assez clair comment faire... =)

CONCERNANT LE DÉCODAGE

Il a traversé mon esprit aujourd'hui pourquoi vous obtenez une erreur sur le décodage de l'IDR (je présume que vous avez reconstruit bon). Comment construisez-vous votre AVC Decoder Enregistrement de la Configuration? La lib que vous utilisez sont automatiques? Sinon et si vous havent entendu parler de cela, continuer la lecture...

AVCDCR est spécifié pour permettre décodeurs pour analyser rapidement toutes les données dont ils ont besoin pour décoder le H264 (AVC) flux vidéo. Et les données est la suivante:

• ProfileIDC
• ProfileIOP
• LevelIDC
• SPS (Séquence de Jeux de paramètres)
• PPS (Image de Paramètre)

Toutes ces données sont envoyées dans RTSP session SDP sous le champs: profile-level-id et sprop-parameter-sets.

DÉCODAGE PROFIL-NIVEAU-ID

Prifile niveau de l'ID de chaîne est divisée en 3 sous-chaînes, chacune de 2 caractères:

[PROFILE IDC][PROFILE IOP][LEVEL IDC]

Chaque sous-chaîne représente un octet dans base16! Donc, si le Profil de l'IDC est de 28, ce qui signifie qu'il est actuellement de 40 en base10. Plus tard, vous allez utiliser base10 valeurs pour construire AVC Decoder Enregistrement de la Configuration.

DÉCODAGE SPROP-PARAMÈTRE-ENSEMBLES

Sprops sont généralement 2 cordes (peut être plus) qui sont séparées par des virgules, et encodées en base64! Vous pouvez décoder les deux d'entre eux, mais il n'est pas nécessaire. Votre travail ici est juste de les convertir en base64 une chaîne en un tableau d'octets pour une utilisation ultérieure. Maintenant, vous avez 2 tableaux d'octets, le premier tableau nous SPS, le second, est PPS.

LA CONSTRUCTION DE LA AVCDCR

Maintenant, vous avez tout ce que vous devez construire AVCDCR, vous commencez par faire un nouveau propre tampon, maintenant, écris ces choses dans l'ordre expliqué ici:

1 Octet qui a de la valeur 1 et représente la version

2 - Profil de l'IDC octet

3 - Prifile IOP octet

4 - Niveau IDC octet

5 Octets dont la valeur 0xFF (google AVC Decoder Configuration de l'Enregistrement pour voir ce que c'est)

6 Octets dont la valeur 0xE1

7 - Court avec la valeur de la SPS longueur du tableau

8 - SPS tableau d'octets

9 - Octet avec le nombre de PPS tableaux (vous pourriez avoir de plus en plus dans sprop-paramètre)

10 - Court avec la longueur de la suite PPS tableau

11 - PPS tableau

DÉCODAGE DE FLUX VIDÉO

Maintenant, vous avez le tableau d'octets qui indique au décodeur comment décoder les flux vidéo H264. Je crois que vous avez besoin de cette si votre lib n'est pas le construire lui-même à partir de SDP...

OriginalL'auteur Cipi

J'ai une mise en œuvre de cette @ https://net7mma.codeplex.com/ pour c#, mais le processus est le même partout.

Voici le code

///<summary>
///Implements Packetization and Depacketization of packets defined in <see href="https://tools.ietf.org/html/rfc6184">RFC6184</see>.
///</summary>
public class RFC6184Frame : Rtp.RtpFrame
{
///<summary>
///Emulation Prevention
///</summary>
static byte[] NalStart = { 0x00, 0x00, 0x01 };
public RFC6184Frame(byte payloadType) : base(payloadType) { }
public RFC6184Frame(Rtp.RtpFrame existing) : base(existing) { }
public RFC6184Frame(RFC6184Frame f) : this((Rtp.RtpFrame)f) { Buffer = f.Buffer; }
public System.IO.MemoryStream Buffer { get; set; }
///<summary>
///Creates any <see cref="Rtp.RtpPacket"/>'s required for the given nal
///</summary>
///<param name="nal">The nal</param>
///<param name="mtu">The mtu</param>
public virtual void Packetize(byte[] nal, int mtu = 1500)
{
if (nal == null) return;
int nalLength = nal.Length;
int offset = 0;
if (nalLength >= mtu)
{
//Make a Fragment Indicator with start bit
byte[] FUI = new byte[] { (byte)(1 << 7), 0x00 };
bool marker = false;
while (offset < nalLength)
{
//Set the end bit if no more data remains
if (offset + mtu > nalLength)
{
FUI[0] |= (byte)(1 << 6);
marker = true;
}
else if (offset > 0) //For packets other than the start
{
//No Start, No End
FUI[0] = 0;
}
//Add the packet
Add(new Rtp.RtpPacket(2, false, false, marker, PayloadTypeByte, 0, SynchronizationSourceIdentifier, HighestSequenceNumber + 1, 0, FUI.Concat(nal.Skip(offset).Take(mtu)).ToArray()));
//Move the offset
offset += mtu;
}
} //Should check for first byte to be 1 - 23?
else Add(new Rtp.RtpPacket(2, false, false, true, PayloadTypeByte, 0, SynchronizationSourceIdentifier, HighestSequenceNumber + 1, 0, nal));
}
///<summary>
///Creates <see cref="Buffer"/> with a H.264 RBSP from the contained packets
///</summary>
public virtual void Depacketize() { bool sps, pps, sei, slice, idr; Depacketize(out sps, out pps, out sei, out slice, out idr); }
///<summary>
///Parses all contained packets and writes any contained Nal Units in the RBSP to <see cref="Buffer"/>.
///</summary>
///<param name="containsSps">Indicates if a Sequence Parameter Set was found</param>
///<param name="containsPps">Indicates if a Picture Parameter Set was found</param>
///<param name="containsSei">Indicates if Supplementatal Encoder Information was found</param>
///<param name="containsSlice">Indicates if a Slice was found</param>
///<param name="isIdr">Indicates if a IDR Slice was found</param>
public virtual void Depacketize(out bool containsSps, out bool containsPps, out bool containsSei, out bool containsSlice, out bool isIdr)
{
containsSps = containsPps = containsSei = containsSlice = isIdr = false;
DisposeBuffer();
this.Buffer = new MemoryStream();
//Get all packets in the frame
foreach (Rtp.RtpPacket packet in m_Packets.Values.Distinct()) 
ProcessPacket(packet, out containsSps, out containsPps, out containsSei, out containsSlice, out isIdr);
//Order by DON?
this.Buffer.Position = 0;
}
///<summary>
///Depacketizes a single packet.
///</summary>
///<param name="packet"></param>
///<param name="containsSps"></param>
///<param name="containsPps"></param>
///<param name="containsSei"></param>
///<param name="containsSlice"></param>
///<param name="isIdr"></param>
internal protected virtual void ProcessPacket(Rtp.RtpPacket packet, out bool containsSps, out bool containsPps, out bool containsSei, out bool containsSlice, out bool isIdr)
{
containsSps = containsPps = containsSei = containsSlice = isIdr = false;
//Starting at offset 0
int offset = 0;
//Obtain the data of the packet (without source list or padding)
byte[] packetData = packet.Coefficients.ToArray();
//Cache the length
int count = packetData.Length;
//Must have at least 2 bytes
if (count <= 2) return;
//Determine if the forbidden bit is set and the type of nal from the first byte
byte firstByte = packetData[offset];
//bool forbiddenZeroBit = ((firstByte & 0x80) >> 7) != 0;
byte nalUnitType = (byte)(firstByte & Common.Binary.FiveBitMaxValue);
//o  The F bit MUST be cleared if all F bits of the aggregated NAL units are zero; otherwise, it MUST be set.
//if (forbiddenZeroBit && nalUnitType <= 23 && nalUnitType > 29) throw new InvalidOperationException("Forbidden Zero Bit is Set.");
//Determine what to do
switch (nalUnitType)
{
//Reserved - Ignore
case 0:
case 30:
case 31:
{
return;
}
case 24: //STAP - A
case 25: //STAP - B
case 26: //MTAP - 16
case 27: //MTAP - 24
{
//Move to Nal Data
++offset;
//Todo Determine if need to Order by DON first.
//EAT DON for ALL BUT STAP - A
if (nalUnitType != 24) offset += 2;
//Consume the rest of the data from the packet
while (offset < count)
{
//Determine the nal unit size which does not include the nal header
int tmp_nal_size = Common.Binary.Read16(packetData, offset, BitConverter.IsLittleEndian);
offset += 2;
//If the nal had data then write it
if (tmp_nal_size > 0)
{
//For DOND and TSOFFSET
switch (nalUnitType)
{
case 25://MTAP - 16
{
//SKIP DOND and TSOFFSET
offset += 3;
goto default;
}
case 26://MTAP - 24
{
//SKIP DOND and TSOFFSET
offset += 4;
goto default;
}
default:
{
//Read the nal header but don't move the offset
byte nalHeader = (byte)(packetData[offset] & Common.Binary.FiveBitMaxValue);
if (nalHeader > 5)
{
if (nalHeader == 6)
{
Buffer.WriteByte(0);
containsSei = true;
}
else if (nalHeader == 7)
{
Buffer.WriteByte(0);
containsPps = true;
}
else if (nalHeader == 8)
{
Buffer.WriteByte(0);
containsSps = true;
}
}
if (nalHeader == 1) containsSlice = true;
if (nalHeader == 5) isIdr = true;
//Done reading
break;
}
}
//Write the start code
Buffer.Write(NalStart, 0, 3);
//Write the nal header and data
Buffer.Write(packetData, offset, tmp_nal_size);
//Move the offset past the nal
offset += tmp_nal_size;
}
}
return;
}
case 28: //FU - A
case 29: //FU - B
{
/*
Informative note: When an FU-A occurs in interleaved mode, it
always follows an FU-B, which sets its DON.
* Informative note: If a transmitter wants to encapsulate a single
NAL unit per packet and transmit packets out of their decoding
order, STAP-B packet type can be used.
*/
//Need 2 bytes
if (count > 2)
{
//Read the Header
byte FUHeader = packetData[++offset];
bool Start = ((FUHeader & 0x80) >> 7) > 0;
//bool End = ((FUHeader & 0x40) >> 6) > 0;
//bool Receiver = (FUHeader & 0x20) != 0;
//if (Receiver) throw new InvalidOperationException("Receiver Bit Set");
//Move to data
++offset;
//Todo Determine if need to Order by DON first.
//DON Present in FU - B
if (nalUnitType == 29) offset += 2;
//Determine the fragment size
int fragment_size = count - offset;
//If the size was valid
if (fragment_size > 0)
{
//If the start bit was set
if (Start)
{
//Reconstruct the nal header
//Use the first 3 bits of the first byte and last 5 bites of the FU Header
byte nalHeader = (byte)((firstByte & 0xE0) | (FUHeader & Common.Binary.FiveBitMaxValue));
//Could have been SPS /PPS /SEI
if (nalHeader > 5)
{
if (nalHeader == 6)
{
Buffer.WriteByte(0);
containsSei = true;
}
else if (nalHeader == 7)
{
Buffer.WriteByte(0);
containsPps = true;
}
else if (nalHeader == 8)
{
Buffer.WriteByte(0);
containsSps = true;
}
}
if (nalHeader == 1) containsSlice = true;
if (nalHeader == 5) isIdr = true;
//Write the start code
Buffer.Write(NalStart, 0, 3);
//Write the re-construced header
Buffer.WriteByte(nalHeader);
}
//Write the data of the fragment.
Buffer.Write(packetData, offset, fragment_size);
}
}
return;
}
default:
{
//6 SEI, 7 and 8 are SPS and PPS
if (nalUnitType > 5)
{
if (nalUnitType == 6)
{
Buffer.WriteByte(0);
containsSei = true;
}
else if (nalUnitType == 7)
{
Buffer.WriteByte(0);
containsPps = true;
}
else if (nalUnitType == 8)
{
Buffer.WriteByte(0);
containsSps = true;
}
}
if (nalUnitType == 1) containsSlice = true;
if (nalUnitType == 5) isIdr = true;
//Write the start code
Buffer.Write(NalStart, 0, 3);
//Write the nal heaer and data data
Buffer.Write(packetData, offset, count - offset);
return;
}
}
}
internal void DisposeBuffer()
{
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
public override void Dispose()
{
if (Disposed) return;
base.Dispose();
DisposeBuffer();
}
//To go to an Image...
//Look for a SliceHeader in the Buffer
//Decode Macroblocks in Slice
//Convert Yuv to Rgb
}

Il y a aussi des implémentations pour diverses autres RFC), qui aident à mettre les médias à jouer dans un MediaElement ou dans d'autres logiciels ou tout simplement l'enregistrer sur le disque.

Écrit à un format de conteneur est en cours.

OriginalL'auteur Jay