nppi_compression_functions.h

 /* Copyright 2009-2018 NVIDIA Corporation.  All rights reserved. 
  * 
  * NOTICE TO LICENSEE: 
  * 
  * The source code and/or documentation ("Licensed Deliverables") are 
  * subject to NVIDIA intellectual property rights under U.S. and 
  * international Copyright laws. 
  * 
  * The Licensed Deliverables contained herein are PROPRIETARY and 
  * CONFIDENTIAL to NVIDIA and are being provided under the terms and 
  * conditions of a form of NVIDIA software license agreement by and 
  * between NVIDIA and Licensee ("License Agreement") or electronically 
  * accepted by Licensee.  Notwithstanding any terms or conditions to 
  * the contrary in the License Agreement, reproduction or disclosure 
  * of the Licensed Deliverables to any third party without the express 
  * written consent of NVIDIA is prohibited. 
  * 
  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE 
  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE 
  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE 
  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND. 
  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED 
  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, 
  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. 
  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE 
  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY 
  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY 
  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  * OF THESE LICENSED DELIVERABLES. 
  * 
  * U.S. Government End Users.  These Licensed Deliverables are a 
  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT 
  * 1995), consisting of "commercial computer software" and "commercial 
  * computer software documentation" as such terms are used in 48 
  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government 
  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and 
  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all 
  * U.S. Government End Users acquire the Licensed Deliverables with 
  * only those rights set forth herein. 
  * 
  * Any use of the Licensed Deliverables in individual and commercial 
  * software must include, in the user documentation and internal 
  * comments to the code, the above Disclaimer and U.S. Government End 
  * Users Notice. 
  */ 
#ifndef NV_NPPI_COMPRESSION_FUNCTIONS_H
#define NV_NPPI_COMPRESSION_FUNCTIONS_H
 
#include "nppdefs.h"

