Recherche avancée

Médias (5)

Mot : - Tags -/open film making

Autres articles (85)

  • Mise à jour de la version 0.1 vers 0.2

    24 juin 2013, par

    Explications des différents changements notables lors du passage de la version 0.1 de MediaSPIP à la version 0.3. Quelles sont les nouveautés
    Au niveau des dépendances logicielles Utilisation des dernières versions de FFMpeg (>= v1.2.1) ; Installation des dépendances pour Smush ; Installation de MediaInfo et FFprobe pour la récupération des métadonnées ; On n’utilise plus ffmpeg2theora ; On n’installe plus flvtool2 au profit de flvtool++ ; On n’installe plus ffmpeg-php qui n’est plus maintenu au (...)

  • Personnaliser en ajoutant son logo, sa bannière ou son image de fond

    5 septembre 2013, par

    Certains thèmes prennent en compte trois éléments de personnalisation : l’ajout d’un logo ; l’ajout d’une bannière l’ajout d’une image de fond ;

  • Ecrire une actualité

    21 juin 2013, par

    Présentez les changements dans votre MédiaSPIP ou les actualités de vos projets sur votre MédiaSPIP grâce à la rubrique actualités.
    Dans le thème par défaut spipeo de MédiaSPIP, les actualités sont affichées en bas de la page principale sous les éditoriaux.
    Vous pouvez personnaliser le formulaire de création d’une actualité.
    Formulaire de création d’une actualité Dans le cas d’un document de type actualité, les champs proposés par défaut sont : Date de publication ( personnaliser la date de publication ) (...)

Sur d’autres sites (11233)

  • Anomalie #3757 (Fermé) : Indication de mise à jour dans l’espace privé.

    22 mars 2016, par svpip -

    Vérifier sur SPIP 3.1.0 sans aucun ajout personnel ni plugin.

    Absence d’indication de mise à jour d’une nouvelle version de SPIP depuis le pied de page de l’espace privé.

    Aujourd’hui mardi 22 mars 2016, l’info reste inchangée (alors que la versions 3.1.1 est sortie depuis le 10 mars 2016) :

    " SPIP 3.1.0 [22707] est un logiciel libre distribué sous licence GPL.
    + écran de sécurité 1.2.2 "

  • Anomalie #4569 (Nouveau) : Accessibilité, boutons et javascript

    5 octobre 2020

    Il y a 2 types de boutons qui ne répondent peut-être pas aux critères d’accessibilité, à vérifier.

    Bouton « Détails » dans le modèle document_desc

    Ce bouton sert à afficher ou masquer les détails complets d’un document.
    Actuellement c’est juste un lien <a></a> sans href et du javascript inline :

    <span class="CodeRay"><span class="tag">span> <span class="attribute-name">class</span>=<span class="string"><span class="delimiter">"</span><span class="content">lien_details bouton link</span><span class="delimiter">"</span></span> 
    
    <span class="attribute-name">onClick</span>=<span class="string"><span class="delimiter">"</span><span class="predefined">$</span>(<span class="local-variable">this</span>).parent().next(<span class="string"><span class="delimiter">'</span><span class="content">.detaillees</span><span class="delimiter">'</span></span>).toggle(); <span class="keyword">return</span> <span class="predefined-constant">true</span>;<span class="delimiter">"</span></span> 
    
    <span class="attribute-name">title</span>=<span class="string"><span class="delimiter">"</span><span class="content">&lt;:medias:details_document_afficher_masquer|attribut_html:</span></span><span class="error">></span>"<span class="error">></span><span class="tag">&lt;:medias:details_document:></span><span class="tag"></span>
    
</span></span>

    Boutons pour changer le mode d’affichage

    Il s’agit des 3 boutons ajoutés en javascript qui permettent de changer le mode d’affichage de la liste des documents liés.
    Ils sont générés en javascript dans gestion_listes_documents.js.
    Là il s’agit d’un simple <span></span>. Un clic dessus toggle des classes sur une cible.

    <span class="CodeRay">
    
