Recherche avancée

Sur d’autres sites (8350)

• Programmatically creating a video using FFmpeg, using SDL's sprite screenshot BMP

  28 octobre 2016, par alok

  I have an animation/sprite developed in C++ on SDL2 libs (based on this answer). The bitmaps are saved to a certain path. They are of dimensions 640x480 and format is given by the SDL constant SDL_PIXELFORMAT_ARGB8888.

  I have a second program written in C on top of FFmpeg libs, which reads one image from the above path (just one for the time being, will read the whole series when it works for just one).
  This does the following (in gist - skipping validation & comments for conciseness)

  AVCodec *codec;
  
  AVCodecContext *c = NULL;
  
  int i, ret, x, y, got_output;
  
  FILE *f;
  
  AVFrame *frame;
  
  AVPacket pkt;
  
  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  
  
  codec = avcodec_find_encoder(codec_id);
  
  c = avcodec_alloc_context3(codec);
  
  c->bit_rate = 400000;
  
  /* resolution must be a multiple of two */
  
  c->width = 640;
  
  c->height = 480;
  
  c->time_base = (AVRational ) { 1, 25 };
  
  c->gop_size = 5;
  
  c->max_b_frames = 1;
  
  c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
  av_opt_set(c->priv_data, "preset", "slow", 0);
  
  avcodec_open2(c, codec, NULL);
  
  
  
  fopen(filename, "wb");
  
  frame = av_frame_alloc();
  
  av_image_alloc(frame->data, frame->linesize, c->width, c->height, c->pix_fmt, 32);
  
  
  
  for (i = 0; i < 25; ++i) {
  
      readSingleFile("/tmp/alok1/ss099.bmp", &frame->data);//Read the saved BMP into frame->data
  
      frame->pts = i;
  
      frame->width = 640;
  
      frame->height = 480;
  
      frame->format = -1;
  
  
  
      av_init_packet(&pkt);
  
      pkt.data = NULL; // packet data will be allocated by the encoder
  
      pkt.size = 0;
  
      ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
  
  
  
  
  
      if (got_output) {
  
          printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
          fwrite(pkt.data, 1, pkt.size, f);
  
      }
  
      av_packet_unref(&pkt);
  
  }
  
  for (got_output = 1; got_output; i++) {
  
      fflush(stdout);
  
  
  
      ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
  
      if (ret < 0) {
  
          fprintf(stderr, "Error encoding frame\n");
  
          exit(1);
  
      }
  
  
  
      if (got_output) {
  
          printf("[DELAYED]Write frame %3d (size=%5d)\n", i, pkt.size);
  
          fwrite(pkt.data, 1, pkt.size, f);
  
          av_packet_unref(&pkt);
  
      }
  
  }
  
  
  
  fwrite(endcode, 1, sizeof(endcode), f);
  
  //cleanup

  As a result of the above code(which compiles without trouble), I can get a video which plays for 1 second - this part is working as expected. Problem is that the image seen is a green full screen like below.

  The image that is being read using the readSingleImage(...) function is rendered by image viewer(linux, gwenview and okular) as follows :

  Any pointers as to what could be going wrong ?

