orthanc-webviewer: Orthanc/Sdk-0.9.4/orthanc/OrthancCPlugin.h comparison

comparison Orthanc/Sdk-0.9.4/orthanc/OrthancCPlugin.h @ 101:2932473a9b19 refactoring

fix prefetching

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 27 Nov 2015 22:05:51 +0100
parents	d6da56f86e5a
children

comparison

equal deleted inserted replaced

-:f5b1a9267da0
+:2932473a9b19
 *    - Register all its REST callbacks using ::OrthancPluginRegisterRestCallback().
 *    - Possibly register its callback for received DICOM instances using ::OrthancPluginRegisterOnStoredInstanceCallback().
 *    - Possibly register its callback for changes to the DICOM store using ::OrthancPluginRegisterOnChangeCallback().
 *    - Possibly register a custom storage area using ::OrthancPluginRegisterStorageArea().
 *    - Possibly register a custom database back-end area using OrthancPluginRegisterDatabaseBackendV2().
+*    - Possibly register a handler for C-Find SCP against DICOM worklists using OrthancPluginRegisterWorklistCallback().
+*    - Possibly register a custom decoder for DICOM images using OrthancPluginRegisterDecodeImageCallback().
 * -# <tt>void OrthancPluginFinalize()</tt>:
 *    This function is invoked by Orthanc during its shutdown. The plugin
 *    must free all its memory.
 * -# <tt>const char* OrthancPluginGetName()</tt>:
 *    The plugin must return a short string to identify itself.
 * @defgroup REST REST
 * @brief Functions to answer REST requests in a callback.
 *
 * @defgroup Callbacks Callbacks
 * @brief Functions to register and manage callbacks by the plugins.
+*
+* @defgroup Worklists Worklists
+* @brief Functions to register and manage worklists.
 *
 * @defgroup Orthanc Orthanc
 * @brief Functions to access the content of the Orthanc server.
 **/
 #define ORTHANC_PLUGINS_API
 #endif
 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER     0
 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER     9
-#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER  4
+#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER  5
 /********************************************************************
 ** Check that function inlining is properly supported. The use of
 OrthancPluginErrorCode_UnknownPluginService = 26    /*!< Plugin invoking an unknown service */,
 OrthancPluginErrorCode_UnknownDicomTag = 27    /*!< Unknown DICOM tag */,
 OrthancPluginErrorCode_BadJson = 28    /*!< Cannot parse a JSON document */,
 OrthancPluginErrorCode_Unauthorized = 29    /*!< Bad credentials were provided to an HTTP request */,
 OrthancPluginErrorCode_BadFont = 30    /*!< Badly formatted font file */,
+OrthancPluginErrorCode_DatabasePlugin = 31    /*!< The plugin implementing a custom database back-end does not fulfill the proper interface */,
+OrthancPluginErrorCode_StorageAreaPlugin = 32    /*!< Error in the plugin implementing a custom storage area */,
+OrthancPluginErrorCode_EmptyRequest = 33    /*!< The request is empty */,
+OrthancPluginErrorCode_NotAcceptable = 34    /*!< Cannot send a response which is acceptable according to the Accept HTTP header */,
 OrthancPluginErrorCode_SQLiteNotOpened = 1000    /*!< SQLite: The database is not opened */,
 OrthancPluginErrorCode_SQLiteAlreadyOpened = 1001    /*!< SQLite: Connection is already open */,
 OrthancPluginErrorCode_SQLiteCannotOpen = 1002    /*!< SQLite: Unable to open the database */,
 OrthancPluginErrorCode_SQLiteStatementAlreadyUsed = 1003    /*!< SQLite: This cached statement is already being referred to */,
 OrthancPluginErrorCode_SQLiteExecute = 1004    /*!< SQLite: Cannot execute a command */,
 OrthancPluginErrorCode_CannotExecuteLua = 2031    /*!< Cannot execute a Lua command */,
 OrthancPluginErrorCode_LuaAlreadyExecuted = 2032    /*!< Arguments cannot be pushed after the Lua function is executed */,
 OrthancPluginErrorCode_LuaBadOutput = 2033    /*!< The Lua function does not give the expected number of outputs */,
 OrthancPluginErrorCode_NotLuaPredicate = 2034    /*!< The Lua function is not a predicate (only true/false outputs allowed) */,
 OrthancPluginErrorCode_LuaReturnsNoString = 2035    /*!< The Lua function does not return a string */,
+OrthancPluginErrorCode_StorageAreaAlreadyRegistered = 2036    /*!< Another plugin has already registered a custom storage area */,
+OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered = 2037    /*!< Another plugin has already registered a custom database back-end */,
+OrthancPluginErrorCode_DatabaseNotInitialized = 2038    /*!< Plugin trying to call the database during its initialization */,
+OrthancPluginErrorCode_SslDisabled = 2039    /*!< Orthanc has been built without SSL support */,
+OrthancPluginErrorCode_CannotOrderSlices = 2040    /*!< Unable to order the slices of the series */,
+OrthancPluginErrorCode_NoWorklistHandler = 2041    /*!< No request handler factory for DICOM C-Find Modality SCP */,
 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
 } OrthancPluginErrorCode;
 _OrthancPluginService_BufferCompression = 14,
 _OrthancPluginService_ReadFile = 15,
 _OrthancPluginService_WriteFile = 16,
 _OrthancPluginService_GetErrorDescription = 17,
 _OrthancPluginService_CallHttpClient = 18,
