// Copyright (c) 2012 The WebM project authors. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS.  All contributing project authors may
// be found in the AUTHORS file in the root of the source tree.
#include "encoder/win/video_sink_filter.h"

#include <dvdmedia.h>
#include <vfwmsgs.h>

#include "encoder/win/dshow_util.h"
#include "encoder/win/media_source_dshow.h"
#include "encoder/win/media_type_dshow.h"
#include "encoder/win/webm_guids.h"
#include "glog/logging.h"

namespace webmlive {

///////////////////////////////////////////////////////////////////////////////
// VideoSinkPin
//

VideoSinkPin::VideoSinkPin(TCHAR* ptr_object_name,
                           VideoSinkFilter* ptr_filter,
                           CCritSec* ptr_filter_lock,
                           HRESULT* ptr_result,
                           LPCWSTR ptr_pin_name)
    : CBaseInputPin(ptr_object_name,
                    ptr_filter,
                    ptr_filter_lock,
                    ptr_result,
                    ptr_pin_name) {
}

VideoSinkPin::~VideoSinkPin() {
}

// Returns preferred media type.
HRESULT VideoSinkPin::GetMediaType(int32 type_index,
                                   CMediaType* ptr_media_type) {
  if (type_index < 0 || !ptr_media_type) {
    return E_INVALIDARG;
  }
  if (type_index > 1) {
    return VFW_S_NO_MORE_ITEMS;
  }
  VIDEOINFOHEADER* const ptr_video_info =
      reinterpret_cast<VIDEOINFOHEADER*>(
          ptr_media_type->AllocFormatBuffer(sizeof(VIDEOINFOHEADER)));
  if (!ptr_video_info) {
    LOG(ERROR) << "VIDEOINFOHEADER alloc failed.";
    return E_OUTOFMEMORY;
  }
  ZeroMemory(ptr_video_info, sizeof(VIDEOINFOHEADER));
  ptr_video_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

  // Use empty source/dest rectangle-- the entire image is needed, and there is
  // no target subrect.
  SetRectEmpty(&ptr_video_info->rcSource);
  SetRectEmpty(&ptr_video_info->rcTarget);

  // Set values for all input types supported.
  ptr_media_type->SetType(&MEDIATYPE_Video);
  ptr_media_type->SetFormatType(&FORMAT_VideoInfo);
  ptr_media_type->SetTemporalCompression(FALSE);
  ptr_video_info->bmiHeader.biPlanes = 1;

  if (requested_config_.width != 0)
    ptr_video_info->bmiHeader.biWidth = requested_config_.width;
  if (requested_config_.height != 0)
    ptr_video_info->bmiHeader.biHeight = requested_config_.height;

  if (type_index == 0) {
    // Set sub type and format data for I420.
    ptr_video_info->bmiHeader.biCompression = MAKEFOURCC('I', '4', '2', '0');
    ptr_video_info->bmiHeader.biBitCount = kI420BitCount;
    ptr_media_type->SetSubtype(&MEDIASUBTYPE_I420);
  } else {
    // Set sub type and format data for YV12.
    ptr_video_info->bmiHeader.biCompression = MAKEFOURCC('Y', 'V', '1', '2');
    ptr_video_info->bmiHeader.biBitCount = kYV12BitCount;
    ptr_media_type->SetSubtype(&MEDIASUBTYPE_YV12);
  }

  // Set sample size.
  ptr_video_info->bmiHeader.biSizeImage = DIBSIZE(ptr_video_info->bmiHeader);
  ptr_media_type->SetSampleSize(ptr_video_info->bmiHeader.biSizeImage);
  LOG(INFO) << "\n GetMediaType type_index=" << type_index << "\n"
            << "   width=" << ptr_video_info->bmiHeader.biWidth << "\n"
            << "   height=" << ptr_video_info->bmiHeader.biHeight << "\n"
            << std::hex << "   biCompression="
            << ptr_video_info->bmiHeader.biCompression;
  return S_OK;
}

const BITMAPINFOHEADER* BitmapInfo(const GUID& format_guid,
                                   const uint8* ptr_format_blob,
                                   uint32 format_length) {
  const BITMAPINFOHEADER* ptr_header = NULL;
  if (ptr_format_blob) {
    if (format_guid == FORMAT_VideoInfo &&
        format_length >= sizeof(VIDEOINFOHEADER)) {
      const VIDEOINFOHEADER* ptr_video_info =
          reinterpret_cast<const VIDEOINFOHEADER*>(ptr_format_blob);
      ptr_header = &ptr_video_info->bmiHeader;
    } else if (format_guid == FORMAT_VideoInfo2 &&
               format_length >= sizeof(VIDEOINFOHEADER2)) {
      const VIDEOINFOHEADER2* ptr_video_info =
          reinterpret_cast<const VIDEOINFOHEADER2*>(ptr_format_blob);
      ptr_header = &ptr_video_info->bmiHeader;
    }
  }
  return ptr_header;
}

// Confirms that |ptr_media_type| is VIDEOINFOHEADER or VIDEOINFOHEADER2 and
// has a subtype of MEDIASUBTYPE_I420.
HRESULT VideoSinkPin::CheckMediaType(const CMediaType* ptr_media_type) {
  // Confirm media type is acceptable.
  const GUID* const ptr_type_guid = ptr_media_type->Type();
  if (!ptr_type_guid || *ptr_type_guid != MEDIATYPE_Video) {
    return VFW_E_TYPE_NOT_ACCEPTED;
  }

  // Confirm that subtype and formattype GUIDs can be obtained.
  const GUID* const ptr_subtype_guid = ptr_media_type->Subtype();
  const GUID* const ptr_format_guid = ptr_media_type->FormatType();
  if (!ptr_subtype_guid || !ptr_format_guid) {
      return E_INVALIDARG;
  }

  const GUID& format_guid = *ptr_format_guid;
  const GUID& subtype_guid = *ptr_subtype_guid;

  // Confirm that the subtype is acceptable.
  if (!AcceptableSubType(subtype_guid)) {
    return VFW_E_TYPE_NOT_ACCEPTED;
  }

  // Obtain access to the BITMAPINFOHEADER, and confirm that the video format
  // is acceptable.
  const uint8* ptr_format = ptr_media_type->Format();
  const uint32 format_length = ptr_media_type->FormatLength();
  const BITMAPINFOHEADER* ptr_header =
      BitmapInfo(format_guid, ptr_format, format_length);
  if (ptr_header) {
    if (FourCCToVideoFormat(ptr_header->biCompression,
                            ptr_header->biBitCount,
                            &actual_config_.format)) {
      // |ptr_media_type| contains a video frame with a pixel format that is
      // acceptable-- store format information.
      actual_config_.width = ptr_header->biWidth;
      actual_config_.height = ptr_header->biHeight;

      // Store the stride for use with |VideoFrame::Init()|-- it's needed for
      // format conversion.
      actual_config_.stride = DIBWIDTHBYTES(*ptr_header);
    }
  }

  LOG(INFO) << "\n CheckMediaType actual video settings\n"
            << "   width=" << actual_config_.width << "\n"
            << "   height=" << actual_config_.height << "\n"
            << "   stride=" << actual_config_.stride << "\n"
            << "   format=" << actual_config_.format;
  return S_OK;
}

// Calls CBaseInputPin::Receive and then passes |ptr_sample| to
// |VideoSinkFilter::OnFrameReceived|.
HRESULT VideoSinkPin::Receive(IMediaSample* ptr_sample) {
  CHECK_NOTNULL(m_pFilter);
  CHECK_NOTNULL(ptr_sample);
  VideoSinkFilter* ptr_filter = reinterpret_cast<VideoSinkFilter*>(m_pFilter);
  CAutoLock lock(&ptr_filter->filter_lock_);
  HRESULT hr = CBaseInputPin::Receive(ptr_sample);
  if (FAILED(hr)) {
    if (hr != VFW_E_WRONG_STATE) {
      // Log the error only when it is not |VFW_E_WRONG_STATE|. The filter
      // graph appears to always call |Receive()| once after |Stop()|.
      LOG(ERROR) << "CBaseInputPin::Receive failed. " << HRLOG(hr);
    }
    return hr;
  }
  hr = ptr_filter->OnFrameReceived(ptr_sample);
  if (FAILED(hr)) {
    LOG(ERROR) << "OnFrameReceived failed. " << HRLOG(hr);
  }
  return S_OK;
}

bool VideoSinkPin::AcceptableSubType(const GUID& media_sub_type) {
  return (media_sub_type == MEDIASUBTYPE_I420 ||
          media_sub_type == MEDIASUBTYPE_YV12 ||
          media_sub_type == MEDIASUBTYPE_YUY2 ||
          media_sub_type == MEDIASUBTYPE_YUYV ||
          media_sub_type == MEDIASUBTYPE_UYVY ||
          media_sub_type == MEDIASUBTYPE_RGB24 ||
          media_sub_type == MEDIASUBTYPE_RGB32);
}

// Copies |actual_config_| to |ptr_config|. Note that the filter lock is always
// held by caller, |VideoSinkFilter::config|.
HRESULT VideoSinkPin::config(VideoConfig* ptr_config) const {
  if (!ptr_config) {
    return E_POINTER;
  }
  *ptr_config = actual_config_;
  return S_OK;
}

// Sets |requested_config_| and resets |actual_config_|. Filter lock always
// held by caller, |VideoSinkFilter::set_config|.
HRESULT VideoSinkPin::set_config(const VideoConfig& config) {
  requested_config_ = config;
  actual_config_ = VideoConfig();
  return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
// VideoSinkFilter
//
VideoSinkFilter::VideoSinkFilter(
    const TCHAR* ptr_filter_name,
    LPUNKNOWN ptr_iunknown,
    VideoFrameCallbackInterface* ptr_frame_callback,
    HRESULT* ptr_result)
    : CBaseFilter(ptr_filter_name,
                  ptr_iunknown,
                  &filter_lock_,
                  CLSID_VideoSinkFilter) {
  if (!ptr_frame_callback) {
    *ptr_result = E_INVALIDARG;
    return;
  }
  ptr_frame_callback_ = ptr_frame_callback;
  sink_pin_.reset(
      new (std::nothrow) VideoSinkPin(NAME("VideoSinkInputPin"),  // NOLINT
                                      this, &filter_lock_, ptr_result,
                                      L"VideoSink"));
  if (!sink_pin_) {
    *ptr_result = E_OUTOFMEMORY;
  } else {
    *ptr_result = S_OK;
  }
}

VideoSinkFilter::~VideoSinkFilter() {
}

// Locks filter and returns |VideoSinkPin::config|.
HRESULT VideoSinkFilter::config(VideoConfig* ptr_config) const {
  CAutoLock lock(&filter_lock_);
  return sink_pin_->config(ptr_config);
}

// Locks filter and returns |VideoSinkPin::set_config|.
HRESULT VideoSinkFilter::set_config(const VideoConfig& config) {
  if (m_State != State_Stopped) {
    return VFW_E_NOT_STOPPED;
  }
  CAutoLock lock(&filter_lock_);
  return sink_pin_->set_config(config);
}

// Locks filter and returns VideoSinkPin pointer wrapped by |sink_pin_|.
CBasePin* VideoSinkFilter::GetPin(int index) {
  CBasePin* ptr_pin = NULL;
  CAutoLock lock(&filter_lock_);
  if (index == 0) {
    ptr_pin = sink_pin_.get();
  }
  return ptr_pin;
}

// Lock owned by |VideoSinkPin::Receive|. Copies buffer from |ptr_sample| into
// |frame_|, and then passes |frame_| to
// |VideoFrameCallbackInterface::OnVideoFrameReceived|.
HRESULT VideoSinkFilter::OnFrameReceived(IMediaSample* ptr_sample) {
  if (!ptr_sample) {
    return E_POINTER;
  }
  BYTE* ptr_sample_buffer = NULL;
  HRESULT hr = ptr_sample->GetPointer(&ptr_sample_buffer);
  if (FAILED(hr) || !ptr_sample_buffer) {
    LOG(ERROR) << "OnFrameReceived called with empty sample.";
    hr = (hr == S_OK) ? E_FAIL : hr;
    return hr;
  }
  int64 timestamp = 0;
  int64 duration = 0;
  REFERENCE_TIME start_time = 0;
  REFERENCE_TIME end_time = 0;
  hr = ptr_sample->GetTime(&start_time, &end_time);
  if (FAILED(hr)) {
    LOG(ERROR) << "OnFrameReceived cannot get media time(s)." << HRLOG(hr);
    return hr;
  }
  timestamp = media_time_to_milliseconds(start_time);
  if (hr != VFW_S_NO_STOP_TIME) {
    duration = media_time_to_milliseconds(end_time) - timestamp;
  } else {
    LOG(WARNING) << "OnFrameReceived using time per frame for duration.";
    AM_MEDIA_TYPE media_type = {0};
    hr = sink_pin_->ConnectionMediaType(&media_type);
    if (FAILED(hr)) {
      LOG(ERROR) << "OnFrameReceived pin has no media type: " << HRLOG(hr);
      return hr;
    }
    VideoMediaType video_format;
    if (video_format.Init(media_type)) {
      LOG(ERROR) << "OnFrameReceived cannot Init VideoMediaType.";
      return E_FAIL;
    }
    duration = media_time_to_milliseconds(video_format.avg_time_per_frame());
  }

  // TODO(tomfinegan): Write an allocator that retrieves frames from
  //                   |WebmEncoder::EncoderThread| and avoid this extra copy.

  const int status = frame_.Init(sink_pin_->actual_config_,
                                 true,  // always "keyframes"
                                 timestamp,
                                 duration,
                                 ptr_sample_buffer,
                                 ptr_sample->GetActualDataLength());
  if (status) {
    LOG(ERROR) << "OnFrameReceived frame init failed: " << status;
    return E_FAIL;
  }
  LOG(INFO) << "OnFrameReceived received a frame:"
            << " width="  << sink_pin_->actual_config_.width
            << " height=" << sink_pin_->actual_config_.height
            << " format=" << sink_pin_->actual_config_.format
            << " stride=" << sink_pin_->actual_config_.stride
            << " timestamp(sec)=" << (timestamp / 1000.0)
            << " timestamp="      << timestamp
            << " duration(sec)= " << (duration / 1000.0)
            << " duration= "      << duration
            << " size=" << frame_.buffer_length();
  int frame_status = ptr_frame_callback_->OnVideoFrameReceived(&frame_);
  if (frame_status && frame_status != VideoFrameCallbackInterface::kDropped) {
    LOG(ERROR) << "OnVideoFrameReceived failed, status=" << frame_status;
  }
  return S_OK;
}

}  // namespace webmlive