modify return value check inside decoder

unknown committed 10 years ago

Commit 9cb4f4e1 parent 13586a311 files · +216 −197Browse files

Showing the changes to codec/decoder/core/src/decode_slice.cpp (1 of 11 files). Show all

Unified · Split

codec/decoder/core/src/decode_slice.cpp+103−103

   PDeblockingFilterMbFunc pDeblockMb;
   if (!pCtx->bAvcBasedFlag && iCurLayerWidth != pCtx->iCurSeqIntervalMaxPicWidth) {
-    return -1;
+    return ERR_INFO_WIDTH_MISMATCH;
   }
   iNextMbXyIndex   = pSliceHeader->iFirstMbInSlice;
                  "WelsTargetSliceConstruction():::MB(%d, %d) construction error. pCurSlice_type:%d",
                  pCurLayer->iMbX, pCurLayer->iMbY, pCurSlice->eSliceType);
-        return -1;
+        return ERR_INFO_MB_RECON_FAIL;
       }
     }
                "WelsTargetSliceConstruction():::pCtx->iTotalNumMbRec:%d, iTotalMbTargetLayer:%d",
                pCtx->iTotalNumMbRec, iTotalMbTargetLayer);
-      return -1;
+      return ERR_INFO_MB_NUM_EXCEED_FAIL;
     }
     if (pSliceHeader->pPps->uiNumSliceGroups > 1) {
   pCtx->pDec->iHeightInPixel = iCurLayerHeight;
   if ((pCurSlice->eSliceType != I_SLICE) && (pCurSlice->eSliceType != P_SLICE))
-    return 0;
+    return ERR_NONE; //no error but just ignore the type unsupported
   if (pCtx->pParam->bParseOnly) //for parse only, deblocking should not go on
-    return 0;
+    return ERR_NONE;
   pDeblockMb = WelsDeblockingMb;
   if (1 == pSliceHeader->uiDisableDeblockingFilterIdc
       || pCtx->pCurDqLayer->sLayerInfo.sSliceInLayer.iTotalMbInCurSlice <= 0) {
-    return 0;//NO_SUPPORTED_FILTER_IDX
+    return ERR_NONE;//NO_SUPPORTED_FILTER_IDX
   } else {
     WelsDeblockingFilterSlice (pCtx, pDeblockMb);
   }
   // any other filter_idc not supported here, 7/22/2010
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsMbInterSampleConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer,
     }
   }
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsMbInterConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer) {
   int32_t iMbX = pCurLayer->iMbX;
   pCtx->sBlockFunc.pWelsSetNonZeroCountFunc (
     pCurLayer->pNzc[pCurLayer->iMbXyIndex]); // set all none-zero nzc to 1; dbk can be opti!
-  return 0;
+  return ERR_NONE;
 }
 void WelsLumaDcDequantIdct (int16_t* pBlock, int32_t iQp, PWelsDecoderContext pCtx) {
     WelsLumaDcDequantIdct (pCurLayer->pScaledTCoeff[iMbXy], pCurLayer->pLumaQp[iMbXy], pCtx);
     RecI16x16Mb (iMbXy, pCtx, pCurLayer->pScaledTCoeff[iMbXy], pCurLayer);
-    return 0;
+    return ERR_NONE;
   }
   if (IS_INTRA8x8 (pCurLayer->pMbType[iMbXy])) {
   if (IS_INTRA4x4 (pCurLayer->pMbType[iMbXy]))
     RecI4x4Mb (iMbXy, pCtx, pCurLayer->pScaledTCoeff[iMbXy], pCurLayer);
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsMbInterPrediction (PWelsDecoderContext pCtx, PDqLayer pCurLayer) {
   GetInterPred (pDstY, pDstCb, pDstCr, pCtx);
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsTargetMbConstruction (PWelsDecoderContext pCtx) {
   PDqLayer pCurLayer = pCtx->pCurDqLayer;
   if (MB_TYPE_INTRA_PCM == pCurLayer->pMbType[pCurLayer->iMbXyIndex]) {
     //already decoded and reconstructed when parsing
-    return 0;
+    return ERR_NONE;
   } else if (IS_INTRA (pCurLayer->pMbType[pCurLayer->iMbXyIndex])) {
     WelsMbIntraPredictionConstruction (pCtx, pCurLayer, 1);
   } else if (IS_INTER (pCurLayer->pMbType[pCurLayer->iMbXyIndex])) { //InterMB
   } else {
     WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsTargetMbConstruction():::::Unknown MB type: %d",
              pCurLayer->pMbType[pCurLayer->iMbXyIndex]);
-    return -1;
+    return ERR_INFO_MB_RECON_FAIL;
   }
-  return 0;
+  return ERR_NONE;
 }
 void WelsChromaDcIdct (int16_t* pBlock) {
     iFinalMode = CheckIntraNxNPredMode (&iSampleAvail[0], &iBestMode, i, false);
     if (iFinalMode  == ERR_INVALID_INTRA4X4_MODE) {
-      return ERR_INFO_INVALID_I4x4_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I4x4_PRED_MODE);
     }
     pCurDqLayer->pIntra4x4FinalMode[iMbXy][g_kuiScan4[i]] = iFinalMode;
   if (pCurDqLayer->sLayerInfo.pPps->bEntropyCodingModeFlag) {
     WELS_READ_VERIFY (ParseIntraPredModeChromaCabac (pCtx, uiNeighAvail, iCode));
     if (iCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = iCode;
   } else {
     WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //intra_chroma_pred_mode
     if (uiCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = uiCode;
   }
   if (-1 == pCurDqLayer->pChromaPredMode[iMbXy]
       || CheckIntraChromaPredMode (uiNeighAvail, &pCurDqLayer->pChromaPredMode[iMbXy])) {
-    return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
   }
   return ERR_NONE;
 }
     iFinalMode = CheckIntraNxNPredMode (&iSampleAvail[0], &iBestMode, i << 2, true);
     if (iFinalMode  == ERR_INVALID_INTRA4X4_MODE) {
-      return ERR_INFO_INVALID_I4x4_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I4x4_PRED_MODE);
     }
     for (int j = 0; j < 4; j++) {
   if (pCurDqLayer->sLayerInfo.pPps->bEntropyCodingModeFlag) {
     WELS_READ_VERIFY (ParseIntraPredModeChromaCabac (pCtx, uiNeighAvail, iCode));
     if (iCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = iCode;
   } else {
     WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //intra_chroma_pred_mode
     if (uiCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = uiCode;
   }
   if (-1 == pCurDqLayer->pChromaPredMode[iMbXy]
       || CheckIntraChromaPredMode (uiNeighAvail, &pCurDqLayer->pChromaPredMode[iMbXy])) {
-    return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
   }
   return ERR_NONE;
   if (CheckIntra16x16PredMode (uiNeighAvail,
                                &pCurDqLayer->pIntraPredMode[iMbXy][7])) { //invalid iPredMode, must stop decoding
-    return ERR_INFO_INVALID_I16x16_PRED_MODE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I16x16_PRED_MODE);
   }
   if (pCtx->pSps->uiChromaFormatIdc == 0)
     return ERR_NONE;
   if (pCurDqLayer->sLayerInfo.pPps->bEntropyCodingModeFlag) {
     WELS_READ_VERIFY (ParseIntraPredModeChromaCabac (pCtx, uiNeighAvail, iCode));
     if (iCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = iCode;
   } else {
     WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //intra_chroma_pred_mode
     if (uiCode > MAX_PRED_MODE_ID_CHROMA) {
-      return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
     }
     pCurDqLayer->pChromaPredMode[iMbXy] = uiCode;
   }
   if (-1 == pCurDqLayer->pChromaPredMode[iMbXy]
       || CheckIntraChromaPredMode (uiNeighAvail, &pCurDqLayer->pChromaPredMode[iMbXy])) {
-    return ERR_INFO_INVALID_I_CHROMA_PRED_MODE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_I_CHROMA_PRED_MODE);
   }
   return ERR_NONE;
   GetNeighborAvailMbType (&sNeighAvail, pCurLayer);
   WELS_READ_VERIFY (ParseMBTypeISliceCabac (pCtx, &sNeighAvail, uiMbType));
   if (uiMbType > 25) {
-    return ERR_INFO_INVALID_MB_TYPE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
   } else if (!pCtx->pSps->uiChromaFormatIdc && ((uiMbType >= 5 && uiMbType <= 12) || (uiMbType >= 17
              && uiMbType <= 24))) {
-    return ERR_INFO_INVALID_MB_TYPE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
   } else if (25 == uiMbType) {   //I_PCM
     WELS_READ_VERIFY (ParseIPCMInfoCabac (pCtx));
     pSlice->iLastDeltaQp = 0;
     int32_t iQpDelta, iId8x8, iId4x4;
     WELS_READ_VERIFY (ParseDeltaQpCabac (pCtx, iQpDelta));
     if (iQpDelta > 25 || iQpDelta < -26) {//out of iQpDelta range
-      return ERR_INFO_INVALID_QP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_QP);
     }
     pCurLayer->pLumaQp[iMbXy] = (pSlice->iLastMbQp + iQpDelta + 52) % 52; //update last_mb_qp
     pSlice->iLastMbQp = pCurLayer->pLumaQp[iMbXy];
   } else { //Intra mode
     uiMbType -= 5;
     if (uiMbType > 25)
-      return ERR_INFO_INVALID_MB_TYPE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
     if (!pCtx->pSps->uiChromaFormatIdc && ((uiMbType >= 5 && uiMbType <= 12) || (uiMbType >= 17 && uiMbType <= 24)))
-      return ERR_INFO_INVALID_MB_TYPE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
     if (25 == uiMbType) {   //I_PCM
       WELS_READ_VERIFY (ParseIPCMInfoCabac (pCtx));
     WELS_READ_VERIFY (ParseDeltaQpCabac (pCtx, iQpDelta));
     if (iQpDelta > 25 || iQpDelta < -26) { //out of iQpDelta range
-      return ERR_INFO_INVALID_QP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_QP);
     }
     pCurLayer->pLumaQp[iMbXy] = (pSlice->iLastMbQp + iQpDelta + 52) % 52; //update last_mb_qp
     pSlice->iLastMbQp = pCurLayer->pLumaQp[iMbXy];
   const int32_t iMbXy = pCurLayer->iMbXyIndex;
   int8_t* pNzc = pCurLayer->pNzc[iMbXy];
   int32_t i;
+  int32_t iRet = ERR_NONE;
   uint32_t uiMbType = 0, uiCbp = 0, uiCbpL = 0, uiCbpC = 0;
   uint32_t uiCode;
   int32_t iCode;
   WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //uiMbType
   uiMbType = uiCode;
   if (uiMbType > 25)
-    return ERR_INFO_INVALID_MB_TYPE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
   if (!pCtx->pSps->uiChromaFormatIdc && ((uiMbType >= 5 && uiMbType <= 12) || (uiMbType >= 17 && uiMbType <= 24)))
-    return ERR_INFO_INVALID_MB_TYPE;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
   if (25 == uiMbType) {
     int32_t iDecStrideL = pCurLayer->pDec->iLinesize[0];
     memset (pCurLayer->pChromaQp[iMbXy], 0, sizeof (pCurLayer->pChromaQp[iMbXy]));
     memset (pNzc, 16, sizeof (pCurLayer->pNzc[iMbXy]));   //Rec. 9.2.1 for PCM, nzc=16
     WELS_READ_VERIFY (InitReadBits (pBs, 0));
-    return 0;
+    return ERR_NONE;
   } else if (0 == uiMbType) { //reference to JM
     ENFORCE_STACK_ALIGN_1D (int8_t, pIntraPredMode, 48, 16);
     pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA4x4;
     uiCbp = uiCode;
     //G.9.1 Alternative parsing process for coded pBlock pattern
     if (pCtx->pSps->uiChromaFormatIdc && (uiCbp > 47))
-      return ERR_INFO_INVALID_CBP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_CBP);
     if (!pCtx->pSps->uiChromaFormatIdc && (uiCbp > 15))
-      return ERR_INFO_INVALID_CBP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_CBP);
     if (pCtx->pSps->uiChromaFormatIdc)
       uiCbp = g_kuiIntra4x4CbpTable[uiCbp];
     iQpDelta = iCode;
     if (iQpDelta > 25 || iQpDelta < -26) { //out of iQpDelta range
-      return ERR_INFO_INVALID_QP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_QP);
     }
     pCurLayer->pLumaQp[iMbXy] = (pSlice->iLastMbQp + iQpDelta + 52) % 52; //update last_mb_qp
     if (MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy]) {
       //step1: Luma DC
-      if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 0, 16,
+      if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 0, 16, g_kuiLumaDcZigzagScan, I16_LUMA_DC,
-                                  g_kuiLumaDcZigzagScan, I16_LUMA_DC, pCurLayer->pScaledTCoeff[iMbXy], pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                          pCurLayer->pScaledTCoeff[iMbXy], pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-        return -1;//abnormal
+        return iRet;//abnormal
       }
       //step2: Luma AC
       if (uiCbpL) {
         for (i = 0; i < 16; i++) {
-          if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, i,
+          if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, i, iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1,
-                                      iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1),
+                                              g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1), I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i << 4),
-                                      I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i << 4), pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                              pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-            return -1;//abnormal
+            return iRet;//abnormal
           }
         }
         ST32A4 (&pNzc[0], LD32 (&pNonZeroCount[1 + 8 * 1]));
           if (uiCbpL & (1 << iId8x8)) {
             int32_t iIndex = (iId8x8 << 2);
             for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
-              if (WelsResidualBlockCavlc8x8 (pVlcTable, pNonZeroCount, pBs, iIndex,
+              if ((iRet = WelsResidualBlockCavlc8x8 (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - iScanIdxStart + 1,
-                                             iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan8x8 + iScanIdxStart, iMbResProperty,
+                                                     g_kuiZigzagScan8x8 + iScanIdxStart, iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iId8x8 << 6), iId4x4,
-                                             pCurLayer->pScaledTCoeff[iMbXy] + (iId8x8 << 6), iId4x4, pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                                     pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-                return -1;
+                return iRet;
               }
               iIndex++;
             }
             int32_t iIndex = (iId8x8 << 2);
             for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
               //Luma (DC and AC decoding together)
-              if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex,
+              if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - iScanIdxStart + 1,
-                                          iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan + iScanIdxStart,
+                                                  g_kuiZigzagScan + iScanIdxStart, LUMA_DC_AC_INTRA, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4),
-                                          LUMA_DC_AC_INTRA, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4), pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                                  pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-                return -1;//abnormal
+                return iRet;//abnormal
               }
               iIndex++;
             }
     if (1 == uiCbpC || 2 == uiCbpC) {
       for (i = 0; i < 2; i++) { //Cb Cr
         iMbResProperty = i ? CHROMA_DC_V : CHROMA_DC_U;
-        if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs,
+        if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 16 + (i << 2), 4, g_kuiChromaDcScan, iMbResProperty,
-                                    16 + (i << 2), 4, g_kuiChromaDcScan, iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i << 6),
+                                            pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i << 6), pCurLayer->pChromaQp[iMbXy][i], pCtx)) != ERR_NONE) {
-                                    pCurLayer->pChromaQp[iMbXy][i], pCtx)) {
+          return iRet;//abnormal
-          return -1;//abnormal
         }
       }
     }
         iMbResProperty = i ? CHROMA_AC_V : CHROMA_AC_U;
         int32_t iIndex = 16 + (i << 2);
         for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
