Recherche avancée
Médias (1)
-
Collections - Formulaire de création rapide
19 février 2013, par
Mis à jour : Février 2013
Langue : français
Type : Image
Autres articles (46)
-
MediaSPIP v0.2
21 juin 2013, parMediaSPIP 0.2 est la première version de MediaSPIP stable.
Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...) -
Mise à disposition des fichiers
14 avril 2011, parPar défaut, lors de son initialisation, MediaSPIP ne permet pas aux visiteurs de télécharger les fichiers qu’ils soient originaux ou le résultat de leur transformation ou encodage. Il permet uniquement de les visualiser.
Cependant, il est possible et facile d’autoriser les visiteurs à avoir accès à ces documents et ce sous différentes formes.
Tout cela se passe dans la page de configuration du squelette. Il vous faut aller dans l’espace d’administration du canal, et choisir dans la navigation (...) -
Installation en mode ferme
4 février 2011, parLe mode ferme permet d’héberger plusieurs sites de type MediaSPIP en n’installant qu’une seule fois son noyau fonctionnel.
C’est la méthode que nous utilisons sur cette même plateforme.
L’utilisation en mode ferme nécessite de connaïtre un peu le mécanisme de SPIP contrairement à la version standalone qui ne nécessite pas réellement de connaissances spécifique puisque l’espace privé habituel de SPIP n’est plus utilisé.
Dans un premier temps, vous devez avoir installé les mêmes fichiers que l’installation (...)
Sur d’autres sites (5830)
-
lavc/vvcdec : remove unneeded set_output_format
26 janvier, par Nuo Mi -
How to install ffmpeg on a Windows Dockerhub image ?
18 janvier, par Youssef KharoufiI have a program that executes a ffmpeg command to a video input, copies this video and pastes is in an output directory.


Here is my code in case you would want to duplicate it :


using Renderer.Models;
using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;

public class Program
{
 public static async Task Main(string[] args)
 {
 var result = new DockerTaskResult();
 try
 {
 // Path to the JSON input file
 string jsonInputPath = @"C:\Users\ykharoufi\source\repos\Renderer\Renderer\Json\task.json";

 // Check if the JSON file exists
 if (!File.Exists(jsonInputPath))
 {
 throw new FileNotFoundException($"JSON input file not found at path: {jsonInputPath}");
 }

 // Read the JSON content
 string jsonContent = File.ReadAllText(jsonInputPath);

 try
 {
 // Deserialize the JSON into a DockerTask object
 DockerTask task = JsonSerializer.Deserialize<dockertask>(jsonContent);
 if (task == null)
 {
 throw new Exception("Failed to deserialize the task from JSON.");
 }

 // Validate the input paths
 if (string.IsNullOrEmpty(task.InputFileRepoPath) || !File.Exists(task.InputFileRepoPath))
 {
 throw new Exception($"Input file path is invalid or does not exist: {task.InputFileRepoPath}");
 }

 if (string.IsNullOrEmpty(task.OutputFileRepoPath) || !Directory.Exists(task.OutputFileRepoPath))
 {
 throw new Exception($"Output directory path is invalid or does not exist: {task.OutputFileRepoPath}");
 }

 // Initialize the Docker worker and run the task
 var worker = new DockerWorker();
 var success = await worker.RunDockerTaskAsync(task);

 if (success.Success)
 {
 result.Success = true;
 result.Message = "Command executed successfully!";

 // Check the output directory for files
 if (Directory.Exists(task.OutputFileRepoPath))
 {
 result.OutputFiles = Directory.GetFiles(task.OutputFileRepoPath);
 }
 }
 else
 {
 result.Success = false;
 result.Message = "Failed to execute the command.";
 result.ErrorDetails = success.ErrorDetails;
 }
 }
 catch (JsonException)
 {
 // Handle invalid JSON format
 result.Success = false;
 result.Message = "Invalid JSON format.";
 result.ErrorDetails = "Invalid data entry";
 }
 }
 catch (Exception ex)
 {
 result.Success = false;
 result.Message = "An error occurred during execution.";
 result.ErrorDetails = ex.Message;
 }
 finally
 {
 // Serialize the result to JSON and write to console
 string outputJson = JsonSerializer.Serialize(result, new JsonSerializerOptions { WriteIndented = true });
 Console.WriteLine(outputJson);
 }
 }
}

 using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
