Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 42befdd2 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 10188272 from 38f74691 to udc-release 

Change-Id: I6d855c3c4ebbd4741763a57ca437f85fe7e0a7b0
parents 30df68c9 38f74691

media/TEST_MAPPING

+0 −48
Original line number Diff line number Diff line
@@ -44,53 +44,5 @@ 
            ],

            "file_patterns": ["(?i)drm|crypto"]

        }

    ],



    "platinum-postsubmit": [

        // runs regularly, independent of changes in this tree.

        // signals if changes elsewhere break media functionality

        // @FlakyTest: in staged-postsubmit, but not postsubmit

        {

            "name": "CtsMediaCodecTestCases",

            "options": [

                {

                    "include-filter": "android.media.codec.cts.EncodeDecodeTest"

                }

            ]

        },

        {

            "name": "CtsMediaCodecTestCases",

            "options": [

                {

                    "include-filter": "android.media.codec.cts.DecodeEditEncodeTest"

                },

                {

                    "exclude-annotation": "androidx.test.filters.FlakyTest"

                }

            ]

        }

    ],



    "staged-platinum-postsubmit": [

        // runs every four hours

        {

            "name": "CtsMediaCodecTestCases",

            "options": [

                {

                    "include-filter": "android.media.codec.cts.EncodeDecodeTest"

                }

            ]

        },

        {

            "name": "CtsMediaCodecTestCases",

            "options": [

                {

                    "include-filter": "android.media.codec.cts.DecodeEditEncodeTest"

                }

            ]

        }

    ]



    // TODO (b/229286407) Add EncodeDecodeTest and DecodeEditEncodeTest to

    // platinum-postsubmit once issues in cuttlefish are fixed

}

media/codec2/components/gav1/C2SoftGav1Dec.cpp

+144 −13
Original line number Diff line number Diff line
@@ -29,6 +29,14 @@ 
#include <media/stagefright/foundation/AUtils.h>

#include <media/stagefright/foundation/MediaDefs.h>



// libyuv version required for I410ToAB30Matrix and I210ToAB30Matrix.

#if LIBYUV_VERSION >= 1780

#include <algorithm>

#define HAVE_LIBYUV_I410_I210_TO_AB30 1

#else

#define HAVE_LIBYUV_I410_I210_TO_AB30 0

#endif



namespace android {



// codecname set and passed in as a compile flag from Android.bp
@@ -726,6 +734,24 @@ void C2SoftGav1Dec::getVuiParams(const libgav1::DecoderBuffer *buffer) { 
    }

}



void C2SoftGav1Dec::setError(const std::unique_ptr<C2Work> &work, c2_status_t error) {

    mSignalledError = true;

    work->result = error;

    work->workletsProcessed = 1u;

}



bool C2SoftGav1Dec::allocTmpFrameBuffer(size_t size) {

    if (size > mTmpFrameBufferSize) {

        mTmpFrameBuffer = std::make_unique<uint16_t[]>(size);

        if (mTmpFrameBuffer == nullptr) {

            mTmpFrameBufferSize = 0;

            return false;

        }

        mTmpFrameBufferSize = size;

    }

    return true;

}



bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool,

                                 const std::unique_ptr<C2Work> &work) {

  if (!(work && pool)) return false;
@@ -772,6 +798,7 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
  getHDRStaticParams(buffer, work);

  getHDR10PlusInfoData(buffer, work);



#if LIBYUV_VERSION < 1779

  if (buffer->bitdepth == 10 &&

      !(buffer->image_format == libgav1::kImageFormatYuv420 ||

        buffer->image_format == libgav1::kImageFormatMonochrome400)) {
@@ -781,6 +808,7 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
    work->result = C2_CORRUPTED;

    return false;

  }

#endif



  const bool isMonochrome =

      buffer->image_format == libgav1::kImageFormatMonochrome400;
@@ -798,6 +826,7 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
      allowRGBA1010102 = true;

    }

    format = getHalPixelFormatForBitDepth10(allowRGBA1010102);

