Recherche avancée

Sur d’autres sites (6540)

• I want to play RTSP IP camera using ffmpeg and exoPlayer in android how to I do this

  3 juin 2023, par jcredking

  I was tyr LibVlc but I get dealy in this and can't record the stream anyone has proper solution for this please provide me

  


• Revision 5ddcbeeb7d : Adjust style to match Google Coding Style a little more closely. Most of these

  31 octobre 2012, par Ronald S. Bultje

  Changed Paths : Modify /vp8/common/onyxd.h Modify /vp8/decoder/dboolhuff.c Modify /vp8/decoder/dboolhuff.h Modify /vp8/decoder/decodframe.c Modify /vp8/decoder/dequantize.c Modify /vp8/decoder/detokenize.c Modify /vp8/decoder/idct_blk.c Modify /vp8/decoder/onyxd_if.c (...)

• Screen Capture with FFMPEG and Google Native Client

  18 juillet 2016, par Mohammad Abu Musa

  I am building a screen recorder that is based on Native Client for Google, I have ffmpeg installed and ready but I do not have experience programming in ffmpeg. so I am looking for tips to understand how to build this recorder.

  My goal is to make a screen recorder and export videos as webm files, I have all the required libraries I just could not find any code examples to hack on

  This is what I achieved so far

  #define __STDC_LIMIT_MACROS
  
  
  
  #include 
  
  #include <iostream>
  
  #include 
  
  #include 
  
  #include <sstream>
  
  #include 
  
  #include <vector>
  
  
  
  #include "ppapi/cpp/instance.h"
  
  #include "ppapi/cpp/var_dictionary.h"
  
  #include "ppapi/c/pp_errors.h"
  
  #include "ppapi/c/ppb_console.h"
  
  #include "ppapi/cpp/input_event.h"
  
  #include "ppapi/cpp/module.h"
  
  #include "ppapi/cpp/rect.h"
  
  #include "ppapi/cpp/var.h"
  
  #include "ppapi/cpp/var_array_buffer.h"
  
  
  
  // Begin File IO headers
  
  #include "ppapi/c/pp_stdint.h"
  
  #include "ppapi/c/ppb_file_io.h"
  
  #include "ppapi/cpp/directory_entry.h"
  
  #include "ppapi/cpp/file_io.h"
  
  #include "ppapi/cpp/file_ref.h"
  
  #include "ppapi/cpp/file_system.h"
  
  #include "ppapi/cpp/instance.h"
  
  #include "ppapi/cpp/message_loop.h"
  
  #include "ppapi/cpp/module.h"
  
  #include "ppapi/cpp/var.h"
  
  #include "ppapi/cpp/var_array.h"
  
  #include "ppapi/utility/completion_callback_factory.h"
  
  #include "ppapi/utility/threading/simple_thread.h"
  
  
  
  #ifndef INT32_MAX
  
  #define INT32_MAX (0x7FFFFFFF)
  
  #endif
  
  
  
  #ifdef WIN32
  
  #undef min
  
  #undef max
  
  #undef PostMessage
  
  
  
  // Allow 'this' in initializer list
  
  #pragma warning(disable : 4355)
  
  #endif
  
  
  
  namespace {
  
  typedef std::vector StringVector;
  
  }
  
  //End File IO headers
  
  
  
  extern "C" {
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  }
  
  
  
  const char* file_name = "/file.txt";
  
  const char* video_name = "/video.mpeg";
  
  const char* file_text = "Echo from NaCl: ";
  
  
  
  /**
  
   * Pixel formats and codecs
  
   */
  
  static const AVPixelFormat sourcePixelFormat = AV_PIX_FMT_BGR24;
  
  static const AVPixelFormat destPixelFormat = AV_PIX_FMT_YUV420P;
  
  static const AVCodecID destCodec = AV_CODEC_ID_MPEG2VIDEO;
  
  
  
  class RecorderInstance: public pp::Instance {
  
  public:
  
      explicit RecorderInstance(PP_Instance instance) :
  
              pp::Instance(instance), callback_factory_(this), file_system_(this,
  
                      PP_FILESYSTEMTYPE_LOCALPERSISTENT), file_system_ready_(
  
                      false), file_thread_(this) {
  
      }
  
  
  
      virtual ~RecorderInstance() {
  
          file_thread_.Join();
  
      }
  
  
  
      virtual bool Init(uint32_t /*argc*/, const char * /*argn*/[],
  
              const char * /*argv*/[]) {
  
          file_thread_.Start();
  
          file_thread_.message_loop().PostWork(
  
                  callback_factory_.NewCallback(
  
                          &amp;RecorderInstance::OpenFileSystem));
  
          avcodec_register_all(); // mandatory to register ffmpeg functions
  
  
  
          return true;
  
      }
  
  
  
  private:
  
      pp::CompletionCallbackFactory<recorderinstance> callback_factory_;
  
      pp::FileSystem file_system_;
  
  
  
      // Indicates whether file_system_ was opened successfully. We only read/write
  
      // this on the file_thread_.
  
      bool file_system_ready_;
  
      pp::SimpleThread file_thread_;
  
  
  
      virtual void HandleMessage(const pp::Var&amp; var_message) {
  
          if (!var_message.is_dictionary()) {
  
              LogToConsole(PP_LOGLEVEL_ERROR, pp::Var("Invalid message!"));
  
              return;
  
          }
  
  
  
          pp::VarDictionary dict_message(var_message);
  
          std::string command = dict_message.Get("message").AsString();
  
  
  
  
  
          if (command == "sendFrame") {
  
              pp::VarArrayBuffer data(dict_message.Get("data"));
  
              uint width = 600;
  
              uint height = 800;
  
              uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
              /**
  
               * Create an encoder and open it
  
               */
  
              avcodec_register_all();
  
  
  
              AVCodec *h264encoder = avcodec_find_encoder(destCodec);
  
              AVCodecContext *h264encoderContext = avcodec_alloc_context3(
  
                      h264encoder);
  
  
  
              h264encoderContext->pix_fmt = destPixelFormat;
  
              h264encoderContext->width = width;
  
              h264encoderContext->height = height;
  
  
  
              if (avcodec_open2(h264encoderContext, h264encoder, NULL) &lt; 0) {
  
                  ShowErrorMessage("Cannot open codec" ,-1);
  
                  return;
  
              }
  
  
  
              /**
  
               * Create a stream
  
               */
  
              AVFormatContext *cv2avFormatContext = avformat_alloc_context();
  
              AVStream *h264outputstream = avformat_new_stream(cv2avFormatContext,
  
                      h264encoder);
  
  
  
              AVFrame *sourceAvFrame = av_frame_alloc(), *destAvFrame =
  
                      av_frame_alloc();
  
              int got_frame;
  
  
  
              FILE* videoOutFile = fopen("video", "wb");
  
              /**
  
               * Prepare the conversion context
  
               */
  
              SwsContext *bgr2yuvcontext = sws_getContext(width, height,
  
                      sourcePixelFormat, width, height, destPixelFormat,
  
                      SWS_BICUBIC, NULL, NULL, NULL);
  
  
  
              int framesToEncode = 100;
  
              /**
  
               * Convert and encode frames
  
               */
  
              for (uint i = 0; i &lt; framesToEncode; i++) {
  
  
  
                  /**
  
                   * Allocate source frame, i.e. input to sws_scale()
  
                   */
  
                  av_image_alloc(sourceAvFrame->data, sourceAvFrame->linesize,
  
                          width, height, sourcePixelFormat, 1);
  
  
  
                  /**
  
                   * Copy image data into AVFrame from cv::Mat
  
                   */
  
                  for (uint32_t h = 0; h &lt; height; h++)
  
                      memcpy(
  
                              &amp;(sourceAvFrame->data[0][h
  
                                      * sourceAvFrame->linesize[0]]),
  
                              &amp;(data), width * 3);
  
  
  
                  /**
  
                   * Allocate destination frame, i.e. output from sws_scale()
  
                   */
  
                  av_image_alloc(destAvFrame->data, destAvFrame->linesize, width,
  
                          height, destPixelFormat, 1);
  
  
  
                  sws_scale(bgr2yuvcontext, sourceAvFrame->data,
  
                          sourceAvFrame->linesize, 0, height, destAvFrame->data,
  
                          destAvFrame->linesize);
  
                  sws_freeContext(bgr2yuvcontext);
  
                  /**
  
                   * Prepare an AVPacket and set buffer to NULL so that it'll be allocated by FFmpeg
  
                   */
  
                  AVPacket avEncodedPacket;
  
                  av_init_packet(&amp;avEncodedPacket);
  
                  avEncodedPacket.data = NULL;
  
                  avEncodedPacket.size = 0;
  
  
  
                  destAvFrame->pts = i;
  
                  avcodec_encode_video2(h264encoderContext, &amp;avEncodedPacket,
  
                          destAvFrame, &amp;got_frame);
  
  
  
                  if (got_frame) {
  
                      ShowErrorMessage(
  
                              "Encoded a frame of size \n",-1); //+ (string)avEncodedPacket.size + "\n");
  
  
  
                      if (fwrite(avEncodedPacket.data, 1, avEncodedPacket.size,
  
                              videoOutFile) &lt; (unsigned) avEncodedPacket.size)
  
                          ShowErrorMessage(
  
                                  "Could not write all \n",-1);
  
                                  //+ avEncodedPacket.size
  
                                          //+ " bytes, but will continue..\n"
  
  
  
  
  
                      fflush(videoOutFile);
  
  
  
                  }
  
                  /**
  
                   * Per-frame cleanup
  
                   */
  
                  av_packet_free_side_data(&amp;avEncodedPacket);
  
                  av_free_packet(&amp;avEncodedPacket);
  
                  av_freep(sourceAvFrame->data);
  
                  av_frame_free(&amp;sourceAvFrame);
  
                  av_freep(destAvFrame->data);
  
                  av_frame_free(&amp;destAvFrame);
  
  
  
              }
  
  
  
              fwrite(endcode, 1, sizeof(endcode), videoOutFile);
  
              fclose(videoOutFile);
  
  
  
              /**
  
               * Final cleanup
  
               */
  
              avformat_free_context(cv2avFormatContext);
  
              avcodec_close(h264encoderContext);
  
              avcodec_free_context(&amp;h264encoderContext);
  
  
  
          } else if (command == "createFile") {
  
              file_thread_.message_loop().PostWork(
  
                      callback_factory_.NewCallback(&amp;RecorderInstance::Save,
  
                              file_name, file_text));
  
          }
  
      }
  
  
  
  
  
      void OpenFileSystem(int32_t /* result */) {
  
          int32_t rv = file_system_.Open(1024 * 1024, pp::BlockUntilComplete());
  
          if (rv == PP_OK) {
  
              file_system_ready_ = true;
  
              // Notify the user interface that we're ready
  
              ShowStatusMessage("STORAGE READY");
  
          } else {
  
              ShowErrorMessage("Failed to open file system", rv);
  
          }
  
      }
  
  
  
      void Save(int32_t /* result */, const std::string&amp; file_name,
  
              const std::string&amp; file_contents) {
  
          if (!file_system_ready_) {
  
              ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
  
              return;
  
          }
  
          pp::FileRef ref(file_system_, file_name.c_str());
  
          pp::FileIO file(this);
  
  
  
          int32_t open_result = file.Open(ref,
  
                  PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE
  
                          | PP_FILEOPENFLAG_TRUNCATE, pp::BlockUntilComplete());
  
          if (open_result != PP_OK) {
  
              ShowErrorMessage("File open for write failed", open_result);
  
              return;
  
          }
  
  
  
          // We have truncated the file to 0 bytes. So we need only write if
  
          // file_contents is non-empty.
  
          if (!file_contents.empty()) {
  
              if (file_contents.length() > INT32_MAX) {
  
                  ShowErrorMessage("File too big", PP_ERROR_FILETOOBIG);
  
                  return;
  
              }
  
              int64_t offset = 0;
  
              int32_t bytes_written = 0;
  
              do {
  
                  bytes_written = file.Write(offset,
  
                          file_contents.data() + offset, file_contents.length(),
  
                          pp::BlockUntilComplete());
  
                  if (bytes_written > 0) {
  
                      offset += bytes_written;
  
                  } else {
  
                      ShowErrorMessage("File write failed", bytes_written);
  
                      return;
  
                  }
  
              } while (bytes_written
  
                      &lt; static_cast(file_contents.length()));
  
          }
  
          // All bytes have been written, flush the write buffer to complete
  
          int32_t flush_result = file.Flush(pp::BlockUntilComplete());
  
          if (flush_result != PP_OK) {
  
              ShowErrorMessage("File fail to flush", flush_result);
  
              return;
  
          }
  
          ShowStatusMessage("Save success");
  
      }
  
  
  
      /// Encapsulates our simple javascript communication protocol
  
      void ShowErrorMessage(const std::string&amp; message, int32_t result) {
  
          std::stringstream ss;
  
          ss &lt;&lt; "ERROR: " &lt;&lt; message &lt;&lt; " -- Error #: " &lt;&lt; result &lt;&lt; "\n";
  
          PostMessage(ss.str());
  
      }
  
  
  
      void ShowStatusMessage(const std::string&amp; message) {
  
          std::stringstream ss;
  
          ss &lt;&lt; "LOG: " &lt;&lt; message &lt;&lt; "\n";
  
          PostMessage(ss.str());
  
      }
  
  
  
  };
  
  
  
  class RecorderModule: public pp::Module {
  
  public:
  
      RecorderModule() :
  
              pp::Module() {
  
      }
  
  
  
      virtual ~RecorderModule() {
  
      }
  
  
  
      virtual pp::Instance* CreateInstance(PP_Instance instance) {
  
          return new RecorderInstance(instance);
  
      }
  
  };
  
  
  
  namespace pp {
  
  
  
  /**
  
   * This function is an entry point to a NaCl application.
  
   * It must be implemented.
  
   */
  
  Module* CreateModule() {
  
      return new RecorderModule();
  
  }
  
  
  
  }  // namespace pp
  
  </recorderinstance></vector></sstream></iostream>