Merge mozilla-central to inbound a=merge on a CLOSED TREE

--HG--
extra : amend_source : fe224af87d863a8482fa90b6108ef3c5c93391f9

devtools/client/aboutdebugging-new/src/modules/extensions-helper.js

@@ -18,38 +18,8 @@ loader.lazyRequireGetter(
   true
 );
 
-const { Toolbox } = require("devtools/client/framework/toolbox");
-const { gDevTools } = require("devtools/client/framework/devtools");
-
 const { PREFERENCES } = require("../constants");
 
-let addonToolbox = null;
-
-/**
- * Start debugging an addon.
- *
- * @param {String} id
- *        The addon id to debug.
- * @param {DebuggerClient} client
- *        Required for debugging.
- */
-exports.debugAddon = async function(id, client) {
-  const addonFront = await client.mainRoot.getAddon({ id });
-
-  const target = await addonFront.connect();
-
-  // Close previous addon debugging toolbox.
-  if (addonToolbox) {
-    addonToolbox.destroy();
-  }
-
-  const hostType = Toolbox.HostType.WINDOW;
-  addonToolbox = await gDevTools.showToolbox(target, null, hostType);
-  addonToolbox.once("destroy", () => {
-    addonToolbox = null;
-  });
-};
-
 /**
  * Uninstall the addon with the provided id.
  * Resolves when the addon shutdown has completed.

devtools/client/inspector/fonts/components/FontPropertyValue.js

@@ -150,7 +150,11 @@ class FontPropertyValue extends PureComponent {
       value = this.state.initialValue;
     }
 
-    this.updateValue(value);
+    // Avoid updating the value if a keyword value like "normal" is present
+    if (!this.props.valueLabel) {
+      this.updateValue(value);
+    }
+
     this.toggleInteractiveState(false);
   }
 

devtools/server/actors/styles.js

@@ -1595,8 +1595,8 @@ var StyleRuleActor = protocol.ActorClassWithSpec(styleRuleSpec, {
       text = `${selectorText} {${ruleBodyText}}`;
     }
 
-    const prettyCSS = prettifyCSS(text);
+    const { result } = prettifyCSS(text);
-    return Promise.resolve(prettyCSS);
+    return Promise.resolve(result);
   },
 
   /**

devtools/server/tests/browser/browser.ini

@@ -138,6 +138,7 @@ fail-if = fission
 fail-if = fission
 [browser_storage_updates.js]
 fail-if = fission
+[browser_styles_getRuleText.js]
 [browser_stylesheets_getTextEmpty.js]
 [browser_stylesheets_nested-iframes.js]
 [browser_register_actor.js]

devtools/server/tests/browser/browser_styles_getRuleText.js

@@ -0,0 +1,35 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Test that StyleRuleActor.getRuleText returns the contents of the CSS rule.
+
+const CSS_RULE = `#test {
+  background-color: #f06;
+}`;
+
+const CONTENT = `
+  <style type='text/css'>
+    ${CSS_RULE}
+  </style>
+  <div id="test"></div>
+`;
+
+const TEST_URI = `data:text/html;charset=utf-8,${encodeURIComponent(CONTENT)}`;
+
+add_task(async function() {
+  const { inspector, target, walker } = await initInspectorFront(TEST_URI);
+
+  const pageStyle = await inspector.getPageStyle();
+  const element = await walker.querySelector(walker.rootNode, "#test");
+  const entries = await pageStyle.getApplied(element, { inherited: false });
+
+  const rule = entries[1].rule;
+  const text = await rule.getRuleText();
+
+  is(text, CSS_RULE, "CSS rule text content matches");
+
+  await target.destroy();
+});

dom/media/Benchmark.cpp

@@ -240,6 +240,11 @@ void BenchmarkPlayback::DemuxNextSample() {
 void BenchmarkPlayback::InitDecoder(UniquePtr<TrackInfo>&& aInfo) {
   MOZ_ASSERT(OnThread());
 
+  if (!aInfo) {
+    Error(MediaResult(NS_ERROR_FAILURE, "Invalid TrackInfo"));
+    return;
+  }
+
   RefPtr<PDMFactory> platform = new PDMFactory();
   mInfo = std::move(aInfo);
   mDecoder = platform->CreateDecoder({*mInfo, mDecoderTaskQueue});

dom/xhr/XMLHttpRequestMainThread.h

@@ -526,7 +526,29 @@ class XMLHttpRequestMainThread final : public XMLHttpRequest,
       }
 
       bool operator<(const HeaderEntry& aOther) const {
-        return mName < aOther.mName;
+        if (!IsLowercaseResponseHeader()) {
+          return mName < aOther.mName;
+        }
+        uint32_t selfLen = mName.Length();
+        uint32_t otherLen = aOther.mName.Length();
+        uint32_t min = XPCOM_MIN(selfLen, otherLen);
+        for (uint32_t i = 0; i < min; ++i) {
+          unsigned char self = mName[i];
+          unsigned char other = aOther.mName[i];
+          MOZ_ASSERT(!(self >= 'A' && self <= 'Z'));
+          MOZ_ASSERT(!(other >= 'A' && other <= 'Z'));
+          if (self == other) {
+            continue;
+          }
+          if (self >= 'a' && self <= 'z') {
+            self -= 0x20;
+          }
+          if (other >= 'a' && other <= 'z') {
+            other -= 0x20;
+          }
+          return self < other;
+        }
+        return selfLen < otherLen;
       }
     };
 

layout/style/FontFace.cpp

@@ -82,6 +82,8 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(FontFace)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLoaded)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFontFaceSet)
+  tmp->mInFontFaceSet = false;
+  tmp->SetUserFontEntry(nullptr);
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mOtherFontFaceSets)
   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

media/ffvpx/libavcodec/dummy_funcs.c

@@ -1,852 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim:set ts=2 sw=2 sts=2 et cindent: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "avcodec.h"
-
-typedef struct FFTContext FFTContext;
-typedef struct H264PredContext H264PredContext;
-typedef struct RDFTContext RDFTContext;
-typedef struct VideoDSPContext VideoDSPContext;
-typedef struct VP8DSPContext VP8DSPContext;
-typedef struct VP9DSPContext VP9DSPContext;
-typedef struct FLACDSPContext FLACDSPContext;
-
-AVHWAccel ff_h263_vaapi_hwaccel;
-AVHWAccel ff_h263_videotoolbox_hwaccel;
-AVHWAccel ff_h264_d3d11va_hwaccel;
-AVHWAccel ff_h264_dxva2_hwaccel;
-AVHWAccel ff_h264_vaapi_hwaccel;
-AVHWAccel ff_h264_vdpau_hwaccel;
-AVHWAccel ff_h264_videotoolbox_hwaccel;
-AVHWAccel ff_hevc_d3d11va_hwaccel;
-AVHWAccel ff_hevc_dxva2_hwaccel;
-AVHWAccel ff_hevc_vaapi_hwaccel;
-AVHWAccel ff_hevc_vdpau_hwaccel;
-AVHWAccel ff_mpeg1_xvmc_hwaccel;
-AVHWAccel ff_mpeg1_vdpau_hwaccel;
-AVHWAccel ff_mpeg1_videotoolbox_hwaccel;
-AVHWAccel ff_mpeg2_xvmc_hwaccel;
-AVHWAccel ff_mpeg2_d3d11va_hwaccel;
-AVHWAccel ff_mpeg2_dxva2_hwaccel;
-AVHWAccel ff_mpeg2_vaapi_hwaccel;
-AVHWAccel ff_mpeg2_vdpau_hwaccel;
-AVHWAccel ff_mpeg2_videotoolbox_hwaccel;
-AVHWAccel ff_mpeg4_vaapi_hwaccel;
-AVHWAccel ff_mpeg4_vdpau_hwaccel;
-AVHWAccel ff_mpeg4_videotoolbox_hwaccel;
-AVHWAccel ff_vc1_d3d11va_hwaccel;
-AVHWAccel ff_vc1_dxva2_hwaccel;
-AVHWAccel ff_vc1_vaapi_hwaccel;
-AVHWAccel ff_vc1_vdpau_hwaccel;
-AVHWAccel ff_wmv3_d3d11va_hwaccel;
-AVHWAccel ff_wmv3_dxva2_hwaccel;
-AVHWAccel ff_wmv3_vaapi_hwaccel;
-AVHWAccel ff_wmv3_vdpau_hwaccel;
-AVHWAccel ff_vp9_d3d11va_hwaccel;
-AVHWAccel ff_vp9_dxva2_hwaccel;
-AVHWAccel ff_vp9_vaapi_hwaccel;
-/* Added by FFmpeg 3.4 */
-AVHWAccel ff_h264_d3d11va2_hwaccel;
-AVHWAccel ff_hevc_d3d11va2_hwaccel;
-AVHWAccel ff_hevc_videotoolbox_hwaccel;
-AVHWAccel ff_mpeg2_d3d11va2_hwaccel;
-AVHWAccel ff_vc1_d3d11va2_hwaccel;
-AVHWAccel ff_vp9_d3d11va2_hwaccel;
-AVHWAccel ff_wmv3_d3d11va2_hwaccel;
-
-AVCodec ff_a64multi_encoder;
-AVCodec ff_a64multi5_encoder;
-AVCodec ff_aasc_decoder;
-AVCodec ff_aic_decoder;
-AVCodec ff_alias_pix_encoder;
-AVCodec ff_alias_pix_decoder;
-AVCodec ff_amv_encoder;
-AVCodec ff_amv_decoder;
-AVCodec ff_anm_decoder;
-AVCodec ff_ansi_decoder;
-AVCodec ff_apng_encoder;
-AVCodec ff_apng_decoder;
-AVCodec ff_asv1_encoder;
-AVCodec ff_asv1_decoder;
-AVCodec ff_asv2_encoder;
-AVCodec ff_asv2_decoder;
-AVCodec ff_aura_decoder;
-AVCodec ff_aura2_decoder;
-AVCodec ff_avrp_encoder;
-AVCodec ff_avrp_decoder;
-AVCodec ff_avrn_decoder;
-AVCodec ff_avs_decoder;
-AVCodec ff_avui_encoder;
-AVCodec ff_avui_decoder;
-AVCodec ff_ayuv_encoder;
-AVCodec ff_ayuv_decoder;
-AVCodec ff_bethsoftvid_decoder;
-AVCodec ff_bfi_decoder;
-AVCodec ff_bink_decoder;
-AVCodec ff_bmp_encoder;
-AVCodec ff_bmp_decoder;
-AVCodec ff_bmv_video_decoder;
-AVCodec ff_brender_pix_decoder;
-AVCodec ff_c93_decoder;
-AVCodec ff_cavs_decoder;
-AVCodec ff_cdgraphics_decoder;
-AVCodec ff_cdxl_decoder;
-AVCodec ff_cfhd_decoder;
-AVCodec ff_cinepak_encoder;
-AVCodec ff_cinepak_decoder;
-AVCodec ff_cljr_encoder;
-AVCodec ff_cljr_decoder;
-AVCodec ff_cllc_decoder;
-AVCodec ff_comfortnoise_encoder;
-AVCodec ff_comfortnoise_decoder;
-AVCodec ff_cpia_decoder;
-AVCodec ff_cscd_decoder;
-AVCodec ff_cyuv_decoder;
-AVCodec ff_dds_decoder;
-AVCodec ff_dfa_decoder;
-AVCodec ff_dirac_decoder;
-AVCodec ff_dnxhd_encoder;
-AVCodec ff_dnxhd_decoder;
-AVCodec ff_dpx_encoder;
-AVCodec ff_dpx_decoder;
-AVCodec ff_dsicinvideo_decoder;
-AVCodec ff_dvaudio_decoder;
-AVCodec ff_dvvideo_encoder;
-AVCodec ff_dvvideo_decoder;
-AVCodec ff_dxa_decoder;
-AVCodec ff_dxtory_decoder;
-AVCodec ff_eacmv_decoder;
-AVCodec ff_eamad_decoder;
-AVCodec ff_eatgq_decoder;
-AVCodec ff_eatgv_decoder;
-AVCodec ff_eatqi_decoder;
-AVCodec ff_eightbps_decoder;
-AVCodec ff_eightsvx_exp_decoder;
-AVCodec ff_eightsvx_fib_decoder;
-AVCodec ff_escape124_decoder;
-AVCodec ff_escape130_decoder;
-AVCodec ff_exr_decoder;
-AVCodec ff_ffv1_encoder;
-AVCodec ff_ffv1_decoder;
-AVCodec ff_ffvhuff_encoder;
-AVCodec ff_ffvhuff_decoder;
-AVCodec ff_fic_decoder;
-AVCodec ff_flashsv_encoder;
-AVCodec ff_flashsv_decoder;
-AVCodec ff_flashsv2_encoder;
-AVCodec ff_flashsv2_decoder;
-AVCodec ff_flic_decoder;
-AVCodec ff_flv_encoder;
-AVCodec ff_flv_decoder;
-AVCodec ff_fourxm_decoder;
-AVCodec ff_fraps_decoder;
-AVCodec ff_frwu_decoder;
-AVCodec ff_g2m_decoder;
-AVCodec ff_gif_encoder;
-AVCodec ff_gif_decoder;
-AVCodec ff_h261_encoder;
-AVCodec ff_h261_decoder;
-AVCodec ff_h263_encoder;
-AVCodec ff_h263_decoder;
-AVCodec ff_h263i_decoder;
-AVCodec ff_h263p_encoder;
-AVCodec ff_h263p_decoder;
-AVCodec ff_h264_decoder;
-AVCodec ff_h264_crystalhd_decoder;
-AVCodec ff_h264_mmal_decoder;
-AVCodec ff_h264_qsv_decoder;
-AVCodec ff_hap_encoder;
-AVCodec ff_hap_decoder;
-AVCodec ff_hevc_decoder;
-AVCodec ff_hevc_qsv_decoder;
-AVCodec ff_hnm4_video_decoder;
-AVCodec ff_hq_hqa_decoder;
-AVCodec ff_hqx_decoder;
-AVCodec ff_huffyuv_encoder;
-AVCodec ff_huffyuv_decoder;
-AVCodec ff_idcin_decoder;
-AVCodec ff_iff_byterun1_decoder;
-AVCodec ff_iff_ilbm_decoder;
-AVCodec ff_indeo2_decoder;
-AVCodec ff_indeo3_decoder;
-AVCodec ff_indeo4_decoder;
-AVCodec ff_indeo5_decoder;
-AVCodec ff_interplay_video_decoder;
-AVCodec ff_jpeg2000_encoder;
-AVCodec ff_jpeg2000_decoder;
-AVCodec ff_jpegls_encoder;
-AVCodec ff_jpegls_decoder;
-AVCodec ff_jv_decoder;
-AVCodec ff_kgv1_decoder;
-AVCodec ff_kmvc_decoder;
-AVCodec ff_lagarith_decoder;
-AVCodec ff_ljpeg_encoder;
-AVCodec ff_loco_decoder;
-AVCodec ff_mdec_decoder;
-AVCodec ff_mimic_decoder;
-AVCodec ff_mjpeg_encoder;
-AVCodec ff_mjpeg_decoder;
-AVCodec ff_mjpegb_decoder;
-AVCodec ff_mmvideo_decoder;
-AVCodec ff_motionpixels_decoder;
-AVCodec ff_mpeg1video_encoder;
-AVCodec ff_mpeg1video_decoder;
-AVCodec ff_mpeg2video_encoder;
-AVCodec ff_mpeg2video_decoder;
-AVCodec ff_mpeg4_encoder;
-AVCodec ff_mpeg4_decoder;
-AVCodec ff_mpeg4_crystalhd_decoder;
-AVCodec ff_mpeg4_mmal_decoder;
-AVCodec ff_mpegvideo_decoder;
-AVCodec ff_mpeg2_crystalhd_decoder;
-AVCodec ff_mpeg2_qsv_decoder;
-AVCodec ff_msa1_decoder;
-AVCodec ff_msmpeg4_crystalhd_decoder;
-AVCodec ff_msmpeg4v1_decoder;
-AVCodec ff_msmpeg4v2_encoder;
-AVCodec ff_msmpeg4v2_decoder;
-AVCodec ff_msmpeg4v3_encoder;
-AVCodec ff_msmpeg4v3_decoder;
-AVCodec ff_msrle_decoder;
-AVCodec ff_mss1_decoder;
-AVCodec ff_mss2_decoder;
-AVCodec ff_msvideo1_encoder;
-AVCodec ff_msvideo1_decoder;
-AVCodec ff_mszh_decoder;
-AVCodec ff_mts2_decoder;
-AVCodec ff_mvc1_decoder;
-AVCodec ff_mvc2_decoder;
-AVCodec ff_mxpeg_decoder;
-AVCodec ff_nuv_decoder;
-AVCodec ff_paf_video_decoder;
-AVCodec ff_pam_encoder;
-AVCodec ff_pam_decoder;
-AVCodec ff_pbm_encoder;
-AVCodec ff_pbm_decoder;
-AVCodec ff_pcx_encoder;
-AVCodec ff_pcx_decoder;
-AVCodec ff_pgm_encoder;
-AVCodec ff_pgm_decoder;
-AVCodec ff_pgmyuv_encoder;
-AVCodec ff_pgmyuv_decoder;
-AVCodec ff_pictor_decoder;
-AVCodec ff_png_encoder;
-AVCodec ff_png_decoder;
-AVCodec ff_ppm_encoder;
-AVCodec ff_ppm_decoder;
-AVCodec ff_prores_encoder;
-AVCodec ff_prores_decoder;
-AVCodec ff_prores_aw_encoder;
-AVCodec ff_prores_ks_encoder;
-AVCodec ff_prores_lgpl_decoder;
-AVCodec ff_ptx_decoder;
-AVCodec ff_qdraw_decoder;
-AVCodec ff_qpeg_decoder;
-AVCodec ff_qtrle_encoder;
-AVCodec ff_qtrle_decoder;
-AVCodec ff_r10k_encoder;
-AVCodec ff_r10k_decoder;
-AVCodec ff_r210_encoder;
-AVCodec ff_r210_decoder;
-AVCodec ff_rawvideo_encoder;
-AVCodec ff_rawvideo_decoder;
-AVCodec ff_rl2_decoder;
-AVCodec ff_roq_encoder;
-AVCodec ff_roq_decoder;
-AVCodec ff_rpza_decoder;
-AVCodec ff_rv10_encoder;
-AVCodec ff_rv10_decoder;
-AVCodec ff_rv20_encoder;
-AVCodec ff_rv20_decoder;
-AVCodec ff_rv30_decoder;
-AVCodec ff_rv40_decoder;
-AVCodec ff_s302m_encoder;
-AVCodec ff_s302m_decoder;
-AVCodec ff_sanm_decoder;
-AVCodec ff_sgi_encoder;
-AVCodec ff_sgi_decoder;
-AVCodec ff_sgirle_decoder;
-AVCodec ff_smacker_decoder;
-AVCodec ff_smc_decoder;
-AVCodec ff_smvjpeg_decoder;
-AVCodec ff_snow_encoder;
-AVCodec ff_snow_decoder;
-AVCodec ff_sp5x_decoder;
-AVCodec ff_sunrast_encoder;
-AVCodec ff_sunrast_decoder;
-AVCodec ff_svq1_encoder;
-AVCodec ff_svq1_decoder;
-AVCodec ff_svq3_decoder;
-AVCodec ff_targa_encoder;
-AVCodec ff_targa_decoder;
-AVCodec ff_targa_y216_decoder;
-AVCodec ff_tdsc_decoder;
-AVCodec ff_theora_decoder;
-AVCodec ff_thp_decoder;
-AVCodec ff_tiertexseqvideo_decoder;
-AVCodec ff_tiff_encoder;
-AVCodec ff_tiff_decoder;
-AVCodec ff_tmv_decoder;
-AVCodec ff_truemotion1_decoder;
-AVCodec ff_truemotion2_decoder;
-AVCodec ff_tscc_decoder;
-AVCodec ff_tscc2_decoder;
-AVCodec ff_txd_decoder;
-AVCodec ff_ulti_decoder;
-AVCodec ff_utvideo_encoder;
-AVCodec ff_utvideo_decoder;
-AVCodec ff_v210_encoder;
-AVCodec ff_v210_decoder;
-AVCodec ff_v210x_decoder;
-AVCodec ff_v308_encoder;
-AVCodec ff_v308_decoder;
-AVCodec ff_v408_encoder;
-AVCodec ff_v408_decoder;
-AVCodec ff_v410_encoder;
-AVCodec ff_v410_decoder;
-AVCodec ff_vb_decoder;
-AVCodec ff_vble_decoder;
-AVCodec ff_vc1_decoder;
-AVCodec ff_vc1_crystalhd_decoder;
-AVCodec ff_vc1image_decoder;
-AVCodec ff_vc1_qsv_decoder;
-AVCodec ff_vc2_encoder;
-AVCodec ff_vcr1_decoder;
-AVCodec ff_vmdvideo_decoder;
-AVCodec ff_vmnc_decoder;
-AVCodec ff_vp3_decoder;
-AVCodec ff_vp5_decoder;
-AVCodec ff_vp6_decoder;
-AVCodec ff_vp6a_decoder;
-AVCodec ff_vp6f_decoder;
-AVCodec ff_vp7_decoder;
-AVCodec ff_vqa_decoder;
-AVCodec ff_webp_decoder;
-AVCodec ff_wmv1_encoder;
-AVCodec ff_wmv1_decoder;
-AVCodec ff_wmv2_encoder;
-AVCodec ff_wmv2_decoder;
-AVCodec ff_wmv3_decoder;
-AVCodec ff_wmv3_crystalhd_decoder;
-AVCodec ff_wmv3image_decoder;
-AVCodec ff_wnv1_decoder;
-AVCodec ff_xan_wc3_decoder;
-AVCodec ff_xan_wc4_decoder;
-AVCodec ff_xbm_encoder;
-AVCodec ff_xbm_decoder;
-AVCodec ff_xface_encoder;
-AVCodec ff_xface_decoder;
-AVCodec ff_xl_decoder;
-AVCodec ff_xwd_encoder;
-AVCodec ff_xwd_decoder;
-AVCodec ff_y41p_encoder;
-AVCodec ff_y41p_decoder;
-AVCodec ff_yop_decoder;
-AVCodec ff_yuv4_encoder;
-AVCodec ff_yuv4_decoder;
-AVCodec ff_zero12v_decoder;
-AVCodec ff_zerocodec_decoder;
-AVCodec ff_zlib_encoder;
-AVCodec ff_zlib_decoder;
-AVCodec ff_zmbv_encoder;
-AVCodec ff_zmbv_decoder;
-AVCodec ff_aac_encoder;
-AVCodec ff_aac_decoder;
-AVCodec ff_aac_fixed_decoder;
-AVCodec ff_aac_latm_decoder;
-AVCodec ff_ac3_encoder;
-AVCodec ff_ac3_decoder;
-AVCodec ff_ac3_fixed_encoder;
-AVCodec ff_ac3_fixed_decoder;
-AVCodec ff_alac_encoder;
-AVCodec ff_alac_decoder;
-AVCodec ff_als_decoder;
-AVCodec ff_amrnb_decoder;
-AVCodec ff_amrwb_decoder;
-AVCodec ff_ape_decoder;
-AVCodec ff_atrac1_decoder;
-AVCodec ff_atrac3_decoder;
-AVCodec ff_atrac3p_decoder;
-AVCodec ff_binkaudio_dct_decoder;
-AVCodec ff_binkaudio_rdft_decoder;
-AVCodec ff_bmv_audio_decoder;
-AVCodec ff_cook_decoder;
-AVCodec ff_dca_encoder;
-AVCodec ff_dca_decoder;
-AVCodec ff_dsd_lsbf_decoder;
-AVCodec ff_dsd_msbf_decoder;
-AVCodec ff_dsd_lsbf_planar_decoder;
-AVCodec ff_dsd_msbf_planar_decoder;
-AVCodec ff_dsicinaudio_decoder;
-AVCodec ff_dss_sp_decoder;
-AVCodec ff_eac3_encoder;
-AVCodec ff_eac3_decoder;
-AVCodec ff_evrc_decoder;
-AVCodec ff_ffwavesynth_decoder;
-AVCodec ff_flac_encoder;
-AVCodec ff_g723_1_encoder;
-AVCodec ff_g723_1_decoder;
-AVCodec ff_g729_decoder;
-AVCodec ff_gsm_decoder;
-AVCodec ff_gsm_ms_decoder;
-AVCodec ff_iac_decoder;
-AVCodec ff_imc_decoder;
-AVCodec ff_mace3_decoder;
-AVCodec ff_mace6_decoder;
-AVCodec ff_metasound_decoder;
-AVCodec ff_mlp_decoder;
-AVCodec ff_mp1_decoder;
-AVCodec ff_mp1float_decoder;
-AVCodec ff_mp2_encoder;
-AVCodec ff_mp2_decoder;
-AVCodec ff_mp2float_decoder;
-AVCodec ff_mp2fixed_encoder;
-AVCodec ff_mp3_decoder;
-AVCodec ff_mp3float_decoder;
-AVCodec ff_mp3adu_decoder;
-AVCodec ff_mp3adufloat_decoder;
-AVCodec ff_mp3on4_decoder;
-AVCodec ff_mp3on4float_decoder;
-AVCodec ff_mpc7_decoder;
-AVCodec ff_mpc8_decoder;
-AVCodec ff_nellymoser_encoder;
-AVCodec ff_nellymoser_decoder;
-AVCodec ff_on2avc_decoder;
-AVCodec ff_opus_decoder;
-AVCodec ff_paf_audio_decoder;
-AVCodec ff_qcelp_decoder;
-AVCodec ff_qdm2_decoder;
-AVCodec ff_ra_144_encoder;
-AVCodec ff_ra_144_decoder;
-AVCodec ff_ra_288_decoder;
-AVCodec ff_ralf_decoder;
-AVCodec ff_shorten_decoder;
-AVCodec ff_sipr_decoder;
-AVCodec ff_smackaud_decoder;
-AVCodec ff_sonic_encoder;
-AVCodec ff_sonic_decoder;
-AVCodec ff_sonic_ls_encoder;
-AVCodec ff_tak_decoder;
-AVCodec ff_truehd_decoder;
-AVCodec ff_truespeech_decoder;
-AVCodec ff_tta_encoder;
-AVCodec ff_tta_decoder;
-AVCodec ff_twinvq_decoder;
-AVCodec ff_vmdaudio_decoder;
-AVCodec ff_vorbis_encoder;
-AVCodec ff_vorbis_decoder;
-AVCodec ff_wavpack_encoder;
-AVCodec ff_wavpack_decoder;
-AVCodec ff_wmalossless_decoder;
-AVCodec ff_wmapro_decoder;
-AVCodec ff_wmav1_encoder;
-AVCodec ff_wmav1_decoder;
-AVCodec ff_wmav2_encoder;
-AVCodec ff_wmav2_decoder;
-AVCodec ff_wmavoice_decoder;
-AVCodec ff_ws_snd1_decoder;
-AVCodec ff_pcm_alaw_encoder;
-AVCodec ff_pcm_alaw_decoder;
-AVCodec ff_pcm_bluray_decoder;
-AVCodec ff_pcm_dvd_decoder;
-AVCodec ff_pcm_f32be_encoder;
-AVCodec ff_pcm_f32be_decoder;
-AVCodec ff_pcm_f32le_encoder;
-AVCodec ff_pcm_f32le_decoder;
-AVCodec ff_pcm_f64be_encoder;
-AVCodec ff_pcm_f64be_decoder;
-AVCodec ff_pcm_f64le_encoder;
-AVCodec ff_pcm_f64le_decoder;
-AVCodec ff_pcm_lxf_decoder;
-AVCodec ff_pcm_mulaw_encoder;
-AVCodec ff_pcm_mulaw_decoder;
-AVCodec ff_pcm_s8_encoder;
-AVCodec ff_pcm_s8_decoder;
-AVCodec ff_pcm_s8_planar_encoder;
-AVCodec ff_pcm_s8_planar_decoder;
-AVCodec ff_pcm_s16be_encoder;
-AVCodec ff_pcm_s16be_decoder;
-AVCodec ff_pcm_s16be_planar_encoder;
-AVCodec ff_pcm_s16be_planar_decoder;
-AVCodec ff_pcm_s16le_encoder;
-AVCodec ff_pcm_s16le_decoder;
-AVCodec ff_pcm_s16le_planar_encoder;
-AVCodec ff_pcm_s16le_planar_decoder;
-AVCodec ff_pcm_s24be_encoder;
-AVCodec ff_pcm_s24be_decoder;
-AVCodec ff_pcm_s24daud_encoder;
-AVCodec ff_pcm_s24daud_decoder;
-AVCodec ff_pcm_s24le_encoder;
-AVCodec ff_pcm_s24le_decoder;
-AVCodec ff_pcm_s24le_planar_encoder;
-AVCodec ff_pcm_s24le_planar_decoder;
-AVCodec ff_pcm_s32be_encoder;
-AVCodec ff_pcm_s32be_decoder;
-AVCodec ff_pcm_s32le_encoder;
-AVCodec ff_pcm_s32le_decoder;
-AVCodec ff_pcm_s32le_planar_encoder;
-AVCodec ff_pcm_s32le_planar_decoder;
-AVCodec ff_pcm_u8_encoder;
-AVCodec ff_pcm_u8_decoder;
-AVCodec ff_pcm_u16be_encoder;
-AVCodec ff_pcm_u16be_decoder;
-AVCodec ff_pcm_u16le_encoder;
-AVCodec ff_pcm_u16le_decoder;
-AVCodec ff_pcm_u24be_encoder;
-AVCodec ff_pcm_u24be_decoder;
-AVCodec ff_pcm_u24le_encoder;
-AVCodec ff_pcm_u24le_decoder;
-AVCodec ff_pcm_u32be_encoder;
-AVCodec ff_pcm_u32be_decoder;
-AVCodec ff_pcm_u32le_encoder;
-AVCodec ff_pcm_u32le_decoder;
-AVCodec ff_pcm_zork_decoder;
-AVCodec ff_interplay_dpcm_decoder;
-AVCodec ff_roq_dpcm_encoder;
-AVCodec ff_roq_dpcm_decoder;
-AVCodec ff_sol_dpcm_decoder;
-AVCodec ff_xan_dpcm_decoder;
-AVCodec ff_adpcm_4xm_decoder;
-AVCodec ff_adpcm_adx_encoder;
-AVCodec ff_adpcm_adx_decoder;
-AVCodec ff_adpcm_afc_decoder;
-AVCodec ff_adpcm_ct_decoder;
-AVCodec ff_adpcm_dtk_decoder;
-AVCodec ff_adpcm_ea_decoder;
-AVCodec ff_adpcm_ea_maxis_xa_decoder;
-AVCodec ff_adpcm_ea_r1_decoder;
-AVCodec ff_adpcm_ea_r2_decoder;
-AVCodec ff_adpcm_ea_r3_decoder;
-AVCodec ff_adpcm_ea_xas_decoder;
-AVCodec ff_adpcm_g722_encoder;
-AVCodec ff_adpcm_g722_decoder;
-AVCodec ff_adpcm_g726_encoder;
-AVCodec ff_adpcm_g726_decoder;
-AVCodec ff_adpcm_g726le_decoder;
-AVCodec ff_adpcm_ima_amv_decoder;
-AVCodec ff_adpcm_ima_apc_decoder;
-AVCodec ff_adpcm_ima_dk3_decoder;
-AVCodec ff_adpcm_ima_dk4_decoder;
-AVCodec ff_adpcm_ima_ea_eacs_decoder;
-AVCodec ff_adpcm_ima_ea_sead_decoder;
-AVCodec ff_adpcm_ima_iss_decoder;
-AVCodec ff_adpcm_ima_oki_decoder;
-AVCodec ff_adpcm_ima_qt_encoder;
-AVCodec ff_adpcm_ima_qt_decoder;
-AVCodec ff_adpcm_ima_rad_decoder;
-AVCodec ff_adpcm_ima_smjpeg_decoder;
-AVCodec ff_adpcm_ima_wav_encoder;
-AVCodec ff_adpcm_ima_wav_decoder;
-AVCodec ff_adpcm_ima_ws_decoder;
-AVCodec ff_adpcm_ms_encoder;
-AVCodec ff_adpcm_ms_decoder;
-AVCodec ff_adpcm_sbpro_2_decoder;
-AVCodec ff_adpcm_sbpro_3_decoder;
-AVCodec ff_adpcm_sbpro_4_decoder;
-AVCodec ff_adpcm_swf_encoder;
-AVCodec ff_adpcm_swf_decoder;
-AVCodec ff_adpcm_thp_decoder;
-AVCodec ff_adpcm_thp_le_decoder;
-AVCodec ff_adpcm_vima_decoder;
-AVCodec ff_adpcm_xa_decoder;
-AVCodec ff_adpcm_yamaha_encoder;
-AVCodec ff_adpcm_yamaha_decoder;
-AVCodec ff_vima_decoder;
-AVCodec ff_ssa_encoder;
-AVCodec ff_ssa_decoder;
-AVCodec ff_ass_encoder;
-AVCodec ff_ass_decoder;
-AVCodec ff_ccaption_decoder;
-AVCodec ff_dvbsub_encoder;
-AVCodec ff_dvbsub_decoder;
-AVCodec ff_dvdsub_encoder;
-AVCodec ff_dvdsub_decoder;
-AVCodec ff_jacosub_decoder;
-AVCodec ff_microdvd_decoder;
-AVCodec ff_movtext_encoder;
-AVCodec ff_movtext_decoder;
-AVCodec ff_mpl2_decoder;
-AVCodec ff_pgssub_decoder;
-AVCodec ff_pjs_decoder;
-AVCodec ff_realtext_decoder;
-AVCodec ff_sami_decoder;
-AVCodec ff_srt_encoder;
-AVCodec ff_srt_decoder;
-AVCodec ff_stl_decoder;
-AVCodec ff_subrip_encoder;
-AVCodec ff_subrip_decoder;
-AVCodec ff_subviewer_decoder;
-AVCodec ff_subviewer1_decoder;
-AVCodec ff_text_decoder;
-AVCodec ff_vplayer_decoder;
-AVCodec ff_webvtt_encoder;
-AVCodec ff_webvtt_decoder;
-AVCodec ff_xsub_encoder;
-AVCodec ff_xsub_decoder;
-AVCodec ff_libcelt_decoder;
-AVCodec ff_libdcadec_decoder;
-AVCodec ff_libfaac_encoder;
-AVCodec ff_libfdk_aac_encoder;
-AVCodec ff_libfdk_aac_decoder;
-AVCodec ff_libgsm_encoder;
-AVCodec ff_libgsm_decoder;
-AVCodec ff_libgsm_ms_encoder;
-AVCodec ff_libgsm_ms_decoder;
-AVCodec ff_libilbc_encoder;
-AVCodec ff_libilbc_decoder;
-AVCodec ff_libmp3lame_encoder;
-AVCodec ff_libopencore_amrnb_encoder;
-AVCodec ff_libopencore_amrnb_decoder;
-AVCodec ff_libopencore_amrwb_decoder;
-AVCodec ff_libopenjpeg_encoder;
-AVCodec ff_libopenjpeg_decoder;
-AVCodec ff_libopus_encoder;
-AVCodec ff_libopus_decoder;
-AVCodec ff_libschroedinger_encoder;
-AVCodec ff_libschroedinger_decoder;
-AVCodec ff_libshine_encoder;
-AVCodec ff_libspeex_encoder;
-AVCodec ff_libspeex_decoder;
-AVCodec ff_libstagefright_h264_decoder;
-AVCodec ff_libtheora_encoder;
-AVCodec ff_libtwolame_encoder;
-AVCodec ff_libutvideo_encoder;
-AVCodec ff_libutvideo_decoder;
-AVCodec ff_libvo_aacenc_encoder;
-AVCodec ff_libvo_amrwbenc_encoder;
-AVCodec ff_libvorbis_encoder;
-AVCodec ff_libvorbis_decoder;
-AVCodec ff_libvpx_vp8_encoder;
-AVCodec ff_libvpx_vp8_decoder;
-AVCodec ff_libvpx_vp9_encoder;
-AVCodec ff_libvpx_vp9_decoder;
-AVCodec ff_libwavpack_encoder;
-AVCodec ff_libwebp_anim_encoder;
-AVCodec ff_libwebp_encoder;
-AVCodec ff_libx262_encoder;
-AVCodec ff_libx264_encoder;
-AVCodec ff_libx264rgb_encoder;
-AVCodec ff_libx265_encoder;
-AVCodec ff_libxavs_encoder;
-AVCodec ff_libxvid_encoder;
-AVCodec ff_libzvbi_teletext_decoder;
-AVCodec ff_libaacplus_encoder;
-AVCodec ff_bintext_decoder;
-AVCodec ff_xbin_decoder;
-AVCodec ff_idf_decoder;
-AVCodec ff_libopenh264_encoder;
-AVCodec ff_h264_qsv_encoder;
-AVCodec ff_nvenc_encoder;
-AVCodec ff_nvenc_h264_encoder;
-AVCodec ff_nvenc_hevc_encoder;
-AVCodec ff_hevc_qsv_encoder;
-AVCodec ff_libkvazaar_encoder;
-AVCodec ff_mpeg2_qsv_encoder;
-AVCodec ff_dxv_decoder;
-AVCodec ff_mpeg2_mmal_decoder;
-AVCodec ff_rscc_decoder;
-AVCodec ff_screenpresso_decoder;
-AVCodec ff_sdx2_dpcm_decoder;
-AVCodec ff_vc1_mmal_decoder;
-AVCodec ff_wrapped_avframe_encoder;
-AVCodec ff_interplay_acm_decoder;
-AVCodec ff_xma1_decoder;
-AVCodec ff_xma2_decoder;
-AVCodec ff_adpcm_aica_decoder;
-AVCodec ff_adpcm_psx_decoder;
-AVCodec ff_text_encoder;
-AVCodec ff_vp9_cuvid_decoder;
-AVCodec ff_vp8_cuvid_decoder;
-AVCodec ff_vc1_cuvid_decoder;
-AVCodec ff_mjpeg_vaapi_encoder;
-AVCodec ff_hevc_vaapi_encoder;
-AVCodec ff_hevc_nvenc_encoder;
-AVCodec ff_hevc_cuvid_decoder;
-AVCodec ff_h264_videotoolbox_encoder;
-AVCodec ff_h264_vaapi_encoder;
-AVCodec ff_h264_omx_encoder;
-AVCodec ff_h264_nvenc_encoder;
-AVCodec ff_h264_cuvid_decoder;
-AVCodec ff_qdm2_at_decoder;
-AVCodec ff_qdmc_at_decoder;
-AVCodec ff_pcm_mulaw_at_decoder;
-AVCodec ff_pcm_mulaw_at_encoder;
-AVCodec ff_pcm_alaw_at_decoder;
-AVCodec ff_pcm_alaw_at_encoder;
-AVCodec ff_mp3_at_decoder;
-AVCodec ff_mp2_at_decoder;
-AVCodec ff_mp1_at_decoder;
-AVCodec ff_ilbc_at_decoder;
-AVCodec ff_ilbc_at_encoder;
-AVCodec ff_gsm_ms_at_decoder;
-AVCodec ff_eac3_at_decoder;
-AVCodec ff_amr_nb_at_decoder;
-AVCodec ff_alac_at_decoder;
-AVCodec ff_alac_at_encoder;
-AVCodec ff_adpcm_ima_qt_at_decoder;
-AVCodec ff_ac3_at_decoder;
-AVCodec ff_aac_at_decoder;
-AVCodec ff_aac_at_encoder;
-AVCodec ff_adpcm_mtaf_decoder;
-AVCodec ff_adpcm_ima_dat4_decoder;
-AVCodec ff_dst_decoder;
-AVCodec ff_ylc_decoder;
-AVCodec ff_truemotion2rt_decoder;
-AVCodec ff_sheervideo_decoder;
-AVCodec ff_magicyuv_decoder;
-AVCodec ff_m101_decoder;
-AVCodec ff_h264_mediacodec_decoder;
-/* Added by FFmpeg 3.2 */
-AVCodec ff_vp9_mediacodec_decoder;
-AVCodec ff_vp8_mediacodec_decoder;
-AVCodec ff_mpeg4_mediacodec_decoder;
-AVCodec ff_mpeg4_cuvid_decoder;
-AVCodec ff_mpeg2_cuvid_decoder;
-AVCodec ff_mjpeg_cuvid_decoder;
-AVCodec ff_hevc_mediacodec_decoder;
-AVCodec ff_libopenh264_decoder;
-AVCodec ff_pcm_s64le_decoder;
-AVCodec ff_pcm_s64le_encoder;
-AVCodec ff_pcm_s64be_decoder;
-AVCodec ff_pcm_s64be_encoder;
-AVCodec ff_truehd_encoder;
-AVCodec ff_mlp_encoder;
-/* Added by FFmpeg 3.4 */
-AVCodec ff_clearvideo_decoder;
-AVCodec ff_fits_encoder;
-AVCodec ff_fits_decoder;
-AVCodec ff_fmvc_decoder;
-AVCodec ff_gdv_decoder;
-AVCodec ff_h263_v4l2m2m_decoder;
-AVCodec ff_h264_v4l2m2m_decoder;
-AVCodec ff_h264_rkmpp_decoder;
-AVCodec ff_hevc_rkmpp_decoder;
-AVCodec ff_hevc_v4l2m2m_decoder;
-AVCodec ff_mpeg4_v4l2m2m_decoder;
-AVCodec ff_mpeg1_v4l2m2m_decoder;
-AVCodec ff_mpeg2_v4l2m2m_decoder;
-AVCodec ff_mpeg2_mediacodec_decoder;
-AVCodec ff_mscc_decoder;
-AVCodec ff_pixlet_decoder;
-AVCodec ff_psd_decoder;
-AVCodec ff_scpr_decoder;
-AVCodec ff_speedhq_decoder;
-AVCodec ff_srgc_decoder;
-AVCodec ff_vc1_v4l2m2m_decoder;
-AVCodec ff_vp8_rkmpp_decoder;
-AVCodec ff_vp8_v4l2m2m_decoder;
-AVCodec ff_vp9_rkmpp_decoder;
-AVCodec ff_vp9_v4l2m2m_decoder;
-AVCodec ff_bitpacked_decoder;
-AVCodec ff_wrapped_avframe_decoder;
-AVCodec ff_xpm_decoder;
-AVCodec ff_atrac3al_decoder;
-AVCodec ff_atrac3pal_decoder;
-AVCodec ff_dolby_e_decoder;
-AVCodec ff_opus_encoder;
-AVCodec ff_qdmc_decoder;
-AVCodec ff_pcm_f16le_decoder;
-AVCodec ff_pcm_f24le_decoder;
-AVCodec ff_gremlin_dpcm_decoder;
-AVCodec ff_adpcm_g726le_encoder;
-AVCodec ff_librsvg_decoder;
-AVCodec ff_h263_v4l2m2m_encoder;
-AVCodec ff_h264_v4l2m2m_encoder;
-AVCodec ff_hevc_v4l2m2m_encoder;
-AVCodec ff_mpeg2_vaapi_encoder;
-AVCodec ff_mpeg4_v4l2m2m_encoder;
-AVCodec ff_vp8_qsv_decoder;
-AVCodec ff_vp8_v4l2m2m_encoder;
-AVCodec ff_vp8_vaapi_encoder;
-AVCodec ff_vp9_vaapi_encoder;
-
-
-AVCodecParser ff_aac_parser;
-AVCodecParser ff_aac_latm_parser;
-AVCodecParser ff_ac3_parser;
-AVCodecParser ff_adx_parser;
-AVCodecParser ff_bmp_parser;
-AVCodecParser ff_cavsvideo_parser;
-AVCodecParser ff_cook_parser;
-AVCodecParser ff_dca_parser;
-AVCodecParser ff_dirac_parser;
-AVCodecParser ff_dnxhd_parser;
-AVCodecParser ff_dpx_parser;
-AVCodecParser ff_dvaudio_parser;
-AVCodecParser ff_dvbsub_parser;
-AVCodecParser ff_dvdsub_parser;
-AVCodecParser ff_dvd_nav_parser;
-AVCodecParser ff_flac_parser;
-AVCodecParser ff_g729_parser;
-AVCodecParser ff_gsm_parser;
-AVCodecParser ff_h261_parser;
-AVCodecParser ff_h263_parser;
-AVCodecParser ff_h264_parser;
-AVCodecParser ff_hevc_parser;
-AVCodecParser ff_mjpeg_parser;
-AVCodecParser ff_mlp_parser;
-AVCodecParser ff_mpeg4video_parser;
-AVCodecParser ff_mpegaudio_parser;
-AVCodecParser ff_mpegvideo_parser;
-AVCodecParser ff_opus_parser;
-AVCodecParser ff_png_parser;
-AVCodecParser ff_pnm_parser;
-AVCodecParser ff_rv30_parser;
-AVCodecParser ff_rv40_parser;
-AVCodecParser ff_tak_parser;
-AVCodecParser ff_vc1_parser;
-AVCodecParser ff_vorbis_parser;
-AVCodecParser ff_vp3_parser;
-/* Added by FFmpeg 3.4 */
-AVCodecParser ff_sipr_parser;
-AVCodecParser ff_xma_parser;
-
-AVBitStreamFilter ff_aac_adtstoasc_bsf;
-AVBitStreamFilter ff_chomp_bsf;
-AVBitStreamFilter ff_dump_extradata_bsf;
-AVBitStreamFilter ff_h264_mp4toannexb_bsf;
-AVBitStreamFilter ff_hevc_mp4toannexb_bsf;
-AVBitStreamFilter ff_imx_dump_header_bsf;
-AVBitStreamFilter ff_mjpeg2jpeg_bsf;
-AVBitStreamFilter ff_mjpega_dump_header_bsf;
-AVBitStreamFilter ff_mp3_header_decompress_bsf;
-AVBitStreamFilter ff_mpeg4_unpack_bframes_bsf;
-AVBitStreamFilter ff_mov2textsub_bsf;
-AVBitStreamFilter ff_noise_bsf;
-AVBitStreamFilter ff_remove_extradata_bsf;
-AVBitStreamFilter ff_text2movsub_bsf;
-
-void ff_fft_init_arm(FFTContext *s) {}
-void ff_fft_init_mips(FFTContext *s) {}
-void ff_fft_init_ppc(FFTContext *s) {}
-void ff_rdft_init_arm(RDFTContext *s) {}
-void ff_h264_pred_init_arm(H264PredContext *h, int codec_id,
-                           const int bit_depth, const int chroma_format_idc) {}
-void ff_h264_pred_init_mips(H264PredContext *h, int codec_id,
-                            const int bit_depth, const int chroma_format_idc) {}
-void ff_me_cmp_init_static(void) {}
-int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options) { return 0; }
-void ff_frame_thread_encoder_free(AVCodecContext *avctx) {}
-int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr) { return 0; }
-void ff_videodsp_init_arm(VideoDSPContext *ctx, int bpc) {}
-void ff_videodsp_init_ppc(VideoDSPContext *ctx, int bpc) {}
-void ff_videodsp_init_mips(VideoDSPContext *ctx, int bpc) {}
-void ff_vp7dsp_init(VP8DSPContext *c) {}
-void ff_vp78dsp_init_arm(VP8DSPContext *c) {}
-void ff_vp78dsp_init_ppc(VP8DSPContext *c) {}
-void ff_vp8dsp_init_arm(VP8DSPContext *c) {}
-void ff_vp8dsp_init_mips(VP8DSPContext *c) {}
-void ff_vp9dsp_init_mips(VP9DSPContext *dsp, int bpp) {}
-void ff_vp9dsp_init_arm(VP9DSPContext *dsp, int bpp) {}
-#if !defined(__arm__)
-void ff_flacdsp_init_arm(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps) {}
-#endif
-#if !defined(HAVE_64BIT_BUILD)
-void ff_flac_decorrelate_indep8_16_sse2(uint8_t **out, int32_t **in, int channels, int len, int shift) {}
-void ff_flac_decorrelate_indep8_32_avx(uint8_t **out, int32_t **in, int channels, int len, int shift) {}
-void ff_flac_decorrelate_indep8_16_avx(uint8_t **out, int32_t **in, int channels, int len, int shift) {}
-void ff_flac_decorrelate_indep8_32_sse2(uint8_t **out, int32_t **in, int channels, int len, int shift) {}
-#endif

