Recherche avancée
Médias (1)
-
Sintel MP4 Surround 5.1 Full
13 mai 2011, par
Mis à jour : Février 2012
Langue : English
Type : Video
Autres articles (53)
-
Modifier la date de publication
21 juin 2013, parComment changer la date de publication d’un média ?
Il faut au préalable rajouter un champ "Date de publication" dans le masque de formulaire adéquat :
Administrer > Configuration des masques de formulaires > Sélectionner "Un média"
Dans la rubrique "Champs à ajouter, cocher "Date de publication "
Cliquer en bas de la page sur Enregistrer -
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs -
Encoding and processing into web-friendly formats
13 avril 2011, parMediaSPIP 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 (...)
Sur d’autres sites (5699)
-
Saving frames as JPG with FFMPEG (Visual Studio / C++)
10 novembre 2022, par Diego SatizabalI am trying to save all frames from a mp4 video in separate JPG files, I have a code that runs and actually saves something to JPG files but files are not recognized as images and nothing is showing.


Below my full code, I am using Visual Studio 2022 in Windows 11 and FFMPEG 5.1. The function that saves the images is save_frame_as_jpeg which is actually an adaption from the code provided here but changing the use of avcodec_encode_video2 for avcodec_send_frame/avcodec_receive_packet as indicated in the documentation.


I am obiously doing something wrong but cannot quite find it, BTW, I know that a simple command (ffmpeg -i input.mp4 -vf fps=1 vid_%d.png) will do this but I am requiring to do it by code.


Any help is appreciated, thanks in advance !


// FfmpegTests.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#pragma warning(disable : 4996)
extern "C"
{
 #include "libavformat/avformat.h"
 #include "libavcodec/avcodec.h"
 #include "libavfilter/avfilter.h"
 #include "libavutil/opt.h"
 #include "libavutil/avutil.h"
 #include "libavutil/error.h"
 #include "libavfilter/buffersrc.h"
 #include "libavfilter/buffersink.h"
 #include "libswscale/swscale.h"
}

#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avfilter.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "swscale.lib")

#include <cstdio>
#include <iostream>
#include <chrono>
#include <thread>


static AVFormatContext* fmt_ctx;
static AVCodecContext* dec_ctx;
AVFilterGraph* filter_graph;
AVFilterContext* buffersrc_ctx;
AVFilterContext* buffersink_ctx;
static int video_stream_index = -1;

const char* filter_descr = "scale=78:24,transpose=cclock";
static int64_t last_pts = AV_NOPTS_VALUE;

static int open_input_file(const char* filename)
{
 const AVCodec* dec;
 int ret;

 if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
 return ret;
 }

 if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
 return ret;
 }

 /* select the video stream */
 ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
 return ret;
 }
 video_stream_index = ret;

 /* create decoding context */
 dec_ctx = avcodec_alloc_context3(dec);
 if (!dec_ctx)
 return AVERROR(ENOMEM);
 avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_stream_index]->codecpar);

 /* init the video decoder */
 if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
 return ret;
 }

 return 0;
}

static int init_filters(const char* filters_descr)
{
 char args[512];
 int ret = 0;
 const AVFilter* buffersrc = avfilter_get_by_name("buffer");
 const AVFilter* buffersink = avfilter_get_by_name("buffersink");
 AVFilterInOut* outputs = avfilter_inout_alloc();
 AVFilterInOut* inputs = avfilter_inout_alloc();
 AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
 enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };

 filter_graph = avfilter_graph_alloc();
 if (!outputs || !inputs || !filter_graph) {
 ret = AVERROR(ENOMEM);
 goto end;
 }

 /* buffer video source: the decoded frames from the decoder will be inserted here. */
 snprintf(args, sizeof(args),
 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
 dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
 time_base.num, time_base.den,
 dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

 ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
 args, NULL, filter_graph);
 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
 goto end;
 }

 /* buffer video sink: to terminate the filter chain. */
 ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
 NULL, NULL, filter_graph);
 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
 goto end;
 }

 ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
 goto end;
 }

 outputs->name = av_strdup("in");
 outputs->filter_ctx = buffersrc_ctx;
 outputs->pad_idx = 0;
 outputs->next = NULL;

 inputs->name = av_strdup("out");
 inputs->filter_ctx = buffersink_ctx;
 inputs->pad_idx = 0;
 inputs->next = NULL;

 if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
 &inputs, &outputs, NULL)) < 0)
 goto end;

 if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
 goto end;

