Video's orientation get changed while saved in sdcard in android
<p>I have a problem that I am developing an App in which video recording feature is available, when recording is completed its thumbnail and video gets saved in SDCARD, recording is done in portrait mode, but when we want to play it from SDCARD then it is playing in Landscape mode. I don't know why? Please suggest me any solution regarding that.</p>

<p><strong>Code of Video Recording:</strong></p>

<pre><code>package com.irant.cameraApplication;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.hardware.Camera;
import android.media.MediaRecorder;
import android.media.MediaRecorder.VideoEncoder;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.widget.Button;
import android.widget.Chronometer;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.Toast;

import com.irant.a1techno.AfterLoginHome;
import com.irant.a1techno.CameraPlay;
import com.irant.a1techno.R;

/***
 *  TODO: 1. sound on/off
 *  2. resolution change
 * @author roman10
 *
 */

public class VideoCapture_New extends Activity implements SurfaceHolder.Callback {
    private SurfaceView prSurfaceView;
    private ImageButton prStartBtn, prFrontBackCamera;
    private Button prSettingsBtn;
    public String TAG = "IRANT";
    private boolean prRecordInProcess;
    private SurfaceHolder prSurfaceHolder;
    private Camera prCamera;
    private final String cVideoFilePath = "/sdcard/";
    Chronometer cm_VideoCapture;
    private Context prContext;
    public static boolean frontCamera= false;
    int mRotation;
    LinearLayout linearLayoutRedbtn;
    ImageButton btn;
    Animation animation;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        this.requestWindowFeature(Window.FEATURE_NO_TITLE);
        prContext = this.getApplicationContext();
        setContentView(R.layout.videocapture_new);
        Utils.createDirIfNotExist(cVideoFilePath);

        animation = new AlphaAnimation(1, 0); // Change alpha from fully visible to invisible
        animation.setDuration(500); // duration - half a second
        animation.setInterpolator(new LinearInterpolator()); // do not alter animation rate
        animation.setRepeatCount(Animation.INFINITE); // Repeat animation infinitely
        animation.setRepeatMode(Animation.REVERSE); // Reverse animation at the end so the button will fade back in
        btn = (ImageButton) findViewById(R.id.main_btn1);

        linearLayoutRedbtn=(LinearLayout) findViewById(R.id.linear_btn1);

        linearLayoutRedbtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                if (prRecordInProcess == false) {
                    cm_VideoCapture.clearComposingText();
                    startRecording();
                    cm_VideoCapture.start();
                    linearLayoutRedbtn.startAnimation(animation);
                } else {
                    stopRecording();
                    linearLayoutRedbtn.clearAnimation();
                    cm_VideoCapture.stop();
                    cm_VideoCapture.clearComposingText();
                    Intent intent = new Intent(VideoCapture_New.this, CameraPlay.class);
                    startActivity(intent);
                }

            }
        });
        cm_VideoCapture = (Chronometer)findViewById(R.id.cm_VideoCapture);
        prSurfaceView = (SurfaceView) findViewById(R.id.surface_camera);
        prStartBtn = (ImageButton) findViewById(R.id.main_btn1);
        prFrontBackCamera = (ImageButton)findViewById(R.id.btn_frontBackCamera);
        cm_VideoCapture.clearComposingText();
       // prSettingsBtn = (Button) findViewById(R.id.main_btn2);
        prRecordInProcess = false;
        prStartBtn.setOnClickListener(new View.OnClickListener() {
            //@Override
            public void onClick(View v) {
                if (prRecordInProcess == false) {
                    cm_VideoCapture.clearComposingText();
                    startRecording();
                    cm_VideoCapture.start();
                } else {
                    stopRecording();
                    btn.clearAnimation();
                    cm_VideoCapture.stop();
                    cm_VideoCapture.clearComposingText();
                    Intent intent = new Intent(VideoCapture_New.this, CameraPlay.class);
                    startActivity(intent);
                }
            }
        });

        prFrontBackCamera.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                //prCamera = openFrontFacingCameraGingerbread();
                try{
            if(prCamera.getNumberOfCameras()==2)
            {
                if(frontCamera)
                {
                    frontCamera = false;
                    prCamera.stopPreview();
                    prMediaRecorder.release();
                    prMediaRecorder = null;
                    prCamera.release();
                    prCamera = null;
                }
                else
                {

                    frontCamera = true;
                    prCamera.stopPreview();
                    prMediaRecorder.release();
                    prMediaRecorder = null;
                    prCamera.release();
                    prCamera = null;
                }
                Intent intent = new Intent(VideoCapture_New.this, VideoCapture_New.class);
                startActivity(intent);
            }
            else
            {
                Toast.makeText(VideoCapture_New.this, "Your device doesn't contain Front Camera.", Toast.LENGTH_SHORT).show();
            }
                }catch(Exception e)
                {
                    e.printStackTrace();
                    Toast.makeText(VideoCapture_New.this, "Your device is not compatible for Front Camera.", Toast.LENGTH_SHORT).show();

                }

            }
        });

        prSurfaceHolder = prSurfaceView.getHolder();
        prSurfaceHolder.addCallback(this);
        prSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        prMediaRecorder = new MediaRecorder();
    }

    private Camera openFrontFacingCameraGingerbread() 
    {
         Camera camera = null;

            // Look for front-facing camera, using the Gingerbread API.
            // Java reflection is used for backwards compatibility with pre-Gingerbread APIs.
            try {
                Class&lt;?&gt; cameraClass = Class.forName("android.hardware.Camera");
                Object cameraInfo = null;
                Field field = null;
                int cameraCount = 0;
                Method getNumberOfCamerasMethod = cameraClass.getMethod( "getNumberOfCameras" );
                if ( getNumberOfCamerasMethod != null ) {
                    cameraCount = (Integer) getNumberOfCamerasMethod.invoke( null, (Object[]) null );
                }
                Class&lt;?&gt; cameraInfoClass = Class.forName("android.hardware.Camera$CameraInfo");
                if ( cameraInfoClass != null ) {
                    cameraInfo = cameraInfoClass.newInstance();
                }
                if ( cameraInfo != null ) {
                    field = cameraInfo.getClass().getField( "facing" );
                }
                Method getCameraInfoMethod = cameraClass.getMethod( "getCameraInfo", Integer.TYPE, cameraInfoClass );
                if ( getCameraInfoMethod != null &amp;&amp; cameraInfoClass != null &amp;&amp; field != null ) {
                    for ( int camIdx = 0; camIdx &lt; cameraCount; camIdx++ ) {
                        getCameraInfoMethod.invoke( null, camIdx, cameraInfo );
                        int facing = field.getInt( cameraInfo );
                        if ( facing == 1 ) { // Camera.CameraInfo.CAMERA_FACING_FRONT 
                            try {
                                Method cameraOpenMethod = cameraClass.getMethod( "open", Integer.TYPE );
                                if ( cameraOpenMethod != null ) {
                                    camera = (Camera) cameraOpenMethod.invoke( null, camIdx );
                                }
                            } catch (RuntimeException e) {
                                Log.e(TAG, "Camera failed to open: " + e.getLocalizedMessage());
                                camera= prCamera;
                            }
                        }
                    }
                }
            }
            // Ignore the bevy of checked exceptions the Java Reflection API throws - if it fails, who cares.
            catch ( ClassNotFoundException e        ) {Log.e(TAG, "ClassNotFoundException" + e.getLocalizedMessage());}
            catch ( NoSuchMethodException e         ) {Log.e(TAG, "NoSuchMethodException" + e.getLocalizedMessage());}
            catch ( NoSuchFieldException e          ) {Log.e(TAG, "NoSuchFieldException" + e.getLocalizedMessage());}
            catch ( IllegalAccessException e        ) {Log.e(TAG, "IllegalAccessException" + e.getLocalizedMessage());}
            catch ( InvocationTargetException e     ) {Log.e(TAG, "InvocationTargetException" + e.getLocalizedMessage());}
            catch ( InstantiationException e        ) {Log.e(TAG, "InstantiationException" + e.getLocalizedMessage());}
            catch ( SecurityException e             ) {Log.e(TAG, "SecurityException" + e.getLocalizedMessage());}
            catch ( NullPointerException e             ) {Log.e(TAG, "NullPointerException" + e.getLocalizedMessage());}

            if ( camera == null ) {
                // Try using the pre-Gingerbread APIs to open the camera.
                try {
                    camera = Camera.open();
                } catch (RuntimeException e) {
                    Log.e(TAG, "Camera failed to open: " + e.getLocalizedMessage());
                }
            }

            return camera;
    }

    @Override
    public void surfaceChanged(SurfaceHolder _holder, int _format, int _width, int _height) {
        Camera.Parameters lParam = prCamera.getParameters();

        prCamera.setParameters(lParam);
        try {
            prCamera.setPreviewDisplay(_holder);
            prCamera.startPreview();
            //prPreviewRunning = true;
        } catch (IOException _le) {
            _le.printStackTrace();
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder arg0) {
        if(frontCamera == false)
        {
        prCamera = Camera.open();
        if (prCamera == null) {
            Toast.makeText(this.getApplicationContext(), "Camera is not available!", Toast.LENGTH_SHORT).show();
            finish();
        }
        }
        else if(frontCamera == true)
        {
            try{
         int cameraCount = 0;
            Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
            cameraCount = Camera.getNumberOfCameras();
            for ( int camIdx = 0; camIdx &lt; cameraCount; camIdx++ ) {
                Camera.getCameraInfo( camIdx, cameraInfo );
                if ( cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT  ) {
                    try {
                        prCamera = Camera.open( camIdx );
                    } catch (RuntimeException e) {
                        Log.i("Camera failed to open: ",e.getLocalizedMessage());
                    }
                }
            }
            }catch(Exception e)
            {
                Toast.makeText(VideoCapture_New.this, "Your Device doesn't compatible for Fron Camera.", Toast.LENGTH_SHORT).show();
            }
        }
         try {
            Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();  
             Camera.getCameraInfo(0, info);        
             int rotation = getWindowManager().getDefaultDisplay().getRotation();  
             int degrees = 0;        
             switch (rotation) {          
             case Surface.ROTATION_0: degrees = 0; break;    
             case Surface.ROTATION_90: degrees = 90; break;    
             case Surface.ROTATION_180: degrees = 180; break;  
             case Surface.ROTATION_270: degrees = 270; break;   
             }     
             int result;    
             if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {   
                 result = (info.orientation + degrees) % 360;     
                 result = (360 - result) % 360;  // compensate the mirror    
                 } else {  // back-facing    
                     result = (info.orientation - degrees + 360) % 360;       
                     }         
             this.mRotation = result;       
             prCamera.setDisplayOrientation(result);
        } catch (NoClassDefFoundError e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            Toast.makeText(VideoCapture_New.this, "There is no Front Camera Facility.", Toast.LENGTH_SHORT).show();
        } 
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder arg0) {
        try {
            if (prRecordInProcess) {
                stopRecording();
            } else {
                prCamera.stopPreview();
            }
            prMediaRecorder.release();
            prMediaRecorder = null;
            prCamera.release();
            prCamera = null;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    private MediaRecorder prMediaRecorder;
    private final int cMaxRecordDurationInMs = 30000;
    private final long cMaxFileSizeInBytes = 5000000;
    private final int cFrameRate = 20;
    private File prRecordedFile;

    private void updateEncodingOptions() {
        if (prRecordInProcess) {
            stopRecording();
            startRecording();
            Toast.makeText(prContext, "Recording restarted with new options!", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(prContext, "Recording options updated!", Toast.LENGTH_SHORT).show();
        }
    }

    private boolean startRecording() {
        prCamera.stopPreview();
        try {
            prCamera.unlock();
            prMediaRecorder.setCamera(prCamera);

            prMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
            prMediaRecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
            String lVideoFileFullPath=".mp4";




            prMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
            String lDisplayMsg = "Current container format: ";
            prMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
            prMediaRecorder.setVideoEncoder(VideoEncoder.H263);


            lDisplayMsg += "Current encoding format: ";

            lVideoFileFullPath = cVideoFilePath + "myvideo" + lVideoFileFullPath;
            //prMediaRecorder.setOrientationHint(360);
            prMediaRecorder.setVideoSize(176, 144); 
            prMediaRecorder.setVideoFrameRate(12);
            prRecordedFile = new File(lVideoFileFullPath);
            prMediaRecorder.setOutputFile(prRecordedFile.getPath());


            prMediaRecorder.setVideoFrameRate(cFrameRate);
            prMediaRecorder.setPreviewDisplay(prSurfaceHolder.getSurface());
            prMediaRecorder.setMaxDuration(cMaxRecordDurationInMs);
            prMediaRecorder.setMaxFileSize(cMaxFileSizeInBytes);
            //prepare for capturing
            //state: DataSourceConfigured =&gt; prepared
            prMediaRecorder.prepare();
            //start recording
            //state: prepared =&gt; recording
            prMediaRecorder.start();
            //prStartBtn.setText("Stop");
            prRecordInProcess = true;
            return true;
        } catch (IOException _le) {
            _le.printStackTrace();
            return false;
        }
    }

    private void stopRecording() {
        prMediaRecorder.stop();
        prMediaRecorder.reset();
        try {
            prCamera.reconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //prStartBtn.setText("Start");
        prRecordInProcess = false;
        prCamera.startPreview();
    }

    private static final int REQUEST_DECODING_OPTIONS = 0;
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
        super.onActivityResult(requestCode, resultCode, intent);
        switch (requestCode) {
        case REQUEST_DECODING_OPTIONS:
            if (resultCode == RESULT_OK) {
                updateEncodingOptions();
            }
            break;
        }
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {

            /*
             * if(collapse==true||collapse_cat==true||collapse_FuelEconomy==true||
             * collapse_LatestNews
             * ==true||collapse_price==true||collapse_RecentlyViwed==true){
             * Intent restartResearchActivity = new
             * Intent(ResearchListNew.this,ResearchListNew.class);
             * restartResearchActivity.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
             * startActivity(restartResearchActivity);
             * 
             * } else { finish(); }
             */
            Intent intent = new Intent(VideoCapture_New.this, AfterLoginHome.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            startActivity(intent);
            return true;
        } else {

            return super.onKeyDown(keyCode, event);
        }

    }
}
</code></pre>
