Recherche avancée
Autres articles (103)
-
Creating farms of unique websites
13 avril 2011, parMediaSPIP platforms can be installed as a farm, with a single "core" hosted on a dedicated server and used by multiple websites.
This allows (among other things) : implementation costs to be shared between several different projects / individuals rapid deployment of multiple unique sites creation of groups of like-minded sites, making it possible to browse media in a more controlled and selective environment than the major "open" (...) -
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir -
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs
Sur d’autres sites (13420)
-
FFmpeg.Autogen : Issue with Zero-Sized Atom Boxes in MP4 Output
16 juin 2024, par Alexander JanssonI just started learning ffmpeg using ffmpeg.autogen wrapper version 5.1 in c#, and ffmpeg shared libs version 5.1. Im trying to facilitate a class which screenrecords using gdigrab and produces streamable mp4 to a/an buffer/event. Everything seems to work as suposed to with no error except that the outputstream produces atom boxes with 0 in size thus small file size aswell, no data seems to be produced in the boxes, the "debug test mp4 file" is analyzed with MP4Box and the box info is provided in the thread.


To be more specific why does this code produce empty atomboxes, is someone able to make the data produced actually contain any frame data from the gdigrab editing my code ?


`code :


public unsafe class ScreenStreamer : IDisposable
 {
 private readonly AVCodec* productionCodec;
 private readonly AVCodec* screenCaptureAVCodec;
 private readonly AVCodecContext* productionAVCodecContext;
 private readonly AVFormatContext* productionFormatContext;
 private readonly AVCodecContext* screenCaptureAVCodecContext;
 private readonly AVDictionary* productionAVCodecOptions;
 private readonly AVInputFormat* screenCaptureInputFormat;
 private readonly AVFormatContext* screenCaptureInputFormatContext;
 private readonly int gDIGrabVideoStreamIndex;
 private readonly System.Drawing.Size screenBounds;
 private readonly int _produceAtleastAmount;
 public EventHandler OnNewVideoDataProduced;
 private MemoryStream unsafeToManagedBridgeBuffer;
 private CancellationTokenSource cancellationTokenSource;
 private Task recorderTask;

 public ScreenStreamer(int fps, int bitrate, int screenIndex, int produceAtleastAmount = 1000)
 {
 ffmpeg.avdevice_register_all();
 ffmpeg.avformat_network_init();
 recorderTask = Task.CompletedTask;
 cancellationTokenSource = new CancellationTokenSource();
 unsafeToManagedBridgeBuffer = new MemoryStream();
 _produceAtleastAmount = produceAtleastAmount;

 // Allocate and initialize production codec and context
 productionCodec = ffmpeg.avcodec_find_encoder(AVCodecID.AV_CODEC_ID_H264);
 if (productionCodec == null) throw new ApplicationException("Could not find encoder for codec ID H264.");

 productionAVCodecContext = ffmpeg.avcodec_alloc_context3(productionCodec);
 if (productionAVCodecContext == null) throw new ApplicationException("Could not allocate video codec context.");

 // Set codec parameters
 screenBounds = RetrieveScreenBounds(screenIndex);
 productionAVCodecContext->width = screenBounds.Width;
 productionAVCodecContext->height = screenBounds.Height;
 productionAVCodecContext->time_base = new AVRational() { den = fps, num = 1 };
 productionAVCodecContext->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
 productionAVCodecContext->bit_rate = bitrate;

 int result = ffmpeg.av_opt_set(productionAVCodecContext->priv_data, "preset", "veryfast", 0);
 if (result != 0)
 {
 throw new ApplicationException($"Failed to set options with error code {result}.");
 }

 // Open codec
 fixed (AVDictionary** pm = &productionAVCodecOptions)
 {
 result = ffmpeg.av_dict_set(pm, "movflags", "frag_keyframe+empty_moov+default_base_moof", 0);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to set dictionary with error code {result}.");
 }

 result = ffmpeg.avcodec_open2(productionAVCodecContext, productionCodec, pm);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to open codec with error code {result}.");
 }
 }

 // Allocate and initialize screen capture codec and context
 screenCaptureInputFormat = ffmpeg.av_find_input_format("gdigrab");
 if (screenCaptureInputFormat == null) throw new ApplicationException("Could not find input format gdigrab.");

 fixed (AVFormatContext** ps = &screenCaptureInputFormatContext)
 {
 result = ffmpeg.avformat_open_input(ps, "desktop", screenCaptureInputFormat, null);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to open input with error code {result}.");
 }

 result = ffmpeg.avformat_find_stream_info(screenCaptureInputFormatContext, null);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to find stream info with error code {result}.");
 }
 }

 gDIGrabVideoStreamIndex = -1;
 for (int i = 0; i < screenCaptureInputFormatContext->nb_streams; i++)
 {
 if (screenCaptureInputFormatContext->streams[i]->codecpar->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
 {
 gDIGrabVideoStreamIndex = i;
 break;
 }
 }

 if (gDIGrabVideoStreamIndex < 0)
 {
 throw new ApplicationException("Failed to find video stream in input.");
 }

 AVCodecParameters* codecParameters = screenCaptureInputFormatContext->streams[gDIGrabVideoStreamIndex]->codecpar;
 screenCaptureAVCodec = ffmpeg.avcodec_find_decoder(codecParameters->codec_id);
 if (screenCaptureAVCodec == null)
 {
 throw new ApplicationException("Could not find decoder for screen capture.");
 }

 screenCaptureAVCodecContext = ffmpeg.avcodec_alloc_context3(screenCaptureAVCodec);
 if (screenCaptureAVCodecContext == null)
 {
 throw new ApplicationException("Could not allocate screen capture codec context.");
 }

 result = ffmpeg.avcodec_parameters_to_context(screenCaptureAVCodecContext, codecParameters);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to copy codec parameters to context with error code {result}.");
 }

 result = ffmpeg.avcodec_open2(screenCaptureAVCodecContext, screenCaptureAVCodec, null);
 if (result < 0)
 {
 throw new ApplicationException($"Failed to open screen capture codec with error code {result}.");
 }
 }

 public void Start()
 {
 recorderTask = Task.Run(() =>
 {
 AVPacket* packet = ffmpeg.av_packet_alloc();
 AVFrame* rawFrame = ffmpeg.av_frame_alloc();
 AVFrame* compatibleFrame = null;
 byte* dstBuffer = null;

 try
 {
 while (!cancellationTokenSource.Token.IsCancellationRequested)
 {
 if (ffmpeg.av_read_frame(screenCaptureInputFormatContext, packet) >= 0)
 {
 if (packet->stream_index == gDIGrabVideoStreamIndex)
 {
 int response = ffmpeg.avcodec_send_packet(screenCaptureAVCodecContext, packet);
 if (response < 0)
 {
 throw new ApplicationException($"Error while sending a packet to the decoder: {response}");
 }

 response = ffmpeg.avcodec_receive_frame(screenCaptureAVCodecContext, rawFrame);
 if (response == ffmpeg.AVERROR(ffmpeg.EAGAIN) || response == ffmpeg.AVERROR_EOF)
 {
 continue;
 }
 else if (response < 0)
 {
 throw new ApplicationException($"Error while receiving a frame from the decoder: {response}");
 }

 compatibleFrame = ConvertToCompatiblePixelFormat(rawFrame, out dstBuffer);

 response = ffmpeg.avcodec_send_frame(productionAVCodecContext, compatibleFrame);
 if (response < 0)
 {
 throw new ApplicationException($"Error while sending a frame to the encoder: {response}");
 }

 while (response >= 0)
 {
 response = ffmpeg.avcodec_receive_packet(productionAVCodecContext, packet);
 if (response == ffmpeg.AVERROR(ffmpeg.EAGAIN) || response == ffmpeg.AVERROR_EOF)
 {
 break;
 }
 else if (response < 0)
 {
 throw new ApplicationException($"Error while receiving a packet from the encoder: {response}");
 }

 using var packetStream = new UnmanagedMemoryStream(packet->data, packet->size);
 packetStream.CopyTo(unsafeToManagedBridgeBuffer);
 byte[] managedBytes = unsafeToManagedBridgeBuffer.ToArray();
 OnNewVideoDataProduced?.Invoke(this, managedBytes);
 unsafeToManagedBridgeBuffer.SetLength(0);
 }
 }
 }
 ffmpeg.av_packet_unref(packet);
 ffmpeg.av_frame_unref(rawFrame);
 if (compatibleFrame != null)
 {
 ffmpeg.av_frame_unref(compatibleFrame);
 ffmpeg.av_free(dstBuffer);
 }
 }
 }
 finally
 {
 ffmpeg.av_packet_free(&packet);
 ffmpeg.av_frame_free(&rawFrame);
 if (compatibleFrame != null)
 {
 ffmpeg.av_frame_free(&compatibleFrame);
 }
 }
 });
 }

 public AVFrame* ConvertToCompatiblePixelFormat(AVFrame* srcFrame, out byte* dstBuffer)
 {
 AVFrame* dstFrame = ffmpeg.av_frame_alloc();
 int buffer_size = ffmpeg.av_image_get_buffer_size(productionAVCodecContext->pix_fmt, productionAVCodecContext->width, productionAVCodecContext->height, 1);
 byte_ptrArray4 dstData = new byte_ptrArray4();
 int_array4 dstLinesize = new int_array4();
 dstBuffer = (byte*)ffmpeg.av_malloc((ulong)buffer_size);
 ffmpeg.av_image_fill_arrays(ref dstData, ref dstLinesize, dstBuffer, productionAVCodecContext->pix_fmt, productionAVCodecContext->width, productionAVCodecContext->height, 1);

 dstFrame->format = (int)productionAVCodecContext->pix_fmt;
 dstFrame->width = productionAVCodecContext->width;
 dstFrame->height = productionAVCodecContext->height;
 dstFrame->data.UpdateFrom(dstData);
 dstFrame->linesize.UpdateFrom(dstLinesize);

 SwsContext* swsCtx = ffmpeg.sws_getContext(
 srcFrame->width, srcFrame->height, (AVPixelFormat)srcFrame->format,
 productionAVCodecContext->width, productionAVCodecContext->height, productionAVCodecContext->pix_fmt,
 ffmpeg.SWS_BILINEAR, null, null, null);

 if (swsCtx == null)
 {
 throw new ApplicationException("Could not initialize the conversion context.");
 }

 ffmpeg.sws_scale(swsCtx, srcFrame->data, srcFrame->linesize, 0, srcFrame->height, dstFrame->data, dstFrame->linesize);
 ffmpeg.sws_freeContext(swsCtx);
 return dstFrame;
 }

 private System.Drawing.Size RetrieveScreenBounds(int screenIndex)
 {
 return new System.Drawing.Size(1920, 1080);
 }

 public void Dispose()
 {
 cancellationTokenSource?.Cancel();
 recorderTask?.Wait();
 cancellationTokenSource?.Dispose();
 recorderTask?.Dispose();
 unsafeToManagedBridgeBuffer?.Dispose();

 fixed (AVCodecContext** p = &productionAVCodecContext)
 {
 if (*p != null)
 {
 ffmpeg.avcodec_free_context(p);
 }
 }
 fixed (AVCodecContext** p = &screenCaptureAVCodecContext)
 {
 if (*p != null)
 {
 ffmpeg.avcodec_free_context(p);
 }
 }

 if (productionFormatContext != null)
 {
 ffmpeg.avformat_free_context(productionFormatContext);
 }

 if (screenCaptureInputFormatContext != null)
 {
 ffmpeg.avformat_free_context(screenCaptureInputFormatContext);
 }

 if (productionAVCodecOptions != null)
 {
 fixed (AVDictionary** p = &productionAVCodecOptions)
 {
 ffmpeg.av_dict_free(p);
 }
 }
 }
 }


I call Start method and wait 8 econds, out of scope I write the bytes to an mp4 file without using the write trailer just to debug the atomboxes. and the mp4 debugging box output I got :


(Full OUTPUT)
https://pastebin.com/xkM4MfG7



(Not full)




"
<boxes>
<uuidbox size="0" type="uuid" uuid="{00000000-00000000-00000000-00000000}" specification="unknown" container="unknown">
</uuidbox>
<trackreferencetypebox size="0" type="cdsc" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="hint" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="font" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="hind" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="vdep" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="vplx" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="subt" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="thmb" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="mpod" specification="p14" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="dpnd" specification="p14" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="sync" specification="p14" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="ipir" specification="p14" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="sbas" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="scal" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="tbas" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="sabt" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="oref" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="adda" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="adrc" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="iloc" specification="p12" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="avcp" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="swto" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="swfr" specification="p15" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="chap" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="tmcd" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="cdep" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="scpt" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="ssrc" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<trackreferencetypebox size="0" type="lyra" specification="apple" container="tref">
<trackreferenceentry trackid=""></trackreferenceentry>
</trackreferencetypebox>
<itemreferencebox size="0" type="tbas" specification="p12" container="iref">
<itemreferenceboxentry itemid=""></itemreferenceboxentry>
</itemreferencebox>
<itemreferencebox size="0" type="iloc" specification="p12" container="iref">
<itemreferenceboxentry itemid=""></itemreferenceboxentry>
</itemreferencebox>
<itemreferencebox size="0" type="fdel" specification="p12" container="iref">
<itemreferenceboxentry itemid=""></itemreferenceboxentry>
</itemreferencebox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<rollrecoveryentry></rollrecoveryentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<audioprerollentry></audioprerollentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<visualrandomaccessentry></visualrandomaccessentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<cencsampleencryptiongroupentry isencrypted="" kid=""></cencsampleencryptiongroupentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<operatingpointsinformation>
 <profiletierlevel></profiletierlevel>
<operatingpoint minpicwidth="" minpicheight="" maxpicwidth="" maxpicheight="" maxchromaformat="" maxbitdepth="" avgframerate="" constantframerate="" maxbitrate="" avgbitrate=""></operatingpoint>

</operatingpointsinformation>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<layerinformation>
<layerinfoitem></layerinfoitem>
</layerinformation>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<tileregiongroupentry tilegroup="" independent="" x="" y="" w="" h="">
<tileregiondependency tileid=""></tileregiondependency>
</tileregiongroupentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<nalumap rle="">
<nalumapentry groupid=""></nalumapentry>
</nalumap>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<temporallevelentry></temporallevelentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p12" container="stbl traf">
<sapentry></sapentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<syncsamplegroupentry></syncsamplegroupentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="p15" container="stbl traf">
<subpictureorderentry refs=""></subpictureorderentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="3gpp" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<samplegroupdescriptionbox size="0" type="sgpd" version="0" flags="0" specification="3gpp" container="stbl traf">
<defaultsamplegroupdescriptionentry size=""></defaultsamplegroupdescriptionentry>
</samplegroupdescriptionbox>
<sampledescriptionentrybox size="0" type="GNRM" specification="unknown" container="stsd" extensiondatasize="0">
</sampledescriptionentrybox>
<visualsampledescriptionbox size="0" type="GNRV" specification="unknown" container="stsd" version="0" revision="0" vendor="0" temporalquality="0" spacialquality="0" width="0" height="0" horizontalresolution="4718592" verticalresolution="4718592" compressorname="" bitdepth="24">
</visualsampledescriptionbox>
<audiosampledescriptionbox size="0" type="GNRA" specification="unknown" container="stsd" version="0" revision="0" vendor="0" channelcount="2" bitspersample="16" samplerate="0">
</audiosampledescriptionbox>
<trackgrouptypebox size="0" type="msrc" version="0" flags="0" specification="p12" container="trgr">
</trackgrouptypebox>
<trackgrouptypebox size="0" type="ster" version="0" flags="0" specification="p12" container="trgr">
</trackgrouptypebox>
<trackgrouptypebox size="0" type="cstg" version="0" flags="0" specification="p15" container="trgr">
</trackgrouptypebox>
<freespacebox size="0" type="free" specification="p12" container="*">
</freespacebox>
<freespacebox size="0" type="free" specification="p12" container="*">
</freespacebox>
<mediadatabox size="0" type="mdat" specification="p12" container="file">
</mediadatabox>
<mediadatabox size="0" type="mdat" specification="p12" container="meta">
"
</mediadatabox></boxes>

-
Decode multiple video on GPU (FFmpeg.autogen + C#)
5 décembre 2024, par Sang NguyenI'm trying to use the basic example about decoding video (FFmpeg.AutoGen.Example) in the FFmpeg.autogen 4.3.0.3 library https://github.com/Ruslan-B/FFmpeg.AutoGen to decode multiple videos on a GPU (AMD radeon R7 430). My main function is as follows :


private static void Main(string[] args)
 {
 var url = @".\abc.mp4";
 for (int i = 0; i < 11; i++)
 {
 url = @"D:\video\abc" + i + ".mp4";
 new Thread(() =>
 {
 DecodeAllFramesToImages(AVHWDeviceType.AV_HWDEVICE_TYPE_D3D11VA, url);
 }).Start();
 }
 }


I try to decode video abc.mp4 with GPU Hardware Acceleration. However, an error occurs when i run thread count greater than 10. The error images is as follows :


- 

- "System.AccessViolationException : Attempted to read or write protected memory. This is often an indication that other memory." enter image description here
- And in the console screen there is an error message "Failed to create D3D11VA video decoder" and "Failed setup for format d3d11 : hwaccel innitialisation returned error"
enter image description here.






I'm new to the ffmpeg library recently, so I don't know the problem very well, I would love to have your help with this error !!


private static unsafe void DecodeAllFramesToImages(AVHWDeviceType HWDevice, string url)
 { 
 using (var vsd = new VideoStreamDecoder(url,HWDevice))
 {
 Console.WriteLine($"codec name: {vsd.CodecName}");

 var info = vsd.GetContextInfo();
 info.ToList().ForEach(x => Console.WriteLine($"{x.Key} = {x.Value}"));

 var sourceSize = vsd.FrameSize;
 var sourcePixelFormat = HWDevice == AVHWDeviceType.AV_HWDEVICE_TYPE_NONE ? vsd.PixelFormat : GetHWPixelFormat(HWDevice);
 var destinationSize = sourceSize;
 var destinationPixelFormat = AVPixelFormat.AV_PIX_FMT_YUV420P;
 using (var vfc = new VideoFrameConverter(sourceSize, sourcePixelFormat, destinationSize, destinationPixelFormat))
 {
 var frameNumber = 0;
 while (vsd.TryDecodeNextFrame(out var frame))
 {
 //var convertedFrame = vfc.Convert(frame); 
 // using (var bitmap = new Bitmap(convertedFrame.width, convertedFrame.height, convertedFrame.linesize[0], PixelFormat.Format24bppRgb, (IntPtr) convertedFrame.data[0]))
 // bitmap.Save($"frame.{frameNumber:D8}.jpg", ImageFormat.Jpeg);
 
 Console.WriteLine($"frame: {frameNumber}");
 frameNumber++;
 }
 }
 }
 }


using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;

namespace FFmpeg.AutoGen.Example
{
 public sealed unsafe class VideoStreamDecoder : IDisposable
 {
 private readonly AVCodecContext* _pCodecContext;
 private readonly AVFormatContext* _pFormatContext;
 private readonly int _streamIndex;
 private readonly AVFrame* _pFrame;
 private readonly AVFrame* _receivedFrame;
 private readonly AVPacket* _pPacket;

 public VideoStreamDecoder(string url, AVHWDeviceType HWDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
 {
 _pFormatContext = ffmpeg.avformat_alloc_context();
 _receivedFrame = ffmpeg.av_frame_alloc();
 var pFormatContext = _pFormatContext;
 ffmpeg.avformat_open_input(&pFormatContext, url, null, null).ThrowExceptionIfError();
 ffmpeg.avformat_find_stream_info(_pFormatContext, null).ThrowExceptionIfError();
 AVCodec* codec = null;
 _streamIndex = ffmpeg.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0).ThrowExceptionIfError();
 _pCodecContext = ffmpeg.avcodec_alloc_context3(codec);
 if (HWDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
 {
 ffmpeg.av_hwdevice_ctx_create(&_pCodecContext->hw_device_ctx, HWDeviceType, null, null, 0).ThrowExceptionIfError();
 }
 ffmpeg.avcodec_parameters_to_context(_pCodecContext, _pFormatContext->streams[_streamIndex]->codecpar).ThrowExceptionIfError();
 ffmpeg.avcodec_open2(_pCodecContext, codec, null).ThrowExceptionIfError(); 
 CodecName = ffmpeg.avcodec_get_name(codec->id);
 FrameSize = new Size(_pCodecContext->width, _pCodecContext->height);
 PixelFormat = _pCodecContext->pix_fmt;
 _pPacket = ffmpeg.av_packet_alloc();
 _pFrame = ffmpeg.av_frame_alloc();
 }

 public string CodecName { get; }
 public Size FrameSize { get; }
 public AVPixelFormat PixelFormat { get; }

 public void Dispose()
 {
 ffmpeg.av_frame_unref(_pFrame);
 ffmpeg.av_free(_pFrame);

 ffmpeg.av_packet_unref(_pPacket);
 ffmpeg.av_free(_pPacket);

 ffmpeg.avcodec_close(_pCodecContext);
 var pFormatContext = _pFormatContext;
 ffmpeg.avformat_close_input(&pFormatContext);
 }

 public bool TryDecodeNextFrame(out AVFrame frame)
 {
 ffmpeg.av_frame_unref(_pFrame);
 ffmpeg.av_frame_unref(_receivedFrame);
 int error;
 do
 {
 try
 {
 do
 {
 error = ffmpeg.av_read_frame(_pFormatContext, _pPacket);
 if (error == ffmpeg.AVERROR_EOF)
 {
 frame = *_pFrame;
 return false;
 }

 error.ThrowExceptionIfError();
 } while (_pPacket->stream_index != _streamIndex);

 ffmpeg.avcodec_send_packet(_pCodecContext, _pPacket).ThrowExceptionIfError();
 }
 finally
 {
 ffmpeg.av_packet_unref(_pPacket);
 }

 error = ffmpeg.avcodec_receive_frame(_pCodecContext, _pFrame);
 } while (error == ffmpeg.AVERROR(ffmpeg.EAGAIN));
 error.ThrowExceptionIfError();
 if (_pCodecContext->hw_device_ctx != null)
 {
 ffmpeg.av_hwframe_transfer_data(_receivedFrame, _pFrame, 0).ThrowExceptionIfError();
 frame = *_receivedFrame;
 }
 else
 {
 frame = *_pFrame;
 }
 return true;
 }
 public IReadOnlyDictionary GetContextInfo()
 {
 AVDictionaryEntry* tag = null;
 var result = new Dictionary();
 while ((tag = ffmpeg.av_dict_get(_pFormatContext->metadata, "", tag, ffmpeg.AV_DICT_IGNORE_SUFFIX)) != null)
 {
 var key = Marshal.PtrToStringAnsi((IntPtr) tag->key);
 var value = Marshal.PtrToStringAnsi((IntPtr) tag->value);
 result.Add(key, value);
 }
 return result;
 }
 }
}


-
Read multiple frames in demuxer
22 décembre 2024, par AyconI use
FFmpeg.AutoGen. This is C# wrapper offfmpeg(7.0) C++ library for reading mediafiles and generate stream of frames for other application.
I want get n frames and hold pointers in memory indefinitely.
However, I am completely confused trying to figure out which API is deprecated and how I can tell ffmpeg to hold the pointers in memory until I tell it to.

I don't want to copy the frame after receiving it if I can avoid it.

I tried many ways.

My last attempt was to receive the frames usingffmpeg.avcodec_send_packet(),ffmpeg.av_read_frame()andffmpeg.avcodec_receive_frame()functions as it is specified in the current manual.

My code fragment for reading frames :

using Core.Backends.FFmpeg.Helpers;
using Core.Backends.FFmpeg.UnsafeWrappers;
using Core.Enums;
using Core.Interfaces;
using FFmpeg.AutoGen.Abstractions;
using System.Diagnostics;
using System.Drawing;

namespace Core.Backends.FFmpeg.Internal;

internal class Video : IVideo
{
 private readonly AVFormatHandler p_format;
 private readonly AVCodecHandler p_codec;
 private readonly AVPacketWrapper p_packet;
 private readonly FramesPool p_framesPool;
 private readonly FramesPool p_framesBufferPool;
 private bool p_disposedValue;

 public Video(VideoMetadata _videoMetadata, AVFormatHandler _format, AVCodecHandler _codec, int _bufferizedFramesCount = 1)
 {
 Duration = _videoMetadata.Duration;
 FrameRate = _videoMetadata.FrameRate;
 FrameSize = _videoMetadata.FrameSize;
 PixelFormat = _videoMetadata.PixelFormat;
 SelectedStreamID = _videoMetadata.SelectedStreamID;
 p_format = _format;
 p_codec = _codec;
 p_packet = new AVPacketWrapper();
 var frame = new AVFrameWrapper(p_format, p_packet);
 p_framesPool = new(frame, _bufferizedFramesCount);
 p_framesBufferPool = new(frame, _bufferizedFramesCount);
 }

 /// <inheritdoc></inheritdoc>
 public long Duration { get; init; }

 /// <inheritdoc></inheritdoc>
 public (int num, int den) FrameRate { get; init; }

 /// <inheritdoc></inheritdoc>
 public Size FrameSize { get; init; }

 /// <inheritdoc></inheritdoc>
 public PixelFormat PixelFormat { get; init; }

 private int SelectedStreamID { get; init; }

 private unsafe int SendPacket(AVPacketWrapper? _packet)
 {
 if (_packet == null)
 return ffmpeg.avcodec_send_packet(p_codec.AVCodecContextPointer, null);

 return ffmpeg.avcodec_send_packet(p_codec.AVCodecContextPointer, _packet.AVPacketPointer);
 }

 private unsafe bool IsSelectedStream(AVPacketWrapper _packet)
 {
 return _packet.AVPacketPointer->stream_index == SelectedStreamID;
 }

 private unsafe int ReadFrame(AVPacketWrapper _packet)
 {
 return ffmpeg.av_read_frame(p_format.AVFormatPointer, _packet.AVPacketPointer);
 }

 private static unsafe void UnrefPacket(AVPacketWrapper _packet) => ffmpeg.av_packet_unref(_packet.AVPacketPointer);

 private IEnumerable<int> ReadToSelectedStream(AVPacketWrapper _packet)
 {
 do
 {
 UnrefPacket(p_packet);
 yield return ReadFrame(_packet);
 } while (!IsSelectedStream(_packet));
 }

 private unsafe void FlushBuffers() => ffmpeg.avcodec_flush_buffers(p_codec.AVCodecContextPointer);

 private IEnumerable<avpacketwrapper> GetNextPacketPrivate()
 {
 try
 {
 while (true)
 {
 foreach (int errorCodeRead in ReadToSelectedStream(p_packet))
 {
 if (errorCodeRead == ffmpeg.AVERROR_EOF)
 break;

 errorCodeRead.ThrowInvalidOperationExceptionIfError();
 }

 int errorCodeSend = SendPacket(p_packet);

 if (errorCodeSend == ffmpeg.AVERROR(ffmpeg.EAGAIN))
 {
 yield return p_packet;
 continue;
 }

 if (errorCodeSend == ffmpeg.AVERROR_EOF)
 {
 yield return p_packet;
 break;
 }

 errorCodeSend.ThrowInvalidOperationExceptionIfError();

 yield return p_packet;
 }

 // Last iteration special case handling
 int errorCodeSendLast = SendPacket(null);

 if (errorCodeSendLast != ffmpeg.AVERROR_EOF)
 errorCodeSendLast.ThrowInvalidOperationExceptionIfError();

 yield return p_packet;
 }
 finally
 {
 UnrefPacket(p_packet);
 FlushBuffers();
 }
 }

 private unsafe int ReceiveFrame(AVFrameWrapper _frame)
 {
 return ffmpeg.avcodec_receive_frame(p_codec.AVCodecContextPointer, _frame.AVFramePointer);
 }

 private unsafe AVFrameWrapper HWFrameCopyIfRequired(AVCodecHandler _codec, AVFrameWrapper _frame, AVFrameWrapper _buffer)
 {
 if (_codec.AVCodecContextPointer->hw_device_ctx != null)
 {
 int errorCode = ffmpeg.av_hwframe_transfer_data(_buffer.AVFramePointer, _frame.AVFramePointer, flags: 0);
 errorCode.ThrowInvalidOperationExceptionIfError();
 return _buffer;
 }

 return _frame;
 }

 private IEnumerable GetNextFramePrivate(AVFrameWrapper _fresh_frame, AVFrameWrapper _fresh_frameBuffer)
 {
 int readCode;

 while (true)
 {
 readCode = ReceiveFrame(_fresh_frame);

 if (readCode == ffmpeg.AVERROR(ffmpeg.EAGAIN) || readCode == ffmpeg.AVERROR_EOF)
 yield break;

 readCode.ThrowInvalidOperationExceptionIfError();
 
 yield return HWFrameCopyIfRequired(p_codec, _fresh_frame, _fresh_frameBuffer);
 }
 }

 private static void RefreshFrames
 (
 IEnumerator<avframewrapper> _framesEnumerator,
 IEnumerator<avframewrapper> _framesBufferEnumerator,
 out AVFrameWrapper _frame,
 out AVFrameWrapper _frameBuffer
 )
 {
 // Catch fresh frame from pool
 Debug.Assert(_framesEnumerator.MoveNext(), "Пул фреймов никогда не должен завершать предоставление фреймов.");
 _frame = _framesEnumerator.Current;

 // Catch fresh frame buffer from pool
 Debug.Assert(_framesBufferEnumerator.MoveNext(), "Пул фреймов никогда не должен завершать предоставление фреймов.");
 _frameBuffer = _framesBufferEnumerator.Current;
 }

 /// <inheritdoc></inheritdoc>
 public IEnumerable GetNextFrame()
 {
 IEnumerator<avframewrapper> framesEnumerator = p_framesPool.GetNextFrame().GetEnumerator();
 IEnumerator<avframewrapper> framesBufferEnumerator = p_framesBufferPool.GetNextFrame().GetEnumerator();
 RefreshFrames(framesEnumerator, framesBufferEnumerator, out AVFrameWrapper fresh_frame, out AVFrameWrapper fresh_frameBuffer);
 foreach (var packet in GetNextPacketPrivate())
 foreach (var frame in GetNextFramePrivate(fresh_frame, fresh_frameBuffer))
 {
 yield return frame;
 RefreshFrames(framesEnumerator, framesBufferEnumerator, out fresh_frame, out fresh_frameBuffer);
 }
 }

 protected virtual void Dispose(bool disposing)
 {
 if (!p_disposedValue)
 {
 if (disposing)
 {
 }

 p_packet.Dispose();
 p_framesPool.Flush();
 p_framesBufferPool.Flush();

 p_disposedValue = true;
 }
 }

 ~Video()
 {
 Dispose(disposing: false);
 }

 public void Dispose()
 {
 Dispose(disposing: true);
 GC.SuppressFinalize(this);
 }
}
</avframewrapper></avframewrapper></avframewrapper></avframewrapper></avpacketwrapper></int>

My
FramesPoolclass :

using Core.Backends.FFmpeg.UnsafeWrappers;
using FFmpeg.AutoGen.Abstractions;

namespace Core.Backends.FFmpeg.Internal;

internal class FramesPool
{
 private readonly AVFrameWrapper p_frameWrapper;
 private readonly Queue<avframewrapper> p_frames;
 private readonly int p_count;

 public FramesPool(AVFrameWrapper _initframeWrapper, int _count = 1)
 {
 p_frameWrapper = _initframeWrapper;
 p_frames = new(_count);
 p_frames.Enqueue(p_frameWrapper);
 p_count = _count;
 }

 private static unsafe void UnrefFrame(AVFrameWrapper _frame) => ffmpeg.av_frame_unref(_frame.AVFramePointer);

 public IEnumerable<avframewrapper> GetNextFrame()
 {
 // First frame case
 UnrefFrame(p_frameWrapper);
 yield return p_frameWrapper;

 while (true)
 {
 if (p_frames.Count < p_count)
 {
 var new_frame = p_frameWrapper.Clone();
 p_frames.Enqueue(new_frame);
 yield return new_frame;
 }
 else
 {
 var frame = p_frames.Dequeue();
 UnrefFrame(frame);
 yield return frame;
 p_frames.Enqueue(frame);
 }
 }
 }

 public void Flush()
 {
 foreach(var frame in p_frames)
 {
 UnrefFrame(frame);
 frame.Dispose();
 }

 p_frames.Clear();
 }
}
</avframewrapper></avframewrapper>

Additional calls, among others :


ffmpeg.avformat_alloc_context();
ffmpeg.avformat_open_input(pptr, p_filePath, null, null);
ffmpeg.av_hwdevice_ctx_create(&p_avCodecHandler!.AVCodecContextPointer->hw_device_ctx, strongDevice, null, null, 0);
ffmpeg.av_find_best_stream(/*args*/);
ffmpeg.avcodec_alloc_context3(p_avCodec);
ffmpeg.avcodec_parameters_to_context(/*args*/);
ffmpeg.avcodec_open2(/*args*/);


Function
ffmpeg.av_hwframe_transfer_data(_buffer.AVFramePointer, _frame.AVFramePointer, flags: 0);returns "-22" (message : "Invalid argument")

Please, help me)


Syndiquer tout le site
