Changeset 455:35e5a1a71e54


Ignore:
Timestamp:
05/19/2015 11:57:42 AM (6 years ago)
Author:
Dmitry Fedorov <fedorov@…>
Branch:
default
Phase:
public
Message:

updated ffmpeg and supported WebM VP9 encoding

Files:
2 added
24 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    r454 r455  
    8383        @echo
    8484        @echo
    85         @echo "Building libx265 20150509 in $(LIBX265)"
     85        @echo "Building libx265 1.4 in $(LIBX265)"
    8686        #(cd $(LIBX265)/build/linux; chmod -f u+x make-Makefiles.bash)
    8787        #(cd $(LIBX265)/build/linux; bash make-Makefiles.bash )
  • libsrc/ffmpeg/include/libavcodec/avcodec.h

    r357 r455  
    291291    AV_CODEC_ID_MVC1_DEPRECATED,
    292292    AV_CODEC_ID_MVC2_DEPRECATED,
     293    AV_CODEC_ID_HQX,
     294    AV_CODEC_ID_TDSC,
     295    AV_CODEC_ID_HQ_HQA,
    293296
    294297    AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
     
    391394    AV_CODEC_ID_ADPCM_VIMA_DEPRECATED,
    392395    AV_CODEC_ID_ADPCM_VIMA = MKBETAG('V','I','M','A'),
     396#if FF_API_VIMA_DECODER
    393397    AV_CODEC_ID_VIMA       = MKBETAG('V','I','M','A'),
     398#endif
    394399    AV_CODEC_ID_ADPCM_AFC  = MKBETAG('A','F','C',' '),
    395400    AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG('O','K','I',' '),
     
    482487    AV_CODEC_ID_PAF_AUDIO_DEPRECATED,
    483488    AV_CODEC_ID_ON2AVC,
     489    AV_CODEC_ID_DSS_SP,
    484490    AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
    485491    AV_CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
     
    10331039
    10341040    /**
     1041     * This side data should be associated with an audio stream and corresponds
     1042     * to enum AVAudioServiceType.
     1043     */
     1044    AV_PKT_DATA_AUDIO_SERVICE_TYPE,
     1045
     1046    /**
    10351047     * Recommmends skipping the specified number of samples
    10361048     * @code
     
    12611273    unsigned int codec_tag;
    12621274
    1263     /**
    1264      * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
    1265      * This is used to work around some encoder bugs.
    1266      * - encoding: unused
    1267      * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
    1268      */
     1275#if FF_API_STREAM_CODEC_TAG
     1276    /**
     1277     * @deprecated this field is unused
     1278     */
     1279    attribute_deprecated
    12691280    unsigned int stream_codec_tag;
     1281#endif
    12701282
    12711283    void *priv_data;
     
    18141826     * precision of the intra DC coefficient - 8
    18151827     * - encoding: Set by user.
    1816      * - decoding: unused
     1828     * - decoding: Set by libavcodec
    18171829     */
    18181830    int intra_dc_precision;
     
    28412853#define FF_PROFILE_DTS_HD_HRA  50
    28422854#define FF_PROFILE_DTS_HD_MA   60
     2855#define FF_PROFILE_DTS_EXPRESS 70
    28432856
    28442857#define FF_PROFILE_MPEG2_422    0
     
    29002913#define FF_PROFILE_HEVC_REXT                        4
    29012914
     2915#define FF_PROFILE_VP9_0                            0
     2916#define FF_PROFILE_VP9_1                            1
     2917#define FF_PROFILE_VP9_2                            2
     2918#define FF_PROFILE_VP9_3                            3
     2919
    29022920    /**
    29032921     * level
     
    32533271     */
    32543272    void (*flush)(AVCodecContext *);
     3273    /**
     3274     * Internal codec capabilities.
     3275     * See FF_CODEC_CAP_* in internal.h
     3276     */
     3277    int caps_internal;
    32553278} AVCodec;
    32563279
     
    36483671 * @warning This function is not thread safe!
    36493672 *
     3673 * @note Always call this function before using decoding routines (such as
     3674 * @ref avcodec_decode_video2()).
     3675 *
    36503676 * @code
    36513677 * avcodec_register_all();
     
    38263852
    38273853int av_packet_split_side_data(AVPacket *pkt);
     3854
     3855const char *av_packet_side_data_name(enum AVPacketSideDataType type);
    38283856
    38293857/**
     
    40954123 *          larger than the actual read bytes because some optimized bitstream
    40964124 *          readers read 32 or 64 bits at once and could read over the end.
     4125 *
     4126 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
     4127 * before packets may be fed to the decoder.
    40974128 *
    40984129 * @param      avctx the codec context
     
    41404171 * avpkt->size=0 at the end to return the remaining frames.
    41414172 *
     4173 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
     4174 * before packets may be fed to the decoder.
     4175 *
    41424176 * @param avctx the codec context
    41434177 * @param[out] picture The AVFrame in which the decoded video frame will be stored.
     
    41864220 * marked with CODEC_CAP_DELAY, then no subtitles will be returned.
    41874221 *
     4222 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
     4223 * before packets may be fed to the decoder.
     4224 *
    41884225 * @param avctx the codec context
    41894226 * @param[out] sub The Preallocated AVSubtitle in which the decoded subtitle will be stored,
     
    43624399     */
    43634400    int output_picture_number;
     4401
     4402    /**
     4403     * Dimensions of the decoded video intended for presentation.
     4404     */
     4405    int width;
     4406    int height;
     4407
     4408    /**
     4409     * Dimensions of the coded video.
     4410     */
     4411    int coded_width;
     4412    int coded_height;
     4413
     4414    /**
     4415     * The format of the coded data, corresponds to enum AVPixelFormat for video
     4416     * and for enum AVSampleFormat for audio.
     4417     *
     4418     * Note that a decoder can have considerable freedom in how exactly it
     4419     * decodes the data, so the format reported here might be different from the
     4420     * one returned by a decoder.
     4421     */
     4422    int format;
    43644423} AVCodecParserContext;
    43654424
  • libsrc/ffmpeg/include/libavcodec/vda.h

    r357 r455  
    172172     */
    173173    VDADecoderOutputCallback output_callback;
     174
     175    /**
     176     * CVPixelBuffer Format Type that VDA will use for decoded frames; set by
     177     * the caller.
     178     */
     179    OSType cv_pix_fmt_type;
    174180} AVVDAContext;
    175181
     
    200206
    201207/**
     208 * This is a convenience function that creates and sets up the VDA context using
     209 * an internal implementation.
     210 *
     211 * @param avctx the corresponding codec context
     212 * @param vdactx the VDA context to use
     213 *
     214 * @return >= 0 on success, a negative AVERROR code on failure
     215 */
     216int av_vda_default_init2(AVCodecContext *avctx, AVVDAContext *vdactx);
     217
     218/**
    202219 * This function must be called to free the VDA context initialized with
    203220 * av_vda_default_init().
  • libsrc/ffmpeg/include/libavcodec/version.h

    r357 r455  
    3030
    3131#define LIBAVCODEC_VERSION_MAJOR 56
    32 #define LIBAVCODEC_VERSION_MINOR  20
    33 #define LIBAVCODEC_VERSION_MICRO 100
     32#define LIBAVCODEC_VERSION_MINOR  39
     33#define LIBAVCODEC_VERSION_MICRO 101
    3434
    3535#define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
     
    4949 */
    5050
     51#ifndef FF_API_VIMA_DECODER
     52#define FF_API_VIMA_DECODER     (LIBAVCODEC_VERSION_MAJOR < 57)
     53#endif
    5154#ifndef FF_API_REQUEST_CHANNELS
    5255#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 57)
     
    185188#define FF_API_MPV_OPT           (LIBAVCODEC_VERSION_MAJOR < 59)
    186189#endif
     190#ifndef FF_API_STREAM_CODEC_TAG
     191#define FF_API_STREAM_CODEC_TAG  (LIBAVCODEC_VERSION_MAJOR < 59)
     192#endif
    187193
    188194#endif /* AVCODEC_VERSION_H */
  • libsrc/ffmpeg/include/libavcodec/vorbis_parser.h

    r357 r455  
    4848#define VORBIS_FLAG_HEADER  0x00000001
    4949#define VORBIS_FLAG_COMMENT 0x00000002
     50#define VORBIS_FLAG_SETUP   0x00000004
    5051
    5152/**
  • libsrc/ffmpeg/include/libavfilter/avfilter.h

    r357 r455  
    12461246/**
    12471247 * Allocate a filter graph.
     1248 *
     1249 * @return the allocated filter graph on success or NULL.
    12481250 */
    12491251AVFilterGraph *avfilter_graph_alloc(void);
     
    14201422 * Add a graph described by a string to a graph.
    14211423 *
     1424 * In the graph filters description, if the input label of the first
     1425 * filter is not specified, "in" is assumed; if the output label of
     1426 * the last filter is not specified, "out" is assumed.
     1427 *
    14221428 * @param graph   the filter graph where to link the parsed graph context
    14231429 * @param filters string to be parsed
  • libsrc/ffmpeg/include/libavfilter/version.h

    r357 r455  
    3131
    3232#define LIBAVFILTER_VERSION_MAJOR  5
    33 #define LIBAVFILTER_VERSION_MINOR  7
    34 #define LIBAVFILTER_VERSION_MICRO 100
     33#define LIBAVFILTER_VERSION_MINOR  16
     34#define LIBAVFILTER_VERSION_MICRO 101
    3535
    3636#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
  • libsrc/ffmpeg/include/libavformat/avformat.h

    r357 r455  
    199199 *   that the timebase actually used by the muxer can be different, as will be
    200200 *   described later).
     201 * - It is advised to manually initialize only the relevant fields in
     202 *   AVCodecContext, rather than using @ref avcodec_copy_context() during
     203 *   remuxing: there is no guarantee that the codec context values remain valid
     204 *   for both input and output format contexts.
    201205 * - The caller may fill in additional information, such as @ref
    202206 *   AVFormatContext.metadata "global" or @ref AVStream.metadata "per-stream"
     
    230234 * @defgroup lavf_io I/O Read/Write
    231235 * @{
     236 * @section lavf_io_dirlist Directory listing
     237 * The directory listing API allows to list files on remote servers.
     238 *
     239 * Some of possible use cases:
     240 * - an "open file" dialog to choose files from a remote location,
     241 * - a recursive media finder providing a player with an ability to play all
     242 * files from a given directory.
     243 *
     244 * @subsection lavf_io_dirlist_open Opening a directory
     245 * At first, a directory needs to be opened by calling avio_open_dir()
     246 * supplied with a URL and, optionally, ::AVDictionary containing
     247 * protocol-specific parameters. The function returns zero or positive
     248 * integer and allocates AVIODirContext on success.
     249 *
     250 * @code
     251 * AVIODirContext *ctx = NULL;
     252 * if (avio_open_dir(&ctx, "smb://example.com/some_dir", NULL) < 0) {
     253 *     fprintf(stderr, "Cannot open directory.\n");
     254 *     abort();
     255 * }
     256 * @endcode
     257 *
     258 * This code tries to open a sample directory using smb protocol without
     259 * any additional parameters.
     260 *
     261 * @subsection lavf_io_dirlist_read Reading entries
     262 * Each directory's entry (i.e. file, another directory, anything else
     263 * within ::AVIODirEntryType) is represented by AVIODirEntry.
     264 * Reading consecutive entries from an opened AVIODirContext is done by
     265 * repeatedly calling avio_read_dir() on it. Each call returns zero or
     266 * positive integer if successful. Reading can be stopped right after the
     267 * NULL entry has been read -- it means there are no entries left to be
     268 * read. The following code reads all entries from a directory associated
     269 * with ctx and prints their names to standard output.
     270 * @code
     271 * AVIODirEntry *entry = NULL;
     272 * for (;;) {
     273 *     if (avio_read_dir(ctx, &entry) < 0) {
     274 *         fprintf(stderr, "Cannot list directory.\n");
     275 *         abort();
     276 *     }
     277 *     if (!entry)
     278 *         break;
     279 *     printf("%s\n", entry->name);
     280 *     avio_free_directory_entry(&entry);
     281 * }
     282 * @endcode
    232283 * @}
    233284 *
     
    552603     */
    553604    int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
     605    enum AVCodecID data_codec; /**< default data codec */
    554606} AVOutputFormat;
    555607/**
     
    10321084
    10331085    /**
     1086     * If not 0, the number of samples that should be skipped from the start of
     1087     * the stream (the samples are removed from packets with pts==0, which also
     1088     * assumes negative timestamps do not happen).
     1089     * Intended for use with formats such as mp3 with ad-hoc gapless audio
     1090     * support.
     1091     */
     1092    int64_t start_skip_samples;
     1093
     1094    /**
    10341095     * If not 0, the first audio sample that should be discarded from the stream.
    10351096     * This is broken by design (needs global sample count), but can't be
     
    11771238                                         void *data, size_t data_size);
    11781239
     1240typedef int (*AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
     1241                              const AVIOInterruptCB *int_cb, AVDictionary **options);
    11791242
    11801243/**
     
    13311394#define AVFMT_FLAG_PRIV_OPT    0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
    13321395#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate.
     1396#define AVFMT_FLAG_FAST_SEEK   0x80000 ///< Enable fast, but inaccurate seeks for some formats
    13331397
    13341398    /**
     
    15031567#define AVFMT_AVOID_NEG_TS_MAKE_ZERO         2 ///< Shift timestamps so that they start at 0
    15041568
    1505 
    15061569    /**
    15071570     * Transport stream id.
     
    16171680    char *format_whitelist;
    16181681
    1619     /*****************************************************************
    1620      * All fields below this line are not part of the public API. They
    1621      * may not be used outside of libavformat and can be changed and
    1622      * removed at will.
    1623      * New public fields should be added right above.
    1624      *****************************************************************
    1625      */
    1626 
    1627     /**
    1628      * This buffer is only needed when packets were already buffered but
    1629      * not decoded, for example to get the codec parameters in MPEG
    1630      * streams.
    1631      */
    1632     struct AVPacketList *packet_buffer;
    1633     struct AVPacketList *packet_buffer_end;
    1634 
    1635     /* av_seek_frame() support */
    1636     int64_t data_offset; /**< offset of the first packet */
    1637 
    1638     /**
    1639      * Raw packets from the demuxer, prior to parsing and decoding.
    1640      * This buffer is used for buffering packets until the codec can
    1641      * be identified, as parsing cannot be done without knowing the
    1642      * codec.
    1643      */
    1644     struct AVPacketList *raw_packet_buffer;
    1645     struct AVPacketList *raw_packet_buffer_end;
    1646     /**
    1647      * Packets split by the parser get queued here.
    1648      */
    1649     struct AVPacketList *parse_queue;
    1650     struct AVPacketList *parse_queue_end;
    1651     /**
    1652      * Remaining size available for raw_packet_buffer, in bytes.
    1653      */
    1654 #define RAW_PACKET_BUFFER_SIZE 2500000
    1655     int raw_packet_buffer_remaining_size;
    1656 
    1657     /**
    1658      * Offset to remap timestamps to be non-negative.
    1659      * Expressed in timebase units.
    1660      * @see AVStream.mux_ts_offset
    1661      */
    1662     int64_t offset;
    1663 
    1664     /**
    1665      * Timebase for the timestamp offset.
    1666      */
    1667     AVRational offset_timebase;
    1668 
    16691682    /**
    16701683     * An opaque field for libavformat internal usage.
     
    17041717     */
    17051718    AVCodec *subtitle_codec;
     1719
     1720    /**
     1721     * Forced data codec.
     1722     * This allows forcing a specific decoder, even when there are multiple with
     1723     * the same codec_id.
     1724     * Demuxing: Set by user via av_format_set_data_codec (NO direct access).
     1725     */
     1726    AVCodec *data_codec;
    17061727
    17071728    /**
     
    17561777     */
    17571778    uint8_t *dump_separator;
     1779
     1780    /**
     1781     * Forced Data codec_id.
     1782     * Demuxing: Set by user.
     1783     */
     1784    enum AVCodecID data_codec_id;
     1785
     1786    /**
     1787     * Called to open further IO contexts when needed for demuxing.
     1788     *
     1789     * This can be set by the user application to perform security checks on
     1790     * the URLs before opening them.
     1791     * The function should behave like avio_open2(), AVFormatContext is provided
     1792     * as contextual information and to reach AVFormatContext.opaque.
     1793     *
     1794     * If NULL then some simple checks are used together with avio_open2().
     1795     *
     1796     * Must not be accessed directly from outside avformat.
     1797     * @See av_format_set_open_cb()
     1798     *
     1799     * Demuxing: Set by user.
     1800     */
     1801    int (*open_cb)(struct AVFormatContext *s, AVIOContext **p, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options);
    17581802} AVFormatContext;
    17591803
     
    17651809AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s);
    17661810void      av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c);
     1811AVCodec * av_format_get_data_codec(const AVFormatContext *s);
     1812void      av_format_set_data_codec(AVFormatContext *s, AVCodec *c);
    17671813int       av_format_get_metadata_header_padding(const AVFormatContext *s);
    17681814void      av_format_set_metadata_header_padding(AVFormatContext *s, int c);
     
    17711817av_format_control_message av_format_get_control_message_cb(const AVFormatContext *s);
    17721818void      av_format_set_control_message_cb(AVFormatContext *s, av_format_control_message callback);
     1819AVOpenCallback av_format_get_open_cb(const AVFormatContext *s);
     1820void      av_format_set_open_cb(AVFormatContext *s, AVOpenCallback callback);
    17731821
    17741822/**
     
    21662214 */
    21672215int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
     2216
     2217/**
     2218 * Discard all internally buffered data. This can be useful when dealing with
     2219 * discontinuities in the byte stream. Generally works only with formats that
     2220 * can resync. This includes headerless formats like MPEG-TS/TS but should also
     2221 * work with NUT, Ogg and in a limited way AVI for example.
     2222 *
     2223 * The set of streams, the detected duration, stream parameters and codecs do
     2224 * not change when calling this function. If you want a complete reset, it's
     2225 * better to open a new AVFormatContext.
     2226 *
     2227 * This does not flush the AVIOContext (s->pb). If necessary, call
     2228 * avio_flush(s->pb) before calling this function.
     2229 *
     2230 * @param s media file handle
     2231 * @return >=0 on success, error code otherwise
     2232 */
     2233int avformat_flush(AVFormatContext *s);
    21682234
    21692235/**
  • libsrc/ffmpeg/include/libavformat/avio.h

    r357 r455  
    3434
    3535#include "libavformat/version.h"
    36 
    3736
    3837#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
     
    5352    void *opaque;
    5453} AVIOInterruptCB;
     54
     55/**
     56 * Directory entry types.
     57 */
     58enum AVIODirEntryType {
     59    AVIO_ENTRY_UNKNOWN,
     60    AVIO_ENTRY_BLOCK_DEVICE,
     61    AVIO_ENTRY_CHARACTER_DEVICE,
     62    AVIO_ENTRY_DIRECTORY,
     63    AVIO_ENTRY_NAMED_PIPE,
     64    AVIO_ENTRY_SYMBOLIC_LINK,
     65    AVIO_ENTRY_SOCKET,
     66    AVIO_ENTRY_FILE,
     67    AVIO_ENTRY_SERVER,
     68    AVIO_ENTRY_SHARE,
     69    AVIO_ENTRY_WORKGROUP,
     70};
     71
     72/**
     73 * Describes single entry of the directory.
     74 *
     75 * Only name and type fields are guaranteed be set.
     76 * Rest of fields are protocol or/and platform dependent and might be unknown.
     77 */
     78typedef struct AVIODirEntry {
     79    char *name;                           /**< Filename */
     80    int type;                             /**< Type of the entry */
     81    int utf8;                             /**< Set to 1 when name is encoded with UTF-8, 0 otherwise.
     82                                               Name can be encoded with UTF-8 eventhough 0 is set. */
     83    int64_t size;                         /**< File size in bytes, -1 if unknown. */
     84    int64_t modification_timestamp;       /**< Time of last modification in microseconds since unix
     85                                               epoch, -1 if unknown. */
     86    int64_t access_timestamp;             /**< Time of last access in microseconds since unix epoch,
     87                                               -1 if unknown. */
     88    int64_t status_change_timestamp;      /**< Time of last status change in microseconds since unix
     89                                               epoch, -1 if unknown. */
     90    int64_t user_id;                      /**< User ID of owner, -1 if unknown. */
     91    int64_t group_id;                     /**< Group ID of owner, -1 if unknown. */
     92    int64_t filemode;                     /**< Unix file mode, -1 if unknown. */
     93} AVIODirEntry;
     94
     95typedef struct AVIODirContext {
     96    struct URLContext *url_context;
     97} AVIODirContext;
    5598
    5699/**
     
    182225
    183226/**
     227 * Open directory for reading.
     228 *
     229 * @param s       directory read context. Pointer to a NULL pointer must be passed.
     230 * @param url     directory to be listed.
     231 * @param options A dictionary filled with protocol-private options. On return
     232 *                this parameter will be destroyed and replaced with a dictionary
     233 *                containing options that were not found. May be NULL.
     234 * @return >=0 on success or negative on error.
     235 */
     236int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options);
     237
     238/**
     239 * Get next directory entry.
     240 *
     241 * Returned entry must be freed with avio_free_directory_entry(). In particular
     242 * it may outlive AVIODirContext.
     243 *
     244 * @param s         directory read context.
     245 * @param[out] next next entry or NULL when no more entries.
     246 * @return >=0 on success or negative on error. End of list is not considered an
     247 *             error.
     248 */
     249int avio_read_dir(AVIODirContext *s, AVIODirEntry **next);
     250
     251/**
     252 * Close directory.
     253 *
     254 * @note Entries created using avio_read_dir() are not deleted and must be
     255 * freeded with avio_free_directory_entry().
     256 *
     257 * @param s         directory read context.
     258 * @return >=0 on success or negative on error.
     259 */
     260int avio_close_dir(AVIODirContext **s);
     261
     262/**
     263 * Free entry allocated by avio_read_dir().
     264 *
     265 * @param entry entry to be freed.
     266 */
     267void avio_free_directory_entry(AVIODirEntry **entry);
     268
     269/**
    184270 * Allocate and initialize an AVIOContext for buffered I/O. It must be later
    185271 * freed with av_free().
     
    235321
    236322/**
     323 * Convert an UTF-8 string to UTF-16BE and write it.
     324 * @return number of bytes written.
     325 */
     326int avio_put_str16be(AVIOContext *s, const char *str);
     327
     328/**
    237329 * Passing this as the "whence" parameter to a seek function causes it to
    238330 * return the filesize without seeking anywhere. Supporting this is optional.
  • libsrc/ffmpeg/include/libavformat/version.h

    r357 r455  
    3131
    3232#define LIBAVFORMAT_VERSION_MAJOR 56
    33 #define LIBAVFORMAT_VERSION_MINOR  18
     33#define LIBAVFORMAT_VERSION_MINOR  33
    3434#define LIBAVFORMAT_VERSION_MICRO 101
    3535
  • libsrc/ffmpeg/include/libavutil/attributes.h

    r314 r455  
    2828
    2929#ifdef __GNUC__
    30 #    define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y)
     30#    define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
    3131#else
    3232#    define AV_GCC_VERSION_AT_LEAST(x,y) 0
  • libsrc/ffmpeg/include/libavutil/avstring.h

    r357 r455  
    276276 */
    277277int av_match_name(const char *name, const char *names);
     278
     279/**
     280 * Append path component to the existing path.
     281 * Path separator '/' is placed between when needed.
     282 * Resulting string have to be freed with av_free().
     283 * @param path      base path
     284 * @param component component to be appended
     285 * @return new path or NULL on error.
     286 */
     287char *av_append_path_component(const char *path, const char *component);
    278288
    279289enum AVEscapeMode {
  • libsrc/ffmpeg/include/libavutil/common.h

    r314 r455  
    148148static av_always_inline av_const int8_t av_clip_int8_c(int a)
    149149{
    150     if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F;
     150    if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
    151151    else                  return a;
    152152}
     
    170170static av_always_inline av_const int16_t av_clip_int16_c(int a)
    171171{
    172     if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
     172    if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
    173173    else                      return a;
    174174}
     
    183183    if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
    184184    else                                         return (int32_t)a;
     185}
     186
     187/**
     188 * Clip a signed integer into the -(2^p),(2^p-1) range.
     189 * @param  a value to clip
     190 * @param  p bit position to clip at
     191 * @return clipped value
     192 */
     193static av_always_inline av_const int av_clip_intp2_c(int a, int p)
     194{
     195    if ((a + (1 << p)) & ~((2 << p) - 1))
     196        return (a >> 31) ^ ((1 << p) - 1);
     197    else
     198        return a;
    185199}
    186200
     
    195209    if (a & ~((1<<p) - 1)) return -a >> 31 & ((1<<p) - 1);
    196210    else                   return  a;
     211}
     212
     213/**
     214 * Clear high bits from an unsigned integer starting with specific bit position
     215 * @param  a value to clip
     216 * @param  p bit position to clip at
     217 * @return clipped value
     218 */
     219static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
     220{
     221    return a & ((1 << p) - 1);
    197222}
    198223
     
    447472#   define av_clipl_int32   av_clipl_int32_c
    448473#endif
     474#ifndef av_clip_intp2
     475#   define av_clip_intp2    av_clip_intp2_c
     476#endif
    449477#ifndef av_clip_uintp2
    450478#   define av_clip_uintp2   av_clip_uintp2_c
    451479#endif
     480#ifndef av_mod_uintp2
     481#   define av_mod_uintp2    av_mod_uintp2_c
     482#endif
    452483#ifndef av_sat_add32
    453484#   define av_sat_add32     av_sat_add32_c
  • libsrc/ffmpeg/include/libavutil/display.h

    r357 r455  
    5656 *
    5757 * @param matrix the transformation matrix
    58  * @return the angle (in degrees) by which the transformation rotates the frame.
    59  *         The angle will be in range [-180.0, 180.0], or NaN if the matrix is
    60  *         singular.
     58 * @return the angle (in degrees) by which the transformation rotates the frame
     59 *         counterclockwise. The angle will be in range [-180.0, 180.0],
     60 *         or NaN if the matrix is singular.
    6161 *
    6262 * @note floating point numbers are inherently inexact, so callers are
     
    6666
    6767/**
    68  * Initialize a transformation matrix describing a pure rotation by the
    69  * specified angle (in degrees).
     68 * Initialize a transformation matrix describing a pure counterclockwise
     69 * rotation by the specified angle (in degrees).
    7070 *
    7171 * @param matrix an allocated transformation matrix (will be fully overwritten
  • libsrc/ffmpeg/include/libavutil/ffversion.h

    r357 r455  
    11#ifndef AVUTIL_FFVERSION_H
    22#define AVUTIL_FFVERSION_H
    3 #define FFMPEG_VERSION "N-69040-gb23a866"
     3#define FFMPEG_VERSION "N-72211-g451be67"
    44#endif /* AVUTIL_FFVERSION_H */
  • libsrc/ffmpeg/include/libavutil/frame.h

    r357 r455  
    107107     */
    108108    AV_FRAME_DATA_SKIP_SAMPLES,
     109
     110    /**
     111     * This side data must be associated with an audio frame and corresponds to
     112     * enum AVAudioServiceType defined in avcodec.h.
     113     */
     114    AV_FRAME_DATA_AUDIO_SERVICE_TYPE,
    109115};
    110116
     
    119125};
    120126
     127
     128/**
     129 * Structure to hold side data for an AVFrame.
     130 *
     131 * sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added
     132 * to the end with a minor bump.
     133 */
    121134typedef struct AVFrameSideData {
    122135    enum AVFrameSideDataType type;
     
    124137    int      size;
    125138    AVDictionary *metadata;
     139    AVBufferRef *buf;
    126140} AVFrameSideData;
    127141
     
    415429    /**
    416430     * AVBuffer references backing the data for this frame. If all elements of
    417      * this array are NULL, then this frame is not reference counted.
     431     * this array are NULL, then this frame is not reference counted. This array
     432     * must be filled contiguously -- if buf[i] is non-NULL then buf[j] must
     433     * also be non-NULL for all j < i.
    418434     *
    419435     * There may be at most one AVBuffer per data plane, so for video this array
     
    651667
    652668/**
    653  * Move everythnig contained in src to dst and reset src.
     669 * Move everything contained in src to dst and reset src.
    654670 */
    655671void av_frame_move_ref(AVFrame *dst, AVFrame *src);
  • libsrc/ffmpeg/include/libavutil/imgutils.h

    r357 r455  
    131131 * pointers will be set pointing to the different picture planes and
    132132 * the line sizes of the different planes will be stored in the
    133  * lines_sizes array. Call with !src to get the required
     133 * lines_sizes array. Call with src == NULL to get the required
    134134 * size for the src buffer.
    135135 *
  • libsrc/ffmpeg/include/libavutil/log.h

    r357 r455  
    2525#include "avutil.h"
    2626#include "attributes.h"
     27#include "version.h"
    2728
    2829typedef enum {
     
    199200
    200201/**
     202 * Extremely verbose debugging, useful for libav* development.
     203 */
     204#define AV_LOG_TRACE    56
     205
     206/**
    201207 * @}
    202208 */
     
    210216 * recommended.
    211217 */
    212 #define AV_LOG_C(x) (x << 8)
     218#define AV_LOG_C(x) ((x) << 8)
    213219
    214220/**
     
    220226 *
    221227 * @param avcl A pointer to an arbitrary struct of which the first field is a
    222  *        pointer to an AVClass struct.
     228 *        pointer to an AVClass struct or NULL if general log.
    223229 * @param level The importance level of the message expressed using a @ref
    224230 *        lavu_log_constants "Logging Constant".
     
    312318                        char *line, int line_size, int *print_prefix);
    313319
     320#if FF_API_DLOG
    314321/**
    315322 * av_dlog macros
     323 * @deprecated unused
    316324 * Useful to print debug messages that shouldn't get compiled in normally.
    317325 */
     
    322330#    define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
    323331#endif
     332#endif /* FF_API_DLOG */
    324333
    325334/**
  • libsrc/ffmpeg/include/libavutil/parseutils.h

    r314 r455  
    147147
    148148/**
    149  * Parse the input string p according to the format string fmt and
    150  * store its results in the structure dt.
    151  * This implementation supports only a subset of the formats supported
    152  * by the standard strptime().
    153  *
    154  * In particular it actually supports the parameters:
    155  * - %H: the hour as a decimal number, using a 24-hour clock, in the
    156  * range '00' through '23'
    157  * - %J: hours as a decimal number, in the range '0' through INT_MAX
    158  * - %M: the minute as a decimal number, using a 24-hour clock, in the
    159  * range '00' through '59'
    160  * - %S: the second as a decimal number, using a 24-hour clock, in the
    161  * range '00' through '59'
    162  * - %Y: the year as a decimal number, using the Gregorian calendar
    163  * - %m: the month as a decimal number, in the range '1' through '12'
    164  * - %d: the day of the month as a decimal number, in the range '1'
    165  * through '31'
    166  * - %%: a literal '%'
    167  *
    168  * @return a pointer to the first character not processed in this
    169  * function call, or NULL in case the function fails to match all of
    170  * the fmt string and therefore an error occurred
    171  */
    172 char *av_small_strptime(const char *p, const char *fmt, struct tm *dt);
    173 
    174 /**
    175149 * Attempt to find a specific tag in a URL.
    176150 *
     
    181155
    182156/**
     157 * Simplified version of strptime
     158 *
     159 * Parse the input string p according to the format string fmt and
     160 * store its results in the structure dt.
     161 * This implementation supports only a subset of the formats supported
     162 * by the standard strptime().
     163 *
     164 * The supported input field descriptors are listed below.
     165 * - %H: the hour as a decimal number, using a 24-hour clock, in the
     166 *   range '00' through '23'
     167 * - %J: hours as a decimal number, in the range '0' through INT_MAX
     168 * - %M: the minute as a decimal number, using a 24-hour clock, in the
     169 *   range '00' through '59'
     170 * - %S: the second as a decimal number, using a 24-hour clock, in the
     171 *   range '00' through '59'
     172 * - %Y: the year as a decimal number, using the Gregorian calendar
     173 * - %m: the month as a decimal number, in the range '1' through '12'
     174 * - %d: the day of the month as a decimal number, in the range '1'
     175 *   through '31'
     176 * - %T: alias for '%H:%M:%S'
     177 * - %%: a literal '%'
     178 *
     179 * @return a pointer to the first character not processed in this function
     180 *         call. In case the input string contains more characters than
     181 *         required by the format string the return value points right after
     182 *         the last consumed input character. In case the whole input string
     183 *         is consumed the return value points to the null byte at the end of
     184 *         the string. On failure NULL is returned.
     185 */
     186char *av_small_strptime(const char *p, const char *fmt, struct tm *dt);
     187
     188/**
    183189 * Convert the decomposed UTC time in tm to a time_t value.
    184190 */
  • libsrc/ffmpeg/include/libavutil/pixdesc.h

    r357 r455  
    9494     * If the format has 2 or 4 components, then alpha is last.
    9595     * If the format has 1 or 2 components, then luma is 0.
    96      * If the format has 3 or 4 components,
    97      * if the RGB flag is set then 0 is red, 1 is green and 2 is blue;
    98      * otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V.
     96     * If the format has 3 or 4 components:
     97     *   if the RGB flag is set then 0 is red, 1 is green and 2 is blue;
     98     *   otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V.
    9999     */
    100100    AVComponentDescriptor comp[4];
     
    130130 */
    131131#define AV_PIX_FMT_FLAG_RGB          (1 << 5)
    132 /**
    133  * The pixel format is "pseudo-paletted". This means that FFmpeg treats it as
    134  * paletted internally, but the palette is generated by the decoder and is not
    135  * stored in the file.
     132
     133/**
     134 * The pixel format is "pseudo-paletted". This means that it contains a
     135 * fixed palette in the 2nd plane but the palette is fixed/constant for each
     136 * PIX_FMT. This allows interpreting the data as if it was PAL8, which can
     137 * in some cases be simpler. Or the data can be interpreted purely based on
     138 * the pixel format without using the palette.
     139 * An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
    136140 */
    137141#define AV_PIX_FMT_FLAG_PSEUDOPAL    (1 << 6)
    138 /**
    139  * The pixel format has an alpha channel.
     142
     143/**
     144 * The pixel format has an alpha channel. This is set on all formats that
     145 * support alpha in some way. The exception is AV_PIX_FMT_PAL8, which can
     146 * carry alpha as part of the palette. Details are explained in the
     147 * AVPixelFormat enum, and are also encoded in the corresponding
     148 * AVPixFmtDescriptor.
     149 *
     150 * The alpha is always straight, never pre-multiplied.
     151 *
     152 * If a codec or a filter does not support alpha, it should set all alpha to
     153 * opaque, or use the equivalent pixel formats without alpha component, e.g.
     154 * AV_PIX_FMT_RGB0 (or AV_PIX_FMT_RGB24 etc.) instead of AV_PIX_FMT_RGBA.
    140155 */
    141156#define AV_PIX_FMT_FLAG_ALPHA        (1 << 7)
     
    296311int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt);
    297312
    298 void ff_check_pixfmt_descriptors(void);
    299 
    300313/**
    301314 * Utility function to swap the endianness of a pixel format.
  • libsrc/ffmpeg/include/libavutil/pixfmt.h

    r357 r455  
    4545 *
    4646 * @par
    47  * When the pixel format is palettized RGB (AV_PIX_FMT_PAL8), the palettized
     47 * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
    4848 * image data is stored in AVFrame.data[0]. The palette is transported in
    4949 * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
    5050 * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
    51  * also endian-specific). Note also that the individual RGB palette
     51 * also endian-specific). Note also that the individual RGB32 palette
    5252 * components stored in AVFrame.data[1] should be in the range 0..255.
    5353 * This is important as many custom PAL8 video codecs that were designed
     
    7777    AV_PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
    7878    AV_PIX_FMT_MONOBLACK, ///<        Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
    79     AV_PIX_FMT_PAL8,      ///< 8 bit with PIX_FMT_RGB32 palette
    80     AV_PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range
    81     AV_PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range
    82     AV_PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range
     79    AV_PIX_FMT_PAL8,      ///< 8 bit with AV_PIX_FMT_RGB32 palette
     80    AV_PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
     81    AV_PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
     82    AV_PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
    8383#if FF_API_XVMC
    8484    AV_PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
     
    105105    AV_PIX_FMT_GRAY16LE,  ///<        Y        , 16bpp, little-endian
    106106    AV_PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
    107     AV_PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range
     107    AV_PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
    108108    AV_PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
    109109#if FF_API_VDPAU
     
    119119    AV_PIX_FMT_RGB565BE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
    120120    AV_PIX_FMT_RGB565LE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
    121     AV_PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0
    122     AV_PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0
     121    AV_PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian   , X=unused/undefined
     122    AV_PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
    123123
    124124    AV_PIX_FMT_BGR565BE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
    125125    AV_PIX_FMT_BGR565LE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
    126     AV_PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1
    127     AV_PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1
     126    AV_PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian   , X=unused/undefined
     127    AV_PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
    128128
    129129    AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
     
    142142    AV_PIX_FMT_DXVA2_VLD,    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
    143143
    144     AV_PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0
    145     AV_PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0
    146     AV_PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1
    147     AV_PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1
     144    AV_PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
     145    AV_PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian,    X=unused/undefined
     146    AV_PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
     147    AV_PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian,    X=unused/undefined
    148148    AV_PIX_FMT_YA8,       ///< 8bit gray, 8bit alpha
    149149
     
    240240    AV_PIX_FMT_YA16LE,       ///< 16bit gray, 16bit alpha (little-endian)
    241241
     242    /**
     243     * duplicated pixel formats for compatibility with libav.
     244     * FFmpeg supports these formats since May 3 2013 (commit e6d4e687558d08187e7a415a7725e4b1a416f782)
     245     * Libav added them Jan 14 2015 with incompatible values (commit 0e6c7dfa650e8b0497bfa7a06394b7a462ddc33a)
     246     */
     247    AV_PIX_FMT_GBRAP_LIBAV,        ///< planar GBRA 4:4:4:4 32bpp
     248    AV_PIX_FMT_GBRAP16BE_LIBAV,    ///< planar GBRA 4:4:4:4 64bpp, big-endian
     249    AV_PIX_FMT_GBRAP16LE_LIBAV,    ///< planar GBRA 4:4:4:4 64bpp, little-endian
     250    /**
     251     *  HW acceleration through QSV, data[3] contains a pointer to the
     252     *  mfxFrameSurface1 structure.
     253     */
     254    AV_PIX_FMT_QSV,
     255    /**
     256     * HW acceleration though MMAL, data[3] contains a pointer to the
     257     * MMAL_BUFFER_HEADER_T structure.
     258     */
     259    AV_PIX_FMT_MMAL,
    242260
    243261#ifndef AV_PIX_FMT_ABI_GIT_MASTER
     
    247265    AV_PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
    248266#endif
    249     AV_PIX_FMT_0RGB=0x123+4,      ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB...
    250     AV_PIX_FMT_RGB0,      ///< packed RGB 8:8:8, 32bpp, RGB0RGB0...
    251     AV_PIX_FMT_0BGR,      ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR...
    252     AV_PIX_FMT_BGR0,      ///< packed BGR 8:8:8, 32bpp, BGR0BGR0...
     267    AV_PIX_FMT_0RGB=0x123+4,///< packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
     268    AV_PIX_FMT_RGB0,        ///< packed RGB 8:8:8, 32bpp, RGBXRGBX...   X=unused/undefined
     269    AV_PIX_FMT_0BGR,        ///< packed BGR 8:8:8, 32bpp, XBGRXBGR...   X=unused/undefined
     270    AV_PIX_FMT_BGR0,        ///< packed BGR 8:8:8, 32bpp, BGRXBGRX...   X=unused/undefined
    253271    AV_PIX_FMT_YUVA444P,  ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
    254272    AV_PIX_FMT_YUVA422P,  ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
     
    273291    AV_PIX_FMT_GBRAP16BE,   ///< planar GBRA 4:4:4:4 64bpp, big-endian
    274292    AV_PIX_FMT_GBRAP16LE,   ///< planar GBRA 4:4:4:4 64bpp, little-endian
    275     AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of PIX_FMT_YUV411P and setting color_range
     293    AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
    276294
    277295    AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
     
    290308    AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
    291309#endif /* !FF_API_XVMC */
     310    AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
     311    AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
     312    AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
     313    AV_PIX_FMT_YUV440P12BE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
    292314
    293315    AV_PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
     
    305327#define AV_PIX_FMT_BGRA64BE AV_PIX_FMT_BGRA64BE_LIBAV
    306328#define AV_PIX_FMT_BGRA64LE AV_PIX_FMT_BGRA64LE_LIBAV
     329#define AV_PIX_FMT_GBRAP     AV_PIX_FMT_GBRAP_LIBAV
     330#define AV_PIX_FMT_GBRAP16BE AV_PIX_FMT_GBRAP16BE_LIBAV
     331#define AV_PIX_FMT_GBRAP16LE AV_PIX_FMT_GBRAP16LE_LIBAV
    307332#endif
    308333
     
    342367#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
    343368#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
     369#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
    344370#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
    345371#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
    346372#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
     373#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
    347374#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
    348375#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
  • libsrc/ffmpeg/include/libavutil/version.h

    r357 r455  
    3333 */
    3434
    35 #define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
     35#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
    3636#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
    3737#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
     
    5757
    5858#define LIBAVUTIL_VERSION_MAJOR  54
    59 #define LIBAVUTIL_VERSION_MINOR  16
    60 #define LIBAVUTIL_VERSION_MICRO 100
     59#define LIBAVUTIL_VERSION_MINOR  23
     60#define LIBAVUTIL_VERSION_MICRO 101
    6161
    6262#define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
     
    120120#define FF_API_OPT_TYPE_METADATA        (LIBAVUTIL_VERSION_MAJOR < 55)
    121121#endif
     122#ifndef FF_API_DLOG
     123#define FF_API_DLOG                     (LIBAVUTIL_VERSION_MAJOR < 55)
     124#endif
    122125
    123126#ifndef FF_CONST_AVUTIL55
  • libsrc/libbioimg/formats/mpeg/bim_ffmpeg_format.cpp

    r371 r455  
    5656#define BIM_FORMAT_FFMPEG_WEBM       14
    5757#define BIM_FORMAT_FFMPEG_H265       15
     58#define BIM_FORMAT_FFMPEG_WEBM9      16
    5859
    5960
     
    9091    v.push_back( "webm" );       // 14 "WebM",
    9192    v.push_back( "mp4" );        // 15 "H265",
     93    v.push_back( "webm" );       // 16 "WebM VP9",
    9294    return v;
    9395}
     
    111113    v.push_back( "" );     // 14 "WebM",
    112114    v.push_back( "" );     // 15 "H265",
     115    v.push_back("");       // 16 "WebM VP9",
    113116    return v;
    114117}
     
    134137    v.push_back( AV_CODEC_ID_NONE );  // 14 "WebM default VP8 or VP9
    135138    v.push_back( AV_CODEC_ID_H265 );  // 15 "MPEG4 H265",
     139    v.push_back(AV_CODEC_ID_VP9);    // 16 "WebM VP9
    136140    return v;
    137141}
     
    160164    v.insert( std::make_pair( "webm", 14 ) );
    161165    v.insert( std::make_pair( "h265", 15 ) );
     166    v.insert(std::make_pair("webm", 16));
    162167    return v;
    163168}
     
    182187    v.push_back(10);   // 14 "WebM VP8"
    183188    v.push_back(100);  // 15 "MPEG4 H265"
     189    v.push_back(10);   // 16 "WebM VP9"
    184190    return v;
    185191}
     
    204210    v.push_back(0);   // 14 "WebM VP8"
    205211    v.push_back(1000000);  // 15 "MPEG4 H265"
     212    v.push_back(0);   // 16 "WebM VP9"
    206213    return v;
    207214}
     
    703710//****************************************************************************
    704711
    705 #define BIM_FFMPEG_NUM_FORMATS 16
     712#define BIM_FFMPEG_NUM_FORMATS 17
    706713
    707714FormatItem ffMpegItems[BIM_FFMPEG_NUM_FORMATS] = {
     
    882889      //TDivFormatConstrains constrains ( w, h, pages, minsampl, maxsampl, minbitsampl, maxbitsampl, noLut )
    883890    { 0, 0, 0, 3, 3, 8, 8, 1 }
    884   }               
     891  }, {
     892      "WEBM9",            // short name, no spaces
     893      "WebM VP9", // Long format name
     894      "webm",        // pipe "|" separated supported extension list
     895      1, //canRead;      // 0 - NO, 1 - YES
     896      1, //canWrite;     // 0 - NO, 1 - YES
     897      0, //canReadMeta;  // 0 - NO, 1 - YES
     898      0, //canWriteMeta; // 0 - NO, 1 - YES
     899      1, //canWriteMultiPage;   // 0 - NO, 1 - YES
     900      //TDivFormatConstrains constrains ( w, h, pages, minsampl, maxsampl, minbitsampl, maxbitsampl, noLut )
     901      { 0, 0, 0, 3, 3, 8, 8, 1 }
     902  }
    885903};
    886904
     
    888906
    889907  sizeof(FormatHeader),
    890   "2.5.3",
     908  "2.6.3",
    891909  "FFMPEG",
    892910  "FFMPEG codecs",
  • testing/runtest.py

    r415 r455  
    654654    test_video_write( "FLV", "161pkcvampz1Live2-17-2004_11-57-21_AM.tif" )
    655655    test_video_write( "WEBM", "161pkcvampz1Live2-17-2004_11-57-21_AM.tif" )
     656    test_video_write( "WEBM9", "161pkcvampz1Live2-17-2004_11-57-21_AM.tif" )
    656657    test_video_write( "H264", "161pkcvampz1Live2-17-2004_11-57-21_AM.tif" )
    657658    test_video_write( "H265", "161pkcvampz1Live2-17-2004_11-57-21_AM.tif" )
Note: See TracChangeset for help on using the changeset viewer.