end:
 avfilter_inout_free(&inputs);
 avfilter_inout_free(&outputs);

 return ret;
}

static void display_frame(const AVFrame* frame, AVRational time_base)
{
 int x, y;
 uint8_t* p0, * p;
 int64_t delay;

 if (frame->pts != AV_NOPTS_VALUE) {
 if (last_pts != AV_NOPTS_VALUE) {
 /* sleep roughly the right amount of time;
 * usleep is in microseconds, just like AV_TIME_BASE. */
 AVRational timeBaseQ;
 timeBaseQ.num = 1;
 timeBaseQ.den = AV_TIME_BASE;

 delay = av_rescale_q(frame->pts - last_pts, time_base, timeBaseQ);
 if (delay > 0 && delay < 1000000)
 std::this_thread::sleep_for(std::chrono::microseconds(delay));
 }
 last_pts = frame->pts;
 }

 /* Trivial ASCII grayscale display. */
 p0 = frame->data[0];
 puts("\033c");
 for (y = 0; y < frame->height; y++) {
 p = p0;
 for (x = 0; x < frame->width; x++)
 putchar(" .-+#"[*(p++) / 52]);
 putchar('\n');
 p0 += frame->linesize[0];
 }
 fflush(stdout);
}

int save_frame_as_jpeg(AVCodecContext* pCodecCtx, AVFrame* pFrame, int FrameNo) {
 int ret = 0;

 const AVCodec* jpegCodec = avcodec_find_encoder(AV_CODEC_ID_JPEG2000);
 if (!jpegCodec) {
 return -1;
 }
 AVCodecContext* jpegContext = avcodec_alloc_context3(jpegCodec);
 if (!jpegContext) {
 return -1;
 }

 jpegContext->pix_fmt = pCodecCtx->pix_fmt;
 jpegContext->height = pFrame->height;
 jpegContext->width = pFrame->width;
 jpegContext->time_base = AVRational{ 1,10 };

 ret = avcodec_open2(jpegContext, jpegCodec, NULL);
 if (ret < 0) {
 return ret;
 }
 FILE* JPEGFile;
 char JPEGFName[256];

 AVPacket packet;
 packet.data = NULL;
 packet.size = 0;
 av_init_packet(&packet);

 int gotFrame;

 ret = avcodec_send_frame(jpegContext, pFrame);
 if (ret < 0) {
 return ret;
 }

 ret = avcodec_receive_packet(jpegContext, &packet);
 if (ret < 0) {
 return ret;
 }

 sprintf(JPEGFName, "c:\\folder\\dvr-%06d.jpg", FrameNo);
 JPEGFile = fopen(JPEGFName, "wb");
 fwrite(packet.data, 1, packet.size, JPEGFile);
 fclose(JPEGFile);

 av_packet_unref(&packet);
 avcodec_close(jpegContext);
 return 0;
}

