Recherche avancée

Médias (5)

Mot : - Tags -/open film making

Autres articles (111)

  • Les autorisations surchargées par les plugins

    27 avril 2010, par

    Mediaspip core
    autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs

  • Script d’installation automatique de MediaSPIP

    25 avril 2011, par

    Afin de palier aux difficultés d’installation dues principalement aux dépendances logicielles coté serveur, un script d’installation "tout en un" en bash a été créé afin de faciliter cette étape sur un serveur doté d’une distribution Linux compatible.
    Vous devez bénéficier d’un accès SSH à votre serveur et d’un compte "root" afin de l’utiliser, ce qui permettra d’installer les dépendances. Contactez votre hébergeur si vous ne disposez pas de cela.
    La documentation de l’utilisation du script d’installation (...)

  • Demande de création d’un canal

    12 mars 2010, par

    En fonction de la configuration de la plateforme, l’utilisateur peu avoir à sa disposition deux méthodes différentes de demande de création de canal. La première est au moment de son inscription, la seconde, après son inscription en remplissant un formulaire de demande.
    Les deux manières demandent les mêmes choses fonctionnent à peu près de la même manière, le futur utilisateur doit remplir une série de champ de formulaire permettant tout d’abord aux administrateurs d’avoir des informations quant à (...)

