ffmpeg_video_decoder.cc revision 116680a4aac90f2aa7413d9095a592090648e557
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "media/filters/ffmpeg_video_decoder.h" 6 7#include <algorithm> 8#include <string> 9 10#include "base/bind.h" 11#include "base/callback_helpers.h" 12#include "base/command_line.h" 13#include "base/location.h" 14#include "base/single_thread_task_runner.h" 15#include "base/strings/string_number_conversions.h" 16#include "media/base/bind_to_current_loop.h" 17#include "media/base/decoder_buffer.h" 18#include "media/base/limits.h" 19#include "media/base/media_switches.h" 20#include "media/base/pipeline.h" 21#include "media/base/video_decoder_config.h" 22#include "media/base/video_frame.h" 23#include "media/base/video_util.h" 24#include "media/ffmpeg/ffmpeg_common.h" 25#include "media/filters/ffmpeg_glue.h" 26 27namespace media { 28 29// Always try to use three threads for video decoding. There is little reason 30// not to since current day CPUs tend to be multi-core and we measured 31// performance benefits on older machines such as P4s with hyperthreading. 32// 33// Handling decoding on separate threads also frees up the pipeline thread to 34// continue processing. Although it'd be nice to have the option of a single 35// decoding thread, FFmpeg treats having one thread the same as having zero 36// threads (i.e., avcodec_decode_video() will execute on the calling thread). 37// Yet another reason for having two threads :) 38static const int kDecodeThreads = 2; 39static const int kMaxDecodeThreads = 16; 40 41// Returns the number of threads given the FFmpeg CodecID. Also inspects the 42// command line for a valid --video-threads flag. 43static int GetThreadCount(AVCodecID codec_id) { 44 // Refer to http://crbug.com/93932 for tsan suppressions on decoding. 45 int decode_threads = kDecodeThreads; 46 47 const CommandLine* cmd_line = CommandLine::ForCurrentProcess(); 48 std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads)); 49 if (threads.empty() || !base::StringToInt(threads, &decode_threads)) 50 return decode_threads; 51 52 decode_threads = std::max(decode_threads, 0); 53 decode_threads = std::min(decode_threads, kMaxDecodeThreads); 54 return decode_threads; 55} 56 57static int GetVideoBufferImpl(struct AVCodecContext* s, 58 AVFrame* frame, 59 int flags) { 60 FFmpegVideoDecoder* decoder = static_cast<FFmpegVideoDecoder*>(s->opaque); 61 return decoder->GetVideoBuffer(s, frame, flags); 62} 63 64static void ReleaseVideoBufferImpl(void* opaque, uint8* data) { 65 scoped_refptr<VideoFrame> video_frame; 66 video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque)); 67} 68 69static size_t RoundUp(size_t value, size_t alignment) { 70 // Check that |alignment| is a power of 2. 71 DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1))); 72 return ((value + (alignment - 1)) & ~(alignment - 1)); 73} 74 75FFmpegVideoDecoder::FFmpegVideoDecoder( 76 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) 77 : task_runner_(task_runner), state_(kUninitialized), 78 decode_nalus_(false) {} 79 80int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context, 81 AVFrame* frame, 82 int flags) { 83 // Don't use |codec_context_| here! With threaded decoding, 84 // it will contain unsynchronized width/height/pix_fmt values, 85 // whereas |codec_context| contains the current threads's 86 // updated width/height/pix_fmt, which can change for adaptive 87 // content. 88 VideoFrame::Format format = PixelFormatToVideoFormat(codec_context->pix_fmt); 89 if (format == VideoFrame::UNKNOWN) 90 return AVERROR(EINVAL); 91 DCHECK(format == VideoFrame::YV12 || format == VideoFrame::YV16 || 92 format == VideoFrame::YV12J || format == VideoFrame::YV24); 93 94 gfx::Size size(codec_context->width, codec_context->height); 95 const int ret = av_image_check_size(size.width(), size.height(), 0, NULL); 96 if (ret < 0) 97 return ret; 98 99 gfx::Size natural_size; 100 if (codec_context->sample_aspect_ratio.num > 0) { 101 natural_size = GetNaturalSize(size, 102 codec_context->sample_aspect_ratio.num, 103 codec_context->sample_aspect_ratio.den); 104 } else { 105 natural_size = config_.natural_size(); 106 } 107 108 // FFmpeg has specific requirements on the allocation size of the frame. The 109 // following logic replicates FFmpeg's allocation strategy to ensure buffers 110 // are not overread / overwritten. See ff_init_buffer_info() for details. 111 // 112 // When lowres is non-zero, dimensions should be divided by 2^(lowres), but 113 // since we don't use this, just DCHECK that it's zero. 114 // 115 // Always round up to a multiple of two to match VideoFrame restrictions on 116 // frame alignment. 117 DCHECK_EQ(codec_context->lowres, 0); 118 gfx::Size coded_size( 119 RoundUp(std::max(size.width(), codec_context->coded_width), 2), 120 RoundUp(std::max(size.height(), codec_context->coded_height), 2)); 121 122 if (!VideoFrame::IsValidConfig( 123 format, coded_size, gfx::Rect(size), natural_size)) 124 return AVERROR(EINVAL); 125 126 scoped_refptr<VideoFrame> video_frame = frame_pool_.CreateFrame( 127 format, coded_size, gfx::Rect(size), natural_size, kNoTimestamp()); 128 129 for (int i = 0; i < 3; i++) { 130 frame->data[i] = video_frame->data(i); 131 frame->linesize[i] = video_frame->stride(i); 132 } 133 134 frame->width = coded_size.width(); 135 frame->height = coded_size.height(); 136 frame->format = codec_context->pix_fmt; 137 frame->reordered_opaque = codec_context->reordered_opaque; 138 139 // Now create an AVBufferRef for the data just allocated. It will own the 140 // reference to the VideoFrame object. 141 void* opaque = NULL; 142 video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque)); 143 frame->buf[0] = 144 av_buffer_create(frame->data[0], 145 VideoFrame::AllocationSize(format, coded_size), 146 ReleaseVideoBufferImpl, 147 opaque, 148 0); 149 return 0; 150} 151 152void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config, 153 bool low_delay, 154 const PipelineStatusCB& status_cb, 155 const OutputCB& output_cb) { 156 DCHECK(task_runner_->BelongsToCurrentThread()); 157 DCHECK(!config.is_encrypted()); 158 DCHECK(!output_cb.is_null()); 159 160 FFmpegGlue::InitializeFFmpeg(); 161 162 config_ = config; 163 PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb); 164 165 if (!config.IsValidConfig() || !ConfigureDecoder(low_delay)) { 166 initialize_cb.Run(DECODER_ERROR_NOT_SUPPORTED); 167 return; 168 } 169 170 output_cb_ = BindToCurrentLoop(output_cb); 171 172 // Success! 173 state_ = kNormal; 174 initialize_cb.Run(PIPELINE_OK); 175} 176 177void FFmpegVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer, 178 const DecodeCB& decode_cb) { 179 DCHECK(task_runner_->BelongsToCurrentThread()); 180 DCHECK(buffer); 181 DCHECK(!decode_cb.is_null()); 182 CHECK_NE(state_, kUninitialized); 183 184 DecodeCB decode_cb_bound = BindToCurrentLoop(decode_cb); 185 186 if (state_ == kError) { 187 decode_cb_bound.Run(kDecodeError); 188 return; 189 } 190 191 if (state_ == kDecodeFinished) { 192 decode_cb_bound.Run(kOk); 193 return; 194 } 195 196 DCHECK_EQ(state_, kNormal); 197 198 // During decode, because reads are issued asynchronously, it is possible to 199 // receive multiple end of stream buffers since each decode is acked. When the 200 // first end of stream buffer is read, FFmpeg may still have frames queued 201 // up in the decoder so we need to go through the decode loop until it stops 202 // giving sensible data. After that, the decoder should output empty 203 // frames. There are three states the decoder can be in: 204 // 205 // kNormal: This is the starting state. Buffers are decoded. Decode errors 206 // are discarded. 207 // kDecodeFinished: All calls return empty frames. 208 // kError: Unexpected error happened. 209 // 210 // These are the possible state transitions. 211 // 212 // kNormal -> kDecodeFinished: 213 // When EOS buffer is received and the codec has been flushed. 214 // kNormal -> kError: 215 // A decoding error occurs and decoding needs to stop. 216 // (any state) -> kNormal: 217 // Any time Reset() is called. 218 219 bool has_produced_frame; 220 do { 221 has_produced_frame = false; 222 if (!FFmpegDecode(buffer, &has_produced_frame)) { 223 state_ = kError; 224 decode_cb_bound.Run(kDecodeError); 225 return; 226 } 227 // Repeat to flush the decoder after receiving EOS buffer. 228 } while (buffer->end_of_stream() && has_produced_frame); 229 230 if (buffer->end_of_stream()) 231 state_ = kDecodeFinished; 232 233 decode_cb_bound.Run(kOk); 234} 235 236void FFmpegVideoDecoder::Reset(const base::Closure& closure) { 237 DCHECK(task_runner_->BelongsToCurrentThread()); 238 239 avcodec_flush_buffers(codec_context_.get()); 240 state_ = kNormal; 241 task_runner_->PostTask(FROM_HERE, closure); 242} 243 244FFmpegVideoDecoder::~FFmpegVideoDecoder() { 245 DCHECK(task_runner_->BelongsToCurrentThread()); 246 247 if (state_ != kUninitialized) 248 ReleaseFFmpegResources(); 249} 250 251bool FFmpegVideoDecoder::FFmpegDecode( 252 const scoped_refptr<DecoderBuffer>& buffer, 253 bool* has_produced_frame) { 254 DCHECK(!*has_produced_frame); 255 256 // Create a packet for input data. 257 // Due to FFmpeg API changes we no longer have const read-only pointers. 258 AVPacket packet; 259 av_init_packet(&packet); 260 if (buffer->end_of_stream()) { 261 packet.data = NULL; 262 packet.size = 0; 263 } else { 264 packet.data = const_cast<uint8*>(buffer->data()); 265 packet.size = buffer->data_size(); 266 267 // Let FFmpeg handle presentation timestamp reordering. 268 codec_context_->reordered_opaque = buffer->timestamp().InMicroseconds(); 269 } 270 271 int frame_decoded = 0; 272 int result = avcodec_decode_video2(codec_context_.get(), 273 av_frame_.get(), 274 &frame_decoded, 275 &packet); 276 // Log the problem if we can't decode a video frame and exit early. 277 if (result < 0) { 278 LOG(ERROR) << "Error decoding video: " << buffer->AsHumanReadableString(); 279 return false; 280 } 281 282 // FFmpeg says some codecs might have multiple frames per packet. Previous 283 // discussions with rbultje@ indicate this shouldn't be true for the codecs 284 // we use. 285 DCHECK_EQ(result, packet.size); 286 287 // If no frame was produced then signal that more data is required to 288 // produce more frames. This can happen under two circumstances: 289 // 1) Decoder was recently initialized/flushed 290 // 2) End of stream was reached and all internal frames have been output 291 if (frame_decoded == 0) { 292 return true; 293 } 294 295 // TODO(fbarchard): Work around for FFmpeg http://crbug.com/27675 296 // The decoder is in a bad state and not decoding correctly. 297 // Checking for NULL avoids a crash in CopyPlane(). 298 if (!av_frame_->data[VideoFrame::kYPlane] || 299 !av_frame_->data[VideoFrame::kUPlane] || 300 !av_frame_->data[VideoFrame::kVPlane]) { 301 LOG(ERROR) << "Video frame was produced yet has invalid frame data."; 302 av_frame_unref(av_frame_.get()); 303 return false; 304 } 305 306 scoped_refptr<VideoFrame> frame = 307 reinterpret_cast<VideoFrame*>(av_buffer_get_opaque(av_frame_->buf[0])); 308 frame->set_timestamp( 309 base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque)); 310 *has_produced_frame = true; 311 output_cb_.Run(frame); 312 313 av_frame_unref(av_frame_.get()); 314 return true; 315} 316 317void FFmpegVideoDecoder::ReleaseFFmpegResources() { 318 codec_context_.reset(); 319 av_frame_.reset(); 320} 321 322bool FFmpegVideoDecoder::ConfigureDecoder(bool low_delay) { 323 // Release existing decoder resources if necessary. 324 ReleaseFFmpegResources(); 325 326 // Initialize AVCodecContext structure. 327 codec_context_.reset(avcodec_alloc_context3(NULL)); 328 VideoDecoderConfigToAVCodecContext(config_, codec_context_.get()); 329 330 codec_context_->thread_count = GetThreadCount(codec_context_->codec_id); 331 codec_context_->thread_type = low_delay ? FF_THREAD_SLICE : FF_THREAD_FRAME; 332 codec_context_->opaque = this; 333 codec_context_->flags |= CODEC_FLAG_EMU_EDGE; 334 codec_context_->get_buffer2 = GetVideoBufferImpl; 335 codec_context_->refcounted_frames = 1; 336 337 if (decode_nalus_) 338 codec_context_->flags2 |= CODEC_FLAG2_CHUNKS; 339 340 AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id); 341 if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) { 342 ReleaseFFmpegResources(); 343 return false; 344 } 345 346 av_frame_.reset(av_frame_alloc()); 347 return true; 348} 349 350} // namespace media 351