static analysis fixes

Author: maruncz

src/librawspeed/decoders/DngDecoder.cpp

@@ -147,7 +147,7 @@ void DngDecoder::dropUnsuportedChunks(std::vector<const TiffIFD*>* data) {
   }
 }
 
-void DngDecoder::parseCFA(const TiffIFD* raw, RawImage::frame_ptr_t frame) {
+void DngDecoder::parseCFA(const TiffIFD* raw, const RawImage::frame_ptr_t &frame) {
 
   // Check if layout is OK, if present
   if (raw->hasEntry(TiffTag::CFALAYOUT) &&
@@ -214,7 +214,7 @@ void DngDecoder::parseCFA(const TiffIFD* raw, RawImage::frame_ptr_t frame) {
 
 DngTilingDescription
 DngDecoder::getTilingDescription(const TiffIFD* raw,
-                                 RawImage::frame_ptr_t frame) {
+                                 const RawImage::frame_ptr_t &frame) {
   if (raw->hasEntry(TiffTag::TILEOFFSETS)) {
     const uint32_t tilew = raw->getEntry(TiffTag::TILEWIDTH)->getU32();
     const uint32_t tileh = raw->getEntry(TiffTag::TILELENGTH)->getU32();
@@ -274,7 +274,7 @@ DngDecoder::getTilingDescription(const TiffIFD* raw,
 
 void DngDecoder::decodeData(const TiffIFD* raw, uint32_t sample_format,
                             int compression, int bps,
-                            RawImage::frame_ptr_t frame) {
+                            const RawImage::frame_ptr_t &frame) {
   if (compression == 8 && sample_format != 3) {
     ThrowRDE("Only float format is supported for "
              "deflate-compressed data.");
@@ -429,7 +429,7 @@ void DngDecoder::decodeRawInternal() {
 }
 
 void DngDecoder::handleMetadata(const TiffIFD* raw, int compression, int bps,
-                                RawImage::frame_ptr_t frame) {
+                                const RawImage::frame_ptr_t &frame) {
   // Crop
   if (raw->hasEntry(TiffTag::ACTIVEAREA)) {
     const TiffEntry* active_area = raw->getEntry(TiffTag::ACTIVEAREA);
@@ -675,7 +675,7 @@ void DngDecoder::checkSupportInternal(const CameraMetaData* meta) {
 
 /* Decodes DNG masked areas into blackareas in the image */
 bool DngDecoder::decodeMaskedAreas(const TiffIFD* raw,
-                                   RawImage::frame_ptr_t frame) {
+                                   const RawImage::frame_ptr_t &frame) {
   const TiffEntry* masked = raw->getEntry(TiffTag::MASKEDAREAS);
 
   if (masked->type != TiffDataType::SHORT && masked->type != TiffDataType::LONG)
@@ -718,7 +718,7 @@ bool DngDecoder::decodeMaskedAreas(const TiffIFD* raw,
 }
 
 bool DngDecoder::decodeBlackLevels(const TiffIFD* raw,
-                                   RawImage::frame_ptr_t frame) {
+                                   const RawImage::frame_ptr_t &frame) {
   iPoint2D blackdim(1, 1);
   if (raw->hasEntry(TiffTag::BLACKLEVELREPEATDIM)) {
     const TiffEntry* bleveldim = raw->getEntry(TiffTag::BLACKLEVELREPEATDIM);
@@ -815,7 +815,7 @@ bool DngDecoder::decodeBlackLevels(const TiffIFD* raw,
   return true;
 }
 
-void DngDecoder::setBlack(const TiffIFD* raw, RawImage::frame_ptr_t frame) {
+void DngDecoder::setBlack(const TiffIFD* raw, const RawImage::frame_ptr_t &frame) {
 
   if (raw->hasEntry(TiffTag::MASKEDAREAS) && decodeMaskedAreas(raw, frame))
     return;

src/librawspeed/decoders/DngDecoder.h

@@ -48,18 +48,18 @@ class DngDecoder final : public AbstractTiffDecoder {
   [[nodiscard]] int getDecoderVersion() const override { return 0; }
   bool mFixLjpeg;
   static void dropUnsuportedChunks(std::vector<const TiffIFD*>* data);
-  static void parseCFA(const TiffIFD* raw, RawImage::frame_ptr_t frame);
+  static void parseCFA(const TiffIFD* raw, const RawImage::frame_ptr_t &frame);
   static DngTilingDescription getTilingDescription(const TiffIFD* raw,
-                                                   RawImage::frame_ptr_t frame);
+                                                   const RawImage::frame_ptr_t &frame);
   void decodeData(const TiffIFD* raw, uint32_t sample_format, int compression,
-                  int bps, RawImage::frame_ptr_t frame);
+                  int bps, const RawImage::frame_ptr_t &frame);
   void handleMetadata(const TiffIFD* raw, int compression, int bps,
-                      RawImage::frame_ptr_t frame);
+                      const RawImage::frame_ptr_t &frame);
   static bool decodeMaskedAreas(const TiffIFD* raw,
-                                RawImage::frame_ptr_t frame);
+                                const RawImage::frame_ptr_t &frame);
   static bool decodeBlackLevels(const TiffIFD* raw,
-                                RawImage::frame_ptr_t frame);
-  static void setBlack(const TiffIFD* raw, RawImage::frame_ptr_t frame);
+                                const RawImage::frame_ptr_t &frame);
+  static void setBlack(const TiffIFD* raw, const RawImage::frame_ptr_t &frame);
 };
 
 } // namespace rawspeed

src/librawspeed/decoders/RawDecoder.cpp

@@ -277,12 +277,12 @@ void RawDecoder::decodeRaw() {
   try {
     decodeRawInternal();
     /// TODO paralelize?
-    for (auto raw : mRaw) {
-      mRaw.get(0)->checkMemIsInitialized();
+    for (const auto &raw : mRaw) {
+      raw->checkMemIsInitialized();
 
       if (interpolateBadPixels) {
-        mRaw.get(0)->fixBadPixels();
-        mRaw.get(0)->checkMemIsInitialized();
+        raw->fixBadPixels();
+        raw->checkMemIsInitialized();
       }
     }
     mRaw.metadata.pixelAspectRatio =

src/utilities/rstest/rstest.cpp

@@ -165,7 +165,7 @@ std::string img_hash(const RawImage& r, bool noSamples) {
   APPEND(&oss, "canonical_alias: %s\n", r.metadata.canonical_alias.c_str());
   APPEND(&oss, "canonical_id: %s\n", r.metadata.canonical_id.c_str());
 
-  for (auto frame : r) {
+  for (const auto &frame : r) {
 
     APPEND(&oss, "isoSpeed: %d\n", r.metadata.isoSpeed);
     APPEND(&oss, "blackLevel: %d\n", frame->blackLevel);
@@ -385,13 +385,14 @@ size_t process(const std::string& filename, const CameraMetaData* metadata,
     // write the hash. if force is set, then we are potentially overwriting here
     ofstream f(hashfile);
     f << img_hash(decoder->mRaw, noSamples);
-    if (o.dump)
+    if (o.dump){
       for (rawspeed::RawImage::storage_t::size_type i = 0;
            i < decoder->mRaw.size(); ++i) {
         std::stringstream s;
         s << filename << "." << i;
         writeImage(decoder->mRaw.get(i).get(), s.str());
       }
+    }
   } else {
     // do generate the hash string regardless.
     std::string h = img_hash(decoder->mRaw, noSamples);
@@ -406,13 +407,14 @@ size_t process(const std::string& filename, const CameraMetaData* metadata,
     if (h!= truth) {
       ofstream f(filename + ".hash.failed");
       f << h;
-      if (o.dump)
+      if (o.dump){
         for (rawspeed::RawImage::storage_t::size_type i = 0;
              i < decoder->mRaw.size(); ++i) {
           std::stringstream s;
           s << filename << "." << i << ".failed";
           writeImage(decoder->mRaw.get(i).get(), s.str());
         }
+      }
       throw RstestHashMismatch("hash/metadata mismatch", time);
     }
   }