From: Alessandro Decina <alessandro.d@gmail.com>

Bug 760140 - Query the GstRegistry for the required demuxers/decoders from canPlayType

diff --git a/content/base/src/nsContentUtils.cpp b/content/base/src/nsContentUtils.cpp

--- a/content/base/src/nsContentUtils.cpp

+++ b/content/base/src/nsContentUtils.cpp

 #include "xpcprivate.h" // nsXPConnect

 #include "nsScriptSecurityManager.h"

 #include "nsIChannelPolicy.h"

 #include "nsChannelPolicy.h"

 #include "nsIContentSecurityPolicy.h"

 #include "nsContentDLF.h"

 #ifdef MOZ_MEDIA

 #include "nsHTMLMediaElement.h"

+#ifdef MOZ_GSTREAMER

+#include "nsGStreamerDecoder.h"

+#endif

 #endif

 #include "nsDOMTouchEvent.h"

 #include "nsIContentViewer.h"

 #include "nsIObjectLoadingContent.h"

 #include "nsCCUncollectableMarker.h"

 #include "mozilla/Base64.h"

 #include "mozilla/Preferences.h"

 #include "nsDOMMutationObserver.h"

         }

         return docFactory.forget();

       }

     }

   }

 #endif

 #ifdef MOZ_GSTREAMER

-  if (nsHTMLMediaElement::IsH264Enabled()) {

-    for (unsigned int i = 0; i < ArrayLength(nsHTMLMediaElement::gH264Types); ++i) {

-      const char* type = nsHTMLMediaElement::gH264Types[i];

-      if (!strcmp(aType, type)) {

-        docFactory = do_GetService("@mozilla.org/content/document-loader-factory;1");

-        if (docFactory && aLoaderType) {

-          *aLoaderType = TYPE_CONTENT;

-        }

-        return docFactory.forget();

+  if (nsHTMLMediaElement::IsGStreamerEnabled()) {

+    if (nsGStreamerDecoder::CanHandleMediaType(aType, nullptr)) {

+      docFactory = do_GetService("@mozilla.org/content/document-loader-factory;1");

+      if (docFactory && aLoaderType) {

+        *aLoaderType = TYPE_CONTENT;

       }

+      return docFactory.forget();

     }

   }

 #endif

 #ifdef MOZ_MEDIA_PLUGINS

   if (nsHTMLMediaElement::IsMediaPluginsEnabled() &&

       nsHTMLMediaElement::IsMediaPluginsType(nsDependentCString(aType))) {

     docFactory = do_GetService("@mozilla.org/content/document-loader-factory;1");

diff --git a/content/html/content/public/nsHTMLMediaElement.h b/content/html/content/public/nsHTMLMediaElement.h

--- a/content/html/content/public/nsHTMLMediaElement.h

+++ b/content/html/content/public/nsHTMLMediaElement.h

   void UpdateMediaSize(nsIntSize size);

   // Returns the CanPlayStatus indicating if we can handle this

   // MIME type. The MIME type should not include the codecs parameter.

   // If it returns anything other than CANPLAY_NO then it also

   // returns a null-terminated list of supported codecs

   // in *aSupportedCodecs. This list should not be freed, it is static data.

   static CanPlayStatus CanHandleMediaType(const char* aMIMEType,

-                                          char const *const ** aSupportedCodecs);

+                                          const char* aCodecs,

+                                          char const *const ** aSupportedCodecs,

+                                          bool* aCheckSupportedCodecs);

   // Returns the CanPlayStatus indicating if we can handle the

   // full MIME type including the optional codecs parameter.

   static CanPlayStatus GetCanPlay(const nsAString& aType);

   // Returns true if we should handle this MIME type when it appears

   // as an <object> or as a toplevel page. If, in practice, our support

   // for the type is more limited than appears in the wild, we should return

 #ifdef MOZ_WEBM

   static bool IsWebMEnabled();

   static bool IsWebMType(const nsACString& aType);

   static const char gWebMTypes[2][11];

   static char const *const gWebMCodecs[4];

 #endif

 #ifdef MOZ_GSTREAMER

-  static bool IsH264Enabled();

-  static bool IsH264Type(const nsACString& aType);

-  static const char gH264Types[3][16];

-  static char const *const gH264Codecs[7];

+  static bool IsGStreamerEnabled();

 #endif

 #endif

diff --git a/content/html/content/src/nsHTMLMediaElement.cpp b/content/html/content/src/nsHTMLMediaElement.cpp

--- a/content/html/content/src/nsHTMLMediaElement.cpp

+++ b/content/html/content/src/nsHTMLMediaElement.cpp

     }

   }

   return false;

 }

 #endif

 #ifdef MOZ_GSTREAMER

