Recherche avancée

Médias (1)

Mot : - Tags -/musée

Autres articles (18)

  • Contribute to documentation

    13 avril 2011

    Documentation is vital to the development of improved technical capabilities.
    MediaSPIP welcomes documentation by users as well as developers - including : critique of existing features and functions articles contributed by developers, administrators, content producers and editors screenshots to illustrate the above translations of existing documentation into other languages
    To contribute, register to the project users’ mailing (...)

  • Contribute to a better visual interface

    13 avril 2011

    MediaSPIP is based on a system of themes and templates. Templates define the placement of information on the page, and can be adapted to a wide range of uses. Themes define the overall graphic appearance of the site.
    Anyone can submit a new graphic theme or template and make it available to the MediaSPIP community.

  • Création définitive du canal

    12 mars 2010, par

    Lorsque votre demande est validée, vous pouvez alors procéder à la création proprement dite du canal. Chaque canal est un site à part entière placé sous votre responsabilité. Les administrateurs de la plateforme n’y ont aucun accès.
    A la validation, vous recevez un email vous invitant donc à créer votre canal.
    Pour ce faire il vous suffit de vous rendre à son adresse, dans notre exemple "http://votre_sous_domaine.mediaspip.net".
    A ce moment là un mot de passe vous est demandé, il vous suffit d’y (...)

Sur d’autres sites (3306)

  • 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 < 0)
    
        {
    
            throw new Exception("Unable to copy parameters to context! [" + result + "]");
    
        }
    

    
        codecContext.thread_count(0);
    

    
        result = avcodec_open2(codecContext, codec, new AVDictionary());
    
        if(result < 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]<<24)&0xff000000|(bytes[offset+1]<<16)&0x00ff0000|(bytes[offset+2]<<8)&0x0000ff00|(bytes[offset+3]<<0)&0x000000ff;
    
    }
    

    
    private static long byteToLong(byte[] bytes, int offset)
    
    {
    
        return (bytes[offset]<<56)&0xff00000000000000L|(bytes[offset+1]<<48)&0x00ff000000000000L|(bytes[offset+2]<<40)&0x0000ff0000000000L|(bytes[offset+3]<<32)&0x000000ff00000000L|(bytes[offset+4]<<24)&0x00000000ff000000L|(bytes[offset+5]<<16)&0x0000000000ff0000L|(bytes[offset+6]<<8)&0x000000000000ff00L|(bytes[offset+7]<<0)&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

  • How to get 20 screenshots from a video with tile or mosiac effect ffmpeg ?

    2 octobre 2019, par Nane

    I am trying to get 20(Will take screens at 5%, 10%, 15%, 20%,.., of the video) screenshot which will be arranged in a single image like this Link

    I found this command but it is taking screenshot based on frames like 1000 I want to get evenly distributed 20 screenshots of the entire video

    ffmpeg -ss 00:00:10 -i movie.avi -frames 1 -vf "select=not(mod(n\,1000)),scale=320:240,tile=2x3" out.png

  • the same audio have different length using different tools (librosa,ffprobe)

    29 octobre 2019, par Fathy Eltanany

    I want to measure an audio file’s duration.
    I’m using two different tools and got different values.

    1. ffprobe :
      I’m using this line to get duration using ffprobe
     ffprobe -i audio.m4a -show_entries format=duration -v quiet -of csv="p=0"

    result :780.320000 seconds
    2. Librosa (python library)
    and using this line to get duartion using librosa

    y1, sr1 = librosa.load(audio_path, sr=44100)
    
librosa.get_duration(y1, sr1) * 1000

    result 780329.7959183673 milliseconds

    Does anyone know what’s causing the difference ?

Navigation