Recherche avancée

Sur d’autres sites (7756)

• VP8 for Real-time Video Applications

  15 février 2011, par noreply@blogger.com (John Luther)

  With the growing interest in videoconferencing on the web platform, it’s a good time to explore the features of VP8 that make it an exceptionally good codec for real-time applications like videoconferencing.

  VP8 Design History & Features

  Real-time applications were a primary use case when VP8 was designed. The VP8 encoder has features specifically engineered to overcome the challenges inherent in compressing and transmitting real-time video data.
  

  • Processor-adaptive encoding. 16 encoder complexity levels automatically (or manually) adjust encoder features such as motion search strategy, quantizer optimizations, and loop filtering strength.
  • Encoder can be configured to use a target percentage of the host CPU.
    Ability to measure the time taken to encode each frame and adjust encoder complexity dynamically to keep the encoding time per frame constant
  • Robust error recovery (packet retransmission, forward error correction, recovery frame/new keyframe requests)
  • Temporal scalability (i.e., a single video bitstream that can degrade as needed depending on a participant’s available bandwidth)
  • Highly efficient decoding performance on low-power devices. Conventional video technology has grown to a state of complexity where dedicated hardware chips are needed to make it work well. With VP8, software-based solutions have proven to meet customer needs without requiring specialized hardware.

  For a more information about real-time video features in VP8, see the slide presentation by WebM Project engineer Paul Wilkins (PDF file).

  Commercially Available Products

  Millions of people around the world have been using VP7/8 for video chat for years. VP8 is deployed in some of today’s most popular consumer videoconferencing applications, including Skype (group video calling), Sightspeed, ooVoo and Logitech Vid. All of these vendors are active WebM project supporters. VP8’s predecessor, VP7, has been used in Skype video calling since 2005 and is supported in the new Skype app for iPhone. Other real-time VP8 implementations are coming soon, including ooVoo, and VP8 will play a leading role in Google’s plans for real-time applications on the web platform.

  Real-time applications will be extremely important as the web platform matures. The WebM community has made significant improvements in VP8 for real-time use cases since our launch and will continue to do so in the future.

  John Luther is Product Manager of the WebM Project.

  

• How can I broadcast a Twilio (group room) video conference ?

  2 novembre 2022, par Danish

  I have been trying different solutions/approaches for last few days and posting here to get some more options.

  



  I am planning to use Twilio's Programmable Video solution with Group room (upto 50 participants) to allow hosts/presenters to join video conference meeting. Right now I am able to setup and get started with quickstart example here

  



  Also, in parallel, I need to be able to broadcast that live meeting room through RTMP/HLS (audio+video) streaming that can be viewed (through another portal) by large user set (ideally around 10k+)

  



  Twilio support team suggested - integrating Twilio Video with Wowza using screenscrapping and ffmpeg (i.e. render the video into a (maybe virtual) screen, capture it and send to Wowza using ffmpeg.)

  



  I am new to both ffmpeg and wowza. However, I am looking to see high level solution which can be used to achieve this (with minimum hanging parts).

  



  Ideal flow i can think of is

  



  

  • Start a Twilio video conference room with actual presenters

  


  • all participants share there video and audio tracks with each other in the room - standard behavior

  


  • a new ghost-participant joins-in from stand-alone server (from wowza or SIP) and subscribes to audio-video tracks in conference.

  


  • arrange & combine those tracks into one channel and stream it as HLS

  


  • this ghost-participant will also be able to identify dominant speaker and re-arrange video tracks to show current speaker occupying bigger space (just like zoom)

  


  • and of course, this streamed video (with audio) will be one-way and viewers cannot interact. Just see be able to see the room broadcasting.

  


  



  Also/FYI
I have tried exploring few more options below (with no success)

  



  


  1. a blog here explain how can we broadcast a twilio audio
conference. At the bottom it also mention about video streaming. but, I am not getting how can we use SIP to get video stream that can be broadcasted. Also, how can I manipulate video tracks to show dominant speakers in full screen view Vs other participant in thumbnail view i.e. custom layouts.

  


  2. I also explored option of Wowza WebRTC streaming to achieve this, but it has got other technical challenges with setting up video room with multiple participants. I am going to reach out to them to see if this use-case is possible with their offering.

  


  3. I am looking for something as simple as here - dial as guest participant into video room from standalone streaming server/wowza server. And get output as single stream to broadcast.

  


  



  Any other pointers or links to solutions would be helpful.

  