<span class="tag">span> <span class="attribute-name">class</span>=<span class="string"><span class="delimiter">"</span><span class="content">affichages</span><span class="delimiter">"</span></span><span class="tag">></span>
    
  <span class="tag">span> <span class="attribute-name">class</span>=<span class="string"><span class="delimiter">"</span><span class="content">icone grand on</span><span class="delimiter">"</span></span> <span class="attribute-name">title</span>=<span class="string"><span class="delimiter">"</span><span class="content">Affichage en grand</span><span class="delimiter">"</span></span><span class="tag">></span><span class="tag"></span></span>
    
  <span class="tag">span> <span class="attribute-name">class</span>=<span class="string"><span class="delimiter">"</span><span class="content">icone cases</span><span class="delimiter">"</span></span> <span class="attribute-name">title</span>=<span class="string"><span class="delimiter">"</span><span class="content">Affichage en cases</span><span class="delimiter">"</span></span><span class="tag">></span><span class="tag"></span></span>
    
  <span class="tag">span> <span class="attribute-name">class</span>=<span class="string"><span class="delimiter">"</span><span class="content">icone liste</span><span class="delimiter">"</span></span> <span class="attribute-name">title</span>=<span class="string"><span class="delimiter">"</span><span class="content">Affichage en liste compacte</span><span class="delimiter">"</span></span><span class="tag">></span><span class="tag"></span></span>
    
<span class="tag"></span>
    
</span></span>

  • Send AVPacket over Network

    2 décembre 2019, par Yondonator

    I’m generating AVPackets with an encoder with ffmpeg and now I want to send them with UDP to another Computer and show them there.
    The problem is I don’t know how to convert the packet to bytes and back. I tried this to copy the package :

    AVPacket newPacket = avcodec.av_packet_alloc();
    

    

    
ByteBuffer byteBuffer = packet.buf().buffer().asByteBuffer();
    
int bufferSize = byteBuffer.capacity();
    
byte bytes[] = new byte[bufferSize];
    
byteBuffer.get(bytes);
    
AVBufferRef newBufferRef = avutil.av_buffer_alloc(bufferSize);
    
newBufferRef.data(new BytePointer(bytes));
    
newPacket.buf(newBufferRef);
    

    

    
ByteBuffer dataBuffer = packet.data().asByteBuffer();
    
int dataSize = dataBuffer.capacity();
    
byte dataBytes[] = new byte[dataSize];
    
dataBuffer.get(dataBytes);
    
BytePointer dataPointer = new BytePointer(dataBytes);
    
newPacket.data(dataPointer);
    

    

    
newPacket.dts(packet.dts());
    
newPacket.duration(packet.duration());
    
newPacket.flags(packet.flags());
    
newPacket.pos(packet.pos());
    
newPacket.pts(packet.pts());
    
newPacket.side_data_elems(0);
    
newPacket.size(packet.size());
    
newPacket.stream_index(packet.stream_index());
    

    

    
videoPlayer.sendPacket(newPacket);

    This gives me this Error :

    [h264 @ 0000018951be8440] Invalid NAL unit size (3290676 > 77).
    
[h264 @ 0000018951be8440] Error splitting the input into NAL units.
    
[h264 @ 0000018951bf6480] Invalid NAL unit size (15305314 > 163).
    
[h264 @ 0000018951bf6480] Error splitting the input into NAL units.

    The problem is newPacket.data(). When I set it directly : newPacket.data(packet.data())
    it works. Also packet.data().asByteBuffer().capacity() returns 1 and packet.data().capacity() returns 0.

    This is my method that creates the decoder :

    private void startUnsafe() throws Exception
    
    {
    
        int result;
    

    
        convertContext = null;
    
        codec = null;
    
        codecContext = null;
    
        AVFrame = null;
    
        RGBAVFrame = null;
    
        frame = new Frame();
    

    
        codec = avcodec_find_decoder(codecID);
    
        if(codec == null)
    
        {
    
            throw new Exception("Unable to find decoder");
    
        }
    

    
        codecContext = avcodec_alloc_context3(codec);
    
        if(codecContext == null)
    
        {
    
            releaseUnsafe();
    
            throw new Exception("Unable to alloc codec context!");
    
        }
    

    
        AVCodecParameters para = avcodec_parameters_alloc();
    
        para.bit_rate(streamBitrate);
    
        para.width(streamWidth);
    
        para.height(streamHeight);
    
        para.codec_id(codecID);
    
        para.codec_type(AVMEDIA_TYPE_VIDEO);
    
        try
    
        {
    
            byte extradataByte[] = Files.readAllBytes(new File("extradata.byte").toPath());
    
            para.extradata(new BytePointer(extradataByte));
    
            para.extradata_size(extradataByte.length);
    
        }
    
        catch (IOException e1)
    
        {
    
            e1.printStackTrace();
    
            throw new Exception("extradata file not available");
    
        }
    

    
        result = avcodec_parameters_to_context(codecContext, para);
    
        if(result &lt; 0)
    
        {
    
            throw new Exception("Unable to copy parameters to context! [" + result + "]");
    
        }
    

    
        codecContext.thread_count(0);
    

    
        result = avcodec_open2(codecContext, codec, new AVDictionary());
    
        if(result &lt; 0)
    
        {
    
            releaseUnsafe();
    
            throw new Exception("Unable to open codec context![" + result + "]");
    
        }
    

    
        AVFrame = av_frame_alloc();
    
        if(AVFrame == null)
    
        {
    
            releaseUnsafe();
    
            throw new Exception("Unable to alloc AVFrame!");
    
        }
    

    
        RGBAVFrame = av_frame_alloc();
    
        if(RGBAVFrame == null)
    
        {
    
            releaseUnsafe();
    
            throw new Exception("Unable to alloc AVFrame!");
    
        }
    
        initRGBAVFrame();
    

    
        TimerTask task = new TimerTask() {
    

    
            @Override
    
            public void run()
    
            {
    
                timerTask();
    
            }
    
        };
    
        timer = new Timer();
    
        timer.scheduleAtFixedRate(task, 0, (long) (1000/streamFramerateDouble));
    

    
        window.setVisible(true);
    
    }

    The file extradata.byte has some bytes that I got from another video, because without them it doesn’t work too.

    EDIT :

    package org.stratostream.streaming;
    

    
