Filter plugin. Problem after change image depth.

Question

Hi All !
I already wrote filter plugin it work fine but only for image depth 8bit, after i change image depth on 16 or 32 bits I getting error msg box from photoshop.
I try change on 'destination.colBits = 8' or 'destination.colBits = pChannel->depth' or ' (pChannel->bounds.bottom - pChannel->bounds.top) * pChannel->depth;'  but all the same.
PixelMemoryDesc destination;
destination.data = data; //*pixel
destination.depth = pChannel->depth;
destination.rowBits = (pChannel->bounds.right - pChannel->bounds.left) * pChannel->depth;
destination.colBits = 8;
destination.bitOffset = 0 ;
Please help someone !
Very Thanks in Advance !
All code below:
//  Gauss.cpp
//  gauss
//  Created by Dmitry Volkov on 30.12.14.
//  Copyright (c) 2014 Automatic System Metering. All rights reserved.
#include "Gauss.h"
#include "GaussUI.h"
#include "FilterBigDocument.h"
#include <fstream>
using namespace std;
SPBasicSuite* sSPBasic = NULL;
FilterRecord* gFilterRecord = NULL;
PSChannelPortsSuite1* sPSChannelPortsSuite = NULL;
PSBufferSuite2* sPSBufferSuite64 = NULL;
int16* gResult = NULL;
void DoParameters ();
void DoPrepare ();
void DoStart ();
void DoFinish ();
void DoEffect();
void GaussianBlurEffect(ReadChannelDesc* pChannel, char* data);
void ReadLayerData(ReadChannelDesc* pChannel, char* pLayerData);
void WriteLayerData(ReadChannelDesc* pChannel, char* pLayerData);
DLLExport MACPASCAL void PluginMain(const int16 selector,
                                    FilterRecordPtr filterRecord,
                                    intptr_t * data,
                                    int16 * result)
    sSPBasic = filterRecord->sSPBasic;
    gFilterRecord = filterRecord;
    gResult = result;
    try {
            if (sSPBasic->AcquireSuite(kPSChannelPortsSuite,
                                               kPSChannelPortsSuiteVersion3,
                                               (const void **)&sPSChannelPortsSuite))
                *gResult = errPlugInHostInsufficient;
            if (sSPBasic->AcquireSuite( kPSBufferSuite,
                                               kPSBufferSuiteVersion2,
                                               (const void **)&sPSBufferSuite64))
                *gResult = errPlugInHostInsufficient;
            if (sPSChannelPortsSuite == NULL || sPSBufferSuite64 == NULL)
                *result = errPlugInHostInsufficient;
                return;
            switch (selector)
                case filterSelectorParameters:
                    DoParameters();
                    break;
                case filterSelectorPrepare:
                    DoPrepare();
                    break;
                case filterSelectorStart:
                    DoStart();
                    break;
                case filterSelectorFinish:
                    DoFinish();
                    break;
    catch (...)
        if (NULL != result)
            *result = -1;
void DoParameters ()
void DoPrepare ()
void DoStart ()
    if (*gResult == noErr)
        if (doUi())
            DoEffect();
void DoFinish ()
#define defColBits 8
void DoEffect()
    // Start with the first target composite channel
    ReadChannelDesc *pChannel = gFilterRecord->documentInfo->targetCompositeChannels;
    // Calculation width and height our filter window
    int32 width = pChannel->bounds.right - pChannel->bounds.left;
    int32 height = pChannel->bounds.bottom - pChannel->bounds.top;
    fstream logFile ("/Volumes/Macintosh Media/GaussLogFile.txt", ios::out);
    logFile << endl << "top " << pChannel->bounds.top;
    logFile << endl << "bottom " << pChannel->bounds.bottom;
    logFile << endl << "left " << pChannel->bounds.left;
    logFile << endl << "right " << pChannel->bounds.right;
    logFile << endl << "depth " << pChannel->depth;
    logFile << endl << "vRes " << gFilterRecord->documentInfo->vResolution;
    logFile << endl << "hRes " << gFilterRecord->documentInfo->hResolution;
    // Get a buffer to hold each channel as we process. Note we can using standart malloc(size_t) or operator new(size_t)
    // functions, but  Adobe recommend sPSBufferSuite64->New() for memory allocation
    char *pLayerData = sPSBufferSuite64->New(NULL, width*height*pChannel->depth/8);
    if (pLayerData == NULL)
        return;
    // we may have a multichannel document
    if (pChannel == NULL)
        pChannel = gFilterRecord->documentInfo->alphaChannels;
    // Loop through each of the channels
    while (pChannel != NULL && *gResult == noErr)
        ReadLayerData(pChannel, pLayerData);
        GaussianBlurEffect(pChannel, pLayerData);
        WriteLayerData(pChannel, pLayerData);
        // off to the next channel
        pChannel = pChannel->next;
    pChannel = gFilterRecord->documentInfo->targetTransparency;
    // Delete pLayerData
    sPSBufferSuite64->Dispose((char**)&pLayerData);
void GaussianBlurEffect(ReadChannelDesc* pChannel, char *data)
    // Make sure Photoshop supports the Gaussian Blur operation
    Boolean supported;
    if (sPSChannelPortsSuite->SupportsOperation(PSChannelPortGaussianBlurFilter,
                                                &supported))
        return;
    if (!supported)
        return;
    // Set up a local rect for the size of our port
    VRect writeRect = pChannel->bounds;
    PIChannelPort inPort, outPort;
    // Photoshop will make us a new port and manage the memory for us
    if (sPSChannelPortsSuite->New(&inPort,
                                  &writeRect,
                                  pChannel->depth,
                                  true))
        return;
    if (sPSChannelPortsSuite->New(&outPort,
                                  &writeRect,
                                  pChannel->depth,
                                  true))
        return;
    // Set up a PixelMemoryDesc to tell how our channel data is layed out
    PixelMemoryDesc destination;
    destination.data = data; //*pixel
    destination.depth = pChannel->depth;
    destination.rowBits = (pChannel->bounds.right - pChannel->bounds.left) * pChannel->depth;
    destination.colBits = defColBits;
    destination.bitOffset = 0 ;
    // Write the current effect we have into this port
    if (sPSChannelPortsSuite->WritePixelsToBaseLevel(inPort,
                                                     &writeRect,
                                                     &destination))
        return;
    // Set up the paramaters for the Gaussian Blur
    PSGaussianBlurParameters gbp;
    int inRadius = 1;
    Fixed what = inRadius << 16;
    gbp.radius = what;
    gbp.padding = -1;
    sPSChannelPortsSuite->ApplyOperation(PSChannelPortGaussianBlurFilter,
                                                             inPort,
                                                             outPort,
                                                             NULL,
                                                             (void*)&gbp,
                                                             &writeRect);
    if (sPSChannelPortsSuite->ReadPixelsFromLevel(outPort,
                                                  0,
                                                  &writeRect,
                                                  &destination))
        return;
    // Delete the temp port in use
    sPSChannelPortsSuite->Dispose(&inPort);
    sPSChannelPortsSuite->Dispose(&outPort);
void ReadLayerData(ReadChannelDesc *pChannel, char *pLayerData)
    // Make sure there is something for me to read from
    Boolean canRead;
    if (pChannel == NULL)
        canRead = false;
    else if (pChannel->port == NULL)
        canRead = false;
    else if (sPSChannelPortsSuite->CanRead(pChannel->port, &canRead))
        // this function should not error, tell the host accordingly
        *gResult = errPlugInHostInsufficient;
        return;
    // if everything is still ok we will continue
    if (!canRead || pLayerData == NULL)
        return;
    // some local variables to play with
    VRect readRect = pChannel->bounds;
    PixelMemoryDesc destination;
    // set up the PixelMemoryDesc
    destination.data = pLayerData;
    destination.depth = pChannel->depth;
    destination.rowBits = pChannel->depth * (readRect.right - readRect.left);
    destination.colBits = defColBits;
    destination.bitOffset = 0 ;
    // Read this data into our buffer, you could check the read_rect to see if
    // you got everything you desired
    if (sPSChannelPortsSuite->ReadPixelsFromLevel(
                                                  pChannel->port,
                                                  0,
                                                  &readRect,
                                                  &destination))
        *gResult = errPlugInHostInsufficient;
        return;
void WriteLayerData(ReadChannelDesc *pChannel, char *pLayerData)
    Boolean canWrite = true;
    if (pChannel == NULL || pLayerData == NULL)
        canWrite = false;
    else if (pChannel->writePort == NULL)
        canWrite = false;
    else if (sPSChannelPortsSuite->CanWrite(pChannel->writePort, &canWrite))
        *gResult = errPlugInHostInsufficient;
        return;
    if (!canWrite)
        return;
    VRect writeRect = pChannel->bounds;
    PixelMemoryDesc destination;
    destination.data = pLayerData;
    destination.depth = pChannel->depth;
    destination.rowBits = pChannel->depth * (writeRect.right - writeRect.left); //HSIZE * pChannel->depth * gXFactor*2;
    destination.colBits = defColBits;
    destination.bitOffset = 0 ;
    if (sPSChannelPortsSuite->WritePixelsToBaseLevel(
                                                     pChannel->writePort,
                                                     &writeRect,
                                                     &destination))
        *gResult = errPlugInHostInsufficient;
        return;

Answer 1

Have you reviewed your code vs the Dissolve example? It is enabled for other bit depths as well.