webm_video_client.cc

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include <packager/media/formats/webm/webm_video_client.h>
 
#include <absl/log/log.h>
 
#include <packager/macros/logging.h>
#include <packager/media/base/buffer_writer.h>
#include <packager/media/base/fourccs.h>
#include <packager/media/base/video_util.h>
#include <packager/media/codecs/av1_codec_configuration_record.h>
#include <packager/media/codecs/vp_codec_configuration_record.h>
#include <packager/media/formats/webm/webm_constants.h>
 
namespace {
 
// Timestamps are represented in double in WebM. Convert to int64_t in us.
const int32_t kWebMTimeScale = 1000000;
 
}  // namespace
 
namespace shaka {
namespace media {
 
WebMVideoClient::WebMVideoClient() {}
 
WebMVideoClient::~WebMVideoClient() {}
 
void WebMVideoClient::Reset() {
  pixel_width_ = -1;
  pixel_height_ = -1;
  crop_bottom_ = -1;
  crop_top_ = -1;
  crop_left_ = -1;
  crop_right_ = -1;
  display_width_ = -1;
  display_height_ = -1;
  display_unit_ = -1;
  alpha_mode_ = -1;
 
  matrix_coefficients_ = -1;
  bits_per_channel_ = -1;
  chroma_subsampling_horz_ = -1;
  chroma_subsampling_vert_ = -1;
  chroma_siting_horz_ = -1;
  chroma_siting_vert_ = -1;
  color_range_ = -1;
  transfer_characteristics_ = -1;
  color_primaries_ = -1;
}
 
std::shared_ptr<VideoStreamInfo> WebMVideoClient::GetVideoStreamInfo(
    int64_t track_num,
    const std::string& codec_id,
    const std::vector<uint8_t>& codec_private,
    bool is_encrypted) {
  std::string codec_string;
  Codec video_codec = kUnknownCodec;
  if (codec_id == "V_AV1") {
    video_codec = kCodecAV1;
 
    // CodecPrivate is mandatory per AV in Matroska / WebM specification.
    // https://github.com/Matroska-Org/matroska-specification/blob/av1-mappin/codec/av1.md#codecprivate-1
    AV1CodecConfigurationRecord av1_config;
    if (!av1_config.Parse(codec_private)) {
      LOG(ERROR) << "Failed to parse AV1 codec_private.";
      return nullptr;
    }
    codec_string = av1_config.GetCodecString();
  } else if (codec_id == "V_VP8") {
    video_codec = kCodecVP8;
    // codec_string for VP8 is parsed later.
  } else if (codec_id == "V_VP9") {
    video_codec = kCodecVP9;
    // codec_string for VP9 is parsed later.
  } else {
    LOG(ERROR) << "Unsupported video codec_id " << codec_id;
    return nullptr;
  }
 
  if (pixel_width_ <= 0 || pixel_height_ <= 0)
    return nullptr;
 
  // Set crop and display unit defaults if these elements are not present.
  if (crop_bottom_ == -1)
    crop_bottom_ = 0;
 
  if (crop_top_ == -1)
    crop_top_ = 0;
 
  if (crop_left_ == -1)
    crop_left_ = 0;
 
  if (crop_right_ == -1)
    crop_right_ = 0;
 
  if (display_unit_ == -1)
    display_unit_ = 0;
 
  uint16_t width_after_crop = pixel_width_ - (crop_left_ + crop_right_);
  uint16_t height_after_crop = pixel_height_ - (crop_top_ + crop_bottom_);
 
  if (display_unit_ == 0) {
    if (display_width_ <= 0)
      display_width_ = width_after_crop;
    if (display_height_ <= 0)
      display_height_ = height_after_crop;
  } else if (display_unit_ == 3) {
    if (display_width_ <= 0 || display_height_ <= 0)
      return nullptr;
  } else {
    LOG(ERROR) << "Unsupported display unit type " << display_unit_;
    return nullptr;
  }
 
  // Calculate sample aspect ratio.
  uint32_t pixel_width;
  uint32_t pixel_height;
  DerivePixelWidthHeight(width_after_crop, height_after_crop, display_width_,
                         display_height_, &pixel_width, &pixel_height);
 
  // |codec_private| may be overriden later for some codecs, e.g. VP9 since for
  // VP9, the format for MP4 and WebM are different; MP4 format is used as the
  // intermediate format.
  auto video_stream_info = std::make_shared<VideoStreamInfo>(
      track_num, kWebMTimeScale, 0, video_codec, H26xStreamFormat::kUnSpecified,
      codec_string, codec_private.data(), codec_private.size(),
      width_after_crop, height_after_crop, pixel_width, pixel_height, 0, 0, 0,
      0, 0, std::string(), is_encrypted);
 
  // Set colr box data for VP8/VP9 codecs
  if ((video_codec == kCodecVP8 || video_codec == kCodecVP9) &&
      HasColorInfo()) {
    std::vector<uint8_t> colr_data = GenerateColrBoxData();
    if (!colr_data.empty()) {
      video_stream_info->set_colr_data(colr_data.data(), colr_data.size());
    }
  }
 
  return video_stream_info;
}
 
VPCodecConfigurationRecord WebMVideoClient::GetVpCodecConfig(
    const std::vector<uint8_t>& codec_private) {
  VPCodecConfigurationRecord vp_config;
  vp_config.ParseWebM(codec_private);
  if (matrix_coefficients_ != -1) {
    vp_config.set_matrix_coefficients(matrix_coefficients_);
  }
  if (bits_per_channel_ != -1) {
    vp_config.set_bit_depth(bits_per_channel_);
  }
  if (chroma_subsampling_horz_ != -1 && chroma_subsampling_vert_ != -1) {
    vp_config.SetChromaSubsampling(chroma_subsampling_horz_,
                                   chroma_subsampling_vert_);
  }
  if (chroma_siting_horz_ != -1 && chroma_siting_vert_ != -1) {
    vp_config.SetChromaLocation(chroma_siting_horz_, chroma_siting_vert_);
  }
  if (color_range_ != -1) {
    if (color_range_ == 0)
      vp_config.set_video_full_range_flag(false);
    else if (color_range_ == 1)
      vp_config.set_video_full_range_flag(true);
    // Ignore for other values.
  }
  if (transfer_characteristics_ != -1) {
    vp_config.set_transfer_characteristics(transfer_characteristics_);
  }
  if (color_primaries_ != -1) {
    vp_config.set_color_primaries(color_primaries_);
  }
  return vp_config;
}
 
WebMParserClient* WebMVideoClient::OnListStart(int id) {
  return id == kWebMIdColor || id == kWebMIdProjection
             ? this
             : WebMParserClient::OnListStart(id);
}
 
bool WebMVideoClient::OnListEnd(int id) {
  return id == kWebMIdColor || id == kWebMIdProjection
             ? true
             : WebMParserClient::OnListEnd(id);
}
 
bool WebMVideoClient::OnUInt(int id, int64_t val) {
  int64_t* dst = nullptr;
 
  switch (id) {
    case kWebMIdPixelWidth:
      dst = &pixel_width_;
      break;
    case kWebMIdPixelHeight:
      dst = &pixel_height_;
      break;
    case kWebMIdPixelCropTop:
      dst = &crop_top_;
      break;
    case kWebMIdPixelCropBottom:
      dst = &crop_bottom_;
      break;
    case kWebMIdPixelCropLeft:
      dst = &crop_left_;
      break;
    case kWebMIdPixelCropRight:
      dst = &crop_right_;
      break;
    case kWebMIdDisplayWidth:
      dst = &display_width_;
      break;
    case kWebMIdDisplayHeight:
      dst = &display_height_;
      break;
    case kWebMIdDisplayUnit:
      dst = &display_unit_;
      break;
    case kWebMIdAlphaMode:
      dst = &alpha_mode_;
      break;
    case kWebMIdColorMatrixCoefficients:
      dst = &matrix_coefficients_;
      break;
    case kWebMIdColorBitsPerChannel:
      dst = &bits_per_channel_;
      break;
    case kWebMIdColorChromaSubsamplingHorz:
      dst = &chroma_subsampling_horz_;
      break;
    case kWebMIdColorChromaSubsamplingVert:
      dst = &chroma_subsampling_vert_;
      break;
    case kWebMIdColorChromaSitingHorz:
      dst = &chroma_siting_horz_;
      break;
    case kWebMIdColorChromaSitingVert:
      dst = &chroma_siting_vert_;
      break;
    case kWebMIdColorRange:
      dst = &color_range_;
      break;
    case kWebMIdColorTransferCharacteristics:
      dst = &transfer_characteristics_;
      break;
    case kWebMIdColorPrimaries:
      dst = &color_primaries_;
      break;
    case kWebMIdColorMaxCLL:
    case kWebMIdColorMaxFALL:
      NOTIMPLEMENTED() << "HDR is not supported yet.";
      return true;
    case kWebMIdProjectionType:
      LOG(WARNING) << "Ignoring ProjectionType with value " << val;
      return true;
    default:
      return true;
  }
 
  if (*dst != -1) {
    LOG(ERROR) << "Multiple values for id " << std::hex << id << " specified ("
               << *dst << " and " << val << ")";
    return false;
  }
 
  *dst = val;
  return true;
}
 
bool WebMVideoClient::OnBinary(int /*id*/,
                               const uint8_t* /*data*/,
                               int /*size*/) {
  // Accept binary fields we don't care about for now.
  return true;
}
 
bool WebMVideoClient::OnFloat(int /*id*/, double /*val*/) {
  // Accept float fields we don't care about for now.
  return true;
}
 
bool WebMVideoClient::HasColorInfo() const {
  return color_range_ != -1 || color_primaries_ != -1 ||
         transfer_characteristics_ != -1 || matrix_coefficients_ != -1;
}
 
std::vector<uint8_t> WebMVideoClient::GenerateColrBoxData() const {
  BufferWriter writer;
 
  writer.AppendInt(static_cast<uint32_t>(0));  // Size placeholder
  writer.AppendInt(FOURCC_colr);
  writer.AppendInt(FOURCC_nclx);
 
  // Use BT.709 as default when not specified
  uint16_t primaries =
      (color_primaries_ != -1) ? static_cast<uint16_t>(color_primaries_) : 1;
  uint16_t transfer = (transfer_characteristics_ != -1)
                          ? static_cast<uint16_t>(transfer_characteristics_)
                          : 1;
  uint16_t matrix = (matrix_coefficients_ != -1)
                        ? static_cast<uint16_t>(matrix_coefficients_)
                        : 1;
 
  writer.AppendInt(primaries);
  writer.AppendInt(transfer);
  writer.AppendInt(matrix);
 
  // WebM color_range: 0 = limited range, 1 = full range
  uint8_t full_range_flag = 0;
  if (color_range_ != -1) {
    full_range_flag = (color_range_ == 1) ? 1 : 0;
  }
  writer.AppendInt(full_range_flag);
 
  const uint8_t* buffer = writer.Buffer();
  size_t buffer_size = writer.Size();
 
  std::vector<uint8_t> data(buffer, buffer + buffer_size);
  uint32_t box_size = static_cast<uint32_t>(data.size());
 
  // Update size field in big-endian
  data[0] = (box_size >> 24) & 0xFF;
  data[1] = (box_size >> 16) & 0xFF;
  data[2] = (box_size >> 8) & 0xFF;
  data[3] = box_size & 0xFF;
 
  return data;
}
 
}  // namespace media
}  // namespace shaka