From f2a2f7188b33a724eeb28bfadc7424da3341ff5d Mon Sep 17 00:00:00 2001 From: "mr. m" <91018726+mr-cheffy@users.noreply.github.com> Date: Mon, 10 Aug 2026 13:50:24 +0200 Subject: [PATCH] gh-14889: Add support for ffmpeg 63 (gh-14907) --- scripts/update_external_patches.py | 2 +- .../bug-2057577-ffmpeg-63-support.patch | 10727 ++++++++++++++++ src/external-patches/manifest.json | 6 + 3 files changed, 10734 insertions(+), 1 deletion(-) create mode 100644 src/external-patches/firefox/bug-2057577-ffmpeg-63-support.patch diff --git a/scripts/update_external_patches.py b/scripts/update_external_patches.py index 341cb77f7..bb7a26626 100644 --- a/scripts/update_external_patches.py +++ b/scripts/update_external_patches.py @@ -83,7 +83,7 @@ def main(): dest = patch.get("dest") if not url or not dest: die(f"Patch entry missing 'url' or 'dest': {patch}") - filename = url.split("/")[-1] + filename = patch.get("filename", url.split("/")[-1]) output_file = os.path.join(OUTPUT_DIR, dest, filename) download_patch_from_url(url, output_file) replaces = patch.get("replaces", {}) diff --git a/src/external-patches/firefox/bug-2057577-ffmpeg-63-support.patch b/src/external-patches/firefox/bug-2057577-ffmpeg-63-support.patch new file mode 100644 index 000000000..d6a4b35d8 --- /dev/null +++ b/src/external-patches/firefox/bug-2057577-ffmpeg-63-support.patch @@ -0,0 +1,10727 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tymur Boiko +Date: Thu, 30 Jul 2026 11:21:21 +0000 +Subject: [PATCH] Bug 2057577 - DOM Media - Add FFmpeg 63 support. + r=alwu,frontend-codestyle-reviewers,Standard8 + +Raise FFMPEG_MAX_MAJOR_VERSION to 63 and add the ffmpeg63 header tree +so system/custom libavcodec.so.63 can be loaded. Keep libavcodec.so.62 +in the runtime linker search list after the max bump. Adapt to FFmpeg +63 API removals: query sample rates via avcodec_get_supported_config, +and pick the Vulkan transfer queue from AVVulkanDeviceContext::qf. + +Differential Revision: https://phabricator.services.mozilla.com/D314026 +--- + .clang-format-ignore | 1 + + .prettierignore | 1 + + .../platforms/ffmpeg/FFmpegAudioEncoder.cpp | 18 +- + .../platforms/ffmpeg/FFmpegLibWrapper.cpp | 154 +- + dom/media/platforms/ffmpeg/FFmpegLibWrapper.h | 7 +- + .../platforms/ffmpeg/FFmpegRuntimeLinker.cpp | 12 + + .../platforms/ffmpeg/FFmpegVideoDecoder.cpp | 19 +- + .../include/COPYING.LGPLv2.1 | 0 + .../ffmpeg63/include/libavcodec/avcodec.h | 2961 +++++++++++++++++ + .../ffmpeg63/include/libavcodec/avdct.h | 91 + + .../ffmpeg/ffmpeg63/include/libavcodec/bsf.h | 708 ++++ + .../ffmpeg63/include/libavcodec/codec.h | 345 ++ + .../include/libavcodec/codec_desc.h | 0 + .../ffmpeg63/include/libavcodec/codec_id.h | 687 ++++ + .../ffmpeg63/include/libavcodec/codec_par.h | 302 ++ + .../include/libavcodec/defs.h | 0 + .../ffmpeg63/include/libavcodec/packet.h | 950 ++++++ + .../include/libavcodec/vdpau.h | 0 + .../ffmpeg63/include/libavcodec/version.h | 45 + + .../include/libavcodec/version_major.h | 45 + + .../ffmpeg63/include/libavutil/attributes.h | 235 ++ + .../include/libavutil/avconfig.h | 0 + .../ffmpeg63/include/libavutil/avutil.h | 340 ++ + .../include/libavutil/buffer.h | 0 + .../include/libavutil/channel_layout.h | 0 + .../ffmpeg63/include/libavutil/common.h | 578 ++++ + .../ffmpeg/ffmpeg63/include/libavutil/cpu.h | 152 + + .../include/libavutil/dict.h | 0 + .../include/libavutil/error.h | 0 + .../ffmpeg/ffmpeg63/include/libavutil/frame.h | 1221 +++++++ + .../include/libavutil/hwcontext.h | 0 + .../include/libavutil/hwcontext_drm.h | 0 + .../include/libavutil/hwcontext_vaapi.h | 0 + .../include/libavutil/hwcontext_vulkan.h | 355 ++ + .../include/libavutil/intfloat.h | 0 + .../include/libavutil/log.h | 0 + .../include/libavutil/macros.h | 0 + .../include/libavutil/mathematics.h | 0 + .../include/libavutil/mem.h | 0 + .../ffmpeg63/include/libavutil/pixfmt.h | 823 +++++ + .../include/libavutil/rational.h | 0 + .../include/libavutil/samplefmt.h | 0 + .../ffmpeg63/include/libavutil/version.h | 118 + + .../ffmpeg/{ffmpeg61 => ffmpeg63}/moz.build | 0 + dom/media/platforms/ffmpeg/moz.build | 1 + + tools/rewriting/ThirdPartyPaths.txt | 1 + + 46 files changed, 10093 insertions(+), 77 deletions(-) + copy dom/media/platforms/ffmpeg/{ffmpeg57 => ffmpeg63}/include/COPYING.LGPLv2.1 (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avcodec.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avdct.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/bsf.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavcodec/codec_desc.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_id.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_par.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavcodec/defs.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/packet.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavcodec/vdpau.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version_major.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/attributes.h + copy dom/media/platforms/ffmpeg/{ffmpeg58 => ffmpeg63}/include/libavutil/avconfig.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avutil.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/buffer.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/channel_layout.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/common.h + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/cpu.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/dict.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/error.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/frame.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/hwcontext.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg58 => ffmpeg63}/include/libavutil/hwcontext_drm.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/hwcontext_vaapi.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vulkan.h + copy dom/media/platforms/ffmpeg/{ffmpeg57 => ffmpeg63}/include/libavutil/intfloat.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/log.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/macros.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/mathematics.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/mem.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/pixfmt.h + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/rational.h (100%) + copy dom/media/platforms/ffmpeg/{ffmpeg62 => ffmpeg63}/include/libavutil/samplefmt.h (100%) + create mode 100644 dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/version.h + copy dom/media/platforms/ffmpeg/{ffmpeg61 => ffmpeg63}/moz.build (100%) + +diff --git a/.clang-format-ignore b/.clang-format-ignore +index b1709cdc0a9a..255e0c27f7c6 100644 +--- a/.clang-format-ignore ++++ b/.clang-format-ignore +@@ -83,6 +83,7 @@ dom/media/platforms/ffmpeg/ffmpeg59/.* + dom/media/platforms/ffmpeg/ffmpeg60/.* + dom/media/platforms/ffmpeg/ffmpeg61/.* + dom/media/platforms/ffmpeg/ffmpeg62/.* ++dom/media/platforms/ffmpeg/ffmpeg63/.* + dom/media/platforms/ffmpeg/libav53/.* + dom/media/platforms/ffmpeg/libav54/.* + dom/media/platforms/ffmpeg/libav55/.* +diff --git a/.prettierignore b/.prettierignore +index fbfad276db19..63bcd4afa0dc 100644 +--- a/.prettierignore ++++ b/.prettierignore +@@ -1382,6 +1382,7 @@ dom/media/platforms/ffmpeg/ffmpeg59/ + dom/media/platforms/ffmpeg/ffmpeg60/ + dom/media/platforms/ffmpeg/ffmpeg61/ + dom/media/platforms/ffmpeg/ffmpeg62/ ++dom/media/platforms/ffmpeg/ffmpeg63/ + dom/media/platforms/ffmpeg/libav53/ + dom/media/platforms/ffmpeg/libav54/ + dom/media/platforms/ffmpeg/libav55/ +diff --git a/dom/media/platforms/ffmpeg/FFmpegAudioEncoder.cpp b/dom/media/platforms/ffmpeg/FFmpegAudioEncoder.cpp +index 2259aa6f03e1..1f1d0ab65fb1 100644 +--- a/dom/media/platforms/ffmpeg/FFmpegAudioEncoder.cpp ++++ b/dom/media/platforms/ffmpeg/FFmpegAudioEncoder.cpp +@@ -69,15 +69,29 @@ MediaResult FFmpegAudioEncoder::InitEncoder() { + // Find a compatible input rate for the codec, update the encoder config, and + // note the rate at which this instance was configured. + mInputSampleRate = AssertedCast(mConfig.mSampleRate); +- if (codec->supported_samplerates) { ++ const int* supportedSampleRatesList = nullptr; ++#if LIBAVCODEC_VERSION_MAJOR >= 63 ++ // FFmpeg 63 replaced AVCodec::supported_samplerates with this query API. ++ if (mLib->avcodec_get_supported_config) { ++ const void* configs = nullptr; ++ if (mLib->avcodec_get_supported_config(mCodecContext, codec, ++ AV_CODEC_CONFIG_SAMPLE_RATE, 0, ++ &configs, nullptr) >= 0) { ++ supportedSampleRatesList = static_cast(configs); ++ } ++ } ++#else ++ supportedSampleRatesList = codec->supported_samplerates; ++#endif ++ if (supportedSampleRatesList) { + // Ensure the sample-rate list is sorted, iterate and either find that the + // sample rate is supported, or pick the same rate just above the audio + // input sample-rate (as to not lose information). If the audio is higher + // than the highest supported sample-rate, down-sample to the highest + // sample-rate supported by the codec. This is the case when encoding high + // samplerate audio to opus. + AutoTArray supportedSampleRates; +- IterateZeroTerminated(codec->supported_samplerates, ++ IterateZeroTerminated(supportedSampleRatesList, + [&supportedSampleRates](int aRate) mutable { + supportedSampleRates.AppendElement(aRate); + }); +diff --git a/dom/media/platforms/ffmpeg/FFmpegLibWrapper.cpp b/dom/media/platforms/ffmpeg/FFmpegLibWrapper.cpp +index 0534f73428ce..2da74f671fd4 100644 +--- a/dom/media/platforms/ffmpeg/FFmpegLibWrapper.cpp ++++ b/dom/media/platforms/ffmpeg/FFmpegLibWrapper.cpp +@@ -81,19 +81,21 @@ FFmpegLibWrapper::LinkResult FFmpegLibWrapper::Link() { + AV_FUNC_60 = 1 << 7, + AV_FUNC_61 = 1 << 8, + AV_FUNC_62 = 1 << 9, ++ AV_FUNC_63 = 1 << 10, + AV_FUNC_AVUTIL_53 = AV_FUNC_53 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_54 = AV_FUNC_54 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_55 = AV_FUNC_55 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_56 = AV_FUNC_56 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_57 = AV_FUNC_57 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_58 = AV_FUNC_58 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_59 = AV_FUNC_59 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_60 = AV_FUNC_60 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_61 = AV_FUNC_61 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVUTIL_62 = AV_FUNC_62 | AV_FUNC_AVUTIL_MASK, ++ AV_FUNC_AVUTIL_63 = AV_FUNC_63 | AV_FUNC_AVUTIL_MASK, + AV_FUNC_AVCODEC_ALL = AV_FUNC_53 | AV_FUNC_54 | AV_FUNC_55 | AV_FUNC_56 | + AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62, ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63, + AV_FUNC_AVUTIL_ALL = AV_FUNC_AVCODEC_ALL | AV_FUNC_AVUTIL_MASK + }; + // AV_FUNC_N = 1 << (N - 53), so these two checks enforce that +@@ -138,6 +140,9 @@ FFmpegLibWrapper::LinkResult FFmpegLibWrapper::Link() { + case 62: + version = AV_FUNC_62; + break; ++ case 63: ++ version = AV_FUNC_63; ++ break; + default: + FFMPEGV_LOG("Unknown avcodec version: {}", macro); + Unlink(); +@@ -187,177 +192,186 @@ FFmpegLibWrapper::LinkResult FFmpegLibWrapper::Link() { + AV_FUNC(avcodec_decode_video2, AV_FUNC_53 | AV_FUNC_54 | AV_FUNC_55 | + AV_FUNC_56 | AV_FUNC_57 | AV_FUNC_58) + AV_FUNC(avcodec_find_decoder, AV_FUNC_AVCODEC_ALL) +- AV_FUNC(avcodec_find_decoder_by_name, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC(avcodec_find_decoder_by_name, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | ++ AV_FUNC_63) + AV_FUNC(avcodec_find_encoder, AV_FUNC_AVCODEC_ALL) +- AV_FUNC(avcodec_find_encoder_by_name, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC(avcodec_find_encoder_by_name, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | ++ AV_FUNC_63) + AV_FUNC(avcodec_flush_buffers, AV_FUNC_AVCODEC_ALL) + AV_FUNC(avcodec_open2, AV_FUNC_AVCODEC_ALL) + AV_FUNC(avcodec_register_all, AV_FUNC_53 | AV_FUNC_54 | AV_FUNC_55 | + AV_FUNC_56 | AV_FUNC_57 | AV_FUNC_58) + AV_FUNC(av_init_packet, (AV_FUNC_55 | AV_FUNC_56 | AV_FUNC_57 | AV_FUNC_58 | + AV_FUNC_59 | AV_FUNC_60)) + AV_FUNC(av_parser_init, AV_FUNC_AVCODEC_ALL) + AV_FUNC(av_parser_close, AV_FUNC_AVCODEC_ALL) + AV_FUNC(av_parser_parse2, AV_FUNC_AVCODEC_ALL) + AV_FUNC(avcodec_align_dimensions, AV_FUNC_AVCODEC_ALL) + AV_FUNC(avcodec_alloc_frame, (AV_FUNC_53 | AV_FUNC_54)) + AV_FUNC(avcodec_get_frame_defaults, (AV_FUNC_53 | AV_FUNC_54)) + AV_FUNC(avcodec_free_frame, AV_FUNC_54) +- AV_FUNC(avcodec_send_packet, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC(avcodec_receive_packet, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC(avcodec_send_frame, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC(avcodec_receive_frame, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC(avcodec_send_packet, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC(avcodec_receive_packet, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC(avcodec_send_frame, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC(avcodec_receive_frame, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63) + AV_FUNC(avcodec_default_get_buffer2, + (AV_FUNC_55 | AV_FUNC_56 | AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | +- AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62)) ++ AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63)) + AV_FUNC(av_packet_alloc, (AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62)) ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63)) + AV_FUNC(av_packet_unref, (AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62)) ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63)) + AV_FUNC(av_packet_free, (AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62)) ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63)) + AV_FUNC(avcodec_descriptor_get, AV_FUNC_AVCODEC_ALL) + AV_FUNC(av_log_set_callback, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_log_set_level, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_malloc, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_mallocz, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_freep, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_frame_alloc, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_frame_clone, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_frame_free, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_frame_unref, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_frame_get_buffer, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_frame_make_writable, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_image_check_size, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_image_get_buffer_size, AV_FUNC_AVUTIL_ALL) + AV_FUNC_OPTION(av_channel_layout_default, +- AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | ++ AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION(av_channel_layout_from_mask, +- AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62) +- AV_FUNC_OPTION(av_channel_layout_copy, +- AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | ++ AV_FUNC_AVUTIL_63) ++ AV_FUNC_OPTION(av_channel_layout_copy, AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | ++ AV_FUNC_AVUTIL_62 | ++ AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION(av_buffer_get_opaque, + (AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | AV_FUNC_AVUTIL_58 | + AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62)) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63)) + AV_FUNC(av_buffer_create, + (AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_61 | AV_FUNC_62)) ++ AV_FUNC_61 | AV_FUNC_62 | AV_FUNC_63)) + AV_FUNC_OPTION(av_frame_get_colorspace, + AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58) + AV_FUNC_OPTION(av_frame_get_color_range, + AV_FUNC_AVUTIL_55 | AV_FUNC_AVUTIL_56 | AV_FUNC_AVUTIL_57 | + AV_FUNC_AVUTIL_58) + AV_FUNC(av_strerror, AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC(av_get_sample_fmt_name, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_dict_set, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_dict_free, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_opt_set, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_opt_set_double, AV_FUNC_AVUTIL_ALL) + AV_FUNC(av_opt_set_int, AV_FUNC_AVUTIL_ALL) + AV_FUNC(avcodec_free_context, AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | +- AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62 | ++ AV_FUNC_63) + AV_FUNC_OPTION_SILENT(avcodec_get_hw_config, AV_FUNC_58 | AV_FUNC_59 | + AV_FUNC_60 | AV_FUNC_61 | +- AV_FUNC_62) ++ AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC_OPTION_SILENT(avcodec_get_supported_config, AV_FUNC_62 | AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_codec_is_decoder, AV_FUNC_58 | AV_FUNC_59 | + AV_FUNC_60 | AV_FUNC_61 | +- AV_FUNC_62) ++ AV_FUNC_62 | AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_codec_is_encoder, AV_FUNC_58 | AV_FUNC_59 | + AV_FUNC_60 | AV_FUNC_61 | +- AV_FUNC_62) ++ AV_FUNC_62 | AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_codec_iterate, AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC_61 | AV_FUNC_62 | ++ AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_hwdevice_ctx_init, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT(av_hwdevice_ctx_create, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT(av_hwdevice_ctx_alloc, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT( + av_buffer_ref, AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62) +- AV_FUNC_OPTION_SILENT(av_buffer_unref, AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | +- AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_61 | AV_FUNC_AVUTIL_62 | ++ AV_FUNC_AVUTIL_63) ++ AV_FUNC_OPTION_SILENT(av_buffer_unref, ++ AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | ++ AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT(av_hwframe_ctx_alloc, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT(av_hwframe_ctx_init, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) +- AV_FUNC_OPTION_SILENT(av_hwframe_map, AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | +- AV_FUNC_AVUTIL_60 | +- AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) +- AV_FUNC_OPTION_SILENT( +- avcodec_get_hw_frames_parameters, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) ++ AV_FUNC_OPTION_SILENT(av_hwframe_map, ++ AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | ++ AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) ++ AV_FUNC_OPTION_SILENT(avcodec_get_hw_frames_parameters, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) + + #ifdef MOZ_WIDGET_GTK +- AV_FUNC_OPTION_SILENT(av_hwdevice_hwconfig_alloc, AV_FUNC_58 | AV_FUNC_59 | +- AV_FUNC_60 | +- AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC_OPTION_SILENT( +- av_hwdevice_get_hwframe_constraints, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC_OPTION_SILENT( +- av_hwframe_constraints_free, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC_OPTION_SILENT( +- av_hwframe_transfer_get_formats, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) +- AV_FUNC_OPTION_SILENT( +- av_hwdevice_ctx_create_derived, +- AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | AV_FUNC_62) ++ AV_FUNC_OPTION_SILENT(av_hwdevice_hwconfig_alloc, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC_OPTION_SILENT(av_hwdevice_get_hwframe_constraints, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC_OPTION_SILENT(av_hwframe_constraints_free, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC_OPTION_SILENT(av_hwframe_transfer_get_formats, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) ++ AV_FUNC_OPTION_SILENT(av_hwdevice_ctx_create_derived, ++ AV_FUNC_58 | AV_FUNC_59 | AV_FUNC_60 | AV_FUNC_61 | ++ AV_FUNC_62 | AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_hwdevice_get_type_name, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + AV_FUNC_OPTION_SILENT(avcodec_get_name, AV_FUNC_57 | AV_FUNC_58 | AV_FUNC_59 | + AV_FUNC_60 | AV_FUNC_61 | +- AV_FUNC_62) ++ AV_FUNC_62 | AV_FUNC_63) + AV_FUNC_OPTION_SILENT(av_get_pix_fmt_string, + AV_FUNC_AVUTIL_58 | AV_FUNC_AVUTIL_59 | + AV_FUNC_AVUTIL_60 | AV_FUNC_AVUTIL_61 | +- AV_FUNC_AVUTIL_62) ++ AV_FUNC_AVUTIL_62 | AV_FUNC_AVUTIL_63) + #endif + + AV_FUNC_OPTION(av_tx_init, AV_FUNC_AVUTIL_ALL) +diff --git a/dom/media/platforms/ffmpeg/FFmpegLibWrapper.h b/dom/media/platforms/ffmpeg/FFmpegLibWrapper.h +index e2579c0fdaac..2e16beb6834b 100644 +--- a/dom/media/platforms/ffmpeg/FFmpegLibWrapper.h ++++ b/dom/media/platforms/ffmpeg/FFmpegLibWrapper.h +@@ -9,7 +9,7 @@ + // FFmpeg release, the AV_FUNC_NN bindings, case NN dispatch, and the ffmpegNN/ + // subdirectory in FFmpegLibWrapper.cpp / FFmpegRuntimeLinker.cpp must all be + // updated. Static asserts in FFmpegLibWrapper::Link() enforce consistency. +-#define FFMPEG_MAX_MAJOR_VERSION 62 ++#define FFMPEG_MAX_MAJOR_VERSION 63 + #define FFMPEG_MAX_MAJOR_VERSION_STR_HELPER(x) #x + #define FFMPEG_MAX_MAJOR_VERSION_STR(x) FFMPEG_MAX_MAJOR_VERSION_STR_HELPER(x) + +@@ -183,6 +183,11 @@ struct MOZ_ONLY_USED_TO_AVOID_STATIC_CONSTRUCTORS FFmpegLibWrapper { + // libavcodec > 58 + const AVCodecHWConfig* (*avcodec_get_hw_config)(const AVCodec* codec, + int index); ++ // libavcodec >= 62 ++ int (*avcodec_get_supported_config)(const AVCodecContext* avctx, ++ const AVCodec* codec, int config, ++ unsigned flags, const void** out_configs, ++ int* out_num_configs); + // libavutil >= 58 + AVBufferRef* (*av_hwdevice_ctx_alloc)(int); + int (*av_hwdevice_ctx_init)(AVBufferRef* ref); +diff --git a/dom/media/platforms/ffmpeg/FFmpegRuntimeLinker.cpp b/dom/media/platforms/ffmpeg/FFmpegRuntimeLinker.cpp +index e7f20e588588..99bdd1e4e185 100644 +--- a/dom/media/platforms/ffmpeg/FFmpegRuntimeLinker.cpp ++++ b/dom/media/platforms/ffmpeg/FFmpegRuntimeLinker.cpp +@@ -37,20 +37,22 @@ static const char* sLibs[] = { + // clang-format off + #if defined(XP_DARWIN) + "libavcodec." FFMPEG_MAX_MAJOR_VERSION_STR(FFMPEG_MAX_MAJOR_VERSION) ".dylib", ++ "libavcodec.62.dylib", + "libavcodec.61.dylib", + "libavcodec.60.dylib", + "libavcodec.59.dylib", + "libavcodec.58.dylib", + "libavcodec.57.dylib", + "libavcodec.56.dylib", + "libavcodec.55.dylib", + "libavcodec.54.dylib", + "libavcodec.53.dylib", + #elif defined(XP_OPENBSD) + "libavcodec.so", // OpenBSD port controls the major/minor library version + // of ffmpeg and update it regulary on ABI/API changes + #else + "libavcodec.so." FFMPEG_MAX_MAJOR_VERSION_STR(FFMPEG_MAX_MAJOR_VERSION), ++ "libavcodec.so.62", + "libavcodec.so.61", + "libavcodec.so.60", + "libavcodec.so.59", +@@ -135,6 +137,10 @@ bool FFmpegRuntimeLinker::Init() { + FFmpegDecoderModule<62>::Init(&sLibAV); + FFmpegEncoderModule<62>::Init(&sLibAV); + break; ++ case 63: ++ FFmpegDecoderModule<63>::Init(&sLibAV); ++ FFmpegEncoderModule<63>::Init(&sLibAV); ++ break; + } + return true; + case FFmpegLibWrapper::LinkResult::NoProvidedLib: +@@ -228,6 +234,9 @@ already_AddRefed FFmpegRuntimeLinker::CreateDecoder() { + case 62: + module = FFmpegDecoderModule<62>::Create(&sLibAV); + break; ++ case 63: ++ module = FFmpegDecoderModule<63>::Create(&sLibAV); ++ break; + default: + module = nullptr; + } +@@ -269,6 +278,9 @@ already_AddRefed FFmpegRuntimeLinker::CreateEncoder() { + case 62: + module = FFmpegEncoderModule<62>::Create(&sLibAV); + break; ++ case 63: ++ module = FFmpegEncoderModule<63>::Create(&sLibAV); ++ break; + default: + module = nullptr; + } +diff --git a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp +index 0d4578030e43..325c1e2149fb 100644 +--- a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp ++++ b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp +@@ -2220,10 +2220,21 @@ MediaResult FFmpegVideoDecoder::CreateImageVulkan( + + auto* devCtx = (AVHWDeviceContext*)mVulkanDeviceContext->data; + auto* vkDevCtx = (AVVulkanDeviceContext*)devCtx->hwctx; +- if (!mVulkanDecoder.InitCtx( +- vkDevCtx->act_dev, vkDevCtx->phys_dev, vkDevCtx->get_proc_addr, +- vkDevCtx->inst, +- (uint32_t)std::max(vkDevCtx->queue_family_tx_index, 0))) { ++ uint32_t txQueueFamily = 0; ++# if LIBAVCODEC_VERSION_MAJOR >= 63 ++ // FFmpeg 63 replaced queue_family_tx_index with the qf array. ++ for (int i = 0; i < vkDevCtx->nb_qf; i++) { ++ if (vkDevCtx->qf[i].flags & VK_QUEUE_TRANSFER_BIT) { ++ txQueueFamily = (uint32_t)std::max(vkDevCtx->qf[i].idx, 0); ++ break; ++ } ++ } ++# else ++ txQueueFamily = (uint32_t)std::max(vkDevCtx->queue_family_tx_index, 0); ++# endif ++ if (!mVulkanDecoder.InitCtx(vkDevCtx->act_dev, vkDevCtx->phys_dev, ++ vkDevCtx->get_proc_addr, vkDevCtx->inst, ++ txQueueFamily)) { + return MediaResult( + NS_ERROR_DOM_MEDIA_FATAL_ERR, + RESULT_DETAIL("Failed to init Vulkan Context structure")); +diff --git a/dom/media/platforms/ffmpeg/ffmpeg57/include/COPYING.LGPLv2.1 b/dom/media/platforms/ffmpeg/ffmpeg63/include/COPYING.LGPLv2.1 +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg57/include/COPYING.LGPLv2.1 +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/COPYING.LGPLv2.1 +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avcodec.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avcodec.h +new file mode 100644 +index 000000000000..6bce0d388d80 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avcodec.h +@@ -0,0 +1,2961 @@ ++/* ++ * copyright (c) 2001 Fabrice Bellard ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_AVCODEC_H ++#define AVCODEC_AVCODEC_H ++ ++/** ++ * @file ++ * @ingroup libavc ++ * Libavcodec external API header ++ */ ++ ++#include "libavutil/samplefmt.h" ++#include "libavutil/attributes.h" ++#include "libavutil/avutil.h" ++#include "libavutil/buffer.h" ++#include "libavutil/channel_layout.h" ++#include "libavutil/dict.h" ++#include "libavutil/frame.h" ++#include "libavutil/log.h" ++#include "libavutil/pixfmt.h" ++#include "libavutil/rational.h" ++ ++#include "codec.h" ++#include "codec_id.h" ++#include "defs.h" ++#include "packet.h" ++#include "version_major.h" ++#ifndef HAVE_AV_CONFIG_H ++/* When included as part of the ffmpeg build, only include the major version ++ * to avoid unnecessary rebuilds. When included externally, keep including ++ * the full version information. */ ++#include "version.h" ++ ++#include "codec_desc.h" ++#include "codec_par.h" ++#endif ++ ++struct AVCodecParameters; ++ ++/** ++ * @defgroup libavc libavcodec ++ * Encoding/Decoding Library ++ * ++ * @{ ++ * ++ * @defgroup lavc_decoding Decoding ++ * @{ ++ * @} ++ * ++ * @defgroup lavc_encoding Encoding ++ * @{ ++ * @} ++ * ++ * @defgroup lavc_codec Codecs ++ * @{ ++ * @defgroup lavc_codec_native Native Codecs ++ * @{ ++ * @} ++ * @defgroup lavc_codec_wrappers External library wrappers ++ * @{ ++ * @} ++ * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge ++ * @{ ++ * @} ++ * @} ++ * @defgroup lavc_internal Internal ++ * @{ ++ * @} ++ * @} ++ */ ++ ++/** ++ * @ingroup libavc ++ * @defgroup lavc_encdec send/receive encoding and decoding API overview ++ * @{ ++ * ++ * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/ ++ * avcodec_receive_packet() functions provide an encode/decode API, which ++ * decouples input and output. ++ * ++ * The API is very similar for encoding/decoding and audio/video, and works as ++ * follows: ++ * - Set up and open the AVCodecContext as usual. ++ * - Send valid input: ++ * - For decoding, call avcodec_send_packet() to give the decoder raw ++ * compressed data in an AVPacket. ++ * - For encoding, call avcodec_send_frame() to give the encoder an AVFrame ++ * containing uncompressed audio or video. ++ * ++ * In both cases, it is recommended that AVPackets and AVFrames are ++ * refcounted, or libavcodec might have to copy the input data. (libavformat ++ * always returns refcounted AVPackets, and av_frame_get_buffer() allocates ++ * refcounted AVFrames.) ++ * - Receive output in a loop. Periodically call one of the avcodec_receive_*() ++ * functions and process their output: ++ * - For decoding, call avcodec_receive_frame(). On success, it will return ++ * an AVFrame containing uncompressed audio or video data. ++ * - For encoding, call avcodec_receive_packet(). On success, it will return ++ * an AVPacket with a compressed frame. ++ * ++ * Repeat this call until it returns AVERROR(EAGAIN) or an error. The ++ * AVERROR(EAGAIN) return value means that new input data is required to ++ * return new output. In this case, continue with sending input. For each ++ * input frame/packet, the codec will typically return 1 output frame/packet, ++ * but it can also be 0 or more than 1. ++ * ++ * At the beginning of decoding or encoding, the codec might accept multiple ++ * input frames/packets without returning a frame, until its internal buffers ++ * are filled. This situation is handled transparently if you follow the steps ++ * outlined above. ++ * ++ * In theory, sending input can result in EAGAIN - this should happen only if ++ * not all output was received. You can use this to structure alternative decode ++ * or encode loops other than the one suggested above. For example, you could ++ * try sending new input on each iteration, and try to receive output if that ++ * returns EAGAIN. ++ * ++ * End of stream situations. These require "flushing" (aka draining) the codec, ++ * as the codec might buffer multiple frames or packets internally for ++ * performance or out of necessity (consider B-frames). ++ * This is handled as follows: ++ * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding) ++ * or avcodec_send_frame() (encoding) functions. This will enter draining ++ * mode. ++ * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet() ++ * (encoding) in a loop until AVERROR_EOF is returned. The functions will ++ * not return AVERROR(EAGAIN), unless you forgot to enter draining mode. ++ * - Before decoding can be resumed again, the codec has to be reset with ++ * avcodec_flush_buffers(). ++ * ++ * Using the API as outlined above is highly recommended. But it is also ++ * possible to call functions outside of this rigid schema. For example, you can ++ * call avcodec_send_packet() repeatedly without calling ++ * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed ++ * until the codec's internal buffer has been filled up (which is typically of ++ * size 1 per output frame, after initial input), and then reject input with ++ * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to ++ * read at least some output. ++ * ++ * Not all codecs will follow a rigid and predictable dataflow; the only ++ * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on ++ * one end implies that a receive/send call on the other end will succeed, or ++ * at least will not fail with AVERROR(EAGAIN). In general, no codec will ++ * permit unlimited buffering of input or output. ++ * ++ * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This ++ * would be an invalid state, which could put the codec user into an endless ++ * loop. The API has no concept of time either: it cannot happen that trying to ++ * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second ++ * later accepts the packet (with no other receive/flush API calls involved). ++ * The API is a strict state machine, and the passage of time is not supposed ++ * to influence it. Some timing-dependent behavior might still be deemed ++ * acceptable in certain cases. But it must never result in both send/receive ++ * returning EAGAIN at the same time at any point. It must also absolutely be ++ * avoided that the current state is "unstable" and can "flip-flop" between ++ * the send/receive APIs allowing progress. For example, it's not allowed that ++ * the codec randomly decides that it actually wants to consume a packet now ++ * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an ++ * avcodec_send_packet() call. ++ * @} ++ */ ++ ++/** ++ * @defgroup lavc_core Core functions/structures. ++ * @ingroup libavc ++ * ++ * Basic definitions, functions for querying libavcodec capabilities, ++ * allocating core structures, etc. ++ * @{ ++ */ ++ ++/** ++ * @ingroup lavc_encoding ++ */ ++typedef struct RcOverride{ ++ int start_frame; ++ int end_frame; ++ int qscale; // If this is 0 then quality_factor will be used instead. ++ float quality_factor; ++} RcOverride; ++ ++/* encoding support ++ These flags can be passed in AVCodecContext.flags before initialization. ++ Note: Not everything is supported yet. ++*/ ++ ++/** ++ * Allow decoders to produce frames with data planes that are not aligned ++ * to CPU requirements (e.g. due to cropping). ++ */ ++#define AV_CODEC_FLAG_UNALIGNED (1 << 0) ++/** ++ * Use fixed qscale. ++ */ ++#define AV_CODEC_FLAG_QSCALE (1 << 1) ++/** ++ * 4 MV per MB allowed / advanced prediction for H.263. ++ */ ++#define AV_CODEC_FLAG_4MV (1 << 2) ++/** ++ * Output even those frames that might be corrupted. ++ */ ++#define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3) ++/** ++ * Use qpel MC. ++ */ ++#define AV_CODEC_FLAG_QPEL (1 << 4) ++/** ++ * Request the encoder to output reconstructed frames, i.e.\ frames that would ++ * be produced by decoding the encoded bitstream. These frames may be retrieved ++ * by calling avcodec_receive_frame() immediately after a successful call to ++ * avcodec_receive_packet(). ++ * ++ * Should only be used with encoders flagged with the ++ * @ref AV_CODEC_CAP_ENCODER_RECON_FRAME capability. ++ * ++ * @note ++ * Each reconstructed frame returned by the encoder corresponds to the last ++ * encoded packet, i.e. the frames are returned in coded order rather than ++ * presentation order. ++ * ++ * @note ++ * Frame parameters (like pixel format or dimensions) do not have to match the ++ * AVCodecContext values. Make sure to use the values from the returned frame. ++ */ ++#define AV_CODEC_FLAG_RECON_FRAME (1 << 6) ++/** ++ * @par decoding ++ * Request the decoder to propagate each packet's AVPacket.opaque and ++ * AVPacket.opaque_ref to its corresponding output AVFrame. ++ * ++ * @par encoding: ++ * Request the encoder to propagate each frame's AVFrame.opaque and ++ * AVFrame.opaque_ref values to its corresponding output AVPacket. ++ * ++ * @par ++ * May only be set on encoders that have the ++ * @ref AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability flag. ++ * ++ * @note ++ * While in typical cases one input frame produces exactly one output packet ++ * (perhaps after a delay), in general the mapping of frames to packets is ++ * M-to-N, so ++ * - Any number of input frames may be associated with any given output packet. ++ * This includes zero - e.g. some encoders may output packets that carry only ++ * metadata about the whole stream. ++ * - A given input frame may be associated with any number of output packets. ++ * Again this includes zero - e.g. some encoders may drop frames under certain ++ * conditions. ++ * . ++ * This implies that when using this flag, the caller must NOT assume that ++ * - a given input frame's opaques will necessarily appear on some output packet; ++ * - every output packet will have some non-NULL opaque value. ++ * . ++ * When an output packet contains multiple frames, the opaque values will be ++ * taken from the first of those. ++ * ++ * @note ++ * The converse holds for decoders, with frames and packets switched. ++ */ ++#define AV_CODEC_FLAG_COPY_OPAQUE (1 << 7) ++/** ++ * Signal to the encoder that the values of AVFrame.duration are valid and ++ * should be used (typically for transferring them to output packets). ++ * ++ * If this flag is not set, frame durations are ignored. ++ */ ++#define AV_CODEC_FLAG_FRAME_DURATION (1 << 8) ++/** ++ * Use internal 2pass ratecontrol in first pass mode. ++ */ ++#define AV_CODEC_FLAG_PASS1 (1 << 9) ++/** ++ * Use internal 2pass ratecontrol in second pass mode. ++ */ ++#define AV_CODEC_FLAG_PASS2 (1 << 10) ++/** ++ * loop filter. ++ */ ++#define AV_CODEC_FLAG_LOOP_FILTER (1 << 11) ++/** ++ * Only decode/encode grayscale. ++ */ ++#define AV_CODEC_FLAG_GRAY (1 << 13) ++/** ++ * error[?] variables will be set during encoding. ++ */ ++#define AV_CODEC_FLAG_PSNR (1 << 15) ++/** ++ * Use interlaced DCT. ++ */ ++#define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18) ++/** ++ * Force low delay. ++ */ ++#define AV_CODEC_FLAG_LOW_DELAY (1 << 19) ++/** ++ * Place global headers in extradata instead of every keyframe. ++ */ ++#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22) ++/** ++ * Use only bitexact stuff (except (I)DCT). ++ */ ++#define AV_CODEC_FLAG_BITEXACT (1 << 23) ++/* Fx : Flag for H.263+ extra options */ ++/** ++ * H.263 advanced intra coding / MPEG-4 AC prediction ++ */ ++#define AV_CODEC_FLAG_AC_PRED (1 << 24) ++/** ++ * interlaced motion estimation ++ */ ++#define AV_CODEC_FLAG_INTERLACED_ME (1 << 29) ++#define AV_CODEC_FLAG_CLOSED_GOP (1U << 31) ++ ++/** ++ * Allow non spec compliant speedup tricks. ++ */ ++#define AV_CODEC_FLAG2_FAST (1 << 0) ++/** ++ * Skip bitstream encoding. ++ */ ++#define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2) ++/** ++ * Place global headers at every keyframe instead of in extradata. ++ */ ++#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3) ++ ++/** ++ * Input bitstream might be truncated at a packet boundaries ++ * instead of only at frame boundaries. ++ */ ++#define AV_CODEC_FLAG2_CHUNKS (1 << 15) ++/** ++ * Discard cropping information from SPS. ++ */ ++#define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16) ++/** ++ * Force audio encoders to use a fixed frame size. ++ */ ++#define AV_CODEC_FLAG2_FIXED_FRAME_SIZE (1 << 17) ++ ++/** ++ * Show all frames before the first keyframe ++ */ ++#define AV_CODEC_FLAG2_SHOW_ALL (1 << 22) ++/** ++ * Export motion vectors through frame side data ++ */ ++#define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28) ++/** ++ * Do not skip samples and export skip information as frame side data ++ */ ++#define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29) ++/** ++ * Do not reset ASS ReadOrder field on flush (subtitles decoding) ++ */ ++#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30) ++/** ++ * Generate/parse ICC profiles on encode/decode, as appropriate for the type of ++ * file. No effect on codecs which cannot contain embedded ICC profiles, or ++ * when compiled without support for lcms2. ++ */ ++#define AV_CODEC_FLAG2_ICC_PROFILES (1U << 31) ++ ++/* Exported side data. ++ These flags can be passed in AVCodecContext.export_side_data before initialization. ++*/ ++/** ++ * Export motion vectors through frame side data ++ */ ++#define AV_CODEC_EXPORT_DATA_MVS (1 << 0) ++/** ++ * Export encoder Producer Reference Time through packet side data ++ */ ++#define AV_CODEC_EXPORT_DATA_PRFT (1 << 1) ++/** ++ * Decoding only. ++ * Export the AVVideoEncParams structure through frame side data. ++ */ ++#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS (1 << 2) ++/** ++ * Decoding only. ++ * Do not apply film grain, export it instead. ++ */ ++#define AV_CODEC_EXPORT_DATA_FILM_GRAIN (1 << 3) ++ ++/** ++ * Decoding only. ++ * Do not apply picture enhancement layers, export them instead. ++ */ ++#define AV_CODEC_EXPORT_DATA_ENHANCEMENTS (1 << 4) ++ ++/** ++ * The decoder will keep a reference to the frame and may reuse it later. ++ */ ++#define AV_GET_BUFFER_FLAG_REF (1 << 0) ++ ++/** ++ * The encoder will keep a reference to the packet and may reuse it later. ++ */ ++#define AV_GET_ENCODE_BUFFER_FLAG_REF (1 << 0) ++ ++/** ++ * The decoder will bypass frame threading and return the next frame as soon as ++ * possible. Note that this may deliver frames earlier than the advertised ++ * `AVCodecContext.delay`. No effect when frame threading is disabled, or on ++ * encoding. ++ */ ++#define AV_CODEC_RECEIVE_FRAME_FLAG_SYNCHRONOUS (1 << 0) ++ ++/** ++ * main external API structure. ++ * New fields can be added to the end with minor version bumps. ++ * Removal, reordering and changes to existing fields require a major ++ * version bump. ++ * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user ++ * applications. ++ * The name string for AVOptions options matches the associated command line ++ * parameter name and can be found in libavcodec/options_table.h ++ * The AVOption/command line parameter names differ in some cases from the C ++ * structure field names for historic reasons or brevity. ++ * sizeof(AVCodecContext) must not be used outside libav*. ++ */ ++typedef struct AVCodecContext { ++ /** ++ * information on struct for av_log ++ * - set by avcodec_alloc_context3 ++ */ ++ const AVClass *av_class; ++ int log_level_offset; ++ ++ enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ ++ const struct AVCodec *codec; ++ enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ ++ ++ /** ++ * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). ++ * This is used to work around some encoder bugs. ++ * A demuxer should set this to what is stored in the field used to identify the codec. ++ * If there are multiple such fields in a container then the demuxer should choose the one ++ * which maximizes the information about the used codec. ++ * If the codec tag field in a container is larger than 32 bits then the demuxer should ++ * remap the longer ID to 32 bits with a table or other structure. Alternatively a new ++ * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated ++ * first. ++ * - encoding: Set by user, if not then the default based on codec_id will be used. ++ * - decoding: Set by user, will be converted to uppercase by libavcodec during init. ++ */ ++ unsigned int codec_tag; ++ ++ void *priv_data; ++ ++ /** ++ * Private context used for internal data. ++ * ++ * Unlike priv_data, this is not codec-specific. It is used in general ++ * libavcodec functions. ++ */ ++ struct AVCodecInternal *internal; ++ ++ /** ++ * Private data of the user, can be used to carry app specific stuff. ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ void *opaque; ++ ++ /** ++ * the average bitrate ++ * - encoding: Set by user; unused for constant quantizer encoding. ++ * - decoding: Set by user, may be overwritten by libavcodec ++ * if this info is available in the stream ++ */ ++ int64_t bit_rate; ++ ++ /** ++ * AV_CODEC_FLAG_*. ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int flags; ++ ++ /** ++ * AV_CODEC_FLAG2_* ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int flags2; ++ ++ /** ++ * Out-of-band global headers that may be used by some codecs. ++ * ++ * - decoding: Should be set by the caller when available (typically from a ++ * demuxer) before opening the decoder; some decoders require this to be ++ * set and will fail to initialize otherwise. ++ * ++ * The array must be allocated with the av_malloc() family of functions; ++ * allocated size must be at least AV_INPUT_BUFFER_PADDING_SIZE bytes ++ * larger than extradata_size. ++ * ++ * - encoding: May be set by the encoder in avcodec_open2() (possibly ++ * depending on whether the AV_CODEC_FLAG_GLOBAL_HEADER flag is set). ++ * ++ * After being set, the array is owned by the codec and freed in ++ * avcodec_free_context(). ++ */ ++ uint8_t *extradata; ++ int extradata_size; ++ ++ /** ++ * This is the fundamental unit of time (in seconds) in terms ++ * of which frame timestamps are represented. For fixed-fps content, ++ * timebase should be 1/framerate and timestamp increments should be ++ * identically 1. ++ * This often, but not always is the inverse of the frame rate or field rate ++ * for video. 1/time_base is not the average frame rate if the frame rate is not ++ * constant. ++ * ++ * Like containers, elementary streams also can store timestamps, 1/time_base ++ * is the unit in which these timestamps are specified. ++ * As example of such codec time base see ISO/IEC 14496-2:2001(E) ++ * vop_time_increment_resolution and fixed_vop_rate ++ * (fixed_vop_rate == 0 implies that it is different from the framerate) ++ * ++ * - encoding: MUST be set by user. ++ * - decoding: unused. ++ */ ++ AVRational time_base; ++ ++ /** ++ * Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed. ++ * - encoding: unused. ++ * - decoding: set by user. ++ */ ++ AVRational pkt_timebase; ++ ++ /** ++ * - decoding: For codecs that store a framerate value in the compressed ++ * bitstream, the decoder may export it here. { 0, 1} when ++ * unknown. ++ * - encoding: May be used to signal the framerate of CFR content to an ++ * encoder. ++ */ ++ AVRational framerate; ++ ++ /** ++ * Codec delay. ++ * ++ * Encoding: Number of frames delay there will be from the encoder input to ++ * the decoder output. (we assume the decoder matches the spec) ++ * Decoding: Number of frames delay in addition to what a standard decoder ++ * as specified in the spec would produce. ++ * ++ * Video: ++ * Number of frames the decoded output will be delayed relative to the ++ * encoded input. ++ * ++ * Audio: ++ * For encoding, this field is unused (see initial_padding). ++ * ++ * For decoding, this is the number of samples the decoder needs to ++ * output before the decoder's output is valid. When seeking, you should ++ * start decoding this many samples prior to your desired seek point. ++ * ++ * - encoding: Set by libavcodec. ++ * - decoding: Set by libavcodec. ++ */ ++ int delay; ++ ++ ++ /* video only */ ++ /** ++ * picture width / height. ++ * ++ * @note Those fields may not match the values of the last ++ * AVFrame output by avcodec_receive_frame() due frame ++ * reordering. ++ * ++ * - encoding: MUST be set by user. ++ * - decoding: May be set by the user before opening the decoder if known e.g. ++ * from the container. Some decoders will require the dimensions ++ * to be set by the caller. During decoding, the decoder may ++ * overwrite those values as required while parsing the data. ++ */ ++ int width, height; ++ ++ /** ++ * Bitstream width / height, may be different from width/height e.g. when ++ * the decoded frame is cropped before being output or lowres is enabled. ++ * ++ * @note Those field may not match the value of the last ++ * AVFrame output by avcodec_receive_frame() due frame ++ * reordering. ++ * ++ * - encoding: unused ++ * - decoding: May be set by the user before opening the decoder if known ++ * e.g. from the container. During decoding, the decoder may ++ * overwrite those values as required while parsing the data. ++ */ ++ int coded_width, coded_height; ++ ++ /** ++ * sample aspect ratio (0 if unknown) ++ * That is the width of a pixel divided by the height of the pixel. ++ * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec. ++ */ ++ AVRational sample_aspect_ratio; ++ ++ /** ++ * Pixel format, see AV_PIX_FMT_xxx. ++ * May be set by the demuxer if known from headers. ++ * May be overridden by the decoder if it knows better. ++ * ++ * @note This field may not match the value of the last ++ * AVFrame output by avcodec_receive_frame() due frame ++ * reordering. ++ * ++ * - encoding: Set by user. ++ * - decoding: Set by user if known, overridden by libavcodec while ++ * parsing the data. ++ */ ++ enum AVPixelFormat pix_fmt; ++ ++ /** ++ * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx. ++ * - encoding: unused. ++ * - decoding: Set by libavcodec before calling get_format() ++ */ ++ enum AVPixelFormat sw_pix_fmt; ++ ++ /** ++ * 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 to override the default output color range value, ++ * If not specified, libavcodec sets the color range depending on the ++ * output format. ++ * - decoding: Set by libavcodec, can be set by the user to propagate the ++ * color range to components reading from the decoder context. ++ */ ++ enum AVColorRange color_range; ++ ++ /** ++ * This defines the location of chroma samples. ++ * - encoding: Set by user ++ * - decoding: Set by libavcodec ++ */ ++ enum AVChromaLocation chroma_sample_location; ++ ++ /** Field order ++ * - encoding: set by libavcodec ++ * - decoding: Set by user. ++ */ ++ enum AVFieldOrder field_order; ++ ++ /** ++ * number of reference frames ++ * - encoding: Set by user. ++ * - decoding: Set by lavc. ++ */ ++ int refs; ++ ++ /** ++ * Size of the frame reordering buffer in the decoder. ++ * For MPEG-2 it is 1 IPB or 0 low delay IP. ++ * - encoding: Set by libavcodec. ++ * - decoding: Set by libavcodec. ++ */ ++ int has_b_frames; ++ ++ /** ++ * slice flags ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ int slice_flags; ++#define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display ++#define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG-2 field pics) ++#define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) ++ ++ /** ++ * 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. ++ * When multithreading is used, it may be called from multiple threads ++ * at the same time; threads might draw different parts of the same AVFrame, ++ * or multiple AVFrames, and there is no guarantee that slices will be drawn ++ * in order. ++ * 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. ++ * In that mode instead of pixel data, AVFrame points to ++ * a structure specific to the acceleration API. The application ++ * reads the structure and can change some fields to indicate progress ++ * or mark state. ++ * - encoding: unused ++ * - decoding: Set by user. ++ * @param height the height of the slice ++ * @param y the y position of the slice ++ * @param type 1->top field, 2->bottom field, 3->frame ++ * @param offset offset into the AVFrame.data from which the slice should be read ++ */ ++ void (*draw_horiz_band)(struct AVCodecContext *s, ++ const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], ++ int y, int type, int height); ++ ++ /** ++ * Callback to negotiate the pixel format. Decoding only, may be set by the ++ * caller before avcodec_open2(). ++ * ++ * Called by some decoders to select the pixel format that will be used for ++ * the output frames. This is mainly used to set up hardware acceleration, ++ * then the provided format list contains the corresponding hwaccel pixel ++ * formats alongside the "software" one. The software pixel format may also ++ * be retrieved from \ref sw_pix_fmt. ++ * ++ * This callback will be called when the coded frame properties (such as ++ * resolution, pixel format, etc.) change and more than one output format is ++ * supported for those new properties. If a hardware pixel format is chosen ++ * and initialization for it fails, the callback may be called again ++ * immediately. ++ * ++ * This callback may be called from different threads if the decoder is ++ * multi-threaded, but not from more than one thread simultaneously. ++ * ++ * @param fmt list of formats which may be used in the current ++ * configuration, terminated by AV_PIX_FMT_NONE. ++ * @warning Behavior is undefined if the callback returns a value other ++ * than one of the formats in fmt or AV_PIX_FMT_NONE. ++ * @return the chosen format or AV_PIX_FMT_NONE ++ */ ++ enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt); ++ ++ /** ++ * maximum number of B-frames between non-B-frames ++ * Note: The output will be delayed by max_b_frames+1 relative to the input. ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int max_b_frames; ++ ++ /** ++ * qscale factor between IP and B-frames ++ * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). ++ * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float b_quant_factor; ++ ++ /** ++ * qscale offset between IP and B-frames ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float b_quant_offset; ++ ++ /** ++ * qscale factor between P- and I-frames ++ * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset). ++ * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float i_quant_factor; ++ ++ /** ++ * qscale offset between P and I-frames ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float i_quant_offset; ++ ++ /** ++ * luminance masking (0-> disabled) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float lumi_masking; ++ ++ /** ++ * temporary complexity masking (0-> disabled) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float temporal_cplx_masking; ++ ++ /** ++ * spatial complexity masking (0-> disabled) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float spatial_cplx_masking; ++ ++ /** ++ * p block masking (0-> disabled) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float p_masking; ++ ++ /** ++ * darkness masking (0-> disabled) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ float dark_masking; ++ ++ /** ++ * noise vs. sse weight for the nsse comparison function ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int nsse_weight; ++ ++ /** ++ * motion estimation comparison function ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int me_cmp; ++ /** ++ * subpixel motion estimation comparison function ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int me_sub_cmp; ++ /** ++ * macroblock comparison function (not supported yet) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int mb_cmp; ++ /** ++ * interlaced DCT comparison function ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int ildct_cmp; ++#define FF_CMP_SAD 0 ++#define FF_CMP_SSE 1 ++#define FF_CMP_SATD 2 ++#define FF_CMP_DCT 3 ++#define FF_CMP_PSNR 4 ++#define FF_CMP_BIT 5 ++#define FF_CMP_RD 6 ++#define FF_CMP_ZERO 7 ++#define FF_CMP_VSAD 8 ++#define FF_CMP_VSSE 9 ++#define FF_CMP_NSSE 10 ++#define FF_CMP_W53 11 ++#define FF_CMP_W97 12 ++#define FF_CMP_DCTMAX 13 ++#define FF_CMP_DCT264 14 ++#define FF_CMP_MEDIAN_SAD 15 ++#define FF_CMP_CHROMA 256 ++ ++ /** ++ * ME diamond size & shape ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int dia_size; ++ ++ /** ++ * amount of previous MV predictors (2a+1 x 2a+1 square) ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int last_predictor_count; ++ ++ /** ++ * motion estimation prepass comparison function ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int me_pre_cmp; ++ ++ /** ++ * ME prepass diamond size & shape ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int pre_dia_size; ++ ++ /** ++ * subpel ME quality ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int me_subpel_quality; ++ ++ /** ++ * maximum motion estimation search range in subpel units ++ * If 0 then no limit. ++ * ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int me_range; ++ ++ /** ++ * macroblock decision mode ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int mb_decision; ++#define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp ++#define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits ++#define FF_MB_DECISION_RD 2 ///< rate distortion ++ ++ /** ++ * custom intra quantization matrix ++ * Must be allocated with the av_malloc() family of functions, and will be freed in ++ * avcodec_free_context(). ++ * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL. ++ * - decoding: Set/allocated/freed by libavcodec. ++ */ ++ uint16_t *intra_matrix; ++ ++ /** ++ * custom inter quantization matrix ++ * Must be allocated with the av_malloc() family of functions, and will be freed in ++ * avcodec_free_context(). ++ * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL. ++ * - decoding: Set/allocated/freed by libavcodec. ++ */ ++ uint16_t *inter_matrix; ++ ++ /** ++ * custom intra quantization matrix ++ * - encoding: Set by user, can be NULL. ++ * - decoding: unused. ++ */ ++ uint16_t *chroma_intra_matrix; ++ ++#if FF_API_INTRA_DC_PRECISION ++ /** ++ * precision of the intra DC coefficient - 8 ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec ++ * @deprecated Use the MPEG-2 encoder's private option "intra_dc_precision" instead. ++ */ ++ attribute_deprecated ++ int intra_dc_precision; ++#endif ++ ++ /** ++ * minimum MB Lagrange multiplier ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int mb_lmin; ++ ++ /** ++ * maximum MB Lagrange multiplier ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int mb_lmax; ++ ++ /** ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int bidir_refine; ++ ++ /** ++ * minimum GOP size ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int keyint_min; ++ ++ /** ++ * the number of pictures in a group of pictures, or 0 for intra_only ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int gop_size; ++ ++ /** ++ * Note: Value depends upon the compare function used for fullpel ME. ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int mv0_threshold; ++ ++ /** ++ * Number of slices. ++ * Indicates number of picture subdivisions. Used for parallelized ++ * decoding. ++ * - encoding: Set by user ++ * - decoding: unused ++ */ ++ int slices; ++ ++ /* audio only */ ++ int sample_rate; ///< samples per second ++ ++ /** ++ * audio sample format ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec. ++ */ ++ enum AVSampleFormat sample_fmt; ///< sample format ++ ++ /** ++ * Audio channel layout. ++ * - encoding: must be set by the caller, to one of AVCodec.ch_layouts. ++ * - decoding: may be set by the caller if known e.g. from the container. ++ * The decoder can then override during decoding as needed. ++ */ ++ AVChannelLayout ch_layout; ++ ++ /** ++ * Number of samples per channel in an audio frame. ++ * ++ * - encoding: may be set by the user before calling avcodec_open2(), and ++ * libavcodec may then overwrite it if needed. Each submitted frame ++ * except the last must contain exactly frame_size samples per channel. ++ * May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, except ++ * when AV_CODEC_FLAG2_FIXED_FRAME_SIZE is requested, then the ++ * frame size is not restricted. ++ * - decoding: may be set by some decoders to indicate constant frame size ++ */ ++ int frame_size; ++ ++ /* The following data should not be initialized. */ ++ /** ++ * number of bytes per packet if constant and known or 0 ++ * Used by some WAV based audio codecs. ++ */ ++ int block_align; ++ ++ /** ++ * Audio cutoff bandwidth (0 means "automatic") ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int cutoff; ++ ++ /** ++ * Type of service that the audio stream conveys. ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec. ++ */ ++ enum AVAudioServiceType audio_service_type; ++ ++ /** ++ * desired sample format ++ * - encoding: Not used. ++ * - decoding: Set by user. ++ * Decoder will decode to this format if it can. ++ */ ++ enum AVSampleFormat request_sample_fmt; ++ ++ /** ++ * Audio only. The number of "priming" samples (padding) inserted by the ++ * encoder at the beginning of the audio. I.e. this number of leading ++ * decoded samples must be discarded by the caller to get the original audio ++ * without leading padding. ++ * ++ * - decoding: unused ++ * - encoding: Set by libavcodec. The timestamps on the output packets are ++ * adjusted by the encoder so that they always refer to the ++ * first sample of the data actually contained in the packet, ++ * including any added padding. E.g. if the timebase is ++ * 1/samplerate and the timestamp of the first input sample is ++ * 0, the timestamp of the first output packet will be ++ * -initial_padding. ++ */ ++ int initial_padding; ++ ++ /** ++ * Audio only. The amount of padding (in samples) appended by the encoder to ++ * the end of the audio. I.e. this number of decoded samples must be ++ * discarded by the caller from the end of the stream to get the original ++ * audio without any trailing padding. ++ * ++ * - decoding: unused ++ * - encoding: unused ++ */ ++ int trailing_padding; ++ ++ /** ++ * Number of samples to skip after a discontinuity ++ * - decoding: unused ++ * - encoding: set by libavcodec ++ */ ++ int seek_preroll; ++ ++ /** ++ * This callback is called at the beginning of each frame to get data ++ * buffer(s) for it. There may be one contiguous buffer for all the data or ++ * there may be a buffer per each data plane or anything in between. What ++ * this means is, you may set however many entries in buf[] you feel necessary. ++ * Each buffer must be reference-counted using the AVBuffer API (see description ++ * of buf[] below). ++ * ++ * The following fields will be set in the frame before this callback is ++ * called: ++ * - format ++ * - width, height (video only) ++ * - sample_rate, channel_layout, nb_samples (audio only) ++ * Their values may differ from the corresponding values in ++ * AVCodecContext. This callback must use the frame values, not the codec ++ * context values, to calculate the required buffer size. ++ * ++ * This callback must fill the following fields in the frame: ++ * - data[] ++ * - linesize[] ++ * - extended_data: ++ * * if the data is planar audio with more than 8 channels, then this ++ * callback must allocate and fill extended_data to contain all pointers ++ * to all data planes. data[] must hold as many pointers as it can. ++ * extended_data must be allocated with av_malloc() and will be freed in ++ * av_frame_unref(). ++ * * otherwise extended_data must point to data ++ * - buf[] must contain one or more pointers to AVBufferRef structures. Each of ++ * the frame's data and extended_data pointers must be contained in these. That ++ * is, one AVBufferRef for each allocated chunk of memory, not necessarily one ++ * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(), ++ * and av_buffer_ref(). ++ * - extended_buf and nb_extended_buf must be allocated with av_malloc() by ++ * this callback and filled with the extra buffers if there are more ++ * buffers than buf[] can hold. extended_buf will be freed in ++ * av_frame_unref(). ++ * Decoders will generally initialize the whole buffer before it is output ++ * but it can in rare error conditions happen that uninitialized data is passed ++ * through. \important The buffers returned by get_buffer* should thus not contain sensitive ++ * data. ++ * ++ * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call ++ * avcodec_default_get_buffer2() instead of providing buffers allocated by ++ * some other means. ++ * ++ * Each data plane must be aligned to the maximum required by the target ++ * CPU. ++ * ++ * @see avcodec_default_get_buffer2() ++ * ++ * Video: ++ * ++ * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused ++ * (read and/or written to if it is writable) later by libavcodec. ++ * ++ * avcodec_align_dimensions2() should be used to find the required width and ++ * height, as they normally need to be rounded up to the next multiple of 16. ++ * ++ * Some decoders do not support linesizes changing between frames. ++ * ++ * If frame multithreading is used, this callback may be called from a ++ * different thread, but not from more than one at once. Does not need to be ++ * reentrant. ++ * ++ * @see avcodec_align_dimensions2() ++ * ++ * Audio: ++ * ++ * Decoders request a buffer of a particular size by setting ++ * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may, ++ * however, utilize only part of the buffer by setting AVFrame.nb_samples ++ * to a smaller value in the output frame. ++ * ++ * As a convenience, av_samples_get_buffer_size() and ++ * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2() ++ * functions to find the required data size and to fill data pointers and ++ * linesize. In AVFrame.linesize, only linesize[0] may be set for audio ++ * since all planes must be the same size. ++ * ++ * @see av_samples_get_buffer_size(), av_samples_fill_arrays() ++ * ++ * - encoding: unused ++ * - decoding: Set by libavcodec, user can override. ++ */ ++ int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags); ++ ++ /* - encoding parameters */ ++ /** ++ * number of bits the bitstream is allowed to diverge from the reference. ++ * the reference can be CBR (for CBR pass1) or VBR (for pass2) ++ * - encoding: Set by user; unused for constant quantizer encoding. ++ * - decoding: unused ++ */ ++ int bit_rate_tolerance; ++ ++ /** ++ * Global quality for codecs which cannot change it per frame. ++ * This should be proportional to MPEG-1/2/4 qscale. ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int global_quality; ++ ++ /** ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int compression_level; ++#define FF_COMPRESSION_DEFAULT -1 ++ ++ float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) ++ float qblur; ///< amount of qscale smoothing over time (0.0-1.0) ++ ++ /** ++ * minimum quantizer ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int qmin; ++ ++ /** ++ * maximum quantizer ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int qmax; ++ ++ /** ++ * maximum quantizer difference between frames ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int max_qdiff; ++ ++ /** ++ * decoder bitstream buffer size ++ * - encoding: Set by user. ++ * - decoding: May be set by libavcodec. ++ */ ++ int rc_buffer_size; ++ ++ /** ++ * ratecontrol override, see RcOverride ++ * - encoding: Allocated/set/freed by user. ++ * - decoding: unused ++ */ ++ int rc_override_count; ++ RcOverride *rc_override; ++ ++ /** ++ * maximum bitrate ++ * - encoding: Set by user. ++ * - decoding: Set by user, may be overwritten by libavcodec. ++ */ ++ int64_t rc_max_rate; ++ ++ /** ++ * minimum bitrate ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int64_t rc_min_rate; ++ ++ /** ++ * Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ++ * - encoding: Set by user. ++ * - decoding: unused. ++ */ ++ float rc_max_available_vbv_use; ++ ++ /** ++ * Ratecontrol attempt to use, at least, times the amount needed to prevent a vbv overflow. ++ * - encoding: Set by user. ++ * - decoding: unused. ++ */ ++ float rc_min_vbv_overflow_use; ++ ++ /** ++ * Number of bits which should be loaded into the rc buffer before decoding starts. ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int rc_initial_buffer_occupancy; ++ ++ /** ++ * trellis RD quantization ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int trellis; ++ ++ /** ++ * pass1 encoding statistics output buffer ++ * - encoding: Set by libavcodec. ++ * - decoding: unused ++ */ ++ char *stats_out; ++ ++ /** ++ * pass2 encoding statistics input buffer ++ * Concatenated stuff from stats_out of pass1 should be placed here. ++ * - encoding: Allocated/set/freed by user. ++ * - decoding: unused ++ */ ++ char *stats_in; ++ ++ /** ++ * Work around bugs in encoders which sometimes cannot be detected automatically. ++ * - encoding: Set by user ++ * - decoding: Set by user ++ */ ++ int workaround_bugs; ++#define FF_BUG_AUTODETECT 1 ///< autodetection ++#define FF_BUG_XVID_ILACE 4 ++#define FF_BUG_UMP4 8 ++#define FF_BUG_NO_PADDING 16 ++#define FF_BUG_AMV 32 ++#define FF_BUG_QPEL_CHROMA 64 ++#define FF_BUG_STD_QPEL 128 ++#define FF_BUG_QPEL_CHROMA2 256 ++#define FF_BUG_DIRECT_BLOCKSIZE 512 ++#define FF_BUG_EDGE 1024 ++#define FF_BUG_HPEL_CHROMA 2048 ++#define FF_BUG_DC_CLIP 4096 ++#define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. ++#define FF_BUG_TRUNCATED 16384 ++#define FF_BUG_IEDGE 32768 ++ ++ /** ++ * strictly follow the standard (MPEG-4, ...). ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ * Setting this to STRICT or higher means the encoder and decoder will ++ * generally do stupid things, whereas setting it to unofficial or lower ++ * will mean the encoder might produce output that is not supported by all ++ * spec-compliant decoders. Decoders don't differentiate between normal, ++ * unofficial and experimental (that is, they always try to decode things ++ * when they can) unless they are explicitly asked to behave stupidly ++ * (=strictly conform to the specs) ++ * This may only be set to one of the FF_COMPLIANCE_* values in defs.h. ++ */ ++ int strict_std_compliance; ++ ++ /** ++ * error concealment flags ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ int error_concealment; ++#define FF_EC_GUESS_MVS 1 ++#define FF_EC_DEBLOCK 2 ++#define FF_EC_FAVOR_INTER 256 ++ ++ /** ++ * debug ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int debug; ++#define FF_DEBUG_PICT_INFO 1 ++#define FF_DEBUG_RC 2 ++#define FF_DEBUG_BITSTREAM 4 ++#define FF_DEBUG_MB_TYPE 8 ++#define FF_DEBUG_QP 16 ++#define FF_DEBUG_DCT_COEFF 0x00000040 ++#define FF_DEBUG_SKIP 0x00000080 ++#define FF_DEBUG_STARTCODE 0x00000100 ++#define FF_DEBUG_ER 0x00000400 ++#define FF_DEBUG_MMCO 0x00000800 ++#define FF_DEBUG_BUGS 0x00001000 ++#define FF_DEBUG_BUFFERS 0x00008000 ++#define FF_DEBUG_THREADS 0x00010000 ++#define FF_DEBUG_GREEN_MD 0x00800000 ++#define FF_DEBUG_NOMC 0x01000000 ++ ++ /** ++ * Error recognition; may misdetect some more or less valid parts as errors. ++ * This is a bitfield of the AV_EF_* values defined in defs.h. ++ * ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int err_recognition; ++ ++ /** ++ * Hardware accelerator in use ++ * - encoding: unused. ++ * - decoding: Set by libavcodec ++ */ ++ const struct AVHWAccel *hwaccel; ++ ++ /** ++ * Legacy hardware accelerator context. ++ * ++ * For some hardware acceleration methods, the caller may use this field to ++ * signal hwaccel-specific data to the codec. The struct pointed to by this ++ * pointer is hwaccel-dependent and defined in the respective header. Please ++ * refer to the FFmpeg HW accelerator documentation to know how to fill ++ * this. ++ * ++ * In most cases this field is optional - the necessary information may also ++ * be provided to libavcodec through @ref hw_frames_ctx or @ref ++ * hw_device_ctx (see avcodec_get_hw_config()). However, in some cases it ++ * may be the only method of signalling some (optional) information. ++ * ++ * The struct and its contents are owned by the caller. ++ * ++ * - encoding: May be set by the caller before avcodec_open2(). Must remain ++ * valid until avcodec_free_context(). ++ * - decoding: May be set by the caller in the get_format() callback. ++ * Must remain valid until the next get_format() call, ++ * or avcodec_free_context() (whichever comes first). ++ */ ++ void *hwaccel_context; ++ ++ /** ++ * A reference to the AVHWFramesContext describing the input (for encoding) ++ * or output (decoding) frames. The reference is set by the caller and ++ * afterwards owned (and freed) by libavcodec - it should never be read by ++ * the caller after being set. ++ * ++ * - decoding: This field should be set by the caller from the get_format() ++ * callback. The previous reference (if any) will always be ++ * unreffed by libavcodec before the get_format() call. ++ * ++ * If the default get_buffer2() is used with a hwaccel pixel ++ * format, then this AVHWFramesContext will be used for ++ * allocating the frame buffers. ++ * ++ * - encoding: For hardware encoders configured to use a hwaccel pixel ++ * format, this field should be set by the caller to a reference ++ * to the AVHWFramesContext describing input frames. ++ * AVHWFramesContext.format must be equal to ++ * AVCodecContext.pix_fmt. ++ * ++ * This field should be set before avcodec_open2() is called. ++ */ ++ AVBufferRef *hw_frames_ctx; ++ ++ /** ++ * A reference to the AVHWDeviceContext describing the device which will ++ * be used by a hardware encoder/decoder. The reference is set by the ++ * caller and afterwards owned (and freed) by libavcodec. ++ * ++ * This should be used if either the codec device does not require ++ * hardware frames or any that are used are to be allocated internally by ++ * libavcodec. If the user wishes to supply any of the frames used as ++ * encoder input or decoder output then hw_frames_ctx should be used ++ * instead. When hw_frames_ctx is set in get_format() for a decoder, this ++ * field will be ignored while decoding the associated stream segment, but ++ * may again be used on a following one after another get_format() call. ++ * ++ * For both encoders and decoders this field should be set before ++ * avcodec_open2() is called and must not be written to thereafter. ++ * ++ * Note that some decoders may require this field to be set initially in ++ * order to support hw_frames_ctx at all - in that case, all frames ++ * contexts used must be created on the same device. ++ */ ++ AVBufferRef *hw_device_ctx; ++ ++ /** ++ * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated ++ * decoding (if active). ++ * - encoding: unused ++ * - decoding: Set by user (either before avcodec_open2(), or in the ++ * AVCodecContext.get_format callback) ++ */ ++ int hwaccel_flags; ++ ++ /** ++ * Video decoding only. Sets the number of extra hardware frames which ++ * the decoder will allocate for use by the caller. This must be set ++ * before avcodec_open2() is called. ++ * ++ * Some hardware decoders require all frames that they will use for ++ * output to be defined in advance before decoding starts. For such ++ * decoders, the hardware frame pool must therefore be of a fixed size. ++ * The extra frames set here are on top of any number that the decoder ++ * needs internally in order to operate normally (for example, frames ++ * used as reference pictures). ++ */ ++ int extra_hw_frames; ++ ++ /** ++ * error ++ * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR. ++ * - decoding: unused ++ */ ++ uint64_t error[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * DCT algorithm, see FF_DCT_* below ++ * - encoding: Set by user. ++ * - decoding: unused ++ */ ++ int dct_algo; ++#define FF_DCT_AUTO 0 ++#define FF_DCT_FASTINT 1 ++#define FF_DCT_INT 2 ++#define FF_DCT_MMX 3 ++#define FF_DCT_ALTIVEC 5 ++#define FF_DCT_FAAN 6 ++#define FF_DCT_NEON 7 ++ ++ /** ++ * IDCT algorithm, see FF_IDCT_* below. ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int idct_algo; ++#define FF_IDCT_AUTO 0 ++#define FF_IDCT_INT 1 ++#define FF_IDCT_SIMPLE 2 ++#define FF_IDCT_SIMPLEMMX 3 ++#define FF_IDCT_ARM 7 ++#define FF_IDCT_ALTIVEC 8 ++#define FF_IDCT_SIMPLEARM 10 ++#define FF_IDCT_XVID 14 ++#define FF_IDCT_SIMPLEARMV5TE 16 ++#define FF_IDCT_SIMPLEARMV6 17 ++#define FF_IDCT_FAAN 20 ++#define FF_IDCT_SIMPLENEON 22 ++#define FF_IDCT_SIMPLEAUTO 128 ++ ++ /** ++ * bits per sample/pixel from the demuxer (needed for huffyuv). ++ * - encoding: Set by libavcodec. ++ * - decoding: Set by user. ++ */ ++ int bits_per_coded_sample; ++ ++ /** ++ * Bits per sample/pixel of internal libavcodec pixel/sample format. ++ * - encoding: set by user. ++ * - decoding: set by libavcodec. ++ */ ++ int bits_per_raw_sample; ++ ++ /** ++ * thread count ++ * is used to decide how many independent tasks should be passed to execute() ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ int thread_count; ++ ++ /** ++ * Which multithreading methods to use. ++ * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, ++ * so clients which cannot provide future frames should not use it. ++ * ++ * - 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 ++ ++ /** ++ * Which multithreading methods are in use by the codec. ++ * - encoding: Set by libavcodec. ++ * - decoding: Set by libavcodec. ++ */ ++ int active_thread_type; ++ ++ /** ++ * The codec may call this to execute several independent things. ++ * It will return only after finishing all tasks. ++ * The user may replace this with some multithreaded implementation, ++ * the default implementation will execute the parts serially. ++ * @param count the number of things to execute ++ * - encoding: Set by libavcodec, user can override. ++ * - decoding: Set by libavcodec, user can override. ++ */ ++ int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); ++ ++ /** ++ * The codec may call this to execute several independent things. ++ * It will return only after finishing all tasks. ++ * The user may replace this with some multithreaded implementation, ++ * the default implementation will execute the parts serially. ++ * @param c context passed also to func ++ * @param count the number of things to execute ++ * @param arg2 argument passed unchanged to func ++ * @param ret return values of executed functions, must have space for "count" values. May be NULL. ++ * @param func function that will be called count times, with jobnr from 0 to count-1. ++ * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no ++ * two instances of func executing at the same time will have the same threadnr. ++ * @return always 0 currently, but code should handle a future improvement where when any call to func ++ * returns < 0 no further calls to func may be done and < 0 is returned. ++ * - encoding: Set by libavcodec, user can override. ++ * - decoding: Set by libavcodec, user can override. ++ */ ++ int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); ++ ++ /** ++ * profile ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec. ++ * See the AV_PROFILE_* defines in defs.h. ++ */ ++ int profile; ++ ++ /** ++ * Encoding level descriptor. ++ * - encoding: Set by user, corresponds to a specific level defined by the ++ * codec, usually corresponding to the profile level, if not specified it ++ * is set to AV_LEVEL_UNKNOWN. ++ * - decoding: Set by libavcodec. ++ * See AV_LEVEL_* in defs.h. ++ */ ++ int level; ++ ++ /** ++ * Skip loop filtering for selected frames. ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ enum AVDiscard skip_loop_filter; ++ ++ /** ++ * Skip IDCT/dequantization for selected frames. ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ enum AVDiscard skip_idct; ++ ++ /** ++ * Skip decoding for selected frames. ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ enum AVDiscard skip_frame; ++ ++ /** ++ * Skip processing alpha if supported by codec. ++ * Note that if the format uses pre-multiplied alpha (common with VP6, ++ * and recommended due to better video quality/compression) ++ * the image will look as if alpha-blended onto a black background. ++ * However for formats that do not use pre-multiplied alpha ++ * there might be serious artefacts (though e.g. libswscale currently ++ * assumes pre-multiplied alpha anyway). ++ * ++ * - decoding: set by user ++ * - encoding: unused ++ */ ++ int skip_alpha; ++ ++ /** ++ * Number of macroblock rows at the top which are skipped. ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ int skip_top; ++ ++ /** ++ * Number of macroblock rows at the bottom which are skipped. ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ int skip_bottom; ++ ++ /** ++ * low resolution decoding, 1-> 1/2 size, 2->1/4 size ++ * - encoding: unused ++ * - decoding: Set by user. ++ */ ++ int lowres; ++ ++ /** ++ * AVCodecDescriptor ++ * - encoding: unused. ++ * - decoding: set by libavcodec. ++ */ ++ const struct AVCodecDescriptor *codec_descriptor; ++ ++ /** ++ * Character encoding of the input subtitles file. ++ * - decoding: set by user ++ * - encoding: unused ++ */ ++ char *sub_charenc; ++ ++ /** ++ * Subtitles character encoding mode. Formats or codecs might be adjusting ++ * this setting (if they are doing the conversion themselves for instance). ++ * - decoding: set by libavcodec ++ * - encoding: unused ++ */ ++ int sub_charenc_mode; ++#define FF_SUB_CHARENC_MODE_DO_NOTHING -1 ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance) ++#define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself ++#define FF_SUB_CHARENC_MODE_PRE_DECODER 1 ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv ++#define FF_SUB_CHARENC_MODE_IGNORE 2 ///< neither convert the subtitles, nor check them for valid UTF-8 ++ ++ /** ++ * Header containing style information for text subtitles. ++ * For SUBTITLE_ASS subtitle type, it should contain the whole ASS ++ * [Script Info] and [V4+ Styles] section, plus the [Events] line and ++ * the Format line following. It shouldn't include any Dialogue line. ++ * ++ * - encoding: May be set by the caller before avcodec_open2() to an array ++ * allocated with the av_malloc() family of functions. ++ * - decoding: May be set by libavcodec in avcodec_open2(). ++ * ++ * After being set, the array is owned by the codec and freed in ++ * avcodec_free_context(). ++ */ ++ int subtitle_header_size; ++ uint8_t *subtitle_header; ++ ++ /** ++ * dump format separator. ++ * can be ", " or "\n " or anything else ++ * - encoding: Set by user. ++ * - decoding: Set by user. ++ */ ++ uint8_t *dump_separator; ++ ++ /** ++ * ',' separated list of allowed decoders. ++ * If NULL then all are allowed ++ * - encoding: unused ++ * - decoding: set by user ++ */ ++ char *codec_whitelist; ++ ++ /** ++ * Additional data associated with the entire coded stream. ++ * ++ * - decoding: may be set by user before calling avcodec_open2(). ++ * - encoding: may be set by libavcodec after avcodec_open2(). ++ */ ++ AVPacketSideData *coded_side_data; ++ int nb_coded_side_data; ++ ++ /** ++ * Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of ++ * metadata exported in frame, packet, or coded stream side data by ++ * decoders and encoders. ++ * ++ * - decoding: set by user ++ * - encoding: set by user ++ */ ++ int export_side_data; ++ ++ /** ++ * The number of pixels per image to maximally accept. ++ * ++ * - decoding: set by user ++ * - encoding: set by user ++ */ ++ int64_t max_pixels; ++ ++ /** ++ * Video decoding only. Certain video codecs support cropping, meaning that ++ * only a sub-rectangle of the decoded frame is intended for display. This ++ * option controls how cropping is handled by libavcodec. ++ * ++ * When set to 1 (the default), libavcodec will apply cropping internally. ++ * I.e. it will modify the output frame width/height fields and offset the ++ * data pointers (only by as much as possible while preserving alignment, or ++ * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that ++ * the frames output by the decoder refer only to the cropped area. The ++ * crop_* fields of the output frames will be zero. ++ * ++ * When set to 0, the width/height fields of the output frames will be set ++ * to the coded dimensions and the crop_* fields will describe the cropping ++ * rectangle. Applying the cropping is left to the caller. ++ * ++ * @warning When hardware acceleration with opaque output frames is used, ++ * libavcodec is unable to apply cropping from the top/left border. ++ * ++ * @note when this option is set to zero, the width/height fields of the ++ * AVCodecContext and output AVFrames have different meanings. The codec ++ * context fields store display dimensions (with the coded dimensions in ++ * coded_width/height), while the frame fields store the coded dimensions ++ * (with the display dimensions being determined by the crop_* fields). ++ */ ++ int apply_cropping; ++ ++ /** ++ * The percentage of damaged samples to discard a frame. ++ * ++ * - decoding: set by user ++ * - encoding: unused ++ */ ++ int discard_damaged_percentage; ++ ++ /** ++ * The number of samples per frame to maximally accept. ++ * ++ * - decoding: set by user ++ * - encoding: set by user ++ */ ++ int64_t max_samples; ++ ++ /** ++ * This callback is called at the beginning of each packet to get a data ++ * buffer for it. ++ * ++ * The following field will be set in the packet before this callback is ++ * called: ++ * - size ++ * This callback must use the above value to calculate the required buffer size, ++ * which must padded by at least AV_INPUT_BUFFER_PADDING_SIZE bytes. ++ * ++ * In some specific cases, the encoder may not use the entire buffer allocated by this ++ * callback. This will be reflected in the size value in the packet once returned by ++ * avcodec_receive_packet(). ++ * ++ * This callback must fill the following fields in the packet: ++ * - data: alignment requirements for AVPacket apply, if any. Some architectures and ++ * encoders may benefit from having aligned data. ++ * - buf: must contain a pointer to an AVBufferRef structure. The packet's ++ * data pointer must be contained in it. See: av_buffer_create(), av_buffer_alloc(), ++ * and av_buffer_ref(). ++ * ++ * If AV_CODEC_CAP_DR1 is not set then get_encode_buffer() must call ++ * avcodec_default_get_encode_buffer() instead of providing a buffer allocated by ++ * some other means. ++ * ++ * The flags field may contain a combination of AV_GET_ENCODE_BUFFER_FLAG_ flags. ++ * They may be used for example to hint what use the buffer may get after being ++ * created. ++ * Implementations of this callback may ignore flags they don't understand. ++ * If AV_GET_ENCODE_BUFFER_FLAG_REF is set in flags then the packet may be reused ++ * (read and/or written to if it is writable) later by libavcodec. ++ * ++ * This callback must be thread-safe, as when frame threading is used, it may ++ * be called from multiple threads simultaneously. ++ * ++ * @see avcodec_default_get_encode_buffer() ++ * ++ * - encoding: Set by libavcodec, user can override. ++ * - decoding: unused ++ */ ++ int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags); ++ ++ /** ++ * Frame counter, set by libavcodec. ++ * ++ * - decoding: total number of frames returned from the decoder so far. ++ * - encoding: total number of frames passed to the encoder so far. ++ * ++ * @note the counter is not incremented if encoding/decoding resulted in ++ * an error. ++ */ ++ int64_t frame_num; ++ ++ /** ++ * Decoding only. May be set by the caller before avcodec_open2() to an ++ * av_malloc()'ed array (or via AVOptions). Owned and freed by the decoder ++ * afterwards. ++ * ++ * Side data attached to decoded frames may come from several sources: ++ * 1. coded_side_data, which the decoder will for certain types translate ++ * from packet-type to frame-type and attach to frames; ++ * 2. side data attached to an AVPacket sent for decoding (same ++ * considerations as above); ++ * 3. extracted from the coded bytestream. ++ * The first two cases are supplied by the caller and typically come from a ++ * container. ++ * ++ * This array configures decoder behaviour in cases when side data of the ++ * same type is present both in the coded bytestream and in the ++ * user-supplied side data (items 1. and 2. above). In all cases, at most ++ * one instance of each side data type will be attached to output frames. By ++ * default it will be the bytestream side data. Adding an ++ * AVPacketSideDataType value to this array will flip the preference for ++ * this type, thus making the decoder prefer user-supplied side data over ++ * bytestream. In case side data of the same type is present both in ++ * coded_data and attacked to a packet, the packet instance always has ++ * priority. ++ * ++ * The array may also contain a single -1, in which case the preference is ++ * switched for all side data types. ++ */ ++ int *side_data_prefer_packet; ++ /** ++ * Number of entries in side_data_prefer_packet. ++ */ ++ unsigned nb_side_data_prefer_packet; ++ ++ /** ++ * Array containing static side data, such as HDR10 CLL / MDCV structures. ++ * Side data entries should be allocated by usage of helpers defined in ++ * libavutil/frame.h. ++ * ++ * - encoding: may be set by user before calling avcodec_open2() for ++ * encoder configuration. Afterwards owned and freed by the ++ * encoder. ++ * - decoding: may be set by libavcodec in avcodec_open2(). ++ */ ++ AVFrameSideData **decoded_side_data; ++ int nb_decoded_side_data; ++ ++ /** ++ * Indicates how the alpha channel of the video is represented. ++ * - encoding: Set by user ++ * - decoding: Set by libavcodec ++ */ ++ enum AVAlphaMode alpha_mode; ++} AVCodecContext; ++ ++/** ++ * @defgroup lavc_hwaccel AVHWAccel ++ * ++ * @note Nothing in this structure should be accessed by the user. At some ++ * point in future it will not be externally visible at all. ++ * ++ * @{ ++ */ ++typedef struct AVHWAccel { ++ /** ++ * Name of the hardware accelerated codec. ++ * The name is globally unique among encoders and among decoders (but an ++ * encoder and a decoder can share the same name). ++ */ ++ const char *name; ++ ++ /** ++ * Type of codec implemented by the hardware accelerator. ++ * ++ * See AVMEDIA_TYPE_xxx ++ */ ++ enum AVMediaType type; ++ ++ /** ++ * Codec implemented by the hardware accelerator. ++ * ++ * See AV_CODEC_ID_xxx ++ */ ++ enum AVCodecID id; ++ ++ /** ++ * Supported pixel format. ++ * ++ * Only hardware accelerated formats are supported here. ++ */ ++ enum AVPixelFormat pix_fmt; ++ ++ /** ++ * Hardware accelerated codec capabilities. ++ * see AV_HWACCEL_CODEC_CAP_* ++ */ ++ int capabilities; ++} AVHWAccel; ++ ++/** ++ * HWAccel is experimental and is thus avoided in favor of non experimental ++ * codecs ++ */ ++#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200 ++ ++/** ++ * Hardware acceleration should be used for decoding even if the codec level ++ * used is unknown or higher than the maximum supported level reported by the ++ * hardware driver. ++ * ++ * It's generally a good idea to pass this flag unless you have a specific ++ * reason not to, as hardware tends to under-report supported levels. ++ */ ++#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0) ++ ++/** ++ * Hardware acceleration can output YUV pixel formats with a different chroma ++ * sampling than 4:2:0 and/or other than 8 bits per component. ++ */ ++#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1) ++ ++/** ++ * Hardware acceleration should still be attempted for decoding when the ++ * codec profile does not match the reported capabilities of the hardware. ++ * ++ * For example, this can be used to try to decode baseline profile H.264 ++ * streams in hardware - it will often succeed, because many streams marked ++ * as baseline profile actually conform to constrained baseline profile. ++ * ++ * @warning If the stream is actually not supported then the behaviour is ++ * undefined, and may include returning entirely incorrect output ++ * while indicating success. ++ */ ++#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2) ++ ++/** ++ * Some hardware decoders (namely nvdec) can either output direct decoder ++ * surfaces, or make an on-device copy and return said copy. ++ * There is a hard limit on how many decoder surfaces there can be, and it ++ * cannot be accurately guessed ahead of time. ++ * For some processing chains, this can be okay, but others will run into the ++ * limit and in turn produce very confusing errors that require fine tuning of ++ * more or less obscure options by the user, or in extreme cases cannot be ++ * resolved at all without inserting an avfilter that forces a copy. ++ * ++ * Thus, the hwaccel will by default make a copy for safety and resilience. ++ * If a users really wants to minimize the amount of copies, they can set this ++ * flag and ensure their processing chain does not exhaust the surface pool. ++ */ ++#define AV_HWACCEL_FLAG_UNSAFE_OUTPUT (1 << 3) ++ ++/** ++ * @} ++ */ ++ ++enum AVSubtitleType { ++ SUBTITLE_NONE, ++ ++ SUBTITLE_BITMAP, ///< A bitmap, pict will be set ++ ++ /** ++ * Plain text, the text field must be set by the decoder and is ++ * authoritative. ass and pict fields may contain approximations. ++ */ ++ SUBTITLE_TEXT, ++ ++ /** ++ * Formatted text, the ass field must be set by the decoder and is ++ * authoritative. pict and text fields may contain approximations. ++ */ ++ SUBTITLE_ASS, ++}; ++ ++#define AV_SUBTITLE_FLAG_FORCED 0x00000001 ++ ++typedef struct AVSubtitleRect { ++ int x; ///< top left corner of pict, undefined when pict is not set ++ int y; ///< top left corner of pict, undefined when pict is not set ++ int w; ///< width of pict, undefined when pict is not set ++ int h; ///< height of pict, undefined when pict is not set ++ int nb_colors; ///< number of colors in pict, undefined when pict is not set ++ ++ /** ++ * data+linesize for the bitmap of this subtitle. ++ * Can be set for text/ass as well once they are rendered. ++ */ ++ uint8_t *data[4]; ++ int linesize[4]; ++ ++ int flags; ++ enum AVSubtitleType type; ++ ++ char *text; ///< 0 terminated plain UTF-8 text ++ ++ /** ++ * 0 terminated ASS/SSA compatible event line. ++ * The presentation of this is unaffected by the other values in this ++ * struct. ++ */ ++ char *ass; ++} AVSubtitleRect; ++ ++typedef struct AVSubtitle { ++ uint16_t format; /* 0 = graphics */ ++ uint32_t start_display_time; /* relative to packet pts, in ms */ ++ uint32_t end_display_time; /* relative to packet pts, in ms */ ++ unsigned num_rects; ++ AVSubtitleRect **rects; ++ int64_t pts; ///< Same as packet pts, in AV_TIME_BASE ++} AVSubtitle; ++ ++/** ++ * Return the LIBAVCODEC_VERSION_INT constant. ++ */ ++unsigned avcodec_version(void); ++ ++/** ++ * Return the libavcodec build-time configuration. ++ */ ++const char *avcodec_configuration(void); ++ ++/** ++ * Return the libavcodec license. ++ */ ++const char *avcodec_license(void); ++ ++/** ++ * Allocate an AVCodecContext and set its fields to default values. The ++ * resulting struct should be freed with avcodec_free_context(). ++ * ++ * @param codec if non-NULL, allocate private data and initialize defaults ++ * for the given codec. It is illegal to then call avcodec_open2() ++ * with a different codec. ++ * If NULL, then the codec-specific defaults won't be initialized, ++ * which may result in suboptimal default settings (this is ++ * important mainly for encoders, e.g. libx264). ++ * ++ * @return An AVCodecContext filled with default values or NULL on failure. ++ */ ++AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); ++ ++/** ++ * Free the codec context and everything associated with it and write NULL to ++ * the provided pointer. ++ */ ++void avcodec_free_context(AVCodecContext **avctx); ++ ++/** ++ * Get the AVClass for AVCodecContext. It can be used in combination with ++ * AV_OPT_SEARCH_FAKE_OBJ for examining options. ++ * ++ * @see av_opt_find(). ++ */ ++const AVClass *avcodec_get_class(void); ++ ++/** ++ * Get the AVClass for AVSubtitleRect. It can be used in combination with ++ * AV_OPT_SEARCH_FAKE_OBJ for examining options. ++ * ++ * @see av_opt_find(). ++ */ ++const AVClass *avcodec_get_subtitle_rect_class(void); ++ ++/** ++ * Fill the parameters struct based on the values from the supplied codec ++ * context. Any allocated fields in par are freed and replaced with duplicates ++ * of the corresponding fields in codec. ++ * ++ * @return >= 0 on success, a negative AVERROR code on failure ++ * ++ * @relates AVCodecParameters ++ */ ++int avcodec_parameters_from_context(struct AVCodecParameters *par, ++ const AVCodecContext *codec); ++ ++/** ++ * Fill the codec context based on the values from the supplied codec ++ * parameters. Any allocated fields in codec that have a corresponding field in ++ * par are freed and replaced with duplicates of the corresponding field in par. ++ * Fields in codec that do not have a counterpart in par are not touched. ++ * ++ * @return >= 0 on success, a negative AVERROR code on failure. ++ * ++ * @relates AVCodecParameters ++ */ ++int avcodec_parameters_to_context(AVCodecContext *codec, ++ const struct AVCodecParameters *par); ++ ++/** ++ * Initialize the AVCodecContext to use the given AVCodec. Prior to using this ++ * function the context has to be allocated with avcodec_alloc_context3(). ++ * ++ * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), ++ * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for ++ * retrieving a codec. ++ * ++ * Depending on the codec, you might need to set options in the codec context ++ * also for decoding (e.g. width, height, or the pixel or audio sample format in ++ * the case the information is not available in the bitstream, as when decoding ++ * raw audio or video). ++ * ++ * Options in the codec context can be set either by setting them in the options ++ * AVDictionary, or by setting the values in the context itself, directly or by ++ * using the av_opt_set() API before calling this function. ++ * ++ * Example: ++ * @code ++ * av_dict_set(&opts, "b", "2.5M", 0); ++ * codec = avcodec_find_decoder(AV_CODEC_ID_H264); ++ * if (!codec) ++ * exit(1); ++ * ++ * context = avcodec_alloc_context3(codec); ++ * ++ * if (avcodec_open2(context, codec, opts) < 0) ++ * exit(1); ++ * @endcode ++ * ++ * In the case AVCodecParameters are available (e.g. when demuxing a stream ++ * using libavformat, and accessing the AVStream contained in the demuxer), the ++ * codec parameters can be copied to the codec context using ++ * avcodec_parameters_to_context(), as in the following example: ++ * ++ * @code ++ * AVStream *stream = ...; ++ * context = avcodec_alloc_context3(codec); ++ * if (avcodec_parameters_to_context(context, stream->codecpar) < 0) ++ * exit(1); ++ * if (avcodec_open2(context, codec, NULL) < 0) ++ * exit(1); ++ * @endcode ++ * ++ * @note Always call this function before using decoding routines (such as ++ * @ref avcodec_receive_frame()). ++ * ++ * @param avctx The context to initialize. ++ * @param codec The codec to open this context for. If a non-NULL codec has been ++ * previously passed to avcodec_alloc_context3() or ++ * for this context, then this parameter MUST be either NULL or ++ * equal to the previously passed codec. ++ * @param options A dictionary filled with AVCodecContext and codec-private ++ * options, which are set on top of the options already set in ++ * avctx, can be NULL. On return this object will be filled with ++ * options that were not found in the avctx codec context. ++ * ++ * @return zero on success, a negative value on error ++ * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(), ++ * av_dict_set(), av_opt_set(), av_opt_find(), avcodec_parameters_to_context() ++ */ ++int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options); ++ ++/** ++ * Free all allocated data in the given subtitle struct. ++ * ++ * @param sub AVSubtitle to free. ++ */ ++void avsubtitle_free(AVSubtitle *sub); ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @addtogroup lavc_decoding ++ * @{ ++ */ ++ ++/** ++ * The default callback for AVCodecContext.get_buffer2(). It is made public so ++ * it can be called by custom get_buffer2() implementations for decoders without ++ * AV_CODEC_CAP_DR1 set. ++ */ ++int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags); ++ ++/** ++ * The default callback for AVCodecContext.get_encode_buffer(). It is made public so ++ * it can be called by custom get_encode_buffer() implementations for encoders without ++ * AV_CODEC_CAP_DR1 set. ++ */ ++int avcodec_default_get_encode_buffer(AVCodecContext *s, AVPacket *pkt, int flags); ++ ++/** ++ * Modify width and height values so that they will result in a memory ++ * buffer that is acceptable for the codec if you do not use any horizontal ++ * padding. ++ * ++ * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. ++ */ ++void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); ++ ++/** ++ * Modify width and height values so that they will result in a memory ++ * buffer that is acceptable for the codec if you also ensure that all ++ * line sizes are a multiple of the respective linesize_align[i]. ++ * ++ * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. ++ */ ++void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, ++ int linesize_align[AV_NUM_DATA_POINTERS]); ++ ++/** ++ * Decode a subtitle message. ++ * Return a negative value on 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. ++ * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for ++ * simplicity, because the performance difference is expected to be negligible ++ * and reusing a get_buffer written for video codecs would probably perform badly ++ * due to a potentially very different allocation pattern. ++ * ++ * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input ++ * and output. This means that for some packets they will not immediately ++ * produce decoded output and need to be flushed at the end of decoding to get ++ * all the decoded data. Flushing is done by calling this function with packets ++ * with avpkt->data set to NULL and avpkt->size set to 0 until it stops ++ * returning subtitles. It is safe to flush even those decoders that are not ++ * marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned. ++ * ++ * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() ++ * before packets may be fed to the decoder. ++ * ++ * @param avctx the codec context ++ * @param[out] sub The preallocated AVSubtitle in which the decoded subtitle will be stored, ++ * must be freed with avsubtitle_free if *got_sub_ptr is set. ++ * @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, const AVPacket *avpkt); ++ ++/** ++ * Supply raw packet data as input to a decoder. ++ * ++ * Internally, this call will copy relevant AVCodecContext fields, which can ++ * influence decoding per-packet, and apply them when the packet is actually ++ * decoded. (For example AVCodecContext.skip_frame, which might direct the ++ * decoder to drop the frame contained by the packet sent with this function.) ++ * ++ * @warning The input buffer, avpkt->data must be AV_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. ++ * ++ * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() ++ * before packets may be fed to the decoder. ++ * ++ * @param avctx codec context ++ * @param[in] avpkt The input AVPacket. Usually, this will be a single video ++ * frame, or several complete audio frames. ++ * Ownership of the packet remains with the caller, and the ++ * decoder will not write to the packet. The decoder may create ++ * a reference to the packet data (or copy it if the packet is ++ * not reference-counted). ++ * Unlike with older APIs, the packet is always fully consumed, ++ * and if it contains multiple frames (e.g. some audio codecs), ++ * will require you to call avcodec_receive_frame() multiple ++ * times afterwards before you can send a new packet. ++ * It can be NULL (or an AVPacket with data set to NULL and ++ * size set to 0); in this case, it is considered a flush ++ * packet, which signals the end of the stream. Sending the ++ * first flush packet will return success. Subsequent ones are ++ * unnecessary and will return AVERROR_EOF. If the decoder ++ * still has frames buffered, it will return them after sending ++ * a flush packet. ++ * ++ * @retval 0 success ++ * @retval AVERROR(EAGAIN) input is not accepted in the current state - user ++ * must read output with avcodec_receive_frame() (once ++ * all output is read, the packet should be resent, ++ * and the call will not fail with EAGAIN). ++ * @retval AVERROR_EOF the decoder has been flushed, and no new packets can be ++ * sent to it (also returned if more than 1 flush ++ * packet is sent) ++ * @retval AVERROR(EINVAL) codec not opened, it is an encoder, or requires flush ++ * @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar ++ * @retval "another negative error code" legitimate decoding errors ++ */ ++int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt); ++ ++/** ++ * Return decoded output data from a decoder or encoder (when the ++ * @ref AV_CODEC_FLAG_RECON_FRAME flag is used). ++ * ++ * @param avctx codec context ++ * @param frame This will be set to a reference-counted video or audio ++ * frame (depending on the decoder type) allocated by the ++ * codec. Note that the function will always call ++ * av_frame_unref(frame) before doing anything else. ++ * @param flags Combination of AV_CODEC_RECEIVE_FRAME_FLAG_* flags. ++ * ++ * @retval 0 success, a frame was returned ++ * @retval AVERROR(EAGAIN) output is not available in this state - user must ++ * try to send new input ++ * @retval AVERROR_EOF the codec has been fully flushed, and there will be ++ * no more output frames ++ * @retval AVERROR(EINVAL) codec not opened, or it is an encoder without the ++ * @ref AV_CODEC_FLAG_RECON_FRAME flag enabled ++ * @retval "other negative error code" legitimate decoding errors ++ */ ++int avcodec_receive_frame_flags(AVCodecContext *avctx, AVFrame *frame, unsigned flags); ++ ++/** ++ * Alias for `avcodec_receive_frame_flags(avctx, frame, 0)`. ++ */ ++int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame); ++ ++/** ++ * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet() ++ * to retrieve buffered output packets. ++ * ++ * @param avctx codec context ++ * @param[in] frame AVFrame containing the raw audio or video frame to be encoded. ++ * Ownership of the frame remains with the caller, and the ++ * encoder will not write to the frame. The encoder may create ++ * a reference to the frame data (or copy it if the frame is ++ * not reference-counted). ++ * It can be NULL, in which case it is considered a flush ++ * packet. This signals the end of the stream. If the encoder ++ * still has packets buffered, it will return them after this ++ * call. Once flushing mode has been entered, additional flush ++ * packets are ignored, and sending frames will return ++ * AVERROR_EOF. ++ * ++ * For audio: ++ * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame ++ * can have any number of samples. ++ * If it is not set, or AV_CODEC_FLAG2_FIXED_FRAME_SIZE was ++ * requested, then frame->nb_samples must be equal to ++ * avctx->frame_size for all frames except the last. ++ * The final frame may be smaller than avctx->frame_size. ++ * @retval 0 success ++ * @retval AVERROR(EAGAIN) input is not accepted in the current state - user must ++ * read output with avcodec_receive_packet() (once all ++ * output is read, the packet should be resent, and the ++ * call will not fail with EAGAIN). ++ * @retval AVERROR_EOF the encoder has been flushed, and no new frames can ++ * be sent to it ++ * @retval AVERROR(EINVAL) codec not opened, it is a decoder, or requires flush ++ * @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar ++ * @retval "another negative error code" legitimate encoding errors ++ */ ++int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame); ++ ++/** ++ * Read encoded data from the encoder. ++ * ++ * @param avctx codec context ++ * @param avpkt This will be set to a reference-counted packet allocated by the ++ * encoder. Note that the function will always call ++ * av_packet_unref(avpkt) before doing anything else. ++ * @retval 0 success ++ * @retval AVERROR(EAGAIN) output is not available in the current state - user must ++ * try to send input ++ * @retval AVERROR_EOF the encoder has been fully flushed, and there will be no ++ * more output packets ++ * @retval AVERROR(EINVAL) codec not opened, or it is a decoder ++ * @retval "another negative error code" legitimate encoding errors ++ */ ++int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt); ++ ++/** ++ * Create and return a AVHWFramesContext with values adequate for hardware ++ * decoding. This is meant to get called from the get_format callback, and is ++ * a helper for preparing a AVHWFramesContext for AVCodecContext.hw_frames_ctx. ++ * This API is for decoding with certain hardware acceleration modes/APIs only. ++ * ++ * The returned AVHWFramesContext is not initialized. The caller must do this ++ * with av_hwframe_ctx_init(). ++ * ++ * Calling this function is not a requirement, but makes it simpler to avoid ++ * codec or hardware API specific details when manually allocating frames. ++ * ++ * Alternatively to this, an API user can set AVCodecContext.hw_device_ctx, ++ * which sets up AVCodecContext.hw_frames_ctx fully automatically, and makes ++ * it unnecessary to call this function or having to care about ++ * AVHWFramesContext initialization at all. ++ * ++ * There are a number of requirements for calling this function: ++ * ++ * - It must be called from get_format with the same avctx parameter that was ++ * passed to get_format. Calling it outside of get_format is not allowed, and ++ * can trigger undefined behavior. ++ * - The function is not always supported (see description of return values). ++ * Even if this function returns successfully, hwaccel initialization could ++ * fail later. (The degree to which implementations check whether the stream ++ * is actually supported varies. Some do this check only after the user's ++ * get_format callback returns.) ++ * - The hw_pix_fmt must be one of the choices suggested by get_format. If the ++ * user decides to use a AVHWFramesContext prepared with this API function, ++ * the user must return the same hw_pix_fmt from get_format. ++ * - The device_ref passed to this function must support the given hw_pix_fmt. ++ * - After calling this API function, it is the user's responsibility to ++ * initialize the AVHWFramesContext (returned by the out_frames_ref parameter), ++ * and to set AVCodecContext.hw_frames_ctx to it. If done, this must be done ++ * before returning from get_format (this is implied by the normal ++ * AVCodecContext.hw_frames_ctx API rules). ++ * - The AVHWFramesContext parameters may change every time time get_format is ++ * called. Also, AVCodecContext.hw_frames_ctx is reset before get_format. So ++ * you are inherently required to go through this process again on every ++ * get_format call. ++ * - It is perfectly possible to call this function without actually using ++ * the resulting AVHWFramesContext. One use-case might be trying to reuse a ++ * previously initialized AVHWFramesContext, and calling this API function ++ * only to test whether the required frame parameters have changed. ++ * - Fields that use dynamically allocated values of any kind must not be set ++ * by the user unless setting them is explicitly allowed by the documentation. ++ * If the user sets AVHWFramesContext.free and AVHWFramesContext.user_opaque, ++ * the new free callback must call the potentially set previous free callback. ++ * This API call may set any dynamically allocated fields, including the free ++ * callback. ++ * ++ * The function will set at least the following fields on AVHWFramesContext ++ * (potentially more, depending on hwaccel API): ++ * ++ * - All fields set by av_hwframe_ctx_alloc(). ++ * - Set the format field to hw_pix_fmt. ++ * - Set the sw_format field to the most suited and most versatile format. (An ++ * implication is that this will prefer generic formats over opaque formats ++ * with arbitrary restrictions, if possible.) ++ * - Set the width/height fields to the coded frame size, rounded up to the ++ * API-specific minimum alignment. ++ * - Only _if_ the hwaccel requires a pre-allocated pool: set the initial_pool_size ++ * field to the number of maximum reference surfaces possible with the codec, ++ * plus 1 surface for the user to work (meaning the user can safely reference ++ * at most 1 decoded surface at a time), plus additional buffering introduced ++ * by frame threading. If the hwaccel does not require pre-allocation, the ++ * field is left to 0, and the decoder will allocate new surfaces on demand ++ * during decoding. ++ * - Possibly AVHWFramesContext.hwctx fields, depending on the underlying ++ * hardware API. ++ * ++ * Essentially, out_frames_ref returns the same as av_hwframe_ctx_alloc(), but ++ * with basic frame parameters set. ++ * ++ * The function is stateless, and does not change the AVCodecContext or the ++ * device_ref AVHWDeviceContext. ++ * ++ * @param avctx The context which is currently calling get_format, and which ++ * implicitly contains all state needed for filling the returned ++ * AVHWFramesContext properly. ++ * @param device_ref A reference to the AVHWDeviceContext describing the device ++ * which will be used by the hardware decoder. ++ * @param hw_pix_fmt The hwaccel format you are going to return from get_format. ++ * @param out_frames_ref On success, set to a reference to an _uninitialized_ ++ * AVHWFramesContext, created from the given device_ref. ++ * Fields will be set to values required for decoding. ++ * Not changed if an error is returned. ++ * @return zero on success, a negative value on error. The following error codes ++ * have special semantics: ++ * AVERROR(ENOENT): the decoder does not support this functionality. Setup ++ * is always manual, or it is a decoder which does not ++ * support setting AVCodecContext.hw_frames_ctx at all, ++ * or it is a software format. ++ * AVERROR(EINVAL): it is known that hardware decoding is not supported for ++ * this configuration, or the device_ref is not supported ++ * for the hwaccel referenced by hw_pix_fmt. ++ */ ++int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, ++ AVBufferRef *device_ref, ++ enum AVPixelFormat hw_pix_fmt, ++ AVBufferRef **out_frames_ref); ++ ++enum AVCodecConfig { ++ AV_CODEC_CONFIG_PIX_FORMAT, ///< AVPixelFormat, terminated by AV_PIX_FMT_NONE ++ AV_CODEC_CONFIG_FRAME_RATE, ///< AVRational, terminated by {0, 0} ++ AV_CODEC_CONFIG_SAMPLE_RATE, ///< int, terminated by 0 ++ AV_CODEC_CONFIG_SAMPLE_FORMAT, ///< AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE ++ AV_CODEC_CONFIG_CHANNEL_LAYOUT, ///< AVChannelLayout, terminated by {0} ++ AV_CODEC_CONFIG_COLOR_RANGE, ///< AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED ++ AV_CODEC_CONFIG_COLOR_SPACE, ///< AVColorSpace, terminated by AVCOL_SPC_UNSPECIFIED ++ AV_CODEC_CONFIG_ALPHA_MODE, ///< AVAlphaMode, terminated by AVALPHA_MODE_UNSPECIFIED ++}; ++ ++/** ++ * Retrieve a list of all supported values for a given configuration type. ++ * ++ * @param avctx An optional context to use. Values such as ++ * `strict_std_compliance` may affect the result. If NULL, ++ * default values are used. ++ * @param codec The codec to query, or NULL to use avctx->codec. ++ * @param config The configuration to query. ++ * @param flags Currently unused; should be set to zero. ++ * @param out_configs On success, set to a list of configurations, terminated ++ * by a config-specific terminator, or NULL if all ++ * possible values are supported. ++ * @param out_num_configs On success, set to the number of elements in ++ *out_configs, excluding the terminator. Optional. ++ */ ++int avcodec_get_supported_config(const AVCodecContext *avctx, ++ const AVCodec *codec, enum AVCodecConfig config, ++ unsigned flags, const void **out_configs, ++ int *out_num_configs); ++ ++ ++ ++/** ++ * @defgroup lavc_parsing Frame parsing ++ * @{ ++ */ ++ ++enum AVPictureStructure { ++ AV_PICTURE_STRUCTURE_UNKNOWN, ///< unknown ++ AV_PICTURE_STRUCTURE_TOP_FIELD, ///< coded as top field ++ AV_PICTURE_STRUCTURE_BOTTOM_FIELD, ///< coded as bottom field ++ AV_PICTURE_STRUCTURE_FRAME, ///< coded as frame ++}; ++ ++typedef struct AVCodecParserContext { ++ void *priv_data; ++ const struct AVCodecParser *parser; ++ int64_t frame_offset; /* offset of the current frame */ ++ int64_t cur_offset; /* current offset ++ (incremented by each av_parser_parse()) */ ++ int64_t next_frame_offset; /* offset of the next frame */ ++ /* video info */ ++ int pict_type; /* XXX: Put it back in AVCodecContext. */ ++ /** ++ * This field is used for proper frame duration computation in lavf. ++ * It signals, how much longer the frame duration of the current frame ++ * is compared to normal frame duration. ++ * ++ * frame_duration = (1 + repeat_pict) * time_base ++ * ++ * It is used by codecs like H.264 to display telecined material. ++ */ ++ int repeat_pict; /* XXX: Put it back in AVCodecContext. */ ++ int64_t pts; /* pts of the current frame */ ++ int64_t dts; /* dts of the current frame */ ++ ++ /* private data */ ++ int64_t last_pts; ++ int64_t last_dts; ++ int fetch_timestamp; ++ ++#define AV_PARSER_PTS_NB 4 ++ int cur_frame_start_index; ++ int64_t cur_frame_offset[AV_PARSER_PTS_NB]; ++ int64_t cur_frame_pts[AV_PARSER_PTS_NB]; ++ int64_t cur_frame_dts[AV_PARSER_PTS_NB]; ++ ++ int flags; ++#define PARSER_FLAG_COMPLETE_FRAMES 0x0001 ++#define PARSER_FLAG_ONCE 0x0002 ++/// Set if the parser has a valid file offset ++#define PARSER_FLAG_FETCHED_OFFSET 0x0004 ++#define PARSER_FLAG_USE_CODEC_TS 0x1000 ++ ++ int64_t offset; ///< byte offset from starting packet start ++ int64_t cur_frame_end[AV_PARSER_PTS_NB]; ++ ++ /** ++ * Set by parser to 1 for key frames and 0 for non-key frames. ++ * It is initialized to -1, so if the parser doesn't set this flag, ++ * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames ++ * will be used. ++ */ ++ int key_frame; ++ ++ // Timestamp generation support: ++ /** ++ * Synchronization point for start of timestamp generation. ++ * ++ * Set to >0 for sync point, 0 for no sync point and <0 for undefined ++ * (default). ++ * ++ * For example, this corresponds to presence of H.264 buffering period ++ * SEI message. ++ */ ++ int dts_sync_point; ++ ++ /** ++ * Offset of the current timestamp against last timestamp sync point in ++ * units of AVCodecContext.time_base. ++ * ++ * Set to INT_MIN when dts_sync_point unused. Otherwise, it must ++ * contain a valid timestamp offset. ++ * ++ * Note that the timestamp of sync point has usually a nonzero ++ * dts_ref_dts_delta, which refers to the previous sync point. Offset of ++ * the next frame after timestamp sync point will be usually 1. ++ * ++ * For example, this corresponds to H.264 cpb_removal_delay. ++ */ ++ int dts_ref_dts_delta; ++ ++ /** ++ * Presentation delay of current frame in units of AVCodecContext.time_base. ++ * ++ * Set to INT_MIN when dts_sync_point unused. Otherwise, it must ++ * contain valid non-negative timestamp delta (presentation time of a frame ++ * must not lie in the past). ++ * ++ * This delay represents the difference between decoding and presentation ++ * time of the frame. ++ * ++ * For example, this corresponds to H.264 dpb_output_delay. ++ */ ++ int pts_dts_delta; ++ ++ /** ++ * Position of the packet in file. ++ * ++ * Analogous to cur_frame_pts/dts ++ */ ++ int64_t cur_frame_pos[AV_PARSER_PTS_NB]; ++ ++ /** ++ * Byte position of currently parsed frame in stream. ++ */ ++ int64_t pos; ++ ++ /** ++ * Previous frame byte position. ++ */ ++ int64_t last_pos; ++ ++ /** ++ * Duration of the current frame. ++ * For audio, this is in units of 1 / AVCodecContext.sample_rate. ++ * For all other types, this is in units of AVCodecContext.time_base. ++ */ ++ int duration; ++ ++ enum AVFieldOrder field_order; ++ ++ /** ++ * Indicate whether a picture is coded as a frame, top field or bottom field. ++ * ++ * For example, H.264 field_pic_flag equal to 0 corresponds to ++ * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag ++ * equal to 1 and bottom_field_flag equal to 0 corresponds to ++ * AV_PICTURE_STRUCTURE_TOP_FIELD. ++ */ ++ enum AVPictureStructure picture_structure; ++ ++ /** ++ * Picture number incremented in presentation or output order. ++ * This field may be reinitialized at the first picture of a new sequence. ++ * ++ * For example, this corresponds to H.264 PicOrderCnt. ++ */ ++ int output_picture_number; ++ ++ /** ++ * Dimensions of the decoded video intended for presentation. ++ */ ++ int width; ++ int height; ++ ++ /** ++ * Dimensions of the coded video. ++ */ ++ int coded_width; ++ int coded_height; ++ ++ /** ++ * The format of the coded data, corresponds to enum AVPixelFormat for video ++ * and for enum AVSampleFormat for audio. ++ * ++ * Note that a decoder can have considerable freedom in how exactly it ++ * decodes the data, so the format reported here might be different from the ++ * one returned by a decoder. ++ */ ++ int format; ++} AVCodecParserContext; ++ ++typedef struct AVCodecParser { ++ enum AVCodecID codec_ids[7]; /* several codec IDs are permitted */ ++} AVCodecParser; ++ ++/** ++ * Iterate over all registered codec parsers. ++ * ++ * @param opaque a pointer where libavcodec will store the iteration state. Must ++ * point to NULL to start the iteration. ++ * ++ * @return the next registered codec parser or NULL when the iteration is ++ * finished ++ */ ++const AVCodecParser *av_parser_iterate(void **opaque); ++ ++AVCodecParserContext *av_parser_init(enum AVCodecID codec_id); ++ ++/** ++ * Parse a packet. ++ * ++ * @param s parser context. ++ * @param avctx codec context. ++ * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. ++ * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. ++ * @param buf input buffer. ++ * @param buf_size buffer size in bytes without the padding. I.e. the full buffer ++ size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE. ++ To signal EOF, this should be 0 (so that the last frame ++ can be output). ++ * @param pts input presentation timestamp. ++ * @param dts input decoding timestamp. ++ * @param pos input byte position in stream. ++ * @return the number of bytes of the input bitstream used. ++ * ++ * Example: ++ * @code ++ * while(in_len){ ++ * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, ++ * in_data, in_len, ++ * pts, dts, pos); ++ * in_data += len; ++ * in_len -= len; ++ * ++ * if(size) ++ * decode_frame(data, size); ++ * } ++ * @endcode ++ */ ++int av_parser_parse2(AVCodecParserContext *s, ++ AVCodecContext *avctx, ++ uint8_t **poutbuf, int *poutbuf_size, ++ const uint8_t *buf, int buf_size, ++ int64_t pts, int64_t dts, ++ int64_t pos); ++ ++void av_parser_close(AVCodecParserContext *s); ++ ++/** ++ * @} ++ * @} ++ */ ++ ++/** ++ * @addtogroup lavc_encoding ++ * @{ ++ */ ++ ++int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, ++ const AVSubtitle *sub); ++ ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @defgroup lavc_misc Utility functions ++ * @ingroup libavc ++ * ++ * Miscellaneous utility functions related to both encoding and decoding ++ * (or neither). ++ * @{ ++ */ ++ ++/** ++ * @defgroup lavc_misc_pixfmt Pixel formats ++ * ++ * Functions for working with pixel formats. ++ * @{ ++ */ ++ ++/** ++ * Return a value representing the fourCC code associated to the ++ * pixel format pix_fmt, or 0 if no associated fourCC code can be ++ * found. ++ */ ++unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt); ++ ++/** ++ * Find the best pixel format to convert to given a certain source pixel ++ * format. When converting from one pixel format to another, information loss ++ * may occur. For example, when converting from RGB24 to GRAY, the color ++ * information will be lost. Similarly, other losses occur when converting from ++ * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of ++ * the given pixel formats should be used to suffer the least amount of loss. ++ * The pixel formats from which it chooses one, are determined by the ++ * pix_fmt_list parameter. ++ * ++ * ++ * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from ++ * @param[in] src_pix_fmt source pixel format ++ * @param[in] has_alpha Whether the source pixel format alpha channel is used. ++ * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. ++ * @return The best pixel format to convert to or -1 if none was found. ++ */ ++enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list, ++ enum AVPixelFormat src_pix_fmt, ++ int has_alpha, int *loss_ptr); ++ ++enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt); ++ ++/** ++ * @} ++ */ ++ ++void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); ++ ++int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); ++int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); ++//FIXME func typedef ++ ++/** ++ * Fill AVFrame audio data and linesize pointers. ++ * ++ * The buffer buf must be a preallocated buffer with a size big enough ++ * to contain the specified samples amount. The filled AVFrame data ++ * pointers will point to this buffer. ++ * ++ * AVFrame extended_data channel pointers are allocated if necessary for ++ * planar audio. ++ * ++ * @param frame the AVFrame ++ * frame->nb_samples must be set prior to calling the ++ * function. This function fills in frame->data, ++ * frame->extended_data, frame->linesize[0]. ++ * @param nb_channels channel count ++ * @param sample_fmt sample format ++ * @param buf buffer to use for frame data ++ * @param buf_size size of buffer ++ * @param align plane size sample alignment (0 = default) ++ * @return >=0 on success, negative error code on failure ++ * @todo return the size in bytes required to store the samples in ++ * case of success, at the next libavutil bump ++ */ ++int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, ++ enum AVSampleFormat sample_fmt, const uint8_t *buf, ++ int buf_size, int align); ++ ++/** ++ * Reset the internal codec state / flush internal buffers. Should be called ++ * e.g. when seeking or when switching to a different stream. ++ * ++ * @note for decoders, this function just releases any references the decoder ++ * might keep internally, but the caller's references remain valid. ++ * ++ * @note for encoders, this function will only do something if the encoder ++ * declares support for AV_CODEC_CAP_ENCODER_FLUSH. When called, the encoder ++ * will drain any remaining packets, and can then be reused for a different ++ * stream (as opposed to sending a null frame which will leave the encoder ++ * in a permanent EOF state after draining). This can be desirable if the ++ * cost of tearing down and replacing the encoder instance is high. ++ */ ++void avcodec_flush_buffers(AVCodecContext *avctx); ++ ++/** ++ * Return audio frame duration. ++ * ++ * @param avctx codec context ++ * @param frame_bytes size of the frame, or 0 if unknown ++ * @return frame duration, in samples, if known. 0 if not able to ++ * determine. ++ */ ++int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes); ++ ++/* memory */ ++ ++/** ++ * Same behaviour av_fast_malloc but the buffer has additional ++ * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0. ++ * ++ * In addition the whole buffer will initially and after resizes ++ * be 0-initialized so that no uninitialized data will ever appear. ++ */ ++void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size); ++ ++/** ++ * Same behaviour av_fast_padded_malloc except that buffer will always ++ * be 0-initialized after call. ++ */ ++void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size); ++ ++/** ++ * @return a positive value if s is open (i.e. avcodec_open2() was called on it), ++ * 0 otherwise. ++ */ ++int avcodec_is_open(AVCodecContext *s); ++ ++/** ++ * @} ++ */ ++ ++#endif /* AVCODEC_AVCODEC_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avdct.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avdct.h +new file mode 100644 +index 000000000000..f110ba72493e +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/avdct.h +@@ -0,0 +1,91 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_AVDCT_H ++#define AVCODEC_AVDCT_H ++ ++#include ++#include ++ ++#include "libavutil/opt.h" ++ ++/** ++ * AVDCT context. ++ * @note function pointers can be NULL if the specific features have been ++ * disabled at build time. ++ */ ++typedef struct AVDCT { ++ const AVClass *av_class; ++ ++ void (*idct)(int16_t *block /* align 16 */); ++ ++ /** ++ * IDCT input permutation. ++ * Several optimized IDCTs need a permutated input (relative to the ++ * normal order of the reference IDCT). ++ * This permutation must be performed before the idct_put/add. ++ * Note, normally this can be merged with the zigzag/alternate scan
++ * An example to avoid confusion: ++ * - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...) ++ * - (x -> reference DCT -> reference IDCT -> x) ++ * - (x -> reference DCT -> simple_mmx_perm = idct_permutation ++ * -> simple_idct_mmx -> x) ++ * - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant ++ * -> simple_idct_mmx -> ...) ++ */ ++ uint8_t idct_permutation[64]; ++ ++ void (*fdct)(int16_t *block /* align 16 */); ++ ++ ++ /** ++ * DCT algorithm. ++ * must use AVOptions to set this field. ++ */ ++ int dct_algo; ++ ++ /** ++ * IDCT algorithm. ++ * must use AVOptions to set this field. ++ */ ++ int idct_algo; ++ ++ void (*get_pixels)(int16_t *block /* align 16 */, ++ const uint8_t *pixels /* align 8 */, ++ ptrdiff_t line_size); ++ ++ int bits_per_sample; ++ ++ void (*get_pixels_unaligned)(int16_t *block /* align 16 */, ++ const uint8_t *pixels, ++ ptrdiff_t line_size); ++} AVDCT; ++ ++/** ++ * Allocates a AVDCT context. ++ * This needs to be initialized with avcodec_dct_init() after optionally ++ * configuring it with AVOptions. ++ * ++ * To free it use av_free() ++ */ ++AVDCT *avcodec_dct_alloc(void); ++int avcodec_dct_init(AVDCT *); ++ ++const AVClass *avcodec_dct_get_class(void); ++ ++#endif /* AVCODEC_AVDCT_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/bsf.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/bsf.h +new file mode 100644 +index 000000000000..9bde9a41b810 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/bsf.h +@@ -0,0 +1,708 @@ ++/* ++ * Bitstream filters public API ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_BSF_H ++#define AVCODEC_BSF_H ++ ++#include "libavutil/dict.h" ++#include "libavutil/log.h" ++#include "libavutil/rational.h" ++ ++#include "codec_id.h" ++#include "codec_par.h" ++#include "packet.h" ++ ++/** ++ * @defgroup lavc_bsf Bitstream filters ++ * @ingroup libavc ++ * ++ * Bitstream filters transform encoded media data without decoding it. This ++ * allows e.g. manipulating various header values. Bitstream filters operate on ++ * @ref AVPacket "AVPackets". ++ * ++ * The bitstream filtering API is centered around two structures: ++ * AVBitStreamFilter and AVBSFContext. The former represents a bitstream filter ++ * in abstract, the latter a specific filtering process. Obtain an ++ * AVBitStreamFilter using av_bsf_get_by_name() or av_bsf_iterate(), then pass ++ * it to av_bsf_alloc() to create an AVBSFContext. Fill in the user-settable ++ * AVBSFContext fields, as described in its documentation, then call ++ * av_bsf_init() to prepare the filter context for use. ++ * ++ * Submit packets for filtering using av_bsf_send_packet(), obtain filtered ++ * results with av_bsf_receive_packet(). When no more input packets will be ++ * sent, submit a NULL AVPacket to signal the end of the stream to the filter. ++ * av_bsf_receive_packet() will then return trailing packets, if any are ++ * produced by the filter. ++ * ++ * Finally, free the filter context with av_bsf_free(). ++ * @{ ++ */ ++ ++/** ++ * The bitstream filter state. ++ * ++ * This struct must be allocated with av_bsf_alloc() and freed with ++ * av_bsf_free(). ++ * ++ * The fields in the struct will only be changed (by the caller or by the ++ * filter) as described in their documentation, and are to be considered ++ * immutable otherwise. ++ */ ++typedef struct AVBSFContext { ++ /** ++ * A class for logging and AVOptions ++ */ ++ const AVClass *av_class; ++ ++ /** ++ * The bitstream filter this context is an instance of. ++ */ ++ const struct AVBitStreamFilter *filter; ++ ++ /** ++ * Opaque filter-specific private data. If filter->priv_class is non-NULL, ++ * this is an AVOptions-enabled struct. ++ */ ++ void *priv_data; ++ ++ /** ++ * Parameters of the input stream. This field is allocated in ++ * av_bsf_alloc(), it needs to be filled by the caller before ++ * av_bsf_init(). ++ */ ++ AVCodecParameters *par_in; ++ ++ /** ++ * Parameters of the output stream. This field is allocated in ++ * av_bsf_alloc(), it is set by the filter in av_bsf_init(). ++ */ ++ AVCodecParameters *par_out; ++ ++ /** ++ * The timebase used for the timestamps of the input packets. Set by the ++ * caller before av_bsf_init(). ++ */ ++ AVRational time_base_in; ++ ++ /** ++ * The timebase used for the timestamps of the output packets. Set by the ++ * filter in av_bsf_init(). ++ */ ++ AVRational time_base_out; ++} AVBSFContext; ++ ++typedef struct AVBitStreamFilter { ++ const char *name; ++ ++ /** ++ * A list of codec ids supported by the filter, terminated by ++ * AV_CODEC_ID_NONE. ++ * May be NULL, in that case the bitstream filter works with any codec id. ++ */ ++ const enum AVCodecID *codec_ids; ++ ++ /** ++ * A class for the private data, used to declare bitstream filter private ++ * AVOptions. This field is NULL for bitstream filters that do not declare ++ * any options. ++ * ++ * If this field is non-NULL, the first member of the filter private data ++ * must be a pointer to AVClass, which will be set by libavcodec generic ++ * code to this class. ++ */ ++ const AVClass *priv_class; ++} AVBitStreamFilter; ++ ++/** ++ * @return a bitstream filter with the specified name or NULL if no such ++ * bitstream filter exists. ++ */ ++const AVBitStreamFilter *av_bsf_get_by_name(const char *name); ++ ++/** ++ * Iterate over all registered bitstream filters. ++ * ++ * @param opaque a pointer where libavcodec will store the iteration state. Must ++ * point to NULL to start the iteration. ++ * ++ * @return the next registered bitstream filter or NULL when the iteration is ++ * finished ++ */ ++const AVBitStreamFilter *av_bsf_iterate(void **opaque); ++ ++/** ++ * Allocate a context for a given bitstream filter. The caller must fill in the ++ * context parameters as described in the documentation and then call ++ * av_bsf_init() before sending any data to the filter. ++ * ++ * @param filter the filter for which to allocate an instance. ++ * @param[out] ctx a pointer into which the pointer to the newly-allocated context ++ * will be written. It must be freed with av_bsf_free() after the ++ * filtering is done. ++ * ++ * @return 0 on success, a negative AVERROR code on failure ++ */ ++int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx); ++ ++/** ++ * Prepare the filter for use, after all the parameters and options have been ++ * set. ++ * ++ * @param ctx a AVBSFContext previously allocated with av_bsf_alloc() ++ */ ++int av_bsf_init(AVBSFContext *ctx); ++ ++/** ++ * Submit a packet for filtering. ++ * ++ * After sending each packet, the filter must be completely drained by calling ++ * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or ++ * AVERROR_EOF. ++ * ++ * @param ctx an initialized AVBSFContext ++ * @param pkt the packet to filter. The bitstream filter will take ownership of ++ * the packet and reset the contents of pkt. pkt is not touched if an error occurs. ++ * If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero), ++ * it signals the end of the stream (i.e. no more non-empty packets will be sent; ++ * sending more empty packets does nothing) and will cause the filter to output ++ * any packets it may have buffered internally. ++ * ++ * @return ++ * - 0 on success. ++ * - AVERROR(EAGAIN) if packets need to be retrieved from the filter (using ++ * av_bsf_receive_packet()) before new input can be consumed. ++ * - Another negative AVERROR value if an error occurs. ++ */ ++int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt); ++ ++/** ++ * Retrieve a filtered packet. ++ * ++ * @param ctx an initialized AVBSFContext ++ * @param[out] pkt this struct will be filled with the contents of the filtered ++ * packet. It is owned by the caller and must be freed using ++ * av_packet_unref() when it is no longer needed. ++ * This parameter should be "clean" (i.e. freshly allocated ++ * with av_packet_alloc() or unreffed with av_packet_unref()) ++ * when this function is called. If this function returns ++ * successfully, the contents of pkt will be completely ++ * overwritten by the returned data. On failure, pkt is not ++ * touched. ++ * ++ * @return ++ * - 0 on success. ++ * - AVERROR(EAGAIN) if more packets need to be sent to the filter (using ++ * av_bsf_send_packet()) to get more output. ++ * - AVERROR_EOF if there will be no further output from the filter. ++ * - Another negative AVERROR value if an error occurs. ++ * ++ * @note one input packet may result in several output packets, so after sending ++ * a packet with av_bsf_send_packet(), this function needs to be called ++ * repeatedly until it stops returning 0. It is also possible for a filter to ++ * output fewer packets than were sent to it, so this function may return ++ * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call. ++ */ ++int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt); ++ ++/** ++ * Reset the internal bitstream filter state. Should be called e.g. when seeking. ++ */ ++void av_bsf_flush(AVBSFContext *ctx); ++ ++/** ++ * Free a bitstream filter context and everything associated with it; write NULL ++ * into the supplied pointer. ++ */ ++void av_bsf_free(AVBSFContext **ctx); ++ ++/** ++ * Get the AVClass for AVBSFContext. It can be used in combination with ++ * AV_OPT_SEARCH_FAKE_OBJ for examining options. ++ * ++ * @see av_opt_find(). ++ */ ++const AVClass *av_bsf_get_class(void); ++ ++/** ++ * Structure for chain/list of bitstream filters. ++ * Empty list can be allocated by av_bsf_list_alloc(). ++ */ ++typedef struct AVBSFList AVBSFList; ++ ++/** ++ * Allocate empty list of bitstream filters. ++ * The list must be later freed by av_bsf_list_free() ++ * or finalized by av_bsf_list_finalize(). ++ * ++ * @return Pointer to @ref AVBSFList on success, NULL in case of failure ++ */ ++AVBSFList *av_bsf_list_alloc(void); ++ ++/** ++ * Free list of bitstream filters. ++ * ++ * @param lst Pointer to pointer returned by av_bsf_list_alloc() ++ */ ++void av_bsf_list_free(AVBSFList **lst); ++ ++/** ++ * Append bitstream filter to the list of bitstream filters. ++ * ++ * @param lst List to append to ++ * @param bsf Filter context to be appended ++ * ++ * @return >=0 on success, negative AVERROR in case of failure ++ */ ++int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf); ++ ++/** ++ * Construct new bitstream filter context given it's name and options ++ * and append it to the list of bitstream filters. ++ * ++ * @param lst List to append to ++ * @param bsf_name Name of the bitstream filter ++ * @param options Options for the bitstream filter, can be set to NULL ++ * ++ * @return >=0 on success, negative AVERROR in case of failure ++ */ ++int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options); ++/** ++ * Finalize list of bitstream filters. ++ * ++ * This function will transform @ref AVBSFList to single @ref AVBSFContext, ++ * so the whole chain of bitstream filters can be treated as single filter ++ * freshly allocated by av_bsf_alloc(). ++ * If the call is successful, @ref AVBSFList structure is freed and lst ++ * will be set to NULL. In case of failure, caller is responsible for ++ * freeing the structure by av_bsf_list_free() ++ * ++ * @param lst Filter list structure to be transformed ++ * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure ++ * representing the chain of bitstream filters ++ * ++ * @return >=0 on success, negative AVERROR in case of failure ++ */ ++int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf); ++ ++/** ++ * Parse string describing list of bitstream filters and create single ++ * @ref AVBSFContext describing the whole chain of bitstream filters. ++ * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly ++ * allocated by av_bsf_alloc(). ++ * ++ * @param str String describing chain of bitstream filters in format ++ * `bsf1[=opt1=val1:opt2=val2][,bsf2]` ++ * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure ++ * representing the chain of bitstream filters ++ * ++ * @return >=0 on success, negative AVERROR in case of failure ++ */ ++int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf); ++ ++/** ++ * Get null/pass-through bitstream filter. ++ * ++ * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter ++ * ++ * @return ++ */ ++int av_bsf_get_null_filter(AVBSFContext **bsf); ++ ++/** ++ * @defgroup lavc_bsfgraph Bitstream filter graph ++ * Experimental graph-based API for bitstream filters. ++ * @{ ++ */ ++ ++/** ++ * A link between two filters. This contains pointers to the source and ++ * destination filters between which this link exists, and the indexes of ++ * the pads involved. ++ */ ++typedef struct AVBitStreamFilterLink AVBitStreamFilterLink; ++ ++/** ++ * A filter pad used for either input or output. ++ */ ++typedef struct AVBitStreamFilterPad AVBitStreamFilterPad; ++ ++/** An instance of a filter */ ++typedef struct AVBitStreamFilterContext { ++ /** ++ * A class for logging and AVOptions ++ */ ++ const AVClass *av_class; ++ ++ /** ++ * The bitstream filter this context is an instance of. ++ */ ++ const struct AVBitStreamFilter *filter; ++ ++ /** ++ * name of this filter instance ++ */ ++ char *name; ++ ++ AVBitStreamFilterPad *input_pads; ///< array of input pads ++ AVBitStreamFilterLink **inputs; ///< array of pointers to input links ++ unsigned nb_inputs; ///< number of input pads ++ ++ AVBitStreamFilterPad *output_pads; ///< array of output pads ++ AVBitStreamFilterLink **outputs; ///< array of pointers to output links ++ unsigned nb_outputs; ///< number of output pads ++ ++ /** ++ * Opaque filter-specific private data. If filter->priv_class is non-NULL, ++ * this is an AVOptions-enabled struct. ++ */ ++ void *priv_data; ++ ++ /** ++ * filtergraph this filter belongs to ++ */ ++ struct AVBitStreamFilterGraph *graph; ++} AVBitStreamFilterContext; ++ ++/** ++ * The number of the filter inputs is not determined just by the filter's static ++ * inputs. The filter might add additional inputs during initialization depending ++ * on the options supplied to it. ++ */ ++#define AV_BSF_FLAG_DYNAMIC_INPUTS (1 << 0) ++/** ++ * The number of the filter outputs is not determined just by the filter's static ++ * outputs. The filter might add additional outputs during initialization depending ++ * on the options supplied to it. ++ */ ++#define AV_BSF_FLAG_DYNAMIC_OUTPUTS (1 << 1) ++/** ++ * The filter is a "metadata" filter - it does not modify the packet data in any ++ * way. It may only affect the metadata (i.e. those fields copied by ++ * av_packet_copy_props()). ++ * ++ * More precisely, this means that the data of any packet output by the filter ++ * must be exactly equal to some packet that is received on one of its inputs. ++ * Furthermore, all packets produced on a given output must correspond to packet ++ * received on the same input and their order must be unchanged. ++ * Note that the filter may still drop or duplicate the frames. ++ */ ++#define AV_BSF_FLAG_METADATA_ONLY (1 << 2) ++ ++/** ++ * Get the name of an AVBitStreamFilterPad. ++ * ++ * @param pads an array of AVBitStreamFilterPads ++ * @param pad_idx index of the pad in the array; it is the caller's ++ * responsibility to ensure the index is valid ++ * ++ * @return name of the pad_idx'th pad in pads ++ */ ++const char *av_bsf_pad_get_name(const AVBitStreamFilterPad *pads, int pad_idx); ++ ++/** ++ * Get the codec ids supported by an AVBitStreamFilterPad. ++ * ++ * @param pads an array of AVBitStreamFilterPads ++ * @param pad_idx index of the pad in the array; it is the caller's ++ * responsibility to ensure the index is valid ++ * ++ * @return an array of AVCodecID terminated by AV_CODEC_ID_NONE, or NULL ++ * if the pad has no codec id constrains. ++ */ ++const enum AVCodecID *av_bsf_pad_get_codec_ids(const AVBitStreamFilterPad *pads, int pad_idx); ++ ++/** ++ * Link two filters together. ++ * ++ * @param src the source filter ++ * @param srcpad index of the output pad on the source filter ++ * @param dst the destination filter ++ * @param dstpad index of the input pad on the destination filter ++ * @return zero on success ++ */ ++int av_bsf_link(AVBitStreamFilterContext *src, unsigned srcpad, ++ AVBitStreamFilterContext *dst, unsigned dstpad); ++ ++/** ++ * Initialize a filter with the supplied parameters. ++ * ++ * @param ctx uninitialized filter context to initialize ++ * @param args Options to initialize the filter with. This must be a ++ * ':'-separated list of options in the 'key=value' form. ++ * May be NULL if the options have been set directly using the ++ * AVOptions API or there are no options that need to be set. ++ * @return 0 on success, a negative AVERROR on failure ++ */ ++int av_bsf_init_str(AVBitStreamFilterContext *ctx, const char *args); ++ ++/** ++ * Initialize a filter with the supplied dictionary of options. ++ * ++ * @param ctx uninitialized filter context to initialize ++ * @param options An AVDictionary filled with options for this filter. On ++ * return this parameter will be destroyed and replaced with ++ * a dict containing options that were not found. This dictionary ++ * must be freed by the caller. ++ * May be NULL, then this function is equivalent to ++ * av_bsf_init_str() with the second parameter set to NULL. ++ * @return 0 on success, a negative AVERROR on failure ++ * ++ * @note This function and av_bsf_init_str() do essentially the same thing, ++ * the difference is in manner in which the options are passed. It is up to the ++ * calling code to choose whichever is more preferable. The two functions also ++ * behave differently when some of the provided options are not declared as ++ * supported by the filter. In such a case, av_bsf_init_str() will fail, but ++ * this function will leave those extra options in the options AVDictionary and ++ * continue as usual. ++ */ ++int av_bsf_init_dict(AVBitStreamFilterContext *ctx, AVDictionary **options); ++ ++typedef struct AVBitStreamFilterGraph { ++ const AVClass *av_class; ++ ++ AVBitStreamFilterContext **filters; ++ ++ unsigned nb_filters; ++ ++ /** ++ * Sets the maximum number of buffered packets in the filtergraph combined. ++ * ++ * Zero means no limit. This field must be set before calling ++ * av_bsf_graph_config(). ++ */ ++ unsigned max_buffered_packets; ++} AVBitStreamFilterGraph; ++ ++/** ++ * Allocate a filter graph. ++ * ++ * @return the allocated filter graph on success or NULL. ++ */ ++AVBitStreamFilterGraph *av_bsf_graph_alloc(void); ++ ++/** ++ * Create a new filter instance in a filter graph. ++ * ++ * @param[out] filt_ctx A pointer into which the pointer to the newly-allocated context ++ * will be written on success. May be NULL. Note that it is also ++ * retrievable directly through AVBitStreamFilterGraph.filters or ++ * with @ref av_bsf_graph_get_filter(). ++ * @param[in] filter the filter to create an instance of ++ * @param[in] name Name to give to the new instance (will be copied to ++ * AVBitStreamFilterContext.name). This may be used by the caller to ++ * identify different filters, libavcodec itself assigns no semantics ++ * to this parameter. May be NULL. ++ * @param[in] graph graph in which the new filter will be used ++ * ++ * @note On failure and if filt_ctx is not NULL, *filt_ctx will be set to NULL. ++ * @return a negative AVERROR error code in case of failure, a non negative value otherwise ++ */ ++int av_bsf_graph_alloc_filter(AVBitStreamFilterContext **filt_ctx, ++ const AVBitStreamFilter *filter, ++ const char *name, ++ AVBitStreamFilterGraph *graph); ++ ++/** ++ * A convenience wrapper that allocates and initializes a filter in a single ++ * step. The filter instance is created from the filter filt and inited with the ++ * parameter args. ++ * ++ * @param[out] filt_ctx A pointer into which the pointer to the newly-allocated context ++ * will be written on success. May be NULL. Note that it is also ++ * retrievable directly through AVBitStreamFilterGraph.filters or ++ * with @ref av_bsf_graph_get_filter(). ++ * @param[in] name the instance name to give to the created filter instance ++ * @param[in] graph_ctx the filter graph ++ * @return a negative AVERROR error code in case of failure, a non negative value otherwise ++ * ++ * @note On failure and if filt_ctx is not NULL, *filt_ctx will be set to NULL. ++ * @warning Since the filter is initialized after this function successfully ++ * returns, you MUST NOT set any further options on it. If you need to ++ * do that, call ::av_bsf_graph_alloc_filter(), followed by setting ++ * the options, followed by ::av_bsf_init_dict() instead of this ++ * function. ++ */ ++int av_bsf_graph_create_filter(AVBitStreamFilterContext **filt_ctx, ++ const AVBitStreamFilter *filt, ++ const char *name, AVDictionary **options, ++ AVBitStreamFilterGraph *graph_ctx); ++ ++/** ++ * Get a filter instance identified by instance name from graph. ++ * ++ * @param graph filter graph to search through. ++ * @param name filter instance name (should be unique in the graph). ++ * @return the pointer to the found filter instance or NULL if it ++ * cannot be found. ++ */ ++AVBitStreamFilterContext *av_bsf_graph_get_filter(AVBitStreamFilterGraph *graph, const char *name); ++ ++/** ++ * Check validity and configure all the links and formats in the graph. ++ * ++ * @param graphctx the filter graph ++ * @param log_ctx context used for logging ++ * @return >= 0 in case of success, a negative AVERROR code otherwise ++ */ ++int av_bsf_graph_config(AVBitStreamFilterGraph *graphctx, void *log_ctx); ++ ++/** ++ * Get the index of the source filter in the filtergraph that reported needing ++ * input more urgently. ++ * ++ * @return the index value of a source filter in the filtergraph, or AVERROR(EOF) ++ * if no source is accepting more packets. ++ */ ++int av_bsf_graph_source_needs_input(const AVBitStreamFilterGraph *graph); ++ ++/** ++ * Free a graph, destroy its links, and set *graph to NULL. ++ * If *graph is NULL, do nothing. ++ */ ++void av_bsf_graph_free(AVBitStreamFilterGraph **graph); ++ ++/** ++ * @defgroup lavc_bsfgraph_source Packet source API ++ * ++ * The source filter is there to connect filter graphs to applications ++ * They have a single output, connected to the graph, and no input. ++ * Packets must be fed to it using av_bsf_source_add_packet(). ++ * @{ ++ */ ++ ++enum { ++ /** ++ * Immediately push the packet to the output. ++ */ ++ AV_BSF_SOURCE_FLAG_PUSH = 1 << 0, ++ ++ /** ++ * Keep a reference to the packet. ++ */ ++ AV_BSF_SOURCE_FLAG_KEEP_REF = 1 << 1, ++}; ++ ++/** ++ * Initialize the source filter with the provided parameters. ++ * This function may be called multiple times, the later calls override the ++ * previous ones. Some of the parameters may also be set through AVOptions, then ++ * whatever method is used last takes precedence. ++ * ++ * @param ctx an instance of the source filter ++ * @param param the stream parameters. The packet later passed to this filter ++ * must conform to those parameters. All the allocated fields in ++ * param remain owned by the caller, libavcodec will make internal ++ * copies or references when necessary. ++ * @return 0 on success, a negative AVERROR code on failure. ++ */ ++int av_bsf_source_parameters_set(AVBitStreamFilterContext *ctx, const AVCodecParameters *par); ++ ++/** ++ * Add a packet to the buffer source. ++ * ++ * By default, this function will take ownership of the reference(s) and reset ++ * the packet. This can be controlled using the flags. ++ * ++ * If this function returns an error, the input packet is not touched. ++ * ++ * @param buffer_src pointer to a source filter context ++ * @param packet a packet, or NULL to mark EOF ++ * @param flags a combination of AV_BSF_FLAG_* ++ * @return >= 0 in case of success, a negative AVERROR code ++ * in case of failure ++ */ ++av_warn_unused_result ++int av_bsf_source_add_packet(AVBitStreamFilterContext *ctx, AVPacket *pkt, int flags); ++ ++/** ++ * Returns 0 or a negative AVERROR code. Currently, this will only ever ++ * return AVERROR(EOF), to indicate that the buffer source has been closed, ++ * either as a result of av_bsf_source_close(), or because the downstream ++ * filter is no longer accepting new data. ++ */ ++int av_bsf_source_get_status(AVBitStreamFilterContext *ctx); ++ ++/** ++ * Close the source after EOF. ++ * ++ * This is similar to passing NULL to av_bsf_source_add_packet() ++ * except it takes the timestamp of the EOF, i.e. the timestamp of the end ++ * of the last packet. ++ */ ++int av_bsf_source_close(AVBitStreamFilterContext *ctx, int64_t pts, unsigned flags); ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @defgroup lavc_bsfgraph_sink Packet sink API ++ * @{ ++ * ++ * The sink filter is there to connect filter graphs to applications ++ * They have a single input, connected to the graph, and no output. ++ * Packets must be extracted using av_bsf_sink_get_packet(). ++ */ ++ ++enum { ++ /** ++ * Tell av_buffersink_get_buffer_ref() to read video/samples buffer ++ * reference, but not remove it from the buffer. This is useful if you ++ * need only to read a video/samples buffer, without to fetch it. ++ */ ++ AV_BSF_SINK_FLAG_PEEK = 1 << 0, ++ ++ /** ++ * Tell av_bsf_sink_get_packet() not to request a packet from its input. ++ * If a packet is already buffered, it is read (and removed from the buffer), ++ * but if no packet is present, return AVERROR(EAGAIN). ++ */ ++ AV_BSF_SINK_FLAG_NO_REQUEST = 1 << 1, ++}; ++ ++/** ++ * Get a packet with filtered data from sink and put it in packet. ++ * ++ * @param ctx pointer to a sink filter context. ++ * @param packet pointer to an allocated packet that will be filled with data. ++ * The data must be freed using av_packet_unref() / av_packet_free() ++ * @param flags a combination of AV_BSF_SINK_FLAG_* flags ++ * ++ * @retval AVERROR(EAGAIN) output could not be produced. ++ * if AV_BSF_SINK_FLAG_NO_REQUEST was not set, ++ * @ref av_bsf_graph_needs_input can be called to ++ * know which source needs input more urgently. ++ * @retval >= 0 success ++ * @retval "another negative error code" legitimate error ++ */ ++int av_bsf_sink_get_packet(AVBitStreamFilterContext *ctx, AVPacket *pkt, int flags); ++ ++AVRational av_bsf_sink_get_time_base(const AVBitStreamFilterContext *ctx); ++const AVCodecParameters *av_bsf_sink_get_parameters(const AVBitStreamFilterContext *ctx); ++ ++/** ++ * @} ++ * ++ * @} ++ * ++ * @} ++ */ ++ ++#endif // AVCODEC_BSF_H +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec.h +new file mode 100644 +index 000000000000..0966d2e616b2 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec.h +@@ -0,0 +1,345 @@ ++/* ++ * AVCodec public API ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_CODEC_H ++#define AVCODEC_CODEC_H ++ ++#include ++ ++#include "libavutil/avutil.h" ++#include "libavutil/hwcontext.h" ++#include "libavutil/log.h" ++#include "libavutil/pixfmt.h" ++ ++#include "libavcodec/codec_id.h" ++ ++/** ++ * @addtogroup lavc_core ++ * @{ ++ */ ++ ++/** ++ * Decoder can use draw_horiz_band callback. ++ */ ++#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0) ++/** ++ * Codec uses get_buffer() or get_encode_buffer() for allocating buffers and ++ * supports custom allocators. ++ * If not set, it might not use get_buffer() or get_encode_buffer() at all, or ++ * use operations that assume the buffer was allocated by ++ * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer. ++ */ ++#define AV_CODEC_CAP_DR1 (1 << 1) ++/** ++ * Encoder or decoder requires flushing with NULL input at the end in order to ++ * give the complete and correct output. ++ * ++ * NOTE: If this flag is not set, the codec is guaranteed to never be fed with ++ * with NULL data. The user can still send NULL data to the public encode ++ * or decode function, but libavcodec will not pass it along to the codec ++ * unless this flag is set. ++ * ++ * Decoders: ++ * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, ++ * avpkt->size=0 at the end to get the delayed data until the decoder no longer ++ * returns frames. ++ * ++ * Encoders: ++ * The encoder needs to be fed with NULL data at the end of encoding until the ++ * encoder no longer returns data. ++ * ++ * NOTE: For encoders implementing the AVCodec.encode2() function, setting this ++ * flag also means that the encoder must set the pts and duration for ++ * each output packet. If this flag is not set, the pts and duration will ++ * be determined by libavcodec from the input frame. ++ */ ++#define AV_CODEC_CAP_DELAY (1 << 5) ++/** ++ * Codec can be fed a final frame with a smaller size. ++ * This can be used to prevent truncation of the last audio samples. ++ */ ++#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6) ++ ++/** ++ * Codec is experimental and is thus avoided in favor of non experimental ++ * encoders ++ */ ++#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9) ++/** ++ * Codec should fill in channel configuration and samplerate instead of container ++ */ ++#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10) ++/** ++ * Codec supports frame-level multithreading. ++ */ ++#define AV_CODEC_CAP_FRAME_THREADS (1 << 12) ++/** ++ * Codec supports slice-based (or partition-based) multithreading. ++ */ ++#define AV_CODEC_CAP_SLICE_THREADS (1 << 13) ++/** ++ * Codec supports changed parameters at any point. ++ */ ++#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14) ++/** ++ * Codec supports multithreading through a method other than slice- or ++ * frame-level multithreading. Typically this marks wrappers around ++ * multithreading-capable external libraries. ++ */ ++#define AV_CODEC_CAP_OTHER_THREADS (1 << 15) ++/** ++ * Audio encoder supports receiving a different number of samples in each call. ++ */ ++#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16) ++/** ++ * Decoder is not a preferred choice for probing. ++ * This indicates that the decoder is not a good choice for probing. ++ * It could for example be an expensive to spin up hardware decoder, ++ * or it could simply not provide a lot of useful information about ++ * the stream. ++ * A decoder marked with this flag should only be used as last resort ++ * choice for probing. ++ */ ++#define AV_CODEC_CAP_AVOID_PROBING (1 << 17) ++ ++/** ++ * Codec is backed by a hardware implementation. Typically used to ++ * identify a non-hwaccel hardware decoder. For information about hwaccels, use ++ * avcodec_get_hw_config() instead. ++ */ ++#define AV_CODEC_CAP_HARDWARE (1 << 18) ++ ++/** ++ * Codec is potentially backed by a hardware implementation, but not ++ * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the ++ * implementation provides some sort of internal fallback. ++ */ ++#define AV_CODEC_CAP_HYBRID (1 << 19) ++ ++/** ++ * This encoder can reorder user opaque values from input AVFrames and return ++ * them with corresponding output packets. ++ * @see AV_CODEC_FLAG_COPY_OPAQUE ++ */ ++#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20) ++ ++/** ++ * This encoder can be flushed using avcodec_flush_buffers(). If this flag is ++ * not set, the encoder must be closed and reopened to ensure that no frames ++ * remain pending. ++ */ ++#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21) ++ ++/** ++ * The encoder is able to output reconstructed frame data, i.e. raw frames that ++ * would be produced by decoding the encoded bitstream. ++ * ++ * Reconstructed frame output is enabled by the AV_CODEC_FLAG_RECON_FRAME flag. ++ */ ++#define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22) ++ ++/** ++ * AVProfile. ++ */ ++typedef struct AVProfile { ++ int profile; ++ const char *name; ///< short name for the profile ++} AVProfile; ++ ++/** ++ * AVCodec. ++ */ ++typedef struct AVCodec { ++ /** ++ * Name of the codec implementation. ++ * The name is globally unique among encoders and among decoders (but an ++ * encoder and a decoder can share the same name). ++ * This is the primary way to find a codec from the user perspective. ++ */ ++ const char *name; ++ /** ++ * Descriptive name for the codec, meant to be more human readable than name. ++ * You should use the NULL_IF_CONFIG_SMALL() macro to define it. ++ */ ++ const char *long_name; ++ enum AVMediaType type; ++ enum AVCodecID id; ++ /** ++ * Codec capabilities. ++ * see AV_CODEC_CAP_* ++ */ ++ int capabilities; ++ uint8_t max_lowres; ///< maximum value for lowres supported by the decoder ++ ++ const AVClass *priv_class; ///< AVClass for the private context ++ const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {AV_PROFILE_UNKNOWN} ++ ++ /** ++ * Group name of the codec implementation. ++ * This is a short symbolic name of the wrapper backing this codec. A ++ * wrapper uses some kind of external implementation for the codec, such ++ * as an external library, or a codec implementation provided by the OS or ++ * the hardware. ++ * If this field is NULL, this is a builtin, libavcodec native codec. ++ * If non-NULL, this will be the suffix in AVCodec.name in most cases ++ * (usually AVCodec.name will be of the form "_"). ++ */ ++ const char *wrapper_name; ++} AVCodec; ++ ++/** ++ * Iterate over all registered codecs. ++ * ++ * @param opaque a pointer where libavcodec will store the iteration state. Must ++ * point to NULL to start the iteration. ++ * ++ * @return the next registered codec or NULL when the iteration is ++ * finished ++ */ ++const AVCodec *av_codec_iterate(void **opaque); ++ ++/** ++ * Find a registered decoder with a matching codec ID. ++ * ++ * @param id AVCodecID of the requested decoder ++ * @return A decoder if one was found, NULL otherwise. ++ */ ++const AVCodec *avcodec_find_decoder(enum AVCodecID id); ++ ++/** ++ * Find a registered decoder with the specified name. ++ * ++ * @param name name of the requested decoder ++ * @return A decoder if one was found, NULL otherwise. ++ */ ++const AVCodec *avcodec_find_decoder_by_name(const char *name); ++ ++/** ++ * Find a registered encoder with a matching codec ID. ++ * ++ * @param id AVCodecID of the requested encoder ++ * @return An encoder if one was found, NULL otherwise. ++ */ ++const AVCodec *avcodec_find_encoder(enum AVCodecID id); ++ ++/** ++ * Find a registered encoder with the specified name. ++ * ++ * @param name name of the requested encoder ++ * @return An encoder if one was found, NULL otherwise. ++ */ ++const AVCodec *avcodec_find_encoder_by_name(const char *name); ++/** ++ * @return a non-zero number if codec is an encoder, zero otherwise ++ */ ++int av_codec_is_encoder(const AVCodec *codec); ++ ++/** ++ * @return a non-zero number if codec is a decoder, zero otherwise ++ */ ++int av_codec_is_decoder(const AVCodec *codec); ++ ++/** ++ * Return a name for the specified profile, if available. ++ * ++ * @param codec the codec that is searched for the given profile ++ * @param profile the profile value for which a name is requested ++ * @return A name for the profile if found, NULL otherwise. ++ */ ++const char *av_get_profile_name(const AVCodec *codec, int profile); ++ ++enum { ++ /** ++ * The codec supports this format via the hw_device_ctx interface. ++ * ++ * When selecting this format, AVCodecContext.hw_device_ctx should ++ * have been set to a device of the specified type before calling ++ * avcodec_open2(). ++ */ ++ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01, ++ /** ++ * The codec supports this format via the hw_frames_ctx interface. ++ * ++ * When selecting this format for a decoder, ++ * AVCodecContext.hw_frames_ctx should be set to a suitable frames ++ * context inside the get_format() callback. The frames context ++ * must have been created on a device of the specified type. ++ * ++ * When selecting this format for an encoder, ++ * AVCodecContext.hw_frames_ctx should be set to the context which ++ * will be used for the input frames before calling avcodec_open2(). ++ */ ++ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02, ++ /** ++ * The codec supports this format by some internal method. ++ * ++ * This format can be selected without any additional configuration - ++ * no device or frames context is required. ++ */ ++ AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04, ++ /** ++ * The codec supports this format by some ad-hoc method. ++ * ++ * Additional settings and/or function calls are required. See the ++ * codec-specific documentation for details. (Methods requiring ++ * this sort of configuration are deprecated and others should be ++ * used in preference.) ++ */ ++ AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08, ++}; ++ ++typedef struct AVCodecHWConfig { ++ /** ++ * For decoders, a hardware pixel format which that decoder may be ++ * able to decode to if suitable hardware is available. ++ * ++ * For encoders, a pixel format which the encoder may be able to ++ * accept. If set to AV_PIX_FMT_NONE, this applies to all pixel ++ * formats supported by the codec. ++ */ ++ enum AVPixelFormat pix_fmt; ++ /** ++ * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible ++ * setup methods which can be used with this configuration. ++ */ ++ int methods; ++ /** ++ * The device type associated with the configuration. ++ * ++ * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and ++ * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused. ++ */ ++ enum AVHWDeviceType device_type; ++} AVCodecHWConfig; ++ ++/** ++ * Retrieve supported hardware configurations for a codec. ++ * ++ * Values of index from zero to some maximum return the indexed configuration ++ * descriptor; all other values return NULL. If the codec does not support ++ * any hardware configurations then it will always return NULL. ++ */ ++const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index); ++ ++/** ++ * @} ++ */ ++ ++#endif /* AVCODEC_CODEC_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/codec_desc.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_desc.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/codec_desc.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_desc.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_id.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_id.h +new file mode 100644 +index 000000000000..ff2c21526c43 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_id.h +@@ -0,0 +1,687 @@ ++/* ++ * Codec IDs ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_CODEC_ID_H ++#define AVCODEC_CODEC_ID_H ++ ++#include "libavutil/avutil.h" ++#include "libavutil/samplefmt.h" ++ ++/** ++ * @addtogroup lavc_core ++ * @{ ++ */ ++ ++/** ++ * Identify the syntax and semantics of the bitstream. ++ * The principle is roughly: ++ * Two decoders with the same ID can decode the same streams. ++ * Two encoders with the same ID can encode compatible streams. ++ * There may be slight deviations from the principle due to implementation ++ * details. ++ * ++ * If you add a codec ID to this list, add it so that ++ * 1. no value of an existing codec ID changes (that would break ABI), ++ * 2. it is as close as possible to similar codecs ++ * ++ * After adding new codec IDs, do not forget to add an entry to the codec ++ * descriptor list and bump libavcodec minor version. ++ */ ++enum AVCodecID { ++ AV_CODEC_ID_NONE, ++ ++ /* video codecs */ ++ AV_CODEC_ID_MPEG1VIDEO, ++ AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding ++ AV_CODEC_ID_H261, ++ AV_CODEC_ID_H263, ++ AV_CODEC_ID_RV10, ++ AV_CODEC_ID_RV20, ++ AV_CODEC_ID_MJPEG, ++ AV_CODEC_ID_MJPEGB, ++ AV_CODEC_ID_LJPEG, ++ AV_CODEC_ID_SP5X, ++ AV_CODEC_ID_JPEGLS, ++ AV_CODEC_ID_MPEG4, ++ AV_CODEC_ID_RAWVIDEO, ++ AV_CODEC_ID_MSMPEG4V1, ++ AV_CODEC_ID_MSMPEG4V2, ++ AV_CODEC_ID_MSMPEG4V3, ++ AV_CODEC_ID_WMV1, ++ AV_CODEC_ID_WMV2, ++ AV_CODEC_ID_H263P, ++ AV_CODEC_ID_H263I, ++ AV_CODEC_ID_FLV1, ++ AV_CODEC_ID_SVQ1, ++ AV_CODEC_ID_SVQ3, ++ AV_CODEC_ID_DVVIDEO, ++ AV_CODEC_ID_HUFFYUV, ++ AV_CODEC_ID_CYUV, ++ AV_CODEC_ID_H264, ++ AV_CODEC_ID_INDEO3, ++ AV_CODEC_ID_VP3, ++ AV_CODEC_ID_THEORA, ++ AV_CODEC_ID_ASV1, ++ AV_CODEC_ID_ASV2, ++ AV_CODEC_ID_FFV1, ++ AV_CODEC_ID_4XM, ++ AV_CODEC_ID_VCR1, ++ AV_CODEC_ID_CLJR, ++ AV_CODEC_ID_MDEC, ++ AV_CODEC_ID_ROQ, ++ AV_CODEC_ID_INTERPLAY_VIDEO, ++ AV_CODEC_ID_XAN_WC3, ++ AV_CODEC_ID_XAN_WC4, ++ AV_CODEC_ID_RPZA, ++ AV_CODEC_ID_CINEPAK, ++ AV_CODEC_ID_WS_VQA, ++ AV_CODEC_ID_MSRLE, ++ AV_CODEC_ID_MSVIDEO1, ++ AV_CODEC_ID_IDCIN, ++ AV_CODEC_ID_8BPS, ++ AV_CODEC_ID_SMC, ++ AV_CODEC_ID_FLIC, ++ AV_CODEC_ID_TRUEMOTION1, ++ AV_CODEC_ID_VMDVIDEO, ++ AV_CODEC_ID_MSZH, ++ AV_CODEC_ID_ZLIB, ++ AV_CODEC_ID_QTRLE, ++ AV_CODEC_ID_TSCC, ++ AV_CODEC_ID_ULTI, ++ AV_CODEC_ID_QDRAW, ++ AV_CODEC_ID_VIXL, ++ AV_CODEC_ID_QPEG, ++ AV_CODEC_ID_PNG, ++ AV_CODEC_ID_PPM, ++ AV_CODEC_ID_PBM, ++ AV_CODEC_ID_PGM, ++ AV_CODEC_ID_PGMYUV, ++ AV_CODEC_ID_PAM, ++ AV_CODEC_ID_FFVHUFF, ++ AV_CODEC_ID_RV30, ++ AV_CODEC_ID_RV40, ++ AV_CODEC_ID_VC1, ++ AV_CODEC_ID_WMV3, ++ AV_CODEC_ID_LOCO, ++ AV_CODEC_ID_WNV1, ++ AV_CODEC_ID_AASC, ++ AV_CODEC_ID_INDEO2, ++ AV_CODEC_ID_FRAPS, ++ AV_CODEC_ID_TRUEMOTION2, ++ AV_CODEC_ID_BMP, ++ AV_CODEC_ID_CSCD, ++ AV_CODEC_ID_MMVIDEO, ++ AV_CODEC_ID_ZMBV, ++ AV_CODEC_ID_AVS, ++ AV_CODEC_ID_SMACKVIDEO, ++ AV_CODEC_ID_NUV, ++ AV_CODEC_ID_KMVC, ++ AV_CODEC_ID_FLASHSV, ++ AV_CODEC_ID_CAVS, ++ AV_CODEC_ID_JPEG2000, ++ AV_CODEC_ID_VMNC, ++ AV_CODEC_ID_VP5, ++ AV_CODEC_ID_VP6, ++ AV_CODEC_ID_VP6F, ++ AV_CODEC_ID_TARGA, ++ AV_CODEC_ID_DSICINVIDEO, ++ AV_CODEC_ID_TIERTEXSEQVIDEO, ++ AV_CODEC_ID_TIFF, ++ AV_CODEC_ID_GIF, ++ AV_CODEC_ID_DXA, ++ AV_CODEC_ID_DNXHD, ++ AV_CODEC_ID_THP, ++ AV_CODEC_ID_SGI, ++ AV_CODEC_ID_C93, ++ AV_CODEC_ID_BETHSOFTVID, ++ AV_CODEC_ID_PTX, ++ AV_CODEC_ID_TXD, ++ AV_CODEC_ID_VP6A, ++ AV_CODEC_ID_AMV, ++ AV_CODEC_ID_VB, ++ AV_CODEC_ID_PCX, ++ AV_CODEC_ID_SUNRAST, ++ AV_CODEC_ID_INDEO4, ++ AV_CODEC_ID_INDEO5, ++ AV_CODEC_ID_MIMIC, ++ AV_CODEC_ID_RL2, ++ AV_CODEC_ID_ESCAPE124, ++ AV_CODEC_ID_DIRAC, ++ AV_CODEC_ID_BFI, ++ AV_CODEC_ID_CMV, ++ AV_CODEC_ID_MOTIONPIXELS, ++ AV_CODEC_ID_TGV, ++ AV_CODEC_ID_TGQ, ++ AV_CODEC_ID_TQI, ++ AV_CODEC_ID_AURA, ++ AV_CODEC_ID_AURA2, ++ AV_CODEC_ID_V210X, ++ AV_CODEC_ID_TMV, ++ AV_CODEC_ID_V210, ++ AV_CODEC_ID_DPX, ++ AV_CODEC_ID_MAD, ++ AV_CODEC_ID_FRWU, ++ AV_CODEC_ID_FLASHSV2, ++ AV_CODEC_ID_CDGRAPHICS, ++ AV_CODEC_ID_R210, ++ AV_CODEC_ID_ANM, ++ AV_CODEC_ID_BINKVIDEO, ++ AV_CODEC_ID_IFF_ILBM, ++#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM ++ AV_CODEC_ID_KGV1, ++ AV_CODEC_ID_YOP, ++ AV_CODEC_ID_VP8, ++ AV_CODEC_ID_PICTOR, ++ AV_CODEC_ID_ANSI, ++ AV_CODEC_ID_A64_MULTI, ++ AV_CODEC_ID_A64_MULTI5, ++ AV_CODEC_ID_R10K, ++ AV_CODEC_ID_MXPEG, ++ AV_CODEC_ID_LAGARITH, ++ AV_CODEC_ID_PRORES, ++ AV_CODEC_ID_JV, ++ AV_CODEC_ID_DFA, ++ AV_CODEC_ID_WMV3IMAGE, ++ AV_CODEC_ID_VC1IMAGE, ++ AV_CODEC_ID_UTVIDEO, ++ AV_CODEC_ID_BMV_VIDEO, ++ AV_CODEC_ID_VBLE, ++ AV_CODEC_ID_DXTORY, ++ AV_CODEC_ID_XWD, ++ AV_CODEC_ID_CDXL, ++ AV_CODEC_ID_XBM, ++ AV_CODEC_ID_ZEROCODEC, ++ AV_CODEC_ID_MSS1, ++ AV_CODEC_ID_MSA1, ++ AV_CODEC_ID_TSCC2, ++ AV_CODEC_ID_MTS2, ++ AV_CODEC_ID_CLLC, ++ AV_CODEC_ID_MSS2, ++ AV_CODEC_ID_VP9, ++ AV_CODEC_ID_AIC, ++ AV_CODEC_ID_ESCAPE130, ++ AV_CODEC_ID_G2M, ++ AV_CODEC_ID_WEBP, ++ AV_CODEC_ID_HNM4_VIDEO, ++ AV_CODEC_ID_HEVC, ++#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC ++ AV_CODEC_ID_FIC, ++ AV_CODEC_ID_ALIAS_PIX, ++ AV_CODEC_ID_BRENDER_PIX, ++ AV_CODEC_ID_PAF_VIDEO, ++ AV_CODEC_ID_EXR, ++ AV_CODEC_ID_VP7, ++ AV_CODEC_ID_SANM, ++ AV_CODEC_ID_SGIRLE, ++ AV_CODEC_ID_MVC1, ++ AV_CODEC_ID_MVC2, ++ AV_CODEC_ID_HQX, ++ AV_CODEC_ID_TDSC, ++ AV_CODEC_ID_HQ_HQA, ++ AV_CODEC_ID_HAP, ++ AV_CODEC_ID_DDS, ++ AV_CODEC_ID_DXV, ++ AV_CODEC_ID_SCREENPRESSO, ++ AV_CODEC_ID_RSCC, ++ AV_CODEC_ID_AVS2, ++ AV_CODEC_ID_PGX, ++ AV_CODEC_ID_AVS3, ++ AV_CODEC_ID_MSP2, ++ AV_CODEC_ID_VVC, ++#define AV_CODEC_ID_H266 AV_CODEC_ID_VVC ++ AV_CODEC_ID_Y41P, ++ AV_CODEC_ID_AVRP, ++ AV_CODEC_ID_012V, ++ AV_CODEC_ID_AVUI, ++ AV_CODEC_ID_TARGA_Y216, ++ AV_CODEC_ID_YUV4, ++ AV_CODEC_ID_AVRN, ++ AV_CODEC_ID_CPIA, ++ AV_CODEC_ID_XFACE, ++ AV_CODEC_ID_SNOW, ++ AV_CODEC_ID_SMVJPEG, ++ AV_CODEC_ID_APNG, ++ AV_CODEC_ID_DAALA, ++ AV_CODEC_ID_CFHD, ++ AV_CODEC_ID_TRUEMOTION2RT, ++ AV_CODEC_ID_M101, ++ AV_CODEC_ID_MAGICYUV, ++ AV_CODEC_ID_SHEERVIDEO, ++ AV_CODEC_ID_YLC, ++ AV_CODEC_ID_PSD, ++ AV_CODEC_ID_PIXLET, ++ AV_CODEC_ID_SPEEDHQ, ++ AV_CODEC_ID_FMVC, ++ AV_CODEC_ID_SCPR, ++ AV_CODEC_ID_CLEARVIDEO, ++ AV_CODEC_ID_XPM, ++ AV_CODEC_ID_AV1, ++ AV_CODEC_ID_BITPACKED, ++ AV_CODEC_ID_MSCC, ++ AV_CODEC_ID_SRGC, ++ AV_CODEC_ID_SVG, ++ AV_CODEC_ID_GDV, ++ AV_CODEC_ID_FITS, ++ AV_CODEC_ID_IMM4, ++ AV_CODEC_ID_PROSUMER, ++ AV_CODEC_ID_MWSC, ++ AV_CODEC_ID_WCMV, ++ AV_CODEC_ID_RASC, ++ AV_CODEC_ID_HYMT, ++ AV_CODEC_ID_ARBC, ++ AV_CODEC_ID_AGM, ++ AV_CODEC_ID_LSCR, ++ AV_CODEC_ID_VP4, ++ AV_CODEC_ID_IMM5, ++ AV_CODEC_ID_MVDV, ++ AV_CODEC_ID_MVHA, ++ AV_CODEC_ID_CDTOONS, ++ AV_CODEC_ID_MV30, ++ AV_CODEC_ID_NOTCHLC, ++ AV_CODEC_ID_PFM, ++ AV_CODEC_ID_MOBICLIP, ++ AV_CODEC_ID_PHOTOCD, ++ AV_CODEC_ID_IPU, ++ AV_CODEC_ID_ARGO, ++ AV_CODEC_ID_CRI, ++ AV_CODEC_ID_SIMBIOSIS_IMX, ++ AV_CODEC_ID_SGA_VIDEO, ++ AV_CODEC_ID_GEM, ++ AV_CODEC_ID_VBN, ++ AV_CODEC_ID_JPEGXL, ++ AV_CODEC_ID_QOI, ++ AV_CODEC_ID_PHM, ++ AV_CODEC_ID_RADIANCE_HDR, ++ AV_CODEC_ID_WBMP, ++ AV_CODEC_ID_MEDIA100, ++ AV_CODEC_ID_VQC, ++ AV_CODEC_ID_PDV, ++ AV_CODEC_ID_EVC, ++ AV_CODEC_ID_RTV1, ++ AV_CODEC_ID_VMIX, ++ AV_CODEC_ID_LEAD, ++ AV_CODEC_ID_DNXUC, ++ AV_CODEC_ID_RV60, ++ AV_CODEC_ID_JPEGXL_ANIM, ++ AV_CODEC_ID_APV, ++ AV_CODEC_ID_PRORES_RAW, ++ AV_CODEC_ID_JPEGXS, ++ AV_CODEC_ID_WEBP_ANIM, ++ ++ /* various PCM "codecs" */ ++ AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs ++ AV_CODEC_ID_PCM_S16LE = 0x10000, ++ AV_CODEC_ID_PCM_S16BE, ++ AV_CODEC_ID_PCM_U16LE, ++ AV_CODEC_ID_PCM_U16BE, ++ AV_CODEC_ID_PCM_S8, ++ AV_CODEC_ID_PCM_U8, ++ AV_CODEC_ID_PCM_MULAW, ++ AV_CODEC_ID_PCM_ALAW, ++ AV_CODEC_ID_PCM_S32LE, ++ AV_CODEC_ID_PCM_S32BE, ++ AV_CODEC_ID_PCM_U32LE, ++ AV_CODEC_ID_PCM_U32BE, ++ AV_CODEC_ID_PCM_S24LE, ++ AV_CODEC_ID_PCM_S24BE, ++ AV_CODEC_ID_PCM_U24LE, ++ AV_CODEC_ID_PCM_U24BE, ++ AV_CODEC_ID_PCM_S24DAUD, ++ AV_CODEC_ID_PCM_ZORK, ++ AV_CODEC_ID_PCM_S16LE_PLANAR, ++ AV_CODEC_ID_PCM_DVD, ++ AV_CODEC_ID_PCM_F32BE, ++ AV_CODEC_ID_PCM_F32LE, ++ AV_CODEC_ID_PCM_F64BE, ++ AV_CODEC_ID_PCM_F64LE, ++ AV_CODEC_ID_PCM_BLURAY, ++ AV_CODEC_ID_PCM_LXF, ++ AV_CODEC_ID_S302M, ++ AV_CODEC_ID_PCM_S8_PLANAR, ++ AV_CODEC_ID_PCM_S24LE_PLANAR, ++ AV_CODEC_ID_PCM_S32LE_PLANAR, ++ AV_CODEC_ID_PCM_S16BE_PLANAR, ++ AV_CODEC_ID_PCM_S64LE, ++ AV_CODEC_ID_PCM_S64BE, ++ AV_CODEC_ID_PCM_F16LE, ++ AV_CODEC_ID_PCM_F24LE, ++ AV_CODEC_ID_PCM_VIDC, ++ AV_CODEC_ID_PCM_SGA, ++ ++ /* various ADPCM codecs */ ++ AV_CODEC_ID_ADPCM_IMA_QT = 0x11000, ++ AV_CODEC_ID_ADPCM_IMA_WAV, ++ AV_CODEC_ID_ADPCM_IMA_DK3, ++ AV_CODEC_ID_ADPCM_IMA_DK4, ++ AV_CODEC_ID_ADPCM_IMA_WS, ++ AV_CODEC_ID_ADPCM_IMA_SMJPEG, ++ AV_CODEC_ID_ADPCM_MS, ++ AV_CODEC_ID_ADPCM_4XM, ++ AV_CODEC_ID_ADPCM_XA, ++ AV_CODEC_ID_ADPCM_ADX, ++ AV_CODEC_ID_ADPCM_EA, ++ AV_CODEC_ID_ADPCM_G726, ++ AV_CODEC_ID_ADPCM_CT, ++ AV_CODEC_ID_ADPCM_SWF, ++ AV_CODEC_ID_ADPCM_YAMAHA, ++ AV_CODEC_ID_ADPCM_SBPRO_4, ++ AV_CODEC_ID_ADPCM_SBPRO_3, ++ AV_CODEC_ID_ADPCM_SBPRO_2, ++ AV_CODEC_ID_ADPCM_THP, ++ AV_CODEC_ID_ADPCM_IMA_AMV, ++ AV_CODEC_ID_ADPCM_EA_R1, ++ AV_CODEC_ID_ADPCM_EA_R3, ++ AV_CODEC_ID_ADPCM_EA_R2, ++ AV_CODEC_ID_ADPCM_IMA_EA_SEAD, ++ AV_CODEC_ID_ADPCM_IMA_EA_EACS, ++ AV_CODEC_ID_ADPCM_EA_XAS, ++ AV_CODEC_ID_ADPCM_EA_MAXIS_XA, ++ AV_CODEC_ID_ADPCM_IMA_ISS, ++ AV_CODEC_ID_ADPCM_G722, ++ AV_CODEC_ID_ADPCM_IMA_APC, ++ AV_CODEC_ID_ADPCM_VIMA, ++ AV_CODEC_ID_ADPCM_AFC, ++ AV_CODEC_ID_ADPCM_IMA_OKI, ++ AV_CODEC_ID_ADPCM_DTK, ++ AV_CODEC_ID_ADPCM_IMA_RAD, ++ AV_CODEC_ID_ADPCM_G726LE, ++ AV_CODEC_ID_ADPCM_THP_LE, ++ AV_CODEC_ID_ADPCM_PSX, ++ AV_CODEC_ID_ADPCM_AICA, ++ AV_CODEC_ID_ADPCM_IMA_DAT4, ++ AV_CODEC_ID_ADPCM_MTAF, ++ AV_CODEC_ID_ADPCM_AGM, ++ AV_CODEC_ID_ADPCM_ARGO, ++ AV_CODEC_ID_ADPCM_IMA_SSI, ++ AV_CODEC_ID_ADPCM_ZORK, ++ AV_CODEC_ID_ADPCM_IMA_APM, ++ AV_CODEC_ID_ADPCM_IMA_ALP, ++ AV_CODEC_ID_ADPCM_IMA_MTF, ++ AV_CODEC_ID_ADPCM_IMA_CUNNING, ++ AV_CODEC_ID_ADPCM_IMA_MOFLEX, ++ AV_CODEC_ID_ADPCM_IMA_ACORN, ++ AV_CODEC_ID_ADPCM_XMD, ++ AV_CODEC_ID_ADPCM_IMA_XBOX, ++ AV_CODEC_ID_ADPCM_SANYO, ++ AV_CODEC_ID_ADPCM_IMA_HVQM4, ++ AV_CODEC_ID_ADPCM_IMA_PDA, ++ AV_CODEC_ID_ADPCM_N64, ++ AV_CODEC_ID_ADPCM_IMA_HVQM2, ++ AV_CODEC_ID_ADPCM_IMA_MAGIX, ++ AV_CODEC_ID_ADPCM_PSXC, ++ AV_CODEC_ID_ADPCM_CIRCUS, ++ AV_CODEC_ID_ADPCM_IMA_ESCAPE, ++ ++ /* AMR */ ++ AV_CODEC_ID_AMR_NB = 0x12000, ++ AV_CODEC_ID_AMR_WB, ++ ++ /* RealAudio codecs*/ ++ AV_CODEC_ID_RA_144 = 0x13000, ++ AV_CODEC_ID_RA_288, ++ ++ /* various DPCM codecs */ ++ AV_CODEC_ID_ROQ_DPCM = 0x14000, ++ AV_CODEC_ID_INTERPLAY_DPCM, ++ AV_CODEC_ID_XAN_DPCM, ++ AV_CODEC_ID_SOL_DPCM, ++ AV_CODEC_ID_SDX2_DPCM, ++ AV_CODEC_ID_GREMLIN_DPCM, ++ AV_CODEC_ID_DERF_DPCM, ++ AV_CODEC_ID_WADY_DPCM, ++ AV_CODEC_ID_CBD2_DPCM, ++ ++ /* audio codecs */ ++ AV_CODEC_ID_MP2 = 0x15000, ++ AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 ++ AV_CODEC_ID_AAC, ++ AV_CODEC_ID_AC3, ++ AV_CODEC_ID_DTS, ++ AV_CODEC_ID_VORBIS, ++ AV_CODEC_ID_DVAUDIO, ++ AV_CODEC_ID_WMAV1, ++ AV_CODEC_ID_WMAV2, ++ AV_CODEC_ID_MACE3, ++ AV_CODEC_ID_MACE6, ++ AV_CODEC_ID_VMDAUDIO, ++ AV_CODEC_ID_FLAC, ++ AV_CODEC_ID_MP3ADU, ++ AV_CODEC_ID_MP3ON4, ++ AV_CODEC_ID_SHORTEN, ++ AV_CODEC_ID_ALAC, ++ AV_CODEC_ID_WESTWOOD_SND1, ++ AV_CODEC_ID_GSM, ///< as in Berlin toast format ++ AV_CODEC_ID_QDM2, ++ AV_CODEC_ID_COOK, ++ AV_CODEC_ID_TRUESPEECH, ++ AV_CODEC_ID_TTA, ++ AV_CODEC_ID_SMACKAUDIO, ++ AV_CODEC_ID_QCELP, ++ AV_CODEC_ID_WAVPACK, ++ AV_CODEC_ID_DSICINAUDIO, ++ AV_CODEC_ID_IMC, ++ AV_CODEC_ID_MUSEPACK7, ++ AV_CODEC_ID_MLP, ++ AV_CODEC_ID_GSM_MS, /* as found in WAV */ ++ AV_CODEC_ID_ATRAC3, ++ AV_CODEC_ID_APE, ++ AV_CODEC_ID_NELLYMOSER, ++ AV_CODEC_ID_MUSEPACK8, ++ AV_CODEC_ID_SPEEX, ++ AV_CODEC_ID_WMAVOICE, ++ AV_CODEC_ID_WMAPRO, ++ AV_CODEC_ID_WMALOSSLESS, ++ AV_CODEC_ID_ATRAC3P, ++ AV_CODEC_ID_EAC3, ++ AV_CODEC_ID_SIPR, ++ AV_CODEC_ID_MP1, ++ AV_CODEC_ID_TWINVQ, ++ AV_CODEC_ID_TRUEHD, ++ AV_CODEC_ID_MP4ALS, ++ AV_CODEC_ID_ATRAC1, ++ AV_CODEC_ID_BINKAUDIO_RDFT, ++ AV_CODEC_ID_BINKAUDIO_DCT, ++ AV_CODEC_ID_AAC_LATM, ++ AV_CODEC_ID_QDMC, ++ AV_CODEC_ID_CELT, ++ AV_CODEC_ID_G723_1, ++ AV_CODEC_ID_G729, ++ AV_CODEC_ID_8SVX_EXP, ++ AV_CODEC_ID_8SVX_FIB, ++ AV_CODEC_ID_BMV_AUDIO, ++ AV_CODEC_ID_RALF, ++ AV_CODEC_ID_IAC, ++ AV_CODEC_ID_ILBC, ++ AV_CODEC_ID_OPUS, ++ AV_CODEC_ID_COMFORT_NOISE, ++ AV_CODEC_ID_TAK, ++ AV_CODEC_ID_METASOUND, ++ AV_CODEC_ID_PAF_AUDIO, ++ AV_CODEC_ID_ON2AVC, ++ AV_CODEC_ID_DSS_SP, ++ AV_CODEC_ID_CODEC2, ++ AV_CODEC_ID_FFWAVESYNTH, ++ AV_CODEC_ID_SONIC, ++ AV_CODEC_ID_SONIC_LS, ++ AV_CODEC_ID_EVRC, ++ AV_CODEC_ID_SMV, ++ AV_CODEC_ID_DSD_LSBF, ++ AV_CODEC_ID_DSD_MSBF, ++ AV_CODEC_ID_DSD_LSBF_PLANAR, ++ AV_CODEC_ID_DSD_MSBF_PLANAR, ++ AV_CODEC_ID_4GV, ++ AV_CODEC_ID_INTERPLAY_ACM, ++ AV_CODEC_ID_XMA1, ++ AV_CODEC_ID_XMA2, ++ AV_CODEC_ID_DST, ++ AV_CODEC_ID_ATRAC3AL, ++ AV_CODEC_ID_ATRAC3PAL, ++ AV_CODEC_ID_DOLBY_E, ++ AV_CODEC_ID_APTX, ++ AV_CODEC_ID_APTX_HD, ++ AV_CODEC_ID_SBC, ++ AV_CODEC_ID_ATRAC9, ++ AV_CODEC_ID_HCOM, ++ AV_CODEC_ID_ACELP_KELVIN, ++ AV_CODEC_ID_MPEGH_3D_AUDIO, ++ AV_CODEC_ID_SIREN, ++ AV_CODEC_ID_HCA, ++ AV_CODEC_ID_FASTAUDIO, ++ AV_CODEC_ID_MSNSIREN, ++ AV_CODEC_ID_DFPWM, ++ AV_CODEC_ID_BONK, ++ AV_CODEC_ID_MISC4, ++ AV_CODEC_ID_APAC, ++ AV_CODEC_ID_FTR, ++ AV_CODEC_ID_WAVARC, ++ AV_CODEC_ID_RKA, ++ AV_CODEC_ID_AC4, ++ AV_CODEC_ID_OSQ, ++ AV_CODEC_ID_QOA, ++ AV_CODEC_ID_LC3, ++ AV_CODEC_ID_G728, ++ AV_CODEC_ID_AHX, ++ AV_CODEC_ID_APPLE_APAC, ++ ++ /* subtitle codecs */ ++ AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. ++ AV_CODEC_ID_DVD_SUBTITLE = 0x17000, ++ AV_CODEC_ID_DVB_SUBTITLE, ++ AV_CODEC_ID_TEXT, ///< raw UTF-8 text ++ AV_CODEC_ID_XSUB, ++ AV_CODEC_ID_SSA, ++ AV_CODEC_ID_MOV_TEXT, ++ AV_CODEC_ID_HDMV_PGS_SUBTITLE, ++ AV_CODEC_ID_DVB_TELETEXT, ++ AV_CODEC_ID_SRT, ++ AV_CODEC_ID_MICRODVD, ++ AV_CODEC_ID_EIA_608, ++ AV_CODEC_ID_JACOSUB, ++ AV_CODEC_ID_SAMI, ++ AV_CODEC_ID_REALTEXT, ++ AV_CODEC_ID_STL, ++ AV_CODEC_ID_SUBVIEWER1, ++ AV_CODEC_ID_SUBVIEWER, ++ AV_CODEC_ID_SUBRIP, ++ AV_CODEC_ID_WEBVTT, ++ AV_CODEC_ID_MPL2, ++ AV_CODEC_ID_VPLAYER, ++ AV_CODEC_ID_PJS, ++ AV_CODEC_ID_ASS, ++ AV_CODEC_ID_HDMV_TEXT_SUBTITLE, ++ AV_CODEC_ID_TTML, ++ AV_CODEC_ID_ARIB_CAPTION, ++ AV_CODEC_ID_IVTV_VBI, ++ ++ /* other specific kind of codecs (generally used for attachments) */ ++ AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. ++ AV_CODEC_ID_TTF = 0x18000, ++ ++ AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream. ++ AV_CODEC_ID_EPG, ++ AV_CODEC_ID_BINTEXT, ++ AV_CODEC_ID_XBIN, ++ AV_CODEC_ID_IDF, ++ AV_CODEC_ID_OTF, ++ AV_CODEC_ID_SMPTE_KLV, ++ AV_CODEC_ID_DVD_NAV, ++ AV_CODEC_ID_TIMED_ID3, ++ AV_CODEC_ID_BIN_DATA, ++ AV_CODEC_ID_SMPTE_2038, ++ AV_CODEC_ID_LCEVC, ++ AV_CODEC_ID_SMPTE_436M_ANC, ++ AV_CODEC_ID_ITUT_T35, ++ ++ ++ AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it ++ ++ AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS ++ * stream (only used by libavformat) */ ++ AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems ++ * stream (only used by libavformat) */ ++ AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. ++ AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket ++ /** ++ * Dummy null video codec, useful mainly for development and debugging. ++ * Null encoder/decoder discard all input and never return any output. ++ */ ++ AV_CODEC_ID_VNULL, ++ /** ++ * Dummy null audio codec, useful mainly for development and debugging. ++ * Null encoder/decoder discard all input and never return any output. ++ */ ++ AV_CODEC_ID_ANULL, ++}; ++ ++/** ++ * Get the type of the given codec. ++ */ ++enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); ++ ++/** ++ * Get the name of a codec. ++ * @return a static string identifying the codec; never NULL ++ */ ++const char *avcodec_get_name(enum AVCodecID id); ++ ++/** ++ * Return codec bits per sample. ++ * ++ * @param[in] codec_id the codec ++ * @return Number of bits per sample or zero if unknown for the given codec. ++ */ ++int av_get_bits_per_sample(enum AVCodecID codec_id); ++ ++/** ++ * Return codec bits per sample. ++ * Only return non-zero if the bits per sample is exactly correct, not an ++ * approximation. ++ * ++ * @param[in] codec_id the codec ++ * @return Number of bits per sample or zero if unknown for the given codec. ++ */ ++int av_get_exact_bits_per_sample(enum AVCodecID codec_id); ++ ++/** ++ * Return a name for the specified profile, if available. ++ * ++ * @param codec_id the ID of the codec to which the requested profile belongs ++ * @param profile the profile value for which a name is requested ++ * @return A name for the profile if found, NULL otherwise. ++ * ++ * @note unlike av_get_profile_name(), which searches a list of profiles ++ * supported by a specific decoder or encoder implementation, this ++ * function searches the list of profiles from the AVCodecDescriptor ++ */ ++const char *avcodec_profile_name(enum AVCodecID codec_id, int profile); ++ ++/** ++ * Return the PCM codec associated with a sample format. ++ * @param be endianness, 0 for little, 1 for big, ++ * -1 (or anything else) for native ++ * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE ++ */ ++enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be); ++ ++/** ++ * @} ++ */ ++ ++#endif // AVCODEC_CODEC_ID_H +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_par.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_par.h +new file mode 100644 +index 000000000000..d880e3a80d79 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/codec_par.h +@@ -0,0 +1,302 @@ ++/* ++ * Codec parameters public API ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_CODEC_PAR_H ++#define AVCODEC_CODEC_PAR_H ++ ++#include ++ ++#include "libavutil/avutil.h" ++#include "libavutil/channel_layout.h" ++#include "libavutil/rational.h" ++#include "libavutil/pixfmt.h" ++ ++#include "codec_id.h" ++#include "defs.h" ++#include "packet.h" ++ ++/** ++ * @defgroup lavc_codec_params Codec parameters ++ * @ingroup lavc_core ++ * @{ ++ */ ++ ++/** ++ * This struct describes the properties of an encoded stream. ++ * ++ * @note ++ * The `sizeof(AVCodecParameters)` is not a part of the public ABI, ++ * therefore this struct must be allocated with ::avcodec_parameters_alloc() ++ * and freed with ::avcodec_parameters_free(). ++ */ ++typedef struct AVCodecParameters { ++ /** ++ * General type of the encoded data. ++ */ ++ enum AVMediaType codec_type; ++ /** ++ * Specific type of the encoded data (the codec used). ++ */ ++ enum AVCodecID codec_id; ++ /** ++ * Additional information about the codec (corresponds to the AVI FOURCC). ++ */ ++ uint32_t codec_tag; ++ ++ /** ++ * Extra binary data needed for initializing the decoder, codec-dependent. ++ * ++ * Must be allocated with ::av_malloc() and will be freed by ++ * ::avcodec_parameters_free(). The allocated size of extradata must be at ++ * least #extradata_size + ::AV_INPUT_BUFFER_PADDING_SIZE, with the padding ++ * bytes zeroed. ++ */ ++ uint8_t *extradata; ++ /** ++ * Size of the extradata content in bytes. ++ */ ++ int extradata_size; ++ ++ /** ++ * Additional data associated with the entire stream. ++ * ++ * Should be allocated with ::av_packet_side_data_new() or ++ * ::av_packet_side_data_add(), and will be freed by ::avcodec_parameters_free(). ++ */ ++ AVPacketSideData *coded_side_data; ++ ++ /** ++ * Amount of entries in #coded_side_data. ++ */ ++ int nb_coded_side_data; ++ ++ /** ++ * - Video: the pixel format, the value corresponds to enum ::AVPixelFormat. ++ * - Audio: the sample format, the value corresponds to enum ::AVSampleFormat. ++ */ ++ int format; ++ ++ /** ++ * The average bitrate of the encoded data (in bits per second). ++ */ ++ int64_t bit_rate; ++ ++ /** ++ * The number of bits per sample in the codedwords. ++ * ++ * This is basically the bitrate per sample. It is mandatory for a bunch of ++ * formats to actually decode them. It's the number of bits for one sample in ++ * the actual coded bitstream. ++ * ++ * This could be, for example, 4, for ADPCM. ++ * For PCM formats this matches #bits_per_raw_sample. ++ * ++ * Can be 0. ++ */ ++ int bits_per_coded_sample; ++ ++ /** ++ * The number of valid bits in each output sample. ++ * ++ * If the sample format has more bits, the least significant bits are additional ++ * padding bits, which are always 0. Use right shifts to reduce the sample ++ * to its actual size. ++ * ++ * For example, audio formats with 24-bit samples will have #bits_per_raw_sample ++ * set to 24, and ::format set to ::AV_SAMPLE_FMT_S32. To get the original sample, ++ * use: `(int32_t)sample >> 8`. ++ * ++ * For ADPCM, this might be 12 or 16, or similar. ++ * ++ * Can be 0. ++ */ ++ int bits_per_raw_sample; ++ ++ /** ++ * Codec-specific bitstream restrictions that the stream conforms to. ++ */ ++ int profile; ++ int level; ++ ++ /** ++ * The width of the video frame in pixels. ++ * ++ * Video only. ++ */ ++ int width; ++ ++ /** ++ * The height of the video frame in pixels. ++ * ++ * Video only. ++ */ ++ int height; ++ ++ /** ++ * The aspect ratio (width/height) which a single pixel ++ * should have when displayed. ++ * ++ * When the aspect ratio is unknown or undefined, the numerator should be ++ * set to 0 (the denominator may have any value). ++ * ++ * Video only. ++ */ ++ AVRational sample_aspect_ratio; ++ ++ /** ++ * Number of frames per second, for streams with constant frame ++ * durations. Should be set to `{ 0, 1 }` when some frames have differing ++ * durations or if the value is not known. ++ * ++ * @note This field corresponds to values that are stored in codec-level ++ * headers and is typically overridden by container/transport-layer ++ * timestamps, when available. It should thus be used only as a last resort, ++ * when no higher-level timing information is available. ++ * ++ * Video only. ++ */ ++ AVRational framerate; ++ ++ /** ++ * The order of the fields in interlaced video. ++ * ++ * Video only. ++ */ ++ enum AVFieldOrder field_order; ++ ++ /** ++ * Additional colorspace characteristics. ++ * ++ * Video only. ++ */ ++ enum AVColorRange color_range; ++ enum AVColorPrimaries color_primaries; ++ enum AVColorTransferCharacteristic color_trc; ++ enum AVColorSpace color_space; ++ enum AVChromaLocation chroma_location; ++ ++ /** ++ * Number of delayed frames. ++ * ++ * Video only. ++ */ ++ int video_delay; ++ ++ /** ++ * The channel layout and number of channels. ++ * ++ * Audio only. ++ */ ++ AVChannelLayout ch_layout; ++ /** ++ * The number of audio samples per second. ++ * ++ * Audio only. ++ */ ++ int sample_rate; ++ /** ++ * The number of bytes per coded audio frame, required by some formats. ++ * ++ * Audio only. ++ * ++ * Corresponds to nBlockAlign in WAVEFORMATEX. ++ */ ++ int block_align; ++ /** ++ * Audio frame size, if known. Required by some formats to be static. ++ * ++ * Audio only. ++ */ ++ int frame_size; ++ ++ /** ++ * Number of padding audio samples at the start. ++ * ++ * The amount of padding (in samples) inserted by the encoder at ++ * the beginning of the audio. I.e. this number of leading decoded samples ++ * must be discarded to get the original audio without leading ++ * padding. ++ * ++ * Audio only. ++ */ ++ int initial_padding; ++ /** ++ * Number of padding audio samples at the end. ++ * ++ * The amount of padding (in samples) appended by the encoder to ++ * the end of the audio. I.e. this number of decoded samples must be ++ * discarded from the end of the stream to get the original ++ * audio without any trailing padding. ++ * ++ * Audio only. ++ */ ++ int trailing_padding; ++ /** ++ * Number of audio samples to skip after a discontinuity. ++ * ++ * Audio only. ++ */ ++ int seek_preroll; ++ ++ /** ++ * Video with alpha channel only. Alpha channel handling ++ */ ++ enum AVAlphaMode alpha_mode; ++} AVCodecParameters; ++ ++/** ++ * @relates AVCodecParameters ++ * @{ ++ */ ++ ++/** ++ * Allocate a new AVCodecParameters and set its fields to default values ++ * (unknown/invalid/0). The returned struct must be freed with ++ * ::avcodec_parameters_free(). ++ */ ++AVCodecParameters *avcodec_parameters_alloc(void); ++ ++/** ++ * Free an AVCodecParameters instance and everything associated with it and ++ * write `NULL` to the supplied pointer. ++ */ ++void avcodec_parameters_free(AVCodecParameters **par); ++ ++/** ++ * Copy the contents of \p src to \p dst. Any allocated fields in dst are freed and ++ * replaced with newly allocated duplicates of the corresponding fields in src. ++ * ++ * @return >= 0 on success, a negative AVERROR code on failure. ++ */ ++int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src); ++ ++/** ++ * This function is the same as ::av_get_audio_frame_duration(), except it works ++ * with ::AVCodecParameters instead of an ::AVCodecContext. ++ */ ++int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes); ++ ++/** @} */ ++ ++/** ++ * @} ++ */ ++ ++#endif // AVCODEC_CODEC_PAR_H +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/defs.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/defs.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/defs.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/defs.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/packet.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/packet.h +new file mode 100644 +index 000000000000..00774a703073 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/packet.h +@@ -0,0 +1,950 @@ ++/* ++ * AVPacket public API ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_PACKET_H ++#define AVCODEC_PACKET_H ++ ++#include ++#include ++ ++#include "libavutil/attributes.h" ++#include "libavutil/buffer.h" ++#include "libavutil/dict.h" ++#include "libavutil/rational.h" ++#include "libavutil/version.h" ++ ++#include "libavcodec/version_major.h" ++ ++/** ++ * @defgroup lavc_packet_side_data AVPacketSideData ++ * ++ * Types and functions for working with AVPacketSideData. ++ * @{ ++ */ ++enum AVPacketSideDataType { ++ /** ++ * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE ++ * bytes worth of palette. This side data signals that a new palette is ++ * present. ++ */ ++ AV_PKT_DATA_PALETTE, ++ ++ /** ++ * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format ++ * that the extradata buffer was changed and the receiving side should ++ * act upon it appropriately. The new extradata is embedded in the side ++ * data buffer and should be immediately used for processing the current ++ * frame or packet. ++ */ ++ AV_PKT_DATA_NEW_EXTRADATA, ++ ++ /** ++ * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows: ++ * @code ++ * u32le param_flags ++ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) ++ * s32le sample_rate ++ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) ++ * s32le width ++ * s32le height ++ * @endcode ++ */ ++ AV_PKT_DATA_PARAM_CHANGE, ++ ++ /** ++ * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of ++ * structures with info about macroblocks relevant to splitting the ++ * packet into smaller packets on macroblock edges (e.g. as for RFC 2190). ++ * That is, it does not necessarily contain info about all macroblocks, ++ * as long as the distance between macroblocks in the info is smaller ++ * than the target payload size. ++ * Each MB info structure is 12 bytes, and is laid out as follows: ++ * @code ++ * u32le bit offset from the start of the packet ++ * u8 current quantizer at the start of the macroblock ++ * u8 GOB number ++ * u16le macroblock address within the GOB ++ * u8 horizontal MV predictor ++ * u8 vertical MV predictor ++ * u8 horizontal MV predictor for block number 3 ++ * u8 vertical MV predictor for block number 3 ++ * @endcode ++ */ ++ AV_PKT_DATA_H263_MB_INFO, ++ ++ /** ++ * This side data should be associated with an audio stream and contains ++ * ReplayGain information in form of the AVReplayGain struct. ++ */ ++ AV_PKT_DATA_REPLAYGAIN, ++ ++ /** ++ * This side data contains a 3x3 transformation matrix describing an affine ++ * transformation that needs to be applied to the decoded video frames for ++ * correct presentation. ++ * ++ * See libavutil/display.h for a detailed description of the data. ++ */ ++ AV_PKT_DATA_DISPLAYMATRIX, ++ ++ /** ++ * This side data should be associated with a video stream and contains ++ * Stereoscopic 3D information in form of the AVStereo3D struct. ++ */ ++ AV_PKT_DATA_STEREO3D, ++ ++ /** ++ * This side data should be associated with an audio stream and corresponds ++ * to enum AVAudioServiceType. ++ */ ++ AV_PKT_DATA_AUDIO_SERVICE_TYPE, ++ ++ /** ++ * This side data contains quality related information from the encoder. ++ * @code ++ * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad). ++ * u8 picture type ++ * u8 error count ++ * u16 reserved ++ * u64le[error count] sum of squared differences between encoder in and output ++ * @endcode ++ */ ++ AV_PKT_DATA_QUALITY_STATS, ++ ++ /** ++ * This side data contains an integer value representing the stream index ++ * of a "fallback" track. A fallback track indicates an alternate ++ * track to use when the current track can not be decoded for some reason. ++ * e.g. no decoder available for codec. ++ */ ++ AV_PKT_DATA_FALLBACK_TRACK, ++ ++ /** ++ * This side data corresponds to the AVCPBProperties struct. ++ */ ++ AV_PKT_DATA_CPB_PROPERTIES, ++ ++ /** ++ * Recommends skipping the specified number of samples ++ * @code ++ * u32le number of samples to skip from start of this packet ++ * u32le number of samples to skip from end of this packet ++ * u8 reason for start skip ++ * u8 reason for end skip (0=padding silence, 1=convergence) ++ * @endcode ++ */ ++ AV_PKT_DATA_SKIP_SAMPLES, ++ ++ /** ++ * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that ++ * the packet may contain "dual mono" audio specific to Japanese DTV ++ * and if it is true, recommends only the selected channel to be used. ++ * @code ++ * u8 selected channels (0=main/left, 1=sub/right, 2=both) ++ * @endcode ++ */ ++ AV_PKT_DATA_JP_DUALMONO, ++ ++ /** ++ * A list of zero terminated key/value strings. There is no end marker for ++ * the list, so it is required to rely on the side data size to stop. ++ */ ++ AV_PKT_DATA_STRINGS_METADATA, ++ ++ /** ++ * Subtitle event position ++ * @code ++ * u32le x1 ++ * u32le y1 ++ * u32le x2 ++ * u32le y2 ++ * @endcode ++ */ ++ AV_PKT_DATA_SUBTITLE_POSITION, ++ ++ /** ++ * Data found in BlockAdditional element of matroska container. There is ++ * no end marker for the data, so it is required to rely on the side data ++ * size to recognize the end. 8 byte id (as found in BlockAddId) followed ++ * by data. ++ */ ++ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, ++ ++ /** ++ * The optional first identifier line of a WebVTT cue. ++ */ ++ AV_PKT_DATA_WEBVTT_IDENTIFIER, ++ ++ /** ++ * The optional settings (rendering instructions) that immediately ++ * follow the timestamp specifier of a WebVTT cue. ++ */ ++ AV_PKT_DATA_WEBVTT_SETTINGS, ++ ++ /** ++ * A list of zero terminated key/value strings. There is no end marker for ++ * the list, so it is required to rely on the side data size to stop. This ++ * side data includes updated metadata which appeared in the stream. ++ */ ++ AV_PKT_DATA_METADATA_UPDATE, ++ ++ /** ++ * MPEGTS stream ID as uint8_t, this is required to pass the stream ID ++ * information from the demuxer to the corresponding muxer. ++ */ ++ AV_PKT_DATA_MPEGTS_STREAM_ID, ++ ++ /** ++ * Mastering display metadata (based on SMPTE-2086:2014). This metadata ++ * should be associated with a video stream and contains data in the form ++ * of the AVMasteringDisplayMetadata struct. ++ */ ++ AV_PKT_DATA_MASTERING_DISPLAY_METADATA, ++ ++ /** ++ * This side data should be associated with a video stream and corresponds ++ * to the AVSphericalMapping structure. ++ */ ++ AV_PKT_DATA_SPHERICAL, ++ ++ /** ++ * Content light level (based on CTA-861.3). This metadata should be ++ * associated with a video stream and contains data in the form of the ++ * AVContentLightMetadata struct. ++ */ ++ AV_PKT_DATA_CONTENT_LIGHT_LEVEL, ++ ++ /** ++ * ATSC A53 Part 4 Closed Captions. This metadata should be associated with ++ * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data. ++ * The number of bytes of CC data is AVPacketSideData.size. ++ */ ++ AV_PKT_DATA_A53_CC, ++ ++ /** ++ * This side data is encryption initialization data. ++ * The format is not part of ABI, use av_encryption_init_info_* methods to ++ * access. ++ */ ++ AV_PKT_DATA_ENCRYPTION_INIT_INFO, ++ ++ /** ++ * This side data contains encryption info for how to decrypt the packet. ++ * The format is not part of ABI, use av_encryption_info_* methods to access. ++ */ ++ AV_PKT_DATA_ENCRYPTION_INFO, ++ ++ /** ++ * Active Format Description data consisting of a single byte as specified ++ * in ETSI TS 101 154 using AVActiveFormatDescription enum. ++ */ ++ AV_PKT_DATA_AFD, ++ ++ /** ++ * Producer Reference Time data corresponding to the AVProducerReferenceTime struct, ++ * usually exported by some encoders (on demand through the prft flag set in the ++ * AVCodecContext export_side_data field). ++ */ ++ AV_PKT_DATA_PRFT, ++ ++ /** ++ * ICC profile data consisting of an opaque octet buffer following the ++ * format described by ISO 15076-1. ++ */ ++ AV_PKT_DATA_ICC_PROFILE, ++ ++ /** ++ * DOVI configuration ++ * ref: ++ * dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2 ++ * dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3 ++ * Tags are stored in struct AVDOVIDecoderConfigurationRecord. ++ */ ++ AV_PKT_DATA_DOVI_CONF, ++ ++ /** ++ * Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t ++ * where the first uint32_t describes how many (1-3) of the other timecodes are used. ++ * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum() ++ * function in libavutil/timecode.h. ++ */ ++ AV_PKT_DATA_S12M_TIMECODE, ++ ++ /** ++ * HDR10+ dynamic metadata associated with a video frame. The metadata is in ++ * the form of the AVDynamicHDRPlus struct and contains ++ * information for color volume transform - application 4 of ++ * SMPTE 2094-40:2016 standard. ++ */ ++ AV_PKT_DATA_DYNAMIC_HDR10_PLUS, ++ ++ /** ++ * IAMF Mix Gain Parameter Data associated with the audio frame. This metadata ++ * is in the form of the AVIAMFParamDefinition struct and contains information ++ * defined in sections 3.6.1 and 3.8.1 of the Immersive Audio Model and ++ * Formats standard. ++ */ ++ AV_PKT_DATA_IAMF_MIX_GAIN_PARAM, ++ ++ /** ++ * IAMF Demixing Info Parameter Data associated with the audio frame. This ++ * metadata is in the form of the AVIAMFParamDefinition struct and contains ++ * information defined in sections 3.6.1 and 3.8.2 of the Immersive Audio Model ++ * and Formats standard. ++ */ ++ AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM, ++ ++ /** ++ * IAMF Recon Gain Info Parameter Data associated with the audio frame. This ++ * metadata is in the form of the AVIAMFParamDefinition struct and contains ++ * information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model ++ * and Formats standard. ++ */ ++ AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM, ++ ++ /** ++ * Ambient viewing environment metadata, as defined by H.274. This metadata ++ * should be associated with a video stream and contains data in the form ++ * of the AVAmbientViewingEnvironment struct. ++ */ ++ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT, ++ ++ /** ++ * The number of pixels to discard from the top/bottom/left/right border of the ++ * decoded frame to obtain the sub-rectangle intended for presentation. ++ * ++ * @code ++ * u32le crop_top ++ * u32le crop_bottom ++ * u32le crop_left ++ * u32le crop_right ++ * @endcode ++ */ ++ AV_PKT_DATA_FRAME_CROPPING, ++ ++ /** ++ * Raw LCEVC payload data, as a uint8_t array, with NAL emulation ++ * bytes intact. ++ */ ++ AV_PKT_DATA_LCEVC, ++ ++ /** ++ * This side data contains information about the reference display width(s) ++ * and reference viewing distance(s) as well as information about the ++ * corresponding reference stereo pair(s), i.e., the pair(s) of views to be ++ * displayed for the viewer's left and right eyes on the reference display ++ * at the reference viewing distance. ++ * The payload is the AV3DReferenceDisplaysInfo struct defined in ++ * libavutil/tdrdi.h. ++ */ ++ AV_PKT_DATA_3D_REFERENCE_DISPLAYS, ++ ++ /** ++ * Contains the last received RTCP SR (Sender Report) information ++ * in the form of the AVRTCPSenderReport struct. ++ */ ++ AV_PKT_DATA_RTCP_SR, ++ ++ /** ++ * Extensible image file format metadata. The payload is a buffer containing ++ * EXIF metadata, starting with either 49 49 2a 00, or 4d 4d 00 2a. ++ */ ++ AV_PKT_DATA_EXIF, ++ ++ /** ++ * HDR dynamic metadata associated with a video frame. The payload is an ++ * AVDynamicHDRSmpte2094App5 type and contains information for color volume ++ * transform as specified in the SMPTE 2094-50 standard. ++ */ ++ AV_PKT_DATA_DYNAMIC_HDR_SMPTE_2094_APP5, ++ ++ /** ++ * Dolby Vision enhancement-layer HEVC decoder configuration. ++ * Parsed from the @c hvcE box in ISOM-based containers or the ++ * corresponding BlockAdditionMapping in Matroska. The data is a raw ++ * HEVCDecoderConfigurationRecord as defined in ISO 14496-15. ++ */ ++ AV_PKT_DATA_HEVC_CONF, ++ ++ /** ++ * The number of side data types. ++ * This is not part of the public API/ABI in the sense that it may ++ * change when new side data types are added. ++ * This must stay the last enum value. ++ * If its value becomes huge, some code using it ++ * needs to be updated as it assumes it to be smaller than other limits. ++ */ ++ AV_PKT_DATA_NB ++}; ++ ++/** ++ * This structure stores auxiliary information for decoding, presenting, or ++ * otherwise processing the coded stream. It is typically exported by demuxers ++ * and encoders and can be fed to decoders and muxers either in a per packet ++ * basis, or as global side data (applying to the entire coded stream). ++ * ++ * Global side data is handled as follows: ++ * - During demuxing, it may be exported through ++ * @ref AVCodecParameters.coded_side_data "AVStream's codec parameters", which can ++ * then be passed as input to decoders through the ++ * @ref AVCodecContext.coded_side_data "decoder context's side data", for ++ * initialization. ++ * - For muxing, it can be fed through @ref AVCodecParameters.coded_side_data ++ * "AVStream's codec parameters", typically the output of encoders through ++ * the @ref AVCodecContext.coded_side_data "encoder context's side data", for ++ * initialization. ++ * ++ * Packet specific side data is handled as follows: ++ * - During demuxing, it may be exported through @ref AVPacket.side_data ++ * "AVPacket's side data", which can then be passed as input to decoders. ++ * - For muxing, it can be fed through @ref AVPacket.side_data "AVPacket's ++ * side data", typically the output of encoders. ++ * ++ * Different modules may accept or export different types of side data ++ * depending on media type and codec. Refer to @ref AVPacketSideDataType for a ++ * list of defined types and where they may be found or used. ++ */ ++typedef struct AVPacketSideData { ++ uint8_t *data; ++ size_t size; ++ enum AVPacketSideDataType type; ++} AVPacketSideData; ++ ++/** ++ * Allocate a new packet side data. ++ * ++ * @param sd pointer to an array of side data to which the side data should ++ * be added. *sd may be NULL, in which case the array will be ++ * initialized. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. The integer value will be increased by 1 on success. ++ * @param type side data type ++ * @param size desired side data size ++ * @param flags currently unused. Must be zero ++ * ++ * @return pointer to freshly allocated side data on success, or NULL otherwise. ++ */ ++AVPacketSideData *av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, ++ enum AVPacketSideDataType type, ++ size_t size, int flags); ++ ++/** ++ * Wrap existing data as packet side data. ++ * ++ * @param sd pointer to an array of side data to which the side data should ++ * be added. *sd may be NULL, in which case the array will be ++ * initialized ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. The integer value will be increased by 1 on success. ++ * @param type side data type ++ * @param data a data array. It must be allocated with the av_malloc() family ++ * of functions. The ownership of the data is transferred to the ++ * side data array on success ++ * @param size size of the data array ++ * @param flags currently unused. Must be zero ++ * ++ * @return pointer to freshly allocated side data on success, or NULL otherwise ++ * On failure, the side data array is unchanged and the data remains ++ * owned by the caller. ++ */ ++AVPacketSideData *av_packet_side_data_add(AVPacketSideData **sd, int *nb_sd, ++ enum AVPacketSideDataType type, ++ void *data, size_t size, int flags); ++ ++/** ++ * Get side information from a side data array. ++ * ++ * @param sd the array from which the side data should be fetched ++ * @param nb_sd value containing the number of entries in the array. ++ * @param type desired side information type ++ * ++ * @return pointer to side data if present or NULL otherwise ++ */ ++const AVPacketSideData *av_packet_side_data_get(const AVPacketSideData *sd, ++ int nb_sd, ++ enum AVPacketSideDataType type); ++ ++/** ++ * Remove side data of the given type from a side data array. ++ * ++ * @param sd the array from which the side data should be removed ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. Will be reduced by the amount of entries removed ++ * upon return ++ * @param type side information type ++ */ ++void av_packet_side_data_remove(AVPacketSideData *sd, int *nb_sd, ++ enum AVPacketSideDataType type); ++ ++/** ++ * Convenience function to free all the side data stored in an array, and ++ * the array itself. ++ * ++ * @param sd pointer to array of side data to free. Will be set to NULL ++ * upon return. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. Will be set to 0 upon return. ++ */ ++void av_packet_side_data_free(AVPacketSideData **sd, int *nb_sd); ++ ++struct AVFrameSideData; ++ ++/** ++ * Add a new packet side data entry to an array based on existing frame ++ * side data, if a matching type exists for packet side data. ++ * ++ * @param flags Currently unused. Must be 0. ++ * @retval >= 0 Success ++ * @retval AVERROR(EINVAL) The frame side data type does not have a matching ++ * packet side data type. ++ * @retval AVERROR(ENOMEM) Failed to add a side data entry to the array, or ++ * similar. ++ */ ++int av_packet_side_data_from_frame(AVPacketSideData **sd, int *nb_sd, ++ const struct AVFrameSideData *src, unsigned int flags); ++/** ++ * Add a new frame side data entry to an array based on existing packet ++ * side data, if a matching type exists for frame side data. ++ * ++ * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, ++ * or 0. ++ * @retval >= 0 Success ++ * @retval AVERROR(EINVAL) The packet side data type does not have a matching ++ * frame side data type. ++ * @retval AVERROR(ENOMEM) Failed to add a side data entry to the array, or ++ * similar. ++ */ ++int av_packet_side_data_to_frame(struct AVFrameSideData ***sd, int *nb_sd, ++ const AVPacketSideData *src, unsigned int flags); ++ ++const char *av_packet_side_data_name(enum AVPacketSideDataType type); ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @defgroup lavc_packet AVPacket ++ * ++ * Types and functions for working with AVPacket. ++ * @{ ++ */ ++ ++/** ++ * This structure stores compressed data. It is typically exported by demuxers ++ * and then passed as input to decoders, or received as output from encoders and ++ * then passed to muxers. ++ * ++ * For video, it should typically contain one compressed frame. For audio it may ++ * contain several compressed frames. Encoders are allowed to output empty ++ * packets, with no compressed data, containing only side data ++ * (e.g. to update some stream parameters at the end of encoding). ++ * ++ * The semantics of data ownership depends on the buf field. ++ * If it is set, the packet data is dynamically allocated and is ++ * valid indefinitely until a call to av_packet_unref() reduces the ++ * reference count to 0. ++ * ++ * If the buf field is not set av_packet_ref() would make a copy instead ++ * of increasing the reference count. ++ * ++ * The side data is always allocated with av_malloc(), copied by ++ * av_packet_ref() and freed by av_packet_unref(). ++ * ++ * sizeof(AVPacket) being a part of the public ABI is deprecated. once ++ * av_init_packet() is removed, new packets will only be able to be allocated ++ * with av_packet_alloc(), and new fields may be added to the end of the struct ++ * with a minor bump. ++ * ++ * @see av_packet_alloc ++ * @see av_packet_ref ++ * @see av_packet_unref ++ */ ++typedef struct AVPacket { ++ /** ++ * A reference to the reference-counted buffer where the packet data is ++ * stored. ++ * May be NULL, then the packet data is not reference-counted. ++ */ ++ AVBufferRef *buf; ++ /** ++ * 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; ++ /** ++ * A combination of AV_PKT_FLAG values ++ */ ++ int flags; ++ /** ++ * Additional packet data that can be provided by the container. ++ * Packet can contain several types of side information. ++ */ ++ AVPacketSideData *side_data; ++ int side_data_elems; ++ ++ /** ++ * Duration of this packet in AVStream->time_base units, 0 if unknown. ++ * Equals next_pts - this_pts in presentation order. ++ */ ++ int64_t duration; ++ ++ int64_t pos; ///< byte position in stream, -1 if unknown ++ ++ /** ++ * for some private data of the user ++ */ ++ void *opaque; ++ ++ /** ++ * AVBufferRef for free use by the API user. FFmpeg will never check the ++ * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when ++ * the packet is unreferenced. av_packet_copy_props() calls create a new ++ * reference with av_buffer_ref() for the target packet's opaque_ref field. ++ * ++ * This is unrelated to the opaque field, although it serves a similar ++ * purpose. ++ */ ++ AVBufferRef *opaque_ref; ++ ++ /** ++ * Time base of the packet's timestamps. ++ * In the future, this field may be set on packets output by encoders or ++ * demuxers, but its value will be by default ignored on input to decoders ++ * or muxers. ++ */ ++ AVRational time_base; ++} AVPacket; ++ ++#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe ++#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted ++/** ++ * Flag is used to discard packets which are required to maintain valid ++ * decoder state but are not required for output and should be dropped ++ * after decoding. ++ **/ ++#define AV_PKT_FLAG_DISCARD 0x0004 ++/** ++ * The packet comes from a trusted source. ++ * ++ * Otherwise-unsafe constructs such as arbitrary pointers to data ++ * outside the packet may be followed. ++ */ ++#define AV_PKT_FLAG_TRUSTED 0x0008 ++/** ++ * Flag is used to indicate packets that contain frames that can ++ * be discarded by the decoder. I.e. Non-reference frames. ++ */ ++#define AV_PKT_FLAG_DISPOSABLE 0x0010 ++ ++enum AVSideDataParamChangeFlags { ++ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, ++ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, ++}; ++ ++/** ++ * Allocate an AVPacket and set its fields to default values. The resulting ++ * struct must be freed using av_packet_free(). ++ * ++ * @return An AVPacket filled with default values or NULL on failure. ++ * ++ * @note this only allocates the AVPacket itself, not the data buffers. Those ++ * must be allocated through other means such as av_new_packet. ++ * ++ * @see av_new_packet ++ */ ++AVPacket *av_packet_alloc(void); ++ ++/** ++ * Create a new packet that references the same data as src. ++ * ++ * This is a shortcut for av_packet_alloc()+av_packet_ref(). ++ * ++ * @return newly created AVPacket on success, NULL on error. ++ * ++ * @see av_packet_alloc ++ * @see av_packet_ref ++ */ ++AVPacket *av_packet_clone(const AVPacket *src); ++ ++/** ++ * Free the packet, if the packet is reference counted, it will be ++ * unreferenced first. ++ * ++ * @param pkt packet to be freed. The pointer will be set to NULL. ++ * @note passing NULL is a no-op. ++ */ ++void av_packet_free(AVPacket **pkt); ++ ++#if FF_API_INIT_PACKET ++/** ++ * Initialize optional fields of a packet with default values. ++ * ++ * Note, this does not touch the data and size members, which have to be ++ * initialized separately. ++ * ++ * @param pkt packet ++ * ++ * @see av_packet_alloc ++ * @see av_packet_unref ++ * ++ * @deprecated This function is deprecated. Once it's removed, ++ sizeof(AVPacket) will not be a part of the ABI anymore. ++ */ ++attribute_deprecated ++void av_init_packet(AVPacket *pkt); ++#endif ++ ++/** ++ * 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); ++ ++/** ++ * Increase packet size, correctly zeroing padding ++ * ++ * @param pkt packet ++ * @param grow_by number of bytes by which to increase the size of the packet ++ */ ++int av_grow_packet(AVPacket *pkt, int grow_by); ++ ++/** ++ * Initialize a reference-counted packet from av_malloc()ed data. ++ * ++ * @param pkt packet to be initialized. This function will set the data, size, ++ * and buf fields, all others are left untouched. ++ * @param data Data allocated by av_malloc() to be used as packet data. If this ++ * function returns successfully, the data is owned by the underlying AVBuffer. ++ * The caller may not access the data through other means. ++ * @param size size of data in bytes, without the padding. I.e. the full buffer ++ * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE. ++ * ++ * @return 0 on success, a negative AVERROR on error ++ */ ++int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size); ++ ++/** ++ * Allocate new information of a packet. ++ * ++ * @param pkt packet ++ * @param type side information type ++ * @param size side information size ++ * @return pointer to fresh allocated data or NULL otherwise ++ */ ++uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, ++ size_t size); ++ ++/** ++ * Wrap an existing array as a packet side data. ++ * ++ * @param pkt packet ++ * @param type side information type ++ * @param data the side data array. It must be allocated with the av_malloc() ++ * family of functions. The ownership of the data is transferred to ++ * pkt. ++ * @param size side information size ++ * @return a non-negative number on success, a negative AVERROR code on ++ * failure. On failure, the packet is unchanged and the data remains ++ * owned by the caller. ++ */ ++int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, ++ uint8_t *data, size_t size); ++ ++/** ++ * Shrink the already allocated side data buffer ++ * ++ * @param pkt packet ++ * @param type side information type ++ * @param size new side information size ++ * @return 0 on success, < 0 on failure ++ */ ++int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, ++ size_t size); ++ ++/** ++ * Get side information from packet. ++ * ++ * @param pkt packet ++ * @param type desired side information type ++ * @param size If supplied, *size will be set to the size of the side data ++ * or to zero if the desired side data is not present. ++ * @return pointer to data if present or NULL otherwise ++ */ ++uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, ++ size_t *size); ++ ++/** ++ * Pack a dictionary for use in side_data. ++ * ++ * @param dict The dictionary to pack. ++ * @param size pointer to store the size of the returned data ++ * @return pointer to data if successful, NULL otherwise ++ */ ++uint8_t *av_packet_pack_dictionary(const AVDictionary *dict, size_t *size); ++/** ++ * Unpack a dictionary from side_data. ++ * ++ * @param data data from side_data ++ * @param size size of the data ++ * @param dict the metadata storage dictionary ++ * @return 0 on success, < 0 on failure ++ */ ++int av_packet_unpack_dictionary(const uint8_t *data, size_t size, ++ AVDictionary **dict); ++ ++/** ++ * Convenience function to free all the side data stored. ++ * All the other fields stay untouched. ++ * ++ * @param pkt packet ++ */ ++void av_packet_free_side_data(AVPacket *pkt); ++ ++/** ++ * Setup a new reference to the data described by a given packet ++ * ++ * If src is reference-counted, setup dst as a new reference to the ++ * buffer in src. Otherwise allocate a new buffer in dst and copy the ++ * data from src into it. ++ * ++ * All the other fields are copied from src. ++ * ++ * @see av_packet_unref ++ * ++ * @param dst Destination packet. Will be completely overwritten. ++ * @param src Source packet ++ * ++ * @return 0 on success, a negative AVERROR on error. On error, dst ++ * will be blank (as if returned by av_packet_alloc()). ++ */ ++int av_packet_ref(AVPacket *dst, const AVPacket *src); ++ ++/** ++ * Wipe the packet. ++ * ++ * Unreference the buffer referenced by the packet and reset the ++ * remaining packet fields to their default values. ++ * ++ * @param pkt The packet to be unreferenced. ++ */ ++void av_packet_unref(AVPacket *pkt); ++ ++/** ++ * Move every field in src to dst and reset src. ++ * ++ * @see av_packet_unref ++ * ++ * @param src Source packet, will be reset ++ * @param dst Destination packet ++ */ ++void av_packet_move_ref(AVPacket *dst, AVPacket *src); ++ ++/** ++ * Copy only "properties" fields from src to dst. ++ * ++ * Properties for the purpose of this function are all the fields ++ * beside those related to the packet data (buf, data, size) ++ * ++ * @param dst Destination packet ++ * @param src Source packet ++ * ++ * @return 0 on success AVERROR on failure. ++ */ ++int av_packet_copy_props(AVPacket *dst, const AVPacket *src); ++ ++/** ++ * Ensure the data described by a given packet is reference counted. ++ * ++ * @note This function does not ensure that the reference will be writable. ++ * Use av_packet_make_writable instead for that purpose. ++ * ++ * @see av_packet_ref ++ * @see av_packet_make_writable ++ * ++ * @param pkt packet whose data should be made reference counted. ++ * ++ * @return 0 on success, a negative AVERROR on error. On failure, the ++ * packet is unchanged. ++ */ ++int av_packet_make_refcounted(AVPacket *pkt); ++ ++/** ++ * Create a writable reference for the data described by a given packet, ++ * avoiding data copy if possible. ++ * ++ * @param pkt Packet whose data should be made writable. ++ * ++ * @return 0 on success, a negative AVERROR on failure. On failure, the ++ * packet is unchanged. ++ */ ++int av_packet_make_writable(AVPacket *pkt); ++ ++/** ++ * Convert valid timing fields (timestamps / durations) in a packet from one ++ * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be ++ * ignored. ++ * ++ * @param pkt packet on which the conversion will be performed ++ * @param tb_src source timebase, in which the timing fields in pkt are ++ * expressed ++ * @param tb_dst destination timebase, to which the timing fields will be ++ * converted ++ */ ++void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst); ++ ++/** ++ * Allocate an AVContainerFifo instance for AVPacket. ++ * ++ * @param flags currently unused ++ */ ++struct AVContainerFifo *av_container_fifo_alloc_avpacket(unsigned flags); ++ ++/** ++ * @} ++ */ ++ ++#endif // AVCODEC_PACKET_H +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/vdpau.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/vdpau.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavcodec/vdpau.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/vdpau.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version.h +new file mode 100644 +index 000000000000..39dbec020812 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version.h +@@ -0,0 +1,45 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_VERSION_H ++#define AVCODEC_VERSION_H ++ ++/** ++ * @file ++ * @ingroup libavc ++ * Libavcodec version macros. ++ */ ++ ++#include "libavutil/version.h" ++ ++#include "version_major.h" ++ ++#define LIBAVCODEC_VERSION_MINOR 6 ++#define LIBAVCODEC_VERSION_MICRO 101 ++ ++#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ ++ LIBAVCODEC_VERSION_MINOR, \ ++ LIBAVCODEC_VERSION_MICRO) ++#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \ ++ LIBAVCODEC_VERSION_MINOR, \ ++ LIBAVCODEC_VERSION_MICRO) ++#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT ++ ++#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) ++ ++#endif /* AVCODEC_VERSION_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version_major.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version_major.h +new file mode 100644 +index 000000000000..166646eb6d72 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavcodec/version_major.h +@@ -0,0 +1,45 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_VERSION_MAJOR_H ++#define AVCODEC_VERSION_MAJOR_H ++ ++/** ++ * @file ++ * @ingroup libavc ++ * Libavcodec version macros. ++ */ ++ ++#define LIBAVCODEC_VERSION_MAJOR 63 ++ ++/** ++ * FF_API_* defines may be placed below to indicate public API that will be ++ * dropped at a future version bump. The defines themselves are not part of ++ * the public API and may change, break or disappear at any time. ++ * ++ * @note, when bumping the major version it is recommended to manually ++ * disable each FF_API_* in its own commit instead of disabling them all ++ * at once through the bump. This improves the git bisect-ability of the change. ++ */ ++ ++#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 64) ++ ++#define FF_API_INTRA_DC_PRECISION (LIBAVCODEC_VERSION_MAJOR < 64) ++#define FF_API_MJPEG_EXTERN_HUFF (LIBAVCODEC_VERSION_MAJOR < 64) ++ ++#endif /* AVCODEC_VERSION_MAJOR_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/attributes.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/attributes.h +new file mode 100644 +index 000000000000..cd4c4338c7fa +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/attributes.h +@@ -0,0 +1,235 @@ ++/* ++ * copyright (c) 2006 Michael Niedermayer ++ * ++ * 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 ++ */ ++ ++/** ++ * @file ++ * Macro definitions for various function/variable attributes ++ */ ++ ++#ifndef AVUTIL_ATTRIBUTES_H ++#define AVUTIL_ATTRIBUTES_H ++ ++#ifdef __GNUC__ ++# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y)) ++# define AV_GCC_VERSION_AT_MOST(x,y) (__GNUC__ < (x) || __GNUC__ == (x) && __GNUC_MINOR__ <= (y)) ++#else ++# define AV_GCC_VERSION_AT_LEAST(x,y) 0 ++# define AV_GCC_VERSION_AT_MOST(x,y) 0 ++#endif ++ ++#ifdef __has_builtin ++# define AV_HAS_BUILTIN(x) __has_builtin(x) ++#else ++# define AV_HAS_BUILTIN(x) 0 ++#endif ++ ++#ifdef __has_attribute ++# define AV_HAS_ATTRIBUTE(x) __has_attribute(x) ++#else ++# define AV_HAS_ATTRIBUTE(x) 0 ++#endif ++ ++#if defined(__cplusplus) && \ ++ defined(__has_cpp_attribute) && \ ++ __cplusplus >= 201103L ++# define AV_HAS_STD_ATTRIBUTE(x) __has_cpp_attribute(x) ++#elif !defined(__cplusplus) && \ ++ defined(__has_c_attribute) && \ ++ defined(__STDC_VERSION__) && \ ++ __STDC_VERSION__ >= 202311L ++# define AV_HAS_STD_ATTRIBUTE(x) __has_c_attribute(x) ++#else ++# define AV_HAS_STD_ATTRIBUTE(x) 0 ++#endif ++ ++#if AV_HAS_STD_ATTRIBUTE(fallthrough) ++# define av_fallthrough [[fallthrough]] ++#elif AV_HAS_ATTRIBUTE(fallthrough) ++# define av_fallthrough __attribute__((fallthrough)) ++#else ++# define av_fallthrough do {} while(0) ++#endif ++ ++#ifndef av_always_inline ++#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) ++# define av_always_inline __attribute__((always_inline)) inline ++#elif defined(_MSC_VER) ++# define av_always_inline __forceinline ++#else ++# define av_always_inline inline ++#endif ++#endif ++ ++#ifndef av_extern_inline ++#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__) ++# define av_extern_inline extern inline ++#else ++# define av_extern_inline inline ++#endif ++#endif ++ ++#if AV_HAS_STD_ATTRIBUTE(nodiscard) ++# define av_warn_unused_result [[nodiscard]] ++#elif AV_GCC_VERSION_AT_LEAST(3,4) || defined(__clang__) ++# define av_warn_unused_result __attribute__((warn_unused_result)) ++#else ++# define av_warn_unused_result ++#endif ++ ++#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) ++# define av_noinline __attribute__((noinline)) ++#elif defined(_MSC_VER) ++# define av_noinline __declspec(noinline) ++#else ++# define av_noinline ++#endif ++ ++#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) ++# define av_pure __attribute__((pure)) ++#else ++# define av_pure ++#endif ++ ++#if AV_GCC_VERSION_AT_LEAST(2,6) || defined(__clang__) ++# define av_const __attribute__((const)) ++#else ++# define av_const ++#endif ++ ++#if AV_GCC_VERSION_AT_LEAST(4,3) || defined(__clang__) ++# define av_cold __attribute__((cold)) ++#else ++# define av_cold ++#endif ++ ++#if (AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__clang__ )) || AV_HAS_ATTRIBUTE(flatten) ++# define av_flatten __attribute__((flatten)) ++#else ++# define av_flatten ++#endif ++ ++#if AV_HAS_STD_ATTRIBUTE(deprecated) ++# define attribute_deprecated [[deprecated]] ++#elif AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) ++# define attribute_deprecated __attribute__((deprecated)) ++#elif defined(_MSC_VER) ++# define attribute_deprecated __declspec(deprecated) ++#else ++# define attribute_deprecated ++#endif ++ ++/** ++ * Disable warnings about deprecated features ++ * This is useful for sections of code kept for backward compatibility and ++ * scheduled for removal. ++ */ ++#ifndef AV_NOWARN_DEPRECATED ++#if AV_GCC_VERSION_AT_LEAST(4,6) || defined(__clang__) ++# define AV_NOWARN_DEPRECATED(code) \ ++ _Pragma("GCC diagnostic push") \ ++ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ ++ code \ ++ _Pragma("GCC diagnostic pop") ++#elif defined(_MSC_VER) ++# define AV_NOWARN_DEPRECATED(code) \ ++ __pragma(warning(push)) \ ++ __pragma(warning(disable : 4996)) \ ++ code; \ ++ __pragma(warning(pop)) ++#else ++# define AV_NOWARN_DEPRECATED(code) code ++#endif ++#endif ++ ++#if AV_HAS_STD_ATTRIBUTE(maybe_unused) ++# define av_unused [[maybe_unused]] ++#elif defined(__GNUC__) || defined(__clang__) ++# define av_unused __attribute__((unused)) ++#else ++# define av_unused ++#endif ++ ++/** ++ * Mark a variable as used and prevent the compiler from optimizing it ++ * away. This is useful for variables accessed only from inline ++ * assembler without the compiler being aware. ++ */ ++#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) ++# define av_used __attribute__((used)) ++#else ++# define av_used ++#endif ++ ++#if AV_GCC_VERSION_AT_LEAST(3,3) || defined(__clang__) ++# define av_alias __attribute__((may_alias)) ++#else ++# define av_alias ++#endif ++ ++#if (defined(__GNUC__) || defined(__clang__)) && !defined(__INTEL_COMPILER) ++# define av_uninit(x) x=x ++#else ++# define av_uninit(x) x ++#endif ++ ++#if defined(__GNUC__) || defined(__clang__) ++# define av_builtin_constant_p __builtin_constant_p ++#else ++# define av_builtin_constant_p(x) 0 ++#endif ++ ++// for __MINGW_PRINTF_FORMAT and __MINGW_SCANF_FORMAT ++#ifdef __MINGW32__ ++# include ++#endif ++ ++#ifdef __MINGW_PRINTF_FORMAT ++# define AV_PRINTF_FMT __MINGW_PRINTF_FORMAT ++#elif AV_HAS_ATTRIBUTE(format) ++# define AV_PRINTF_FMT __printf__ ++#endif ++ ++#ifdef __MINGW_SCANF_FORMAT ++# define AV_SCANF_FMT __MINGW_SCANF_FORMAT ++#elif AV_HAS_ATTRIBUTE(format) ++# define AV_SCANF_FMT __scanf__ ++#endif ++ ++#ifdef AV_PRINTF_FMT ++# define av_printf_format(fmtpos, attrpos) __attribute__((format(AV_PRINTF_FMT, fmtpos, attrpos))) ++#else ++# define av_printf_format(fmtpos, attrpos) ++#endif ++ ++#ifdef AV_SCANF_FMT ++# define av_scanf_format(fmtpos, attrpos) __attribute__((format(AV_SCANF_FMT, fmtpos, attrpos))) ++#else ++# define av_scanf_format(fmtpos, attrpos) ++#endif ++ ++#if AV_HAS_STD_ATTRIBUTE(noreturn) ++# define av_noreturn [[noreturn]] ++#elif AV_GCC_VERSION_AT_LEAST(2,5) || defined(__clang__) ++# define av_noreturn __attribute__((noreturn)) ++#else ++# define av_noreturn ++#endif ++ ++#endif /* AVUTIL_ATTRIBUTES_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg58/include/libavutil/avconfig.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avconfig.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg58/include/libavutil/avconfig.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avconfig.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avutil.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avutil.h +new file mode 100644 +index 000000000000..003a63b7b112 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/avutil.h +@@ -0,0 +1,340 @@ ++/* ++ * copyright (c) 2006 Michael Niedermayer ++ * ++ * 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 AVUTIL_AVUTIL_H ++#define AVUTIL_AVUTIL_H ++ ++/** ++ * @file ++ * @ingroup lavu ++ * Convenience header that includes @ref lavu "libavutil"'s core. ++ */ ++ ++/** ++ * @mainpage ++ * ++ * @section ffmpeg_intro Introduction ++ * ++ * This document describes the usage of the different libraries ++ * provided by FFmpeg. ++ * ++ * @li @ref libavc "libavcodec" encoding/decoding library ++ * @li @ref lavfi "libavfilter" graph-based frame editing library ++ * @li @ref libavf "libavformat" I/O and muxing/demuxing library ++ * @li @ref lavd "libavdevice" special devices muxing/demuxing library ++ * @li @ref lavu "libavutil" common utility library ++ * @li @ref lswr "libswresample" audio resampling, format conversion and mixing ++ * @li @ref libsws "libswscale" color conversion and scaling library ++ * ++ * @section ffmpeg_versioning Versioning and compatibility ++ * ++ * Each of the FFmpeg libraries contains a version.h header, which defines a ++ * major, minor and micro version number with the ++ * LIBRARYNAME_VERSION_{MAJOR,MINOR,MICRO} macros. The major version ++ * number is incremented with backward incompatible changes - e.g. removing ++ * parts of the public API, reordering public struct members, etc. The minor ++ * version number is incremented for backward compatible API changes or major ++ * new features - e.g. adding a new public function or a new decoder. The micro ++ * version number is incremented for smaller changes that a calling program ++ * might still want to check for - e.g. changing behavior in a previously ++ * unspecified situation. ++ * ++ * FFmpeg guarantees backward API and ABI compatibility for each library as long ++ * as its major version number is unchanged. This means that no public symbols ++ * will be removed or renamed. Types and names of the public struct members and ++ * values of public macros and enums will remain the same (unless they were ++ * explicitly declared as not part of the public API). Documented behavior will ++ * not change. ++ * ++ * In other words, any correct program that works with a given FFmpeg snapshot ++ * should work just as well without any changes with any later snapshot with the ++ * same major versions. This applies to both rebuilding the program against new ++ * FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program ++ * links against. ++ * ++ * However, new public symbols may be added and new members may be appended to ++ * public structs whose size is not part of public ABI (most public structs in ++ * FFmpeg). New macros and enum values may be added. Behavior in undocumented ++ * situations may change slightly (and be documented). All those are accompanied ++ * by an entry in doc/APIchanges and incrementing either the minor or micro ++ * version number. ++ */ ++ ++/** ++ * @defgroup lavu libavutil ++ * Common code shared across all FFmpeg libraries. ++ * ++ * @note ++ * libavutil is designed to be modular. In most cases, in order to use the ++ * functions provided by one component of libavutil you must explicitly include ++ * the specific header containing that feature. If you are only using ++ * media-related components, you could simply include libavutil/avutil.h, which ++ * brings in most of the "core" components. ++ * ++ * @{ ++ * ++ * @defgroup lavu_crypto Crypto and Hashing ++ * ++ * @{ ++ * @} ++ * ++ * @defgroup lavu_math Mathematics ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_string String Manipulation ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_mem Memory Management ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_data Data Structures ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_video Video related ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_audio Audio related ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_error Error Codes ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_log Logging Facility ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup lavu_misc Other ++ * ++ * @{ ++ * ++ * @defgroup preproc_misc Preprocessor String Macros ++ * ++ * @{ ++ * ++ * @} ++ * ++ * @defgroup version_utils Library Version Macros ++ * ++ * @{ ++ * ++ * @} ++ */ ++ ++ ++/** ++ * @addtogroup lavu_ver ++ * @{ ++ */ ++ ++/** ++ * Return the LIBAVUTIL_VERSION_INT constant. ++ */ ++unsigned avutil_version(void); ++ ++/** ++ * Return an informative version string. This usually is the actual release ++ * version number or a git commit description. This string has no fixed format ++ * and can change any time. It should never be parsed by code. ++ */ ++const char *av_version_info(void); ++ ++/** ++ * Return the libavutil build-time configuration. ++ */ ++const char *avutil_configuration(void); ++ ++/** ++ * Return the libavutil license. ++ */ ++const char *avutil_license(void); ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @addtogroup lavu_media Media Type ++ * @brief Media Type ++ */ ++ ++enum AVMediaType { ++ AVMEDIA_TYPE_UNKNOWN = -1, ///< Usually treated as AVMEDIA_TYPE_DATA ++ AVMEDIA_TYPE_VIDEO, ++ AVMEDIA_TYPE_AUDIO, ++ AVMEDIA_TYPE_DATA, ///< Opaque data information usually continuous ++ AVMEDIA_TYPE_SUBTITLE, ++ AVMEDIA_TYPE_ATTACHMENT, ///< Opaque data information usually sparse ++ AVMEDIA_TYPE_NB ++}; ++ ++/** ++ * Return a string describing the media_type enum, NULL if media_type ++ * is unknown. ++ */ ++const char *av_get_media_type_string(enum AVMediaType media_type); ++ ++/** ++ * @defgroup lavu_const Constants ++ * @{ ++ * ++ * @defgroup lavu_enc Encoding specific ++ * ++ * @note those definition should move to avcodec ++ * @{ ++ */ ++ ++#define FF_LAMBDA_SHIFT 7 ++#define FF_LAMBDA_SCALE (1< ++ * ++ * 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 ++ */ ++ ++/** ++ * @file ++ * common internal and external API header ++ */ ++ ++#ifndef AVUTIL_COMMON_H ++#define AVUTIL_COMMON_H ++ ++#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C) ++#error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS ++#endif ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "attributes.h" ++#include "error.h" ++#include "macros.h" ++#include "version.h" ++ ++#ifdef HAVE_AV_CONFIG_H ++# include "config.h" ++# include "intmath.h" ++# include "internal.h" ++#else ++# include "mem.h" ++#endif /* HAVE_AV_CONFIG_H */ ++ ++//rounded division & shift ++#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) ++/* assume b>0 */ ++#define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) ++/* Fast a/(1<=0 and b>=0 */ ++#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \ ++ : ((a) + (1<<(b)) - 1) >> (b)) ++/* Backwards compat. */ ++#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT ++ ++#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b)) ++#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b)) ++ ++/** ++ * Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they ++ * are not representable as absolute values of their type. This is the same ++ * as with *abs() ++ * @see FFNABS() ++ */ ++#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) ++#define FFSIGN(a) ((a) > 0 ? 1 : -1) ++ ++/** ++ * Negative Absolute value. ++ * this works for all integers of all types. ++ * As with many macros, this evaluates its argument twice, it thus must not have ++ * a sideeffect, that is FFNABS(x++) has undefined behavior. ++ */ ++#define FFNABS(a) ((a) <= 0 ? (a) : (-(a))) ++ ++/** ++ * Unsigned Absolute value. ++ * This takes the absolute value of a signed int and returns it as a unsigned. ++ * This also works with INT_MIN which would otherwise not be representable ++ * As with many macros, this evaluates its argument twice. ++ */ ++#define FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a)) ++#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a)) ++ ++/* misc math functions */ ++ ++#ifndef av_ceil_log2 ++# define av_ceil_log2 av_ceil_log2_c ++#endif ++#ifndef av_clip ++# define av_clip av_clip_c ++#endif ++#ifndef av_clip64 ++# define av_clip64 av_clip64_c ++#endif ++#ifndef av_clip_uint8 ++# define av_clip_uint8 av_clip_uint8_c ++#endif ++#ifndef av_clip_int8 ++# define av_clip_int8 av_clip_int8_c ++#endif ++#ifndef av_clip_uint16 ++# define av_clip_uint16 av_clip_uint16_c ++#endif ++#ifndef av_clip_int16 ++# define av_clip_int16 av_clip_int16_c ++#endif ++#ifndef av_clipl_int32 ++# define av_clipl_int32 av_clipl_int32_c ++#endif ++#ifndef av_clip_intp2 ++# define av_clip_intp2 av_clip_intp2_c ++#endif ++#ifndef av_clip_uintp2 ++# define av_clip_uintp2 av_clip_uintp2_c ++#endif ++#ifndef av_sat_add32 ++# define av_sat_add32 av_sat_add32_c ++#endif ++#ifndef av_sat_dadd32 ++# define av_sat_dadd32 av_sat_dadd32_c ++#endif ++#ifndef av_sat_sub32 ++# define av_sat_sub32 av_sat_sub32_c ++#endif ++#ifndef av_sat_dsub32 ++# define av_sat_dsub32 av_sat_dsub32_c ++#endif ++#ifndef av_sat_add64 ++# define av_sat_add64 av_sat_add64_c ++#endif ++#ifndef av_sat_sub64 ++# define av_sat_sub64 av_sat_sub64_c ++#endif ++#ifndef av_clipf ++# define av_clipf av_clipf_c ++#endif ++#ifndef av_clipd ++# define av_clipd av_clipd_c ++#endif ++#ifndef av_zero_extend ++# define av_zero_extend av_zero_extend_c ++#endif ++#ifndef av_popcount ++# define av_popcount av_popcount_c ++#endif ++#ifndef av_popcount64 ++# define av_popcount64 av_popcount64_c ++#endif ++#ifndef av_parity ++# define av_parity av_parity_c ++#endif ++ ++#ifndef av_log2 ++av_const int av_log2(unsigned v); ++#endif ++ ++#ifndef av_log2_16bit ++av_const int av_log2_16bit(unsigned v); ++#endif ++ ++/** ++ * Clip a signed integer value into the amin-amax range. ++ * @param a value to clip ++ * @param amin minimum value of the clip range ++ * @param amax maximum value of the clip range ++ * @return clipped value ++ */ ++static av_always_inline av_const int av_clip_c(int a, int amin, int amax) ++{ ++#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 ++ if (amin > amax) abort(); ++#endif ++ if (a < amin) return amin; ++ else if (a > amax) return amax; ++ else return a; ++} ++ ++/** ++ * Clip a signed 64bit integer value into the amin-amax range. ++ * @param a value to clip ++ * @param amin minimum value of the clip range ++ * @param amax maximum value of the clip range ++ * @return clipped value ++ */ ++static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax) ++{ ++#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 ++ if (amin > amax) abort(); ++#endif ++ if (a < amin) return amin; ++ else if (a > amax) return amax; ++ else return a; ++} ++ ++/** ++ * Clip a signed integer value into the 0-255 range. ++ * @param a value to clip ++ * @return clipped value ++ */ ++static av_always_inline av_const uint8_t av_clip_uint8_c(int a) ++{ ++ if (a&(~0xFF)) return (~a)>>31; ++ else return a; ++} ++ ++/** ++ * Clip a signed integer value into the -128,127 range. ++ * @param a value to clip ++ * @return clipped value ++ */ ++static av_always_inline av_const int8_t av_clip_int8_c(int a) ++{ ++ if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F; ++ else return a; ++} ++ ++/** ++ * Clip a signed integer value into the 0-65535 range. ++ * @param a value to clip ++ * @return clipped value ++ */ ++static av_always_inline av_const uint16_t av_clip_uint16_c(int a) ++{ ++ if (a&(~0xFFFF)) return (~a)>>31; ++ else return a; ++} ++ ++/** ++ * Clip a signed integer value into the -32768,32767 range. ++ * @param a value to clip ++ * @return clipped value ++ */ ++static av_always_inline av_const int16_t av_clip_int16_c(int a) ++{ ++ if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF; ++ else return a; ++} ++ ++/** ++ * Clip a signed 64-bit integer value into the -2147483648,2147483647 range. ++ * @param a value to clip ++ * @return clipped value ++ */ ++static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a) ++{ ++ if ((a+UINT64_C(0x80000000)) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF); ++ else return (int32_t)a; ++} ++ ++/** ++ * Clip a signed integer into the -(2^p),(2^p-1) range. ++ * @param a value to clip ++ * @param p bit position to clip at ++ * @return clipped value ++ */ ++static av_always_inline av_const int av_clip_intp2_c(int a, int p) ++{ ++ if (((unsigned)a + (1U << p)) & ~((2U << p) - 1)) ++ return (a >> 31) ^ ((1 << p) - 1); ++ else ++ return a; ++} ++ ++/** ++ * Clip a signed integer to an unsigned power of two range. ++ * @param a value to clip ++ * @param p bit position to clip at ++ * @return clipped value ++ */ ++static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p) ++{ ++ if (a & ~((1U<> 31 & ((1U<= 2 ++ if (p > 31) abort(); ++#endif ++ return a & ((1U << p) - 1); ++} ++ ++/** ++ * Add two signed 32-bit values with saturation. ++ * ++ * @param a one value ++ * @param b another value ++ * @return sum with signed saturation ++ */ ++static av_always_inline int av_sat_add32_c(int a, int b) ++{ ++ return av_clipl_int32((int64_t)a + b); ++} ++ ++/** ++ * Add a doubled value to another value with saturation at both stages. ++ * ++ * @param a first value ++ * @param b value doubled and added to a ++ * @return sum sat(a + sat(2*b)) with signed saturation ++ */ ++static av_always_inline int av_sat_dadd32_c(int a, int b) ++{ ++ return av_sat_add32(a, av_sat_add32(b, b)); ++} ++ ++/** ++ * Subtract two signed 32-bit values with saturation. ++ * ++ * @param a one value ++ * @param b another value ++ * @return difference with signed saturation ++ */ ++static av_always_inline int av_sat_sub32_c(int a, int b) ++{ ++ return av_clipl_int32((int64_t)a - b); ++} ++ ++/** ++ * Subtract a doubled value from another value with saturation at both stages. ++ * ++ * @param a first value ++ * @param b value doubled and subtracted from a ++ * @return difference sat(a - sat(2*b)) with signed saturation ++ */ ++static av_always_inline int av_sat_dsub32_c(int a, int b) ++{ ++ return av_sat_sub32(a, av_sat_add32(b, b)); ++} ++ ++/** ++ * Add two signed 64-bit values with saturation. ++ * ++ * @param a one value ++ * @param b another value ++ * @return sum with signed saturation ++ */ ++static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) { ++#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_add_overflow) ++ int64_t tmp; ++ return !__builtin_add_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN); ++#else ++ int64_t s = a+(uint64_t)b; ++ if ((int64_t)(a^b | ~s^b) >= 0) ++ return INT64_MAX ^ (b >> 63); ++ return s; ++#endif ++} ++ ++/** ++ * Subtract two signed 64-bit values with saturation. ++ * ++ * @param a one value ++ * @param b another value ++ * @return difference with signed saturation ++ */ ++static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) { ++#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_sub_overflow) ++ int64_t tmp; ++ return !__builtin_sub_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN); ++#else ++ if (b <= 0 && a >= INT64_MAX + b) ++ return INT64_MAX; ++ if (b >= 0 && a <= INT64_MIN + b) ++ return INT64_MIN; ++ return a - b; ++#endif ++} ++ ++/** ++ * Clip a float value into the amin-amax range. ++ * If a is nan or -inf amin will be returned. ++ * If a is +inf amax will be returned. ++ * @param a value to clip ++ * @param amin minimum value of the clip range ++ * @param amax maximum value of the clip range ++ * @return clipped value ++ */ ++static av_always_inline av_const float av_clipf_c(float a, float amin, float amax) ++{ ++#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 ++ if (amin > amax) abort(); ++#endif ++ return FFMIN(FFMAX(a, amin), amax); ++} ++ ++/** ++ * Clip a double value into the amin-amax range. ++ * If a is nan or -inf amin will be returned. ++ * If a is +inf amax will be returned. ++ * @param a value to clip ++ * @param amin minimum value of the clip range ++ * @param amax maximum value of the clip range ++ * @return clipped value ++ */ ++static av_always_inline av_const double av_clipd_c(double a, double amin, double amax) ++{ ++#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 ++ if (amin > amax) abort(); ++#endif ++ return FFMIN(FFMAX(a, amin), amax); ++} ++ ++/** Compute ceil(log2(x)). ++ * @param x value used to compute ceil(log2(x)) ++ * @return computed ceiling of log2(x) ++ */ ++static av_always_inline av_const int av_ceil_log2_c(int x) ++{ ++ return av_log2((x - 1U) << 1); ++} ++ ++/** ++ * Count number of bits set to one in x ++ * @param x value to count bits of ++ * @return the number of bits set to one in x ++ */ ++static av_always_inline av_const int av_popcount_c(uint32_t x) ++{ ++ x -= (x >> 1) & 0x55555555; ++ x = (x & 0x33333333) + ((x >> 2) & 0x33333333); ++ x = (x + (x >> 4)) & 0x0F0F0F0F; ++ x += x >> 8; ++ return (x + (x >> 16)) & 0x3F; ++} ++ ++/** ++ * Count number of bits set to one in x ++ * @param x value to count bits of ++ * @return the number of bits set to one in x ++ */ ++static av_always_inline av_const int av_popcount64_c(uint64_t x) ++{ ++ return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32)); ++} ++ ++static av_always_inline av_const int av_parity_c(uint32_t v) ++{ ++ return av_popcount(v) & 1; ++} ++ ++/** ++ * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. ++ * ++ * @param val Output value, must be an lvalue of type uint32_t. ++ * @param GET_BYTE Expression reading one byte from the input. ++ * Evaluated up to 7 times (4 for the currently ++ * assigned Unicode range). With a memory buffer ++ * input, this could be *ptr++, or if you want to make sure ++ * that *ptr stops at the end of a NULL terminated string then ++ * *ptr ? *ptr++ : 0 ++ * @param ERROR Expression to be evaluated on invalid input, ++ * typically a goto statement. ++ * ++ * @warning ERROR should not contain a loop control statement which ++ * could interact with the internal while loop, and should force an ++ * exit from the macro code (e.g. through a goto or a return) in order ++ * to prevent undefined results. ++ */ ++#define GET_UTF8(val, GET_BYTE, ERROR)\ ++ val= (uint8_t)(GET_BYTE);\ ++ {\ ++ uint32_t top = (val & 128) >> 1;\ ++ if ((val & 0xc0) == 0x80 || val >= 0xFE)\ ++ {ERROR}\ ++ while (val & top) {\ ++ unsigned int tmp = (uint8_t)(GET_BYTE) - 128;\ ++ if(tmp>>6)\ ++ {ERROR}\ ++ val= (val<<6) + tmp;\ ++ top <<= 5;\ ++ }\ ++ val &= (top << 1) - 1;\ ++ } ++ ++/** ++ * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form. ++ * ++ * @param val Output value, must be an lvalue of type uint32_t. ++ * @param GET_16BIT Expression returning two bytes of UTF-16 data converted ++ * to native byte order. Evaluated one or two times. ++ * @param ERROR Expression to be evaluated on invalid input, ++ * typically a goto statement. ++ */ ++#define GET_UTF16(val, GET_16BIT, ERROR)\ ++ val = (uint16_t)(GET_16BIT);\ ++ {\ ++ unsigned int hi = val - 0xD800;\ ++ if (hi < 0x800) {\ ++ val = (uint16_t)(GET_16BIT) - 0xDC00;\ ++ if (val > 0x3FFU || hi > 0x3FFU)\ ++ {ERROR}\ ++ val += (hi<<10) + 0x10000;\ ++ }\ ++ }\ ++ ++/** ++ * @def PUT_UTF8(val, tmp, PUT_BYTE) ++ * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). ++ * @param val is an input-only argument and should be of type uint32_t. It holds ++ * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If ++ * val is given as a function it is executed only once. ++ * @param tmp is a temporary variable and should be of type uint8_t. It ++ * represents an intermediate value during conversion that is to be ++ * output by PUT_BYTE. ++ * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. ++ * It could be a function or a statement, and uses tmp as the input byte. ++ * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be ++ * executed up to 4 times for values in the valid UTF-8 range and up to ++ * 7 times in the general case, depending on the length of the converted ++ * Unicode character. ++ */ ++#define PUT_UTF8(val, tmp, PUT_BYTE)\ ++ {\ ++ int bytes, shift;\ ++ uint32_t in = val;\ ++ if (in < 0x80) {\ ++ tmp = in;\ ++ PUT_BYTE\ ++ } else {\ ++ bytes = (av_log2(in) + 4) / 5;\ ++ shift = (bytes - 1) * 6;\ ++ tmp = (256 - (256 >> bytes)) | (in >> shift);\ ++ PUT_BYTE\ ++ while (shift >= 6) {\ ++ shift -= 6;\ ++ tmp = 0x80 | ((in >> shift) & 0x3f);\ ++ PUT_BYTE\ ++ }\ ++ }\ ++ } ++ ++/** ++ * @def PUT_UTF16(val, tmp, PUT_16BIT) ++ * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes). ++ * @param val is an input-only argument and should be of type uint32_t. It holds ++ * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If ++ * val is given as a function it is executed only once. ++ * @param tmp is a temporary variable and should be of type uint16_t. It ++ * represents an intermediate value during conversion that is to be ++ * output by PUT_16BIT. ++ * @param PUT_16BIT writes the converted UTF-16 data to any proper destination ++ * in desired endianness. It could be a function or a statement, and uses tmp ++ * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;" ++ * PUT_BYTE will be executed 1 or 2 times depending on input character. ++ */ ++#define PUT_UTF16(val, tmp, PUT_16BIT)\ ++ {\ ++ uint32_t in = val;\ ++ if (in < 0x10000) {\ ++ tmp = in;\ ++ PUT_16BIT\ ++ } else {\ ++ tmp = 0xD800 | ((in - 0x10000) >> 10);\ ++ PUT_16BIT\ ++ tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\ ++ PUT_16BIT\ ++ }\ ++ }\ ++ ++#endif /* AVUTIL_COMMON_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/cpu.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/cpu.h +new file mode 100644 +index 000000000000..c41686344f00 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/cpu.h +@@ -0,0 +1,152 @@ ++/* ++ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_CPU_H ++#define AVUTIL_CPU_H ++ ++#include ++#include "version.h" ++ ++#if FF_API_CPU_FLAG_FORCE ++#define AV_CPU_FLAG_FORCE 0x80000000 /* @deprecated, should not be used */ ++#endif ++ ++ /* lower 16 bits - CPU features */ ++#define AV_CPU_FLAG_MMX 0x0001 ///< standard MMX ++#define AV_CPU_FLAG_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext ++#define AV_CPU_FLAG_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext ++#define AV_CPU_FLAG_3DNOW 0x0004 ///< AMD 3DNOW ++#define AV_CPU_FLAG_SSE 0x0008 ///< SSE functions ++#define AV_CPU_FLAG_SSE2 0x0010 ///< PIV SSE2 functions ++#define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster ++ ///< than regular MMX/SSE (e.g. Core1) ++#define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt ++#define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions ++#define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster ++ ///< than regular MMX/SSE (e.g. Core1) ++#define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions ++#define AV_CPU_FLAG_SSSE3SLOW 0x4000000 ///< SSSE3 supported, but usually not faster ++#define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower ++#define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions ++#define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions ++#define AV_CPU_FLAG_AESNI 0x80000 ///< Advanced Encryption Standard functions ++#define AV_CPU_FLAG_CLMUL 0x400000 ///< Carry-less Multiplication instruction ++#define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used ++#define AV_CPU_FLAG_AVXSLOW 0x8000000 ///< AVX supported, but slow when using YMM registers (e.g. Bulldozer) ++#define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions ++#define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions ++#define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction ++#define AV_CPU_FLAG_AVX2 0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used ++#define AV_CPU_FLAG_FMA3 0x10000 ///< Haswell FMA3 functions ++#define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1 ++#define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2 ++#define AV_CPU_FLAG_AVX512 0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used ++#define AV_CPU_FLAG_AVX512ICL 0x200000 ///< F/CD/BW/DQ/VL/VNNI/IFMA/VBMI/VBMI2/VPOPCNTDQ/BITALG/GFNI/VAES/VPCLMULQDQ ++#define AV_CPU_FLAG_SLOW_GATHER 0x2000000 ///< CPU has slow gathers. ++ ++#define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard ++#define AV_CPU_FLAG_VSX 0x0002 ///< ISA 2.06 ++#define AV_CPU_FLAG_POWER8 0x0004 ///< ISA 2.07 ++ ++#define AV_CPU_FLAG_ARMV5TE (1 << 0) ++#define AV_CPU_FLAG_ARMV6 (1 << 1) ++#define AV_CPU_FLAG_ARMV6T2 (1 << 2) ++#define AV_CPU_FLAG_VFP (1 << 3) ++#define AV_CPU_FLAG_VFPV3 (1 << 4) ++#define AV_CPU_FLAG_NEON (1 << 5) ++#define AV_CPU_FLAG_ARMV8 (1 << 6) ++#define AV_CPU_FLAG_VFP_VM (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations ++#define AV_CPU_FLAG_DOTPROD (1 << 8) ++#define AV_CPU_FLAG_I8MM (1 << 9) ++#define AV_CPU_FLAG_SVE (1 <<10) ++#define AV_CPU_FLAG_SVE2 (1 <<11) ++#define AV_CPU_FLAG_SME (1 <<12) ++#define AV_CPU_FLAG_ARM_CRC (1 <<13) ++#define AV_CPU_FLAG_SME2 (1 <<14) ++#define AV_CPU_FLAG_SME_I16I64 (1 <<15) ++#define AV_CPU_FLAG_SETEND (1 <<16) ++#define AV_CPU_FLAG_PMULL (1 <<17) ++#define AV_CPU_FLAG_EOR3 (1 <<18) ++ ++#define AV_CPU_FLAG_MMI (1 << 0) ++#define AV_CPU_FLAG_MSA (1 << 1) ++ ++//Loongarch SIMD extension. ++#define AV_CPU_FLAG_LSX (1 << 0) ++#define AV_CPU_FLAG_LASX (1 << 1) ++ ++// RISC-V extensions ++#define AV_CPU_FLAG_RVI (1 << 0) ///< I (full GPR bank) ++#define AV_CPU_FLAG_RVV_I32 (1 << 3) ///< Vectors of 8/16/32-bit int's */ ++#define AV_CPU_FLAG_RVV_F32 (1 << 4) ///< Vectors of float's */ ++#define AV_CPU_FLAG_RVV_I64 (1 << 5) ///< Vectors of 64-bit int's */ ++#define AV_CPU_FLAG_RVV_F64 (1 << 6) ///< Vectors of double's ++#define AV_CPU_FLAG_RVB_BASIC (1 << 7) ///< Basic bit-manipulations ++#define AV_CPU_FLAG_RV_ZVBB (1 << 9) ///< Vector basic bit-manipulations ++#define AV_CPU_FLAG_RV_MISALIGNED (1 <<10) ///< Fast misaligned accesses ++#define AV_CPU_FLAG_RVB (1 <<11) ///< B (bit manipulations) ++ ++// WASM extensions ++#define AV_CPU_FLAG_SIMD128 (1 << 0) ++ ++/** ++ * Return the flags which specify extensions supported by the CPU. ++ * The returned value is affected by av_force_cpu_flags() if that was used ++ * before. So av_get_cpu_flags() can easily be used in an application to ++ * detect the enabled cpu flags. ++ */ ++int av_get_cpu_flags(void); ++ ++/** ++ * Disables cpu detection and forces the specified flags. ++ * -1 is a special case that disables forcing of specific flags. ++ */ ++void av_force_cpu_flags(int flags); ++ ++/** ++ * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. ++ * ++ * @return negative on error. ++ */ ++int av_parse_cpu_caps(unsigned *flags, const char *s); ++ ++/** ++ * @return the number of logical CPU cores present. ++ */ ++int av_cpu_count(void); ++ ++/** ++ * Overrides cpu count detection and forces the specified count. ++ * Count < 1 disables forcing of specific count. ++ */ ++void av_cpu_force_count(int count); ++ ++/** ++ * Get the maximum data alignment that may be required by FFmpeg. ++ * ++ * Note that this is affected by the build configuration and the CPU flags mask, ++ * so e.g. if the CPU supports AVX, but libavutil has been built with ++ * --disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through ++ * av_set_cpu_flags_mask(), then this function will behave as if AVX is not ++ * present. ++ */ ++size_t av_cpu_max_align(void); ++ ++#endif /* AVUTIL_CPU_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/dict.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/dict.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/dict.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/dict.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/error.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/error.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/error.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/error.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/frame.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/frame.h +new file mode 100644 +index 000000000000..e8cc765e5dbe +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/frame.h +@@ -0,0 +1,1221 @@ ++/* ++ * 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 ++ */ ++ ++/** ++ * @file ++ * @ingroup lavu_frame ++ * reference-counted frame API ++ */ ++ ++#ifndef AVUTIL_FRAME_H ++#define AVUTIL_FRAME_H ++ ++#include ++#include ++ ++#include "avutil.h" ++#include "buffer.h" ++#include "channel_layout.h" ++#include "dict.h" ++#include "rational.h" ++#include "samplefmt.h" ++#include "pixfmt.h" ++#include "version.h" ++ ++ ++/** ++ * @defgroup lavu_frame AVFrame ++ * @ingroup lavu_data ++ * ++ * @{ ++ * AVFrame is an abstraction for reference-counted raw multimedia data. ++ */ ++ ++enum AVFrameSideDataType { ++ /** ++ * The data is the AVPanScan struct defined in libavcodec. ++ */ ++ AV_FRAME_DATA_PANSCAN, ++ /** ++ * ATSC A53 Part 4 Closed Captions. ++ * A53 CC bitstream is stored as uint8_t in AVFrameSideData.data. ++ * The number of bytes of CC data is AVFrameSideData.size. ++ */ ++ AV_FRAME_DATA_A53_CC, ++ /** ++ * Stereoscopic 3d metadata. ++ * The data is the AVStereo3D struct defined in libavutil/stereo3d.h. ++ */ ++ AV_FRAME_DATA_STEREO3D, ++ /** ++ * The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h. ++ */ ++ AV_FRAME_DATA_MATRIXENCODING, ++ /** ++ * Metadata relevant to a downmix procedure. ++ * The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h. ++ */ ++ AV_FRAME_DATA_DOWNMIX_INFO, ++ /** ++ * ReplayGain information in the form of the AVReplayGain struct. ++ */ ++ AV_FRAME_DATA_REPLAYGAIN, ++ /** ++ * This side data contains a 3x3 transformation matrix describing an affine ++ * transformation that needs to be applied to the frame for correct ++ * presentation. ++ * ++ * See libavutil/display.h for a detailed description of the data. ++ */ ++ AV_FRAME_DATA_DISPLAYMATRIX, ++ /** ++ * Active Format Description data consisting of a single byte as specified ++ * in ETSI TS 101 154 using AVActiveFormatDescription enum. ++ */ ++ AV_FRAME_DATA_AFD, ++ /** ++ * Motion vectors exported by some codecs (on demand through the export_mvs ++ * flag set in the libavcodec AVCodecContext flags2 option). ++ * The data is the AVMotionVector struct defined in ++ * libavutil/motion_vector.h. ++ */ ++ AV_FRAME_DATA_MOTION_VECTORS, ++ /** ++ * Recommends skipping the specified number of samples. This is exported ++ * only if the "skip_manual" AVOption is set in libavcodec. ++ * This has the same format as AV_PKT_DATA_SKIP_SAMPLES. ++ * @code ++ * u32le number of samples to skip from start of this packet ++ * u32le number of samples to skip from end of this packet ++ * u8 reason for start skip ++ * u8 reason for end skip (0=padding silence, 1=convergence) ++ * @endcode ++ */ ++ AV_FRAME_DATA_SKIP_SAMPLES, ++ /** ++ * This side data must be associated with an audio frame and corresponds to ++ * enum AVAudioServiceType defined in avcodec.h. ++ */ ++ AV_FRAME_DATA_AUDIO_SERVICE_TYPE, ++ /** ++ * Mastering display metadata associated with a video frame. The payload is ++ * an AVMasteringDisplayMetadata type and contains information about the ++ * mastering display color volume. ++ */ ++ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA, ++ /** ++ * The GOP timecode in 25 bit timecode format. Data format is 64-bit integer. ++ * This is set on the first frame of a GOP that has a temporal reference of 0. ++ */ ++ AV_FRAME_DATA_GOP_TIMECODE, ++ ++ /** ++ * The data represents the AVSphericalMapping structure defined in ++ * libavutil/spherical.h. ++ */ ++ AV_FRAME_DATA_SPHERICAL, ++ ++ /** ++ * Content light level (based on CTA-861.3). This payload contains data in ++ * the form of the AVContentLightMetadata struct. ++ */ ++ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL, ++ ++ /** ++ * The data contains an ICC profile as an opaque octet buffer following the ++ * format described by ISO 15076-1 with an optional name defined in the ++ * metadata key entry "name". ++ */ ++ AV_FRAME_DATA_ICC_PROFILE, ++ ++ /** ++ * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t ++ * where the first uint32_t describes how many (1-3) of the other timecodes are used. ++ * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum() ++ * function in libavutil/timecode.h. ++ */ ++ AV_FRAME_DATA_S12M_TIMECODE, ++ ++ /** ++ * HDR dynamic metadata associated with a video frame. The payload is ++ * an AVDynamicHDRPlus type and contains information for color ++ * volume transform - application 4 of SMPTE 2094-40:2016 standard. ++ */ ++ AV_FRAME_DATA_DYNAMIC_HDR_PLUS, ++ ++ /** ++ * Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of ++ * array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size. ++ */ ++ AV_FRAME_DATA_REGIONS_OF_INTEREST, ++ ++ /** ++ * Encoding parameters for a video frame, as described by AVVideoEncParams. ++ */ ++ AV_FRAME_DATA_VIDEO_ENC_PARAMS, ++ ++ /** ++ * User data unregistered metadata associated with a video frame. ++ * This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose ++ * The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of ++ * uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte. ++ */ ++ AV_FRAME_DATA_SEI_UNREGISTERED, ++ ++ /** ++ * Film grain parameters for a frame, described by AVFilmGrainParams. ++ * Must be present for every frame which should have film grain applied. ++ * ++ * May be present multiple times, for example when there are multiple ++ * alternative parameter sets for different video signal characteristics. ++ * The user should select the most appropriate set for the application. ++ */ ++ AV_FRAME_DATA_FILM_GRAIN_PARAMS, ++ ++ /** ++ * Bounding boxes for object detection and classification, ++ * as described by AVDetectionBBoxHeader. ++ */ ++ AV_FRAME_DATA_DETECTION_BBOXES, ++ ++ /** ++ * Dolby Vision RPU raw data, suitable for passing to x265 ++ * or other libraries. Array of uint8_t, with NAL emulation ++ * bytes intact. ++ */ ++ AV_FRAME_DATA_DOVI_RPU_BUFFER, ++ ++ /** ++ * Parsed Dolby Vision metadata, suitable for passing to a software ++ * implementation. The payload is the AVDOVIMetadata struct defined in ++ * libavutil/dovi_meta.h. ++ */ ++ AV_FRAME_DATA_DOVI_METADATA, ++ ++ /** ++ * HDR Vivid dynamic metadata associated with a video frame. The payload is ++ * an AVDynamicHDRVivid type and contains information for color ++ * volume transform - CUVA 005.1-2021. ++ */ ++ AV_FRAME_DATA_DYNAMIC_HDR_VIVID, ++ ++ /** ++ * Ambient viewing environment metadata, as defined by H.274. ++ */ ++ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT, ++ ++ /** ++ * Provide encoder-specific hinting information about changed/unchanged ++ * portions of a frame. It can be used to pass information about which ++ * macroblocks can be skipped because they didn't change from the ++ * corresponding ones in the previous frame. This could be useful for ++ * applications which know this information in advance to speed up ++ * encoding. ++ */ ++ AV_FRAME_DATA_VIDEO_HINT, ++ ++ /** ++ * Raw LCEVC payload data, as a uint8_t array, with NAL emulation ++ * bytes intact. ++ */ ++ AV_FRAME_DATA_LCEVC, ++ ++ /** ++ * This side data must be associated with a video frame. ++ * The presence of this side data indicates that the video stream is ++ * composed of multiple views (e.g. stereoscopic 3D content, ++ * cf. H.264 Annex H or H.265 Annex G). ++ * The data is an int storing the view ID. ++ */ ++ AV_FRAME_DATA_VIEW_ID, ++ ++ /** ++ * This side data contains information about the reference display width(s) ++ * and reference viewing distance(s) as well as information about the ++ * corresponding reference stereo pair(s), i.e., the pair(s) of views to be ++ * displayed for the viewer's left and right eyes on the reference display ++ * at the reference viewing distance. ++ * The payload is the AV3DReferenceDisplaysInfo struct defined in ++ * libavutil/tdrdi.h. ++ */ ++ AV_FRAME_DATA_3D_REFERENCE_DISPLAYS, ++ ++ /** ++ * Exchangeable image file format metadata. The payload is a buffer containing ++ * EXIF metadata, starting with either 49 49 2a 00, or 4d 4d 00 2a. These four ++ * bytes signify the endianness, and occur as the first part of the TIFF header. ++ */ ++ AV_FRAME_DATA_EXIF, ++ ++ /** ++ * HDR dynamic metadata associated with a video frame. The payload is ++ * an AVDynamicHDRSmpte2094App5 type and contains information for color ++ * volume transform as specified in the SMPTE 2094-50 standard. ++ */ ++ AV_FRAME_DATA_DYNAMIC_HDR_SMPTE_2094_APP5, ++ ++ /** ++ * IAMF Mix Gain Parameter Data associated with the audio frame. This metadata ++ * is in the form of the AVIAMFParamDefinition struct and contains information ++ * defined in sections 3.6.1 and 3.8.1 of the Immersive Audio Model and ++ * Formats standard. ++ */ ++ AV_FRAME_DATA_IAMF_MIX_GAIN_PARAM, ++ ++ /** ++ * IAMF Demixing Info Parameter Data associated with the audio frame. This ++ * metadata is in the form of the AVIAMFParamDefinition struct and contains ++ * information defined in sections 3.6.1 and 3.8.2 of the Immersive Audio Model ++ * and Formats standard. ++ */ ++ AV_FRAME_DATA_IAMF_DEMIXING_INFO_PARAM, ++ ++ /** ++ * IAMF Recon Gain Info Parameter Data associated with the audio frame. This ++ * metadata is in the form of the AVIAMFParamDefinition struct and contains ++ * information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model ++ * and Formats standard. ++ */ ++ AV_FRAME_DATA_IAMF_RECON_GAIN_INFO_PARAM, ++ ++ /** ++ * Color information from a RAW camera codecs, needed to correctly process ++ * the video data. The payload is an AVRawColorParams struct defined in ++ * libavutil/raw_color_params.h. ++ */ ++ AV_FRAME_DATA_RAW_COLOR_PARAMS, ++ ++ /** ++ * Metadata relevant to a downmix procedure in the form of a remixig matrix. ++ * The data is the AVDownmixMatrix struct defined in libavutil/downmix_info.h. ++ */ ++ AV_FRAME_DATA_DOWNMIX_MATRIX, ++}; ++ ++enum AVActiveFormatDescription { ++ AV_AFD_SAME = 8, ++ AV_AFD_4_3 = 9, ++ AV_AFD_16_9 = 10, ++ AV_AFD_14_9 = 11, ++ AV_AFD_4_3_SP_14_9 = 13, ++ AV_AFD_16_9_SP_14_9 = 14, ++ AV_AFD_SP_4_3 = 15, ++}; ++ ++ ++/** ++ * Structure to hold side data for an AVFrame. ++ * ++ * sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added ++ * to the end with a minor bump. ++ */ ++typedef struct AVFrameSideData { ++ enum AVFrameSideDataType type; ++ uint8_t *data; ++ size_t size; ++ AVDictionary *metadata; ++ AVBufferRef *buf; ++} AVFrameSideData; ++ ++enum AVSideDataProps { ++ /** ++ * The side data type can be used in stream-global structures. ++ * Side data types without this property are only meaningful on per-frame ++ * basis. ++ */ ++ AV_SIDE_DATA_PROP_GLOBAL = (1 << 0), ++ ++ /** ++ * Multiple instances of this side data type can be meaningfully present in ++ * a single side data array. ++ */ ++ AV_SIDE_DATA_PROP_MULTI = (1 << 1), ++ ++ /** ++ * Side data depends on the video dimensions. Side data with this property ++ * loses its meaning when rescaling or cropping the image, unless ++ * either recomputed or adjusted to the new resolution. ++ */ ++ AV_SIDE_DATA_PROP_SIZE_DEPENDENT = (1 << 2), ++ ++ /** ++ * Side data depends on the video color space. Side data with this property ++ * loses its meaning when changing the video color encoding, e.g. by ++ * adapting to a different set of primaries or transfer characteristics. ++ */ ++ AV_SIDE_DATA_PROP_COLOR_DEPENDENT = (1 << 3), ++ ++ /** ++ * Side data depends on the channel layout. Side data with this property ++ * loses its meaning when downmixing or upmixing, unless either recomputed ++ * or adjusted to the new layout. ++ */ ++ AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT = (1 << 4), ++}; ++ ++/** ++ * This struct describes the properties of a side data type. Its instance ++ * corresponding to a given type can be obtained from av_frame_side_data_desc(). ++ */ ++typedef struct AVSideDataDescriptor { ++ /** ++ * Human-readable side data description. ++ */ ++ const char *name; ++ ++ /** ++ * Side data property flags, a combination of AVSideDataProps values. ++ */ ++ unsigned props; ++} AVSideDataDescriptor; ++ ++/** ++ * Structure describing a single Region Of Interest. ++ * ++ * When multiple regions are defined in a single side-data block, they ++ * should be ordered from most to least important - some encoders are only ++ * capable of supporting a limited number of distinct regions, so will have ++ * to truncate the list. ++ * ++ * When overlapping regions are defined, the first region containing a given ++ * area of the frame applies. ++ */ ++typedef struct AVRegionOfInterest { ++ /** ++ * Must be set to the size of this data structure (that is, ++ * sizeof(AVRegionOfInterest)). ++ */ ++ uint32_t self_size; ++ /** ++ * Distance in pixels from the top edge of the frame to the top and ++ * bottom edges and from the left edge of the frame to the left and ++ * right edges of the rectangle defining this region of interest. ++ * ++ * The constraints on a region are encoder dependent, so the region ++ * actually affected may be slightly larger for alignment or other ++ * reasons. ++ */ ++ int top; ++ int bottom; ++ int left; ++ int right; ++ /** ++ * Quantisation offset. ++ * ++ * Must be in the range -1 to +1. A value of zero indicates no quality ++ * change. A negative value asks for better quality (less quantisation), ++ * while a positive value asks for worse quality (greater quantisation). ++ * ++ * The range is calibrated so that the extreme values indicate the ++ * largest possible offset - if the rest of the frame is encoded with the ++ * worst possible quality, an offset of -1 indicates that this region ++ * should be encoded with the best possible quality anyway. Intermediate ++ * values are then interpolated in some codec-dependent way. ++ * ++ * For example, in 10-bit H.264 the quantisation parameter varies between ++ * -12 and 51. A typical qoffset value of -1/10 therefore indicates that ++ * this region should be encoded with a QP around one-tenth of the full ++ * range better than the rest of the frame. So, if most of the frame ++ * were to be encoded with a QP of around 30, this region would get a QP ++ * of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3). ++ * An extreme value of -1 would indicate that this region should be ++ * encoded with the best possible quality regardless of the treatment of ++ * the rest of the frame - that is, should be encoded at a QP of -12. ++ */ ++ AVRational qoffset; ++} AVRegionOfInterest; ++ ++/** ++ * This structure describes decoded (raw) audio or video data. ++ * ++ * AVFrame must be allocated using av_frame_alloc(). Note that this only ++ * allocates the AVFrame itself, the buffers for the data must be managed ++ * through other means (see below). ++ * AVFrame must be freed with av_frame_free(). ++ * ++ * AVFrame is typically allocated once and then reused multiple times to hold ++ * different data (e.g. a single AVFrame to hold frames received from a ++ * decoder). In such a case, av_frame_unref() will free any references held by ++ * the frame and reset it to its original clean state before it ++ * is reused again. ++ * ++ * The data described by an AVFrame is usually reference counted through the ++ * AVBuffer API. The underlying buffer references are stored in AVFrame.buf / ++ * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at ++ * least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case, ++ * every single data plane must be contained in one of the buffers in ++ * AVFrame.buf or AVFrame.extended_buf. ++ * There may be a single buffer for all the data, or one separate buffer for ++ * each plane, or anything in between. ++ * ++ * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added ++ * to the end with a minor bump. ++ * ++ * Fields can be accessed through AVOptions, the name string used, matches the ++ * C structure field name for fields accessible through AVOptions. ++ */ ++typedef struct AVFrame { ++#define AV_NUM_DATA_POINTERS 8 ++ /** ++ * pointer to the picture/channel planes. ++ * This might be different from the first allocated byte. For video, ++ * it could even point to the end of the image data. ++ * ++ * All pointers in data and extended_data must point into one of the ++ * AVBufferRef in buf or extended_buf. ++ * ++ * Some decoders access areas outside 0,0 - width,height, please ++ * see avcodec_align_dimensions2(). Some filters and swscale can read ++ * up to 16 bytes beyond the planes, if these filters are to be used, ++ * then 16 extra bytes must be allocated. ++ * ++ * NOTE: Pointers not needed by the format MUST be set to NULL. ++ * ++ * @attention In case of video, the data[] pointers can point to the ++ * end of image data in order to reverse line order, when used in ++ * combination with negative values in the linesize[] array. ++ */ ++ uint8_t *data[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * For video, a positive or negative value, which is typically indicating ++ * the size in bytes of each picture line, but it can also be: ++ * - the negative byte size of lines for vertical flipping ++ * (with data[n] pointing to the end of the data ++ * - a positive or negative multiple of the byte size as for accessing ++ * even and odd fields of a frame (possibly flipped) ++ * ++ * For audio, only linesize[0] may be set. For planar audio, each channel ++ * plane must be the same size. ++ * ++ * For video the linesizes should be multiples of the CPUs alignment ++ * preference, this is 16 or 32 for modern desktop CPUs. ++ * Some code requires such alignment other code can be slower without ++ * correct alignment, for yet other it makes no difference. ++ * ++ * @note The linesize may be larger than the size of usable data -- there ++ * may be extra padding present for performance reasons. ++ * ++ * @attention In case of video, line size values can be negative to achieve ++ * a vertically inverted iteration over image lines. ++ */ ++ int linesize[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * pointers to the data planes/channels. ++ * ++ * For video, this should simply point to data[]. ++ * ++ * For planar audio, each channel has a separate data pointer, and ++ * linesize[0] contains the size of each channel buffer. ++ * For packed audio, there is just one data pointer, and linesize[0] ++ * contains the total size of the buffer for all channels. ++ * ++ * Note: Both data and extended_data should always be set in a valid frame, ++ * but for planar audio with more channels that can fit in data, ++ * extended_data must be used in order to access all channels. ++ */ ++ uint8_t **extended_data; ++ ++ /** ++ * @name Video dimensions ++ * Video frames only. The coded dimensions (in pixels) of the video frame, ++ * i.e. the size of the rectangle that contains some well-defined values. ++ * ++ * @note The part of the frame intended for display/presentation is further ++ * restricted by the @ref cropping "Cropping rectangle". ++ * @{ ++ */ ++ int width, height; ++ /** ++ * @} ++ */ ++ ++ /** ++ * number of audio samples (per channel) described by this frame ++ */ ++ int nb_samples; ++ ++ /** ++ * format of the frame, -1 if unknown or unset ++ * Values correspond to enum AVPixelFormat for video frames, ++ * enum AVSampleFormat for audio) ++ */ ++ int format; ++ ++ /** ++ * Picture type of the frame. ++ */ ++ enum AVPictureType pict_type; ++ ++ /** ++ * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified. ++ */ ++ AVRational sample_aspect_ratio; ++ ++ /** ++ * Presentation timestamp in time_base units (time when frame should be shown to user). ++ */ ++ int64_t pts; ++ ++ /** ++ * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used) ++ * This is also the Presentation time of this AVFrame calculated from ++ * only AVPacket.dts values without pts values. ++ */ ++ int64_t pkt_dts; ++ ++ /** ++ * Time base for the timestamps in this frame. ++ * In the future, this field may be set on frames output by decoders or ++ * filters, but its value will be by default ignored on input to encoders ++ * or filters. ++ */ ++ AVRational time_base; ++ ++ /** ++ * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) ++ */ ++ int quality; ++ ++ /** ++ * Frame owner's private data. ++ * ++ * This field may be set by the code that allocates/owns the frame data. ++ * It is then not touched by any library functions, except: ++ * - it is copied to other references by av_frame_copy_props() (and hence by ++ * av_frame_ref()); ++ * - it is set to NULL when the frame is cleared by av_frame_unref() ++ * - on the caller's explicit request. E.g. libavcodec encoders/decoders ++ * will copy this field to/from @ref AVPacket "AVPackets" if the caller sets ++ * @ref AV_CODEC_FLAG_COPY_OPAQUE. ++ * ++ * @see opaque_ref the reference-counted analogue ++ */ ++ void *opaque; ++ ++ /** ++ * Number of fields in this frame which should be repeated, i.e. the total ++ * duration of this frame should be repeat_pict + 2 normal field durations. ++ * ++ * For interlaced frames this field may be set to 1, which signals that this ++ * frame should be presented as 3 fields: beginning with the first field (as ++ * determined by AV_FRAME_FLAG_TOP_FIELD_FIRST being set or not), followed ++ * by the second field, and then the first field again. ++ * ++ * For progressive frames this field may be set to a multiple of 2, which ++ * signals that this frame's duration should be (repeat_pict + 2) / 2 ++ * normal frame durations. ++ * ++ * @note This field is computed from MPEG2 repeat_first_field flag and its ++ * associated flags, H.264 pic_struct from picture timing SEI, and ++ * their analogues in other codecs. Typically it should only be used when ++ * higher-layer timing information is not available. ++ */ ++ int repeat_pict; ++ ++ /** ++ * Sample rate of the audio data. ++ */ ++ int sample_rate; ++ ++ /** ++ * AVBuffer references backing the data for this frame. All the pointers in ++ * data and extended_data must point inside one of the buffers in buf or ++ * extended_buf. This array must be filled contiguously -- if buf[i] is ++ * non-NULL then buf[j] must also be non-NULL for all j < i. ++ * ++ * There may be at most one AVBuffer per data plane, so for video this array ++ * always contains all the references. For planar audio with more than ++ * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in ++ * this array. Then the extra AVBufferRef pointers are stored in the ++ * extended_buf array. ++ */ ++ AVBufferRef *buf[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * For planar audio which requires more than AV_NUM_DATA_POINTERS ++ * AVBufferRef pointers, this array will hold all the references which ++ * cannot fit into AVFrame.buf. ++ * ++ * Note that this is different from AVFrame.extended_data, which always ++ * contains all the pointers. This array only contains the extra pointers, ++ * which cannot fit into AVFrame.buf. ++ * ++ * This array is always allocated using av_malloc() by whoever constructs ++ * the frame. It is freed in av_frame_unref(). ++ */ ++ AVBufferRef **extended_buf; ++ /** ++ * Number of elements in extended_buf. ++ */ ++ int nb_extended_buf; ++ ++ AVFrameSideData **side_data; ++ int nb_side_data; ++ ++/** ++ * @defgroup lavu_frame_flags AV_FRAME_FLAGS ++ * @ingroup lavu_frame ++ * Flags describing additional frame properties. ++ * ++ * @{ ++ */ ++ ++/** ++ * The frame data may be corrupted, e.g. due to decoding errors. ++ */ ++#define AV_FRAME_FLAG_CORRUPT (1 << 0) ++/** ++ * A flag to mark frames that are keyframes. ++ */ ++#define AV_FRAME_FLAG_KEY (1 << 1) ++/** ++ * A flag to mark the frames which need to be decoded, but shouldn't be output. ++ */ ++#define AV_FRAME_FLAG_DISCARD (1 << 2) ++/** ++ * A flag to mark frames whose content is interlaced. ++ */ ++#define AV_FRAME_FLAG_INTERLACED (1 << 3) ++/** ++ * A flag to mark frames where the top field is displayed first if the content ++ * is interlaced. ++ */ ++#define AV_FRAME_FLAG_TOP_FIELD_FIRST (1 << 4) ++/** ++ * A decoder can use this flag to mark frames which were originally encoded losslessly. ++ * ++ * For coding bitstream formats which support both lossless and lossy ++ * encoding, it is sometimes possible for a decoder to determine which method ++ * was used when the bitstream was encoded. ++ */ ++#define AV_FRAME_FLAG_LOSSLESS (1 << 5) ++/** ++ * @} ++ */ ++ ++ /** ++ * Frame flags, a combination of @ref lavu_frame_flags ++ */ ++ int flags; ++ ++ /** ++ * MPEG vs JPEG YUV range. ++ * - encoding: Set by user ++ * - decoding: Set by libavcodec ++ */ ++ enum AVColorRange color_range; ++ ++ enum AVColorPrimaries color_primaries; ++ ++ enum AVColorTransferCharacteristic color_trc; ++ ++ /** ++ * YUV colorspace type. ++ * - encoding: Set by user ++ * - decoding: Set by libavcodec ++ */ ++ enum AVColorSpace colorspace; ++ ++ enum AVChromaLocation chroma_location; ++ ++ /** ++ * frame timestamp estimated using various heuristics, in stream time base ++ * - encoding: unused ++ * - decoding: set by libavcodec, read by user. ++ */ ++ int64_t best_effort_timestamp; ++ ++ /** ++ * metadata. ++ * - encoding: Set by user. ++ * - decoding: Set by libavcodec. ++ */ ++ AVDictionary *metadata; ++ ++ /** ++ * decode error flags of the frame, set to a combination of ++ * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there ++ * were errors during the decoding. ++ * - encoding: unused ++ * - decoding: set by libavcodec, read by user. ++ */ ++ int decode_error_flags; ++#define FF_DECODE_ERROR_INVALID_BITSTREAM 1 ++#define FF_DECODE_ERROR_MISSING_REFERENCE 2 ++#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4 ++#define FF_DECODE_ERROR_DECODE_SLICES 8 ++ ++ /** ++ * For hwaccel-format frames, this should be a reference to the ++ * AVHWFramesContext describing the frame. ++ */ ++ AVBufferRef *hw_frames_ctx; ++ ++ /** ++ * Frame owner's private data. ++ * ++ * This field may be set by the code that allocates/owns the frame data. ++ * It is then not touched by any library functions, except: ++ * - a new reference to the underlying buffer is propagated by ++ * av_frame_copy_props() (and hence by av_frame_ref()); ++ * - it is unreferenced in av_frame_unref(); ++ * - on the caller's explicit request. E.g. libavcodec encoders/decoders ++ * will propagate a new reference to/from @ref AVPacket "AVPackets" if the ++ * caller sets @ref AV_CODEC_FLAG_COPY_OPAQUE. ++ * ++ * @see opaque the plain pointer analogue ++ */ ++ AVBufferRef *opaque_ref; ++ ++ /** ++ * @anchor cropping ++ * @name Cropping ++ * Video frames only. The number of pixels to discard from the ++ * top/bottom/left/right border of the frame to obtain the sub-rectangle of ++ * the frame intended for presentation. ++ * @{ ++ */ ++ size_t crop_top; ++ size_t crop_bottom; ++ size_t crop_left; ++ size_t crop_right; ++ /** ++ * @} ++ */ ++ ++ /** ++ * RefStruct reference for internal use by a single libav* library. ++ * Must not be used to transfer data between libraries. ++ * Has to be NULL when ownership of the frame leaves the respective library. ++ * ++ * Code outside the FFmpeg libs must never check or change private_ref. ++ */ ++ void *private_ref; ++ ++ /** ++ * Channel layout of the audio data. ++ */ ++ AVChannelLayout ch_layout; ++ ++ /** ++ * Duration of the frame, in the same units as pts. 0 if unknown. ++ */ ++ int64_t duration; ++ ++ /** ++ * Indicates how the alpha channel of the video is to be handled. ++ * - encoding: Set by user ++ * - decoding: Set by libavcodec ++ */ ++ enum AVAlphaMode alpha_mode; ++} AVFrame; ++ ++ ++/** ++ * Allocate an AVFrame and set its fields to default values. The resulting ++ * struct must be freed using av_frame_free(). ++ * ++ * @return An AVFrame filled with default values or NULL on failure. ++ * ++ * @note this only allocates the AVFrame itself, not the data buffers. Those ++ * must be allocated through other means, e.g. with av_frame_get_buffer() or ++ * manually. ++ */ ++AVFrame *av_frame_alloc(void); ++ ++/** ++ * Free the frame and any dynamically allocated objects in it, ++ * e.g. extended_data. If the frame is reference counted, it will be ++ * unreferenced first. ++ * ++ * @param frame frame to be freed. The pointer will be set to NULL. ++ */ ++void av_frame_free(AVFrame **frame); ++ ++/** ++ * Set up a new reference to the data described by the source frame. ++ * ++ * Copy frame properties from src to dst and create a new reference for each ++ * AVBufferRef from src. ++ * ++ * If src is not reference counted, new buffers are allocated and the data is ++ * copied. ++ * ++ * @warning: dst MUST have been either unreferenced with av_frame_unref(dst), ++ * or newly allocated with av_frame_alloc() before calling this ++ * function, or undefined behavior will occur. ++ * ++ * @return 0 on success, a negative AVERROR on error ++ */ ++int av_frame_ref(AVFrame *dst, const AVFrame *src); ++ ++/** ++ * Ensure the destination frame refers to the same data described by the source ++ * frame, either by creating a new reference for each AVBufferRef from src if ++ * they differ from those in dst, by allocating new buffers and copying data if ++ * src is not reference counted, or by unreferencing it if src is empty. ++ * ++ * Frame properties on dst will be replaced by those from src. ++ * ++ * @return 0 on success, a negative AVERROR on error. On error, dst is ++ * unreferenced. ++ */ ++int av_frame_replace(AVFrame *dst, const AVFrame *src); ++ ++/** ++ * Create a new frame that references the same data as src. ++ * ++ * This is a shortcut for av_frame_alloc()+av_frame_ref(). ++ * ++ * @return newly created AVFrame on success, NULL on error. ++ */ ++AVFrame *av_frame_clone(const AVFrame *src); ++ ++/** ++ * Unreference all the buffers referenced by frame and reset the frame fields. ++ */ ++void av_frame_unref(AVFrame *frame); ++ ++/** ++ * Move everything contained in src to dst and reset src. ++ * ++ * @warning: dst is not unreferenced, but directly overwritten without reading ++ * or deallocating its contents. Call av_frame_unref(dst) manually ++ * before calling this function to ensure that no memory is leaked. ++ */ ++void av_frame_move_ref(AVFrame *dst, AVFrame *src); ++ ++/** ++ * Allocate new buffer(s) for audio or video data. ++ * ++ * The following fields must be set on frame before calling this function: ++ * - format (pixel format for video, sample format for audio) ++ * - width and height for video ++ * - nb_samples and ch_layout for audio ++ * ++ * This function will fill AVFrame.data and AVFrame.buf arrays and, if ++ * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf. ++ * For planar formats, one buffer will be allocated for each plane. ++ * ++ * @warning: if frame already has been allocated, calling this function will ++ * leak memory. In addition, undefined behavior can occur in certain ++ * cases. ++ * ++ * @param frame frame in which to store the new buffers. ++ * @param align Required buffer size and data pointer alignment. If equal to 0, ++ * alignment will be chosen automatically for the current CPU. ++ * It is highly recommended to pass 0 here unless you know what ++ * you are doing. ++ * ++ * @return 0 on success, a negative AVERROR on error. ++ */ ++int av_frame_get_buffer(AVFrame *frame, int align); ++ ++/** ++ * Check if the frame data is writable. ++ * ++ * @return A positive value if the frame data is writable (which is true if and ++ * only if each of the underlying buffers has only one reference, namely the one ++ * stored in this frame). Return 0 otherwise. ++ * ++ * If 1 is returned the answer is valid until av_buffer_ref() is called on any ++ * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly). ++ * ++ * @see av_frame_make_writable(), av_buffer_is_writable() ++ */ ++int av_frame_is_writable(AVFrame *frame); ++ ++/** ++ * Ensure that the frame data is writable, avoiding data copy if possible. ++ * ++ * Do nothing if the frame is writable, allocate new buffers and copy the data ++ * if it is not. Non-refcounted frames behave as non-writable, i.e. a copy ++ * is always made. ++ * ++ * @return 0 on success, a negative AVERROR on error. ++ * ++ * @see av_frame_is_writable(), av_buffer_is_writable(), ++ * av_buffer_make_writable() ++ */ ++int av_frame_make_writable(AVFrame *frame); ++ ++/** ++ * Copy the frame data from src to dst. ++ * ++ * This function does not allocate anything, dst must be already initialized and ++ * allocated with the same parameters as src. ++ * ++ * This function only copies the frame data (i.e. the contents of the data / ++ * extended data arrays), not any other properties. ++ * ++ * @return >= 0 on success, a negative AVERROR on error. ++ */ ++int av_frame_copy(AVFrame *dst, const AVFrame *src); ++ ++/** ++ * Copy only "metadata" fields from src to dst. ++ * ++ * Metadata for the purpose of this function are those fields that do not affect ++ * the data layout in the buffers. E.g. pts, sample rate (for audio) or sample ++ * aspect ratio (for video), but not width/height or channel layout. ++ * Side data is also copied. ++ */ ++int av_frame_copy_props(AVFrame *dst, const AVFrame *src); ++ ++/** ++ * Get the buffer reference a given data plane is stored in. ++ * ++ * @param frame the frame to get the plane's buffer from ++ * @param plane index of the data plane of interest in frame->extended_data. ++ * ++ * @return the buffer reference that contains the plane or NULL if the input ++ * frame is not valid. ++ */ ++AVBufferRef *av_frame_get_plane_buffer(const AVFrame *frame, int plane); ++ ++/** ++ * Add a new side data to a frame. ++ * ++ * @param frame a frame to which the side data should be added ++ * @param type type of the added side data ++ * @param size size of the side data ++ * ++ * @return newly added side data on success, NULL on error ++ */ ++AVFrameSideData *av_frame_new_side_data(AVFrame *frame, ++ enum AVFrameSideDataType type, ++ size_t size); ++ ++/** ++ * Add a new side data to a frame from an existing AVBufferRef ++ * ++ * @param frame a frame to which the side data should be added ++ * @param type the type of the added side data ++ * @param buf an AVBufferRef to add as side data. The ownership of ++ * the reference is transferred to the frame. ++ * ++ * @return newly added side data on success, NULL on error. On failure ++ * the frame is unchanged and the AVBufferRef remains owned by ++ * the caller. ++ */ ++AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame, ++ enum AVFrameSideDataType type, ++ AVBufferRef *buf); ++ ++/** ++ * @return a pointer to the side data of a given type on success, NULL if there ++ * is no side data with such type in this frame. ++ */ ++AVFrameSideData *av_frame_get_side_data(const AVFrame *frame, ++ enum AVFrameSideDataType type); ++ ++/** ++ * Remove and free all side data instances of the given type. ++ */ ++void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type); ++ ++ ++/** ++ * Flags for frame cropping. ++ */ ++enum { ++ /** ++ * Apply the maximum possible cropping, even if it requires setting the ++ * AVFrame.data[] entries to unaligned pointers. Passing unaligned data ++ * to FFmpeg API is generally not allowed, and causes undefined behavior ++ * (such as crashes). You can pass unaligned data only to FFmpeg APIs that ++ * are explicitly documented to accept it. Use this flag only if you ++ * absolutely know what you are doing. ++ */ ++ AV_FRAME_CROP_UNALIGNED = 1 << 0, ++}; ++ ++/** ++ * Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ ++ * crop_bottom fields. If cropping is successful, the function will adjust the ++ * data pointers and the width/height fields, and set the crop fields to 0. ++ * ++ * In all cases, the cropping boundaries will be rounded to the inherent ++ * alignment of the pixel format. In some cases, such as for opaque hwaccel ++ * formats, the left/top cropping is ignored. The crop fields are set to 0 even ++ * if the cropping was rounded or ignored. ++ * ++ * @param frame the frame which should be cropped ++ * @param flags Some combination of AV_FRAME_CROP_* flags, or 0. ++ * ++ * @return >= 0 on success, a negative AVERROR on error. If the cropping fields ++ * were invalid, AVERROR(ERANGE) is returned, and nothing is changed. ++ */ ++int av_frame_apply_cropping(AVFrame *frame, int flags); ++ ++/** ++ * @return a string identifying the side data type ++ */ ++const char *av_frame_side_data_name(enum AVFrameSideDataType type); ++ ++/** ++ * @return side data descriptor corresponding to a given side data type, NULL ++ * when not available. ++ */ ++const AVSideDataDescriptor *av_frame_side_data_desc(enum AVFrameSideDataType type); ++ ++/** ++ * Free all side data entries and their contents, then zeroes out the ++ * values which the pointers are pointing to. ++ * ++ * @param sd pointer to array of side data to free. Will be set to NULL ++ * upon return. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. Will be set to 0 upon return. ++ */ ++void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd); ++ ++/** ++ * Remove existing entries before adding new ones. ++ */ ++#define AV_FRAME_SIDE_DATA_FLAG_UNIQUE (1 << 0) ++/** ++ * Don't add a new entry if another of the same type exists. ++ * Applies only for side data types without the AV_SIDE_DATA_PROP_MULTI prop. ++ */ ++#define AV_FRAME_SIDE_DATA_FLAG_REPLACE (1 << 1) ++/** ++ * Create a new reference to the passed in buffer instead of taking ownership ++ * of it. ++ */ ++#define AV_FRAME_SIDE_DATA_FLAG_NEW_REF (1 << 2) ++ ++/** ++ * Add new side data entry to an array. ++ * ++ * @param sd pointer to array of side data to which to add another entry, ++ * or to NULL in order to start a new array. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. ++ * @param type type of the added side data ++ * @param size size of the side data ++ * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0. ++ * ++ * @return newly added side data on success, NULL on error. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of ++ * matching AVFrameSideDataType will be removed before the addition ++ * is attempted. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an ++ * entry of the same type already exists, it will be replaced instead. ++ */ ++AVFrameSideData *av_frame_side_data_new(AVFrameSideData ***sd, int *nb_sd, ++ enum AVFrameSideDataType type, ++ size_t size, unsigned int flags); ++ ++/** ++ * Add a new side data entry to an array from an existing AVBufferRef. ++ * ++ * @param sd pointer to array of side data to which to add another entry, ++ * or to NULL in order to start a new array. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. ++ * @param type type of the added side data ++ * @param buf Pointer to AVBufferRef to add to the array. On success, ++ * the function takes ownership of the AVBufferRef and *buf is ++ * set to NULL, unless AV_FRAME_SIDE_DATA_FLAG_NEW_REF is set ++ * in which case the ownership will remain with the caller. ++ * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0. ++ * ++ * @return newly added side data on success, NULL on error. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of ++ * matching AVFrameSideDataType will be removed before the addition ++ * is attempted. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an ++ * entry of the same type already exists, it will be replaced instead. ++ * ++ */ ++AVFrameSideData *av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, ++ enum AVFrameSideDataType type, ++ AVBufferRef **buf, unsigned int flags); ++ ++/** ++ * Add a new side data entry to an array based on existing side data, taking ++ * a reference towards the contained AVBufferRef. ++ * ++ * @param sd pointer to array of side data to which to add another entry, ++ * or to NULL in order to start a new array. ++ * @param nb_sd pointer to an integer containing the number of entries in ++ * the array. ++ * @param src side data to be cloned, with a new reference utilized ++ * for the buffer. ++ * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0. ++ * ++ * @return negative error code on failure, >=0 on success. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of ++ * matching AVFrameSideDataType will be removed before the addition ++ * is attempted. ++ * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an ++ * entry of the same type already exists, it will be replaced instead. ++ */ ++int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, ++ const AVFrameSideData *src, unsigned int flags); ++ ++/** ++ * Get a side data entry of a specific type from an array. ++ * ++ * @param sd array of side data. ++ * @param nb_sd integer containing the number of entries in the array. ++ * @param type type of side data to be queried ++ * ++ * @return a pointer to the side data of a given type on success, NULL if there ++ * is no side data with such type in this set. ++ */ ++const AVFrameSideData *av_frame_side_data_get_c(const AVFrameSideData * const *sd, ++ const int nb_sd, ++ enum AVFrameSideDataType type); ++ ++/** ++ * Wrapper around av_frame_side_data_get_c() to workaround the limitation ++ * that for any type T the conversion from T * const * to const T * const * ++ * is not performed automatically in C. ++ * @see av_frame_side_data_get_c() ++ */ ++static inline ++const AVFrameSideData *av_frame_side_data_get(AVFrameSideData * const *sd, ++ const int nb_sd, ++ enum AVFrameSideDataType type) ++{ ++ return av_frame_side_data_get_c((const AVFrameSideData * const *)sd, ++ nb_sd, type); ++} ++ ++/** ++ * Remove and free all side data instances of the given type from an array. ++ */ ++void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd, ++ enum AVFrameSideDataType type); ++ ++/** ++ * Remove and free all side data instances that match any of the given ++ * side data properties. (See enum AVSideDataProps) ++ */ ++void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, ++ int props); ++ ++/** ++ * @} ++ */ ++ ++#endif /* AVUTIL_FRAME_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/hwcontext.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/hwcontext.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg58/include/libavutil/hwcontext_drm.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_drm.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg58/include/libavutil/hwcontext_drm.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_drm.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/hwcontext_vaapi.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vaapi.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/hwcontext_vaapi.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vaapi.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vulkan.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vulkan.h +new file mode 100644 +index 000000000000..87c2a2d28deb +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/hwcontext_vulkan.h +@@ -0,0 +1,355 @@ ++/* ++ * 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 AVUTIL_HWCONTEXT_VULKAN_H ++#define AVUTIL_HWCONTEXT_VULKAN_H ++ ++#if defined(_WIN32) && !defined(VK_USE_PLATFORM_WIN32_KHR) ++#define VK_USE_PLATFORM_WIN32_KHR ++#endif ++#include ++ ++#include "pixfmt.h" ++#include "frame.h" ++#include "hwcontext.h" ++ ++typedef struct AVVkFrame AVVkFrame; ++ ++typedef struct AVVulkanDeviceQueueFamily { ++ /* Queue family index */ ++ int idx; ++ /* Number of queues in the queue family in use */ ++ int num; ++ /* Queue family capabilities. Must be non-zero. ++ * Flags may be removed to indicate the queue family may not be used ++ * for a given purpose. */ ++ VkQueueFlagBits flags; ++ /* Vulkan implementations are allowed to list multiple video queues ++ * which differ in what they can encode or decode. */ ++ VkVideoCodecOperationFlagBitsKHR video_caps; ++} AVVulkanDeviceQueueFamily; ++ ++/** ++ * @file ++ * API-specific header for AV_HWDEVICE_TYPE_VULKAN. ++ * ++ * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs ++ * with the data pointer set to an AVVkFrame. ++ */ ++ ++/** ++ * Main Vulkan context, allocated as AVHWDeviceContext.hwctx. ++ * All of these can be set before init to change what the context uses ++ */ ++typedef struct AVVulkanDeviceContext { ++ /** ++ * Custom memory allocator, else NULL ++ */ ++ const VkAllocationCallbacks *alloc; ++ ++ /** ++ * Pointer to a vkGetInstanceProcAddr loading function. ++ * If unset, will dynamically load and use libvulkan. ++ */ ++ PFN_vkGetInstanceProcAddr get_proc_addr; ++ ++ /** ++ * Vulkan instance. Must be at least version 1.3. ++ */ ++ VkInstance inst; ++ ++ /** ++ * Physical device ++ */ ++ VkPhysicalDevice phys_dev; ++ ++ /** ++ * Active device ++ */ ++ VkDevice act_dev; ++ ++ /** ++ * This structure should be set to the set of features that present and enabled ++ * during device creation. When a device is created by FFmpeg, it will default to ++ * enabling all that are present of the shaderImageGatherExtended, ++ * fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features. ++ */ ++ VkPhysicalDeviceFeatures2 device_features; ++ ++ /** ++ * Enabled instance extensions. ++ * If supplying your own device context, set this to an array of strings, with ++ * each entry containing the specified Vulkan extension string to enable. ++ * Duplicates are possible and accepted. ++ * If no extensions are enabled, set these fields to NULL, and 0 respectively. ++ * av_vk_get_optional_instance_extensions() can be used to enumerate extensions ++ * that FFmpeg may use if enabled. ++ */ ++ const char * const *enabled_inst_extensions; ++ int nb_enabled_inst_extensions; ++ ++ /** ++ * Enabled device extensions. By default, VK_KHR_external_memory_fd, ++ * VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier, ++ * VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found. ++ * If supplying your own device context, these fields takes the same format as ++ * the above fields, with the same conditions that duplicates are possible ++ * and accepted, and that NULL and 0 respectively means no extensions are enabled. ++ * av_vk_get_optional_device_extensions() can be used to enumerate extensions ++ * that FFmpeg may use if enabled. ++ */ ++ const char * const *enabled_dev_extensions; ++ int nb_enabled_dev_extensions; ++ ++#if FF_API_VULKAN_SYNC_QUEUES ++ /** ++ * Locks a queue, preventing other threads from submitting any command ++ * buffers to this queue. ++ * If set to NULL, will be set to lavu-internal functions that utilize a ++ * mutex. ++ * ++ * Deprecated: use VK_KHR_internally_synchronized_queues. ++ */ ++ attribute_deprecated ++ void (*lock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index); ++ ++ /** ++ * Similar to lock_queue(), unlocks a queue. Must only be called after locking. ++ * ++ * Deprecated: use VK_KHR_internally_synchronized_queues. ++ */ ++ attribute_deprecated ++ void (*unlock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index); ++#endif ++ ++ /** ++ * Queue families used. Must be preferentially ordered. List may contain ++ * duplicates. ++ * ++ * For compatibility reasons, all the enabled queue families listed above ++ * (queue_family_(tx/comp/encode/decode)_index) must also be included in ++ * this list until they're removed after deprecation. ++ */ ++ AVVulkanDeviceQueueFamily qf[64]; ++ int nb_qf; ++ ++ /* Queue creation flags, for vkGetDeviceQueue2. */ ++ VkDeviceQueueCreateFlags queue_flags; ++} AVVulkanDeviceContext; ++ ++/** ++ * Defines the behaviour of frame allocation. ++ */ ++typedef enum AVVkFrameFlags { ++ /* Unless this flag is set, autodetected flags will be OR'd based on the ++ * device and tiling during av_hwframe_ctx_init(). */ ++ AV_VK_FRAME_FLAG_NONE = (1ULL << 0), ++ ++ /* Disables multiplane images. ++ * This is required to export/import images from CUDA. */ ++ AV_VK_FRAME_FLAG_DISABLE_MULTIPLANE = (1ULL << 2), ++} AVVkFrameFlags; ++ ++/** ++ * Allocated as AVHWFramesContext.hwctx, used to set pool-specific options ++ */ ++typedef struct AVVulkanFramesContext { ++ /** ++ * Controls the tiling of allocated frames. ++ * If left as VK_IMAGE_TILING_OPTIMAL (0), will use optimal tiling. ++ * Can be set to VK_IMAGE_TILING_LINEAR to force linear images, ++ * or VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT to force DMABUF-backed ++ * images. ++ * @note Imported frames from other APIs ignore this. ++ */ ++ VkImageTiling tiling; ++ ++ /** ++ * Defines extra usage of output frames. If non-zero, all flags MUST be ++ * supported by the VkFormat. Regardless, frames will always have the ++ * following usage flags enabled, if supported by the format: ++ * - VK_IMAGE_USAGE_SAMPLED_BIT ++ * - VK_IMAGE_USAGE_STORAGE_BIT ++ * - VK_IMAGE_USAGE_TRANSFER_SRC_BIT ++ * - VK_IMAGE_USAGE_TRANSFER_DST_BIT ++ */ ++ VkImageUsageFlagBits usage; ++ ++ /** ++ * Extension data for image creation. ++ * If DRM tiling is used, a VkImageDrmFormatModifierListCreateInfoEXT structure ++ * can be added to specify the exact modifier to use. ++ * ++ * Additional structures may be added at av_hwframe_ctx_init() time, ++ * which will be freed automatically on uninit(), so users must only free ++ * any structures they've allocated themselves. ++ */ ++ void *create_pnext; ++ ++ /** ++ * Extension data for memory allocation. Must have as many entries as ++ * the number of planes of the sw_format. ++ * This will be chained to VkExportMemoryAllocateInfo, which is used ++ * to make all pool images exportable to other APIs if the necessary ++ * extensions are present in enabled_dev_extensions. ++ */ ++ void *alloc_pnext[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * A combination of AVVkFrameFlags. Unless AV_VK_FRAME_FLAG_NONE is set, ++ * autodetected flags will be OR'd based on the device and tiling during ++ * av_hwframe_ctx_init(). ++ */ ++ AVVkFrameFlags flags; ++ ++ /** ++ * Flags to set during image creation. If unset, defaults to ++ * VK_IMAGE_CREATE_ALIAS_BIT. ++ */ ++ VkImageCreateFlags img_flags; ++ ++ /** ++ * Vulkan format for each image. MUST be compatible with the pixel format. ++ * If unset, will be automatically set. ++ * There are at most two compatible formats for a frame - a multiplane ++ * format, and a single-plane multi-image format. ++ */ ++ VkFormat format[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Number of layers each image will have. ++ */ ++ int nb_layers; ++ ++ /** ++ * Locks a frame, preventing other threads from changing frame properties. ++ * Users SHOULD only ever lock just before command submission in order ++ * to get accurate frame properties, and unlock immediately after command ++ * submission without waiting for it to finish. ++ * ++ * If unset, will be set to lavu-internal functions that utilize a mutex. ++ */ ++ void (*lock_frame)(struct AVHWFramesContext *fc, AVVkFrame *vkf); ++ ++ /** ++ * Similar to lock_frame(), unlocks a frame. Must only be called after locking. ++ */ ++ void (*unlock_frame)(struct AVHWFramesContext *fc, AVVkFrame *vkf); ++} AVVulkanFramesContext; ++ ++/* ++ * Frame structure. ++ * ++ * @note the size of this structure is not part of the ABI, to allocate ++ * you must use @av_vk_frame_alloc(). ++ */ ++struct AVVkFrame { ++ /** ++ * Vulkan images to which the memory is bound to. ++ * May be one for multiplane formats, or multiple. ++ */ ++ VkImage img[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Tiling for the frame. ++ */ ++ VkImageTiling tiling; ++ ++ /** ++ * Memory backing the images. Either one, or as many as there are planes ++ * in the sw_format. ++ * In case of having multiple VkImages, but one memory, the offset field ++ * will indicate the bound offset for each image. ++ */ ++ VkDeviceMemory mem[AV_NUM_DATA_POINTERS]; ++ size_t size[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * OR'd flags for all memory allocated ++ */ ++ VkMemoryPropertyFlagBits flags; ++ ++ /** ++ * Updated after every barrier. One per VkImage. ++ */ ++ VkAccessFlagBits2 access[AV_NUM_DATA_POINTERS]; ++ VkImageLayout layout[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Synchronization timeline semaphores, one for each VkImage. ++ * Must not be freed manually. Must be waited on at every submission using ++ * the value in sem_value, and must be signalled at every submission, ++ * using an incremented value. ++ */ ++ VkSemaphore sem[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Up to date semaphore value at which each image becomes accessible. ++ * One per VkImage. ++ * Clients must wait on this value when submitting a command queue, ++ * and increment it when signalling. ++ */ ++ uint64_t sem_value[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Describes the binding offset of each image to the VkDeviceMemory. ++ * One per VkImage. ++ */ ++ ptrdiff_t offset[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Queue family of the images. Must be VK_QUEUE_FAMILY_IGNORED if ++ * the image was allocated with the CONCURRENT concurrency option. ++ * One per VkImage. ++ */ ++ uint32_t queue_family[AV_NUM_DATA_POINTERS]; ++ ++ /** ++ * Internal data. Not to be accessed by users in any way. ++ */ ++ struct AVVkFrameInternal *internal; ++}; ++ ++/** ++ * Allocates a single AVVkFrame and initializes everything as 0. ++ * @note Must be freed via av_free() ++ */ ++AVVkFrame *av_vk_frame_alloc(void); ++ ++/** ++ * Returns the optimal per-plane Vulkan format for a given sw_format, ++ * one for each plane. ++ * Returns NULL on unsupported formats. ++ */ ++const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p); ++ ++/** ++ * Returns an array of optional Vulkan instance extensions that FFmpeg ++ * may use if enabled. ++ * @note Must be freed via av_free() ++ */ ++const char **av_vk_get_optional_instance_extensions(int *count); ++ ++/** ++ * Returns an array of optional Vulkan device extensions that FFmpeg ++ * may use if enabled. ++ * @note Must be freed via av_free() ++ */ ++const char **av_vk_get_optional_device_extensions(int *count); ++ ++#endif /* AVUTIL_HWCONTEXT_VULKAN_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg57/include/libavutil/intfloat.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/intfloat.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg57/include/libavutil/intfloat.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/intfloat.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/log.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/log.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/log.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/log.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/macros.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/macros.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/macros.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/macros.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/mathematics.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/mathematics.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/mathematics.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/mathematics.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/mem.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/mem.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/mem.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/mem.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/pixfmt.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/pixfmt.h +new file mode 100644 +index 000000000000..b08881cc1f8d +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/pixfmt.h +@@ -0,0 +1,823 @@ ++/* ++ * copyright (c) 2006 Michael Niedermayer ++ * ++ * 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 AVUTIL_PIXFMT_H ++#define AVUTIL_PIXFMT_H ++ ++/** ++ * @file ++ * pixel format definitions ++ */ ++ ++#include "libavutil/avconfig.h" ++#include "version.h" ++ ++#define AVPALETTE_SIZE 1024 ++#define AVPALETTE_COUNT 256 ++ ++/** ++ * Maximum number of planes in any pixel format. ++ * This should be used when a maximum is needed, but code should not ++ * be written to require a maximum for no good reason. ++ */ ++#define AV_VIDEO_MAX_PLANES 4 ++ ++/** ++ * Pixel format. ++ * ++ * @note ++ * AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA ++ * color is put together as: ++ * (A << 24) | (R << 16) | (G << 8) | B ++ * This is stored as BGRA on little-endian CPU architectures and ARGB on ++ * big-endian CPUs. ++ * ++ * @note ++ * If the resolution is not a multiple of the chroma subsampling factor ++ * then the chroma plane resolution must be rounded up. ++ * ++ * @par ++ * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized ++ * image data is stored in AVFrame.data[0]. The palette is transported in ++ * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is ++ * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is ++ * also endian-specific). Note also that the individual RGB32 palette ++ * components stored in AVFrame.data[1] should be in the range 0..255. ++ * This is important as many custom PAL8 video codecs that were designed ++ * to run on the IBM VGA graphics adapter use 6-bit palette components. ++ * ++ * @par ++ * For all the 8 bits per pixel formats, an RGB32 palette is in data[1] like ++ * for pal8. This palette is filled in automatically by the function ++ * allocating the picture. ++ */ ++enum AVPixelFormat { ++ AV_PIX_FMT_NONE = -1, ++ AV_PIX_FMT_YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) ++ AV_PIX_FMT_YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr ++ AV_PIX_FMT_RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB... ++ AV_PIX_FMT_BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR... ++ AV_PIX_FMT_YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) ++ AV_PIX_FMT_YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) ++ AV_PIX_FMT_YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) ++ AV_PIX_FMT_YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) ++ AV_PIX_FMT_GRAY8, ///< Y , 8bpp ++ AV_PIX_FMT_MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb ++ AV_PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb ++ AV_PIX_FMT_PAL8, ///< 8 bits with AV_PIX_FMT_RGB32 palette ++ 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 ++ 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 ++ 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 ++ AV_PIX_FMT_UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 ++ AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 ++ AV_PIX_FMT_BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) ++ AV_PIX_FMT_BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits ++ AV_PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) ++ AV_PIX_FMT_RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb) ++ AV_PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits ++ AV_PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) ++ AV_PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) ++ AV_PIX_FMT_NV21, ///< as above, but U and V bytes are swapped ++ ++ AV_PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB... ++ AV_PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA... ++ AV_PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR... ++ AV_PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA... ++ ++ AV_PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian ++ AV_PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian ++ AV_PIX_FMT_YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples) ++ AV_PIX_FMT_YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range ++ AV_PIX_FMT_YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples) ++ AV_PIX_FMT_RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian ++ AV_PIX_FMT_RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian ++ ++ AV_PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian ++ AV_PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian ++ AV_PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined ++ AV_PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ++ ++ AV_PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian ++ AV_PIX_FMT_BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian ++ AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined ++ AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ++ ++ /** ++ * Hardware acceleration through VA-API, data[3] contains a ++ * VASurfaceID. ++ */ ++ AV_PIX_FMT_VAAPI, ++ ++ AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian ++ AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian ++ AV_PIX_FMT_YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ AV_PIX_FMT_YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian ++ AV_PIX_FMT_YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian ++ AV_PIX_FMT_DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer ++ ++ AV_PIX_FMT_RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ++ AV_PIX_FMT_RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined ++ AV_PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined ++ AV_PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined ++ AV_PIX_FMT_YA8, ///< 8 bits gray, 8 bits alpha ++ ++ AV_PIX_FMT_Y400A = AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8 ++ AV_PIX_FMT_GRAY8A= AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8 ++ ++ AV_PIX_FMT_BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian ++ AV_PIX_FMT_BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian ++ ++ /** ++ * The following 12 formats have the disadvantage of needing 1 format for each bit depth. ++ * Notice that each 9/10 bits sample is stored in 16 bits with extra padding. ++ * If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better. ++ */ ++ AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian ++ AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian ++ AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian ++ AV_PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian ++ AV_PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ AV_PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian ++ AV_PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian ++ AV_PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian ++ AV_PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian ++ AV_PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ AV_PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_GBRP, ///< planar GBR 4:4:4 24bpp ++ AV_PIX_FMT_GBR24P = AV_PIX_FMT_GBRP, // alias for #AV_PIX_FMT_GBRP ++ AV_PIX_FMT_GBRP9BE, ///< planar GBR 4:4:4 27bpp, big-endian ++ AV_PIX_FMT_GBRP9LE, ///< planar GBR 4:4:4 27bpp, little-endian ++ AV_PIX_FMT_GBRP10BE, ///< planar GBR 4:4:4 30bpp, big-endian ++ AV_PIX_FMT_GBRP10LE, ///< planar GBR 4:4:4 30bpp, little-endian ++ AV_PIX_FMT_GBRP16BE, ///< planar GBR 4:4:4 48bpp, big-endian ++ AV_PIX_FMT_GBRP16LE, ///< planar GBR 4:4:4 48bpp, little-endian ++ AV_PIX_FMT_YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples) ++ AV_PIX_FMT_YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples) ++ AV_PIX_FMT_YUVA420P9BE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian ++ AV_PIX_FMT_YUVA420P9LE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ++ AV_PIX_FMT_YUVA422P9BE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian ++ AV_PIX_FMT_YUVA422P9LE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian ++ AV_PIX_FMT_YUVA444P9BE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian ++ AV_PIX_FMT_YUVA444P9LE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian ++ AV_PIX_FMT_YUVA420P10BE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA420P10LE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian) ++ AV_PIX_FMT_YUVA422P10BE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA422P10LE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian) ++ AV_PIX_FMT_YUVA444P10BE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA444P10LE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian) ++ AV_PIX_FMT_YUVA420P16BE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA420P16LE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian) ++ AV_PIX_FMT_YUVA422P16BE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian) ++ AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian) ++ AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian) ++ ++ AV_PIX_FMT_VDPAU, ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface ++ ++ AV_PIX_FMT_XYZ12LE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0 ++ AV_PIX_FMT_XYZ12BE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0 ++ AV_PIX_FMT_NV16, ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) ++ AV_PIX_FMT_NV20LE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_NV20BE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ ++ AV_PIX_FMT_RGBA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian ++ AV_PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian ++ AV_PIX_FMT_BGRA64BE, ///< 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 big-endian ++ 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 ++ ++ AV_PIX_FMT_YVYU422, ///< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb ++ ++ AV_PIX_FMT_YA16BE, ///< 16 bits gray, 16 bits alpha (big-endian) ++ AV_PIX_FMT_YA16LE, ///< 16 bits gray, 16 bits alpha (little-endian) ++ ++ AV_PIX_FMT_GBRAP, ///< planar GBRA 4:4:4:4 32bpp ++ AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian ++ AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian ++ /** ++ * HW acceleration through QSV, data[3] contains a pointer to the ++ * mfxFrameSurface1 structure. ++ * ++ * Before FFmpeg 5.0: ++ * mfxFrameSurface1.Data.MemId contains a pointer when importing ++ * the following frames as QSV frames: ++ * ++ * VAAPI: ++ * mfxFrameSurface1.Data.MemId contains a pointer to VASurfaceID ++ * ++ * DXVA2: ++ * mfxFrameSurface1.Data.MemId contains a pointer to IDirect3DSurface9 ++ * ++ * FFmpeg 5.0 and above: ++ * mfxFrameSurface1.Data.MemId contains a pointer to the mfxHDLPair ++ * structure when importing the following frames as QSV frames: ++ * ++ * VAAPI: ++ * mfxHDLPair.first contains a VASurfaceID pointer. ++ * mfxHDLPair.second is always MFX_INFINITE. ++ * ++ * DXVA2: ++ * mfxHDLPair.first contains IDirect3DSurface9 pointer. ++ * mfxHDLPair.second is always MFX_INFINITE. ++ * ++ * D3D11: ++ * mfxHDLPair.first contains a ID3D11Texture2D pointer. ++ * mfxHDLPair.second contains the texture array index of the frame if the ++ * ID3D11Texture2D is an array texture, or always MFX_INFINITE if it is a ++ * normal texture. ++ */ ++ AV_PIX_FMT_QSV, ++ /** ++ * HW acceleration though MMAL, data[3] contains a pointer to the ++ * MMAL_BUFFER_HEADER_T structure. ++ */ ++ AV_PIX_FMT_MMAL, ++ ++ AV_PIX_FMT_D3D11VA_VLD, ///< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer ++ ++ /** ++ * HW acceleration through CUDA. data[i] contain CUdeviceptr pointers ++ * exactly as for system memory frames. ++ */ ++ AV_PIX_FMT_CUDA, ++ ++ AV_PIX_FMT_0RGB, ///< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined ++ AV_PIX_FMT_RGB0, ///< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined ++ AV_PIX_FMT_0BGR, ///< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined ++ AV_PIX_FMT_BGR0, ///< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined ++ ++ AV_PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian ++ AV_PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian ++ AV_PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian ++ AV_PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian ++ AV_PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ AV_PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian ++ AV_PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian ++ AV_PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian ++ AV_PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian ++ AV_PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian ++ AV_PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian ++ AV_PIX_FMT_GBRP12BE, ///< planar GBR 4:4:4 36bpp, big-endian ++ AV_PIX_FMT_GBRP12LE, ///< planar GBR 4:4:4 36bpp, little-endian ++ AV_PIX_FMT_GBRP14BE, ///< planar GBR 4:4:4 42bpp, big-endian ++ AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian ++ 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 ++ ++ AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples ++ AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples ++ AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples ++ AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples ++ AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian ++ AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian ++ AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian ++ AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian ++ AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian ++ AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian ++ AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian ++ AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian ++ ++ AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian ++ AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian ++ AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian ++ AV_PIX_FMT_YUV440P12BE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian ++ AV_PIX_FMT_AYUV64LE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian ++ AV_PIX_FMT_AYUV64BE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian ++ ++ AV_PIX_FMT_VIDEOTOOLBOX, ///< hardware decoding through Videotoolbox ++ ++ AV_PIX_FMT_P010LE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian ++ AV_PIX_FMT_P010BE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian ++ ++ AV_PIX_FMT_GBRAP12BE, ///< planar GBR 4:4:4:4 48bpp, big-endian ++ AV_PIX_FMT_GBRAP12LE, ///< planar GBR 4:4:4:4 48bpp, little-endian ++ ++ AV_PIX_FMT_GBRAP10BE, ///< planar GBR 4:4:4:4 40bpp, big-endian ++ AV_PIX_FMT_GBRAP10LE, ///< planar GBR 4:4:4:4 40bpp, little-endian ++ ++ AV_PIX_FMT_MEDIACODEC, ///< hardware decoding through MediaCodec ++ ++ AV_PIX_FMT_GRAY12BE, ///< Y , 12bpp, big-endian ++ AV_PIX_FMT_GRAY12LE, ///< Y , 12bpp, little-endian ++ AV_PIX_FMT_GRAY10BE, ///< Y , 10bpp, big-endian ++ AV_PIX_FMT_GRAY10LE, ///< Y , 10bpp, little-endian ++ ++ AV_PIX_FMT_P016LE, ///< like NV12, with 16bpp per component, little-endian ++ AV_PIX_FMT_P016BE, ///< like NV12, with 16bpp per component, big-endian ++ ++ /** ++ * Hardware surfaces for Direct3D11. ++ * ++ * This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11 ++ * hwaccel API and filtering support AV_PIX_FMT_D3D11 only. ++ * ++ * data[0] contains a ID3D11Texture2D pointer, and data[1] contains the ++ * texture array index of the frame as intptr_t if the ID3D11Texture2D is ++ * an array texture (or always 0 if it's a normal texture). ++ */ ++ AV_PIX_FMT_D3D11, ++ ++ AV_PIX_FMT_GRAY9BE, ///< Y , 9bpp, big-endian ++ AV_PIX_FMT_GRAY9LE, ///< Y , 9bpp, little-endian ++ ++ AV_PIX_FMT_GBRPF32BE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian ++ AV_PIX_FMT_GBRPF32LE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian ++ AV_PIX_FMT_GBRAPF32BE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian ++ AV_PIX_FMT_GBRAPF32LE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian ++ ++ /** ++ * DRM-managed buffers exposed through PRIME buffer sharing. ++ * ++ * data[0] points to an AVDRMFrameDescriptor. ++ */ ++ AV_PIX_FMT_DRM_PRIME, ++ /** ++ * Hardware surfaces for OpenCL. ++ * ++ * data[i] contain 2D image objects (typed in C as cl_mem, used ++ * in OpenCL as image2d_t) for each plane of the surface. ++ */ ++ AV_PIX_FMT_OPENCL, ++ ++ AV_PIX_FMT_GRAY14BE, ///< Y , 14bpp, big-endian ++ AV_PIX_FMT_GRAY14LE, ///< Y , 14bpp, little-endian ++ ++ AV_PIX_FMT_GRAYF32BE, ///< IEEE-754 single precision Y, 32bpp, big-endian ++ AV_PIX_FMT_GRAYF32LE, ///< IEEE-754 single precision Y, 32bpp, little-endian ++ ++ AV_PIX_FMT_YUVA422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian ++ AV_PIX_FMT_YUVA422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian ++ AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian ++ AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian ++ ++ AV_PIX_FMT_NV24, ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) ++ AV_PIX_FMT_NV42, ///< as above, but U and V bytes are swapped ++ ++ /** ++ * Vulkan hardware images. ++ * ++ * data[0] points to an AVVkFrame ++ */ ++ AV_PIX_FMT_VULKAN, ++ ++ AV_PIX_FMT_Y210BE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian ++ AV_PIX_FMT_Y210LE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian ++ ++ AV_PIX_FMT_X2RGB10LE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined ++ AV_PIX_FMT_X2RGB10BE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined ++ AV_PIX_FMT_X2BGR10LE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined ++ AV_PIX_FMT_X2BGR10BE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined ++ ++ AV_PIX_FMT_P210BE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian ++ AV_PIX_FMT_P210LE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian ++ ++ AV_PIX_FMT_P410BE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian ++ AV_PIX_FMT_P410LE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian ++ ++ AV_PIX_FMT_P216BE, ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian ++ AV_PIX_FMT_P216LE, ///< interleaved chroma YUV 4:2:2, 32bpp, little-endian ++ ++ AV_PIX_FMT_P416BE, ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian ++ AV_PIX_FMT_P416LE, ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian ++ ++ AV_PIX_FMT_VUYA, ///< packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA... ++ ++ AV_PIX_FMT_RGBAF16BE, ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian ++ AV_PIX_FMT_RGBAF16LE, ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian ++ ++ AV_PIX_FMT_VUYX, ///< packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined ++ ++ AV_PIX_FMT_P012LE, ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian ++ AV_PIX_FMT_P012BE, ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian ++ ++ AV_PIX_FMT_Y212BE, ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian ++ AV_PIX_FMT_Y212LE, ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian ++ ++ AV_PIX_FMT_XV30BE, ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined ++ AV_PIX_FMT_XV30LE, ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined ++ ++ AV_PIX_FMT_XV36BE, ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined ++ AV_PIX_FMT_XV36LE, ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined ++ ++ AV_PIX_FMT_RGBF32BE, ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian ++ AV_PIX_FMT_RGBF32LE, ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian ++ ++ AV_PIX_FMT_RGBAF32BE, ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian ++ AV_PIX_FMT_RGBAF32LE, ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian ++ ++ AV_PIX_FMT_P212BE, ///< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian ++ AV_PIX_FMT_P212LE, ///< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian ++ ++ AV_PIX_FMT_P412BE, ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian ++ AV_PIX_FMT_P412LE, ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian ++ ++ AV_PIX_FMT_GBRAP14BE, ///< planar GBR 4:4:4:4 56bpp, big-endian ++ AV_PIX_FMT_GBRAP14LE, ///< planar GBR 4:4:4:4 56bpp, little-endian ++ ++ /** ++ * Hardware surfaces for Direct3D 12. ++ * ++ * data[0] points to an AVD3D12VAFrame ++ */ ++ AV_PIX_FMT_D3D12, ++ ++ AV_PIX_FMT_AYUV, ///< packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV... ++ ++ AV_PIX_FMT_UYVA, ///< packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA... ++ ++ AV_PIX_FMT_VYU444, ///< packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU... ++ ++ AV_PIX_FMT_V30XBE, ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), big-endian ++ AV_PIX_FMT_V30XLE, ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian ++ ++ AV_PIX_FMT_RGBF16BE, ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., big-endian ++ AV_PIX_FMT_RGBF16LE, ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., little-endian ++ ++ AV_PIX_FMT_RGBA128BE, ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian ++ AV_PIX_FMT_RGBA128LE, ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian ++ ++ AV_PIX_FMT_RGB96BE, ///< packed RGBA 32:32:32, 96bpp, RGBRGB..., big-endian ++ AV_PIX_FMT_RGB96LE, ///< packed RGBA 32:32:32, 96bpp, RGBRGB..., little-endian ++ ++ AV_PIX_FMT_Y216BE, ///< packed YUV 4:2:2 like YUYV422, 32bpp, big-endian ++ AV_PIX_FMT_Y216LE, ///< packed YUV 4:2:2 like YUYV422, 32bpp, little-endian ++ ++ AV_PIX_FMT_XV48BE, ///< packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefined ++ AV_PIX_FMT_XV48LE, ///< packed XVYU 4:4:4, 64bpp, little-endian, variant of Y416 where alpha channel is left undefined ++ ++ AV_PIX_FMT_GBRPF16BE, ///< IEEE-754 half precision planer GBR 4:4:4, 48bpp, big-endian ++ AV_PIX_FMT_GBRPF16LE, ///< IEEE-754 half precision planer GBR 4:4:4, 48bpp, little-endian ++ AV_PIX_FMT_GBRAPF16BE, ///< IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian ++ AV_PIX_FMT_GBRAPF16LE, ///< IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian ++ ++ AV_PIX_FMT_GRAYF16BE, ///< IEEE-754 half precision Y, 16bpp, big-endian ++ AV_PIX_FMT_GRAYF16LE, ///< IEEE-754 half precision Y, 16bpp, little-endian ++ ++ /** ++ * HW acceleration through AMF. data[0] contain AMFSurface pointer ++ */ ++ AV_PIX_FMT_AMF_SURFACE, ++ ++ AV_PIX_FMT_GRAY32BE, ///< Y , 32bpp, big-endian ++ AV_PIX_FMT_GRAY32LE, ///< Y , 32bpp, little-endian ++ ++ AV_PIX_FMT_YAF32BE, ///< IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, big-endian ++ AV_PIX_FMT_YAF32LE, ///< IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, little-endian ++ ++ AV_PIX_FMT_YAF16BE, ///< IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, big-endian ++ AV_PIX_FMT_YAF16LE, ///< IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, little-endian ++ ++ AV_PIX_FMT_GBRAP32BE, ///< planar GBRA 4:4:4:4 128bpp, big-endian ++ AV_PIX_FMT_GBRAP32LE, ///< planar GBRA 4:4:4:4 128bpp, little-endian ++ ++ AV_PIX_FMT_YUV444P10MSBBE, ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian ++ AV_PIX_FMT_YUV444P10MSBLE, ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian ++ AV_PIX_FMT_YUV444P12MSBBE, ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian ++ AV_PIX_FMT_YUV444P12MSBLE, ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian ++ AV_PIX_FMT_GBRP10MSBBE, ///< planar GBR 4:4:4 30bpp, lowest bits zero, big-endian ++ AV_PIX_FMT_GBRP10MSBLE, ///< planar GBR 4:4:4 30bpp, lowest bits zero, little-endian ++ AV_PIX_FMT_GBRP12MSBBE, ///< planar GBR 4:4:4 36bpp, lowest bits zero, big-endian ++ AV_PIX_FMT_GBRP12MSBLE, ///< planar GBR 4:4:4 36bpp, lowest bits zero, little-endian ++ ++ AV_PIX_FMT_OHCODEC, /// hardware decoding through openharmony ++ ++ /** ++ * CUDA block-linear (opaque). data[0] is a CUarray in block-linear layout, ++ * e.g. from NVDEC opaque decode. Use for zero-copy to NVENC (CUDA array input). ++ */ ++ AV_PIX_FMT_CUARRAY, ++ ++ 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 ++}; ++ ++#if AV_HAVE_BIGENDIAN ++# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##be ++#else ++# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le ++#endif ++ ++#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA) ++#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR) ++#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA) ++#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB) ++#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0) ++#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0) ++ ++#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE) ++#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE) ++#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE) ++#define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE) ++#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE) ++#define AV_PIX_FMT_GRAY32 AV_PIX_FMT_NE(GRAY32BE, GRAY32LE) ++#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE) ++#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE) ++#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE) ++#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE) ++#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE) ++#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE) ++#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE) ++#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE) ++#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE) ++#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE) ++#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE) ++ ++#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE) ++#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE) ++#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE) ++#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE) ++#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE) ++#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE) ++#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE) ++#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE) ++#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE) ++#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE) ++#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE) ++#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE) ++#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE) ++#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE) ++#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE) ++#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE) ++#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE) ++ ++#define AV_PIX_FMT_YUV444P10MSB AV_PIX_FMT_NE(YUV444P10MSBBE, YUV444P10MSBLE) ++#define AV_PIX_FMT_YUV444P12MSB AV_PIX_FMT_NE(YUV444P12MSBBE, YUV444P12MSBLE) ++ ++#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE) ++#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE) ++#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE) ++#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE) ++#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE) ++#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE) ++#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE) ++#define AV_PIX_FMT_GBRAP14 AV_PIX_FMT_NE(GBRAP14BE, GBRAP14LE) ++#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE) ++#define AV_PIX_FMT_GBRAP32 AV_PIX_FMT_NE(GBRAP32BE, GBRAP32LE) ++ ++#define AV_PIX_FMT_GBRP10MSB AV_PIX_FMT_NE(GBRP10MSBBE, GBRP10MSBLE) ++#define AV_PIX_FMT_GBRP12MSB AV_PIX_FMT_NE(GBRP12MSBBE, GBRP12MSBLE) ++ ++#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE) ++#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE) ++#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE) ++#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE) ++ ++#define AV_PIX_FMT_GBRPF16 AV_PIX_FMT_NE(GBRPF16BE, GBRPF16LE) ++#define AV_PIX_FMT_GBRAPF16 AV_PIX_FMT_NE(GBRAPF16BE, GBRAPF16LE) ++#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE) ++#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE) ++ ++#define AV_PIX_FMT_GRAYF16 AV_PIX_FMT_NE(GRAYF16BE, GRAYF16LE) ++#define AV_PIX_FMT_GRAYF32 AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE) ++ ++#define AV_PIX_FMT_YAF16 AV_PIX_FMT_NE(YAF16BE, YAF16LE) ++#define AV_PIX_FMT_YAF32 AV_PIX_FMT_NE(YAF32BE, YAF32LE) ++ ++#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE) ++#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE) ++#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE) ++#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE) ++#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE) ++#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE) ++#define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE) ++#define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE) ++#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE) ++#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE) ++#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE) ++ ++#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE) ++#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE) ++#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE) ++#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE) ++#define AV_PIX_FMT_P012 AV_PIX_FMT_NE(P012BE, P012LE) ++#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE) ++ ++#define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE) ++#define AV_PIX_FMT_Y212 AV_PIX_FMT_NE(Y212BE, Y212LE) ++#define AV_PIX_FMT_Y216 AV_PIX_FMT_NE(Y216BE, Y216LE) ++#define AV_PIX_FMT_XV30 AV_PIX_FMT_NE(XV30BE, XV30LE) ++#define AV_PIX_FMT_XV36 AV_PIX_FMT_NE(XV36BE, XV36LE) ++#define AV_PIX_FMT_XV48 AV_PIX_FMT_NE(XV48BE, XV48LE) ++#define AV_PIX_FMT_V30X AV_PIX_FMT_NE(V30XBE, V30XLE) ++#define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE) ++#define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE) ++ ++#define AV_PIX_FMT_P210 AV_PIX_FMT_NE(P210BE, P210LE) ++#define AV_PIX_FMT_P410 AV_PIX_FMT_NE(P410BE, P410LE) ++#define AV_PIX_FMT_P212 AV_PIX_FMT_NE(P212BE, P212LE) ++#define AV_PIX_FMT_P412 AV_PIX_FMT_NE(P412BE, P412LE) ++#define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE) ++#define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE) ++ ++#define AV_PIX_FMT_RGBF16 AV_PIX_FMT_NE(RGBF16BE, RGBF16LE) ++#define AV_PIX_FMT_RGBAF16 AV_PIX_FMT_NE(RGBAF16BE, RGBAF16LE) ++ ++#define AV_PIX_FMT_RGBF32 AV_PIX_FMT_NE(RGBF32BE, RGBF32LE) ++#define AV_PIX_FMT_RGBAF32 AV_PIX_FMT_NE(RGBAF32BE, RGBAF32LE) ++ ++#define AV_PIX_FMT_RGB96 AV_PIX_FMT_NE(RGB96BE, RGB96LE) ++#define AV_PIX_FMT_RGBA128 AV_PIX_FMT_NE(RGBA128BE, RGBA128LE) ++ ++/** ++ * Chromaticity coordinates of the source primaries. ++ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273. ++ */ ++enum AVColorPrimaries { ++ AVCOL_PRI_RESERVED0 = 0, ++ AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B ++ AVCOL_PRI_UNSPECIFIED = 2, ++ AVCOL_PRI_RESERVED = 3, ++ AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20) ++ ++ 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, ///< identical to above, also called "SMPTE C" even though it uses D65 ++ AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C ++ AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020 ++ AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ) ++ AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428, ++ AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3 ++ AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3 ++ AVCOL_PRI_EBU3213 = 22, ///< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors ++ AVCOL_PRI_JEDEC_P22 = AVCOL_PRI_EBU3213, ++ AVCOL_PRI_NB, ///< Not part of ABI ++ ++ /* The following entries are not part of H.273, but custom extensions */ ++ AVCOL_PRI_EXT_BASE = 256, ++ AVCOL_PRI_V_GAMUT = AVCOL_PRI_EXT_BASE, ++ AVCOL_PRI_EXT_NB ///< Not part of ABI ++}; ++ ++/** ++ * Color Transfer Characteristic. ++ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2. ++ */ ++enum AVColorTransferCharacteristic { ++ AVCOL_TRC_RESERVED0 = 0, ++ AVCOL_TRC_BT709 = 1, ///< also ITU-R BT1361 ++ AVCOL_TRC_UNSPECIFIED = 2, ++ AVCOL_TRC_RESERVED = 3, ++ AVCOL_TRC_GAMMA22 = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM ++ AVCOL_TRC_GAMMA28 = 5, ///< also ITU-R BT470BG ++ AVCOL_TRC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC ++ AVCOL_TRC_SMPTE240M = 7, ++ AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics" ++ AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)" ++ AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)" ++ AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4 ++ AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut ++ AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC) ++ AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10-bit system ++ AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12-bit system ++ AVCOL_TRC_SMPTE2084 = 16, ///< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems ++ AVCOL_TRC_SMPTEST2084 = AVCOL_TRC_SMPTE2084, ++ AVCOL_TRC_SMPTE428 = 17, ///< SMPTE ST 428-1 ++ AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428, ++ AVCOL_TRC_ARIB_STD_B67 = 18, ///< ARIB STD-B67, known as "Hybrid log-gamma" ++ AVCOL_TRC_NB, ///< Not part of ABI ++ ++ /* The following entries are not part of H.273, but custom extensions */ ++ AVCOL_TRC_EXT_BASE = 256, ++ AVCOL_TRC_V_LOG = AVCOL_TRC_EXT_BASE, ++ AVCOL_TRC_EXT_NB ///< Not part of ABI ++}; ++ ++/** ++ * YUV colorspace type. ++ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3. ++ */ ++enum AVColorSpace { ++ AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1 ++ AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B ++ AVCOL_SPC_UNSPECIFIED = 2, ++ AVCOL_SPC_RESERVED = 3, ///< reserved for future use by ITU-T and ISO/IEC just like 15-255 are ++ AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20) ++ 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, ///< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries ++ AVCOL_SPC_YCGCO = 8, ///< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16 ++ AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO, ++ AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system ++ AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system ++ AVCOL_SPC_SMPTE2085 = 11, ///< SMPTE 2085, Y'D'zD'x ++ AVCOL_SPC_CHROMA_DERIVED_NCL = 12, ///< Chromaticity-derived non-constant luminance system ++ AVCOL_SPC_CHROMA_DERIVED_CL = 13, ///< Chromaticity-derived constant luminance system ++ AVCOL_SPC_ICTCP = 14, ///< ITU-R BT.2100-0, ICtCp ++ AVCOL_SPC_IPT_C2 = 15, ///< SMPTE ST 2128, IPT-C2 ++ AVCOL_SPC_YCGCO_RE = 16, ///< YCgCo-R, even addition of bits ++ AVCOL_SPC_YCGCO_RO = 17, ///< YCgCo-R, odd addition of bits ++ AVCOL_SPC_NB ///< Not part of ABI ++}; ++ ++/** ++ * Visual content value range. ++ * ++ * These values are based on definitions that can be found in multiple ++ * specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance ++ * and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital ++ * Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit ++ * integer representation). At the time of writing, the BT.2100 one is ++ * recommended, as it also defines the full range representation. ++ * ++ * Common definitions: ++ * - For RGB and luma planes such as Y in YCbCr and I in ICtCp, ++ * 'E' is the original value in range of 0.0 to 1.0. ++ * - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original ++ * value in range of -0.5 to 0.5. ++ * - 'n' is the output bit depth. ++ * - For additional definitions such as rounding and clipping to valid n ++ * bit unsigned integer range, please refer to BT.2100 (Table 9). ++ */ ++enum AVColorRange { ++ AVCOL_RANGE_UNSPECIFIED = 0, ++ ++ /** ++ * Narrow or limited range content. ++ * ++ * - For luma planes: ++ * ++ * (219 * E + 16) * 2^(n-8) ++ * ++ * F.ex. the range of 16-235 for 8 bits ++ * ++ * - For chroma planes: ++ * ++ * (224 * E + 128) * 2^(n-8) ++ * ++ * F.ex. the range of 16-240 for 8 bits ++ */ ++ AVCOL_RANGE_MPEG = 1, ++ ++ /** ++ * Full range content. ++ * ++ * - For RGB and luma planes: ++ * ++ * (2^n - 1) * E ++ * ++ * F.ex. the range of 0-255 for 8 bits ++ * ++ * - For chroma planes: ++ * ++ * (2^n - 1) * E + 2^(n - 1) ++ * ++ * F.ex. the range of 1-255 for 8 bits ++ */ ++ AVCOL_RANGE_JPEG = 2, ++ AVCOL_RANGE_NB ///< Not part of ABI ++}; ++ ++/** ++ * Location of chroma samples. ++ * ++ * Illustration showing the location of the first (top left) chroma sample of the ++ * image, the left shows only luma, the right ++ * shows the location of the chroma sample, the 2 could be imagined to overlay ++ * each other but are drawn separately due to limitations of ASCII ++ * ++ * 1st 2nd 1st 2nd horizontal luma sample positions ++ * v v v v ++ * ______ ______ ++ *1st luma line > |X X ... |3 4 X ... X are luma samples, ++ * | |1 2 1-6 are possible chroma positions ++ *2nd luma line > |X X ... |5 6 X ... 0 is undefined/unknown position ++ */ ++enum AVChromaLocation { ++ AVCHROMA_LOC_UNSPECIFIED = 0, ++ AVCHROMA_LOC_LEFT = 1, ///< MPEG-2/4 4:2:0, H.264 default for 4:2:0 ++ AVCHROMA_LOC_CENTER = 2, ///< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0 ++ AVCHROMA_LOC_TOPLEFT = 3, ///< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2 ++ AVCHROMA_LOC_TOP = 4, ++ AVCHROMA_LOC_BOTTOMLEFT = 5, ++ AVCHROMA_LOC_BOTTOM = 6, ++ AVCHROMA_LOC_NB ///< Not part of ABI ++}; ++ ++/** ++ * Correlation between the alpha channel and color values. ++ */ ++enum AVAlphaMode { ++ AVALPHA_MODE_UNSPECIFIED = 0, ///< Unknown alpha handling, or no alpha channel ++ AVALPHA_MODE_PREMULTIPLIED = 1, ///< Alpha channel is multiplied into color values ++ AVALPHA_MODE_STRAIGHT = 2, ///< Alpha channel is independent of color values ++ AVALPHA_MODE_NB ///< Not part of ABI ++}; ++ ++#endif /* AVUTIL_PIXFMT_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/rational.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/rational.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/rational.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/rational.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/samplefmt.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/samplefmt.h +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg62/include/libavutil/samplefmt.h +copy to dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/samplefmt.h +diff --git a/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/version.h b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/version.h +new file mode 100644 +index 000000000000..d5bf20cf8975 +--- /dev/null ++++ b/dom/media/platforms/ffmpeg/ffmpeg63/include/libavutil/version.h +@@ -0,0 +1,118 @@ ++/* ++ * copyright (c) 2003 Fabrice Bellard ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/** ++ * @file ++ * @ingroup lavu ++ * Libavutil version macros ++ */ ++ ++#ifndef AVUTIL_VERSION_H ++#define AVUTIL_VERSION_H ++ ++#include "macros.h" ++ ++/** ++ * @addtogroup version_utils ++ * ++ * Useful to check and match library version in order to maintain ++ * backward compatibility. ++ * ++ * The FFmpeg libraries follow a versioning scheme very similar to ++ * Semantic Versioning (http://semver.org/) ++ * The difference is that the component called PATCH is called MICRO in FFmpeg ++ * and its value is reset to 100 instead of 0 to keep it above or equal to 100. ++ * Also we do not increase MICRO for every bugfix or change in git master. ++ * ++ * Prior to FFmpeg 3.2 point releases did not change any lib version number to ++ * avoid aliassing different git master checkouts. ++ * Starting with FFmpeg 3.2, the released library versions will occupy ++ * a separate MAJOR.MINOR that is not used on the master development branch. ++ * That is if we branch a release of master 55.10.123 we will bump to 55.11.100 ++ * for the release and master will continue at 55.12.100 after it. Each new ++ * point release will then bump the MICRO improving the usefulness of the lib ++ * versions. ++ * ++ * @{ ++ */ ++ ++#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c)) ++#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c ++#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c) ++ ++/** ++ * Extract version components from the full ::AV_VERSION_INT int as returned ++ * by functions like ::avformat_version() and ::avcodec_version() ++ */ ++#define AV_VERSION_MAJOR(a) ((a) >> 16) ++#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8) ++#define AV_VERSION_MICRO(a) ((a) & 0xFF) ++ ++/** ++ * @} ++ */ ++ ++/** ++ * @defgroup lavu_ver Version and Build diagnostics ++ * ++ * Macros and function useful to check at compile time and at runtime ++ * which version of libavutil is in use. ++ * ++ * @{ ++ */ ++ ++#define LIBAVUTIL_VERSION_MAJOR 61 ++#define LIBAVUTIL_VERSION_MINOR 5 ++#define LIBAVUTIL_VERSION_MICRO 100 ++ ++#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ ++ LIBAVUTIL_VERSION_MINOR, \ ++ LIBAVUTIL_VERSION_MICRO) ++#define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \ ++ LIBAVUTIL_VERSION_MINOR, \ ++ LIBAVUTIL_VERSION_MICRO) ++#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT ++ ++#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) ++ ++/** ++ * @defgroup lavu_depr_guards Deprecation Guards ++ * FF_API_* defines may be placed below to indicate public API that will be ++ * dropped at a future version bump. The defines themselves are not part of ++ * the public API and may change, break or disappear at any time. ++ * ++ * @note, when bumping the major version it is recommended to manually ++ * disable each FF_API_* in its own commit instead of disabling them all ++ * at once through the bump. This improves the git bisect-ability of the change. ++ * ++ * @{ ++ */ ++ ++#define FF_API_CPU_FLAG_FORCE (LIBAVUTIL_VERSION_MAJOR < 62) ++#define FF_API_DOVI_L11_INVALID_PROPS (LIBAVUTIL_VERSION_MAJOR < 62) ++#define FF_API_ASSERT_FPU (LIBAVUTIL_VERSION_MAJOR < 62) ++#define FF_API_VULKAN_SYNC_QUEUES (LIBAVUTIL_VERSION_MAJOR < 62) ++ ++/** ++ * @} ++ * @} ++ */ ++ ++#endif /* AVUTIL_VERSION_H */ +diff --git a/dom/media/platforms/ffmpeg/ffmpeg61/moz.build b/dom/media/platforms/ffmpeg/ffmpeg63/moz.build +similarity index 100% +copy from dom/media/platforms/ffmpeg/ffmpeg61/moz.build +copy to dom/media/platforms/ffmpeg/ffmpeg63/moz.build +diff --git a/dom/media/platforms/ffmpeg/moz.build b/dom/media/platforms/ffmpeg/moz.build +index 48baf252f1ba..921a31688389 100644 +--- a/dom/media/platforms/ffmpeg/moz.build ++++ b/dom/media/platforms/ffmpeg/moz.build +@@ -16,6 +16,7 @@ DIRS += [ + "ffmpeg60", + "ffmpeg61", + "ffmpeg62", ++ "ffmpeg63", + ] + + UNIFIED_SOURCES += ["FFmpegRuntimeLinker.cpp"] +diff --git a/tools/rewriting/ThirdPartyPaths.txt b/tools/rewriting/ThirdPartyPaths.txt +index 3a7b65ea26a4..9e3b38290dbf 100644 +--- a/tools/rewriting/ThirdPartyPaths.txt ++++ b/tools/rewriting/ThirdPartyPaths.txt +@@ -35,6 +35,7 @@ dom/media/platforms/ffmpeg/ffmpeg59/ + dom/media/platforms/ffmpeg/ffmpeg60/ + dom/media/platforms/ffmpeg/ffmpeg61/ + dom/media/platforms/ffmpeg/ffmpeg62/ ++dom/media/platforms/ffmpeg/ffmpeg63/ + dom/media/platforms/ffmpeg/libav53/ + dom/media/platforms/ffmpeg/libav54/ + dom/media/platforms/ffmpeg/libav55/ diff --git a/src/external-patches/manifest.json b/src/external-patches/manifest.json index bcc92b779..bd0a21c02 100644 --- a/src/external-patches/manifest.json +++ b/src/external-patches/manifest.json @@ -48,5 +48,11 @@ "D312091" ], "name": "Expose tiled attribute to all platforms" + }, + { + "type": "patch", + "url": "https://gitlab.archlinux.org/archlinux/packaging/packages/firefox/-/raw/main/0002-Bug-2057577-DOM-Media-Add-FFmpeg-63-support.-r-alwu-.patch", + "dest": "firefox", + "filename": "bug-2057577-ffmpeg-63-support.patch" } ]