Recherche avancée

Médias (0)

Mot : - Tags -/signalement

Aucun média correspondant à vos critères n’est disponible sur le site.

Autres articles (34)

  • La file d’attente de SPIPmotion

    28 novembre 2010, par

    Une file d’attente stockée dans la base de donnée
    Lors de son installation, SPIPmotion crée une nouvelle table dans la base de donnée intitulée spip_spipmotion_attentes.
    Cette nouvelle table est constituée des champs suivants : id_spipmotion_attente, l’identifiant numérique unique de la tâche à traiter ; id_document, l’identifiant numérique du document original à encoder ; id_objet l’identifiant unique de l’objet auquel le document encodé devra être attaché automatiquement ; objet, le type d’objet auquel (...)

  • Contribute to documentation

    13 avril 2011

    Documentation is vital to the development of improved technical capabilities.
    MediaSPIP welcomes documentation by users as well as developers - including : critique of existing features and functions articles contributed by developers, administrators, content producers and editors screenshots to illustrate the above translations of existing documentation into other languages
    To contribute, register to the project users’ mailing (...)

  • Selection of projects using MediaSPIP

    2 mai 2011, par

    The examples below are representative elements of MediaSPIP specific uses for specific projects.
    MediaSPIP farm @ Infini
    The non profit organizationInfini develops hospitality activities, internet access point, training, realizing innovative projects in the field of information and communication technologies and Communication, and hosting of websites. It plays a unique and prominent role in the Brest (France) area, at the national level, among the half-dozen such association. Its members (...)

