title: Convert Rtsp Packet to bitmap in c#
body: <p>Hello Every on I have implemented SharpRtsp in c# <a href="https://github.com/ngraziano/SharpRTSP" rel="nofollow noreferrer">https://github.com/ngraziano/SharpRTSP</a>
  I am receiving rtsp Packets and it has h264 format It has following method in H264Payload Class</p>
  
  <pre><code>private List&lt;byte[]&gt; Process_H264_RTP_Frame(List&lt;byte[]&gt; rtp_payloads)
          {
              Console.WriteLine("RTP Data comprised of " + rtp_payloads.Count + " rtp packets");
  
              List&lt;byte[]&gt; nal_units = new List&lt;byte[]&gt;(); // Stores the NAL units for a Video Frame. May be more than one NAL unit in a video frame.
  
              for (int payload_index = 0; payload_index &lt; rtp_payloads.Count; payload_index++)
              {
                  // Examine the first rtp_payload and the first byte (the NAL header)
                  int nal_header_f_bit = (rtp_payloads[payload_index][0] &gt;&gt; 7) &amp; 0x01;
                  int nal_header_nri = (rtp_payloads[payload_index][0] &gt;&gt; 5) &amp; 0x03;
                  int nal_header_type = (rtp_payloads[payload_index][0] &gt;&gt; 0) &amp; 0x1F;
  
                  // If the Nal Header Type is in the range 1..23 this is a normal NAL (not fragmented)
                  // So write the NAL to the file
                  if (nal_header_type &gt;= 1 &amp;&amp; nal_header_type &lt;= 23)
                  {
                      Console.WriteLine("Normal NAL");
                      norm++;
                      nal_units.Add(rtp_payloads[payload_index]);
                  }
                  // There are 4 types of Aggregation Packet (split over RTP payloads)
                  else if (nal_header_type == 24)
                  {
                      Console.WriteLine("Agg STAP-A");
                      stap_a++;
  
                      // RTP packet contains multiple NALs, each with a 16 bit header
                      //   Read 16 byte size
                      //   Read NAL
                      try
                      {
                          int ptr = 1; // start after the nal_header_type which was '24'
                          // if we have at least 2 more bytes (the 16 bit size) then consume more data
                          while (ptr + 2 &lt; (rtp_payloads[payload_index].Length - 1))
                          {
                              int size = (rtp_payloads[payload_index][ptr] &lt;&lt; 8) + (rtp_payloads[payload_index][ptr + 1] &lt;&lt; 0);
                              ptr = ptr + 2;
                              byte[] nal = new byte[size];
                              System.Array.Copy(rtp_payloads[payload_index], ptr, nal, 0, size); // copy the NAL
                              nal_units.Add(nal); // Add to list of NALs for this RTP frame. Start Codes like 00 00 00 01 get added later
                              ptr = ptr + size;
                          }
                      }
                      catch
                      {
                          // do nothing
                      }
                  }
                  else if (nal_header_type == 25)
                  {
                      Console.WriteLine("Agg STAP-B not supported");
                      stap_b++;
                  }
                  else if (nal_header_type == 26)
                  {
                      Console.WriteLine("Agg MTAP16 not supported");
                      mtap16++;
                  }
                  else if (nal_header_type == 27)
                  {
                      Console.WriteLine("Agg MTAP24 not supported");
                      mtap24++;
                  }
                  else if (nal_header_type == 28)
                  {
                      Console.WriteLine("Frag FU-A");
                      fu_a++;
  
                      // Parse Fragmentation Unit Header
                      int fu_header_s = (rtp_payloads[payload_index][1] &gt;&gt; 7) &amp; 0x01;  // start marker
                      int fu_header_e = (rtp_payloads[payload_index][1] &gt;&gt; 6) &amp; 0x01;  // end marker
                      int fu_header_r = (rtp_payloads[payload_index][1] &gt;&gt; 5) &amp; 0x01;  // reserved. should be 0
                      int fu_header_type = (rtp_payloads[payload_index][1] &gt;&gt; 0) &amp; 0x1F; // Original NAL unit header
  
                      Console.WriteLine("Frag FU-A s=" + fu_header_s + "e=" + fu_header_e);
  
                      // Check Start and End flags
                      if (fu_header_s == 1 &amp;&amp; fu_header_e == 0)
                      {
                          // Start of Fragment.
                          // Initiise the fragmented_nal byte array
                          // Build the NAL header with the original F and NRI flags but use the the Type field from the fu_header_type
                          byte reconstructed_nal_type = (byte)((nal_header_f_bit &lt;&lt; 7) + (nal_header_nri &lt;&lt; 5) + fu_header_type);
  
                          // Empty the stream
                          fragmented_nal.SetLength(0);
  
                          // Add reconstructed_nal_type byte to the memory stream
                          fragmented_nal.WriteByte(reconstructed_nal_type);
  
                          // copy the rest of the RTP payload to the memory stream
                          fragmented_nal.Write(rtp_payloads[payload_index], 2, rtp_payloads[payload_index].Length - 2);
                      }
  
                      if (fu_header_s == 0 &amp;&amp; fu_header_e == 0)
                      {
                          // Middle part of Fragment
                          // Append this payload to the fragmented_nal
                          // Data starts after the NAL Unit Type byte and the FU Header byte
                          fragmented_nal.Write(rtp_payloads[payload_index], 2, rtp_payloads[payload_index].Length - 2);
                      }
  
                      if (fu_header_s == 0 &amp;&amp; fu_header_e == 1)
                      {
                          // End part of Fragment
                          // Append this payload to the fragmented_nal
                          // Data starts after the NAL Unit Type byte and the FU Header byte
                          fragmented_nal.Write(rtp_payloads[payload_index], 2, rtp_payloads[payload_index].Length - 2);
  
                          // Add the NAL to the array of NAL units
                          nal_units.Add(fragmented_nal.ToArray());
                      }
                  }
  
                  else if (nal_header_type == 29)
                  {
                      Console.WriteLine("Frag FU-B not supported");
                      fu_b++;
                  }
                  else
                  {
                      Console.WriteLine("Unknown NAL header " + nal_header_type + " not supported");
                  }
  
              }
  
              // Output some statistics
              Console.WriteLine("Norm=" + norm + " ST-A=" + stap_a + " ST-B=" + stap_b + " M16=" + mtap16 + " M24=" + mtap24 + " FU-A=" + fu_a + " FU-B=" + fu_b);
  
              // Output all the NALs that form one RTP Frame (one frame of video)
              return nal_units;
  
          }
  
  
      }
  </code></pre>
  
  <p>I have triew and done reading but i have not found any way to convert H264 Frame into bitmap I just want it to save as bitmaps can any body help me o convert this data to bitmap?</p>