media/ffvpx/libavcodec/moz.build

@@ -22,7 +22,6 @@ SOURCES += [
     'bsf.c',
     'codec_desc.c',
     'decode.c',
-    'dummy_funcs.c',
     'flac.c',
     'flacdata.c',
     'flacdec.c',

media/ffvpx/libavutil/dummy_funcs.c

@@ -1,37 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim:set ts=2 sw=2 sts=2 et cindent: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "avutil.h"
-#include "hwcontext.h"
-
-// cpu_internal.c
-#if !defined(_ARM64_)
-int ff_get_cpu_flags_aarch64(void) { return 0; }
-#endif
-#if !defined(__arm__)
-int ff_get_cpu_flags_arm(void) { return 0; }
-#endif
-int ff_get_cpu_flags_ppc(void) { return 0; }
-
-// float_dsp.c
-#include "float_dsp.h"
-#if !defined(_ARM64_)
-void ff_float_dsp_init_aarch64(AVFloatDSPContext *fdsp) {}
-#endif
-void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int strict) {}
-void ff_float_dsp_init_mips(AVFloatDSPContext *fdsp) {}
-#if !defined(__arm__)
-void ff_float_dsp_init_arm(AVFloatDSPContext *fdsp) {}
-#endif
-
-// cpu.c
-#if !defined(_ARM64_)
-size_t ff_get_cpu_max_align_aarch64() { return 0; }
-#endif
-size_t ff_get_cpu_max_align_ppc() { return 0; }
-#if !defined(__arm__)
-size_t ff_get_cpu_max_align_arm() { return 0; }
-#endif