#if !HAVE_LIBYUV_I410_I210_TO_AB30

    if ((format == HAL_PIXEL_FORMAT_RGBA_1010102) &&

        (buffer->image_format != libgav1::kImageFormatYuv420)) {

        ALOGE("Only YUV420 output is supported when targeting RGBA_1010102");
@@ -806,6 +835,7 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
      work->workletsProcessed = 1u;

      return false;

    }

#endif

  }



  if (mHalPixelFormat != format) {
@@ -854,9 +884,6 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
  uint8_t *dstY = const_cast<uint8_t *>(wView.data()[C2PlanarLayout::PLANE_Y]);

  uint8_t *dstU = const_cast<uint8_t *>(wView.data()[C2PlanarLayout::PLANE_U]);

  uint8_t *dstV = const_cast<uint8_t *>(wView.data()[C2PlanarLayout::PLANE_V]);

  size_t srcYStride = buffer->stride[0];

  size_t srcUStride = buffer->stride[1];

  size_t srcVStride = buffer->stride[2];



  C2PlanarLayout layout = wView.layout();

  size_t dstYStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
@@ -867,26 +894,130 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
    const uint16_t *srcY = (const uint16_t *)buffer->plane[0];

    const uint16_t *srcU = (const uint16_t *)buffer->plane[1];

    const uint16_t *srcV = (const uint16_t *)buffer->plane[2];

    size_t srcYStride = buffer->stride[0] / 2;

    size_t srcUStride = buffer->stride[1] / 2;

    size_t srcVStride = buffer->stride[2] / 2;



    if (format == HAL_PIXEL_FORMAT_RGBA_1010102) {

        bool processed = false;

#if HAVE_LIBYUV_I410_I210_TO_AB30

        if (buffer->image_format == libgav1::kImageFormatYuv444) {

            libyuv::I410ToAB30Matrix(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                                     dstY, dstYStride, &libyuv::kYuvV2020Constants,

                                     mWidth, mHeight);

            processed = true;

        } else if (buffer->image_format == libgav1::kImageFormatYuv422) {

            libyuv::I210ToAB30Matrix(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                                     dstY, dstYStride, &libyuv::kYuvV2020Constants,

                                     mWidth, mHeight);

            processed = true;

        }

#endif  // HAVE_LIBYUV_I410_I210_TO_AB30

        if (!processed) {

            if (isMonochrome) {

                const size_t tmpSize = mWidth;

                const bool needFill = tmpSize > mTmpFrameBufferSize;

                if (!allocTmpFrameBuffer(tmpSize)) {

                    ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);

                    setError(work, C2_NO_MEMORY);

                    return false;

                }

                srcU = srcV = mTmpFrameBuffer.get();

                srcUStride = srcVStride = 0;

                if (needFill) {

                    std::fill_n(mTmpFrameBuffer.get(), tmpSize, 512);

                }

            }

            convertYUV420Planar16ToY410OrRGBA1010102(

                (uint32_t *)dstY, srcY, srcU, srcV, srcYStride / 2,

                srcUStride / 2, srcVStride / 2,

                    (uint32_t *)dstY, srcY, srcU, srcV, srcYStride,

                    srcUStride, srcVStride,

                    dstYStride / sizeof(uint32_t), mWidth, mHeight,

                    std::static_pointer_cast<const C2ColorAspectsStruct>(codedColorAspects));

        }

    } else if (format == HAL_PIXEL_FORMAT_YCBCR_P010) {

        dstYStride /= 2;

        dstUStride /= 2;

        dstVStride /= 2;

#if LIBYUV_VERSION >= 1779

        if (buffer->image_format == libgav1::kImageFormatYuv444 ||

            buffer->image_format == libgav1::kImageFormatYuv422) {

            // TODO(https://crbug.com/libyuv/952): replace this block with libyuv::I410ToP010 and

            // libyuv::I210ToP010 when they are available.

            // Note it may be safe to alias dstY in I010ToP010, but the libyuv API doesn't make any

            // guarantees.

            const size_t tmpSize = dstYStride * mHeight + dstUStride * align(mHeight, 2);

            if (!allocTmpFrameBuffer(tmpSize)) {

                ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);

                setError(work, C2_NO_MEMORY);

                return false;

            }

            uint16_t *const tmpY = mTmpFrameBuffer.get();

            uint16_t *const tmpU = tmpY + dstYStride * mHeight;

            uint16_t *const tmpV = tmpU + dstUStride * align(mHeight, 2) / 2;

            if (buffer->image_format == libgav1::kImageFormatYuv444) {

                libyuv::I410ToI010(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                                   tmpY, dstYStride, tmpU, dstUStride, tmpV, dstUStride,

                                   mWidth, mHeight);

            } else {

                libyuv::I210ToI010(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                                   tmpY, dstYStride, tmpU, dstUStride, tmpV, dstUStride,

                                   mWidth, mHeight);

            }

            libyuv::I010ToP010(tmpY, dstYStride, tmpU, dstUStride, tmpV, dstVStride,

                               (uint16_t*)dstY, dstYStride, (uint16_t*)dstU, dstUStride,

                               mWidth, mHeight);

        } else {

            convertYUV420Planar16ToP010((uint16_t *)dstY, (uint16_t *)dstU, srcY, srcU, srcV,

                                    srcYStride / 2, srcUStride / 2, srcVStride / 2, dstYStride / 2,

                                    dstUStride / 2, mWidth, mHeight, isMonochrome);

                                        srcYStride, srcUStride, srcVStride, dstYStride,

                                        dstUStride, mWidth, mHeight, isMonochrome);

        }