+_OrthancPluginService_RegisterErrorCode = 19,
+_OrthancPluginService_RegisterDictionaryTag = 20,
+_OrthancPluginService_DicomBufferToJson = 21,
+_OrthancPluginService_DicomInstanceToJson = 22,
+_OrthancPluginService_CreateDicom = 23,
+_OrthancPluginService_ComputeMd5 = 24,
+_OrthancPluginService_ComputeSha1 = 25,
 /* Registration of callbacks */
 _OrthancPluginService_RegisterRestCallback = 1000,
 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
 _OrthancPluginService_RegisterStorageArea = 1002,
 _OrthancPluginService_RegisterOnChangeCallback = 1003,
 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
+_OrthancPluginService_RegisterWorklistCallback = 1005,
+_OrthancPluginService_RegisterDecodeImageCallback = 1006,
 /* Sending answers to REST calls */
 _OrthancPluginService_AnswerBuffer = 2000,
 _OrthancPluginService_CompressAndAnswerPngImage = 2001,  /* Unused as of Orthanc 0.9.4 */
 _OrthancPluginService_Redirect = 2002,
 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
+_OrthancPluginService_ReconstructMainDicomTags = 3014,
+_OrthancPluginService_RestApiGet2 = 3015,
 /* Access to DICOM instances */
 _OrthancPluginService_GetInstanceRemoteAet = 4000,
 _OrthancPluginService_GetInstanceSize = 4001,
 _OrthancPluginService_GetInstanceData = 4002,
 _OrthancPluginService_GetInstanceJson = 4003,
 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
 _OrthancPluginService_HasInstanceMetadata = 4005,
 _OrthancPluginService_GetInstanceMetadata = 4006,
+_OrthancPluginService_GetInstanceOrigin = 4007,
 /* Services for plugins implementing a database back-end */
 _OrthancPluginService_RegisterDatabaseBackend = 5000,
 _OrthancPluginService_DatabaseAnswer = 5001,
 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
 _OrthancPluginService_CompressImage = 6007,
 _OrthancPluginService_ConvertPixelFormat = 6008,
 _OrthancPluginService_GetFontsCount = 6009,
 _OrthancPluginService_GetFontInfo = 6010,
 _OrthancPluginService_DrawText = 6011,
+_OrthancPluginService_CreateImage = 6012,
+_OrthancPluginService_CreateImageAccessor = 6013,
+_OrthancPluginService_DecodeDicomImage = 6014,
+/* Primitives for handling worklists */
+_OrthancPluginService_WorklistAddAnswer = 7000,
+_OrthancPluginService_WorklistMarkIncomplete = 7001,
+_OrthancPluginService_WorklistIsMatch = 7002,
+_OrthancPluginService_WorklistGetDicomQuery = 7003,
 _OrthancPluginService_INTERNAL = 0x7fffffff
 } _OrthancPluginService;
 {
 OrthancPluginResourceType_Patient = 0,     /*!< Patient */
 OrthancPluginResourceType_Study = 1,       /*!< Study */
 OrthancPluginResourceType_Series = 2,      /*!< Series */
 OrthancPluginResourceType_Instance = 3,    /*!< Instance */
+OrthancPluginResourceType_None = 4,        /*!< Unavailable resource type */
 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
 } OrthancPluginResourceType;
 OrthancPluginChangeType_NewSeries = 5,          /*!< New series created */
 OrthancPluginChangeType_NewStudy = 6,           /*!< New study created */
 OrthancPluginChangeType_StablePatient = 7,      /*!< Timeout: No new instance in this patient */
 OrthancPluginChangeType_StableSeries = 8,       /*!< Timeout: No new instance in this series */
 OrthancPluginChangeType_StableStudy = 9,        /*!< Timeout: No new instance in this study */
+OrthancPluginChangeType_OrthancStarted = 10,    /*!< Orthanc has started */
+OrthancPluginChangeType_OrthancStopped = 11,    /*!< Orthanc is stopping */
+OrthancPluginChangeType_UpdatedAttachment = 12, /*!< Some user-defined attachment has changed for this resource */
+OrthancPluginChangeType_UpdatedMetadata = 13,   /*!< Some user-defined metadata has changed for this resource */
 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
 } OrthancPluginChangeType;
 * The image formats that are supported by the Orthanc core.
 * @ingroup Images
 **/
 typedef enum
 {
-OrthancPluginImageFormat_Png = 0,   /*!< Image compressed using PNG */
+OrthancPluginImageFormat_Png = 0,    /*!< Image compressed using PNG */
-OrthancPluginImageFormat_Jpeg = 1,  /*!< Image compressed using JPEG */
+OrthancPluginImageFormat_Jpeg = 1,   /*!< Image compressed using JPEG */
+OrthancPluginImageFormat_Dicom = 2,  /*!< Image compressed using DICOM */
 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
 } OrthancPluginImageFormat;
