Enregistrer le flux sous Android

Bonjour,
je suis entrain de faire mon projet de fin d'étude (vidéo surveillance mobile sous android)
j'ai réussi à faire la visualisation la caméra ip.
y a -t- qlq qui peut m'aider pour enregistrer le flux dans une fichier .avi
merci d'avance
voila mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
package com.surveillance.form;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import com.surveillance.form.MjpegView;
import com.surveillance.form.Mjpegsample;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import javax.media.CaptureDeviceInfo; 
import javax.media.MediaLocator;
 
public class SurveillanceActivity extends Activity implements OnClickListener {
    private EditText IP1;
	public MjpegView mv;
	boolean affiche = false;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Button BVTR= (Button) findViewById(R.id.VTR);
        IP1=(EditText) findViewById (R.id.ADR); 
        BVTR.setOnClickListener( this );
    }
 
    public void ConnectCam(String IP) throws IOException {
 
 
		String URL = "http://"+IP+"/axis-cgi/mjpg/video.cgi";
 
	//   Object ou on va afficher le flux de la caméra 
 
		mv = new MjpegView(getBaseContext());
 
   //Permét d'afficher l'objet mjpegview//
 
		setContentView(mv);
 
		mv.setSource(Mjpegsample.read(URL.trim())); //LA SOURCE DE MJPEG
 
 
		mv.setDisplayMode(MjpegView.SIZE_BEST_FIT);
		//mv.showFps(true);
		mv.showFps(false);
		affiche = true;
 
	}
 
	//@Override
	public void onClick(View arg0) {
 
 
		try {
			ConnectCam( IP1.getText().toString());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
 
	}
}

Le choix du format de la vidéo (avi) ne me semble pas le meilleur. Trop lourd.

Bonjour
merci pour votre réponse.
l'essentiel que je veux une enregistrer védio, est-ce que tu peux m'aider s'il te plait pour une autre extension
et merci .

si possible sous "3gp" et merci

Bonjour a tous,
J'ai le même problème, je veux faire l’enregistrement de flux de caméra ip sous la format 3gp
Est ce vous pouvez m'aidez?

visualisation de camera ip

j'ai essayé avec ce code mais le flux n'apparut pas dans l'emulateur
Voici mon activité principale

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package com.surveillance.form;
 
import com.surveillance.form.MjpegView;
import com.surveillance.form.Mjpegsample;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
 
public class SurveillanceActivity extends Activity implements OnClickListener {
    /** Called when the activity is first created. */
 
