fixup! [MM][MSE][CAPI] Implement MSE with CAPI port.

CAPI returning internal errors through error callback function.
Updated error handling code to handle CAPI errors.

CAPI player state is updated based on buffer status callback.

Shared memory is wrapped to mediapacket. So, memcpy of input buffer is
reduced.

It fixs minor style violations, which is applied in beta/m42_2311_t.

Reference: http://165.213.202.130/gerrit/#/c/95263/

Reviewed by: msu.koo, sm.venugopal, sns.park

Change-Id: I9a44300f4ca76fe26e44f3f5a85edd0087cc5fb1
Signed-off-by: k2.nagaraju <k2.nagaraju@samsung.com>

diff --git a/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.cc b/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.cc
index 76ed86b..7d2b234 100755 (executable)
--- a/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.cc
+++ b/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.cc
@@ -24,7 +24,14 @@ const int kDurationUpdateInterval = 100;
 const double kSeekBufferingWaitInSec = 2;
 
 // Iframe time offset for demuxer.
-const double kDemuxerSeekIFrameTime = 0.5;
+const double kDemuxerSeekIFrameTime = (0.5);
+
+// Appsrc Buffering size
+const unsigned long long max_size = 2097152;  // 2MB
+
+// Appsrc minimum buffering level
+const unsigned int min_threshold = 30;
+
 }  // namespace
 
 
@@ -88,7 +95,7 @@ static void OnCapiVideoBufStatusCB(unsigned int size, void* user_data) {
       static_cast<MediaSourcePlayerCapi*>(user_data);
   if (!player || player->IsPlayerDestructing())
     return;
-  player->OnReadDemuxedData(media::DemuxerStream::VIDEO, true);
+  player->OnReadDemuxedData(media::DemuxerStream::VIDEO);
 }
 
 static void OnCapiAudioBufStatusCB(unsigned int size, void* user_data) {
@@ -96,7 +103,7 @@ static void OnCapiAudioBufStatusCB(unsigned int size, void* user_data) {
       static_cast<MediaSourcePlayerCapi*>(user_data);
   if (!player || player->IsPlayerDestructing())
     return;
-  player->OnReadDemuxedData(media::DemuxerStream::AUDIO, true);
+  player->OnReadDemuxedData(media::DemuxerStream::AUDIO);
 }
 
 #else
@@ -107,9 +114,9 @@ static void OnCapiAudioBufStatusCB(player_media_stream_buffer_status_e status,
   if (!player || player->IsPlayerDestructing())
     return;
   if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
-    player->OnReadDemuxedData(media::DemuxerStream::AUDIO, true);
+    player->OnUpdateDataStatus(media::DemuxerStream::AUDIO, true);
   } else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
-      player->OnReadDemuxedData(media::DemuxerStream::AUDIO, false);
+    player->OnUpdateDataStatus(media::DemuxerStream::AUDIO, false);
   }
 }
 
@@ -120,9 +127,9 @@ static void  OnCapiVideoBufStatusCB(player_media_stream_buffer_status_e status,
   if (!player || player->IsPlayerDestructing())
     return;
   if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
-    player->OnReadDemuxedData(media::DemuxerStream::VIDEO, true);
+    player->OnUpdateDataStatus(media::DemuxerStream::VIDEO, true);
   } else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
-      player->OnReadDemuxedData(media::DemuxerStream::VIDEO, false);
+    player->OnUpdateDataStatus(media::DemuxerStream::VIDEO, false);
   }
 }
 #endif  // USE_LEGACY_PLAYER_CAPI
@@ -144,6 +151,7 @@ static void OnMediaPktDecoded(media_packet_h packet, void* data) {
 #endif
 
 void OnPlaybackCompleteCB(void* user_data) {
+  LOG(INFO) << "On playback complete Call back";
   MediaSourcePlayerCapi* player =
     static_cast<MediaSourcePlayerCapi*>(user_data);
 
@@ -153,6 +161,22 @@ void OnPlaybackCompleteCB(void* user_data) {
   player->OnPlaybackComplete();
 }
 
+void OnPlayerErrorCB(int error_code, void* user_data) {
+  MediaSourcePlayerCapi* player =
+    static_cast<MediaSourcePlayerCapi*>(user_data);
+
+  if (!player)
+    return;
+
+  player->OnPlayerError(error_code, "OnPlayerErrorCB");
+}
+
+void MediaSourcePlayerCapi::OnPlayerError(int error_code, const char* msg) {
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MediaSourcePlayerCapi::handlePlayerError,
+                            base::Unretained(this), error_code, msg));
+}
+
 void MediaSourcePlayerCapi::OnPlaybackComplete() {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaSourcePlayerCapi::PlaybackComplete,
@@ -167,7 +191,6 @@ void MediaSourcePlayerCapi::OnHandleBufferingMessage(int perc) {
 }
 
 void MediaSourcePlayerCapi::OnPrepareComplete() {
-  LOG(INFO) << __FUNCTION__;
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaSourcePlayerCapi::PrepareComplete,
                             base::Unretained(this)));
