media / gpu / v4l2 / v4l2_framerate_control.cc [blame]

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/gpu/v4l2/v4l2_framerate_control.h"

#include <linux/videodev2.h>

#include "base/command_line.h"
#include "base/sequence_checker.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "media/base/media_switches.h"

namespace {
// Numerical value of ioctl() OK return value;
constexpr int kIoctlOk = 0;

double GetUserFrameRate() {
  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
  if (!cmd_line->HasSwitch(switches::kHardwareVideoDecodeFrameRate))
    return 0.0;

  const std::string framerate_str(
      cmd_line->GetSwitchValueASCII(switches::kHardwareVideoDecodeFrameRate));

  constexpr double kMaxFramerate = 120.0;
  double framerate = 0;
  if (base::StringToDouble(framerate_str, &framerate) && framerate >= 0.0 &&
      framerate <= kMaxFramerate) {
    return framerate;
  }
  VLOG(1) << "Requested framerate is unreasonable: " << framerate
          << "fps, not overriding.";
  return 0.0;
}

bool FrameRateControlPresent(
    const media::V4L2FrameRateControl::IoctlAsCallback& ioctl_cb) {
  struct v4l2_streamparm parms;
  memset(&parms, 0, sizeof(parms));
  parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

  // Try to set the framerate to 30fps to see if the control is available.
  // VIDIOC_G_PARM can not be used as it does not return the current
  // framerate.
  parms.parm.output.timeperframe.numerator = 1;
  parms.parm.output.timeperframe.denominator = 30;

  const double user_framerate = GetUserFrameRate();
  if (user_framerate > 0.0) {
    parms.parm.output.timeperframe.numerator = 1000;
    parms.parm.output.timeperframe.denominator = 1000.0 * user_framerate;
    VLOG(1) << "Overriding playback framerate. Set at " << user_framerate
            << " fps.";
  }

  if (ioctl_cb.Run(VIDIOC_S_PARM, &parms) != kIoctlOk) {
    VLOG(1) << "Failed to issue VIDIOC_S_PARM command";
    return false;
  }

  return (user_framerate == 0) &&
         (parms.parm.output.capability & V4L2_CAP_TIMEPERFRAME);
}

}  // namespace
namespace media {

static constexpr unsigned int kMovingAverageWindowSize = 32;
static constexpr base::TimeDelta kFrameIntervalFor120fps =
    base::Milliseconds(8);
static constexpr base::TimeDelta kFrameIntervalFor24fps =
    base::Milliseconds(41);

V4L2FrameRateControl::V4L2FrameRateControl(
    const IoctlAsCallback& ioctl_cb,
    scoped_refptr<base::SequencedTaskRunner> task_runner)
    : ioctl_cb_(ioctl_cb),
      framerate_control_present_(FrameRateControlPresent(ioctl_cb_)),
      current_frame_duration_avg_ms_(0),
      last_frame_display_time_(base::TimeTicks::Now()),
      frame_duration_moving_average_(kMovingAverageWindowSize),
      task_runner_(task_runner),
      weak_this_factory_(this) {
  DETACH_FROM_SEQUENCE(sequence_checker_);
}

V4L2FrameRateControl::~V4L2FrameRateControl() = default;

void V4L2FrameRateControl::UpdateFrameRate() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  if (frame_duration_moving_average_.Count() < kMovingAverageWindowSize) {
    return;
  }

  const base::TimeDelta frame_duration_avg =
      frame_duration_moving_average_.Mean();

  if (frame_duration_avg > kFrameIntervalFor120fps &&
      frame_duration_avg < kFrameIntervalFor24fps &&
      frame_duration_avg.InMilliseconds() != current_frame_duration_avg_ms_) {
    current_frame_duration_avg_ms_ = frame_duration_avg.InMilliseconds();

    struct v4l2_streamparm parms;
    memset(&parms, 0, sizeof(parms));
    parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    parms.parm.output.timeperframe.numerator = current_frame_duration_avg_ms_;
    parms.parm.output.timeperframe.denominator = 1000L;

    TRACE_COUNTER_ID1("media,gpu", "V4L2 time per frame (ms)", this,
                      current_frame_duration_avg_ms_);
    TRACE_COUNTER_ID1("media,gpu", "V4L2 estimated frame rate (Hz)", this,
                      std::round(frame_duration_avg.ToHz()));

    if (ioctl_cb_.Run(VIDIOC_S_PARM, &parms) != kIoctlOk) {
      LOG(ERROR) << "Failed to issue VIDIOC_S_PARM command";
      TRACE_EVENT0("media,gpu", "V4L2 VIDIOC_S_PARM call failed");
    }

    DVLOG(4) << "Average framerate: " << frame_duration_avg.ToHz();
  }
}

// static
void V4L2FrameRateControl::RecordFrameDurationThunk(
    base::WeakPtr<V4L2FrameRateControl> weak_this,
    scoped_refptr<base::SequencedTaskRunner> task_runner) {
  if (task_runner->RunsTasksInCurrentSequence()) {
    if (weak_this) {
      weak_this->RecordFrameDuration();
    }
  } else {
    task_runner->PostTask(
        FROM_HERE,
        base::BindOnce(&V4L2FrameRateControl::RecordFrameDuration, weak_this));
  }
}

void V4L2FrameRateControl::RecordFrameDuration() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  constexpr base::TimeDelta kMaxFrameInterval = base::Milliseconds(500);
  const base::TimeTicks frame_display_time = base::TimeTicks::Now();
  const base::TimeDelta duration =
      frame_display_time - last_frame_display_time_;

  // Frames are expected to be returned at a consistent cadence because the
  // durations are recorded after the frame is displayed, but this isn't always
  // the case.  If the video is not visible, then the frames will be returned
  // as soon as they are decoded.  The window needs to be large enough to
  // handle this scenario.  The video may also be paused, in which case there
  // could be a large duration.  In this case, reset the filter.
  if (duration > kMaxFrameInterval)
    frame_duration_moving_average_.Reset();
  else
    frame_duration_moving_average_.AddSample(duration);

  last_frame_display_time_ = frame_display_time;

  UpdateFrameRate();
}

void V4L2FrameRateControl::AttachToVideoFrame(
    scoped_refptr<VideoFrame>& video_frame) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  if (!framerate_control_present_)
    return;

  video_frame->AddDestructionObserver(
      base::BindOnce(&V4L2FrameRateControl::RecordFrameDurationThunk,
                     weak_this_factory_.GetWeakPtr(), task_runner_));
}

void V4L2FrameRateControl::AttachToFrameResource(
    scoped_refptr<FrameResource>& frame) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  if (!framerate_control_present_) {
    return;
  }

  frame->AddDestructionObserver(
      base::BindOnce(&V4L2FrameRateControl::RecordFrameDurationThunk,
                     weak_this_factory_.GetWeakPtr(), task_runner_));
}

}  // namespace media