media/ffvpx/libavutil/moz.build

@@ -23,7 +23,6 @@ SOURCES += [
     'cpu.c',
     'crc.c',
     'dict.c',
-    'dummy_funcs.c',
     'error.c',
     'eval.c',
     'fifo.c',

media/libcubeb/moz.yaml

@@ -19,5 +19,5 @@ origin:
   license: "ISC"
 
   # update.sh will update this value
-  release: "98a1c8e61c78d4e3b8839352617a1e2432717a42 (2019-06-20 13:30:20 -0700)"
+  release: "0b5b52d371598bfe6bee2385c2d74c8901791e92 (2019-07-19 13:45:46 +1200)"
 

media/libcubeb/src/cubeb.c

@@ -74,7 +74,7 @@ validate_stream_params(cubeb_stream_params * input_stream_params,
   XASSERT(input_stream_params || output_stream_params);
   if (output_stream_params) {
     if (output_stream_params->rate < 1000 || output_stream_params->rate > 192000 ||
-        output_stream_params->channels < 1) {
+        output_stream_params->channels < 1 || output_stream_params->channels > UINT8_MAX) {
       return CUBEB_ERROR_INVALID_FORMAT;
     }
   }

media/libcubeb/src/cubeb_audiounit.cpp

@@ -61,7 +61,7 @@ const char * PRIVATE_AGGREGATE_DEVICE_NAME = "CubebAggregateDevice";
 /* Testing empirically, some headsets report a minimal latency that is very
  * low, but this does not work in practice. Lie and say the minimum is 256
  * frames. */
-const uint32_t SAFE_MIN_LATENCY_FRAMES = 256;
+const uint32_t SAFE_MIN_LATENCY_FRAMES = 128;
 const uint32_t SAFE_MAX_LATENCY_FRAMES = 512;
 
 const AudioObjectPropertyAddress DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS = {
@@ -241,6 +241,7 @@ struct cubeb_stream {
   /* Latency requested by the user. */
   uint32_t latency_frames = 0;
   atomic<uint32_t> current_latency_frames{ 0 };
+  atomic<uint32_t> total_output_latency_frames { 0 };
   atomic<float> panning{ 0 };
   unique_ptr<cubeb_resampler, decltype(&cubeb_resampler_destroy)> resampler;
   /* This is true if a device change callback is currently running.  */
@@ -368,8 +369,10 @@ typedef UInt32 AudioObjectID;
 
 #define AudioGetCurrentHostTime mach_absolute_time
 
+#endif
+
 uint64_t
-AudioConvertHostTimeToNanos(uint64_t host_time)
+ConvertHostTimeToNanos(uint64_t host_time)
 {
   static struct mach_timebase_info timebase_info;
   static bool initialized = false;
@@ -385,7 +388,6 @@ AudioConvertHostTimeToNanos(uint64_t host_time)
   }
   return (uint64_t)answer;
 }
-#endif
 
 static void
 audiounit_increment_active_streams(cubeb * ctx)
@@ -583,6 +585,15 @@ audiounit_output_callback(void * user_ptr,
 
   cubeb_stream * stm = static_cast<cubeb_stream *>(user_ptr);
 
+  uint64_t now = ConvertHostTimeToNanos(mach_absolute_time());
+  uint64_t audio_output_time = ConvertHostTimeToNanos(tstamp->mHostTime);
+  uint64_t output_latency_ns = audio_output_time - now;
+
+  const int ns2s = 1e9;
+  // The total output latency is the timestamp difference + the stream latency +
+  // the hardware latency.
+  stm->total_output_latency_frames = output_latency_ns * stm->output_hw_rate / ns2s + stm->current_latency_frames;
+
   ALOGV("(%p) output: buffers %u, size %u, channels %u, frames %u, total input frames %lu.",
         stm,
         (unsigned int) outBufferList->mNumberBuffers,
@@ -2973,7 +2984,7 @@ audiounit_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
   //TODO
   return CUBEB_ERROR_NOT_SUPPORTED;
 #else
-  *latency = stm->current_latency_frames;
+  *latency = stm->total_output_latency_frames;
   return CUBEB_OK;
 #endif
 }

media/libcubeb/src/cubeb_pulse.c

@@ -573,7 +573,9 @@ layout_to_channel_map(cubeb_channel_layout layout, pa_channel_map * cm)
     }
     channelMap = channelMap >> 1;
   }
-  cm->channels = cubeb_channel_layout_nb_channels(layout);
+  unsigned int channels_from_layout = cubeb_channel_layout_nb_channels(layout);
+  assert(channels_from_layout <= UINT8_MAX);
+  cm->channels = (uint8_t) channels_from_layout;
 }
 
 static void pulse_context_destroy(cubeb * ctx);
@@ -826,7 +828,9 @@ create_pa_stream(cubeb_stream * stm,
   if (ss.format == PA_SAMPLE_INVALID)
     return CUBEB_ERROR_INVALID_FORMAT;
   ss.rate = stream_params->rate;
-  ss.channels = stream_params->channels;
+  if (stream_params->channels > UINT8_MAX)
+    return CUBEB_ERROR_INVALID_FORMAT;
+  ss.channels = (uint8_t) stream_params->channels;
 
   if (stream_params->layout == CUBEB_LAYOUT_UNDEFINED) {
     pa_channel_map cm;

taskcluster/docker/funsize-update-generator/Pipfile

@@ -3,7 +3,6 @@ python_version = '3.6'
 
 [packages]
 aiohttp = "*"
-datadog = "*"
 mar = "*"
 redo = "*"
 requests = "*"

taskcluster/docker/funsize-update-generator/Pipfile.lock

@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "8ae855f2ef3d4d9dcaa6dd796ee176980724e8215eea64494710ef603cadd3c5"
+            "sha256": "99aadbfad074e19038b66e1ac7d268cdf10db18212b3e02fe497b8cc60d8bfec"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -181,21 +181,6 @@
             ],
             "version": "==2.7"
         },
-        "datadog": {
-            "hashes": [
-                "sha256:0e33727bd9ef0b8201359accdf12f61fb58ab541bf4062693aca16653f8e7a0a",
-                "sha256:995e51d142ae3624c86c78369b268f23386bb207df5345d718c241718387875c"
-            ],
-            "index": "pypi",
-            "version": "==0.29.3"
-        },
-        "decorator": {
-            "hashes": [
-                "sha256:86156361c50488b84a3f148056ea716ca587df2f0de1d34750d35c21312725de",
-                "sha256:f069f3a01830ca754ba5258fde2278454a0b5b79e0d7f5c13b3b97e57d4acff6"
-            ],
-            "version": "==4.4.0"
-        },
         "dictdiffer": {
             "hashes": [
                 "sha256:97cf4ef98ebc1acf737074aed41e379cf48ab5ff528c92109dfb8e2e619e6809",
@@ -316,6 +301,17 @@
         },
         "pyasn1": {
             "hashes": [
+                "sha256:061442c60842f6d11051d4fdae9bc197b64bd41573a12234a753a0cb80b4f30b",
+                "sha256:0ee2449bf4c4e535823acc25624c45a8b454f328d59d3f3eeb82d3567100b9bd",
+                "sha256:5f9fb05c33e53b9a6ee3b1ed1d292043f83df465852bec876e93b47fd2df7eed",
+                "sha256:65201d28e081f690a32401e6253cca4449ccacc8f3988e811fae66bd822910ee",
+                "sha256:79b336b073a52fa3c3d8728e78fa56b7d03138ef59f44084de5f39650265b5ff",
+                "sha256:8ec20f61483764de281e0b4aba7d12716189700debcfa9e7935780850bf527f3",
+                "sha256:9458d0273f95d035de4c0d5e0643f25daba330582cc71bb554fe6969c015042a",
+                "sha256:98d97a1833a29ca61cd04a60414def8f02f406d732f9f0bcb49f769faff1b699",
+                "sha256:b00d7bfb6603517e189d1ad76967c7e805139f63e43096e5f871d1277f50aea5",
+                "sha256:b06c0cfd708b806ea025426aace45551f91ea7f557e0c2d4fbd9a4b346873ce0",
+                "sha256:d14d05984581770333731690f5453efd4b82e1e5d824a1d7976b868a2e5c38e8",
                 "sha256:da2420fe13a9452d8ae97a0e478adde1dee153b11ba832a95b223a2ba01c10f7",
                 "sha256:da6b43a8c9ae93bc80e2739efb38cc776ba74a886e3e9318d65fe81a8b8a2c6e"
             ],
@@ -338,7 +334,6 @@
                 "sha256:7e6584c74aeed623791615e26efd690f29817a27c73085b78e4bad02493df2fb",
                 "sha256:c89805f6f4d64db21ed966fda138f8a5ed7a4fdbc1a8ee329ce1b74e3c74da9e"
             ],
-            "markers": "python_version >= '2.7'",
             "version": "==2.8.0"
         },
         "pyyaml": {
@@ -355,7 +350,6 @@
                 "sha256:c68ea4d3ba1705da1e0d85da6684ac657912679a649e8868bd850d2c299cce13",
                 "sha256:e23d0cc5299223dcc37885dae624f382297717e459ea24053709675a976a3e19"
             ],
-            "markers": "python_version != '2.6'",
             "version": "==5.1"
         },
         "redo": {
@@ -456,7 +450,6 @@
                 "sha256:b246607a25ac80bedac05c6f282e3cdaf3afb65420fd024ac94435cabe6e18d1",
                 "sha256:dbe59173209418ae49d485b87d1681aefa36252ee85884c31346debd19463232"
             ],
