Recherche avancée

Médias (2)

Mot : - Tags -/doc2img

Autres articles (54)

  • 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 (...)

  • Configurer la prise en compte des langues

    15 novembre 2010, par

    Accéder à la configuration et ajouter des langues prises en compte
    Afin de configurer la prise en compte de nouvelles langues, il est nécessaire de se rendre dans la partie "Administrer" du site.
    De là, dans le menu de navigation, vous pouvez accéder à une partie "Gestion des langues" permettant d’activer la prise en compte de nouvelles langues.
    Chaque nouvelle langue ajoutée reste désactivable tant qu’aucun objet n’est créé dans cette langue. Dans ce cas, elle devient grisée dans la configuration et (...)

  • XMP PHP

    13 mai 2011, par

    Dixit Wikipedia, XMP signifie :
    Extensible Metadata Platform ou XMP est un format de métadonnées basé sur XML utilisé dans les applications PDF, de photographie et de graphisme. Il a été lancé par Adobe Systems en avril 2001 en étant intégré à la version 5.0 d’Adobe Acrobat.
    Étant basé sur XML, il gère un ensemble de tags dynamiques pour l’utilisation dans le cadre du Web sémantique.
    XMP permet d’enregistrer sous forme d’un document XML des informations relatives à un fichier : titre, auteur, historique (...)

Sur d’autres sites (5019)

  • FFMPEG - convert video without losing resolution

    29 octobre 2015, par Srh

    I am using ffmpeg to convert mp4 video from youtube. The video is HD 1080. When I convert it to mpeg2video, the video loses its sharpness, regardless of the -s 1920x1080 parameter. How can I convert the video without losing picture sharpness ? The command I use is :

    ffmpeg -i BBB.mp4 -vcodec mpeg2video -s1920x1080 -acodec copy -f mpegts BBB.ts

  • FFmpeg : generating H264 video in c++

    13 octobre 2015, par EZEROFIVE EMD

    Im using ffmpeg library in windows with vs2012 to convert a series of images into Mp4 with H264 encoding. Im new to FFMPEG.

    Below is my code. Everything went fine. Video is created.But i can play the video in vlc player only if i changed the extension to ".h264", also when i check for codec information it says "H264 - MPEG-4 AVC (part 10) (h264)". but when i checked the same for other mp4 videos which are downloaded from web. it says "H264 - MPEG-4" AVC (part 10) (avc1)". I dont understand where it went wrong. Also i searched a lot, some says like add SPS and PPS.

    const uint8_t sps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00,
    
0x0a, 0xf8, 0x41, 0xa2 };
    
const uint8_t pps[] = { 0x00, 0x00, 0x00, 0x01, 0x68, 0xce,
    
0x38, 0x80 };

    So i added the above value to video file before i add the image stream. But no luck.
    Can anyone help on this..Thanks in advance.

    const uint8_t sps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00,
    
0x0a, 0xf8, 0x41, 0xa2 };
    
const uint8_t pps[] = { 0x00, 0x00, 0x00, 0x01, 0x68, 0xce,
    
0x38, 0x80 };
    
const uint8_t slice_header[] = { 0x00, 0x00, 0x00, 0x01, 0x05, 0x88,
    
0x84, 0x21, 0xa0 };
    
const uint8_t macroblock_header[] = { 0x0d, 0x00 };
    

    
const uint8_t spspps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x0a, 0xf8, 0x41, 0xa2, 
    
                           0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x38, 0x80
    
                         };
    

    