#else  // LIBYUV_VERSION < 1779

        convertYUV420Planar16ToP010((uint16_t *)dstY, (uint16_t *)dstU, srcY, srcU, srcV,

                                    srcYStride, srcUStride, srcVStride, dstYStride,

                                    dstUStride, mWidth, mHeight, isMonochrome);

#endif  // LIBYUV_VERSION >= 1779

    } else {

#if LIBYUV_VERSION >= 1779

        if (buffer->image_format == libgav1::kImageFormatYuv444) {

            // TODO(https://crbug.com/libyuv/950): replace this block with libyuv::I410ToI420 when

            // it's available.

            const size_t tmpSize = dstYStride * mHeight + dstUStride * align(mHeight, 2);

            if (!allocTmpFrameBuffer(tmpSize)) {

                ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);

                setError(work, C2_NO_MEMORY);

                return false;

            }

            uint16_t *const tmpY = mTmpFrameBuffer.get();

            uint16_t *const tmpU = tmpY + dstYStride * mHeight;

            uint16_t *const tmpV = tmpU + dstUStride * align(mHeight, 2) / 2;

            libyuv::I410ToI010(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                               tmpY, dstYStride, tmpU, dstUStride, tmpV, dstVStride,

                               mWidth, mHeight);

            libyuv::I010ToI420(tmpY, dstYStride, tmpU, dstUStride, tmpV, dstUStride,

                               dstY, dstYStride, dstU, dstUStride, dstV, dstVStride,

                               mWidth, mHeight);

        } else if (buffer->image_format == libgav1::kImageFormatYuv422) {

            libyuv::I210ToI420(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

                               dstY, dstYStride, dstU, dstUStride, dstV, dstVStride,

                               mWidth, mHeight);

        } else {

        convertYUV420Planar16ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride / 2,

                                    srcUStride / 2, srcVStride / 2, dstYStride, dstUStride, mWidth,

                                    mHeight, isMonochrome);

            convertYUV420Planar16ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride,

                                        srcUStride, srcVStride, dstYStride, dstUStride,

                                        mWidth, mHeight, isMonochrome);

        }

