Recherche avancée

Sur d’autres sites (10769)

• Is it possible for me to put a mask over a transparent image with ffmpeg ?

  14 juin 2019, par Pedro Valle

  I’m trying to make an overlay with a mask over a transparent image with ffmpeg, but the background of the image that gets the mask turns black, is there any way to make this background remain transparent ?

  ffmpeg -i background.jpg -loop 1 -i image.png -loop 1 -i mask.png -filter_complex [0]setpts=PTS-STARTPTS,scale=720:720[background];[2]alphaextract,scale=640x320[mask];[1]scale=640x320[image];[image][mask]alphamerge[final_mask];[background][final_mask]overlay=100:100[final] -map [final] -t 00:00:05.000 -y result.mp4
  result

• How to save video data in a vector using ffmpeg ? (C++)

  25 octobre 2022, par nokla

  I'm new to ffmpeg and I am trying to write a program for video editing.

  


  I want to import a video file and save it somehow in a vector so I could edit its frames later.
When I saved all the decoded AVFrames in a vector I saw it takes a lot of memory and that I need to find a better way to do so.

  


  The function I used for reading a video :

  


  ** the function is in a class that representing video, source type is std::vector<avframe></avframe>

  


  void VideoSource::ReadSource(std::string path)
{
    // Open the file using libavformat
    AVFormatContext* av_format_ctx = avformat_alloc_context();
    if (!av_format_ctx) {
        printf("Couldn't create AVFormatContext\n");
        return; 
    }
    if (avformat_open_input(&av_format_ctx, path.c_str(), NULL, NULL) != 0) {
        printf("Couldn't open video file\n");
        return;
    }

    // Find the first valid video stream inside the file
    int video_stream_index = -1;
    AVCodecParameters* av_codec_params = NULL;
    const AVCodec* av_codec = NULL;
    for (int i = 0; i < av_format_ctx->nb_streams; i)
    {
        av_codec_params = av_format_ctx->streams[i]->codecpar;
        av_codec = avcodec_find_decoder(av_codec_params->codec_id);

        if (!av_codec) {
            continue;
        }
        if (av_codec_params->codec_type == AVMEDIA_TYPE_VIDEO) {
            video_stream_index = i;
            break;
        }
    }

    if (video_stream_index == -1) {
        printf("Couldn't find valid video stream inside file\n");
        return;
    }

    // Set up a codec context for the decoder
    AVCodecContext* av_codec_ctx = avcodec_alloc_context3(av_codec);
    if (!av_codec_ctx) {
        printf("Couldn't create AVCpdecContext\n");
        return;
    }

    if (avcodec_parameters_to_context(av_codec_ctx, av_codec_params) < 0)
    {
        printf("Couldn't initialize AVCodecContext\n");
        return;
    }
    if (avcodec_open2(av_codec_ctx, av_codec, NULL) < 0) {
        printf("Couldn't open codec\n");
        return;
    }

    AVFrame* av_frame = av_frame_alloc();
    if (!av_frame) {
        printf("Couldn't allocate AVFrame\n");
        return;
    }
    AVPacket* av_packet = av_packet_alloc();
    if (!av_packet) {
        printf("Couldn't allocate AVPacket\n");
        return;
    }
    int response;

    while (av_read_frame(av_format_ctx, av_packet) >= 0) {
        if (av_packet->stream_index != video_stream_index) {
            av_packet_unref(av_packet);
            continue;
        }
        response = avcodec_send_packet(av_codec_ctx, av_packet);
        if (response < 0) {
            printf("Failed to decode packet: %s\n", av_err2str(response));
            return;
        }
        response = avcodec_receive_frame(av_codec_ctx, av_frame);
        if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
            av_packet_unref(av_packet);
            continue;
        }
        else if (response < 0) {
            printf("Failed to decode frame: %s\n", av_err2str(response));
            return;
        }
        av_packet_unref(av_packet);

        av_packet = av_packet_alloc();

        // response = avcodec_send_frame(av_codec_ctx, av_frame);

        source.push_back(*new AVFrame);
        source.back() = *av_frame_clone(av_frame);

        av_frame_unref(av_frame);
    }
    

    avformat_close_input(&av_format_ctx);
    avformat_free_context(av_format_ctx);
    av_frame_free(&av_frame);
    av_packet_free(&av_packet);
    avcodec_free_context(&av_codec_ctx);
}


  


  I thought maybe I should save it as a vector of encoded AVFrames or as a vector of encoded packet that contains some frames in it.

  


  When I tried to encode a single AVFrame, I added this line
response = avcodec_send_frame(av_codec_ctx, av_frame); before pushing the frame into the vector (You can see it marked as a comment in the code above).
  
It returned invalid argument (-22) and I am not sure why.

  


  Questions :

  


  

  1. Why did I get that error (-22) ?

  


  2. How to save an encoded packet with multiple AVFrame in it ?

  


  3. Is there a better way of working on a video that won't take as much memory ?

  


  


• Révision 19166 : Upgrade du fichier avec retours d’experience du plugin migration

  27 mars 2012, par cedric -