Recherche avancée

Médias (1)

Mot : - Tags -/ogv

Autres articles (108)

  • Le profil des utilisateurs

    12 avril 2011, par

    Chaque utilisateur dispose d’une page de profil lui permettant de modifier ses informations personnelle. Dans le menu de haut de page par défaut, un élément de menu est automatiquement créé à l’initialisation de MediaSPIP, visible uniquement si le visiteur est identifié sur le site.
    L’utilisateur a accès à la modification de profil depuis sa page auteur, un lien dans la navigation "Modifier votre profil" est (...)

  • Websites made ​​with MediaSPIP

    2 mai 2011, par

    This page lists some websites based on MediaSPIP.

  • Ajouter des informations spécifiques aux utilisateurs et autres modifications de comportement liées aux auteurs

    12 avril 2011, par

    La manière la plus simple d’ajouter des informations aux auteurs est d’installer le plugin Inscription3. Il permet également de modifier certains comportements liés aux utilisateurs (référez-vous à sa documentation pour plus d’informations).
    Il est également possible d’ajouter des champs aux auteurs en installant les plugins champs extras 2 et Interface pour champs extras.

Sur d’autres sites (15814)

  • FFMPEG Api conversion from YUV420P to RGB produces strange output

    20 novembre 2024, par fasc8

    I'm using the FFMPEG Api in Rust to get RGB images from video files.

    


    While some videos work correct and I get the frames back as expected, some work not. Or at least the result is not the way I expected it to be.

    


    The code I use in Rust :

    


    ffmpeg::init().unwrap();

let in_ctx = input(&Path::new(source)).unwrap();
let input = in_ctx
    .streams()
    .best(Type::Video)
    .ok_or(ffmpeg::Error::StreamNotFound)?;

let decoder = input.codec().decoder().video()?;

let scaler = Context::get(
    decoder.format(),
    decoder.width(),
    decoder.height(),
    Pixel::RGB24,
    decoder.width(),
    decoder.height(),
    Flags::FULL_CHR_H_INT | Flags::ACCURATE_RND,
)?; // <--- Is basically sws_getContext

// later to get the actual frame
let mut decoded = Video::empty();
if self.decoder.receive_frame(&mut decoded).is_ok() {
    let mut rgb_frame = Video::empty();
    self.scaler.run(&decoded, &mut rgb_frame)?; // <--- Does sws_scale
    println!("Converted Pixel Format: {}", rgb_frame.format() as i32);
    Ok(Some(rgb_frame))
}


    


    Which should roughly translate to C like so :

    


    // Get the context and video stream
SwsContext * ctx = sws_getContext(imgWidth, imgHeight,
                              imgFormat, imgWidth, imgHeight,
                              AV_PIX_FMT_RGB24, 0, 0, 0, 0);
sws_scale(ctx, decoded.data, decoded.linesize, 0, decoded.height, rgb_frame.data, rbg_frame.linesize);


    


    And like I said earlier, sometimes it works fine and I get the expected frame back. But sometimes I get something like this :
Weird result image

    


    I saved the images as .ppm files for quick visual comparison. I used this method, which basically writes the bytes to a file with a simple .ppm header :

    


    fn save_file(frame: &Video, index: usize) -> std::result::Result<(), std::io::Error> 
{
    let mut file = File::create(format!("frame{}.ppm", index))?;
    file.write_all(format!("P6\n{} {}\n255\n", frame.width(), frame.height()).as_bytes())?;
    file.write_all(frame.data(0))?;
    Ok(())
}


    


    Here you can see that on the left side there is a good image result vs. on the right side there is a bad image result.
Comparison of the .ppm files

    


    To come to the question now :

    


    Why is this happening. I tested everything on my side and the only thing left is ffmpeg conversion. FFMPEG seems to convert these two test files differently even though it reports YUV420P as format for both. I cannot figure out what the difference may be...

    


    Here the info for the two video files i used :

    


    Good video file :

    


    General
Complete name                            : /mnt/smb/Snapchat-174933781.mp4
Format                                   : MPEG-4
Format profile                           : Base Media / Version 2
Codec ID                                 : mp42 (isom/mp42)
File size                                : 1.90 MiB
Duration                                 : 9 s 612 ms
Overall bit rate                         : 1 661 kb/s
Encoded date                             : UTC 2021-07-28 22:09:36
Tagged date                              : UTC 2021-07-28 22:09:36
eng                                      : -180.00