int ff_load_image(uint8_t *data[4], int linesize[4],
    
        int *w, int *h, enum PixelFormat *pix_fmt,
    
        const char *filename, void *log_ctx)
    
    {
    
        AVInputFormat *iformat = NULL;
    
        AVFormatContext *format_ctx = NULL;
    
        AVCodec *codec=NULL;
    
        AVCodecContext *codec_ctx=NULL;
    
        AVFrame *frame=NULL;
    
        int frame_decoded, ret = 0;
    
        AVPacket pkt;
    

    
        av_register_all();
    

    
        iformat = av_find_input_format("image2");
    
        if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {
    
            return ret;
    
        }
    

    
        codec_ctx = format_ctx->streams[0]->codec;
    
        codec = avcodec_find_decoder(codec_ctx->codec_id);
    
        if (!codec) {
    
            ret = AVERROR(EINVAL);
    
            goto end;
    
        }
    

    
        if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
    
            goto end;
    
        }
    

    
        //if (!(frame = avcodec_alloc_frame()) ) {
    
        if (!(frame = av_frame_alloc()) ) {
    
            ret = AVERROR(ENOMEM);
    
            goto end;
    
        }
    

    
        ret = av_read_frame(format_ctx, &pkt);
    
        if (ret < 0) {
    
            goto end;
    
        }
    

    
        ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);
    
        if (ret < 0 || !frame_decoded) {
    
            goto end;
    
        }
    
        ret = 0;
    

    
        *w       = frame->width;
    
        *h       = frame->height;
    
        *pix_fmt = (PixelFormat)frame->format;
    

    
        if ((ret = av_image_alloc(data, linesize, *w, *h, (AVPixelFormat)*pix_fmt, 16)) < 0)
    
            goto end;
    
        ret = 0;
    

    
        av_image_copy(data, linesize, (const uint8_t **)frame->data, frame->linesize, (AVPixelFormat)*pix_fmt, *w, *h);
    

    
