Recherche avancée

Sur d’autres sites (9206)

• Basic "pass-through" use of FFmpegReader/FFmpegWriter in scikit-video

  6 février 2021, par JonathanZ supports MonicaC

  I am starting to use scikit-video and am having trouble writing files. I have reduced the problem to the simplest possible example

  


  vid_file = "6710185719062326259_stamp_25pct.mp4"
output_file = "out_temp3.mp4"
reader = skvideo.io.FFmpegReader(vid_file)
writer = skvideo.io.FFmpegWriter(output_file)
for frame in reader.nextFrame():
        writer.writeFrame(frame)
writer.close()


  


  I'm playing the files in VLC, and the vid_file is valid but the output file, though playable, is mostly big green blocks (though I can discern some details from the original video in it).

  


  My goal, or course, is to do "interesting" manipulations of the frame before I write it out, but I need to get the "no modifications" version working correctly first. I'm also going to be using this on large files, so the vread/vwrite functions that process an entire file at once are not appropriate.

  


  I'm guessing I need to set the appropriate values in the outputdict parameter for the FFmpegWriter, but there are so many that I don't know where to start. I have tried

  


  writer = skvideo.io.FFmpegWriter(output_file, outputdict={'-crf': '0', '-pix_fmt': 'rgb24'})


  


  (-crf 0 to suppress any compression, -pixfmt rgb24 as that's what FFmpegReader says it delivers by default, but these don't work either.

  


  Any ideas on how to make this work ?

  


  Here's the skvideo.io.ffprobe video information for the input file.

  


  {
    "@index": "0",
    "@codec_name": "h264",
    "@codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
    "@profile": "High",
    "@codec_type": "video",
    "@codec_time_base": "1/30",
    "@codec_tag_string": "avc1",
    "@codec_tag": "0x31637661",
    "@width": "480",
    "@height": "270",
    "@coded_width": "480",
    "@coded_height": "272",
    "@has_b_frames": "2",
    "@pix_fmt": "yuv420p",
    "@level": "21",
    "@chroma_location": "left",
    "@refs": "1",
    "@is_avc": "true",
    "@nal_length_size": "4",
    "@r_frame_rate": "15/1",
    "@avg_frame_rate": "15/1",
    "@time_base": "1/15360",
    "@start_pts": "0",
    "@start_time": "0.000000",
    "@duration_ts": "122880",
    "@duration": "8.000000",
    "@bit_rate": "183806",
    "@bits_per_raw_sample": "8",
    "@nb_frames": "120",
    "disposition": {
        "@default": "1",
        "@dub": "0",
        "@original": "0",
        "@comment": "0",
        "@lyrics": "0",
        "@karaoke": "0",
        "@forced": "0",
        "@hearing_impaired": "0",
        "@visual_impaired": "0",
        "@clean_effects": "0",
        "@attached_pic": "0",
        "@timed_thumbnails": "0"
    },
    "tag": [
        {
            "@key": "language",
            "@value": "und"
        },
        {
            "@key": "handler_name",
            "@value": "VideoHandler"
        }
    ]
}


  


  I will mention that when I ffprobe the output file the only differences I see are 1) the timing data is different, which isn't surprising, and 2) the output file has

  


      "@has_b_frames": "0",
    "@pix_fmt": "yuv444p",


  


  I'm pretty confident the reader is working okay, because if I write out the data with

  


  skimage.io.imsave('x.png', frame,  check_contrast=False)


  


  it looks good.

  


• How do I write audio and video to the same file using FFMPEG and C ?

  29 juin 2018, par benwiz

  I am consuming an audio file and a video file using ffmpeg in a C program. I am modifying both the audio and the video data. In working the code below I write both each of these streams to its own file. How can I write both streams to the same file ?

  #include 
  
  #include 
  
  #include 
  
  
  
  // Video resolution
  
  #define W 1280
  
  #define H 720
  
  
  
  // Allocate a buffer to store one video frame
  
  unsigned char video_frame[H][W][3] = {0};
  
  
  
  int main()
  
  {
  
      // Audio pipes
  
      FILE *audio_pipein = popen("ffmpeg -i data/daft-punk.mp3 -f s16le -ac 1 -", "r");
  
      FILE *audio_pipeout = popen("ffmpeg -y -f s16le -ar 44100 -ac 1 -i - out/daft-punk.mp3", "w");
  
  
  
      // Video pipes
  
      FILE *video_pipein = popen("ffmpeg -i data/daft-punk.mp4 -f image2pipe -vcodec rawvideo -pix_fmt rgb24 -", "r");
  
      FILE *video_pipeout = popen("ffmpeg -y -f rawvideo -vcodec rawvideo -pix_fmt rgb24 -s 1280x720 -r 25 -i - -f mp4 -q:v 5 -an -vcodec mpeg4 out/daft-punk.mp4", "w");
  
  
  
      // Audio vars
  
      int16_t audio_sample;
  
      int audio_count;
  
      int audio_n = 0;
  
  
  
      // Video vars
  
      int x = 0;
  
      int y = 0;
  
      int video_count = 0;
  
  
  
      // Read, modify, and write one audio_sample and video_frame at a time
  
      while (1)
  
      {
  
          // Audio
  
          audio_count = fread(&audio_sample, 2, 1, audio_pipein); // read one 2-byte audio_sample
  
          if (audio_count == 1)
  
          {
  
              ++audio_n;
  
              audio_sample = audio_sample * sin(audio_n * 5.0 * 2 * M_PI / 44100.0);
  
              fwrite(&audio_sample, 2, 1, audio_pipeout);
  
          }
  
  
  
          // Video
  
          video_count = fread(video_frame, 1, H * W * 3, video_pipein); // Read a frame from the input pipe into the buffer
  
          if (video_count == H * W * 3)                                 // Only modify and write if frame exists
  
          {
  
              for (y = 0; y < H; ++y)     // Process this frame
  
                  for (x = 0; x < W; ++x) // Invert each colour component in every pixel
  
                  {
  
                      video_frame[y][x][0] = 255 - video_frame[y][x][0]; // red
  
                      video_frame[y][x][1] = 255 - video_frame[y][x][1]; // green
  
                      video_frame[y][x][2] = 255 - video_frame[y][x][2]; // blue
  
                  }
  
              fwrite(video_frame, 1, H * W * 3, video_pipeout); // Write this frame to the output pipe
  
          }
  
  
  
          // Break if both complete
  
          if (audio_count != 1 && video_count != H * W * 3)
  
              break;
  
      }
  
  
  
      // Close audio pipes
  
      pclose(audio_pipein);
  
      pclose(audio_pipeout);
  
  
  
      // Close video pipes
  
      fflush(video_pipein);
  
      fflush(video_pipeout);
  
      pclose(video_pipein);
  
      pclose(video_pipeout);
  
  
  
      return 0;
  
  }

  I took the base for this code from this article.

  Thanks !