-const char nsHTMLMediaElement::gH264Types[3][16] = {

-  "video/mp4",

-  "video/3gpp",

-  "video/quicktime",

-};

-

-nsHTMLMediaElement::IsH264Enabled()

 {

-  return Preferences::GetBool("media.h264.enabled");

-}

-

-bool

-nsHTMLMediaElement::IsH264Type(const nsACString& aType)

-{

-  if (!IsH264Enabled()) {

-    return false;

-  }

-

-  for (uint32_t i = 0; i < ArrayLength(gH264Types); ++i) {

-    if (aType.EqualsASCII(gH264Types[i])) {

-      return true;

-    }

-  }

-

-  return false;

+  return Preferences::GetBool("media.gstreamer.enabled");

 }

 #endif

   return false;

 }

 #endif

 /* static */

 nsHTMLMediaElement::CanPlayStatus 

 nsHTMLMediaElement::CanHandleMediaType(const char* aMIMEType,

-                                       char const *const ** aCodecList)

+                                       const char *aCodecs,

+                                       char const *const ** aCodecList,

+                                       bool* aCheckCodecList)

 {

+  if (aCheckCodecList)

+    *aCheckCodecList = true;

 #ifdef MOZ_RAW

   if (IsRawType(nsDependentCString(aMIMEType))) {

     *aCodecList = gRawCodecs;

     return CANPLAY_MAYBE;

   }

 #endif

 #ifdef MOZ_OGG

   if (IsOggType(nsDependentCString(aMIMEType))) {

     *aCodecList = gWebMCodecs;

     return CANPLAY_YES;

   }

 #endif

 #ifdef MOZ_GSTREAMER

-  if (IsH264Type(nsDependentCString(aMIMEType))) {

-    *aCodecList = gH264Codecs;

-    return CANPLAY_MAYBE;

-  }

+  if (aCheckCodecList)

+    *aCheckCodecList = false;

+  if (aCodecList)

+    *aCodecList = nullptr;

+  if (nsGStreamerDecoder::CanHandleMediaType(aMIMEType, aCodecs))

+    return CANPLAY_YES;

 #endif

     return CANPLAY_MAYBE;

 #endif

   if (IsOggType(nsDependentCString(aMIMEType)))

     return true;

 #endif

 #ifdef MOZ_WEBM

   if (IsWebMType(nsDependentCString(aMIMEType)))

     return true;

 #endif

 #ifdef MOZ_GSTREAMER

-  if (IsH264Type(nsDependentCString(aMIMEType)))

+  if (nsGStreamerDecoder::CanHandleMediaType(aMIMEType, nullptr))

     return true;

 #endif

     return true;

 #endif

 {

   nsContentTypeParser parser(aType);

   nsAutoString mimeType;

   nsresult rv = parser.GetType(mimeType);

   if (NS_FAILED(rv))

     return CANPLAY_NO;

   NS_ConvertUTF16toUTF8 mimeTypeUTF8(mimeType);

+  nsAutoString codecs;

+  rv = parser.GetParameter("codecs", codecs);

+  NS_ConvertUTF16toUTF8 codecsUTF8(codecs);

   char const *const * supportedCodecs;

+  bool checkSupportedCodecs = true;

   CanPlayStatus status = CanHandleMediaType(mimeTypeUTF8.get(),

-                                            &supportedCodecs);

+                                            codecsUTF8.get(),

+                                            &supportedCodecs,

+                                            &checkSupportedCodecs);

   if (status == CANPLAY_NO)

     return CANPLAY_NO;

-  nsAutoString codecs;

-  rv = parser.GetParameter("codecs", codecs);

-  if (NS_FAILED(rv)) {

-    // Parameter not found or whatever

+  if (codecs.IsEmpty() || !checkSupportedCodecs) {

+    /* no codecs to check for or they were already checked in CanHandleMediaType

+     * above */

     return status;

   }

   CanPlayStatus result = CANPLAY_YES;

   // See http://www.rfc-editor.org/rfc/rfc4281.txt for the description

   // of the 'codecs' parameter

   nsCharSeparatedTokenizer tokenizer(codecs, ',');

   bool expectMoreTokens = false;

     if (decoder->Init(this)) {

       return decoder.forget();

     }

   }

 #endif

 #ifdef MOZ_GSTREAMER 

-  if (IsH264Type(aType)) {

+  const char *type;

+  NS_CStringGetData(aType, &type, NULL);

+  if (nsGStreamerDecoder::CanHandleMediaType(type, NULL)) {

     nsRefPtr<nsGStreamerDecoder> decoder = new nsGStreamerDecoder();

     if (decoder->Init(this)) {

       return decoder.forget();

     }

   }

 #endif

   return nullptr;

 }

diff --git a/content/media/gstreamer/Makefile.in b/content/media/gstreamer/Makefile.in

--- a/content/media/gstreamer/Makefile.in

+++ b/content/media/gstreamer/Makefile.in

@@ -17,16 +17,17 @@ LIBXUL_LIBRARY 	= 1

 EXPORTS		+= \

 		nsGStreamerDecoder.h \

 		$(NULL)

 CPPSRCS		= \

 		nsGStreamerReader.cpp \

 		nsGStreamerDecoder.cpp \

+		nsGStreamerFormatHelper.cpp \

 		$(NULL)

 FORCE_STATIC_LIB = 1

 include $(topsrcdir)/config/rules.mk

 CFLAGS		+= $(GSTREAMER_CFLAGS)

 CXXFLAGS	+= $(GSTREAMER_CFLAGS)

diff --git a/content/media/gstreamer/nsGStreamerDecoder.cpp b/content/media/gstreamer/nsGStreamerDecoder.cpp

--- a/content/media/gstreamer/nsGStreamerDecoder.cpp

+++ b/content/media/gstreamer/nsGStreamerDecoder.cpp

@@ -2,13 +2,19 @@

 /* 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 "nsBuiltinDecoderStateMachine.h"

 #include "nsGStreamerReader.h"

 #include "nsGStreamerDecoder.h"

+#include "nsGStreamerFormatHelper.h"

 nsDecoderStateMachine* nsGStreamerDecoder::CreateStateMachine()

 {

   return new nsBuiltinDecoderStateMachine(this, new nsGStreamerReader(this));

 }

+

+bool nsGStreamerDecoder::CanHandleMediaType(const char* aMIMEType,

+                                            const char* aCodecs) {

+  return nsGStreamerFormatHelper::Instance()->CanHandleMediaType(aMIMEType, aCodecs);

+}

diff --git a/content/media/gstreamer/nsGStreamerDecoder.h b/content/media/gstreamer/nsGStreamerDecoder.h

--- a/content/media/gstreamer/nsGStreamerDecoder.h

+++ b/content/media/gstreamer/nsGStreamerDecoder.h

@@ -9,11 +9,12 @@

 #include "nsBuiltinDecoder.h"

 class nsGStreamerDecoder : public nsBuiltinDecoder

 {

 public:

   virtual nsMediaDecoder* Clone() { return new nsGStreamerDecoder(); }

   virtual nsDecoderStateMachine* CreateStateMachine();

+  static bool CanHandleMediaType(const char* aMIMEType, const char* aCodecs);

 };

 #endif

diff --git a/content/media/gstreamer/nsGStreamerFormatHelper.cpp b/content/media/gstreamer/nsGStreamerFormatHelper.cpp

new file mode 100644

--- /dev/null

+++ b/content/media/gstreamer/nsGStreamerFormatHelper.cpp

@@ -0,0 +1,149 @@

+/* -*- 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 "nsGStreamerFormatHelper.h"

+#include "nsCharSeparatedTokenizer.h"

+#include "nsXPCOMStrings.h"

+

+#define ENTRY_FORMAT(entry) entry[0]

+#define ENTRY_CAPS(entry) entry[1]

+

+nsGStreamerFormatHelper* nsGStreamerFormatHelper::gInstance = NULL;

+

+nsGStreamerFormatHelper *nsGStreamerFormatHelper::Instance() {

+  if (!gInstance) {

+    gst_init(NULL, NULL);

+    gInstance = new nsGStreamerFormatHelper();

+  }

+

+  return gInstance;

+}

+

+nsGStreamerFormatHelper::nsGStreamerFormatHelper()

+  : mFactories(NULL),

+    mCookie(0)

+{

+  const char *containers[3][2] = {

+    {"video/mp4", "video/quicktime"},

+    {"audio/mp4", "audio/mpeg, mpegversion=(int)4"},

+    {"audio/mpeg", "audio/mpeg, mpegversion=(int)1"},

+  };

+  memcpy(mContainers, containers, sizeof(containers));

+

+  const char *codecs[7][2] = {

+    {"avc1.42E01E", "video/x-h264"},

+    {"avc1.42001E", "video/x-h264"},

+    {"avc1.58A01E", "video/x-h264"},

+    {"avc1.4D401E", "video/x-h264"},

+    {"avc1.64001E", "video/x-h264"},

+    {"mp4a.40.2", "audio/mpeg, mpegversion=(int)4"},

+    {"mp3", "audio/mpeg, mpegversion=(int)1"},

+  };

+  memcpy(mCodecs, codecs, sizeof(codecs));

+}

+

+nsGStreamerFormatHelper::~nsGStreamerFormatHelper() {

+  if (mFactories)

+    g_list_free(mFactories);

+}

+

+bool nsGStreamerFormatHelper::CanHandleMediaType(const char* aMIMEType,

+                                                 const char *aCodecs) {

+  GstCaps *caps = ConvertFormatsToCaps(aMIMEType, aCodecs);

+  if (!caps) {

+    return false;

+  }

+

+  bool ret = HaveElementsToProcessCaps(caps);

+  gst_caps_unref(caps);

+

+  return ret;

+}

+

+GstCaps *nsGStreamerFormatHelper::ConvertFormatsToCaps(const char *aMIMEType,

+                                                       const char *aCodecs) {

+  unsigned int i;

+

+  /* convert aMIMEType to gst container caps */

+  const char *capsString = NULL;

+  for (i = 0; i < G_N_ELEMENTS(mContainers); i++) {

+    if (!strcmp(ENTRY_FORMAT(mContainers[i]), aMIMEType)) {

+      capsString = ENTRY_CAPS(mContainers[i]);

+      break;

+    }

+  }

+

+  if (!capsString) {

+    /* we couldn't find any matching caps */

+    return NULL;

+  }

+

+  GstCaps *caps = gst_caps_from_string(capsString);

+  /* container only */

+  if (!aCodecs) {

+    return caps;

+  }

+

+  nsDependentCSubstring codecs(aCodecs, strlen(aCodecs));

+  nsCCharSeparatedTokenizer tokenizer(codecs, ',');

+  while (tokenizer.hasMoreTokens()) {

+    const nsCSubstring& codec = tokenizer.nextToken();

+    capsString = NULL;

+

+    for (i = 0; i < G_N_ELEMENTS(mCodecs); i++) {

+      if (codec.Equals(ENTRY_FORMAT(mCodecs[i]))) {

+        capsString = ENTRY_CAPS(mCodecs[i]);

+        break;

+      }

+    }

+

+    if (!capsString) {

+      gst_caps_unref(caps);

+      return NULL;

+    }

+

+    GstCaps *tmp = gst_caps_from_string(capsString);

+    /* appends and frees tmp */

+    gst_caps_append(caps, tmp);

+  }

+

+  return caps;

+}

