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

Commit 210d52ea authored by Manisha Jajoo's avatar Manisha Jajoo Committed by Harish Mahendrakar
Browse files

C2SoftGav1Dec: add support for HDRStatic and HDR10Plus Info type 

Test: atest CtsMediaDecoderTestCases:HDRDecoderTest
Test: atest CtsMediaV2TestCases:DecoderHDRInfoTest
Bug: 227830772

Change-Id: I85012b8b87e4c4ff98150f091a92721a3c7242b9
parent 6906fb05

media/codec2/components/gav1/C2SoftGav1Dec.cpp

+138 −0
Original line number Original line Diff line number Diff line
@@ -100,6 +100,29 @@ class C2SoftGav1Dec::IntfImpl : public SimpleInterface<void>::BaseParams { 
            .withSetter(Hdr10PlusInfoOutputSetter)

            .withSetter(Hdr10PlusInfoOutputSetter)

            .build());

            .build());





    // default static info

    C2HdrStaticMetadataStruct defaultStaticInfo{};

    helper->addStructDescriptors<C2MasteringDisplayColorVolumeStruct, C2ColorXyStruct>();

    addParameter(

        DefineParam(mHdrStaticInfo, C2_PARAMKEY_HDR_STATIC_INFO)

            .withDefault(new C2StreamHdrStaticInfo::output(0u, defaultStaticInfo))

            .withFields({

                C2F(mHdrStaticInfo, mastering.red.x).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.red.y).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.green.x).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.green.y).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.blue.x).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.blue.y).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1),

                C2F(mHdrStaticInfo, mastering.maxLuminance).inRange(0, 65535),

                C2F(mHdrStaticInfo, mastering.minLuminance).inRange(0, 6.5535),

                C2F(mHdrStaticInfo, maxCll).inRange(0, 0XFFFF),

                C2F(mHdrStaticInfo, maxFall).inRange(0, 0XFFFF)

            })

            .withSetter(HdrStaticInfoSetter)

            .build());



    addParameter(

    addParameter(

        DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE)

        DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE)

            .withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240))

            .withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240))
@@ -330,6 +353,47 @@ class C2SoftGav1Dec::IntfImpl : public SimpleInterface<void>::BaseParams { 
  // unsafe getters

  // unsafe getters

  std::shared_ptr<C2StreamPixelFormatInfo::output> getPixelFormat_l() const { return mPixelFormat; }

  std::shared_ptr<C2StreamPixelFormatInfo::output> getPixelFormat_l() const { return mPixelFormat; }





  static C2R HdrStaticInfoSetter(bool mayBlock, C2P<C2StreamHdrStaticInfo::output> &me) {

    (void)mayBlock;

    if (me.v.mastering.red.x > 1) {

      me.set().mastering.red.x = 1;

    }

    if (me.v.mastering.red.y > 1) {

      me.set().mastering.red.y = 1;

    }

    if (me.v.mastering.green.x > 1) {

      me.set().mastering.green.x = 1;

    }

    if (me.v.mastering.green.y > 1) {

      me.set().mastering.green.y = 1;

    }

    if (me.v.mastering.blue.x > 1) {

      me.set().mastering.blue.x = 1;

    }

    if (me.v.mastering.blue.y > 1) {

      me.set().mastering.blue.y = 1;

    }

    if (me.v.mastering.white.x > 1) {

      me.set().mastering.white.x = 1;

    }

    if (me.v.mastering.white.y > 1) {

      me.set().mastering.white.y = 1;

    }

    if (me.v.mastering.maxLuminance > 65535.0) {

      me.set().mastering.maxLuminance = 65535.0;

    }

    if (me.v.mastering.minLuminance > 6.5535) {

      me.set().mastering.minLuminance = 6.5535;

    }

    if (me.v.maxCll > 65535.0) {

      me.set().maxCll = 65535.0;

    }

    if (me.v.maxFall > 65535.0) {

      me.set().maxFall = 65535.0;

    }

    return C2R::Ok();

  }



 private:

 private:

  std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel;

  std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel;

  std::shared_ptr<C2StreamPictureSizeInfo::output> mSize;

  std::shared_ptr<C2StreamPictureSizeInfo::output> mSize;
@@ -342,6 +406,7 @@ class C2SoftGav1Dec::IntfImpl : public SimpleInterface<void>::BaseParams { 
  std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;

  std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;

  std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput;

  std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput;

  std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput;

  std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput;

  std::shared_ptr<C2StreamHdrStaticInfo::output> mHdrStaticInfo;

};

};





C2SoftGav1Dec::C2SoftGav1Dec(const char *name, c2_node_id_t id,

C2SoftGav1Dec::C2SoftGav1Dec(const char *name, c2_node_id_t id,
@@ -560,6 +625,76 @@ void C2SoftGav1Dec::process(const std::unique_ptr<C2Work> &work, 
  }

  }

}

}





