/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <memory>

#include "perfetto/ext/base/hash.h"
#include "perfetto/ext/base/string_utils.h"

#include "src/trace_processor/importers/common/args_tracker.h"
#include "src/trace_processor/importers/common/flow_tracker.h"
#include "src/trace_processor/importers/common/process_tracker.h"
#include "src/trace_processor/importers/common/slice_tracker.h"
#include "src/trace_processor/importers/common/track_tracker.h"
#include "src/trace_processor/importers/ftrace/v4l2_tracker.h"

#include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
#include "protos/perfetto/trace/ftrace/v4l2.pbzero.h"

#include "v4l2_tracker.h"

namespace perfetto {
namespace trace_processor {

namespace {
using protos::pbzero::FtraceEvent;
using protos::pbzero::V4l2DqbufFtraceEvent;
using protos::pbzero::V4l2QbufFtraceEvent;
using protos::pbzero::Vb2V4l2BufDoneFtraceEvent;
using protos::pbzero::Vb2V4l2BufQueueFtraceEvent;
using protos::pbzero::Vb2V4l2DqbufFtraceEvent;
using protos::pbzero::Vb2V4l2QbufFtraceEvent;
using protozero::ConstBytes;
}  // namespace

V4l2Tracker::V4l2Tracker(TraceProcessorContext* context)
    : context_(context),
      buf_event_ids_(*context->storage),
      buf_type_ids_(*context_->storage),
      buf_field_ids_(*context->storage),
      tc_type_ids_(*context->storage) {}

V4l2Tracker::~V4l2Tracker() = default;

void V4l2Tracker::ParseV4l2Event(uint64_t fld_id,
                                 int64_t timestamp,
                                 uint32_t pid,
                                 const ConstBytes& bytes) {
  switch (fld_id) {
    case FtraceEvent::kV4l2QbufFieldNumber: {
      V4l2QbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = pb_evt.index();
      evt.type = pb_evt.type();
      evt.bytesused = pb_evt.bytesused();
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name(
          "VIDIOC_QBUF minor=%" PRIu32 " seq=%" PRIu32 " type=%" PRIu32
          " index=%" PRIu32,
          evt.device_minor, evt.sequence, *evt.type, *evt.index);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      std::optional<SliceId> slice_id =
          AddSlice(buf_name_id, timestamp, pid, evt);

      uint64_t hash = base::Hasher::Combine(evt.device_minor, evt.sequence,
                                            *evt.type, *evt.index);

      QueuedBuffer queued_buffer;
      queued_buffer.queue_slice_id = slice_id;

      queued_buffers_.Insert(hash, std::move(queued_buffer));
      break;
    }
    case FtraceEvent::kV4l2DqbufFieldNumber: {
      V4l2DqbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = pb_evt.index();
      evt.type = pb_evt.type();
      evt.bytesused = pb_evt.bytesused();
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name(
          "VIDIOC_DQBUF minor=%" PRIu32 " seq=%" PRIu32 " type=%" PRIu32
          " index=%" PRIu32,
          evt.device_minor, evt.sequence, *evt.type, *evt.index);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      std::optional<SliceId> slice_id =
          AddSlice(buf_name_id, timestamp, pid, evt);

      uint64_t hash = base::Hasher::Combine(evt.device_minor, evt.sequence,
                                            *evt.type, *evt.index);

      const QueuedBuffer* queued_buffer = queued_buffers_.Find(hash);
      if (queued_buffer) {
        if (queued_buffer->queue_slice_id && slice_id) {
          context_->flow_tracker->InsertFlow(*queued_buffer->queue_slice_id,
                                             *slice_id);
        }

        queued_buffers_.Erase(hash);
      }
      break;
    }
    case FtraceEvent::kVb2V4l2BufQueueFieldNumber: {
      Vb2V4l2BufQueueFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = std::nullopt;
      evt.type = std::nullopt;
      evt.bytesused = std::nullopt;
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name("vb2_v4l2_buf_queue minor=%" PRIu32
                                     " seq=%" PRIu32 " type=0 index=0",
                                     evt.device_minor, evt.sequence);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      AddSlice(buf_name_id, timestamp, pid, evt);
      break;
    }
    case FtraceEvent::kVb2V4l2BufDoneFieldNumber: {
      Vb2V4l2BufDoneFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = std::nullopt;
      evt.type = std::nullopt;
      evt.bytesused = std::nullopt;
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name("vb2_v4l2_buf_done minor=%" PRIu32
                                     " seq=%" PRIu32 " type=0 index=0",
                                     evt.device_minor, evt.sequence);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      AddSlice(buf_name_id, timestamp, pid, evt);
      break;
    }
    case FtraceEvent::kVb2V4l2QbufFieldNumber: {
      Vb2V4l2QbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = std::nullopt;
      evt.type = std::nullopt;
      evt.bytesused = std::nullopt;
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name("vb2_v4l2_qbuf minor=%" PRIu32
                                     " seq=%" PRIu32 " type=0 index=0",
                                     evt.device_minor, evt.sequence);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      AddSlice(buf_name_id, timestamp, pid, evt);
      break;
    }
    case FtraceEvent::kVb2V4l2DqbufFieldNumber: {
      Vb2V4l2DqbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
      BufferEvent evt;
      evt.device_minor = pb_evt.minor();
      evt.index = std::nullopt;
      evt.type = std::nullopt;
      evt.bytesused = std::nullopt;
      evt.flags = pb_evt.flags();
      evt.field = pb_evt.field();
      evt.timestamp = pb_evt.timestamp();
      evt.sequence = pb_evt.sequence();
      evt.timecode_flags = pb_evt.timecode_flags();
      evt.timecode_frames = pb_evt.timecode_frames();
      evt.timecode_hours = pb_evt.timecode_hours();
      evt.timecode_minutes = pb_evt.timecode_minutes();
      evt.timecode_seconds = pb_evt.timecode_seconds();
      evt.timecode_type = pb_evt.timecode_type();
      evt.timecode_userbits0 = pb_evt.timecode_userbits0();
      evt.timecode_userbits1 = pb_evt.timecode_userbits1();
      evt.timecode_userbits2 = pb_evt.timecode_userbits2();
      evt.timecode_userbits3 = pb_evt.timecode_userbits3();

      base::StackString<64> buf_name("vb2_v4l2_qbuf minor=%" PRIu32
                                     " seq=%" PRIu32 " type=0 index=0",
                                     evt.device_minor, evt.sequence);

      StringId buf_name_id =
          context_->storage->InternString(buf_name.string_view());
      AddSlice(buf_name_id, timestamp, pid, evt);
      break;
    }
    default:
      break;
  }
}

std::optional<SliceId> V4l2Tracker::AddSlice(StringId buf_name_id,
                                             int64_t timestamp,
                                             uint32_t pid,
                                             const BufferEvent& evt) {
  UniqueTid utid = context_->process_tracker->GetOrCreateThread(pid);
  TrackId track_id = context_->track_tracker->InternThreadTrack(utid);

  std::optional<SliceId> slice_id = context_->slice_tracker->Scoped(
      timestamp, track_id, buf_event_ids_.v4l2, buf_name_id, 0,
      [this, &evt](ArgsTracker::BoundInserter* inserter) {
        this->AddArgs(evt, inserter);
      });

  return slice_id;
}

void V4l2Tracker::AddArgs(const BufferEvent& evt,
                          ArgsTracker::BoundInserter* inserter) {
  inserter->AddArg(buf_event_ids_.device_minor,
                   Variadic::Integer(evt.device_minor));

  if (evt.index)
    inserter->AddArg(buf_event_ids_.index, Variadic::Integer(*evt.index));
  if (evt.type)
    inserter->AddArg(buf_event_ids_.type,
                     Variadic::String(buf_type_ids_.Map(*evt.type)));
  if (evt.bytesused)
    inserter->AddArg(buf_event_ids_.bytesused,
                     Variadic::Integer(*evt.bytesused));

  inserter->AddArg(buf_event_ids_.flags,
                   Variadic::String(InternBufFlags(evt.flags)));
  inserter->AddArg(buf_event_ids_.field,
                   Variadic::String(buf_field_ids_.Map(evt.field)));
  inserter->AddArg(buf_event_ids_.timestamp, Variadic::Integer(evt.timestamp));
  inserter->AddArg(buf_event_ids_.timecode_type,
                   Variadic::String(tc_type_ids_.Map(evt.timecode_type)));
  inserter->AddArg(buf_event_ids_.timecode_flags,
                   Variadic::String(InternTcFlags(evt.timecode_flags)));
  inserter->AddArg(buf_event_ids_.timecode_frames,
                   Variadic::Integer(evt.timecode_frames));
  inserter->AddArg(buf_event_ids_.timecode_seconds,
                   Variadic::Integer(evt.timecode_seconds));
  inserter->AddArg(buf_event_ids_.timecode_minutes,
                   Variadic::Integer(evt.timecode_minutes));
  inserter->AddArg(buf_event_ids_.timecode_hours,
                   Variadic::Integer(evt.timecode_hours));
  inserter->AddArg(buf_event_ids_.timecode_userbits0,
                   Variadic::Integer(evt.timecode_userbits0));
  inserter->AddArg(buf_event_ids_.timecode_userbits1,
                   Variadic::Integer(evt.timecode_userbits1));
  inserter->AddArg(buf_event_ids_.timecode_userbits2,
                   Variadic::Integer(evt.timecode_userbits2));
  inserter->AddArg(buf_event_ids_.timecode_userbits3,
                   Variadic::Integer(evt.timecode_userbits3));
  inserter->AddArg(buf_event_ids_.sequence, Variadic::Integer(evt.sequence));
}

V4l2Tracker::BufferEventStringIds::BufferEventStringIds(TraceStorage& storage)
    : v4l2(storage.InternString("Video 4 Linux 2")),
      v4l2_qbuf(storage.InternString("v4l2_qbuf")),
      v4l2_dqbuf(storage.InternString("v4l2_dqbuf")),
      device_minor(storage.InternString("minor")),
      index(storage.InternString("index")),
      type(storage.InternString("type")),
      bytesused(storage.InternString("bytesused")),
      flags(storage.InternString("flags")),
      field(storage.InternString("field")),
      timestamp(storage.InternString("timestamp")),
      timecode_type(storage.InternString("timecode_type")),
      timecode_flags(storage.InternString("timecode_flags")),
      timecode_frames(storage.InternString("timecode_frames")),
      timecode_seconds(storage.InternString("timecode_seconds")),
      timecode_minutes(storage.InternString("timecode_minutes")),
      timecode_hours(storage.InternString("timecode_hours")),
      timecode_userbits0(storage.InternString("timecode_userbits0")),
      timecode_userbits1(storage.InternString("timecode_userbits1")),
      timecode_userbits2(storage.InternString("timecode_userbits2")),
      timecode_userbits3(storage.InternString("timecode_userbits3")),
      sequence(storage.InternString("sequence")) {}

V4l2Tracker::BufferTypeStringIds::BufferTypeStringIds(TraceStorage& storage)
    : video_capture(storage.InternString("VIDEO_CAPTURE")),
      video_output(storage.InternString("VIDEO_OUTPUT")),
      video_overlay(storage.InternString("VIDEO_OVERLAY")),
      vbi_capture(storage.InternString("VBI_CAPTURE")),
      vbi_output(storage.InternString("VBI_OUTPUT")),
      sliced_vbi_capture(storage.InternString("SLICED_VBI_CAPTURE")),
      sliced_vbi_output(storage.InternString("SLICED_VBI_OUTPUT")),
      video_output_overlay(storage.InternString("VIDEO_OUTPUT_OVERLAY")),
      video_capture_mplane(storage.InternString("VIDEO_CAPTURE_MPLANE")),
      video_output_mplane(storage.InternString("VIDEO_OUTPUT_MPLANE")),
      sdr_capture(storage.InternString("SDR_CAPTURE")),
      sdr_output(storage.InternString("SDR_OUTPUT")),
      meta_capture(storage.InternString("META_CAPTURE")),
      meta_output(storage.InternString("META_OUTPUT")),
      priv(storage.InternString("PRIVATE")) {}

StringId V4l2Tracker::BufferTypeStringIds::Map(uint32_t buf_type) {
  // Values taken from linux/videodev2.h
  switch (buf_type) {
    case 1:
      return video_capture;
    case 2:
      return video_output;
    case 3:
      return video_overlay;
    case 4:
      return vbi_capture;
    case 5:
      return vbi_output;
    case 6:
      return sliced_vbi_capture;
    case 7:
      return sliced_vbi_output;
    case 8:
      return video_output_overlay;
    case 9:
      return video_capture_mplane;
    case 10:
      return video_output_mplane;
    case 11:
      return sdr_capture;
    case 12:
      return sdr_output;
    case 13:
      return meta_capture;
    case 14:
      return meta_output;
    case 0x80:
      return priv;
    default:
      return kNullStringId;
  }
}

V4l2Tracker::BufferFieldStringIds::BufferFieldStringIds(TraceStorage& storage)
    : any(storage.InternString("ANY")),
      none(storage.InternString("NONE")),
      top(storage.InternString("TOP")),
      bottom(storage.InternString("BOTTOM")),
      interlaced(storage.InternString("INTERLACED")),
      seq_tb(storage.InternString("SEQ_TB")),
      seq_bt(storage.InternString("SEQ_BT")),
      alternate(storage.InternString("ALTERNATE")),
      interlaced_tb(storage.InternString("INTERLACED_TB")),
      interlaced_bt(storage.InternString("INTERLACED_BT")) {}

StringId V4l2Tracker::BufferFieldStringIds::Map(uint32_t field) {
  // Values taken from linux/videodev2.h
  switch (field) {
    case 0:
      return any;
    case 1:
      return none;
    case 2:
      return top;
    case 3:
      return bottom;
    case 4:
      return interlaced;
    case 5:
      return seq_tb;
    case 6:
      return seq_bt;
    case 7:
      return alternate;
    case 8:
      return interlaced_tb;
    case 9:
      return interlaced_bt;
    default:
      return kNullStringId;
  }
}

V4l2Tracker::TimecodeTypeStringIds::TimecodeTypeStringIds(TraceStorage& storage)
    : type_24fps(storage.InternString("24FPS")),
      type_25fps(storage.InternString("25FPS")),
      type_30fps(storage.InternString("30FPS")),
      type_50fps(storage.InternString("50FPS")),
      type_60fps(storage.InternString("60FPS")) {}

StringId V4l2Tracker::TimecodeTypeStringIds::Map(uint32_t type) {
  switch (type) {
    case 1:
      return type_24fps;
    case 2:
      return type_25fps;
    case 3:
      return type_30fps;
    case 4:
      return type_50fps;
    case 5:
      return type_60fps;
    default:
      return kNullStringId;
  }
}

StringId V4l2Tracker::InternBufFlags(uint32_t flags) {
  std::vector<std::string> present_flags;

  if (flags & 0x00000001)
    present_flags.push_back("MAPPED");
  if (flags & 0x00000002)
    present_flags.push_back("QUEUED");
  if (flags & 0x00000004)
    present_flags.push_back("DONE");
  if (flags & 0x00000008)
    present_flags.push_back("KEYFRAME");
  if (flags & 0x00000010)
    present_flags.push_back("PFRAME");
  if (flags & 0x00000020)
    present_flags.push_back("BFRAME");
  if (flags & 0x00000040)
    present_flags.push_back("ERROR");
  if (flags & 0x00000080)
    present_flags.push_back("IN_REQUEST");
  if (flags & 0x00000100)
    present_flags.push_back("TIMECODE");
  if (flags & 0x00000200)
    present_flags.push_back("M2M_HOLD_CAPTURE_BUF");
  if (flags & 0x00000400)
    present_flags.push_back("PREPARED");
  if (flags & 0x00000800)
    present_flags.push_back("NO_CACHE_INVALIDATE");
  if (flags & 0x00001000)
    present_flags.push_back("NO_CACHE_CLEAN");
  if (flags & 0x0000e000)
    present_flags.push_back("TIMESTAMP_MASK");
  if (flags == 0x00000000)
    present_flags.push_back("TIMESTAMP_UNKNOWN");
  if (flags & 0x00002000)
    present_flags.push_back("TIMESTAMP_MONOTONIC");
  if (flags & 0x00004000)
    present_flags.push_back("TIMESTAMP_COPY");
  if (flags & 0x00070000)
    present_flags.push_back("TSTAMP_SRC_MASK");
  if (flags == 0x00000000)
    present_flags.push_back("TSTAMP_SRC_EOF");
  if (flags & 0x00010000)
    present_flags.push_back("TSTAMP_SRC_SOE");
  if (flags & 0x00100000)
    present_flags.push_back("LAST");
  if (flags & 0x00800000)
    present_flags.push_back("REQUEST_FD");

  return context_->storage->InternString(
      base::Join(present_flags, "|").c_str());
}

StringId V4l2Tracker::InternTcFlags(uint32_t flags) {
  std::vector<std::string> present_flags;

  if (flags == 0x0000)
    present_flags.push_back("USERBITS_USERDEFINED");
  if (flags & 0x0001)
    present_flags.push_back("FLAG_DROPFRAME");
  if (flags & 0x0002)
    present_flags.push_back("FLAG_COLORFRAME");
  if ((flags & 0x000C) == 0x0004)
    present_flags.push_back("USERBITS_field(01)");
  if ((flags & 0x000C) == 0x0008)
    present_flags.push_back("USERBITS_field(10)");
  if ((flags & 0x000C) == 0x000C)
    present_flags.push_back("USERBITS_field(11)");
  if (flags & 0x0008)
    present_flags.push_back("USERBITS_8BITCHARS");

  return context_->storage->InternString(
      base::Join(present_flags, "|").c_str());
}

}  // namespace trace_processor
}  // namespace perfetto