Sur d’autres sites (5787)

  • building a voice recorder using html5 and javascript

    16 juillet 2014, par lama

    I want to build a voice recorder using HTML5 same as one found in gitHub JSSoundecorder, but what I want is for the user to be able to choose the file format before recording the voice.I can do this using ffmpeg. In other words the user must be able to select the audio format by check box (mp3,wma,pcm) and in the background code, the .wav file usually created by the program instead of displaying it, it should be converted by the format selected then displayed in the new format.this is the ffmpeg code we can use ,but I don’t know how to get the .wav audio file to convert it and show it.please if someone have ideas,or if can find demos I have been looking for weeks.this is the ffmpeg code :

       var fileName;
    
   var fileBuffer;
    

    
   function timeToSeconds(time) {
    
      var parts = time.split(":");
    
      return parseFloat(parts[0]) * 60 * 60 + parseFloat(parts[1]) * 60 + parseFloat(parts[2]) + parseFloat("0." + parts[3]);
    
  }
    

    
  // create ffmpeg worker
    
  function getFFMPEGWorker() {
    
      // regexps for extracting time from ffmpeg logs
    
      var durationRegexp = /Duration: (.*?), /
    
      var timeRegexp = /time=(.*?) /;
    
      var duration;
    

    
      var ffmpegWorker = new Worker('worker.js');
    
      var durationLine;
    
      ffmpegWorker.addEventListener('message', function(event) {
    
          var message = event.data;
    
          console.log(message.type);
    
          if (message.type === "ready" && window.File && window.FileList && window.FileReader) {
    
              // script loaded, hide loader
    
              $('#loading').hide();
    
          } else if (message.type == "stdout") {
    
              console.log(message.data);
    
          } else if (message.type == "stderr") {
    
              console.log(message.data);
    
              // try to extract duration
    
              if (durationRegexp.exec(message.data)) {
    
                  duration = timeToSeconds(durationRegexp.exec(message.data)[1]);
    
              }
    
              // try to extract time
    
              if (timeRegexp.exec(message.data)) {
    
                  var time = timeToSeconds(timeRegexp.exec(message.data)[1]);
    
                  if (duration) {
    
                      $("#progress").text("Progress: " + Math.floor(time / duration * 100) + "%");
    
                      $("#progress").show();
    
                  }
    
              }
    
          } else if (message.type == "done") {
    
              var code = message.data.code;
    

    
             console.log(message.data);
    
              var outFileNames = Object.keys(message.data.outputFiles);
    

    
              console.log(outFileNames);
    
              if (code == 0 && outFileNames.length) {
    
                  var outFileName = outFileNames[0];
    

    
                  var outFileBuffer = message.data.outputFiles[outFileName];
    

    
                  var src = window.URL.createObjectURL(new Blob([outFileBuffer]));
    

    
                  $("#downloadLink").attr('href', src);
    
                  $("#download").show();
    
              } else {
    
                  $("#error").show();
    
              }
    
              $("#converting").hide();
    
              $("#progress").hide();
    
          }
    
      }, false);
    
      return ffmpegWorker;
    
   }
    

    
   // create ffmpeg worker
    
   var ffmpegWorker = getFFMPEGWorker();
    
   var ffmpegRunning = false;
    

    
   $('#convert').click(function() {
    
      // terminate existing worker
    
      if (ffmpegRunning) {
    
          ffmpegWorker.terminate();
    
          ffmpegWorker = getFFMPEGWorker();
    
      }
    
      ffmpegRunning = true;
    

    
      // display converting animation
    
      $("#converting").show();
    
      $("#error").hide();
    

    
      // hide download div
    
      $("#download").hide();
    

    
      // change download file name
    
      var fileNameExt = fileName.substr(fileName.lastIndexOf('.') + 1);
    

    
      var outFileName = fileName.substr(0, fileName.lastIndexOf('.')) + "." + getOutFormat();
    

    
        $("#downloadLink").attr("download", outFileName);
    
      $("#downloadLink").text(outFileName);
    

    
      var arguments = [];
    
      arguments.push("-i");
    
      arguments.push(fileName);
    

    
      arguments.push("-b:a");
    
      arguments.push(getBitrate());
    

    
      switch (getOutFormat()) {
    
          case "mp3":
    
              arguments.push("-acodec");
    
              arguments.push("libmp3lame");
    
              arguments.push("out.mp3");
    
              break;
    

    
          case "wma":
    
              arguments.push("-acodec");
    
              arguments.push("wmav1");
    
              arguments.push("out.asf");
    
              break;
    

    
          case "pcm":
    
              arguments.push("-f");
    
              arguments.push("s16le");
    
              arguments.push("-acodec");
    
              arguments.push("pcm_s16le");
    
              arguments.push("out.pcm");
    
      }
    

    
      ffmpegWorker.postMessage({
    

    
          type: "command",
    
          arguments: arguments,
    
          files: [
    
              {
    
                  "name": fileName,
    
                  "buffer": fileBuffer
    
              }
    
          ]
    

    
      });
    
  });
    

    
  function getOutFormat() {
    
      return $('input[name=format]:checked').val();
    
  }
    

    
  function getBitrate() {
    
      return $('input[name=bitrate]:checked').val();
    
  }
    

    
  // disable conversion at start
    
  $('#convert').attr('disabled', 'true');
    

    
  function readInputFile(file) {
    
      // disable conversion for the time of file loading
    
      $('#convert').attr('disabled', 'true');
    

    
      // load file content
    
      var reader = new FileReader();
    
      reader.onload = function(e) {
    
          $('#convert').removeAttr('disabled');
    
          fileName = file.name;
    
        console.log(fileName);
    
          fileBuffer = e.target.result;
    
      }
    
      reader.readAsArrayBuffer(file);
    

    
  }
    

    
  // reset file selector at start
    
  function resetInputFile() {
    
      $("#inFile").wrap('<form>').closest('form').get(0).reset();
    
      $("#inFile").unwrap();
    
  }
    
  resetInputFile();
    

    
  function handleFileSelect(event) {
    
      var files = event.target.files; // FileList object
    
  console.log(files);
    
      // files is a FileList of File objects. display first file name
    
      file = files[0];
    
      console.log(file);
    
      if (file) {
    
          $("#drop").text("Drop file here");
    
          readInputFile(file);
    

    

    
      }
    
  }
    

    

    
  // setup input file listeners
    

    
  document.getElementById('inFile').addEventListener('change', handleFileSelect, false);
    
