Recherche avancée

Médias (0)

Mot : - Tags -/alertes

Aucun média correspondant à vos critères n’est disponible sur le site.

Autres articles (106)

  • MediaSPIP 0.1 Beta version

    25 avril 2011, par

    MediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
    The zip file provided here only contains the sources of MediaSPIP in its standalone version.
    To get a working installation, you must manually install all-software dependencies on the server.
    If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...)

  • Amélioration de la version de base

    13 septembre 2013

    Jolie sélection multiple
    Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
    Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...)

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

Sur d’autres sites (15916)

  • Set H264 high quality encoding in FFMPEG

    25 décembre 2015, par hiitiger

    I’m working on a function, using ffmpeg to encode a serial images to a MP4 file.
    I use H264 codec, and want to have a high quality output.

    Other things now goes well, but the video quality looks obvious loss.

    After some Google, I set codec context like this

    video_st = avformat_new_stream(oc, 0);
    ....
    pVideoCodec  = avcodec_find_encoder(fmt->video_codec); //AV_CODEC_ID_H264
    ....
    avcodec_get_context_defaults3(video_st->codec, pVideoCodec);
    video_st->codec->codec_id =  fmt->video_codec;
    video_st->codec->width = m_outWidth;
    video_st->codec->height = m_outHeight;
    video_st->codec->time_base.den = m_fps;
    video_st->codec->time_base.num = 1;
    video_st->codec->pix_fmt = AV_PIX_FMT_YUV420P;

    AVDictionary *param = nullptr;
    av_dict_set(&param, "qp", "0", 0);
    av_dict_set(&param, "preset", "medium", 0);

    I also try to set bit_rate. But all turned out to be bad.

    I want a visually loss less output video.

    So what parameters should I set or anything else did I missed ?

  • How to explain the given ffplay C code snippet ?

    20 juillet 2015, par Jerikc XIONG

    The following code snippet is from ffplay :

    static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
       int got_frame = 0;

       do {
           int ret = -1;

           if (d->queue->abort_request)
               return -1;

           if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
               AVPacket pkt;
               do {
                   if (d->queue->nb_packets == 0)
                       SDL_CondSignal(d->empty_queue_cond);
                   if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
                       return -1;
                   if (pkt.data == flush_pkt.data) {
                       avcodec_flush_buffers(d->avctx);
                       d->finished = 0;
                       d->next_pts = d->start_pts;
                       d->next_pts_tb = d->start_pts_tb;
                   }
               } while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
               av_free_packet(&d->pkt);
               d->pkt_temp = d->pkt = pkt;
               d->packet_pending = 1;
           }

           switch (d->avctx->codec_type) {
               case AVMEDIA_TYPE_VIDEO:
                   ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
                   if (got_frame) {
                       if (decoder_reorder_pts == -1) {
                           frame->pts = av_frame_get_best_effort_timestamp(frame);
                       } else if (decoder_reorder_pts) {
                           frame->pts = frame->pkt_pts;
                       } else {
                           frame->pts = frame->pkt_dts;
                       }
                   }
                   break;
               case AVMEDIA_TYPE_AUDIO:
                   ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
                   if (got_frame) {
                       AVRational tb = (AVRational){1, frame->sample_rate};
                       if (frame->pts != AV_NOPTS_VALUE)
                           frame->pts = av_rescale_q(frame->pts, d->avctx->time_base, tb);
                       else if (frame->pkt_pts != AV_NOPTS_VALUE)
                           frame->pts = av_rescale_q(frame->pkt_pts, av_codec_get_pkt_timebase(d->avctx), tb);
                       else if (d->next_pts != AV_NOPTS_VALUE)
                           frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
                       if (frame->pts != AV_NOPTS_VALUE) {
                           d->next_pts = frame->pts + frame->nb_samples;
                           d->next_pts_tb = tb;
                       }
                   }
                   break;
               case AVMEDIA_TYPE_SUBTITLE:
                   ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
                   break;
           }

           if (ret < 0) {
               d->packet_pending = 0;
           } else {
               d->pkt_temp.dts =
               d->pkt_temp.pts = AV_NOPTS_VALUE;
               if (d->pkt_temp.data) {
                   if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
                       ret = d->pkt_temp.size;
                   d->pkt_temp.data += ret;
                   d->pkt_temp.size -= ret;
                   if (d->pkt_temp.size <= 0)
                       d->packet_pending = 0;
               } else {
                   if (!got_frame) {
                       d->packet_pending = 0;
                       d->finished = d->pkt_serial; // FLAG
                   }
               }
           }
       } while (!got_frame && !d->finished);

       return got_frame;
    }

    It’s difficult for me to understand the following code :

    d->finished = d->pkt_serial; // FLAG

    Can anyone help me ?

    Thanks.

  • C++, FFmpeg, save AVPacket infomation into videostate structure in ffplay.c

    28 mai 2015, par Yoohoo

    I am currently working on a project that tests video streaming. In the project, video stream is encoded with H.264 before send and decoded after receive, using FFmpeg codec and functions.

    I can encode video stream by

    init_video_encode(AV_CODEC_ID_H264);

    where

    static void init_video_encode(AVCodecID codec_id){
    codec = avcodec_find_encoder(codec_id);
    if (!codec) {
       fprintf(stderr, "Codec not found\n");
       exit(1);
    }

    c = avcodec_alloc_context3(codec);
    if (!c) {
       fprintf(stderr, "Could not allocate video codec context\n");
       exit(1);
    }

    /* put sample parameters */
    c->bit_rate = 400000;
    /* resolution must be a multiple of two */
    c->width = 640;
    c->height = 480;
    /* frames per second */
    c->time_base= (AVRational){1,25};
    c->gop_size = 10; /* emit one intra frame every ten frames */
    c->max_b_frames=max_f;
    c->pix_fmt = AV_PIX_FMT_YUV420P;

    if(codec_id == AV_CODEC_ID_H264)
       av_opt_set(c->priv_data, "preset", "slow", 0);

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

    frame = avcodec_alloc_frame();
    if (!frame) {
       fprintf(stderr, "Could not allocate video frame\n");
       exit(1);
    }
    frame->format = c->pix_fmt;
    frame->width  = c->width;
    frame->height = c->height;

    /* the image can be allocated by any means and av_image_alloc() is
    * just the most convenient way if av_malloc() is to be used */
    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
                        c->pix_fmt, 32);

    /* get the delayed frames */
    if (ret < 0) {
       fprintf(stderr, "Could not allocate raw picture buffer\n");
       exit(1);
    }
       av_init_packet(&pkt);

    //}

       pkt.data = NULL;    // packet data will be allocated by the encoder
       pkt.size = 0;
       //cout<<"\nBefore YUV\n";
       if(count == 0)
       read_yuv420(frame->data[0]);
       count ++;
      // cout<<"\nAfter YUV\n";
       if(count == SUBSITY) {
       count = 0;
       }

       frame->pts = i++;

       /* encode the image */
       ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
       if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            return -1;
       }
       //cout<<"\nRecord the Video\n";
       if (got_output) {
            //printf("Write frame %3d (size=%5d)\n", i, pkt.size);
            //cout<<"\nBefore Memcpy\n\n\n";

            memcpy(inbufout+totalSize,pkt.data,pkt.size);
            //cout<<"\nAfter Memcpy\n\n\n";
            totalSize+=pkt.size;

    The video encoder works very well, if I write the encoded packet into a .h264 file, it can be played. But at the decoder side, I cannot decode the received packet with :

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

       c = avcodec_alloc_context3(codec);
       if (!c) {
           fprintf(stderr, "Could not allocate video codec context\n");
           exit(1);
       }

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

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

       frame = avcodec_alloc_frame();
       if (!frame) {
           fprintf(stderr, "Could not allocate video frame\n");
           exit(1);
       }
    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
       if (len < 0) {
           fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
           return len;
       }

    The reason of failure is lacking parser, I have tried to build a parser but failed......

    Therefore I am wondering using ffplay.c as a header file in my receiver program so that I can use it as the decoder and player.

    I have took a look at ffplay.c, it actually fetch file into a videostate structure and processing it. The fetching part is from line 3188 of ffplay.c :

    VideoState *is;

       is = av_mallocz(sizeof(VideoState));
       if (!is)
           return NULL;
       av_strlcpy(is->filename, filename, sizeof(is->filename));
       is->iformat = iformat;
       is->ytop    = 0;
       is->xleft   = 0;

       /* start video display */
       if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
           goto fail;
       if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
           goto fail;
       if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
           goto fail;

       packet_queue_init(&is->videoq);
       packet_queue_init(&is->audioq);
       packet_queue_init(&is->subtitleq);

       is->continue_read_thread = SDL_CreateCond();

       init_clock(&is->vidclk, &is->videoq.serial);
       init_clock(&is->audclk, &is->audioq.serial);
       init_clock(&is->extclk, &is->extclk.serial);
       is->audio_clock_serial = -1;
       is->av_sync_type = av_sync_type;
       is->read_tid     = SDL_CreateThread(read_thread, is);
       if (!is->read_tid) {
    fail:
           stream_close(is);
           return NULL;
       }

    Now instead of fetching file, I want to modify ffplay.c code so that let it fetch the received packet, I can save received packet to AVPacket by

    static AVPacket avpkt;
    avpkt.data = inbuf;

    My question is : how to put AVPacket information into videostate structure ?