Recherche avancée

Sur d’autres sites (9915)

• How to encode using the FFMpeg in Android (using H263)

  10 mai 2019, par Kenny910

  I am trying to follow the sample code on encoding in the ffmpeg document and successfully build a application to encode and generate a mp4 file but I face the following problems :

  1) I am using the H263 for encoding but I can only set the width and height of the AVCodecContext to 176x144, for other case (like 720x480 or 640x480) it will return fail.

  2) I can’t play the output mp4 file by using the default Android player, isn’t it support H263 mp4 file ? p.s. I can play it by using other player

  3) Is there any sample code on encoding other video frame to make a new video (which mean decode the video and encode it back in different quality setting, also i would like to modify the frame content) ?

  Here is my code, thanks !

  JNIEXPORT jint JNICALL Java_com_ffmpeg_encoder_FFEncoder_nativeEncoder(JNIEnv* env, jobject thiz, jstring filename){
  
  
  
  LOGI("nativeEncoder()");
  
  
  
  avcodec_register_all();
  
  avcodec_init();
  
  av_register_all();
  
  
  
  AVCodec         *codec;
  
  AVCodecContext  *codecCtx;
  
  int             i;
  
  int             out_size;
  
  int             size;
  
  int             x;
  
  int             y;
  
  int             output_buffer_size;
  
  FILE            *file;
  
  AVFrame         *picture;
  
  uint8_t         *output_buffer;
  
  uint8_t         *picture_buffer;
  
  
  
  /* Manual Variables */
  
  int             l;
  
  int             fps = 30;
  
  int             videoLength = 5;
  
  
  
  /* find the H263 video encoder */
  
  codec = avcodec_find_encoder(CODEC_ID_H263);
  
  if (!codec) {
  
      LOGI("avcodec_find_encoder() run fail.");
  
  }
  
  
  
  codecCtx = avcodec_alloc_context();
  
  picture = avcodec_alloc_frame();
  
  
  
  /* put sample parameters */
  
  codecCtx->bit_rate = 400000;
  
  /* resolution must be a multiple of two */
  
  codecCtx->width = 176;
  
  codecCtx->height = 144;
  
  /* frames per second */
  
  codecCtx->time_base = (AVRational){1,fps};
  
  codecCtx->pix_fmt = PIX_FMT_YUV420P;
  
  codecCtx->codec_id = CODEC_ID_H263;
  
  codecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
  
  
  
  /* open it */
  
  if (avcodec_open(codecCtx, codec) < 0) {
  
      LOGI("avcodec_open() run fail.");
  
  }
  
  
  
  const char* mfileName = (*env)->GetStringUTFChars(env, filename, 0);
  
  
  
  file = fopen(mfileName, "wb");
  
  if (!file) {
  
      LOGI("fopen() run fail.");
  
  }
  
  
  
  (*env)->ReleaseStringUTFChars(env, filename, mfileName);
  
  
  
  /* alloc image and output buffer */
  
  output_buffer_size = 100000;
  
  output_buffer = malloc(output_buffer_size);
  
  
  
  size = codecCtx->width * codecCtx->height;
  
  picture_buffer = malloc((size * 3) / 2); /* size for YUV 420 */
  
  
  
  picture->data[0] = picture_buffer;
  
  picture->data[1] = picture->data[0] + size;
  
  picture->data[2] = picture->data[1] + size / 4;
  
  picture->linesize[0] = codecCtx->width;
  
  picture->linesize[1] = codecCtx->width / 2;
  
  picture->linesize[2] = codecCtx->width / 2;
  
  
  
  for(l=0;l/encode 1 second of video
  
      for(i=0;i/prepare a dummy image YCbCr
  
          //Y
  
          for(y=0;yheight;y++) {
  
              for(x=0;xwidth;x++) {
  
                  picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
  
              }
  
          }
  
  
  
          //Cb and Cr
  
          for(y=0;yheight/2;y++) {
  
              for(x=0;xwidth/2;x++) {
  
                  picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
  
                  picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
  
              }
  
          }
  
  
  
          //encode the image
  
          out_size = avcodec_encode_video(codecCtx, output_buffer, output_buffer_size, picture);
  
          fwrite(output_buffer, 1, out_size, file);
  
      }
  
  
  
      //get the delayed frames
  
      for(; out_size; i++) {
  
          out_size = avcodec_encode_video(codecCtx, output_buffer, output_buffer_size, NULL);
  
          fwrite(output_buffer, 1, out_size, file);
  
      }
  
  }
  
  
  
  //add sequence end code to have a real mpeg file
  
  output_buffer[0] = 0x00;
  
  output_buffer[1] = 0x00;
  
  output_buffer[2] = 0x01;
  
  output_buffer[3] = 0xb7;
  
  
  
  fwrite(output_buffer, 1, 4, file);
  
  fclose(file);
  
  free(picture_buffer);
  
  free(output_buffer);
  
  avcodec_close(codecCtx);
  
  av_free(codecCtx);
  
  av_free(picture);
  
  
  
  LOGI("finish");
  
  
  
  return 0; }

