Recherche avancée

Sur d’autres sites (5028)

• EC2 for video-encoding

  24 septembre 2012, par TK Kocheran

  I have a potential job which will require me to do some video encoding with FFMPEG and x264. I'll have a series of files which I'll need to encode once, then I'll be able to bring down the instances. Since I'm not really sure of the resource utilization of x264 and FFMPEG, what kind of instances should I get ? I'm thinking either a

  High-CPU Extra Large Instance

  7 GB of memory
  20 EC2 Compute Units (8 virtual cores with 2.5 EC2 Compute Units each)
  1690 GB of instance storage
  64-bit platform
  I/O Performance : High
  API name : c1.xlarge

  or, alternatively a

  Cluster GPU Quadruple Extra Large Instance

  22 GB of memory
  33.5 EC2 Compute Units (2 x Intel Xeon X5570, quad-core “Nehalem” architecture)
  2 x NVIDIA Tesla “Fermi” M2050 GPUs
  1690 GB of instance storage
  64-bit platform
  I/O Performance : Very High (10 Gigabit Ethernet)
  API name : cg1.4xlarge

  What should I use ? Does x264/FFMPEG perform better with faster/more CPUs or does it really pound the GPU more ? In any case, it seems that the Cluster GPU seems to be the higher performance instance. What should I prefer ?

• fate : add tests for cdxl video

  21 février 2012, par Paul B Mahol

  fate : add tests for cdxl video