using Docker.DotNet;
using Docker.DotNet.Models;
using Renderer.Models;

public class DockerWorker
{
 private readonly DockerClient _dockerClient;

 public DockerWorker()
 {
 Console.WriteLine("Initializing Docker client...");
 _dockerClient = new DockerClientConfiguration(
 new Uri("npipe://./pipe/docker_engine")) // Windows Docker URI
 .CreateClient();
 Console.WriteLine("Docker client initialized.");
 }

 public async Task<dockertaskresult> RunDockerTaskAsync(DockerTask task)
 {
 var result = new DockerTaskResult();

 try
 {
 Console.WriteLine("Starting Docker task...");
 Console.WriteLine($"Image: {task.ImageNaming}");
 Console.WriteLine($"Container: {task.ContainerNaming}");
 Console.WriteLine($"Input Path: {task.InputFileRepoPath}");
 Console.WriteLine($"Output Path: {task.OutputFileRepoPath}");
 Console.WriteLine($"Command: {task.CommandDef}");

 // Ensure the Docker image exists
 Console.WriteLine("Checking if Docker image exists...");
 var imageCheckResult = await EnsureImageExists(task.ImageNaming);
 if (!imageCheckResult.Success)
 {
 result.Success = false;
 result.Message = imageCheckResult.Message;
 result.ErrorDetails = imageCheckResult.ErrorDetails;
 return result;
 }
 Console.WriteLine("Docker image verified.");

 // Determine platform
 var platform = await GetImagePlatform(task.ImageNaming);
 Console.WriteLine($"Detected image platform: {platform}");

 // Translate paths
 string inputVolume, outputVolume;
 if (platform == "linux")
 {
 inputVolume = $"{task.InputFileRepoPath.Replace("C:\\", "/mnt/c/").Replace("\\", "/")}:/app/input";
 outputVolume = $"{task.OutputFileRepoPath.Replace("C:\\", "/mnt/c/").Replace("\\", "/")}:/app/output";
 }
 else if (platform == "windows")
 {
 string inputDir = Path.GetFullPath(Path.GetDirectoryName(task.InputFileRepoPath)).TrimEnd('\\');
 string outputDir = Path.GetFullPath(task.OutputFileRepoPath).TrimEnd('\\');

 if (!Directory.Exists(inputDir))
 {
 throw new Exception($"Input directory does not exist: {inputDir}");
 }
 if (!Directory.Exists(outputDir))
 {
 throw new Exception($"Output directory does not exist: {outputDir}");
 }

 inputVolume = $"{inputDir}:C:\\app\\input";
 outputVolume = $"{outputDir}:C:\\app\\output";

 Console.WriteLine($"Input volume: {inputVolume}");
 Console.WriteLine($"Output volume: {outputVolume}");
 }
 else
 {
 throw new Exception($"Unsupported platform: {platform}");
 }

 // Create container
 Console.WriteLine("Creating Docker container...");
 var containerResponse = await _dockerClient.Containers.CreateContainerAsync(new CreateContainerParameters
 {
 Image = task.ImageNaming,
 Name = task.ContainerNaming,
 HostConfig = new HostConfig
 {
 Binds = new List<string> { inputVolume, outputVolume },
 AutoRemove = true
 },
 Cmd = new[] { platform == "linux" ? "bash" : "cmd.exe", "/c", task.CommandDef }
 });

 if (string.IsNullOrEmpty(containerResponse.ID))
 {
 throw new Exception("Failed to create Docker container.");
 }
 Console.WriteLine($"Container created with ID: {containerResponse.ID}");

 // Start container
 Console.WriteLine("Starting container...");
 bool started = await _dockerClient.Containers.StartContainerAsync(containerResponse.ID, new ContainerStartParameters());
 if (!started)
 {
 throw new Exception($"Failed to start container: {task.ContainerNaming}");
 }

 // Wait for container to finish
 Console.WriteLine("Waiting for container to finish...");
 var waitResponse = await _dockerClient.Containers.WaitContainerAsync(containerResponse.ID);

 if (waitResponse.StatusCode != 0)
 {
 Console.WriteLine($"Container exited with error code: {waitResponse.StatusCode}");
 await FetchContainerLogs(containerResponse.ID);
 throw new Exception($"Container exited with non-zero status code: {waitResponse.StatusCode}");
 }

 // Fetch logs
 Console.WriteLine("Fetching container logs...");
 await FetchContainerLogs(containerResponse.ID);

 result.Success = true;
 result.Message = "Docker task completed successfully.";
 return result;
 }
 catch (Exception ex)
 {
 Console.WriteLine($"Error: {ex.Message}");
 result.Success = false;
 result.Message = "An error occurred during execution.";
 result.ErrorDetails = ex.Message;
 return result;
 }
 }

