Commit:fbf22d9c44e81ab5593664bdf77d6f7a0bc63770 (browse)
Parent:adb27023e44aa64b868881e0b9e11bbb6ea4cae9
Author:Sigrid Haflínudóttir <ftrvxmtrx@gmail.com>
Date:Tue Sep 15 17:29:23 CES 2020
Message:
fix lots of warnings

src/basetype.h => src/basetype.h
@@ -26,6 +26,8 @@
 #include <libc.h>
 typedef unsigned long size_t;
 typedef uintptr uintptr_t;
+#define _ASSERT_USED
+#define NULL nil
 #endif
 #else
 #define werrstr(...)

src/h264bsd_cavlc.c => src/h264bsd_cavlc.c
@@ -393,7 +393,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeCoeffToken(u32 bits, u32 nc)
+static u32 DecodeCoeffToken(u32 bits, u32 nc)
 {
 
 /* Variables */
@@ -470,7 +470,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeLevelPrefix(u32 bits)
+static u32 DecodeLevelPrefix(u32 bits)
 {
 
 /* Variables */
@@ -536,12 +536,12 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeTotalZeros(u32 bits, u32 totalCoeff, u32 isChromaDC)
+static u32 DecodeTotalZeros(u32 bits, u32 totalCoeff, u32 isChromaDC)
 {
 
 /* Variables */
 
-    u32 value = 0x0;
+    u32 value;
 
 /* Code */
 
@@ -658,7 +658,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeRunBefore(u32 bits, u32 zerosLeft)
+static u32 DecodeRunBefore(u32 bits, u32 zerosLeft)
 {
 
 /* Variables */

src/h264bsd_conceal.c => src/h264bsd_conceal.c
@@ -263,7 +263,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 ConcealMb(mbStorage_t *pMb, image_t *currImage, u32 row, u32 col,
+static u32 ConcealMb(mbStorage_t *pMb, image_t *currImage, u32 row, u32 col,
     u32 sliceType, u8 *refData)
 {
 
@@ -356,6 +356,7 @@
         a[1] = *pData++; a[1] += *pData++; a[1] += *pData++; a[1] += *pData++;
         a[2] = *pData++; a[2] += *pData++; a[2] += *pData++; a[2] += *pData++;
         a[3] = *pData++; a[3] += *pData++; a[3] += *pData++; a[3] += *pData++;
+        USED(pData);
         j++;
         hor++;
         firstPhase[0] += a[0] + a[1] + a[2] + a[3];
@@ -369,6 +370,7 @@
         b[1] = *pData++; b[1] += *pData++; b[1] += *pData++; b[1] += *pData++;
         b[2] = *pData++; b[2] += *pData++; b[2] += *pData++; b[2] += *pData++;
         b[3] = *pData++; b[3] += *pData++; b[3] += *pData++; b[3] += *pData++;
+        USED(pData);
         j++;
         hor++;
         firstPhase[0] += b[0] + b[1] + b[2] + b[3];
@@ -483,6 +485,7 @@
             a[1] = *pData++; a[1] += *pData++;
             a[2] = *pData++; a[2] += *pData++;
             a[3] = *pData++; a[3] += *pData++;
+            USED(pData);
             j++;
             hor++;
             firstPhase[0] += a[0] + a[1] + a[2] + a[3];
@@ -495,6 +498,7 @@
             b[1] = *pData++; b[1] += *pData++;
             b[2] = *pData++; b[2] += *pData++;
             b[3] = *pData++; b[3] += *pData++;
+            USED(pData);
             j++;
             hor++;
             firstPhase[0] += b[0] + b[1] + b[2] + b[3];
@@ -597,7 +601,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Transform(i32 *data)
+static void Transform(i32 *data)
 {
 
     u32 col;

src/h264bsd_deblocking.c => src/h264bsd_deblocking.c
@@ -234,7 +234,7 @@
             of a macroblock.
 
 ------------------------------------------------------------------------------*/
-u32 IsSliceBoundaryOnLeft(mbStorage_t *mb)
+static u32 IsSliceBoundaryOnLeft(mbStorage_t *mb)
 {
 
 /* Variables */
@@ -259,7 +259,7 @@
             current macroblock.
 
 ------------------------------------------------------------------------------*/
-u32 IsSliceBoundaryOnTop(mbStorage_t *mb)
+static u32 IsSliceBoundaryOnTop(mbStorage_t *mb)
 {
 
 /* Variables */
@@ -286,7 +286,7 @@
           shall be filtered.
 
 ------------------------------------------------------------------------------*/
-u32 GetMbFilteringFlags(mbStorage_t *mb)
+static u32 GetMbFilteringFlags(mbStorage_t *mb)
 {
 
 /* Variables */
@@ -329,7 +329,7 @@
             called -> no intra mb condition here.
 
 ------------------------------------------------------------------------------*/
-u32 InnerBoundaryStrength(mbStorage_t *mb1, u32 ind1, u32 ind2)
+static u32 InnerBoundaryStrength(mbStorage_t *mb1, u32 ind1, u32 ind2)
 {
     i32 tmp1, tmp2;
     i32 mv1, mv2, mv3, mv4;
@@ -392,7 +392,7 @@
             before this is called -> no intra mb conditions here.
 
 ------------------------------------------------------------------------------*/
-u32 EdgeBoundaryStrength(mbStorage_t *mb1, mbStorage_t *mb2,
+static u32 EdgeBoundaryStrength(mbStorage_t *mb1, mbStorage_t *mb2,
     u32 ind1, u32 ind2)
 {
 
@@ -596,7 +596,6 @@
     ASSERT(image->height);
 
     picWidthInMbs = image->width;
-    data = image->data;
     picSizeInMbs = picWidthInMbs * image->height;
 
     pMb = mb;
@@ -653,7 +652,7 @@
             Filter one vertical 4-pixel luma edge.
 
 ------------------------------------------------------------------------------*/
-void FilterVerLumaEdge(
+static void FilterVerLumaEdge(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -768,7 +767,7 @@
             Filter one horizontal 4-pixel luma edge
 
 ------------------------------------------------------------------------------*/
-void FilterHorLumaEdge(
+static void FilterHorLumaEdge(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -844,7 +843,7 @@
             be done when bS is equal to all four edges.
 
 ------------------------------------------------------------------------------*/
-void FilterHorLuma(
+static void FilterHorLuma(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -964,7 +963,7 @@
             Filter one vertical 2-pixel chroma edge
 
 ------------------------------------------------------------------------------*/
-void FilterVerChromaEdge(
+static void FilterVerChromaEdge(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -1039,7 +1038,7 @@
             Filter one horizontal 2-pixel chroma edge
 
 ------------------------------------------------------------------------------*/
-void FilterHorChromaEdge(
+static void FilterHorChromaEdge(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -1087,7 +1086,7 @@
             can be done if bS is equal for all four edges.
 
 ------------------------------------------------------------------------------*/
-void FilterHorChroma(
+static void FilterHorChroma(
   u8 *data,
   u32 bS,
   edgeThreshold_t *thresholds,
@@ -1184,7 +1183,7 @@
             the macroblock had non-zero value, HANTRO_FALSE otherwise.
 
 ------------------------------------------------------------------------------*/
-u32 GetBoundaryStrengths(mbStorage_t *mb, bS_t *bS, u32 flags)
+static u32 GetBoundaryStrengths(mbStorage_t *mb, bS_t *bS, u32 flags)
 {
 
 /* Variables */
@@ -1387,7 +1386,7 @@
             luma edges of a macroblock.
 
 ------------------------------------------------------------------------------*/
-void GetLumaEdgeThresholds(
+static void GetLumaEdgeThresholds(
   edgeThreshold_t *thresholds,
   mbStorage_t *mb,
   u32 filteringFlags)
@@ -1466,7 +1465,7 @@
             chroma edges of a macroblock.
 
 ------------------------------------------------------------------------------*/
-void GetChromaEdgeThresholds(
+static void GetChromaEdgeThresholds(
   edgeThreshold_t *thresholds,
   mbStorage_t *mb,
   u32 filteringFlags,
@@ -1548,7 +1547,7 @@
             Function to filter all luma edges of a macroblock
 
 ------------------------------------------------------------------------------*/
-void FilterLuma(
+static void FilterLuma(
   u8 *data,
   bS_t *bS,
   edgeThreshold_t *thresholds,
@@ -1630,7 +1629,7 @@
             Function to filter all chroma edges of a macroblock
 
 ------------------------------------------------------------------------------*/
-void FilterChroma(
+static void FilterChroma(
   u8 *dataCb,
   u8 *dataCr,
   bS_t *bS,

src/h264bsd_decoder.c => src/h264bsd_decoder.c
@@ -244,10 +244,10 @@
                 pStorage->currImage->data =
                     h264bsdAllocateDpbImage(pStorage->dpb);
                 h264bsdInitRefPicList(pStorage->dpb);
-                tmp = h264bsdConceal(pStorage, pStorage->currImage, P_SLICE);
+                h264bsdConceal(pStorage, pStorage->currImage, P_SLICE);
             }
             else
-                tmp = h264bsdConceal(pStorage, pStorage->currImage,
+                h264bsdConceal(pStorage, pStorage->currImage,
                     pStorage->sliceHeader->sliceType);
 
             picReady = HANTRO_TRUE;
@@ -279,7 +279,7 @@
                     FREE(seqParamSet.vuiParameters);
                     return(H264BSD_ERROR);
                 }
-                tmp = h264bsdStoreSeqParamSet(pStorage, &seqParamSet);
+                h264bsdStoreSeqParamSet(pStorage, &seqParamSet);
                 break;
 
             case NAL_PIC_PARAM_SET:
@@ -294,7 +294,7 @@
                     FREE(picParamSet.sliceGroupId);
                     return(H264BSD_ERROR);
                 }
-                tmp = h264bsdStorePicParamSet(pStorage, &picParamSet);
+                h264bsdStorePicParamSet(pStorage, &picParamSet);
                 break;
 
             case NAL_CODED_SLICE_IDR:
@@ -483,7 +483,7 @@
         {
             if (pStorage->prevNalUnit->nalRefIdc)
             {
-                tmp = h264bsdMarkDecRefPic(pStorage->dpb,
+                h264bsdMarkDecRefPic(pStorage->dpb,
                     &pStorage->sliceHeader->decRefPicMarking,
                     pStorage->currImage, pStorage->sliceHeader->frameNum,
                     picOrderCnt,
@@ -495,7 +495,7 @@
              * reordering */
             else
             {
-                tmp = h264bsdMarkDecRefPic(pStorage->dpb, NULL,
+                h264bsdMarkDecRefPic(pStorage->dpb, NULL,
                     pStorage->currImage, pStorage->sliceHeader->frameNum,
                     picOrderCnt,
                     IS_IDR_NAL_UNIT(pStorage->prevNalUnit) ?

src/h264bsd_dpb.c => src/h264bsd_dpb.c
@@ -1378,7 +1378,7 @@
 
 ------------------------------------------------------------------------------*/
 
-dpbPicture_t* FindSmallestPicOrderCnt(dpbStorage_t *dpb)
+static dpbPicture_t* FindSmallestPicOrderCnt(dpbStorage_t *dpb)
 {
 
 /* Variables */
@@ -1421,7 +1421,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 OutputPicture(dpbStorage_t *dpb)
+static u32 OutputPicture(dpbStorage_t *dpb)
 {
 
 /* Variables */

src/h264bsd_image.c => src/h264bsd_image.c
@@ -93,7 +93,7 @@
 
     ASSERT(image);
     ASSERT(data);
-    ASSERT(!((u32)data&0x3));
+    ASSERT(!((uintptr_t)data&0x3));
 
     width = image->width;
 
@@ -102,9 +102,9 @@
     lum = (u32*)image->luma;
     cb = (u32*)image->cb;
     cr = (u32*)image->cr;
-    ASSERT(!((u32)lum&0x3));
-    ASSERT(!((u32)cb&0x3));
-    ASSERT(!((u32)cr&0x3));
+    ASSERT(!((uintptr_t)lum&0x3));
+    ASSERT(!((uintptr_t)cb&0x3));
+    ASSERT(!((uintptr_t)cr&0x3));
 
     ptr = (u32*)data;
 
@@ -192,7 +192,7 @@
     ASSERT(image);
     ASSERT(data);
     ASSERT(mbNum < image->width * image->height);
-    ASSERT(!((u32)data&0x3));
+    ASSERT(!((uintptr_t)data&0x3));
 
     /* Image size in macroblocks */
     picWidth = image->width;
@@ -219,8 +219,8 @@
         tmp = data + y*16 + x;
         imageBlock = lum + y*picWidth + x;
 
-        ASSERT(!((u32)tmp&0x3));
-        ASSERT(!((u32)imageBlock&0x3));
+        ASSERT(!((uintptr_t)tmp&0x3));
+        ASSERT(!((uintptr_t)imageBlock&0x3));
 
         if (IS_RESIDUAL_EMPTY(pRes))
         {
@@ -293,8 +293,8 @@
         tmp += y*8 + x;
         imageBlock += y*picWidth + x;
 
-        ASSERT(!((u32)tmp&0x3));
-        ASSERT(!((u32)imageBlock&0x3));
+        ASSERT(!((uintptr_t)tmp&0x3));
+        ASSERT(!((uintptr_t)imageBlock&0x3));
 
         if (IS_RESIDUAL_EMPTY(pRes))
         {

src/h264bsd_inter_prediction.c => src/h264bsd_inter_prediction.c
@@ -491,7 +491,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
+static u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
 {
 
 /* Variables */
@@ -548,10 +548,22 @@
     if (tmp == NULL)
         return(HANTRO_NOK);
 
-    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
-    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] =
-    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] =
-    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;
+    pMb->mv[0] = mv;
+    pMb->mv[1] = mv;
+    pMb->mv[2] = mv;
+    pMb->mv[3] = mv;
+    pMb->mv[4] = mv;
+    pMb->mv[5] = mv;
+    pMb->mv[6] = mv;
+    pMb->mv[7] = mv;
+    pMb->mv[8] = mv;
+    pMb->mv[9] = mv;
+    pMb->mv[10] = mv;
+    pMb->mv[11] = mv;
+    pMb->mv[12] = mv;
+    pMb->mv[13] = mv;
+    pMb->mv[14] = mv;
+    pMb->mv[15] = mv;
 
     pMb->refPic[0] = refIndex;
     pMb->refPic[1] = refIndex;
@@ -575,7 +587,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
+static u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
 {
 
 /* Variables */
@@ -622,8 +634,14 @@
     if (tmp == NULL)
         return(HANTRO_NOK);
 
-    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
-    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] = mv;
+    pMb->mv[0] = mv;
+    pMb->mv[1] = mv;
+    pMb->mv[2] = mv;
+    pMb->mv[3] = mv;
+    pMb->mv[4] = mv;
+    pMb->mv[5] = mv;
+    pMb->mv[6] = mv;
+    pMb->mv[7] = mv;
     pMb->refPic[0] = refIndex;
     pMb->refPic[1] = refIndex;
     pMb->refAddr[0] = tmp;
@@ -662,8 +680,14 @@
     if (tmp == NULL)
         return(HANTRO_NOK);
 
-    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] =
-    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;
+    pMb->mv[8] = mv;
+    pMb->mv[9] = mv;
+    pMb->mv[10] = mv;
+    pMb->mv[11] = mv;
+    pMb->mv[12] = mv;
+    pMb->mv[13] = mv;
+    pMb->mv[14] = mv;
+    pMb->mv[15] = mv;
     pMb->refPic[2] = refIndex;
     pMb->refPic[3] = refIndex;
     pMb->refAddr[2] = tmp;
@@ -682,7 +706,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
+static u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
 {
 
 /* Variables */
@@ -729,8 +753,14 @@
     if (tmp == NULL)
         return(HANTRO_NOK);
 
-    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
-    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] = mv;
+    pMb->mv[0] = mv;
+    pMb->mv[1] = mv;
+    pMb->mv[2] = mv;
+    pMb->mv[3] = mv;
+    pMb->mv[8] = mv;
+    pMb->mv[9] = mv;
+    pMb->mv[10] = mv;
+    pMb->mv[11] = mv;
     pMb->refPic[0] = refIndex;
     pMb->refPic[2] = refIndex;
     pMb->refAddr[0] = tmp;
@@ -772,8 +802,14 @@
     if (tmp == NULL)
         return(HANTRO_NOK);
 
-    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] =
-    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;
+    pMb->mv[4] = mv;
+    pMb->mv[5] = mv;
+    pMb->mv[6] = mv;
+    pMb->mv[7] = mv;
+    pMb->mv[12] = mv;
+    pMb->mv[13] = mv;
+    pMb->mv[14] = mv;
+    pMb->mv[15] = mv;
     pMb->refPic[1] = refIndex;
     pMb->refPic[3] = refIndex;
     pMb->refAddr[1] = tmp;
@@ -792,7 +828,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred, dpbStorage_t *dpb)
+static u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred, dpbStorage_t *dpb)
 {
 
 /* Variables */
@@ -829,7 +865,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred, u32 mbPartIdx,
+static u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred, u32 mbPartIdx,
     u32 subMbPartIdx)
 {
 
@@ -917,7 +953,7 @@
 
 ------------------------------------------------------------------------------*/
 
-i32 MedianFilter(i32 a, i32 b, i32 c)
+static i32 MedianFilter(i32 a, i32 b, i32 c)
 {
 
 /* Variables */
@@ -926,7 +962,7 @@
 
 /* Code */
 
-    max = min = med = a;
+    max = min = a;
     if (b > max)
     {
         max = b;
@@ -960,7 +996,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb,
+static void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb,
     interNeighbour_t *n, u32 index)
 {
 
@@ -996,7 +1032,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex)
+static void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex)
 {
 
     if ( a[1].available || a[2].available || !a[0].available)

src/h264bsd_intra_prediction.c => src/h264bsd_intra_prediction.c
@@ -997,7 +997,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra16x16VerticalPrediction(u8 *data, u8 *above)
+static void Intra16x16VerticalPrediction(u8 *data, u8 *above)
 {
 
 /* Variables */
@@ -1028,7 +1028,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra16x16HorizontalPrediction(u8 *data, u8 *left)
+static void Intra16x16HorizontalPrediction(u8 *data, u8 *left)
 {
 
 /* Variables */
@@ -1059,7 +1059,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra16x16DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
+static void Intra16x16DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
     u32 availableB)
 {
 
@@ -1110,7 +1110,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra16x16PlanePrediction(u8 *data, u8 *above, u8 *left)
+static void Intra16x16PlanePrediction(u8 *data, u8 *above, u8 *left)
 {
 
 /* Variables */
@@ -1157,7 +1157,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void IntraChromaDcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
+static void IntraChromaDcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
     u32 availableB)
 {
 
@@ -1255,7 +1255,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void IntraChromaHorizontalPrediction(u8 *data, u8 *left)
+static void IntraChromaHorizontalPrediction(u8 *data, u8 *left)
 {
 
 /* Variables */
@@ -1290,7 +1290,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void IntraChromaVerticalPrediction(u8 *data, u8 *above)
+static void IntraChromaVerticalPrediction(u8 *data, u8 *above)
 {
 
 /* Variables */
@@ -1325,7 +1325,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void IntraChromaPlanePrediction(u8 *data, u8 *above, u8 *left)
+static void IntraChromaPlanePrediction(u8 *data, u8 *above, u8 *left)
 {
 
 /* Variables */
@@ -1385,7 +1385,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Get4x4NeighbourPels(u8 *a, u8 *l, u8 *data, u8 *above, u8 *left,
+static void Get4x4NeighbourPels(u8 *a, u8 *l, u8 *data, u8 *above, u8 *left,
     u32 blockNum)
 {
 
@@ -1490,7 +1490,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4VerticalPrediction(u8 *data, u8 *above)
+static void Intra4x4VerticalPrediction(u8 *data, u8 *above)
 {
 
 /* Variables */
@@ -1522,7 +1522,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4HorizontalPrediction(u8 *data, u8 *left)
+static void Intra4x4HorizontalPrediction(u8 *data, u8 *left)
 {
 
 /* Variables */
@@ -1554,7 +1554,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
+static void Intra4x4DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA,
     u32 availableB)
 {
 
@@ -1609,7 +1609,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4DiagonalDownLeftPrediction(u8 *data, u8 *above)
+static void Intra4x4DiagonalDownLeftPrediction(u8 *data, u8 *above)
 {
 
 /* Variables */
@@ -1647,7 +1647,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4DiagonalDownRightPrediction(u8 *data, u8 *above, u8 *left)
+static void Intra4x4DiagonalDownRightPrediction(u8 *data, u8 *above, u8 *left)
 {
 
 /* Variables */
@@ -1685,7 +1685,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4VerticalRightPrediction(u8 *data, u8 *above, u8 *left)
+static void Intra4x4VerticalRightPrediction(u8 *data, u8 *above, u8 *left)
 {
 
 /* Variables */
@@ -1724,7 +1724,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4HorizontalDownPrediction(u8 *data, u8 *above, u8 *left)
+static void Intra4x4HorizontalDownPrediction(u8 *data, u8 *above, u8 *left)
 {
 
 /* Variables */
@@ -1762,7 +1762,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4VerticalLeftPrediction(u8 *data, u8 *above)
+static void Intra4x4VerticalLeftPrediction(u8 *data, u8 *above)
 {
 
 /* Variables */
@@ -1800,7 +1800,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Intra4x4HorizontalUpPrediction(u8 *data, u8 *left)
+static void Intra4x4HorizontalUpPrediction(u8 *data, u8 *left)
 {
 
 /* Variables */
@@ -1841,7 +1841,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void Write4x4To16x16(u8 *data, u8 *data4x4, u32 blockNum)
+static void Write4x4To16x16(u8 *data, u8 *data4x4, u32 blockNum)
 {
 
 /* Variables */
@@ -1860,7 +1860,7 @@
 
     data += y*16+x;
 
-    ASSERT(((u32)data&0x3) == 0);
+    ASSERT(((uintptr_t)data&0x3) == 0);
 
     /*lint --e(826) */
     out32 = (u32 *)data;
@@ -1870,7 +1870,7 @@
     out32[0] = *in32++;
     out32[4] = *in32++;
     out32[8] = *in32++;
-    out32[12] = *in32++;
+    out32[12] = *in32;
 }
 
 /*------------------------------------------------------------------------------
@@ -1883,7 +1883,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DetermineIntra4x4PredMode(macroblockLayer_t *pMbLayer,
+static u32 DetermineIntra4x4PredMode(macroblockLayer_t *pMbLayer,
     u32 available, neighbour_t *nA, neighbour_t *nB, u32 index,
     mbStorage_t *nMbA, mbStorage_t *nMbB)
 {

src/h264bsd_macroblock_layer.c => src/h264bsd_macroblock_layer.c
@@ -351,7 +351,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeMbPred(strmData_t *pStrmData, mbPred_t *pMbPred, mbType_e mbType,
+static u32 DecodeMbPred(strmData_t *pStrmData, mbPred_t *pMbPred, mbType_e mbType,
     u32 numRefIdxActive)
 {
 
@@ -439,7 +439,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeSubMbPred(strmData_t *pStrmData, subMbPred_t *pSubMbPred,
+static u32 DecodeSubMbPred(strmData_t *pStrmData, subMbPred_t *pSubMbPred,
     mbType_e mbType, u32 numRefIdxActive)
 {
 
@@ -697,7 +697,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecodeResidual(strmData_t *pStrmData, residual_t *pResidual,
+static u32 DecodeResidual(strmData_t *pStrmData, residual_t *pResidual,
     mbStorage_t *pMb, mbType_e mbType, u32 codedBlockPattern)
 {
 
@@ -805,9 +805,9 @@
 
 ------------------------------------------------------------------------------*/
 #ifdef H264DEC_OMXDL
-u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, u8 *pTotalCoeff)
+static u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, u8 *pTotalCoeff)
 #else
-u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, i16 *pTotalCoeff)
+static u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, i16 *pTotalCoeff)
 #endif
 {
 /*lint -e702 */
@@ -878,7 +878,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 CbpIntra16x16(mbType_e mbType)
+static u32 CbpIntra16x16(mbType_e mbType)
 {
 
 /* Variables */
@@ -1337,7 +1337,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 ProcessResidual(mbStorage_t *pMb, i32 residualLevel[][16], u32 *coeffMap)
+static u32 ProcessResidual(mbStorage_t *pMb, i32 residualLevel[][16], u32 *coeffMap)
 {
 
 /* Variables */

src/h264bsd_pic_order_cnt.c => src/h264bsd_pic_order_cnt.c
@@ -245,6 +245,8 @@
                 absFrameNum -= 1;
 
             /* step 3 */
+            picOrderCntCycleCnt = 0;
+            frameNumInPicOrderCntCycle = 0;
             if (absFrameNum > 0)
             {
                 picOrderCntCycleCnt =

src/h264bsd_pic_param_set.c => src/h264bsd_pic_param_set.c
@@ -327,7 +327,7 @@
     pPicParamSet->redundantPicCntPresentFlag = (tmp == 1) ?
                                     HANTRO_TRUE : HANTRO_FALSE;
 
-    tmp = h264bsdRbspTrailingBits(pStrmData);
+    h264bsdRbspTrailingBits(pStrmData);
 
     /* ignore possible errors in trailing bits of parameters sets */
     return(HANTRO_OK);

src/h264bsd_reconstruct.c => src/h264bsd_reconstruct.c
@@ -2140,6 +2140,8 @@
 #ifndef FLASCC
     ASSERT(ref);
     ASSERT(fill);
+    USED(left);
+    USED(right);
 
     memcpy(fill, ref, center);
 #else
@@ -2257,7 +2259,6 @@
 /* Variables */
 
     i32 xstop, ystop;
-    void (*fp)(u8*, u8*, i32, i32, i32);
     i32 left, x, right;
     i32 top, y, bottom;
 
@@ -2274,13 +2275,6 @@
     xstop = x0 + (i32)blockWidth;
     ystop = y0 + (i32)blockHeight;
 
-    /* Choose correct function whether overfilling on left-edge or right-edge
-     * is needed or not */
-    if (x0 >= 0 && xstop <= (i32)width)
-        fp = FillRow1;
-    else
-        fp = h264bsdFillRow7;
-
     if (ystop < 0)
         y0 = -(i32)blockHeight;
 
@@ -2357,7 +2351,8 @@
     /* Bottom-overfilling */
     for ( ; bottom; bottom-- )
     {
-        //(*fp)(ref, fill, left, x, right);
+        /* Choose correct function whether overfilling on left-edge or right-edge
+         * is needed or not */
         if (x0 >= 0 && xstop <= (i32)width)
             FillRow1(ref, fill, left, x, right);
         else

src/h264bsd_sei.c => src/h264bsd_sei.c
@@ -981,6 +981,7 @@
 
     ASSERT(pStrmData);
     ASSERT(pDecRefPicMarkingRepetition);
+    USED(numRefFrames);
 
 
     tmp = h264bsdGetBits(pStrmData, 1);
@@ -999,7 +1000,7 @@
     //  &pDecRefPicMarkingRepetition->decRefPicMarking, NAL_SEI, numRefFrames);
     return(HANTRO_NOK);
 
-    return(tmp);
+    //return(tmp);
 
 }
 

src/h264bsd_seq_param_set.c => src/h264bsd_seq_param_set.c
@@ -106,9 +106,9 @@
     pSeqParamSet->profileIdc = tmp;
 
     /* constrained_set0_flag */
-    tmp = h264bsdGetBits(pStrmData, 1);
+    h264bsdGetBits(pStrmData, 1);
     /* constrained_set1_flag */
-    tmp = h264bsdGetBits(pStrmData, 1);
+    h264bsdGetBits(pStrmData, 1);
     /* constrained_set2_flag */
     tmp = h264bsdGetBits(pStrmData, 1);
 
@@ -349,7 +349,7 @@
         }
     }
 
-    tmp = h264bsdRbspTrailingBits(pStrmData);
+    h264bsdRbspTrailingBits(pStrmData);
 
     /* ignore possible errors in trailing bits of parameters sets */
     return(HANTRO_OK);
@@ -381,7 +381,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc)
+static u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc)
 {
 
 /* Variables */

src/h264bsd_slice_data.c => src/h264bsd_slice_data.c
@@ -251,7 +251,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void SetMbParams(mbStorage_t *pMb, sliceHeader_t *pSlice, u32 sliceId,
+static void SetMbParams(mbStorage_t *pMb, sliceHeader_t *pSlice, u32 sliceId,
     i32 chromaQpIndexOffset)
 {
 

src/h264bsd_slice_group_map.c => src/h264bsd_slice_group_map.c
@@ -118,7 +118,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeInterleavedMap(
+static void DecodeInterleavedMap(
   u32 *map,
   u32 numSliceGroups,
   u32 *runLength,
@@ -172,7 +172,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeDispersedMap(
+static void DecodeDispersedMap(
   u32 *map,
   u32 numSliceGroups,
   u32 picWidth,
@@ -223,7 +223,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeForegroundLeftOverMap(
+static void DecodeForegroundLeftOverMap(
   u32 *map,
   u32 numSliceGroups,
   u32 *topLeft,
@@ -292,7 +292,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeBoxOutMap(
+static void DecodeBoxOutMap(
   u32 *map,
   u32 sliceGroupChangeDirectionFlag,
   u32 unitsInSliceGroup0,
@@ -398,7 +398,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeRasterScanMap(
+static void DecodeRasterScanMap(
   u32 *map,
   u32 sliceGroupChangeDirectionFlag,
   u32 sizeOfUpperLeftGroup,
@@ -446,7 +446,7 @@
 
 ------------------------------------------------------------------------------*/
 
-void DecodeWipeMap(
+static void DecodeWipeMap(
   u32 *map,
   u32 sliceGroupChangeDirectionFlag,
   u32 sizeOfUpperLeftGroup,

src/h264bsd_slice_header.c => src/h264bsd_slice_header.c
@@ -407,7 +407,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 NumSliceGroupChangeCycleBits(u32 picSizeInMbs, u32 sliceGroupChangeRate)
+static u32 NumSliceGroupChangeCycleBits(u32 picSizeInMbs, u32 sliceGroupChangeRate)
 {
 
 /* Variables */
@@ -465,7 +465,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 RefPicListReordering(strmData_t *pStrmData,
+static u32 RefPicListReordering(strmData_t *pStrmData,
     refPicListReordering_t *pRefPicListReordering, u32 numRefIdxActive,
     u32 maxPicNum)
 {
@@ -569,7 +569,7 @@
 
 ------------------------------------------------------------------------------*/
 
-u32 DecRefPicMarking(strmData_t *pStrmData,
+static u32 DecRefPicMarking(strmData_t *pStrmData,
     decRefPicMarking_t *pDecRefPicMarking, nalUnitType_e nalUnitType,
     u32 numRefFrames)
 {

src/h264bsd_storage.c => src/h264bsd_storage.c
@@ -792,7 +792,7 @@
             HANTRO_NOK     invalid data in picture parameter set
 
 ------------------------------------------------------------------------------*/
-u32 CheckPps(picParamSet_t *pps, seqParamSet_t *sps)
+static u32 CheckPps(picParamSet_t *pps, seqParamSet_t *sps)
 {
 
     u32 i;

src/h264bsd_util.h => src/h264bsd_util.h
@@ -41,10 +41,6 @@
 #include "h264bsd_stream.h"
 #include "h264bsd_image.h"
 
-#ifdef _ASSERT_USED
-#include <assert.h>
-#endif
-
 #if defined(_RANGE_CHECK) || defined(_DEBUG_PRINT) || defined(_ERROR_PRINT)
 #include <stdio.h>
 #endif
@@ -78,6 +74,9 @@
 
 /* macro for assertion, used only if compiler flag _ASSERT_USED is defined */
 #ifdef _ASSERT_USED
+#ifndef __plan9__
+#include <assert.h>
+#endif
 #define ASSERT(expr) assert(expr)
 #else
 #define ASSERT(expr)