Recherche avancée

Médias (1)

Mot : - Tags -/Rennes

Autres articles (21)

  • Participer à sa traduction

    10 avril 2011

    Vous pouvez nous aider à améliorer les locutions utilisées dans le logiciel ou à traduire celui-ci dans n’importe qu’elle nouvelle langue permettant sa diffusion à de nouvelles communautés linguistiques.
    Pour ce faire, on utilise l’interface de traduction de SPIP où l’ensemble des modules de langue de MediaSPIP sont à disposition. ll vous suffit de vous inscrire sur la liste de discussion des traducteurs pour demander plus d’informations.
    Actuellement MediaSPIP n’est disponible qu’en français et (...)

  • Encoding and processing into web-friendly formats

    13 avril 2011, par

    MediaSPIP automatically converts uploaded files to internet-compatible formats.
    Video files are encoded in MP4, Ogv and WebM (supported by HTML5) and MP4 (supported by Flash).
    Audio files are encoded in MP3 and Ogg (supported by HTML5) and MP3 (supported by Flash).
    Where possible, text is analyzed in order to retrieve the data needed for search engine detection, and then exported as a series of image files.
    All uploaded files are stored online in their original format, so you can (...)

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

Sur d’autres sites (6659)

  • FFmpeg poor quality encoded MPEG-4 video

    10 octobre 2017, par Frank Natoli

    Have adapted FFmpeg sample muxing.c under Windows 7 to write MP4 files from video camera RGB data.
    Using muxing.c default bit_rate=400000.
    Am not setting global_quality.
    Resultant MP4 is poor quality, highly pixelated.
    Original raw images in video camera are sharp.
    What values should I use for bit_rate ? Do I have to also set rc_max_rate ?
    What values should I use for global_quality ? Do I have to set any flags to enable use of global_quality ?
    Is bit_rate versus global_quality an either/or situation ? Or can both be useful in adjusting quality ?
    Thanks for your time.

  • Undefined reference, using FFMpeg-library (AvCodec) on Ubuntu, 64-bits system

    5 mai 2012, par Anders Branderud

    I am running the example code of the latest FFMpeg-library.
    I have inserted the example code into the file videofecencoder.c :

    /*
    
* copyright (c) 2001 Fabrice Bellard
    
*
    
* This file is part of Libav.
    
*
    
* Libav is free software; you can redistribute it and/or
    
* modify it under the terms of the GNU Lesser General Public
    
* License as published by the Free Software Foundation; either
    
* version 2.1 of the License, or (at your option) any later version.
    
*
    
* Libav is distributed in the hope that it will be useful,
    
* but WITHOUT ANY WARRANTY; without even the implied warranty of
    
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
* Lesser General Public License for more details.
    
*
    
* You should have received a copy of the GNU Lesser General Public
    
* License along with Libav; if not, write to the Free Software
    
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
*/
    
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    

    

    
#include 
    
#include 
    
#include 
    

    
#ifdef HAVE_AV_CONFIG_H
    
#undef HAVE_AV_CONFIG_H
    
#endif
    

    
#include "libavutil/imgutils.h"
    
#include "libavutil/opt.h"
    
#include "libavcodec/avcodec.h"
    
#include "libavutil/mathematics.h"
    
#include "libavutil/samplefmt.h"
    

    
#define INBUF_SIZE 4096
    
#define AUDIO_INBUF_SIZE 20480
    
#define AUDIO_REFILL_THRESH 4096
    

    
/*
    
* Video encoding example
    
*/
    
static void video_encode_example(const char *filename, int codec_id)
    
