v4l2_codec2: Adapt VideoPixelFormat code to Android standards.
This CL reworks the VideoPixelFormat class that was branched
from Chrome:
- Removed all Chrome-specific references from comments
- Removed specific numbering as we don't need compatibility with Chrome
- Removed deprecated formats
- Adhere to the Android coding style.
- Make use of Android logging mechanisms.
- Make use of Android assert macros.
Bug: 155138142
Test: arc.VideoEncodeAccel.h264_192p_i420_vm
Change-Id: I8387af0b427ebc990ec6374432f18ad732894569
diff --git a/common/FormatConverter.cpp b/common/FormatConverter.cpp
index 7e9c2e5..d694bd1 100644
--- a/common/FormatConverter.cpp
+++ b/common/FormatConverter.cpp
@@ -29,9 +29,8 @@
namespace {
// The constant expression of mapping the pixel format conversion pair (src, dst) to a unique
// integer.
-constexpr int convertMap(media::VideoPixelFormat src, media::VideoPixelFormat dst) {
- return static_cast<int>(src) *
- (static_cast<int>(media::VideoPixelFormat::PIXEL_FORMAT_MAX) + 1) +
+constexpr int convertMap(VideoPixelFormat src, VideoPixelFormat dst) {
+ return static_cast<int>(src) * (static_cast<int>(VideoPixelFormat::UNKNOWN) + 1) +
static_cast<int>(dst);
}
@@ -93,12 +92,11 @@
}
// static
-std::unique_ptr<FormatConverter> FormatConverter::Create(media::VideoPixelFormat outFormat,
+std::unique_ptr<FormatConverter> FormatConverter::Create(VideoPixelFormat outFormat,
const ui::Size& visibleSize,
uint32_t inputCount,
const ui::Size& codedSize) {
- if (outFormat != media::VideoPixelFormat::PIXEL_FORMAT_I420 &&
- outFormat != media::VideoPixelFormat::PIXEL_FORMAT_NV12) {
+ if (outFormat != VideoPixelFormat::I420 && outFormat != VideoPixelFormat::NV12) {
ALOGE("Unsupported output format: %d", static_cast<int32_t>(outFormat));
return nullptr;
}
@@ -111,11 +109,10 @@
return converter;
}
-c2_status_t FormatConverter::initialize(media::VideoPixelFormat outFormat,
- const ui::Size& visibleSize, uint32_t inputCount,
- const ui::Size& codedSize) {
+c2_status_t FormatConverter::initialize(VideoPixelFormat outFormat, const ui::Size& visibleSize,
+ uint32_t inputCount, const ui::Size& codedSize) {
ALOGV("initialize(out_format=%s, visible_size=%dx%d, input_count=%u, coded_size=%dx%d)",
- media::VideoPixelFormatToString(outFormat).c_str(), visibleSize.width, visibleSize.height,
+ videoPixelFormatToString(outFormat).c_str(), visibleSize.width, visibleSize.height,
inputCount, codedSize.width, codedSize.height);
std::shared_ptr<C2BlockPool> pool;
@@ -126,7 +123,7 @@
}
HalPixelFormat halFormat;
- if (outFormat == media::VideoPixelFormat::PIXEL_FORMAT_I420) {
+ if (outFormat == VideoPixelFormat::I420) {
// Android HAL format doesn't have I420, we use YV12 instead and swap U and V data while
// conversion to perform I420.
halFormat = HalPixelFormat::YV12;
@@ -201,7 +198,7 @@
const int dstStrideV = outputLayout.planes[C2PlanarLayout::PLANE_U].rowInc; // only for I420
const int dstStrideUV = outputLayout.planes[C2PlanarLayout::PLANE_U].rowInc; // only for NV12
- media::VideoPixelFormat inputFormat = media::VideoPixelFormat::PIXEL_FORMAT_UNKNOWN;
+ VideoPixelFormat inputFormat = VideoPixelFormat::UNKNOWN;
*status = C2_OK;
if (inputLayout.type == C2PlanarLayout::TYPE_YUV) {
const uint8_t* srcY = inputView.data()[C2PlanarLayout::PLANE_Y];
@@ -211,10 +208,9 @@
const int srcStrideU = inputLayout.planes[C2PlanarLayout::PLANE_U].rowInc;
const int srcStrideV = inputLayout.planes[C2PlanarLayout::PLANE_V].rowInc;
if (inputLayout.rootPlanes == 3) {
- inputFormat = media::VideoPixelFormat::PIXEL_FORMAT_YV12;
+ inputFormat = VideoPixelFormat::YV12;
} else if (inputLayout.rootPlanes == 2) {
- inputFormat = (srcV > srcU) ? media::VideoPixelFormat::PIXEL_FORMAT_NV12
- : media::VideoPixelFormat::PIXEL_FORMAT_NV21;
+ inputFormat = (srcV > srcU) ? VideoPixelFormat::NV12 : VideoPixelFormat::NV21;
}
if (inputFormat == mOutFormat) {
@@ -224,32 +220,28 @@
}
switch (convertMap(inputFormat, mOutFormat)) {
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_YV12,
- media::VideoPixelFormat::PIXEL_FORMAT_I420):
+ case convertMap(VideoPixelFormat::YV12, VideoPixelFormat::I420):
libyuv::I420Copy(srcY, srcStrideY, srcU, srcStrideU, srcV, srcStrideV, dstY, dstStrideY,
dstU, dstStrideU, dstV, dstStrideV, mVisibleSize.width,
mVisibleSize.height);
break;
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_YV12,
- media::VideoPixelFormat::PIXEL_FORMAT_NV12):
+ case convertMap(VideoPixelFormat::YV12, VideoPixelFormat::NV12):
libyuv::I420ToNV12(srcY, srcStrideY, srcU, srcStrideU, srcV, srcStrideV, dstY,
dstStrideY, dstUV, dstStrideUV, mVisibleSize.width,
mVisibleSize.height);
break;
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_NV12,
- media::VideoPixelFormat::PIXEL_FORMAT_I420):
+ case convertMap(VideoPixelFormat::NV12, VideoPixelFormat::I420):
libyuv::NV12ToI420(srcY, srcStrideY, srcU, srcStrideU, dstY, dstStrideY, dstU,
dstStrideU, dstV, dstStrideV, mVisibleSize.width,
mVisibleSize.height);
break;
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_NV21,
- media::VideoPixelFormat::PIXEL_FORMAT_I420):
+ case convertMap(VideoPixelFormat::NV21, VideoPixelFormat::I420):
libyuv::NV21ToI420(srcY, srcStrideY, srcV, srcStrideV, dstY, dstStrideY, dstU,
dstStrideU, dstV, dstStrideV, mVisibleSize.width,
mVisibleSize.height);
break;
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_NV21,
- media::VideoPixelFormat::PIXEL_FORMAT_NV12):
+ case convertMap(VideoPixelFormat::NV21, VideoPixelFormat::NV12):
+ ALOGV("%s(): Converting PIXEL_FORMAT_NV21 -> PIXEL_FORMAT_NV12", __func__);
libyuv::CopyPlane(srcY, srcStrideY, dstY, dstStrideY, mVisibleSize.width,
mVisibleSize.height);
copyPlaneByPixel(srcU, srcStrideU, 2, dstUV, dstStrideUV, 2, mVisibleSize.width / 2,
@@ -259,28 +251,26 @@
break;
default:
ALOGE("Unsupported pixel format conversion from %s to %s",
- media::VideoPixelFormatToString(inputFormat).c_str(),
- media::VideoPixelFormatToString(mOutFormat).c_str());
+ videoPixelFormatToString(inputFormat).c_str(),
+ videoPixelFormatToString(mOutFormat).c_str());
*status = C2_CORRUPTED;
return inputBlock; // This is actually redundant and should not be used.
}
} else if (inputLayout.type == C2PlanarLayout::TYPE_RGB) {
// There is only RGBA_8888 specified in C2AllocationGralloc::map(), no BGRA_8888. Maybe
// BGRA_8888 is not used now?
- inputFormat = media::VideoPixelFormat::PIXEL_FORMAT_ABGR;
+ inputFormat = VideoPixelFormat::ABGR;
const uint8_t* srcRGB = (idMap) ? idMap->addr() : inputView.data()[C2PlanarLayout::PLANE_R];
const int srcStrideRGB =
(idMap) ? idMap->rowInc() : inputLayout.planes[C2PlanarLayout::PLANE_R].rowInc;
switch (convertMap(inputFormat, mOutFormat)) {
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_ABGR,
- media::VideoPixelFormat::PIXEL_FORMAT_I420):
+ case convertMap(VideoPixelFormat::ABGR, VideoPixelFormat::I420):
libyuv::ABGRToI420(srcRGB, srcStrideRGB, dstY, dstStrideY, dstU, dstStrideU, dstV,
dstStrideV, mVisibleSize.width, mVisibleSize.height);
break;
- case convertMap(media::VideoPixelFormat::PIXEL_FORMAT_ABGR,
- media::VideoPixelFormat::PIXEL_FORMAT_NV12): {
+ case convertMap(VideoPixelFormat::ABGR, VideoPixelFormat::NV12): {
// There is no libyuv function to convert ABGR to NV12. Therefore, we first convert to
// I420 on dst-Y plane and temporary U/V plane. Then we copy U and V pixels from
// temporary planes to dst-UV interleavedly.
@@ -295,8 +285,8 @@
}
default:
ALOGE("Unsupported pixel format conversion from %s to %s",
- media::VideoPixelFormatToString(inputFormat).c_str(),
- media::VideoPixelFormatToString(mOutFormat).c_str());
+ videoPixelFormatToString(inputFormat).c_str(),
+ videoPixelFormatToString(mOutFormat).c_str());
*status = C2_CORRUPTED;
return inputBlock; // This is actually redundant and should not be used.
}
@@ -307,7 +297,7 @@
}
ALOGV("convertBlock(frame_index=%" PRIu64 ", format=%s)", frameIndex,
- media::VideoPixelFormatToString(inputFormat).c_str());
+ videoPixelFormatToString(inputFormat).c_str());
entry->mAssociatedFrameIndex = frameIndex;
mAvailableQueue.pop();
return outputBlock->share(C2Rect(mVisibleSize.width, mVisibleSize.height), C2Fence());
diff --git a/common/Fourcc.cpp b/common/Fourcc.cpp
index 71120f8..f7d3efd 100644
--- a/common/Fourcc.cpp
+++ b/common/Fourcc.cpp
@@ -36,128 +36,128 @@
case MM21:
return Fourcc(static_cast<Value>(fourcc));
}
- ALOGE("Unmapped fourcc: %s", media::FourccToString(fourcc).c_str());
+ ALOGE("Unmapped fourcc: %s", fourccToString(fourcc).c_str());
return std::nullopt;
}
// static
-std::optional<Fourcc> Fourcc::fromVideoPixelFormat(media::VideoPixelFormat pixelFormat,
+std::optional<Fourcc> Fourcc::fromVideoPixelFormat(VideoPixelFormat pixelFormat,
bool singlePlanar) {
if (singlePlanar) {
switch (pixelFormat) {
- case media::PIXEL_FORMAT_ARGB:
+ case VideoPixelFormat::ARGB:
return Fourcc(AR24);
- case media::PIXEL_FORMAT_ABGR:
+ case VideoPixelFormat::ABGR:
return Fourcc(AB24);
- case media::PIXEL_FORMAT_XRGB:
+ case VideoPixelFormat::XRGB:
return Fourcc(XR24);
- case media::PIXEL_FORMAT_XBGR:
+ case VideoPixelFormat::XBGR:
return Fourcc(XB24);
- case media::PIXEL_FORMAT_BGRA:
+ case VideoPixelFormat::BGRA:
return Fourcc(RGB4);
- case media::PIXEL_FORMAT_I420:
+ case VideoPixelFormat::I420:
return Fourcc(YU12);
- case media::PIXEL_FORMAT_YV12:
+ case VideoPixelFormat::YV12:
return Fourcc(YV12);
- case media::PIXEL_FORMAT_YUY2:
+ case VideoPixelFormat::YUY2:
return Fourcc(YUYV);
- case media::PIXEL_FORMAT_NV12:
+ case VideoPixelFormat::NV12:
return Fourcc(NV12);
- case media::PIXEL_FORMAT_NV21:
+ case VideoPixelFormat::NV21:
return Fourcc(NV21);
- case media::PIXEL_FORMAT_I422:
- case media::PIXEL_FORMAT_I420A:
- case media::PIXEL_FORMAT_I444:
- case media::PIXEL_FORMAT_RGB24:
- case media::PIXEL_FORMAT_MJPEG:
- case media::PIXEL_FORMAT_YUV420P9:
- case media::PIXEL_FORMAT_YUV420P10:
- case media::PIXEL_FORMAT_YUV422P9:
- case media::PIXEL_FORMAT_YUV422P10:
- case media::PIXEL_FORMAT_YUV444P9:
- case media::PIXEL_FORMAT_YUV444P10:
- case media::PIXEL_FORMAT_YUV420P12:
- case media::PIXEL_FORMAT_YUV422P12:
- case media::PIXEL_FORMAT_YUV444P12:
- case media::PIXEL_FORMAT_Y16:
- case media::PIXEL_FORMAT_P016LE:
- case media::PIXEL_FORMAT_XR30:
- case media::PIXEL_FORMAT_XB30:
- case media::PIXEL_FORMAT_UNKNOWN:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::P016LE:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ case VideoPixelFormat::UNKNOWN:
break;
}
} else {
switch (pixelFormat) {
- case media::PIXEL_FORMAT_I420:
+ case VideoPixelFormat::I420:
return Fourcc(YM12);
- case media::PIXEL_FORMAT_YV12:
+ case VideoPixelFormat::YV12:
return Fourcc(YM21);
- case media::PIXEL_FORMAT_NV12:
+ case VideoPixelFormat::NV12:
return Fourcc(NM12);
- case media::PIXEL_FORMAT_I422:
+ case VideoPixelFormat::I422:
return Fourcc(YM16);
- case media::PIXEL_FORMAT_NV21:
+ case VideoPixelFormat::NV21:
return Fourcc(NM21);
- case media::PIXEL_FORMAT_I420A:
- case media::PIXEL_FORMAT_I444:
- case media::PIXEL_FORMAT_YUY2:
- case media::PIXEL_FORMAT_ARGB:
- case media::PIXEL_FORMAT_XRGB:
- case media::PIXEL_FORMAT_RGB24:
- case media::PIXEL_FORMAT_MJPEG:
- case media::PIXEL_FORMAT_YUV420P9:
- case media::PIXEL_FORMAT_YUV420P10:
- case media::PIXEL_FORMAT_YUV422P9:
- case media::PIXEL_FORMAT_YUV422P10:
- case media::PIXEL_FORMAT_YUV444P9:
- case media::PIXEL_FORMAT_YUV444P10:
- case media::PIXEL_FORMAT_YUV420P12:
- case media::PIXEL_FORMAT_YUV422P12:
- case media::PIXEL_FORMAT_YUV444P12:
- case media::PIXEL_FORMAT_Y16:
- case media::PIXEL_FORMAT_ABGR:
- case media::PIXEL_FORMAT_XBGR:
- case media::PIXEL_FORMAT_P016LE:
- case media::PIXEL_FORMAT_XR30:
- case media::PIXEL_FORMAT_XB30:
- case media::PIXEL_FORMAT_BGRA:
- case media::PIXEL_FORMAT_UNKNOWN:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::P016LE:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::UNKNOWN:
break;
}
}
- ALOGE("Unmapped %s for %s", VideoPixelFormatToString(pixelFormat).c_str(),
+ ALOGE("Unmapped %s for %s", videoPixelFormatToString(pixelFormat).c_str(),
singlePlanar ? "single-planar" : "multi-planar");
return std::nullopt;
}
-media::VideoPixelFormat Fourcc::toVideoPixelFormat() const {
+VideoPixelFormat Fourcc::toVideoPixelFormat() const {
switch (mValue) {
case AR24:
- return media::PIXEL_FORMAT_ARGB;
+ return VideoPixelFormat::ARGB;
case AB24:
- return media::PIXEL_FORMAT_ABGR;
+ return VideoPixelFormat::ABGR;
case XR24:
- return media::PIXEL_FORMAT_XRGB;
+ return VideoPixelFormat::XRGB;
case XB24:
- return media::PIXEL_FORMAT_XBGR;
+ return VideoPixelFormat::XBGR;
case RGB4:
- return media::PIXEL_FORMAT_BGRA;
+ return VideoPixelFormat::BGRA;
case YU12:
case YM12:
- return media::PIXEL_FORMAT_I420;
+ return VideoPixelFormat::I420;
case YV12:
case YM21:
- return media::PIXEL_FORMAT_YV12;
+ return VideoPixelFormat::YV12;
case YUYV:
- return media::PIXEL_FORMAT_YUY2;
+ return VideoPixelFormat::YUY2;
case NV12:
case NM12:
- return media::PIXEL_FORMAT_NV12;
+ return VideoPixelFormat::NV12;
case NV21:
case NM21:
- return media::PIXEL_FORMAT_NV21;
+ return VideoPixelFormat::NV21;
case YM16:
- return media::PIXEL_FORMAT_I422;
+ return VideoPixelFormat::I422;
// V4L2_PIX_FMT_MT21C is only used for MT8173 hardware video decoder output
// and should be converted by MT8173 image processor for compositor to
// render. Since it is an intermediate format for video decoder,
@@ -170,11 +170,11 @@
// similar to V4L2_PIX_FMT_MT21C but is not compressed ; thus it can also
// be mapped to PIXEL_FORMAT_NV12.
case MM21:
- return media::PIXEL_FORMAT_NV12;
+ return VideoPixelFormat::NV12;
}
ALOGE("Unmapped Fourcc: %s", toString().c_str());
- return media::PIXEL_FORMAT_UNKNOWN;
+ return VideoPixelFormat::UNKNOWN;
}
// static
@@ -247,7 +247,7 @@
}
std::string Fourcc::toString() const {
- return media::FourccToString(static_cast<uint32_t>(mValue));
+ return fourccToString(static_cast<uint32_t>(mValue));
}
static_assert(Fourcc::AR24 == V4L2_PIX_FMT_ABGR32, "Mismatch Fourcc");
diff --git a/common/V4L2Device.cpp b/common/V4L2Device.cpp
index cd07f22..a31d82b 100644
--- a/common/V4L2Device.cpp
+++ b/common/V4L2Device.cpp
@@ -1101,7 +1101,7 @@
std::string path = getDevicePathFor(type, v4l2PixFmt);
if (path.empty()) {
- ALOGE("No devices supporting %s for type: %u", media::FourccToString(v4l2PixFmt).c_str(),
+ ALOGE("No devices supporting %s for type: %u", fourccToString(v4l2PixFmt).c_str(),
static_cast<uint32_t>(type));
return false;
}
@@ -1356,7 +1356,7 @@
}
break;
default:
- ALOGE("Unhandled pixelformat %s", media::FourccToString(pixFmt).c_str());
+ ALOGE("Unhandled pixelformat %s", fourccToString(pixFmt).c_str());
return {};
}
@@ -1442,7 +1442,7 @@
ui::Size V4L2Device::allocatedSizeFromV4L2Format(const struct v4l2_format& format) {
ui::Size codedSize;
ui::Size visibleSize;
- media::VideoPixelFormat frameFormat = media::PIXEL_FORMAT_UNKNOWN;
+ VideoPixelFormat frameFormat = VideoPixelFormat::UNKNOWN;
size_t bytesPerLine = 0;
// Total bytes in the frame.
size_t sizeimage = 0;
@@ -1458,7 +1458,7 @@
const uint32_t pixFmt = format.fmt.pix_mp.pixelformat;
const auto frameFourcc = Fourcc::fromV4L2PixFmt(pixFmt);
if (!frameFourcc) {
- ALOGE("Unsupported format %s", media::FourccToString(pixFmt).c_str());
+ ALOGE("Unsupported format %s", fourccToString(pixFmt).c_str());
return codedSize;
}
frameFormat = frameFourcc->toVideoPixelFormat();
@@ -1470,10 +1470,10 @@
const uint32_t fourcc = format.fmt.pix.pixelformat;
const auto frameFourcc = Fourcc::fromV4L2PixFmt(fourcc);
if (!frameFourcc) {
- ALOGE("Unsupported format %s", media::FourccToString(fourcc).c_str());
+ ALOGE("Unsupported format %s", fourccToString(fourcc).c_str());
return codedSize;
}
- frameFormat = frameFourcc ? frameFourcc->toVideoPixelFormat() : media::PIXEL_FORMAT_UNKNOWN;
+ frameFormat = frameFourcc ? frameFourcc->toVideoPixelFormat() : VideoPixelFormat::UNKNOWN;
}
// V4L2 does not provide per-plane bytesperline (bpl) when different components are sharing one
@@ -1485,12 +1485,12 @@
// elsewhere to calculate coded height.
// We need bits per pixel for one component only to calculate the coded width from bytesperline.
- int planeHorizBitsPerPixel = media::PlaneHorizontalBitsPerPixel(frameFormat, 0);
+ int planeHorizBitsPerPixel = planeHorizontalBitsPerPixel(frameFormat, 0);
// Adding up bpp for each component will give us total bpp for all components.
int totalBpp = 0;
- for (size_t i = 0; i < media::NumPlanes(frameFormat); ++i)
- totalBpp += media::PlaneBitsPerPixel(frameFormat, i);
+ for (size_t i = 0; i < numPlanes(frameFormat); ++i)
+ totalBpp += planeBitsPerPixel(frameFormat, i);
if (sizeimage == 0 || bytesPerLine == 0 || planeHorizBitsPerPixel == 0 || totalBpp == 0 ||
(bytesPerLine * 8) % planeHorizBitsPerPixel != 0) {
@@ -1509,8 +1509,8 @@
// Sanity checks. Calculated coded size has to contain given visible size and fulfill buffer
// byte size requirements.
- ALOG_ASSERT(media::Rect(codedSize).Contains(media::Rect(visibleSize)));
- ALOG_ASSERT(sizeimage <= media::AllocationSize(frameFormat, codedSize));
+ ALOG_ASSERT(Rect(codedSize).Contains(Rect(visibleSize)));
+ ALOG_ASSERT(sizeimage <= allocationSize(frameFormat, codedSize));
return codedSize;
}
@@ -1555,7 +1555,7 @@
// single-planar
const struct v4l2_pix_format& pix = format.fmt.pix;
s << ", width_height: " << toString(ui::Size(pix.width, pix.height))
- << ", pixelformat: " << media::FourccToString(pix.pixelformat) << ", field: " << pix.field
+ << ", pixelformat: " << fourccToString(pix.pixelformat) << ", field: " << pix.field
<< ", bytesperline: " << pix.bytesperline << ", sizeimage: " << pix.sizeimage;
} else if (V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
const struct v4l2_pix_format_mplane& pixMp = format.fmt.pix_mp;
@@ -1563,8 +1563,7 @@
// integer, which is not what we want. Casting pix_mp.num_planes unsigned int solves the
// issue.
s << ", width_height: " << toString(ui::Size(pixMp.width, pixMp.height))
- << ", pixelformat: " << media::FourccToString(pixMp.pixelformat)
- << ", field: " << pixMp.field
+ << ", pixelformat: " << fourccToString(pixMp.pixelformat) << ", field: " << pixMp.field
<< ", num_planes: " << static_cast<unsigned int>(pixMp.num_planes);
for (size_t i = 0; i < pixMp.num_planes; ++i) {
const struct v4l2_plane_pix_format& plane_fmt = pixMp.plane_fmt[i];
@@ -1624,20 +1623,20 @@
const auto videoFourcc = Fourcc::fromV4L2PixFmt(pixFmt);
if (!videoFourcc) {
ALOGE("Failed to convert pixel format to VideoPixelFormat: %s",
- media::FourccToString(pixFmt).c_str());
+ fourccToString(pixFmt).c_str());
return std::nullopt;
}
- const media::VideoPixelFormat videoFormat = videoFourcc->toVideoPixelFormat();
+ const VideoPixelFormat videoFormat = videoFourcc->toVideoPixelFormat();
const size_t numBuffers = pixMp.num_planes;
- const size_t numColorPlanes = media::NumPlanes(videoFormat);
+ const size_t numColorPlanes = numPlanes(videoFormat);
if (numColorPlanes == 0) {
ALOGE("Unsupported video format for NumPlanes(): %s",
- VideoPixelFormatToString(videoFormat).c_str());
+ videoPixelFormatToString(videoFormat).c_str());
return std::nullopt;
}
if (numBuffers > numColorPlanes) {
ALOGE("pix_mp.num_planes: %zu should not be larger than NumPlanes(%s): %zu", numBuffers,
- VideoPixelFormatToString(videoFormat).c_str(), numColorPlanes);
+ videoPixelFormatToString(videoFormat).c_str(), numColorPlanes);
return std::nullopt;
}
// Reserve capacity in advance to prevent unnecessary vector reallocation.
@@ -1680,7 +1679,7 @@
}
default:
ALOGE("Cannot derive stride for each plane for pixel format %s",
- media::FourccToString(pixFmt).c_str());
+ fourccToString(pixFmt).c_str());
return std::nullopt;
}
}
@@ -1693,7 +1692,7 @@
size_t V4L2Device::getNumPlanesOfV4L2PixFmt(uint32_t pixFmt) {
std::optional<Fourcc> fourcc = Fourcc::fromV4L2PixFmt(pixFmt);
if (fourcc && fourcc->isMultiPlanar()) {
- return media::NumPlanes(fourcc->toVideoPixelFormat());
+ return numPlanes(fourcc->toVideoPixelFormat());
}
return 1u;
}
@@ -1728,13 +1727,13 @@
maxResolution->set(1920, 1088);
ALOGE("GetSupportedResolution failed to get maximum resolution for fourcc %s, "
"fall back to %s",
- media::FourccToString(pixelFormat).c_str(), toString(*maxResolution).c_str());
+ fourccToString(pixelFormat).c_str(), toString(*maxResolution).c_str());
}
if (isEmpty(*minResolution)) {
minResolution->set(16, 16);
ALOGE("GetSupportedResolution failed to get minimum resolution for fourcc %s, "
"fall back to %s",
- media::FourccToString(pixelFormat).c_str(), toString(*minResolution).c_str());
+ fourccToString(pixelFormat).c_str(), toString(*minResolution).c_str());
}
}
diff --git a/common/VideoPixelFormat.cpp b/common/VideoPixelFormat.cpp
index ec75873..f175c26 100644
--- a/common/VideoPixelFormat.cpp
+++ b/common/VideoPixelFormat.cpp
@@ -6,382 +6,366 @@
#include <v4l2_codec2/common/VideoPixelFormat.h>
-#include "base/bits.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "base/strings/stringprintf.h"
+#include <base/bits.h>
+#include <utils/Log.h>
-namespace media {
+namespace android {
namespace {
enum {
- kMaxPlanes = 4,
- kYPlane = 0,
- kARGBPlane = kYPlane,
- kUPlane = 1,
- kUVPlane = kUPlane,
- kVPlane = 2,
- kAPlane = 3,
- };
-
+ kMaxPlanes = 4,
+ kYPlane = 0,
+ kARGBPlane = kYPlane,
+ kUPlane = 1,
+ kUVPlane = kUPlane,
+ kVPlane = 2,
+ kAPlane = 3,
+};
}
-std::string VideoPixelFormatToString(VideoPixelFormat format) {
- switch (format) {
- case PIXEL_FORMAT_UNKNOWN:
- return "PIXEL_FORMAT_UNKNOWN";
- case PIXEL_FORMAT_I420:
- return "PIXEL_FORMAT_I420";
- case PIXEL_FORMAT_YV12:
- return "PIXEL_FORMAT_YV12";
- case PIXEL_FORMAT_I422:
- return "PIXEL_FORMAT_I422";
- case PIXEL_FORMAT_I420A:
- return "PIXEL_FORMAT_I420A";
- case PIXEL_FORMAT_I444:
- return "PIXEL_FORMAT_I444";
- case PIXEL_FORMAT_NV12:
- return "PIXEL_FORMAT_NV12";
- case PIXEL_FORMAT_NV21:
- return "PIXEL_FORMAT_NV21";
- case PIXEL_FORMAT_YUY2:
- return "PIXEL_FORMAT_YUY2";
- case PIXEL_FORMAT_ARGB:
- return "PIXEL_FORMAT_ARGB";
- case PIXEL_FORMAT_XRGB:
- return "PIXEL_FORMAT_XRGB";
- case PIXEL_FORMAT_RGB24:
- return "PIXEL_FORMAT_RGB24";
- case PIXEL_FORMAT_MJPEG:
- return "PIXEL_FORMAT_MJPEG";
- case PIXEL_FORMAT_YUV420P9:
- return "PIXEL_FORMAT_YUV420P9";
- case PIXEL_FORMAT_YUV420P10:
- return "PIXEL_FORMAT_YUV420P10";
- case PIXEL_FORMAT_YUV422P9:
- return "PIXEL_FORMAT_YUV422P9";
- case PIXEL_FORMAT_YUV422P10:
- return "PIXEL_FORMAT_YUV422P10";
- case PIXEL_FORMAT_YUV444P9:
- return "PIXEL_FORMAT_YUV444P9";
- case PIXEL_FORMAT_YUV444P10:
- return "PIXEL_FORMAT_YUV444P10";
- case PIXEL_FORMAT_YUV420P12:
- return "PIXEL_FORMAT_YUV420P12";
- case PIXEL_FORMAT_YUV422P12:
- return "PIXEL_FORMAT_YUV422P12";
- case PIXEL_FORMAT_YUV444P12:
- return "PIXEL_FORMAT_YUV444P12";
- case PIXEL_FORMAT_Y16:
- return "PIXEL_FORMAT_Y16";
- case PIXEL_FORMAT_ABGR:
- return "PIXEL_FORMAT_ABGR";
- case PIXEL_FORMAT_XBGR:
- return "PIXEL_FORMAT_XBGR";
- case PIXEL_FORMAT_P016LE:
- return "PIXEL_FORMAT_P016LE";
- case PIXEL_FORMAT_XR30:
- return "PIXEL_FORMAT_XR30";
- case PIXEL_FORMAT_XB30:
- return "PIXEL_FORMAT_XB30";
- case PIXEL_FORMAT_BGRA:
- return "PIXEL_FORMAT_BGRA";
- }
- NOTREACHED() << "Invalid VideoPixelFormat provided: " << format;
- return "";
+std::string videoPixelFormatToString(VideoPixelFormat format) {
+ switch (format) {
+ case VideoPixelFormat::I420:
+ return "I420";
+ case VideoPixelFormat::YV12:
+ return "YV12";
+ case VideoPixelFormat::I422:
+ return "I422";
+ case VideoPixelFormat::I420A:
+ return "I420A";
+ case VideoPixelFormat::I444:
+ return "I444";
+ case VideoPixelFormat::NV12:
+ return "NV12";
+ case VideoPixelFormat::NV21:
+ return "NV21";
+ case VideoPixelFormat::YUY2:
+ return "YUY2";
+ case VideoPixelFormat::ARGB:
+ return "ARGB";
+ case VideoPixelFormat::XRGB:
+ return "XRGB";
+ case VideoPixelFormat::RGB24:
+ return "RGB24";
+ case VideoPixelFormat::MJPEG:
+ return "MJPEG";
+ case VideoPixelFormat::YUV420P9:
+ return "YUV420P9";
+ case VideoPixelFormat::YUV420P10:
+ return "YUV420P10";
+ case VideoPixelFormat::YUV422P9:
+ return "YUV422P9";
+ case VideoPixelFormat::YUV422P10:
+ return "YUV422P10";
+ case VideoPixelFormat::YUV444P9:
+ return "YUV444P9";
+ case VideoPixelFormat::YUV444P10:
+ return "YUV444P10";
+ case VideoPixelFormat::YUV420P12:
+ return "YUV420P12";
+ case VideoPixelFormat::YUV422P12:
+ return "YUV422P12";
+ case VideoPixelFormat::YUV444P12:
+ return "YUV444P12";
+ case VideoPixelFormat::Y16:
+ return "Y16";
+ case VideoPixelFormat::ABGR:
+ return "ABGR";
+ case VideoPixelFormat::XBGR:
+ return "XBGR";
+ case VideoPixelFormat::P016LE:
+ return "P016LE";
+ case VideoPixelFormat::XR30:
+ return "XR30";
+ case VideoPixelFormat::XB30:
+ return "XB30";
+ case VideoPixelFormat::BGRA:
+ return "BGRA";
+ case VideoPixelFormat::UNKNOWN:
+ return "UNKNOWN";
+ }
}
-std::string FourccToString(uint32_t fourcc) {
- std::string result = "0000";
- for (size_t i = 0; i < 4; ++i, fourcc >>= 8) {
- const char c = static_cast<char>(fourcc & 0xFF);
- if (c <= 0x1f || c >= 0x7f)
- return base::StringPrintf("0x%x", fourcc);
- result[i] = c;
- }
- return result;
+std::string fourccToString(uint32_t fourcc) {
+ std::string result = "0000";
+ for (size_t i = 0; i < 4; ++i, fourcc >>= 8) {
+ const char c = static_cast<char>(fourcc & 0xFF);
+ if (c <= 0x1f || c >= 0x7f) {
+ return (std::stringstream("0x") << std::hex << fourcc).str();
+ }
+ result[i] = c;
+ }
+ return result;
}
-size_t BitDepth(VideoPixelFormat format) {
- switch (format) {
- case PIXEL_FORMAT_UNKNOWN:
- NOTREACHED();
- FALLTHROUGH;
- case PIXEL_FORMAT_I420:
- case PIXEL_FORMAT_YV12:
- case PIXEL_FORMAT_I422:
- case PIXEL_FORMAT_I420A:
- case PIXEL_FORMAT_I444:
- case PIXEL_FORMAT_NV12:
- case PIXEL_FORMAT_NV21:
- case PIXEL_FORMAT_YUY2:
- case PIXEL_FORMAT_ARGB:
- case PIXEL_FORMAT_XRGB:
- case PIXEL_FORMAT_RGB24:
- case PIXEL_FORMAT_MJPEG:
- case PIXEL_FORMAT_ABGR:
- case PIXEL_FORMAT_XBGR:
- case PIXEL_FORMAT_BGRA:
- return 8;
- case PIXEL_FORMAT_YUV420P9:
- case PIXEL_FORMAT_YUV422P9:
- case PIXEL_FORMAT_YUV444P9:
- return 9;
- case PIXEL_FORMAT_YUV420P10:
- case PIXEL_FORMAT_YUV422P10:
- case PIXEL_FORMAT_YUV444P10:
- case PIXEL_FORMAT_XR30:
- case PIXEL_FORMAT_XB30:
- return 10;
- case PIXEL_FORMAT_YUV420P12:
- case PIXEL_FORMAT_YUV422P12:
- case PIXEL_FORMAT_YUV444P12:
- return 12;
- case PIXEL_FORMAT_Y16:
- case PIXEL_FORMAT_P016LE:
- return 16;
- }
- NOTREACHED();
- return 0;
+size_t bitDepth(VideoPixelFormat format) {
+ switch (format) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::YV12:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::NV21:
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::BGRA:
+ return 8;
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV444P9:
+ return 9;
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ return 10;
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ return 12;
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::P016LE:
+ return 16;
+ case VideoPixelFormat::UNKNOWN:
+ ALOGE("Invalid pixel format");
+ return 0;
+ }
}
// If it is required to allocate aligned to multiple-of-two size overall for the
// frame of pixel |format|.
static bool RequiresEvenSizeAllocation(VideoPixelFormat format) {
- switch (format) {
- case PIXEL_FORMAT_ARGB:
- case PIXEL_FORMAT_XRGB:
- case PIXEL_FORMAT_RGB24:
- case PIXEL_FORMAT_Y16:
- case PIXEL_FORMAT_ABGR:
- case PIXEL_FORMAT_XBGR:
- case PIXEL_FORMAT_XR30:
- case PIXEL_FORMAT_XB30:
- case PIXEL_FORMAT_BGRA:
- return false;
- case PIXEL_FORMAT_NV12:
- case PIXEL_FORMAT_NV21:
- case PIXEL_FORMAT_I420:
- case PIXEL_FORMAT_MJPEG:
- case PIXEL_FORMAT_YUY2:
- case PIXEL_FORMAT_YV12:
- case PIXEL_FORMAT_I422:
- case PIXEL_FORMAT_I444:
- case PIXEL_FORMAT_YUV420P9:
- case PIXEL_FORMAT_YUV422P9:
- case PIXEL_FORMAT_YUV444P9:
- case PIXEL_FORMAT_YUV420P10:
- case PIXEL_FORMAT_YUV422P10:
- case PIXEL_FORMAT_YUV444P10:
- case PIXEL_FORMAT_YUV420P12:
- case PIXEL_FORMAT_YUV422P12:
- case PIXEL_FORMAT_YUV444P12:
- case PIXEL_FORMAT_I420A:
- case PIXEL_FORMAT_P016LE:
- return true;
- case PIXEL_FORMAT_UNKNOWN:
- break;
- }
- NOTREACHED() << "Unsupported video frame format: " << format;
- return false;
-}
-
-size_t NumPlanes(VideoPixelFormat format) {
- switch (format) {
- case PIXEL_FORMAT_YUY2:
- case PIXEL_FORMAT_ARGB:
- case PIXEL_FORMAT_BGRA:
- case PIXEL_FORMAT_XRGB:
- case PIXEL_FORMAT_RGB24:
- case PIXEL_FORMAT_MJPEG:
- case PIXEL_FORMAT_Y16:
- case PIXEL_FORMAT_ABGR:
- case PIXEL_FORMAT_XBGR:
- case PIXEL_FORMAT_XR30:
- case PIXEL_FORMAT_XB30:
- return 1;
- case PIXEL_FORMAT_NV12:
- case PIXEL_FORMAT_NV21:
- case PIXEL_FORMAT_P016LE:
- return 2;
- case PIXEL_FORMAT_I420:
- case PIXEL_FORMAT_YV12:
- case PIXEL_FORMAT_I422:
- case PIXEL_FORMAT_I444:
- case PIXEL_FORMAT_YUV420P9:
- case PIXEL_FORMAT_YUV422P9:
- case PIXEL_FORMAT_YUV444P9:
- case PIXEL_FORMAT_YUV420P10:
- case PIXEL_FORMAT_YUV422P10:
- case PIXEL_FORMAT_YUV444P10:
- case PIXEL_FORMAT_YUV420P12:
- case PIXEL_FORMAT_YUV422P12:
- case PIXEL_FORMAT_YUV444P12:
- return 3;
- case PIXEL_FORMAT_I420A:
- return 4;
- case PIXEL_FORMAT_UNKNOWN:
- // Note: PIXEL_FORMAT_UNKNOWN is used for end-of-stream frame.
- // Set its NumPlanes() to zero to avoid NOTREACHED().
- return 0;
- }
- NOTREACHED() << "Unsupported video frame format: " << format;
- return 0;
-}
-
-size_t AllocationSize(VideoPixelFormat format,
- const android::ui::Size& coded_size) {
- size_t total = 0;
- for (size_t i = 0; i < NumPlanes(format); ++i) {
- android::ui::Size plane_size = PlaneSize(format, i, coded_size);
- total += (plane_size.width * plane_size.height);
- }
-
- return total;
-}
-
-android::ui::Size PlaneSize(VideoPixelFormat format,
- size_t plane,
- const android::ui::Size& coded_size) {
- DCHECK(IsValidPlane(plane, format));
-
- int width = coded_size.width;
- int height = coded_size.height;
- if (RequiresEvenSizeAllocation(format)) {
- // Align to multiple-of-two size overall. This ensures that non-subsampled
- // planes can be addressed by pixel with the same scaling as the subsampled
- // planes.
- width = base::bits::Align(width, 2);
- height = base::bits::Align(height, 2);
- }
-
- const android::ui::Size subsample = SampleSize(format, plane);
- DCHECK(width % subsample.width == 0);
- DCHECK(height % subsample.height == 0);
- return android::ui::Size(BytesPerElement(format, plane) * width / subsample.width,
- height / subsample.height);
-}
-
-int PlaneHorizontalBitsPerPixel(VideoPixelFormat format,
- size_t plane) {
- DCHECK(IsValidPlane(plane, format));
- const int bits_per_element = 8 * BytesPerElement(format, plane);
- const int horiz_pixels_per_element = SampleSize(format, plane).width;
- DCHECK_EQ(bits_per_element % horiz_pixels_per_element, 0);
- return bits_per_element / horiz_pixels_per_element;
-}
-
-int PlaneBitsPerPixel(VideoPixelFormat format, size_t plane) {
- DCHECK(IsValidPlane(plane, format));
- return PlaneHorizontalBitsPerPixel(format, plane) /
- SampleSize(format, plane).height;
-}
-
-int BytesPerElement(VideoPixelFormat format, size_t plane) {
- DCHECK(IsValidPlane(format, plane));
- switch (format) {
- case PIXEL_FORMAT_ARGB:
- case PIXEL_FORMAT_BGRA:
- case PIXEL_FORMAT_XRGB:
- case PIXEL_FORMAT_ABGR:
- case PIXEL_FORMAT_XBGR:
- case PIXEL_FORMAT_XR30:
- case PIXEL_FORMAT_XB30:
- return 4;
- case PIXEL_FORMAT_RGB24:
- return 3;
- case PIXEL_FORMAT_Y16:
- case PIXEL_FORMAT_YUY2:
- case PIXEL_FORMAT_YUV420P9:
- case PIXEL_FORMAT_YUV422P9:
- case PIXEL_FORMAT_YUV444P9:
- case PIXEL_FORMAT_YUV420P10:
- case PIXEL_FORMAT_YUV422P10:
- case PIXEL_FORMAT_YUV444P10:
- case PIXEL_FORMAT_YUV420P12:
- case PIXEL_FORMAT_YUV422P12:
- case PIXEL_FORMAT_YUV444P12:
- case PIXEL_FORMAT_P016LE:
- return 2;
- case PIXEL_FORMAT_NV12:
- case PIXEL_FORMAT_NV21: {
- static const int bytes_per_element[] = {1, 2};
- DCHECK_LT(plane, base::size(bytes_per_element));
- return bytes_per_element[plane];
+ switch (format) {
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ case VideoPixelFormat::BGRA:
+ return false;
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::NV21:
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::YV12:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::P016LE:
+ return true;
+ case VideoPixelFormat::UNKNOWN:
+ ALOGE("Invalid pixel format");
+ return false;
}
- case PIXEL_FORMAT_YV12:
- case PIXEL_FORMAT_I420:
- case PIXEL_FORMAT_I422:
- case PIXEL_FORMAT_I420A:
- case PIXEL_FORMAT_I444:
- return 1;
- case PIXEL_FORMAT_MJPEG:
- return 0;
- case PIXEL_FORMAT_UNKNOWN:
- break;
- }
- NOTREACHED();
- return 0;
}
-bool IsValidPlane(VideoPixelFormat format, size_t plane) {
- DCHECK_LE(NumPlanes(format), static_cast<size_t>(kMaxPlanes));
- return plane < NumPlanes(format);
+size_t numPlanes(VideoPixelFormat format) {
+ switch (format) {
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ return 1;
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::NV21:
+ case VideoPixelFormat::P016LE:
+ return 2;
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::YV12:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ return 3;
+ case VideoPixelFormat::I420A:
+ return 4;
+ case VideoPixelFormat::UNKNOWN:
+ // Note: VideoPixelFormat::UNKNOWN is used for end-of-stream frame.
+ return 0;
+ }
+}
+
+size_t allocationSize(VideoPixelFormat format, const android::ui::Size& coded_size) {
+ size_t total = 0;
+ for (size_t i = 0; i < numPlanes(format); ++i) {
+ android::ui::Size plane_size = planeSize(format, i, coded_size);
+ total += (plane_size.width * plane_size.height);
+ }
+
+ return total;
+}
+
+android::ui::Size planeSize(VideoPixelFormat format, size_t plane,
+ const android::ui::Size& coded_size) {
+ ALOG_ASSERT(isValidPlane(plane, format));
+
+ int width = coded_size.width;
+ int height = coded_size.height;
+ if (RequiresEvenSizeAllocation(format)) {
+ // Align to multiple-of-two size overall. This ensures that non-subsampled
+ // planes can be addressed by pixel with the same scaling as the subsampled
+ // planes.
+ width = base::bits::Align(width, 2);
+ height = base::bits::Align(height, 2);
+ }
+
+ const android::ui::Size subsample = SampleSize(format, plane);
+ ALOG_ASSERT(width % subsample.width == 0);
+ ALOG_ASSERT(height % subsample.height == 0);
+ return android::ui::Size(bytesPerElement(format, plane) * width / subsample.width,
+ height / subsample.height);
+}
+
+int planeHorizontalBitsPerPixel(VideoPixelFormat format, size_t plane) {
+ ALOG_ASSERT(isValidPlane(plane, format));
+ const int bitsPerElement = 8 * bytesPerElement(format, plane);
+ const int horizPixelsPerElement = SampleSize(format, plane).width;
+ ALOG_ASSERT(bitsPerElement % horizPixelsPerElement == 0);
+ return bitsPerElement / horizPixelsPerElement;
+}
+
+int planeBitsPerPixel(VideoPixelFormat format, size_t plane) {
+ ALOG_ASSERT(isValidPlane(plane, format));
+ return planeHorizontalBitsPerPixel(format, plane) / SampleSize(format, plane).height;
+}
+
+int bytesPerElement(VideoPixelFormat format, size_t plane) {
+ ALOG_ASSERT(isValidPlane(format, plane));
+ switch (format) {
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ return 4;
+ case VideoPixelFormat::RGB24:
+ return 3;
+ case VideoPixelFormat::Y16:
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::YUV422P12:
+ case VideoPixelFormat::YUV444P12:
+ case VideoPixelFormat::P016LE:
+ return 2;
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::NV21: {
+ static const int bytes_per_element[] = {1, 2};
+ ALOG_ASSERT(plane < base::size(bytes_per_element));
+ return bytes_per_element[plane];
+ }
+ case VideoPixelFormat::YV12:
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I444:
+ return 1;
+ case VideoPixelFormat::MJPEG:
+ return 0;
+ case VideoPixelFormat::UNKNOWN:
+ ALOGE("Invalid pixel format");
+ return 0;
+ }
+}
+
+bool isValidPlane(VideoPixelFormat format, size_t plane) {
+ ALOG_ASSERT(numPlanes(format) <= static_cast<size_t>(kMaxPlanes));
+ return plane < numPlanes(format);
}
android::ui::Size SampleSize(VideoPixelFormat format, size_t plane) {
- DCHECK(IsValidPlane(format, plane));
+ ALOG_ASSERT(isValidPlane(format, plane));
- switch (plane) {
+ switch (plane) {
case kYPlane: // and kARGBPlane:
case kAPlane:
- return android::ui::Size(1, 1);
+ return android::ui::Size(1, 1);
case kUPlane: // and kUVPlane:
case kVPlane:
- switch (format) {
- case PIXEL_FORMAT_I444:
- case PIXEL_FORMAT_YUV444P9:
- case PIXEL_FORMAT_YUV444P10:
- case PIXEL_FORMAT_YUV444P12:
- case PIXEL_FORMAT_Y16:
- return android::ui::Size(1, 1);
+ switch (format) {
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::YUV444P9:
+ case VideoPixelFormat::YUV444P10:
+ case VideoPixelFormat::YUV444P12:
+ case VideoPixelFormat::Y16:
+ return android::ui::Size(1, 1);
- case PIXEL_FORMAT_I422:
- case PIXEL_FORMAT_YUV422P9:
- case PIXEL_FORMAT_YUV422P10:
- case PIXEL_FORMAT_YUV422P12:
- return android::ui::Size(2, 1);
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::YUV422P9:
+ case VideoPixelFormat::YUV422P10:
+ case VideoPixelFormat::YUV422P12:
+ return android::ui::Size(2, 1);
- case PIXEL_FORMAT_YV12:
- case PIXEL_FORMAT_I420:
- case PIXEL_FORMAT_I420A:
- case PIXEL_FORMAT_NV12:
- case PIXEL_FORMAT_NV21:
- case PIXEL_FORMAT_YUV420P9:
- case PIXEL_FORMAT_YUV420P10:
- case PIXEL_FORMAT_YUV420P12:
- case PIXEL_FORMAT_P016LE:
- return android::ui::Size(2, 2);
+ case VideoPixelFormat::YV12:
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::NV21:
+ case VideoPixelFormat::YUV420P9:
+ case VideoPixelFormat::YUV420P10:
+ case VideoPixelFormat::YUV420P12:
+ case VideoPixelFormat::P016LE:
+ return android::ui::Size(2, 2);
- case PIXEL_FORMAT_UNKNOWN:
- case PIXEL_FORMAT_YUY2:
- case PIXEL_FORMAT_ARGB:
- case PIXEL_FORMAT_XRGB:
- case PIXEL_FORMAT_RGB24:
- case PIXEL_FORMAT_MJPEG:
- case PIXEL_FORMAT_ABGR:
- case PIXEL_FORMAT_XBGR:
- case PIXEL_FORMAT_XR30:
- case PIXEL_FORMAT_XB30:
- case PIXEL_FORMAT_BGRA:
- break;
- }
- }
- NOTREACHED();
- return android::ui::Size();
+ case VideoPixelFormat::UNKNOWN:
+ case VideoPixelFormat::YUY2:
+ case VideoPixelFormat::ARGB:
+ case VideoPixelFormat::XRGB:
+ case VideoPixelFormat::RGB24:
+ case VideoPixelFormat::MJPEG:
+ case VideoPixelFormat::ABGR:
+ case VideoPixelFormat::XBGR:
+ case VideoPixelFormat::XR30:
+ case VideoPixelFormat::XB30:
+ case VideoPixelFormat::BGRA:
+ ALOGE("Invalid pixel format");
+ }
+ }
+
+ return android::ui::Size();
}
-} // namespace media
-
+} // namespace android
diff --git a/common/include/v4l2_codec2/common/Common.h b/common/include/v4l2_codec2/common/Common.h
index d18e06b..0775af1 100644
--- a/common/include/v4l2_codec2/common/Common.h
+++ b/common/include/v4l2_codec2/common/Common.h
@@ -27,7 +27,7 @@
// A video frame's layout, containing pixel format, size and layout of individual planes.
struct VideoFrameLayout {
- media::VideoPixelFormat mFormat = media::PIXEL_FORMAT_UNKNOWN;
+ VideoPixelFormat mFormat = VideoPixelFormat::UNKNOWN;
android::ui::Size mCodedSize;
std::vector<VideoFramePlane> mPlanes;
bool mMultiPlanar = false;
diff --git a/common/include/v4l2_codec2/common/EncodeHelpers.h b/common/include/v4l2_codec2/common/EncodeHelpers.h
index 180e1bc..bfbdd05 100644
--- a/common/include/v4l2_codec2/common/EncodeHelpers.h
+++ b/common/include/v4l2_codec2/common/EncodeHelpers.h
@@ -27,7 +27,7 @@
DMABUF = 1,
};
- media::VideoPixelFormat mInputFormat;
+ VideoPixelFormat mInputFormat;
ui::Size mInputVisibleSize;
C2Config::profile_t mOutputProfile;
uint32_t mInitialBitrate;
diff --git a/common/include/v4l2_codec2/common/FormatConverter.h b/common/include/v4l2_codec2/common/FormatConverter.h
index de9d21a..bc3f85a 100644
--- a/common/include/v4l2_codec2/common/FormatConverter.h
+++ b/common/include/v4l2_codec2/common/FormatConverter.h
@@ -51,7 +51,7 @@
// Create FormatConverter instance and initialize it, nullptr will be returned on
// initialization error.
- static std::unique_ptr<FormatConverter> Create(media::VideoPixelFormat outFormat,
+ static std::unique_ptr<FormatConverter> Create(VideoPixelFormat outFormat,
const ui::Size& visibleSize, uint32_t inputCount,
const ui::Size& codedSize);
@@ -93,7 +93,7 @@
// Initialize foramt converter. It will pre-allocate a set of graphic blocks as |codedSize| and
// |outFormat|. This function should be called prior to other functions.
- c2_status_t initialize(media::VideoPixelFormat outFormat, const ui::Size& visibleSize,
+ c2_status_t initialize(VideoPixelFormat outFormat, const ui::Size& visibleSize,
uint32_t inputCount, const ui::Size& codedSize);
// The array of block entries.
@@ -106,7 +106,7 @@
std::unique_ptr<uint8_t[]> mTempPlaneU;
std::unique_ptr<uint8_t[]> mTempPlaneV;
- media::VideoPixelFormat mOutFormat = media::VideoPixelFormat::PIXEL_FORMAT_UNKNOWN;
+ VideoPixelFormat mOutFormat = VideoPixelFormat::UNKNOWN;
ui::Size mVisibleSize;
};
diff --git a/common/include/v4l2_codec2/common/Fourcc.h b/common/include/v4l2_codec2/common/Fourcc.h
index 85da0b1..a0f5fc4 100644
--- a/common/include/v4l2_codec2/common/Fourcc.h
+++ b/common/include/v4l2_codec2/common/Fourcc.h
@@ -124,7 +124,7 @@
// Converts a VideoPixelFormat to Fourcc. Returns nullopt for invalid input. Note that a
// VideoPixelFormat may have two Fourcc counterparts. Caller has to specify if it is for
// single-planar or multi-planar format.
- static std::optional<Fourcc> fromVideoPixelFormat(media::VideoPixelFormat pixelFormat,
+ static std::optional<Fourcc> fromVideoPixelFormat(VideoPixelFormat pixelFormat,
bool singlePlanar = true);
// Converts a V4L2PixFmt to Fourcc. Returns nullopt for invalid input.
static std::optional<Fourcc> fromV4L2PixFmt(uint32_t v4l2PixFmt);
@@ -132,7 +132,7 @@
// Value getters:
// Returns the VideoPixelFormat counterpart of the value. Returns PIXEL_FORMAT_UNKNOWN if no
// mapping is found.
- media::VideoPixelFormat toVideoPixelFormat() const;
+ VideoPixelFormat toVideoPixelFormat() const;
// Returns the V4L2PixFmt counterpart of the value. Returns 0 if no mapping is found.
uint32_t toV4L2PixFmt() const;
diff --git a/common/include/v4l2_codec2/common/V4L2Device.h b/common/include/v4l2_codec2/common/V4L2Device.h
index fd197a2..b4c909c 100644
--- a/common/include/v4l2_codec2/common/V4L2Device.h
+++ b/common/include/v4l2_codec2/common/V4L2Device.h
@@ -24,7 +24,6 @@
#include <ui/Size.h>
#include <v4l2_codec2/common/Common.h>
#include <v4l2_codec2/common/V4L2DevicePoller.h>
-#include <v4l2_codec2/common/VideoPixelFormat.h>
#include <v4l2_codec2/common/VideoTypes.h>
namespace android {
diff --git a/common/include/v4l2_codec2/common/VideoPixelFormat.h b/common/include/v4l2_codec2/common/VideoPixelFormat.h
index 99e604a..2cfe910 100644
--- a/common/include/v4l2_codec2/common/VideoPixelFormat.h
+++ b/common/include/v4l2_codec2/common/VideoPixelFormat.h
@@ -4,126 +4,87 @@
// Note: ported from Chromium commit head: 3b7ce92816e2
// Note: only necessary functions are ported from video_types.h
-#ifndef VIDEO_PIXEL_FORMAT_H_
-#define VIDEO_PIXEL_FORMAT_H_
+#ifndef ANDROID_V4L2_CODEC2_COMMON_VIDEO_PIXEL_FORMAT_H
+#define ANDROID_V4L2_CODEC2_COMMON_VIDEO_PIXEL_FORMAT_H
#include <string>
#include "ui/Size.h"
-namespace media {
+namespace android {
// Pixel formats roughly based on FOURCC labels, see:
// http://www.fourcc.org/rgb.php and http://www.fourcc.org/yuv.php
-// Logged to UMA, so never reuse values. Leave gaps if necessary.
-// Ordered as planar, semi-planar, YUV-packed, and RGB formats.
-// When a VideoFrame is backed by native textures, VideoPixelFormat describes
-// how those textures should be sampled and combined to produce the final
-// pixels.
-enum VideoPixelFormat {
- PIXEL_FORMAT_UNKNOWN = 0, // Unknown or unspecified format value.
- PIXEL_FORMAT_I420 =
- 1, // 12bpp YUV planar 1x1 Y, 2x2 UV samples, a.k.a. YU12.
-
- // Note: Chrome does not actually support YVU compositing, so you probably
- // don't actually want to use this. See http://crbug.com/784627.
- PIXEL_FORMAT_YV12 = 2, // 12bpp YVU planar 1x1 Y, 2x2 VU samples.
-
- PIXEL_FORMAT_I422 = 3, // 16bpp YUV planar 1x1 Y, 2x1 UV samples.
- PIXEL_FORMAT_I420A = 4, // 20bpp YUVA planar 1x1 Y, 2x2 UV, 1x1 A samples.
- PIXEL_FORMAT_I444 = 5, // 24bpp YUV planar, no subsampling.
- PIXEL_FORMAT_NV12 =
- 6, // 12bpp with Y plane followed by a 2x2 interleaved UV plane.
- PIXEL_FORMAT_NV21 =
- 7, // 12bpp with Y plane followed by a 2x2 interleaved VU plane.
- /* PIXEL_FORMAT_UYVY = 8, Deprecated */
- PIXEL_FORMAT_YUY2 =
- 9, // 16bpp interleaved 1x1 Y, 2x1 U, 1x1 Y, 2x1 V samples.
- PIXEL_FORMAT_ARGB = 10, // 32bpp BGRA (byte-order), 1 plane.
- PIXEL_FORMAT_XRGB = 11, // 24bpp BGRX (byte-order), 1 plane.
- PIXEL_FORMAT_RGB24 = 12, // 24bpp BGR (byte-order), 1 plane.
-
- /* PIXEL_FORMAT_RGB32 = 13, Deprecated */
- PIXEL_FORMAT_MJPEG = 14, // MJPEG compressed.
- /* PIXEL_FORMAT_MT21 = 15, Deprecated */
-
- // The P* in the formats below designates the number of bits per pixel
- // component. I.e. P9 is 9-bits per pixel component, P10 is 10-bits per pixel
- // component, etc.
- PIXEL_FORMAT_YUV420P9 = 16,
- PIXEL_FORMAT_YUV420P10 = 17,
- PIXEL_FORMAT_YUV422P9 = 18,
- PIXEL_FORMAT_YUV422P10 = 19,
- PIXEL_FORMAT_YUV444P9 = 20,
- PIXEL_FORMAT_YUV444P10 = 21,
- PIXEL_FORMAT_YUV420P12 = 22,
- PIXEL_FORMAT_YUV422P12 = 23,
- PIXEL_FORMAT_YUV444P12 = 24,
-
- /* PIXEL_FORMAT_Y8 = 25, Deprecated */
- PIXEL_FORMAT_Y16 = 26, // single 16bpp plane.
-
- PIXEL_FORMAT_ABGR = 27, // 32bpp RGBA (byte-order), 1 plane.
- PIXEL_FORMAT_XBGR = 28, // 24bpp RGBX (byte-order), 1 plane.
-
- PIXEL_FORMAT_P016LE = 29, // 24bpp NV12, 16 bits per channel
-
- PIXEL_FORMAT_XR30 =
- 30, // 32bpp BGRX, 10 bits per channel, 2 bits ignored, 1 plane
- PIXEL_FORMAT_XB30 =
- 31, // 32bpp RGBX, 10 bits per channel, 2 bits ignored, 1 plane
-
- PIXEL_FORMAT_BGRA = 32, // 32bpp ARGB (byte-order), 1 plane.
-
- // Please update UMA histogram enumeration when adding new formats here.
- PIXEL_FORMAT_MAX =
- PIXEL_FORMAT_BGRA, // Must always be equal to largest entry logged.
+enum class VideoPixelFormat {
+ I420, // 12bpp YUV planar 1x1 Y, 2x2 UV samples, a.k.a. YU12.
+ YV12, // 12bpp YVU planar 1x1 Y, 2x2 VU samples.
+ I422, // 16bpp YUV planar 1x1 Y, 2x1 UV samples.
+ I420A, // 20bpp YUVA planar 1x1 Y, 2x2 UV, 1x1 A samples.
+ I444, // 24bpp YUV planar, no subsampling.
+ NV12, // 12bpp with Y plane followed by a 2x2 interleaved UV plane.
+ NV21, // 12bpp with Y plane followed by a 2x2 interleaved VU plane.
+ YUY2, // 16bpp interleaved 1x1 Y, 2x1 U, 1x1 Y, 2x1 V samples.
+ ARGB, // 32bpp BGRA (byte-order), 1 plane.
+ XRGB, // 24bpp BGRX (byte-order), 1 plane.
+ RGB24, // 24bpp BGR (byte-order), 1 plane.
+ MJPEG, // MJPEG compressed.
+ Y16, // single 16bpp plane.
+ ABGR, // 32bpp RGBA (byte-order), 1 plane.
+ XBGR, // 24bpp RGBX (byte-order), 1 plane.
+ P016LE, // 24bpp NV12, 16 bits per channel
+ XR30, // 32bpp BGRX, 10 bits per channel, 2 bits ignored, 1 plane
+ XB30, // 32bpp RGBX, 10 bits per channel, 2 bits ignored, 1 plane
+ BGRA, // 32bpp ARGB (byte-order), 1 plane.
+ // The P* in the formats below designates the number of bits per pixel component. I.e. P9 is
+ // 9-bits per pixel component, P10 is 10-bits per pixel component, etc.
+ YUV420P9,
+ YUV420P10,
+ YUV422P9,
+ YUV422P10,
+ YUV444P9,
+ YUV444P10,
+ YUV420P12,
+ YUV422P12,
+ YUV444P12,
+ UNKNOWN, // Unknown or unspecified format value.
};
// Returns the name of a Format as a string.
-std::string VideoPixelFormatToString(VideoPixelFormat format);
+std::string videoPixelFormatToString(VideoPixelFormat format);
-// Returns human readable fourcc string.
-// If any of the four characters is non-printable, it outputs
-// "0x<32-bit integer in hex>", e.g. FourccToString(0x66616b00) returns
-// "0x66616b00".
-std::string FourccToString(uint32_t fourcc);
+// Returns human readable fourcc string. If any of the four characters is non-printable, it outputs
+// "0x<32-bit integer in hex>", e.g. FourccToString(0x66616b00) returns "0x66616b00".
+std::string fourccToString(uint32_t fourcc);
// Returns the number of significant bits per channel.
-size_t BitDepth(VideoPixelFormat format);
+size_t bitDepth(VideoPixelFormat format);
// Returns the number of planes for the |format|.
-size_t NumPlanes(VideoPixelFormat format);
+size_t numPlanes(VideoPixelFormat format);
-// Returns the required allocation size for a (tightly packed) frame of the
-// given coded size and format.
-size_t AllocationSize(VideoPixelFormat format, const android::ui::Size& coded_size);
+// Returns required allocation size for a (tightly packed) frame of the given coded size and format.
+size_t allocationSize(VideoPixelFormat format, const android::ui::Size& coded_size);
-// Returns the plane Size (in bytes) for a plane of the given coded size
-// and format.
-android::ui::Size PlaneSize(VideoPixelFormat format,
- size_t plane,
- const android::ui::Size& coded_size);
+// Returns the plane Size (in bytes) for a plane of the given coded size and format.
+android::ui::Size planeSize(VideoPixelFormat format, size_t plane,
+ const android::ui::Size& coded_size);
// Returns horizontal bits per pixel for given |plane| and |format|.
-int PlaneHorizontalBitsPerPixel(VideoPixelFormat format, size_t plane);
+int planeHorizontalBitsPerPixel(VideoPixelFormat format, size_t plane);
// Returns bits per pixel for given |plane| and |format|.
-int PlaneBitsPerPixel(VideoPixelFormat format, size_t plane);
+int planeBitsPerPixel(VideoPixelFormat format, size_t plane);
// Returns the number of bytes per element for given |plane| and |format|.
-int BytesPerElement(VideoPixelFormat format, size_t plane);
+int bytesPerElement(VideoPixelFormat format, size_t plane);
// Returns true if |plane| is a valid plane index for the given |format|.
-bool IsValidPlane(size_t plane, VideoPixelFormat format);
-
-// Returns true if |plane| is a valid plane index for the given |format|.
-bool IsValidPlane(VideoPixelFormat format, size_t plane);
+bool isValidPlane(VideoPixelFormat format, size_t plane);
// Returns the pixel size of each subsample for a given |plane| and |format|.
-// E.g. 2x2 for the U-plane in PIXEL_FORMAT_I420.
+// E.g. 2x2 for the U-plane in I420.
android::ui::Size SampleSize(VideoPixelFormat format, size_t plane);
-} // namespace media
+} // namespace android
-#endif // VIDEO_PIXEL_FORMAT_H_
+#endif // ANDROID_V4L2_CODEC2_COMMON_VIDEO_PIXEL_FORMAT_H