@@ -191,9 +214,7 @@ MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(
 }
 
 MediaSourcePlayerCapi::MediaSourcePlayerCapi(
-    int player_id,
-    scoped_ptr<DemuxerEfl> demuxer,
-    MediaPlayerManager* manager)
+    int player_id, scoped_ptr<DemuxerEfl> demuxer, MediaPlayerManager* manager)
     : MediaPlayerEfl(player_id, manager),
       demuxer_(demuxer.Pass()),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ -212,15 +233,15 @@ MediaSourcePlayerCapi::MediaSourcePlayerCapi(
       is_end_reached_(false),
       error_occured_(false),
       player_prepared_(false),
-      media_packet_(NULL),
-      m_videoFormat(NULL),
-      m_audioFormat(NULL),
       Eos_video(false),
       Eos_audio(false),
+      media_packet_(NULL),
 #if defined(TIZEN_VIDEO_HOLE)
       native_window_(0),
 #else
       previous_packet_(NULL),
+      m_videoFormat(NULL),
+      m_audioFormat(NULL),
 #endif
       seek_offset_(0) {
   demuxer_->Initialize(this);
@@ -245,7 +266,11 @@ MediaSourcePlayerCapi::MediaSourcePlayerCapi(
     handlePlayerError(ret, "player_set_sound_type");
     return;
   }
-
+  ret = player_set_error_cb(player_, OnPlayerErrorCB, this);
+  if (ret != PLAYER_ERROR_NONE) {
+    handlePlayerError(ret, "player_set_error_cb");
+    return;
+  }
   ret = player_set_completed_cb(player_, OnPlaybackCompleteCB, this);
   if (ret != PLAYER_ERROR_NONE) {
     handlePlayerError(ret, "player_set_completed_cb");
@@ -302,20 +327,21 @@ MediaSourcePlayerCapi::MediaSourcePlayerCapi(
 
 // Helper method which prints errors occured while calling CAPI api's.
 void MediaSourcePlayerCapi::handlePlayerError(int err, char const* from) {
-  int index;
-  for (index = 0; index < ERROR_MAX; index++) {
+  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;
+                 << " 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;
-
+               << err << " from " << from;
+  StopCurrentTimeUpdateTimer();
+  HandleError(MediaPlayerEfl::NetworkStateDecodeError);
 }
 
 void MediaSourcePlayerCapi::HandleError(
@@ -330,7 +356,7 @@ void MediaSourcePlayerCapi::HandleError(
 void MediaSourcePlayerCapi::HandleBufferingMessage(int percent) {
   if (IsPlayerDestructing())
     return;
-  // add code if required
+  // FIXME: add code if required
   return;
 }
 
@@ -339,15 +365,14 @@ void MediaSourcePlayerCapi::SeekComplete() {
 
   // Initiate play for internal seeks.
   if (GetPlayerState() != PLAYER_STATE_PLAYING)
-    task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&MediaSourcePlayerCapi::Play,
-                         base::Unretained(this)));
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&MediaSourcePlayerCapi::Play,
+                              base::Unretained(this)));
 
   manager()->OnTimeUpdate(GetPlayerId(), GetCurrentTime());
   task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&MediaSourcePlayerCapi::OnTimeChanged,
-                     base::Unretained(this)));
+      FROM_HERE, base::Bind(&MediaSourcePlayerCapi::OnTimeChanged,
+                            base::Unretained(this)));
 }
 
 void MediaSourcePlayerCapi::UpdateSeekState(MediaSeekState state) {
@@ -437,8 +462,9 @@ void MediaSourcePlayerCapi::SeekInternal() {
   ret = player_set_position(player_,
       ConvertSecondsToMilliSeconds(seek_offset_), OnSeekCompleteCB, this);
 #else
-  ret = player_set_play_position(player_,
-      ConvertSecondsToMilliSeconds(seek_offset_), true, OnSeekCompleteCB, this);
+  ret = player_set_play_position(
+      player_, ConvertSecondsToMilliSeconds(seek_offset_),
+      true, OnSeekCompleteCB, this);
 #endif
 
   seek_offset_ = 0.0;
@@ -467,8 +493,8 @@ void MediaSourcePlayerCapi::OnDemuxerSeekDone(
   audio_buffer_queue_.clear();
   video_buffer_queue_.clear();
 
-  OnReadDemuxedData(media::DemuxerStream::AUDIO, true);
-  OnReadDemuxedData(media::DemuxerStream::VIDEO, true);
+  OnReadDemuxedData(media::DemuxerStream::AUDIO);
+  OnReadDemuxedData(media::DemuxerStream::VIDEO);
 }
 
 #if defined(TIZEN_VIDEO_HOLE)
@@ -483,7 +509,8 @@ void MediaSourcePlayerCapi::MoveAndresizeWindow(int x, int y, int width,
     return;
 
   Display* native_display = static_cast<Display*>(ecore_x_display_get());
-  if (!XMoveResizeWindow(native_display, native_window_, x, y, width, height)) {
+  if (!XMoveResizeWindow(
+      native_display, native_window_, x, y, width, height)) {
     return;
   }
 
@@ -503,21 +530,20 @@ void MediaSourcePlayerCapi::MediaPacketUpdated(media_packet_h packet) {
   if (previous_packet_)
     media_packet_destroy(previous_packet_);
 
-  tbm_surface_h surface;
+  tbm_surface_h surface = nullptr;
   media_packet_get_tbm_surface(packet, &surface);
   SendFrame(surface);
   previous_packet_ = packet;
 }
 
 void MediaSourcePlayerCapi::SendFrame(tbm_surface_h surface) {
-  tbm_surface_info_s suf_info;
+  tbm_surface_info_s suf_info = {0, };
   int ret = tbm_surface_get_info(surface, &suf_info);
   if (ret != TBM_SURFACE_ERROR_NONE) {
     LOG(ERROR) << "tbm_surface_get_info() failed";
     return;
   }
-  if (height_ != suf_info.height ||
-      width_ != suf_info.width ||
+  if (height_ != suf_info.height || width_ != suf_info.width ||
       video_format_ == 0) {
     height_ = suf_info.height;
     width_ = suf_info.width;
@@ -540,7 +566,7 @@ void MediaSourcePlayerCapi::SendFrame(tbm_surface_h surface) {
     return;
   }
 
-  int position;
+  int position = 0;
 #if defined(USE_LEGACY_PLAYER_CAPI)
   player_get_position(player_, &position);
 #else
@@ -555,7 +581,7 @@ void MediaSourcePlayerCapi::SendFrame(tbm_surface_h surface) {
 #endif  // TIZEN_VIDEO_HOLE
 
 void MediaSourcePlayerCapi::SetVolume(double volume) {
-  if (GetPlayerState() == PLAYER_STATE_NONE)
+  if (GetPlayerState() <= PLAYER_STATE_IDLE)
     return;
 
   if (player_set_volume(player_, volume, volume) != PLAYER_ERROR_NONE)
@@ -589,13 +615,14 @@ void MediaSourcePlayerCapi::OnCurrentTimeUpdateTimerFired() {
 }
 
 void MediaSourcePlayerCapi::StartCurrentTimeUpdateTimer() {
-  if (!current_time_update_timer_.IsRunning()) {
-    current_time_update_timer_.Start(
-        FROM_HERE,
-        base::TimeDelta::FromMilliseconds(kDurationUpdateInterval),
-        this,
-        &MediaSourcePlayerCapi::OnCurrentTimeUpdateTimerFired);
-  }
+  if (current_time_update_timer_.IsRunning())
+    return;
+
+  current_time_update_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kDurationUpdateInterval),
+      this,
+      &MediaSourcePlayerCapi::OnCurrentTimeUpdateTimerFired);
 }
 
 void MediaSourcePlayerCapi::StopCurrentTimeUpdateTimer() {
@@ -612,17 +639,16 @@ void MediaSourcePlayerCapi::Play() {
     return;
   }
 
-
 #if defined(OS_TIZEN_MOBILE)
   WakeUpDisplayAndAcquireDisplayLock();
 #endif
-    int ret = player_start(player_);
-    if (ret != PLAYER_ERROR_NONE) {
-      handlePlayerError(ret, "player_start()");
-      return;
-    }
-    playing_ = true;
-    StartCurrentTimeUpdateTimer();
+  int ret = player_start(player_);
+  if (ret != PLAYER_ERROR_NONE) {
+    handlePlayerError(ret, "player_start()");
+    return;
+  }
+  playing_ = true;
+  StartCurrentTimeUpdateTimer();
 }
 
 void MediaSourcePlayerCapi::Pause(bool is_media_related_action) {
@@ -683,6 +709,9 @@ void MediaSourcePlayerCapi::Release() {
   if (media_packet_)
     media_packet_destroy(media_packet_);
   media_packet_ = NULL;
+  if (previous_packet_)
+    media_packet_destroy(previous_packet_);
+  previous_packet_ = NULL;
 #endif
 }
 
@@ -756,21 +785,20 @@ void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
     return;
   }
 
-  media_format_mimetype_e audiomimeType;
+  media_format_mimetype_e audiomimeType = MEDIA_FORMAT_MP3;
   if (configs.audio_codec == kCodecAAC)
     audiomimeType = MEDIA_FORMAT_AAC;
-  else if (configs.audio_codec == kCodecMP3)
-    audiomimeType = MEDIA_FORMAT_MP3;
 
-  LOG(INFO) << "samplerate " <<samplerate << " channel "
-             << channel << " audiomimeType " << audiomimeType;
+  LOG(INFO) << "samplerate: " << samplerate
+            << ", channel: " << channel
+            << ", audiomimeType: " << audiomimeType;
 
   media_format_set_audio_mime(m_audioFormat, audiomimeType);
   media_format_set_audio_channel(m_audioFormat, channel);
   media_format_set_audio_samplerate(m_audioFormat, samplerate);
 
   ret = player_set_media_stream_info(player_, PLAYER_STREAM_TYPE_AUDIO,
-                                       m_audioFormat);
+                                     m_audioFormat);
   if (ret != PLAYER_ERROR_NONE) {
     LOG(ERROR) << "player_set_audio_stream_info Error: " << ret;
     return;
@@ -790,16 +818,15 @@ void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
     return;
   }
 
-  media_format_mimetype_e videomimeType;
-  if (configs.video_codec == kCodecH264)
-      videomimeType = MEDIA_FORMAT_H264_SP;
+  media_format_mimetype_e videomimeType = MEDIA_FORMAT_H264_SP;
 
   media_format_set_video_mime(m_videoFormat, videomimeType);
   media_format_set_video_width(m_videoFormat, width_);
   media_format_set_video_height(m_videoFormat, height_);
 
-  LOG(INFO) << "width " <<width_ << " height " << height_
-             << " videomimeType " << videomimeType;
+  LOG(INFO) << "width: " << width_
+            << ", height: " << height_
+            << ", videomimeType: " << videomimeType;
 
   ret = player_set_media_stream_info(player_,
                                      PLAYER_STREAM_TYPE_VIDEO,
@@ -809,6 +836,12 @@ void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
     return;
   }
 
+  // FIXME(Kodam): This property should be updated based on dynamic
+  // resolution change
+  player_set_media_stream_buffer_max_size(
+      player_, PLAYER_STREAM_TYPE_VIDEO, max_size);
+  player_set_media_stream_buffer_min_threshold(
+      player_, PLAYER_STREAM_TYPE_VIDEO, min_threshold);
   ret = player_set_media_stream_buffer_status_cb(player_,
                                                  PLAYER_STREAM_TYPE_VIDEO,
                                                  OnCapiVideoBufStatusCB,
@@ -821,6 +854,7 @@ void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
   // Audio stream is present if sample rate is valid.
   if (samplerate > 0)
     media_type_ |= MEDIA_AUDIO_MASK;
+
   // Video stream is present if both video width and height are valid.
   if (width_ > 0 && height_ > 0)
     media_type_ |= MEDIA_VIDEO_MASK;
@@ -837,10 +871,11 @@ void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
       return;
     }
   }
-  // Need to check where is the exact place for this code.
+
+  // FIXME(Venu): Need to check where is the exact place for this code.
   // For make it work added this below code
   manager()->OnReadyStateChange(GetPlayerId(),
-                    MediaPlayerEfl::ReadyStateHaveEnoughData);
+                                MediaPlayerEfl::ReadyStateHaveEnoughData);
 }
 
 void MediaSourcePlayerCapi::ReadDemuxedData(
@@ -850,24 +885,74 @@ void MediaSourcePlayerCapi::ReadDemuxedData(
   demuxer_->RequestDemuxerData(type);
 }
 
-void MediaSourcePlayerCapi::OnReadDemuxedData(
-    media::DemuxerStream::Type type, bool status) {
+// FIXME(Venu): Handle on main thread in first place.
+void MediaSourcePlayerCapi::OnUpdateDataStatus(
+    media::DemuxerStream::Type type, bool underflow_status) {
   if (IsPlayerDestructing()) {
     LOG(ERROR) << "CAPI player deinitializing. Just return";
     return;
   }
+
   if (type == media::DemuxerStream::VIDEO) {
-    should_feed_video_ = status;
+    HandleUnderFlowStatus(media::DemuxerStream::VIDEO,
+                          underflow_status, should_feed_video_);
   } else if (type == media::DemuxerStream::AUDIO) {
-    should_feed_audio_ = status;
+    HandleUnderFlowStatus(media::DemuxerStream::AUDIO,
+                          underflow_status, should_feed_audio_);
   }
-  if (status) {
+}
+
+void MediaSourcePlayerCapi::HandleUnderFlowStatus(
+    media::DemuxerStream::Type type, bool underflow_status, bool should_feed_) {
+  if (underflow_status && !should_feed_) {
+    if (type == media::DemuxerStream::VIDEO) {
+      should_feed_video_ = underflow_status;
+      LOG(INFO) << "Video Underflow " << should_feed_video_
+                << " call CAPI Pause";
+    } else if (type == media::DemuxerStream::AUDIO) {
+      should_feed_audio_ = underflow_status;
+      LOG(INFO) << "Audio Underflow " << should_feed_audio_
+                << " call CAPI Pause";
+    }
+    if (player_prepared_) {
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(&MediaSourcePlayerCapi::Pause,
+                                base::Unretained(this), true));
+    }
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&MediaSourcePlayerCapi::ReadDemuxedData,
                               base::Unretained(this), type));
+  } else if (!underflow_status && should_feed_) {
+    if (type == media::DemuxerStream::VIDEO) {
+      should_feed_video_ = underflow_status;
+      LOG(INFO) << "Video Overflow " << should_feed_video_
+                << " call CAPI Play";
+    } else if (type == media::DemuxerStream::AUDIO) {
+      should_feed_audio_ = underflow_status;
+      LOG(INFO) << "Audio Overflow " << should_feed_audio_
+                << " call CAPI Play";
+    }
+
+    // FIXME(Kodam): Distinguish from user triggered PAUSE.
+    if(!should_feed_audio_ && !should_feed_video_) {
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(&MediaSourcePlayerCapi::Play,
+                                base::Unretained(this)));
+    }
   }
 }
 
+void MediaSourcePlayerCapi::OnReadDemuxedData(
+    media::DemuxerStream::Type type) {
+  if (IsPlayerDestructing()) {
+    LOG(ERROR) << "CAPI player deinitializing. Just return";
+    return;
+  }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MediaSourcePlayerCapi::ReadDemuxedData,
+                            base::Unretained(this), type));
+}
+
 void MediaSourcePlayerCapi::OnDemuxerDataAvailable(
     base::SharedMemoryHandle foreign_memory_handle,
     const media::DemuxedBufferMetaData& meta_data) {
@@ -892,12 +977,13 @@ void MediaSourcePlayerCapi::OnDemuxerDataAvailable(
     LOG(ERROR) << "ERROR : Size of shared memory is Zero";
     return;
   }
-
+#if defined(USE_LEGACY_PLAYER_CAPI)
   if (should_feed_audio_ && should_feed_video_ &&
       !playing_ && player_prepared_ && (seek_state_ == MEDIA_SEEK_NONE)) {
-    Play();
+      if (GetPlayerState() != PLAYER_STATE_PAUSED)
+        Play();
   }
-
+#endif
   ReadFromQueueIfAny(meta_data.type);
 
   if (meta_data.type == media::DemuxerStream::AUDIO && !should_feed_audio_) {
@@ -923,64 +1009,32 @@ void MediaSourcePlayerCapi::OnDemuxerDataAvailable(
     return;
   }
 
-#if defined(USE_LEGACY_PLAYER_CAPI)
-  int ret = PLAYER_ERROR_NONE;
-  if (meta_data.type == media::DemuxerStream::AUDIO) {
-    ret = player_submit_packet(player_,
-                               static_cast<uint8*>shared_memory.memory(),
-                               size, timestamp, PLAYER_TRACK_TYPE_AUDIO);
-  } else if (meta_data.type == media::DemuxerStream::VIDEO) {
-      ret = player_submit_packet(player_,
-                                 static_cast<uint8*>shared_memory.memory(),
-                                 size, timestamp, PLAYER_TRACK_TYPE_VIDEO);
-  }
-  if (ret != PLAYER_ERROR_NONE) {
-    LOG(ERROR) << "player_submit_packet()  Error: " <<  ret;
-    return;
-  }
-#else
   if (meta_data.type == media::DemuxerStream::AUDIO) {
-    if (media_packet_create_alloc(m_audioFormat, NULL, NULL, &media_packet_)
+    if (media_packet_create_from_external_memory(
+        m_audioFormat, static_cast<void*>(shared_memory.memory()),
+        meta_data.size, NULL, NULL, &media_packet_)
             != MEDIA_PACKET_ERROR_NONE) {
-      LOG(ERROR) << "media_packet_create_alloc failed\n";
-      media_format_unref(m_audioFormat);
+      LOG(ERROR) << "Audio media_packet_create_from_external_memory failed";
       return;
     }
   } else if (meta_data.type == media::DemuxerStream::VIDEO) {
-    if (media_packet_create_alloc(m_videoFormat, NULL, NULL, &media_packet_)
+    if (media_packet_create_from_external_memory(
+        m_videoFormat, static_cast<void*>(shared_memory.memory()),
+        meta_data.size, NULL, NULL, &media_packet_)
             != MEDIA_PACKET_ERROR_NONE) {
-      LOG(ERROR) << "media_packet_create_alloc failed\n";
-      media_format_unref(m_videoFormat);
+      LOG(ERROR) << "Video media_packet_create_from_external_memory failed";
       return;
     }
   }
-  uint8_t* data = NULL;
-  if (media_packet_get_buffer_data_ptr(media_packet_,
-                                       reinterpret_cast<void**>(&data))
-          != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_get_buffer_data_ptr failed\n";
-    return;
-  }
-
-  if (media_packet_set_buffer_size(media_packet_, meta_data.size)
-          != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_set_buffer_size failed\n";
-    return;
-  }
 
   if (media_packet_set_pts(media_packet_, meta_data.timestamp.InMilliseconds())
           != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_set_pts failed\n";
+    LOG(ERROR) << "media_packet_set_pts failed";
     return;
   }
-
-  memcpy(data, shared_memory.memory(), meta_data.size);
-
   if (player_push_media_stream(player_, media_packet_)
-          != PLAYER_ERROR_NONE) {
+          != MEDIA_PACKET_ERROR_NONE)
     LOG(ERROR) << "player_push_media_stream failed";
-    return;
-  }
 
   if (meta_data.type == media::DemuxerStream::AUDIO)
     media_format_unref(m_audioFormat);
@@ -990,12 +1044,11 @@ void MediaSourcePlayerCapi::OnDemuxerDataAvailable(
   if (media_packet_)
     media_packet_destroy(media_packet_);
   media_packet_ = NULL;
-#endif
+
   if (meta_data.type == media::DemuxerStream::AUDIO)
-    OnReadDemuxedData(media::DemuxerStream::AUDIO, should_feed_audio_);
+    OnReadDemuxedData(media::DemuxerStream::AUDIO);
   else if (meta_data.type == media::DemuxerStream::VIDEO)
-    OnReadDemuxedData(media::DemuxerStream::VIDEO, should_feed_video_);
-
+    OnReadDemuxedData(media::DemuxerStream::VIDEO);
   return;
 }
 
@@ -1009,17 +1062,13 @@ void MediaSourcePlayerCapi::BufferMetaDataAvailable(
 
   switch (meta_data.status) {
     case media::DemuxerStream::kAborted:
-      if (meta_data.type == media::DemuxerStream::AUDIO)
-        OnReadDemuxedData(media::DemuxerStream::AUDIO, should_feed_audio_);
-      else if (meta_data.type == media::DemuxerStream::VIDEO)
-        OnReadDemuxedData(media::DemuxerStream::VIDEO, should_feed_video_);
-      break;
-
+      LOG(WARNING) << "[BROWSER] : DemuxerStream::kAborted, Stream type = "
+                   << meta_data.type;
     case media::DemuxerStream::kConfigChanged:
       if (meta_data.type == media::DemuxerStream::AUDIO)
-        OnReadDemuxedData(media::DemuxerStream::AUDIO, should_feed_audio_);
+        OnReadDemuxedData(media::DemuxerStream::AUDIO);
       else if (meta_data.type == media::DemuxerStream::VIDEO)
-        OnReadDemuxedData(media::DemuxerStream::VIDEO, should_feed_video_);
+        OnReadDemuxedData(media::DemuxerStream::VIDEO);
       break;
 
     case media::DemuxerStream::kOk:
@@ -1038,46 +1087,49 @@ void MediaSourcePlayerCapi::BufferMetaDataAvailable(
 }
 
 void MediaSourcePlayerCapi::SendEosToCapi(
-       const media::DemuxedBufferMetaData& meta_data) {
+    const media::DemuxedBufferMetaData& meta_data) {
+  int ret = PLAYER_ERROR_NONE;
 #if defined(USE_LEGACY_PLAYER_CAPI)
   if (meta_data.type == media::DemuxerStream::AUDIO)
-    player_submit_packet(player_, NULL, 0, 0, PLAYER_TRACK_TYPE_AUDIO);
+    ret = player_submit_packet(player_, NULL, 0, 0, PLAYER_TRACK_TYPE_AUDIO);
   else if (meta_data.type == media::DemuxerStream::VIDEO)
-    player_submit_packet(player_, NULL, 0, 0, PLAYER_TRACK_TYPE_VIDEO);
+    ret = player_submit_packet(player_, NULL, 0, 0, PLAYER_TRACK_TYPE_VIDEO);
+  if (ret != PLAYER_ERROR_NONE)
+    handlePlayerError(ret, "player_submit_packet()");
 #else
   if (meta_data.type == media::DemuxerStream::AUDIO) {
     if (!Eos_audio) {
       if (media_packet_create(m_audioFormat, NULL, NULL, &media_packet_)
               != MEDIA_PACKET_ERROR_NONE) {
-        LOG(ERROR) << "media_packet_create_alloc failed\n";
-        media_format_unref(m_audioFormat);
+        LOG(ERROR) << "Audio media_packet_create failed";
         return;
       }
       Eos_audio = true;
     } else {
-        LOG(ERROR) << "Audio EOS Already Pushed";
-        return;
+      LOG(ERROR) << "Audio EOS Already Pushed";
+      return;
     }
   } else if (meta_data.type == media::DemuxerStream::VIDEO) {
-      if (!Eos_video) {
-        if (media_packet_create(m_videoFormat, NULL, NULL, &media_packet_)
-                != MEDIA_PACKET_ERROR_NONE) {
-          LOG(ERROR) << "media_packet_create_alloc failed\n";
-          media_format_unref(m_videoFormat);
-          return;
-        }
-        Eos_video = true;
-      } else {
-          LOG(ERROR) << "Video EOS Already Pushed";
-          return;
+    if (!Eos_video) {
+      if (media_packet_create(m_videoFormat, NULL, NULL, &media_packet_)
+              != MEDIA_PACKET_ERROR_NONE) {
+        LOG(ERROR) << "Video media_packet_create failed";
+        return;
       }
+      Eos_video = true;
+    } else {
+      LOG(ERROR) << "Video EOS Already Pushed";
+      return;
+    }
   }
-  media_packet_set_flags(media_packet_, MEDIA_PACKET_END_OF_STREAM);
 
-  if (player_push_media_stream(player_, media_packet_) != PLAYER_ERROR_NONE) {
+  if (media_packet_set_flags(media_packet_, MEDIA_PACKET_END_OF_STREAM)
+          != MEDIA_PACKET_ERROR_NONE)
+    LOG(ERROR) << "media_packet_set_flags failed";
+
+  if (player_push_media_stream(player_, media_packet_)
+          != MEDIA_PACKET_ERROR_NONE)
     LOG(ERROR) << "player_push_media_stream failed";
-    return;
-  }
 
   if (meta_data.type == media::DemuxerStream::AUDIO)
     media_format_unref(m_audioFormat);
@@ -1087,13 +1139,14 @@ void MediaSourcePlayerCapi::SendEosToCapi(
   if (media_packet_)
     media_packet_destroy(media_packet_);
   media_packet_ = NULL;
+
 #endif
   return;
 }
 
 void MediaSourcePlayerCapi::ReadFromQueueIfAny(
     DemuxerStream::Type type) {
-  uint8_t* data = NULL;
+  void* data = NULL;
   if (error_occured_) {
     LOG(ERROR) << "error occured in capi";
     return;
@@ -1121,64 +1174,36 @@ void MediaSourcePlayerCapi::ReadFromQueueIfAny(
   uint64 size = static_cast<uint64>(decoder_buffer.get()->data_size());
 
   uint64 timestamp =
-      static_cast<uint64>(decoder_buffer.get()->timestamp().InMicroseconds() *
-                           1000);
-#if defined(USE_LEGACY_PLAYER_CAPI)
-  int ret;
+      static_cast<uint64>(decoder_buffer.get()->timestamp().InMilliseconds());
   if (type == media::DemuxerStream::AUDIO) {
-    ret = player_submit_packet(player_,
-                               decoder_buffer.get()->writable_data(),
-                               size, timestamp, PLAYER_TRACK_TYPE_AUDIO);
-  } else if (type == media::DemuxerStream::VIDEO) {
-    ret = player_submit_packet(player_,
-                               decoder_buffer.get()->writable_data(),
-                               size, timestamp, PLAYER_TRACK_TYPE_VIDEO);
-  }
-  if (ret != PLAYER_ERROR_NONE) {
-    LOG(ERROR) << "player_submit_packet() Error: " <<  ret;
-    return;
-  }
-#else
-  if (type == media::DemuxerStream::AUDIO) {
-    if (media_packet_create_alloc(m_audioFormat, NULL, NULL, &media_packet_)
+    if (media_packet_create_from_external_memory(
+        m_audioFormat,
+        static_cast<void*>(decoder_buffer.get()->writable_data()),
+        size, NULL, NULL, &media_packet_)
             != MEDIA_PACKET_ERROR_NONE) {
-      LOG(ERROR) << "Audio media_packet_create_alloc failed\n";
-      media_format_unref(m_audioFormat);
+      LOG(ERROR) << "Audio media_packet_create_from_external_memory failed";
       return;
     }
   } else if (type == media::DemuxerStream::VIDEO) {
-      if (media_packet_create_alloc(m_videoFormat, NULL, NULL, &media_packet_)
-              != MEDIA_PACKET_ERROR_NONE) {
-        LOG(ERROR) << "Video media_packet_create_alloc failed\n";
-        media_format_unref(m_videoFormat);
-        return;
-      }
-  }
-
-  if (media_packet_get_buffer_data_ptr(media_packet_,
-                                       reinterpret_cast<void**>(&data))
-          != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_get_buffer_data_ptr failed\n";
-    return;
-  }
-  memcpy(data, decoder_buffer.get()->writable_data(), size);
-
-  if (media_packet_set_buffer_size(media_packet_, (uint64)size)
-          != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_set_buffer_size failed\n";
-    return;
+    if (media_packet_create_from_external_memory(
+        m_videoFormat,
+        static_cast<void*>(decoder_buffer.get()->writable_data()),
+        size, NULL, NULL, &media_packet_)
+            != MEDIA_PACKET_ERROR_NONE) {
+      LOG(ERROR) << "Video media_packet_create_from_external_memory failed";
+      return;
+    }
   }
 
   if (media_packet_set_pts(media_packet_, timestamp)
           != MEDIA_PACKET_ERROR_NONE) {
-    LOG(ERROR) << "media_packet_set_pts failed\n";
+    LOG(ERROR) << "media_packet_set_pts failed";
     return;
   }
+
   if (player_push_media_stream(player_, media_packet_)
-          != PLAYER_ERROR_NONE) {
+          != MEDIA_PACKET_ERROR_NONE)
     LOG(ERROR) << "player_push_media_stream failed";
-    return;
-  }
 
   if (type == media::DemuxerStream::AUDIO)
     media_format_unref(m_audioFormat);
@@ -1189,7 +1214,7 @@ void MediaSourcePlayerCapi::ReadFromQueueIfAny(
   if (media_packet_)
     media_packet_destroy(media_packet_);
   media_packet_ = NULL;
-#endif
+
   ReadFromQueueIfAny(type);
   return;
 }
@@ -1224,4 +1249,5 @@ void MediaSourcePlayerCapi::SaveDecoderBuffer(
   else if (meta_data.type == media::DemuxerStream::VIDEO)
     video_buffer_queue_.push_back(buffer);
 }
+
 }  // namespace media

diff --git a/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.h b/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.h
old mode 100644 (file)
new mode 100755 (executable)
index af8ad94..4d8527f
--- a/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.h
+++ b/tizen_src/chromium_impl/media/base/tizen/media_source_player_capi.h
@@ -32,8 +32,7 @@ class MEDIA_EXPORT MediaSourcePlayerCapi
   // Constructs a player with the given ID and demuxer. |manager| must outlive
   // the lifetime of this object.
   MediaSourcePlayerCapi(
-      int player_id,
-      scoped_ptr<DemuxerEfl> demuxer,
+      int player_id, scoped_ptr<DemuxerEfl> demuxer,
       MediaPlayerManager* manager);
 
   ~MediaSourcePlayerCapi() override {};
@@ -57,7 +56,9 @@ class MEDIA_EXPORT MediaSourcePlayerCapi
       const base::TimeDelta& actual_browser_seek_time) override;
   void OnDemuxerDurationChanged(base::TimeDelta duration) override;
 
-  void OnReadDemuxedData(media::DemuxerStream::Type type, bool status);
+  void OnReadDemuxedData(media::DemuxerStream::Type type);
+  void OnUpdateDataStatus(media::DemuxerStream::Type type,
+                          bool underflow_status);
   void SeekComplete();
 #if defined(TIZEN_VIDEO_HOLE)
   void PlatformSurfaceUpdated();
@@ -68,6 +69,7 @@ class MEDIA_EXPORT MediaSourcePlayerCapi
   void OnHandleBufferingMessage(int percent);
   void OnPlaybackComplete();
   void OnPrepareComplete();
+  void OnPlayerError(int error_code, const char* msg);
  protected:
   void Release() override;
 
@@ -104,7 +106,8 @@ class MEDIA_EXPORT MediaSourcePlayerCapi
 
   // Error handling API
   void HandleError(media::MediaPlayerEfl::NetworkState state);
-
+  void HandleUnderFlowStatus(media::DemuxerStream::Type type,
+                             bool underflow_status, bool should_feed_);
   scoped_ptr<DemuxerEfl> demuxer_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
@@ -142,10 +145,13 @@ class MEDIA_EXPORT MediaSourcePlayerCapi
   unsigned native_window_;
 #else
   media_packet_h previous_packet_;
-#endif
-  double seek_offset_;
+
+  // FIXME(Venu): Make them a smart pointer to avoid leak.
   media_format_h m_videoFormat;
   media_format_h m_audioFormat;
+#endif
+  double seek_offset_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerCapi);
 };