Fix several android issues. 1. Fix "cannot launch" issue: fix fortify fwrite FILE issue and add null ptr check on configuration params. 2. Add media codec capacity check in extractor mode. 3. Fix hang issue in initial process by increasing the timeout limitation of init segment processing. 4. Fix hang issue in switching viewport by correcting stitching strategy. 5. Fix core dump issue caused by get/add current pose. 6. Fix mismatch frame issue in non-catchup mode.

luoying1234 · U1X6WK · commit 9b8569ab9074 · 2021-07-02T10:28:19.000+08:00
Signed-off-by: Luo, Ying &lt;ying2.luo@intel.com&gt;
diff --git a/src/OmafDashAccess/OmafDashSource.cpp b/src/OmafDashAccess/OmafDashSource.cpp
@@ -705,7 +705,7 @@ void OmafDashSource::thread_dynamic() {
     SetStatus(STATUS_STOPPED);
     return;
   }
-  uint32_t wait_time = 3000;
+  uint32_t wait_time = 10000;
   uint32_t current_wait_time = 0;
   bool isInitSegParsed = omaf_reader_mgr_->IsInitSegmentsParsed();
   while (!isInitSegParsed) {
@@ -795,7 +795,7 @@ void OmafDashSource::thread_static() {
     SetStatus(STATUS_STOPPED);
     return;
   }
-  uint32_t wait_time = 3000;
+  uint32_t wait_time = 10000;
   uint32_t current_wait_time = 0;
   bool isInitSegParsed = omaf_reader_mgr_->IsInitSegmentsParsed();
   while (!isInitSegParsed) {
diff --git a/src/OmafDashAccess/OmafMediaStream.cpp b/src/OmafDashAccess/OmafMediaStream.cpp
@@ -883,6 +883,7 @@ int32_t OmafMediaStream::TaskRun(OmafTilesStitch *stitch, std::pair<uint64_t, st
       std::lock_guard<std::mutex> lock(m_catchupPacketsMutex);
       m_catchupMergedPackets[video_id].push_back(catchupMergedPacket);
       OMAF_LOG(LOG_INFO, "[FrameSequences][CatchUp][Stitch]: Push one stitched catchup packet at PTS %lld, video id %d\n", currPTS, video_id);
+      // ANDROID_LOGD("[FrameSequences][CatchUp][Stitch]: Push one stitched catchup packet at PTS %lld, video id %d\n", currPTS, video_id);
     }
 
     // DONE remove successfully processed catchup tile tracks.
diff --git a/src/OmafDashAccess/OmafTilesStitch.cpp b/src/OmafDashAccess/OmafTilesStitch.cpp
@@ -452,7 +452,7 @@ int32_t OmafTilesStitch::UpdateSelectedTiles(std::map<uint32_t, MediaPacket *> &
   return ERROR_NONE;
 }
 
-vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y)
+vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y, QualityRank ranking)
 {
     vector<pair<uint32_t, uint32_t>> arrangementArr;
     if (packetsSize < splitNum || splitNum == 0)
@@ -524,7 +524,7 @@ vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t
         }
 
         OMAF_LOG(LOG_INFO, "one arrangement has the tile division of %u x %u\n", sqrtedSize, dividedSize);