int main(int argc, char** argv)
{
 AVFrame* frame;
 AVFrame* filt_frame;
 AVPacket* packet;
 int ret;

 if (argc != 2) {
 fprintf(stderr, "Usage: %s file\n", argv[0]);
 exit(1);
 }

 frame = av_frame_alloc();
 filt_frame = av_frame_alloc();
 packet = av_packet_alloc();

 if (!frame || !filt_frame || !packet) {
 fprintf(stderr, "Could not allocate frame or packet\n");
 exit(1);
 }

 if ((ret = open_input_file(argv[1])) < 0)
 goto end;
 if ((ret = init_filters(filter_descr)) < 0)
 goto end;

 while (true)
 {
 if ((ret = av_read_frame(fmt_ctx, packet)) < 0)
 break;

 if (packet->stream_index == video_stream_index) {
 ret = avcodec_send_packet(dec_ctx, packet);
 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");
 break;
 }

 while (ret >= 0)
 {
 ret = avcodec_receive_frame(dec_ctx, frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 break;
 }
 else if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");
 goto end;
 }

 frame->pts = frame->best_effort_timestamp;

 /* push the decoded frame into the filtergraph */
 if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
 av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
 break;
 }

 /* pull filtered frames from the filtergraph */
 while (1) {
 ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 break;
 if (ret < 0)
 goto end;
 display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
 av_frame_unref(filt_frame);
 
 ret = save_frame_as_jpeg(dec_ctx, frame, dec_ctx->frame_number);
 if (ret < 0)
 goto end;
 }
 av_frame_unref(frame);
 }
 }
 av_packet_unref(packet);
 }

end:
 avfilter_graph_free(&filter_graph);
 avcodec_free_context(&dec_ctx);
 avformat_close_input(&fmt_ctx);
 av_frame_free(&frame);
 av_frame_free(&filt_frame);
 av_packet_free(&packet);

 if (ret < 0 && ret != AVERROR_EOF) {
 char errBuf[AV_ERROR_MAX_STRING_SIZE]{0};
 int res = av_strerror(ret, errBuf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error: %s\n", errBuf);
 exit(1);
 }

 exit(0);
}
</thread></chrono></iostream></cstdio>

-
ffmpeg encoding leaves me with blank space at the end where the video pauses and there is nothing ahead
6 novembre 2022, par Nisarg DesaiI was trying to slice some of the video being played and clip it in mpv.net using a .lua script which uses ffmpeg to encode the webm output. ffmpeg sometimes leaves some seconds blank and without any video/audio ahead while clipping from source. Is there any solution to this ?


