nvmedia_ijpe.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
#ifndef NVMEDIA_IJPE_H
#define NVMEDIA_IJPE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "nvmedia_core.h"
#include "nvscibuf.h"
#include "nvscisync.h"
#include "nvmedia_common_encode_decode.h"
#include "nvmedia_common_encode.h"
#define NVMEDIA_IJPE_VERSION_MAJOR   1
 
#define NVMEDIA_IJPE_VERSION_MINOR   0
 
#define NVMEDIA_IJPE_VERSION_PATCH   0
 
#define NVMEDIA_IJPE_MAX_PRENVSCISYNCFENCES             (16U)
 
#define NVMEDIA_JPEG_ENC_FLAG_NONE                      (0 << 0)
 
#define NVMEDIA_JPEG_ENC_FLAG_SKIP_SOI                  (1 << 0)
 
#define NVMEDIA_IMAGE_JPEG_ATTRIBUTE_QUALITY            (1 << 0)
 
#define NVMEDIA_IMAGE_JPEG_ATTRIBUTE_RESTARTINTERVAL    (1 << 1)
 
#define NVMEDIA_IMAGE_JPEG_ATTRIBUTE_TARGETSIZE         (1 << 2)
 
#define NVMEDIA_IMAGE_JPEG_ATTRIBUTE_QUANTTABLE         (1 << 3)
 
#define NVMEDIA_IMAGE_JPEG_ATTRIBUTE_HUFFTABLE          (1 << 4)
 
typedef struct {
   uint8_t length[16];
   uint8_t *values;
} NvMediaJPHuffmanTableSpecfication;
 
typedef struct {
   uint8_t quality;
   uint32_t restartInterval;
   uint32_t targetImageSize;
   uint8_t lumaQuant[64];
   uint8_t chromaQuant[64];
   NvMediaJPHuffmanTableSpecfication *lumaDC;
   NvMediaJPHuffmanTableSpecfication *lumaAC;
   NvMediaJPHuffmanTableSpecfication *chromaDC;
   NvMediaJPHuffmanTableSpecfication *chromaAC;
} NvMediaJPEncAttributes;
 
typedef struct NvMediaIJPE NvMediaIJPE;
 
NvMediaStatus
NvMediaIJPEGetVersion(
    NvMediaVersion *version
);
 
NvMediaIJPE *
NvMediaIJPECreate(
    //NvMediaSurfaceType inputFormat,
    NvSciBufAttrList bufAttrList,
    uint8_t maxOutputBuffering,
    uint32_t  maxBitstreamBytes,
    NvMediaJPEGInstanceId instanceId
);
 
NvMediaIJPE *
NvMediaIJPECreateEx(
    uint8_t maxOutputBuffering,
    uint32_t  maxBitstreamBytes,
    NvMediaJPEGInstanceId instanceId
);
 
void NvMediaIJPEDestroy(NvMediaIJPE *encoder);
 
NvMediaStatus
NvMediaIJPEFeedFrame(
    const NvMediaIJPE *encoder,
    NvSciBufObj bufObj,
    uint8_t quality,
    NvMediaJPEGInstanceId instanceId
);
 
NvMediaStatus
NvMediaIJPEFeedFrameQuant(
    const NvMediaIJPE *encoder,
    NvSciBufObj bufObj,
    uint8_t *lumaQuant,
    uint8_t *chromaQuant,
    NvMediaJPEGInstanceId instanceId
);
 
NvMediaStatus
NvMediaIJPEFeedFrameRateControl(
    const NvMediaIJPE *encoder,
    NvSciBufObj bufObj,
    uint8_t *lumaQuant,
    uint8_t *chromaQuant,
    uint32_t targetImageSize,
    NvMediaJPEGInstanceId instanceId
);
 
NvMediaStatus
NvMediaIJPESetAttributes(
    const NvMediaIJPE *encoder,
    uint32_t attributeMask,
    const void *attributes
);
 
NvMediaStatus
NvMediaIJPEGetBits(
    const NvMediaIJPE *encoder,
    uint32_t *numBytes,
    void *buffer,
    uint32_t flags
);
 
NvMediaStatus
NvMediaIJPEGetBitsEx(
    const NvMediaIJPE *encoder,
    uint32_t *numBytes,
    uint32_t numBitstreamBuffers,
    const NvMediaBitstreamBuffer *bitstreams,
    uint32_t flags
);
 
NvMediaStatus
NvMediaIJPEBitsAvailable(
    const NvMediaIJPE *encoder,
    uint32_t *numBytesAvailable,
    NvMediaBlockingType blockingType,
    uint32_t millisecondTimeout
);
 
NvMediaStatus
NvMediaIJPERegisterNvSciBufObj(
    const NvMediaIJPE   *encoder,
    NvSciBufObj         bufObj
);
 
// coverity[misra_c_2012_rule_8_7_violation : FALSE]
NvMediaStatus
NvMediaIJPEUnregisterNvSciBufObj(
    const NvMediaIJPE    *encoder,
    NvSciBufObj          bufObj
);
 
 
NvMediaStatus
NvMediaIJPEFillNvSciBufAttrList(
    NvMediaJPEGInstanceId     instanceId,
    NvSciBufAttrList          attrlist
);
 
NvMediaStatus
NvMediaIJPEFillNvSciSyncAttrList(
    const NvMediaIJPE           *encoder,
    NvSciSyncAttrList          attrlist,
    NvMediaNvSciSyncClientType clienttype
);
 
 
NvMediaStatus
NvMediaIJPERegisterNvSciSyncObj(
    const NvMediaIJPE           *encoder,
    NvMediaNvSciSyncObjType    syncobjtype,
    NvSciSyncObj               nvscisync
);
 
NvMediaStatus
NvMediaIJPEUnregisterNvSciSyncObj(
    const NvMediaIJPE  *encoder,
    NvSciSyncObj      nvscisync
);
 
NvMediaStatus
NvMediaIJPESetNvSciSyncObjforEOF(
    const NvMediaIJPE      *encoder,
    NvSciSyncObj          nvscisyncEOF
);
 
NvMediaStatus
NvMediaIJPEInsertPreNvSciSyncFence(
    const NvMediaIJPE         *encoder,
    const NvSciSyncFence     *prenvscisyncfence
);
 
NvMediaStatus
NvMediaIJPEGetEOFNvSciSyncFence(
    const NvMediaIJPE        *encoder,
    NvSciSyncObj      eofnvscisyncobj,
    NvSciSyncFence    *eofnvscisyncfence
);
 
 
#ifdef __cplusplus
}     /* extern "C" */
#endif
 
#endif /* NVMEDIA_IJPE_H */