• H264 decoding using ffmpeg

  18 mai 2019, par Kindermann

  I’m trying to decode a video stream with ffmpeg library, that’s how I do it basically :

  void video_decode(const char *filename)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      int frame_count=0;
  
      FILE *f;
  
      AVFrame *frame;
  
      uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
  
      AVPacket avpkt;
  
      av_init_packet(&avpkt);
  
      memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  
      printf("Decoding video file...\n");
  
      /* find the h264 video decoder */
  
      codec = avcodec_find_decoder(AV_CODEC_ID_H264);
  
      c = avcodec_alloc_context3(codec);
  
      c->bit_rate = 400000;
  
      c->width = 1920;
  
      c->height = 1080;
  
  
  
      if (avcodec_open2(c, codec, NULL) < 0) {
  
          fprintf(stderr, "Could not open codec\n");
  
          exit(1);
  
      }
  
      frame = av_frame_alloc();
  
      for (;;) {
  
          avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);         
  
      if (avpkt.size == 0)
  
              break;
  
          avpkt.data = inbuf;
  
          while(avpkt.size > 0){
  
  
  
          int len, got_frame;
  
              len = avcodec_decode_video2(c, frame, &got_frame, &avpkt);          
  
          if (len < 0) {
  
                  fprintf(stderr, "Errr while decding frame %d\n", frame_count);
  
                  exit (1);
  
              }
  
              if (got_frame) {
  
                  //Print out frame information..
  
          }
  
              if (avpkt.data) {
  
                  avpkt.size -= len;
  
                  avpkt.data += len;
  
              }
  
      }               
  
      }  
  
  }

  But I got the following outputs :

  Decoding video file...
  
  [h264 @ 0x303c040] decode_slice_header error
  
  [h264 @ 0x303c040] decode_slice_header error
  
  [h264 @ 0x303c040] decode_slice_header error
  
  [h264 @ 0x303c040] no frame!
  
  Errr while decding frame 0

  Obviously the initiation of codec was incomplete. Do you have experience with h264 api ? Any help would be appreciated.

• FFMPEG avformat_write_header changing my stream time_base

  12 juillet 2019, par cesarpachon

  I am muxing video using ffmpeg 2.1.3 with libavcodec 55.39.101 (forced to that version because is the one available in google-chrome PNACL port project). all my frames seems to have bad the time. they try to be rendered all at once at the beggining of the video when playing it.

  I am setting the stream time base to 1/25, but just after calling avformat_write_header, it has the value of -18082736/1.
  in each frame, when I print the stream time_base it says 1/12800, while the time_base of codec is always ok (1/25).

  console log before and after av_format_write_header :

  before avformat_write_header stream time_base: 1/25
  
  after avformat_write_header ret 0 stream time_base: -18082736/1

  the code (abreviated to keep the post short, all calls in the original version had error checking) :

  AVCodecContext *codecContext;
  
  AVCodec * codec = avcodec_find_encoder(codec_id);  
  
  myOutputStream->stream = avformat_new_stream(outputFormatContext, *codec);
  
  myOutputStream->stream->id = outputFormatContext->nb_streams-1;
  
  codecContext = myOutputStream->stream->codec;
  
  codecContext->codec_id = codec_id;
  
  codecContext->bit_rate = 400000;
  
  codecContext->width    = width;
  
  codecContext->height   = height;
  
  myOutputStream->stream->time_base = (AVRational){ 1, 25 };
  
  codecContext->time_base       = myOutputStream->stream->time_base;
  
  codecContext->gop_size      = 12; 
  
  codecContext->pix_fmt       = AV_PIX_FMT_YUV420P;
  
  AVDictionary *opt = NULL;
  
  av_dict_copy(&opt, opt_arg, 0);
  
  ret = avcodec_open2(codecContext, codec, &opt);
  
  av_dict_free(&opt);
  
  myOutputStream->frame = alloc_picture(codecContext->pix_fmt, codecContext->width, codecContext->height);
  
    myOutputStream->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, codecContext->width, codecContext->height);
  
  
  
  //before: printing g_outputContext->stream time_base here
  
  ret = avformat_write_header(g_outputContext, &opt);
  
  //after: printing g_outputContext->stream time_base here

  If I run ffmpeg -i on the final video, I got this (why duration is zero ?) :

  Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'test4.mp4':
  
    Metadata:
  
      major_brand     : isom
  
      minor_version   : 512
  
      compatible_brands: isomiso2mp41
  
      encoder         : Lavf55.19.104
  
    Duration: 00:00:00.05, start: 0.000000, bitrate: 99549 kb/s
  
      Stream #0:0(und): Video: mpeg4 (Simple Profile) (mp4v / 0x7634706D), yuv420p, 800x600 [SAR 1:1 DAR 4:3], 463106 kb/s, 12800 fps, 12800 tbr, 12800 tbn, 25 tbc (default)
  
      Metadata:
  
        handler_name    : VideoHandler