The code for the script is given below (was taken from here https://github.com/occivink/mpv-scripts) :


local utils = require "mp.utils"
local msg = require "mp.msg"
local options = require "mp.options"

local ON_WINDOWS = (package.config:sub(1,1) ~= "/")

local start_timestamp = nil
local profile_start = ""

-- implementation detail of the osd message
local timer = nil
local timer_duration = 2

-- folder creation if it doesnt exist
function exists(file)
 local ok, err, code = os.rename(file, file)
 if not ok then
 if code == 13 then
 return true
 end
 end
 return ok, err
end

--- Check if a directory exists in this path
function create_dir(path)
 local dir = "\"" .. path .. "\""
 if not exists(path .."/") then
 os.execute("mkdir " .. dir)
 end
end

function append_table(lhs, rhs)
 for i = 1,#rhs do
 lhs[#lhs+1] = rhs[i]
 end
 return lhs
end

function file_exists(name)
 local f = io.open(name, "r")
 if f ~= nil then
 io.close(f)
 return true
 else
 return false
 end
end

function get_extension(path)
 local candidate = string.match(path, "%.([^.]+)$")
 if candidate then
 for _, ext in ipairs({ "mkv", "webm", "mp4", "avi" }) do
 if candidate == ext then
 return candidate
 end
 end
 end
 return "mkv"
end

function get_output_string(dir, format, input, extension, title, from, to, profile)
 local res = utils.readdir(dir)
 if not res then
 return nil
 end
 local files = {}
 for _, f in ipairs(res) do
 files[f] = true
 end
 local output = format
 output = string.gsub(output, "$f", function() return input end)
 output = string.gsub(output, "$t", function() return title end)
 output = string.gsub(output, "$s", function() return seconds_to_time_string(from, true) end)
 output = string.gsub(output, "$e", function() return seconds_to_time_string(to, true) end)
 output = string.gsub(output, "$d", function() return seconds_to_time_string(to-from, true) end)
 output = string.gsub(output, "$x", function() return extension end)
 output = string.gsub(output, "$p", function() return profile end)
 if ON_WINDOWS then
 output = string.gsub(output, "[/\\|<>?:\"*]", "_")
 end
 if not string.find(output, "$n") then
 return files[output] and nil or output
 end
 local i = 1
 while true do
 local potential_name = string.gsub(output, "$n", tostring(i))
 if not files[potential_name] then
 return potential_name
 end
 i = i + 1
 end
end

function get_video_filters()
 local filters = {}
 for _, vf in ipairs(mp.get_property_native("vf")) do
 local name = vf["name"]
 name = string.gsub(name, '^lavfi%-', '')
 local filter
 if name == "crop" then
 local p = vf["params"]
 filter = string.format("crop=%d:%d:%d:%d", p.w, p.h, p.x, p.y)
 elseif name == "mirror" then
 filter = "hflip"
 elseif name == "flip" then
 filter = "vflip"
 elseif name == "rotate" then
 local rotation = vf["params"]["angle"]
 -- rotate is NOT the filter we want here
 if rotation == "90" then
 filter = "transpose=clock"
 elseif rotation == "180" then
 filter = "transpose=clock,transpose=clock"
 elseif rotation == "270" then
 filter = "transpose=cclock"
 end
 end
 filters[#filters + 1] = filter
 end
 return filters
end

function get_input_info(default_path, only_active)
 local accepted = {
 video = true,
 audio = not mp.get_property_bool("mute"),
 sub = mp.get_property_bool("sub-visibility")
 }
 local ret = {}
 for _, track in ipairs(mp.get_property_native("track-list")) do
 local track_path = track["external-filename"] or default_path
 if not only_active or (track["selected"] and accepted[track["type"]]) then
 local tracks = ret[track_path]
 if not tracks then
 ret[track_path] = { track["ff-index"] }
 else
 tracks[#tracks + 1] = track["ff-index"]
 end
 end
 end
 return ret
end

function seconds_to_time_string(seconds, full)
 local ret = string.format("%02d:%02d.%03d"
 , math.floor(seconds / 60) % 60
 , math.floor(seconds) % 60
 , seconds * 1000 % 1000
 )
 if full or seconds > 3600 then
 ret = string.format("%d:%s", math.floor(seconds / 3600), ret)
 end
 return ret
end

function start_encoding(from, to, settings)
 local args = {
 settings.ffmpeg_command,
 "-loglevel", "panic", "-hide_banner",
 }
 local append_args = function(table) args = append_table(args, table) end

 local path = mp.get_property("path")
 local is_stream = not file_exists(path)
 if is_stream then
 path = mp.get_property("stream-path")
 end

 local track_args = {}
 local start = seconds_to_time_string(from, false)
 local input_index = 0
 for input_path, tracks in pairs(get_input_info(path, settings.only_active_tracks)) do
 append_args({
 "-ss", start,
 "-i", input_path,
 })
 if settings.only_active_tracks then
 for _, track_index in ipairs(tracks) do
 track_args = append_table(track_args, { "-map", string.format("%d:%d", input_index, track_index)})
 end
 else
 track_args = append_table(track_args, { "-map", tostring(input_index)})
 end
 input_index = input_index + 1
 end

 append_args({"-to", tostring(to-from)})
 append_args(track_args)

 -- apply some of the video filters currently in the chain
 local filters = {}
 if settings.preserve_filters then
 filters = get_video_filters()
 end
 if settings.append_filter ~= "" then
 filters[#filters + 1] = settings.append_filter
 end
 if #filters > 0 then
 append_args({ "-filter:v", table.concat(filters, ",") })
 end

 -- split the user-passed settings on whitespace
 for token in string.gmatch(settings.codec, "[^%s]+") do
 args[#args + 1] = token
 end

 -- path of the output
 local output_directory = mp.get_property("options/screenshot-directory")
 -- local checkbool = exists(output_directory.."/")
 -- mp.osd_message("" .. type(checkbool), timer_duration)
 -- if not checkbool then 
 -- os.execute("mkdir" .. output_directory)
 -- end
 if output_directory == "" then
 if is_stream then
 output_directory = "."
 else
 output_directory, _ = utils.split_path(path)
 end
 else
 output_directory = string.gsub(output_directory, "^~", os.getenv("HOME") or "~")
 end
 local input_name = mp.get_property("filename/no-ext") or "encode"
 local title = mp.get_property("media-title")
 local extension = get_extension(path)
 local output_name = get_output_string(output_directory, settings.output_format, input_name, extension, title, from, to, settings.profile)
 if not output_name then
 mp.osd_message("Invalid path " .. output_directory)
 return
 end
 args[#args + 1] = utils.join_path(output_directory, output_name)

 if settings.print then
 local o = ""
 -- fuck this is ugly
 for i = 1, #args do
 local fmt = ""
 if i == 1 then
 fmt = "%s%s"
 elseif i >= 2 and i <= 4 then
 fmt = "%s"
 elseif args[i-1] == "-i" or i == #args or args[i-1] == "-filter:v" then
 fmt = "%s '%s'"
 else
 fmt = "%s %s"
 end
 o = string.format(fmt, o, args[i])
 end
 print(o)
 end
 if settings.detached then
 utils.subprocess_detached({ args = args })
 else
 local res = utils.subprocess({ args = args, max_size = 0, cancellable = false })
 if res.status == 0 then
 mp.osd_message("Finished encoding succesfully")
 else
 mp.osd_message("Failed to encode, check the log")
 end
 end
end

function clear_timestamp()
 timer:kill()
 start_timestamp = nil
 profile_start = ""
 mp.remove_key_binding("encode-ESC")
 mp.remove_key_binding("encode-ENTER")
 mp.osd_message("", 0)
end

function set_timestamp(profile)
 if not mp.get_property("path") then
 mp.osd_message("No file currently playing")
 return
 end
 if not mp.get_property_bool("seekable") then
 mp.osd_message("Cannot encode non-seekable media")
 return
 end
 create_dir(mp.get_property("options/screenshot-directory"))
 if not start_timestamp or profile ~= profile_start then
 profile_start = profile
 start_timestamp = mp.get_property_number("time-pos")
 local msg = function()
 mp.osd_message(
 string.format("encode [%s]: waiting for end timestamp", profile or "default"),
 timer_duration
 )
 end
 msg()
 timer = mp.add_periodic_timer(timer_duration, msg)
 mp.add_forced_key_binding("ESC", "encode-ESC", clear_timestamp)
 mp.add_forced_key_binding("ENTER", "encode-ENTER", function() set_timestamp(profile) end)
 else
 local from = start_timestamp
 local to = mp.get_property_number("time-pos")
 if to <= from then
 mp.osd_message("Second timestamp cannot be before the first", timer_duration)
 timer:kill()
 timer:resume()
 return
 end
 clear_timestamp()
 mp.osd_message(string.format("Encoding from %s to %s"
 , seconds_to_time_string(from, false)
 , seconds_to_time_string(to, false)
 ), timer_duration)
 -- include the current frame into the extract
 local fps = mp.get_property_number("container-fps") or 30
 to = to + 1 / fps / 2
 local settings = {
 detached = false,
 container = "",
 only_active_tracks = false,
 preserve_filters = true,
 append_filter = "",
 codec = "-c:v libvpx-vp9 -lossless 1 -b:v 1000k -deadline good",
 output_format = "$f_$n.webm",
 output_directory = "",
 ffmpeg_command = "ffmpeg",
 print = true,
 }
 if profile then
 options.read_options(settings, profile)
 if settings.container ~= "" then
 msg.warn("The 'container' setting is deprecated, use 'output_format' now")
 settings.output_format = settings.output_format .. "." .. settings.container
 end
 settings.profile = profile
 else
 settings.profile = "default"
 end 
 start_encoding(from, to, settings)
 end
end

mp.add_key_binding(nil, "set-timestamp", set_timestamp)


-
match an image to a specific frame within a video with ffmpeg
2 juin 2021, par az0I have some images that were taken from a video via screen capture. I would like to know when in the video these images appear (timestamps). Is there a way to programmatically match an image with a specific frame in a video using ffmpeg or some other tool ?



I am very open to different technologies as I'm eager to automate this. It would be extremely time consuming to do this manually.


Syndiquer tout le site