Sur d’autres sites (5186)

  • Encoding a screenshot into a video using FFMPEG

    2 juillet 2013, par mohM

    I'm trying to get the pixels from the screen, and encode the screenshot into a video using ffmpeg. I've seen a couple of examples but they either assume you already have the pixel data, or use image file input. It seems like whether I use sws_scale() or not (which is included in the examples I've seen), or whether I'm typecasting a HBITMAP or RGBQUAD* it's telling me that the image src data is bad and is encoding a blank image rather than the screenshot. Is there something I'm missing here ?

    AVCodec* codec;
    
AVCodecContext* c = NULL;
    
AVFrame* inpic;
    
uint8_t* outbuf, *picture_buf;
    
int i, out_size, size, outbuf_size;
    
HBITMAP hBmp;
    
//int x,y;
    

    
avcodec_register_all();
    

    
printf("Video encoding\n");
    

    
// Find the mpeg1 video encoder
    
codec = avcodec_find_encoder(CODEC_ID_H264);
    
if (!codec) {
    
    fprintf(stderr, "Codec not found\n");
    
    exit(1);
    
}
    
else printf("H264 codec found\n");
    

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

    
c->bit_rate = 400000;
    
c->width = screenWidth;                                     // resolution must be a multiple of two
    
c->height = screenHeight;
    
c->time_base.num = 1;
    
c->time_base.den = 25;
    
c->gop_size = 10;                                           // emit one intra frame every ten frames
    
c->max_b_frames=1;
    
c->pix_fmt = PIX_FMT_YUV420P;
    
c->codec_id = CODEC_ID_H264;
    
//c->codec_type = AVMEDIA_TYPE_VIDEO;
    

    
//av_opt_set(c->priv_data, "preset", "slow", 0);
    
//printf("Setting presets to slow for performance\n");
    

    
// Open the encoder
    
if (avcodec_open2(c, codec,NULL) < 0) {
    
    fprintf(stderr, "Could not open codec\n");
    
    exit(1);
    
}
    
else printf("H264 codec opened\n");
    

    
outbuf_size = 100000 + 12*c->width*c->height;           // alloc image and output buffer
    
//outbuf_size = 100000;
    
outbuf = static_cast(malloc(outbuf_size));
    
size = c->width * c->height;
    
picture_buf = static_cast(malloc((size*3)/2));
    
printf("Setting buffer size to: %d\n",outbuf_size);
    

    
FILE* f = fopen("example.mpg","wb");
    
if(!f) printf("x  -  Cannot open video file for writing\n");
    
else printf("Opened video file for writing\n");
    

    
/*inpic->data[0] = picture_buf;
    
inpic->data[1] = inpic->data[0] + size;
    
inpic->data[2] = inpic->data[1] + size / 4;
    
inpic->linesize[0] = c->width;
    
inpic->linesize[1] = c->width / 2;
    
inpic->linesize[2] = c->width / 2;*/
    

    

    
//int x,y;
    
// encode 1 second of video
    
for(i=0;itime_base.den;i++) {
    
    fflush(stdout);
    

    

    
    HWND hDesktopWnd = GetDesktopWindow();
    
    HDC hDesktopDC = GetDC(hDesktopWnd);
    
    HDC hCaptureDC = CreateCompatibleDC(hDesktopDC);
    
    hBmp = CreateCompatibleBitmap(GetDC(0), screenWidth, screenHeight);
    
    SelectObject(hCaptureDC, hBmp);
    
    BitBlt(hCaptureDC, 0, 0, screenWidth, screenHeight, hDesktopDC, 0, 0, SRCCOPY|CAPTUREBLT);
    
    BITMAPINFO bmi = {0}; 
    
    bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader); 
    
    bmi.bmiHeader.biWidth = screenWidth; 
    
    bmi.bmiHeader.biHeight = screenHeight; 
    
    bmi.bmiHeader.biPlanes = 1; 
    
    bmi.bmiHeader.biBitCount = 32; 
    
    bmi.bmiHeader.biCompression = BI_RGB;
    
    RGBQUAD *pPixels = new RGBQUAD[screenWidth*screenHeight];
    
    GetDIBits(hCaptureDC,hBmp,0,screenHeight,pPixels,&bmi,DIB_RGB_COLORS);
    

    
inpic->pts = (float) i * (1000.0/(float)(c->time_base.den))*90;
    
    avpicture_fill((AVPicture*)inpic, (uint8_t*)pPixels, PIX_FMT_BGR32, c->width, c->height);                   // Fill picture with image
    
    av_image_alloc(inpic->data, inpic->linesize, c->width, c->height, c->pix_fmt, 1);
    
    //printf("Allocated frame\n");
    
    //SaveBMPFile(L"screenshot.bmp",hBmp,hDc,screenWidth,screenHeight);
    
    ReleaseDC(hDesktopWnd,hDesktopDC);
    
    DeleteDC(hCaptureDC);
    
    DeleteObject(hBmp);
    

    
    // encode the image
    
    out_size = avcodec_encode_video(c, outbuf, outbuf_size, inpic);
    
    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("Writing 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(picture_buf);
    
free(outbuf);
    

    
avcodec_close(c);
    
av_free(c);
    
av_free(inpic);
    
printf("Closed codec and Freed\n");

  • ffmpeg Could not find input stream [closed]

    17 avril 2013, par Peter Walker

    I've seen lot's of post on streaming video feeds to ffserver but still haven't found what I wanted.

    I use not only on the mp4 file but avi and other formats as well.

        ffmpeg -i test5.mp4 http://localhost:8090/feed1.ffm

    I keep finding this error.

        Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'test5.mp4':
    
    Metadata:
    
           major_brand     : isom
    
           minor_version   : 512
    
           compatible_brands: isomiso2mp41
    
           encoder         : Lavf53.21.1
    
    Duration: 00:05:00.00, start: 0.000000, bitrate: 278 kb/s
    
    Stream #0.0(und): Video: mpeg4 (Simple Profile), yuv420p, 640x320 [PAR 1:1 DAR     2:1], 277 kb/s, 25 fps, 25 tbr, 25 tbn, 25 tbc
    
    Incompatible sample format '(null)' for codec 'mp2', auto-selecting format 's16'
    
    Last message repeated 1 times
    
    Output #0, ffm, to 'http://localhost:8090/feed1.ffm':
    
    Stream #0.0: Video: [0][0][0][0] / 0x0000, yuv420p, q=0-0, 1000k tbn
    
    Stream #0.1: Video: mpeg1video, (null), 32622x226393720, q=2-31, pass 1, pass 2,     226393 kb/s, 1000k tbn
    
    Stream #0.2: Audio: mp2, 22050 Hz, 1 channels, s16, 226391 kb/s
    
    Stream #0.3: Video: msmpeg4, yuv420p, 352x240, q=2-31, 226391 kb/s, 1000k tbn, 15  tbc
    
    Could not find input stream matching output stream #0.2
    
    *** glibc detected *** ffmpeg: free(): invalid pointer: 0x0000000000a53d00 ***
    
    ======= Backtrace: =========
    
    /lib/x86_64-linux-gnu/libc.so.6(+0x7e626)[0x7f6e0d4af626]
    
    /usr/lib/x86_64-linux-gnu/libavformat.so.53(avformat_free_context+0xb0)    [0x7f6e0f2c9c70]
    
    ffmpeg[0x4089bf]
    
    ffmpeg[0x40a52f]
    
    ffmpeg[0x407a04]
    
    /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f6e0d45276d]

    The config file I used for the ffserver is

        Port 8090
    
    RTSPPort 7654
    
    BindAddress 0.0.0.0
    
    MaxHTTPConnections 2000
    
    MaxClients 1000
    
    MaxBandwidth 500000
    
    CustomLog -
    
    NoDaemon
    
    <feed>
    
            File /tmp/feed1.ffm
    
            FileMaxSize 5M
    
    #       NoAudio
    
    </feed>
    

    
    <stream>
    
            Feed feed1.ffm
    
            Format rtp
    
    #       NoAudio
    
            VideoFrameRate 30
    
    </stream>

    Can anyone help me figure out some something or something to look for ?
    I tried googling but almost everyone uses video feeds instead or it just works well for them.
    Any clue or direction/suggestion would help. Thank you so much in advance.

  • libavcodec : ffprobe on file encoded with FFV1 codec reports "read_quant_table error"

    20 novembre 2016, par Ali Alidoust

    I’m using the following code to encode a series of frames into an mkv or avi file with FFV1 encoding :

       HRESULT Session::createContext(LPCSTR filename, UINT width, UINT height, UINT fps_num, UINT fps_den) {
    
    LOG("Exporting to file: ", filename);
    

    
    AVCodecID codecId = AV_CODEC_ID_FFV1;
    
    this->pixelFormat = AV_PIX_FMT_YUV420P;
    

    
    this->codec = avcodec_find_encoder(codecId);
    
    RET_IF_NULL(this->codec, "Could not create codec", E_FAIL);
    

    
    this->oformat = av_guess_format(NULL, filename, NULL);
    
    RET_IF_NULL(this->oformat, "Could not create format", E_FAIL);
    
    this->oformat->video_codec = codecId;
    
    this->width = width;
    
    this->height = height;
    
    this->codecContext = avcodec_alloc_context3(this->codec);
    
    RET_IF_NULL(this->codecContext, "Could not allocate context for the codec", E_FAIL);
    

    
    this->codecContext->codec = this->codec;
    
    this->codecContext->codec_id = codecId;
    

    
    this->codecContext->pix_fmt = pixelFormat;
    
    this->codecContext->width = this->width;
    
    this->codecContext->height = this->height;
    
    this->codecContext->time_base.num = fps_den;
    
    this->codecContext->time_base.den = fps_num;
    

    
    this->codecContext->gop_size = 1;
    

    

    
    RET_IF_FAILED_AV(avformat_alloc_output_context2(&amp;fmtContext, this->oformat, NULL, NULL), "Could not allocate format context", E_FAIL);
    
    RET_IF_NULL(this->fmtContext, "Could not allocate format context", E_FAIL);
    

    
    this->fmtContext->oformat = this->oformat;
    
    this->fmtContext->video_codec_id = codecId;
    

    
    this->stream = avformat_new_stream(this->fmtContext, this->codec);
    
    RET_IF_NULL(this->stream, "Could not create new stream", E_FAIL);
    
    this->stream->time_base = this->codecContext->time_base;
    
    RET_IF_FAILED_AV(avcodec_parameters_from_context(this->stream->codecpar, this->codecContext), "Could not convert AVCodecContext to AVParameters", E_FAIL);
    

    
    if (this->fmtContext->oformat->flags &amp; AVFMT_GLOBALHEADER)
    
    {
    
        this->codecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
    
    }
    

    
    av_opt_set_int(this->codecContext->priv_data, "coder", 0, 0);
    
    av_opt_set_int(this->codecContext->priv_data, "context", 1, 0);
    
    av_opt_set_int(this->codecContext->priv_data, "slicecrc", 1, 0);
    
    //av_opt_set_int(this->codecContext->priv_data, "slicecrc", 1, 0);
    
    //av_opt_set_int(this->codecContext->priv_data, "pix_fmt", pixelFormat, 0);
    

    
    RET_IF_FAILED_AV(avcodec_open2(this->codecContext, this->codec, NULL), "Could not open codec", E_FAIL);
    
    RET_IF_FAILED_AV(avio_open(&amp;this->fmtContext->pb, filename, AVIO_FLAG_WRITE), "Could not open output file", E_FAIL);
    
    RET_IF_NULL(this->fmtContext->pb, "Could not open output file", E_FAIL);
    
    RET_IF_FAILED_AV(avformat_write_header(this->fmtContext, NULL), "Could not write header", E_FAIL);
    

    
    frame = av_frame_alloc();
    
    RET_IF_NULL(frame, "Could not allocate frame", E_FAIL);
    
    frame->format = this->codecContext->pix_fmt;
    
    frame->width = width;
    
    frame->height = height;
    
    return S_OK;
    
}
    

    
HRESULT Session::writeFrame(IMFSample * pSample) {
    
    IMFMediaBuffer *mediaBuffer = NULL;
    
    BYTE *pDataNV12 = NULL;
    
    DWORD length;
    

    
    RET_IF_FAILED(pSample->ConvertToContiguousBuffer(&amp;mediaBuffer), "Could not convert IMFSample to contagiuous buffer", E_FAIL);
    
    RET_IF_FAILED(mediaBuffer->GetCurrentLength(&amp;length), "Could not get buffer length", E_FAIL);
    
    RET_IF_FAILED(mediaBuffer->Lock(&amp;pDataNV12, NULL, NULL), "Could not lock the buffer", E_FAIL);
    
    BYTE *pDataYUV420P = new BYTE[length];
    
    this->convertNV12toYUV420P(pDataNV12, pDataYUV420P, this->width, this->height);
    
    RET_IF_FAILED(av_image_fill_arrays(frame->data, frame->linesize, pDataYUV420P, pixelFormat, this->width, this->height, 1), "Could not fill the frame with data from the buffer", E_FAIL);
    
    LOG_IF_FAILED(mediaBuffer->Unlock(), "Could not unlock the buffer");
    

    
    frame->pts = av_rescale_q(this->pts++, this->codecContext->time_base, this->stream->time_base);
    

    
    AVPacket pkt;
    

    
    av_init_packet(&amp;pkt);
    
    pkt.data = NULL;
    
    pkt.size = 0;
    

    
    RET_IF_FAILED_AV(avcodec_send_frame(this->codecContext, frame), "Could not send the frame to the encoder", E_FAIL);
    
    delete[] pDataYUV420P;
    
    if (SUCCEEDED(avcodec_receive_packet(this->codecContext, &amp;pkt))) {
    
        RET_IF_FAILED_AV(av_interleaved_write_frame(this->fmtContext, &amp;pkt), "Could not write the received packet.", E_FAIL);
    
    }
    

    
    av_packet_unref(&amp;pkt);
    

    
    return S_OK;
    
}
    

    
HRESULT Session::endSession() {
    
    LOG("Ending session...");
    

    
    LOG("Closing files...")
    
    LOG_IF_FAILED_AV(av_write_trailer(this->fmtContext), "Could not finalize the output file.");
    
    LOG_IF_FAILED_AV(avio_close(this->fmtContext->pb), "Could not close the output file.");
    
    LOG_IF_FAILED_AV(avcodec_close(this->codecContext), "Could not close the codec.");
    
    av_free(this->codecContext);
    
    LOG("Done.")
    
    return S_OK;
    
}

    The problem is that the generated file is not playable in either VLC or MPC-HC. However, MPC-HC reports following info in file properties :

    General
    
Unique ID                      : 202978442142665779317960161865934977227 (0x98B439D9BE859109BD5EC00A62A238CB)
    
Complete name                  : T:\Test.mkv
    
Format                         : Matroska
    
Format version                 : Version 4 / Version 2
    
File size                      : 24.6 MiB
    
Duration                       : 147ms
    
Overall bit rate               : 1 401 Mbps
    
Writing application            : Lavf57.57.100
    
Writing library                : Lavf57.57.100
    

    
Video
    
ID                             : 1
    
Format                         : FFV1
    
Format version                 : Version 0
    
Codec ID                       : V_MS/VFW/FOURCC / FFV1
    
Duration                       : 147ms
    
Width                          : 1 280 pixels
    
Height                         : 720 pixels
    
Display aspect ratio           : 16:9
    
Frame rate mode                : Constant
    
Frame rate                     : 1 000.000 fps
    
Color space                    : YUV
    
Chroma subsampling             : 4:2:0
    
Bit depth                      : 8 bits
    
Compression mode               : Lossless
    
Default                        : Yes
    
Forced                         : No
    
DURATION                       : 00:00:00.147000000
    
coder_type                     : Golomb Rice

    Something to note is that it reports 1000 FPS which is weird since I’ve set AVCodecContext::time_base in the code.

    UPDATE 1 :

    I managed to set the correct fps by setting time_base property of the stream :

    this->stream->time_base.den = fps_num;
    
this->stream->time_base.num = fps_den;

    VLC plays the output file but it shows VLC logo instead of the video, as if there is no video stream in the file.

    UPDATE 2 :

    Cleaned up the code. Now if I set codecId = AV_CODEC_ID_MPEG2VIDEO the output file is valid and is played in both VLC and MPC-HC. Using ffprobe on the file with FFV1 encoding yields the following result :

    C:\root\apps\ffmpeg>ffprobe.exe t:\test.avi
    
ffprobe version 3.2 Copyright (c) 2007-2016 the FFmpeg developers
    
  built with gcc 5.4.0 (GCC)
    
  configuration: --disable-static --enable-shared --enable-gpl --enable-version3 --disable-w32threads --enable-dxva2 --enable-libmfx --enable-nvenc --enable-avisynth --enable-bzlib --enable-libebur128 --enable-fontconfig --enable-frei0r --enable-gnutls --enable-iconv --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libfreetype --enable-libgme --enable-libgsm --enable-libilbc --enable-libmodplug --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenh264 --enable-libopenjpeg --enable-libopus --enable-librtmp --enable-libschroedinger --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvo-amrwbenc --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs --enable-libxvid --enable-libzimg --enable-lzma --enable-decklink --enable-zlib
    
  libavutil      55. 34.100 / 55. 34.100
    
  libavcodec     57. 64.100 / 57. 64.100
    
  libavformat    57. 56.100 / 57. 56.100
    
  libavdevice    57.  1.100 / 57.  1.100
    
  libavfilter     6. 65.100 /  6. 65.100
    
  libswscale      4.  2.100 /  4.  2.100
    
  libswresample   2.  3.100 /  2.  3.100
    
  libpostproc    54.  1.100 / 54.  1.100
    
[ffv1 @ 00000000006b83a0] read_quant_table error
    
Input #0, avi, from 't:\test.avi':
    
  Metadata:
    
    encoder         : Lavf57.56.100
    
  Duration: 00:00:04.94, start: 0.000000, bitrate: 107005 kb/s
    
    Stream #0:0: Video: ffv1 (FFV1 / 0x31564646), yuv420p, 1280x720, 107717 kb/s, 29.97 fps, 29.97 tbr, 29.97 tbn, 29.97 tbc

Navigation