 private async Task<string> GetImagePlatform(string imageName)
 {
 try
 {
 Console.WriteLine($"Inspecting Docker image: {imageName}...");
 var imageDetails = await _dockerClient.Images.InspectImageAsync(imageName);
 Console.WriteLine($"Image platform: {imageDetails.Os}");
 return imageDetails.Os.ToLower();
 }
 catch (Exception ex)
 {
 throw new Exception($"Failed to inspect image: {ex.Message}");
 }
 }

 private async Task<dockertaskresult> EnsureImageExists(string imageName)
 {
 var result = new DockerTaskResult();
 try
 {
 Console.WriteLine($"Pulling Docker image: {imageName}...");
 await _dockerClient.Images.CreateImageAsync(
 new ImagesCreateParameters { FromImage = imageName, Tag = "latest" },
 null,
 new Progress<jsonmessage>()
 );
 result.Success = true;
 result.Message = "Docker image is available.";
 }
 catch (Exception ex)
 {
 result.Success = false;
 result.Message = $"Failed to pull Docker image: {imageName}";
 result.ErrorDetails = ex.Message;
 }
 return result;
 }

 private async Task FetchContainerLogs(string containerId)
 {
 try
 {
 Console.WriteLine($"Fetching logs for container: {containerId}...");
 var logs = await _dockerClient.Containers.GetContainerLogsAsync(
 containerId,
 new ContainerLogsParameters { ShowStdout = true, ShowStderr = true });

 using (var reader = new StreamReader(logs))
 {
 string logLine;
 while ((logLine = await reader.ReadLineAsync()) != null)
 {
 Console.WriteLine(logLine);
 }
 }
 }
 catch (Exception ex)
 {
 Console.WriteLine($"Failed to fetch logs: {ex.Message}");
 }
 }
}

 {
 "ImageNaming": "khuser/windowsimage:latest",
 "ContainerNaming": "custom-worker-container",
 "InputFileRepoPath": "C:/Users/user/source/repos/Renderer/Renderer/wwwroot/audio.mp4",
 "OutputFileRepoPath": "C:/Users/user/Desktop/output/",
 "CommandDef": "ffmpeg -i C:\\app\\input\\audio.mp4 -c copy C:\\app\\output\\copiedAudio.mp4"
</jsonmessage></dockertaskresult></string></string></dockertaskresult></dockertask>

}. My problem is what I get in the output of my program :
Initializing Docker client... Docker client initialized. Starting Docker task... Image: khyoussef/windowsimage:latest Container: custom-worker-container Input Path: C:/Users/ykharoufi/source/repos/Renderer/Renderer/wwwroot/audio.mp4 Output Path: C:/Users/ykharoufi/Desktop/output/ Command: ffmpeg -i C:\app\input\audio.mp4 -c copy C:\app\output\copiedAudio.mp4 Checking if Docker image exists... Pulling Docker image: khyoussef/windowsimage:latest... Docker image verified. Inspecting Docker image: khyoussef/windowsimage:latest... Image platform: windows Detected image platform: windows Input volume: C:\Users\ykharoufi\source\repos\Renderer\Renderer\wwwroot:C:\app\input Output volume: C:\Users\ykharoufi\Desktop\output:C:\app\output Creating Docker container... Container created with ID: 1daca99b3c76bc8c99c1aed7d2c546ae75aedd9aa1feb0f5002e54769390248e Starting container... Waiting for container to finish... Container exited with error code: 1 Fetching logs for container: 1daca99b3c76bc8c99c1aed7d2c546ae75aedd9aa1feb0f5002e54769390248e... @'ffmpeg' is not recognized as an internal or external command, !operable program or batch file. Error: Container exited with non-zero status code: 1 { "Success": false, "Message": "Failed to execute the command.", "ErrorDetails": "Container exited with non-zero status code: 1", "OutputFiles": null }, This is the Dockerfile I am working with :