• Decode audio and video and process both streams — ffmpeg, sdl, opencv

  6 mai 2013, par Eric

  My goal is to proceed on audio and video of mpeg-2 file independently, and to keep synchronicity on both flows. Duration of video is about 1 or 2 minutes maximum.

  1. First, following this post "opencv for reading videos (and do the process),ffmpeg for audio , and SDL used to play both" sounds perfect. I have done some modification on the code considering recent ffmpeg naming changes. Compilation with cmake on 64-bits machine is fine. I get an error "Unsupported codec [3]" when opening codec.
     The code is following.

  2. Second, I looking for code dealing with synchronicity on both flows.

  ---

  #include "opencv/highgui.h"
  
  #include "opencv/cv.h"
  
  
  
  #ifndef INT64_C
  
  #define INT64_C(c) (c ## LL)
  
  #define UINT64_C(c) (c ## ULL)
  
  #endif
  
  
  
  extern "C"{
  
  #include <sdl></sdl>SDL.h>
  
  #include <sdl></sdl>SDL_thread.h>
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  }
  
  
  
  #include <iostream>
  
  #include 
  
  #include 
  
  
  
  using namespace cv;
  
  
  
  #define SDL_AUDIO_BUFFER_SIZE 1024
  
  
  
  typedef struct PacketQueue
  
  {
  
     AVPacketList *first_pkt, *last_pkt;
  
     int nb_packets;
  
     int size;
  
     SDL_mutex *mutex;
  
     SDL_cond *cond;
  
  } PacketQueue;
  
  PacketQueue audioq;
  
  
  
  int audioStream = -1;
  
  int videoStream = -1;
  
  int quit = 0;
  
  
  
  SDL_Surface* screen = NULL;
  
  SDL_Surface* surface = NULL;
  
  
  
  AVFormatContext* pFormatCtx = NULL;
  
  AVCodecContext* aCodecCtx = NULL;
  
  AVCodecContext* pCodecCtx = NULL;
  
  
  
  void show_frame(IplImage* img){
  
     if (!screen){
  
        screen = SDL_SetVideoMode(img->width, img->height, 0, 0);
  
        if (!screen){
  
           fprintf(stderr, "SDL: could not set video mode - exiting\n");
  
           exit(1);
  
        }
  
     }
  
     // Assuming IplImage packed as BGR 24bits
  
     SDL_Surface* surface = SDL_CreateRGBSurfaceFrom((void*)img->imageData,
  
                                                     img->width,
  
                                                     img->height,
  
                                                     img->depth * img->nChannels,
  
                                                     img->widthStep,
  
                                                     0xff0000, 0x00ff00, 0x0000ff, 0
  
                                                    );
  
  
  
     SDL_BlitSurface(surface, 0, screen, 0);
  
     SDL_Flip(screen);
  
  }
  
  
  
  void packet_queue_init(PacketQueue *q){
  
     memset(q, 0, sizeof(PacketQueue));
  
     q->mutex = SDL_CreateMutex();
  
     q->cond = SDL_CreateCond();
  
  }
  
  
  
  int packet_queue_put(PacketQueue *q, AVPacket *pkt){
  
     AVPacketList *pkt1;
  
     if (av_dup_packet(pkt) &lt; 0){
  
        return -1;
  
     }
  
  
  
     pkt1 = (AVPacketList*) av_malloc(sizeof(AVPacketList));
  
     //pkt1 = (AVPacketList*) malloc(sizeof(AVPacketList));
  
     if (!pkt1) return -1;
  
     pkt1->pkt = *pkt;
  
     pkt1->next = NULL;
  
  
  
     SDL_LockMutex(q->mutex);
  
  
  
     if (!q->last_pkt)
  
        q->first_pkt = pkt1;
  
     else
  
        q->last_pkt->next = pkt1;
  
  
  
     q->last_pkt = pkt1;
  
     q->nb_packets++;
  
     q->size += pkt1->pkt.size;
  
     SDL_CondSignal(q->cond);
  
  
  
     SDL_UnlockMutex(q->mutex);
  
     return 0;
  
  }
  
  
  
  static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block){
  
     AVPacketList *pkt1;
  
     int ret;
  
  
  
     SDL_LockMutex(q->mutex);
  
     for (;;){
  
        if( quit){
  
           ret = -1;
  
           break;
  
        }
  
  
  
        pkt1 = q->first_pkt;
  
        if (pkt1){
  
           q->first_pkt = pkt1->next;
  
           if (!q->first_pkt)
  
              q->last_pkt = NULL;
  
  
  
           q->nb_packets--;
  
           q->size -= pkt1->pkt.size;
  
           *pkt = pkt1->pkt;
  
           av_free(pkt1);
  
           //free(pkt1);
  
           ret = 1;
  
           break;
  
        }
  
  
  
        else if (!block){
  
           ret = 0;
  
           break;
  
        }
  
        else{
  
           SDL_CondWait(q->cond, q->mutex);
  
        }
  
     }
  
  
  
     SDL_UnlockMutex(q->mutex);
  
     return ret;
  
  }
  
  
  
  int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size){
  
     static AVPacket pkt;
  
     static uint8_t *audio_pkt_data = NULL;
  
     static int audio_pkt_size = 0;
  
  
  
     int len1, data_size;
  
  
  
     for (;;){
  
        while (audio_pkt_size > 0){
  
           data_size = buf_size;
  
           len1 = avcodec_decode_audio3(aCodecCtx, (int16_t*)audio_buf, &amp;data_size, &amp;pkt);
  
           if (len1 &lt; 0){
  
              // if error, skip frame
  
              audio_pkt_size = 0;
  
              break;
  
           }
  
           audio_pkt_data += len1;
  
           audio_pkt_size -= len1;
  
           if (data_size &lt;= 0){
  
              // No data yet, get more frames
  
              continue;
  
           }
  
           // We have data, return it and come back for more later
  
           return data_size;
  
       }
  
  
  
       if (pkt.data)
  
          av_free_packet(&amp;pkt);
  
       if (quit) return -1;
  
       if (packet_queue_get(&amp;audioq, &amp;pkt, 1) &lt; 0) return -1;
  
       audio_pkt_data = pkt.data;
  
       audio_pkt_size = pkt.size;
  
    }
  
  }
  
  
  
  void audio_callback(void *userdata, Uint8 *stream, int len){
  
    AVCodecContext *aCodecCtx = (AVCodecContext *)userdata;
  
    int len1, audio_size;
  
  
  
    static uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];
  
    static unsigned int audio_buf_size = 0;
  
    static unsigned int audio_buf_index = 0;
  
  
  
    while (len > 0){
  
       if (audio_buf_index >= audio_buf_size){
  
          // We have already sent all our data; get more
  
          audio_size = audio_decode_frame(aCodecCtx, audio_buf, sizeof(audio_buf));
  
          if(audio_size &lt; 0){
  
             // If error, output silence
  
             audio_buf_size = 1024; // arbitrary?
  
             memset(audio_buf, 0, audio_buf_size);
  
          }
  
          else{
  
             audio_buf_size = audio_size;
  
          }
  
          audio_buf_index = 0;
  
      }
  
  
  
      len1 = audio_buf_size - audio_buf_index;
  
      if (len1 > len)
  
         len1 = len;
  
      memcpy(stream, (uint8_t *)audio_buf + audio_buf_index, len1);
  
      len -= len1;
  
      stream += len1;
  
      audio_buf_index += len1;
  
    }
  
  }
  
  
  
       void setup_ffmpeg(char* filename)
  
       {
  
          if (avformat_open_input(&amp;pFormatCtx, filename, NULL, NULL) != 0){
  
             fprintf(stderr, "FFmpeg failed to open file %s!\n", filename);
  
             exit(-1);
  
          }
  
  
  
          if (av_find_stream_info(pFormatCtx) &lt; 0){
  
             fprintf(stderr, "FFmpeg failed to retrieve stream info!\n");
  
             exit(-1);
  
          }
  
  
  
          // Dump information about file onto standard error
  
          av_dump_format(pFormatCtx, 0, filename, 0);
  
  
  
          // Find the first video stream
  
          int i = 0;
  
          for (i; i &lt; pFormatCtx->nb_streams; i++){
  
             if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &amp;&amp; videoStream &lt; 0){
  
                videoStream = i;
  
             }
  
  
  
             if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &amp;&amp; audioStream &lt; 0){
  
                audioStream = i;
  
             }
  
          }
  
  
  
          if (videoStream == -1){
  
             fprintf(stderr, "No video stream found in %s!\n", filename);
  
             exit(-1);
  
          }
  
  
  
          if (audioStream == -1){
  
             fprintf(stderr, "No audio stream found in %s!\n", filename);
  
             exit(-1);
  
          }
  
  
  
          // Get a pointer to the codec context for the audio stream
  
          aCodecCtx = pFormatCtx->streams[audioStream]->codec;
  
  
  
          // Set audio settings from codec info
  
          SDL_AudioSpec wanted_spec;
  
          wanted_spec.freq = aCodecCtx->sample_rate;
  
          wanted_spec.format = AUDIO_S16SYS;
  
          wanted_spec.channels = aCodecCtx->channels;
  
          wanted_spec.silence = 0;
  
          wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
  
          wanted_spec.callback = audio_callback;
  
          wanted_spec.userdata = aCodecCtx;
  
  
  
          SDL_AudioSpec spec;
  
          if (SDL_OpenAudio(&amp;wanted_spec, &amp;spec) &lt; 0){
  
             fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
  
             exit(-1);
  
          }
  
  
  
          AVCodec* aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
  
          if (!aCodec){
  
             fprintf(stderr, "Unsupported codec [1]!\n");
  
             exit(-1);
  
          }
  
          avcodec_open(aCodecCtx, aCodec);
  
  
  
          // audio_st = pFormatCtx->streams[index]
  
          packet_queue_init(&amp;audioq);
  
          SDL_PauseAudio(0);
  
  
  
          // Get a pointer to the codec context for the video stream
  
          pCodecCtx = pFormatCtx->streams[videoStream]->codec;
  
  
  
          // Find the decoder for the video stream
  
          AVCodec* pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
  
          if (pCodec == NULL){
  
             fprintf(stderr, "Unsupported codec [2]!\n");
  
             exit(-1); // Codec not found
  
          }
  
  
  
          // Open codec
  
          if (avcodec_open(pCodecCtx, pCodec) &lt; 0){
  
             fprintf(stderr, "Unsupported codec [3]!\n");
  
             exit(-1); // Could not open codec
  
          }
  
       }
  
  
  
  
  
       int main(int argc, char* argv[])
  
       {
  
          if (argc &lt; 2){
  
              std::cout &lt;&lt; "Usage: " &lt;&lt; argv[0] &lt;&lt; " <video>" &lt;&lt; std::endl;
  
              return -1;
  
          }
  
  
  
          av_register_all();
  
  
  
          // Init SDL
  
          if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER))
  
          {
  
             fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
  
             return -1;
  
          }
  
  
  
          // Init ffmpeg and setup some SDL stuff related to Audio
  
          setup_ffmpeg(argv[1]);
  
  
  
          VideoCapture cap(argv[1]);
  
          if (!cap.isOpened()){
  
             std::cout &lt;&lt; "Failed to load file!" &lt;&lt; std::endl;
  
             return -1;
  
          }
  
  
  
          AVPacket packet;
  
          while (av_read_frame(pFormatCtx, &amp;packet) >= 0)
  
          {
  
             if (packet.stream_index == videoStream)
  
             {
  
                // Actually this is were SYNC between audio/video would happen.
  
                // Right now I assume that every VIDEO packet contains an entire video frame, and that&#39;s not true. A video frame can be made by multiple packets!
  
                // But for the time being, assume 1 video frame == 1 video packet,
  
                // so instead of reading the frame through ffmpeg, I read it through OpenCV.
  
  
  
                Mat frame;
  
                cap >> frame; // get a new frame from camera
  
  
  
                // do some processing on the frame, either as a Mat or as IplImage.
  
                // For educational purposes, applying a lame grayscale conversion
  
                IplImage ipl_frame = frame;
  
                for (int i = 0; i &lt; ipl_frame.width * ipl_frame.height * ipl_frame.nChannels; i += ipl_frame.nChannels)
  
                {
  
                   ipl_frame.imageData[i] = (ipl_frame.imageData[i] + ipl_frame.imageData[i+1] + ipl_frame.imageData[i+2])/3;   //B
  
                   ipl_frame.imageData[i+1] = (ipl_frame.imageData[i] + ipl_frame.imageData[i+1] + ipl_frame.imageData[i+2])/3; //G
  
                   ipl_frame.imageData[i+2] = (ipl_frame.imageData[i] + ipl_frame.imageData[i+1] + ipl_frame.imageData[i+2])/3; //R
  
                }
  
  
  
                // Display it on SDL window
  
                show_frame(&amp;ipl_frame);
  
  
  
                av_free_packet(&amp;packet);
  
             }
  
             else if (packet.stream_index == audioStream)
  
             {
  
                packet_queue_put(&amp;audioq, &amp;packet);
  
             }
  
             else
  
             {
  
                av_free_packet(&amp;packet);
  
             }
  
  
  
             SDL_Event event;
  
             SDL_PollEvent(&amp;event);
  
             switch (event.type)
  
             {
  
             case SDL_QUIT:
  
                SDL_FreeSurface(surface);
  
                SDL_Quit();
  
                break;
  
  
  
             default:
  
                break;
  
             }
  
          }
  
  
  
          // the camera will be deinitialized automatically in VideoCapture destructor
  
  
  
          // Close the codec
  
          avcodec_close(pCodecCtx);
  
  
  
          // Close the video file
  
          av_close_input_file(pFormatCtx);
  
  
  
          return 0;
  
       }
  
  </video></iostream>