Sur d’autres sites (8302)

• Create a video from images using libav

  24 février 2015, par Pierrexn

  I’m trying to create a mp4 file using libav, but the result is unreadable.

  Here is the code that i use :

  #include <libavformat></libavformat>avformat.h>
  
  #include <libavutil></libavutil>avutil.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  
  
  #define WIDTH 480
  
  #define HEIGHT 360
  
  #define TARGET_FPS 30
  
  
  
  int main() {
  
  
  
  av_register_all();
  
  
  
  AVOutputFormat *oformat = av_guess_format(NULL, "test.mp4", NULL);
  
  if (oformat == NULL)
  
  {
  
      printf("Set default\n");
  
      oformat = av_guess_format("mpeg", NULL, NULL);
  
  }
  
  //oformat->video_codec = AV_CODEC_ID_H264;
  
  AVCodec *codec = avcodec_find_encoder(oformat->video_codec);
  
  
  
  AVCodecContext* codec_context;
  
  codec_context = avcodec_alloc_context3(codec);
  
  codec_context->codec_id = oformat->video_codec;
  
  codec_context->codec_type = AVMEDIA_TYPE_VIDEO;
  
  codec_context->gop_size = 30;
  
  codec_context->bit_rate = WIDTH * HEIGHT * 4;
  
  codec_context->width = WIDTH;
  
  codec_context->height = HEIGHT;
  
  codec_context->time_base = (AVRational){1,TARGET_FPS};
  
  codec_context->max_b_frames = 1;
  
  codec_context->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
  AVFormatContext* format_context;
  
  format_context = avformat_alloc_context();
  
  format_context->oformat = oformat;
  
  format_context->video_codec_id = oformat->video_codec;
  
  
  
  //
  
  
  
  AVStream *video_stream = avformat_new_stream(format_context, codec);
  
  if (! video_stream)
  
  {
  
     printf("Could not allocate stream\n");
  
  }
  
  video_stream->codec = codec_context;
  
  
  
  if (format_context->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
  {
  
     codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  }
  
  
  
  //
  
  
  
  if (avcodec_open2(codec_context, codec, NULL) &lt; 0) {
  
      fprintf(stderr, "could not open codec\n");
  
      exit(1);
  
  }
  
  
  
  if (avio_open(&amp;format_context->pb, "test.mp4", AVIO_FLAG_WRITE) &lt; 0) {
  
    fprintf(stderr, "avio_open failed\n");
  
    exit(1);
  
  }
  
  
  
  avformat_write_header(format_context, NULL);

  Encoding some frames

  int i, x, y, got_output, write_ret;
  
  AVPacket pkt;
  
  AVFrame *frame;
  
  frame = av_frame_alloc();
  
  int ret = av_image_alloc(frame->data, frame->linesize, codec_context->width, codec_context->height, codec_context->pix_fmt, 32);
  
  if (ret < 0) {
  
      fprintf(stderr, "could not alloc raw picture buffer\n");
  
      exit(1);
  
  }
  
  frame->format = codec_context->pix_fmt;
  
  frame->width = codec_context->width;
  
  frame->height = codec_context->height;
  
  for(i=0;i<25;i++) {
  
      av_init_packet(&pkt);
  
      pkt.data = NULL; // packet data will be allocated by the encoder
  
      pkt.size = 0;
  
  
  
      fflush(stdout);
  
      /* prepare a dummy image */
  
      /* Y */
  
      for(y=0;yheight;y++) {
  
          for(x=0;xwidth;x++) {
  
              frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
  
          }
  
      }
  
      /* Cb and Cr */
  
      for(y=0;yheight/2;y++) {
  
          for(x=0;xwidth/2;x++) {
  
              frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
  
              frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
  
          }
  
      }
  
      frame->pts = i;
  
  
  
      /* encode the image */
  
      ret = avcodec_encode_video2(codec_context, &pkt, frame, &got_output);
  
      if (ret < 0) {
  
          fprintf(stderr, "error encoding frame\n");
  
          exit(1);
  
      }
  
      if (got_output) {
  
          printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
  
          //av_interleaved_write_frame(format_context, &pkt);
  
          write_ret = av_write_frame(format_context, &pkt);
  
          if (write_ret < 0) {
  
              fprintf(stderr, "Error writing frame\n");
  
              exit(1);
  
          }
  
          av_free_packet(&pkt);
  
      }
  
  }
  
  for (got_output = 1; got_output; i++) {
  
      fflush(stdout);
  
      ret = avcodec_encode_video2(codec_context, &pkt, NULL, &got_output);
  
      if (ret < 0) {
  
          fprintf(stderr, "error encoding frame\n");
  
          exit(1);
  
      }
  
      if (got_output) {
  
          printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
  
          //av_interleaved_write_frame(format_context, &pkt);
  
          write_ret = av_write_frame(format_context, &pkt);
  
          if (write_ret < 0) {
  
              fprintf(stderr, "Error writing frame\n");
  
              exit(1);
  
          }
  
          av_free_packet(&pkt);
  
      }
  
  }

  Cleaning

  avcodec_close(codec_context);
  
  av_free(codec_context);
  
  av_freep(&frame->data[0]);
  
  avcodec_free_frame(&frame);
  
  
  
  for (i = 0; i < format_context->nb_streams; i++) {
  
      avcodec_close(format_context->streams[i]->codec);
  
  }
  
  
  
  avio_close(format_context->pb);
  
  
  
  av_free(format_context);
  
  }

  The result file has 149361 bytes, but can’t be readed.
  where i’m wrong ??

• Improper use of system() call ?

  28 mai 2013, par Dima1982

  I have a particle system program that generates a .dat file with particle coordinates in every iteration. The end goal is to run the program multiple times via a script with different parameters. So, I am trying to setup my program in a way that, for every run, all relevant data are going to be stored in a folder.

  What I do is to generate PNGs from the .dat files with Gnuplot, call ffmpeg to create a video out of the PNGs, use WinRAR to compress the .dat files and finally clean up, by deleting all the intermediate files. This works, when I do it in the working directory.

  Now I try to create a new directory and do the same stuff in there. My code :

  // Load the proper library to use chdir() function
  
  #ifdef _WIN32
  
  #include 
  
  #elif defined __linux__ || defined __APPLE__&&__MACH__
  
  #include 
  
  #endif
  
  
  
  // Make output directory and change working directory to new directory
  
      ostringstream dirCommand;
  
      dirCommand << "mkdir " << folderName_str;
  
      system(dirCommand.str().c_str());
  
      const char* test  = folderName_str.c_str();
  
      #ifdef _WIN32
  
          if(_chdir(test))
  
          {
  
              printf( "Unable to locate the directory: %s\n",test);
  
              return;
  
          }
  
      #elif defined __linux__ || defined __APPLE__&&__MACH__
  
          if(chdir(test))
  
          {
  
              printf( "Unable to locate the directory: %s\n",test);
  
              return;
  
          }
  
      #endif
  
          else
  
              printf("Created output directory...\n");

  Already for this part, I know that there are going to be objections. I have looked extensively on SO and many people favor SetCurrentDirectory() for Windows, or they are skeptical about using system(). In my defense, I am a novice programmer and my knowledge is really limited...

  Now, when I try to make the video with FFMpeg and then rar/tar my files :

  // Make video
  
          std::cout << "Generating Video..." << endl;
  
          ostringstream command;
  
          command << "ffmpeg -f image2 -r 1/0.1 -i output_%01d.png -vcodec mpeg4 " << videoName_str << ".avi -loglevel quiet";
  
          std::system(command.str().c_str());
  
  
  
          // Clean Up!
  
          std::cout << "Cleaning up!" << endl;
  
          ostringstream command2;
  
          #ifdef _WIN32
  
              command2 << "rar -inul a " << videoName_str << ".rar *.dat settings.gp loadfile.gp";
  
          #elif defined __linux__ || defined __APPLE__&&__MACH__
  
              command2 << "tar cf " << videoName_str << ".tar *.dat settings.gp loadfile.gp";
  
          #endif
  
          std::system(command2.str().c_str());

  I get very different behaviors in Win/ Linux.

  Win 7 x64, Visual Studio 2010/12

  In windows, the folder is created. The .dat files are generated correctly and gnuplot plots the PNGs as well. When ffmpeg is called, nothing happens. No error message from FFMpeg or anything. The same goes for WinRAR. Maybe, for the last thing, I can use the command line utility of 7z which is free !

  Linux Mint 14 x64, Qt 4.8.1

  Strangely enough, the behavior is inverted from that of Windows. As soon as the dir is changed, only the first .dat file is generated. It is as if every subsequent call I make to fprintf() for my file generation does not work, or gets lost somewhere. Gnuplot works, as do ffmpeg and tar !!

  I am really perplexed. Any help, would be really appreciated.

• ffmpeg exit code 429496724 when opening file with {} in name

  16 février, par Holly Wilson

  I'm trying to write a program that will read the names of files in a directory, and parse them for info which it will then write into that file's metadata (seems pointless, I know, but it's more of a trial run for a larger project. If I can figure this out, then I'll be ready to move on to what I actually want to do).
All of my filenames are formatted :

  


  Title, Article* - Subtitle* Cut* [Year]
*if present

  


  The four test videos I'm using are titled :

  


  Test Video 1 [2000]

  


  Test Video 2, A [2000]

  


  Test Video 3 Test Cut [2000]

  


  Test Video 4 - The Testening [2000]

  


  The code seems to be working fine on videos 1, 2, & 4 ; but video 3 is causing me a lot of headache.

  


  //node C:\Users\User\Documents\Coding\Tools\testMDG.js
const fs = require('fs');
const path = require('path');
const ffmpeg = require('fluent-ffmpeg');
const async = require('async');
const directory = path.normalize('F:\\Movies & TV\\Movies\\testDir');
let x = 0;
const fileArray = [];
const succArray = [];
const failArray = [];
// Set the path to the ffmpeg executable
ffmpeg.setFfmpegPath(path.normalize('C:\\ffmpeg\\bin\\ffmpeg.exe'));

// Add this near the start of your script
const tempDir = path.join(directory, 'temp');
if (!fs.existsSync(tempDir)) {
    fs.mkdirSync(tempDir, { recursive: true });
}

const progresscsv = path.normalize('C:\\Users\\User\\Documents\\Coding\\Tools\\progress.csv');
if (fs.existsSync(progresscsv)) {
    fs.unlinkSync(progresscsv);
};

const csvStream = fs.createWriteStream(progresscsv);
csvStream.write('File Name,Status\n');

const CONCURRENCY_LIMIT = 3; // Adjust based on your system capabilities

// Add at the start of your script
const processedFiles = new Set();

function sanitizeFilePath(filePath) {
    return filePath.replace(/([{}])/g, '\\$1');
}

// Create a queue
const queue = async.queue(async (task, callback) => {
    const { file, filePath, tempFilePath, movieMetadata } = task;
    try {
        await new Promise((resolve, reject) => {
            console.log(`ffmpeg reading: ${sanitizeFilePath(filePath)}`);
            ffmpeg(sanitizeFilePath(filePath))
                .outputOptions([
                    '-y',
                    '-c', 'copy',
                    '-map', '0',
                    '-metadata', `title=${movieMetadata.title}`,
                    '-metadata', `subtitle=${movieMetadata.subtitle || ''}`,
                    '-metadata', `comment=${movieMetadata.cut || ''}`,
                    '-metadata', `year=${movieMetadata.year}`
                ])
                .on('error', (err) => reject(err))
                .on('end', () => resolve())
                .saveToFile(tempFilePath);
        });
        
        // Handle success
        console.log(`Successfully processed: ${file}`);
        succArray.push(file);
        // Only call callback once
        if (callback && typeof callback === 'function') {
            callback();
        }
    } catch (err) {
        // Handle error
        console.error(`Error processing ${file}: ${err.message}`);
        failArray.push(file);
        // Only call callback once with error
        if (callback && typeof callback === 'function') {
            callback(err);
        }
    }
}, CONCURRENCY_LIMIT);

fs.readdir(directory, (err, files) => {
    if (err) {
        console.error(`Error reading directory: ${err.message}`);
        return;
    }
    console.log(directory);

    // Filter for files only
    files = files.filter(file => fs.statSync(path.join(directory, file)).isFile());
    console.log(files);

    for (const file of files) {
        x++;
        const filePath = path.join(directory, file);
        let desort = file.replace(/(.*),\s(the\s|an\s|a\s)/i, '$2'+'$1 ') || file;
        
        // Create task object for queue
        const task = {
            file,
            filePath: filePath,
            tempFilePath: path.join(directory, 'temp', `temp_${x}_${path.parse(file).name
                .replace(/[^a-zA-Z0-9]/g, '_')}${path.extname(file)}`),
            movieMetadata: {
                title: desort.replace(/(\s[\-\{\[].*)/gi, ``),
                subtitle: desort.includes('-') ? desort.replace(/(.*)\-\s(.*?)[\{\[].*/gi, '$2') : null,
                cut: desort.includes('{') ? desort.replace(/.*\{(.*)\}.*/gi, '$1') : null,
                year: desort.replace(/.*\[(.*)\].*/gi, '$1')
            }
        };
        
        // Add to processing queue
        queue.push(task, (err) => {
            if (!processedFiles.has(task.file)) {
                processedFiles.add(task.file);
                if (err) {
                    csvStream.write(`${task.file},Failed\n`);
                } else {
                    csvStream.write(`${task.file},Processed\n`);
                }
            }
        });
    }
});

// Add queue completion handler
queue.drain(() => {
    console.log('All files have been processed');
    console.log(`Success: ${succArray.length} files: ${succArray}`);
    console.log(`Failed: ${failArray.length} files: ${failArray}`);
});

//node C:\Users\User\Documents\Coding\Tools\testMDG.js


  


  And the console is logging :

  


  PS C:\Users\User> node C:\Users\User\Documents\Coding\Tools\testMDG.js
F:\Movies & TV\Movies\testDir
[
  'Test Video 1 [2020].mp4',
  'Test Video 2, A [2020].mp4',
  'Test Video 3 {Test Cut} [2020].mp4',
  'Test Video 4 - The Testening [2020].mp4'
]
ffmpeg reading: F:\Movies & TV\Movies\testDir\Test Video 1 [2020].mp4
ffmpeg reading: F:\Movies & TV\Movies\testDir\Test Video 2, A [2020].mp4
ffmpeg reading: F:\Movies & TV\Movies\testDir\Test Video 3 \{Test Cut\} [2020].mp4
Error processing Test Video 3 {Test Cut} [2020].mp4: ffmpeg exited with code 4294967294: Error opening input file F:\Movies & TV\Movies\testDir\Test Video 3 \{Test Cut\} [2020].mp4.
Error opening input files: No such file or directory

ffmpeg reading: F:\Movies & TV\Movies\testDir\Test Video 4 - The Testening [2020].mp4
Successfully processed: Test Video 1 [2020].mp4
Successfully processed: Test Video 2, A [2020].mp4
Successfully processed: Test Video 4 - The Testening [2020].mp4
All files have been processed
Success: 3 files: Test Video 1 [2020].mp4,Test Video 2, A [2020].mp4,Test Video 4 - The Testening [2020].mp4
Failed: 1 files: Test Video 3 {Test Cut} [2020].mp4


  


  I've tried so many different solutions in the sanitizeFilePath function. Escaping the {} characters (as included below), escaping all non-alphanumeric characters, putting the filepath in quotes, etc. VSCode's CoPilot is just pulling me round in circles, suggesting solutions I've already tried.