`# Use Windows Server Core as the base image
FROM mcr.microsoft.com/windows/server:ltsc2022

# Set the working directory
WORKDIR /app

# Install required tools (FFmpeg and Visual C++ Redistributable)
RUN powershell -Command \
 $ErrorActionPreference = 'Stop'; \
 # Install Visual C++ Redistributable
 Invoke-WebRequest -Uri https://aka.ms/vs/16/release/vc_redist.x64.exe -OutFile vc_redist.x64.exe; \
 Start-Process -FilePath vc_redist.x64.exe -ArgumentList '/install', '/quiet', '/norestart' -NoNewWindow -Wait; \
 Remove-Item -Force vc_redist.x64.exe; \
 # Download FFmpeg
 Invoke-WebRequest -Uri https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n7.1-latest-win64-gpl-7.1.zip -OutFile ffmpeg.zip; \
 # Extract FFmpeg
 Expand-Archive -Path ffmpeg.zip -DestinationPath C:\ffmpeg; \
 Remove-Item -Force ffmpeg.zip; \
 # Debug step: Verify FFmpeg extraction
 Write-Output "FFmpeg extracted to C:\\ffmpeg"; \
 dir C:\ffmpeg; \
 dir C:\ffmpeg\ffmpeg-n7.1-latest-win64-gpl-7.1\bin

# Add FFmpeg to PATH permanently
ENV PATH="C:\\ffmpeg\\ffmpeg-n7.1-latest-win64-gpl-7.1\\bin;${PATH}"

# Verify FFmpeg installation
RUN ["cmd", "/S", "/C", "ffmpeg -version"]

# Copy required files to the container
COPY ./ /app/

# Default to a PowerShell session
CMD ["C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe", "-NoExit"]
`


. I did build it using this command : docker build -t khuser/windowsimage:latest -f Dockerfile .


-
Issues with Video Recording Duration and Smooth Playback when Using v4l2 framework to MP4 (FFmpeg)
9 décembre 2024, par ReenaI'm trying to record a video from a USB device with v4l2 framework and save it in MP4 format using FFmpeg. My sample code successfully captures and saves the video, but I'm running into some issues :


The recorded video duration is shorter than expected. For instance :


When recording a 1-minute video at 1280x720, the output file only has 58 or 59 seconds. For 1920x1080, the duration is even more off — only about 28 or 30 seconds, instead of the expected 1 minute. Additionally, the video is not smooth. There are noticeable drops in frames and playback inconsistencies.


My setup :


Using a USB device with v4l2 framework Saving the video in MP4 format Tested with different resolutions (1280x720, 1920x1080) I've attached my sample code below. Could someone help me figure out why I'm experiencing these issues with video duration and smooth playback ?


#include 
#include 
#include 
#include 
#include <sys></sys>ioctl.h>
#include <sys></sys>mman.h>
#include <linux></linux>videodev2.h>
#include <libavformat></libavformat>avformat.h>
#include <libavcodec></libavcodec>avcodec.h>
#include <libavutil></libavutil>imgutils.h>
#include <libavutil></libavutil>opt.h>
#include <libswscale></libswscale>swscale.h>
#include 
#include <sys></sys>time.h>
#include 

#define WIDTH 1280
#define HEIGHT 720
#define FPS 30
#define DURATION 10 // Recording duration in seconds
#define BUFFER_COUNT 4 // Number of buffers

struct buffer {
 void *start;
 size_t length;
};

struct buffer *buffers;

void open_device(int *fd, const char *device) {
 *fd = open(device, O_RDWR | O_NONBLOCK);
 if (*fd < 0) {
 perror("Cannot open video device");
 exit(1);
 }
}

void init_mmap(int fd) {
 struct v4l2_requestbuffers req;
 memset(&req, 0, sizeof(req));
 req.count = BUFFER_COUNT;
 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 req.memory = V4L2_MEMORY_MMAP;

 if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
 perror("Requesting buffer");
 exit(1);
 }

 buffers = calloc(req.count, sizeof(*buffers));
 for (size_t i = 0; i < req.count; ++i) {
 struct v4l2_buffer buf;
 memset(&buf, 0, sizeof(buf));
 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_MMAP;
 buf.index = i;

 if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
 perror("Querying buffer");
 exit(1);
 }

 buffers[i].length = buf.length;
 buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);

 if (MAP_FAILED == buffers[i].start) {
 perror("mmap");
 exit(1);
 }
 }
}