Video
ID                                       : 512
Format                                   : AVC
Format/Info                              : Advanced Video Codec
Format profile                           : High@L3.1
Format settings                          : CABAC / 1 Ref Frames
Format settings, CABAC                   : Yes
Format settings, Reference frames        : 1 frame
Format settings, GOP                     : M=1, N=30
Codec ID                                 : avc1
Codec ID/Info                            : Advanced Video Coding
Duration                                 : 9 s 598 ms
Bit rate                                 : 1 597 kb/s
Width                                    : 480 pixels
Height                                   : 944 pixels
Display aspect ratio                     : 0.508
Frame rate mode                          : Variable
Frame rate                               : 29.797 FPS
Minimum frame rate                       : 15.000 FPS
Maximum frame rate                       : 30.000 FPS
Color space                              : YUV
Chroma subsampling                       : 4:2:0
Bit depth                                : 8 bits
Scan type                                : Progressive
Bits/(Pixel*Frame)                       : 0.118
Stream size                              : 1.83 MiB (96%)
Title                                    : Snap Video
Language                                 : English
Encoded date                             : UTC 2021-07-28 22:09:36
Tagged date                              : UTC 2021-07-28 22:09:36
Color range                              : Full
colour_range_Original                    : Limited
Color primaries                          : BT.709
Transfer characteristics                 : BT.601
transfer_characteristics_Original        : BT.709
Matrix coefficients                      : BT.709
Codec configuration box                  : avcC

Audio
ID                                       : 256
Format                                   : AAC LC
Format/Info                              : Advanced Audio Codec Low Complexity
Codec ID                                 : mp4a-40-2
Duration                                 : 9 s 612 ms
Bit rate mode                            : Constant
Bit rate                                 : 62.0 kb/s
Channel(s)                               : 1 channel
Channel layout                           : C
Sampling rate                            : 44.1 kHz
Frame rate                               : 43.066 FPS (1024 SPF)
Compression mode                         : Lossy
Stream size                              : 73.3 KiB (4%)
Title                                    : Snap Audio
Language                                 : English
Encoded date                             : UTC 2021-07-28 22:09:36
Tagged date                              : UTC 2021-07-28 22:09:36


    


    Bad video file :

    


    General
Complete name                            : /mnt/smb/Snapchat-1989594918.mp4
Format                                   : MPEG-4
Format profile                           : Base Media / Version 2
Codec ID                                 : mp42 (isom/mp42)
File size                                : 2.97 MiB
Duration                                 : 6 s 313 ms
Overall bit rate                         : 3 948 kb/s
Encoded date                             : UTC 2019-07-11 06:43:04
Tagged date                              : UTC 2019-07-11 06:43:04
com.android.version                      : 9

Video
ID                                       : 1
Format                                   : AVC
Format/Info                              : Advanced Video Codec
Format profile                           : Baseline@L3.1
Format settings                          : 1 Ref Frames
Format settings, CABAC                   : No
Format settings, Reference frames        : 1 frame
Format settings, GOP                     : M=1, N=30
Codec ID                                 : avc1
Codec ID/Info                            : Advanced Video Coding
Duration                                 : 6 s 313 ms
Bit rate                                 : 3 945 kb/s
Width                                    : 496 pixels
Height                                   : 960 pixels
Display aspect ratio                     : 0.517
Frame rate mode                          : Variable
Frame rate                               : 29.306 FPS
Minimum frame rate                       : 19.767 FPS
Maximum frame rate                       : 39.508 FPS
Color space                              : YUV
Chroma subsampling                       : 4:2:0
Bit depth                                : 8 bits
Scan type                                : Progressive
Bits/(Pixel*Frame)                       : 0.283
Stream size                              : 2.97 MiB (100%)
Title                                    : VideoHandle
Language                                 : English
Encoded date                             : UTC 2019-07-11 06:43:04
Tagged date                              : UTC 2019-07-11 06:43:04
Color range                              : Limited
Color primaries                          : BT.709
Transfer characteristics                 : BT.709
Matrix coefficients                      : BT.709
Codec configuration box                  : avcC


    


    Or as a diff image : image diff

    


    The problem is that I am not that familiar with ffmpeg yet I don't know all the quirks it has.

    


    I hope someone can point me in the right direction.

    


  • Decode H264 video using libavcodec, C

    10 janvier 2015, par deadman

    I’m trying to decode a raw h264 file with ffmpeg/libavcodec, but can’t get it to work properly. Output should be a raw YUV-File for now. It’s possible to compile the code with GCC

    gcc -o decoder decoder.c -L./lib/ -llibavcodec -llibavutil

    avcodec.dll, avutil.dll and swresample.dll must be placed in the directory for the .exe to start. Output in the CMD looks like this (only part of it, but its always like this) :

    [h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] Missing reference picture, default is 65562
    
[h264 @ 00a80f20] error while decoding MB 80 54, bytestream -10
    
[h264 @ 00a80f20] concealing 1649 DC, 1649 AC, 1649 MV errors in B frame
    
[h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] Missing reference picture, default is 65566
    
[h264 @ 00a80f20] Missing reference picture, default is 65566
    
[h264 @ 00a80f20] Missing reference picture, default is 65566
    
[h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] Missing reference picture, default is 65568
    
[h264 @ 00a80f20] reference picture missing during reorder
    
[h264 @ 00a80f20] Missing reference picture, default is 65570
    
