src/media/cast/sender/video_encoder_impl.cc

   1 // Copyright 2014 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/cast/sender/video_encoder_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "media/base/video_frame.h"
  13 #include "media/cast/cast_defines.h"
  14 #include "media/cast/sender/fake_software_video_encoder.h"
  15 #if !defined(MEDIA_DISABLE_LIBVPX)
  16 #include "media/cast/sender/vp8_encoder.h"
  17 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
  18
  19 namespace media {
  20 namespace cast {
  21
  22 namespace {
  23
  24 #if !defined(MEDIA_DISABLE_LIBVPX)
  25 typedef base::Callback<void(Vp8Encoder*)> PassEncoderCallback;
  26
  27 void InitializeEncoderOnEncoderThread(
  28     const scoped_refptr<CastEnvironment>& environment,
  29     SoftwareVideoEncoder* encoder) {
  30   DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO));
  31   encoder->Initialize();
  32 }
  33 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
  34
  35 void EncodeVideoFrameOnEncoderThread(
  36     scoped_refptr<CastEnvironment> environment,
  37     SoftwareVideoEncoder* encoder,
  38     const scoped_refptr<media::VideoFrame>& video_frame,
  39     const base::TimeTicks& capture_time,
  40     const VideoEncoderImpl::CodecDynamicConfig& dynamic_config,
  41     const VideoEncoderImpl::FrameEncodedCallback& frame_encoded_callback) {
  42   DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO));
  43   if (dynamic_config.key_frame_requested) {
  44     encoder->GenerateKeyFrame();
  45   }
  46   encoder->LatestFrameIdToReference(
  47       dynamic_config.latest_frame_id_to_reference);
  48   encoder->UpdateRates(dynamic_config.bit_rate);
  49
  50   scoped_ptr<EncodedFrame> encoded_frame(
  51       new EncodedFrame());
  52   if (!encoder->Encode(video_frame, encoded_frame.get())) {
  53     VLOG(1) << "Encoding failed";
  54     return;
  55   }
  56   if (encoded_frame->data.empty()) {
  57     VLOG(1) << "Encoding resulted in an empty frame";
  58     return;
  59   }
  60   encoded_frame->rtp_timestamp = GetVideoRtpTimestamp(capture_time);
  61   encoded_frame->reference_time = capture_time;
  62
  63   environment->PostTask(
  64       CastEnvironment::MAIN,
  65       FROM_HERE,
  66       base::Bind(
  67           frame_encoded_callback, base::Passed(&encoded_frame)));
  68 }
  69 }  // namespace
  70
  71 VideoEncoderImpl::VideoEncoderImpl(
  72     scoped_refptr<CastEnvironment> cast_environment,
  73     const VideoSenderConfig& video_config,
  74     int max_unacked_frames)
  75     : cast_environment_(cast_environment) {
  76   if (video_config.codec == CODEC_VIDEO_VP8) {
  77 #if !defined(MEDIA_DISABLE_LIBVPX)
  78     encoder_.reset(new Vp8Encoder(video_config, max_unacked_frames));
  79     cast_environment_->PostTask(CastEnvironment::VIDEO,
  80                                 FROM_HERE,
  81                                 base::Bind(&InitializeEncoderOnEncoderThread,
  82                                            cast_environment,
  83                                            encoder_.get()));
  84 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
  85 #ifndef OFFICIAL_BUILD
  86   } else if (video_config.codec == CODEC_VIDEO_FAKE) {
  87     encoder_.reset(new FakeSoftwareVideoEncoder(video_config));
  88 #endif
  89   } else {
  90     DCHECK(false) << "Invalid config";  // Codec not supported.
  91   }
  92
  93   dynamic_config_.key_frame_requested = false;
  94   dynamic_config_.latest_frame_id_to_reference = kStartFrameId;
  95   dynamic_config_.bit_rate = video_config.start_bitrate;
  96 }
  97
  98 VideoEncoderImpl::~VideoEncoderImpl() {
  99   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 100   if (encoder_) {
 101     cast_environment_->PostTask(
 102         CastEnvironment::VIDEO,
 103         FROM_HERE,
 104         base::Bind(&base::DeletePointer<SoftwareVideoEncoder>,
 105                    encoder_.release()));
 106   }
 107 }
 108
 109 bool VideoEncoderImpl::EncodeVideoFrame(
 110     const scoped_refptr<media::VideoFrame>& video_frame,
 111     const base::TimeTicks& capture_time,
 112     const FrameEncodedCallback& frame_encoded_callback) {
 113   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 114   cast_environment_->PostTask(CastEnvironment::VIDEO,
 115                               FROM_HERE,
 116                               base::Bind(&EncodeVideoFrameOnEncoderThread,
 117                                          cast_environment_,
 118                                          encoder_.get(),
 119                                          video_frame,
 120                                          capture_time,
 121                                          dynamic_config_,
 122                                          frame_encoded_callback));
 123
 124   dynamic_config_.key_frame_requested = false;
 125   return true;
 126 }
 127
 128 // Inform the encoder about the new target bit rate.
 129 void VideoEncoderImpl::SetBitRate(int new_bit_rate) {
 130   dynamic_config_.bit_rate = new_bit_rate;
 131 }
 132
 133 // Inform the encoder to encode the next frame as a key frame.
 134 void VideoEncoderImpl::GenerateKeyFrame() {
 135   dynamic_config_.key_frame_requested = true;
 136 }
 137
 138 // Inform the encoder to only reference frames older or equal to frame_id;
 139 void VideoEncoderImpl::LatestFrameIdToReference(uint32 frame_id) {
 140   dynamic_config_.latest_frame_id_to_reference = frame_id;
 141 }
 142
 143 }  //  namespace cast
 144 }  //  namespace media