-        if (dividedSize > sqrtedSize ) {
+        if (maxTile_x > maxTile_y || ranking != HIGHEST_QUALITY_RANKING) {
           oneArrangement = std::make_pair(sqrtedSize, dividedSize); //height , width
         } else {
           oneArrangement = std::make_pair(dividedSize, sqrtedSize);
@@ -574,7 +574,7 @@ std::map<QualityRank, std::vector<TilesMergeArrangement *>> OmafTilesStitch::Cal
     uint32_t splitNum = ceil(float(packetsSize) / (maxTile_x * maxTile_y));
 
     // 3. generate row and col arrays according to split num and maxTile_x & maxTile_y
-    vector<pair<uint32_t, uint32_t>> rowAndColArr = GenerateRowAndColArr(packetsSize, splitNum, maxTile_x, maxTile_y);
+    vector<pair<uint32_t, uint32_t>> rowAndColArr = GenerateRowAndColArr(packetsSize, splitNum, maxTile_x, maxTile_y, qualityRanking);
     vector<TilesMergeArrangement*> mergeArrList;
     for (uint32_t i = 0; i < splitNum; i++)
     {
diff --git a/src/OmafDashAccess/OmafTilesStitch.h b/src/OmafDashAccess/OmafTilesStitch.h
@@ -261,7 +261,7 @@ class OmafTilesStitch {
 
   int32_t UpdateInitTilesMergeArr();
 
-  vector<pair<uint32_t, uint32_t>> GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y);
+  vector<pair<uint32_t, uint32_t>> GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y, QualityRank ranking);
 
  private:
   bool m_isInitialized;  //<! whether the stitch class has been initialized
diff --git a/src/doc/Immersive_Video_Delivery_RefPlayer.md b/src/doc/Immersive_Video_Delivery_RefPlayer.md
@@ -55,4 +55,8 @@ The configuration file, config.xml, is used to config parameters for 360 linux p
 | maxVideoDecodeWidth | max video decoded width | decoded width that is supported |
 | maxVideoDecodeHeight | max video decoded height | decoded height that is supported |
 | predict | viewport prediction plugin | 0 is disable and 1 is enable |
+| intimeviewportupdate | support catch up path | 0 is disable and 1 is enable |
+| responseTimesInOneSeg| max catch up streams num in one segment duration | 1 or 2 |
+| maxCatchupWidth | max width of catch up streams | lower than 4k |
+| maxCatchupHeight | max height of catch up streams | lower than 4k |
 | PathOf360SCVPPlugins | path of 360SCVP plugins | needed for planar format rendering |
diff --git a/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MediaLoader.java b/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MediaLoader.java
@@ -102,6 +102,9 @@ public class MediaLoader {
     private SceneRenderer sceneRenderer;
     // The displaySurface is configured after both GL initialization and media loading.
     private Surface[] decodeSurface = new Surface[MAX_SURFACE_NUM + MAX_CATCHUP_SURFACE_NUM];
+    private Pair<Integer, Surface> decoder_surface = null;
+    private Pair<Integer, Surface> decoder_surface_cu = null;
+    private Pair<Integer, Surface> display_surface = null;
     private Surface displaySurface;
 
     // The actual work of loading media happens on a background thread.
@@ -200,80 +203,80 @@ private synchronized void displayWhenReady() {
         }
         // The important methods here are the setSurface & lockCanvas calls. These will have to happen
         // after the GLView is created.
-        if (mediaPlayer != null && sceneRenderer.decode_surface_ready) {
-            // 1. create decode surfaces and set them to native player.
-            for (int i=0;i<MAX_SURFACE_NUM;i++){
-                Pair<Integer, Surface> decoder_surface = sceneRenderer.createDecodeSurface(
-                    mediaPlayer.mConfig.maxVideoDecodeWidth, mediaPlayer.mConfig.maxVideoDecodeHeight, i);
-                Log.i(TAG, "Complete to create one decode surface! surface id is " + i);
-                mediaPlayer.SetDecodeSurface(decoder_surface.second, decoder_surface.first, i);//set surface
-                Log.i(TAG, "ready to set decode surface!");
-                decodeSurface[i] = decoder_surface.second;
-                Log.i(TAG, "decode id in java " + decoder_surface.first);
-            }
-            for (int i=MAX_SURFACE_NUM;i<MAX_CATCHUP_SURFACE_NUM + MAX_SURFACE_NUM;i++){
-                Pair<Integer, Surface> decoder_surface = sceneRenderer.createDecodeSurface(
-                        mediaPlayer.mConfig.maxCatchupWidth, mediaPlayer.mConfig.maxCatchupHeight, i);
-                Log.i(TAG, "Complete to create one catch-up decode surface! surface id is " + i);
-                mediaPlayer.SetDecodeSurface(decoder_surface.second, decoder_surface.first, i);//set surface
-                Log.i(TAG, "ready to set decode surface!");
-                decodeSurface[i] = decoder_surface.second;
-                Log.i(TAG, "decode id in java " + decoder_surface.first);
-            }
-            // 2. create native player and get display width and height and projection format
-            int ret = mediaPlayer.Create("./config.xml");
-            if (ret != 0)
-            {
-                Log.e(TAG, "native media player create failed!");
-                return;
-            }
-            // 3. create mesh according to PF
-            int stereoFormat = Mesh.MEDIA_MONOSCOPIC;
-            Mesh.MeshParams params = new Mesh.MeshParams();
-            int projFormat = mediaPlayer.GetProjectionFormat();
-            Log.i(TAG, "pf is " + projFormat);
-            if (projFormat == PF_CUBEMAP) {
-                mesh = CubeMapMesh.Create(params, context);
-                Log.i(TAG, "Create cubemap mesh!");
-            }
-            else {
-                params.radius = SPHERE_RADIUS_METERS;
-                params.latitudes = DEFAULT_SPHERE_ROWS;
-                params.longitudes = DEFAULT_SPHERE_COLUMNS;
-                params.vFOV = DEFAULT_SPHERE_VERTICAL_DEGREES;
-                params.hFOV = DEFAULT_SPHERE_HORIZONTAL_DEGREES;
-                params.mediaFormat = stereoFormat;
-                mesh = ERPMesh.Create(params);
-                Log.i(TAG, "Create ERP mesh!");
-                if (projFormat != PF_ERP) {
-                    Log.e(TAG, "Projection format is invalid! Default is ERP format!");
+        if (mediaPlayer.mConfig != null && sceneRenderer.decode_surface_ready) {
+            synchronized (this) {
+                // 1. create decode surfaces and set them to native player.
+                for (int i = 0; i < MAX_SURFACE_NUM; i++) {
+                    decoder_surface = sceneRenderer.createDecodeSurface(
+                            mediaPlayer.mConfig.maxVideoDecodeWidth, mediaPlayer.mConfig.maxVideoDecodeHeight, i);
+                    Log.i(TAG, "Complete to create one decode surface! surface id is " + i);
+                    mediaPlayer.SetDecodeSurface(decoder_surface.second, decoder_surface.first, i);//set surface
+                    Log.i(TAG, "ready to set decode surface!");
+                    decodeSurface[i] = decoder_surface.second;
+                    Log.i(TAG, "decode id in java " + decoder_surface.first);
                 }
+                for (int i = MAX_SURFACE_NUM; i < MAX_CATCHUP_SURFACE_NUM + MAX_SURFACE_NUM; i++) {
+                    decoder_surface_cu = sceneRenderer.createDecodeSurface(
+                            mediaPlayer.mConfig.maxCatchupWidth, mediaPlayer.mConfig.maxCatchupHeight, i);
+                    Log.i(TAG, "Complete to create one catch-up decode surface! surface id is " + i);
+                    mediaPlayer.SetDecodeSurface(decoder_surface_cu.second, decoder_surface_cu.first, i);//set surface
+                    Log.i(TAG, "ready to set decode surface!");
+                    decodeSurface[i] = decoder_surface_cu.second;
+                    Log.i(TAG, "decode id in java " + decoder_surface_cu.first);
+                }
+                // 2. create native player and get display width and height and projection format
+                int ret = mediaPlayer.Create("./config.xml");
+                if (ret != 0) {
+                    Log.e(TAG, "native media player create failed!");
+                    return;
+                }
+                // 3. create mesh according to PF
+                int stereoFormat = Mesh.MEDIA_MONOSCOPIC;
+                Mesh.MeshParams params = new Mesh.MeshParams();
+                int projFormat = mediaPlayer.GetProjectionFormat();
+                Log.i(TAG, "pf is " + projFormat);
+                if (projFormat == PF_CUBEMAP) {
+                    mesh = CubeMapMesh.Create(params, context);
+                    Log.i(TAG, "Create cubemap mesh!");
+                } else {
+                    params.radius = SPHERE_RADIUS_METERS;
+                    params.latitudes = DEFAULT_SPHERE_ROWS;
+                    params.longitudes = DEFAULT_SPHERE_COLUMNS;
+                    params.vFOV = DEFAULT_SPHERE_VERTICAL_DEGREES;
+                    params.hFOV = DEFAULT_SPHERE_HORIZONTAL_DEGREES;
+                    params.mediaFormat = stereoFormat;
+                    mesh = ERPMesh.Create(params);
+                    Log.i(TAG, "Create ERP mesh!");
+                    if (projFormat != PF_ERP) {
+                        Log.e(TAG, "Projection format is invalid! Default is ERP format!");
+                    }
+                }
+                // 4. get width / height and create display surface and set it to native player
+                int displayWidth = mediaPlayer.GetWidth();
+                int displayHeight = mediaPlayer.GetHeight();
+                if (projFormat == PF_ERP) {
+                    sceneRenderer.displayTexId = Utils.glCreateTextureFor2D(mediaPlayer.GetWidth(), mediaPlayer.GetHeight());
+                    Log.i(TAG, "ERP Display texture id is " + sceneRenderer.displayTexId);
+                } else if (projFormat == PF_CUBEMAP) {
+                    sceneRenderer.displayTexId = Utils.glCreateTextureForCube(mediaPlayer.GetWidth(), mediaPlayer.GetHeight());
+                    Log.i(TAG, "Cubemap Display texture id is " + sceneRenderer.displayTexId);
+                } else {
+                    sceneRenderer.displayTexId = 0;
+                    Log.e(TAG, "Projection format is invalid! displayer texture id is set to zero!");
+                }
+                sceneRenderer.displayTexture = new SurfaceTexture(sceneRenderer.displayTexId);
+                checkGlError();
+                Log.i(TAG, "display width is " + displayWidth + " display height is " + displayHeight);
+                display_surface = sceneRenderer.createDisplaySurface(
+                        displayWidth, displayHeight, mesh);
+                Log.i(TAG, "ready to create display surface");
+                mediaPlayer.SetDisplaySurface(display_surface.first);
+
+                displaySurface = display_surface.second;
+                // 4. start native player thread
+                Log.i(TAG, "start to start!");
+                mediaPlayer.Start();
             }
-            // 4. get width / height and create display surface and set it to native player
-            int displayWidth = mediaPlayer.GetWidth();
-            int displayHeight = mediaPlayer.GetHeight();
-            if (projFormat == PF_ERP) {
-                sceneRenderer.displayTexId = Utils.glCreateTextureFor2D(mediaPlayer.GetWidth(), mediaPlayer.GetHeight());
-                Log.i(TAG, "ERP Display texture id is " + sceneRenderer.displayTexId);
-            }else if (projFormat == PF_CUBEMAP) {
-                sceneRenderer.displayTexId = Utils.glCreateTextureForCube(mediaPlayer.GetWidth(), mediaPlayer.GetHeight());
-                Log.i(TAG, "Cubemap Display texture id is " + sceneRenderer.displayTexId);
-            }else {
-                sceneRenderer.displayTexId = 0;
-                Log.e(TAG, "Projection format is invalid! displayer texture id is set to zero!");
-            }
-            sceneRenderer.displayTexture = new SurfaceTexture(sceneRenderer.displayTexId);
-            checkGlError();
-            Log.i(TAG, "display width is " + displayWidth + " display height is " + displayHeight);
-            Pair<Integer, Surface> display_surface = sceneRenderer.createDisplaySurface(
-                    displayWidth, displayHeight, mesh);
-            Log.i(TAG, "ready to create display surface");
-            mediaPlayer.SetDisplaySurface(display_surface.first);
-
-            displaySurface = display_surface.second;
-            // 4. start native player thread
-            Log.i(TAG, "start to start!");
-            mediaPlayer.Start();
         }else
         {
             Log.e(TAG, "media player is invalid!");
diff --git a/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MediaPlayer/NativeMediaPlayer.java b/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MediaPlayer/NativeMediaPlayer.java
@@ -44,9 +44,15 @@
 
 public class NativeMediaPlayer {
     private final String TAG = "NATIVE_MEDIA_PLAYER";
+
+    public final int READY = 0;
+    public final int PLAY = 1;
+    public final int PAUSED = 2;
+    public final int STOPPED = 3;
+
     private long mHandler;
     public RenderConfig mConfig;
-    private int status = 0;
+    private int status = READY;
     private Context context;
 
     static {
@@ -115,15 +121,6 @@ public HeadPose() {
         }
     }
 
-    public int GetCurrentStatus()
-    {
-        return status;
-    }
-
-    public void SetCurrentStatus(int st)
-    {
-        status = st;
-    }
     /**
      * Original signature : <code>Handler Init()</code><br>
      * <i>native declaration : line 82</i>
diff --git a/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MonoscopicView.java b/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/MonoscopicView.java
@@ -307,8 +307,10 @@ public void onSurfaceChanged(GL10 gl, int width, int height) {
             screenWidth = width;
             screenHeight = height;
             GLES20.glViewport(0, 0, width, height);
-            Matrix.perspectiveM(
-                    projectionMatrix, 0, mediaLoader.mediaPlayer.mConfig.viewportVFOV, (float) width / height, Z_NEAR, Z_FAR);
+            if (mediaLoader.mediaPlayer != null && mediaLoader.mediaPlayer.mConfig != null) {
+                Matrix.perspectiveM(
+                        projectionMatrix, 0, mediaLoader.mediaPlayer.mConfig.viewportVFOV, (float) width / height, Z_NEAR, Z_FAR);
+            }
         }
 
         @Override
@@ -322,7 +324,9 @@ public void onDrawFrame(GL10 gl) {
             }
 
             Matrix.multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
-            scene.glDrawFrame(viewProjectionMatrix, Type.MONOCULAR, screenWidth, screenHeight);
+            if (mediaLoader.mediaPlayer != null && mediaLoader.mediaPlayer.GetStatus() == mediaLoader.mediaPlayer.PLAY) {
+                scene.glDrawFrame(viewProjectionMatrix, Type.MONOCULAR, screenWidth, screenHeight);
+            }
         }
 
         /** Adjusts the GL camera's rotation based on device rotation. Runs on the sensor thread. */
diff --git a/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/Rendering/SceneRenderer.java b/src/player/app/android/app/src/main/java/com/vcd/immersive/omafplayer/Rendering/SceneRenderer.java
@@ -277,10 +277,15 @@ private synchronized boolean glConfigureScene() {
      */
     public void glDrawFrame(float[] viewProjectionMatrix, int eyeType, int width, int height) {
         Log.i(TAG, "begin to draw frame !");
-        if (mediaPlayer != null) {
-            mediaPlayer.SetCurrentStatus(1);
+        if (mediaPlayer == null) {
+            return;
+        }
+        if (mediaPlayer.GetStatus() == mediaPlayer.STOPPED) {
+            Log.e(TAG, "Media player set to stopped!");
+            return;
         }
-        else{
+        if (mediaPlayer.GetStatus() != mediaPlayer.PLAY) {
+            Log.i(TAG, "Media player is not in PLAY mode!");
             return;
         }
         if (!glConfigureScene()) {
@@ -313,7 +318,7 @@ public void glDrawFrame(float[] viewProjectionMatrix, int eyeType, int width, in
             }
             Log.i(TAG, "update tex image at pts " + cnt++);
         }
-        if (drawTimes++ % 2 == 0)
+        if (drawTimes++ % 2 == 0 && cnt > renderCount)
         {
             Log.i(TAG, "begin to update display tex!");
             int ret = 0;
@@ -433,22 +438,26 @@ public synchronized void setVideoFrameListener(OnFrameAvailableListener videoFra
 
     public void SetCurrentPosition(int pts)
     {
-        if (mediaPlayer != null && mediaPlayer.GetCurrentStatus() != 0 && pose_history.size() != 0) {
-            NativeMediaPlayer.HeadPose pose = pose_history.getFirst();
-            pose.pts = pts;
-            mediaPlayer.SetCurrentPosition(pose);
-            Log.i(TAG, "Set current position to native player and pts is " + pose.pts);
+        synchronized (this) {
+            if (mediaPlayer != null && mediaPlayer.GetStatus() != 0 && pose_history.size() != 0) {
+                NativeMediaPlayer.HeadPose pose = pose_history.getFirst();
+                pose.pts = pts;
+                mediaPlayer.SetCurrentPosition(pose);
+                Log.i(TAG, "Set current position to native player and pts is " + pose.pts);
+            }
         }
     }
 
     public void AddCurrentPose(NativeMediaPlayer.HeadPose pose)
     {
-        if (pose != null) {
-            pose_history.addFirst(pose);
-        }
-        int max_pose_number = 100;
-        if (pose_history.size() > max_pose_number) {
-            pose_history.removeLast();
+        synchronized (this) {
+            if (pose != null) {
+                pose_history.addFirst(pose);
+            }
+            int max_pose_number = 100;
+            if (pose_history.size() > max_pose_number) {
+                pose_history.removeLast();
+            }
         }
     }
 }
diff --git a/src/player/player_lib/Api/MediaPlayer_Android.cpp b/src/player/player_lib/Api/MediaPlayer_Android.cpp
@@ -137,5 +137,12 @@ RenderStatus MediaPlayer_Android::Close()
     return RENDER_STATUS_OK;
 }
 
+int MediaPlayer_Android::UpdateDisplayTex(int render_count)
+{
+    m_renderManager->UpdateFrames(render_count);
+    int ret = m_renderManager->UpdateDisplayTex();
+    return ret;
+}
+
 VCD_NS_END
 #endif
diff --git a/src/player/player_lib/Api/MediaPlayer_Android.h b/src/player/player_lib/Api/MediaPlayer_Android.h
@@ -102,7 +102,13 @@ class MediaPlayer_Android
     //!
     RenderStatus Close();
 
-    uint32_t GetStatus() { return m_status; };
+    uint32_t GetStatus() {
+        if (m_mediaSource->GetStatus() == STATUS_STOPPED) {
+            return STOPPED;
+        }
+        else
+            return m_status;
+    };
 
     bool IsPlaying() { return m_status == PLAY; };
 
@@ -119,11 +125,7 @@ class MediaPlayer_Android
 
     int32_t GetProjectionFormat() { return m_mediaSource->GetMediaInfo().mVideoInfo[0].mProjFormat; };
 
-    int UpdateDisplayTex(int render_count)
-    {
-        m_renderManager->UpdateFrames(render_count);
-        return m_renderManager->UpdateDisplayTex();
-    };
+    int UpdateDisplayTex(int render_count);
 
     void SetDecodeSurface(jobject surface, int tex_id, int video_id)
     {
diff --git a/src/player/player_lib/Decoder/DecoderManager.cpp b/src/player/player_lib/Decoder/DecoderManager.cpp
diff --git a/src/player/player_lib/Decoder/VideoDecoder_hw.cpp b/src/player/player_lib/Decoder/VideoDecoder_hw.cpp
diff --git a/src/player/player_lib/MediaSource/DashMediaSource.cpp b/src/player/player_lib/MediaSource/DashMediaSource.cpp
diff --git a/src/player/player_lib/MediaSource/DashMediaSource.h b/src/player/player_lib/MediaSource/DashMediaSource.h
diff --git a/src/player/player_lib/MediaSource/MediaSource.h b/src/player/player_lib/MediaSource/MediaSource.h

Original file line number	Diff line number	Diff line change
`@@ -883,6 +883,7 @@ int32_t OmafMediaStream::TaskRun(OmafTilesStitch *stitch, std::pair<uint64_t, st`
`883`	`883`	`std::lock_guard<std::mutex> lock(m_catchupPacketsMutex);`
`884`	`884`	`m_catchupMergedPackets[video_id].push_back(catchupMergedPacket);`
`885`	`885`	`OMAF_LOG(LOG_INFO, "[FrameSequences][CatchUp][Stitch]: Push one stitched catchup packet at PTS %lld, video id %d\n", currPTS, video_id);`
	`886`	`+ // ANDROID_LOGD("[FrameSequences][CatchUp][Stitch]: Push one stitched catchup packet at PTS %lld, video id %d\n", currPTS, video_id);`
`886`	`887`	`}`
`887`	`888`
`888`	`889`	`// DONE remove successfully processed catchup tile tracks.`
Original file line number	Diff line number	Diff line change
`@@ -452,7 +452,7 @@ int32_t OmafTilesStitch::UpdateSelectedTiles(std::map<uint32_t, MediaPacket *> &`
`452`	`452`	`return ERROR_NONE;`
`453`	`453`	`}`
`454`	`454`
`455`		`-vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y)`
	`455`	`+vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t packetsSize, uint32_t splitNum, uint32_t maxTile_x, uint32_t maxTile_y, QualityRank ranking)`
`456`	`456`	`{`
`457`	`457`	`vector<pair<uint32_t, uint32_t>> arrangementArr;`
`458`	`458`	`if (packetsSize < splitNum \|\| splitNum == 0)`
`@@ -524,7 +524,7 @@ vector<pair<uint32_t, uint32_t>> OmafTilesStitch::GenerateRowAndColArr(uint32_t`
`524`	`524`	`}`
`525`	`525`
`526`	`526`	`OMAF_LOG(LOG_INFO, "one arrangement has the tile division of %u x %u\n", sqrtedSize, dividedSize);`
`527`		`- if (dividedSize > sqrtedSize ) {`
	`527`	`+ if (maxTile_x > maxTile_y \|\| ranking != HIGHEST_QUALITY_RANKING) {`
`528`	`528`	`oneArrangement = std::make_pair(sqrtedSize, dividedSize); //height , width`
`529`	`529`	`} else {`
`530`	`530`	`oneArrangement = std::make_pair(dividedSize, sqrtedSize);`
`@@ -574,7 +574,7 @@ std::map<QualityRank, std::vector<TilesMergeArrangement *>> OmafTilesStitch::Cal`
`574`	`574`	`uint32_t splitNum = ceil(float(packetsSize) / (maxTile_x * maxTile_y));`
`575`	`575`
`576`	`576`	`// 3. generate row and col arrays according to split num and maxTile_x & maxTile_y`
`577`		`- vector<pair<uint32_t, uint32_t>> rowAndColArr = GenerateRowAndColArr(packetsSize, splitNum, maxTile_x, maxTile_y);`
	`577`	`+ vector<pair<uint32_t, uint32_t>> rowAndColArr = GenerateRowAndColArr(packetsSize, splitNum, maxTile_x, maxTile_y, qualityRanking);`
`578`	`578`	`vector<TilesMergeArrangement*> mergeArrList;`
`579`	`579`	`for (uint32_t i = 0; i < splitNum; i++)`
`580`	`580`	`{`
Original file line number	Diff line number	Diff line change
`@@ -277,10 +277,15 @@ private synchronized boolean glConfigureScene() {`
`277`	`277`	`*/`
`278`	`278`	`public void glDrawFrame(float[] viewProjectionMatrix, int eyeType, int width, int height) {`
`279`	`279`	`Log.i(TAG, "begin to draw frame !");`
`280`		`- if (mediaPlayer != null) {`
`281`		`- mediaPlayer.SetCurrentStatus(1);`
	`280`	`+ if (mediaPlayer == null) {`
	`281`	`+ return;`
	`282`	`+ }`
	`283`	`+ if (mediaPlayer.GetStatus() == mediaPlayer.STOPPED) {`
	`284`	`+ Log.e(TAG, "Media player set to stopped!");`
	`285`	`+ return;`
`282`	`286`	`}`
`283`		`- else{`
	`287`	`+ if (mediaPlayer.GetStatus() != mediaPlayer.PLAY) {`
	`288`	`+ Log.i(TAG, "Media player is not in PLAY mode!");`
`284`	`289`	`return;`
`285`	`290`	`}`
`286`	`291`	`if (!glConfigureScene()) {`
`@@ -313,7 +318,7 @@ public void glDrawFrame(float[] viewProjectionMatrix, int eyeType, int width, in`
`313`	`318`	`}`
`314`	`319`	`Log.i(TAG, "update tex image at pts " + cnt++);`
`315`	`320`	`}`
`316`		`- if (drawTimes++ % 2 == 0)`
	`321`	`+ if (drawTimes++ % 2 == 0 && cnt > renderCount)`
`317`	`322`	`{`
`318`	`323`	`Log.i(TAG, "begin to update display tex!");`
`319`	`324`	`int ret = 0;`
`@@ -433,22 +438,26 @@ public synchronized void setVideoFrameListener(OnFrameAvailableListener videoFra`
`433`	`438`
`434`	`439`	`public void SetCurrentPosition(int pts)`
`435`	`440`	`{`
`436`		`- if (mediaPlayer != null && mediaPlayer.GetCurrentStatus() != 0 && pose_history.size() != 0) {`
`437`		`- NativeMediaPlayer.HeadPose pose = pose_history.getFirst();`
`438`		`- pose.pts = pts;`
`439`		`- mediaPlayer.SetCurrentPosition(pose);`
`440`		`- Log.i(TAG, "Set current position to native player and pts is " + pose.pts);`
	`441`	`+ synchronized (this) {`
	`442`	`+ if (mediaPlayer != null && mediaPlayer.GetStatus() != 0 && pose_history.size() != 0) {`
	`443`	`+ NativeMediaPlayer.HeadPose pose = pose_history.getFirst();`
	`444`	`+ pose.pts = pts;`
	`445`	`+ mediaPlayer.SetCurrentPosition(pose);`
	`446`	`+ Log.i(TAG, "Set current position to native player and pts is " + pose.pts);`
	`447`	`+ }`
`441`	`448`	`}`
`442`	`449`	`}`
`443`	`450`
`444`	`451`	`public void AddCurrentPose(NativeMediaPlayer.HeadPose pose)`
`445`	`452`	`{`
`446`		`- if (pose != null) {`
`447`		`- pose_history.addFirst(pose);`
`448`		`- }`
`449`		`- int max_pose_number = 100;`
`450`		`- if (pose_history.size() > max_pose_number) {`
`451`		`- pose_history.removeLast();`
	`453`	`+ synchronized (this) {`
	`454`	`+ if (pose != null) {`
	`455`	`+ pose_history.addFirst(pose);`
	`456`	`+ }`
	`457`	`+ int max_pose_number = 100;`
	`458`	`+ if (pose_history.size() > max_pose_number) {`
	`459`	`+ pose_history.removeLast();`
	`460`	`+ }`
`452`	`461`	`}`
`453`	`462`	`}`
`454`	`463`	`}`