#include "content/public/browser/browser_thread.h"
#include "media/base/efl/media_player_manager_efl.h"
+#include "media/base/efl/media_player_util_efl.h"
namespace media {
}
#endif
+void MediaPlayerEfl::OnMediaError(MediaError err) {
+ blink::WebMediaPlayer::NetworkState state =
+ blink::WebMediaPlayer::NetworkStateEmpty;
+
+ switch (err) {
+ case MEDIA_ERROR_FORMAT:
+ state = blink::WebMediaPlayer::NetworkStateFormatError;
+ break;
+ case MEDIA_ERROR_DECODE:
+ state = blink::WebMediaPlayer::NetworkStateDecodeError;
+ break;
+ case MEDIA_ERROR_NETWORK:
+ state = blink::WebMediaPlayer::NetworkStateNetworkError;
+ break;
+ }
+
+ manager()->OnNetworkStateChange(GetPlayerId(), state);
+
+#if defined(OS_TIZEN_MOBILE)
+ ReleaseDisplayLock();
+#endif
+}
+
} // namespace media
class MediaPlayerManager;
-// Error types for MediaErrorCB.
-enum MediaErrorType {
- MEDIA_ERROR_FORMAT,
- MEDIA_ERROR_DECODE,
- MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK,
- MEDIA_ERROR_INVALID_CODE,
-};
-
// media type masks
const int MEDIA_AUDIO_MASK = 0x02;
const int MEDIA_VIDEO_MASK = 0x01;
#if defined(TIZEN_TBM_SUPPORT)
void DeliverMediaPacket(ScopedMediaPacket packet);
#endif
+ virtual void OnMediaError(MediaError error_type);
int width_;
int height_;
namespace media {
+std::string GetErrorString(int player_error) {
+ switch (player_error) {
+ case PLAYER_ERROR_OUT_OF_MEMORY:
+ return "PLAYER_ERROR_OUT_OF_MEMORY";
+ case PLAYER_ERROR_INVALID_PARAMETER:
+ return "PLAYER_ERROR_INVALID_PARAMETER";
+ case PLAYER_ERROR_NO_SUCH_FILE:
+ return "PLAYER_ERROR_NO_SUCH_FILE";
+ case PLAYER_ERROR_INVALID_OPERATION:
+ return "PLAYER_ERROR_INVALID_OPERATION";
+ case PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE:
+ return "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE";
+ case PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE:
+ return "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE";
+ case PLAYER_ERROR_SEEK_FAILED:
+ return "PLAYER_ERROR_SEEK_FAILED";
+ case PLAYER_ERROR_INVALID_STATE:
+ return "PLAYER_ERROR_INVALID_STATE";
+ case PLAYER_ERROR_NOT_SUPPORTED_FILE:
+ return "PLAYER_ERROR_NOT_SUPPORTED_FILE";
+ case PLAYER_ERROR_INVALID_URI:
+ return "PLAYER_ERROR_INVALID_URI";
+ case PLAYER_ERROR_SOUND_POLICY:
+ return "PLAYER_ERROR_SOUND_POLICY";
+ case PLAYER_ERROR_CONNECTION_FAILED:
+ return "PLAYER_ERROR_CONNECTION_FAILED";
+ case PLAYER_ERROR_VIDEO_CAPTURE_FAILED:
+ return "PLAYER_ERROR_VIDEO_CAPTURE_FAILED";
+ case PLAYER_ERROR_DRM_EXPIRED:
+ return "PLAYER_ERROR_DRM_EXPIRED";
+ case PLAYER_ERROR_DRM_NO_LICENSE:
+ return "PLAYER_ERROR_DRM_NO_LICENSE";
+ case PLAYER_ERROR_DRM_FUTURE_USE:
+ return "PLAYER_ERROR_DRM_FUTURE_USE";
+ case PLAYER_ERROR_DRM_NOT_PERMITTED:
+ return "PLAYER_ERROR_DRM_NOT_PERMITTED";
+ case PLAYER_ERROR_RESOURCE_LIMIT:
+ return "PLAYER_ERROR_RESOURCE_LIMIT";
+ default:
+ break;
+ }
+
+ std::stringstream sstream;
+
+ sstream << "PLAYER_ERROR_UNKNOWN(-0x" << std::abs(player_error) << ") "
+ << get_error_message(player_error);
+
+ return sstream.str();
+}
+
+MediaError GetMediaError(int capi_player_error) {
+ MediaError retval = MEDIA_ERROR_DECODE;
+
+ if (capi_player_error == PLAYER_ERROR_NO_SUCH_FILE ||
+ capi_player_error == PLAYER_ERROR_INVALID_URI ||
+ capi_player_error == PLAYER_ERROR_NOT_SUPPORTED_FILE)
+ retval = MEDIA_ERROR_FORMAT;
+ else if (capi_player_error == PLAYER_ERROR_CONNECTION_FAILED)
+ retval = MEDIA_ERROR_NETWORK;
+
+ return retval;
+}
+
void MediaPacketDeleter::operator()(media_packet_s* ptr) const {
if (ptr != nullptr)
media_packet_destroy(ptr);
MEDIA_SEEK_PLAYER, // Player is seeking
} MediaSeekState;
+// Error types for MediaPlayerEfl
+enum MediaError {
+ MEDIA_ERROR_FORMAT, // Unsupported Format
+ MEDIA_ERROR_DECODE, // Decoder error.
+ MEDIA_ERROR_NETWORK, // Network error.
+};
+
+std::string GetErrorString(int capi_player_error);
+MediaError GetMediaError(int capi_player_error);
+
double ConvertNanoSecondsToSeconds(int64 time);
double ConvertMilliSecondsToSeconds(int time);
double ConvertSecondsToMilliSeconds(double time);
PLAYER_STATE_DELAYED_SEEK,
};
-struct ErrorList {
- player_error_e error_code;
- std::string error_message;
-};
-
-const struct ErrorList errorlist[] = {
- {PLAYER_ERROR_OUT_OF_MEMORY, "PLAYER_ERROR_OUT_OF_MEMORY"},
- {PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"},
- {PLAYER_ERROR_NO_SUCH_FILE, "PLAYER_ERROR_NO_SUCH_FILE"},
- {PLAYER_ERROR_INVALID_OPERATION, "PLAYER_ERROR_INVALID_OPERATION"},
- {PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE,
- "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"},
- {PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE,
- "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"},
- {PLAYER_ERROR_SEEK_FAILED, "PLAYER_ERROR_SEEK_FAILED"},
- {PLAYER_ERROR_INVALID_STATE, "PLAYER_ERROR_INVALID_STATE"},
- {PLAYER_ERROR_NOT_SUPPORTED_FILE, "PLAYER_ERROR_NOT_SUPPORTED_FILE"},
- {PLAYER_ERROR_INVALID_URI, "PLAYER_ERROR_INVALID_URI"},
- {PLAYER_ERROR_SOUND_POLICY, "PLAYER_ERROR_SOUND_POLICY"},
- {PLAYER_ERROR_CONNECTION_FAILED, "PLAYER_ERROR_CONNECTION_FAILED"},
- {PLAYER_ERROR_VIDEO_CAPTURE_FAILED, "PLAYER_ERROR_VIDEO_CAPTURE_FAILED"},
- {PLAYER_ERROR_DRM_EXPIRED, "PLAYER_ERROR_DRM_EXPIRED"},
- {PLAYER_ERROR_DRM_NO_LICENSE, "PLAYER_ERROR_DRM_NO_LICENSE"},
- {PLAYER_ERROR_DRM_FUTURE_USE, "PLAYER_ERROR_DRM_FUTURE_USE"},
- {PLAYER_ERROR_DRM_NOT_PERMITTED, "PLAYER_ERROR_DRM_NOT_PERMITTED"},
- {PLAYER_ERROR_RESOURCE_LIMIT, "PLAYER_ERROR_RESOURCE_LIMIT"}};
-
-const int ERROR_MAX = sizeof(errorlist) / sizeof(errorlist[0]);
-
-
// TODO(max): Remove these proxy free functions.
// Called by player_prepare_async()
media::MediaPlayerBridgeCapi* player =
static_cast<media::MediaPlayerBridgeCapi*>(data);
- player->OnHandleError(error_code, "ErrorCb");
+ player->OnHandlePlayerError(error_code, FROM_HERE);
}
// Called by player_set_interrupted_cb()
weak_factory_(this) {
int ret = player_create(&player_);
if (ret != PLAYER_ERROR_NONE) {
- HandleError(ret, "player_create");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
}
ret = player_set_media_packet_video_frame_decoded_cb(
player_, MediaPacketDecodedCb, this);
if (ret != PLAYER_ERROR_NONE) {
- HandleError(ret, "player_set_media_packet_video_frame_decoded_cb");
+ OnHandlePlayerError(ret, FROM_HERE);
RunCompleteCB(false, FROM_HERE);
return;
}
ret = player_prepare_async(player_, PlayerPreparedCb, this);
if (ret != PLAYER_ERROR_NONE) {
- HandleError(ret, "player_prepare_async");
+ OnHandlePlayerError(ret, FROM_HERE);
RunCompleteCB(false, FROM_HERE);
} else {
manager()->OnReadyStateChange(
}
}
+void MediaPlayerBridgeCapi::OnMediaError(MediaError error_type) {
+ StopBufferingUpdateTimer();
+ StopCurrentTimeUpdateTimer();
+ MediaPlayerEfl::OnMediaError(error_type);
+}
+
void MediaPlayerBridgeCapi::Initialize() {
Prepare(base::Bind(&MediaPlayerBridgeCapi::OnInitComplete,
weak_factory_.GetWeakPtr()));
int err = player_get_audio_stream_info(player_, &sample_rate, &channel,
&audio_bit_rate);
if (err != PLAYER_ERROR_NONE) {
- HandleError(err, "player_get_audio_stream_info");
+ OnHandlePlayerError(err, FROM_HERE);
RunCompleteCB(false, FROM_HERE);
return;
}
int duration = 0;
int ret = player_get_duration(player_, &duration);
if (ret != PLAYER_ERROR_NONE) {
- HandleError(ret, "player_get_duration");
+ OnHandlePlayerError(ret, FROM_HERE);
RunCompleteCB(false, FROM_HERE);
return;
}
GetPlayerId(), blink::WebMediaPlayer::NetworkStateLoading);
}
-// Helper method which prints errors occured while calling CAPI api's.
-//
-// TODO(Venu): CAPI error handling is common to ME / MSE / WebAudio.
-// Move to utility file.
-void MediaPlayerBridgeCapi::HandleError(int err, char const* from) {
- int index = 0;
- for (index = 0; index < ERROR_MAX; ++index) {
- if (errorlist[index].error_code == err) {
- LOG(ERROR) << "Stoping playback of media due to Error code : " << err
- << " Error message : " << errorlist[index].error_message
- << " from " << from;
- break;
- }
- }
-
- if (index == ERROR_MAX)
- LOG(ERROR) << "Stoping playback of media due to Unknown error : "
- << err << " from " << from;
-
- StopBufferingUpdateTimer();
- StopCurrentTimeUpdateTimer();
-
- blink::WebMediaPlayer::NetworkState state =
- blink::WebMediaPlayer::NetworkStateEmpty;
- if (err == PLAYER_ERROR_NO_SUCH_FILE || err == PLAYER_ERROR_INVALID_URI ||
- err == PLAYER_ERROR_NOT_SUPPORTED_FILE)
- state = blink::WebMediaPlayer::NetworkStateFormatError;
- else if (err == PLAYER_ERROR_CONNECTION_FAILED)
- state = blink::WebMediaPlayer::NetworkStateNetworkError;
- else
- state = blink::WebMediaPlayer::NetworkStateDecodeError;
-
- manager()->OnNetworkStateChange(GetPlayerId(), state);
-
-#if defined(OS_TIZEN_MOBILE)
- ReleaseDisplayLock();
-#endif
-}
-
void MediaPlayerBridgeCapi::RunCompleteCB(
bool success,
const tracked_objects::Location& from) {
weak_factory_.GetWeakPtr(), percent));
}
-void MediaPlayerBridgeCapi::OnHandleError(int error_code, const char *msg) {
- task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::HandleError,
- weak_factory_.GetWeakPtr(), error_code, msg));
+void MediaPlayerBridgeCapi::OnHandlePlayerError(
+ int player_error_code, const tracked_objects::Location& location) {
+
+ LOG(ERROR) << GetErrorString(player_error_code) << " from "
+ << location.ToString();
+
+ OnMediaError(GetMediaError(player_error_code));
}
void MediaPlayerBridgeCapi::OnResumeComplete(bool success) {
void OnSeekCompleteUpdate();
void OnPlayerPrepared();
void OnHandleBufferingStatus(int percent);
- void OnHandleError(int ret, char const* from);
+ void OnHandlePlayerError(int player_error_code,
+ const tracked_objects::Location& loc);
void OnResumeComplete(bool success);
void OnInitComplete(bool success);
void OnMediaPacketUpdated(media_packet_h packet);
protected:
void Release() override;
void Prepare(CompleteCB cb);
+ void OnMediaError(MediaError error_type) override;
private:
// |duration_update_timer_| related
void SeekCompleteUpdate();
void PlayerPrepared();
void HandleBufferingStatus(int percent);
- void HandleError(int ret, char const* from);
void RunCompleteCB(bool success,
const tracked_objects::Location& from);
player_state_e GetPlayerState();
} // namespace
namespace media {
-
-struct ErrorList {
- player_error_e error_code;
- std::string error_message;
-};
-
-const struct ErrorList errorlist[] = {
- {PLAYER_ERROR_OUT_OF_MEMORY, "PLAYER_ERROR_OUT_OF_MEMORY"},
- {PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"},
- {PLAYER_ERROR_NO_SUCH_FILE, "PLAYER_ERROR_NO_SUCH_FILE"},
- {PLAYER_ERROR_INVALID_OPERATION, "PLAYER_ERROR_INVALID_OPERATION"},
- {PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE,
- "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"},
-#if defined(OS_TIZEN_MOBILE)
- {PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE,
- "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"},
-#endif
- {PLAYER_ERROR_SEEK_FAILED, "PLAYER_ERROR_SEEK_FAILED"},
- {PLAYER_ERROR_INVALID_STATE, "PLAYER_ERROR_INVALID_STATE"},
- {PLAYER_ERROR_NOT_SUPPORTED_FILE, "PLAYER_ERROR_NOT_SUPPORTED_FILE"},
- {PLAYER_ERROR_INVALID_URI, "PLAYER_ERROR_INVALID_URI"},
- {PLAYER_ERROR_SOUND_POLICY, "PLAYER_ERROR_SOUND_POLICY"},
- {PLAYER_ERROR_CONNECTION_FAILED, "PLAYER_ERROR_CONNECTION_FAILED"},
- {PLAYER_ERROR_VIDEO_CAPTURE_FAILED, "PLAYER_ERROR_VIDEO_CAPTURE_FAILED"},
- {PLAYER_ERROR_DRM_EXPIRED, "PLAYER_ERROR_DRM_EXPIRED"},
- {PLAYER_ERROR_DRM_NO_LICENSE, "PLAYER_ERROR_DRM_NO_LICENSE"},
- {PLAYER_ERROR_DRM_FUTURE_USE, "PLAYER_ERROR_DRM_FUTURE_USE"},
- {PLAYER_ERROR_DRM_NOT_PERMITTED, "PLAYER_ERROR_DRM_NOT_PERMITTED"},
- {PLAYER_ERROR_RESOURCE_LIMIT, "PLAYER_ERROR_RESOURCE_LIMIT"}};
-
-const int ERROR_MAX = sizeof(errorlist) / sizeof(errorlist[0]);
-
void OnCapiPlayerPreparedCB(void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
if (!player)
return;
- player->OnPlayerError(error_code, "OnPlayerErrorCB");
+ player->OnHandlePlayerError(error_code, FROM_HERE);
}
void MediaSourcePlayerCapi::PrepareComplete() {
/*Init Player*/
int ret = player_create(&player_);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_create");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_buffering_cb(player_, OnHandleBufferingMessageCB, this);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_buffering_cb");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_sound_type(player_, SOUND_TYPE_MEDIA);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_sound_type");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_error_cb(player_, OnPlayerErrorCB, this);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_error_cb");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_completed_cb(player_, OnPlaybackCompleteCB, this);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_completed_cb");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_media_packet_video_frame_decoded_cb(
player_, OnMediaPacketDecoded, this);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_media_packet_video_frame_decoded_cb");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
ret = player_set_uri(player_, "es_buff://push_mode");
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_set_uri");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
}
// FIXME: |player_set_playback_rate| is always failing.
int err = player_set_playback_rate(player_, static_cast<float>(rate));
if (err != PLAYER_ERROR_NONE) {
- HandlePlayerError(err, "player_set_playback_rate()");
+ OnHandlePlayerError(err, FROM_HERE);
return;
} else {
// If previous rate was zero and requested rate is non-zero, change the
MediaSeekState state = MEDIA_SEEK_PLAYER;
if (ret != PLAYER_ERROR_NONE) {
LOG(ERROR) << "Seek to " << " failed";
- HandleError(blink::WebMediaPlayer::NetworkStateDecodeError);
+ OnHandlePlayerError(ret, FROM_HERE);
state = MEDIA_SEEK_NONE;
}
UpdateSeekState(state);
#endif
int ret = player_start(player_);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_start()");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
playing_ = true;
int ret = player_pause(player_);
if (ret != PLAYER_ERROR_NONE) {
- HandlePlayerError(ret, "player_pause()");
+ OnHandlePlayerError(ret, FROM_HERE);
return;
}
StopCurrentTimeUpdateTimer();
(configs.audio_codec != kCodecAAC &&
configs.audio_codec != kCodecMP3))) {
LOG(ERROR) << "Audio and Video codecs not supported for MediaSource";
- HandleError(blink::WebMediaPlayer::NetworkStateFormatError);
+ OnHandlePlayerError(PLAYER_ERROR_NOT_SUPPORTED_FILE, FROM_HERE);
return;
}
int samplerate = configs.audio_sampling_rate;
GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveEnoughData);
}
+// Helper method that prints error occured with CAPI.
+void MediaSourcePlayerCapi::OnMediaError(MediaError error_type) {
+ StopCurrentTimeUpdateTimer();
+ MediaPlayerEfl::OnMediaError(error_type);
+}
+
void MediaSourcePlayerCapi::ReadDemuxedData(
media::DemuxerStream::Type type) {
demuxer_->RequestDemuxerData(type);
video_buffer_queue_.push_back(buffer);
}
-// Helper method that prints error occured with CAPI.
-void MediaSourcePlayerCapi::HandlePlayerError(int err, char const* from) {
- int index = 0;
- for (; index < ERROR_MAX; index++) {
- if (errorlist[index].error_code == err) {
- LOG(ERROR) << "Stoping playback of media due to Error code : " << err
- << " Error message : " << errorlist[index].error_message
- << " from " << from;
- break;
- }
- }
-
- if (index == ERROR_MAX)
- LOG(ERROR) << "Stoping playback of media due to Unknown error : "
- << err << " from " << from;
- StopCurrentTimeUpdateTimer();
- HandleError(blink::WebMediaPlayer::NetworkStateDecodeError);
-}
-
-// TODO(Venu): Called directly at few places.
-void MediaSourcePlayerCapi::HandleError(
- blink::WebMediaPlayer::NetworkState state) {
- error_occured_ = true;
- manager()->OnNetworkStateChange(GetPlayerId(), state);
-#if defined(OS_TIZEN_MOBILE)
- ReleaseDisplayLock();
-#endif
-}
-
void MediaSourcePlayerCapi::OnPrepareComplete() {
task_runner_->PostTask(
FROM_HERE, base::Bind(&MediaSourcePlayerCapi::PrepareComplete,
underflow_status));
}
-void MediaSourcePlayerCapi::OnPlayerError(int error_code, const char* msg) {
- task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaSourcePlayerCapi::HandlePlayerError,
- weak_factory_.GetWeakPtr(), error_code, msg));
+void MediaSourcePlayerCapi::OnHandlePlayerError(
+ int player_error_code, const tracked_objects::Location& location) {
+
+ LOG(ERROR) << GetErrorString(player_error_code) << " from "
+ << location.ToString();
+
+ OnMediaError(GetMediaError(player_error_code));
}
} // namespace media
void OnHandleBufferingMessage(int percent);
void OnPlaybackComplete();
void OnPrepareComplete();
- void OnPlayerError(int error_code, const char* msg);
+ void OnHandlePlayerError(int player_error_code,
+ const tracked_objects::Location& loc);
void OnMediaPacketUpdated(media_packet_h packet);
protected:
void Release() override;
+ void OnMediaError(MediaError error_type) override;
private:
player_state_e GetPlayerState();
base::SharedMemoryHandle foreign_memory_handle,
const media::DemuxedBufferMetaData& meta_data);
- // Error handling API
- void HandlePlayerError(int err, char const* from);
- void HandleError(blink::WebMediaPlayer::NetworkState state);
-
scoped_ptr<DemuxerEfl> demuxer_;
const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
projects / platform / framework / web / chromium-efl.git / commitdiff