Recherche avancée

Sur d’autres sites (5297)

• Qt Video Recorder

  11 mai 2014, par Davlog

  I am trying to create a video recorder with Qt. What I did so far was taking a screenshot of a rectangle on the screen and save it. At the end I use ffmpeg to get a video file out of the images.

  I connected a timer’s signal timeout() to my custom slot which takes the snapshot and saves it to my tmp folder. The timer has an intervall of 1000 / 30. That should be 30 times per second. But 1000 / 30 is a little bit more than 33 milliseconds so I cannot really get 30 fps. It’s a bit more.

  I recorded a youtube video with my recorder and everything was smooth but a little bit faster / slower depending on the intervall.

  So my question basically is how do I get really 30 / 40 / 50 / ... fps ?

• how to convert an MPEGTS file into an FLV file by programming with libavcodec

  9 mai 2014, par Hexing B

  I wanna convert an MPEGTS file into an FLV file with libavcodec APIs(just transformat, video/audio codecs are not changed). Following is the code I found on web. After some hack, it can generate an FLV file, which could not be played. Any clue to fix this ?

  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavutil></libavutil>avutil.h>
  
  #include <libavutil></libavutil>rational.h>
  
  #include <libavdevice></libavdevice>avdevice.h>
  
  #include <libavutil></libavutil>mathematics.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  static AVStream* add_output_stream(AVFormatContext* output_format_context, AVStream* input_stream) {
  
      AVCodecContext* input_codec_context = NULL;
  
      AVCodecContext* output_codec_context = NULL;
  
  
  
      AVStream* output_stream = NULL;
  
      output_stream = avformat_new_stream(output_format_context, 0);
  
      if (!output_stream) {
  
          printf("Call av_new_stream function failed\n");
  
          return NULL;
  
      }
  
  
  
      input_codec_context = input_stream->codec;
  
      output_codec_context = output_stream->codec;
  
  
  
      output_codec_context->codec_id = input_codec_context->codec_id;
  
      output_codec_context->codec_type = input_codec_context->codec_type;
  
      // output_codec_context->codec_tag = input_codec_context->codec_tag;
  
      output_codec_context->codec_tag = av_codec_get_tag(output_format_context->oformat->codec_tag, input_codec_context->codec_id);
  
      output_codec_context->bit_rate = input_codec_context->bit_rate;
  
      output_codec_context->extradata = input_codec_context->extradata;
  
      output_codec_context->extradata_size = input_codec_context->extradata_size;
  
  
  
      if (av_q2d(input_codec_context->time_base) * input_codec_context->ticks_per_frame > av_q2d(input_stream->time_base) &amp;&amp; av_q2d(input_stream->time_base) &lt; 1.0 / 1000) {
  
          output_codec_context->time_base = input_codec_context->time_base;
  
          output_codec_context->time_base.num *= input_codec_context->ticks_per_frame;
  
      } else {
  
          output_codec_context->time_base = input_stream->time_base;
  
      }
  
      switch (input_codec_context->codec_type) {
  
      case AVMEDIA_TYPE_AUDIO:
  
          output_codec_context->channel_layout = input_codec_context->channel_layout;
  
          output_codec_context->sample_rate = input_codec_context->sample_rate;
  
          output_codec_context->channels = input_codec_context->channels;
  
          output_codec_context->frame_size = input_codec_context->frame_size;
  
          if ((input_codec_context->block_align == 1 &amp;&amp; input_codec_context->codec_id == CODEC_ID_MP3) || input_codec_context->codec_id == CODEC_ID_AC3) {
  
              output_codec_context->block_align = 0;
  
          } else {
  
              output_codec_context->block_align = input_codec_context->block_align;
  
          }
  
          break;
  
      case AVMEDIA_TYPE_VIDEO:
  
          output_codec_context->pix_fmt = input_codec_context->pix_fmt;
  
          output_codec_context->width = input_codec_context->width;
  
          output_codec_context->height = input_codec_context->height;
  
          output_codec_context->has_b_frames = input_codec_context->has_b_frames;
  
          if (output_format_context->oformat->flags &amp; AVFMT_GLOBALHEADER) {
  
              output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
          }
  
          // output_codec_context->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
  
          break;
  
      default:
  
          break;
  
      }
  
  
  
      return output_stream;
  
  }
  
  
  
  int main(int argc, char* argv[]) {
  
      const char* input = argv[1];
  
      const char* output_prefix = NULL;
  
      char* segment_duration_check = 0;
  
      const char* index = NULL;
  
      char* tmp_index = NULL;
  
      const char* http_prefix = NULL;
  
      long max_tsfiles = 0;
  
      double prev_segment_time = 0;
  
      double segment_duration = 0;
  
  
  
      AVInputFormat* ifmt = NULL;
  
      AVOutputFormat* ofmt = NULL;
  
      AVFormatContext* ic = NULL;
  
      AVFormatContext* oc = NULL;
  
      AVStream* video_st = NULL;
  
      AVStream* audio_st = NULL;
  
      AVCodec* codec = NULL;
  
      AVDictionary* pAVDictionary = NULL;
  
  
  
      av_register_all();
  
      av_log_set_level(AV_LOG_DEBUG);
  
  
  
      char szError[256] = {0};
  
      int nRet = avformat_open_input(&amp;ic, input, ifmt, &amp;pAVDictionary);
  
      if (nRet != 0) {
  
          av_strerror(nRet, szError, 256);
  
          printf(szError);
  
          printf("\n");
  
          printf("Call avformat_open_input function failed!\n");
  
          return 0;
  
      }
  
  
  
      if (avformat_find_stream_info(ic, NULL) &lt; 0) {
  
          printf("Call av_find_stream_info function failed!\n");
  
          return 0;
  
      }
  
  
  
      ofmt = av_guess_format(NULL, argv[2], NULL);
  
      if (!ofmt) {
  
          printf("Call av_guess_format function failed!\n");
  
          return 0;
  
      }
  
  
  
      oc = avformat_alloc_context();
  
      if (!oc) {
  
          printf("Call av_guess_format function failed!\n");
  
          return 0;
  
      }
  
      oc->oformat = ofmt;
  
  
  
      int video_index = -1, audio_index = -1;
  
      unsigned int i;
  
      for (i = 0; i &lt; ic->nb_streams &amp;&amp; (video_index &lt; 0 || audio_index &lt; 0); i++) {
  
          switch (ic->streams[i]->codec->codec_type) {
  
          case AVMEDIA_TYPE_VIDEO:
  
              video_index = i;
  
              ic->streams[i]->discard = AVDISCARD_NONE;
  
              video_st = add_output_stream(oc, ic->streams[i]);
  
              if (video_st->codec->codec_id == CODEC_ID_H264) {
  
                  video_st->codec->opaque = av_bitstream_filter_init("h264_mp4toannexb");
  
              }
  
              break;
  
          case AVMEDIA_TYPE_AUDIO:
  
              audio_index = i;
  
              ic->streams[i]->discard = AVDISCARD_NONE;
  
              audio_st = add_output_stream(oc, ic->streams[i]);
  
              if (audio_st->codec->codec_id == CODEC_ID_AAC &amp;&amp; !audio_st->codec->extradata_size) {
  
                  audio_st->codec->opaque = av_bitstream_filter_init("aac_adtstoasc");
  
              }
  
              break;
  
          default:
  
              ic->streams[i]->discard = AVDISCARD_ALL;
  
              break;
  
          }
  
      }
  
      codec = avcodec_find_decoder(video_st->codec->codec_id);
  
      if (codec == NULL) {
  
          printf("Call avcodec_find_decoder function failed!\n");
  
          return 0;
  
      }
  
  
  
      if (avcodec_open2(video_st->codec, codec, NULL) &lt; 0) {
  
          printf("Call avcodec_open function failed !\n");
  
          return 0;
  
      }
  
  
  
      if (avio_open(&amp;oc->pb, argv[2], AVIO_FLAG_WRITE) &lt; 0) {
  
          return 0;
  
      }
  
  
  
      if (avformat_write_header(oc, &amp;pAVDictionary)) {
  
          printf("Call avformat_write_header function failed.\n");
  
          return 0;
  
      }
  
  
  
      int decode_done = 0;
  
      do {
  
          AVPacket packet;
  
          decode_done = av_read_frame(ic, &amp;packet);
  
          if (decode_done &lt; 0) {
  
              break;
  
          }
  
  
  
          if (packet.stream_index == video_index &amp;&amp; (packet.flags &amp; AV_PKT_FLAG_KEY) &amp;&amp; video_st->codec->opaque != NULL) {
  
              AVPacket pkt = packet;
  
              int a = av_bitstream_filter_filter(video_st->codec->opaque, video_st->codec, NULL, &amp;pkt.data, &amp;pkt.size,
  
                      packet.data, packet.size, packet.flags &amp; AV_PKT_FLAG_KEY);
  
              if (a == 0) {
  
                  memmove(packet.data, pkt.data, pkt.size);
  
                  packet.size = pkt.size;
  
              } else if (a > 0) {
  
                  packet = pkt;
  
              }
  
          }
  
          else if (packet.stream_index == audio_index &amp;&amp; audio_st->codec->opaque != NULL) {
  
              AVPacket pkt = packet;
  
              int a = av_bitstream_filter_filter(audio_st->codec->opaque, audio_st->codec, NULL, &amp;pkt.data, &amp;pkt.size,
  
                      packet.data, packet.size, packet.flags &amp; AV_PKT_FLAG_KEY);
  
              if (a == 0) {
  
                  memmove(packet.data, pkt.data, pkt.size);
  
                  packet.size = pkt.size;
  
              } else if (a > 0) {
  
                  packet = pkt;
  
              }
  
          }
  
          nRet = av_interleaved_write_frame(oc, &amp;packet);
  
          if (nRet &lt; 0) {
  
              printf("Call av_interleaved_write_frame function failed\n");
  
          } else if (nRet > 0) {
  
              printf("End of stream requested\n");
  
              av_free_packet(&amp;packet);
  
                  break;
  
          }
  
          av_free_packet(&amp;packet);
  
      } while(!decode_done);
  
  
  
      av_write_trailer(oc);
  
  
  
      av_bitstream_filter_close(video_st->codec->opaque);  
  
      av_bitstream_filter_close(audio_st->codec->opaque);  
  
      avcodec_close(video_st->codec);
  
      unsigned int k;
  
      for(k = 0; k &lt; oc->nb_streams; k++) {
  
          av_freep(&amp;oc->streams[k]->codec);
  
          av_freep(&amp;oc->streams[k]);
  
      }
  
      av_free(oc);
  
      getchar();
  
      return 0;
  
  }

