/*****************************************************************************/ // Filter // Written by Michael Pfeiffer // // Filter.h // // // Copyright (c) 2003 Haiku Project // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. /*****************************************************************************/ #ifndef _Filter_h #define _Filter_h #include <OS.h> #include <Bitmap.h> #include <Messenger.h> #include <StopWatch.h> #define TIME_FILTER 0 class Filter; typedef int32 intType; typedef int64 long_fixed_point; typedef int32 fixed_point; // Could use shift operator instead of multiplication and division, // but compiler will optimize it for use anyway. #define to_fixed_point(number) static_cast<fixed_point>((number) * kFPPrecisionFactor) #define from_fixed_point(number) ((number) / kFPPrecisionFactor) #define to_float(number) from_fixed_point(static_cast<float>(number)) #define int_value(number) ((number) & kFPInverseMask) #define tail_value(number) ((number) & kFPPrecisionMask) // Has to be called after muliplication of two fixed point values #define mult_correction(number) ((number) / kFPPrecisionFactor) const int32 kFPPrecision = 8; // (32-kFPPrecision).kFPPrecision const int32 kFPPrecisionFactor = (1 << kFPPrecision); const int32 kFPPrecisionMask = ((kFPPrecisionFactor)-1); const int32 kFPInverseMask = (~kFPPrecisionMask); const int32 kFPOne = to_fixed_point(1); // Used by class Filter class FilterThread { public: FilterThread(Filter* filter, int32 i, int32 n, bool runInCurrentThread = false); ~FilterThread(); private: status_t Run(); static status_t worker_thread(void* data); Filter* fFilter; int32 fI; int32 fN; }; class Filter { public: // The filter uses the input "image" as source image // for an operation executed in Run() method which // writes into the destination image, that can be // retrieve using GetBitmap() method. // GetBitmap() must be called either before Start(), // or after Start() and IsRunning() returns false. // To start the operation Start() method has to // be called. The operation is executed in as many // threads as GetMaxNumberOfThreads() returns. // The implementation of GetMaxNumberOfThreads() // can use CPUCount() to retrieve the number of // active CPUs at the time the Filter was created. // IsRunning() is true as long as there are any // threads running. // The operation is complete when IsRunning() is false // and Stop() has not been called. // To abort an operation Stop() method has to // be called. Stop() has to be called after Start(). // When the operation is done Completed() is called. // and only if it has not been aborted, then the listener // receives a message with the specified "what" value. Filter(BBitmap* image, BMessenger listener, uint32 what); virtual ~Filter(); // The bitmap the filter writes into BBitmap* GetBitmap(); // Removes the destination image from Filter (caller is new owner of image) BBitmap* DetachBitmap(); // Starts one or more FilterThreads. Returns immediately if async is true. // Either Wait() or Stop() has to be called if async is true! void Start(bool async = true); // Wait for completion of operation void Wait(); // Has to be called after Start() (even if IsRunning() is false) void Stop(); // Are there any running FilterThreads? bool IsRunning() const; // To be implemented by inherited class (methods are called in this order): virtual BBitmap* CreateDestImage(BBitmap* srcImage) = 0; // The number of processing units virtual int32 GetNumberOfUnits() = 0; // Should calculate part i of n of the image. i starts with zero virtual void Run(int32 i, int32 n) = 0; // Completed() is called when the last FilterThread has completed its work. virtual void Completed(); // Used by FilterThread only! void FilterThreadDone(); void FilterThreadInitFailed(); bool IsBitmapValid(BBitmap* bitmap) const; protected: // Number of threads to be used to perform the operation int32 NumberOfThreads(); BBitmap* GetSrcImage(); BBitmap* GetDestImage(); private: int32 NumberOfActiveCPUs() const; // Returns the number of active CPUs int32 CPUCount() const { return fCPUCount; } BMessenger fListener; uint32 fWhat; int32 fCPUCount; // the number of active CPUs bool fStarted; // has Start() been called? sem_id fWaitForThreads; // to exit int32 fN; // the number of used filter threads int32 fNumberOfThreads; // the current number of FilterThreads volatile bool fIsRunning; // FilterThreads should process data as long as it is true BBitmap* fSrcImage; bool fDestImageInitialized; BBitmap* fDestImage; #if TIME_FILTER BStopWatch* fStopWatch; #endif }; // Scales and optionally dithers an image class Scaler : public Filter { public: Scaler(BBitmap* image, BRect rect, BMessenger listener, uint32 what, bool dither); ~Scaler(); BBitmap* CreateDestImage(BBitmap* srcImage); int32 GetNumberOfUnits(); void Run(int32 i, int32 n); void Completed(); bool Matches(BRect rect, bool dither) const; private: void ScaleBilinear(int32 fromRow, int32 toRow); void ScaleBilinearFP(int32 fromRow, int32 toRow); inline void RowValues(float* sum, const uchar* srcData, intType srcW, intType fromX, intType toX, const float a0X, const float a1X, const int32 kBPP); void DownScaleBilinear(int32 fromRow, int32 toRow); static inline uchar Limit(intType value); void Dither(int32 fromRow, int32 toRow); BBitmap* fScaledImage; BRect fRect; bool fDither; }; // Rotates, mirrors or inverts an image class ImageProcessor : public Filter { public: enum operation { kRotateClockwise, kRotateCounterClockwise, kFlipLeftToRight, kFlipTopToBottom, kInvert, kNumberOfAffineTransformations = 4 }; ImageProcessor(enum operation op, BBitmap* image, BMessenger listener, uint32 what); BBitmap* CreateDestImage(BBitmap* srcImage); int32 GetNumberOfUnits(); void Run(int32 i, int32 n); private: int32 BytesPerPixel(color_space cs) const; inline void CopyPixel(uchar* dest, int32 destX, int32 destY, const uchar* src, int32 x, int32 y); inline void InvertPixel(int32 x, int32 y, uchar* dest, const uchar* src); enum operation fOp; int32 fBPP; int32 fWidth; int32 fHeight; int32 fSrcBPR; int32 fDestBPR; }; #endif