[h264 @ 00a80f20] reference picture missing during reorder

    Heres my code

    #include 
    
#include 
    

    
#ifdef HAVE_AV_CONFIG_H
    
#undef HAVE_AV_CONFIG_H
    
#endif
    

    
#include "libavcodec/avcodec.h"
    
//#include "libavcodec/libavutil/mathematics.h"
    

    
#define INBUF_SIZE 4096
    

    
void video_decode(char *outfilename, char *filename)
    
{
    
    AVCodec *codec;
    
    AVCodecContext *c= NULL;
    
    int frame, got_picture, len;
    
    FILE *f, *outf;
    
    AVFrame *picture;
    
    uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
    
    AVPacket avpkt;
    
    int i;
    

    
    av_init_packet(&avpkt);
    

    
    memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
    

    
    codec = avcodec_find_decoder(AV_CODEC_ID_H264);
    
    if (!codec) {
    
        fprintf(stderr, "codec not found\n");
    
        exit(1);
    
    }
    

    
    c = avcodec_alloc_context3(codec);
    
    picture = av_frame_alloc();
    

    
    if((codec->capabilities)&CODEC_CAP_TRUNCATED)
    
        (c->flags) |= CODEC_FLAG_TRUNCATED;
    

    
    c->height = 1080;
    
    c->width = 1920;
    

    
    if (avcodec_open2(c, codec, NULL) < 0) {
    
        fprintf(stderr, "could not open codec\n");
    
        exit(1);
    
    }
    

    
    f = fopen(filename, "rb");
    
    if (!f) {
    
        fprintf(stderr, "could not open %s\n", filename);
    
        exit(1);
    
    }
    

    
    outf = fopen(outfilename,"w");
    
    if(!outf){
    
        fprintf(stderr, "could not open %s\n", filename);
    
        exit(1);
    
    }
    
    frame = 0;
    
    for(;;) {
    
        avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
    
        if (avpkt.size == 0)
    
            break;
    

    
        avpkt.data = inbuf;
    
        while (avpkt.size > 0) {
    

    
            len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
    

    
            if (len < 0) {
    
                fprintf(stderr, "Error while decoding frame %d\n", frame);
    
                exit(1);
    
            }
    
            if (got_picture) {
    
                printf("saving frame %3d\n", frame);
    
                fflush(stdout);
    
                for(i=0; iheight; i++)
    
                    fwrite(picture->data[0] + i * picture->linesize[0], 1, c->width, outf  );
    
                for(i=0; iheight/2; i++)
    
                    fwrite(picture->data[1] + i * picture->linesize[1], 1, c->width/2, outf );
    
                for(i=0; iheight/2; i++)
    
                    fwrite(picture->data[2] + i * picture->linesize[2], 1, c->width/2, outf );
    
                frame++;
    
            }
    
            avpkt.size -= len;
    
            avpkt.data += len;
    
        }
    
    }
    

    
    avpkt.data = NULL;
    
    avpkt.size = 0;
    
    len = avcodec_decode_video2(c,picture, &got_picture, &avpkt);
    
    if(got_picture) {
    
        printf("saving last frame %d\n",frame);
    
        fflush(stdout);
    
        for(i=0; iheight; i++)
    
            fwrite(picture->data[0] + i * picture->linesize[0], 1, c->width, outf );
    
        for(i=0; iheight/2; i++)
    
            fwrite(picture->data[1] + i * picture->linesize[1], 1, c->width/2, outf );
    
        for(i=0; iheight/2; i++)
    
            fwrite(picture->data[2] + i * picture->linesize[2], 1, c->width/2, outf );
    
        frame++;
    
    }
    

    
    fclose(f);
    
    fclose(outf);
    

    
    avcodec_close(c);
    
    av_free(c);
    
    av_frame_free(&picture);
    
    printf("\n");
    
}
    

    
int main(int argc, char **argv){
    
    avcodec_register_all();
    
    video_decode("test", "trailer.264");
    

    
    return 0;
    
}

    I also tried different videos in different formats (of course i changed the codec in the code in this case) like MPEG1, H263, H265, but none of those was working properly either.
    I hope someone can help me with this and tell me what I’m doing wrong here. Thanks

  • Android-Player-SDK's overview of available Player Frameworks

    8 janvier 2015, par user1767754

    I am completely lost with the possibilities of creating Video-Applications for Android. There is natively the MediaPlayer from Android, or the VideoView which is more convenient but at the same time, there are so many different Video-Player-SDK’s around, that someone cannot see what the benefits are between those Players and which one to use.

    For example, what are the benefits of Vitamino over native Player ?

    Let’s say :
    1) Change Appearing of Player

    2) Add Additional Buttons [E-Mail Video-Link, etc.]

    3) Add Additional Functionality [Overlay text, Drawing]

    4) Get Streaming over a Network-Protocoll

    I hope we can build up here an overview page of available Frameworks and Developer Experiences.

Navigation