{
    
   AVCodec *codec;
    
   AVCodecContext *c= NULL;
    
   int i, out_size, size, x, y, outbuf_size;
    
   FILE *f;
    
   AVFrame *picture;
    
   uint8_t *outbuf;
    
   int nrOfFramesPerSecond  =25;
    
   int nrOfSeconds =1;
    

    

    
   printf("Video encoding\n");
    

    
   /* find the mpeg1 video encoder */
    
   codec = avcodec_find_encoder((CodecID) codec_id);
    
   if (!codec) {
    
       fprintf(stderr, "codec not found\n");
    
       exit(1);
    
   }
    

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

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

    
   if(codec_id == 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);
    
   }
    

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

    
   /* alloc image and output buffer */
    
   outbuf_size = 100000;
    
   outbuf = (uint8_t*) malloc(outbuf_size);
    

    
   /* 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 */
    
   av_image_alloc(picture->data, picture->linesize,
    
                  c->width, c->height, c->pix_fmt, 1);
    

    
   /* encode 1 second of video */
    
   int nrOfFramesTotal = nrOfFramesPerSecond * nrOfSeconds;
    

    
   /* encode 1 second of video */
    
   for(i=0;i < nrOfFramesTotal; i++) {
    
       fflush(stdout);
    
       /* prepare a dummy image */
    
       /* Y */
    
       for(y=0;yheight;y++) {
    
           for(x=0;xwidth;x++) {
    
               picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
    
           }
    
       }
    

    
       /* Cb and Cr */
    
       for(y=0;yheight/2;y++) {
    
           for(x=0;xwidth/2;x++) {
    
               picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
    
               picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
    
           }
    
       }
    

    
       /* encode the image */
    
       out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
    
       printf("encoding frame %3d (size=%5d)\n", i, out_size);
    
       fwrite(outbuf, 1, out_size, f);
    
   }
    

    
   /* get the delayed frames */
    
   for(; out_size; i++) {
    
       fflush(stdout);
    

    
       out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
    
       printf("write frame %3d (size=%5d)\n", i, out_size);
    
       fwrite(outbuf, 1, out_size, f);
    
   }
    

    
   /* add sequence end code to have a real mpeg file */
    
   outbuf[0] = 0x00;
    
   outbuf[1] = 0x00;
    
   outbuf[2] = 0x01;
    
   outbuf[3] = 0xb7;
    
   fwrite(outbuf, 1, 4, f);
    
   fclose(f);
    
   free(outbuf);
    

    
   avcodec_close(c);
    
   av_free(c);
    
   av_free(picture->data[0]);
    
   av_free(picture);
    
   printf("\n");
    
}
    

    
int main(int argc, char **argv)
    
{
    
   const char *filename;
    

    
   /* register all the codecs */
    
   avcodec_register_all();
    

    
   if (argc <= 1) {
    

    
       video_encode_example("/grb_1.mpg", CODEC_ID_MPEG1VIDEO);
    
   } else {
    
       filename = argv[1];
    
   }
    

    

    
   return 0;
    
}

    When I run gcc videofecencoder.cc -lavcodec I get the following error messages :

    /tmp/ccJg8IDy.o: In function `video_encode_example(char const*, int)':
    
videofecencoder.cc:(.text+0x35): undefined reference to `avcodec_find_encoder(CodecID)'
    
videofecencoder.cc:(.text+0x74): undefined reference to `avcodec_alloc_context3(AVCodec*)'
    
videofecencoder.cc:(.text+0x7d): undefined reference to `avcodec_alloc_frame()'
    
videofecencoder.cc:(.text+0x113): undefined reference to `av_opt_set(void*, char const*, char const*, int)'
    
videofecencoder.cc:(.text+0x12b): undefined reference to `avcodec_open2(AVCodecContext*, AVCodec*, AVDictionary**)'
    
videofecencoder.cc:(.text+0x1f0): undefined reference to `av_image_alloc(unsigned char**, int*, int, int, PixelFormat, int)'
    
videofecencoder.cc:(.text+0x35c): undefined reference to `avcodec_encode_video(AVCodecContext*, unsigned char*, int, AVFrame const*)'
    
videofecencoder.cc:(.text+0x3cf): undefined reference to `avcodec_encode_video(AVCodecContext*, unsigned char*, int, AVFrame const*)'
    
videofecencoder.cc:(.text+0x47c): undefined reference to `avcodec_close(AVCodecContext*)'
    
videofecencoder.cc:(.text+0x488): undefined reference to `av_free(void*)'
    
videofecencoder.cc:(.text+0x497): undefined reference to `av_free(void*)'
    
videofecencoder.cc:(.text+0x4a3): undefined reference to `av_free(void*)'
    
/tmp/ccJg8IDy.o: In function `main':
    