• ffmpeg nvenc encode too slow

  13 août 2016, par sweetsource

  i use ffmpeg 3.1 compile with nvenc,when i run the ffmpeg encode example like this：

  #include 
  
  
  
  #include <libavutil></libavutil>opt.h>
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavutil></libavutil>channel_layout.h>
  
  #include <libavutil></libavutil>common.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  #include <libavutil></libavutil>mathematics.h>
  
  #include <libavutil></libavutil>samplefmt.h>
  
  #include <ace></ace>ace_os.h>
  
  
  
  #define INBUF_SIZE 4096
  
  #define AUDIO_INBUF_SIZE 20480
  
  #define AUDIO_REFILL_THRESH 4096
  
  
  
  
  
  
  
  /*
  
   * Video encoding example
  
   */
  
  static void video_encode_example(const char *filename, const char* codec_name)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      int i, ret, x, y, got_output;
  
      ACE_INT64 nstart,nend;
  
      FILE *f;
  
      AVFrame *frame;
  
      AVPacket pkt;
  
      uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  
  
      printf("Encode video file %s\n", filename);
  
  
  
      /* find the video encoder */
  
      codec = avcodec_find_encoder_by_name(codec_name);
  
      if (!codec) {
  
          fprintf(stderr, "Codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
      if (!c) {
  
          fprintf(stderr, "Could not allocate video codec context\n");
  
          exit(1);
  
      }
  
  
  
      /* put sample parameters */
  
      c->bit_rate = 400000;
  
      /* resolution must be a multiple of two */
  
      c->width = 352;
  
      c->height = 288;
  
      /* frames per second */
  
      c->time_base = (AVRational){1,25};
  
      /* emit one intra frame every ten frames
  
       * check frame pict_type before passing frame
  
       * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
  
       * then gop_size is ignored and the output of encoder
  
       * will always be I frame irrespective to gop_size
  
       */
  
      c->gop_size = 25;
  
      c->max_b_frames = 0;
  
      c->thread_count = 1;
  
      c->refs = 4;
  
      c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
      if(!strcmp(codec_name,"libx264")
  
      {
  
          av_opt_set(c->priv_data, "preset", "superfast", 0);
  
          av_opt_set(c->priv_data, "tune", "zerolatency", 0);
  
      }
  
  
  
      if(!strcmp(codec_name,"h264_nvenc")
  
      {
  
          av_opt_set(m_pEncodeCtx->priv_data, "gpu","any",0);
  
          av_opt_set(m_pEncodeCtx->priv_data, "preset", "llhp", 0);
  
          av_opt_set(m_pEncodeCtx->priv_data,"profile","main",0);
  
          m_pEncodeCtx->refs = 0;
  
          m_pEncodeCtx->flags = 0;
  
          m_pEncodeCtx->qmax = 31;
  
          m_pEncodeCtx->qmin = 2;
  
      }
  
  
  
      /* open it */
  
      if (avcodec_open2(c, codec, NULL) &lt; 0) {
  
          fprintf(stderr, "Could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      f = fopen(filename, "wb");
  
      if (!f) {
  
          fprintf(stderr, "Could not open %s\n", filename);
  
          exit(1);
  
      }
  
  
  
      frame = av_frame_alloc();
  
      if (!frame) {
  
          fprintf(stderr, "Could not allocate video frame\n");
  
          exit(1);
  
      }
  
      frame->format = c->pix_fmt;
  
      frame->width  = c->width;
  
      frame->height = c->height;
  
  
  
      /* the image can be allocated by any means and av_image_alloc() is
  
       * just the most convenient way if av_malloc() is to be used */
  
      ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
  
                           c->pix_fmt, 32);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not allocate raw picture buffer\n");
  
          exit(1);
  
      }
  
  
  
      /* encode 1 second of video */
  
      for (i = 0; i &lt; 25; i++) {
  
          av_init_packet(&amp;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; y &lt; c->height; y++) {
  
              for (x = 0; x &lt; c->width; x++) {
  
                  frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
  
              }
  
          }
  
  
  
          /* Cb and Cr */
  
          for (y = 0; y &lt; c->height/2; y++) {
  
              for (x = 0; x &lt; c->width/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 */
  
          nstart = ACE_OS::gettimeofday().get_msec();
  
          ret = avcodec_encode_video2(c, &amp;pkt, frame, &amp;got_output);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Error encoding frame\n");
  
              exit(1);
  
          }
  
  
  
          if (got_output) {
  
              printf("%s take time:%d\n",codec_name,ACE_OS::gettimeofday().get_msec()-nstart);
  
              printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
              fwrite(pkt.data, 1, pkt.size, f);
  
              av_packet_unref(&amp;pkt);
  
          }
  
      }
  
  
  
      /* get the delayed frames */
  
      for (got_output = 1; got_output; i++) {
  
          fflush(stdout);
  
  
  
          ret = avcodec_encode_video2(c, &amp;pkt, NULL, &amp;got_output);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Error encoding frame\n");
  
              exit(1);
  
          }
  
  
  
          if (got_output) {
  
              printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
              fwrite(pkt.data, 1, pkt.size, f);
  
              av_packet_unref(&amp;pkt);
  
          }
  
      }
  
  
  
      /* add sequence end code to have a real MPEG file */
  
      fwrite(endcode, 1, sizeof(endcode), f);
  
      fclose(f);
  
  
  
      avcodec_close(c);
  
      av_free(c);
  
      av_freep(&amp;frame->data[0]);
  
      av_frame_free(&amp;frame);
  
      printf("\n");
  
  }
  
  
  
  
  
  
  
  int main(int argc, char **argv)
  
  {
  
      const char *output_type;
  
  
  
      /* register all the codecs */
  
      avcodec_register_all();
  
      video_encode_example("test.h264", "h264_nvenc");
  
  
  
  
  
      return 0;
  
  }

  it encode one frame to a packet about 1800ms,this is too slow. I use Nvidia Grid K1.Is there some parameter error ? Thanke you very much

• In using FFmpeg SDK, the mp4 file encoded with HEVC(x265) codec not playing in general player

  26 octobre 2016, par Wiktor Kostus

  Everyone !

  I am going to encode mp4 file (x264 codec) to HEVC(x265) codec using FFmpeg SDK.
  Also, I am going to write the encoded file into .mp4 file container.

  The problem I am facing is that the encoded file is played well in FFplay and VLC player but it isn’t played in general HEVC player.

  I used the general method to encode the codec in FFmpeg SDK. I think I have a mistake to use the avformat_write_header() function. It seems that some parameters to pass AVFormatContext, AVOutputFormat or AVCodecContext for HEVC codec are missing.

  Finally, I would like to know the way to write the HEVC codec into mp4 container. I also would like to know the right parameters related to Context instances for HEVC codec.

  Below is my tiny demo code. (I have skipped the code related to InputStream since I think I have a mistake in OutputStream)

  AVFormatContext* pFormatCtx;
  
  AVOutputFormat* fmt;
  
  AVStream* video_st;
  
  AVCodecContext* pCodecCtx;
  
  
  
  const char* out_file = "output.mp4";
  
  
  
  pFormatCtx = avformat_alloc_context();
  
  fmt = av_guess_format(NULL, out_file, NULL);
  
  pFormatCtx->oformat = fmt;
  
  
  
  if (avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0){
  
      printf("Failed to open output file! \n");
  
      return -1;
  
  }
  
  
  
  video_st = avformat_new_stream(pFormatCtx, 0);
  
  video_st->time_base.num = 1; 
  
  video_st->time_base.den = 25;  
  
  
  
  if (video_st==NULL){
  
      return -1;
  
  }
  
  //Param that must set
  
  pCodecCtx = video_st->codec;
  
  pCodecCtx->codec_id =AV_CODEC_ID_HEVC;
  
  pCodecCtx->codec_id = fmt->video_codec;
  
  pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
  
  pCodecCtx->pix_fmt = PIX_FMT_YUV420P;
  
  pCodecCtx->width = in_w;  
  
  pCodecCtx->height = in_h;
  
  pCodecCtx->time_base.num = 1;  
  
  pCodecCtx->time_base.den = 25;  
  
  pCodecCtx->bit_rate = 400000;  
  
  pCodecCtx->gop_size=250;
  
  pCodecCtx->qmin = 10;
  
  pCodecCtx->qmax = 51;
  
  pCodecCtx->max_b_frames = 1;
  
  
  
  // Set Option
  
  AVDictionary *param = 0;
  
  av_dict_set(&param, "preset", "ultrafast", 0);
  
  av_dict_set(&param, "tune", "zero-latency", 0);
  
  av_dict_set(&param, "x265-params", "crf=25", 0);
  
  
  
  pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
  
  if (!pCodec){
  
      printf("Can not find encoder! \n");
  
      return -1;
  
  }
  
  if (avcodec_open2(pCodecCtx, pCodec,&param) < 0){
  
      printf("Failed to open encoder! \n");
  
      return -1;
  
  }
  
  
  
  //Write File Header
  
  avformat_write_header(pFormatCtx, NULL); <------ I think it takes any error in here.

  Help me what I am doing wrong.

  Thank you for your consider.