#ifdef __cplusplus
extern "C" {
#endif

NppStatus 
nppiQuantFwdRawTableInit_JPEG_8u(Npp8u * hpQuantRawTable, int nQualityFactor);

NppStatus 
nppiQuantFwdTableInit_JPEG_8u16u(const Npp8u * hpQuantRawTable, Npp16u * hpQuantFwdRawTable);

NppStatus 
nppiQuantInvTableInit_JPEG_8u16u(const Npp8u * hpQuantRawTable, Npp16u * hpQuantFwdRawTable);


NppStatus 
nppiDCTQuantFwd8x8LS_JPEG_8u16s_C1R_Ctx(const Npp8u  * pSrc, int nSrcStep, 
                                              Npp16s * pDst, int nDstStep, 
                                        const Npp16u * pQuantFwdTable, NppiSize oSizeROI, NppStreamContext nppStreamCtx);

NppStatus 
nppiDCTQuantFwd8x8LS_JPEG_8u16s_C1R(const Npp8u  * pSrc, int nSrcStep, 
                                          Npp16s * pDst, int nDstStep, 
                                    const Npp16u * pQuantFwdTable, NppiSize oSizeROI);

NppStatus 
nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R_Ctx(const Npp16s * pSrc, int nSrcStep, 
                                              Npp8u  * pDst, int nDstStep, 
                                        const Npp16u * pQuantInvTable, NppiSize oSizeROI, NppStreamContext nppStreamCtx);
   
NppStatus 
nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R(const Npp16s * pSrc, int nSrcStep, 
                                          Npp8u  * pDst, int nDstStep, 
                                    const Npp16u * pQuantInvTable, NppiSize oSizeROI);
   

#if defined (__cplusplus)
struct NppiDCTState;
#else
typedef struct NppiDCTState NppiDCTState;
#endif


NppStatus nppiDCTInitAlloc_Ctx(NppiDCTState** ppState, NppStreamContext nppStreamCtx);

NppStatus nppiDCTInitAlloc(NppiDCTState** ppState);

NppStatus nppiDCTFree(NppiDCTState* pState);

NppStatus 
nppiDCTQuantFwd8x8LS_JPEG_8u16s_C1R_NEW_Ctx(const Npp8u  * pSrc, int nSrcStep, 
                                                  Npp16s * pDst, int nDstStep, 
                                            const Npp8u * pQuantizationTable, NppiSize oSizeROI,
                                            NppiDCTState* pState, NppStreamContext nppStreamCtx);

NppStatus 
nppiDCTQuantFwd8x8LS_JPEG_8u16s_C1R_NEW(const Npp8u  * pSrc, int nSrcStep, 
                                              Npp16s * pDst, int nDstStep, 
                                        const Npp8u * pQuantizationTable, NppiSize oSizeROI,
                                        NppiDCTState* pState);

NppStatus 
nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R_NEW_Ctx(const Npp16s * pSrc, int nSrcStep, 
                                                  Npp8u  * pDst, int nDstStep, 
                                            const Npp8u * pQuantizationTable, NppiSize oSizeROI,
                                            NppiDCTState* pState, NppStreamContext nppStreamCtx);
                                    
NppStatus 
nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R_NEW(const Npp16s * pSrc, int nSrcStep, 
                                              Npp8u  * pDst, int nDstStep, 
                                        const Npp8u * pQuantizationTable, NppiSize oSizeROI,
                                        NppiDCTState* pState);
                                    
NppStatus
nppiDCTQuant16Fwd8x8LS_JPEG_8u16s_C1R_NEW_Ctx(const Npp8u  * pSrc, int nSrcStep,
                                                    Npp16s * pDst, int nDstStep,
                                              const Npp16u * pQuantizationTable, NppiSize oSizeROI,
                                              NppiDCTState* pState, NppStreamContext nppStreamCtx);

NppStatus
nppiDCTQuant16Fwd8x8LS_JPEG_8u16s_C1R_NEW(const Npp8u  * pSrc, int nSrcStep,
                                                Npp16s * pDst, int nDstStep,
                                          const Npp16u * pQuantizationTable, NppiSize oSizeROI,
                                          NppiDCTState* pState);

NppStatus
nppiDCTQuant16Inv8x8LS_JPEG_16s8u_C1R_NEW_Ctx(const Npp16s * pSrc, int nSrcStep,
                                                    Npp8u  * pDst, int nDstStep,
                                              const Npp16u * pQuantizationTable, NppiSize oSizeROI,
                                              NppiDCTState* pState, NppStreamContext nppStreamCtx);
                                          
NppStatus
nppiDCTQuant16Inv8x8LS_JPEG_16s8u_C1R_NEW(const Npp16s * pSrc, int nSrcStep,
                                                Npp8u  * pDst, int nDstStep,
                                          const Npp16u * pQuantizationTable, NppiSize oSizeROI,
                                          NppiDCTState* pState);
                                          
#if defined (__cplusplus)
struct NppiDecodeHuffmanSpec;
#else
typedef struct NppiDecodeHuffmanSpec NppiDecodeHuffmanSpec;
#endif

NppStatus
nppiDecodeHuffmanSpecGetBufSize_JPEG(int* pSize);

NppStatus
nppiDecodeHuffmanSpecInitHost_JPEG(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiDecodeHuffmanSpec  *pHuffmanSpec);

NppStatus
nppiDecodeHuffmanSpecInitAllocHost_JPEG(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiDecodeHuffmanSpec  **ppHuffmanSpec);

NppStatus
nppiDecodeHuffmanSpecFreeHost_JPEG(NppiDecodeHuffmanSpec  *pHuffmanSpec);

NppStatus
nppiDecodeHuffmanScanHost_JPEG_8u16s_P1R_Ctx(const Npp8u  * pSrc, Npp32s nLength,
                                             Npp32s restartInterval, Npp32s Ss, Npp32s Se, Npp32s Ah, Npp32s Al,
                                             Npp16s * pDst, Npp32s nDstStep,
                                             NppiDecodeHuffmanSpec  * pHuffmanTableDC, 
                                             NppiDecodeHuffmanSpec  * pHuffmanTableAC, 
                                             NppiSize oSizeROI, NppStreamContext nppStreamCtx); 

NppStatus
nppiDecodeHuffmanScanHost_JPEG_8u16s_P1R(const Npp8u  * pSrc, Npp32s nLength,
                                         Npp32s restartInterval, Npp32s Ss, Npp32s Se, Npp32s Ah, Npp32s Al,
                                         Npp16s * pDst, Npp32s nDstStep,
                                         NppiDecodeHuffmanSpec  * pHuffmanTableDC, 
                                         NppiDecodeHuffmanSpec  * pHuffmanTableAC, 
                                         NppiSize oSizeROI); 

 NppStatus
 nppiDecodeHuffmanScanHost_JPEG_8u16s_P3R_Ctx(const Npp8u * pSrc, Npp32s nLength,
                                              Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                              Npp16s * apDst[3], Npp32s aDstStep[3],
                                              NppiDecodeHuffmanSpec * apHuffmanDCTable[3], 
                                              NppiDecodeHuffmanSpec * apHuffmanACTable[3], 
                                              NppiSize aSizeROI[3], NppStreamContext nppStreamCtx);

 NppStatus
 nppiDecodeHuffmanScanHost_JPEG_8u16s_P3R(const Npp8u * pSrc, Npp32s nLength,
                                          Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                          Npp16s * apDst[3], Npp32s aDstStep[3],
                                          NppiDecodeHuffmanSpec * apHuffmanDCTable[3], 
                                          NppiDecodeHuffmanSpec * apHuffmanACTable[3], 
                                          NppiSize aSizeROI[3]);

#if defined (__cplusplus)
struct NppiEncodeHuffmanSpec;
#else
typedef struct NppiEncodeHuffmanSpec NppiEncodeHuffmanSpec;
#endif


NppStatus
nppiEncodeHuffmanSpecGetBufSize_JPEG(int* pSize);

NppStatus
nppiEncodeHuffmanSpecInit_JPEG_Ctx(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiEncodeHuffmanSpec  *pHuffmanSpec, NppStreamContext nppStreamCtx);

NppStatus
nppiEncodeHuffmanSpecInit_JPEG(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiEncodeHuffmanSpec  *pHuffmanSpec);

NppStatus
nppiEncodeHuffmanSpecInitAlloc_JPEG_Ctx(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiEncodeHuffmanSpec  **ppHuffmanSpec, NppStreamContext nppStreamCtx);

NppStatus
nppiEncodeHuffmanSpecInitAlloc_JPEG(const Npp8u* pRawHuffmanTable, NppiHuffmanTableType eTableType, NppiEncodeHuffmanSpec  **ppHuffmanSpec);

NppStatus
nppiEncodeHuffmanSpecFree_JPEG(NppiEncodeHuffmanSpec  *pHuffmanSpec);

NppStatus
nppiEncodeHuffmanScan_JPEG_8u16s_P1R_Ctx(const Npp16s * pSrc, Npp32s nSrcStep,
                                         Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                         Npp8u * pDst, Npp32s* nLength,
                                         NppiEncodeHuffmanSpec  * pHuffmanTableDC, 
                                         NppiEncodeHuffmanSpec  * pHuffmanTableAC, 
                                         NppiSize oSizeROI,
                                         Npp8u* pTempStorage, NppStreamContext nppStreamCtx); 

NppStatus
nppiEncodeHuffmanScan_JPEG_8u16s_P1R(const Npp16s * pSrc, Npp32s nSrcStep,
                                     Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                     Npp8u * pDst, Npp32s* nLength,
                                     NppiEncodeHuffmanSpec  * pHuffmanTableDC, 
                                     NppiEncodeHuffmanSpec  * pHuffmanTableAC, 
                                     NppiSize oSizeROI,
                                     Npp8u* pTempStorage); 

 NppStatus
 nppiEncodeHuffmanScan_JPEG_8u16s_P3R_Ctx(Npp16s * apSrc[3], Npp32s aSrcStep[3],
                                          Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                          Npp8u  * pDst, Npp32s* nLength,
                                          NppiEncodeHuffmanSpec * apHuffmanDCTable[3], 
                                          NppiEncodeHuffmanSpec * apHuffmanACTable[3], 
                                          NppiSize aSizeROI[3],
                                          Npp8u* pTempStorage, NppStreamContext nppStreamCtx);

NppStatus
 nppiEncodeHuffmanScan_JPEG_8u16s_P3R(Npp16s * apSrc[3], Npp32s aSrcStep[3],
                                      Npp32s nRestartInterval, Npp32s nSs, Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                      Npp8u  * pDst, Npp32s* nLength,
                                      NppiEncodeHuffmanSpec * apHuffmanDCTable[3], 
                                      NppiEncodeHuffmanSpec * apHuffmanACTable[3], 
                                      NppiSize aSizeROI[3],
                                      Npp8u* pTempStorage);

NppStatus
nppiEncodeOptimizeHuffmanScan_JPEG_8u16s_P1R_Ctx(const Npp16s * pSrc, Npp32s nSrcStep,
                                                 Npp32s nRestartInterval, Npp32s nSs, 
                                                 Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                                 Npp8u * pDst, Npp32s * pLength,
                                                 Npp8u * hpCodesDC, Npp8u * hpTableDC,
                                                 Npp8u * hpCodesAC, Npp8u * hpTableAC,
                                                 NppiEncodeHuffmanSpec * pHuffmanDCTable, 
                                                 NppiEncodeHuffmanSpec * pHuffmanACTable, 
                                                 NppiSize oSizeROI, Npp8u * pTempStorage, NppStreamContext nppStreamCtx);

NppStatus
nppiEncodeOptimizeHuffmanScan_JPEG_8u16s_P1R(const Npp16s * pSrc, Npp32s nSrcStep,
                                             Npp32s nRestartInterval, Npp32s nSs, 
                                             Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                             Npp8u * pDst, Npp32s * pLength,
                                             Npp8u * hpCodesDC, Npp8u * hpTableDC,
                                             Npp8u * hpCodesAC, Npp8u * hpTableAC,
                                             NppiEncodeHuffmanSpec * pHuffmanDCTable, 
                                             NppiEncodeHuffmanSpec * pHuffmanACTable, 
                                             NppiSize oSizeROI, Npp8u * pTempStorage);

NppStatus
nppiEncodeOptimizeHuffmanScan_JPEG_8u16s_P3R_Ctx(Npp16s * apSrc[3], Npp32s aSrcStep[3],
                                                 Npp32s nRestartInterval, Npp32s nSs, 
                                                 Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                                 Npp8u * pDst, Npp32s * pLength,
                                                 Npp8u * hpCodesDC[3], Npp8u * hpTableDC[3],
                                                 Npp8u * hpCodesAC[3], Npp8u * hpTableAC[3],
                                                 NppiEncodeHuffmanSpec * apHuffmanDCTable[3], 
                                                 NppiEncodeHuffmanSpec * apHuffmanACTable[3], 
                                                 NppiSize oSizeROI[3], Npp8u * pTempStorage, NppStreamContext nppStreamCtx);

NppStatus
nppiEncodeOptimizeHuffmanScan_JPEG_8u16s_P3R(Npp16s * apSrc[3], Npp32s aSrcStep[3],
                                             Npp32s nRestartInterval, Npp32s nSs, 
                                             Npp32s nSe, Npp32s nAh, Npp32s nAl,
                                             Npp8u * pDst, Npp32s * pLength,
                                             Npp8u * hpCodesDC[3], Npp8u * hpTableDC[3],
                                             Npp8u * hpCodesAC[3], Npp8u * hpTableAC[3],
                                             NppiEncodeHuffmanSpec * apHuffmanDCTable[3], 
                                             NppiEncodeHuffmanSpec * apHuffmanACTable[3], 
                                             NppiSize oSizeROI[3], Npp8u * pTempStorage);

NppStatus nppiEncodeHuffmanGetSize(NppiSize oSize, int nChannels, size_t * pBufSize);

NppStatus nppiEncodeOptimizeHuffmanGetSize(NppiSize oSize, int nChannels, int * pBufSize);



typedef struct {
    Npp8u nComponents; 
    NppiSize oSizeInBlocks; 
    NppiSize aComponentSubsampling[4]; 
    Npp16s * apComponentBuffer[4]; 
} NppiJpegFrameDescr; 

typedef struct {
    Npp8u nComponents; 
    Npp8u aComponentIdx[4]; 
    Npp8u aComponentDcHtSel[4]; 
    Npp8u aComponentAcHtSel[4]; 
    const Npp8u * apRawDcHtTable[4]; 
    const Npp8u * apRawAcHtTable[4]; 
    Npp8u nSs; 
    Npp8u nSe; 
    Npp8u nAh; 
    Npp8u nAl; 
    Npp32s restartInterval; 
    Npp32s length; 
} NppiJpegScanDescr;

enum NppiJpegDecodeJobKind {
    NPPI_JPEG_DECODE_SIMPLE, 
    // SIMPLE can be split into:
    NPPI_JPEG_DECODE_PRE, 
    NPPI_JPEG_DECODE_CPU, 
    NPPI_JPEG_DECODE_GPU, 

    NPPI_JPEG_DECODE_MEMZERO, 
    NPPI_JPEG_DECODE_FINALIZE 
};

typedef struct {
    NppiJpegFrameDescr * pFrame; 
    NppiJpegScanDescr * pScan; 
    enum NppiJpegDecodeJobKind eKind;
} NppiJpegDecodeJob;

#define NPPI_JPEG_DECODE_N_BUFFERS 3

typedef struct {
    const Npp8u * pCpuScan;
    Npp8u * pGpuScan;
    void * apCpuBuffer[NPPI_JPEG_DECODE_N_BUFFERS];
    void * apGpuBuffer[NPPI_JPEG_DECODE_N_BUFFERS];
} NppiJpegDecodeJobMemory;

NppStatus nppiJpegDecodeJobMemorySize(const NppiJpegDecodeJob * pJob, size_t * aSize);

NppStatus nppiJpegDecodeJob_Ctx(const NppiJpegDecodeJob * pJob, const NppiJpegDecodeJobMemory * pMemory, NppStreamContext nppStreamCtx);

NppStatus nppiJpegDecodeJob(const NppiJpegDecodeJob * pJob, const NppiJpegDecodeJobMemory * pMemory);

NppStatus nppiJpegDecodeJobCreateMemzero(NppiJpegDecodeJob * pJob);

NppStatus nppiJpegDecodeJobCreateFinalize(NppiJpegDecodeJob * pJob);

size_t nppiJpegDecodeGetScanDeadzoneSize(void);

size_t nppiJpegDecodeGetDCTBufferSize(NppiSize oBlocks);

NppStatus nppiDCTInv4x4_WebP_16s_C1R_Ctx(const Npp16s * pSrc, int nSrcStep, Npp16s * pDst, int nDstStep, NppiSize oSizeROI, NppStreamContext nppStreamCtx);

NppStatus nppiDCTInv4x4_WebP_16s_C1R(const Npp16s * pSrc, int nSrcStep, Npp16s * pDst, int nDstStep, NppiSize oSizeROI);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* NV_NPPI_COMPRESSION_FUNCTIONS_H */