#else  // LIBYUV_VERSION < 1779

        convertYUV420Planar16ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride,

                                    srcUStride, srcVStride, dstYStride, dstUStride,

                                    mWidth, mHeight, isMonochrome);

#endif  // LIBYUV_VERSION >= 1779

    }

  } else {

    const uint8_t *srcY = (const uint8_t *)buffer->plane[0];

    const uint8_t *srcU = (const uint8_t *)buffer->plane[1];

    const uint8_t *srcV = (const uint8_t *)buffer->plane[2];

    size_t srcYStride = buffer->stride[0];

    size_t srcUStride = buffer->stride[1];

    size_t srcVStride = buffer->stride[2];



    if (buffer->image_format == libgav1::kImageFormatYuv444) {

        libyuv::I444ToI420(srcY, srcYStride, srcU, srcUStride, srcV, srcVStride,

media/codec2/components/gav1/C2SoftGav1Dec.h

+8 −0
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ 


#include <inttypes.h>



#include <memory>



#include <media/stagefright/foundation/ColorUtils.h>



#include <SimpleC2Component.h>
@@ -60,6 +62,9 @@ struct C2SoftGav1Dec : public SimpleC2Component { 
  uint32_t mHeight;

  bool mSignalledOutputEos;

  bool mSignalledError;

  // Used during 10-bit I444/I422 to 10-bit P010 & 8-bit I420 conversions.

  std::unique_ptr<uint16_t[]> mTmpFrameBuffer;

  size_t mTmpFrameBufferSize = 0;



  C2StreamHdrStaticMetadataInfo::output mHdrStaticMetadataInfo;

  std::unique_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfo = nullptr;
@@ -97,6 +102,9 @@ struct C2SoftGav1Dec : public SimpleC2Component { 
  void destroyDecoder();

  void finishWork(uint64_t index, const std::unique_ptr<C2Work>& work,

                  const std::shared_ptr<C2GraphicBlock>& block);

  // Sets |work->result| and mSignalledError. Returns false.

  void setError(const std::unique_ptr<C2Work> &work, c2_status_t error);

  bool allocTmpFrameBuffer(size_t size);

  bool outputBuffer(const std::shared_ptr<C2BlockPool>& pool,

                    const std::unique_ptr<C2Work>& work);

  c2_status_t drainInternal(uint32_t drainMode,

media/libstagefright/MediaCodec.cpp

+97 −5
Original line number Diff line number Diff line
@@ -19,12 +19,12 @@ 
#define LOG_TAG "MediaCodec"

#include <utils/Log.h>



#include <set>

#include <random>

#include <stdlib.h>

#include <dlfcn.h>

#include <inttypes.h>

#include <random>

#include <set>

#include <stdlib.h>

#include <dlfcn.h>

#include <string>



#include <C2Buffer.h>
@@ -90,6 +90,8 @@ using aidl::android::media::BnResourceManagerClient; 
using aidl::android::media::IResourceManagerClient;

using aidl::android::media::IResourceManagerService;

using aidl::android::media::ClientInfoParcel;

using FreezeEvent = VideoRenderQualityTracker::FreezeEvent;

using JudderEvent = VideoRenderQualityTracker::JudderEvent;



// key for media statistics

static const char *kCodecKeyName = "codec";
@@ -212,6 +214,7 @@ static const char *kCodecFramesSkipped = "android.media.mediacodec.frames-skippe 
static const char *kCodecFramerateContent = "android.media.mediacodec.framerate-content";

static const char *kCodecFramerateDesired = "android.media.mediacodec.framerate-desired";

static const char *kCodecFramerateActual = "android.media.mediacodec.framerate-actual";

// Freeze

static const char *kCodecFreezeCount = "android.media.mediacodec.freeze-count";

static const char *kCodecFreezeScore = "android.media.mediacodec.freeze-score";

static const char *kCodecFreezeRate = "android.media.mediacodec.freeze-rate";
@@ -226,6 +229,7 @@ static const char *kCodecFreezeDistanceMsHistogram = 
        "android.media.mediacodec.freeze-distance-ms-histogram";

static const char *kCodecFreezeDistanceMsHistogramBuckets =

        "android.media.mediacodec.freeze-distance-ms-histogram-buckets";

// Judder

static const char *kCodecJudderCount = "android.media.mediacodec.judder-count";

static const char *kCodecJudderScore = "android.media.mediacodec.judder-score";

static const char *kCodecJudderRate = "android.media.mediacodec.judder-rate";
@@ -234,6 +238,32 @@ static const char *kCodecJudderScoreMax = "android.media.mediacodec.judder-score 
static const char *kCodecJudderScoreHistogram = "android.media.mediacodec.judder-score-histogram";

static const char *kCodecJudderScoreHistogramBuckets =

        "android.media.mediacodec.judder-score-histogram-buckets";

// Freeze event

static const char *kCodecFreezeEventCount = "android.media.mediacodec.freeze-event-count";

static const char *kFreezeEventKeyName = "freeze";

static const char *kFreezeEventInitialTimeUs = "android.media.mediacodec.freeze.initial-time-us";

static const char *kFreezeEventDurationMs = "android.media.mediacodec.freeze.duration-ms";

static const char *kFreezeEventCount = "android.media.mediacodec.freeze.count";

static const char *kFreezeEventAvgDurationMs = "android.media.mediacodec.freeze.avg-duration-ms";

static const char *kFreezeEventAvgDistanceMs = "android.media.mediacodec.freeze.avg-distance-ms";

static const char *kFreezeEventDetailsDurationMs =

        "android.media.mediacodec.freeze.details-duration-ms";

static const char *kFreezeEventDetailsDistanceMs =

        "android.media.mediacodec.freeze.details-distance-ms";

// Judder event

static const char *kCodecJudderEventCount = "android.media.mediacodec.judder-event-count";

static const char *kJudderEventKeyName = "judder";

static const char *kJudderEventInitialTimeUs = "android.media.mediacodec.judder.initial-time-us";

static const char *kJudderEventDurationMs = "android.media.mediacodec.judder.duration-ms";

static const char *kJudderEventCount = "android.media.mediacodec.judder.count";

static const char *kJudderEventAvgScore = "android.media.mediacodec.judder.avg-score";

static const char *kJudderEventAvgDistanceMs = "android.media.mediacodec.judder.avg-distance-ms";

static const char *kJudderEventDetailsActualDurationUs =

        "android.media.mediacodec.judder.details-actual-duration-us";

static const char *kJudderEventDetailsContentDurationUs =

        "android.media.mediacodec.judder.details-content-duration-us";

static const char *kJudderEventDetailsDistanceMs =

        "android.media.mediacodec.judder.details-distance-ms";



// XXX suppress until we get our representation right

static bool kEmitHistogram = false;
@@ -1169,6 +1199,12 @@ void MediaCodec::updateMediametrics() { 
            mediametrics_setString(mMetricsHandle, kCodecJudderScoreHistogramBuckets,

                                   h.emitBuckets());

        }

        if (m.freezeEventCount != 0) {

            mediametrics_setInt32(mMetricsHandle, kCodecFreezeEventCount, m.freezeEventCount);

        }

        if (m.judderEventCount != 0) {

            mediametrics_setInt32(mMetricsHandle, kCodecJudderEventCount, m.judderEventCount);

        }

    }



    if (mLatencyHist.getCount() != 0 ) {
@@ -1407,6 +1443,53 @@ void MediaCodec::updateEphemeralMediametrics(mediametrics_handle_t item) { 
    }

}



static std::string emitVector(std::vector<int32_t> vector) {

    std::ostringstream sstr;

    for (size_t i = 0; i < vector.size(); ++i) {

        if (i != 0) {

            sstr << ',';

        }

        sstr << vector[i];

    }

    return sstr.str();

}



static void reportToMediaMetricsIfValid(const FreezeEvent &e) {

    if (e.valid) {

        mediametrics_handle_t handle = mediametrics_create(kFreezeEventKeyName);

        mediametrics_setInt64(handle, kFreezeEventInitialTimeUs, e.initialTimeUs);

        mediametrics_setInt32(handle, kFreezeEventDurationMs, e.durationMs);

        mediametrics_setInt64(handle, kFreezeEventCount, e.count);

        mediametrics_setInt32(handle, kFreezeEventAvgDurationMs, e.sumDurationMs / e.count);

        mediametrics_setInt32(handle, kFreezeEventAvgDistanceMs, e.sumDistanceMs / e.count);

        mediametrics_setString(handle, kFreezeEventDetailsDurationMs,

                               emitVector(e.details.durationMs));

        mediametrics_setString(handle, kFreezeEventDetailsDistanceMs,

                               emitVector(e.details.distanceMs));

        mediametrics_selfRecord(handle);

        mediametrics_delete(handle);

    }

}



static void reportToMediaMetricsIfValid(const JudderEvent &e) {

    if (e.valid) {

        mediametrics_handle_t handle = mediametrics_create(kJudderEventKeyName);

        mediametrics_setInt64(handle, kJudderEventInitialTimeUs, e.initialTimeUs);

        mediametrics_setInt32(handle, kJudderEventDurationMs, e.durationMs);

        mediametrics_setInt64(handle, kJudderEventCount, e.count);

        mediametrics_setInt32(handle, kJudderEventAvgScore, e.sumScore / e.count);

        mediametrics_setInt32(handle, kJudderEventAvgDistanceMs, e.sumDistanceMs / e.count);

        mediametrics_setString(handle, kJudderEventDetailsActualDurationUs,

                               emitVector(e.details.actualRenderDurationUs));

        mediametrics_setString(handle, kJudderEventDetailsContentDurationUs,

                               emitVector(e.details.contentRenderDurationUs));

        mediametrics_setString(handle, kJudderEventDetailsDistanceMs,

                               emitVector(e.details.distanceMs));

        mediametrics_selfRecord(handle);

        mediametrics_delete(handle);

    }

}



void MediaCodec::flushMediametrics() {

    ALOGD("flushMediametrics");
@@ -1425,6 +1508,10 @@ void MediaCodec::flushMediametrics() { 
    }

    // we no longer have anything pending upload

    mMetricsToUpload = false;



    // Freeze and judder events are reported separately

    reportToMediaMetricsIfValid(mVideoRenderQualityTracker.getAndResetFreezeEvent());

    reportToMediaMetricsIfValid(mVideoRenderQualityTracker.getAndResetJudderEvent());

}



void MediaCodec::updateLowLatency(const sp<AMessage> &msg) {
@@ -1538,7 +1625,12 @@ void MediaCodec::processRenderedFrames(const sp<AMessage> &msg) { 
            // Tunneled frames use INT64_MAX to indicate end-of-stream, so don't report it as a

            // rendered frame.

            if (!mTunneled || mediaTimeUs != INT64_MAX) {

                mVideoRenderQualityTracker.onFrameRendered(mediaTimeUs, renderTimeNs);

                FreezeEvent freezeEvent;

                JudderEvent judderEvent;

                mVideoRenderQualityTracker.onFrameRendered(mediaTimeUs, renderTimeNs, &freezeEvent,

                                                           &judderEvent);

                reportToMediaMetricsIfValid(freezeEvent);

                reportToMediaMetricsIfValid(judderEvent);

            }

        }

    }

media/libstagefright/VideoRenderQualityTracker.cpp

+159 −11

File changed.

Preview size limit exceeded, changes collapsed.