To M56: Roll src/third_party/ffmpeg/ 3c7a09882..cdf4accee (3188 commits).

media/ffmpeg/ffmpeg_common.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/ffmpeg/ffmpeg_common.h"
 
 #include "base/logging.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 387 matching lines @@
       break;
     default:
       DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
                 config->bits_per_channel());
       break;
   }
 
   return true;
 }
 
+std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext>
+AVStreamToAVCodecContext(const AVStream* stream) {
+  std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> codec_context(
+      avcodec_alloc_context3(nullptr));
+  if (avcodec_parameters_to_context(codec_context.get(), stream->codecpar) <
+      0) {
+    return nullptr;
+  }
+
+  return codec_context;
+}
+
 bool AVStreamToAudioDecoderConfig(const AVStream* stream,
                                   AudioDecoderConfig* config) {
+  std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> codec_context(
+      AVStreamToAVCodecContext(stream));
+  if (!codec_context)
+    return false;
+
   return AVCodecContextToAudioDecoderConfig(
-      stream->codec, GetEncryptionScheme(stream), config);
+      codec_context.get(), GetEncryptionScheme(stream), config);
 }
 
 void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
                                         AVCodecContext* codec_context) {
   codec_context->codec_type = AVMEDIA_TYPE_AUDIO;
   codec_context->codec_id = AudioCodecToCodecID(config.codec(),
                                                 config.sample_format());
   codec_context->sample_fmt = SampleFormatToAVSampleFormat(
       config.sample_format());
 
@@ skipping 12 matching lines @@
         av_malloc(config.extra_data().size() + FF_INPUT_BUFFER_PADDING_SIZE));
     memcpy(codec_context->extradata, &config.extra_data()[0],
            config.extra_data().size());
     memset(codec_context->extradata + config.extra_data().size(), '\0',
            FF_INPUT_BUFFER_PADDING_SIZE);
   }
 }
 
 bool AVStreamToVideoDecoderConfig(const AVStream* stream,
                                   VideoDecoderConfig* config) {
-  // Anticipating AVStream.codec.coded_{width,height} will be inaccessible in
-  // ffmpeg soon, just use the width and height, padded below, as hints of the
-  // coded size.
-  gfx::Size coded_size(stream->codec->width, stream->codec->height);
+  std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> codec_context(
+      AVStreamToAVCodecContext(stream));
+  if (!codec_context)
+    return false;
+
+  // AVStream.codec->coded_{width,height} access is deprecated in ffmpeg.
+  // Use just the width and height as hints of coded size.
+  gfx::Size coded_size(codec_context->width, codec_context->height);
 
   // TODO(vrk): This assumes decoded frame data starts at (0, 0), which is true
   // for now, but may not always be true forever. Fix this in the future.
-  gfx::Rect visible_rect(stream->codec->width, stream->codec->height);
+  gfx::Rect visible_rect(codec_context->width, codec_context->height);
 
   AVRational aspect_ratio = { 1, 1 };
   if (stream->sample_aspect_ratio.num)
     aspect_ratio = stream->sample_aspect_ratio;
-  else if (stream->codec->sample_aspect_ratio.num)
-    aspect_ratio = stream->codec->sample_aspect_ratio;
+  else if (codec_context->sample_aspect_ratio.num)
+    aspect_ratio = codec_context->sample_aspect_ratio;
 
-  VideoCodec codec = CodecIDToVideoCodec(stream->codec->codec_id);
+  VideoCodec codec = CodecIDToVideoCodec(codec_context->codec_id);
 
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   if (codec == kCodecVP8)
     profile = VP8PROFILE_ANY;
   else if (codec == kCodecVP9)
     // TODO(servolk): Find a way to obtain actual VP9 profile from FFmpeg.
     // crbug.com/592074
     profile = VP9PROFILE_PROFILE0;
   else
-    profile = ProfileIDToVideoCodecProfile(stream->codec->profile);
+    profile = ProfileIDToVideoCodecProfile(codec_context->profile);
 
   // Without the FFmpeg h264 decoder, AVFormat is unable to get the profile, so
   // default to baseline and let the VDA fail later if it doesn't support the
   // real profile. This is alright because if the FFmpeg h264 decoder isn't
   // enabled, there is no fallback if the VDA fails.
 #if defined(DISABLE_FFMPEG_VIDEO_DECODERS)
   if (codec == kCodecH264)
     profile = H264PROFILE_BASELINE;
 #endif
 
   gfx::Size natural_size = GetNaturalSize(
       visible_rect.size(), aspect_ratio.num, aspect_ratio.den);
 
   VideoPixelFormat format =
-      AVPixelFormatToVideoPixelFormat(stream->codec->pix_fmt);
+      AVPixelFormatToVideoPixelFormat(codec_context->pix_fmt);
   // The format and coded size may be unknown if FFmpeg is compiled without
   // video decoders.
 #if defined(DISABLE_FFMPEG_VIDEO_DECODERS)
   if (format == PIXEL_FORMAT_UNKNOWN)
     format = PIXEL_FORMAT_YV12;
   if (coded_size == gfx::Size(0, 0))
     coded_size = visible_rect.size();
 #endif
 
   if (codec == kCodecVP9) {
     // TODO(tomfinegan): libavcodec doesn't know about VP9.
     format = PIXEL_FORMAT_YV12;
     coded_size = visible_rect.size();
   }
 
   // Pad out |coded_size| for subsampled YUV formats.
   if (format != PIXEL_FORMAT_YV24) {
     coded_size.set_width((coded_size.width() + 1) / 2 * 2);
     if (format != PIXEL_FORMAT_YV16)
       coded_size.set_height((coded_size.height() + 1) / 2 * 2);
   }
 
   AVDictionaryEntry* webm_alpha =
       av_dict_get(stream->metadata, "alpha_mode", nullptr, 0);
   if (webm_alpha && !strcmp(webm_alpha->value, "1")) {
     format = PIXEL_FORMAT_YV12A;
   }
 
   // Prefer the color space found by libavcodec if available.
-  ColorSpace color_space = AVColorSpaceToColorSpace(stream->codec->colorspace,
-                                                    stream->codec->color_range);
+  ColorSpace color_space = AVColorSpaceToColorSpace(codec_context->colorspace,
+                                                    codec_context->color_range);
   if (color_space == COLOR_SPACE_UNSPECIFIED) {
     // Otherwise, assume that SD video is usually Rec.601, and HD is usually
     // Rec.709.
     color_space = (natural_size.height() < 720) ? COLOR_SPACE_SD_REC601
                                                 : COLOR_SPACE_HD_REC709;
   }
 
-  // AVStream occasionally has invalid extra data. See http://crbug.com/517163
-  if ((stream->codec->extradata_size == 0) !=
-      (stream->codec->extradata == nullptr)) {
-    LOG(ERROR) << __func__
-               << (stream->codec->extradata == nullptr ? " NULL" : " Non-Null")
-               << " extra data cannot have size of "
-               << stream->codec->extradata_size << ".";
+  // AVCodecContext occasionally has invalid extra data. See
+  // http://crbug.com/517163
+  if (codec_context->extradata != nullptr &&
+      codec_context->extradata_size == 0) {
+    LOG(ERROR) << __func__ << " Non-Null extra data cannot have size of 0.";
     return false;
   }
+  CHECK_EQ(codec_context->extradata == nullptr,
+           codec_context->extradata_size == 0);
 
   std::vector<uint8_t> extra_data;
-  if (stream->codec->extradata_size > 0) {
-    extra_data.assign(stream->codec->extradata,
-                      stream->codec->extradata + stream->codec->extradata_size);
+  if (codec_context->extradata_size > 0) {
+    extra_data.assign(codec_context->extradata,
+                      codec_context->extradata + codec_context->extradata_size);
   }
   config->Initialize(codec, profile, format, color_space, coded_size,
                      visible_rect, natural_size, extra_data,
                      GetEncryptionScheme(stream));
   return true;
 }
 
 void VideoDecoderConfigToAVCodecContext(
     const VideoDecoderConfig& config,
     AVCodecContext* codec_context) {
@@ skipping 179 matching lines @@
       return COLOR_SPACE_HD_REC709;
     case AVCOL_SPC_SMPTE170M:
     case AVCOL_SPC_BT470BG:
       return COLOR_SPACE_SD_REC601;
     default:
       DVLOG(1) << "Unknown AVColorSpace: " << color_space;
   }
   return COLOR_SPACE_UNSPECIFIED;
 }
 
-bool FFmpegUTCDateToTime(const char* date_utc, base::Time* out) {
-  DCHECK(date_utc);
-  DCHECK(out);
-
-  std::vector<base::StringPiece> fields = base::SplitStringPiece(
-      date_utc, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (fields.size() != 2)
-    return false;
-
-  std::vector<base::StringPiece> date_fields = base::SplitStringPiece(
-      fields[0], "-", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (date_fields.size() != 3)
-    return false;
-
-  // TODO(acolwell): Update this parsing code when FFmpeg returns sub-second
-  // information.
-  std::vector<base::StringPiece> time_fields = base::SplitStringPiece(
-      fields[1], ":", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (time_fields.size() != 3)
-    return false;
-
-  base::Time::Exploded exploded;
-  exploded.millisecond = 0;
-  // This field cannot be uninitialized. Unless not modified, make it 0 here
-  // then.
-  exploded.day_of_week = 0;
-  if (base::StringToInt(date_fields[0], &exploded.year) &&
-      base::StringToInt(date_fields[1], &exploded.month) &&
-      base::StringToInt(date_fields[2], &exploded.day_of_month) &&
-      base::StringToInt(time_fields[0], &exploded.hour) &&
-      base::StringToInt(time_fields[1], &exploded.minute) &&
-      base::StringToInt(time_fields[2], &exploded.second)) {
-    if (base::Time::FromUTCExploded(exploded, out))
-      return true;
-  }
-
-  return false;
-}
-
 int32_t HashCodecName(const char* codec_name) {
   // Use the first 32-bits from the SHA1 hash as the identifier.
   int32_t hash;
   memcpy(&hash, base::SHA1HashString(codec_name).substr(0, 4).c_str(), 4);
   return hash;
 }
 
 #define TEST_PRIMARY(P)                                                 \
   static_assert(                                                        \
       static_cast<int>(gfx::ColorSpace::PrimaryID::P) == AVCOL_PRI_##P, \
@@ skipping 46 matching lines @@
 TEST_COLORSPACE(RESERVED);
 TEST_COLORSPACE(FCC);
 TEST_COLORSPACE(BT470BG);
 TEST_COLORSPACE(SMPTE170M);
 TEST_COLORSPACE(SMPTE240M);
 TEST_COLORSPACE(YCOCG);
 TEST_COLORSPACE(BT2020_NCL);
 TEST_COLORSPACE(BT2020_CL);
 
 }  // namespace media