import java.nio.ByteBuffer;
    

    

    
import org.bytedeco.javacpp.BytePointer;
    
import org.bytedeco.javacpp.Pointer;
    
import org.bytedeco.javacpp.avcodec;
    
import org.bytedeco.javacpp.avutil;
    
import org.bytedeco.javacpp.avcodec.AVPacket;
    
import org.bytedeco.javacpp.avcodec.AVPacketSideData;
    

    

    
public class PacketIO {
    

    

    
    public static final int SIDE_DATA_FIELD = 0;
    
    public static final int SIDE_ELEMENTS_FIELD = 4;
    
    public static final int SIDE_TYPE_FIELD = 8;
    
    public static final int DTS_FIELD = 12;
    
    public static final int PTS_FIELD = 20;
    
    public static final int FLAGS_FIELD = 28;
    
    public static final int DATA_OFFSET = 32;
    

    
    public static byte[] toByte(AVPacket packet) throws Exception
    
    {
    
        int dataSize = packet.size();
    
        ByteBuffer dataBuffer = packet.data().capacity(dataSize).asByteBuffer();
    
        byte dataBytes[] = new byte[dataSize];
    
        dataBuffer.get(dataBytes);
    

    
        AVPacketSideData sideData = packet.side_data();
    
        int sideSize = sideData.size();
    
        ByteBuffer sideBuffer = sideData.data().capacity(sideSize).asByteBuffer();
    
        byte sideBytes[] = new byte[sideSize];
    
        sideBuffer.get(sideBytes);
    

    
        int sideOffset = DATA_OFFSET + dataSize;
    
        int resultSize = sideOffset + sideSize;
    
        byte resultBytes[] = new byte[resultSize];
    
        System.arraycopy(dataBytes, 0, resultBytes, DATA_OFFSET, dataSize);
    
        System.arraycopy(sideBytes, 0, resultBytes, sideOffset, sideSize);
    
        resultBytes[SIDE_DATA_FIELD] = (byte) (sideOffset >>> 24);
    
        resultBytes[SIDE_DATA_FIELD+1] = (byte) (sideOffset >>> 16);
    
        resultBytes[SIDE_DATA_FIELD+2] = (byte) (sideOffset >>> 8);
    
        resultBytes[SIDE_DATA_FIELD+3] = (byte) (sideOffset >>> 0);
    

    
        int sideType = sideData.type();
    
        intToByte(resultBytes, SIDE_TYPE_FIELD, sideType);
    

    
        int sideElements = packet.side_data_elems();
    
        intToByte(resultBytes, SIDE_ELEMENTS_FIELD, sideElements);
    

    
        long dts = packet.dts();
    
        longToByte(resultBytes, DTS_FIELD, dts);
    

    
        long pts = packet.pts();
    
        longToByte(resultBytes, PTS_FIELD, pts);
    

    
        int flags = packet.flags();
    
        intToByte(resultBytes, FLAGS_FIELD, flags);
    

    
        return resultBytes;
    
    }
    

    
    public static AVPacket toPacket(byte bytes[]) throws Exception
    
