1/* 2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16/** 17 * @addtogroup format 18 * @{ 19 * 20 * @brief Defines format-related APIs. 21 * 22 * For example, you use this module to define custom data types and to initialize, create, 23 * destroy the muxer and demuxer, and set their parameters. Also, you can read demuxer data frames, 24 * select demuxer tracks, add muxer tracks, and write data frames into a container. 25 * 26 * @since 1.0 27 * @version 1.0 28 */ 29 30/** 31 * @file format_interface.h 32 * 33 * @brief Declares format-related APIs. 34 * 35 * For example, you use the functions provided in this file to define custom data types and to initialize, 36 * create, destroy the muxer and demuxer, and set their parameters. Also, you can read demuxer data frames, 37 * select demuxer tracks, add muxer tracks, and write data frames into a container. 38 * 39 * @since 1.0 40 * @version 1.0 41 */ 42 43#ifndef FORMAT_INTERFACE_H 44#define FORMAT_INTERFACE_H 45 46#include "format_type.h" 47 48#ifdef __cplusplus 49#if __cplusplus 50extern "C" { 51#endif 52#endif /* __cplusplus */ 53 54/** 55 * @brief Initializes the format. 56 * 57 * You can call this function to initialize the demuxer and muxer. 58 * This function should always be called before other format-specific functions, 59 * and it can be called only once within a process. 60 * 61 * @since 1.0 62 * @version 1.0 63 */ 64void FormatInit(void); 65 66/** 67 * @brief Deinitializes the format. 68 * 69 * You can call this function to deinitialize the demuxer and muxer. 70 * This function works in pair with {@link FormatInit}. 71 * 72 * @since 1.0 73 * @version 1.0 74 */ 75void FormatDeInit(void); 76 77/** 78 * @brief Creates a demuxer component and returns its context handle. 79 * 80 * This function returns the demuxer context handle without probing the container format or 81 * obtaining stream information. 82 * 83 * @param source Indicates the pointer to the format source of the demuxer. For details, see {@link FormatSource}. 84 * @param handle Indicates the double pointer to the demuxer context handle. 85 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 86 */ 87int32_t FormatDemuxerCreate(const FormatSource *source, FormatHandle * const handle); 88 89/** 90 * @brief Sets demuxer attributes. 91 * 92 * You can call this function to set the HTTP header, HTTP referer, and other extension items for the demuxer 93 * after {@link FormatDemuxerCreate} is called. 94 * 95 * @param handle Indicates the pointer to the demuxer context handle. 96 * @param trackId Identifies the track. If the value is an invalid value (<b>-1</b>), 97 * this parameter identifies the file or program. 98 * @param metaData Indicates the pointer to an array of key-value pairs representing parameter names and values. 99 * For details, see {@link ParameterItem}. 100 * @param metaDataCnt Indicates the number of key-value pairs in the array. 101 * This parameter works in pair with <b>metaData</b>. 102 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 103 * @since 1.0 104 * @version 1.0 105 */ 106int32_t FormatDemuxerSetParameter(const FormatHandle handle, int32_t trackId, 107 const ParameterItem *metaData, int32_t metaDataCnt); 108 109/** 110 * @brief Obtains demuxer attributes. 111 * 112 * You can call this function to obtain the HTTP header, HTTP referer, and other extension items for the demuxer 113 * after {@link FormatDemuxerCreate} is called. The demuxer will store the value in the <b>metaData</b> 114 * based on the key.If the demuxer has allocated memory for the <b>metaData</b> to store the value, 115 * the caller should manually free the memory. 116 * 117 * @param handle Indicates the pointer to the demuxer context handle. 118 * @param trackId Identifies the track. If the value is an invalid value (<b>-1</b>), 119 * this parameter identifies the file or program. 120 * @param metaData Indicates the pointer to the buffer for storing the parameters values 121 * that the demuxer has searched for based on the input key. For details, see {@link ParameterItem}. 122 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 123 * @since 1.0 124 * @version 1.0 125 */ 126int32_t FormatDemuxerGetParameter(const FormatHandle handle, int32_t trackId, ParameterItem *metaData); 127 128/** 129 * @brief Sets a callback for the demuxer. 130 * 131 * The callback will be invoked to notify the upper layer of internal events of the demuxer. 132 * 133 * @param handle Indicates the pointer to the demuxer context handle. 134 * @param callBack Indicates the pointer to the callback, as defined in {@link FormatCallback}. 135 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 136 * @since 1.0 137 * @version 1.0 138 */ 139int32_t FormatDemuxerSetCallBack(const FormatHandle handle, const FormatCallback *callBack); 140 141/** 142 * @brief Sets buffer information for the demuxer. 143 * 144 * If there is a buffer mechanism in the demuxer, you can call this function to set the maximum buffer size and time. 145 * Alternatively, you can disable the buffer mechanism by setting the buffer size and time to <b>0</b> in 146 * the <b>setting</b> parameter. If there is no buffer mechanism or the default setting is retained, 147 * you can skip this function. 148 * 149 * @param handle Indicates the pointer to the demuxer context handle. 150 * @param setting Indicates the pointer to the maximum demuxer buffer size and time, 151 * as defined in {@link FormatBufferSetting}. 152 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 153 */ 154int32_t FormatDemuxerSetBufferConfig(const FormatHandle handle, const FormatBufferSetting *setting); 155 156/** 157 * @brief Obtains the buffer information of the demuxer. 158 * 159 * If there is a buffer mechanism in the demuxer, you can call this function to obtain the maximum buffer size and time. 160 * 161 * @param handle Indicates the pointer to the demuxer context handle. 162 * @param setting Indicates the pointer to the maximum demuxer buffer size and time, 163 * as defined in {@link FormatBufferSetting}. 164 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 165 * @since 1.0 166 * @version 1.0 167 */ 168int32_t FormatDemuxerGetBufferConfig(const FormatHandle handle, FormatBufferSetting *setting); 169 170/** 171 * @brief Makes preparations for the demuxer. 172 * 173 * This function triggers the demuxer to probe the media file container format and parse stream information. 174 * You can obtain media file attributes only after this function is called. 175 * 176 * @param handle Indicates the pointer to the demuxer context handle. 177 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 178 * @since 1.0 179 * @version 1.0 180 */ 181int32_t FormatDemuxerPrepare(const FormatHandle handle); 182 183/** 184 * @brief Obtains the attributes of a media file. 185 * 186 * The attributes contain file, program, and stream attributes. 187 * This function should be called after {@link FormatDemuxerPrepare} is called. 188 * 189 * @param handle Indicates the pointer to the demuxer context handle. 190 * @param info Indicates the pointer to the source attributes, as defined in {@link FileInfo}. 191 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 192 * @since 1.0 193 * @version 1.0 194 */ 195int32_t FormatDemuxerGetFileInfo(const FormatHandle handle, FileInfo *info); 196 197/** 198 * @brief Selects a specified media track. 199 * 200 * The media tracks to select must belong to the same program. 201 * If you do not call this function, the default media tracks of the default program are selected. 202 * If <b>programId</b> is valid but <b>trackId</b> is invalid, the default media track of the specified program is used. 203 * 204 * @param handle Indicates the pointer to the demuxer context handle. 205 * @param programId Identifies the program. 206 * @param trackId Identifies the media track. If a valid value is passed, the media track must belong to 207 * the specified program. If an invalid value is passed, the default media track of the specified program is used. 208 * If multiple audio tracks are specified, the player determines which audio track to use. 209 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 210 * @since 1.0 211 * @version 1.0 212 */ 213int32_t FormatDemuxerSelectTrack(const FormatHandle handle, int32_t programId, int32_t trackId); 214 215/** 216 * @brief Unselects a specified media track from which the demuxer reads data frames. 217 * 218 * The demuxer can read all media tracks of the default program. You can call this function to 219 * unselect all or certain tracks of a specified program that the demuxer is expected not to read. 220 * If <b>trackId</b> is invalid, the demuxer will read none of the tracks of the specified program. 221 * 222 * @param handle Indicates the pointer to the demuxer context handle. 223 * @param programId Identifies the program. 224 * @param trackId Identifies the media track that the demuxer will unselect. 225 * This parameter works in pair with <b>programId</b>. If a valid value is passed, the media track must belong to 226 * the program specified by <b>programId</b>. If an invalid value is passed, and all media tracks of the specified 227 * program are unselected. 228 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 229 * @since 1.0 230 * @version 1.0 231 */ 232int32_t FormatDemuxerUnselectTrack(const FormatHandle handle, int32_t programId, int32_t trackId); 233 234/** 235 * @brief Starts the demuxer. 236 * 237 * After being started, the caller can read data frames from the demuxer. 238 * This function should be called after {@link FormatDemuxerPrepare} is called. 239 * 240 * @param handle Indicates the pointer to the demuxer context handle. 241 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 242 * @since 1.0 243 * @version 1.0 244 */ 245int32_t FormatDemuxerStart(const FormatHandle handle); 246 247/** 248 * @brief Obtains the ID of the media track selected by the demuxer for output. 249 * 250 * The demuxer automatically selects the default program and its media tracks. 251 * However, if the program and media tracks have changed after {@link FormatDemuxerSelectTrack} and 252 * {@link FormatDemuxerUnselectTrack} are called, you can obtain the currently selected program and media tracks 253 * by calling this function (<b>FormatDemuxerGetSelectedTrack</b>. 254 * 255 * @param handle Indicates the pointer to the demuxer context handle. 256 * @param programId Identifies the pointer to the program. 257 * @param trackId Identifies the array of selected media tracks. This parameter works in pair with <b>nums</b>. 258 * @param nums Indicates the pointer to the total number of selected media tracks. 259 * This parameter works in pair with <b>trackId</b>. 260 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 261 * @since 1.0 262 * @version 1.0 263 */ 264int32_t FormatDemuxerGetSelectedTrack(const FormatHandle handle, int32_t *programId, int32_t trackId[], int32_t *nums); 265 266/** 267 * @brief Reads data frames. 268 * 269 * After the data frames are read, 270 * you need to call {@link FormatDemuxerFreeFame} to free them. 271 * 272 * @param handle Indicates the pointer to the demuxer context handle. 273 * @param frame Indicates the pointer to the data structure {@link FormatFrame}. 274 * @param timeOutMs Indicates the time required for waiting data frame read. 275 * The value <b>0</b> indicates that data frames are immediately read without any wait. 276 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 277 * @since 1.0 278 * @version 1.0 279 */ 280int32_t FormatDemuxerReadFrame(const FormatHandle handle, FormatFrame *frame, int32_t timeOutMs); 281 282/** 283 * @brief Frees data frames. 284 * 285 * You can call this function to free the data frames obtained by calling {@link FormatDemuxerReadFrame}. 286 * 287 * @param handle Indicates the pointer to the demuxer context handle. 288 * @param frame Indicates the pointer to the data structure {@link FormatFrame}. 289 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 290 * @since 1.0 291 * @version 1.0 292 */ 293int32_t FormatDemuxerFreeFrame(const FormatHandle handle, FormatFrame *frame); 294 295/** 296 * @brief Seeks for a specified position for the demuxer. 297 * 298 * After being started, the demuxer seeks for a specified position to read data frames. 299 * You can specify the position close to the time specified by <b>streamIndex</b>. 300 * 301 * @param handle Indicates the pointer to the demuxer context handle. 302 * @param streamIndex Identifies the stream in the media file. 303 * @param timeStampUs Indicates the target position, in microseconds. 304 * @param mode Indicates the seek mode, as defined in {@link FormatSeekMode}. 305 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 306 * @since 1.0 307 * @version 1.0 308 */ 309int32_t FormatDemuxerSeek(const FormatHandle handle, int32_t streamIndex, int64_t timeStampUs, FormatSeekMode mode); 310 311/** 312 * @brief Stops the demuxer from working. 313 * 314 * After this function is called, the demuxer cannot resume decapsulation. 315 * 316 * @param handle Indicates the pointer to the demuxer context handle. 317 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 318 * @since 1.0 319 * @version 1.0 320 */ 321int32_t FormatDemuxerStop(const FormatHandle handle); 322 323/** 324 * @brief Destroys demuxer resources. 325 * 326 * This function works in pair with {@link FormatDemuxerCreate}. 327 * If you do not call this function, resource leakage may occur. 328 * 329 * @param handle Indicates the pointer to the demuxer context handle. 330 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 331 * @since 1.0 332 * @version 1.0 333 */ 334int32_t FormatDemuxerDestroy(const FormatHandle handle); 335 336/** 337 * @brief Creates a muxer and returns its context handle. 338 * 339 * @param handle Indicates the double pointer to the muxer context handle. 340 * @param outputConfig Indicates the pointer to the muxer output configuration, 341 * as defined in {@link FormatOutputConfig}. 342 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 343 * @since 1.0 344 * @version 1.0 345 */ 346int32_t FormatMuxerCreate(FormatHandle * const handle, const FormatOutputConfig *outputConfig); 347 348/** 349 * @brief Destroys a muxer and releases its resources created by calling {@link FormatMuxerCreate}. 350 * 351 * @param handle Indicates the pointer to the muxer context handle. 352 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 353 * @since 1.0 354 * @version 1.0 355 */ 356int32_t FormatMuxerDestroy(const FormatHandle handle); 357 358/** 359 * @brief Adds a media track source for the muxer. For details about track sources, see {@link TrackSource}. 360 * 361 * This function must be called after {@link FormatMuxerCreate} is successfully called and 362 * before {@link FormatMuxerStart} is called. 363 * 364 * @param handle Indicates the pointer to the muxer context handle. 365 * @param trackSource Indicates the pointer to the track source. 366 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 367 * @since 1.0 368 * @version 1.0 369 */ 370int32_t FormatMuxerAddTrack(const FormatHandle handle, const TrackSource *trackSource); 371 372/** 373 * @brief Sets a callback for the muxer. For details about the callback, see {@link FormatCallback}. 374 * 375 * This function should be called after {@link FormatMuxerCreate} is successfully called. 376 * 377 * @param handle Indicates the pointer to the muxer context handle. 378 * @param FormatCallback Indicates the pointer to the muxer callback to set. 379 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 380 * @since 1.0 381 * @version 1.0 382 */ 383int32_t FormatMuxerSetCallBack(const FormatHandle handle, const FormatCallback *callBack); 384 385/** 386 * @brief Sets the orientation of the video track for the muxer. 387 * 388 * This function should be called after {@link FormatMuxerAddTrack} is successfully called. 389 * The following degrees are supported: 0, 90, 180, and 270. 390 * 391 * @param handle Indicates the pointer to the muxer context handle. 392 * @param degrees Indicates the clockwise angle of the video track. 393 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 394 * @since 1.0 395 * @version 1.0 396 */ 397int32_t FormatMuxerSetOrientation(const FormatHandle handle, int degrees); 398 399/** 400 * @brief Sets the geographical information for the output file of the muxer. 401 * 402 * This function should be called after {@link FormatMuxerCreate} is successfully called. 403 * 404 * @param handle Indicates the pointer to the muxer context handle. 405 * @param latitude Indicates the latitude, within the range [-90,90]. 406 * @param longitude Indicates the longitude, within the range [-180,180]. 407 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 408 * @since 1.0 409 * @version 1.0 410 */ 411int32_t FormatMuxerSetLocation(const FormatHandle handle, int latitude, int longitude); 412 413/** 414 * @brief Sets the maximum size (in bytes) for the output file of the muxer. 415 * 416 * This function should be called after {@link FormatMuxerCreate} is successfully called. 417 * 418 * @param handle Indicates the pointer to the muxer context handle. 419 * @param bytes Indicates the maximum size of a file, in bytes. If the value is <b>0</b> or negative, 420 * the operation fails and the maximum size does not take effect. In this case, the maximum size of a single file 421 * supported by the current file system is used as the value of this parameter. 422 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 423 * @since 1.0 424 * @version 1.0 425 */ 426int32_t FormatMuxerSetMaxFileSize(const FormatHandle handle, int64_t bytes); 427 428/** 429 * @brief Sets the maximum duration (in seconds) for the output file. 430 * 431 * You need to call this function before calling {@link FormatMuxerStart}. If the maximum duration you set is valid 432 * and capturing is approaching 90% of that duration or the remaining duration is 1s, the message 433 * {@link MUXER_INFO_MAX_DURATION_APPROACHING} is reported via {@link OnInfo} of {@link FormatCallback}. If the output 434 * file has been set by calling {@link FormatMuxerCreate}, you need to call {@link FormatMuxerSetNextOutputFile} 435 * to set the next output file. Otherwise, the current output file will be overwritten when the capturing reaches 436 * the maximum duration you set. 437 * 438 * @param handle Indicates the pointer to the muxer context handle. 439 * @param duration Indicates the maximum duration to set, in seconds. If the value is <b>0</b> or negative, 440 * the operation fails. In this case, the default duration (60 seconds) will be used. 441 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 442 * @since 1.0 443 * @version 1.0 444 */ 445int32_t FormatMuxerSetMaxFileDuration(const FormatHandle handle, int64_t durationUs); 446 447/** 448 * @brief Manually splits a file. 449 * 450 * This function can be called after {@link FormatMuxerStart} is called. Once this function is called, 451 * the file is split based on the manual split type. After manual split is complete, file split will proceed to 452 * use the initially set split type. You can call this function again only after 453 * the {@link MUXER_INFO_FILE_SPLIT_FINISHED} event is reported. 454 * 455 * @param handle Indicates the pointer to the muxer context handle. 456 * @param type Indicates the file split type, as defined in {@link FileSplitType}. 457 * @param timestamp Indicates the file split timestamp. This parameter is not supported currently. 458 * The value <b>¨C1</b> indicates that the file is split at the time this function is called. 459 * @param duration Indicates the period from the file split time to the time the next output file starts. 460 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 461 * @since 1.0 462 * @version 1.0 463 */ 464int32_t FormatMuxerSetFileSplitDuration(const FormatHandle handle, ManualSplitType type, 465 int64_t timestampUs, uint32_t durationUs); 466 467/** 468 * @brief Starts the muxer. 469 * 470 * You can call this function to encapsulate media data after the muxer is created, media tracks are added, 471 * and related parameters are set. 472 * 473 * @param handle Indicates the pointer to the muxer context handle. 474 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 475 * @since 1.0 476 * @version 1.0 477 */ 478int32_t FormatMuxerStart(FormatHandle handle); 479 480/** 481 * @brief Writes data frames into the muxer. 482 * 483 * This function should be called after {@link FormatMuxerCreate} is successfully called. 484 * 485 * @param handle Indicates the pointer to the muxer context handle. 486 * @param frameData Indicates the pointer to the data structure {@link FormatFrame}. 487 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 488 * @since 1.0 489 * @version 1.0 490 */ 491int32_t FormatMuxerWriteFrame(const FormatHandle handle, const FormatFrame *frameData); 492 493/** 494 * @brief Sets the descriptor for the next output file. 495 * 496 * If {@link FormatMuxerCreate} is successfully called and the file descriptor involved is valid, you can call 497 * this function (<b>FormatMuxerSetNextOutputFile</b>) upon receiving the message 498 * {@link MUXER_INFO_MAX_FILESIZE_APPROACHING} or {@link MUXER_INFO_MAX_DURATION_APPROACHING}. 499 * 500 * @param handle Indicates the pointer to the muxer context handle. 501 * @param fd Indicates the file descriptor to set. 502 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 503 * @since 1.0 504 * @version 1.0 505 */ 506int32_t FormatMuxerSetNextOutputFile(const FormatHandle handle, int32_t fd); 507 508/** 509 * @brief Stops the muxer that was started by calling {@link FormatMuxerStart}. 510 * 511 * @param handle Indicates the pointer to the muxer context handle. 512 * @param block Indicates how to stop the muxer. The value <b>true</b> indicates that the muxer is stopped 513 * after all buffered data is processed, and <b>false</b> indicates that the buffered data is discarded and 514 * the muxer is immediately stopped. 515 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 516 * @since 1.0 517 * @version 1.0 518 */ 519int32_t FormatMuxerStop(const FormatHandle handle, bool block); 520 521/** 522 * @brief Sets muxer attributes. 523 * 524 * This is an extended function that can be used to add MP4-dedicated boxes and tags (such as <b>exif</b>). 525 * 526 * @param handle Indicates the pointer to the muxer context handle. 527 * @param trackId Identifies the media track. If the value is {@link FORMAT_INVALID_TRACK_ID}, 528 * this function sets the muxer attributes. 529 * @param item Indicates the pointer to the items carrying muxer attributes. You can specify multiple items at a time 530 * in this parameter, which works in pair with <b>itemNum</b>. 531 * @param itemNum Indicates the number of attributes set at a time. 532 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value otherwise. 533 * @since 1.0 534 * @version 1.0 535 */ 536int32_t FormatMuxerSetParameter(const FormatHandle handle, int32_t trackId, const ParameterItem *item, 537 int32_t itemNum); 538 539/** 540 * @brief Obtains muxer attributes. 541 * 542 * This is an extended function that can be used to obtain muxer or track attributes. 543 * The demuxer then obtains the muxer attributes based on the key contained in <b>item</b>. 544 * 545 * @param handle Indicates the pointer to the muxer context handle. 546 * @param trackId Identifies the media track. If the value is {@link FORMAT_INVALID_TRACK_ID}, 547 * this function obtains the muxer attributes. 548 * @param item Indicates the pointer to the items carrying muxer attributes. You can specify multiple items at a time 549 * in this parameter, which works in pair with <b>itemNum</b>. 550 * @param itemNum Indicates the number of attributes set at a time. 551 * @return Returns <b>0</b> if the operation is successful; returns a non-zero value if any requested attribute 552 * fails to be obtained or is not found. 553 * @since 1.0 554 * @version 1.0 555 */ 556int32_t FormatMuxerGetParameter(const FormatHandle handle, int32_t trackId, ParameterItem *item, int32_t itemNum); 557 558#ifdef __cplusplus 559#if __cplusplus 560} 561#endif 562#endif /* __cplusplus */ 563 564#endif // FORMAT_INTERFACE_H 565/** @} */