text: /*
   * AVCodec public API
   *
   * This file is part of FFmpeg.
   *
   * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #ifndef AVCODEC_CODEC_H
  #define AVCODEC_CODEC_H
  
  #include <stdint.h>
  
  #include "libavutil/avutil.h"
  #include "libavutil/hwcontext.h"
  #include "libavutil/log.h"
  #include "libavutil/pixfmt.h"
  #include "libavutil/rational.h"
  #include "libavutil/samplefmt.h"
  
  #include "libavcodec/codec_id.h"
  #include "libavcodec/version.h"
  
  /**
   * @addtogroup lavc_core
   * @{
   */
  
  /**
   * Decoder can use draw_horiz_band callback.
   */
  #define AV_CODEC_CAP_DRAW_HORIZ_BAND     (1 <<  0)
  /**
   * Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
   * supports custom allocators.
   * If not set, it might not use get_buffer() or get_encode_buffer() at all, or
   * use operations that assume the buffer was allocated by
   * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
   */
  #define AV_CODEC_CAP_DR1                 (1 <<  1)
  #if FF_API_FLAG_TRUNCATED
  /**
   * @deprecated Use parsers to always send proper frames.
   */
  #define AV_CODEC_CAP_TRUNCATED           (1 <<  3)
  #endif
  /**
   * Encoder or decoder requires flushing with NULL input at the end in order to
   * give the complete and correct output.
   *
   * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
   *       with NULL data. The user can still send NULL data to the public encode
   *       or decode function, but libavcodec will not pass it along to the codec
   *       unless this flag is set.
   *
   * Decoders:
   * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
   * avpkt->size=0 at the end to get the delayed data until the decoder no longer
   * returns frames.
   *
   * Encoders:
   * The encoder needs to be fed with NULL data at the end of encoding until the
   * encoder no longer returns data.
   *
   * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
   *       flag also means that the encoder must set the pts and duration for
   *       each output packet. If this flag is not set, the pts and duration will
   *       be determined by libavcodec from the input frame.
   */
  #define AV_CODEC_CAP_DELAY               (1 <<  5)
  /**
   * Codec can be fed a final frame with a smaller size.
   * This can be used to prevent truncation of the last audio samples.
   */
  #define AV_CODEC_CAP_SMALL_LAST_FRAME    (1 <<  6)
  
  /**
   * Codec can output multiple frames per AVPacket
   * Normally demuxers return one frame at a time, demuxers which do not do
   * are connected to a parser to split what they return into proper frames.
   * This flag is reserved to the very rare category of codecs which have a
   * bitstream that cannot be split into frames without timeconsuming
   * operations like full decoding. Demuxers carrying such bitstreams thus
   * may return multiple frames in a packet. This has many disadvantages like
   * prohibiting stream copy in many cases thus it should only be considered
   * as a last resort.
   */
  #define AV_CODEC_CAP_SUBFRAMES           (1 <<  8)
  /**
   * Codec is experimental and is thus avoided in favor of non experimental
   * encoders
   */
  #define AV_CODEC_CAP_EXPERIMENTAL        (1 <<  9)
  /**
   * Codec should fill in channel configuration and samplerate instead of container
   */
  #define AV_CODEC_CAP_CHANNEL_CONF        (1 << 10)
  /**
   * Codec supports frame-level multithreading.
   */
  #define AV_CODEC_CAP_FRAME_THREADS       (1 << 12)
  /**
   * Codec supports slice-based (or partition-based) multithreading.
   */
  #define AV_CODEC_CAP_SLICE_THREADS       (1 << 13)
  /**
   * Codec supports changed parameters at any point.
   */
  #define AV_CODEC_CAP_PARAM_CHANGE        (1 << 14)
  /**
   * Codec supports multithreading through a method other than slice- or
   * frame-level multithreading. Typically this marks wrappers around
   * multithreading-capable external libraries.
   */
  #define AV_CODEC_CAP_OTHER_THREADS       (1 << 15)
  #if FF_API_AUTO_THREADS
  #define AV_CODEC_CAP_AUTO_THREADS        AV_CODEC_CAP_OTHER_THREADS
  #endif
  /**
   * Audio encoder supports receiving a different number of samples in each call.
   */
  #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
  /**
   * Decoder is not a preferred choice for probing.
   * This indicates that the decoder is not a good choice for probing.
   * It could for example be an expensive to spin up hardware decoder,
   * or it could simply not provide a lot of useful information about
   * the stream.
   * A decoder marked with this flag should only be used as last resort
   * choice for probing.
   */
  #define AV_CODEC_CAP_AVOID_PROBING       (1 << 17)
  
  #if FF_API_UNUSED_CODEC_CAPS
  /**
   * Deprecated and unused. Use AVCodecDescriptor.props instead
   */
  #define AV_CODEC_CAP_INTRA_ONLY       0x40000000
  /**
   * Deprecated and unused. Use AVCodecDescriptor.props instead
   */
  #define AV_CODEC_CAP_LOSSLESS         0x80000000
  #endif
  
  /**
   * Codec is backed by a hardware implementation. Typically used to
   * identify a non-hwaccel hardware decoder. For information about hwaccels, use
   * avcodec_get_hw_config() instead.
   */
  #define AV_CODEC_CAP_HARDWARE            (1 << 18)
  
  /**
   * Codec is potentially backed by a hardware implementation, but not
   * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
   * implementation provides some sort of internal fallback.
   */
  #define AV_CODEC_CAP_HYBRID              (1 << 19)
  
  /**
   * This codec takes the reordered_opaque field from input AVFrames
   * and returns it in the corresponding field in AVCodecContext after
   * encoding.
   */
  #define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
  
  /**
   * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
   * not set, the encoder must be closed and reopened to ensure that no frames
   * remain pending.
   */
  #define AV_CODEC_CAP_ENCODER_FLUSH   (1 << 21)
  
  /**
   * AVProfile.
   */
  typedef struct AVProfile {
      int profile;
      const char *name; ///< short name for the profile
  } AVProfile;
  
  typedef struct AVCodecDefault AVCodecDefault;
  
  struct AVCodecContext;
  struct AVSubtitle;
  struct AVPacket;
  
  /**
   * AVCodec.
   */
  typedef struct AVCodec {
      /**
       * Name of the codec implementation.
       * The name is globally unique among encoders and among decoders (but an
       * encoder and a decoder can share the same name).
       * This is the primary way to find a codec from the user perspective.
       */
      const char *name;
      /**
       * Descriptive name for the codec, meant to be more human readable than name.
       * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
       */
      const char *long_name;
      enum AVMediaType type;
      enum AVCodecID id;
      /**
       * Codec capabilities.
       * see AV_CODEC_CAP_*
       */
      int capabilities;
      uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
      const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
      const enum AVPixelFormat *pix_fmts;     ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
      const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
      const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
      const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
      const AVClass *priv_class;              ///< AVClass for the private context
      const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
  
      /**
       * Group name of the codec implementation.
       * This is a short symbolic name of the wrapper backing this codec. A
       * wrapper uses some kind of external implementation for the codec, such
       * as an external library, or a codec implementation provided by the OS or
       * the hardware.
       * If this field is NULL, this is a builtin, libavcodec native codec.
       * If non-NULL, this will be the suffix in AVCodec.name in most cases
       * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
       */
      const char *wrapper_name;
  
      /*****************************************************************
       * No fields below this line are part of the public API. They
       * may not be used outside of libavcodec and can be changed and
       * removed at will.
       * New public fields should be added right above.
       *****************************************************************
       */
      /**
       * Internal codec capabilities.
       * See FF_CODEC_CAP_* in internal.h
       */
      int caps_internal;
  
      int priv_data_size;
      /**
       * @name Frame-level threading support functions
       * @{
       */
      /**
       * Copy necessary context variables from a previous thread context to the current one.
       * If not defined, the next thread will start automatically; otherwise, the codec
       * must call ff_thread_finish_setup().
       *
       * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
       */
      int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
  
      /**
       * Copy variables back to the user-facing context
       */
      int (*update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src);
      /** @} */
  
      /**
       * Private codec-specific defaults.
       */
      const AVCodecDefault *defaults;
  
      /**
       * Initialize codec static data, called from av_codec_iterate().
       *
       * This is not intended for time consuming operations as it is
       * run for every codec regardless of that codec being used.
       */
      void (*init_static_data)(struct AVCodec *codec);
  
      int (*init)(struct AVCodecContext *);
      int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size,
                        const struct AVSubtitle *sub);
      /**
       * Encode data to an AVPacket.
       *
       * @param      avctx          codec context
       * @param      avpkt          output AVPacket
       * @param[in]  frame          AVFrame containing the raw data to be encoded
       * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
       *                            non-empty packet was returned in avpkt.
       * @return 0 on success, negative error code on failure
       */
      int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
                     const struct AVFrame *frame, int *got_packet_ptr);
      /**
       * Decode picture or subtitle data.
       *
       * @param      avctx          codec context
       * @param      outdata        codec type dependent output struct
       * @param[out] got_frame_ptr  decoder sets to 0 or 1 to indicate that a
       *                            non-empty frame or subtitle was returned in
       *                            outdata.
       * @param[in]  avpkt          AVPacket containing the data to be decoded
       * @return amount of bytes read from the packet on success, negative error
       *         code on failure
       */
      int (*decode)(struct AVCodecContext *avctx, void *outdata,
                    int *got_frame_ptr, struct AVPacket *avpkt);
      int (*close)(struct AVCodecContext *);
      /**
       * Encode API with decoupled frame/packet dataflow. This function is called
       * to get one output packet. It should call ff_encode_get_frame() to obtain
       * input data.
       */
      int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
  
      /**
       * Decode API with decoupled packet/frame dataflow. This function is called
       * to get one output frame. It should call ff_decode_get_packet() to obtain
       * input data.
       */
      int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
      /**
       * Flush buffers.
       * Will be called when seeking
       */
      void (*flush)(struct AVCodecContext *);
  
      /**
       * Decoding only, a comma-separated list of bitstream filters to apply to
       * packets before decoding.
       */
      const char *bsfs;
  
      /**
       * Array of pointers to hardware configurations supported by the codec,
       * or NULL if no hardware supported.  The array is terminated by a NULL
       * pointer.
       *
       * The user can only access this field via avcodec_get_hw_config().
       */
      const struct AVCodecHWConfigInternal *const *hw_configs;
  
      /**
       * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
       */
      const uint32_t *codec_tags;
  } AVCodec;
  
  /**
   * Iterate over all registered codecs.
   *
   * @param opaque a pointer where libavcodec will store the iteration state. Must
   *               point to NULL to start the iteration.
   *
   * @return the next registered codec or NULL when the iteration is
   *         finished
   */
  const AVCodec *av_codec_iterate(void **opaque);
  
  /**
   * Find a registered decoder with a matching codec ID.
   *
   * @param id AVCodecID of the requested decoder
   * @return A decoder if one was found, NULL otherwise.
   */
  const AVCodec *avcodec_find_decoder(enum AVCodecID id);
  
  /**
   * Find a registered decoder with the specified name.
   *
   * @param name name of the requested decoder
   * @return A decoder if one was found, NULL otherwise.
   */
  const AVCodec *avcodec_find_decoder_by_name(const char *name);
  
  /**
   * Find a registered encoder with a matching codec ID.
   *
   * @param id AVCodecID of the requested encoder
   * @return An encoder if one was found, NULL otherwise.
   */
  const AVCodec *avcodec_find_encoder(enum AVCodecID id);
  
  /**
   * Find a registered encoder with the specified name.
   *
   * @param name name of the requested encoder
   * @return An encoder if one was found, NULL otherwise.
   */
  const AVCodec *avcodec_find_encoder_by_name(const char *name);
  /**
   * @return a non-zero number if codec is an encoder, zero otherwise
   */
  int av_codec_is_encoder(const AVCodec *codec);
  
  /**
   * @return a non-zero number if codec is a decoder, zero otherwise
   */
  int av_codec_is_decoder(const AVCodec *codec);
  
  /**
   * Return a name for the specified profile, if available.
   *
   * @param codec the codec that is searched for the given profile
   * @param profile the profile value for which a name is requested
   * @return A name for the profile if found, NULL otherwise.
   */
  const char *av_get_profile_name(const AVCodec *codec, int profile);
  
  enum {
      /**
       * The codec supports this format via the hw_device_ctx interface.
       *
       * When selecting this format, AVCodecContext.hw_device_ctx should
       * have been set to a device of the specified type before calling
       * avcodec_open2().
       */
      AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
      /**
       * The codec supports this format via the hw_frames_ctx interface.
       *
       * When selecting this format for a decoder,
       * AVCodecContext.hw_frames_ctx should be set to a suitable frames
       * context inside the get_format() callback.  The frames context
       * must have been created on a device of the specified type.
       *
       * When selecting this format for an encoder,
       * AVCodecContext.hw_frames_ctx should be set to the context which
       * will be used for the input frames before calling avcodec_open2().
       */
      AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
      /**
       * The codec supports this format by some internal method.
       *
       * This format can be selected without any additional configuration -
       * no device or frames context is required.
       */
      AV_CODEC_HW_CONFIG_METHOD_INTERNAL      = 0x04,
      /**
       * The codec supports this format by some ad-hoc method.
       *
       * Additional settings and/or function calls are required.  See the
       * codec-specific documentation for details.  (Methods requiring
       * this sort of configuration are deprecated and others should be
       * used in preference.)
       */
      AV_CODEC_HW_CONFIG_METHOD_AD_HOC        = 0x08,
  };
  
  typedef struct AVCodecHWConfig {
      /**
       * For decoders, a hardware pixel format which that decoder may be
       * able to decode to if suitable hardware is available.
       *
       * For encoders, a pixel format which the encoder may be able to
       * accept.  If set to AV_PIX_FMT_NONE, this applies to all pixel
       * formats supported by the codec.
       */
      enum AVPixelFormat pix_fmt;
      /**
       * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
       * setup methods which can be used with this configuration.
       */
      int methods;
      /**
       * The device type associated with the configuration.
       *
       * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
       * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
       */
      enum AVHWDeviceType device_type;
  } AVCodecHWConfig;
  
  /**
   * Retrieve supported hardware configurations for a codec.
   *
   * Values of index from zero to some maximum return the indexed configuration
   * descriptor; all other values return NULL.  If the codec does not support
   * any hardware configurations then it will always return NULL.
   */
  const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
  
  /**
   * @}
   */
  
  #endif /* AVCODEC_CODEC_H */
  