	private Button BVTR;
	private EditText IP1;
	public MjpegView mv;
	boolean affiche = false;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Button BVTR= (Button) findViewById(R.id.VTR);
        IP1=(EditText) findViewById (R.id.ADR); 
        BVTR.setOnClickListener( this );
    }
 
    public void ConnectCam(String IP) {
 
 
		String URL = "http://192.168.1.87/view/view.shtml";
 
		Toast monToast1,monToast2;
 
 
		monToast1 = Toast.makeText(this.getApplicationContext(), "url " + URL,Toast.LENGTH_LONG);
 
		monToast1.show();
 
	//   Object ou on va afficher le flux de la caméra 
 
		mv = new MjpegView(getBaseContext());
 
   //Permét d'afficher l'objet mjpegview//
 
		setContentView(mv);
 
		mv.setSource(Mjpegsample.read(URL.trim())); //LA SOURCE DE MJPEG
 
		//monToast2 = Toast.makeText(this.getApplicationContext(), "OK OK  ",Toast.LENGTH_LONG);
		//monToast2.show();
 
		mv.setDisplayMode(MjpegView.SIZE_BEST_FIT);
		mv.showFps(true);
		mv.showFps(false);
		affiche = true;
 
	}
 
	@Override
	public void onClick(View arg0) {
 
		Toast monToast3;
		ConnectCam( IP1.getText().toString());
		monToast3 = Toast.makeText(this.getApplicationContext(), "Sava  ",Toast.LENGTH_LONG);
		monToast3.show();
 
 
 
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
package com.surveillance.form;
 
 
import java.io.BufferedInputStream;
 
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.Properties;
 
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
 
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
public class Mjpegsample extends DataInputStream {
	private final byte[] SOI_MARKER = { (byte) 0xFF, (byte) 0xD8 };
    private final byte[] EOF_MARKER = { (byte) 0xFF, (byte) 0xD9 };
    private final String CONTENT_LENGTH = "Content-Length";
    private final static int HEADER_MAX_LENGTH = 100;
    private final static int FRAME_MAX_LENGTH = 40000 + HEADER_MAX_LENGTH;
    private int mContentLength = -1;
 
    public static Mjpegsample read(String url) {
        HttpResponse res;
        DefaultHttpClient httpclient = new DefaultHttpClient();		
        try {
            res = httpclient.execute(new HttpGet(URI.create(url)));
            return new Mjpegsample(res.getEntity().getContent());
 
        } catch (ClientProtocolException e) {
        } catch (IOException e) {}
        return null;
    }
    public Mjpegsample(InputStream in) {
    	super(new BufferedInputStream(in, FRAME_MAX_LENGTH)); 
    	}
    private int getEndOfSeqeunce(DataInputStream in, byte[] sequence) throws IOException {
        int seqIndex = 0;
        byte c;
        for(int i=0; i < FRAME_MAX_LENGTH; i++) {
            c = (byte) in.readUnsignedByte();
            if(c == sequence[seqIndex]) {
                seqIndex++;
                if(seqIndex == sequence.length) return i + 1;
            } else seqIndex = 0;
        }
        return -1;
    }
    private int getStartOfSequence(DataInputStream in, byte[] sequence) throws IOException {
        int end = getEndOfSeqeunce(in, sequence);
        return (end < 0) ? (-1) : (end - sequence.length);
    }
    private int parseContentLength(byte[] headerBytes) throws IOException, NumberFormatException {
        ByteArrayInputStream headerIn = new ByteArrayInputStream(headerBytes);
        Properties props = new Properties();
        props.load(headerIn);
        return Integer.parseInt(props.getProperty(CONTENT_LENGTH));
    }	
    public Bitmap readMjpegFrame() throws IOException {
        mark(FRAME_MAX_LENGTH);
        int headerLen = getStartOfSequence(this, SOI_MARKER);
        reset();
        byte[] header = new byte[headerLen];
        readFully(header);
        try {
            mContentLength = parseContentLength(header);
        } catch (NumberFormatException nfe) { 
            mContentLength = getEndOfSeqeunce(this, EOF_MARKER); 
        }
        reset();
        byte[] frameData = new byte[mContentLength];
        skipBytes(headerLen);
        readFully(frameData);
        return BitmapFactory.decodeStream(new ByteArrayInputStream(frameData));
    }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
package com.surveillance.form;
 
import java.io.IOException;
 
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.widget.Toast;
 
import android.util.Log;
 
 
public class MjpegView  extends SurfaceView implements SurfaceHolder.Callback {
 
	public MjpegView(Context context) {
		super(context);
		init(context); 
 
	}
 
	public MjpegView(Context context, AttributeSet attrs) {
		super(context, attrs);
		init(context); 
	}
 
	public final static int POSITION_UPPER_LEFT  = 9;
    public final static int POSITION_UPPER_RIGHT = 3;
    public final static int POSITION_LOWER_LEFT  = 12;
    public final static int POSITION_LOWER_RIGHT = 6;
 
    public final static int SIZE_STANDARD   = 1; 
    public final static int SIZE_BEST_FIT   = 4;
    public final static int SIZE_FULLSCREEN = 8;
 
    private static final String TAG = "MOT_MyActivity"; /* define log tag*/
 
 
    private MjpegViewThread thread;
    private Mjpegsample mIn = null;    
    private boolean showFps = false;
    private boolean mRun = false;
    private boolean surfaceDone = false;    
    private Paint overlayPaint;
    private int overlayTextColor;
    private int overlayBackgroundColor;
    private int ovlPos;
    private int dispWidth;
    private int dispHeight;
    private int displayMode;
 
    public class MjpegViewThread extends Thread {
        private SurfaceHolder mSurfaceHolder;
        private int frameCounter = 0;
        private long start;
        private Bitmap ovl;
 
        public MjpegViewThread(SurfaceHolder surfaceHolder, Context context) {
        	mSurfaceHolder = surfaceHolder; 
 
    		}
 
        private Rect destRect(int bmw, int bmh) {
            int tempx;
            int tempy;
            if (displayMode == MjpegView.SIZE_STANDARD) {
                tempx = (dispWidth / 2) - (bmw / 2);
                tempy = (dispHeight / 2) - (bmh / 2);
                return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
            }
            if (displayMode == MjpegView.SIZE_BEST_FIT) {
                float bmasp = (float) bmw / (float) bmh;
                bmw = dispWidth;
                bmh = (int) (dispWidth / bmasp);
                if (bmh > dispHeight) {
                    bmh = dispHeight;
                    bmw = (int) (dispHeight * bmasp);
                }
                tempx = (dispWidth / 2) - (bmw / 2);
                tempy = (dispHeight / 2) - (bmh / 2);
                return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
            }
            if (displayMode == MjpegView.SIZE_FULLSCREEN) return new Rect(0, 0, dispWidth, dispHeight);
            return null;
        }
 
        public void setSurfaceSize(int width, int height) {
            synchronized(mSurfaceHolder) {
                dispWidth = width;
                dispHeight = height;
            }
        }
 
        private Bitmap makeFpsOverlay(Paint p, String text) {
            Rect b = new Rect();
            p.getTextBounds(text, 0, text.length(), b);
            int bwidth  = b.width()+2;
            int bheight = b.height()+2;
            Bitmap bm = Bitmap.createBitmap(bwidth, bheight, Bitmap.Config.ARGB_8888);
            Canvas c = new Canvas(bm);
            p.setColor(overlayBackgroundColor);
            c.drawRect(0, 0, bwidth, bheight, p);
            p.setColor(overlayTextColor);
            c.drawText(text, -b.left+1, (bheight/2)-((p.ascent()+p.descent())/2)+1, p);
            return bm;        
 
        }
 
 
/////////////////////////////////////////////        
      public void run() {
            start = System.currentTimeMillis();
            PorterDuffXfermode mode = new PorterDuffXfermode(PorterDuff.Mode.DST_OVER);
            Bitmap bm;
            int width;
            int height;
            Rect destRect;
            Canvas c = null;
            Paint p = new Paint();
            String fps = "";
            while (mRun) {
                if(surfaceDone) {
                    try {
                        c = mSurfaceHolder.lockCanvas();
                        synchronized (mSurfaceHolder) {
                            try {
                               bm = mIn.readMjpegFrame();
                               destRect = destRect(bm.getWidth(),bm.getHeight());
                                c.drawColor(Color.BLACK);
                               c.drawBitmap(bm, null, destRect, p);
                                if(showFps) {
                                    p.setXfermode(mode);
                                    if(ovl != null) {
                                   	height = ((ovlPos & 1) == 1) ? destRect.top : destRect.bottom-ovl.getHeight();
                                   	width  = ((ovlPos & 8) == 8) ? destRect.left : destRect.right -ovl.getWidth();
                                       c.drawBitmap(ovl, width, height, null);
                                    }
                                    p.setXfermode(null);
                                    frameCounter++;
                                    if((System.currentTimeMillis() - start) >= 1000) {
                                        fps = String.valueOf(frameCounter)+"fps";
                                        frameCounter = 0; 
                                        start = System.currentTimeMillis();
                                       ovl = makeFpsOverlay(overlayPaint, fps);
                                    }
                                }
                            }
                            catch (IOException e) {}
                        }
                    } 
                    finally { if (c != null) mSurfaceHolder.unlockCanvasAndPost(c); }
                }
            }
        }
    }
    private void init(Context context) {
        SurfaceHolder holder = getHolder();
        holder.addCallback(this);
        thread = new MjpegViewThread(holder, context);
        setFocusable(true);
        overlayPaint = new Paint();
        overlayPaint.setTextAlign(Paint.Align.LEFT);
        overlayPaint.setTextSize(12);
        overlayPaint.setTypeface(Typeface.DEFAULT);
        overlayTextColor = Color.WHITE;
        overlayBackgroundColor = Color.BLACK;
        ovlPos = MjpegView.POSITION_LOWER_RIGHT;
        displayMode = MjpegView.SIZE_STANDARD;
        dispWidth = getWidth();
        dispHeight = getHeight();
    }
 
    public void startPlayback() { 
    	 try{
    	    	// Mon code à éxécuter
 
    	        if(mIn != null) {
    	            mRun = true;
    	            thread.start();  
    	                    }   
    	    	}
    	    	catch(Exception e)
    	    	{  	
    	    		  Log.e(TAG, "this is a log.e messageSTART Playback");
 
    	    	}
 
    }
 
    public void stopPlayback() { 
        mRun = false;
        boolean retry = true;
        while(retry) {
            try {
                thread.join();
                retry = false;
            } 
            catch (InterruptedException e) {}
        }
    }
 
 
    public void surfaceChanged(SurfaceHolder holder, int f, int w, int h) {
    	thread.setSurfaceSize(w, h); 
    	}
 
    public void surfaceDestroyed(SurfaceHolder holder) { 
        surfaceDone = false; 
        stopPlayback(); 
    }
 
 
 
 
    public void surfaceCreated(SurfaceHolder holder) { surfaceDone = true; }
 
    public void showFps(boolean b) { 
    	try{
	    	// Mon code à éxécuter
    		showFps = b;
 
	    	}
	    	catch(Exception e)
	    	{  	
	    		  Log.e(TAG, "this is a log.e messageSTART Playback");
 
	    	}
    	}
 
    public void setSource(Mjpegsample source) {  
   // Toast monToast3;
	//monToast3 = Toast.makeText(null, "MjpegView  ",Toast.LENGTH_LONG);
	//monToast3.show();
 
    try{
    	// Mon code à éxécuter
    	mIn = source;
    	startPlayback();   
    	}
    	catch(Exception e)
    	{  	
    		  Log.e(TAG, "this is a log.e message");
 
    	}
 
    }
 
    public void setOverlayPaint(Paint p) { overlayPaint = p; }
 
    public void setOverlayTextColor(int c) { overlayTextColor = c; }
 
    public void setOverlayBackgroundColor(int c) { overlayBackgroundColor = c; }
 
    public void setOverlayPosition(int p) { ovlPos = p; }
 
    public void setDisplayMode(int s) { displayMode = s; }
 
 
}

est ce qu'il ya quelqu'un qui peut m'aider à corriger le code :(

Bonjour,

As tu une erreur ?

As tu commencé à débogguer ton application pour savoir a quel endroit tu as le problème ?

Merci

visualisation de camera ip

Salut ,
ça marche maintenant le problème c'est dans URL
Merci