// Copyright 2017 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. //#define LOG_NDEBUG 0 #define LOG_TAG "C2VDAAdaptor" #include <C2VDAAdaptor.h> #include <bitstream_buffer.h> #include <native_pixmap_handle.h> #include <v4l2_device.h> #include <v4l2_video_decode_accelerator.h> #include <video_pixel_format.h> #include <utils/Log.h> namespace android { C2VDAAdaptor::C2VDAAdaptor() : mNumOutputBuffers(0u) {} C2VDAAdaptor::~C2VDAAdaptor() { if (mVDA) { destroy(); } } VideoDecodeAcceleratorAdaptor::Result C2VDAAdaptor::initialize( media::VideoCodecProfile profile, bool secureMode, VideoDecodeAcceleratorAdaptor::Client* client) { // TODO: use secureMode here, or ignore? if (mVDA) { ALOGE("Re-initialize() is not allowed"); return ILLEGAL_STATE; } media::VideoDecodeAccelerator::Config config; config.profile = profile; config.output_mode = media::VideoDecodeAccelerator::Config::OutputMode::IMPORT; // TODO(johnylin): may need to implement factory to create VDA if there are multiple VDA // implementations in the future. scoped_refptr<media::V4L2Device> device = new media::V4L2Device(); std::unique_ptr<media::VideoDecodeAccelerator> vda( new media::V4L2VideoDecodeAccelerator(device)); if (!vda->Initialize(config, this)) { ALOGE("Failed to initialize VDA"); return PLATFORM_FAILURE; } mVDA = std::move(vda); mClient = client; return SUCCESS; } void C2VDAAdaptor::decode(int32_t bitstreamId, int ashmemFd, off_t offset, uint32_t bytesUsed) { CHECK(mVDA); mVDA->Decode(media::BitstreamBuffer(bitstreamId, base::SharedMemoryHandle(ashmemFd, true), bytesUsed, offset)); } void C2VDAAdaptor::assignPictureBuffers(uint32_t numOutputBuffers) { CHECK(mVDA); std::vector<media::PictureBuffer> buffers; for (uint32_t id = 0; id < numOutputBuffers; ++id) { buffers.push_back(media::PictureBuffer(static_cast<int32_t>(id), mPictureSize)); } mVDA->AssignPictureBuffers(buffers); mNumOutputBuffers = numOutputBuffers; } void C2VDAAdaptor::importBufferForPicture(int32_t pictureBufferId, HalPixelFormat format, int dmabufFd, const std::vector<VideoFramePlane>& planes) { CHECK(mVDA); CHECK_LT(pictureBufferId, static_cast<int32_t>(mNumOutputBuffers)); media::VideoPixelFormat pixelFormat; switch (format) { case HalPixelFormat::YV12: pixelFormat = media::PIXEL_FORMAT_YV12; break; case HalPixelFormat::NV12: pixelFormat = media::PIXEL_FORMAT_NV12; break; default: LOG_ALWAYS_FATAL("Unsupported format: 0x%x", format); return; } media::NativePixmapHandle handle; handle.fds.emplace_back(base::FileDescriptor(dmabufFd, true)); for (const auto& plane : planes) { handle.planes.emplace_back(plane.mStride, plane.mOffset, 0, 0); } mVDA->ImportBufferForPicture(pictureBufferId, pixelFormat, handle); } void C2VDAAdaptor::reusePictureBuffer(int32_t pictureBufferId) { CHECK(mVDA); CHECK_LT(pictureBufferId, static_cast<int32_t>(mNumOutputBuffers)); mVDA->ReusePictureBuffer(pictureBufferId); } void C2VDAAdaptor::flush() { CHECK(mVDA); mVDA->Flush(); } void C2VDAAdaptor::reset() { CHECK(mVDA); mVDA->Reset(); } void C2VDAAdaptor::destroy() { mVDA.reset(nullptr); mNumOutputBuffers = 0u; mPictureSize = media::Size(); } //static media::VideoDecodeAccelerator::SupportedProfiles C2VDAAdaptor::GetSupportedProfiles( InputCodec inputCodec) { // TODO(johnylin): use factory function to determine whether V4L2 stream or slice API is. uint32_t inputFormatFourcc; if (inputCodec == InputCodec::H264) { inputFormatFourcc = V4L2_PIX_FMT_H264; } else if (inputCodec == InputCodec::VP8) { inputFormatFourcc = V4L2_PIX_FMT_VP8; } else { // InputCodec::VP9 inputFormatFourcc = V4L2_PIX_FMT_VP9; } media::VideoDecodeAccelerator::SupportedProfiles supportedProfiles; auto allProfiles = media::V4L2VideoDecodeAccelerator::GetSupportedProfiles(); for (const auto& profile : allProfiles) { if (inputFormatFourcc == media::V4L2Device::VideoCodecProfileToV4L2PixFmt(profile.profile)) { supportedProfiles.push_back(profile); } } return supportedProfiles; } void C2VDAAdaptor::ProvidePictureBuffers(uint32_t requested_num_of_buffers, media::VideoPixelFormat output_format, const media::Size& dimensions) { // per change ag/3262504, output_format from VDA is no longer used, component side always // allocate graphic buffers for flexible YUV format. (void)output_format; mClient->providePictureBuffers(requested_num_of_buffers, dimensions); mPictureSize = dimensions; } void C2VDAAdaptor::DismissPictureBuffer(int32_t picture_buffer_id) { mClient->dismissPictureBuffer(picture_buffer_id); } void C2VDAAdaptor::PictureReady(const media::Picture& picture) { mClient->pictureReady(picture.picture_buffer_id(), picture.bitstream_buffer_id(), picture.visible_rect()); } void C2VDAAdaptor::NotifyEndOfBitstreamBuffer(int32_t bitstream_buffer_id) { mClient->notifyEndOfBitstreamBuffer(bitstream_buffer_id); } void C2VDAAdaptor::NotifyFlushDone() { mClient->notifyFlushDone(); } void C2VDAAdaptor::NotifyResetDone() { mClient->notifyResetDone(); } static VideoDecodeAcceleratorAdaptor::Result convertErrorCode( media::VideoDecodeAccelerator::Error error) { switch (error) { case media::VideoDecodeAccelerator::ILLEGAL_STATE: return VideoDecodeAcceleratorAdaptor::ILLEGAL_STATE; case media::VideoDecodeAccelerator::INVALID_ARGUMENT: return VideoDecodeAcceleratorAdaptor::INVALID_ARGUMENT; case media::VideoDecodeAccelerator::UNREADABLE_INPUT: return VideoDecodeAcceleratorAdaptor::UNREADABLE_INPUT; case media::VideoDecodeAccelerator::PLATFORM_FAILURE: return VideoDecodeAcceleratorAdaptor::PLATFORM_FAILURE; default: ALOGE("Unknown error code: %d", static_cast<int>(error)); return VideoDecodeAcceleratorAdaptor::PLATFORM_FAILURE; } } void C2VDAAdaptor::NotifyError(media::VideoDecodeAccelerator::Error error) { mClient->notifyError(convertErrorCode(error)); } } // namespace android