void start_capturing(int fd) {
 for (size_t i = 0; i < BUFFER_COUNT; ++i) {
 struct v4l2_buffer buf;
 memset(&buf, 0, sizeof(buf));
 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_MMAP;
 buf.index = i;

 if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
 perror("Queue buffer");
 exit(1);
 }
 }

 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
 perror("Start capture");
 exit(1);
 }
}

void stop_capturing(int fd) {
 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
 perror("Stop capture");
 exit(1);
 }

 printf("Video capture stopped.\n");
}

void unmap_buffers() {
 for (size_t i = 0; i < BUFFER_COUNT; ++i) {
 if (munmap(buffers[i].start, buffers[i].length) < 0) {
 perror("munmap");
 exit(1);
 }
 }

 free(buffers);
}

void initialize_ffmpeg(AVFormatContext **fmt_ctx, AVCodecContext **codec_ctx, AVStream **video_stream, const char *filename) {
 av_register_all();

 AVOutputFormat *fmt = av_guess_format(NULL, filename, NULL);
 if (!fmt) {
 fprintf(stderr, "Could not determine output format\n");
 exit(1);
 }

 if (avformat_alloc_output_context2(fmt_ctx, fmt, NULL, filename) < 0) {
 fprintf(stderr, "Could not allocate format context\n");
 exit(1);
 }

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

 *video_stream = avformat_new_stream(*fmt_ctx, NULL);
 if (!*video_stream) {
 fprintf(stderr, "Could not create stream\n");
 exit(1);
 }

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

 (*codec_ctx)->codec_type = AVMEDIA_TYPE_VIDEO;
 (*codec_ctx)->width = WIDTH;
 (*codec_ctx)->height = HEIGHT;
 (*codec_ctx)->time_base = (AVRational){1, FPS};
 (*codec_ctx)->framerate = (AVRational){FPS, 1};
 (*codec_ctx)->pix_fmt = AV_PIX_FMT_YUV420P;
 (*codec_ctx)->gop_size = 10;
 (*codec_ctx)->max_b_frames = 1;

 av_opt_set(*codec_ctx, "preset", "fast", 0);
 av_opt_set_int(*codec_ctx, "crf", 23, 0);

 (*video_stream)->time_base = (*codec_ctx)->time_base;
 (*video_stream)->codecpar->codec_id = fmt->video_codec;
 (*video_stream)->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 (*video_stream)->codecpar->width = (*codec_ctx)->width;
 (*video_stream)->codecpar->height = (*codec_ctx)->height;
 (*video_stream)->codecpar->format = (*codec_ctx)->pix_fmt;

 if ((*fmt_ctx)->oformat->flags & AVFMT_GLOBALHEADER) {
 (*codec_ctx)->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 }

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

 if (avcodec_parameters_from_context((*video_stream)->codecpar, *codec_ctx) < 0) {
 fprintf(stderr, "Could not copy codec parameters\n");
 exit(1);
 }

 if (!(fmt->flags & AVFMT_NOFILE)) {
 if (avio_open(&(*fmt_ctx)->pb, filename, AVIO_FLAG_WRITE) < 0) {
 fprintf(stderr, "Could not open output file\n");
 exit(1);
 }
 }

 if (avformat_write_header(*fmt_ctx, NULL) < 0) {
 fprintf(stderr, "Could not write header\n");
 exit(1);
 }
}

