Recherche avancée

Sur d’autres sites (4394)

• 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 transpose corrupts video [on hold]

  15 décembre 2016, par Victor.dMdB

  I’m trying to set up a transcoding pipeline with ffmpeg C lib, but if I transpose it, the video is corrupted as shown below.

  If I don’t transpose, the video is fine, ie the rest of the pipeline is correctly set up.

  I’m not actually sure what is actually the issue, is it a problem with the pxiel format ? Why is the transpose corrupting the video stream ? Is there something wrong with my code (added below) ?

  

  The constructor (code was taken from here)

  MyFilter::MyFilter(const std::string filter_desc, AVCodecContext *data_ctx){
  
    avfilter_register_all();
  
    buffersrc_ctx = NULL;
  
    buffersink_ctx = NULL;
  
  
  
      filter_graph = avfilter_graph_alloc();
  
  
  
    AVFilter *buffersink = avfilter_get_by_name("buffersink");
  
    if (!buffersink) {
  
      throw error("filtering sink element not found\n");
  
    }
  
  
  
    if (avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph) < 0) {
  
      throw error("Cannot create buffer sink\n");
  
    }
  
  
  
  
  
  filterInputs  = avfilter_inout_alloc();
  
    filterInputs->name       = av_strdup("out");
  
    filterInputs->filter_ctx = buffersink_ctx;
  
    filterInputs->pad_idx    = 0;
  
    filterInputs->next       = NULL;
  
  
  
      AVFilter *buffersrc  = avfilter_get_by_name("buffer");
  
      if (!buffersrc) {
  
          throw error("filtering source element not found\n");
  
      }
  
  
  
      char args[512];
  
      snprintf(args, sizeof(args), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
  
                      data_ctx->width, data_ctx->height, data_ctx->pix_fmt,
  
                      data_ctx->time_base.num, data_ctx->time_base.den,
  
                      data_ctx->sample_aspect_ratio.num, data_ctx->sample_aspect_ratio.den);
  
  
  
      log(Info, "Setting filter input with %s", args);
  
  
  
  
  
      if (avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph) < 0) {
  
           throw error("Cannot create buffer source\n");
  
      }
  
  
  
      filterOutputs = avfilter_inout_alloc();
  
      filterOutputs->name       = av_strdup("in");
  
      filterOutputs->filter_ctx = buffersrc_ctx;
  
      filterOutputs->pad_idx    = 0;
  
      filterOutputs->next       = NULL;
  
  
  
      if ((avfilter_graph_parse(filter_graph, filter_desc.c_str(), filterInputs, filterOutputs, NULL)) < 0)
  
              log(Warning,"Could not parse input filters");
  
  
  
      if ((avfilter_graph_config(filter_graph, NULL)) < 0)
  
          log(Warning,"Could not configure filter graph");
  
  
  
  }

  And the process

  AVFrame * MyFilter::process(AVFrame *inFrame){
  
  
  
      if (av_buffersrc_add_frame_flags(buffersrc_ctx, inFrame->get(), AV_BUFFERSRC_FLAG_PUSH | AV_BUFFERSRC_FLAG_KEEP_REF ) < 0) {
  
           throw error("Error while feeding the filtergraph\n");
  
       }
  
  
  
      int i = 0;
  
      AVFrame* outFrame =  av_frame_alloc();
  
      if( av_buffersink_get_frame(buffersink_ctx, outFrame) < 0 ){
  
       throw error("Couldnt find a frame\n");
  
      }
  
    return outFrame;
  
  }

  And the filter I’m using is :

   std::string filter_desc = "transpose=cclock"

  As an extra note, it seems like the top bar(visible in the screen capture above) is actually composed of properly rotated pixels, and this works for the whole video. It just degrades for the remaining 99% of pixels.

  EDIT :

  Using this works std::string filter_desc = "rotate=1.58", but then the resolution is not properly shifted.

• Recording video using ffmpeg in android

  11 janvier 2017, par Vishal Ghorpade

  i was studying ffmpeg for android library,was unable to understand a part of the code.

  public void onPreviewFrame(byte[] data, Camera camera)
  
  { 
  
      if (audioRecord == null || audioRecord.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING)
  
      {
  
           startTime = System.currentTimeMillis();
  
           return;
  
      }
  
  
  
      if (RECORD_LENGTH > 0) {
  
          int i = imagesIndex++ % images.length;
  
          yuvImage = images[i];
  
          timestamps[i] = 1000 * (System.currentTimeMillis() - startTime);
  
      }
  
  
  
  //till here i was able to understand but the first statement is for what purpose?
  
  
  
      /* get video data */
  
      if (yuvImage != null && recording) {
  
          ((ByteBuffer)yuvImage.image[0].position(0)).put(data);
  
      }
  
  }