+/**
+* The value representations present in the DICOM standard (version 2013).
+* @ingroup Toolbox
+**/
+typedef enum
+{
+OrthancPluginValueRepresentation_AE = 1,   /*!< Application Entity */
+OrthancPluginValueRepresentation_AS = 2,   /*!< Age String */
+OrthancPluginValueRepresentation_AT = 3,   /*!< Attribute Tag */
+OrthancPluginValueRepresentation_CS = 4,   /*!< Code String */
+OrthancPluginValueRepresentation_DA = 5,   /*!< Date */
+OrthancPluginValueRepresentation_DS = 6,   /*!< Decimal String */
+OrthancPluginValueRepresentation_DT = 7,   /*!< Date Time */
+OrthancPluginValueRepresentation_FD = 8,   /*!< Floating Point Double */
+OrthancPluginValueRepresentation_FL = 9,   /*!< Floating Point Single */
+OrthancPluginValueRepresentation_IS = 10,  /*!< Integer String */
+OrthancPluginValueRepresentation_LO = 11,  /*!< Long String */
+OrthancPluginValueRepresentation_LT = 12,  /*!< Long Text */
+OrthancPluginValueRepresentation_OB = 13,  /*!< Other Byte String */
+OrthancPluginValueRepresentation_OF = 14,  /*!< Other Float String */
+OrthancPluginValueRepresentation_OW = 15,  /*!< Other Word String */
+OrthancPluginValueRepresentation_PN = 16,  /*!< Person Name */
+OrthancPluginValueRepresentation_SH = 17,  /*!< Short String */
+OrthancPluginValueRepresentation_SL = 18,  /*!< Signed Long */
+OrthancPluginValueRepresentation_SQ = 19,  /*!< Sequence of Items */
+OrthancPluginValueRepresentation_SS = 20,  /*!< Signed Short */
+OrthancPluginValueRepresentation_ST = 21,  /*!< Short Text */
+OrthancPluginValueRepresentation_TM = 22,  /*!< Time */
+OrthancPluginValueRepresentation_UI = 23,  /*!< Unique Identifier (UID) */
+OrthancPluginValueRepresentation_UL = 24,  /*!< Unsigned Long */
+OrthancPluginValueRepresentation_UN = 25,  /*!< Unknown */
+OrthancPluginValueRepresentation_US = 26,  /*!< Unsigned Short */
+OrthancPluginValueRepresentation_UT = 27,  /*!< Unlimited Text */
+_OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
+} OrthancPluginValueRepresentation;
+/**
+* The possible output formats for a DICOM-to-JSON conversion.
+* @ingroup Toolbox
+* @see OrthancPluginDicomToJson()
+**/
+typedef enum
+{
+OrthancPluginDicomToJsonFormat_Full = 1,    /*!< Full output, with most details */
+OrthancPluginDicomToJsonFormat_Short = 2,   /*!< Tags output as hexadecimal numbers */
+OrthancPluginDicomToJsonFormat_Simple = 3,  /*!< Human-readable JSON */
+_OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
+} OrthancPluginDicomToJsonFormat;
+/**
+* Flags to customize a DICOM-to-JSON conversion. By default, binary
+* tags are formatted using Data URI scheme.
+* @ingroup Toolbox
+**/
+typedef enum
+{
+OrthancPluginDicomToJsonFlags_IncludeBinary         = (1 << 0),  /*!< Include the binary tags */
+OrthancPluginDicomToJsonFlags_IncludePrivateTags    = (1 << 1),  /*!< Include the private tags */
+OrthancPluginDicomToJsonFlags_IncludeUnknownTags    = (1 << 2),  /*!< Include the tags unknown by the dictionary */
+OrthancPluginDicomToJsonFlags_IncludePixelData      = (1 << 3),  /*!< Include the pixel data */
+OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii  = (1 << 4),  /*!< Output binary tags as-is, dropping non-ASCII */
+OrthancPluginDicomToJsonFlags_ConvertBinaryToNull   = (1 << 5),  /*!< Signal binary tags as null values */
+_OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
+} OrthancPluginDicomToJsonFlags;
+/**
+* Flags to the creation of a DICOM file.
+* @ingroup Toolbox
+* @see OrthancPluginCreateDicom()
+**/
+typedef enum
+{
+OrthancPluginCreateDicomFlags_DecodeDataUriScheme   = (1 << 0),  /*!< Decode fields encoded using data URI scheme */
+OrthancPluginCreateDicomFlags_GenerateIdentifiers   = (1 << 1),  /*!< Automatically generate DICOM identifiers */
+_OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
+} OrthancPluginCreateDicomFlags;
+/**
+* The constraints on the DICOM identifiers that must be supported
+* by the database plugins.
+**/
+typedef enum
+{
+OrthancPluginIdentifierConstraint_Equal = 1,           /*!< Equal */
+OrthancPluginIdentifierConstraint_SmallerOrEqual = 2,  /*!< Less or equal */
+OrthancPluginIdentifierConstraint_GreaterOrEqual = 3,  /*!< More or equal */
+OrthancPluginIdentifierConstraint_Wildcard = 4,        /*!< Case-sensitive wildcard matching (with * and ?) */
+_OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
+} OrthancPluginIdentifierConstraint;
+/**
+* The origin of a DICOM instance that has been received by Orthanc.
+**/
+typedef enum
+{
+OrthancPluginInstanceOrigin_Unknown = 1,        /*!< Unknown origin */
+OrthancPluginInstanceOrigin_DicomProtocol = 2,  /*!< Instance received through DICOM protocol */
+OrthancPluginInstanceOrigin_RestApi = 3,        /*!< Instance received through REST API of Orthanc */
+OrthancPluginInstanceOrigin_Plugin = 4,         /*!< Instance added to Orthanc by a plugin */
+OrthancPluginInstanceOrigin_Lua = 5,            /*!< Instance added to Orthanc by a Lua script */
+_OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
+} OrthancPluginInstanceOrigin;
 /**
 * @brief A memory buffer allocated by the core system of Orthanc.
 *
 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
 /**
+* @brief Opaque structure to an object that represents a C-Find query.
+* @ingroup Worklists
+**/
+typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
+/**
+* @brief Opaque structure to an object that represents the answers to a C-Find query.
+* @ingroup Worklists
+**/
+typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
+/**
 * @brief Signature of a callback function that answers to a REST request.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginRestCallback) (
+typedef OrthancPluginErrorCode (*OrthancPluginRestCallback) (
 OrthancPluginRestOutput* output,
 const char* url,
 const OrthancPluginHttpRequest* request);
 /**
 * @brief Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginOnStoredInstanceCallback) (
+typedef OrthancPluginErrorCode (*OrthancPluginOnStoredInstanceCallback) (
 OrthancPluginDicomInstance* instance,
 const char* instanceId);
 /**
 * @brief Signature of a callback function that is triggered when a change happens to some DICOM resource.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginOnChangeCallback) (
+typedef OrthancPluginErrorCode (*OrthancPluginOnChangeCallback) (
 OrthancPluginChangeType changeType,
 OrthancPluginResourceType resourceType,
 const char* resourceId);
+/**
+* @brief Signature of a callback function to decode a DICOM instance as an image.
+* @ingroup Callbacks
+**/
+typedef OrthancPluginErrorCode (*OrthancPluginDecodeImageCallback) (
+OrthancPluginImage** target,
+const void* dicom,
+const uint32_t size,
+uint32_t frameIndex);
 /**
 * @brief Signature of a function to free dynamic memory.
 * @param size The size of the file.
 * @param type The content type corresponding to this file.
 * @return 0 if success, other value if error.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginStorageCreate) (
+typedef OrthancPluginErrorCode (*OrthancPluginStorageCreate) (
 const char* uuid,
 const void* content,
 int64_t size,
 OrthancPluginContentType type);
 * @param uuid The UUID of the file of interest.
 * @param type The content type corresponding to this file.
 * @return 0 if success, other value if error.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginStorageRead) (
+typedef OrthancPluginErrorCode (*OrthancPluginStorageRead) (
 void** content,
 int64_t* size,
 const char* uuid,
 OrthancPluginContentType type);
 * @param uuid The UUID of the file to be removed.
 * @param type The content type corresponding to this file.
 * @return 0 if success, other value if error.
 * @ingroup Callbacks
 **/