</form>

  • increasing memory occupancy while recording screen save to disk with ffmpeg [on hold]

    19 mai 2016, par vbtang

    wonder if there are any resoures i didn’t free ?or do i need to do something special so that i can free these momery ?

    ps. run the demo step by step, and found it has the same problem, until it quit the main function, it still have 40MB memory occupancy. And i found the memory increase obviously in the screen capture thread,but when it increased to about 150MB, it won’t increase, until i quit the program, it will have 40MB memory left. i feel confused.

    pss. i download ffmpeg dev and shared version form here https://ffmpeg.zeranoe.com/builds/,it seems a dll of debug version ? do i need a release version ?
    here is my demo code.

        #include "stdafx.h"
    

    
#ifdef  __cplusplus
    
extern "C"
    
{
    
#endif
    
#include "libavcodec/avcodec.h"
    
#include "libavformat/avformat.h"
    
#include "libswscale/swscale.h"
    
#include "libavdevice/avdevice.h"
    
#include "libavutil/audio_fifo.h"
    

    
#pragma comment(lib, "avcodec.lib")
    
#pragma comment(lib, "avformat.lib")
    
#pragma comment(lib, "avutil.lib")
    
#pragma comment(lib, "avdevice.lib")
    
#pragma comment(lib, "avfilter.lib")
    

    
//#pragma comment(lib, "avfilter.lib")
    
//#pragma comment(lib, "postproc.lib")
    
//#pragma comment(lib, "swresample.lib")
    
#pragma comment(lib, "swscale.lib")
    
#ifdef __cplusplus
    
};
    
#endif
    

    
AVFormatContext *pFormatCtx_Video = NULL, *pFormatCtx_Audio = NULL, *pFormatCtx_Out = NULL;
    
AVCodecContext  *pCodecCtx_Video;
    
AVCodec         *pCodec_Video;
    
AVFifoBuffer    *fifo_video = NULL;
    
AVAudioFifo     *fifo_audio = NULL;
    
int VideoIndex, AudioIndex;
    

    
CRITICAL_SECTION AudioSection, VideoSection;
    

    

    

    
SwsContext *img_convert_ctx;
    
int frame_size = 0;
    

    
uint8_t *picture_buf = NULL, *frame_buf = NULL;
    

    
bool bCap = true;
    

    
DWORD WINAPI ScreenCapThreadProc( LPVOID lpParam );
    
DWORD WINAPI AudioCapThreadProc( LPVOID lpParam );
    

    
int OpenVideoCapture()
    
{
    
    AVInputFormat *ifmt=av_find_input_format("gdigrab");
    
    //
    
    AVDictionary *options = NULL;
    
    av_dict_set(&amp;options, "framerate", "15", NULL);
    
    //av_dict_set(&amp;options,"offset_x","20",0);
    
    //The distance from the top edge of the screen or desktop
    
    //av_dict_set(&amp;options,"offset_y","40",0);
    
    //Video frame size. The default is to capture the full screen
    
    //av_dict_set(&amp;options,"video_size","320x240",0);
    
    if(avformat_open_input(&amp;pFormatCtx_Video, "desktop", ifmt, &amp;options)!=0)
    
    {
    
        printf("Couldn't open input stream.（无法打开视频输入流）\n");
    
        return -1;
    
    }
    
    if(avformat_find_stream_info(pFormatCtx_Video,NULL)&lt;0)
    
    {
    
        printf("Couldn't find stream information.（无法获取视频流信息）\n");
    
        return -1;
    
    }
    
    if (pFormatCtx_Video->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO)
    
    {
    
        printf("Couldn't find video stream information.（无法获取视频流信息）\n");
    
        return -1;
    
    }
    
    pCodecCtx_Video = pFormatCtx_Video->streams[0]->codec;
    
    pCodec_Video = avcodec_find_decoder(pCodecCtx_Video->codec_id);
    
    if(pCodec_Video == NULL)
    
    {
    
        printf("Codec not found.（没有找到解码器）\n");
    
        return -1;
    
    }
    
    if(avcodec_open2(pCodecCtx_Video, pCodec_Video, NULL) &lt; 0)
    
    {
    
        printf("Could not open codec.（无法打开解码器）\n");
    
        return -1;
    
    }
    

    

    

    
    img_convert_ctx = sws_getContext(pCodecCtx_Video->width, pCodecCtx_Video->height, pCodecCtx_Video->pix_fmt, 
    
        pCodecCtx_Video->width, pCodecCtx_Video->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL); 
    

    
    frame_size = avpicture_get_size(pCodecCtx_Video->pix_fmt, pCodecCtx_Video->width, pCodecCtx_Video->height);
    
    //
    
    fifo_video = av_fifo_alloc(30 * avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height));
    

    
    return 0;
    
}
    

    
static char *dup_wchar_to_utf8(wchar_t *w)
    