end:
    
        if(codec_ctx) { avcodec_close(codec_ctx); }
    
        if(format_ctx) { avformat_close_input(&format_ctx); }
    
        if(frame) { av_freep(&frame); }
    
        av_free_packet(&pkt);
    
                return ret;
    
    }
    

    
    int load_image_into_frame(AVFrame *frame, const char *filename)
    
    {
    
        int retval = -1, res;
    
        static struct SwsContext *sws_ctx;
    
        uint8_t *image_data[4];
    
        int linesize[4];
    
        int source_width, source_height;
    
        enum PixelFormat source_fmt;
    

    
        res = ff_load_image(image_data, linesize, &source_width, &source_height, &source_fmt, filename, NULL);
    

    
        if (source_fmt != frame->format) {
    
            sws_ctx = sws_getContext(source_width, source_height, (AVPixelFormat)source_fmt,
    
                frame->width, frame->height, (AVPixelFormat)frame->format,
    
                sws_flags, NULL, NULL, NULL);
    

    
            sws_scale(sws_ctx,
    
                (const uint8_t * const *)image_data, linesize,
    
                0, frame->height, frame->data, frame->linesize);
    
        }
    

    
        retval = 0;
    
error:
    
        av_freep(&image_data[0]);
    
        sws_freeContext(sws_ctx);
    
        return retval;
    
    }
    

    
    int write_frame_to_file(FILE *file, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
    
        int res, got_output;
    
        av_init_packet(pkt);
    
        pkt->data = NULL;
    
        pkt->size = 0;
    

    
        /* generate synthetic video */
    
        frame->pts += 30;
    

    
        res = avcodec_encode_video2(codec_context, pkt, frame, &got_output);
    

    
        if (got_output) {
    

    
            fwrite(pkt->data, 1, pkt->size, file);
    
            av_free_packet(pkt);
    
        }
    
        return 0;
    
error:
    
        return -1;
    
    }
    

    
    int write_image_to_file(FILE *file, const char *filename, int count, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
    
        int res, i;
    
        res = load_image_into_frame(frame, filename);
    

    
        for (i = 0; i < count; i++) {
    

    
            res = write_frame_to_file(file, frame, codec_context, pkt);
    
        }
    

    
        return 0;
    
error:
    
        return -1;
    
    }
    

    
    int write_delayed_frames_to_file(FILE *file, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
    
        int res, got_output;
    

    
        for (got_output = 1; got_output;) {
    
            res = avcodec_encode_video2(codec_context, pkt, NULL, &got_output);
    

    
            if (got_output) {
    
                fwrite(pkt->data, 1, pkt->size, file);
    
                av_free_packet(pkt);
    
            }
    
        }
    

    
        return 0;
    
error:
    
        return -1;
    
    }
    

    
    AVCodecContext *get_codec_context(int width, int height, int fps)
    
    {
    
        int res;
    
        avcodec_register_all();
    

    
        AVCodec *codec;
    
        AVCodecContext *codec_context = NULL;
    

    
        codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    

    
        codec_context = avcodec_alloc_context3(codec);
    

    
        codec_context->bit_rate = 441000;
    
        codec_context->width = width;
    
        codec_context->height = height;
    
        AVRational temp_113 = {1, fps};
    
        AVRational temp_114 = {fps, 1};
    
        codec_context->time_base= temp_113;
    
        codec_context->gop_size = 10;
    
        codec_context->max_b_frames=1;
    
        codec_context->pix_fmt = AV_PIX_FMT_YUV420P;        
    

    
        res = avcodec_open2(codec_context, codec, NULL);
    

    
        return codec_context;
    
error:
    
        return NULL;
    
    }
    

    
    AVFrame *get_av_frame(AVCodecContext *codec_context) {
    
        int res;
    
        AVFrame *frame;
    

    
        frame = av_frame_alloc();
    
        frame->height = codec_context->height;
    
        frame->width = codec_context->width;
    
        frame->format = codec_context->pix_fmt;
    
        frame->pts = 0;
    

    
        res = av_image_alloc(frame->data, frame->linesize, frame->width, frame->height, (AVPixelFormat)frame->format, 1);
    

    
        return frame;
    
error:
    
        return NULL;
    
    }
    

    
    int main(int argc, char **argv)
    
    {
    
        const char *filename = "result video\\test.mp4";
    
        FILE *file=NULL;
    
        int res, retval=-1;
    
        AVCodecContext *codec_context= NULL;
    
        AVFrame *frame=NULL;
    
        AVPacket pkt;
    
        uint8_t endcode[] = { 0, 0, 1, 0xb7 };
    

    
        codec_context = get_codec_context(1920, 1080, 30);
    

    
        file = fopen(filename, "wb");
    
        //check(file != NULL, "could not open destination file %s", filename);
    

    
        frame = get_av_frame(codec_context);        
    

    
        //fwrite(sps, 1, sizeof(sps), file);
    
        //fwrite(pps, 1, sizeof(pps), file);
    

    
        /*codec_context->extradata = (uint8_t *)malloc(sizeof(uint8_t) * sizeof(spspps));
    

    
        for(unsigned int index = 0; index < sizeof(spspps); index++)
    
        {
    
            codec_context->extradata[index] = spspps[index];
    
        }
    

    
        codec_context->extradata_size = (int)sizeof(spspps);*/
    

    
        codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
    

    
        int i, frames= 51;
    
        for (i = 0; i < frames; i++) {
    
            std::stringstream ss;
    
            ss<<"\\frames\\out"<<( i + 1)<<".jpg";
    
            res = write_image_to_file(file, ss.str().c_str(), 3, frame, codec_context, &pkt);
    
        }
    

    

    
        res = write_delayed_frames_to_file(file, frame, codec_context, &pkt);
    
        fwrite(endcode, 1, sizeof(endcode), file);
    

    
        retval = 0;
    
error:
    
        if (file)
    
            fclose(file);
    
        if (codec_context) {
    
            avcodec_close(codec_context);
    
            av_free(codec_context);
    
        }
    
        if (frame) {
    
            av_freep(&frame->data[0]);
    
            av_free(frame);
    
        }
    
        return retval;
    
    }
    
}

  • ffmpeg javacv audio - integrate audio into video javacv

    16 juillet 2014, par Cyril Lequeux

    I’ve looked for this issue since a while but I didn’t find out any solution...
    I want to create a video from pictures with javacv (great, it works). But now I want to put in a sync way audio into my video. I heard I had to make a byte array with the sound data and then record() according to the audiobitrate/8 = audiobyterate but i didn’t find a simple sample...I’m not the first asking this question but all the same questions are still unanswered

        IplImage Image = cvLoadImage("data/photo.jpg");
    
    FrameRecorder recorder = FFmpegFrameRecorder.createDefault("out.avi", 1920, 1080);
    
    recorder.setVideoCodec(AV_CODEC_ID_MPEG4);
    
    recorder.setFrameRate(30);
    
    recorder.setFormat("avi");
    
    recorder.start();
    
        for(int s=0; s<10; s++){
    
            for(int i=0; i<30; i++){
    
                recorder.record(Image);
    
//Here I want to record my music.mp3 stream
    
            }
    
        }
    
        recorder.stop();

    Please help me, I’m desesperate :p
    Ps : I’m using javacv 0.3 FFMPEG 1.06 OpenCv 2.4.3

Navigation