-typedef int32_t (*OrthancPluginStorageRemove) (
+typedef OrthancPluginErrorCode (*OrthancPluginStorageRemove) (
 const char* uuid,
 OrthancPluginContentType type);
+/**
+* @brief Callback to handle the C-Find SCP requests received by Orthanc.
+*
+* Signature of a callback function that is triggered when Orthanc
+* receives a C-Find SCP request against modality worklists.
+*
+* @param answers The target structure where answers must be stored.
+* @param query The worklist query.
+* @param remoteAet The Application Entity Title (AET) of the modality from which the request originates.
+* @param calledAet The Application Entity Title (AET) of the modality that is called by the request.
+* @return 0 if success, other value if error.
+* @ingroup Worklists
+**/
+typedef OrthancPluginErrorCode (*OrthancPluginWorklistCallback) (
+OrthancPluginWorklistAnswers*     answers,
+const OrthancPluginWorklistQuery* query,
+const char*                       remoteAet,
+const char*                       calledAet);
 /**
 * @brief Data structure that contains information about the Orthanc core.
 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
-sizeof(int32_t) != sizeof(OrthancPluginImageFormat))
+sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
+sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
+sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
+sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
+sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
+sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
+sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
 {
 /* Mismatch in the size of the enumerations */
 return 0;
 }
 *
 * Retrieve a DICOM instance using its Orthanc identifier. The DICOM
 * file is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param instanceId The Orthanc identifier of the DICOM instance of interest.
 * @return 0 if success, or the error code if failure.
 * @ingroup Orthanc
 **/
 ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginGetDicomForInstance(
 *
 * Make a GET call to the built-in Orthanc REST API. The result to
 * the query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiGetAfterPlugins
 * @ingroup Orthanc
 **/
 * called URI to the built-in Orthanc REST API, this call will
 * return the result provided by this plugin. The result to the
 * query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiGet
 * @ingroup Orthanc
 **/
 *
 * Make a POST call to the built-in Orthanc REST API. The result to
 * the query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @param body The body of the POST request.
 * @param bodySize The size of the body.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiPostAfterPlugins
 * called URI to the built-in Orthanc REST API, this call will
 * return the result provided by this plugin. The result to the
 * query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @param body The body of the POST request.
 * @param bodySize The size of the body.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiPost
 *
 * Make a PUT call to the built-in Orthanc REST API. The result to
 * the query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @param body The body of the PUT request.
 * @param bodySize The size of the body.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiPutAfterPlugins
 * called URI to the built-in Orthanc REST API, this call will
 * return the result provided by this plugin. The result to the
 * query is stored into a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param uri The URI in the built-in Orthanc API.
 * @param body The body of the PUT request.
 * @param bodySize The size of the body.
 * @return 0 if success, or the error code if failure.
 * @see OrthancPluginRestApiPut
 }
 typedef struct
 {
-char**                      resultStringToFree;
+char**                       resultStringToFree;
-const char**                resultString;
+const char**                 resultString;
-int64_t*                    resultInt64;
+int64_t*                     resultInt64;
-const char*                 key;
+const char*                  key;
-OrthancPluginDicomInstance* instance;
+OrthancPluginDicomInstance*  instance;
+OrthancPluginInstanceOrigin* resultOrigin;   /* New in Orthanc 0.9.5 SDK */
 } _OrthancPluginAccessDicomInstance;
 /**
 * @brief Get the AET of a DICOM instance.
 /**
 * @brief Register a callback to monitor changes.
 *
 * This function registers a callback function that is called
 * whenever a change happens to some DICOM resource.
+*
+* @warning If your change callback has to call the REST API of
+* Orthanc, you should make these calls in a separate thread (with
+* the events passing through a message queue). Otherwise, this
+* could result in deadlocks in the presence of other plugins or Lua
+* script.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
 * @param callback The callback function.
 * @ingroup Callbacks
 **/
 *
 * This function compresses or decompresses a buffer, using the
 * version of the zlib library that is used by the Orthanc core.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param source The source buffer.
 * @param size The size in bytes of the source buffer.
 * @param compression The compression algorithm.
 * @param uncompress If set to "0", the buffer must be compressed.
 * If set to "1", the buffer must be uncompressed.
 *
 * Read the content of a file on the filesystem, and returns it into
 * a newly allocated memory buffer.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param path The path of the file to be read.
 * @return 0 if success, or the error code if failure.
 **/
 ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginReadFile(
 OrthancPluginContext*       context,
 typedef struct
 {
 const OrthancPluginImage*  image;
 uint32_t*                  resultUint32;
 OrthancPluginPixelFormat*  resultPixelFormat;
-const void**               resultBuffer;
+void**                     resultBuffer;
 } _OrthancPluginGetImageInfo;
 /**
 * @brief Return the pixel format of an image.
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
 * @param image The image of interest.
 * @return The pointer.
 * @ingroup Images
 **/
-ORTHANC_PLUGIN_INLINE const void*  OrthancPluginGetImageBuffer(
+ORTHANC_PLUGIN_INLINE void*  OrthancPluginGetImageBuffer(
 OrthancPluginContext*      context,
 const OrthancPluginImage*  image)
 {
-const void* target = NULL;
+void* target = NULL;
 _OrthancPluginGetImageInfo params;
 memset(&params, 0, sizeof(params));
 params.resultBuffer = &target;
 params.image = image;
 * stored into a newly allocated memory buffer. Favor
 * OrthancPluginRestApiGet() if calling the built-in REST API of the
 * Orthanc instance that hosts this plugin.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param url The URL of interest.
 * @param username The username (can be <tt>NULL</tt> if no password protection).
 * @param password The password (can be <tt>NULL</tt> if no password protection).
 * @return 0 if success, or the error code if failure.
 **/
 * is stored into a newly allocated memory buffer. Favor
 * OrthancPluginRestApiPost() if calling the built-in REST API of
 * the Orthanc instance that hosts this plugin.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param url The URL of interest.
 * @param body The content of the body of the request.
 * @param bodySize The size of the body of the request.
 * @param username The username (can be <tt>NULL</tt> if no password protection).
 * @param password The password (can be <tt>NULL</tt> if no password protection).
 * stored into a newly allocated memory buffer. Favor
 * OrthancPluginRestApiPut() if calling the built-in REST API of the
 * Orthanc instance that hosts this plugin.
 *
 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
-* @param target The target memory buffer.
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
 * @param url The URL of interest.
 * @param body The content of the body of the request.
 * @param bodySize The size of the body of the request.
 * @param username The username (can be <tt>NULL</tt> if no password protection).
 * @param password The password (can be <tt>NULL</tt> if no password protection).
 OrthancPluginStorageArea*   storageArea;
 const char*                 uuid;
 OrthancPluginContentType    type;
 } _OrthancPluginStorageAreaRemove;
 /**
 * @brief Remove a file from the storage area.
 *
 * This function removes a given file from the storage area that is
 * currently used by Orthanc.
 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
 }
+typedef struct
+{
+OrthancPluginErrorCode*  target;
+int32_t                  code;
+uint16_t                 httpStatus;
+const char*              message;
+} _OrthancPluginRegisterErrorCode;
+/**
+* @brief Declare a custom error code for this plugin.
+*
+* This function declares a custom error code that can be generated
+* by this plugin. This declaration is used to enrich the body of
+* the HTTP answer in the case of an error, and to set the proper
+* HTTP status code.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param code The error code that is internal to this plugin.
+* @param httpStatus The HTTP status corresponding to this error.
+* @param message The description of the error.
+* @return The error code that has been assigned inside the Orthanc core.
+* @ingroup Toolbox
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginRegisterErrorCode(
+OrthancPluginContext*    context,
+int32_t                  code,
+uint16_t                 httpStatus,
+const char*              message)
+{
+OrthancPluginErrorCode target;
+_OrthancPluginRegisterErrorCode params;
+params.target = &target;
+params.code = code;
+params.httpStatus = httpStatus;
+params.message = message;
+if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
+{
+return target;
+}
+else
+{
+/* There was an error while assigned the error. Use a generic code. */
+return OrthancPluginErrorCode_Plugin;
+}
+}
+typedef struct
+{
+uint16_t                          group;
+uint16_t                          element;
+OrthancPluginValueRepresentation  vr;
+const char*                       name;
+uint32_t                          minMultiplicity;
+uint32_t                          maxMultiplicity;
+} _OrthancPluginRegisterDictionaryTag;
+/**
+* @brief Register a new tag into the DICOM dictionary.
+*
+* This function declares a new tag in the dictionary of DICOM tags
+* that are known to Orthanc. This function should be used in the
+* OrthancPluginInitialize() callback.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param group The group of the tag.
+* @param element The element of the tag.
+* @param vr The value representation of the tag.
+* @param name The nickname of the tag.
+* @param minMultiplicity The minimum multiplicity of the tag (must be above 0).
+* @param maxMultiplicity The maximum multiplicity of the tag. A value of 0 means
+* an arbitrary multiplicity ("<tt>n</tt>").
+* @return 0 if success, other value if error.
+* @ingroup Toolbox
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginRegisterDictionaryTag(
+OrthancPluginContext*             context,
+uint16_t                          group,
+uint16_t                          element,
+OrthancPluginValueRepresentation  vr,
+const char*                       name,
+uint32_t                          minMultiplicity,
+uint32_t                          maxMultiplicity)
+{
+_OrthancPluginRegisterDictionaryTag params;
+params.group = group;
+params.element = element;
+params.vr = vr;
+params.name = name;
+params.minMultiplicity = minMultiplicity;
+params.maxMultiplicity = maxMultiplicity;
+return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
+}
+typedef struct
+{
+OrthancPluginStorageArea*  storageArea;
+OrthancPluginResourceType  level;
+} _OrthancPluginReconstructMainDicomTags;
+/**
+* @brief Reconstruct the main DICOM tags.
+*
+* This function requests the Orthanc core to reconstruct the main
+* DICOM tags of all the resources of the given type. This function
+* can only be used as a part of the upgrade of a custom database
+* back-end
+* (cf. OrthancPlugins::IDatabaseBackend::UpgradeDatabase). A
+* database transaction will be automatically setup.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param storageArea The storage area.
+* @param level The type of the resources of interest.
+* @return 0 if success, other value if error.
+* @ingroup Callbacks
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginReconstructMainDicomTags(
+OrthancPluginContext*      context,
+OrthancPluginStorageArea*  storageArea,
+OrthancPluginResourceType  level)
+{
+_OrthancPluginReconstructMainDicomTags params;
+params.level = level;
+params.storageArea = storageArea;
+return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
+}
+typedef struct
+{
+char**                          result;
+const char*                     instanceId;
+const char*                     buffer;
+uint32_t                        size;
+OrthancPluginDicomToJsonFormat  format;
+OrthancPluginDicomToJsonFlags   flags;
+uint32_t                        maxStringLength;
+} _OrthancPluginDicomToJson;
+/**
+* @brief Format a DICOM memory buffer as a JSON string.
+*
+* This function takes as input a memory buffer containing a DICOM
+* file, and outputs a JSON string representing the tags of this
+* DICOM file.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param buffer The memory buffer containing the DICOM file.
+* @param size The size of the memory buffer.
+* @param format The output format.
+* @param flags Flags governing the output.
+* @param maxStringLength The maximum length of a field. Too long fields will
+* be output as "null". The 0 value means no maximum length.
+* @return The NULL value if the case of an error, or the JSON
+* string. This string must be freed by OrthancPluginFreeString().
+* @ingroup Toolbox
+* @see OrthancPluginDicomInstanceToJson
+**/
+ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
+OrthancPluginContext*           context,
+const char*                     buffer,
+uint32_t                        size,
+OrthancPluginDicomToJsonFormat  format,
+OrthancPluginDicomToJsonFlags   flags,
+uint32_t                        maxStringLength)
+{
+char* result;
+_OrthancPluginDicomToJson params;
+memset(&params, 0, sizeof(params));
+params.result = &result;
+params.buffer = buffer;
+params.size = size;
+params.format = format;
+params.flags = flags;
+params.maxStringLength = maxStringLength;
+if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
+{
+/* Error */
+return NULL;
+}
+else
+{
+return result;
+}
+}
+/**
+* @brief Format a DICOM instance as a JSON string.
+*
+* This function formats a DICOM instance that is stored in Orthanc,
+* and outputs a JSON string representing the tags of this DICOM
+* instance.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param instanceId The Orthanc identifier of the instance.
+* @param format The output format.
+* @param flags Flags governing the output.
+* @param maxStringLength The maximum length of a field. Too long fields will
+* be output as "null". The 0 value means no maximum length.
+* @return The NULL value if the case of an error, or the JSON
+* string. This string must be freed by OrthancPluginFreeString().
+* @ingroup Toolbox
+* @see OrthancPluginDicomInstanceToJson
+**/
+ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
+OrthancPluginContext*           context,
+const char*                     instanceId,
+OrthancPluginDicomToJsonFormat  format,
+OrthancPluginDicomToJsonFlags   flags,
+uint32_t                        maxStringLength)
+{
+char* result;
+_OrthancPluginDicomToJson params;
+memset(&params, 0, sizeof(params));
+params.result = &result;
+params.instanceId = instanceId;
+params.format = format;
+params.flags = flags;
+params.maxStringLength = maxStringLength;
+if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
+{
+/* Error */
+return NULL;
+}
+else
+{
+return result;
+}
+}
+typedef struct
+{
+OrthancPluginMemoryBuffer*  target;
+const char*                 uri;
+uint32_t                    headersCount;
+const char* const*          headersKeys;
+const char* const*          headersValues;
+int32_t                     afterPlugins;
+} _OrthancPluginRestApiGet2;
+/**
+* @brief Make a GET call to the Orthanc REST API, with custom HTTP headers.
+*
+* Make a GET call to the Orthanc REST API with extended
+* parameters. The result to the query is stored into a newly
+* allocated memory buffer.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
+* @param uri The URI in the built-in Orthanc API.
+* @param headersCount The number of HTTP headers.
+* @param headersKeys Array containing the keys of the HTTP headers.
+* @param headersValues Array containing the values of the HTTP headers.
+* @param afterPlugins If 0, the built-in API of Orthanc is used.
+* If 1, the API is tainted by the plugins.
+* @return 0 if success, or the error code if failure.
+* @see OrthancPluginRestApiGet, OrthancPluginRestApiGetAfterPlugins
+* @ingroup Orthanc
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginRestApiGet2(
+OrthancPluginContext*       context,
+OrthancPluginMemoryBuffer*  target,
+const char*                 uri,
+uint32_t                    headersCount,
+const char* const*          headersKeys,
+const char* const*          headersValues,
+int32_t                     afterPlugins)
+{
+_OrthancPluginRestApiGet2 params;
+params.target = target;
+params.uri = uri;
+params.headersCount = headersCount;
+params.headersKeys = headersKeys;
+params.headersValues = headersValues;
+params.afterPlugins = afterPlugins;
+return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
+}
+typedef struct
+{
+OrthancPluginWorklistCallback callback;
+} _OrthancPluginWorklistCallback;
+/**
+* @brief Register a callback to handle modality worklists requests.
+*
+* This function registers a callback to handle C-Find SCP requests
+* on modality worklists.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param callback The callback.
+* @return 0 if success, other value if error.
+* @ingroup Worklists
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(
+OrthancPluginContext*          context,
+OrthancPluginWorklistCallback  callback)
+{
+_OrthancPluginWorklistCallback params;
+params.callback = callback;
+return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
+}
+typedef struct
+{
+OrthancPluginWorklistAnswers*      answers;
+const OrthancPluginWorklistQuery*  query;
+const void*                        dicom;
+uint32_t                           size;
+} _OrthancPluginWorklistAnswersOperation;
+/**
+* @brief Add one answer to some modality worklist request.
+*
+* This function adds one worklist (encoded as a DICOM file) to the
+* set of answers corresponding to some C-Find SCP request against
+* modality worklists.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param answers The set of answers.
+* @param query The worklist query, as received by the callback.
+* @param dicom The worklist to answer, encoded as a DICOM file.
+* @param size The size of the DICOM file.
+* @return 0 if success, other value if error.
+* @ingroup Worklists
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginWorklistAddAnswer(
+OrthancPluginContext*             context,
+OrthancPluginWorklistAnswers*     answers,
+const OrthancPluginWorklistQuery* query,
+const void*                       dicom,
+uint32_t                          size)
+{
+_OrthancPluginWorklistAnswersOperation params;
+params.answers = answers;
+params.query = query;
+params.dicom = dicom;
+params.size = size;
+return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
+}
+/**
+* @brief Mark the set of worklist answers as incomplete.
+*
+* This function marks as incomplete the set of answers
+* corresponding to some C-Find SCP request against modality
+* worklists. This must be used if canceling the handling of a
+* request when too many answers are to be returned.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param answers The set of answers.
+* @return 0 if success, other value if error.
+* @ingroup Worklists
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginWorklistMarkIncomplete(
+OrthancPluginContext*          context,
+OrthancPluginWorklistAnswers*  answers)
+{
+_OrthancPluginWorklistAnswersOperation params;
+params.answers = answers;
+params.query = NULL;
+params.dicom = NULL;
+params.size = 0;
+return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
+}
+typedef struct
+{
+const OrthancPluginWorklistQuery*  query;
+const void*                        dicom;
+uint32_t                           size;
+int32_t*                           isMatch;
+OrthancPluginMemoryBuffer*         target;
+} _OrthancPluginWorklistQueryOperation;
+/**
+* @brief Test whether a worklist matches the query.
+*
+* This function checks whether one worklist (encoded as a DICOM
+* file) matches the C-Find SCP query against modality
+* worklists. This function must be called before adding the
+* worklist as an answer through OrthancPluginWorklistAddAnswer().
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param query The worklist query, as received by the callback.
+* @param dicom The worklist to answer, encoded as a DICOM file.
+* @param size The size of the DICOM file.
+* @return 1 if the worklist matches the query, 0 otherwise.
+* @ingroup Worklists
+**/
+ORTHANC_PLUGIN_INLINE int32_t  OrthancPluginWorklistIsMatch(
+OrthancPluginContext*              context,
+const OrthancPluginWorklistQuery*  query,
+const void*                        dicom,
+uint32_t                           size)
+{
+int32_t isMatch = 0;
+_OrthancPluginWorklistQueryOperation params;
+params.query = query;
+params.dicom = dicom;
+params.size = size;
+params.isMatch = &isMatch;
+params.target = NULL;
+if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
+{
+return isMatch;
+}
+else
+{
+/* Error: Assume non-match */
+return 0;
+}
+}
+/**
+* @brief Retrieve the worklist query as a DICOM file.
+*
+* This function retrieves the DICOM file that underlies a C-Find
+* SCP query against modality worklists.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param target Memory buffer where to store the DICOM file. It must be freed with OrthancPluginFreeMemoryBuffer().
+* @param query The worklist query, as received by the callback.
+* @return 0 if success, other value if error.
+* @ingroup Worklists
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode  OrthancPluginWorklistGetDicomQuery(
+OrthancPluginContext*              context,
+OrthancPluginMemoryBuffer*         target,
+const OrthancPluginWorklistQuery*  query)
+{
+_OrthancPluginWorklistQueryOperation params;
+params.query = query;
+params.dicom = NULL;
+params.size = 0;
+params.isMatch = NULL;
+params.target = target;
+return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
+}
+/**
+* @brief Get the origin of a DICOM file.
+*
+* This function returns the origin of a DICOM instance that has been received by Orthanc.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param instance The instance of interest.
+* @return The origin of the instance.
+* @ingroup Callbacks
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(
+OrthancPluginContext*       context,
+OrthancPluginDicomInstance* instance)
+{
+OrthancPluginInstanceOrigin origin;
+_OrthancPluginAccessDicomInstance params;
+memset(&params, 0, sizeof(params));
+params.resultOrigin = &origin;
+params.instance = instance;
+if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
+{
+/* Error */
+return OrthancPluginInstanceOrigin_Unknown;
+}
+else
+{
+return origin;
+}
+}
+typedef struct
+{
+OrthancPluginMemoryBuffer*     target;
+const char*                    json;
+const OrthancPluginImage*      pixelData;
+OrthancPluginCreateDicomFlags  flags;
+} _OrthancPluginCreateDicom;
+/**
+* @brief Create a DICOM instance from a JSON string and an image.
+*
+* This function takes as input a string containing a JSON file
+* describing the content of a DICOM instance. As an output, it
+* writes the corresponding DICOM instance to a newly allocated
+* memory buffer. Additionally, an image to be encoded within the
+* DICOM instance can also be provided.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().
+* @param json The input JSON file.
+* @param pixelData The image. Can be NULL, if the pixel data is encoded inside the JSON with the data URI scheme.
+* @param flags Flags governing the output.
+* @return 0 if success, other value if error.
+* @ingroup Toolbox
+* @see OrthancPluginDicomBufferToJson
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateDicom(
+OrthancPluginContext*          context,
+OrthancPluginMemoryBuffer*     target,
+const char*                    json,
+const OrthancPluginImage*      pixelData,
+OrthancPluginCreateDicomFlags  flags)
+{
+_OrthancPluginCreateDicom params;
+params.target = target;
+params.json = json;
+params.pixelData = pixelData;
+params.flags = flags;
+return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
+}
+typedef struct
+{
+OrthancPluginDecodeImageCallback callback;
+} _OrthancPluginDecodeImageCallback;
+/**
+* @brief Register a callback to handle the decoding of DICOM images.
+*
+* This function registers a custom callback to the decoding of
+* DICOM images, replacing the built-in decoder of Orthanc.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param callback The callback.
+* @return 0 if success, other value if error.
+* @ingroup Callbacks
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(
+OrthancPluginContext*             context,
+OrthancPluginDecodeImageCallback  callback)
+{
+_OrthancPluginDecodeImageCallback params;
+params.callback = callback;
+return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
+}
+typedef struct
+{
+OrthancPluginImage**       target;
+OrthancPluginPixelFormat   format;
+uint32_t                   width;
+uint32_t                   height;
+uint32_t                   pitch;
+void*                      buffer;
+const void*                constBuffer;
+uint32_t                   bufferSize;
+uint32_t                   frameIndex;
+} _OrthancPluginCreateImage;
+/**
+* @brief Create an image.
+*
+* This function creates an image of given size and format.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param format The format of the pixels.
+* @param width The width of the image.
+* @param height The height of the image.
+* @return The newly allocated image. It must be freed with OrthancPluginFreeImage().
+* @ingroup Images
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImage(
+OrthancPluginContext*     context,
+OrthancPluginPixelFormat  format,
+uint32_t                  width,
+uint32_t                  height)
+{
+OrthancPluginImage* target = NULL;
+_OrthancPluginCreateImage params;
+memset(&params, 0, sizeof(params));
+params.target = &target;
+params.format = format;
+params.width = width;
+params.height = height;
+if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
+{
+return NULL;
+}
+else
+{
+return target;
+}
+}
+/**
+* @brief Create an image pointing to a memory buffer.
+*
+* This function creates an image whose content points to a memory
+* buffer managed by the plugin. Note that the buffer is directly
+* accessed, no memory is allocated and no data is copied.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param format The format of the pixels.
+* @param width The width of the image.
+* @param height The height of the image.
+* @param pitch The pitch of the image (i.e. the number of bytes
+* between 2 successive lines of the image in the memory buffer).
+* @param buffer The memory buffer.
+* @return The newly allocated image. It must be freed with OrthancPluginFreeImage().
+* @ingroup Images
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImageAccessor(
+OrthancPluginContext*     context,
+OrthancPluginPixelFormat  format,
+uint32_t                  width,
+uint32_t                  height,
+uint32_t                  pitch,
+void*                     buffer)
+{
+OrthancPluginImage* target = NULL;
+_OrthancPluginCreateImage params;
+memset(&params, 0, sizeof(params));
+params.target = &target;
+params.format = format;
+params.width = width;
+params.height = height;
+params.pitch = pitch;
+params.buffer = buffer;
+if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
+{
+return NULL;
+}
+else
+{
+return target;
+}
+}
+/**
+* @brief Decode one frame from a DICOM instance.
+*
+* This function decodes one frame of a DICOM image that is stored
+* in a memory buffer. This function will give the same result as
+* OrthancPluginUncompressImage() for single-frame DICOM images.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param buffer Pointer to a memory buffer containing the DICOM image.
+* @param bufferSize Size of the memory buffer containing the DICOM image.
+* @param frameIndex The index of the frame of interest in a multi-frame image.
+* @return The uncompressed image. It must be freed with OrthancPluginFreeImage().
+* @ingroup Images
+**/
+ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginDecodeDicomImage(
+OrthancPluginContext*  context,
+const void*            buffer,
+uint32_t               bufferSize,
+uint32_t               frameIndex)
+{
+OrthancPluginImage* target = NULL;
+_OrthancPluginCreateImage params;
+memset(&params, 0, sizeof(params));
+params.target = &target;
+params.constBuffer = buffer;
+params.bufferSize = bufferSize;
+params.frameIndex = frameIndex;
+if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
+{
+return NULL;
+}
+else
+{
+return target;
+}
+}
+typedef struct
+{
+char**       result;
+const void*  buffer;
+uint32_t     size;
+} _OrthancPluginComputeHash;
+/**
+* @brief Compute an MD5 hash.
+*
+* This functions computes the MD5 cryptographic hash of the given memory buffer.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param buffer The source memory buffer.
+* @param size The size in bytes of the source buffer.
+* @return The NULL value in case of error, or a string containing the cryptographic hash.
+* This string must be freed by OrthancPluginFreeString().
+* @ingroup Toolbox
+**/
+ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
+OrthancPluginContext*  context,
+const void*            buffer,
+uint32_t               size)
+{
+char* result;
+_OrthancPluginComputeHash params;
+params.result = &result;
+params.buffer = buffer;
+params.size = size;
+if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
+{
+/* Error */
+return NULL;
+}
+else
+{
+return result;
+}
+}
+/**
+* @brief Compute a SHA-1 hash.
+*
+* This functions computes the SHA-1 cryptographic hash of the given memory buffer.
+*
+* @param context The Orthanc plugin context, as received by OrthancPluginInitialize().
+* @param buffer The source memory buffer.
+* @param size The size in bytes of the source buffer.
+* @return The NULL value in case of error, or a string containing the cryptographic hash.
+* This string must be freed by OrthancPluginFreeString().
+* @ingroup Toolbox
+**/
+ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
+OrthancPluginContext*  context,
+const void*            buffer,
+uint32_t               size)
+{
+char* result;
+_OrthancPluginComputeHash params;
+params.result = &result;
+params.buffer = buffer;
+params.size = size;
+if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
+{
+/* Error */
+return NULL;
+}
+else
+{
+return result;
+}
+}
 #ifdef  __cplusplus
 }
 #endif

Mercurial > hg > orthanc-webviewer

comparison Orthanc/Sdk-0.9.4/orthanc/OrthancCPlugin.h @ 101:2932473a9b19 refactoring