-          if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex,
+          if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - WELS_MAX (iScanIdxStart,
-                                      iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1),
+                                              1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1), iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4),
-                                      iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4), pCurLayer->pChromaQp[iMbXy][i], pCtx)) {
+                                              pCurLayer->pChromaQp[iMbXy][i], pCtx)) != ERR_NONE) {
-            return -1;//abnormal
+            return iRet;//abnormal
           }
           iIndex++;
         }
     BsEndCavlc (pBs);
   }
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsDecodeMbCavlcISlice (PWelsDecoderContext pCtx, PNalUnit pNalCur, uint32_t& uiEosFlag) {
     WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
              "WelsDecodeMbCavlcISlice()::::pBs incomplete, iUsedBits:%" PRId64 " > pBs->iBits:%d, MUST stop decoding.",
              (int64_t) iUsedBits, pBs->iBits);
-    return -1;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_BS_INCOMPLETE);
   }
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsActualDecodeMbCavlcPSlice (PWelsDecoderContext pCtx) {
   const int32_t iMbXy = pCurLayer->iMbXyIndex;
   int8_t* pNzc = pCurLayer->pNzc[iMbXy];
   int32_t i;
+  int32_t iRet = ERR_NONE;
   uint32_t uiMbType = 0, uiCbp = 0, uiCbpL = 0, uiCbpC = 0;
   uint32_t uiCode;
   int32_t iCode;
     pCurLayer->pMbType[iMbXy] = g_ksInterMbTypeInfo[uiMbType].iType;
     WelsFillCacheInter (&sNeighAvail, pNonZeroCount, iMotionVector, iRefIndex, pCurLayer);
-    if (ParseInterInfo (pCtx, iMotionVector, iRefIndex, pBs)) {
+    if ((iRet = ParseInterInfo (pCtx, iMotionVector, iRefIndex, pBs)) != ERR_NONE) {
-      return -1;//abnormal
+      return iRet;//abnormal
     }
     if (pSlice->sSliceHeaderExt.bAdaptiveResidualPredFlag == 1) {
       pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;
     } else {
       WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "residual_pred_flag = 1 not supported.");
-      return -1;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP);
     }
   } else { //intra MB type
     uiMbType -= 5;
     if (uiMbType > 25)
-      return ERR_INFO_INVALID_MB_TYPE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
     if (!pCtx->pSps->uiChromaFormatIdc && ((uiMbType >= 5 && uiMbType <= 12) || (uiMbType >= 17 && uiMbType <= 24)))
-      return ERR_INFO_INVALID_MB_TYPE;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_TYPE);
     if (25 == uiMbType) {
       int32_t iDecStrideL = pCurLayer->pDec->iLinesize[0];
       ST32A4 (&pNzc[16], 0x10101010);
       ST32A4 (&pNzc[20], 0x10101010);
       WELS_READ_VERIFY (InitReadBits (pBs, 0));
-      return 0;
+      return ERR_NONE;
     } else {
       if (0 == uiMbType) {
         ENFORCE_STACK_ALIGN_1D (int8_t, pIntraPredMode, 48, 16);
         uiCbpC = pCtx->pSps->uiChromaFormatIdc ? pCurLayer->pCbp[iMbXy] >> 4 : 0;
         uiCbpL = pCurLayer->pCbp[iMbXy] & 15;
         WelsFillCacheNonZeroCount (&sNeighAvail, pNonZeroCount, pCurLayer);
-        if (ParseIntra16x16Mode (pCtx, &sNeighAvail, pBs, pCurLayer)) {
+        if ((iRet = ParseIntra16x16Mode (pCtx, &sNeighAvail, pBs, pCurLayer)) != ERR_NONE) {
-          return -1;
+          return iRet;
         }
       }
     }
     uiCbp = uiCode;
     {
       if (pCtx->pSps->uiChromaFormatIdc && (uiCbp > 47))
-        return ERR_INFO_INVALID_CBP;
+        return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_CBP);
       if (!pCtx->pSps->uiChromaFormatIdc && (uiCbp > 15))
-        return ERR_INFO_INVALID_CBP;
+        return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_CBP);
       if (MB_TYPE_INTRA4x4 == pCurLayer->pMbType[iMbXy] || MB_TYPE_INTRA8x8 == pCurLayer->pMbType[iMbXy]) {
         uiCbp = pCtx->pSps->uiChromaFormatIdc ? g_kuiIntra4x4CbpTable[uiCbp] : g_kuiIntra4x4CbpTable400[uiCbp];
     iQpDelta = iCode;
     if (iQpDelta > 25 || iQpDelta < -26) { //out of iQpDelta range
-      return ERR_INFO_INVALID_QP;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_QP);
     }
     pCurLayer->pLumaQp[iMbXy] = (pSlice->iLastMbQp + iQpDelta + 52) % 52; //update last_mb_qp
     if (MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy]) {
       //step1: Luma DC
-      if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 0, 16, g_kuiLumaDcZigzagScan,
+      if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 0, 16, g_kuiLumaDcZigzagScan, I16_LUMA_DC,
-                                  I16_LUMA_DC, pCurLayer->pScaledTCoeff[iMbXy], pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                          pCurLayer->pScaledTCoeff[iMbXy], pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-        return -1;//abnormal
+        return iRet;//abnormal
       }
       //step2: Luma AC
       if (uiCbpL) {
         for (i = 0; i < 16; i++) {
-          if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, i,
+          if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, i, iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1,
-                                      iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1),
+                                              g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1), I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i << 4),
-                                      I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i << 4), pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                              pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-            return -1;//abnormal
+            return iRet;//abnormal
           }
         }
         ST32A4 (&pNzc[0], LD32 (&pNonZeroCount[1 + 8 * 1]));
           if (uiCbpL & (1 << iId8x8)) {
             int32_t iIndex = (iId8x8 << 2);
             for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
-              if (WelsResidualBlockCavlc8x8 (pVlcTable, pNonZeroCount, pBs, iIndex,
+              if ((iRet = WelsResidualBlockCavlc8x8 (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - iScanIdxStart + 1,
-                                             iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan8x8 + iScanIdxStart, iMbResProperty,
+                                                     g_kuiZigzagScan8x8 + iScanIdxStart, iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iId8x8 << 6), iId4x4,
-                                             pCurLayer->pScaledTCoeff[iMbXy] + (iId8x8 << 6), iId4x4, pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                                     pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-                return -1;
+                return iRet;
               }
               iIndex++;
             }
             int32_t iIndex = (iId8x8 << 2);
             for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
               //Luma (DC and AC decoding together)
-              if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex,
+              if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - iScanIdxStart + 1,
-                                          iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan + iScanIdxStart, iMbResProperty,
+                                                  g_kuiZigzagScan + iScanIdxStart, iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4),
-                                          pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4), pCurLayer->pLumaQp[iMbXy], pCtx)) {
+                                                  pCurLayer->pLumaQp[iMbXy], pCtx)) != ERR_NONE) {
-                return -1;//abnormal
+                return iRet;//abnormal
               }
               iIndex++;
             }
         else
           iMbResProperty = i ? CHROMA_DC_V_INTER : CHROMA_DC_U_INTER;