-            "markers": "python_version >= '3.4'",
             "version": "==1.25.3"
         },
         "yarl": {

taskcluster/docker/funsize-update-generator/scripts/funsize.py

@@ -25,15 +25,9 @@ from scriptworker.utils import retry_async
 from mardor.reader import MarReader
 from mardor.signing import get_keysize
 
-from datadog import initialize, ThreadStats
-
 
 log = logging.getLogger(__name__)
 
-# Create this even when not sending metrics, so the context manager
-# statements work.
-ddstats = ThreadStats(namespace='releng.releases.partials')
-
 
 ROOT_URL = os.environ['TASKCLUSTER_ROOT_URL']
 QUEUE_PREFIX = ("https://queue.taskcluster.net/"
@@ -64,18 +58,6 @@ BCJ_OPTIONS = {
 }
 
 
-def write_dogrc(api_key):
-    """Datadog .dogrc file for command line interface."""
-    dogrc_path = os.path.join(os.path.expanduser('~'), '.dogrc')
-    config = configparser.ConfigParser()
-    config['Connection'] = {
-        'apikey': api_key,
-        'appkey': '',
-    }
-    with open(dogrc_path, 'w') as f:
-        config.write(f)
-
-
 def verify_signature(mar, certs):
     log.info("Checking %s signature", mar)
     with open(mar, 'rb') as mar_fh:
@@ -334,11 +316,7 @@ async def manage_partial(partial_def, filename_template, artifacts_dir,
         dest = os.path.join(work_env.workdir, "{}.mar".format(mar_type))
         unpack_dir = os.path.join(work_env.workdir, mar_type)
 
-        metric_tags = [
+        await retry_download(f, dest)
-            "platform:{}".format(partial_def['platform']),
-        ]
-        with ddstats.timer('mar.download.time', tags=metric_tags):
-            await retry_download(f, dest)
 
         if not os.getenv("MOZ_DISABLE_MAR_CERT_VERIFICATION"):
             verify_signature(dest, signing_certs)
@@ -346,8 +324,7 @@ async def manage_partial(partial_def, filename_template, artifacts_dir,
         complete_mars["%s_size" % mar_type] = os.path.getsize(dest)
         complete_mars["%s_hash" % mar_type] = get_hash(dest)
 
-        with ddstats.timer('mar.unpack.time'):
+        await unpack(work_env, dest, unpack_dir)
-            await unpack(work_env, dest, unpack_dir)
 
         if mar_type == 'to':
             check_channels_in_files.append(dest)
@@ -413,25 +390,11 @@ async def manage_partial(partial_def, filename_template, artifacts_dir,
     await work_env.download_buildsystem_bits(repo=mar_data["repo"],
                                              revision=mar_data["revision"])
 
-    metric_tags = [
+    await generate_partial(work_env, from_path, to_path, dest_mar,
-        "branch:{}".format(mar_data['branch']),
+                           mar_data, use_old_format)
-        "platform:{}".format(mar_data['platform']),
-        # If required. Shouldn't add much useful info, but increases
-        # cardinality of metrics substantially, so avoided.
-        # "locale:{}".format(mar_data['locale']),
-    ]
-    with ddstats.timer('generate_partial.time', tags=metric_tags):
-        await generate_partial(work_env, from_path, to_path, dest_mar,
-                               mar_data, use_old_format)
 
     mar_data["size"] = os.path.getsize(dest_mar)
 
-    metric_tags.append("unit:bytes")
-    # Allows us to find out how many releases there were between the two,
-    # making buckets of the file sizes easier.
-    metric_tags.append("update_number:{}".format(mar_data.get('update_number', 0)))
-    ddstats.gauge('partial_mar_size', mar_data['size'], tags=metric_tags)
-
     mar_data["hash"] = get_hash(dest_mar)
 
     shutil.copy(dest_mar, artifacts_dir)
@@ -470,8 +433,6 @@ async def async_main(args, signing_certs):
 
 def main():
 
-    start = time.time()
-
     parser = argparse.ArgumentParser()
     parser.add_argument("--artifacts-dir", required=True)
     parser.add_argument("--sha1-signing-cert", required=True)
@@ -504,24 +465,6 @@ def main():
     assert(get_keysize(signing_certs['sha1']) == 2048)
     assert(get_keysize(signing_certs['sha384']) == 4096)
 
-    # Intended for local testing.
-    dd_api_key = os.environ.get('DATADOG_API_KEY')
-    # Intended for Taskcluster.
-    if not dd_api_key and os.environ.get('DATADOG_API_SECRET'):
-        dd_api_key = get_secret(os.environ.get('DATADOG_API_SECRET')).get('key')
-
-    if dd_api_key:
-        dd_options = {
-            'api_key': dd_api_key,
-        }
-        log.info("Starting metric collection")
-        initialize(**dd_options)
-        ddstats.start(flush_interval=1)
-        # For use in shell scripts.
-        write_dogrc(dd_api_key)
-    else:
-        log.info("No metric collection")
-
     loop = asyncio.get_event_loop()
     manifest = loop.run_until_complete(async_main(args, signing_certs))
     loop.close()
@@ -532,21 +475,6 @@ def main():
 
     log.debug("{}".format(json.dumps(manifest, indent=2, sort_keys=True)))
 
-    # Warning: Assumption that one partials task will always be for one branch.
-    metric_tags = [
-        "branch:{}".format(manifest[0]['branch']),
-        "platform:{}".format(manifest[0]['platform']),
-    ]
-
-    ddstats.timing('task_duration', time.time() - start,
-                   start, tags=metric_tags)
-
-    # Wait for all the metrics to flush. If the program ends before
-    # they've been sent, they'll be dropped.
-    # Should be more than the flush_interval for the ThreadStats object
-    if dd_api_key:
-        time.sleep(10)
-
 
 if __name__ == '__main__':
     main()

taskcluster/docs/partials.rst

@@ -63,22 +63,6 @@ Partials are made as part of the ``promote`` task group. The previous
 versions used to create the update are specified in ship-it by
 Release Management.
 
-Data About Partials
--------------------
-
-Some metrics are collected in Datadog_ about partial update tasks.
-The prefix used is ``releng.releases.partials``, so the relevant metric names
-will all start with that.
-
-Some dashboards in Datadog are public, some require a login. If you need
-access, file a bug under 'Cloud Services :: Operations: Metrics/Monitoring'
-
-Some examples of potentially useful metrics:
-
-* ``releng.releases.partials.partial_mar_size`` (tagged with branch, platform and update-number)
-* ``releng.releases.partials.task_duration`` - the time the task took, running partial generation concurrently.
-* ``releng.releases.partials.generate_partial.time`` - the time taken to make one partial update
-
 Nightly Partials
 ----------------
 
@@ -137,5 +121,3 @@ Otherwise, it will depend on ``repackage-signing``.
 
 This is not ideal, as it results in unclear logic in the task graph
 generation. It will be improved.
-
-.. _Datadog: https://app.datadoghq.com/metric/explorer

taskcluster/taskgraph/transforms/partials.py

@@ -117,8 +117,6 @@ def make_task_description(config, jobs):
             'env': {
                 'SHA1_SIGNING_CERT': 'nightly_sha1',
                 'SHA384_SIGNING_CERT': 'nightly_sha384',
-                'DATADOG_API_SECRET':
-                    'project/releng/gecko/build/level-{}/datadog-api-key'.format(level),
                 'EXTRA_PARAMS': '--arch={}'.format(architecture(attributes['build_platform'])),
                 'MAR_CHANNEL_ID': attributes['mar-channel-id']
             }
@@ -132,9 +130,7 @@ def make_task_description(config, jobs):
                 dep_job.task["metadata"]["description"]),
             'worker-type': 'b-linux',
             'dependencies': dependencies,
-            'scopes': [
+            'scopes': [],
-                'secrets:get:project/releng/gecko/build/level-%s/datadog-api-key' % level
-            ],
             'attributes': attributes,
             'run-on-projects': dep_job.attributes.get('run_on_projects'),
             'treeherder': treeherder,

testing/marionette/browser.js

@@ -353,7 +353,11 @@ browser.Context = class {
           subject => subject == win
         );
 
-        win.focus();
+        // Bug 1509380 - Missing focus/activate event when Firefox is not
+        // the top-most application. As such wait for the next tick, and
+        // manually focus the newly opened window.
+        win.setTimeout(() => win.focus(), 0);
+
         await Promise.all([activated, focused, startup]);
 
         // The new window shouldn't get focused. As such set the

testing/marionette/client/marionette_driver/geckoinstance.py

@@ -527,6 +527,11 @@ class DesktopInstance(GeckoInstance):
         # when this Firefox version is no longer supported by the client !!!
         "app.update.auto": False,
 
+        # Don't show the content blocking introduction panel
+        # We use a larger number than the default 22 to have some buffer
+        # This can be removed once Firefox 69 and 68 ESR and are no longer supported.
+        "browser.contentblocking.introCount": 99,
+
         # Enable output for dump() and chrome console API
         "browser.dom.window.dump.enabled": True,
         "devtools.console.stdout.chrome": True,

testing/marionette/components/marionette.js

@@ -86,6 +86,11 @@ const RECOMMENDED_PREFS = new Map([
   // (bug 1176798, bug 1177018, bug 1210465)
   ["apz.content_response_timeout", 60000],
 
+  // Don't show the content blocking introduction panel.
+  // We use a larger number than the default 22 to have some buffer
+  // This can be removed once Firefox 69 and 68 ESR and are no longer supported.
+  ["browser.contentblocking.introCount", 99],
+
   // Indicate that the download panel has been shown once so that
   // whichever download test runs first doesn't show the popup
   // inconsistently.

testing/marionette/harness/marionette_harness/runner/mixins/window_manager.py

@@ -163,7 +163,10 @@ class WindowManagerMixin(object):
                     let win = window.openDialog(url, null, "chrome,centerscreen");
                     let focused = waitForFocus(win);
 
-                    win.focus();
+                    // Bug 1509380 - Missing focus/activate event when Firefox is not
+                    // the top-most application. As such wait for the next tick, and
+                    // manually focus the newly opened window.
+                    win.setTimeout(() => win.focus(), 0);
                     await focused;
 
                     // The new window shouldn't get focused. As such set the

testing/web-platform/tests/xhr/getallresponseheaders.htm

@@ -7,7 +7,7 @@
 async_test((t) => {
   const client = new XMLHttpRequest()
   client.onload = t.step_func_done(() => {
-    assert_equals(client.getAllResponseHeaders(), "also-here: Mr. PB\r\newok: lego\r\nfoo-test: 1, 2\r\n")
+    assert_equals(client.getAllResponseHeaders(), "also-here: Mr. PB\r\newok: lego\r\nfoo-test: 1, 2\r\n__custom: token\r\n")
   })
   client.onerror = t.unreached_func("unexpected error")
   client.open("GET", "resources/headers.asis")

testing/web-platform/tests/xhr/resources/headers.asis

@@ -1,5 +1,6 @@
 HTTP/1.1 200 YAYAYAYA
 foo-TEST: 1
 FOO-test: 2
+__Custom: token
 ALSO-here: Mr. PB
 ewok: lego

toolkit/components/telemetry/Scalars.yaml

@@ -2317,7 +2317,7 @@ devtools.changesview:
       - 1532583
     description: >
       Number of times the Copy All Changes button is used in the Changes panel.
-    expires: "70"
+    expires: "73"
     kind: uint
     notification_emails:
       - dev-developer-tools@lists.mozilla.org
@@ -2335,7 +2335,7 @@ devtools.changesview:
       - 1532583
     description: >
       Number of times the Copy Rule button is used in the Changes panel.
-    expires: "70"
+    expires: "73"
     kind: uint
     notification_emails:
       - dev-developer-tools@lists.mozilla.org
@@ -2354,7 +2354,7 @@ devtools.changesview:
     description: >
       Number of times the Copy Declaration option is picked from the Changes panel
       context menu.
-    expires: "70"
+    expires: "73"
     kind: uint
     notification_emails:
       - dev-developer-tools@lists.mozilla.org
@@ -2373,7 +2373,7 @@ devtools.changesview:
     description: >
       Number of times the Copy Rule option is picked from the Changes panel
       context menu.
-    expires: "70"
+    expires: "73"
     kind: uint
     notification_emails:
       - dev-developer-tools@lists.mozilla.org