+

+bool nsGStreamerFormatHelper::HaveElementsToProcessCaps(GstCaps *aCaps) {

+

+  GList *factories = GetFactories();

+

+  GList *list;

+  /* here aCaps contains [containerCaps, [codecCaps1, [codecCaps2, ...]]] so process

+   * caps structures individually as we want one element for _each_

+   * structure */

+  for (unsigned int i = 0; i < gst_caps_get_size(aCaps); i++) {

+    GstStructure *s = gst_caps_get_structure(aCaps, i);

+    GstCaps *caps = gst_caps_new_full(gst_structure_copy(s), NULL);

+    list = gst_element_factory_list_filter (factories, caps, GST_PAD_SINK, FALSE);

+    gst_caps_unref(caps);

+    if (!list) {

+      return false;

+    }

+    g_list_free(list);

+  }

+

+  return true;

+}

+

+GList * nsGStreamerFormatHelper::GetFactories() {

+  uint32_t cookie = gst_default_registry_get_feature_list_cookie ();

+  if (cookie != mCookie) {

+    g_list_free(mFactories);

+    mFactories = gst_element_factory_list_get_elements

+        (GST_ELEMENT_FACTORY_TYPE_DEMUXER | GST_ELEMENT_FACTORY_TYPE_DECODER,

+         GST_RANK_MARGINAL);

+    mCookie = cookie;

+  }

+

+  return mFactories;

+}

diff --git a/content/media/gstreamer/nsGStreamerFormatHelper.h b/content/media/gstreamer/nsGStreamerFormatHelper.h

new file mode 100644

--- /dev/null

+++ b/content/media/gstreamer/nsGStreamerFormatHelper.h

@@ -0,0 +1,37 @@

+/* -*- 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/. */

+