--- a/dom/media/platforms/wrappers/H264Converter.cpp
+++ b/dom/media/platforms/wrappers/H264Converter.cpp
@@ -115,21 +115,22 @@ H264Converter::Decode(MediaRawData* aSam
   if (NS_FAILED(rv)) {
     return DecodePromise::CreateAndReject(rv, __func__);
   }
 
   if (mNeedKeyframe && !aSample->mKeyframe) {
     return DecodePromise::CreateAndResolve(DecodedData(), __func__);
   }
 
-  if (!*mNeedAVCC &&
-      mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe).isErr()) {
+  auto res = !*mNeedAVCC
+             ? mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
+             : Ok();
+  if (res.isErr()) {
     return DecodePromise::CreateAndReject(
-      MediaResult(NS_ERROR_OUT_OF_MEMORY,
-                  RESULT_DETAIL("ConvertSampleToAnnexB")),
+      MediaResult(res.unwrapErr(), RESULT_DETAIL("ConvertSampleToAnnexB")),
       __func__);
   }
 
   mNeedKeyframe = false;
 
   aSample->mExtraData = mCurrentConfig.mExtraData;
 
   return mDecoder->Decode(aSample);
@@ -369,21 +370,23 @@ void
 H264Converter::DecodeFirstSample(MediaRawData* aSample)
 {
   if (mNeedKeyframe && !aSample->mKeyframe) {
     mDecodePromise.Resolve(mPendingFrames, __func__);
     mPendingFrames.Clear();
     return;
   }
 
-  if (!*mNeedAVCC &&
-      mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe).isErr()) {
-    mDecodePromise.Reject(MediaResult(NS_ERROR_OUT_OF_MEMORY,
-                                      RESULT_DETAIL("ConvertSampleToAnnexB")),
-                          __func__);
+  auto res = !*mNeedAVCC
+             ? mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
+             : Ok();
+  if (res.isErr()) {
+    mDecodePromise.Reject(
+      MediaResult(res.unwrapErr(), RESULT_DETAIL("ConvertSampleToAnnexB")),
+      __func__);
     return;
   }
 
   mNeedKeyframe = false;
 
   RefPtr<H264Converter> self = this;
   mDecoder->Decode(aSample)
     ->Then(AbstractThread::GetCurrent()->AsTaskQueue(), __func__,

--- a/media/libstagefright/binding/AnnexB.cpp
+++ b/media/libstagefright/binding/AnnexB.cpp
@@ -42,38 +42,38 @@ AnnexB::ConvertSampleToAnnexB(mozilla::M
   ByteWriter writer(tmp);
 
   while (reader.Remaining() >= 4) {
     uint32_t nalLen;
     MOZ_TRY_VAR(nalLen, reader.ReadU32());
     const uint8_t* p = reader.Read(nalLen);
 
     if (!writer.Write(kAnnexBDelimiter, ArrayLength(kAnnexBDelimiter))) {
-      return Err(NS_ERROR_FAILURE);
+      return Err(NS_ERROR_OUT_OF_MEMORY);
     }
     if (!p) {
       break;
     }
     if (!writer.Write(p, nalLen)) {
-      return Err(NS_ERROR_FAILURE);
+      return Err(NS_ERROR_OUT_OF_MEMORY);
     }
   }
 
   nsAutoPtr<MediaRawDataWriter> samplewriter(aSample->CreateWriter());
 
   if (!samplewriter->Replace(tmp.Elements(), tmp.Length())) {
-    return Err(NS_ERROR_FAILURE);
+    return Err(NS_ERROR_OUT_OF_MEMORY);
   }
 
   // Prepend the Annex B NAL with SPS and PPS tables to keyframes.
   if (aAddSPS && aSample->mKeyframe) {
     RefPtr<MediaByteBuffer> annexB =
       ConvertExtraDataToAnnexB(aSample->mExtraData);
     if (!samplewriter->Prepend(annexB->Elements(), annexB->Length())) {
-      return Err(NS_ERROR_FAILURE);
+      return Err(NS_ERROR_OUT_OF_MEMORY);
     }
 
     // Prepending the NAL with SPS/PPS will mess up the encryption subsample
     // offsets. So we need to account for the extra bytes by increasing
     // the length of the first clear data subsample. Otherwise decryption
     // will fail.
     if (aSample->mCrypto.mValid) {
       MOZ_ASSERT(samplewriter->mCrypto.mPlainSizes.Length() > 0);
@@ -217,27 +217,27 @@ ParseNALUnits(ByteWriter& aBw, BufferRea
   if (rv.isOk()) {
     size_t startOffset = aBr.Offset();
     while (FindStartCode(aBr, startSize).isOk()) {
       size_t offset = aBr.Offset();
       size_t sizeNAL = offset - startOffset - startSize;
       aBr.Seek(startOffset);
       if (!aBw.WriteU32(sizeNAL)
           || !aBw.Write(aBr.Read(sizeNAL), sizeNAL)) {
-        return Err(NS_ERROR_FAILURE);
+        return Err(NS_ERROR_OUT_OF_MEMORY);
       }
       aBr.Read(startSize);
       startOffset = offset;
     }
   }
   size_t sizeNAL = aBr.Remaining();
   if (sizeNAL) {
     if (!aBw.WriteU32(sizeNAL)
         || !aBw.Write(aBr.Read(sizeNAL), sizeNAL)) {
-      return Err(NS_ERROR_FAILURE);
+      return Err(NS_ERROR_OUT_OF_MEMORY);
     }
   }
   return Ok();
 }
 
 bool
 AnnexB::ConvertSampleToAVCC(mozilla::MediaRawData* aSample)
 {
@@ -300,22 +300,22 @@ AnnexB::ConvertSampleTo4BytesAVCC(mozill
       case 4: MOZ_TRY_VAR(nalLen, reader.ReadU32()); break;
     }
     const uint8_t* p = reader.Read(nalLen);
     if (!p) {
       return Ok();
     }
     if (!writer.WriteU32(nalLen)
         || !writer.Write(p, nalLen)) {
-      return Err(NS_ERROR_FAILURE);
+      return Err(NS_ERROR_OUT_OF_MEMORY);
     }
   }
   nsAutoPtr<MediaRawDataWriter> samplewriter(aSample->CreateWriter());
   if (!samplewriter->Replace(dest.Elements(), dest.Length())) {
-    return Err(NS_ERROR_FAILURE);
+    return Err(NS_ERROR_OUT_OF_MEMORY);
   }
   return Ok();
 }
 
 bool
 AnnexB::IsAVCC(const mozilla::MediaRawData* aSample)
 {
   return aSample->Size() >= 3 && aSample->mExtraData &&