src/apps/showimage/Filter.h

   1 /*****************************************************************************/
   2 // Filter
   3 // Written by Michael Pfeiffer
   4 //
   5 // Filter.h
   6 //
   7 //
   8 // Copyright (c) 2003 OpenBeOS Project
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining a
  11 // copy of this software and associated documentation files (the "Software"),
  12 // to deal in the Software without restriction, including without limitation
  13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14 // and/or sell copies of the Software, and to permit persons to whom the
  15 // Software is furnished to do so, subject to the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be included
  18 // in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26 // DEALINGS IN THE SOFTWARE.
  27 /*****************************************************************************/
  28
  29 #ifndef _Filter_h
  30 #define _Filter_h
  31
  32 #include <OS.h>
  33 #include <Bitmap.h>
  34 #include <Messenger.h>
  35 #include <StopWatch.h>
  36
  37 #define TIME_FILTER 0
  38
  39 class Filter;
  40
  41 typedef int32 intType;
  42 typedef int64 long_fixed_point;
  43 typedef int32 fixed_point;
  44
  45 // Could use shift operator instead of multiplication and division,
  46 // but compiler will optimize it for use anyway.
  47 #define to_fixed_point(number) static_cast<fixed_point>((number) * kFPPrecisionFactor)
  48 #define from_fixed_point(number) ((number) / kFPPrecisionFactor)
  49 #define to_float(number) from_fixed_point(static_cast<float>(number))
  50
  51 #define int_value(number) ((number) & kFPInverseMask)
  52 #define tail_value(number) ((number) & kFPPrecisionMask)
  53
  54 // Has to be called after muliplication of two fixed point values
  55 #define mult_correction(number) ((number) / kFPPrecisionFactor)
  56
  57 const int32 kFPPrecision = 8; // (32-kFPPrecision).kFPPrecision
  58 const int32 kFPPrecisionFactor = (1 << kFPPrecision);
  59 const int32 kFPPrecisionMask = ((kFPPrecisionFactor)-1);
  60 const int32 kFPInverseMask = (~kFPPrecisionMask);
  61 const int32 kFPOne = to_fixed_point(1);
  62
  63 // Used by class Filter
  64 class FilterThread {
  65 public:
  66         FilterThread(Filter* filter, int32 i, int32 n,
  67                 bool runInCurrentThread = false);
  68         ~FilterThread();
  69
  70 private:
  71         status_t Run();
  72         static status_t worker_thread(void* data);
  73
  74         Filter* fFilter;
  75         int32   fI;
  76         int32   fN;
  77 };
  78
  79 class Filter {
  80 public:
  81         // The filter uses the input "image" as source image
  82         // for an operation executed in Run() method which
  83         // writes into the destination image, that can be
  84         // retrieve using GetBitmap() method.
  85         // GetBitmap() must be called either before Start(),
  86         // or after Start() and IsRunning() returns false.
  87         // To start the operation Start() method has to
  88         // be called. The operation is executed in as many
  89         // threads as GetMaxNumberOfThreads() returns.
  90         // The implementation of GetMaxNumberOfThreads()
  91         // can use CPUCount() to retrieve the number of
  92         // active CPUs at the time the Filter was created.
  93         // IsRunning() is true as long as there are any
  94         // threads running.
  95         // The operation is complete when IsRunning() is false
  96         // and Stop() has not been called.
  97         // To abort an operation Stop() method has to
  98         // be called. Stop() has to be called after Start().
  99         // When the operation is done Completed() is called.
 100         // and only if it has not been aborted, then the listener
 101         // receives a message with the specified "what" value.
 102         Filter(BBitmap* image, BMessenger listener, uint32 what);
 103         virtual ~Filter();
 104
 105         // The bitmap the filter writes into
 106         BBitmap* GetBitmap();
 107         // Removes the destination image from Filter (caller is new owner of image)
 108         BBitmap* DetachBitmap();
 109
 110         // Starts one or more FilterThreads. Returns immediately if async is true.
 111         // Either Wait() or Stop() has to be called if async is true!
 112         void Start(bool async = true);
 113         // Wait for completion of operation
 114         void Wait();
 115         // Has to be called after Start() (even if IsRunning() is false)
 116         void Stop();
 117         // Are there any running FilterThreads?
 118         bool IsRunning() const;
 119
 120         // To be implemented by inherited class (methods are called in this order):
 121         virtual BBitmap* CreateDestImage(BBitmap* srcImage) = 0;
 122         // The number of processing units
 123         virtual int32 GetNumberOfUnits() = 0;
 124         // Should calculate part i of n of the image. i starts with zero
 125         virtual void Run(int32 i, int32 n) = 0;
 126         // Completed() is called when the last FilterThread has completed its work.
 127         virtual void Completed();
 128
 129         // Used by FilterThread only!
 130         void FilterThreadDone();
 131         void FilterThreadInitFailed();
 132
 133         bool IsBitmapValid(BBitmap* bitmap) const;
 134
 135 protected:
 136         // Number of threads to be used to perform the operation
 137         int32 NumberOfThreads();
 138         BBitmap* GetSrcImage();
 139         BBitmap* GetDestImage();
 140
 141 private:
 142         int32 NumberOfActiveCPUs() const;
 143         // Returns the number of active CPUs
 144         int32 CPUCount() const { return fCPUCount; }
 145
 146         BMessenger              fListener;
 147         uint32                  fWhat;
 148         int32                   fCPUCount; // the number of active CPUs
 149         bool                    fStarted; // has Start() been called?
 150         sem_id                  fWaitForThreads; // to exit
 151         int32                   fN; // the number of used filter threads
 152         int32                   fNumberOfThreads; // the current number of FilterThreads
 153         volatile bool   fIsRunning; // FilterThreads should process data as long as it is true
 154         BBitmap*                fSrcImage;
 155         bool                    fDestImageInitialized;
 156         BBitmap*                fDestImage;
 157 #if TIME_FILTER
 158         BStopWatch*             fStopWatch;
 159 #endif
 160 };
 161
 162 // Scales and optionally dithers an image
 163 class Scaler : public Filter {
 164 public:
 165         Scaler(BBitmap* image, BRect rect, BMessenger listener, uint32 what,
 166                 bool dither);
 167         ~Scaler();
 168
 169         BBitmap* CreateDestImage(BBitmap* srcImage);
 170         int32 GetNumberOfUnits();
 171         void Run(int32 i, int32 n);
 172         void Completed();
 173         bool Matches(BRect rect, bool dither) const;
 174
 175 private:
 176         void ScaleBilinear(int32 fromRow, int32 toRow);
 177         void ScaleBilinearFP(int32 fromRow, int32 toRow);
 178         inline void RowValues(float* sum, const uchar* srcData, intType srcW,
 179                                         intType fromX, intType toX, const float a0X,
 180                                         const float a1X, const int32 kBPP);
 181         void DownScaleBilinear(int32 fromRow, int32 toRow);
 182         static inline uchar Limit(intType value);
 183         void Dither(int32 fromRow, int32 toRow);
 184
 185         BBitmap* fScaledImage;
 186         BRect fRect;
 187         bool fDither;
 188 };
 189
 190 // Rotates, mirrors or inverts an image
 191 class ImageProcessor : public Filter {
 192 public:
 193         enum operation {
 194                 kRotateClockwise,
 195                 kRotateCounterClockwise,
 196                 kFlipLeftToRight,
 197                 kFlipTopToBottom,
 198                 kInvert,
 199                 kNumberOfAffineTransformations = 4
 200         };
 201
 202         ImageProcessor(enum operation op, BBitmap* image, BMessenger listener,
 203                 uint32 what);
 204         BBitmap* CreateDestImage(BBitmap* srcImage);
 205         int32 GetNumberOfUnits();
 206         void Run(int32 i, int32 n);
 207
 208 private:
 209         int32 BytesPerPixel(color_space cs) const;
 210         inline void CopyPixel(uchar* dest, int32 destX, int32 destY,
 211                                         const uchar* src, int32 x, int32 y);
 212         inline void InvertPixel(int32 x, int32 y, uchar* dest, const uchar* src);
 213
 214         enum operation fOp;
 215         int32 fBPP;
 216         int32 fWidth;
 217         int32 fHeight;
 218         int32 fSrcBPR;
 219         int32 fDestBPR;
 220 };
 221
 222 #endif