Recherche avancée

Sur d’autres sites (5701)

• ffmpeg H264 Encode Frame at a time for network streaming

  4 février 2017, par Richard Harrow

  I’m working on a remote desktop application, I would like to send an encoded H264 packet over TCP by using ffmpeg for the encoding. However I couldn’t find useful info for the particular case of encoding just one frame (already on YUV444) and get the packet.

  I have several issues, the first was that :

  avcodec_encode_video2

  Was not blocking, I found that most of the time you get the "delayed" frames at the end, however, since this is a real time streaming the solution was :

  av_opt_set(mCodecContext->priv_data, "tune", "zerolatency", 0);

  Now I got the frame, but several issues, it takes a while and even worse I got a gray with trash pixels video as result. My configuration for the Codec Context :

   m_pCodecCtx->bit_rate=8000000;
  
  m_pCodecCtx->codec_id=AV_CODEC_ID_H264;
  
  m_pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
  
  m_pCodecCtx->width=1920;
  
  m_pCodecCtx->height=1080;
  
  m_pCodecCtx->pix_fmt=AV_PIX_FMT_YUV444P;
  
  m_pCodecCtx->time_base.num = 1;
  
  m_pCodecCtx->time_base.den = 25;
  
  m_pCodecCtx->gop_size = 1;
  
  m_pCodecCtx->keyint_min = 1;
  
  m_pCodecCtx->i_quant_factor = float(0.71);
  
  m_pCodecCtx->b_frame_strategy = 20;
  
  m_pCodecCtx->qcompress = (float)0.6;
  
  m_pCodecCtx->qmax = 51;
  
  m_pCodecCtx->qmin = 20;
  
  m_pCodecCtx->max_qdiff = 4;
  
  m_pCodecCtx->refs = 4;
  
  m_pCodecCtx->max_b_frames = 1;
  
  m_pCodecCtx->thread_count = 1;

  I would like to know how this could be done, how do I set the "I Frames" ? and, that would be the optimal for a "one at a time" encoding ? Also I’m not concerned right now with the quality, just need to be fast enough (under 16 ms).

  For the encoding part :

  nres = avcodec_encode_video2(m_pCodecCtx,&packet,m_pFrame,&framefinished);
  
  
  
  if(nres<0){
  
      qDebug() << "error encoding: " << nres << endl;
  
  }
  
  
  
  if(framefinished){
  
      m_pFrame->pts++;
  
       ofstream vidout("video.h264",ios::app);
  
       if(vidout.good()){
  
           vidout.write((const char*)&packet.data[0],packet.size);
  
       }
  
       vidout.close();
  
  
  
       av_packet_unref(&packet);
  
  
  
  }

  I’m not using a container, just a raw file, ffplay reproduce raw files if the packets are right, and that’s my principal issue. I’m planning to send the packet over tcp and decode on the client. Any help would be greatly appreciated.