void capture_and_encode(int fd, AVFormatContext *fmt_ctx, AVCodecContext *codec_ctx, struct SwsContext *sws_ctx, AVStream *video_stream, int duration) {
 struct v4l2_buffer buffer;
 AVFrame *frame = av_frame_alloc();
 AVPacket packet;
 av_init_packet(&packet);

 frame->format = codec_ctx->pix_fmt;
 frame->width = codec_ctx->width;
 frame->height = codec_ctx->height;
 av_image_alloc(frame->data, frame->linesize, codec_ctx->width, codec_ctx->height, codec_ctx->pix_fmt, 32);

 struct timespec start_time;
 clock_gettime(CLOCK_MONOTONIC, &start_time);
 double elapsed_time = 0;
 int64_t pts_counter = 0;
 int frame_count = 0;

 while (elapsed_time < duration) {
 fd_set fds;
 struct timeval tv;
 int r;

 FD_ZERO(&fds);
 FD_SET(fd, &fds);

 tv.tv_sec = 2;
 tv.tv_usec = 0;

 r = select(fd + 1, &fds, NULL, NULL, &tv);
 if (r == -1) {
 perror("select");
 exit(1);
 }

 if (r == 0) {
 fprintf(stderr, "select timeout\n");
 exit(1);
 }

 memset(&buffer, 0, sizeof(buffer));
 buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buffer.memory = V4L2_MEMORY_MMAP;

 if (ioctl(fd, VIDIOC_DQBUF, &buffer) < 0) {
 if (errno == EAGAIN) continue;
 perror("Could not dequeue buffer");
 exit(1);
 }

 uint8_t *src_slices[1] = {buffers[buffer.index].start};
 int src_stride[1] = {WIDTH * 2}; // UYVY is 2 bytes per pixel

 sws_scale(sws_ctx, src_slices, src_stride, 0, HEIGHT, frame->data, frame->linesize);

 frame->pts = pts_counter;
 pts_counter += av_rescale_q(1, (AVRational){1, FPS}, codec_ctx->time_base);

 if (avcodec_send_frame(codec_ctx, frame) < 0) {
 fprintf(stderr, "Error sending frame\n");
 exit(1);
 }

 while (avcodec_receive_packet(codec_ctx, &packet) == 0) {
 av_packet_rescale_ts(&packet, codec_ctx->time_base, video_stream->time_base);
 packet.stream_index = video_stream->index;

 if (av_interleaved_write_frame(fmt_ctx, &packet) < 0) {
 fprintf(stderr, "Error writing frame\n");
 exit(1);
 }

 av_packet_unref(&packet);
 }
 printf("Processed frame %d\n", frame_count);

 if (ioctl(fd, VIDIOC_QBUF, &buffer) < 0) {
 perror("Could not requeue buffer");
 exit(1);
 }
 frame_count++;
 struct timespec current_time;
 clock_gettime(CLOCK_MONOTONIC, &current_time);
 elapsed_time = (current_time.tv_sec - start_time.tv_sec) + (current_time.tv_nsec - start_time.tv_nsec) / 1e9;
 printf("Elapsed time: %f seconds\n", elapsed_time);
 }

 av_freep(&frame->data[0]);
 av_frame_free(&frame);
 printf("Total frames processed: %d\n", frame_count);
}

int main(int argc, char *argv[]) {
 if (argc != 2) {
 fprintf(stderr, "Usage: %s <output file="file">\n", argv[0]);
 exit(1);
 }

 const char *output_file = argv[1];
 int fd;
 open_device(&fd, "/dev/video2");

 struct v4l2_format fmt;
 memset(&fmt, 0, sizeof(fmt));
 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 fmt.fmt.pix.width = WIDTH;
 fmt.fmt.pix.height = HEIGHT;
 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
 fmt.fmt.pix.field = V4L2_FIELD_NONE;

 if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
 perror("Setting pixel format");
 exit(1);
 }

 if (fmt.fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY) {
 fprintf(stderr, "Device does not support UYVY format\n");
 exit(1);
 }

 init_mmap(fd);
 start_capturing(fd);

 AVFormatContext *fmt_ctx = NULL;
 AVCodecContext *codec_ctx = NULL;
 AVStream *video_stream = NULL;

 initialize_ffmpeg(&fmt_ctx, &codec_ctx, &video_stream, output_file);

 struct SwsContext *sws_ctx = sws_getContext(WIDTH, HEIGHT, AV_PIX_FMT_UYVY422,
 WIDTH, HEIGHT, AV_PIX_FMT_YUV420P,
 SWS_BICUBIC, NULL, NULL, NULL);

 if (!sws_ctx) {
 fprintf(stderr, "Could not initialize SwsContext\n");
 exit(1);
 }

 capture_and_encode(fd, fmt_ctx, codec_ctx, sws_ctx, video_stream, DURATION);

 sws_freeContext(sws_ctx);
 av_write_trailer(fmt_ctx);
 avcodec_free_context(&codec_ctx);
 avformat_free_context(fmt_ctx);
 stop_capturing(fd);
 unmap_buffers();
 close(fd);

 return 0;
}
</output>

Syndiquer tout le site
