0

New FFmpeg public API headers to match our source tarball in deps.

Review URL: http://codereview.chromium.org/113748

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@16771 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
scherkus@chromium.org
2009-05-22 19:26:27 +00:00
parent bfd71998f5
commit 11309735fc
14 changed files with 531 additions and 309 deletions

@ -13,76 +13,83 @@
#include "base/path_service.h"
#include "media/filters/ffmpeg_common.h"
// We create stub references to dynamically loaded functions in ffmpeg
// We create stub references to dynamically loaded functions in FFmpeg
// for ease of linking.
//
// TODO(ajwong): We need to find a more maintainable way to have this work.
// Also, this code should really be in the ffmpeg wrapper, and not here
// Also, this code should really be in the FFmpeg wrapper, and not here
// in the media level. The concept of "weak symbols" looks like it might
// be promising, but I don't quite understand it yet.
//
// TODO(scherkus): I am *this close* to writing the world's coolest macro to
// make modifying this file easier.
extern "C" {
int (*av_get_bits_per_sample_format_ptr)(enum SampleFormat sample_fmt);
// libavcodec functions.
void (*av_free_packet_ptr)(AVPacket* pkt) = NULL;
void av_free_packet(AVPacket* pkt) {
av_free_packet_ptr(pkt);
}
int (*av_get_bits_per_sample_format_ptr)(enum SampleFormat sample_fmt) = NULL;
int av_get_bits_per_sample_format(enum SampleFormat sample_fmt) {
return av_get_bits_per_sample_format_ptr(sample_fmt);
}
int (*av_new_packet_ptr)(AVPacket* pkt, int size);
void (*av_init_packet_ptr)(AVPacket* pkt) = NULL;
void av_init_packet(AVPacket* pkt) {
av_init_packet_ptr(pkt);
}
int (*av_new_packet_ptr)(AVPacket* pkt, int size) = NULL;
int av_new_packet(AVPacket* pkt, int size) {
return av_new_packet_ptr(pkt, size);
}
void (*avcodec_init_ptr)(void) = NULL;
void avcodec_init(void) {
avcodec_init_ptr();
}
AVCodec* (*avcodec_find_decoder_ptr)(enum CodecID id) = NULL;
AVCodec* avcodec_find_decoder(enum CodecID id) {
return avcodec_find_decoder_ptr(id);
}
int (*avcodec_thread_init_ptr)(AVCodecContext* s, int thread_count) = NULL;
int avcodec_thread_init(AVCodecContext* s, int thread_count) {
return avcodec_thread_init_ptr(s, thread_count);
}
int (*avcodec_open_ptr)(AVCodecContext* avctx, AVCodec* codec) = NULL;
int avcodec_open(AVCodecContext* avctx, AVCodec* codec) {
return avcodec_open_ptr(avctx, codec);
}
AVFrame* (*avcodec_alloc_frame_ptr)(void) = NULL;
AVFrame* avcodec_alloc_frame(void) {
return avcodec_alloc_frame_ptr();
}
int (*avcodec_decode_audio2_ptr)(AVCodecContext* avctx, int16_t* samples,
int* frame_size_ptr, const uint8_t* buf,
int buf_size) = NULL;
int avcodec_decode_audio2(AVCodecContext* avctx, int16_t* samples,
int* frame_size_ptr,
const uint8_t* buf, int buf_size) {
int (*avcodec_decode_audio3_ptr)(AVCodecContext* avctx, int16_t* samples,
int* frame_size_ptr, AVPacket* avpkt) = NULL;
int avcodec_decode_audio3(AVCodecContext* avctx, int16_t* samples,
int* frame_size_ptr, AVPacket* avpkt) {
return avcodec_decode_audio3_ptr(avctx, samples, frame_size_ptr, avpkt);
}
return avcodec_decode_audio2_ptr(avctx, samples, frame_size_ptr, buf,
buf_size);
int (*avcodec_decode_video2_ptr)(AVCodecContext* avctx, AVFrame* picture,
int* got_picture_ptr, AVPacket* avpkt) = NULL;
int avcodec_decode_video2(AVCodecContext* avctx, AVFrame* picture,
int* got_picture_ptr, AVPacket* avpkt) {
return avcodec_decode_video2_ptr(avctx, picture, got_picture_ptr, avpkt);
}
AVCodec* (*avcodec_find_decoder_ptr)(enum CodecID id) = NULL;
AVCodec* avcodec_find_decoder(enum CodecID id) {
return avcodec_find_decoder_ptr(id);
}
void (*avcodec_init_ptr)(void) = NULL;
void avcodec_init(void) {
avcodec_init_ptr();
}
int (*avcodec_open_ptr)(AVCodecContext* avctx, AVCodec* codec) = NULL;
int avcodec_open(AVCodecContext* avctx, AVCodec* codec) {
return avcodec_open_ptr(avctx, codec);
}
int (*avcodec_thread_init_ptr)(AVCodecContext* s, int thread_count) = NULL;
int avcodec_thread_init(AVCodecContext* s, int thread_count) {
return avcodec_thread_init_ptr(s, thread_count);
}
int (*avcodec_decode_video_ptr)(AVCodecContext* avctx, AVFrame* picture,
int* got_picture_ptr, const uint8_t* buf,
int buf_size) = NULL;
int avcodec_decode_video(AVCodecContext* avctx, AVFrame* picture,
int* got_picture_ptr, const uint8_t* buf,
int buf_size) {
return avcodec_decode_video_ptr(avctx, picture, got_picture_ptr, buf,
buf_size);
}
void (*av_register_all_ptr)(void);
void av_register_all(void) {
av_register_all_ptr();
// libavformat functions.
int (*av_find_stream_info_ptr)(AVFormatContext* ic) = NULL;
int av_find_stream_info(AVFormatContext* ic) {
return av_find_stream_info_ptr(ic);
}
int (*av_open_input_file_ptr)(AVFormatContext** ic_ptr, const char* filename,
@ -94,16 +101,21 @@ int av_open_input_file(AVFormatContext** ic_ptr, const char* filename,
return av_open_input_file_ptr(ic_ptr, filename, fmt, buf_size, ap);
}
int (*av_find_stream_info_ptr)(AVFormatContext* ic) = NULL;
int av_find_stream_info(AVFormatContext* ic) {
return av_find_stream_info_ptr(ic);
}
int (*av_read_frame_ptr)(AVFormatContext* s, AVPacket* pkt) = NULL;
int av_read_frame(AVFormatContext* s, AVPacket* pkt) {
return av_read_frame_ptr(s, pkt);
}
void (*av_register_all_ptr)(void) = NULL;
void av_register_all(void) {
av_register_all_ptr();
}
int (*av_register_protocol_ptr)(URLProtocol* protocol) = NULL;
int av_register_protocol(URLProtocol* protocol) {
return av_register_protocol_ptr(protocol);
}
int (*av_seek_frame_ptr)(AVFormatContext* s, int stream_index,
int64_t timestamp, int flags) = NULL;
int av_seek_frame(AVFormatContext* s, int stream_index,
@ -111,22 +123,18 @@ int av_seek_frame(AVFormatContext* s, int stream_index,
return av_seek_frame_ptr(s, stream_index, timestamp, flags);
}
int (*av_register_protocol_ptr)(URLProtocol* protocol) = NULL;
int av_register_protocol(URLProtocol* protocol) {
return av_register_protocol_ptr(protocol);
}
// libavutil functions.
void (*av_free_ptr)(void* ptr) = NULL;
void av_free(void* ptr) {
return av_free_ptr(ptr);
}
void* (*av_malloc_ptr)(unsigned int size) = NULL;
void* av_malloc(unsigned int size) {
return av_malloc_ptr(size);
}
void (*av_free_ptr)(void* ptr) = NULL;
void av_free(void* ptr) {
return av_free_ptr(ptr);
}
int64_t (*av_rescale_q_ptr)(int64_t a, AVRational bq, AVRational cq) = NULL;
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) {
return av_rescale_q_ptr(a, bq, cq);
@ -196,87 +204,97 @@ bool InitializeMediaLibrary(const FilePath& module_dir) {
// TODO(ajwong): Extract this to somewhere saner, and hopefully
// autogenerate the bindings from the .def files. Having all this
// code here is incredibly ugly.
// libavcodec functions.
av_free_packet_ptr =
reinterpret_cast<void (*)(AVPacket*)>(
dlsym(libs[FILE_LIBAVCODEC], "av_free_packet"));
av_get_bits_per_sample_format_ptr =
reinterpret_cast<int (*)(enum SampleFormat)>(
dlsym(libs[FILE_LIBAVCODEC], "av_get_bits_per_sample_format"));
av_init_packet_ptr =
reinterpret_cast<void (*)(AVPacket*)>(
dlsym(libs[FILE_LIBAVCODEC], "av_init_packet"));
av_new_packet_ptr =
reinterpret_cast<int (*)(AVPacket*, int)>(
dlsym(libs[FILE_LIBAVCODEC], "av_new_packet"));
avcodec_init_ptr =
reinterpret_cast<void(*)(void)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_init"));
avcodec_find_decoder_ptr =
reinterpret_cast<AVCodec* (*)(enum CodecID)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_find_decoder"));
avcodec_thread_init_ptr =
reinterpret_cast<int (*)(AVCodecContext*, int)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_thread_init"));
avcodec_open_ptr =
reinterpret_cast<int (*)(AVCodecContext*, AVCodec*)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_open"));
avcodec_alloc_frame_ptr =
reinterpret_cast<AVFrame* (*)(void)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_alloc_frame"));
avcodec_decode_audio2_ptr =
reinterpret_cast<int (*)(AVCodecContext*, int16_t*, int*,
const uint8_t*, int)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_decode_audio2"));
avcodec_decode_video_ptr =
reinterpret_cast<int (*)(AVCodecContext*, AVFrame*, int*,
const uint8_t*, int)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_decode_video"));
avcodec_decode_audio3_ptr =
reinterpret_cast<int (*)(AVCodecContext*, int16_t*, int*, AVPacket*)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_decode_audio3"));
avcodec_decode_video2_ptr =
reinterpret_cast<int (*)(AVCodecContext*, AVFrame*, int*, AVPacket*)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_decode_video2"));
avcodec_find_decoder_ptr =
reinterpret_cast<AVCodec* (*)(enum CodecID)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_find_decoder"));
avcodec_init_ptr =
reinterpret_cast<void (*)(void)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_init"));
avcodec_open_ptr =
reinterpret_cast<int (*)(AVCodecContext*, AVCodec*)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_open"));
avcodec_thread_init_ptr =
reinterpret_cast<int (*)(AVCodecContext*, int)>(
dlsym(libs[FILE_LIBAVCODEC], "avcodec_thread_init"));
av_register_all_ptr =
reinterpret_cast<void(*)(void)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_register_all"));
// libavformat functions.
av_find_stream_info_ptr =
reinterpret_cast<int (*)(AVFormatContext*)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_find_stream_info"));
av_open_input_file_ptr =
reinterpret_cast<int (*)(AVFormatContext**, const char*,
AVInputFormat*, int,
AVFormatParameters*)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_open_input_file"));
av_find_stream_info_ptr =
reinterpret_cast<int (*)(AVFormatContext*)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_find_stream_info"));
av_read_frame_ptr =
reinterpret_cast<int (*)(AVFormatContext*, AVPacket*)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_read_frame"));
av_seek_frame_ptr =
reinterpret_cast<int (*)(AVFormatContext*, int, int64_t, int)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_seek_frame"));
av_register_all_ptr =
reinterpret_cast<void (*)(void)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_register_all"));
av_register_protocol_ptr =
reinterpret_cast<int (*)(URLProtocol*)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_register_protocol"));
av_seek_frame_ptr =
reinterpret_cast<int (*)(AVFormatContext*, int, int64_t, int)>(
dlsym(libs[FILE_LIBAVFORMAT], "av_seek_frame"));
av_malloc_ptr =
reinterpret_cast<void* (*)(unsigned int)>(
dlsym(libs[FILE_LIBAVUTIL], "av_malloc"));
// libavutil functions.
av_free_ptr =
reinterpret_cast<void (*)(void*)>(
dlsym(libs[FILE_LIBAVUTIL], "av_free"));
av_malloc_ptr =
reinterpret_cast<void* (*)(unsigned int)>(
dlsym(libs[FILE_LIBAVUTIL], "av_malloc"));
av_rescale_q_ptr =
reinterpret_cast<int64_t (*)(int64_t, AVRational, AVRational)>(
dlsym(libs[FILE_LIBAVUTIL], "av_rescale_q"));
// Check that all the symbols were loaded correctly before returning true.
if (av_get_bits_per_sample_format_ptr &&
if (av_free_packet_ptr &&
av_get_bits_per_sample_format_ptr &&
av_init_packet_ptr &&
av_new_packet_ptr &&
avcodec_init_ptr &&
avcodec_find_decoder_ptr &&
avcodec_thread_init_ptr &&
avcodec_open_ptr &&
avcodec_alloc_frame_ptr &&
avcodec_decode_audio2_ptr &&
avcodec_decode_video_ptr &&
avcodec_decode_audio3_ptr &&
avcodec_decode_video2_ptr &&
avcodec_find_decoder_ptr &&
avcodec_init_ptr &&
avcodec_open_ptr &&
avcodec_thread_init_ptr &&
av_register_all_ptr &&
av_open_input_file_ptr &&
av_find_stream_info_ptr &&
av_open_input_file_ptr &&
av_read_frame_ptr &&
av_seek_frame_ptr &&
av_register_all_ptr &&
av_register_protocol_ptr &&
av_seek_frame_ptr &&
av_malloc_ptr &&
av_free_ptr &&
av_malloc_ptr &&
av_rescale_q_ptr) {
return true;
}

@ -189,12 +189,12 @@ int main(int argc, const char** argv) {
base::TimeTicks decode_start = base::TimeTicks::HighResNow();
if (target_codec == CODEC_TYPE_AUDIO) {
int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
result = avcodec_decode_audio2(codec_context, samples, &size_out,
packet.data, packet.size);
result = avcodec_decode_audio3(codec_context, samples, &size_out,
&packet);
} else if (target_codec == CODEC_TYPE_VIDEO) {
int got_picture = 0;
result = avcodec_decode_video(codec_context, frame, &got_picture,
packet.data, packet.size);
result = avcodec_decode_video2(codec_context, frame, &got_picture,
&packet);
} else {
NOTREACHED();
}

@ -74,13 +74,18 @@ void FFmpegAudioDecoder::OnStop() {
}
void FFmpegAudioDecoder::OnDecode(Buffer* input) {
// Due to FFmpeg API changes we no longer have const read-only pointers.
AVPacket packet;
av_init_packet(&packet);
packet.data = const_cast<uint8*>(input->GetData());
packet.size = input->GetDataSize();
int16_t* output_buffer = reinterpret_cast<int16_t*>(output_buffer_.get());
int output_buffer_size = kOutputBufferSize;
int result = avcodec_decode_audio2(codec_context_,
int result = avcodec_decode_audio3(codec_context_,
output_buffer,
&output_buffer_size,
input->GetData(),
input->GetDataSize());
&packet);
// TODO(ajwong): Consider if kOutputBufferSize should just be an int instead
// of a size_t.

@ -143,6 +143,14 @@ int64 av_rescale_q(int64 a, AVRational bq, AVRational cq) {
return a * num / den;
}
void av_free_packet(AVPacket* packet) {
if (packet->destruct) {
packet->destruct(packet);
packet->data = NULL;
packet->size = 0;
}
}
void DestructPacket(AVPacket* packet) {
delete [] packet->data;
--g_outstanding_packets_av_new_frame;

@ -81,17 +81,20 @@ void FFmpegVideoDecoder::OnDecode(Buffer* buffer) {
times.duration = buffer->GetDuration();
time_queue_.push(times);
// Cast everything to FFmpeg types.
const uint8_t* data_in = buffer->GetData();
const size_t size_in = buffer->GetDataSize();
// Create a packet for input data.
// Due to FFmpeg API changes we no longer have const read-only pointers.
AVPacket packet;
av_init_packet(&packet);
packet.data = const_cast<uint8*>(buffer->GetData());
packet.size = buffer->GetDataSize();
// We don't allocate AVFrame on the stack since different versions of FFmpeg
// may change the size of AVFrame, causing stack corruption. The solution is
// to let FFmpeg allocate the structure via avcodec_alloc_frame().
int decoded = 0;
scoped_ptr_malloc<AVFrame, ScopedPtrAVFree> yuv_frame(avcodec_alloc_frame());
int result = avcodec_decode_video(codec_context_, yuv_frame.get(), &decoded,
data_in, size_in);
int result = avcodec_decode_video2(codec_context_, yuv_frame.get(), &decoded,
&packet);
// Log the problem if we can't decode a video frame.
if (result < 0) {

@ -1,12 +1,16 @@
This contains FFmpeg's public header files from the output of a "make install"
command. The header files are from FFmpeg revision 18286.
command. The header files are from Chromium's copy of FFmpeg.
Steps to reproduce:
1) If on Windows, refer to http://ffmpeg.arrozcru.org for environment setup
2) Check out FFmpeg from their repository
3) ./configure --prefix=/path/to/chrome/src/third_party/ffmpeg
4) make && make install
5) Remove bin and lib folders, leaving the include folder behind
1) If on Windows, refer to our MinGW/MSYS environment setup:
http://src.chromium.org/viewvc/chrome/trunk/deps/third_party/mingw/
2) Grab Chromium's copy of FFmpeg:
http://src.chromium.org/viewvc/chrome/trunk/deps/third_party/ffmpeg/
3) Follow the instructions to build and install.
4) Go to your install location and copy the following into the Chromium tree:
/path/to/install/include/libavcodec
/path/to/install/include/libavformat
/path/to/install/include/libavutil
The project contains some hand-written DEF files used to generate import
libraries to permit dynamically loading FFmpeg. The libaries are linked in
@ -17,4 +21,3 @@ export every method by ordinal, which makes binary compatability with different
builds of FFmpeg difficult if not impossible. Furthermore, it is much easier
to update a DEF file instead of rebuilding FFmpeg to generate new import
libraries.

@ -1,15 +1,13 @@
LIBRARY avcodec-52
EXPORTS
av_free_packet
av_get_bits_per_sample_format
av_init_packet
av_new_packet
avcodec_alloc_context
avcodec_alloc_frame
avcodec_decode_audio2
avcodec_decode_video
avcodec_decode_audio3
avcodec_decode_video2
avcodec_find_decoder
avcodec_get_frame_defaults
avcodec_init
avcodec_open
avcodec_thread_execute
avcodec_thread_free
avcodec_thread_init

@ -23,7 +23,6 @@
'include/libavcodec/opt.h',
'include/libavcodec/vdpau.h',
'include/libavcodec/xvmc.h',
'include/libavdevice/avdevice.h',
'include/libavformat/avformat.h',
'include/libavformat/avio.h',
'include/libavutil/adler32.h',

@ -30,8 +30,8 @@
#include "libavutil/avutil.h"
#define LIBAVCODEC_VERSION_MAJOR 52
#define LIBAVCODEC_VERSION_MINOR 22
#define LIBAVCODEC_VERSION_MICRO 3
#define LIBAVCODEC_VERSION_MINOR 28
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
LIBAVCODEC_VERSION_MINOR, \
@ -193,6 +193,8 @@ enum CodecID {
CODEC_ID_TQI,
CODEC_ID_AURA,
CODEC_ID_AURA2,
CODEC_ID_V210X,
CODEC_ID_TMV,
/* various PCM "codecs" */
CODEC_ID_PCM_S16LE= 0x10000,
@ -313,6 +315,7 @@ enum CodecID {
CODEC_ID_MP1,
CODEC_ID_TWINVQ,
CODEC_ID_TRUEHD,
CODEC_ID_MP4ALS,
/* subtitle codecs */
CODEC_ID_DVD_SUBTITLE= 0x17000,
@ -379,13 +382,17 @@ enum SampleFormat {
/* Audio channel convenience macros */
#define CH_LAYOUT_MONO (CH_FRONT_CENTER)
#define CH_LAYOUT_STEREO (CH_FRONT_LEFT|CH_FRONT_RIGHT)
#define CH_LAYOUT_2_1 (CH_LAYOUT_STEREO|CH_BACK_CENTER)
#define CH_LAYOUT_SURROUND (CH_LAYOUT_STEREO|CH_FRONT_CENTER)
#define CH_LAYOUT_4POINT0 (CH_LAYOUT_SURROUND|CH_BACK_CENTER)
#define CH_LAYOUT_2_2 (CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT)
#define CH_LAYOUT_QUAD (CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT)
#define CH_LAYOUT_5POINT0 (CH_LAYOUT_SURROUND|CH_SIDE_LEFT|CH_SIDE_RIGHT)
#define CH_LAYOUT_5POINT1 (CH_LAYOUT_5POINT0|CH_LOW_FREQUENCY)
#define CH_LAYOUT_5POINT0_BACK (CH_LAYOUT_SURROUND|CH_BACK_LEFT|CH_BACK_RIGHT)
#define CH_LAYOUT_5POINT1_BACK (CH_LAYOUT_5POINT0_BACK|CH_LOW_FREQUENCY)
#define CH_LAYOUT_7POINT1 (CH_LAYOUT_5POINT1|CH_BACK_LEFT|CH_BACK_RIGHT)
#define CH_LAYOUT_7POINT1_WIDE (CH_LAYOUT_SURROUND|CH_LOW_FREQUENCY|\
CH_BACK_LEFT|CH_BACK_RIGHT|\
#define CH_LAYOUT_7POINT1_WIDE (CH_LAYOUT_5POINT1_BACK|\
CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER)
#define CH_LAYOUT_STEREO_DOWNMIX (CH_STEREO_LEFT|CH_STEREO_RIGHT)
@ -435,6 +442,43 @@ enum AVDiscard{
AVDISCARD_ALL = 48, ///< discard all
};
enum AVColorPrimaries{
AVCOL_PRI_BT709 =1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
AVCOL_PRI_UNSPECIFIED=2,
AVCOL_PRI_BT470M =4,
AVCOL_PRI_BT470BG =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
AVCOL_PRI_SMPTE170M =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
AVCOL_PRI_SMPTE240M =7, ///< functionally identical to above
AVCOL_PRI_FILM =8,
AVCOL_PRI_NB , ///< Not part of ABI
};
enum AVColorTransferCharacteristic{
AVCOL_TRC_BT709 =1, ///< also ITU-R BT1361
AVCOL_TRC_UNSPECIFIED=2,
AVCOL_TRC_GAMMA22 =4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
AVCOL_TRC_GAMMA28 =5, ///< also ITU-R BT470BG
AVCOL_TRC_NB , ///< Not part of ABI
};
enum AVColorSpace{
AVCOL_SPC_RGB =0,
AVCOL_SPC_BT709 =1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
AVCOL_SPC_UNSPECIFIED=2,
AVCOL_SPC_FCC =4,
AVCOL_SPC_BT470BG =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
AVCOL_SPC_SMPTE170M =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
AVCOL_SPC_SMPTE240M =7,
AVCOL_SPC_NB , ///< Not part of ABI
};
enum AVColorRange{
AVCOL_RANGE_UNSPECIFIED=0,
AVCOL_RANGE_MPEG =1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
AVCOL_RANGE_JPEG =2, ///< the normal 2^n-1 "JPEG" YUV ranges
AVCOL_RANGE_NB , ///< Not part of ABI
};
typedef struct RcOverride{
int start_frame;
int end_frame;
@ -538,6 +582,10 @@ typedef struct RcOverride{
* Codec can export data for HW decoding (VDPAU).
*/
#define CODEC_CAP_HWACCEL_VDPAU 0x0080
/**
* Codec supports frame-based multithreading.
*/
#define CODEC_CAP_FRAME_THREADS 0x0100
//The following defines may change, don't expect compatibility if you use them.
#define MB_TYPE_INTRA4x4 0x0001
@ -817,7 +865,20 @@ typedef struct AVPanScan{
* - decoding: Set by libavcodec\
*/\
void *hwaccel_picture_private;\
\
/**\
* the AVCodecContext which ff_get_buffer was last called on\
* - encoding: Set by libavcodec.\
* - decoding: Set by libavcodec.\
*/\
struct AVCodecContext *owner;\
\
/**\
* used by multithreading to store frame-specific info\
* - encoding: Set by libavcodec.\
* - decoding: Set by libavcodec.\
*/\
void *thread_opaque;
#define FF_QSCALE_TYPE_MPEG1 0
#define FF_QSCALE_TYPE_MPEG2 1
@ -842,6 +903,55 @@ typedef struct AVPanScan{
#define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content.
#define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update).
typedef struct AVPacket {
/**
* Presentation timestamp in AVStream->time_base units; the time at which
* the decompressed packet will be presented to the user.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
* pts MUST be larger or equal to dts as presentation cannot happen before
* decompression, unless one wants to view hex dumps. Some formats misuse
* the terms dts and pts/cts to mean something different. Such timestamps
* must be converted to true pts/dts before they are stored in AVPacket.
*/
int64_t pts;
/**
* Decompression timestamp in AVStream->time_base units; the time at which
* the packet is decompressed.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
*/
int64_t dts;
uint8_t *data;
int size;
int stream_index;
int flags;
/**
* Duration of this packet in AVStream->time_base units, 0 if unknown.
* Equals next_pts - this_pts in presentation order.
*/
int duration;
void (*destruct)(struct AVPacket *);
void *priv;
int64_t pos; ///< byte position in stream, -1 if unknown
/**
* Time difference in AVStream->time_base units from the pts of this
* packet to the point at which the output from the decoder has converged
* independent from the availability of previous frames. That is, the
* frames are virtually identical no matter if decoding started from
* the very first frame or from this keyframe.
* Is AV_NOPTS_VALUE if unknown.
* This field is not the display duration of the current packet.
*
* The purpose of this field is to allow seeking in streams that have no
* keyframes in the conventional sense. It corresponds to the
* recovery point SEI in H.264 and match_time_delta in NUT. It is also
* essential for some types of subtitle streams to ensure that all
* subtitles are correctly displayed after seeking.
*/
int64_t convergence_duration;
} AVPacket;
#define PKT_FLAG_KEY 0x0001
/**
* Audio Video Frame.
* New fields can be added to the end of FF_COMMON_FRAME with minor version
@ -971,7 +1081,7 @@ typedef struct AVCodecContext {
* If non NULL, 'draw_horiz_band' is called by the libavcodec
* decoder to draw a horizontal band. It improves cache usage. Not
* all codecs can do that. You must check the codec capabilities
* beforehand.
* beforehand. May be called by different threads at the same time.
* The function is also used by hardware acceleration APIs.
* It is called at least once during frame decoding to pass
* the data needed for hardware render.
@ -1006,7 +1116,7 @@ typedef struct AVCodecContext {
* Samples per packet, initialized when calling 'init'.
*/
int frame_size;
int frame_number; ///< audio or video frame number
int frame_number; ///< Number of audio or video frames returned so far
int real_pict_num; ///< Returns the real picture number of previous encoded frame.
/**
@ -1216,6 +1326,8 @@ typedef struct AVCodecContext {
* If pic.reference is set then the frame will be read later by libavcodec.
* avcodec_align_dimensions() should be used to find the required width and
* height, as they normally need to be rounded up to the next multiple of 16.
* May be called by different threads if frame threading is enabled, but not
* by more than one at the same time.
* - encoding: unused
* - decoding: Set by libavcodec., user can override.
*/
@ -1224,7 +1336,9 @@ typedef struct AVCodecContext {
/**
* Called to release buffers which were allocated with get_buffer.
* A released buffer can be reused in get_buffer().
* pic.data[*] must be set to NULL.
* pic.data[*] must be set to NULL. May be called by different threads
* if frame threading is enabled, but not more than one at the same time.
*
* - encoding: unused
* - decoding: Set by libavcodec., user can override.
*/
@ -1456,12 +1570,17 @@ typedef struct AVCodecContext {
/* lower 16 bits - CPU features */
#define FF_MM_MMX 0x0001 ///< standard MMX
#define FF_MM_3DNOW 0x0004 ///< AMD 3DNOW
#if LIBAVCODEC_VERSION_MAJOR < 53
#define FF_MM_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext
#endif
#define FF_MM_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext
#define FF_MM_SSE 0x0008 ///< SSE functions
#define FF_MM_SSE2 0x0010 ///< PIV SSE2 functions
#define FF_MM_3DNOWEXT 0x0020 ///< AMD 3DNowExt
#define FF_MM_SSE3 0x0040 ///< Prescott SSE3 functions
#define FF_MM_SSSE3 0x0080 ///< Conroe SSSE3 functions
#define FF_MM_SSE4 0x0100 ///< Penryn SSE4.1 functions
#define FF_MM_SSE42 0x0200 ///< Nehalem SSE4.2 functions
#define FF_MM_IWMMXT 0x0100 ///< XScale IWMMXT
#define FF_MM_ALTIVEC 0x0001 ///< standard AltiVec
@ -2328,7 +2447,7 @@ typedef struct AVCodecContext {
*/
float rc_min_vbv_overflow_use;
/**
/**
* Hardware accelerator in use
* - encoding: unused.
* - decoding: Set by libavcodec
@ -2355,6 +2474,60 @@ typedef struct AVCodecContext {
* - decoding: Set by user
*/
void *hwaccel_context;
/**
* Chromaticity coordinates of the source primaries.
* - encoding: Set by user
* - decoding: Set by libavcodec
*/
enum AVColorPrimaries color_primaries;
/**
* Color Transfer Characteristic.
* - encoding: Set by user
* - decoding: Set by libavcodec
*/
enum AVColorTransferCharacteristic color_trc;
/**
* YUV colorspace type.
* - encoding: Set by user
* - decoding: Set by libavcodec
*/
enum AVColorSpace colorspace;
/**
* MPEG vs JPEG YUV range.
* - encoding: Set by user
* - decoding: Set by libavcodec
*/
enum AVColorRange color_range;
/**
* Whether this is a copy of the context which had init() called on it.
* This is used by multithreading - shared tables and picture pointers
* should be freed from the original context only.
* - encoding: Set by libavcodec.
* - decoding: Set by libavcodec.
*/
int is_copy;
/**
* Which multithreading methods to use, for codecs that support more than one.
* - encoding: Set by user, otherwise the default is used.
* - decoding: Set by user, otherwise the default is used.
*/
int thread_type;
#define FF_THREAD_FRAME 1 //< Decode more than one frame at once
#define FF_THREAD_SLICE 2 //< Decode more than one part of a single frame at once
#define FF_THREAD_DEFAULT 3 //< Use both if possible.
/**
* Which multithreading methods are actually active at the moment.
* - encoding: Set by libavcodec.
* - decoding: Set by libavcodec.
*/
int active_thread_type;
} AVCodecContext;
/**
@ -2374,8 +2547,7 @@ typedef struct AVCodec {
int (*init)(AVCodecContext *);
int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data);
int (*close)(AVCodecContext *);
int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
const uint8_t *buf, int buf_size);
int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
/**
* Codec capabilities.
* see CODEC_CAP_*
@ -2397,6 +2569,26 @@ typedef struct AVCodec {
const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
const enum SampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
const int64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
/**
* @defgroup framethreading Frame threading support functions.
* @{
*/
/**
* If the codec allocates writable tables in init(), define init_copy() to re-allocate
* them in the copied contexts. Before calling it, priv_data will be set to a copy of
* the original.
*/
int (*init_copy)(AVCodecContext *);
/**
* Copy all necessary context variables from the last thread before starting the next one.
* If the codec doesn't define this, the next thread will start automatically; otherwise,
* the codec must call ff_report_frame_setup_done(). Do not assume anything about the
* contents of priv data except that it has been copied from the original some time after
* codec init. Will not be called if frame threading is disabled.
*/
int (*update_context)(AVCodecContext *, AVCodecContext *from);
/** @} */
} AVCodec;
/**
@ -2574,6 +2766,55 @@ typedef struct AVSubtitle {
AVSubtitleRect **rects;
} AVSubtitle;
/* packet functions */
/**
* @deprecated use NULL instead
*/
attribute_deprecated void av_destruct_packet_nofree(AVPacket *pkt);
/**
* Default packet destructor.
*/
void av_destruct_packet(AVPacket *pkt);
/**
* Initialize optional fields of a packet with default values.
*
* @param pkt packet
*/
void av_init_packet(AVPacket *pkt);
/**
* Allocate the payload of a packet and initialize its fields with
* default values.
*
* @param pkt packet
* @param size wanted payload size
* @return 0 if OK, AVERROR_xxx otherwise
*/
int av_new_packet(AVPacket *pkt, int size);
/**
* Reduce packet size, correctly zeroing padding
*
* @param pkt packet
* @param size new size
*/
void av_shrink_packet(AVPacket *pkt, int size);
/**
* @warning This is a hack - the packet memory allocation stuff is broken. The
* packet is allocated if it was not really allocated.
*/
int av_dup_packet(AVPacket *pkt);
/**
* Free a packet.
*
* @param pkt packet to free
*/
void av_free_packet(AVPacket *pkt);
/* resample.c */
@ -2965,26 +3206,44 @@ int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, v
*/
int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* Decodes an audio frame from \p buf into \p samples.
* The avcodec_decode_audio2() function decodes an audio frame from the input
* buffer \p buf of size \p buf_size. To decode it, it makes use of the
* audio codec which was coupled with \p avctx using avcodec_open(). The
* resulting decoded frame is stored in output buffer \p samples. If no frame
* Wrapper function which calls avcodec_decode_audio3.
*
* @deprecated Use avcodec_decode_audio3 instead.
* @param avctx the codec context
* @param[out] samples the output buffer
* @param[in,out] frame_size_ptr the output buffer size in bytes
* @param[in] buf the input buffer
* @param[in] buf_size the input buffer size in bytes
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
attribute_deprecated int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decodes the audio frame of size avpkt->size from avpkt->data into samples.
* Some decoders may support multiple frames in a single AVPacket, such
* decoders would then just decode the first frame.
* If no frame
* could be decompressed, \p frame_size_ptr is zero. Otherwise, it is the
* decompressed frame size in \e bytes.
*
* @warning You \e must set \p frame_size_ptr to the allocated size of the
* output buffer before calling avcodec_decode_audio2().
* output buffer before calling avcodec_decode_audio3().
*
* @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
* the actual read bytes because some optimized bitstream readers read 32 or 64
* bits at once and could read over the end.
*
* @warning The end of the input buffer \p buf should be set to 0 to ensure that
* @warning The end of the input buffer \p avpkt->data should be set to 0 to ensure that
* no overreading happens for damaged MPEG streams.
*
* @note You might have to align the input buffer \p buf and output buffer \p
* @note You might have to align the input buffer \p avpkt->data and output buffer \p
* samples. The alignment requirements depend on the CPU: On some CPUs it isn't
* necessary at all, on others it won't work at all if not aligned and on others
* it will work but it will have an impact on performance. In practice, the
@ -2996,21 +3255,37 @@ int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
* @param avctx the codec context
* @param[out] samples the output buffer
* @param[in,out] frame_size_ptr the output buffer size in bytes
* @param[in] buf the input buffer
* @param[in] buf_size the input buffer size in bytes
* @param[in] avpkt The input AVPacket containing the input buffer.
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
const uint8_t *buf, int buf_size);
AVPacket *avpkt);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* Decodes a video frame from \p buf into \p picture.
* The avcodec_decode_video() function decodes a video frame from the input
* buffer \p buf of size \p buf_size. To decode it, it makes use of the
* video codec which was coupled with \p avctx using avcodec_open(). The
* resulting decoded frame is stored in \p picture.
* Wrapper function which calls avcodec_decode_video2.
*
* @deprecated Use avcodec_decode_video2 instead.
* @param avctx the codec context
* @param[out] picture The AVFrame in which the decoded video frame will be stored.
* @param[in] buf the input buffer
* @param[in] buf_size the size of the input buffer in bytes
* @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
attribute_deprecated int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decodes the video frame of size avpkt->size from avpkt->data into picture.
* Some decoders may support multiple frames in a single AVPacket, such
* decoders would then just decode the first frame.
*
* @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
* the actual read bytes because some optimized bitstream readers read 32 or 64
@ -3019,7 +3294,7 @@ int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
* @warning The end of the input buffer \p buf should be set to 0 to ensure that
* no overreading happens for damaged MPEG streams.
*
* @note You might have to align the input buffer \p buf and output buffer \p
* @note You might have to align the input buffer \p avpkt->data and output buffer \p
* samples. The alignment requirements depend on the CPU: on some CPUs it isn't
* necessary at all, on others it won't work at all if not aligned and on others
* it will work but it will have an impact on performance. In practice, the
@ -3029,38 +3304,53 @@ int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
* start of the buffer to 16.
*
* @note Some codecs have a delay between input and output, these need to be
* feeded with buf=NULL, buf_size=0 at the end to return the remaining frames.
* feeded with avpkt->data=NULL, avpkt->size=0 at the end to return the remaining frames.
*
* @param avctx the codec context
* @param[out] picture The AVFrame in which the decoded video frame will be stored.
* @param[in] buf the input buffer
* @param[in] buf_size the size of the input buffer in bytes
* @param[in] avpkt The input AVpacket containing the input buffer.
* @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const uint8_t *buf, int buf_size);
AVPacket *avpkt);
#if LIBAVCODEC_VERSION_MAJOR < 53
/* Decode a subtitle message. Return -1 if error, otherwise return the
* number of bytes used. If no subtitle could be decompressed,
* got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. */
int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
attribute_deprecated int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decodes a subtitle message.
* Returns a negative value on error, otherwise returns the number of bytes used.
* If no subtitle could be decompressed, \p got_sub_ptr is zero.
* Otherwise, the subtitle is stored in \p *sub.
*
* @param avctx the codec context
* @param[out] sub The AVSubtitle in which the decoded subtitle will be stored.
* @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
* @param[in] avpkt The input AVPacket containing the input buffer.
*/
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
AVPacket *avpkt);
int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata,
int *data_size_ptr,
uint8_t *buf, int buf_size);
/**
* Encodes an audio frame from \p samples into \p buf.
* The avcodec_encode_audio() function encodes an audio frame from the input
* buffer \p samples. To encode it, it makes use of the audio codec which was
* coupled with \p avctx using avcodec_open(). The resulting encoded frame is
* stored in output buffer \p buf.
*
* @note The output buffer should be at least \c FF_MIN_BUFFER_SIZE bytes large.
* However, for PCM audio the user will know how much space is needed
* because it depends on the value passed in \p buf_size as described
* below. In that case a lower value can be used.
*
* @param avctx the codec context
* @param[out] buf the output buffer
@ -3078,10 +3368,7 @@ int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
/**
* Encodes a video frame from \p pict into \p buf.
* The avcodec_encode_video() function encodes a video frame from the input
* \p pict. To encode it, it makes use of the video codec which was coupled with
* \p avctx using avcodec_open(). The resulting encoded bytes representing the
* frame are stored in the output buffer \p buf. The input picture should be
* The input picture should be
* stored using a specific format, namely \c avctx.pix_fmt.
*
* @param avctx the codec context
@ -3375,6 +3662,20 @@ AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f);
*/
void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size);
/**
* Allocates a buffer, reusing the given one if large enough.
*
* Contrary to av_fast_realloc the current buffer contents might not be
* preserved and on error the old buffer is freed, thus no special
* handling to avoid memleaks is necessary.
*
* @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer
* @param size size of the buffer *ptr points to
* @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
* *size 0 if an error occurred.
*/
void av_fast_malloc(void *ptr, unsigned int *size, unsigned int min_size);
/**
* Copy image 'src' to 'dst'.
*/

@ -1,46 +0,0 @@
/*
* 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 AVDEVICE_AVDEVICE_H
#define AVDEVICE_AVDEVICE_H
#define LIBAVDEVICE_VERSION_MAJOR 52
#define LIBAVDEVICE_VERSION_MINOR 1
#define LIBAVDEVICE_VERSION_MICRO 0
#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
LIBAVDEVICE_VERSION_MINOR, \
LIBAVDEVICE_VERSION_MICRO)
#define LIBAVDEVICE_VERSION AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \
LIBAVDEVICE_VERSION_MINOR, \
LIBAVDEVICE_VERSION_MICRO)
#define LIBAVDEVICE_BUILD LIBAVDEVICE_VERSION_INT
/**
* Returns the LIBAVDEVICE_VERSION_INT constant.
*/
unsigned avdevice_version(void);
/**
* Initialize libavdevice and register all the input and output devices.
* @warning This function is not thread safe.
*/
void avdevice_register_all(void);
#endif /* AVDEVICE_AVDEVICE_H */

@ -63,7 +63,7 @@ struct AVFormatContext;
* want to store, e.g., the email address of the child of producer Alice
* and actor Bob, that could have key=alice_and_bobs_childs_email_address.
* 3. A tag whose value is localized for a particular language is appended
* with a dash character ('-') and the ISO 639 3-letter language code.
* with a dash character ('-') and the ISO 639-2/B 3-letter language code.
* For example: Author-ger=Michael, Author-eng=Mike
* The original/default language is in the unqualified "Author" tag.
* A demuxer should set a default if it sets any translated tag.
@ -114,78 +114,6 @@ void av_metadata_free(AVMetadata **m);
/* packet functions */
typedef struct AVPacket {
/**
* Presentation timestamp in time_base units; the time at which the
* decompressed packet will be presented to the user.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
* pts MUST be larger or equal to dts as presentation cannot happen before
* decompression, unless one wants to view hex dumps. Some formats misuse
* the terms dts and pts/cts to mean something different. Such timestamps
* must be converted to true pts/dts before they are stored in AVPacket.
*/
int64_t pts;
/**
* Decompression timestamp in time_base units; the time at which the
* packet is decompressed.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
*/
int64_t dts;
uint8_t *data;
int size;
int stream_index;
int flags;
/**
* Duration of this packet in time_base units, 0 if unknown.
* Equals next_pts - this_pts in presentation order.
*/
int duration;
void (*destruct)(struct AVPacket *);
void *priv;
int64_t pos; ///< byte position in stream, -1 if unknown
/**
* Time difference in stream time base units from the pts of this
* packet to the point at which the output from the decoder has converged
* independent from the availability of previous frames. That is, the
* frames are virtually identical no matter if decoding started from
* the very first frame or from this keyframe.
* Is AV_NOPTS_VALUE if unknown.
* This field is not the display duration of the current packet.
*
* The purpose of this field is to allow seeking in streams that have no
* keyframes in the conventional sense. It corresponds to the
* recovery point SEI in H.264 and match_time_delta in NUT. It is also
* essential for some types of subtitle streams to ensure that all
* subtitles are correctly displayed after seeking.
*/
int64_t convergence_duration;
} AVPacket;
#define PKT_FLAG_KEY 0x0001
void av_destruct_packet_nofree(AVPacket *pkt);
/**
* Default packet destructor.
*/
void av_destruct_packet(AVPacket *pkt);
/**
* Initialize optional fields of a packet with default values.
*
* @param pkt packet
*/
void av_init_packet(AVPacket *pkt);
/**
* Allocate the payload of a packet and initialize its fields with
* default values.
*
* @param pkt packet
* @param size wanted payload size
* @return 0 if OK, AVERROR_xxx otherwise
*/
int av_new_packet(AVPacket *pkt, int size);
/**
* Allocate and read the payload of a packet and initialize its fields with
@ -197,23 +125,6 @@ int av_new_packet(AVPacket *pkt, int size);
*/
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size);
/**
* @warning This is a hack - the packet memory allocation stuff is broken. The
* packet is allocated if it was not really allocated.
*/
int av_dup_packet(AVPacket *pkt);
/**
* Free a packet.
*
* @param pkt packet to free
*/
static inline void av_free_packet(AVPacket *pkt)
{
if (pkt && pkt->destruct) {
pkt->destruct(pkt);
}
}
/*************************************************/
/* fractional numbers for exact pts handling */
@ -338,7 +249,10 @@ typedef struct AVInputFormat {
AVFormatParameters *ap);
/** Read one packet and put it in 'pkt'. pts and flags are also
set. 'av_new_stream' can be called only if the flag
AVFMTCTX_NOHEADER is used. */
AVFMTCTX_NOHEADER is used.
@return 0 on success, < 0 on error.
When returning an error, pkt must not have been allocated
or must be freed before returning */
int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
/** Close the stream. The AVFormatContext and AVStreams are not
freed by this function */
@ -476,7 +390,7 @@ typedef struct AVStream {
int64_t duration;
#if LIBAVFORMAT_VERSION_INT < (53<<16)
char language[4]; /** ISO 639 3-letter language code (empty string if undefined) */
char language[4]; /** ISO 639-2/B 3-letter language code (empty string if undefined) */
#endif
/* av_read_frame() support */

@ -35,7 +35,7 @@
#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
#define LIBAVUTIL_VERSION_MAJOR 50
#define LIBAVUTIL_VERSION_MINOR 2
#define LIBAVUTIL_VERSION_MINOR 3
#define LIBAVUTIL_VERSION_MICRO 0
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

@ -61,6 +61,14 @@ void av_fifo_reset(AVFifoBuffer *f);
*/
int av_fifo_size(AVFifoBuffer *f);
/**
* Returns the amount of space in bytes in the AVFifoBuffer, that is the
* amount of data you can write into it.
* @param *f AVFifoBuffer to write into
* @return size
*/
int av_fifo_space(AVFifoBuffer *f);
/**
* Feeds data from an AVFifoBuffer to a user-supplied callback.
* @param *f AVFifoBuffer to read from

@ -116,6 +116,13 @@ enum PixelFormat {
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
PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
PIX_FMT_YUV420PLE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
PIX_FMT_YUV420PBE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
PIX_FMT_YUV422PLE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
PIX_FMT_YUV422PBE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
PIX_FMT_YUV444PLE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
PIX_FMT_YUV444PBE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
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
};
@ -137,4 +144,8 @@ enum PixelFormat {
#define PIX_FMT_BGR565 PIX_FMT_NE(BGR565BE, BGR565LE)
#define PIX_FMT_BGR555 PIX_FMT_NE(BGR555BE, BGR555LE)
#define PIX_FMT_YUV420P16 PIX_FMT_NE(YUV420PBE, YUV420PLE)
#define PIX_FMT_YUV422P16 PIX_FMT_NE(YUV422PBE, YUV422PLE)
#define PIX_FMT_YUV444P16 PIX_FMT_NE(YUV444PBE, YUV444PLE)
#endif /* AVUTIL_PIXFMT_H */