int64_t post_time_us = clock_->CurrentTime().us();
++posted_frames_waiting_for_encode_;
- encoder_queue_.PostTask(
- [this, incoming_frame, post_time_us, log_stats]() {
- RTC_DCHECK_RUN_ON(&encoder_queue_);
- encoder_stats_observer_->OnIncomingFrame(incoming_frame.width(),
- incoming_frame.height());
- ++captured_frame_count_;
- const int posted_frames_waiting_for_encode =
- posted_frames_waiting_for_encode_.fetch_sub(1);
- RTC_DCHECK_GT(posted_frames_waiting_for_encode, 0);
- CheckForAnimatedContent(incoming_frame, post_time_us);
- bool cwnd_frame_drop =
- cwnd_frame_drop_interval_ &&
- (cwnd_frame_counter_++ % cwnd_frame_drop_interval_.value() == 0);
- if (posted_frames_waiting_for_encode == 1 && !cwnd_frame_drop) {
- MaybeEncodeVideoFrame(incoming_frame, post_time_us);
- } else {
- if (cwnd_frame_drop) {
- // Frame drop by congestion window pushback. Do not encode this
- // frame.
- ++dropped_frame_cwnd_pushback_count_;
- encoder_stats_observer_->OnFrameDropped(
- VideoStreamEncoderObserver::DropReason::kCongestionWindow);
- } else {
- // There is a newer frame in flight. Do not encode this frame.
- RTC_LOG(LS_VERBOSE)
- << "Incoming frame dropped due to that the encoder is blocked.";
- ++dropped_frame_encoder_block_count_;
- encoder_stats_observer_->OnFrameDropped(
- VideoStreamEncoderObserver::DropReason::kEncoderQueue);
- }
- accumulated_update_rect_.Union(incoming_frame.update_rect());
- accumulated_update_rect_is_valid_ &= incoming_frame.has_update_rect();
- }
- if (log_stats) {
- RTC_LOG(LS_INFO) << "Number of frames: captured "
- << captured_frame_count_
- << ", dropped (due to congestion window pushback) "
- << dropped_frame_cwnd_pushback_count_
- << ", dropped (due to encoder blocked) "
- << dropped_frame_encoder_block_count_
- << ", interval_ms " << kFrameLogIntervalMs;
- captured_frame_count_ = 0;
- dropped_frame_cwnd_pushback_count_ = 0;
- dropped_frame_encoder_block_count_ = 0;
- }
- });
+ encoder_queue_.PostTask([this, incoming_frame, post_time_us, log_stats]() {
+ RTC_DCHECK_RUN_ON(&encoder_queue_);
+ encoder_stats_observer_->OnIncomingFrame(incoming_frame.width(),
+ incoming_frame.height());
+ ++captured_frame_count_;
+ const int posted_frames_waiting_for_encode =
+ posted_frames_waiting_for_encode_.fetch_sub(1);
+ RTC_DCHECK_GT(posted_frames_waiting_for_encode, 0);
+ CheckForAnimatedContent(incoming_frame, post_time_us);
+ bool cwnd_frame_drop =
+ cwnd_frame_drop_interval_ &&
+ (cwnd_frame_counter_++ % cwnd_frame_drop_interval_.value() == 0);
+ if (posted_frames_waiting_for_encode == 1 && !cwnd_frame_drop) {
+ MaybeEncodeVideoFrame(incoming_frame, post_time_us);
+ } else {
+ if (cwnd_frame_drop) {
+ // Frame drop by congestion window pushback. Do not encode this
+ // frame.
+ ++dropped_frame_cwnd_pushback_count_;
+ encoder_stats_observer_->OnFrameDropped(
+ VideoStreamEncoderObserver::DropReason::kCongestionWindow);
+ } else {
+ // There is a newer frame in flight. Do not encode this frame.
+ RTC_LOG(LS_VERBOSE)
+ << "Incoming frame dropped due to that the encoder is blocked.";
+ ++dropped_frame_encoder_block_count_;
+ encoder_stats_observer_->OnFrameDropped(
+ VideoStreamEncoderObserver::DropReason::kEncoderQueue);
+ }
+ accumulated_update_rect_.Union(incoming_frame.update_rect());
+ accumulated_update_rect_is_valid_ &= incoming_frame.has_update_rect();
+ }
+ if (log_stats) {
+ RTC_LOG(LS_INFO) << "Number of frames: captured " << captured_frame_count_
+ << ", dropped (due to congestion window pushback) "
+ << dropped_frame_cwnd_pushback_count_
+ << ", dropped (due to encoder blocked) "
+ << dropped_frame_encoder_block_count_ << ", interval_ms "
+ << kFrameLogIntervalMs;
+ captured_frame_count_ = 0;
+ dropped_frame_cwnd_pushback_count_ = 0;
+ dropped_frame_encoder_block_count_ = 0;
+ }
+ });
}
#if defined(OS_TIZEN)
// bitrate.
// TODO(perkj): Make sure all known encoder implementations handle zero
// target bitrate and remove this check.
-#if !defined(OS_TIZEN_TV_PRODUCT)
- // We need to pause even though `HasInternalSource` returns
- // false. Also in newer Chromium revision `has_internal_source`
- // no longer exists. How to do it properly? We should respect
- // `Encode` requests instead of driving encoder internal.
if (!HasInternalSource() &&
rate_settings.rate_control.bitrate.get_sum_bps() == 0) {
return;
}
-#endif // !defined(OS_TIZEN_TV_PRODUCT)
if (block_bitrate_changes_) {
auto new_rate_control = rate_settings.rate_control;
return updated_target_bitrate;
}
+#if !defined(TIZEN_CAPI_ENCODER_TV_API)
bool VideoStreamEncoder::IsVp8Encoder() {
return encoder_config_.codec_type == VideoCodecType::kVideoCodecVP8;
}
+#endif
void VideoStreamEncoder::OnBitrateUpdated(DataRate target_bitrate,
DataRate stable_target_bitrate,
#include <media/media_packet_internal.h>
+#include "absl/types/optional.h"
#include "base/auto_reset.h"
+#include "base/memory/scoped_refptr.h"
#include "base/threading/thread_task_runner_handle.h"
#include "media/base/tizen/logger/media_logger.h"
+#include "media/base/video_types.h"
#include "third_party/blink/renderer/platform/peerconnection/tizen_video_encoder_facade_helper.h"
#include "third_party/blink/renderer/platform/peerconnection/video_coding_utils.h"
#include "third_party/blink/renderer/platform/webrtc/webrtc_video_frame_adapter.h"
} \
} while (0)
+scoped_refptr<media::VideoFrame> GetVideoFrameWithTBMSurface(
+ const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& video_frame_buffer) {
+ if (video_frame_buffer->type() != webrtc::VideoFrameBuffer::Type::kNative)
+ return nullptr;
+
+ const auto* frame_adapter =
+ static_cast<blink::WebRtcVideoFrameAdapter*>(video_frame_buffer.get());
+ CHECK(frame_adapter);
+
+ auto video_frame = frame_adapter->getMediaVideoFrame();
+ CHECK(video_frame);
+
+ if (video_frame->format() ==
+ media::VideoPixelFormat::PIXEL_FORMAT_TBM_INTER_PROCESS_BUFFER ||
+ video_frame->format() ==
+ media::VideoPixelFormat::PIXEL_FORMAT_TBM_SURFACE) {
+ return video_frame;
+ }
+
+ return nullptr;
+}
+
+rtc::scoped_refptr<const webrtc::NV12BufferInterface> GetNV12Buffer(
+ const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& video_frame_buffer) {
+ rtc::scoped_refptr<const webrtc::NV12BufferInterface> nv12_buffer;
+ if (video_frame_buffer->type() == webrtc::VideoFrameBuffer::Type::kNV12) {
+ nv12_buffer = rtc::scoped_refptr<const webrtc::NV12BufferInterface>(
+ video_frame_buffer->GetNV12());
+ } else {
+ auto i420_buffer = video_frame_buffer->ToI420();
+ if (!i420_buffer) {
+ TIZEN_MEDIA_LOG_NO_INSTANCE(WARNING)
+ << "Could not convert video frame buffer to I420";
+ return nullptr;
+ }
+ nv12_buffer = webrtc::NV12Buffer::Copy(*i420_buffer);
+ }
+
+ return nv12_buffer;
+}
+
} // namespace
TizenVideoEncoderFacade::TizenVideoEncoderFacade(
auto stream_id = std::get<BackendParams>(client_description).stream_id;
const auto& client_params = std::get<StreamParams>(client_description);
- // We are in a preparing stage, before first `Encode` call, so we still don't
- // know if encoding will be performed using data from subscaler or data
- // provided by user. Because of that, we need to check if provided stream
- // parameters fulfills encoder requirements for at least one of encoding modes
- // - subscaler or user data mode.
if (!ValidateParamsInternal(client_params)) {
TIZEN_MEDIA_LOG(ERROR)
<< "Cannot add stream - provided parameters are not supported";
return;
}
- auto encoding_mode = GetFrameEncodingModeInternal(frame);
- if (encoding_mode == EncodingMode::kUnspecified &&
- encoding_mode_ != EncodingMode::kUnspecified) {
- TIZEN_MEDIA_LOG(WARNING)
- << "Cannot determine encoding mode from frame - assuming no "
- "encoding mode change";
- } else if (encoding_mode == EncodingMode::kUnspecified) {
- TIZEN_MEDIA_LOG(WARNING)
- << "Encoding frame failed - cannot determine encoding mode"
- << " from provided frame and encoder does not have any mode set.";
- return;
- }
-
- if (encoding_mode_ == EncodingMode::kUnspecified) {
- ReconfigureEncoderModeInternal(encoding_mode);
- }
-
- if (encoding_mode != encoding_mode_) {
- TIZEN_MEDIA_LOG(WARNING)
- << "Frame with different encoding mode (" << encoding_mode
- << ") than previously set (" << encoding_mode_
- << ") received. Reconfiguring encoder.";
- ReconfigureEncoderModeInternal(encoding_mode);
- }
-
StreamParams frame_params{{ClientParamsKeys::kWidth, frame.width()},
{ClientParamsKeys::kHeight, frame.height()}};
if (!ValidateParamsInternal(frame_params)) {
TIZEN_MEDIA_LOG(ERROR)
<< "Encoding frame failed - provided frame resolution is not"
- << " supported in encoder in current mode - " << encoding_mode_;
+ << " supported.";
return;
}
return;
}
- if (encoding_mode_ == EncodingMode::kEncodingFromSubscaler) {
- // Data is provided to encoder directly from subscaler - return here.
-
- // To prevent running `frame_dropped_closure`, it is replaced by by empty
- // closure. Simple usage of `operator=` will not work, because it runs
- // internal callback.
- frame_dropped_closure.ReplaceClosure({});
- return;
- }
-
- CHECK(encoding_mode_ == EncodingMode::kEncodingFromUserData);
- EncodeUserDataInternal(std::move(frame), std::move(frame_types),
- std::move(frame_dropped_closure));
+ EncodeInternal(std::move(frame), std::move(frame_types),
+ std::move(frame_dropped_closure));
}
void TizenVideoEncoderFacade::UpdateStreamBitrate(
RTCVideoEncoderFacadeHelper::OnEncoderStateChangedCallback, this));
CHECK_AND_RETURN(encoder_set_type(encoder_.get(), ENCODER_TYPE_H264));
+ CHECK_AND_RETURN(
+ encoder_set_input_type(encoder_.get(), ENCODER_INPUT_TYPE_USER));
SetEncoderParametersRangeInternal();
}
////////// RTCVideoEncoderFacadeTizen::TizenVideoEncoderFacade private
/////////////
-void TizenVideoEncoderFacade::EncodeUserDataInternal(
+void TizenVideoEncoderFacade::EncodeInternal(
webrtc::VideoFrame frame,
std::vector<webrtc::VideoFrameType> frame_types,
base::ScopedClosureRunner frame_dropped_closure) {
CHECK(encoder_task_runner_->BelongsToCurrentThread());
- CHECK(encoding_mode_ == EncodingMode::kEncodingFromUserData);
- CHECK(frame.video_frame_buffer());
- rtc::scoped_refptr<const webrtc::NV12BufferInterface> nv12_buffer;
-
- if (frame.video_frame_buffer()->type() ==
- webrtc::VideoFrameBuffer::Type::kNV12) {
- nv12_buffer = rtc::scoped_refptr<const webrtc::NV12BufferInterface>(
- frame.video_frame_buffer()->GetNV12());
+ ExternalBuffer external_buffer;
- } else {
- auto i420_buffer = frame.video_frame_buffer()->ToI420();
- if (!i420_buffer) {
- TIZEN_MEDIA_LOG(WARNING)
- << "Could not convert video frame buffer to I420";
- return;
- }
- nv12_buffer = webrtc::NV12Buffer::Copy(*i420_buffer);
- }
-
- if (!nv12_buffer) {
- TIZEN_MEDIA_LOG(WARNING) << "NV12 buffer is null";
+ auto video_frame_buffer = frame.video_frame_buffer();
+ if (!video_frame_buffer) {
+ TIZEN_MEDIA_LOG(ERROR) << "Video frame buffer for provided frame is empty";
return;
}
CHECK_AND_RETURN_MEDIA_FORMAT(
media_format_set_video_mime(media_format.get(), MEDIA_FORMAT_NV12));
- CHECK_AND_RETURN_MEDIA_FORMAT(media_format_set_video_width(
- media_format.get(), nv12_buffer->width()));
- CHECK_AND_RETURN_MEDIA_FORMAT(media_format_set_video_height(
- media_format.get(), nv12_buffer->height()));
+ CHECK_AND_RETURN_MEDIA_FORMAT(
+ media_format_set_video_width(media_format.get(), frame.width()));
+ CHECK_AND_RETURN_MEDIA_FORMAT(
+ media_format_set_video_height(media_format.get(), frame.height()));
CHECK_AND_RETURN_MEDIA_FORMAT(media_format_set_video_frame_rate(
media_format.get(), cricket::kDefaultVideoEncodeMaxFramerate));
}
// once.
for (size_t i = 0; i < packets_being_encoded_.size() + 1; ++i) {
media_packet_h media_packet_ptr{nullptr};
- CHECK_AND_RETURN_MEDIA_PACKET(media_packet_new_from_external_memory(
- media_format.get(), const_cast<uint8_t*>(nv12_buffer->DataY()),
- NV12DataSize(nv12_buffer->height(), nv12_buffer->StrideY(),
- nv12_buffer->StrideUV()),
- nullptr, nullptr, &media_packet_ptr));
+
+ if (auto video_frame_with_tbm_surface =
+ GetVideoFrameWithTBMSurface(video_frame_buffer)) {
+ CHECK_AND_RETURN_MEDIA_PACKET(media_packet_new_from_tbm_surface(
+ media_format.get(),
+ static_cast<tbm_surface_h>(
+ video_frame_with_tbm_surface->GetTbmBuffer().tbm_surface),
+ nullptr, nullptr, &media_packet_ptr));
+ external_buffer = std::move(video_frame_with_tbm_surface);
+ } else if (auto nv12_buffer = GetNV12Buffer(video_frame_buffer)) {
+ CHECK_AND_RETURN_MEDIA_PACKET(media_packet_new_from_external_memory(
+ media_format.get(), const_cast<uint8_t*>(nv12_buffer->DataY()),
+ NV12DataSize(nv12_buffer->height(), nv12_buffer->StrideY(),
+ nv12_buffer->StrideUV()),
+ nullptr, nullptr, &media_packet_ptr));
+ external_buffer = std::move(nv12_buffer);
+ } else {
+ TIZEN_MEDIA_LOG(WARNING) << "Could not get data from VideoFrameBuffer";
+ return;
+ }
+
media_packet = MediaPacketType(media_packet_ptr);
if (!packets_being_encoded_.count(media_packet.get()))
// callback.
frame_dropped_closure.ReplaceClosure({});
- packets_to_encode_.emplace(std::move(media_packet), std::move(nv12_buffer));
+ packets_to_encode_.emplace(std::move(media_packet),
+ std::move(external_buffer));
SubmitPacketInternal();
}
-EncodingMode TizenVideoEncoderFacade::GetFrameEncodingModeInternal(
- const webrtc::VideoFrame& frame) {
- CHECK(encoder_task_runner_->BelongsToCurrentThread());
-
- auto buffer = frame.video_frame_buffer();
- if (!buffer) {
- TIZEN_MEDIA_LOG(ERROR) << "Video frame buffer for provided frame is empty";
- ReportErrorToProxyInternal();
- return EncodingMode::kUnspecified;
- }
-
- if (buffer->type() != webrtc::VideoFrameBuffer::Type::kNative) {
- TIZEN_MEDIA_LOG(DEBUG) << "Using encoding from user data";
- return EncodingMode::kEncodingFromUserData;
- }
-
- const auto* frame_adapter =
- static_cast<blink::WebRtcVideoFrameAdapter*>(buffer.get());
- CHECK(frame_adapter);
-
- auto video_frame = frame_adapter->getMediaVideoFrame();
- CHECK(video_frame);
-
- if (video_frame->storage_type() == media::VideoFrame::STORAGE_HOLE) {
- TIZEN_MEDIA_LOG(DEBUG) << "Using encoding from subscaler";
- return EncodingMode::kEncodingFromSubscaler;
- }
-
- TIZEN_MEDIA_LOG(DEBUG) << "Using encoding from user data";
- return EncodingMode::kEncodingFromUserData;
-}
-
-void TizenVideoEncoderFacade::ReconfigureEncoderModeInternal(
- EncodingMode new_encoding_mode) {
- TIZEN_MEDIA_LOG(INFO) << new_encoding_mode;
- CHECK(encoder_task_runner_->BelongsToCurrentThread());
-
- if (encoding_mode_ == new_encoding_mode) {
- TIZEN_MEDIA_LOG(VERBOSE);
- return;
- }
-
- if (encoder_state_ != EncoderState::kPreparing &&
- encoder_state_ != EncoderState::kEncoding) {
- TIZEN_MEDIA_LOG(ERROR)
- << "Reconfiguring encoding mode failed - wrong encoder state";
- return;
- }
-
- auto need_to_restart_encoder = encoder_state_ == EncoderState::kEncoding;
- if (need_to_restart_encoder) {
- StopInternal();
- }
-
- if (encoder_state_ != EncoderState::kPreparing) {
- TIZEN_MEDIA_LOG(INFO) << "Cannot reconfigure encoder in state = "
- << encoder_state_;
- return;
- }
-
- encoding_mode_ = new_encoding_mode;
- SetEncoderInputTypeInternal();
-
- if (need_to_restart_encoder)
- StartInternal();
-}
-
void TizenVideoEncoderFacade::ReportErrorToProxyInternal() {
TIZEN_MEDIA_LOG(INFO);
CHECK(encoder_task_runner_->BelongsToCurrentThread());
};
}
-void TizenVideoEncoderFacade::SetEncoderInputTypeInternal() {
+void TizenVideoEncoderFacade::SetEncoderParametersRangeInternal() {
+ TIZEN_MEDIA_LOG(INFO);
CHECK(encoder_task_runner_->BelongsToCurrentThread());
- CHECK(encoding_mode_ != EncodingMode::kUnspecified);
- if (encoder_state_ != EncoderState::kPreparing) {
- TIZEN_MEDIA_LOG(WARNING)
- << "Setting encoder input type failed - wrong encoder state";
- return;
- }
+ encoder_params_map_ = {
+ {ClientParamsKeys::kStreamId,
+ {.name = absl::nullopt, .range = {0, ENCODER_STREAM_MAX - 1}}},
+ {ClientParamsKeys::kBitrate,
+ {.name = ENCODER_VIDEO_PARAM_BITRATE, .range = {}}},
+ {ClientParamsKeys::kFramerate,
+ {.name = ENCODER_VIDEO_PARAM_FRAMERATE, .range = {}}},
+ {ClientParamsKeys::kHeight,
+ {.name = ENCODER_VIDEO_PARAM_HEIGHT, .range = {}}},
+ {ClientParamsKeys::kWidth,
+ {.name = ENCODER_VIDEO_PARAM_WIDTH, .range = {}}},
+ };
- TIZEN_MEDIA_LOG(INFO) << "Setting encoder input type: "
- << ToEncoderInputType(encoding_mode_) << " ("
- << encoding_mode_ << ")";
+ encoder_param_s param{.type = ENCODER_TYPE_H264,
+ .input_type = ENCODER_INPUT_TYPE_USER};
- CHECK_AND_RETURN(encoder_set_input_type(encoder_.get(),
- ToEncoderInputType(encoding_mode_)));
-}
+ for (auto& entry : encoder_params_map_) {
+ if (!entry.second.name.has_value())
+ continue;
-void TizenVideoEncoderFacade::SetEncoderParametersRangeInternal() {
- TIZEN_MEDIA_LOG(INFO);
- CHECK(encoder_task_runner_->BelongsToCurrentThread());
+ int start;
+ int end;
- // Get allowed values for both subscaler encoding and user data encoding.
- // Before first `Encode` method is called, we don't know if we are working in
- // subscaler encoding or user data encoding mode, so we need to get supported
- // values for both of these modes.
- {
- EncoderParamsMapType initial_values = {
- {ClientParamsKeys::kStreamId,
- {.name = absl::nullopt, .range = {0, ENCODER_STREAM_MAX - 1}}},
- {ClientParamsKeys::kBitrate,
- {.name = ENCODER_VIDEO_PARAM_BITRATE, .range = {}}},
- {ClientParamsKeys::kFramerate,
- {.name = ENCODER_VIDEO_PARAM_FRAMERATE, .range = {}}},
- {ClientParamsKeys::kHeight,
- {.name = ENCODER_VIDEO_PARAM_HEIGHT, .range = {}}},
- {ClientParamsKeys::kWidth,
- {.name = ENCODER_VIDEO_PARAM_WIDTH, .range = {}}},
- };
-
- encoder_params_map_ = {
- {EncodingMode::kEncodingFromSubscaler, initial_values},
- {EncodingMode::kEncodingFromUserData, initial_values}};
- }
-
- for (auto& encoding_params : encoder_params_map_) {
- encoder_param_s param{
- .type = ENCODER_TYPE_H264,
- .input_type = ToEncoderInputType(encoding_params.first)};
-
- for (auto& entry : encoding_params.second) {
- if (!entry.second.name.has_value())
- continue;
-
- int start;
- int end;
-
- CHECK_AND_RETURN(encoder_get_param_range(
- encoder_.get(), ¶m, entry.second.name.value(), &start, &end));
- entry.second.range = {static_cast<uint32_t>(start),
- static_cast<uint32_t>(end)};
- }
+ CHECK_AND_RETURN(encoder_get_param_range(
+ encoder_.get(), ¶m, entry.second.name.value(), &start, &end));
+ entry.second.range = {static_cast<uint32_t>(start),
+ static_cast<uint32_t>(end)};
}
}
CHECK(encoder_task_runner_->BelongsToCurrentThread());
CHECK(!encoder_params_map_.empty());
- auto validation_succeeded = false;
- if (encoding_mode_ != EncodingMode::kUnspecified) {
- // encoding_mode_ was already set, so we know which encoder parameters are
- // appropriate for us.
- validation_succeeded =
- ValidateParamsForEncodingModeInternal(encoding_mode_, client_params);
- } else {
- // encoding_mode_ was not set yet, so best we can do, is to check if there
- // is any encoding mode of platform encoder, which will support provided
- // parameters.
- for (const auto& mode_parameters_pair : encoder_params_map_)
- validation_succeeded |= ValidateParamsForEncodingModeInternal(
- mode_parameters_pair.first, client_params);
- }
-
- return validation_succeeded;
-}
-
-bool TizenVideoEncoderFacade::ValidateParamsForEncodingModeInternal(
- EncodingMode encoding_mode,
- const StreamParams& client_params) {
- CHECK(encoder_task_runner_->BelongsToCurrentThread());
- CHECK(encoder_params_map_.count(encoding_mode));
-
for (const auto& param : client_params) {
- const auto& encoder_parameter_struct =
- encoder_params_map_.at(encoding_mode).at(param.first);
+ const auto& encoder_parameter_struct = encoder_params_map_.at(param.first);
if (!gfx::Range{param.second}.IsBoundedBy(encoder_parameter_struct.range)) {
TIZEN_MEDIA_LOG(WARNING)
<< "Unsupported value `" << param.second << "` for parameter `"
- << param.first << "` in encoding mode: `" << encoding_mode
+ << param.first
<< "`. Supported range: " << encoder_parameter_struct.range;
return false;
}
return true;
}
-encoder_input_type_e TizenVideoEncoderFacade::ToEncoderInputType(
- EncodingMode encoding_mode) const {
- switch (encoding_mode) {
- case EncodingMode::kEncodingFromSubscaler:
- return ENCODER_INPUT_TYPE_SYSTEM;
- case EncodingMode::kEncodingFromUserData:
- return ENCODER_INPUT_TYPE_USER;
- case EncodingMode::kUnspecified:
- TIZEN_MEDIA_LOG(ERROR) << "No mapping from EncodingMode::kUnspecified to "
- << "encoder_input_type_e";
- return {};
- }
- NOTREACHED();
- return {};
-}
-
void TizenVideoEncoderFacade::OnDroppedFrame() {
TIZEN_MEDIA_LOG(INFO);
CHECK(encoder_task_runner_->BelongsToCurrentThread());
projects / platform / framework / web / chromium-efl.git / commitdiff