/*
 * 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
 */
module ffmpeg.libavcodec.codec;

import ffmpeg.libavcodec;
import ffmpeg.libavutil;

extern (C) @nogc nothrow:

/**
 * @addtogroup lavc_core
 * @{
 */

/**
 * Decoder can use draw_horiz_band callback.
 */
enum 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.
 */
enum AV_CODEC_CAP_DR1 = 1 << 1;
enum AV_CODEC_CAP_TRUNCATED = 1 << 3;
/**
 * 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.
 */
enum 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.
 */
enum 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.
 */
enum AV_CODEC_CAP_SUBFRAMES = 1 << 8;
/**
 * Codec is experimental and is thus avoided in favor of non experimental
 * encoders
 */
enum AV_CODEC_CAP_EXPERIMENTAL = 1 << 9;
/**
 * Codec should fill in channel configuration and samplerate instead of container
 */
enum AV_CODEC_CAP_CHANNEL_CONF = 1 << 10;
/**
 * Codec supports frame-level multithreading.
 */
enum AV_CODEC_CAP_FRAME_THREADS = 1 << 12;
/**
 * Codec supports slice-based (or partition-based) multithreading.
 */
enum AV_CODEC_CAP_SLICE_THREADS = 1 << 13;
/**
 * Codec supports changed parameters at any point.
 */
enum 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.
 */
enum AV_CODEC_CAP_OTHER_THREADS = 1 << 15;
enum AV_CODEC_CAP_AUTO_THREADS = AV_CODEC_CAP_OTHER_THREADS;

/**
 * Audio encoder supports receiving a different number of samples in each call.
 */
enum 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.
 */
enum AV_CODEC_CAP_AVOID_PROBING = 1 << 17;

/**
 * Deprecated and unused. Use AVCodecDescriptor.props instead
 */
enum AV_CODEC_CAP_INTRA_ONLY = 0x40000000;
/**
 * Deprecated and unused. Use AVCodecDescriptor.props instead
 */
enum AV_CODEC_CAP_LOSSLESS = 0x80000000;

/**
 * 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.
 */
enum 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.
 */
enum 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.
 */
enum 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.
 */
enum AV_CODEC_CAP_ENCODER_FLUSH = 1 << 21;

/**
 * AVProfile.
 */
struct AVProfile
{
    int profile;
    const(char)* name; ///< short name for the profile
}

struct AVCodecDefault;

//struct AVCodecContext;
struct AVSubtitle;

/**
 * AVCodec.
 */
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;
    AVMediaType type;
    AVCodecID id;
    /**
     * Codec capabilities.
     * see AV_CODEC_CAP_*
     */
    int capabilities;
    const(AVRational)* supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
    const(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(AVSampleFormat)* sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
    const(ulong)* channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
    ubyte max_lowres; ///< maximum value for lowres supported by the decoder
    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.
     *****************************************************************
     */
    int priv_data_size;

    AVCodec* next;

    /**
     * @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 function (AVCodecContext* dst, const(AVCodecContext)* src) update_thread_context;
    /** @} */

    /**
     * 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 function (AVCodec* codec) init_static_data;

    int function (AVCodecContext*) init;
    int function (
        AVCodecContext*,
        ubyte* buf,
        int buf_size,
        const(AVSubtitle)* sub) encode_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 function (
        AVCodecContext* avctx,
        AVPacket* avpkt,
        const(AVFrame)* frame,
        int* got_packet_ptr) encode2;
    /**
     * 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 function (
        AVCodecContext* avctx,
        void* outdata,
        int* got_frame_ptr,
        AVPacket* avpkt) decode;
    int function (AVCodecContext*) close;
    /**
     * 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 function (AVCodecContext* avctx, AVPacket* avpkt) receive_packet;

    /**
     * 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 function (AVCodecContext* avctx, AVFrame* frame) receive_frame;
    /**
     * Flush buffers.
     * Will be called when seeking
     */
    void function (AVCodecContext*) flush;
    /**
     * Internal codec capabilities.
     * See FF_CODEC_CAP_* in internal.h
     */
    int caps_internal;

    /**
     * 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().
     */
    struct AVCodecHWConfigInternal;
    const(AVCodecHWConfigInternal*)* hw_configs;

    /**
     * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
     */
    const(uint)* codec_tags;
}

/**
 * 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.
 */
AVCodec* avcodec_find_decoder (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.
 */
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.
 */
AVCodec* avcodec_find_encoder (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.
 */
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);

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
}

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.
     */
    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.
     */
    AVHWDeviceType device_type;
}

/**
 * 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);

/**
 * @}
 */

/* AVCODEC_CODEC_H */