/* * copyright (c) 2001 Fabrice Bellard * * 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_AVCODEC_H#define AVCODEC_AVCODEC_H /** * @file * @ingroup libavc * Libavcodec external API header */ #include <errno.h>#include "libavutil/samplefmt.h"#include "libavutil/attributes.h"#include "libavutil/avutil.h"#include "libavutil/buffer.h"#include "libavutil/cpu.h"#include "libavutil/channel_layout.h"#include "libavutil/dict.h"#include "libavutil/frame.h"#include "libavutil/hwcontext.h"#include "libavutil/log.h"#include "libavutil/pixfmt.h"#include "libavutil/rational.h" #include "bsf.h"#include "codec.h"#include "codec_desc.h"#include "codec_par.h"#include "codec_id.h"#include "packet.h"#include "version.h" /** * @defgroup libavc libavcodec * Encoding/Decoding Library * * @{ * * @defgroup lavc_decoding Decoding * @{ * @} * * @defgroup lavc_encoding Encoding * @{ * @} * * @defgroup lavc_codec Codecs * @{ * @defgroup lavc_codec_native Native Codecs * @{ * @} * @defgroup lavc_codec_wrappers External library wrappers * @{ * @} * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge * @{ * @} * @} * @defgroup lavc_internal Internal * @{ * @} * @} */ /** * @ingroup libavc * @defgroup lavc_encdec send/receive encoding and decoding API overview * @{ * * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/ * avcodec_receive_packet() functions provide an encode/decode API, which * decouples input and output. * * The API is very similar for encoding/decoding and audio/video, and works as * follows: * - Set up and open the AVCodecContext as usual. * - Send valid input: *   - For decoding, call avcodec_send_packet() to give the decoder raw *     compressed data in an AVPacket. *   - For encoding, call avcodec_send_frame() to give the encoder an AVFrame *     containing uncompressed audio or video. * *   In both cases, it is recommended that AVPackets and AVFrames are *   refcounted, or libavcodec might have to copy the input data. (libavformat *   always returns refcounted AVPackets, and av_frame_get_buffer() allocates *   refcounted AVFrames.) * - Receive output in a loop. Periodically call one of the avcodec_receive_*() *   functions and process their output: *   - For decoding, call avcodec_receive_frame(). On success, it will return *     an AVFrame containing uncompressed audio or video data. *   - For encoding, call avcodec_receive_packet(). On success, it will return *     an AVPacket with a compressed frame. * *   Repeat this call until it returns AVERROR(EAGAIN) or an error. The *   AVERROR(EAGAIN) return value means that new input data is required to *   return new output. In this case, continue with sending input. For each *   input frame/packet, the codec will typically return 1 output frame/packet, *   but it can also be 0 or more than 1. * * At the beginning of decoding or encoding, the codec might accept multiple * input frames/packets without returning a frame, until its internal buffers * are filled. This situation is handled transparently if you follow the steps * outlined above. * * In theory, sending input can result in EAGAIN - this should happen only if * not all output was received. You can use this to structure alternative decode * or encode loops other than the one suggested above. For example, you could * try sending new input on each iteration, and try to receive output if that * returns EAGAIN. * * End of stream situations. These require "flushing" (aka draining) the codec, * as the codec might buffer multiple frames or packets internally for * performance or out of necessity (consider B-frames). * This is handled as follows: * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding) *   or avcodec_send_frame() (encoding) functions. This will enter draining *   mode. * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet() *   (encoding) in a loop until AVERROR_EOF is returned. The functions will *   not return AVERROR(EAGAIN), unless you forgot to enter draining mode. * - Before decoding can be resumed again, the codec has to be reset with *   avcodec_flush_buffers(). * * Using the API as outlined above is highly recommended. But it is also * possible to call functions outside of this rigid schema. For example, you can * call avcodec_send_packet() repeatedly without calling * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed * until the codec's internal buffer has been filled up (which is typically of * size 1 per output frame, after initial input), and then reject input with * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to * read at least some output. * * Not all codecs will follow a rigid and predictable dataflow; the only * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on * one end implies that a receive/send call on the other end will succeed, or * at least will not fail with AVERROR(EAGAIN). In general, no codec will * permit unlimited buffering of input or output. * * This API replaces the following legacy functions: * - avcodec_decode_video2() and avcodec_decode_audio4(): *   Use avcodec_send_packet() to feed input to the decoder, then use *   avcodec_receive_frame() to receive decoded frames after each packet. *   Unlike with the old video decoding API, multiple frames might result from *   a packet. For audio, splitting the input packet into frames by partially *   decoding packets becomes transparent to the API user. You never need to *   feed an AVPacket to the API twice (unless it is rejected with AVERROR(EAGAIN) - then *   no data was read from the packet). *   Additionally, sending a flush/draining packet is required only once. * - avcodec_encode_video2()/avcodec_encode_audio2(): *   Use avcodec_send_frame() to feed input to the encoder, then use *   avcodec_receive_packet() to receive encoded packets. *   Providing user-allocated buffers for avcodec_receive_packet() is not *   possible. * - The new API does not handle subtitles yet. * * Mixing new and old function calls on the same AVCodecContext is not allowed, * and will result in undefined behavior. * * Some codecs might require using the new API; using the old API will return * an error when calling it. All codecs support the new API. * * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This * would be an invalid state, which could put the codec user into an endless * loop. The API has no concept of time either: it cannot happen that trying to * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second * later accepts the packet (with no other receive/flush API calls involved). * The API is a strict state machine, and the passage of time is not supposed * to influence it. Some timing-dependent behavior might still be deemed * acceptable in certain cases. But it must never result in both send/receive * returning EAGAIN at the same time at any point. It must also absolutely be * avoided that the current state is "unstable" and can "flip-flop" between * the send/receive APIs allowing progress. For example, it's not allowed that * the codec randomly decides that it actually wants to consume a packet now * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an * avcodec_send_packet() call. * @} */ /** * @defgroup lavc_core Core functions/structures. * @ingroup libavc * * Basic definitions, functions for querying libavcodec capabilities, * allocating core structures, etc. * @{ */ /** * @ingroup lavc_decoding * Required number of additionally allocated bytes at the end of the input bitstream for decoding. * This is mainly needed because some optimized bitstream readers read * 32 or 64 bit at once and could read over the end.<br> * Note: If the first 23 bits of the additional bytes are not 0, then damaged * MPEG bitstreams could cause overread and segfault. */#define AV_INPUT_BUFFER_PADDING_SIZE 64 /** * @ingroup lavc_encoding * minimum encoding buffer size * Used to avoid some checks during header writing. */#define AV_INPUT_BUFFER_MIN_SIZE 16384 /** * @ingroup lavc_decoding */enum AVDiscard{    /* We leave some space between them for extensions (drop some     * keyframes for intra-only or drop just some bidir frames). */    AVDISCARD_NONE    =-16, ///< discard nothing    AVDISCARD_DEFAULT =  0, ///< discard useless packets like 0 size packets in avi    AVDISCARD_NONREF  =  8, ///< discard all non reference    AVDISCARD_BIDIR   = 16, ///< discard all bidirectional frames    AVDISCARD_NONINTRA= 24, ///< discard all non intra frames    AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes    AVDISCARD_ALL     = 48, ///< discard all}; enum AVAudioServiceType {    AV_AUDIO_SERVICE_TYPE_MAIN              = 0,    AV_AUDIO_SERVICE_TYPE_EFFECTS           = 1,    AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,    AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED  = 3,    AV_AUDIO_SERVICE_TYPE_DIALOGUE          = 4,    AV_AUDIO_SERVICE_TYPE_COMMENTARY        = 5,    AV_AUDIO_SERVICE_TYPE_EMERGENCY         = 6,    AV_AUDIO_SERVICE_TYPE_VOICE_OVER        = 7,    AV_AUDIO_SERVICE_TYPE_KARAOKE           = 8,    AV_AUDIO_SERVICE_TYPE_NB                   , ///< Not part of ABI}; /** * @ingroup lavc_encoding */typedef struct RcOverride{    int start_frame;    int end_frame;    int qscale; // If this is 0 then quality_factor will be used instead.    float quality_factor;} RcOverride; /* encoding support   These flags can be passed in AVCodecContext.flags before initialization.   Note: Not everything is supported yet.*/ /** * Allow decoders to produce frames with data planes that are not aligned * to CPU requirements (e.g. due to cropping). */#define AV_CODEC_FLAG_UNALIGNED       (1 <<  0)/** * Use fixed qscale. */#define AV_CODEC_FLAG_QSCALE          (1 <<  1)/** * 4 MV per MB allowed / advanced prediction for H.263. */#define AV_CODEC_FLAG_4MV             (1 <<  2)/** * Output even those frames that might be corrupted. */#define AV_CODEC_FLAG_OUTPUT_CORRUPT  (1 <<  3)/** * Use qpel MC. */#define AV_CODEC_FLAG_QPEL            (1 <<  4)/** * Don't output frames whose parameters differ from first * decoded frame in stream. */#define AV_CODEC_FLAG_DROPCHANGED     (1 <<  5)/** * Use internal 2pass ratecontrol in first pass mode. */#define AV_CODEC_FLAG_PASS1           (1 <<  9)/** * Use internal 2pass ratecontrol in second pass mode. */#define AV_CODEC_FLAG_PASS2           (1 << 10)/** * loop filter. */#define AV_CODEC_FLAG_LOOP_FILTER     (1 << 11)/** * Only decode/encode grayscale. */#define AV_CODEC_FLAG_GRAY            (1 << 13)/** * error[?] variables will be set during encoding. */#define AV_CODEC_FLAG_PSNR            (1 << 15)/** * Input bitstream might be truncated at a random location * instead of only at frame boundaries. */#define AV_CODEC_FLAG_TRUNCATED       (1 << 16)/** * Use interlaced DCT. */#define AV_CODEC_FLAG_INTERLACED_DCT  (1 << 18)/** * Force low delay. */#define AV_CODEC_FLAG_LOW_DELAY       (1 << 19)/** * Place global headers in extradata instead of every keyframe. */#define AV_CODEC_FLAG_GLOBAL_HEADER   (1 << 22)/** * Use only bitexact stuff (except (I)DCT). */#define AV_CODEC_FLAG_BITEXACT        (1 << 23)/* Fx : Flag for H.263+ extra options *//** * H.263 advanced intra coding / MPEG-4 AC prediction */#define AV_CODEC_FLAG_AC_PRED         (1 << 24)/** * interlaced motion estimation */#define AV_CODEC_FLAG_INTERLACED_ME   (1 << 29)#define AV_CODEC_FLAG_CLOSED_GOP      (1U << 31) /** * Allow non spec compliant speedup tricks. */#define AV_CODEC_FLAG2_FAST           (1 <<  0)/** * Skip bitstream encoding. */#define AV_CODEC_FLAG2_NO_OUTPUT      (1 <<  2)/** * Place global headers at every keyframe instead of in extradata. */#define AV_CODEC_FLAG2_LOCAL_HEADER   (1 <<  3) /** * timecode is in drop frame format. DEPRECATED!!!! */#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13) /** * Input bitstream might be truncated at a packet boundaries * instead of only at frame boundaries. */#define AV_CODEC_FLAG2_CHUNKS         (1 << 15)/** * Discard cropping information from SPS. */#define AV_CODEC_FLAG2_IGNORE_CROP    (1 << 16) /** * Show all frames before the first keyframe */#define AV_CODEC_FLAG2_SHOW_ALL       (1 << 22)/** * Export motion vectors through frame side data */#define AV_CODEC_FLAG2_EXPORT_MVS     (1 << 28)/** * Do not skip samples and export skip information as frame side data */#define AV_CODEC_FLAG2_SKIP_MANUAL    (1 << 29)/** * Do not reset ASS ReadOrder field on flush (subtitles decoding) */#define AV_CODEC_FLAG2_RO_FLUSH_NOOP  (1 << 30) /* Unsupported options : *              Syntax Arithmetic coding (SAC) *              Reference Picture Selection *              Independent Segment Decoding *//* /Fx *//* codec capabilities */ /* Exported side data.   These flags can be passed in AVCodecContext.export_side_data before initialization.*//** * Export motion vectors through frame side data */#define AV_CODEC_EXPORT_DATA_MVS         (1 << 0)/** * Export encoder Producer Reference Time through packet side data */#define AV_CODEC_EXPORT_DATA_PRFT        (1 << 1)/** * Decoding only. * Export the AVVideoEncParams structure through frame side data. */#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS (1 << 2)/** * Decoding only. * Do not apply film grain, export it instead. */#define AV_CODEC_EXPORT_DATA_FILM_GRAIN (1 << 3) /** * Pan Scan area. * This specifies the area which should be displayed. * Note there may be multiple such areas for one frame. */typedef struct AVPanScan {    /**     * id     * - encoding: Set by user.     * - decoding: Set by libavcodec.     */    int id;     /**     * width and height in 1/16 pel     * - encoding: Set by user.     * - decoding: Set by libavcodec.     */    int width;    int height;     /**     * position of the top left corner in 1/16 pel for up to 3 fields/frames     * - encoding: Set by user.     * - decoding: Set by libavcodec.     */    int16_t position[3][2];} AVPanScan; /** * This structure describes the bitrate properties of an encoded bitstream. It * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD * parameters for H.264/HEVC. */typedef struct AVCPBProperties {    /**     * Maximum bitrate of the stream, in bits per second.     * Zero if unknown or unspecified.     */#if FF_API_UNSANITIZED_BITRATES    int max_bitrate;#else    int64_t max_bitrate;#endif    /**     * Minimum bitrate of the stream, in bits per second.     * Zero if unknown or unspecified.     */#if FF_API_UNSANITIZED_BITRATES    int min_bitrate;#else    int64_t min_bitrate;#endif    /**     * Average bitrate of the stream, in bits per second.     * Zero if unknown or unspecified.     */#if FF_API_UNSANITIZED_BITRATES    int avg_bitrate;#else    int64_t avg_bitrate;#endif     /**     * The size of the buffer to which the ratecontrol is applied, in bits.     * Zero if unknown or unspecified.     */    int buffer_size;     /**     * The delay between the time the packet this structure is associated with     * is received and the time when it should be decoded, in periods of a 27MHz     * clock.     *     * UINT64_MAX when unknown or unspecified.     */    uint64_t vbv_delay;} AVCPBProperties; /** * This structure supplies correlation between a packet timestamp and a wall clock * production time. The definition follows the Producer Reference Time ('prft')

Lines 1–500 of 4135. Load more