-        if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs,
+        if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, 16 + (i << 2), 4, g_kuiChromaDcScan, iMbResProperty,
-                                    16 + (i << 2), 4, g_kuiChromaDcScan, iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i << 6),
+                                            pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i << 6), pCurLayer->pChromaQp[iMbXy][i], pCtx)) != ERR_NONE) {
-                                    pCurLayer->pChromaQp[iMbXy][i], pCtx)) {
+          return iRet;//abnormal
-          return -1;//abnormal
         }
       }
     } else {
         int32_t iIndex = 16 + (i << 2);
         for (iId4x4 = 0; iId4x4 < 4; iId4x4++) {
-          if (WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex,
+          if ((iRet = WelsResidualBlockCavlc (pVlcTable, pNonZeroCount, pBs, iIndex, iScanIdxEnd - WELS_MAX (iScanIdxStart,
-                                      iScanIdxEnd - WELS_MAX (iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1),
+                                              1) + 1, g_kuiZigzagScan + WELS_MAX (iScanIdxStart, 1), iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4),
-                                      iMbResProperty, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex << 4), pCurLayer->pChromaQp[iMbXy][i], pCtx)) {
+                                              pCurLayer->pChromaQp[iMbXy][i], pCtx)) != ERR_NONE) {
-            return -1;//abnormal
+            return iRet;//abnormal
           }
           iIndex++;
         }
     BsEndCavlc (pBs);
   }
-  return 0;
+  return ERR_NONE;
 }
 int32_t WelsDecodeMbCavlcPSlice (PWelsDecoderContext pCtx, PNalUnit pNalCur, uint32_t& uiEosFlag) {
     WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //mb_skip_run
     pSlice->iMbSkipRun = uiCode;
     if (-1 == pSlice->iMbSkipRun) {
-      return -1;
+      return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_INVALID_MB_SKIP_RUN);
     }
   }
   if (pSlice->iMbSkipRun--) {
     WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
              "WelsDecodeMbCavlcISlice()::::pBs incomplete, iUsedBits:%" PRId64 " > pBs->iBits:%d, MUST stop decoding.",
              (int64_t) iUsedBits, pBs->iBits);
-    return -1;
+    return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_BS_INCOMPLETE);
   }
-  return 0;
+  return ERR_NONE;
 }
 void WelsBlockFuncInit (SBlockFunc*   pFunc,  int32_t iCpu) {

modify return value check inside decoder

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code