Bug 1513042 - Update mp4parse-rust to v0.11.2. r=jya

Update mp4parse-rust update script and pull the new version.

This update changes the mp4parse C-API. Specifically, each track can now
have multiple sample descriptions. Previously we'd just exposed the first for
the entire track, and if others were available they were not exposed via the
API. Because of the API change, we update the C++ interface with mp4parse-rust.

We now inspect the sample info to make sure they're consistent with the parsers
expectations:
- Only a single codec is present for a track, multiple codecs in a track will
  result in us returning an error.
- Only 0 or 1 crypto info is present for a track, more than one set of info will
  result in us returning an error.

We still generalize some of the first sample info to the samples of the track,
as we did before this patch. However, we will now catch the above cases
explicitly.

We now handle crypto information if it is not present on the first sample info.
The parser will iterate through sample infos and use the first set of crypto
info it finds (and fail if it finds 2+).

Differential Revision: https://phabricator.services.mozilla.com/D14107

--HG--
extra : moz-landing-system : lando

Author: Bryce Van Dyk

Cargo.lock

@@ -57,81 +57,150 @@ static void UpdateTrackProtectedInfo(mozilla::TrackInfo& aConfig,
   }
 }
 
-void MP4AudioInfo::Update(const Mp4parseTrackInfo* track,
-                          const Mp4parseTrackAudioInfo* audio) {
-  UpdateTrackProtectedInfo(*this, audio->protected_data);
+MediaResult MP4AudioInfo::Update(const Mp4parseTrackInfo* track,
+                                 const Mp4parseTrackAudioInfo* audio) {
+  MOZ_DIAGNOSTIC_ASSERT(audio->sample_info_count > 0,
+                        "Must have at least one audio sample info");
+  if (audio->sample_info_count == 0) {
+    return MediaResult(
+        NS_ERROR_DOM_MEDIA_METADATA_ERR,
+        RESULT_DETAIL("Got 0 audio sample info while updating audio track"));
+  }
+
+  bool hasCrypto = false;
+  Mp4parseCodec codecType = audio->sample_info[0].codec_type;
+  for (uint32_t i = 0; i < audio->sample_info_count; i++) {
+    if (audio->sample_info[0].codec_type != codecType) {
+      // Different codecs in a single track. We don't handle this.
+      return MediaResult(
+          NS_ERROR_DOM_MEDIA_METADATA_ERR,
+          RESULT_DETAIL(
+              "Multiple codecs encountered while updating audio track"));
+    }
 
-  if (track->codec == MP4PARSE_CODEC_OPUS) {
+    // Update our encryption info if any is present on the sample info.
+    if (audio->sample_info[i].protected_data.is_encrypted) {
+      if (hasCrypto) {
+        // Multiple crypto entries found. We don't handle this.
+        return MediaResult(
+            NS_ERROR_DOM_MEDIA_METADATA_ERR,
+            RESULT_DETAIL(
+                "Multiple crypto info encountered while updating audio track"));
+      }
+      UpdateTrackProtectedInfo(*this, audio->sample_info[i].protected_data);
+      hasCrypto = true;
+    }
+  }
+
+  // We assume that the members of the first sample info are representative of
+  // the entire track. This code will need to be updated should this assumption
+  // ever not hold. E.g. if we need to handle different codecs in a single
+  // track, or if we have different numbers or channels in a single track.
+  Mp4parseByteData codecSpecificConfig =
+      audio->sample_info[0].codec_specific_config;
+  if (codecType == MP4PARSE_CODEC_OPUS) {
     mMimeType = NS_LITERAL_CSTRING("audio/opus");
     // The Opus decoder expects the container's codec delay or
     // pre-skip value, in microseconds, as a 64-bit int at the
     // start of the codec-specific config blob.
-    if (audio->codec_specific_config.data &&
-        audio->codec_specific_config.length >= 12) {
-      uint16_t preskip = mozilla::LittleEndian::readUint16(
-          audio->codec_specific_config.data + 10);
+    if (codecSpecificConfig.data && codecSpecificConfig.length >= 12) {
+      uint16_t preskip =
+          mozilla::LittleEndian::readUint16(codecSpecificConfig.data + 10);
       mozilla::OpusDataDecoder::AppendCodecDelay(
           mCodecSpecificConfig, mozilla::FramesToUsecs(preskip, 48000).value());
     } else {
       // This file will error later as it will be rejected by the opus decoder.
       mozilla::OpusDataDecoder::AppendCodecDelay(mCodecSpecificConfig, 0);
     }
-  } else if (track->codec == MP4PARSE_CODEC_AAC) {
+  } else if (codecType == MP4PARSE_CODEC_AAC) {
     mMimeType = NS_LITERAL_CSTRING("audio/mp4a-latm");
-  } else if (track->codec == MP4PARSE_CODEC_FLAC) {
+  } else if (codecType == MP4PARSE_CODEC_FLAC) {
     mMimeType = NS_LITERAL_CSTRING("audio/flac");
-  } else if (track->codec == MP4PARSE_CODEC_MP3) {
+  } else if (codecType == MP4PARSE_CODEC_MP3) {
     mMimeType = NS_LITERAL_CSTRING("audio/mpeg");
   }
 
-  mRate = audio->sample_rate;
-  mChannels = audio->channels;
-  mBitDepth = audio->bit_depth;
-  mExtendedProfile = audio->extended_profile;
+  mRate = audio->sample_info[0].sample_rate;
+  mChannels = audio->sample_info[0].channels;
+  mBitDepth = audio->sample_info[0].bit_depth;
+  mExtendedProfile = audio->sample_info[0].extended_profile;
   mDuration = TimeUnit::FromMicroseconds(track->duration);
   mMediaTime = TimeUnit::FromMicroseconds(track->media_time);
   mTrackId = track->track_id;
 
   // In stagefright, mProfile is kKeyAACProfile, mExtendedProfile is kKeyAACAOT.
-  if (audio->profile <= 4) {
-    mProfile = audio->profile;
+  if (audio->sample_info[0].profile <= 4) {
+    mProfile = audio->sample_info[0].profile;
   }
 
-  if (audio->extra_data.length > 0) {
-    mExtraData->AppendElements(audio->extra_data.data,
-                               audio->extra_data.length);
+  Mp4parseByteData extraData = audio->sample_info[0].extra_data;
+  // If length is 0 we append nothing
+  mExtraData->AppendElements(extraData.data, extraData.length);
+  mCodecSpecificConfig->AppendElements(codecSpecificConfig.data,
+                                       codecSpecificConfig.length);
+  return NS_OK;
+}
+
+MediaResult MP4VideoInfo::Update(const Mp4parseTrackInfo* track,
+                                 const Mp4parseTrackVideoInfo* video) {
+  MOZ_DIAGNOSTIC_ASSERT(video->sample_info_count > 0,
+                        "Must have at least one video sample info");
+  if (video->sample_info_count == 0) {
+    return MediaResult(
+        NS_ERROR_DOM_MEDIA_METADATA_ERR,
+        RESULT_DETAIL("Got 0 audio sample info while updating video track"));
   }
 
-  if (audio->codec_specific_config.length > 0) {
-    mCodecSpecificConfig->AppendElements(audio->codec_specific_config.data,
-                                         audio->codec_specific_config.length);
+  bool hasCrypto = false;
+  Mp4parseCodec codecType = video->sample_info[0].codec_type;
+  for (uint32_t i = 0; i < video->sample_info_count; i++) {
+    if (video->sample_info[0].codec_type != codecType) {
+      // Different codecs in a single track. We don't handle this.
+      return MediaResult(
+          NS_ERROR_DOM_MEDIA_METADATA_ERR,
+          RESULT_DETAIL(
+              "Multiple codecs encountered while updating video track"));
+    }
+
+    // Update our encryption info if any is present on the sample info.
+    if (video->sample_info[i].protected_data.is_encrypted) {
+      if (hasCrypto) {
+        // Multiple crypto entries found. We don't handle this.
+        return MediaResult(
+            NS_ERROR_DOM_MEDIA_METADATA_ERR,
+            RESULT_DETAIL(
+                "Multiple crypto info encountered while updating video track"));
+      }
+      UpdateTrackProtectedInfo(*this, video->sample_info[i].protected_data);
+      hasCrypto = true;
+    }
   }
-}
 
-void MP4VideoInfo::Update(const Mp4parseTrackInfo* track,
-                          const Mp4parseTrackVideoInfo* video) {
-  UpdateTrackProtectedInfo(*this, video->protected_data);
-  if (track->codec == MP4PARSE_CODEC_AVC) {
+  // We assume that the members of the first sample info are representative of
+  // the entire track. This code will need to be updated should this assumption
+  // ever not hold. E.g. if we need to handle different codecs in a single
+  // track, or if we have different numbers or channels in a single track.
+  if (codecType == MP4PARSE_CODEC_AVC) {
     mMimeType = NS_LITERAL_CSTRING("video/avc");
-  } else if (track->codec == MP4PARSE_CODEC_VP9) {
+  } else if (codecType == MP4PARSE_CODEC_VP9) {
     mMimeType = NS_LITERAL_CSTRING("video/vp9");
-  } else if (track->codec == MP4PARSE_CODEC_AV1) {
+  } else if (codecType == MP4PARSE_CODEC_AV1) {
     mMimeType = NS_LITERAL_CSTRING("video/av1");
-  } else if (track->codec == MP4PARSE_CODEC_MP4V) {
+  } else if (codecType == MP4PARSE_CODEC_MP4V) {
     mMimeType = NS_LITERAL_CSTRING("video/mp4v-es");
   }
   mTrackId = track->track_id;
   mDuration = TimeUnit::FromMicroseconds(track->duration);
   mMediaTime = TimeUnit::FromMicroseconds(track->media_time);
   mDisplay.width = video->display_width;
   mDisplay.height = video->display_height;
-  mImage.width = video->image_width;
-  mImage.height = video->image_height;
+  mImage.width = video->sample_info[0].image_width;
+  mImage.height = video->sample_info[0].image_height;
   mRotation = ToSupportedRotation(video->rotation);
-  if (video->extra_data.data) {
-    mExtraData->AppendElements(video->extra_data.data,
-                               video->extra_data.length);
-  }
+  Mp4parseByteData extraData = video->sample_info[0].extra_data;
+  // If length is 0 we append nothing
+  mExtraData->AppendElements(extraData.data, extraData.length);
+  return NS_OK;
 }
 
 bool MP4VideoInfo::IsValid() const {

dom/media/mp4/DecoderData.cpp

@@ -6,6 +6,7 @@
 #define DECODER_DATA_H_
 
 #include "MediaInfo.h"
+#include "MediaResult.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/Result.h"
 #include "mozilla/Types.h"
@@ -53,8 +54,8 @@ class MP4AudioInfo : public mozilla::AudioInfo {
  public:
   MP4AudioInfo() = default;
 
-  void Update(const Mp4parseTrackInfo* track,
-              const Mp4parseTrackAudioInfo* audio);
+  MediaResult Update(const Mp4parseTrackInfo* track,
+                     const Mp4parseTrackAudioInfo* audio);
 
   virtual bool IsValid() const override;
 };
@@ -63,8 +64,8 @@ class MP4VideoInfo : public mozilla::VideoInfo {
  public:
   MP4VideoInfo() = default;
 
-  void Update(const Mp4parseTrackInfo* track,
-              const Mp4parseTrackVideoInfo* video);
+  MediaResult Update(const Mp4parseTrackInfo* track,
+                     const Mp4parseTrackVideoInfo* video);
 
   virtual bool IsValid() const override;
 };