{
    
    char *s = NULL;
    
    int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
    
    s = (char *) av_malloc(l);
    
    if (s)
    
        WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
    
    return s;
    
}
    

    
int OpenAudioCapture()
    
{
    
    //
    
    AVInputFormat *pAudioInputFmt = av_find_input_format("dshow");
    

    
    //
    
    char * psDevName = dup_wchar_to_utf8(L"audio=virtual-audio-capturer");
    

    
    if (avformat_open_input(&amp;pFormatCtx_Audio, psDevName, pAudioInputFmt,NULL) &lt; 0)
    
    {
    
        printf("Couldn't open input stream.（无法打开音频输入流）\n");
    
        return -1;
    
    }
    

    
    if(avformat_find_stream_info(pFormatCtx_Audio,NULL)&lt;0)  
    
        return -1; 
    

    
    if(pFormatCtx_Audio->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
    
    {
    
        printf("Couldn't find video stream information.（无法获取音频流信息）\n");
    
        return -1;
    
    }
    

    
    AVCodec *tmpCodec = avcodec_find_decoder(pFormatCtx_Audio->streams[0]->codec->codec_id);
    
    if(0 > avcodec_open2(pFormatCtx_Audio->streams[0]->codec, tmpCodec, NULL))
    
    {
    
        printf("can not find or open audio decoder!\n");
    
    }
    

    

    

    
    return 0;
    
}
    

    
int OpenOutPut()
    
{
    
    AVStream *pVideoStream = NULL, *pAudioStream = NULL;
    
    const char *outFileName = "test.mp4";
    
    avformat_alloc_output_context2(&amp;pFormatCtx_Out, NULL, NULL, outFileName);
    

    
    if (pFormatCtx_Video->streams[0]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
    
    {
    
        VideoIndex = 0;
    
        pVideoStream = avformat_new_stream(pFormatCtx_Out, NULL);
    

    
        if (!pVideoStream)
    
        {
    
            printf("can not new stream for output!\n");
    
            return -1;
    
        }
    

    
        //set codec context param
    
        pVideoStream->codec->codec = avcodec_find_encoder(AV_CODEC_ID_MPEG4);
    
        pVideoStream->codec->height = pFormatCtx_Video->streams[0]->codec->height;
    
        pVideoStream->codec->width = pFormatCtx_Video->streams[0]->codec->width;
    

    
        pVideoStream->codec->time_base = pFormatCtx_Video->streams[0]->codec->time_base;
    
        pVideoStream->codec->sample_aspect_ratio = pFormatCtx_Video->streams[0]->codec->sample_aspect_ratio;
    
        // take first format from list of supported formats
    
        pVideoStream->codec->pix_fmt = pFormatCtx_Out->streams[VideoIndex]->codec->codec->pix_fmts[0];
    

    
        //open encoder
    
        if (!pVideoStream->codec->codec)
    
        {
    
            printf("can not find the encoder!\n");
    
            return -1;
    
        }
    

    
        if (pFormatCtx_Out->oformat->flags &amp; AVFMT_GLOBALHEADER)
    
            pVideoStream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
    

    
        if ((avcodec_open2(pVideoStream->codec, pVideoStream->codec->codec, NULL)) &lt; 0)
    
        {
    
            printf("can not open the encoder\n");
    
            return -1;
    
        }
    
    }
    

    
    if(pFormatCtx_Audio->streams[0]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
    
    {
    
        AVCodecContext *pOutputCodecCtx;
    
        AudioIndex = 1;
    
        pAudioStream = avformat_new_stream(pFormatCtx_Out, NULL);
    

    
        pAudioStream->codec->codec = avcodec_find_encoder(pFormatCtx_Out->oformat->audio_codec);
    

    
        pOutputCodecCtx = pAudioStream->codec;
    

    
        pOutputCodecCtx->sample_rate = pFormatCtx_Audio->streams[0]->codec->sample_rate;
    
        pOutputCodecCtx->channel_layout = pFormatCtx_Out->streams[0]->codec->channel_layout;
    
        pOutputCodecCtx->channels = av_get_channel_layout_nb_channels(pAudioStream->codec->channel_layout);
    
        if(pOutputCodecCtx->channel_layout == 0)
    
        {
    
            pOutputCodecCtx->channel_layout = AV_CH_LAYOUT_STEREO;
    
            pOutputCodecCtx->channels = av_get_channel_layout_nb_channels(pOutputCodecCtx->channel_layout);
    

    
        }
    
        pOutputCodecCtx->sample_fmt = pAudioStream->codec->codec->sample_fmts[0];
    
        AVRational time_base={1, pAudioStream->codec->sample_rate};
    
        pAudioStream->time_base = time_base;
    
        //audioCodecCtx->time_base = time_base;
    

    
        pOutputCodecCtx->codec_tag = 0;  
    
        if (pFormatCtx_Out->oformat->flags &amp; AVFMT_GLOBALHEADER)  
    
            pOutputCodecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER;
    

    
        if (avcodec_open2(pOutputCodecCtx, pOutputCodecCtx->codec, 0) &lt; 0)
    
        {
    
            //
    
            return -1;
    
        }
    
    }
    

    
    if (!(pFormatCtx_Out->oformat->flags &amp; AVFMT_NOFILE))
    
    {
    
        if(avio_open(&amp;pFormatCtx_Out->pb, outFileName, AVIO_FLAG_WRITE) &lt; 0)
    
        {
    
            printf("can not open output file handle!\n");
    
            return -1;
    
        }
    
    }
    

    
    if(avformat_write_header(pFormatCtx_Out, NULL) &lt; 0)
    
    {
    
        printf("can not write the header of the output file!\n");
    
        return -1;
    
    }
    

    
    return 0;
    
}
    

    
int _tmain(int argc, _TCHAR* argv[])
    
{
    
    av_register_all();
    
    avdevice_register_all();
    
    if (OpenVideoCapture() &lt; 0)
    
    {
    
        return -1;
    
    }
    
    if (OpenAudioCapture() &lt; 0)
    
    {
    
        return -1;
    
    }
    
    if (OpenOutPut() &lt; 0)
    
    {
    
        return -1;
    
    }
    

    
    InitializeCriticalSection(&amp;VideoSection);
    
    InitializeCriticalSection(&amp;AudioSection);
    

    
    AVFrame *picture = av_frame_alloc();
    
    int size = avpicture_get_size(pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->width, pFormatCtx_Out->streams[VideoIndex]->codec->height);
    
    picture_buf = new uint8_t[size];
    

    
    avpicture_fill((AVPicture *)picture, picture_buf, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->width, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->height);
    

    

    

    
    //star cap screen thread
    
    CreateThread( NULL, 0, ScreenCapThreadProc, 0, 0, NULL);
    
    //star cap audio thread
    
    CreateThread( NULL, 0, AudioCapThreadProc, 0, 0, NULL);
    
    int64_t cur_pts_v=0,cur_pts_a=0;
    
    int VideoFrameIndex = 0, AudioFrameIndex = 0;
    

    
    while(1)
    
    {
    
        if (_kbhit() != 0 &amp;&amp; bCap)
    
        {
    
            bCap = false;
    
            Sleep(2000);//
    
        }
    
        if (fifo_audio &amp;&amp; fifo_video)
    
        {
    
            int sizeAudio = av_audio_fifo_size(fifo_audio);
    
            int sizeVideo = av_fifo_size(fifo_video);
    
            //
    
            if (av_audio_fifo_size(fifo_audio) &lt;= pFormatCtx_Out->streams[AudioIndex]->codec->frame_size &amp;&amp; 
    
                av_fifo_size(fifo_video) &lt;= frame_size &amp;&amp; !bCap)
    
            {
    
                break;
    
            }
    
        }
    

    
        if(av_compare_ts(cur_pts_v, pFormatCtx_Out->streams[VideoIndex]->time_base, 
    
            cur_pts_a,pFormatCtx_Out->streams[AudioIndex]->time_base) &lt;= 0)
    
        {
    
            //read data from fifo
    
            if (av_fifo_size(fifo_video) &lt; frame_size &amp;&amp; !bCap)
    
            {
    
                cur_pts_v = 0x7fffffffffffffff;
    
            }
    
            if(av_fifo_size(fifo_video) >= size)
    
            {
    
                EnterCriticalSection(&amp;VideoSection);
    
                av_fifo_generic_read(fifo_video, picture_buf, size, NULL);
    
                LeaveCriticalSection(&amp;VideoSection);
    

    
                avpicture_fill((AVPicture *)picture, picture_buf, 
    
                    pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt, 
    
                    pFormatCtx_Out->streams[VideoIndex]->codec->width, 
    
                    pFormatCtx_Out->streams[VideoIndex]->codec->height);
    

    
                //pts = n * (（1 / timbase）/ fps);
    
                picture->pts = VideoFrameIndex * ((pFormatCtx_Video->streams[0]->time_base.den / pFormatCtx_Video->streams[0]->time_base.num) / 15);
    

    
                int got_picture = 0;
    
                AVPacket pkt;
    
                av_init_packet(&amp;pkt);
    

    
                pkt.data = NULL;
    
                pkt.size = 0;
    
                int ret = avcodec_encode_video2(pFormatCtx_Out->streams[VideoIndex]->codec, &amp;pkt, picture, &amp;got_picture);
    
                if(ret &lt; 0)
    
                {
    
                    //
    
                    continue;
    
                }
    

    
                if (got_picture==1)
    
                {
    
                    pkt.stream_index = VideoIndex;
    
                    pkt.pts = av_rescale_q_rnd(pkt.pts, pFormatCtx_Video->streams[0]->time_base, 
    
                        pFormatCtx_Out->streams[VideoIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    
                    pkt.dts = av_rescale_q_rnd(pkt.dts,  pFormatCtx_Video->streams[0]->time_base, 
    
                        pFormatCtx_Out->streams[VideoIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    

    
                    pkt.duration = ((pFormatCtx_Out->streams[0]->time_base.den / pFormatCtx_Out->streams[0]->time_base.num) / 15);
    

    
                    cur_pts_v = pkt.pts;
    

    
                    ret = av_interleaved_write_frame(pFormatCtx_Out, &amp;pkt);
    
                    //delete[] pkt.data;
    
                    av_free_packet(&amp;pkt);
    
                }
    
                VideoFrameIndex++;
    
            }
    
        }
    
        else
    
        {
    
            if (NULL == fifo_audio)
    
            {
    
                continue;//
    
            }
    
            if (av_audio_fifo_size(fifo_audio) &lt; pFormatCtx_Out->streams[AudioIndex]->codec->frame_size &amp;&amp; !bCap)
    
            {
    
                cur_pts_a = 0x7fffffffffffffff;
    
            }
    
            if(av_audio_fifo_size(fifo_audio) >= 
    
                (pFormatCtx_Out->streams[AudioIndex]->codec->frame_size > 0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size : 1024))
    
            {
    
                AVFrame *frame;
    
                frame = av_frame_alloc();
    
                frame->nb_samples = pFormatCtx_Out->streams[AudioIndex]->codec->frame_size>0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size: 1024;
    
                frame->channel_layout = pFormatCtx_Out->streams[AudioIndex]->codec->channel_layout;
    
                frame->format = pFormatCtx_Out->streams[AudioIndex]->codec->sample_fmt;
    
                frame->sample_rate = pFormatCtx_Out->streams[AudioIndex]->codec->sample_rate;
    
                av_frame_get_buffer(frame, 0);
    

    
                EnterCriticalSection(&amp;AudioSection);
    
                av_audio_fifo_read(fifo_audio, (void **)frame->data, 
    
                    (pFormatCtx_Out->streams[AudioIndex]->codec->frame_size > 0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size : 1024));
    
                LeaveCriticalSection(&amp;AudioSection);
    

    
                if (pFormatCtx_Out->streams[0]->codec->sample_fmt != pFormatCtx_Audio->streams[AudioIndex]->codec->sample_fmt 
    
                    || pFormatCtx_Out->streams[0]->codec->channels != pFormatCtx_Audio->streams[AudioIndex]->codec->channels 
    
                    || pFormatCtx_Out->streams[0]->codec->sample_rate != pFormatCtx_Audio->streams[AudioIndex]->codec->sample_rate)
    
                {
    
                    //
    
                }
    

    
                AVPacket pkt_out;
    
                av_init_packet(&amp;pkt_out);
    
                int got_picture = -1;
    
                pkt_out.data = NULL;
    
                pkt_out.size = 0;
    

    
                frame->pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;
    
                if (avcodec_encode_audio2(pFormatCtx_Out->streams[AudioIndex]->codec, &amp;pkt_out, frame, &amp;got_picture) &lt; 0)
    
                {
    
                    printf("can not decoder a frame");
    
                }
    
                av_frame_free(&amp;frame);
    
                if (got_picture) 
    
                {
    
                    pkt_out.stream_index = AudioIndex;
    
                    pkt_out.pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;
    
                    pkt_out.dts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;
    
                    pkt_out.duration = pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;
    

    
                    cur_pts_a = pkt_out.pts;
    

    
                    int ret = av_interleaved_write_frame(pFormatCtx_Out, &amp;pkt_out);
    
                    av_free_packet(&amp;pkt_out);
    
                }
    
                AudioFrameIndex++;
    
            }
    
        }
    
    }
    

    
    delete[] picture_buf;
    

    
    delete[]frame_buf;
    
    av_fifo_free(fifo_video);
    
    av_audio_fifo_free(fifo_audio);
    

    
    av_write_trailer(pFormatCtx_Out);
    

    
    avio_close(pFormatCtx_Out->pb);
    
    avformat_free_context(pFormatCtx_Out);
    

    
    if (pFormatCtx_Video != NULL)
    
    {
    
        avformat_close_input(&amp;pFormatCtx_Video);
    
        pFormatCtx_Video = NULL;
    
    }
    
    if (pFormatCtx_Audio != NULL)
    
    {
    
        avformat_close_input(&amp;pFormatCtx_Audio);
    
        pFormatCtx_Audio = NULL;
    
    }
    
    if (NULL != img_convert_ctx)
    
    {
    
        sws_freeContext(img_convert_ctx);
    
        img_convert_ctx = NULL;
    
    }
    

    
    return 0;
    
}
    

    
DWORD WINAPI ScreenCapThreadProc( LPVOID lpParam )
    
{
    
    AVPacket packet;/* = (AVPacket *)av_malloc(sizeof(AVPacket))*/;
    
    int got_picture;
    
    AVFrame *pFrame;
    
    pFrame= av_frame_alloc();
    

    
    AVFrame *picture = av_frame_alloc();
    
    int size = avpicture_get_size(pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->width, pFormatCtx_Out->streams[VideoIndex]->codec->height);
    
    //picture_buf = new uint8_t[size];
    

    
    avpicture_fill((AVPicture *)picture, picture_buf, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->width, 
    
        pFormatCtx_Out->streams[VideoIndex]->codec->height);
    

    
//  FILE *p = NULL;
    
//  p = fopen("proc_test.yuv", "wb+");
    
    av_init_packet(&amp;packet);
    
    int height = pFormatCtx_Out->streams[VideoIndex]->codec->height;
    
    int width = pFormatCtx_Out->streams[VideoIndex]->codec->width;
    
    int y_size=height*width;
    
    while(bCap)
    
    {
    
        packet.data = NULL;
    
        packet.size = 0;
    
        if (av_read_frame(pFormatCtx_Video, &amp;packet) &lt; 0)
    
        {
    
            av_free_packet(&amp;packet);
    
            continue;
    
        }
    
        if(packet.stream_index == 0)
    
        {
    
            if (avcodec_decode_video2(pCodecCtx_Video, pFrame, &amp;got_picture, &amp;packet) &lt; 0)
    
            {
    
                printf("Decode Error.（解码错误）\n");
    
                continue;
    
            }
    
            if (got_picture)
    
            {
    
                sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, 
    
                    pFormatCtx_Out->streams[VideoIndex]->codec->height, picture->data, picture->linesize);
    

    
                if (av_fifo_space(fifo_video) >= size)
    
                {
    
                    EnterCriticalSection(&amp;VideoSection);                    
    
                    av_fifo_generic_write(fifo_video, picture->data[0], y_size, NULL);
    
                    av_fifo_generic_write(fifo_video, picture->data[1], y_size/4, NULL);
    
                    av_fifo_generic_write(fifo_video, picture->data[2], y_size/4, NULL);
    
                    LeaveCriticalSection(&amp;VideoSection);
    
                }
    
            }
    
        }
    
        av_free_packet(&amp;packet);
    
        //Sleep(50);
    
    }
    
    av_frame_free(&amp;pFrame);
    
    av_frame_free(&amp;picture);
    
    //delete[] picture_buf;
    
    return 0;
    
}
    

    
DWORD WINAPI AudioCapThreadProc( LPVOID lpParam )
    
{
    
    AVPacket pkt;
    
    AVFrame *frame;
    
    frame = av_frame_alloc();
    
    int gotframe;
    
    while(bCap)
    
    {
    
        pkt.data = NULL;
    
        pkt.size = 0;
    
        if(av_read_frame(pFormatCtx_Audio,&amp;pkt) &lt; 0)
    
        {
    
            av_free_packet(&amp;pkt);
    
            continue;
    
        }
    

    
        if (avcodec_decode_audio4(pFormatCtx_Audio->streams[0]->codec, frame, &amp;gotframe, &amp;pkt) &lt; 0)
    
        {
    
            av_frame_free(&amp;frame);
    
            printf("can not decoder a frame");
    
            break;
    
        }
    
        av_free_packet(&amp;pkt);
    

    
        if (!gotframe)
    
        {
    
            continue;//
    
        }
    

    
        if (NULL == fifo_audio)
    
        {
    
            fifo_audio = av_audio_fifo_alloc(pFormatCtx_Audio->streams[0]->codec->sample_fmt, 
    
                pFormatCtx_Audio->streams[0]->codec->channels, 30 * frame->nb_samples);
    
        }
    

    
        int buf_space = av_audio_fifo_space(fifo_audio);
    
        if (av_audio_fifo_space(fifo_audio) >= frame->nb_samples)
    
        {
    
            EnterCriticalSection(&amp;AudioSection);
    
            av_audio_fifo_write(fifo_audio, (void **)frame->data, frame->nb_samples);
    
            LeaveCriticalSection(&amp;AudioSection);
    
        }
    
    }
    
    av_frame_free(&amp;frame);
    
    return 0;
    
}

  • FFMPEG Android library

    23 mai 2016, par Phani varma

    I want to combine image and audio to form a video file using FFMPEG.
    Without using NDK is there any way to create a Android project for FFMPEG.
    Please provide any Libraries and Any sample Projects it will helpful for me.

    Thanks in advance.

Navigation