void C2SoftGav1Dec::getHDRStaticParams(const libgav1::DecoderBuffer *buffer,

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

  C2StreamHdrStaticMetadataInfo::output hdrStaticMetadataInfo{};

  bool infoPresent = false;

  if (buffer->has_hdr_mdcv) {

    // hdr_mdcv.primary_chromaticity_* values are in 0.16 fixed-point format.

    hdrStaticMetadataInfo.mastering.red.x = buffer->hdr_mdcv.primary_chromaticity_x[0] / 65536.0;

    hdrStaticMetadataInfo.mastering.red.y = buffer->hdr_mdcv.primary_chromaticity_y[0] / 65536.0;



    hdrStaticMetadataInfo.mastering.green.x = buffer->hdr_mdcv.primary_chromaticity_x[1] / 65536.0;

    hdrStaticMetadataInfo.mastering.green.y = buffer->hdr_mdcv.primary_chromaticity_y[1] / 65536.0;



    hdrStaticMetadataInfo.mastering.blue.x = buffer->hdr_mdcv.primary_chromaticity_x[2] / 65536.0;

    hdrStaticMetadataInfo.mastering.blue.y = buffer->hdr_mdcv.primary_chromaticity_y[2] / 65536.0;



    // hdr_mdcv.white_point_chromaticity_* values are in 0.16 fixed-point format.

    hdrStaticMetadataInfo.mastering.white.x = buffer->hdr_mdcv.white_point_chromaticity_x / 65536.0;

    hdrStaticMetadataInfo.mastering.white.y = buffer->hdr_mdcv.white_point_chromaticity_y / 65536.0;



    // hdr_mdcv.luminance_max is in 24.8 fixed-point format.

    hdrStaticMetadataInfo.mastering.maxLuminance = buffer->hdr_mdcv.luminance_max / 256.0;

    // hdr_mdcv.luminance_min is in 18.14 format.

    hdrStaticMetadataInfo.mastering.minLuminance = buffer->hdr_mdcv.luminance_min / 16384.0;

    infoPresent = true;

  }



  if (buffer->has_hdr_cll) {

    hdrStaticMetadataInfo.maxCll = buffer->hdr_cll.max_cll;

    hdrStaticMetadataInfo.maxFall = buffer->hdr_cll.max_fall;

    infoPresent = true;

  }

  // config if static info has changed

  if (infoPresent && !(hdrStaticMetadataInfo == mHdrStaticMetadataInfo)) {

    mHdrStaticMetadataInfo = hdrStaticMetadataInfo;

    work->worklets.front()->output.configUpdate.push_back(C2Param::Copy(mHdrStaticMetadataInfo));

  }

}



void C2SoftGav1Dec::getHDR10PlusInfoData(const libgav1::DecoderBuffer *buffer,

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

  if (buffer->has_itut_t35) {

    std::vector<uint8_t> payload;

    size_t payloadSize = buffer->itut_t35.payload_size;

    if (payloadSize > 0) {

      payload.push_back(buffer->itut_t35.country_code);

      if (buffer->itut_t35.country_code == 0xFF) {

        payload.push_back(buffer->itut_t35.country_code_extension_byte);

      }

      payload.insert(payload.end(), buffer->itut_t35.payload_bytes,

                     buffer->itut_t35.payload_bytes + buffer->itut_t35.payload_size);

    }



    std::unique_ptr<C2StreamHdr10PlusInfo::output> hdr10PlusInfo =

            C2StreamHdr10PlusInfo::output::AllocUnique(payload.size());

    if (!hdr10PlusInfo) {

      ALOGE("Hdr10PlusInfo allocation failed");

      mSignalledError = true;

      work->result = C2_NO_MEMORY;

      return;

    }

    memcpy(hdr10PlusInfo->m.value, payload.data(), payload.size());



    // config if hdr10Plus info has changed

    if (nullptr == mHdr10PlusInfo || !(*hdr10PlusInfo == *mHdr10PlusInfo)) {

      mHdr10PlusInfo = std::move(hdr10PlusInfo);

      work->worklets.front()->output.configUpdate.push_back(std::move(mHdr10PlusInfo));

    }

  }

}



void C2SoftGav1Dec::getVuiParams(const libgav1::DecoderBuffer *buffer) {

void C2SoftGav1Dec::getVuiParams(const libgav1::DecoderBuffer *buffer) {

    VuiColorAspects vuiColorAspects;

    VuiColorAspects vuiColorAspects;

    vuiColorAspects.primaries = buffer->color_primary;

    vuiColorAspects.primaries = buffer->color_primary;
@@ -635,6 +770,9 @@ bool C2SoftGav1Dec::outputBuffer(const std::shared_ptr<C2BlockPool> &pool, 
  }

  }





  getVuiParams(buffer);

  getVuiParams(buffer);

  getHDRStaticParams(buffer, work);

  getHDR10PlusInfoData(buffer, work);



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

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

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

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

    ALOGE("image_format %d not supported", buffer->image_format);

    ALOGE("image_format %d not supported", buffer->image_format);

media/codec2/components/gav1/C2SoftGav1Dec.h

+7 −0
Original line number Original line Diff line number Diff line
@@ -64,6 +64,9 @@ struct C2SoftGav1Dec : public SimpleC2Component { 
  bool mSignalledOutputEos;

  bool mSignalledOutputEos;

  bool mSignalledError;

  bool mSignalledError;





  C2StreamHdrStaticMetadataInfo::output mHdrStaticMetadataInfo;

  std::unique_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfo = nullptr;



  // Color aspects. These are ISO values and are meant to detect changes in aspects to avoid

  // Color aspects. These are ISO values and are meant to detect changes in aspects to avoid

  // converting them to C2 values for each frame

  // converting them to C2 values for each frame

  struct VuiColorAspects {

  struct VuiColorAspects {
@@ -89,6 +92,10 @@ struct C2SoftGav1Dec : public SimpleC2Component { 
  struct timeval mTimeEnd;    // Time at the end of decode()

  struct timeval mTimeEnd;    // Time at the end of decode()





  bool initDecoder();

  bool initDecoder();

  void getHDRStaticParams(const libgav1::DecoderBuffer *buffer,

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

  void getHDR10PlusInfoData(const libgav1::DecoderBuffer *buffer,

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

  void getVuiParams(const libgav1::DecoderBuffer *buffer);

  void getVuiParams(const libgav1::DecoderBuffer *buffer);

  void destroyDecoder();

  void destroyDecoder();

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

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