• Encoding video only FLV

  25 mars 2012, par NadavRub

  I am trying to generate a video only FLV file, I am using :

  1. libx264 + ffmpeg
  2. 30 fps ( fixed )
  3. playback is done using VLC 2.0.1 and flowplayer

  When playing the FLV the frame-rate seems 1 frame per sec, following is the way I cfg ffmpeg :

  AVOutputFormat* fmtOutput = av_oformat_next(0);
  
  while((0 != fmtOutput) && (0 != strcmp(fmtOutput->name, "flv")))
  
      fmtOutput = av_oformat_next(fmtOutput);
  
  m_pFmtCtxOutput          = avformat_alloc_context();
  
  m_pFmtCtxOutput->oformat = fmtOutput;
  
  
  
  AVStream* pOutVideoStream= av_new_stream(m_pFmtCtxOutput, pInVideoStream->id);
  
  AVCodec*  videoEncoder   = avcodec_find_encoder(CODEC_ID_H264);
  
  
  
  pOutVideoStream->codec->width    = 640;
  
  pOutVideoStream->codec->height   = 480;
  
  pOutVideoStream->codec->level    = 30;
  
  pOutVideoStream->codec->pix_fmt  = PIX_FMT_YUV420P;
  
  pOutVideoStream->codec->bit_rate = 3000000;
  
  
  
  pOutVideoStream->cur_dts         = 0;
  
  pOutVideoStream->first_dts       = 0;
  
  pOutVideoStream->index           = 0;
  
  pOutVideoStream->avg_frame_rate  = (AVRational){ 30, 1 };
  
  pOutVideoStream->time_base       =
  
  pOutVideoStream->codec->time_base= (AVRational){ 1, 30000 };
  
  pOutVideoStream->codec->gop_size = 30;
  
  %% Some specific libx264 settings %%
  
  m_dVideoStep                     = 1000;// packet dts/pts is incremented by this amount each frame
  
  
  
  pOutVideoStream->codec->flags   |= CODEC_FLAG_GLOBAL_HEADER;
  
  avcodec_open(pOutVideoStream->codec, videoEncoder);

  The resulting file seems OK, with the exception of the playback frame-rate.
  having in mind that :

  1. pOutVideoStream->avg_frame_rate = (AVRational) 30, 1  ;
  2. pOutVideoStream->time_base = (AVRational) 1, 30000  ;
  3. pOutVideoStream->codec->time_base= (AVRational) 1, 30000  ;
  4. For each frame I increment the dts/pts by 1000

  What am I doing wrong here ? why the file is playing choppy ( 1 fps ) ?

  Any help will be appreciated.

  Nadav at Sophin