• FFmpeg - MJPEG decoding - getting different values

  27 décembre 2016, par ahmadh

  I have a set of JPEG frames which I am muxing into an avi, which gives me a mjpeg video. This is the command I run on the console :

  ffmpeg -y -start_number 0 -i %06d.JPEG -codec copy vid.avi

  When I try to demux the video using ffmpeg C api, I get frames which are slightly different in values. Demuxing code looks something like this :

  AVFormatContext* fmt_ctx = NULL;
  
  AVCodecContext* cdc_ctx = NULL;
  
  AVCodec* vid_cdc = NULL;
  
  int ret;
  
  unsigned int height, width;
  
  
  
  ....
  
  // read_nframes is the number of frames to read
  
  output_arr = new unsigned char [height * width * 3 * 
  
                                  sizeof(unsigned char) * read_nframes];
  
  
  
  avcodec_open2(cdc_ctx, vid_cdc, NULL);
  
  
  
  int num_bytes;
  
  uint8_t* buffer = NULL;
  
  const AVPixelFormat out_format = AV_PIX_FMT_RGB24;
  
  
  
  num_bytes = av_image_get_buffer_size(out_format, width, height, 1);
  
  buffer = (uint8_t*)av_malloc(num_bytes * sizeof(uint8_t));
  
  
  
  AVFrame* vid_frame = NULL;
  
  vid_frame = av_frame_alloc();
  
  AVFrame* conv_frame = NULL;
  
  conv_frame = av_frame_alloc();
  
  
  
  av_image_fill_arrays(conv_frame->data, conv_frame->linesize, buffer, 
  
                       out_format, width, height, 1);
  
  
  
  struct SwsContext *sws_ctx = NULL;
  
  sws_ctx = sws_getContext(width, height, cdc_ctx->pix_fmt,
  
                           width, height, out_format,
  
                           SWS_BILINEAR, NULL,NULL,NULL);
  
  
  
  int frame_num = 0;
  
  AVPacket vid_pckt;
  
  while (av_read_frame(fmt_ctx, &vid_pckt) >=0) {
  
      ret = avcodec_send_packet(cdc_ctx, &vid_pckt);
  
      if (ret < 0)
  
          break;
  
  
  
      ret = avcodec_receive_frame(cdc_ctx, vid_frame);
  
      if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
  
          break;
  
      if (ret >= 0) {
  
          // convert image from native format to planar GBR
  
          sws_scale(sws_ctx, vid_frame->data, 
  
                    vid_frame->linesize, 0, vid_frame->height, 
  
                    conv_frame->data, conv_frame->linesize);
  
  
  
          unsigned char* r_ptr = output_arr + 
  
              (height * width * sizeof(unsigned char) * 3 * frame_num);
  
          unsigned char* g_ptr = r_ptr + (height * width * sizeof(unsigned char));
  
          unsigned char* b_ptr = g_ptr + (height * width * sizeof(unsigned char));
  
          unsigned int pxl_i = 0;
  
  
  
          for (unsigned int r = 0; r < height; ++r) {
  
              uint8_t* avframe_r = conv_frame->data[0] + r*conv_frame->linesize[0];
  
              for (unsigned int c = 0; c < width; ++c) {
  
                  r_ptr[pxl_i] = avframe_r[0];
  
                  g_ptr[pxl_i]   = avframe_r[1];
  
                  b_ptr[pxl_i]   = avframe_r[2];
  
                  avframe_r += 3;
  
                  ++pxl_i;
  
              }
  
          }
  
  
  
          ++frame_num;
  
  
  
          if (frame_num >= read_nframes)
  
              break;
  
      }
  
  }
  
  
  
  ...

  In my experience around two-thirds of the pixel values are different, each by +-1 (in a range of [0,255]). I am wondering is it due to some decoding scheme FFmpeg uses for reading JPEG frames ? I tried encoding and decoding png frames, and it works perfectly fine.

  In short my goal is to get the same pixel by pixel values for each JPEG frame as I would I have gotten if I was reading the JPEG images directly. Here is the stand-alone code I used. It includes cmake files to build code, and a couple of jpeg frames with the converted avi file to test this problem. (give —filetype png to test the png decoding).