videofecencoder.cc:(.text+0x4c3): undefined reference to `avcodec_register_all()'
    
collect2: ld returnerade avslutningsstatus 1

    The command nm libavcodec.a | grep avcodec_find results in :

    00000000000008e0 T avcodec_find_best_pix_fmt
    
0000000000000740 T avcodec_find_best_pix_fmt2
    
                 U avcodec_find_encoder
    
0000000000002ca0 T avcodec_find_decoder
    
0000000000002cf0 T avcodec_find_decoder_by_name
    
0000000000002bd0 T avcodec_find_encoder
    
0000000000002c30 T avcodec_find_encoder_by_name

    I also have another similar error with another library :
    Undefined reference despite linking in OpenFEC-library

    My system : Ubuntu 11, 64-bits machine

    My next step is to try to compile it on VirtualBox with Ubuntu 32 bits (running on a Windows-OS).

  • FFmpeg mux video use libavformat avcodec but output couldn't be played

    10 août 2017, par tqn

    I’m trying write a app that take an input video and crop it to square video and ignore audio stream. Because bad performance if using command, I’m trying to use libavcodec and libavformat to do it. But the output isn’t playable by any video player and duration is 0 although I wrote all frame. Here are my code.

    void convert_video(char* input) {
    
    AVFormatContext *pFormatCtx = NULL;
    
    int             i, videoStreamIndex;
    
    AVCodecContext  *pCodecCtx = NULL;
    
    AVCodec         *pCodec = NULL;
    
    AVFrame         *pFrame = NULL;
    
    AVFrame         *pFrameSquare = NULL;
    
    AVPacket        packet, outPacket;
    
    int             frameFinished;
    
    int             numBytes;
    
    uint8_t         *buffer = NULL;
    
    AVCodec         *pEncodec = NULL;
    
    AVFormatContext *poFormatCxt = NULL;
    
    MuxOutputStream    videoStream = {0}, audioStream = {0};
    
    int tar_w, tar_h;
    

    
    const enum AVPixelFormat pic_format = AV_PIX_FMT_YUV420P;
    
    const enum AVCodecID codec_id = AV_CODEC_ID_H264;
    
    AVDictionary    *optionsDict = NULL;
    
    char output[50];
    
    sprintf(output, "%soutput.mp4", ANDROID_SDCARD);
    

    
    // Register all formats and codecs
    
    av_register_all();
    

    
    // Open video file
    
    if(avformat_open_input(&pFormatCtx, input, NULL, NULL)!=0)
    
        return; // Couldn't open file
    
    avformat_alloc_output_context2(&poFormatCxt, NULL, NULL, output);
    

    
    // Retrieve stream information
    
    if(avformat_find_stream_info(pFormatCtx, NULL)<0)
    
        return; // Couldn't find stream information
    

    
    // Find the first video stream
    
    videoStreamIndex=-1;
    
    for(i=0; inb_streams; i++)
    
        if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
    
            videoStreamIndex=i;
    
            break;
    
        }
    
    if(videoStreamIndex==-1)
    
        return; // Didn't find a video stream
    

    
    // Get a pointer to the codec context for the video stream
    
    pCodecCtx = pFormatCtx->streams[videoStreamIndex]->codec;
    
    tar_w = pCodecCtx->width > pCodecCtx->height ? pCodecCtx->height : pCodecCtx->width;
    
    tar_h = tar_w;
    

    
    // Find the decoder for the video stream
    
    pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
    
    pEncodec = avcodec_find_encoder(codec_id);
    

    
    add_stream_mux(&videoStream, poFormatCxt, &pEncodec, codec_id, tar_w, tar_h);
    
    videoStream.st[0].time_base = pFormatCtx->streams[videoStreamIndex]->time_base;
    
    videoStream.st[0].codec->time_base = videoStream.st[0].time_base;
    
    videoStream.st[0].codec->time_base.den *= videoStream.st[0].codec->ticks_per_frame;
    
//    add_stream(&audioStream, poFormatCxt, &)
    
    open_video(poFormatCxt, pEncodec, &videoStream, optionsDict);
    
    int ret = avio_open(&poFormatCxt->pb, output, AVIO_FLAG_WRITE);
    

    
    // Open codec
    
    if(avcodec_open2(pCodecCtx, pCodec, &optionsDict) < 0)
    
        return; // Could not open codec
    

    
    ret = avformat_write_header(poFormatCxt, &optionsDict);
    
    if (ret != 0) {
    
        ANDROID_LOG("Died");
    
    }
    

    
    // Allocate video frame
    
    pFrame=av_frame_alloc();
    
    pFrame->format = videoStream.st->codec->pix_fmt;
    
    pFrame->width = pCodecCtx->width;
    
    pFrame->height = pCodecCtx->height;
    
    av_frame_get_buffer(pFrame, 32);
    

    
    // Allocate an AVFrame structure
    
    pFrameSquare=av_frame_alloc();
    
    if(pFrameSquare==NULL)
    
        return;
    

    
    // Determine required buffer size and allocate buffer
    
    numBytes=avpicture_get_size(pic_format, tar_w,
    
                                tar_h);
    
    buffer = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
    

    
    // Assign appropriate parts of buffer to image planes in pFrameSquare
    
    // Note that pFrameSquare is an AVFrame, but AVFrame is a superset
    
    // of AVPicture
    
    ret = avpicture_fill((AVPicture *)pFrameSquare, buffer, pic_format,
    
                   tar_w, tar_h);
    
    if (ret < 0) {
    
        ANDROID_LOG("Can't fill picture");
    
        return;
    
    }
    

    
    // Read frames and save first five frames to disk
    
    i=0;
    
    ret = av_read_frame(pFormatCtx, &packet);
    
    while(ret >= 0) {
    
        // Is this a packet from the video stream?
    
        if(packet.stream_index == videoStreamIndex) {
    
            // Decode video frame
    
//            av_packet_rescale_ts(&packet, videoStream.st->time_base, videoStream.st->codec->time_base);
    
            avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished,
    
                                  &packet);
    
//            while (!frameFinished) {
    
//                avcodec_decode_video2(videoStream.st->codec, pFrame, &frameFinished, NULL);
    
//            }
    
            ANDROID_LOG("Trying to decode frame %d with result %d", i, frameFinished);
    
            ret = av_picture_crop((AVPicture*) pFrameSquare, (AVPicture*) pFrame, pic_format, 0, 0);
    
            if (ret < 0) {
    
                ANDROID_LOG("Can't crop image");
    
            }
    
//            av_frame_get_best_effort_timestamp(pFrame);
    
//            av_rescale_q()
    

    
            if(frameFinished) {
    

    
                // Save the frame to disk
    
                av_init_packet(&outPacket);
    
//                av_packet_rescale_ts(&outPacket, videoStream.st->codec->time_base, videoStream.st->time_base);
    
                pFrameSquare->width = tar_w;
    
                pFrameSquare->height = tar_h;
    
                pFrameSquare->format = pic_format;
    
                pFrameSquare->pts = ++videoStream.next_pts;
    
                ret = avcodec_encode_video2(videoStream.st->codec, &outPacket, pFrameSquare, &frameFinished);
    

    
//                int count = 0;
    
//                while (!frameFinished && count++ < 6) {
    
//                    ret = avcodec_encode_video2(videoStream.st->codec, &outPacket, NULL, &frameFinished);
    
//                }
    
                if (frameFinished) {
    
                    ANDROID_LOG("Writing frame %d", i);
    
                    outPacket.stream_index = videoStreamIndex;
    
                    av_interleaved_write_frame(poFormatCxt, &outPacket);
    
                }
    
                av_free_packet(&outPacket);
    
            }
    
        }
    

    
        // Free the packet that was allocated by av_read_frameav_free_packet(&packet);
    
        ret = av_read_frame(pFormatCtx, &packet);
    
    }
    

    
    ret = av_write_trailer(poFormatCxt);
    
    if (ret < 0) {
    
        ANDROID_LOG("Couldn't write trailer");
    
    } else {
    
        ANDROID_LOG("Video convert finished");
    
    }
    

    
    // Free the RGB image
    
    av_free(buffer);
    
    av_free(pFrameSquare);
    

    
    // Free the YUV frame
    
    av_free(pFrame);
    

    
    // Close the codec
    
    avcodec_close(pCodecCtx);
    
//    avcodec_close(pEncodecCtx);
    

    
    // Close the video file
    
    avformat_close_input(&pFormatCtx);
    

    
    return;
    
}

    Helper

    #define STREAM_DURATION   10.0
    
#define STREAM_FRAME_RATE 25 /* 25 images/s */
    
#define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
    

    
/* Add an output stream. */
    
void add_stream_mux(MuxOutputStream *ost, AVFormatContext *oc,
    
                       AVCodec **codec,
    
                       enum AVCodecID codec_id, int width, int heigh)
    
{
    
    AVCodecContext *codecCtx;
    
    int i;
    
    /* find the encoder */
    
    *codec = avcodec_find_encoder(codec_id);
    
    if (!(*codec)) {
    
        fprintf(stderr, "Could not find encoder for '%s'\n",
    
                avcodec_get_name(codec_id));
    
        exit(1);
    
    }
    
    ost->st = avformat_new_stream(oc, *codec);
    
    if (!ost->st) {
    
        fprintf(stderr, "Could not allocate stream\n");
    
        exit(1);
    
    }
    
    ost->st->id = oc->nb_streams-1;
    
    codecCtx = ost->st->codec;
    
    switch ((*codec)->type) {
    
        case AVMEDIA_TYPE_AUDIO:
    
            codecCtx->sample_fmt  = (*codec)->sample_fmts ?
    
                             (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
    
            codecCtx->bit_rate    = 64000;
    
            codecCtx->sample_rate = 44100;
    
            if ((*codec)->supported_samplerates) {
    
                codecCtx->sample_rate = (*codec)->supported_samplerates[0];
    
                for (i = 0; (*codec)->supported_samplerates[i]; i++) {
    
                    if ((*codec)->supported_samplerates[i] == 44100)
    
                        codecCtx->sample_rate = 44100;
    
                }
    
            }
    
            codecCtx->channels        = av_get_channel_layout_nb_channels(codecCtx->channel_layout);
    
            codecCtx->channel_layout = AV_CH_LAYOUT_STEREO;
    
            if ((*codec)->channel_layouts) {
    
                codecCtx->channel_layout = (*codec)->channel_layouts[0];
    
                for (i = 0; (*codec)->channel_layouts[i]; i++) {
    
                    if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
    
                        codecCtx->channel_layout = AV_CH_LAYOUT_STEREO;
    
                }
    
            }
    
            codecCtx->channels        = av_get_channel_layout_nb_channels(codecCtx->channel_layout);
    
            ost->st->time_base = (AVRational){ 1, codecCtx->sample_rate };
    
            break;
    
        case AVMEDIA_TYPE_VIDEO:
    
            codecCtx->codec_id = codec_id;
    
            codecCtx->bit_rate = 400000;
    
            /* Resolution must be a multiple of two. */
    
            codecCtx->width    = width;
    
            codecCtx->height   = heigh;
    
            /* timebase: This is the fundamental unit of time (in seconds) in terms
    
             * of which frame timestamps are represented. For fixed-fps content,
    
             * timebase should be 1/framerate and timestamp increments should be
    
             * identical to 1. */
    
            ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };
    
            codecCtx->time_base       = ost->st->time_base;
    
            codecCtx->gop_size      = 12; /* emit one intra frame every twelve frames at most */
    
            codecCtx->pix_fmt       = STREAM_PIX_FMT;
    
            if (codecCtx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    
                /* just for testing, we also add B frames */
    
                codecCtx->max_b_frames = 2;
    
            }
    
            if (codecCtx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
    
                /* Needed to avoid using macroblocks in which some coeffs overflow.
    
                 * This does not happen with normal video, it just happens here as
    
                 * the motion of the chroma plane does not match the luma plane. */
    
                codecCtx->mb_decision = 2;
    
            }
    
            break;
    
        default:
    
            break;
    
    }
    
    /* Some formats want stream headers to be separate. */
    
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
    
        codecCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    
}
    
static void open_video(AVFormatContext *oc, AVCodec *codec, MuxOutputStream *ost, AVDictionary *opt_arg)
    
{
    
    int ret;
    
    AVCodecContext *c = ost->st->codec;
    
    AVDictionary *opt = NULL;
    
    av_dict_copy(&opt, opt_arg, 0);
    
    /* open the codec */
    
    ret = avcodec_open2(c, codec, &opt);
    
    av_dict_free(&opt);
    
    if (ret < 0) {
    
        fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
    
        exit(1);
    
    }
    
    /* allocate and init a re-usable frame */
    
    ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
    
    if (!ost->frame) {
    
        fprintf(stderr, "Could not allocate video frame\n");
    
        exit(1);
    
    }
    
    /* If the output format is not YUV420P, then a temporary YUV420P
    
     * picture is needed too. It is then converted to the required
    
     * output format. */
    
    ost->tmp_frame = NULL;
    
    if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
    
        ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
    
        if (!ost->tmp_frame) {
    
            fprintf(stderr, "Could not allocate temporary picture\n");
    
            exit(1);
    
        }
    
    }
    
}

    I’m afraid that I set wrong pts or time_base of frame, and also when decoding or encoding, I see that some first frame is lost, frameFinished is 0. See a post that I’ve to flush decoder by avcodec_decode_video2(videoStream.st->codec, pFrame, &frameFinished, NULL) but after try a few times, frameFinished still is 0, and with avcodec_encode_video2(videoStream.st->codec, &outPacket, NULL, &frameFinished) will throw error in next encode frame. So how I can get all frame that lost ? I’m using FFmpeg version 3.0.1

Navigation