• Some bugs when using SDL2 and ffmpeg to make a video player

  1er juin 2017, par trycatch

  used sws_scale to resize the image, and SDL2.0 to render, pixel format is YUV420P.

  1.When I Create SDL Render with SDL_RENDERER_SOFTWARE, I Get a black image like this :enter image description here, the top-left corner has a green point ;
  But When I Create SDL Render with SDL_RENDERER_ACCELERATED, I can See normal image ;

  2.When I resize the window, the player will crash on SDL_UpdateYUVTexture. I check width, height and linesize of the data, everything is OK.

  WHY ?

  Key Code :

  if (swscale_.frame.width % 2) 
  
    swscale_.frame.width -= 1;
  
  
  
  swscale_.free();
  
  swscale_.context = sws_getContext(
  
          vcodec->width, vcodec->height, vcodec->pix_fmt,
  
          swscale_.frame.width, swscale_.frame.height,
  
          AV_PIX_FMT_YUV420P, SWS_BICUBIC, nullptr, nullptr, nullptr);
  
  
  
  if (!swscale_.context)
  
      throw std::runtime_error("sws_getContext.");
  
  
  
  if (swscale_.frame.avframe)
  
    av_frame_free(&swscale_.frame.avframe);
  
  swscale_.frame.avframe = av_frame_alloc();
  
  unsigned char* out_buffer = (unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, swscale_.frame.width, swscale_.frame.height, 1)+16);
  
  unsigned char* tmp = &out_buffer[16 - (unsigned long long)out_buffer % 16];
  
  av_image_fill_arrays(swscale_.frame.avframe->data, swscale_.frame.avframe->linesize, tmp,
  
    AV_PIX_FMT_YUV420P, swscale_.frame.width, swscale_.frame.height, 1);
  
  
  
  sws_scale(swscale_.context, (const unsigned char* const*)vframe_->data, vframe_->linesize, 
  
    0, vframe_->height,
  
    swscale_.frame.avframe->data, swscale_.frame.avframe->linesize);
  
  
  
  self.onRenderHandle(swscale_.frame);

  Code of SDL rendering :

  void Player::onRender(const frame& frame)
  
  {
  
    if (sdl_lock_.try_lock()) {
  
      ::ValidateRect(native_window_, NULL);
  
      if (frame.width != scr_width_ || frame.height != scr_height_) {
  
        scr_width_ = frame.width; scr_height_ = frame.height;
  
        SDL_SetWindowSize(screen_, scr_width_ + 2, scr_height_ + 2);
  
        SDL_DestroyRenderer(sdl_renderer_);
  
        sdl_renderer_ = SDL_CreateRenderer(screen_, -1, 0);
  
        video_texture_ = SDL_CreateTexture(sdl_renderer_, SDL_PIXELFORMAT_IYUV,
  
          SDL_TEXTUREACCESS_STREAMING, scr_width_, scr_height_);
  
      }
  
      SDL_UpdateYUVTexture(video_texture_, NULL,
  
        frame.avframe->data[0], frame.avframe->linesize[0],
  
        frame.avframe->data[1], frame.avframe->linesize[1],
  
        frame.avframe->data[2], frame.avframe->linesize[2]);
  
      sdl_lock_.unlock();
  
      ::InvalidateRect(native_window_, NULL, false);
  
    }
  
  }
  
  void Player::onPaint()
  
  {
  
    std::lock_guard lock(sdl_lock_);
  
    SDL_RenderClear(sdl_renderer_);
  
    SDL_RenderCopy(sdl_renderer_, video_texture_, NULL, NULL);
  
    SDL_RenderPresent(sdl_renderer_);
  
  }