path: root/screen_source/v4l2_vdin.cpp (plain)
blob: bd63166124f215feef2725745bbe3b92f0d1dd68

1	/*
2	* Copyright (C) 2013 The Android Open Source Project
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17
18	//reinclude because of a bug with the log macros
19	//#define LOG_NDEBUG 0
20	#define LOG_TAG "V4L2VINSOURCE"
21	#include <utils/Log.h>
22	#include <utils/String8.h>
23
24	#include <signal.h>
25	#include <stdio.h>
26	#include <stdlib.h>
27	#include <string.h>
28	#include <fcntl.h>
29	#include <unistd.h>
30	#include <errno.h>
31	#include <sys/ioctl.h>
32	#include <sys/mman.h>
33	#include <sys/select.h>
34	#include <linux/videodev2.h>
35	#include <sys/time.h>
36
37	#include <cutils/properties.h>
38	#include <sys/types.h>
39	#include <sys/stat.h>
40
41	#include "v4l2_vdin.h"
42	#include <ui/GraphicBufferMapper.h>
43	#include <ui/GraphicBuffer.h>
44	#include <linux/videodev2.h>
45
46	namespace android {
47
48	#define V4L2_ROTATE_ID 0x980922
49
50	#ifndef container_of
51	#define container_of(ptr, type, member) ({ \
52	const typeof(((type *) 0)->member) *__mptr = (ptr); \
53	(type *) ((char *) __mptr - (char *)(&((type *)0)->member)); })
54	#endif
55
56	#define BOUNDRY 32
57
58	#define ALIGN(x) (x + (BOUNDRY) - 1)& ~((BOUNDRY) - 1)
59
60	static size_t getBufSize(int format, int width, int height)
61	{
62	size_t buf_size = 0;
63
64	switch (format) {
65	case V4L2_PIX_FMT_YVU420:
66	case V4L2_PIX_FMT_NV21:
67	buf_size = width * height * 3 / 2;
68	break;
69	case V4L2_PIX_FMT_YUYV:
70	case V4L2_PIX_FMT_RGB565:
71	buf_size = width * height * 2;
72	break;
73	case V4L2_PIX_FMT_RGB24:
74	buf_size = width * height * 3;
75	break;
76	case V4L2_PIX_FMT_RGB32:
77	buf_size = width * height * 4;
78	break;
79	default:
80	ALOGE("Invalid format");
81	buf_size = 0;
82	}
83	return buf_size;
84	}
85
86	static int getNativeWindowFormat(int format)
87	{
88	int nativeFormat = HAL_PIXEL_FORMAT_YCbCr_422_I;
89
90	switch (format) {
91	case V4L2_PIX_FMT_YVU420:
92	nativeFormat = HAL_PIXEL_FORMAT_YV12;
93	break;
94	case V4L2_PIX_FMT_NV21:
95	nativeFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
96	break;
97	case V4L2_PIX_FMT_YUYV:
98	nativeFormat = HAL_PIXEL_FORMAT_YCbCr_422_I;
99	break;
100	case V4L2_PIX_FMT_RGB565:
101	nativeFormat = HAL_PIXEL_FORMAT_RGB_565;
102	break;
103	case V4L2_PIX_FMT_RGB24:
104	nativeFormat = HAL_PIXEL_FORMAT_RGB_888;
105	break;
106	case V4L2_PIX_FMT_RGB32:
107	nativeFormat = HAL_PIXEL_FORMAT_RGBA_8888;
108	break;
109	default:
110	ALOGE("Invalid format,Use default format");
111	}
112	return nativeFormat;
113	}
114
115
116	static ANativeWindowBuffer *handle_to_buffer(buffer_handle_t *handle)
117	{
118	return container_of(handle, ANativeWindowBuffer, handle);
119	}
120
121	vdin_screen_source::vdin_screen_source()
122	: mCameraHandle(-1),
123	mVideoInfo(NULL)
124	{
125	ALOGV("%s %d", __FUNCTION__, __LINE__);
126	}
127
128	int vdin_screen_source::init()
129	{
130	ALOGV("%s %d", __FUNCTION__, __LINE__);
131	mCameraHandle = open("/dev/video11", O_RDWR | O_NONBLOCK);
132	if (mCameraHandle < 0) {
133	ALOGE("[%s %d] mCameraHandle:%x [%s]", __FUNCTION__, __LINE__, mCameraHandle, strerror(errno));
134	return -1;
135	}
136	mVideoInfo = (struct VideoInfo *) calloc (1, sizeof (struct VideoInfo));
137	if (mVideoInfo == NULL) {
138	ALOGE("[%s %d] no memory for mVideoInfo", __FUNCTION__, __LINE__);
139	close(mCameraHandle);
140	return NO_MEMORY;
141	}
142	mBufferCount = 4;
143	mPixelFormat = V4L2_PIX_FMT_NV21;
144	mNativeWindowPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
145	mFrameWidth = 1280;
146	mFrameHeight = 720;
147	mBufferSize = mFrameWidth * mFrameHeight * 3 / 2;
148	mSetStateCB = NULL;
149	mState = STOP;
150	mANativeWindow = NULL;
151	mFrameType = 0;
152	mWorkThread = NULL;
153	mDataCB = NULL;
154	mOpen = false;
155	return NO_ERROR;
156	}
157
158	vdin_screen_source::~vdin_screen_source()
159	{
160	if (mVideoInfo) {
161	free (mVideoInfo);
162	}
163	if (mCameraHandle >= 0) {
164	close(mCameraHandle);
165	}
166	}
167
168	int vdin_screen_source::start_v4l2_device()
169	{
170	int ret = -1;
171
172	ALOGV("[%s %d] mCameraHandle:%x", __FUNCTION__, __LINE__, mCameraHandle);
173
174	ioctl(mCameraHandle, VIDIOC_QUERYCAP, &mVideoInfo->cap);
175
176	mVideoInfo->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
177	mVideoInfo->rb.memory = V4L2_MEMORY_MMAP;
178	mVideoInfo->rb.count = mBufferCount;
179
180	ret = ioctl(mCameraHandle, VIDIOC_REQBUFS, &mVideoInfo->rb);
181
182	if (ret < 0) {
183	ALOGE("[%s %d] VIDIOC_REQBUFS:%d mCameraHandle:%x", __FUNCTION__, __LINE__, ret, mCameraHandle);
184	return ret;
185	}
186
187	for (int i = 0; i < mBufferCount; i++) {
188	memset (&mVideoInfo->buf, 0, sizeof (struct v4l2_buffer));
189
190	mVideoInfo->buf.index = i;
191	mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
192	mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
193
194	ret = ioctl (mCameraHandle, VIDIOC_QUERYBUF, &mVideoInfo->buf);
195	if (ret < 0) {
196	ALOGE("[%s %d]VIDIOC_QUERYBUF %d failed", __FUNCTION__, __LINE__, i);
197	return ret;
198	}
199	mVideoInfo->canvas[i] = mVideoInfo->buf.reserved;
200	mVideoInfo->mem[i] = (long *)mmap (0, mVideoInfo->buf.length, PROT_READ | PROT_WRITE,
201	MAP_SHARED, mCameraHandle, mVideoInfo->buf.m.offset);
202
203	if (mVideoInfo->mem[i] == MAP_FAILED) {
204	ALOGE("[%s %d] MAP_FAILED", __FUNCTION__, __LINE__);
205	return -1;
206	}
207	mVideoInfo->refcount[i] = 0;
208	mBufs.add(mVideoInfo->mem[i], i);
209	}
210	ALOGV("[%s %d] VIDIOC_QUERYBUF successful", __FUNCTION__, __LINE__);
211
212	for (int i = 0; i < mBufferCount; i++) {
213	mVideoInfo->buf.index = i;
214	mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
215	mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
216	ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
217	if (ret < 0) {
218	ALOGE("VIDIOC_QBUF Failed");
219	return -1;
220	}
221	}
222	enum v4l2_buf_type bufType;
223	bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
224
225	ret = ioctl (mCameraHandle, VIDIOC_STREAMON, &bufType);
226
227	ALOGV("[%s %d] VIDIOC_STREAMON:%x", __FUNCTION__, __LINE__, ret);
228	return ret;
229	}
230
231	int vdin_screen_source::stop_v4l2_device()
232	{
233	int ret;
234	enum v4l2_buf_type bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
235
236	ret = ioctl (mCameraHandle, VIDIOC_STREAMOFF, &bufType);
237	if (ret < 0) {
238	ALOGE("StopStreaming: Unable to stop capture: %s", strerror(errno));
239	}
240	for (int i = 0; i < mBufferCount; i++) {
241	if (munmap(mVideoInfo->mem[i], mVideoInfo->buf.length) < 0) {
242	ALOGE("Unmap failed");
243	}
244	}
245	return ret;
246	}
247
248	int vdin_screen_source::start()
249	{
250	ALOGV("%s %d", __FUNCTION__, __LINE__);
251	int ret;
252	if (mOpen == true) {
253	ALOGI("already open");
254	return NO_ERROR;
255	}
256
257	ret = start_v4l2_device();
258	if (ret != NO_ERROR) {
259	ALOGE("Start v4l2 device failed:%d", ret);
260	return ret;
261	}
262	if (mFrameType & NATIVE_WINDOW_DATA) {
263	ret = init_native_window();
264	if (ret != NO_ERROR) {
265	ALOGE("Init Native Window Failed:%d", ret);
266	return ret;
267	}
268	}
269	if (mFrameType & NATIVE_WINDOW_DATA || mFrameType & CALL_BACK_DATA) {
270	ALOGD("Create Work Thread");
271	mWorkThread = new WorkThread(this);
272	}
273	if (mSetStateCB != NULL) {
274	mSetStateCB(START);
275	}
276	mState = START;
277	mOpen = true;
278	ALOGV("%s %d ret:%d", __FUNCTION__, __LINE__, ret);
279	return NO_ERROR;
280	}
281
282	int vdin_screen_source::pause()
283	{
284	ALOGV("%s %d", __FUNCTION__, __LINE__);
285	mState = PAUSE;
286	if (mSetStateCB != NULL) {
287	mSetStateCB(PAUSE);
288	}
289	return NO_ERROR;
290	}
291	int vdin_screen_source::stop()
292	{
293	ALOGV("%s %d", __FUNCTION__, __LINE__);
294	int ret;
295	mState = STOPING;
296
297	if (mWorkThread != NULL) {
298	mWorkThread->requestExitAndWait();
299	mWorkThread.clear();
300	}
301
302	mBufferCount = 0;
303	mState = STOP;
304	if (mSetStateCB != NULL) {
305	mSetStateCB(STOP);
306	}
307	mOpen = false;
308	return ret;
309	}
310
311	int vdin_screen_source::set_state_callback(olStateCB callback)
312	{
313	if (!callback) {
314	ALOGE("NULL state callback pointer");
315	return BAD_VALUE;
316	}
317	mSetStateCB = callback;
318	return NO_ERROR;
319	}
320
321	int vdin_screen_source::set_preview_window(ANativeWindow *window)
322	{
323	ALOGV("%s %d", __FUNCTION__, __LINE__);
324	if (mOpen == true) {
325	return NO_ERROR;
326	}
327	//can work without a valid window object ?
328	if (window == NULL) {
329	ALOGD("NULL window object passed to ScreenSource");
330	if (mWorkThread != NULL) {
331	mWorkThread->requestExitAndWait();
332	mWorkThread.clear();
333	}
334	mFrameType &= ~NATIVE_WINDOW_DATA;
335	return NO_ERROR;
336	}
337	mFrameType |= NATIVE_WINDOW_DATA;
338	mANativeWindow = window;
339	return NO_ERROR;
340	}
341
342	int vdin_screen_source::set_data_callback(app_data_callback callback, void *user)
343	{
344	ALOGV("%s %d", __FUNCTION__, __LINE__);
345	if (callback == NULL) {
346	ALOGE("NULL data callback pointer");
347	return BAD_VALUE;
348	}
349	mDataCB = callback;
350	mUser = user;
351	mFrameType |= CALL_BACK_DATA;
352	return NO_ERROR;
353	}
354
355	int vdin_screen_source::get_format()
356	{
357	return mPixelFormat;
358	}
359
360	int vdin_screen_source::set_format(int width, int height, int color_format)
361	{
362	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
363	if (mOpen == true) {
364	return NO_ERROR;
365	}
366	int ret;
367	mVideoInfo->width = ALIGN(width);
368	mVideoInfo->height = height;
369	mVideoInfo->framesizeIn = (mVideoInfo->width * mVideoInfo->height << 3); //note color format
370	mVideoInfo->formatIn = color_format;
371
372	mVideoInfo->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
373	mVideoInfo->format.fmt.pix.width = ALIGN(width);
374	mVideoInfo->format.fmt.pix.height = height;
375	mVideoInfo->format.fmt.pix.pixelformat = color_format;
376	mPixelFormat = color_format;
377	mNativeWindowPixelFormat = getNativeWindowFormat(color_format);
378	mFrameWidth = ALIGN(width);
379	mFrameHeight = height;
380	mBufferSize = getBufSize(color_format, mFrameWidth, mFrameHeight);
381	ALOGD("mFrameWidth:%d,mFrameHeight:%d", mFrameWidth, mFrameHeight);
382	ALOGD("mPixelFormat:%x,mNativeWindowPixelFormat:%x,mBufferSize:%d", mPixelFormat, mNativeWindowPixelFormat, mBufferSize);
383	ret = ioctl(mCameraHandle, VIDIOC_S_FMT, &mVideoInfo->format);
384	if (ret < 0) {
385	ALOGE("[%s %d]VIDIOC_S_FMT %d", __FUNCTION__, __LINE__, ret);
386	return ret;
387	}
388	return ret;
389	}
390
391	int vdin_screen_source::set_rotation(int degree)
392	{
393	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
394
395	int ret = 0;
396	struct v4l2_control ctl;
397
398	if (mCameraHandle < 0) {
399	return -1;
400	}
401
402	if ((degree != 0) && (degree != 90) && (degree != 180) && (degree != 270)) {
403	ALOGE("Set rotate value invalid: %d.", degree);
404	return -1;
405	}
406
407	memset( &ctl, 0, sizeof(ctl));
408	ctl.value = degree;
409	ctl.id = V4L2_ROTATE_ID;
410	ret = ioctl(mCameraHandle, VIDIOC_S_CTRL, &ctl);
411
412	if (ret < 0) {
413	ALOGE("Set rotate value fail: %s. ret=%d", strerror(errno), ret);
414	}
415	return ret ;
416	}
417
418	int vdin_screen_source::set_crop(int x, int y, int width, int height)
419	{
420	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
421	if (NULL == mANativeWindow.get())
422	return BAD_VALUE;
423
424	int err = NO_ERROR;
425	android_native_rect_t crop = { x, y, x + width - 1, y + height - 1 };
426	err = native_window_set_crop(mANativeWindow.get(), &crop);
427	if (err != 0) {
428	ALOGW("Failed to set crop!");
429	return err;
430	}
431	return NO_ERROR;
432	}
433
434	int vdin_screen_source::set_frame_rate(int frameRate)
435	{
436	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
437	int ret = 0;
438	struct v4l2_control ctl;
439
440	if (mCameraHandle < 0) {
441	return -1;
442	}
443
444	struct v4l2_streamparm sparm;
445	memset(&sparm, 0, sizeof( sparm ));
446	sparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//stream_flag;
447	sparm.parm.output.timeperframe.denominator = frameRate;
448	sparm.parm.output.timeperframe.numerator = 1;
449
450	ret = ioctl(mCameraHandle, VIDIOC_S_PARM, &sparm);
451	if (ret < 0) {
452	ALOGE("Set frame rate fail: %s. ret=%d", strerror(errno), ret);
453	}
454	return ret ;
455	}
456
457	int vdin_screen_source::set_amlvideo2_crop(int x, int y, int width, int height)
458	{
459	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
460	int ret = 0;
461
462	struct v4l2_crop crop;
463	memset(&crop, 0, sizeof(struct v4l2_crop));
464
465	crop.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
466	crop.c.left = x;
467	crop.c.top = y;
468	crop.c.width = width;
469	crop.c.height = height;
470	ret = ioctl(mCameraHandle, VIDIOC_S_CROP, &crop);
471	if (ret) {
472	ALOGE("Set frame rate fail: %s. ret=%d", strerror(errno), ret);
473	}
474
475	return ret ;
476	}
477
478	int vdin_screen_source::set_source_type(int sourceType)
479	{
480	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
481	int ret = 0;
482
483	ret = ioctl(mCameraHandle, VIDIOC_S_INPUT, &sourceType);
484	if (ret < 0) {
485	ALOGE("Set source type fail: %s. ret:%d", strerror(errno), ret);
486	}
487	return ret;
488	}
489
490	int vdin_screen_source::get_source_type()
491	{
492	ALOGV("[%s %d]", __FUNCTION__, __LINE__);
493	int ret = -1;
494	int sourceType;
495
496	ret = ioctl(mCameraHandle, VIDIOC_G_INPUT, &sourceType);
497	if (ret < 0) {
498	ALOGE("Set source type fail: %s. ret:%d", strerror(errno), ret);
499	return ret;
500	}
501	return sourceType;
502	}
503
504	int vdin_screen_source::aquire_buffer(aml_screen_buffer_info_t *buff_info)
505	{
506	ALOGV("%s %d", __FUNCTION__, __LINE__);
507	int ret = -1;
508	mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
509	mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
510
511	ret = ioctl(mCameraHandle, VIDIOC_DQBUF, &mVideoInfo->buf);
512	if (ret < 0) {
513	if (EAGAIN == errno) {
514	ret = -EAGAIN;
515	} else {
516	ALOGE("[%s %d]aquire_buffer %d", __FUNCTION__, __LINE__, ret);
517	}
518	buff_info->buffer_mem = 0;
519	buff_info->buffer_canvas = 0;
520	return ret;
521	}
522	buff_info->buffer_mem = mVideoInfo->mem[mVideoInfo->buf.index];
523	buff_info->buffer_canvas = mVideoInfo->canvas[mVideoInfo->buf.index];
524	buff_info->tv_sec = mVideoInfo->buf.timestamp.tv_sec;
525	buff_info->tv_usec = mVideoInfo->buf.timestamp.tv_usec;
526	return ret;
527	}
528
529	/* int vdin_screen_source::inc_buffer_refcount(int *ptr){
530	ALOGV("%s %d", __FUNCTION__, __LINE__);
531	int ret = -1;
532	int index;
533	index = mBufs.valueFor((unsigned int)ptr);
534	mVideoInfo->refcount[index] += 1;
535	return true;
536	} */
537
538	int vdin_screen_source::release_buffer(long *ptr)
539	{
540	ALOGV("%s %d", __FUNCTION__, __LINE__);
541	int ret = -1;
542	int currentIndex;
543	v4l2_buffer hbuf_query;
544
545	Mutex::Autolock autoLock(mLock);
546
547	currentIndex = mBufs.valueFor(ptr);
548	if (mVideoInfo->refcount[currentIndex] > 0) {
549	mVideoInfo->refcount[currentIndex] -= 1;
550	} else {
551	ALOGE("return buffer when refcount already zero");
552	return 0;
553	}
554	if (mVideoInfo->refcount[currentIndex] == 0) {
555	memset(&hbuf_query, 0, sizeof(v4l2_buffer));
556	hbuf_query.index = currentIndex;
557	hbuf_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
558	hbuf_query.memory = V4L2_MEMORY_MMAP;
559	ALOGV("return buffer :%d", currentIndex);
560	ret = ioctl(mCameraHandle, VIDIOC_QBUF, &hbuf_query);
561	if (ret != 0) {
562	ALOGE("Return Buffer :%d failed", currentIndex);
563	}
564	}
565	return 0;
566	}
567
568	int vdin_screen_source::init_native_window()
569	{
570	ALOGV("%s %d", __FUNCTION__, __LINE__);
571	int err = NO_ERROR;
572
573	if (NULL == mANativeWindow.get()) {
574	return BAD_VALUE;
575	}
576
577	// Set gralloc usage bits for window.
578	err = native_window_set_usage(mANativeWindow.get(), SCREENSOURCE_GRALLOC_USAGE);
579	if (err != 0) {
580	ALOGE("native_window_set_usage failed: %s\n", strerror(-err));
581	if (ENODEV == err ) {
582	ALOGE("Preview surface abandoned!");
583	mANativeWindow = NULL;
584	}
585	return err;
586	}
587
588	ALOGD("Number of buffers set to ANativeWindow %d", mBufferCount);
589	///Set the number of buffers needed for camera preview
590	err = native_window_set_buffer_count(mANativeWindow.get(), mBufferCount);
591	if (err != 0) {
592	ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err), -err);
593	if (ENODEV == err) {
594	ALOGE("Preview surface abandoned!");
595	mANativeWindow = NULL;
596	}
597	return err;
598	}
599
600	ALOGD("native_window_set_buffers_geometry format:0x%x", mNativeWindowPixelFormat);
601	// Set window geometry
602	err = native_window_set_buffers_geometry(
603	mANativeWindow.get(),
604	mFrameWidth,
605	mFrameHeight,
606	mNativeWindowPixelFormat);
607
608	if (err != 0) {
609	ALOGE("native_window_set_buffers_geometry failed: %s", strerror(-err));
610	if ( ENODEV == err ) {
611	ALOGE("Surface abandoned!");
612	mANativeWindow = NULL;
613	}
614	return err;
615	}
616	err = native_window_set_scaling_mode(mANativeWindow.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
617	if (err != 0) {
618	ALOGW("Failed to set scaling mode: %d", err);
619	return err;
620	}
621	return NO_ERROR;
622	}
623
624	int vdin_screen_source::workThread()
625	{
626	bool buff_keep = false;
627	int index;
628	aml_screen_buffer_info_t buff_info;
629	int ret;
630	long *src = NULL;
631	unsigned char *dest = NULL;
632	uint8_t *handle = NULL;
633	ANativeWindowBuffer *buf;
634	if (mState == START) {
635	usleep(5000);
636	ret = aquire_buffer(&buff_info);
637	if (ret != 0 || (buff_info.buffer_mem == 0)) {
638	ALOGV("Get V4l2 buffer failed");
639	return ret;
640	}
641	src = (long *)buff_info.buffer_mem;
642	index = mBufs.valueFor(src);
643	if (mFrameType & NATIVE_WINDOW_DATA) {
644	mVideoInfo->refcount[index] += 1;
645	if (mANativeWindow.get() == NULL) {
646	ALOGE("Null window");
647	return BAD_VALUE;
648	}
649	ret = mANativeWindow->dequeueBuffer_DEPRECATED(mANativeWindow.get(), &buf);
650	if (ret != 0) {
651	ALOGE("dequeue buffer failed :%s (%d)", strerror(-ret), -ret);
652	return BAD_VALUE;
653	}
654	mANativeWindow->lockBuffer_DEPRECATED(mANativeWindow.get(), buf);
655	sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(buf, false));
656	graphicBuffer->lock(SCREENSOURCE_GRALLOC_USAGE, (void **)&dest);
657	if (dest == NULL) {
658	ALOGE("Invalid Gralloc Handle");
659	return BAD_VALUE;
660	}
661	memcpy(dest, src, mBufferSize);
662	graphicBuffer->unlock();
663	mANativeWindow->queueBuffer_DEPRECATED(mANativeWindow.get(), buf);
664	graphicBuffer.clear();
665	ALOGV("queue one buffer to native window");
666	release_buffer(src);
667	}
668	if (mFrameType & CALL_BACK_DATA && mDataCB != NULL && mState == START) {
669	mVideoInfo->refcount[index] += 1;
670	mDataCB(mUser, &buff_info);
671	}
672	}
673	return NO_ERROR;
674	}
675
676	}
677