    {
    
        AVPacket packet = avcodec.av_packet_alloc();
    

    
        int sideOffset = byteToInt(bytes, SIDE_DATA_FIELD);
    
        int sideElements = byteToInt(bytes, SIDE_ELEMENTS_FIELD);
    
        int sideType = byteToInt(bytes, SIDE_TYPE_FIELD);
    
        int dataSize = sideOffset - DATA_OFFSET;
    
        int sideSize = bytes.length - sideOffset;
    

    
        long pts = byteToLong(bytes, PTS_FIELD);
    
        long dts = byteToLong(bytes, DTS_FIELD);
    
        int flags = byteToInt(bytes, FLAGS_FIELD);
    

    
        packet.pts(pts);
    
        packet.dts(dts);
    
        packet.flags(flags);
    

    

    
        Pointer newDataPointer =  avutil.av_malloc(bytes.length);
    
        BytePointer dataPointer = new BytePointer(newDataPointer);
    
        byte dataBytes[] = new byte[dataSize];
    
        System.arraycopy(bytes, DATA_OFFSET, dataBytes, 0, dataSize);
    
        dataPointer.put(dataBytes);
    
        packet.data(dataPointer);
    
        packet.size(dataSize);
    

    
        Pointer newSidePointer = avutil.av_malloc(sideSize);
    
        BytePointer sidePointer = new BytePointer(newSidePointer);
    
        byte sideBytes[] = new byte[sideSize];
    
        System.arraycopy(bytes, sideOffset, sideBytes, 0, sideSize);
    
        sidePointer.put(sideBytes);
    
        AVPacketSideData sideData = new AVPacketSideData();
    
        sideData.data(sidePointer);
    
        sideData.type(sideType);
    
        sideData.size(sideSize);
    
        //packet.side_data(sideData);
    
        //packet.side_data_elems(sideElements);
    

    
        return packet;
    
    }
    

    
    private static void intToByte(byte[] bytes, int offset, int value)
    
    {
    
        bytes[offset] = (byte) (value >>> 24);
    
        bytes[offset+1] = (byte) (value >>> 16);
    
        bytes[offset+2] = (byte) (value >>> 8);
    
        bytes[offset+3] = (byte) (value >>> 0);
    
    }
    

    
    private static void longToByte(byte[] bytes, int offset, long value)
    
    {
    
        bytes[offset] = (byte) (value >>> 56);
    
        bytes[offset+1] = (byte) (value >>> 48);
    
        bytes[offset+2] = (byte) (value >>> 40);
    
        bytes[offset+3] = (byte) (value >>> 32);
    
        bytes[offset+4] = (byte) (value >>> 24);
    
        bytes[offset+5] = (byte) (value >>> 16);
    
        bytes[offset+6] = (byte) (value >>> 8);
    
        bytes[offset+7] = (byte) (value >>> 0);
    
    }
    

    
    private static int byteToInt(byte[] bytes, int offset)
    
    {
    
        return (bytes[offset]&lt;&lt;24)&amp;0xff000000|(bytes[offset+1]&lt;&lt;16)&amp;0x00ff0000|(bytes[offset+2]&lt;&lt;8)&amp;0x0000ff00|(bytes[offset+3]&lt;&lt;0)&amp;0x000000ff;
    
    }
    

    
    private static long byteToLong(byte[] bytes, int offset)
    
    {
    
        return (bytes[offset]&lt;&lt;56)&amp;0xff00000000000000L|(bytes[offset+1]&lt;&lt;48)&amp;0x00ff000000000000L|(bytes[offset+2]&lt;&lt;40)&amp;0x0000ff0000000000L|(bytes[offset+3]&lt;&lt;32)&amp;0x000000ff00000000L|(bytes[offset+4]&lt;&lt;24)&amp;0x00000000ff000000L|(bytes[offset+5]&lt;&lt;16)&amp;0x0000000000ff0000L|(bytes[offset+6]&lt;&lt;8)&amp;0x000000000000ff00L|(bytes[offset+7]&lt;&lt;0)&amp;0x00000000000000ffL;
    
    }
    

    
}

    Now I have this class that works fine on the same programm, but when I send the bytes over the network I get a bad output and this error is printed to the console :

    [h264 @ 00000242442acc40] Missing reference picture, default is 72646
    
[h264 @ 000002424089de00] Missing reference picture, default is 72646
    
[h264 @ 000002424089e3c0] mmco: unref short failure
    
[h264 @ 000002424081a580] reference picture missing during reorder
    
[h264 @ 000002424081a580] Missing reference picture, default is 72652
    
[h264 @ 000002424082c400] mmco: unref short failure
    
[h264 @ 000002424082c400] co located POCs unavailable
    
[h264 @ 000002424082c9c0] co located POCs unavailable
    
[h264 @ 00000242442acc40] co located POCs unavailable
    
[h264 @ 000002424089de00] mmco: unref short failure

    I think its because I dont set the sidedata field but when I try to set it the encoder crashes with the second packet.

    The output looks like this :
    Decoder Output

Navigation