• fail continuous transfer video file into buffer

  9 décembre 2016, par chintitomasud

  here I want to process a video file transcoding on demand by using ffmpeg but I failed. without ffmpeg all code runs properly. but using ffmpeg I face some problem. it shows this message :

  Spawning new process /samiul113039/1080.mp4:GET
  piping ffmpeg output to client, pid 10016
  HTTP connection disrupted, killing ffmpeg : 10016
  Spawning new process /samiul113039/1080.mp4:GET
  piping ffmpeg output to client, pid 4796
  HTTP connection disrupted, killing ffmpeg : 4796
  ffmpeg didn’t quit on q, sending signals
  ffmpeg has exited : 10016, code null
  ffmpeg didn’t quit on q, sending signals
  ffmpeg has exited : 4796, code nul
  

  var fs=require('fs');
  
  
  
  var url=require("url");
  
  var urlvalue="http://csestudents.uiu.ac.bd/samiul113039/1080.mp4";
  
  
  
  
  
  var parseurl=url.parse(urlvalue);
  
  
  
  var HDHomeRunIP = parseurl.hostname;
  
  var HDHomeRunPort = parseurl.port;
  
  var childKillTimeoutMs = 1000;
  
  
  
  var parseArgs = require('minimist')(process.argv.slice(2));
  
  
  
  // define startsWith for string
  
  if (typeof String.prototype.startsWith != 'function') {
  
    // see below for better implementation!
  
    String.prototype.startsWith = function (str){
  
      return this.indexOf(str) == 0;
  
    };
  
  }
  
  // Called when the response object fires the 'close' handler, kills ffmpeg 
  
  function responseCloseHandler(command) {
  
    if (command.exited != true) {
  
      console.log('HTTP connection disrupted, killing ffmpeg: ' + command.pid);
  
      // Send a 'q' which signals ffmpeg to quit. 
  
      // Then wait half a second, send a nice signal, wait another half second
  
      // and send SIGKILL
  
      command.stdin.write('q\n');
  
      command.stdin.destroy();
  
      // install timeout and wait
  
      setTimeout(function() {
  
        if (command.exited != true) {
  
          console.log('ffmpeg didn\'t quit on q, sending signals');
  
          // still connected, do safe sig kills
  
          command.kill();
  
          try { 
  
            command.kill('SIGQUIT');
  
          } catch (err) {}
  
          try {
  
            command.kill('SIGINT');
  
          } catch (err) {} 
  
          // wait some more!
  
          setTimeout(function() {
  
            if (command.exited != true) {
  
              console.log('ffmpeg didn\'t quit on signals, sending SIGKILL');
  
              // at this point, just give up and whack it
  
              try {
  
                command.kill('SIGKILL');
  
              } catch (err) {}
  
            }
  
          }, childKillTimeoutMs);
  
        }    
  
      }, childKillTimeoutMs);
  
    }
  
  }
  
  
  
  // Performs a proxy. Copies data from proxy_request into response
  
  function doProxy(request,response,http,options) {
  
    var proxy_request = http.request(options, function (proxy_response) {
  
      proxy_response.on('data', function(chunk) {
  
        response.write(chunk, 'binary');
  
      });
  
      proxy_response.on('end', function() {
  
        response.end();
  
      });
  
      response.writeHead(proxy_response.statusCode, proxy_response.headers);
  
    });
  
    request.on('data', function(chunk) {
  
      proxy_request.write(chunk, 'binary');
  
    });
  
    // error handler
  
    proxy_request.on('error', function(e) {
  
      console.log('problem with request: ' + e.message);
  
      response.writeHeader(500);
  
      response.end();
  
    });
  
  
  
    proxy_request.end();
  
  }
  
  
  
  var child_process = require('child_process');
  
  var auth = require('./auth');
  
  // Performs the transcoding after the URL is validated
  
  function doTranscode(request,response) {
  
    //res.setHeader("Accept-Ranges", "bytes");
  
    response.setHeader("Accept-Ranges", "bytes");
  
    response.setHeader("Content-Type", "video/mp4");        
  
    response.setHeader("Connection","close");
  
    response.setHeader("Cache-Control","no-cache");
  
    response.setHeader("Pragma","no-cache");
  
  
  
    // always write the header
  
    response.writeHeader(200);
  
  
  
    // if get, spawn command stream it
  
    if (request.method == 'GET') {
  
      console.log('Spawning new process ' + request.url + ":" + request.method);
  
  
  
  var command = child_process.spawn('ffmpeg', 
  
                                        ['-i','http://csestudents.uiu.ac.bd/samiul113039/1080.mp4','-f','mpegts','-'],
  
                                        { stdio: ['pipe','pipe','ignore'] }); 
  
  
  
       command.exited = false;
  
      // handler for when ffmpeg dies unexpectedly
  
      command.on('exit',function(code,signal) {
  
        console.log('ffmpeg has exited: ' + command.pid + ", code " + code);
  
        // set flag saying we've quit
  
        command.exited = true;
  
        response.end();
  
      });
  
      command.on('error',function(error) {
  
        console.log('ffmpeg error handler - unable to kill: ' + command.pid);
  
        // on well, might as well give up
  
        command.exited = true;
  
        try {
  
          command.stdin.close(); 
  
        } catch (err) {}
  
        try {
  
          command.stdout.close();
  
        } catch (err) {}
  
        try {
  
          command.stderr.close();
  
        } catch (err) {}
  
        response.end();
  
      });
  
      // handler for when client closes the URL connection - stop ffmpeg
  
      response.on('end',function() { 
  
       responseCloseHandler(command);
  
      });
  
      // handler for when client closes the URL connection - stop ffmpeg
  
      response.on('close',function() { 
  
        responseCloseHandler(command); 
  
      });
  
  
  
      // now stream
  
      console.log('piping ffmpeg output to client, pid ' + command.pid);
  
      command.stdout.pipe(response);
  
      command.stdin.on('error',function(err) {
  
        console.log("Weird error in stdin pipe ", err);
  
        response.end();
  
      });
  
      command.stdout.on('error',function(err) {
  
        console.log("Weird error in stdout pipe ",err);
  
        response.end();
  
      });
  
    } 
  
    else {
  
      // not GET, so close response
  
      response.end();
  
    }
  
  }
  
  
  
  // Load the http module to create an http server.
  
  var http = require('http');
  
  
  
  // Configure our HTTP server to respond with Hello World to all requests.
  
  var server = http.createServer(function (request, response) {
  
    //console.log("New connection from " + request.socket.remoteAddress + ":" + request.url);
  
  
  
    if (auth.validate(request,response)) {
  
      // first send a HEAD request to our HD Home Run with the same url to see if the address is valid.
  
      // This prevents an ffmpeg instance to spawn when clients request invalid things - like robots.txt/etc
  
      var options = {method: 'HEAD', hostname: HDHomeRunIP, port: HDHomeRunPort, path: request.url};
  
      var req = http.request(options, function(res) {
  
        // if they do a get, and it returns good status
  
        if (request.method == "GET" &&
  
            res.statusCode == 200 &&
  
            res.headers["content-type"] != null &&
  
            res.headers["content-type"].startsWith("video")) {
  
          // transcode is possible, start it now!
  
          doTranscode(request,response);
  
        } 
  
        else {
  
          // no video or error, cannot transcode, just forward the response from the HD Home run to the client
  
          if (request.method == "HEAD") {
  
            response.writeHead(res.statusCode,res.headers);
  
            response.end();
  
          }
  
          else {
  
            // do a 301 redirect and have the device response directly  
  
  
  
            // just proxy it, that way browser doesn't redirect to HDHomeRun IP but keeps the node.js server IP
  
            options = {method: request.method, hostname: HDHomeRunIP, /* port: HDHomeRunPort, */path: request.url};
  
            doProxy(request,response,http,options);
  
          }
  
        }
  
      });
  
      req.on('error', function(e) {
  
        console.log('problem with request: ' + e.message);
  
        response.writeHeader(500);
  
        response.end();
  
      });
  
      // finish the client request, rest of processing done in the async callbacks
  
      req.end();
  
    }
  
  });
  
  
  
  // turn on no delay for tcp
  
  server.on('connection', function (socket) {
  
    socket.setNoDelay(true);
  
  });
  
  server.listen(7000);

• ffmpeg php some video output with zero byte

  30 janvier 2017, par medo

  i use this code for change video frame size

  if($this->height > 1440)
  
  exec('ffmpeg -i upload/default/'.$file.' -vf scale=-1:1440 -b 64k upload/1440/'.$file.'');
  
  
  
  
  
  if($this->height > 1080)
  
  exec('ffmpeg -i upload/default/'.$file.' -vf scale=-1:1080 -b 64k  upload/1080/'.$file.'');
  
  
  
  
  
  if($this->height > 720)
  
  exec('ffmpeg -i upload/default/'.$file.' -vf scale=-1:720 -b 64k  upload/720/'.$file.'');
  
  
  
  
  
  if($this->height > 480)
  
  exec('ffmpeg -i upload/default/'.$file.' -vf scale=-1:480 -b 64k  upload/480/'.$file.'');
  
  
  
  
  
  if($this->height > 360)
  
  exec('ffmpeg -i upload/default/'.$file.' -vf scale=-1:360 -b 64k  upload/360/'.$file.'');

  some time 240 frame size give zero byte or 360 some of them like 50% of my converted video with zero byte