path: root/tvapi/android/tvserver/TvService.cpp (plain)
blob: 7cd5907aa6e33258f6a59349da928747c2295e74

1	#define LOG_TAG "TvService"
2
3	#include <utils/Log.h>
4	#include <binder/IServiceManager.h>
5	#include <binder/IPCThreadState.h>
6	#include <utils/String16.h>
7	#include <utils/Errors.h>
8	#include <binder/MemoryBase.h>
9	#include <binder/MemoryHeapBase.h>
10	#include <include/ITvService.h>
11	#include <hardware/hardware.h>
12	#include "TvService.h"
13	#include <cutils/atomic.h>
14	#include <cutils/properties.h>
15	#include <stdint.h>
16	#include <tvconfig/tvconfig.h>
17	#include <tvsetting/CTvSetting.h>
18	#include <audio/CTvAudio.h>
19	#include <tvutils/tvutils.h>
20	#include <version/version.h>
21	#include "../include/tvcmd.h"
22	#include "tv/CTvLog.h"
23	#include <tvdb/CTvRegion.h>
24	extern "C" {
25	#include <stdio.h>
26	#include <sys/types.h>
27	#include <sys/stat.h>
28	#include <fcntl.h>
29	#include <pthread.h>
30	#include <signal.h>
31	#include "make_ext4fs.h"
32	#include "am_ver.h"
33	}
34
35	#define PICTURE_TIMEOUT seconds(5)
36
37	static int getCallingPid()
38	{
39	return IPCThreadState::self()->getCallingPid();
40	}
41
42	TvService *TvService::mTvService = NULL;
43	CTv *TvService::mpTv = NULL;
44
45	void TvService::instantiate()
46	{
47	defaultServiceManager()->addService(String16("aml.tvserver"), TvService::getIntance());
48	}
49
50	TvService::TvService() :
51	BnTvService()
52	{
53	mpStartTvClient = NULL;
54	mpScannerClient = NULL;
55	mUsers = 0;
56	mpTv = new CTv();
57	mpTv->setTvObserver(this);
58	mCapVidFrame.setObserver(this);
59	mpTv->OpenTv();
60	}
61
62	TvService::~TvService()
63	{
64	mpStartTvClient = NULL;
65	mpScannerClient = NULL;
66	int client_size = m_v_Clients.size();
67	wp<Client> client;
68	for (int i = 0; i < client_size; i++) {
69	client = m_v_Clients[i];
70	if (client != 0) {
71	LOGW("some client still connect it!");
72	}
73	}
74	if (mpTv != NULL) {
75	delete mpTv;
76	mpTv = NULL;
77	}
78	}
79
80	void TvService::onTvEvent(const CTvEv &ev)
81	{
82	int type = ev.getEvType();
83	LOGD("TvService::onTvEvent ev type = %d", type);
84	switch (type) {
85	case CTvEv::TV_EVENT_COMMOM: {
86	break;
87	}
88	case CTvEv::TV_EVENT_SCANNER: {
89	CTvScanner::ScannerEvent *pScannerEv = (CTvScanner::ScannerEvent *) (&ev);
90	if (mpScannerClient != NULL) {
91	sp<Client> ScannerClient = mpScannerClient.promote();
92	if (ScannerClient != 0) {
93	Parcel p;
94	LOGD("scanner evt type:%d freq:%d vid:%d acnt:%d",
95	pScannerEv->mType, pScannerEv->mFrequency, pScannerEv->mVid, pScannerEv->mAcnt);
96	p.writeInt32(pScannerEv->mType);
97	p.writeInt32(pScannerEv->mPercent);
98	p.writeInt32(pScannerEv->mTotalChannelCount);
99	p.writeInt32(pScannerEv->mLockedStatus);
100	p.writeInt32(pScannerEv->mChannelNumber);
101	p.writeInt32(pScannerEv->mFrequency);
102	p.writeString16(String16(pScannerEv->mProgramName));
103	p.writeInt32(pScannerEv->mprogramType);
104	p.writeString16(String16(pScannerEv->mMSG));
105	p.writeInt32(pScannerEv->mStrength);
106	p.writeInt32(pScannerEv->mSnr);
107	//ATV
108	p.writeInt32(pScannerEv->mVideoStd);
109	p.writeInt32(pScannerEv->mAudioStd);
110	p.writeInt32(pScannerEv->mIsAutoStd);
111	//DTV
112	p.writeInt32(pScannerEv->mMode);
113	p.writeInt32(pScannerEv->mSymbolRate);
114	p.writeInt32(pScannerEv->mModulation);
115	p.writeInt32(pScannerEv->mBandwidth);
116	p.writeInt32(pScannerEv->mOfdm_mode);
117	p.writeInt32(pScannerEv->mTsId);
118	p.writeInt32(pScannerEv->mONetId);
119	p.writeInt32(pScannerEv->mServiceId);
120	p.writeInt32(pScannerEv->mVid);
121	p.writeInt32(pScannerEv->mVfmt);
122	p.writeInt32(pScannerEv->mAcnt);
123	for (int i = 0; i < pScannerEv->mAcnt; i++)
124	p.writeInt32(pScannerEv->mAid[i]);
125	for (int i = 0; i < pScannerEv->mAcnt; i++)
126	p.writeInt32(pScannerEv->mAfmt[i]);
127	for (int i = 0; i < pScannerEv->mAcnt; i++)
128	p.writeString16(String16(pScannerEv->mAlang[i]));
129	for (int i = 0; i < pScannerEv->mAcnt; i++)
130	p.writeInt32(pScannerEv->mAtype[i]);
131	p.writeInt32(pScannerEv->mPcr);
132	p.writeInt32(pScannerEv->mScnt);
133	for (int i = 0; i < pScannerEv->mScnt; i++)
134	p.writeInt32(pScannerEv->mStype[i]);
135	for (int i = 0; i < pScannerEv->mScnt; i++)
136	p.writeInt32(pScannerEv->mSid[i]);
137	for (int i = 0; i < pScannerEv->mScnt; i++)
138	p.writeInt32(pScannerEv->mSstype[i]);
139	for (int i = 0; i < pScannerEv->mScnt; i++)
140	p.writeInt32(pScannerEv->mSid1[i]);
141	for (int i = 0; i < pScannerEv->mScnt; i++)
142	p.writeInt32(pScannerEv->mSid2[i]);
143	for (int i = 0; i < pScannerEv->mScnt; i++)
144	p.writeString16(String16(pScannerEv->mSlang[i]));
145	ScannerClient->notifyCallback(SCAN_EVENT_CALLBACK, p);
146	}
147	}
148	break;
149	}
150	case CTvEv::TV_EVENT_EPG: {
151	CTvEpg::EpgEvent *pEpgEvent = (CTvEpg::EpgEvent *) (&ev);
152	int client_size = m_v_Clients.size();
153	wp<Client> client;
154	for (int i = 0; i < client_size; i++) {
155	client = m_v_Clients[i];
156	if (client != 0) {
157	sp<Client> currentClient = client.promote();
158	if (currentClient != 0) {
159	Parcel p;
160	p.writeInt32(pEpgEvent->type);
161	p.writeInt32(pEpgEvent->time);
162	p.writeInt32(pEpgEvent->programID);
163	p.writeInt32(pEpgEvent->channelID);
164	currentClient->getTvClient()->notifyCallback(EPG_EVENT_CALLBACK, p);
165	}
166	}
167	}
168	break;
169	}
170	case CTvEv::TV_EVENT_HDMI_IN_CAP: {
171	CTvScreenCapture::CapEvent *pCapEvt = (CTvScreenCapture::CapEvent *)(&ev);
172	int client_size = m_v_Clients.size();
173	wp<Client> client;
174	for (int i = 0; i < client_size; i++) {
175	client = m_v_Clients[i];
176	if (client != 0) {
177	sp<Client> currentClient = client.promote();
178	if (currentClient != 0) {
179	Parcel p;
180	p.writeInt32(pCapEvt->mFrameNum);
181	p.writeInt32(pCapEvt->mFrameSize);
182	p.writeInt32(pCapEvt->mFrameWide);
183	p.writeInt32(pCapEvt->mFrameHeight);
184	currentClient->getTvClient()->notifyCallback(VFRAME_BMP_EVENT_CALLBACK, p);
185	}
186	}
187	}
188	break;
189	}
190	case CTvEv::TV_EVENT_AV_PLAYBACK: {
191	TvEvent::AVPlaybackEvent *pEv = (TvEvent::AVPlaybackEvent *)(&ev);
192	int client_size = m_v_Clients.size();
193	wp<Client> client;
194	for (int i = 0; i < client_size; i++) {
195	client = m_v_Clients[i];
196	if (client != 0) {
197	sp<Client> currentClient = client.promote();
198	if (currentClient != 0) {
199	Parcel p;
200	p.writeInt32(pEv->mMsgType);
201	p.writeInt32(pEv->mProgramId);
202	currentClient->getTvClient()->notifyCallback(DTV_AV_PLAYBACK_CALLBACK, p);
203	}
204	}
205	}
206	break;
207	}
208	case CTvEv::TV_EVENT_SIGLE_DETECT: {
209	TvEvent::SignalInfoEvent *pEv = (TvEvent::SignalInfoEvent *)(&ev);
210
211	int client_size = m_v_Clients.size();
212	wp<Client> client;
213	for (int i = 0; i < client_size; i++) {
214	client = m_v_Clients[i];
215	if (client != 0) {
216	sp<Client> currentClient = client.promote();
217	if (currentClient != 0) {
218	Parcel p;
219	p.writeInt32(pEv->mTrans_fmt);
220	p.writeInt32(pEv->mFmt);
221	p.writeInt32(pEv->mStatus);
222	p.writeInt32(pEv->mReserved);
223	currentClient->getTvClient()->notifyCallback(SIGLE_DETECT_CALLBACK, p);
224	}
225	}
226	}
227	break;
228	}
229	case CTvEv::TV_EVENT_SUBTITLE: {
230	TvEvent::SubtitleEvent *pEv = (TvEvent::SubtitleEvent *)(&ev);
231	sp<Client> pSubtitleClient = mpSubClient.promote();
232	if (pSubtitleClient != NULL) {
233	Parcel p;
234	p.writeInt32(pEv->pic_width);
235	p.writeInt32(pEv->pic_height);
236	pSubtitleClient->notifyCallback(SUBTITLE_UPDATE_CALLBACK, p);
237	}
238	break;
239	}
240	case CTvEv::TV_EVENT_ADC_CALIBRATION: {
241	TvEvent::ADCCalibrationEvent *pEv = (TvEvent::ADCCalibrationEvent *)(&ev);
242	int client_size = m_v_Clients.size();
243	wp<Client> client;
244	for (int i = 0; i < client_size; i++) {
245	client = m_v_Clients[i];
246	if (client != 0) {
247	sp<Client> currentClient = client.promote();
248	if (currentClient != 0) {
249	Parcel p;
250	p.writeInt32(pEv->mState);
251	currentClient->getTvClient()->notifyCallback(ADC_CALIBRATION_CALLBACK, p);
252	}
253	}
254	}
255	break;
256	}
257	case CTvEv::TV_EVENT_VGA: { //VGA
258	TvEvent::VGAEvent *pEv = (TvEvent::VGAEvent *)(&ev);
259	int client_size = m_v_Clients.size();
260	wp<Client> client;
261	for (int i = 0; i < client_size; i++) {
262	client = m_v_Clients[i];
263	if (client != 0) {
264	sp<Client> currentClient = client.promote();
265	if (currentClient != 0) {
266	Parcel p;
267	p.writeInt32(pEv->mState);
268	currentClient->getTvClient()->notifyCallback(VGA_CALLBACK, p);
269	}
270	}
271	}
272	break;
273	}
274	case CTvEv::TV_EVENT_SOURCE_CONNECT: {
275	TvEvent::SourceConnectEvent *pEv = (TvEvent::SourceConnectEvent *)(&ev);
276	int client_size = m_v_Clients.size();
277	wp<Client> client;
278	for (int i = 0; i < client_size; i++) {
279	client = m_v_Clients[i];
280	if (client != 0) {
281	sp<Client> currentClient = client.promote();
282	if (currentClient != 0) {
283	Parcel p;
284	p.writeInt32(pEv->mSourceInput);
285	p.writeInt32(pEv->connectionState);
286	currentClient->getTvClient()->notifyCallback(SOURCE_CONNECT_CALLBACK, p);
287	}
288	}
289	}
290	break;
291	}
292	case CTvEv::TV_EVENT_HDMIRX_CEC: {
293	TvEvent::HDMIRxCECEvent *pEv = (TvEvent::HDMIRxCECEvent *)(&ev);
294	int client_size = m_v_Clients.size();
295	wp<Client> client;
296	for (int i = 0; i < client_size; i++) {
297	client = m_v_Clients[i];
298	if (client != 0) {
299	sp<Client> currentClient = client.promote();
300	if (currentClient != 0) {
301	Parcel p;
302
303	p.writeInt32(pEv->mDataCount);
304	for (int j = 0; j < pEv->mDataCount; j++) {
305	p.writeInt32(pEv->mDataBuf[j]);
306	}
307
308	currentClient->getTvClient()->notifyCallback(HDMIRX_CEC_CALLBACK, p);
309	}
310	}
311	}
312	break;
313	}
314	case CTvEv::TV_EVENT_UPGRADE_FBC: {
315	TvEvent::UpgradeFBCEvent *pEv = (TvEvent::UpgradeFBCEvent *)(&ev);
316
317	int client_size = m_v_Clients.size();
318	wp<Client> client;
319	for (int i = 0; i < client_size; i++) {
320	client = m_v_Clients[i];
321	if (client != 0) {
322	sp<Client> currentClient = client.promote();
323	if (currentClient != 0) {
324	Parcel p;
325	p.writeInt32(pEv->mState);
326	p.writeInt32(pEv->param);
327	currentClient->getTvClient()->notifyCallback(UPGRADE_FBC_CALLBACK, p);
328	}
329	}
330	}
331	break;
332	}
333	case CTvEv::TV_EVENT_SERIAL_COMMUNICATION: {
334	TvEvent::SerialCommunicationEvent *pEv = (TvEvent::SerialCommunicationEvent *)(&ev);
335	int client_size = m_v_Clients.size();
336	wp<Client> client;
337	for (int i = 0; i < client_size; i++) {
338	client = m_v_Clients[i];
339	if (client != 0) {
340	sp<Client> currentClient = client.promote();
341	if (currentClient != 0) {
342	Parcel p;
343	p.writeInt32(pEv->mDevId);
344	p.writeInt32(pEv->mDataCount);
345	for (int j = 0; j < pEv->mDataCount; j++) {
346	p.writeInt32(pEv->mDataBuf[j]);
347	}
348
349	currentClient->getTvClient()->notifyCallback(SERIAL_COMMUNICATION_CALLBACK, p);
350	}
351	}
352	}
353	break;
354	}
355
356	case CTvEv::TV_EVENT_2d4G_HEADSET: {
357	TvEvent::HeadSetOf2d4GEvent *pEv = (TvEvent::HeadSetOf2d4GEvent *)(&ev);
358	LOGD("SendDtvStats status: =%d para2: =%d", pEv->state, pEv->para);
359	int client_size = m_v_Clients.size();
360	wp<Client> client;
361	for (int i = 0; i < client_size; i++) {
362	client = m_v_Clients[i];
363	if (client != 0) {
364	sp<Client> currentClient = client.promote();
365	if (currentClient != 0) {
366	Parcel p;
367	p.writeInt32(pEv->state);
368	p.writeInt32(pEv->para);
369	currentClient->getTvClient()->notifyCallback(HEADSET_STATUS_CALLBACK, p);
370	}
371	}
372	}
373	break;
374	}
375
376	default:
377	break;
378	}
379	}
380
381	sp<ITv> TvService::connect(const sp<ITvClient> &tvClient)
382	{
383	int callingPid = getCallingPid();
384	LOGD("TvService::connect E (pid %d, client %p)", callingPid, IInterface::asBinder(tvClient).get());
385
386	Mutex::Autolock lock(mServiceLock);
387
388	int client_size = m_v_Clients.size();
389	wp<Client> client;
390	for (int i = 0; i < client_size; i++) {
391	client = m_v_Clients[i];
392	if (client != 0) {
393	sp<Client> currentClient = client.promote();
394	if (currentClient != 0) {
395	sp<ITvClient> currentTvClient(currentClient->getTvClient());
396	if (IInterface::asBinder(tvClient) == IInterface::asBinder(currentTvClient)) {
397	LOGD("TvService::connect X (pid %d, same client %p) is reconnecting...", callingPid, IInterface::asBinder(tvClient).get());
398	return currentClient;
399	} else {
400	//LOGD("TvService::connect X (pid %d, new client %p) rejected. "
401	// "(old pid %d, old client %p)", callingPid, tvClient->asBinder().get(), currentClient->mClientPid, currentTvClient->asBinder().get());
402	// if (kill(currentClient->mClientPid, 0) == -1 && errno == ESRCH) {
403	// LOGE("The old client is dead!");
404	// }
405	//return client;
406	//return currentClient;
407	continue;
408	}
409	} else {
410	LOGE("client (pid %d) have delete ------------not exist", callingPid);
411	client.clear();
412	m_v_Clients.removeAt(i);
413	client_size--;
414	continue;
415	}
416	}
417	}
418
419	if (mUsers > 0) {
420	LOGE("Still have client, rejected");
421	//return client;
422	}
423	LOGD("TvService::connect X 3");
424	// client = new Client(this, tvClient, callingPid);
425	//mClient = client;
426
427	sp<Client> newclient = new Client(this, tvClient, callingPid, mpTv);
428	m_v_Clients.add(newclient);
429
430	#if DEBUG_CLIENT_REFERENCES
431	//client->trackMe(true, true);
432	#endif
433	//mCurClient = client;
434	LOGD("TvService::connect X 4");
435	return newclient;
436	}
437
438	void TvService::removeClient(const sp<ITvClient> &tvClient)
439	{
440	int callingPid = getCallingPid();
441
442	Mutex::Autolock lock(mServiceLock);
443
444	int client_size = m_v_Clients.size();
445	wp<Client> client;
446	for (int i = 0; i < client_size; i++) {
447	client = m_v_Clients[i];
448	if (client != 0) {
449	sp<Client> currentClient = client.promote();
450	if (currentClient != 0) {
451	sp<ITvClient> currentTvClient(currentClient->getTvClient());
452	if (IInterface::asBinder(tvClient) == IInterface::asBinder(currentTvClient)) {
453	LOGD("find client , and remove it pid = %d, client = %p i=%d", callingPid, IInterface::asBinder(tvClient).get(), i);
454	client.clear();
455	LOGD("find client , and remove it pid1 ");
456	m_v_Clients.removeAt(i);
457	LOGD("find client , and remove it pid2 ");
458	break;
459	} else {
460	LOGW("removeClient (pid %d): mClient doesn't match!", callingPid);
461	continue;
462	}
463	} else {
464	LOGW("removeclient currentClient == 0 (pid %d)", callingPid);
465	client.clear();
466	m_v_Clients.removeAt(i);
467	client_size--;
468	continue;
469	}
470	} else {
471	LOGW("removeclient client == 0 (pid %d)", callingPid);
472	client.clear();
473	m_v_Clients.removeAt(i);
474	client_size--;
475	continue;
476	}
477	}
478
479	LOGD("removeClient (pid %d) done", callingPid);
480	}
481
482	void TvService::incUsers()
483	{
484	android_atomic_inc(&mUsers);
485	}
486
487	void TvService::decUsers()
488	{
489	android_atomic_dec(&mUsers);
490	}
491
492	TvService::Client::Client(const sp<TvService> &tvService, const sp<ITvClient> &tvClient, pid_t clientPid, CTv *pTv)
493	{
494	int callingPid = getCallingPid();
495	LOGD("Client::Client E (pid %d)", callingPid);
496	mTvService = tvService;
497	mTvClient = tvClient;
498	mClientPid = clientPid;
499	tvService->incUsers();
500	mpTv = pTv;
501	mIsStartTv = false;
502	}
503
504	status_t TvService::Client::checkPid()
505	{
506	int callingPid = getCallingPid();
507	if (mClientPid == callingPid)
508	return NO_ERROR;
509	LOGD("Attempt to use locked tv (client %p) from different process "
510	" (old pid %d, new pid %d)", IInterface::asBinder(getTvClient()).get(), mClientPid, callingPid);
511	return -EBUSY;
512	}
513
514	status_t TvService::Client::lock()
515	{
516	int callingPid = getCallingPid();
517	LOGD("lock from pid %d (mClientPid %d)", callingPid, mClientPid);
518	Mutex::Autolock _l(mLock);
519	// lock tv to this client if the the tv is unlocked
520	if (mClientPid == 0) {
521	mClientPid = callingPid;
522	return NO_ERROR;
523	}
524	// returns NO_ERROR if the client already owns the tv, -EBUSY otherwise
525	return checkPid();
526	}
527
528	status_t TvService::Client::unlock()
529	{
530	int callingPid = getCallingPid();
531	LOGD("unlock from pid %d (mClientPid %d)", callingPid, mClientPid);
532	Mutex::Autolock _l(mLock);
533	// allow anyone to use tv
534	status_t result = checkPid();
535	if (result == NO_ERROR) {
536	mClientPid = 0;
537	LOGD("clear mTvClient (pid %d)", callingPid);
538	// we need to remove the reference so that when app goes
539	// away, the reference count goes to 0.
540	mTvClient.clear();
541	}
542	return result;
543	}
544
545	status_t TvService::Client::connect(const sp<ITvClient> &client)
546	{
547	int callingPid = getCallingPid();
548	LOGD("Client::connect E (pid %d, client %p)", callingPid, IInterface::asBinder(client).get());
549	{
550	sp<ITvClient> oldClient;
551	{
552	Mutex::Autolock _l(mLock);
553	if (mClientPid != 0 && checkPid() != NO_ERROR) {
554	LOGW("Tried to connect to locked tv (old pid %d, new pid %d)", mClientPid, callingPid);
555	return -EBUSY;
556	}
557	oldClient = mTvClient;
558
559	// did the client actually change?
560	if ((mTvClient != NULL) && (IInterface::asBinder(client) == IInterface::asBinder(mTvClient))) {
561	LOGD("Connect to the same client");
562	return NO_ERROR;
563	}
564
565	mTvClient = client;
566	mClientPid = -1;
567	LOGD("Connect to the new client (pid %d, client %p)", callingPid, IInterface::asBinder(mTvClient).get());
568	}
569
570	}
571	mClientPid = callingPid;
572	return NO_ERROR;
573	}
574
575	TvService::Client::~Client()
576	{
577	if (mIsStartTv) mpTv->StopTvLock();
578
579	int callingPid = getCallingPid();
580	// tear down client
581	LOGD("Client::~Client E (pid %d, client %p)", callingPid, IInterface::asBinder(getTvClient()).get());
582	// make sure we tear down the hardware
583	mClientPid = callingPid;
584	disconnect();
585	LOGD("Client::~Client X (pid %d)", mClientPid);
586	}
587
588	void TvService::Client::disconnect()
589	{
590	int callingPid = getCallingPid();
591
592	LOGD("Client::disconnect() E (pid %d client %p)", callingPid, IInterface::asBinder(getTvClient()).get());
593
594	Mutex::Autolock lock(mLock);
595	if (mClientPid <= 0) {
596	LOGE("tv is unlocked (mClientPid = %d), don't tear down hardware", mClientPid);
597	return;
598	}
599	if (checkPid() != NO_ERROR) {
600	LOGE("Different client - don't disconnect");
601	return;
602	}
603
604	mTvService->removeClient(mTvClient);
605	mTvService->decUsers();
606
607	LOGD("Client::disconnect() X (pid %d)", callingPid);
608	}
609
610	status_t TvService::Client::createVideoFrame(const sp<IMemory> &share_mem, int iSourceMode, int iCapVideoLayerOnly)
611	{
612	LOGD(" mem=%d size=%d", share_mem->pointer() == NULL, share_mem->size());
613	LOGD("iSourceMode :%d iCapVideoLayerOnly = %d \n", iSourceMode, iCapVideoLayerOnly);
614	int Len = 0;
615	Mutex::Autolock lock(mLock);
616	mTvService->mCapVidFrame.InitVCap(share_mem);
617
618	if ((1 == iSourceMode) && (1 == iCapVideoLayerOnly)) {
619	mTvService->mCapVidFrame.CapMediaPlayerVideoLayerOnly(1920, 1080);
620	#if 0
621	mTvService->mCapVidFrame.SetVideoParameter(1920, 1080, 50);
622	mTvService->mCapVidFrame.VideoStart();
623	mTvService->mCapVidFrame.GetVideoData(&Len);
624	mTvService->mCapVidFrame.VideoStop();
625	#endif
626	} else if (2 == iSourceMode && 0 == iCapVideoLayerOnly) {
627	mTvService->mCapVidFrame.CapOsdAndVideoLayer(1920, 1080);
628	} else if (2 == iSourceMode && 1 == iCapVideoLayerOnly) {
629	mTvService->mCapVidFrame.CapMediaPlayerVideoLayerOnly(1920, 1080);
630	} else {
631	LOGD("=============== NOT SUPPORT=======================\n");
632	}
633	mTvService->mCapVidFrame.DeinitVideoCap();
634
635	return 0;
636	}
637
638	status_t TvService::Client::createSubtitle(const sp<IMemory> &share_mem)
639	{
640	mSubBmpBuf = share_mem;
641	LOGD("createSubtitle pid = %d, mem=%d size=%d", getCallingPid(), share_mem->pointer() == NULL, share_mem->size());
642	mpTv->setSubtitleBuffer((char *)mSubBmpBuf->pointer());
643	mTvService->mpSubClient = this;
644	//pSub = new CTvSubtitle(share_mem, this);
645	//pSub->run();
646	return 0;
647	}
648	status_t TvService::Client::processCmd(const Parcel &p, Parcel *r)
649	{
650	int tmp_i_buf[128] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
651	unsigned char tmp_uc_buf[512] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
652	unsigned char tmp_uc_buf2[512] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
653	int8_t tmp_int8_buf[512] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
654	static int source_input = 0;
655	int *data_ptr = NULL;
656
657	int cmd = p.readInt32();
658
659	LOGD("enter client=%d cmd=%d", getCallingPid(), cmd);
660	switch (cmd) {
661	// Tv function
662	case OPEN_TV: {
663	break;
664	}
665	case CLOSE_TV: {
666	int ret = mpTv->CloseTv();
667	r->writeInt32(ret);
668	break;
669	}
670	case START_TV: {
671	int mode = p.readInt32();
672	int ret = mpTv->StartTvLock();
673	//mTvService->mpStartTvClient = this;
674	mIsStartTv = true;
675	r->writeInt32(ret);
676	break;
677	}
678	case STOP_TV: {
679	int ret = mpTv->StopTvLock();
680	r->writeInt32(ret);
681	mIsStartTv = false;
682	break;
683	}
684	case GET_TV_STATUS: {
685	int ret = 0;
686	ret = (int)mpTv->GetTvStatus();
687	r->writeInt32(ret);
688	break;
689	}
690	case GET_LAST_SOURCE_INPUT: {
691	int ret = (int)mpTv->GetLastSourceInput();
692	r->writeInt32(ret);
693	break;
694	}
695	case GET_CURRENT_SOURCE_INPUT: {
696	int ret = (int)mpTv->GetCurrentSourceInputLock();
697	r->writeInt32(ret);
698	break;
699	}
700	case GET_CURRENT_SOURCE_INPUT_TYPE: {
701	int ret = 0;//(int)mpTv->Tvin_GetSrcInputType();
702	r->writeInt32(ret);
703	break;
704	}
705	case GET_CURRENT_SIGNAL_INFO: {
706	tvin_info_t siginfo = mpTv->GetCurrentSignalInfo();
707	int frame_rate = mpTv->getHDMIFrameRate();
708	r->writeInt32(siginfo.trans_fmt);
709	r->writeInt32(siginfo.fmt);
710	r->writeInt32(siginfo.status);
711	r->writeInt32(frame_rate);
712	break;
713	}
714	case IS_SOURCE_SWTICH_DONE: {
715	//int ret = mpTv->Tv_IsSourceSwtichDone();
716	r->writeInt32(0);
717	break;
718	}
719	case SET_SOURCE_INPUT: {
720	int sourceinput = p.readInt32();
721	tvin_window_pos_t win_pos;
722	LOGD(" SetSourceInput sourceId= %x", sourceinput);
723	source_input = sourceinput;
724	int ret = mpTv->SetSourceSwitchInput((tv_source_input_t)sourceinput);
725	r->writeInt32(ret);
726	break;
727	}
728	case DO_SUSPEND: {
729	int type = p.readInt32();
730	int ret = mpTv->DoSuspend(type);
731	r->writeInt32(ret);
732	break;
733	}
734	case DO_RESUME: {
735	int type = p.readInt32();
736	int ret = mpTv->DoResume(type);
737	r->writeInt32(ret);
738	break;
739	}
740	case RUN_ADC_AUTO_CALIBRATION: {
741	// int ret = mpTv->Tv_RunADCAutoCalibration();
742	// r->writeInt32(ret);
743	break;
744	}
745	case IS_DVI_SIGNAL: {
746	int ret = mpTv->IsDVISignal();
747	r->writeInt32(ret);
748	break;
749	}
750	case IS_VGA_TIMEING_IN_HDMI: {
751	int ret = mpTv->isVgaFmtInHdmi();
752	r->writeInt32(ret);
753	break;
754	}
755	case GET_VIDEO_PATH_STATUS: {
756	int path_type = p.readInt32();
757	int ret = 0;//(int)mpTv->Tvin_CheckPathActive((tv_path_type_t)path_type);
758	r->writeInt32(ret);
759	break;
760	}
761	case GET_VIDEO_STREAM_STATUS: {
762	// int ret = (int)mpTv->Tvin_CheckVideoStreamStatus();
763	// r->writeInt32(ret);
764	break;
765	}
766	case GET_FIRST_START_SWITCH_TYPE: {
767	//int tmp_val = 0;
768	//int ret = (int)mpTv->Tv_GetFirstStartSwitchType(&tmp_val);
769	//r->writeInt32(ret);
770	r->writeInt32(1);
771	break;
772	}
773	case SET_PREVIEW_WINDOW: {
774	tvin_window_pos_t win_pos;
775	win_pos.x1 = p.readInt32();
776	win_pos.y1 = p.readInt32();
777	win_pos.x2 = p.readInt32();
778	win_pos.y2 = p.readInt32();
779	int ret = (int)mpTv->SetPreviewWindow(win_pos);
780	r->writeInt32(ret);
781	break;
782	}
783
784	case SET_VIDEO_DISABLE: {
785	int value = p.readInt32();
786	int ret = 0;//(int)mpTv->Tv_SetVideoDisable(value);
787	r->writeInt32(ret);
788	break;
789	}
790
791	case GET_SOURCE_CONNECT_STATUS: {
792	int source_input = p.readInt32();
793	int ret = mpTv->GetSourceConnectStatus((tv_source_input_t)source_input);
794	r->writeInt32(ret);
795	break;
796	}
797	//Tv function END
798
799	//VGA
800	case RUN_VGA_AUTO_ADJUST: {
801	//int ret = mpTv->Tv_RunVGAAutoAdjust();
802	int ret = 0;
803	r->writeInt32(ret);
804	break;
805	}
806	case GET_VGA_AUTO_ADJUST_STATUS: {
807	// int fmt = p.readInt32();
808	//int ret = (int) mpTv->Tv_GetVagAutoAdjustStatus();
809	int ret = 0;
810	r->writeInt32(ret);
811	break;
812	}
813	case IS_VGA_AUTO_ADJUST_DONE: {
814	int fmt = p.readInt32();
815	int ret = 0;//mpTv->Tv_IsVGAAutoAdjustDone((tvin_sig_fmt_t)fmt);
816	r->writeInt32(ret);
817	break;
818	}
819	case SET_VGA_HPOS: {
820	// int value = p.readInt32();
821	// int fmt = p.readInt32();
822	//int ret = mpTv->Tv_SetVGAHPos(value, (tvin_sig_fmt_t)fmt);
823	int ret = 0;
824	r->writeInt32(ret);
825	break;
826	}
827	case GET_VGA_HPOS: {
828	// int fmt = p.readInt32();
829	// int ret = mpTv->Tv_GetVGAHPos((tvin_sig_fmt_t)fmt);
830	int ret = 0;
831	r->writeInt32(ret);
832	break;
833	}
834
835	case SET_VGA_VPOS: {
836	// int value = p.readInt32();
837	// int fmt = p.readInt32();
838	// int ret = mpTv->Tv_SetVGAVPos(value, (tvin_sig_fmt_t)fmt);
839	int ret = 0;
840	r->writeInt32(ret);
841	break;
842	}
843	case GET_VGA_VPOS: {
844	// int fmt = p.readInt32();
845	// int ret = mpTv->Tv_GetVGAVPos((tvin_sig_fmt_t)fmt);
846	int ret = 0;
847	r->writeInt32(ret);
848	break;
849	}
850
851	case SET_VGA_CLOCK: {
852	// int value = p.readInt32();
853	// int fmt = p.readInt32();
854	// int ret = mpTv->Tv_SetVGAClock(value, (tvin_sig_fmt_t)fmt);
855	int ret = 0;
856	r->writeInt32(ret);
857	break;
858	}
859	case GET_VGA_CLOCK: {
860	// int fmt = p.readInt32();
861	// int ret = mpTv->Tv_GetVGAClock((tvin_sig_fmt_t)fmt);
862	int ret = 0;
863	r->writeInt32(ret);
864	break;
865	}
866
867	case SET_VGA_PHASE: {
868	// int value = p.readInt32();
869	// int fmt = p.readInt32();
870	// int ret = mpTv->Tv_SetVGAPhase(value, (tvin_sig_fmt_t)fmt);
871	int ret = 0;
872	r->writeInt32(ret);
873	break;
874	}
875	case GET_VGA_PHASE: {
876	// int fmt = p.readInt32();
877	// int ret = mpTv->Tv_GetVGAPhase((tvin_sig_fmt_t)fmt);
878	int ret = 0;
879	r->writeInt32(ret);
880	break;
881	}
882	case SET_VGA_AJUST_PARA: {
883	tvafe_vga_parm_t adjparam;
884	adjparam.clk_step = p.readInt32();
885	adjparam.phase = p.readInt32();
886	adjparam.hpos_step = p.readInt32();
887	adjparam.vpos_step = p.readInt32();
888	adjparam.vga_in_clean = p.readInt32();
889	int fmt = p.readInt32();
890	int ret = 0/*SetVGAAjustPara(adjparam, (tvin_sig_fmt_t)fmt)*/;
891	r->writeInt32(ret);
892	break;
893	}
894	case GET_VGA_AJUST_PARA: {
895	tvafe_vga_parm_t adjparam;
896	int fmt = p.readInt32();
897	int ret = 0/*GetVGAAjustPara(&adjparam, (tvin_sig_fmt_t)fmt)*/;
898	r->writeInt32(adjparam.clk_step);
899	r->writeInt32(adjparam.phase);
900	r->writeInt32(adjparam.hpos_step);
901	r->writeInt32(adjparam.vpos_step);
902	r->writeInt32(adjparam.vga_in_clean);
903	r->writeInt32(ret);
904	break;
905	}
906	case SET_VGAPARAM_DEFAULT: {
907	// int ret = (int)mpTv->TvinResetVgaAjustParam();
908	// r->writeInt32(ret);
909	break;
910	}
911	// VGA END
912
913	// 3D
914
915	case SET_3D_MODE: {
916	int mode = p.readInt32();
917	int ret = mpTv->Tv_Set3DMode((VIDEO_3D_MODE_T)mode);
918	r->writeInt32(ret);
919	break;
920	}
921	case GET_3D_MODE: {
922	int ret = (int)mpTv->Tv_Get3DMode();
923	r->writeInt32(ret);
924	break;
925	}
926	case SET_3D_LR_SWITH: {
927	int on_off = p.readInt32();
928	//int status = p.readInt32();
929	int ret = mpTv->Tv_Set3DLRSwith(on_off);
930	r->writeInt32(ret);
931	break;
932	}
933	case GET_3D_LR_SWITH: {
934	int ret = mpTv->Tv_Get3DLRSwith();
935	r->writeInt32(ret);
936	break;
937	}
938	case SET_3D_TO_2D_MODE: {
939	int mode = p.readInt32();
940	//int status = p.readInt32();
941	int ret = mpTv->Tv_Set3DTo2DMode(mode);
942	r->writeInt32(ret);
943	break;
944	}
945	case GET_3D_TO_2D_MODE: {
946	int ret = mpTv->Tv_Get3DTo2DMode();
947	r->writeInt32(ret);
948	break;
949	}
950	case SET_3D_DEPTH: {
951	int value = p.readInt32();
952	int ret = mpTv->Tv_Set3DDepth(value);
953	r->writeInt32(ret);
954	break;
955	}
956	case GET_3D_DEPTH: {
957	int ret = mpTv->GetSave3DDepth();
958	r->writeInt32(ret);
959	break;
960	}
961	// 3D END
962
963	// PQ
964	case SET_BRIGHTNESS: {
965	int brightness = p.readInt32();
966	int source_type = p.readInt32();
967	int is_save = p.readInt32();
968	int ret = mpTv->Tv_SetBrightness(brightness, (tv_source_input_type_t)source_type, is_save);
969	r->writeInt32(ret);
970	break;
971	}
972	case GET_BRIGHTNESS: {
973	int source_type = p.readInt32();
974	LOGD("GET_BRIGHTNESS------------=%d", source_type);
975	int ret = mpTv->Tv_GetBrightness((tv_source_input_type_t)source_type);
976	r->writeInt32(ret);
977	break;
978	}
979	case SAVE_BRIGHTNESS: {
980	int brightness = p.readInt32();
981	int source_type = p.readInt32();
982	int ret = mpTv->Tv_SaveBrightness(brightness, (tv_source_input_type_t)source_type);
983	r->writeInt32(ret);
984	break;
985	}
986
987	case SET_CONTRAST: {
988	int contrast = p.readInt32();
989	int source_type = p.readInt32();
990	int is_save = p.readInt32();
991	int ret = mpTv->Tv_SetContrast(contrast, (tv_source_input_type_t)source_type, is_save);
992	r->writeInt32(ret);
993	break;
994	}
995	case GET_CONTRAST: {
996	int source_type = p.readInt32();
997	int ret = mpTv->Tv_GetContrast((tv_source_input_type_t)source_type);
998	r->writeInt32(ret);
999	break;
1000	}
1001	case SAVE_CONTRAST: {
1002	int contrast = p.readInt32();
1003	int source_type = p.readInt32();
1004	int ret = mpTv->Tv_SaveContrast(contrast, (tv_source_input_type_t)source_type);
1005	r->writeInt32(ret);
1006	break;
1007	}
1008	case SET_SATUATION: {
1009	int satuation = p.readInt32();
1010	int source_type = p.readInt32();
1011	int fmt = p.readInt32();
1012	int is_save = p.readInt32();
1013	int ret = mpTv->Tv_SetSaturation(satuation, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt, is_save);
1014	r->writeInt32(ret);
1015	break;
1016	}
1017	case GET_SATUATION: {
1018	int source_type = p.readInt32();
1019	int ret = mpTv->Tv_GetSaturation((tv_source_input_type_t)source_type);
1020	r->writeInt32(ret);
1021	break;
1022	}
1023	case SAVE_SATUATION: {
1024	int satuation = p.readInt32();
1025	int source_type = p.readInt32();
1026	int ret = mpTv->Tv_SaveSaturation(satuation, (tv_source_input_type_t)source_type);
1027	r->writeInt32(ret);
1028	break;
1029	}
1030	case SET_HUE: {
1031	int hue = p.readInt32();
1032	int source_type = p.readInt32();
1033	int fmt = p.readInt32();
1034	int is_save = p.readInt32();
1035	int ret = mpTv->Tv_SetHue(hue, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt, is_save);
1036	r->writeInt32(ret);
1037	break;
1038	}
1039	case GET_HUE: {
1040	int source_type = p.readInt32();
1041	int ret = mpTv->Tv_GetHue((tv_source_input_type_t)source_type);
1042	r->writeInt32(ret);
1043	break;
1044	}
1045	case SAVE_HUE: {
1046	int hue = p.readInt32();
1047	int source_type = p.readInt32();
1048	int ret = mpTv->Tv_SaveHue(hue, (tv_source_input_type_t)source_type);
1049	r->writeInt32(ret);
1050	break;
1051	}
1052	case SET_SCENEMODE: {
1053	int mode = p.readInt32();
1054	int is_save = p.readInt32();
1055	int ret = 0;//mpTv->Tv_SetSceneMode((vpp_scene_mode_t)mode,is_save);
1056	r->writeInt32(ret);
1057	break;
1058	}
1059	case GET_SCENEMODE: {
1060	int ret = 0;//(int)mpTv->Tv_GetSceneMode();
1061	r->writeInt32(ret);
1062	break;
1063	}
1064	case SET_PQMODE: {
1065	int mode = p.readInt32();
1066	int source_type = p.readInt32();
1067	int is_save = p.readInt32();
1068	int ret = mpTv->Tv_SetPQMode((vpp_picture_mode_t)mode, (tv_source_input_type_t)source_type, is_save);
1069	r->writeInt32(ret);
1070	break;
1071	}
1072	case GET_PQMODE: {
1073	int source_type = p.readInt32();
1074	int ret = (int)mpTv->Tv_GetPQMode((tv_source_input_type_t)source_type);
1075	r->writeInt32(ret);
1076	break;
1077	}
1078	case SAVE_PQMODE: {
1079	int mode = p.readInt32();
1080	int source_type = p.readInt32();
1081	int ret = mpTv->Tv_SavePQMode((vpp_picture_mode_t)mode, (tv_source_input_type_t)source_type);
1082	r->writeInt32(ret);
1083	break;
1084	}
1085	case SET_SHARPNESS: {
1086	int value = p.readInt32();
1087	int source_type = p.readInt32();
1088	int en = p.readInt32();
1089	int status_3d = p.readInt32();
1090	int is_save = p.readInt32();
1091	int ret = mpTv->Tv_SetSharpness(value, (tv_source_input_type_t)source_type, en, is_save);
1092	r->writeInt32(ret);
1093	break;
1094	}
1095	case GET_SHARPNESS: {
1096	int source_type = p.readInt32();
1097	int ret = mpTv->Tv_GetSharpness((tv_source_input_type_t)source_type);
1098	r->writeInt32(ret);
1099	break;
1100	}
1101	case SAVE_SHARPNESS: {
1102	int value = p.readInt32();
1103	int source_type = p.readInt32();
1104	int is_save = p.readInt32();
1105	int ret = mpTv->Tv_SaveSharpness(value, (tv_source_input_type_t)source_type);
1106	r->writeInt32(ret);
1107	break;
1108	}
1109	case SET_BACKLIGHT: {
1110	int value = p.readInt32();
1111	int source_type = p.readInt32();
1112	int is_save = p.readInt32();
1113	int ret = mpTv->Tv_SetBacklight(value, (tv_source_input_type_t)source_type, is_save);
1114	r->writeInt32(ret);
1115	break;
1116	}
1117	case GET_BACKLIGHT: {
1118	int source_type = p.readInt32();
1119	int ret = mpTv->Tv_GetBacklight((tv_source_input_type_t)source_type);
1120	r->writeInt32(ret);
1121	break;
1122	}
1123	case SAVE_BACKLIGHT: {
1124	int value = p.readInt32();
1125	int source_type = p.readInt32();
1126	int ret = mpTv->Tv_SaveBacklight ( value, (tv_source_input_type_t)source_type );
1127	r->writeInt32(ret);
1128	break;
1129	}
1130	case SET_BACKLIGHT_SWITCH: {
1131	int value = p.readInt32();
1132	int ret = mpTv->Tv_SetBacklight_Switch(value);
1133	r->writeInt32(ret);
1134	break;
1135	}
1136	case GET_BACKLIGHT_SWITCH: {
1137	int ret = mpTv->Tv_GetBacklight_Switch();
1138	r->writeInt32(ret);
1139	break;
1140	}
1141	case SET_COLOR_TEMPERATURE: {
1142	int mode = p.readInt32();
1143	int source_type = p.readInt32();
1144	int is_save = p.readInt32();
1145	int ret = mpTv->Tv_SetColorTemperature((vpp_color_temperature_mode_t)mode, (tv_source_input_type_t)source_type, is_save);
1146	r->writeInt32(ret);
1147	break;
1148	}
1149	case GET_COLOR_TEMPERATURE: {
1150	int source_type = p.readInt32();
1151	int ret = mpTv->Tv_GetColorTemperature((tv_source_input_type_t)source_type);
1152	r->writeInt32(ret);
1153	break;
1154	}
1155	case SAVE_COLOR_TEMPERATURE: {
1156	int mode = p.readInt32();
1157	int source_type = p.readInt32();
1158	int ret = mpTv->Tv_SaveColorTemperature ( (vpp_color_temperature_mode_t)mode, (tv_source_input_type_t)source_type );
1159	r->writeInt32(ret);
1160	break;
1161	}
1162	case SET_DISPLAY_MODE: {
1163	int mode = p.readInt32();
1164	int source_type = p.readInt32();
1165	int fmt = p.readInt32();
1166	int is_save = p.readInt32();
1167	int ret = mpTv->Tv_SetDisplayMode((vpp_display_mode_t)mode, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt, is_save);
1168	r->writeInt32(ret);
1169	break;
1170	}
1171	case GET_DISPLAY_MODE: {
1172	int source_type = p.readInt32();
1173	int ret = (int)mpTv->Tv_GetDisplayMode((tv_source_input_type_t)source_type);
1174	r->writeInt32(ret);
1175	break;
1176	}
1177	case SAVE_DISPLAY_MODE: {
1178	int mode = p.readInt32();
1179	int source_type = p.readInt32();
1180	int ret = mpTv->Tv_SaveDisplayMode((vpp_display_mode_t)mode, (tv_source_input_type_t)source_type);
1181	r->writeInt32(ret);
1182	break;
1183	}
1184	case SET_NOISE_REDUCTION_MODE: {
1185	int mode = p.readInt32();
1186	int source_type = p.readInt32();
1187	int is_save = p.readInt32();
1188	int ret = mpTv->Tv_SetNoiseReductionMode((vpp_noise_reduction_mode_t)mode, (tv_source_input_type_t)source_type, is_save);
1189	r->writeInt32(ret);
1190	break;
1191	}
1192	case GET_NOISE_REDUCTION_MODE: {
1193	int source_type = p.readInt32();
1194	int ret = mpTv->Tv_GetNoiseReductionMode((tv_source_input_type_t)source_type);
1195	r->writeInt32(ret);
1196	break;
1197	}
1198	case SAVE_NOISE_REDUCTION_MODE: {
1199	int mode = p.readInt32();
1200	int source_type = p.readInt32();
1201	int ret = mpTv->Tv_SaveNoiseReductionMode((vpp_noise_reduction_mode_t)mode, (tv_source_input_type_t)source_type);
1202	r->writeInt32(ret);
1203	break;
1204	}
1205	case VPP_SPLIT_SCREEN_EFFECT: {
1206	int mode = p.readInt32();
1207	int width = p.readInt32();
1208	int reverse = p.readInt32();
1209	int ret = mpTv->Tv_SplitScreenEffect(mode, width, reverse);
1210	r->writeInt32(ret);
1211	break;
1212	}
1213	// PQ END
1214
1215	// FACTORY
1216	case FACTORY_SETPQMODE_BRIGHTNESS: {
1217	int source_type = p.readInt32();
1218	int pq_mode = p.readInt32();
1219	int brightness = p.readInt32();
1220	int ret = mpTv->Tv_FactorySetPQMode_Brightness(source_type, pq_mode, brightness);
1221	r->writeInt32(ret);
1222	break;
1223	}
1224	case FACTORY_GETPQMODE_BRIGHTNESS: {
1225	int source_type = p.readInt32();
1226	int pq_mode = p.readInt32();
1227	int ret = mpTv->Tv_FactoryGetPQMode_Brightness(source_type, pq_mode);
1228	r->writeInt32(ret);
1229	break;
1230	}
1231	case FACTORY_SETPQMODE_CONTRAST: {
1232	int source_type = p.readInt32();
1233	int pq_mode = p.readInt32();
1234	int contrast = p.readInt32();
1235	int ret = mpTv->Tv_FactorySetPQMode_Contrast(source_type, pq_mode, contrast);
1236	r->writeInt32(ret);
1237	break;
1238	}
1239	case FACTORY_GETPQMODE_CONTRAST: {
1240	int source_type = p.readInt32();
1241	int pq_mode = p.readInt32();
1242	int ret = mpTv->Tv_FactoryGetPQMode_Contrast(source_type, pq_mode);
1243	r->writeInt32(ret);
1244	break;
1245	}
1246	case FACTORY_SETPQMODE_SATURATION: {
1247	int source_type = p.readInt32();
1248	int pq_mode = p.readInt32();
1249	int saturation = p.readInt32();
1250	int ret = mpTv->Tv_FactorySetPQMode_Saturation(source_type, pq_mode, saturation);
1251	r->writeInt32(ret);
1252	break;
1253	}
1254	case FACTORY_GETPQMODE_SATURATION: {
1255	int source_type = p.readInt32();
1256	int pq_mode = p.readInt32();
1257	int ret = mpTv->Tv_FactoryGetPQMode_Saturation(source_type, pq_mode);
1258	r->writeInt32(ret);
1259	break;
1260	}
1261	case FACTORY_SETPQMODE_HUE: {
1262	int source_type = p.readInt32();
1263	int pq_mode = p.readInt32();
1264	int hue = p.readInt32();
1265	int ret = mpTv->Tv_FactorySetPQMode_Hue(source_type, pq_mode, hue);
1266	r->writeInt32(ret);
1267	break;
1268	}
1269	case FACTORY_GETPQMODE_HUE: {
1270	int source_type = p.readInt32();
1271	int pq_mode = p.readInt32();
1272	int ret = mpTv->Tv_FactoryGetPQMode_Hue(source_type, pq_mode);
1273	r->writeInt32(ret);
1274	break;
1275	}
1276	case FACTORY_SETPQMODE_SHARPNESS: {
1277	int source_type = p.readInt32();
1278	int pq_mode = p.readInt32();
1279	int sharpness = p.readInt32();
1280	int ret = mpTv->Tv_FactorySetPQMode_Sharpness(source_type, pq_mode, sharpness);
1281	r->writeInt32(ret);
1282	break;
1283	}
1284	case FACTORY_GETPQMODE_SHARPNESS: {
1285	int source_type = p.readInt32();
1286	int pq_mode = p.readInt32();
1287	int ret = mpTv->Tv_FactoryGetPQMode_Sharpness(source_type, pq_mode);
1288
1289	r->writeInt32(ret);
1290	break;
1291	}
1292	case FACTORY_SETTESTPATTERN: {
1293	int pattern = p.readInt32();
1294	int ret = mpTv->Tv_FactorySetTestPattern(pattern);
1295	r->writeInt32(ret);
1296	break;
1297	}
1298	case FACTORY_GETTESTPATTERN: {
1299	int ret = mpTv->Tv_FactoryGetTestPattern();
1300	r->writeInt32(ret);
1301	break;
1302	}
1303	case FACTORY_SETPATTERN_YUV: {
1304	int blend = p.readInt32();
1305	int y = p.readInt32();
1306	int u = p.readInt32();
1307	int v = p.readInt32();
1308	int ret = mpTv->Tv_FactorySetScreenColor(blend, y, u, v);
1309	r->writeInt32(ret);
1310	break;
1311	}
1312	case FACTORY_RESETPQMODE: {
1313	int ret = mpTv->Tv_FactoryResetPQMode();
1314	r->writeInt32(ret);
1315	break;
1316	}
1317	case FACTORY_RESETCOLORTEMP: {
1318	int ret = mpTv->Tv_FactoryResetColorTemp();
1319	r->writeInt32(ret);
1320	break;
1321	}
1322	case FACTORY_RESETPAMAMSDEFAULT: {
1323	int ret = mpTv->Tv_FactorySetParamsDefault();
1324	r->writeInt32(ret);
1325	break;
1326	}
1327	case FACTORY_SETDDRSSC: {
1328	int setp = p.readInt32();
1329	int ret = mpTv->Tv_FactorySetDDRSSC(setp);
1330	r->writeInt32(ret);
1331	break;
1332	}
1333	case FACTORY_GETDDRSSC: {
1334	int ret = mpTv->Tv_FactoryGetDDRSSC();
1335	r->writeInt32(ret);
1336	break;
1337	}
1338	case FACTORY_SETLVDSSSC: {
1339	int setp = p.readInt32();
1340	int ret = mpTv->Tv_FactorySetLVDSSSC(setp);
1341	r->writeInt32(ret);
1342	break;
1343	}
1344	case FACTORY_GETLVDSSSC: {
1345	int ret = mpTv->Tv_FactoryGetLVDSSSC();
1346	r->writeInt32(ret);
1347	break;
1348	}
1349	case FACTORY_SETNOLINEPARAMS: {
1350	noline_params_t params;
1351	int noline_params_type = p.readInt32();
1352	int source_type = p.readInt32();
1353	params.osd0 = p.readInt32();
1354	params.osd25 = p.readInt32();
1355	params.osd50 = p.readInt32();
1356	params.osd75 = p.readInt32();
1357	params.osd100 = p.readInt32();
1358	int ret = mpTv->Tv_FactorySetNolineParams(noline_params_type, source_type, params);
1359	r->writeInt32(ret);
1360	break;
1361	}
1362	case FACTORY_GETNOLINEPARAMS: {
1363	int noline_params_type = p.readInt32();
1364	int source_type = p.readInt32();
1365	noline_params_t params = mpTv->Tv_FactoryGetNolineParams(noline_params_type, source_type);
1366	r->writeInt32(params.osd0);
1367	r->writeInt32(params.osd25);
1368	r->writeInt32(params.osd50);
1369	r->writeInt32(params.osd75);
1370	r->writeInt32(params.osd100);
1371	break;
1372	}
1373	case FACTORY_SETOVERSCAN: {
1374	tvin_cutwin_t cutwin_t;
1375	int source_type = p.readInt32();
1376	int fmt = p.readInt32();
1377	int status_3d = p.readInt32();
1378	int trans_fmt = p.readInt32();
1379	cutwin_t.hs = p.readInt32();
1380	cutwin_t.he = p.readInt32();
1381	cutwin_t.vs = p.readInt32();
1382	cutwin_t.ve = p.readInt32();
1383	int ret = mpTv->Tv_FactorySetOverscan(source_type, fmt, status_3d, trans_fmt, cutwin_t);
1384	r->writeInt32(ret);
1385	break;
1386	}
1387	case FACTORY_GETOVERSCAN: {
1388	int source_type = p.readInt32();
1389	int fmt = p.readInt32();
1390	int status_3d = p.readInt32();
1391	int trans_fmt = p.readInt32();
1392	tvin_cutwin_t cutwin_t = mpTv->Tv_FactoryGetOverscan(source_type, fmt, status_3d, trans_fmt);
1393	r->writeInt32(cutwin_t.hs);
1394	r->writeInt32(cutwin_t.he);
1395	r->writeInt32(cutwin_t.vs);
1396	r->writeInt32(cutwin_t.ve);
1397	break;
1398	}
1399	case DELETE_PARAM_PQ_DB: {
1400	int tmpRet = mpTv->Tv_ReplacePqDb();
1401	r->writeInt32(tmpRet);
1402	}
1403	case REPLACE_PARAM_PQ_DB: {
1404	int tmpRet;
1405	String16 tmp_str16;
1406	String8 value_str;
1407
1408	tmp_str16 = p.readString16();
1409	value_str = String8(tmp_str16);
1410
1411	tmpRet = mpTv->Tv_ReplacePqDb(value_str.string());
1412	r->writeInt32(tmpRet);
1413	break;
1414	}
1415	case FACTORY_SET_OUT_DEFAULT: {
1416	int ret = 0;
1417	ret = mpTv->Tv_SSMFacRestoreDefaultSetting();
1418	r->writeInt32(ret);
1419	break;
1420	}
1421	case FACTORY_GETGLOBALOGO_RGAIN: {
1422	int ret = 0;
1423	r->writeInt32(ret);
1424	break;
1425	}
1426	case FACTORY_GETGLOBALOGO_GGAIN: {
1427	int ret = 0;
1428	r->writeInt32(ret);
1429	break;
1430	}
1431	case FACTORY_GETGLOBALOGO_BGAIN: {
1432	int ret = 0;
1433	r->writeInt32(ret);
1434	break;
1435	}
1436	case FACTORY_GETGLOBALOGO_ROFFSET: {
1437	int ret = 0;
1438	r->writeInt32(ret);
1439	break;
1440	}
1441	case FACTORY_GETGLOBALOGO_GOFFSET: {
1442	int ret = 0;
1443	r->writeInt32(ret);
1444	break;
1445	}
1446	case FACTORY_GETGLOBALOGO_BOFFSET: {
1447	int ret = 0;
1448	r->writeInt32(ret);
1449	break;
1450	}
1451	case FACTORY_SETGLOBALOGO_RGAIN: {
1452	int ret = 0;
1453	r->writeInt32(ret);
1454	break;
1455	}
1456	case FACTORY_SETGLOBALOGO_GGAIN: {
1457	int p1 = p.readInt32();
1458	int ret = 0;
1459	r->writeInt32(ret);
1460	break;
1461	}
1462	case FACTORY_SETGLOBALOGO_BGAIN: {
1463	int p1 = p.readInt32();
1464	int ret = 0;
1465	r->writeInt32(ret);
1466	break;
1467	}
1468	case FACTORY_SETGLOBALOGO_ROFFSET: {
1469	int p1 = p.readInt32();
1470	int ret = 0;
1471	r->writeInt32(ret);
1472	break;
1473	}
1474	case FACTORY_SETGLOBALOGO_GOFFSET: {
1475	int p1 = p.readInt32();
1476	int ret = 0;
1477	r->writeInt32(ret);
1478	break;
1479	}
1480	case FACTORY_SETGLOBALOGO_BOFFSET: {
1481	int p1 = p.readInt32();
1482	int ret = 0;
1483	r->writeInt32(ret);
1484	break;
1485	}
1486	case FACTORY_CLEAN_ALL_TABLE_FOR_PROGRAM: {
1487	int ret = mpTv->ClearAnalogFrontEnd();
1488	mpTv->clearDbAllProgramInfoTable();
1489	r->writeInt32(ret);
1490	break;
1491	}
1492	case FACTORY_SETBACKLIGHT_PWM_FREQUENCY: {
1493	int value = p.readInt32();
1494	int ret = 0;//mpTv->GetVpp().Tv_FactorySetBacklightPWM_Frequency(value);
1495	r->writeInt32(ret);
1496	break;
1497	}
1498	case FACTORY_GETBACKLIGHT_PWM_FREQUENCY: {
1499	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetBacklightPWM_Frequency();
1500	r->writeInt32(ret);
1501	break;
1502	}
1503	case FACTORY_SETBACKLIGHT_SWITCH_STATUS: {
1504	int value = p.readInt32();
1505	int ret = 0;//mpTv->GetVpp().Tv_FactorySetBacklight_Switch_status(value);
1506	r->writeInt32(ret);
1507	break;
1508	}
1509	case FACTORY_GETBACKLIGHT_SWITCH_STATUS: {
1510	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetBacklight_Switch_status();
1511	r->writeInt32(ret);
1512	break;
1513	}
1514	case FACTORY_SETBACKLIGHT_PWM_DUTY: {
1515	int value = p.readInt32();
1516	int ret = 0;//mpTv->GetVpp().Tv_FactorySetBacklightPWM_Duty(value);
1517	r->writeInt32(ret);
1518	break;
1519	}
1520	case FACTORY_GETBACKLIGHT_PWM_DUTY: {
1521	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetBacklightPWM_Duty();
1522	r->writeInt32(ret);
1523	break;
1524	}
1525
1526	case FACTORY_SETLVDS_COLOR_DEPTH: {
1527	int value = p.readInt32();
1528	int ret = 0;//mpTv->GetVpp().Tv_FactorySetLVDS_ColorDepth(value);
1529	r->writeInt32(ret);
1530	break;
1531	}
1532	case FACTORY_GETLVDS_COLOR_DEPTH: {
1533	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetLVDS_ColorDepth();
1534	r->writeInt32(ret);
1535	break;
1536	}
1537	case FACTORY_SETLVDS_DITHER_STATUS: {
1538	int value = p.readInt32();
1539	int ret = 0;//mpTv->GetVpp().Tv_FactorySetLVDS_ColorDither_status(value);
1540	r->writeInt32(ret);
1541	break;
1542	}
1543	case FACTORY_GETLVDS_DITHER_STATUS: {
1544	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetLVDS_ColorDither_status();
1545	r->writeInt32(ret);
1546	break;
1547	}
1548	case FACTORY_SETLVDS_MAPPING_STATUS: {
1549	int value = p.readInt32();
1550	int ret = 0;//mpTv->GetVpp().Tv_FactorySetLVDS_Mapping_status(value);
1551	r->writeInt32(ret);
1552	break;
1553	}
1554	case FACTORY_GETLVDS_MAPPING_STATUS: {
1555	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetLVDS_Mapping_status();
1556	r->writeInt32(ret);
1557	break;
1558	}
1559	case FACTORY_SETLVDS_PORT_SWAP_STATUS: {
1560	int value = p.readInt32();
1561	int ret = 0;//mpTv->GetVpp().Tv_FactorySetLVDS_PortSwap_status(value);
1562	r->writeInt32(ret);
1563	break;
1564	}
1565	case FACTORY_GETLVDS_PORT_SWAP_STATUS: {
1566	int ret = 0;//mpTv->GetVpp().Tv_FactoryGetLVDS_PortSwap_status();
1567	r->writeInt32(ret);
1568	break;
1569	}
1570	// FACTORY END
1571
1572	// AUDIO
1573	// AUDIO MUTE
1574	case SET_AUDIO_MUTEKEY_STATUS: {
1575	int status = p.readInt32();
1576	int ret = mpTv->SetAudioMuteForSystem(status);
1577	r->writeInt32(ret);
1578	break;
1579	}
1580	case GET_AUDIO_MUTEKEY_STATUS: {
1581	int ret = mpTv->GetAudioMuteForSystem();
1582	r->writeInt32(ret);
1583	break;
1584	}
1585	case SET_AUDIO_FORCE_MUTE_STATUS: {
1586	int status = p.readInt32();
1587	int ret = 0;//pTv->getTvAudio().AudioSetForceMuteStatus(status);
1588	r->writeInt32(ret);
1589	break;
1590	}
1591	case GET_AUDIO_FORCE_MUTE_STATUS: {
1592	int ret = 0;//mpTv->AudioGetForceMuteStatus();
1593	r->writeInt32(ret);
1594	break;
1595	}
1596	case SET_AUDIO_AVOUT_MUTE_STATUS: {
1597	int status = p.readInt32();
1598	int ret = mpTv->SetAudioAVOutMute(status);
1599	r->writeInt32(ret);
1600	break;
1601	}
1602	case GET_AUDIO_AVOUT_MUTE_STATUS: {
1603	int ret = mpTv->GetAudioAVOutMute();
1604	r->writeInt32(ret);
1605	break;
1606	}
1607	case SET_AUDIO_SPDIF_MUTE_STATUS: {
1608	int status = p.readInt32();
1609	int ret = mpTv->SetAudioSPDIFMute(status);
1610	r->writeInt32(ret);
1611	break;
1612	}
1613	case GET_AUDIO_SPDIF_MUTE_STATUS: {
1614	int ret = mpTv->GetAudioSPDIFMute();
1615	r->writeInt32(ret);
1616	break;
1617	}
1618	// AUDIO MASTER VOLUME
1619	case SET_AUDIO_MASTER_VOLUME: {
1620	int vol = p.readInt32();
1621	int ret = mpTv->SetAudioMasterVolume(vol);
1622	r->writeInt32(ret);
1623	break;
1624	}
1625	case GET_AUDIO_MASTER_VOLUME: {
1626	int ret = mpTv->GetAudioMasterVolume();
1627	r->writeInt32(ret);
1628	break;
1629	}
1630	case SAVE_CUR_AUDIO_MASTER_VOLUME: {
1631	int vol = p.readInt32();
1632	int ret = mpTv->SaveCurAudioMasterVolume(vol);
1633	r->writeInt32(ret);
1634	break;
1635	}
1636	case GET_CUR_AUDIO_MASTER_VOLUME: {
1637	int ret = mpTv->GetCurAudioMasterVolume();
1638	r->writeInt32(ret);
1639	break;
1640	}
1641	//AUDIO BALANCE
1642	case SET_AUDIO_BALANCE: {
1643	int vol = p.readInt32();
1644	int ret = mpTv->SetAudioBalance(vol);
1645	r->writeInt32(ret);
1646	break;
1647	}
1648	case GET_AUDIO_BALANCE: {
1649	int ret = mpTv->GetAudioBalance();
1650	r->writeInt32(ret);
1651	break;
1652	}
1653	case SAVE_CUR_AUDIO_BALANCE: {
1654	int vol = p.readInt32();
1655	int ret = mpTv->SaveCurAudioBalance(vol);
1656	r->writeInt32(ret);
1657	break;
1658	}
1659	case GET_CUR_AUDIO_BALANCE: {
1660	int ret = mpTv->GetCurAudioBalance();
1661	r->writeInt32(ret);
1662	break;
1663	}
1664	//AUDIO SUPPERBASS VOLUME
1665	case SET_AUDIO_SUPPER_BASS_VOLUME: {
1666	int vol = p.readInt32();
1667	int ret = mpTv->SetAudioSupperBassVolume(vol);
1668	r->writeInt32(ret);
1669	break;
1670	}
1671	case GET_AUDIO_SUPPER_BASS_VOLUME: {
1672	int ret = mpTv->GetAudioSupperBassVolume();
1673	r->writeInt32(ret);
1674	break;
1675	}
1676	case SAVE_CUR_AUDIO_SUPPER_BASS_VOLUME: {
1677	int vol = p.readInt32();
1678	int ret = mpTv->SaveCurAudioSupperBassVolume(vol);
1679	r->writeInt32(ret);
1680	break;
1681	}
1682	case GET_CUR_AUDIO_SUPPER_BASS_VOLUME: {
1683	int ret = mpTv->GetCurAudioSupperBassVolume();
1684	r->writeInt32(ret);
1685	break;
1686	}
1687	//AUDIO SUPPERBASS SWITCH
1688	case SET_AUDIO_SUPPER_BASS_SWITCH: {
1689	int vol = p.readInt32();
1690	int ret = mpTv->SetAudioSupperBassSwitch(vol);
1691	r->writeInt32(ret);
1692	break;
1693	}
1694	case GET_AUDIO_SUPPER_BASS_SWITCH: {
1695	int ret = mpTv->GetAudioSupperBassSwitch();
1696	r->writeInt32(ret);
1697	break;
1698	}
1699	case SAVE_CUR_AUDIO_SUPPER_BASS_SWITCH: {
1700	int vol = p.readInt32();
1701	int ret = mpTv->SaveCurAudioSupperBassSwitch(vol);
1702	r->writeInt32(ret);
1703	break;
1704	}
1705	case GET_CUR_AUDIO_SUPPER_BASS_SWITCH: {
1706	int ret = mpTv->GetCurAudioSupperBassSwitch();
1707	r->writeInt32(ret);
1708	break;
1709	}
1710	//AUDIO SRS SURROUND SWITCH
1711	case SET_AUDIO_SRS_SURROUND: {
1712	int vol = p.readInt32();
1713	int ret = mpTv->SetAudioSRSSurround(vol);
1714	mpTv->RefreshAudioMasterVolume(SOURCE_MAX);
1715	r->writeInt32(ret);
1716	break;
1717	}
1718	case GET_AUDIO_SRS_SURROUND: {
1719	int ret = mpTv->GetAudioSRSSurround();
1720	r->writeInt32(ret);
1721	break;
1722	}
1723	case SAVE_CUR_AUDIO_SRS_SURROUND: {
1724	int vol = p.readInt32();
1725	int ret = mpTv->SaveCurAudioSrsSurround(vol);
1726	r->writeInt32(ret);
1727	break;
1728	}
1729	case GET_CUR_AUDIO_SRS_SURROUND: {
1730	int ret = mpTv->GetCurAudioSRSSurround();
1731	r->writeInt32(ret);
1732	break;
1733	}
1734	//AUDIO SRS DIALOG CLARITY
1735	case SET_AUDIO_SRS_DIALOG_CLARITY: {
1736	int vol = p.readInt32();
1737	int ret = mpTv->SetAudioSrsDialogClarity(vol);
1738	mpTv->RefreshAudioMasterVolume(SOURCE_MAX);
1739	r->writeInt32(ret);
1740	break;
1741	}
1742	case GET_AUDIO_SRS_DIALOG_CLARITY: {
1743	int ret = mpTv->GetAudioSrsDialogClarity();
1744	r->writeInt32(ret);
1745	break;
1746	}
1747	case SAVE_CUR_AUDIO_SRS_DIALOG_CLARITY: {
1748	int vol = p.readInt32();
1749	int ret = mpTv->SaveCurAudioSrsDialogClarity(vol);
1750	r->writeInt32(ret);
1751	break;
1752	}
1753	case GET_CUR_AUDIO_SRS_DIALOG_CLARITY: {
1754	int ret = mpTv->GetCurAudioSrsDialogClarity();
1755	r->writeInt32(ret);
1756	break;
1757	}
1758	//AUDIO SRS TRUBASS
1759	case SET_AUDIO_SRS_TRU_BASS: {
1760	int vol = p.readInt32();
1761	int ret = mpTv->SetAudioSrsTruBass(vol);
1762	mpTv->RefreshAudioMasterVolume(SOURCE_MAX);
1763	r->writeInt32(ret);
1764	break;
1765	}
1766	case GET_AUDIO_SRS_TRU_BASS: {
1767	int ret = mpTv->GetAudioSrsTruBass();
1768	r->writeInt32(ret);
1769	break;
1770	}
1771	case SAVE_CUR_AUDIO_SRS_TRU_BASS: {
1772	int vol = p.readInt32();
1773	int ret = mpTv->SaveCurAudioSrsTruBass(vol);
1774	r->writeInt32(ret);
1775	break;
1776	}
1777	case GET_CUR_AUDIO_SRS_TRU_BASS: {
1778	int ret = mpTv->GetCurAudioSrsTruBass();
1779	r->writeInt32(ret);
1780	break;
1781	}
1782	//AUDIO BASS
1783	case SET_AUDIO_BASS_VOLUME: {
1784	int vol = p.readInt32();
1785	int ret = mpTv->SetAudioBassVolume(vol);
1786	r->writeInt32(ret);
1787	break;
1788	}
1789	case GET_AUDIO_BASS_VOLUME: {
1790	int ret = mpTv->GetAudioBassVolume();
1791	r->writeInt32(ret);
1792	break;
1793	}
1794	case SAVE_CUR_AUDIO_BASS_VOLUME: {
1795	int vol = p.readInt32();
1796	int ret = mpTv->SaveCurAudioBassVolume(vol);
1797	r->writeInt32(ret);
1798	break;
1799	}
1800	case GET_CUR_AUDIO_BASS_VOLUME: {
1801	int ret = mpTv->GetCurAudioBassVolume();
1802	r->writeInt32(ret);
1803	break;
1804	}
1805	//AUDIO TREBLE
1806	case SET_AUDIO_TREBLE_VOLUME: {
1807	int vol = p.readInt32();
1808	int ret = mpTv->SetAudioTrebleVolume(vol);
1809	r->writeInt32(ret);
1810	break;
1811	}
1812	case GET_AUDIO_TREBLE_VOLUME: {
1813	int ret = mpTv->GetAudioTrebleVolume();
1814	r->writeInt32(ret);
1815	break;
1816	}
1817	case SAVE_CUR_AUDIO_TREBLE_VOLUME: {
1818	int vol = p.readInt32();
1819	int ret = mpTv->SaveCurAudioTrebleVolume(vol);
1820	r->writeInt32(ret);
1821	break;
1822	}
1823	case GET_CUR_AUDIO_TREBLE_VOLUME: {
1824	int ret = mpTv->GetCurAudioTrebleVolume();
1825	r->writeInt32(ret);
1826	break;
1827	}
1828	//AUDIO SOUND MODE
1829	case SET_AUDIO_SOUND_MODE: {
1830	int vol = p.readInt32();
1831	int ret = mpTv->SetAudioSoundMode(vol);
1832	r->writeInt32(ret);
1833	break;
1834	}
1835	case GET_AUDIO_SOUND_MODE: {
1836	int ret = mpTv->GetAudioSoundMode();
1837	r->writeInt32(ret);
1838	break;
1839	}
1840	case SAVE_CUR_AUDIO_SOUND_MODE: {
1841	int vol = p.readInt32();
1842	int ret = mpTv->SaveCurAudioSoundMode(vol);
1843	r->writeInt32(ret);
1844	break;
1845	}
1846	case GET_CUR_AUDIO_SOUND_MODE: {
1847	int ret = mpTv->GetCurAudioSoundMode();
1848	r->writeInt32(ret);
1849	break;
1850	}
1851	//AUDIO WALL EFFECT
1852	case SET_AUDIO_WALL_EFFECT: {
1853	int vol = p.readInt32();
1854	int ret = mpTv->SetAudioWallEffect(vol);
1855	r->writeInt32(ret);
1856	break;
1857	}
1858	case GET_AUDIO_WALL_EFFECT: {
1859	int ret = mpTv->GetAudioWallEffect();
1860	r->writeInt32(ret);
1861	break;
1862	}
1863	case SAVE_CUR_AUDIO_WALL_EFFECT: {
1864	int vol = p.readInt32();
1865	int ret = mpTv->SaveCurAudioWallEffect(vol);
1866	r->writeInt32(ret);
1867	break;
1868	}
1869	case GET_CUR_AUDIO_WALL_EFFECT: {
1870	int ret = mpTv->GetCurAudioWallEffect();
1871	r->writeInt32(ret);
1872	break;
1873	}
1874	//AUDIO EQ MODE
1875	case SET_AUDIO_EQ_MODE: {
1876	int vol = p.readInt32();
1877	int ret = mpTv->SetAudioEQMode(vol);
1878	r->writeInt32(ret);
1879	break;
1880	}
1881	case GET_AUDIO_EQ_MODE: {
1882	int ret = mpTv->GetAudioEQMode();
1883	r->writeInt32(ret);
1884	break;
1885	}
1886	case SAVE_CUR_AUDIO_EQ_MODE: {
1887	int vol = p.readInt32();
1888	int ret = mpTv->SaveCurAudioEQMode(vol);
1889	r->writeInt32(ret);
1890	break;
1891	}
1892	case GET_CUR_AUDIO_EQ_MODE: {
1893	int ret = mpTv->GetCurAudioEQMode();
1894	r->writeInt32(ret);
1895	break;
1896	}
1897	//AUDIO EQ GAIN
1898	case GET_AUDIO_EQ_RANGE: {
1899	int buf[2];
1900	int ret = mpTv->GetAudioEQRange(buf);
1901	r->writeInt32(2);
1902	r->writeInt32(buf[0]);
1903	r->writeInt32(buf[1]);
1904	r->writeInt32(ret);
1905	break;
1906	}
1907	case GET_AUDIO_EQ_BAND_COUNT: {
1908	int ret = mpTv->GetAudioEQBandCount();
1909	r->writeInt32(ret);
1910	break;
1911	}
1912	case SET_AUDIO_EQ_GAIN: {
1913	int i = 0, tmp_buf_size = 0, ret = 0;
1914	tmp_buf_size = p.readInt32();
1915	for (i = 0; i < tmp_buf_size; i++) {
1916	tmp_i_buf[i] = p.readInt32();
1917	}
1918	ret = mpTv->SetAudioEQGain(tmp_i_buf);
1919	r->writeInt32(ret);
1920	break;
1921	}
1922	case GET_AUDIO_EQ_GAIN: {
1923	int i = 0, tmp_buf_size = 0, ret = 0;
1924	ret = mpTv->GetAudioEQGain(tmp_i_buf);
1925	tmp_buf_size = mpTv->GetAudioEQBandCount();
1926	r->writeInt32(tmp_buf_size);
1927	for (i = 0; i < tmp_buf_size; i++) {
1928	r->writeInt32(tmp_i_buf[i]);
1929	}
1930	r->writeInt32(ret);
1931	break;
1932	}
1933	case SAVE_CUR_AUDIO_EQ_GAIN: {
1934	int i = 0, tmp_buf_size = 0, ret = 0;
1935	tmp_buf_size = p.readInt32();
1936	for (i = 0; i < tmp_buf_size; i++) {
1937	tmp_i_buf[i] = p.readInt32();
1938	}
1939	ret = mpTv->SaveCurAudioEQGain(tmp_i_buf);
1940	r->writeInt32(ret);
1941	break;
1942	}
1943	case GET_CUR_EQ_GAIN: {
1944	int i = 0, tmp_buf_size = 0, ret = 0;
1945	ret = mpTv->GetCurAudioEQGain(tmp_i_buf);
1946	tmp_buf_size = mpTv->GetAudioEQBandCount();
1947	r->writeInt32(tmp_buf_size);
1948	for (i = 0; i < tmp_buf_size; i++) {
1949	r->writeInt32(tmp_i_buf[i]);
1950	}
1951	r->writeInt32(ret);
1952	break;
1953	}
1954	case SET_AUDIO_EQ_SWITCH: {
1955	int tmpVal = p.readInt32();
1956	int ret = mpTv->SetAudioEQSwitch(tmpVal);
1957	r->writeInt32(ret);
1958	break;
1959	}
1960	// AUDIO SPDIF SWITCH
1961	case SET_AUDIO_SPDIF_SWITCH: {
1962	int tmp_val = p.readInt32();
1963	int ret = mpTv->SetAudioSPDIFSwitch(tmp_val);
1964	r->writeInt32(ret);
1965	break;
1966	}
1967	case GET_AUDIO_SPDIF_SWITCH: {
1968	int ret = 0;//mpTv->GetAudioSPDIFSwitch();
1969	r->writeInt32(ret);
1970	break;
1971	}
1972	case SAVE_CUR_AUDIO_SPDIF_SWITCH: {
1973	int tmp_val = p.readInt32();
1974	int ret = mpTv->SaveCurAudioSPDIFSwitch(tmp_val);
1975	r->writeInt32(ret);
1976	break;
1977	}
1978	case GET_CUR_AUDIO_SPDIF_SWITCH: {
1979	int ret = mpTv->GetCurAudioSPDIFSwitch();
1980	r->writeInt32(ret);
1981	break;
1982	}
1983	//AUDIO SPDIF MODE
1984	case SET_AUDIO_SPDIF_MODE: {
1985	int vol = p.readInt32();
1986	int progId = p.readInt32();
1987	int audioTrackId = p.readInt32();
1988	int ret = mpTv->SetAudioSPDIFMode(vol);
1989	mpTv->ResetAudioDecoderForPCMOutput();
1990	r->writeInt32(ret);
1991	break;
1992	}
1993	case GET_AUDIO_SPDIF_MODE: {
1994	int ret = 0;//mpTv->GetAudioSPDIFMode();
1995	r->writeInt32(ret);
1996	break;
1997	}
1998	case SAVE_CUR_AUDIO_SPDIF_MODE: {
1999	int vol = p.readInt32();
2000	int ret = mpTv->SaveCurAudioSPDIFMode(vol);
2001	r->writeInt32(ret);
2002	break;
2003	}
2004	case GET_CUR_AUDIO_SPDIF_MODE: {
2005	int ret = mpTv->GetCurAudioSPDIFMode();
2006	r->writeInt32(ret);
2007	break;
2008	}
2009	case OPEN_AMAUDIO: {
2010	int sr = p.readInt32();
2011	int output_dev = p.readInt32();
2012	int ret = 0;//mpTv->OpenAmAudio(sr, output_dev);
2013	r->writeInt32(ret);
2014	break;
2015	}
2016	case CLOSE_AMAUDIO: {
2017	int ret = 0;//mpTv->CloseAmAudio();
2018	r->writeInt32(ret);
2019	break;
2020	}
2021	case SET_AMAUDIO_INPUT_SR: {
2022	int sr = p.readInt32();
2023	int output_dev = p.readInt32();
2024	int ret = 0;//mpTv->SetAmAudioInputSr(sr, output_dev);
2025	r->writeInt32(ret);
2026	break;
2027	}
2028	case SET_AMAUDIO_OUTPUT_MODE: {
2029	int tmp_val = p.readInt32();
2030	int ret = mpTv->SetAmAudioOutputMode(tmp_val);
2031	r->writeInt32(ret);
2032	break;
2033	}
2034	case SET_AMAUDIO_MUSIC_GAIN: {
2035	int tmp_val = p.readInt32();
2036	int ret = mpTv->SetAmAudioMusicGain(tmp_val);
2037	r->writeInt32(ret);
2038	break;
2039	}
2040	case SET_AMAUDIO_LEFT_GAIN: {
2041	int tmp_val = p.readInt32();
2042	int ret = mpTv->SetAmAudioLeftGain(tmp_val);
2043	r->writeInt32(ret);
2044	break;
2045	}
2046	case SET_AMAUDIO_RIGHT_GAIN: {
2047	int tmp_val = p.readInt32();
2048	int ret = mpTv->SetAmAudioRightGain(tmp_val);
2049	r->writeInt32(ret);
2050	break;
2051	}
2052	case SELECT_LINE_IN_CHANNEL: {
2053	int channel = p.readInt32();
2054	int ret = mpTv->AudioLineInSelectChannel(channel);
2055	r->writeInt32(ret);
2056	LOGD("SELECT_LINE_IN_CHANNEL: channel = %d; ret = %d.\n", channel, ret);
2057	break;
2058	}
2059	case SET_KALAOK_IO_LEVEL: {
2060	int level = p.readInt32();
2061	int ret = mpTv->SetKalaokIO(level);
2062	ret = mpTv->AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_LINEIN);
2063	r->writeInt32(ret);
2064	LOGD("set line in source CC_AUDIO_IN_SOURCE_LINEIN\n");
2065	break;
2066	}
2067
2068	case SET_LINE_IN_CAPTURE_VOL: {
2069	int l_vol = p.readInt32();
2070	int r_vol = p.readInt32();
2071	int ret = mpTv->AudioSetLineInCaptureVolume(l_vol, r_vol);
2072	r->writeInt32(ret);
2073	break;
2074	}
2075	case HANDLE_AUDIO_HEADSET_PLUG_IN: {
2076	int ret = mpTv->AudioHandleHeadsetPlugIn();
2077	r->writeInt32(ret);
2078	break;
2079	}
2080	case HANDLE_AUDIO_HEADSET_PULL_OUT: {
2081	int ret = mpTv->AudioHandleHeadsetPullOut();
2082	r->writeInt32(ret);
2083	break;
2084	}
2085	case SET_AUDIO_VOL_COMP: {
2086	int tmpVal = p.readInt32();
2087	int ret = mpTv->SetCurProgramAudioVolumeCompensationVal(tmpVal);
2088	r->writeInt32(ret);
2089	break;
2090	}
2091	case GET_AUDIO_VOL_COMP: {
2092	int ret = mpTv->GetAudioVolumeCompensationVal(-1);
2093	r->writeInt32(ret);
2094	break;
2095	}
2096	case SAVE_AUDIO_VOL_COMP: {
2097	int tmpVal = p.readInt32();
2098	int ret = -1;//mpTv->atvSaveAudioVolumeCompensationVal(tmpVal);
2099	LOGD("this cmd is empty!!!!!!!!!!!!!!!!!!!");
2100	r->writeInt32(ret);
2101	break;
2102	}
2103	case SET_NOISE_GATE_THRESHOLD: {
2104	int ret = 0;
2105	r->writeInt32(ret);
2106	break;
2107	}
2108	case SET_AUDIO_SOURCE_FOR_KARAOKE: {
2109	int sourceinput = p.readInt32();
2110	int ret = mpTv->Tv_SetAudioSourceType((tv_source_input_t)sourceinput);
2111	r->writeInt32(ret);
2112	break;
2113	}
2114	case SET_DBX_TV_MODE: {
2115	int mode = p.readInt32();
2116	int son_value = p.readInt32();
2117	int vol_value = p.readInt32();
2118	int sur_value = p.readInt32();
2119	int ret = mpTv->SetDbxTvMode(mode, son_value, vol_value, sur_value);
2120	r->writeInt32(ret);
2121	break;
2122	}
2123	case GET_DBX_TV_MODE: {
2124	int mode ;
2125	int son_value ;
2126	int vol_value ;
2127	int sur_value ;
2128	int ret = mpTv->GetDbxTvMode(&mode, &son_value, &vol_value, &sur_value);
2129	r->writeInt32(mode);
2130	r->writeInt32(son_value);
2131	r->writeInt32(vol_value);
2132	r->writeInt32(sur_value);
2133	r->writeInt32(ret);
2134	break;
2135	}
2136
2137	case SET_DRC_ONOFF: {
2138	int val = p.readInt32();
2139	int ret = mpTv->Tv_SetDRC_OnOff(val);
2140	r->writeInt32(ret);
2141	break;
2142	}
2143	case GET_DRC_ONOFF: {
2144	int ret = mpTv->Tv_GetDRC_OnOff();
2145	r->writeInt32(ret);
2146	break;
2147	}
2148	// AUDIO END
2149
2150	// SSM
2151	case SSM_INIT_DEVICE: {
2152	int tmpRet = 0;
2153	tmpRet = mpTv->Tv_SSMRestoreDefaultSetting();//mpTv->Tv_SSMInitDevice();
2154	r->writeInt32(tmpRet);
2155	break;
2156	}
2157	/*case SSM_SAVE_ONE_BYTE: {
2158	int tmpOffset = p.readInt32();
2159	int tmpVal = p.readInt32();
2160	int tmpRet;
2161	tmpRet = SSMWriteOneByte(tmpOffset, tmpVal);
2162	r->writeInt32(tmpRet);
2163	break;
2164	}
2165	case SSM_READ_ONE_BYTE: {
2166	int tmpOffset = p.readInt32();
2167	int tmpRet = 0;
2168	SSMReadOneByte(tmpOffset, &tmpRet);
2169	r->writeInt32(tmpRet);
2170	break;
2171	}
2172	case SSM_SAVE_N_BYTES: {
2173	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2174
2175	tmp_offset = p.readInt32();
2176	tmp_data_len = p.readInt32();
2177
2178	if (tmp_data_len > 0) {
2179	data_ptr = new int[tmp_data_len];
2180
2181	if (data_ptr != NULL) {
2182	for (i = 0; i < tmp_data_len; i++) {
2183	data_ptr[i] = p.readInt32();
2184	}
2185
2186	ret = SSMWriteNTypes(tmp_offset, tmp_data_len, data_ptr);
2187
2188	delete data_ptr;
2189	data_ptr = NULL;
2190	}
2191	}
2192
2193	r->writeInt32(ret);
2194	break;
2195	}
2196	case SSM_READ_N_BYTES: {
2197	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2198	tmp_offset = p.readInt32();
2199	tmp_data_len = p.readInt32();
2200
2201	if (tmp_data_len > 0) {
2202	data_ptr = new int[tmp_data_len];
2203	if (data_ptr != NULL) {
2204	ret = SSMReadNTypes(tmp_offset, tmp_data_len, data_ptr);
2205	if (ret < 0) {
2206	tmp_data_len = 0;
2207	}
2208	r->writeInt32(tmp_data_len);
2209	for (i = 0; i < tmp_data_len; i++) {
2210	r->writeInt32(data_ptr[i]);
2211	}
2212	delete data_ptr;
2213	data_ptr = NULL;
2214	}
2215	}
2216	r->writeInt32(ret);
2217	break;
2218	}*/
2219	case SSM_SAVE_POWER_ON_OFF_CHANNEL: {
2220	int tmpPowerChanNum = p.readInt32();
2221	int tmpRet;
2222	tmpRet = SSMSavePowerOnOffChannel(tmpPowerChanNum);
2223	r->writeInt32(tmpRet);
2224	break;
2225	}
2226	case SSM_READ_POWER_ON_OFF_CHANNEL: {
2227	int tmpRet = 0;
2228	tmpRet = SSMReadPowerOnOffChannel();
2229	r->writeInt32(tmpRet);
2230	break;
2231	}
2232	case SSM_SAVE_SOURCE_INPUT: {
2233	int tmpSouceInput = p.readInt32();
2234	int tmpRet;
2235	tmpRet = SSMSaveSourceInput(tmpSouceInput);
2236	r->writeInt32(tmpRet);
2237	break;
2238	}
2239	case SSM_READ_SOURCE_INPUT: {
2240	int tmpRet = 0;
2241	tmpRet = SSMReadSourceInput();
2242	r->writeInt32(tmpRet);
2243	break;
2244	}
2245	case SSM_SAVE_LAST_SOURCE_INPUT: {
2246	int tmpLastSouceInput = p.readInt32();
2247	int tmpRet;
2248	tmpRet = SSMSaveLastSelectSourceInput(tmpLastSouceInput);
2249	r->writeInt32(tmpRet);
2250	break;
2251	}
2252	case SSM_READ_LAST_SOURCE_INPUT: {
2253	int tmpRet = 0;
2254	tmpRet = SSMReadLastSelectSourceInput();
2255	r->writeInt32(tmpRet);
2256	break;
2257	}
2258	case SSM_SAVE_SYS_LANGUAGE: {
2259	int tmpVal = p.readInt32();
2260	int tmpRet;
2261	tmpRet = SSMSaveSystemLanguage(tmpVal);
2262	r->writeInt32(tmpRet);
2263	break;
2264	}
2265	case SSM_READ_SYS_LANGUAGE: {
2266	int tmpRet = 0;
2267	tmpRet = SSMReadSystemLanguage();
2268	r->writeInt32(tmpRet);
2269	break;
2270	}
2271	case SSM_SAVE_AGING_MODE: {
2272	int tmpVal = p.readInt32();
2273	int tmpRet;
2274	tmpRet = SSMSaveAgingMode(tmpVal);
2275	r->writeInt32(tmpRet);
2276	break;
2277	}
2278	case SSM_READ_AGING_MODE: {
2279	int tmpRet = 0;
2280	tmpRet = SSMReadAgingMode();
2281	r->writeInt32(tmpRet);
2282	break;
2283	}
2284	case SSM_SAVE_PANEL_TYPE: {
2285	int tmpVal = p.readInt32();
2286	int tmpRet;
2287	tmpRet = SSMSavePanelType(tmpVal);
2288	r->writeInt32(tmpRet);
2289	break;
2290	}
2291	case SSM_READ_PANEL_TYPE: {
2292	int tmpRet = 0;
2293	tmpRet = SSMReadPanelType();
2294	r->writeInt32(tmpRet);
2295	break;
2296	}
2297	case SSM_SAVE_MAC_ADDR: {
2298	int i = 0, tmp_buf_size = 0, ret = 0;
2299	tmp_buf_size = p.readInt32();
2300	for (i = 0; i < tmp_buf_size; i++) {
2301	tmp_uc_buf[i] = p.readInt32();
2302	}
2303	ret = KeyData_SaveMacAddress(tmp_uc_buf);
2304	r->writeInt32(ret);
2305	break;
2306	}
2307	case SSM_READ_MAC_ADDR: {
2308	int i = 0, tmp_buf_size = 0, ret = 0;
2309	ret = KeyData_ReadMacAddress(tmp_uc_buf);
2310	tmp_buf_size = KeyData_GetMacAddressDataLen();
2311	r->writeInt32(tmp_buf_size);
2312	for (i = 0; i < tmp_buf_size; i++) {
2313	r->writeInt32(tmp_uc_buf[i]);
2314	}
2315	r->writeInt32(ret);
2316	break;
2317	}
2318	case SSM_SAVE_BAR_CODE: {
2319	int i = 0, tmp_buf_size = 0, ret = 0;
2320	tmp_buf_size = p.readInt32();
2321	for (i = 0; i < tmp_buf_size; i++) {
2322	tmp_uc_buf[i] = p.readInt32();
2323	}
2324	ret = KeyData_SaveBarCode(tmp_uc_buf);
2325	r->writeInt32(ret);
2326	break;
2327	}
2328	case SSM_READ_BAR_CODE: {
2329	int i = 0, tmp_buf_size = 0, ret = 0;
2330	ret = KeyData_ReadBarCode(tmp_uc_buf);
2331	tmp_buf_size = KeyData_GetBarCodeDataLen();
2332	r->writeInt32(tmp_buf_size);
2333	for (i = 0; i < tmp_buf_size; i++) {
2334	r->writeInt32(tmp_uc_buf[i]);
2335	}
2336	r->writeInt32(ret);
2337	break;
2338	}
2339	case SSM_SAVE_PROJECT_ID: {
2340	int tmpVal = p.readInt32();
2341	int tmpRet;
2342	tmpRet = KeyData_SaveProjectID(tmpVal);
2343	r->writeInt32(tmpRet);
2344	break;
2345	}
2346	case SSM_READ_PROJECT_ID: {
2347	int tmpRet = 0;
2348	tmpRet = KeyData_ReadProjectID();
2349	r->writeInt32(tmpRet);
2350	break;
2351	}
2352	case SSM_SAVE_HDCPKEY: {
2353	int i = 0, tmp_buf_size = 0, ret = 0;
2354	tmp_buf_size = p.readInt32();
2355	for (i = 0; i < tmp_buf_size; i++) {
2356	tmp_uc_buf[i] = p.readInt32();
2357	}
2358	ret = SSMSaveHDCPKey(tmp_uc_buf);
2359	r->writeInt32(ret);
2360	break;
2361	}
2362	case SSM_READ_HDCPKEY: {
2363	int i = 0, tmp_buf_size = 0, ret = 0;
2364	ret = SSMReadHDCPKey(tmp_uc_buf);
2365	tmp_buf_size = SSMGetHDCPKeyDataLen();
2366	r->writeInt32(tmp_buf_size);
2367	for (i = 0; i < tmp_buf_size; i++) {
2368	r->writeInt32(tmp_uc_buf[i]);
2369	}
2370	r->writeInt32(ret);
2371	break;
2372	}
2373	case SSM_SAVE_POWER_ON_MUSIC_SWITCH: {
2374	int tmpVal = p.readInt32();
2375	int tmpRet;
2376	tmpRet = SSMSavePowerOnMusicSwitch(tmpVal);
2377	r->writeInt32(tmpRet);
2378	break;
2379	}
2380	case SSM_READ_POWER_ON_MUSIC_SWITCH: {
2381	int tmpRet = 0;
2382	tmpRet = SSMReadPowerOnMusicSwitch();
2383	r->writeInt32(tmpRet);
2384	break;
2385	}
2386	case SSM_SAVE_POWER_ON_MUSIC_VOL: {
2387	int tmpVal = p.readInt32();
2388	int tmpRet;
2389	tmpRet = SSMSavePowerOnMusicVolume(tmpVal);
2390	r->writeInt32(tmpRet);
2391	break;
2392	}
2393	case SSM_READ_POWER_ON_MUSIC_VOL: {
2394	int tmpRet = 0;
2395	tmpRet = SSMReadPowerOnMusicVolume();
2396	r->writeInt32(tmpRet);
2397	break;
2398	}
2399	case SSM_SAVE_SYS_SLEEP_TIMER: {
2400	int tmpVal = p.readInt32();
2401	int tmpRet;
2402	tmpRet = SSMSaveSystemSleepTimer(tmpVal);
2403	r->writeInt32(tmpRet);
2404	break;
2405	}
2406	case SSM_READ_SYS_SLEEP_TIMER: {
2407	int tmpRet = 0;
2408	tmpRet = SSMReadSystemSleepTimer();
2409	r->writeInt32(tmpRet);
2410	break;
2411	}
2412	case SSM_SET_BUS_STATUS: {
2413	int tmpVal = p.readInt32();
2414	int tmpRet = 0;
2415	//showboz
2416	//tmpRet = SSMSetBusStatus(tmpVal);
2417	r->writeInt32(tmpRet);
2418	break;
2419	}
2420	case SSM_GET_BUS_STATUS: {
2421	int tmpRet = 0;
2422	//showboz
2423	//tmpRet = SSMGetBusStatus();
2424	r->writeInt32(tmpRet);
2425	break;
2426	}
2427	case SSM_SAVE_INPUT_SRC_PARENTAL_CTL: {
2428	int tmpSourceIndex = p.readInt32();
2429	int tmpCtlFlag = p.readInt32();
2430	int tmpRet;
2431	tmpRet = SSMSaveInputSourceParentalControl(tmpSourceIndex, tmpCtlFlag);
2432	r->writeInt32(tmpRet);
2433	break;
2434	}
2435	case SSM_READ_INPUT_SRC_PARENTAL_CTL: {
2436	int tmpSourceIndex = p.readInt32();
2437	int tmpRet = 0;
2438	tmpRet = SSMReadInputSourceParentalControl(tmpSourceIndex);
2439	r->writeInt32(tmpRet);
2440	break;
2441	}
2442	case SSM_SAVE_PARENTAL_CTL_SWITCH: {
2443	int tmpSwitchFlag = p.readInt32();
2444	int tmpRet;
2445	tmpRet = SSMSaveParentalControlSwitch(tmpSwitchFlag);
2446	r->writeInt32(tmpRet);
2447	break;
2448	}
2449	case SSM_READ_PARENTAL_CTL_SWITCH: {
2450	int tmpRet = 0;
2451	tmpRet = SSMReadParentalControlSwitch();
2452	r->writeInt32(tmpRet);
2453	break;
2454	}
2455	case SSM_SAVE_PARENTAL_CTL_PASS_WORD: {
2456	String16 pass_wd_str = p.readString16();
2457	int tmpRet;
2458	tmpRet = SSMSaveParentalControlPassWord((unsigned char *)pass_wd_str.string(), pass_wd_str.size() * sizeof(unsigned short));
2459	r->writeInt32(tmpRet);
2460	break;
2461	}
2462	case SSM_READ_PARENTAL_CTL_PASS_WORD: {
2463	int tmpChanID = p.readInt32();
2464	unsigned short tmp_buf [SSM_RW_PARENTAL_CTL_PASSWORD_LEN + 1];
2465	String16 pass_wd_str;
2466	SSMReadParentalControlPassWord(tmp_buf);
2467	tmp_buf[SSM_RW_PARENTAL_CTL_PASSWORD_LEN / sizeof(unsigned short)] = 0;
2468	//pass_wd_str.setTo((const unsigned short *) tmp_buf);
2469	//r->writeString16(pass_wd_str);
2470	break;
2471	}
2472	case SSM_SAVE_USING_DEF_HDCP_KEY_FLAG: {
2473	break;
2474	}
2475	case SSM_READ_USING_DEF_HDCP_KEY_FLAG: {
2476	break;
2477	}
2478	case SSM_GET_CUSTOMER_DATA_START: {
2479	int tmpRet = 0;
2480	tmpRet = SSMGetCustomerDataStart();
2481	r->writeInt32(tmpRet);
2482	break;
2483	}
2484	case SSM_GET_CUSTOMER_DATA_LEN: {
2485	int tmpRet = 0;
2486	tmpRet = SSMGetCustomerDataLen();
2487	r->writeInt32(tmpRet);
2488	break;
2489	}
2490	case SSM_SAVE_STANDBY_MODE: {
2491	int tmp_val = p.readInt32();
2492	int tmpRet;
2493	tmpRet = SSMSaveStandbyMode(tmp_val);
2494	r->writeInt32(tmpRet);
2495	break;
2496	}
2497	case SSM_READ_STANDBY_MODE: {
2498	int tmpRet = 0;
2499	tmpRet = SSMReadStandbyMode();
2500	r->writeInt32(tmpRet);
2501	break;
2502	}
2503	case SSM_SAVE_LOGO_ON_OFF_FLAG: {
2504	int tmpSwitchFlag = p.readInt32();
2505	int tmpRet;
2506	tmpRet = SSMSaveLogoOnOffFlag(tmpSwitchFlag);
2507	r->writeInt32(tmpRet);
2508	break;
2509	}
2510	case SSM_READ_LOGO_ON_OFF_FLAG: {
2511	int tmpRet = 0;
2512	tmpRet = SSMReadLogoOnOffFlag();
2513	r->writeInt32(tmpRet);
2514	break;
2515	}
2516	case SSM_SAVE_HDMIEQ_MODE: {
2517	int tmpSwitchFlag = p.readInt32();
2518	int tmpRet;
2519	tmpRet = SSMSaveHDMIEQMode(tmpSwitchFlag);
2520	r->writeInt32(tmpRet);
2521	break;
2522	}
2523	case SSM_READ_HDMIEQ_MODE: {
2524	int tmpRet = 0;
2525	tmpRet = SSMReadHDMIEQMode();
2526	r->writeInt32(tmpRet);
2527	break;
2528	}
2529	case SSM_SAVE_HDMIINTERNAL_MODE: {
2530	int tmp_val = p.readInt32();
2531	int tmpRet;
2532	tmpRet = SSMSaveHDMIInternalMode(tmp_val);
2533	r->writeInt32(tmpRet);
2534	break;
2535	}
2536	case SSM_READ_HDMIINTERNAL_MODE: {
2537	int tmpRet = 0;
2538	tmpRet = SSMReadHDMIInternalMode();
2539	r->writeInt32(tmpRet);
2540	break;
2541	}
2542	case SSM_SAVE_DISABLE_3D: {
2543	int tmp_val = p.readInt32();
2544	int tmpRet;
2545	tmpRet = SSMSaveDisable3D(tmp_val);
2546	r->writeInt32(tmpRet);
2547	break;
2548	}
2549	case SSM_READ_DISABLE_3D: {
2550	int tmpRet = 0;
2551	tmpRet = SSMReadDisable3D();
2552	r->writeInt32(tmpRet);
2553	break;
2554	}
2555	case SSM_SAVE_GLOBAL_OGOENABLE: {
2556	int tmp_val = p.readInt32();
2557	int tmpRet;
2558	tmpRet = SSMSaveGlobalOgoEnable(tmp_val);
2559	r->writeInt32(tmpRet);
2560	break;
2561	}
2562	case SSM_READ_GLOBAL_OGOENABLE: {
2563	int tmpRet = 0;
2564	tmpRet = SSMReadGlobalOgoEnable();
2565	r->writeInt32(tmpRet);
2566	break;
2567	}
2568	case SSM_SAVE_NON_STANDARD_STATUS: {
2569	int tmp_val = p.readInt32();
2570	int tmpRet;
2571	tmpRet = SSMSaveNonStandardValue(tmp_val);
2572	r->writeInt32(tmpRet);
2573	break;
2574	}
2575	case SSM_READ_NON_STANDARD_STATUS: {
2576	int tmpRet = 0;
2577	tmpRet = SSMReadNonStandardValue();
2578	r->writeInt32(tmpRet);
2579	break;
2580	}
2581	case SSM_SAVE_ADB_SWITCH_STATUS: {
2582	int tmp_val = p.readInt32();
2583	int tmpRet;
2584	tmpRet = SSMSaveAdbSwitchValue(tmp_val);
2585	r->writeInt32(tmpRet);
2586	break;
2587	}
2588	case SSM_READ_ADB_SWITCH_STATUS: {
2589	int tmpRet = 0;
2590	tmpRet = SSMReadAdbSwitchValue();
2591	r->writeInt32(tmpRet);
2592	break;
2593	}
2594	case SSM_SAVE_SERIAL_CMD_SWITCH_STATUS: {
2595	int tmp_val = p.readInt32();
2596	int tmpRet;
2597	tmpRet = SSMSaveSerialCMDSwitchValue(tmp_val);
2598	tmpRet |= mpTv->SetSerialSwitch(SERIAL_A, tmp_val);
2599	r->writeInt32(tmpRet);
2600	break;
2601	}
2602	case SSM_READ_SERIAL_CMD_SWITCH_STATUS: {
2603	int tmpRet = 0;
2604	tmpRet = SSMReadSerialCMDSwitchValue();
2605	r->writeInt32(tmpRet);
2606	break;
2607	}
2608	case SSM_SET_HDCP_KEY: {
2609	int tmpRet = 0;
2610	tmpRet = SSMSetHDCPKey();
2611	r->writeInt32(tmpRet);
2612	break;
2613	}
2614	case SSM_REFRESH_HDCPKEY: {
2615	int tmpRet = 0;
2616	tmpRet = SSMRefreshHDCPKey();
2617	r->writeInt32(tmpRet);
2618	break;
2619	}
2620	case SSM_SAVE_CHROMA_STATUS: {
2621	int tmp_val = p.readInt32();
2622	int tmpRet;
2623	tmpRet = SSMSaveChromaStatus(tmp_val);
2624	r->writeInt32(tmpRet);
2625	break;
2626	}
2627	case SSM_SAVE_CA_BUFFER_SIZE: {
2628	int tmp_val = p.readInt32();
2629	int tmpRet;
2630	tmpRet = SSMSaveCABufferSizeValue(tmp_val);
2631	r->writeInt32(tmpRet);
2632	break;
2633	}
2634	case SSM_READ_CA_BUFFER_SIZE: {
2635	int tmpRet = 0;
2636	tmpRet = SSMReadCABufferSizeValue();
2637	r->writeInt32(tmpRet);
2638	break;
2639	}
2640	case SSM_GET_ATV_DATA_START: {
2641	int tmpRet = 0;
2642	tmpRet = SSMGetATVDataStart();
2643	r->writeInt32(tmpRet);
2644	break;
2645	}
2646	case SSM_GET_ATV_DATA_LEN: {
2647	int tmpRet = 0;
2648	tmpRet = SSMGetATVDataLen();
2649	r->writeInt32(tmpRet);
2650	break;
2651	}
2652	case SSM_GET_VPP_DATA_START: {
2653	int tmpRet = 0;
2654	tmpRet = SSMGetVPPDataStart();
2655	r->writeInt32(tmpRet);
2656	break;
2657	}
2658	case SSM_GET_VPP_DATA_LEN: {
2659	int tmpRet = 0;
2660	tmpRet = SSMGetVPPDataLen();
2661	r->writeInt32(tmpRet);
2662	break;
2663	}
2664	case SSM_SAVE_NOISE_GATE_THRESHOLD_STATUS: {
2665	int tmp_val = p.readInt32();
2666	int tmpRet;
2667	tmpRet = SSMSaveNoiseGateThresholdValue(tmp_val);
2668	r->writeInt32(tmpRet);
2669	break;
2670	}
2671	case SSM_READ_NOISE_GATE_THRESHOLD_STATUS: {
2672	int tmpRet = 0;
2673	tmpRet = SSMReadNoiseGateThresholdValue();
2674	r->writeInt32(tmpRet);
2675	break;
2676	}
2677	case SSM_EEPROM_SAVE_ONE_BYTE_N310_N311: {
2678	int tmpOffset = p.readInt32();
2679	int tmpVal = p.readInt32();
2680	int tmpRet;
2681	tmpRet = SSMSaveEEP_One_N310_N311(tmpOffset, tmpVal);
2682	r->writeInt32(tmpRet);
2683	break;
2684	}
2685	case SSM_EEPROM_READ_ONE_BYTE_N310_N311: {
2686	int tmpOffset = p.readInt32();
2687	int tmpRet = 0;
2688	tmpRet = SSMReadEEP_One_N310_N311(tmpOffset);
2689	r->writeInt32(tmpRet);
2690	break;
2691	}
2692	case SSM_EEPROM_SAVE_N_BYTES_N310_N311: {
2693	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2694
2695	tmp_offset = p.readInt32();
2696	tmp_data_len = p.readInt32();
2697
2698	if (tmp_data_len > 0) {
2699	data_ptr = new int[tmp_data_len];
2700
2701	if (data_ptr != NULL) {
2702	for (i = 0; i < tmp_data_len; i++) {
2703	data_ptr[i] = p.readInt32();
2704	}
2705
2706	ret = SSMSaveEEP_N_N310_N311(tmp_offset, tmp_data_len, data_ptr);
2707
2708	delete data_ptr;
2709	data_ptr = NULL;
2710	}
2711	}
2712
2713	r->writeInt32(ret);
2714	break;
2715	}
2716	case SSM_EEPROM_READ_N_BYTES_N310_N311: {
2717	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2718	tmp_offset = p.readInt32();
2719	tmp_data_len = p.readInt32();
2720
2721	if (tmp_data_len > 0) {
2722	data_ptr = new int[tmp_data_len];
2723	if (data_ptr != NULL) {
2724	ret = SSMReadEEP_N_N310_N311(tmp_offset, tmp_data_len, data_ptr);
2725	if (ret < 0) {
2726	tmp_data_len = 0;
2727	}
2728	r->writeInt32(tmp_data_len);
2729	for (i = 0; i < tmp_data_len; i++) {
2730	r->writeInt32(data_ptr[i]);
2731	}
2732	delete data_ptr;
2733	data_ptr = NULL;
2734	}
2735	}
2736	r->writeInt32(ret);
2737	break;
2738	}
2739	case SSM_FLASH_SAVE_ONE_BYTE_N310_N311: {
2740	int tmpOffset = p.readInt32();
2741	int tmpVal = p.readInt32();
2742	int tmpRet;
2743	tmpRet = SSMSaveFlash_One_N310_N311(tmpOffset, tmpVal);
2744	r->writeInt32(tmpRet);
2745	break;
2746	}
2747	case SSM_FLASH_READ_ONE_BYTE_N310_N311: {
2748	int tmpOffset = p.readInt32();
2749	int tmpRet = 0;
2750	tmpRet = SSMReadFlash_One_N310_N311(tmpOffset);
2751	r->writeInt32(tmpRet);
2752	break;
2753	}
2754	case SSM_FLASH_SAVE_N_BYTES_N310_N311: {
2755	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2756
2757	tmp_offset = p.readInt32();
2758	tmp_data_len = p.readInt32();
2759
2760	if (tmp_data_len > 0) {
2761	data_ptr = new int[tmp_data_len];
2762
2763	if (data_ptr != NULL) {
2764	for (i = 0; i < tmp_data_len; i++) {
2765	data_ptr[i] = p.readInt32();
2766	}
2767
2768	ret = SSMSaveFlash_N_N310_N311(tmp_offset, tmp_data_len, data_ptr);
2769
2770	delete data_ptr;
2771	data_ptr = NULL;
2772	}
2773	}
2774
2775	r->writeInt32(ret);
2776	break;
2777	}
2778	case SSM_FLASH_READ_N_BYTES_N310_N311: {
2779	int i = 0, tmp_offset = 0, tmp_data_len = 0, ret = -1;
2780	tmp_offset = p.readInt32();
2781	tmp_data_len = p.readInt32();
2782
2783	if (tmp_data_len > 0) {
2784	data_ptr = new int[tmp_data_len];
2785	if (data_ptr != NULL) {
2786	ret = SSMReadFlash_N_N310_N311(tmp_offset, tmp_data_len, data_ptr);
2787	if (ret < 0) {
2788	tmp_data_len = 0;
2789	}
2790	r->writeInt32(tmp_data_len);
2791	for (i = 0; i < tmp_data_len; i++) {
2792	r->writeInt32(data_ptr[i]);
2793	}
2794	delete data_ptr;
2795	data_ptr = NULL;
2796	}
2797	}
2798	r->writeInt32(ret);
2799	break;
2800	}
2801	// SSM END
2802
2803	//MISC
2804	case MISC_PROP_SET: {
2805	int tmpRet;
2806	String16 tmp_str16;
2807	String8 key_str, value_str;
2808
2809	tmp_str16 = p.readString16();
2810	key_str = String8(tmp_str16);
2811	tmp_str16 = p.readString16();
2812	value_str = String8(tmp_str16);
2813
2814	tmpRet = property_set(key_str.string(), value_str.string());
2815	r->writeInt32(tmpRet);
2816	break;
2817	}
2818	case MISC_PROP_GET: {
2819	char prop_value[PROPERTY_VALUE_MAX];
2820	String16 tmp_str16;
2821	String8 key_str, def_str;
2822
2823	tmp_str16 = p.readString16();
2824	key_str = String8(tmp_str16);
2825	tmp_str16 = p.readString16();
2826	def_str = String8(tmp_str16);
2827
2828	memset(prop_value, '\0', PROPERTY_VALUE_MAX);
2829	property_get(key_str.string(), prop_value, def_str.string());
2830	tmp_str16 = String16(prop_value);
2831
2832	r->writeString16(tmp_str16);
2833	break;
2834	}
2835	case MISC_CFG_SET: {
2836	int tmpRet;
2837	String16 tmp_str16;
2838	String8 key_str, value_str;
2839
2840	tmp_str16 = p.readString16();
2841	key_str = String8(tmp_str16);
2842	tmp_str16 = p.readString16();
2843	value_str = String8(tmp_str16);
2844
2845	tmpRet = config_set_str(CFG_SECTION_TV, key_str.string(), value_str.string());
2846	r->writeInt32(tmpRet);
2847	break;
2848	}
2849	case MISC_CFG_GET: {
2850	const char *prop_value;
2851	String16 tmp_str16;
2852	String8 key_str, def_str;
2853
2854	tmp_str16 = p.readString16();
2855	key_str = String8(tmp_str16);
2856	tmp_str16 = p.readString16();
2857	def_str = String8(tmp_str16);
2858
2859	prop_value = config_get_str(CFG_SECTION_TV, key_str.string(), def_str.string());
2860	tmp_str16 = String16(prop_value);
2861
2862	r->writeString16(tmp_str16);
2863	break;
2864	}
2865	case MISC_READ_ADC_VAL: {
2866	int tmpChanNum = p.readInt32();
2867	int tmpRet = 0;
2868	tmpRet = ReadADCSpecialChannelValue(tmpChanNum);
2869	r->writeInt32(tmpRet);
2870	break;
2871	}
2872	case MISC_SET_WDT_USER_PET: {
2873	int counter = p.readInt32();
2874	int ret = TvMisc_SetUserCounter(counter);
2875	r->writeInt32(ret);
2876	break;
2877	}
2878	case MISC_SET_WDT_USER_COUNTER: {
2879	int counter_time_out = p.readInt32();
2880	int ret = TvMisc_SetUserCounterTimeOut(counter_time_out);
2881	r->writeInt32(ret);
2882	break;
2883	}
2884	case MISC_SET_WDT_USER_PET_RESET_ENABLE: {
2885	int enable = p.readInt32();
2886	int ret = TvMisc_SetUserPetResetEnable(enable);
2887	r->writeInt32(ret);
2888	break;
2889	}
2890	case MISC_GET_TV_API_VERSION: {
2891	const char *tmp_str8;
2892	String16 tmp_str16;
2893
2894	// write tvapi version info
2895	tmp_str8 = tvservice_get_git_branch_info();
2896	tmp_str16 = String16(tmp_str8);
2897	r->writeString16(tmp_str16);
2898
2899	tmp_str8 = tvservice_get_git_version_info();
2900	tmp_str16 = String16(tmp_str8);
2901	r->writeString16(tmp_str16);
2902
2903	tmp_str8 = tvservice_get_last_chaned_time_info();
2904	tmp_str16 = String16(tmp_str8);
2905	r->writeString16(tmp_str16);
2906
2907	tmp_str8 = tvservice_get_build_time_info();
2908	tmp_str16 = String16(tmp_str8);
2909	r->writeString16(tmp_str16);
2910
2911	tmp_str8 = tvservice_get_build_name_info();
2912	tmp_str16 = String16(tmp_str8);
2913	r->writeString16(tmp_str16);
2914	break;
2915	}
2916	case MISC_GET_DVB_API_VERSION: {
2917	const char *tmp_str8;
2918	String16 tmp_str16;
2919
2920	// write dvb version info
2921	tmp_str8 = dvb_get_git_branch_info();
2922	tmp_str16 = String16(tmp_str8);
2923	r->writeString16(tmp_str16);
2924
2925	tmp_str8 = dvb_get_git_version_info();
2926	tmp_str16 = String16(tmp_str8);
2927	r->writeString16(tmp_str16);
2928
2929	tmp_str8 = dvb_get_last_chaned_time_info();
2930	tmp_str16 = String16(tmp_str8);
2931	r->writeString16(tmp_str16);
2932
2933	tmp_str8 = dvb_get_build_time_info();
2934	tmp_str16 = String16(tmp_str8);
2935	r->writeString16(tmp_str16);
2936
2937	tmp_str8 = dvb_get_build_name_info();
2938	tmp_str16 = String16(tmp_str8);
2939	r->writeString16(tmp_str16);
2940
2941	break;
2942	}
2943	case MISC_SERIAL_SWITCH: {
2944	int dev_id = p.readInt32();
2945	int switch_val = p.readInt32();
2946	int ret = mpTv->SetSerialSwitch(dev_id, switch_val);
2947	r->writeInt32(ret);
2948	break;
2949	}
2950	case MISC_SERIAL_SEND_DATA: {
2951	int i = 0, bufSize = 0, ret = 0;
2952
2953	int dev_id = p.readInt32();
2954
2955	bufSize = p.readInt32();
2956	if (bufSize > (int)sizeof(tmp_uc_buf)) {
2957	bufSize = sizeof(tmp_uc_buf);
2958	}
2959
2960	for (i = 0; i < bufSize; i++) {
2961	tmp_uc_buf[i] = p.readInt32() & 0xFF;
2962	}
2963
2964	ret = mpTv->SendSerialData(dev_id, bufSize, tmp_uc_buf);
2965	r->writeInt32(ret);
2966	break;
2967	}
2968	case MISC_CHANNEL_EXPORT: {
2969	LOGD("MISC_CHANNEL_EXPORT");
2970	int ret = 0;
2971	String16 tmp_str16;
2972	String8 tmp_str;
2973
2974	tmp_str16 = p.readString16();
2975	tmp_str = String8(tmp_str16);
2976
2977	ret = mpTv->ChannelExport(tmp_str.string());
2978	r->writeInt32(ret);
2979	break;
2980	}
2981	case MISC_CHANNEL_IMPORT: {
2982	LOGD("MISC_CHANNEL_IMPORT");
2983	String16 tmp_str16;
2984	String8 tmp_str;
2985
2986	tmp_str16 = p.readString16();
2987	tmp_str = String8(tmp_str16);
2988	int ret = 0;
2989	ret = mpTv->ChannelImport(tmp_str.string());
2990	r->writeInt32(ret);
2991	break;
2992	}
2993	case MISC_GET_PROJECT_INFO: {
2994	String16 tmp_str16;
2995	project_info_t tmpInfo;
2996
2997	if (mpTv->Tv_GetProjectInfo(&tmpInfo) < 0) {
2998	strcpy(tmpInfo.version, "UNKOWN");
2999	strcpy(tmpInfo.panel_type, "UNKOWN");
3000	strcpy(tmpInfo.panel_outputmode, "UNKOWN");
3001	strcpy(tmpInfo.panel_rev, "UNKOWN");
3002	strcpy(tmpInfo.panel_name, "UNKOWN");
3003	strcpy(tmpInfo.amp_curve_name, "UNKOWN");
3004	}
3005
3006	r->writeString16(String16(tmpInfo.version));
3007	r->writeString16(String16(tmpInfo.panel_type));
3008	r->writeString16(String16(tmpInfo.panel_outputmode));
3009	r->writeString16(String16(tmpInfo.panel_rev));
3010	r->writeString16(String16(tmpInfo.panel_name));
3011	r->writeString16(String16(tmpInfo.amp_curve_name));
3012	break;
3013	}
3014	case MISC_GET_PLATFORM_TYPE: {
3015	int ret = mpTv->Tv_GetPlatformType();
3016	r->writeInt32(ret);
3017	break;
3018	}
3019	//MISC END
3020
3021	// EXTAR
3022	case SET_DEBUG_SERIAL_PORT_ONOFF: {
3023	int on_off = p.readInt32();
3024	int ret = mpTv->SetDebugSerialOnOff(on_off);
3025	r->writeInt32(ret);
3026	break;
3027	}
3028
3029	case GET_DEBUG_SERIAL_PORT_ONOFF: {
3030	int ret = mpTv->GetDebugSerialOnOff();
3031	r->writeInt32(ret);
3032	break;
3033	}
3034	case DELETE_DIR_FILES: {
3035	String16 strPath = p.readString16();
3036	if (strPath.size() <= 0) {
3037	r->writeInt32(-1);
3038	break;
3039	}
3040	String8 strP8 = String8(strPath);
3041	int tmp_flag = p.readInt32();
3042	int ret = TvMisc_DeleteDirFiles(strP8.string(), tmp_flag);
3043	r->writeInt32(ret);
3044	break;
3045	}
3046	case DTV_SUBTITLE_INIT: {
3047	int bitmapWidth = p.readInt32();
3048	int bitmapHeight = p.readInt32();
3049	r->writeInt32(mpTv->initSubtitle(bitmapWidth, bitmapHeight));
3050	break;
3051	}
3052	case DTV_SUBTITLE_LOCK: {
3053	r->writeInt32(mpTv->lockSubtitle());
3054	break;
3055	}
3056	case DTV_SUBTITLE_UNLOCK: {
3057	r->writeInt32(mpTv->unlockSubtitle());
3058	break;
3059	}
3060	case DTV_GET_SUBTITLE_SWITCH: {
3061	r->writeInt32(mpTv->getSubSwitchStatus());
3062	break;
3063	}
3064	case DTV_START_SUBTITLE: {
3065	int dmx_id = p.readInt32();
3066	int pid = p.readInt32();
3067	int page_id = p.readInt32();
3068	int anc_page_id = p.readInt32();
3069	r->writeInt32(mpTv->startSubtitle(dmx_id, pid, page_id, anc_page_id));
3070	break;
3071	}
3072	case DTV_STOP_SUBTITLE: {
3073	r->writeInt32(mpTv->stopSubtitle());
3074	break;
3075	}
3076	case DTV_GET_SUBTITLE_INDEX: {
3077	int progId = p.readInt32();
3078	CTvProgram prog;
3079	CTvProgram::selectByID(progId, prog);
3080	r->writeInt32(prog.getSubtitleIndex(progId));
3081	break;
3082	}
3083	case DTV_SET_SUBTITLE_INDEX: {
3084	int progId = p.readInt32();
3085	int index = p.readInt32();
3086	CTvProgram prog;
3087	CTvProgram::selectByID(progId, prog);
3088	r->writeInt32(prog.setSubtitleIndex(progId, index));
3089	break;
3090	}
3091	case ATV_GET_CURRENT_PROGRAM_ID: {
3092	int atvLastProgramId = mpTv->getATVProgramID();
3093	r->writeInt32(atvLastProgramId);
3094	break;
3095	}
3096	case DTV_GET_CURRENT_PROGRAM_ID: {
3097	int dtvLastProgramId = mpTv->getDTVProgramID();
3098	r->writeInt32(dtvLastProgramId);
3099	break;
3100	}
3101	case ATV_SAVE_PROGRAM_ID: {
3102	int progID = p.readInt32();
3103	int retCnt = 0;
3104	mpTv->saveATVProgramID(progID);
3105	r->writeInt32(retCnt);
3106	break;
3107	}
3108	case ATV_GET_MIN_MAX_FREQ: {
3109	int min, max;
3110	int tmpRet = mpTv->getATVMinMaxFreq(&min, &max);
3111	r->writeInt32(min);
3112	r->writeInt32(max);
3113	r->writeInt32(tmpRet);
3114	break;
3115	}
3116	case DTV_GET_SCAN_FREQUENCY_LIST: {
3117	Vector<sp<CTvChannel> > out;
3118	int tmpRet = CTvRegion::getChannelListByName((char *)"CHINA,Default DTMB ALL", out);
3119	r->writeInt32(out.size());
3120	for (int i = 0; i < (int)out.size(); i++) {
3121	r->writeInt32(out[i]->getID());
3122	r->writeInt32(out[i]->getFrequency());
3123	}
3124	r->writeInt32(tmpRet);
3125	break;
3126	}
3127	case DTV_GET_CHANNEL_INFO: {
3128	int dbID = p.readInt32();
3129	channel_info_t chan_info;
3130	int ret = mpTv->getChannelInfoBydbID(dbID, chan_info);
3131	r->writeInt32(chan_info.freq);
3132	r->writeInt32(chan_info.uInfo.dtvChanInfo.strength);
3133	r->writeInt32(chan_info.uInfo.dtvChanInfo.quality);
3134	r->writeInt32(chan_info.uInfo.dtvChanInfo.ber);
3135	r->writeInt32(ret);
3136	break;
3137	}
3138	case ATV_GET_CHANNEL_INFO: {
3139	int dbID = p.readInt32();
3140	channel_info_t chan_info;
3141	int ret = mpTv->getChannelInfoBydbID(dbID, chan_info);
3142	r->writeInt32(chan_info.freq);
3143	r->writeInt32(chan_info.uInfo.atvChanInfo.finefreq);
3144	r->writeInt32(chan_info.uInfo.atvChanInfo.videoStd);
3145	r->writeInt32(chan_info.uInfo.atvChanInfo.audioStd);
3146	r->writeInt32(chan_info.uInfo.atvChanInfo.isAutoStd);
3147	r->writeInt32(ret);
3148	break;
3149	}
3150	case ATV_SCAN_MANUAL: {
3151	int tmpRet = 0;
3152	int startFreq = p.readInt32();
3153	int endFreq = p.readInt32();
3154	int videoStd = p.readInt32();
3155	int audioStd = p.readInt32();
3156	tmpRet = mpTv->atvMunualScan(startFreq, endFreq, videoStd, audioStd);
3157	mTvService->mpScannerClient = this;
3158	r->writeInt32(tmpRet);
3159	break;
3160	}
3161
3162
3163	case ATV_SCAN_AUTO: {
3164	int tmpRet = 0;
3165	LOGD("%s, atv auto scan!!!\n", "TV");
3166	int videoStd = p.readInt32();
3167	int audioStd = p.readInt32();
3168	int searchType = p.readInt32();
3169	tmpRet = mpTv->atvAutoScan(videoStd, audioStd, searchType);
3170	mTvService->mpScannerClient = this;
3171	r->writeInt32(tmpRet);
3172	break;
3173	}
3174	case DTV_SCAN_MANUAL: {
3175	int tmpRet = 0;
3176	int freq = p.readInt32();
3177	tmpRet = mpTv->dtvManualScan(freq, freq);
3178	mTvService->mpScannerClient = this;
3179	r->writeInt32(tmpRet);
3180	break;
3181	}
3182	case DTV_SCAN_MANUAL_BETWEEN_FREQ: {
3183	int tmpRet = 0;
3184	int beginFreq = p.readInt32();
3185	int endFreq = p.readInt32();
3186	int modulation = p.readInt32();
3187	tmpRet = mpTv->dtvManualScan(beginFreq, endFreq, modulation);
3188	mTvService->mpScannerClient = this;
3189	r->writeInt32(tmpRet);
3190	break;
3191	}
3192	case DTV_SCAN_AUTO: {
3193	int tmpRet = 0;
3194	tmpRet = mpTv->dtvAutoScan();
3195	mTvService->mpScannerClient = this;
3196	r->writeInt32(tmpRet);
3197	break;
3198	}
3199	case DTV_SCAN_AUTO_ATSC: {
3200	int tmpRet = 0;
3201	int attenna = p.readInt32();
3202	int vstd = p.readInt32();
3203	int astd = p.readInt32();
3204	tmpRet = mpTv->dtvAutoScanAtscLock(attenna, vstd, astd);
3205	mTvService->mpScannerClient = this;
3206	r->writeInt32(tmpRet);
3207	break;
3208	}
3209	case TV_SUBTITLE_DRAW_END: {
3210	int tmpRet = 0;
3211	//if(pSub)pSub->lock.unlock();
3212	r->writeInt32(tmpRet);
3213	break;
3214	}
3215	case STOP_PROGRAM_PLAY: {
3216	int tmpRet = -1;
3217	tmpRet = mpTv->stopPlayingLock();
3218	r->writeInt32(tmpRet);
3219	break;
3220	}
3221	case DTV_TEST_1: {
3222	// int progid = p.readInt32();
3223	//CTvProgram prog;
3224	// int ret = CTvProgram::selectByID(progid, prog);
3225	//CTvEvent ev;
3226	//ret = ev.getProgPresentEvent(prog.getSrc(), prog.getID(), mpTv->getTvTime(), ev);
3227	//r->writeString16(String16(ev.getName()));
3228	break;
3229	}
3230	case DTV_TEST_2: {
3231	//int cmd = p.readInt32();
3232	//CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
3233	//r->writeString16(String16("xml"));
3234	break;
3235	}
3236
3237	case TV_CLEAR_ALL_PROGRAM: {
3238	int tmpRet = 0;
3239	int arg0 = p.readInt32();
3240
3241	tmpRet = mpTv->clearAllProgram(arg0);
3242	mTvService->mpScannerClient = this;
3243	r->writeInt32(tmpRet);
3244	break;
3245	}
3246
3247	case GET_DISPLAY_RESOLUTION_CONFIG: {
3248	int tmpRet = 0;
3249	tmpRet = mpTv->GetDisplayResolutionConfig();
3250	r->writeInt32(tmpRet);
3251	break;
3252	}
3253
3254	case GET_DISPLAY_RESOLUTION_INFO: {
3255	int tmpRet = 0;
3256	tmpRet = mpTv->GetDisplayResolutionInfo();
3257	r->writeInt32(tmpRet);
3258	break;
3259	}
3260
3261	case HDMIRX_CEC_SEND_CUSTOM_MESSAGE: {
3262	int i = 0, tmp_buf_size = 0, ret = 0;
3263	tmp_buf_size = p.readInt32();
3264	for (i = 0; i < tmp_buf_size; i++) {
3265	tmp_uc_buf[i] = p.readInt32();
3266	}
3267
3268	int tmpRet = 0;
3269	tmpRet = mpTv->SendHDMIRxCECCustomMessage(tmp_uc_buf);
3270	r->writeInt32(tmpRet);
3271	break;
3272	}
3273
3274	case HDMIRX_CEC_SEND_CUSTOM_WAIT_REPLY_MESSAGE: {
3275	int i = 0, tmp_buf_size = 0, ret = 0;
3276	int WaitCmd = 0, timeout = 0;
3277	tmp_buf_size = p.readInt32();
3278	for (i = 0; i < tmp_buf_size; i++) {
3279	tmp_uc_buf[i] = p.readInt32();
3280	}
3281
3282	WaitCmd = p.readInt32();
3283	timeout = p.readInt32();
3284
3285	int tmpRet = 0;
3286	tmpRet = mpTv->SendHDMIRxCECCustomMessageAndWaitReply(tmp_uc_buf, tmp_uc_buf2, WaitCmd, timeout);
3287
3288	r->writeInt32(tmpRet);
3289	if (tmpRet > 0) {
3290	for (i = 0; i < tmpRet; i++) {
3291	r->writeInt32(tmp_uc_buf2[i]);
3292	}
3293	}
3294
3295	r->writeInt32(tmpRet);
3296	break;
3297	}
3298
3299	case HDMIRX_CEC_SEND_BROADCAST_STANDBY_MESSAGE: {
3300	int tmpRet = 0;
3301	tmpRet = mpTv->SendHDMIRxCECBoradcastStandbyMessage();
3302	r->writeInt32(tmpRet);
3303	break;
3304	}
3305
3306	case HDMIRX_CEC_SEND_GIVE_CEC_VERSION_MESSAGE: {
3307	int i = 0, tmp_buf_size = 0, ret = 0;
3308	int sourceinput = p.readInt32();
3309	LOGD("HDMIRX_CEC_SEND_GIVE_CEC_VERSION_MESSAGE: sourceinput = %x", sourceinput);
3310	tmp_buf_size = mpTv->SendHDMIRxCECGiveCECVersionMessage((tv_source_input_t)sourceinput, tmp_uc_buf);
3311	r->writeInt32(tmp_buf_size);
3312	for (i = 0; i < tmp_buf_size; i++) {
3313	r->writeInt32(tmp_uc_buf[i]);
3314	}
3315	r->writeInt32(tmp_buf_size);
3316	break;
3317	}
3318
3319	case HDMIRX_CEC_SEND_GIVE_DEV_VENDOR_ID_MESSAGE: {
3320	int i = 0, tmp_buf_size = 0, ret = 0;
3321	int sourceinput = p.readInt32();
3322	LOGD("HDMIRX_CEC_SEND_GIVE_DEV_VENDOR_ID_MESSAGE: sourceinput = %x", sourceinput);
3323	tmp_buf_size = mpTv->SendHDMIRxCECGiveDeviceVendorIDMessage((tv_source_input_t)sourceinput, tmp_uc_buf);
3324	r->writeInt32(tmp_buf_size);
3325	for (i = 0; i < tmp_buf_size; i++) {
3326	r->writeInt32(tmp_uc_buf[i]);
3327	}
3328	r->writeInt32(tmp_buf_size);
3329	break;
3330	}
3331
3332	case HDMIRX_CEC_SEND_GIVE_OSD_NAME_MESSAGE: {
3333	int i = 0, tmp_buf_size = 0, ret = 0;
3334	int sourceinput = p.readInt32();
3335	LOGD("HDMIRX_CEC_SEND_GIVE_OSD_NAME_MESSAGE: sourceinput = %x", sourceinput);
3336	tmp_buf_size = mpTv->SendHDMIRxCECGiveOSDNameMessage((tv_source_input_t)sourceinput, tmp_uc_buf);
3337	r->writeInt32(tmp_buf_size);
3338	for (i = 0; i < tmp_buf_size; i++) {
3339	r->writeInt32(tmp_uc_buf[i]);
3340	}
3341	r->writeInt32(tmp_buf_size);
3342	break;
3343	}
3344
3345	case GET_HDMI_KSV_INFO: {
3346	int tmpRet = 0;
3347	int ksv_data[2] = {0, 0};
3348	tmpRet = mpTv->GetHdmiHdcpKeyKsvInfo(ksv_data);
3349	r->writeInt32(tmpRet);
3350	r->writeInt32(ksv_data[0]);
3351	r->writeInt32(ksv_data[1]);
3352	break;
3353	}
3354
3355	case HDMI_OUT_TOWHAT: {
3356	r->writeInt32(mpTv->hdmiOutWithFbc() ? 1 : 0);
3357	break;
3358	}
3359	case FACTORY_FBC_UPGRADE: {
3360	String16 tmpName = p.readString16();
3361	String8 strName = String8(tmpName);
3362	sprintf((char *)tmp_uc_buf, "%s", strName.string());
3363	int mode = p.readInt32();
3364	int upgrade_blk_size = p.readInt32();
3365	int ret = mpTv->StartUpgradeFBC((char *)tmp_uc_buf, mode, upgrade_blk_size);
3366	r->writeInt32(ret);
3367	break;
3368	}
3369
3370	case FACTORY_FBC_SET_BRIGHTNESS: {
3371	int value = p.readInt32();
3372	int ret = mpTv->Tv_FactorySet_FBC_Brightness(value);
3373	r->writeInt32(ret);
3374	break;
3375	}
3376
3377	case FACTORY_FBC_GET_BRIGHTNESS: {
3378	int ret = mpTv->Tv_FactoryGet_FBC_Brightness();
3379	r->writeInt32(ret);
3380	break;
3381	}
3382
3383	case FACTORY_FBC_SET_CONTRAST: {
3384	int value = p.readInt32();
3385	int ret = mpTv->Tv_FactorySet_FBC_Contrast(value);
3386	r->writeInt32(ret);
3387	break;
3388	}
3389
3390	case FACTORY_FBC_GET_CONTRAST: {
3391	int ret = mpTv->Tv_FactoryGet_FBC_Contrast();
3392	r->writeInt32(ret);
3393	break;
3394	}
3395
3396	case FACTORY_FBC_SET_SATURATION: {
3397	int value = p.readInt32();
3398	int ret = mpTv->Tv_FactorySet_FBC_Saturation(value);
3399	r->writeInt32(ret);
3400	break;
3401	}
3402
3403	case FACTORY_FBC_GET_SATURATION: {
3404	int ret = mpTv->Tv_FactoryGet_FBC_Saturation();
3405	r->writeInt32(ret);
3406	break;
3407	}
3408
3409	case FACTORY_FBC_SET_HUE: {
3410	int value = p.readInt32();
3411	int ret = mpTv->Tv_FactorySet_FBC_HueColorTint(value);
3412	r->writeInt32(ret);
3413	break;
3414	}
3415
3416	case FACTORY_FBC_GET_HUE: {
3417	int ret = mpTv->Tv_FactoryGet_FBC_HueColorTint();
3418	r->writeInt32(ret);
3419	break;
3420	}
3421
3422	case FACTORY_FBC_SET_BACKLIGHT: {
3423	int value = p.readInt32();
3424	int ret = mpTv->Tv_FactorySet_FBC_Backlight(value);
3425	r->writeInt32(ret);
3426	break;
3427	}
3428
3429	case FACTORY_FBC_GET_BACKLIGHT: {
3430	int ret = mpTv->Tv_FactoryGet_FBC_Backlight();
3431	r->writeInt32(ret);
3432	break;
3433	}
3434	case FACTROY_FBC_SET_LIGHT_SENSOR_STATUS_N310: {
3435	int value = p.readInt32();
3436	int ret = mpTv->Tv_FactorySet_FBC_LightSensor_Status_N310(value);
3437	r->writeInt32(ret);
3438	break;
3439	}
3440
3441	case FACTROY_FBC_GET_LIGHT_SENSOR_STATUS_N310: {
3442	int ret = mpTv->Tv_FactoryGet_FBC_LightSensor_Status_N310();
3443	r->writeInt32(ret);
3444	break;
3445	}
3446	case FACTROY_FBC_SET_DREAM_PANEL_STATUS_N310: {
3447	int value = p.readInt32();
3448	int ret = mpTv->Tv_FactorySet_FBC_Dream_Panel_Status_N310(value);
3449	r->writeInt32(ret);
3450	break;
3451	}
3452
3453	case FACTROY_FBC_GET_DREAM_PANEL_STATUS_N310: {
3454	int ret = mpTv->Tv_FactoryGet_FBC_Dream_Panel_Status_N310();
3455	r->writeInt32(ret);
3456	break;
3457	}
3458	case FACTROY_FBC_SET_MULT_PQ_STATUS_N310: {
3459	int value = p.readInt32();
3460	int ret = mpTv->Tv_FactorySet_FBC_MULT_PQ_Status_N310(value);
3461	r->writeInt32(ret);
3462	break;
3463	}
3464
3465	case FACTROY_FBC_GET_MULT_PQ_STATUS_N310: {
3466	int ret = mpTv->Tv_FactoryGet_FBC_MULT_PQ_Status_N310();
3467	r->writeInt32(ret);
3468	break;
3469	}
3470	case FACTROY_FBC_SET_MEMC_STATUS_N310: {
3471	int value = p.readInt32();
3472	int ret = mpTv->Tv_FactorySet_FBC_MEMC_Status_N310(value);
3473	r->writeInt32(ret);
3474	break;
3475	}
3476
3477	case FACTROY_FBC_GET_MEMC_STATUS_N310: {
3478	int ret = mpTv->Tv_FactoryGet_FBC_MEMC_Status_N310();
3479	r->writeInt32(ret);
3480	break;
3481	}
3482
3483	case MISC_SET_2K_TO_4K_SCALE_UP_MODE : {
3484	int value = p.readInt32();
3485	int ret = mpTv->Tv_Set2k4k_ScalerUp_Mode(value);
3486	r->writeInt32(ret);
3487	break;
3488	}
3489
3490	case MISC_GET_2K_TO_4K_SCALE_UP_MODE: {
3491	int ret = mpTv->Tv_Get2k4k_ScalerUp_Mode();
3492	r->writeInt32(ret);
3493	break;
3494	}
3495	case FACTORY_FBC_SET_BACKLIGHT_EN : {
3496	int value = p.readInt32();
3497	int ret = mpTv->Tv_FactorySet_FBC_backlight_onoff(value);
3498	r->writeInt32(ret);
3499	break;
3500	}
3501
3502	case FACTORY_FBC_GET_BACKLIGHT_EN: {
3503	int ret = mpTv->Tv_FactoryGet_FBC_backlight_onoff();
3504	r->writeInt32(ret);
3505	break;
3506	}
3507	case FACTORY_FBC_TEST_PATTERN: {
3508	int value = p.readInt32();
3509	int ret = mpTv->Tv_SetTestPattern(value);
3510	r->writeInt32(ret);
3511	break;
3512	}
3513	case FACTORY_FBC_SET_LVDS_SSG: {
3514	int value = p.readInt32();
3515	int ret = mpTv->Tv_FactorySet_FBC_LVDS_SSG_Set(value);
3516	r->writeInt32(ret);
3517	break;
3518	}
3519
3520	case FACTORY_FBC_SET_ELEC_MODE: {
3521	int value = p.readInt32();
3522	int ret = mpTv->Tv_FactorySet_FBC_ELEC_MODE(value);
3523	r->writeInt32(ret);
3524	break;
3525	}
3526
3527	case FACTORY_FBC_GET_ELEC_MODE: {
3528	int ret = mpTv->Tv_FactoryGet_FBC_ELEC_MODE();
3529	r->writeInt32(ret);
3530	break;
3531	}
3532
3533	case FACTORY_FBC_SET_BACKLIGHT_N360: {
3534	int value = p.readInt32();
3535	int ret = mpTv->Tv_FactorySet_FBC_BACKLIGHT_N360(value);
3536	r->writeInt32(ret);
3537	break;
3538	}
3539
3540	case FACTORY_FBC_GET_BACKLIGHT_N360: {
3541	int ret = mpTv->Tv_FactoryGet_FBC_BACKLIGHT_N360();
3542	r->writeInt32(ret);
3543	break;
3544	}
3545
3546
3547	case FACTORY_FBC_SET_PIC_MODE: {
3548	int value = p.readInt32();
3549	int ret = mpTv->Tv_FactorySet_FBC_Picture_Mode(value);
3550	r->writeInt32(ret);
3551	break;
3552	}
3553
3554	case FACTORY_FBC_GET_PIC_MODE: {
3555	int ret = mpTv->Tv_FactoryGet_FBC_Picture_Mode();
3556	r->writeInt32(ret);
3557	break;
3558	}
3559
3560	case FACTORY_FBC_SET_TEST_PATTERN: {
3561	int value = p.readInt32();
3562	int ret = mpTv->Tv_FactorySet_FBC_Set_Test_Pattern(value);
3563	r->writeInt32(ret);
3564	break;
3565	}
3566
3567	case FACTORY_FBC_GET_TEST_PATTERN: {
3568	int ret = mpTv->Tv_FactoryGet_FBC_Get_Test_Pattern();
3569	r->writeInt32(ret);
3570	break;
3571	}
3572
3573	case FACTORY_FBC_SET_GAIN_RED: {
3574	int value = p.readInt32();
3575	int ret = mpTv->Tv_FactorySet_FBC_Gain_Red(value);
3576	r->writeInt32(ret);
3577	break;
3578	}
3579
3580	case FACTORY_FBC_GET_GAIN_RED: {
3581	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Red();
3582	r->writeInt32(ret);
3583	break;
3584	}
3585
3586	case FACTORY_FBC_SET_GAIN_GREEN: {
3587	int value = p.readInt32();
3588	int ret = mpTv->Tv_FactorySet_FBC_Gain_Green(value);
3589	r->writeInt32(ret);
3590	break;
3591	}
3592
3593	case FACTORY_FBC_GET_GAIN_GREEN: {
3594	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Green();
3595	r->writeInt32(ret);
3596	break;
3597	}
3598
3599	case FACTORY_FBC_SET_GAIN_BLUE: {
3600	int value = p.readInt32();
3601	int ret = mpTv->Tv_FactorySet_FBC_Gain_Blue(value);
3602	r->writeInt32(ret);
3603	break;
3604	}
3605
3606	case FACTORY_FBC_GET_GAIN_BLUE: {
3607	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Blue();
3608	r->writeInt32(ret);
3609	break;
3610	}
3611
3612	case FACTORY_FBC_SET_OFFSET_RED: {
3613	int value = p.readInt32();
3614	int ret = mpTv->Tv_FactorySet_FBC_Offset_Red(value);
3615	r->writeInt32(ret);
3616	break;
3617	}
3618
3619	case FACTORY_FBC_GET_OFFSET_RED: {
3620	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Red();
3621	r->writeInt32(ret);
3622	break;
3623	}
3624
3625	case FACTORY_FBC_SET_OFFSET_GREEN: {
3626	int value = p.readInt32();
3627	int ret = mpTv->Tv_FactorySet_FBC_Offset_Green(value);
3628	r->writeInt32(ret);
3629	break;
3630	}
3631
3632	case FACTORY_FBC_GET_OFFSET_GREEN: {
3633	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Green();
3634	r->writeInt32(ret);
3635	break;
3636	}
3637
3638	case FACTORY_FBC_SET_OFFSET_BLUE: {
3639	int value = p.readInt32();
3640	int ret = mpTv->Tv_FactorySet_FBC_Offset_Blue(value);
3641	r->writeInt32(ret);
3642	break;
3643	}
3644
3645	case FACTORY_FBC_GET_OFFSET_BLUE: {
3646	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Blue();
3647	r->writeInt32(ret);
3648	break;
3649	}
3650
3651	case FACTORY_FBC_SET_COLORTEMP_MODE: {
3652	int value = p.readInt32();
3653	int ret = mpTv->Tv_FactorySet_FBC_ColorTemp_Mode(value);
3654	r->writeInt32(ret);
3655	break;
3656	}
3657
3658	case FACTORY_FBC_GET_COLORTEMP_MODE: {
3659	int ret = mpTv->Tv_FactoryGet_FBC_ColorTemp_Mode();
3660	r->writeInt32(ret);
3661	break;
3662	}
3663
3664	case FACTORY_FBC_SET_COLORTEMP_MODE_N360: {
3665	int value = p.readInt32();
3666	int ret = mpTv->Tv_FactorySet_FBC_ColorTemp_Mode_N360(value);
3667	r->writeInt32(ret);
3668	break;
3669	}
3670
3671	case FACTORY_FBC_GET_COLORTEMP_MODE_N360: {
3672	int ret = mpTv->Tv_FactoryGet_FBC_ColorTemp_Mode_N360();
3673	r->writeInt32(ret);
3674	break;
3675	}
3676
3677	case FACTORY_FBC_SET_WB_INIT: {
3678	int value = p.readInt32();
3679	int ret = mpTv->Tv_FactorySet_FBC_WB_Initial(value);
3680	r->writeInt32(ret);
3681	break;
3682	}
3683
3684	case FACTORY_FBC_GET_WB_INIT: {
3685	int ret = mpTv->Tv_FactoryGet_FBC_WB_Initial();
3686	r->writeInt32(ret);
3687	break;
3688	}
3689
3690	case FACTORY_FBC_GET_MAINCODE_VERSION: {
3691	char sw_version[64];
3692	char build_time[64];
3693	char git_version[64];
3694	char git_branch[64];
3695	char build_name[64];
3696	CFbcCommunication *fbcIns = GetSingletonFBC();
3697	if (fbcIns != NULL) {
3698	fbcIns->cfbc_Get_FBC_MAINCODE_Version(COMM_DEV_SERIAL, sw_version, build_time, git_version, git_branch, build_name);
3699	r->writeString16(String16(sw_version));
3700	r->writeString16(String16(build_time));
3701	r->writeString16(String16(git_version));
3702	r->writeString16(String16(git_branch));
3703	r->writeString16(String16(build_name));
3704	} else {
3705	r->writeString16(String16("No FBC"));
3706	r->writeString16(String16("No FBC"));
3707	r->writeString16(String16("No FBC"));
3708	r->writeString16(String16("No FBC"));
3709	r->writeString16(String16("No FBC"));
3710	}
3711	break;
3712	}
3713	case FACTORY_SET_SN: {
3714	char StrFactSN[256] = {0};
3715	String16 strTemFactorySn = p.readString16();
3716	String8 strFactorySn = String8(strTemFactorySn);
3717	sprintf((char *)StrFactSN, "%s", strFactorySn.string());
3718	CFbcCommunication *fbcIns = GetSingletonFBC();
3719	if (fbcIns != NULL) {
3720	int iRet = fbcIns->cfbc_Set_FBC_Factory_SN(COMM_DEV_SERIAL, (const char *)StrFactSN);
3721	r->writeInt32(iRet);
3722	} else {
3723	r->writeInt32(-1);
3724	}
3725	break;
3726	}
3727	case FACTORY_GET_SN: {
3728	char factorySerialNumber[256] = {0};
3729	memset((void *)factorySerialNumber, 0, 256);
3730	CFbcCommunication *fbcIns = GetSingletonFBC();
3731	if (fbcIns != NULL) {
3732	fbcIns->cfbc_Get_FBC_Factory_SN(COMM_DEV_SERIAL, factorySerialNumber);
3733	r->writeString16(String16(factorySerialNumber));
3734	} else {
3735	r->writeString16(String16("No FBC"));
3736	}
3737	break;
3738	}
3739	case FACTORY_FBC_PANEL_GET_INFO: {
3740	char panel_model[64];
3741	CFbcCommunication *fbcIns = GetSingletonFBC();
3742	if (fbcIns != NULL) {
3743	fbcIns->cfbc_Get_FBC_Get_PANel_INFO(COMM_DEV_SERIAL, panel_model);
3744	r->writeString16(String16(panel_model));
3745	} else {
3746	r->writeString16(String16(""));
3747	}
3748	break;
3749	}
3750	case FACTORY_FBC_PANEL_POWER_SWITCH: {
3751	int value = p.readInt32();
3752	CFbcCommunication *fbcIns = GetSingletonFBC();
3753	if (fbcIns != NULL) {
3754	int ret = fbcIns->cfbc_Set_FBC_panel_power_switch(COMM_DEV_SERIAL, value);
3755	r->writeInt32(ret);
3756	} else {
3757	r->writeInt32(-1);
3758	}
3759	break;
3760	}
3761	case FACTORY_FBC_PANEL_SUSPEND: {
3762	int value = p.readInt32();
3763	CFbcCommunication *fbcIns = GetSingletonFBC();
3764	if (fbcIns != NULL) {
3765	int ret = fbcIns->cfbc_Set_FBC_suspend(COMM_DEV_SERIAL, value);
3766	r->writeInt32(ret);
3767	} else {
3768	r->writeInt32(-1);
3769	}
3770	break;
3771	}
3772	case FACTORY_FBC_PANEL_USER_SETTING_DEFAULT: {
3773	int value = p.readInt32();
3774	CFbcCommunication *fbcIns = GetSingletonFBC();
3775	if (fbcIns != NULL) {
3776	int ret = fbcIns->cfbc_Set_FBC_User_Setting_Default(COMM_DEV_SERIAL, value);
3777	r->writeInt32(ret);
3778	} else {
3779	r->writeInt32(-1);
3780	}
3781	break;
3782	}
3783	case FACTORY_FBC_VIDEO_MUTE: {
3784	CFbcCommunication *fbcIns = GetSingletonFBC();
3785	if (fbcIns != NULL) {
3786	int ret = fbcIns->cfbc_Set_VMute(COMM_DEV_SERIAL, 1);
3787	r->writeInt32(ret);
3788	} else {
3789	r->writeInt32(-1);
3790	}
3791	break;
3792	}
3793	case FACTORY_FBC_POWER_REBOOT: {
3794	int value = p.readInt32();
3795	CFbcCommunication *fbcIns = GetSingletonFBC();
3796	if (fbcIns != NULL) {
3797	int ret = fbcIns->cfbc_SendRebootToUpgradeCmd(COMM_DEV_SERIAL, value);
3798	r->writeInt32(ret);
3799	} else {
3800	r->writeInt32(-1);
3801	}
3802	break;
3803	}
3804	case FACTORY_FBC_SEND_KEY_TO_FBC: {
3805	int keyCode = p.readInt32();
3806	int param = p.readInt32();
3807	CFbcCommunication *fbcIns = GetSingletonFBC();
3808	if (fbcIns != NULL) {
3809	int ret = fbcIns->cfbc_FBC_Send_Key_To_Fbc(COMM_DEV_SERIAL, keyCode, param);
3810	r->writeInt32(ret);
3811	} else {
3812	r->writeInt32(-1);
3813	}
3814	break;
3815	}
3816	case FACTORY_WHITE_BALANCE_SET_GAIN_RED: {
3817	int source_type = p.readInt32();
3818	int colortemp_mode = p.readInt32();
3819	int value = p.readInt32();
3820	int ret = mpTv->Tv_FactorySetWhiteBalanceRedGain(source_type, colortemp_mode, value);
3821	r->writeInt32(ret);
3822	break;
3823	}
3824	case FACTORY_WHITE_BALANCE_GET_GAIN_RED: {
3825	int source_type = p.readInt32();
3826	int colortemp_mode = p.readInt32();
3827	int ret = mpTv->Tv_FactoryGetWhiteBalanceRedGain(source_type, colortemp_mode);
3828	r->writeInt32(ret);
3829	break;
3830	}
3831	case FACTORY_WHITE_BALANCE_SET_GAIN_GREEN: {
3832	int source_type = p.readInt32();
3833	int colortemp_mode = p.readInt32();
3834	int value = p.readInt32();
3835	int ret = mpTv->Tv_FactorySetWhiteBalanceGreenGain(source_type, colortemp_mode, value);
3836	r->writeInt32(ret);
3837	break;
3838	}
3839	case FACTORY_WHITE_BALANCE_GET_GAIN_GREEN: {
3840	int source_type = p.readInt32();
3841	int colortemp_mode = p.readInt32();
3842	int ret = mpTv->Tv_FactoryGetWhiteBalanceGreenGain(source_type, colortemp_mode);
3843	r->writeInt32(ret);
3844	break;
3845	}
3846	case FACTORY_WHITE_BALANCE_SET_GAIN_BLUE: {
3847	int source_type = p.readInt32();
3848	int colortemp_mode = p.readInt32();
3849	int value = p.readInt32();
3850	int ret = mpTv->Tv_FactorySetWhiteBalanceBlueGain(source_type, colortemp_mode, value);
3851	r->writeInt32(ret);
3852	break;
3853	}
3854	case FACTORY_WHITE_BALANCE_GET_GAIN_BLUE: {
3855	int source_type = p.readInt32();
3856	int colortemp_mode = p.readInt32();
3857	int ret = mpTv->Tv_FactoryGetWhiteBalanceBlueGain(source_type, colortemp_mode);
3858	r->writeInt32(ret);
3859	break;
3860	}
3861	case FACTORY_WHITE_BALANCE_SET_OFFSET_RED: {
3862	int source_type = p.readInt32();
3863	int colortemp_mode = p.readInt32();
3864	int value = p.readInt32();
3865	int ret = mpTv->Tv_FactorySetWhiteBalanceRedOffset(source_type, colortemp_mode, value);
3866	r->writeInt32(ret);
3867	break;
3868	}
3869	case FACTORY_WHITE_BALANCE_GET_OFFSET_RED: {
3870	int source_type = p.readInt32();
3871	int colortemp_mode = p.readInt32();
3872	int ret = mpTv->Tv_FactoryGetWhiteBalanceRedOffset(source_type, colortemp_mode);
3873	r->writeInt32(ret);
3874	break;
3875	}
3876	case FACTORY_WHITE_BALANCE_SET_OFFSET_GREEN: {
3877	int source_type = p.readInt32();
3878	int colortemp_mode = p.readInt32();
3879	int value = p.readInt32();
3880	int ret = mpTv->Tv_FactorySetWhiteBalanceGreenOffset(source_type, colortemp_mode, value);
3881	r->writeInt32(ret);
3882	break;
3883	}
3884	case FACTORY_WHITE_BALANCE_GET_OFFSET_GREEN: {
3885	int source_type = p.readInt32();
3886	int colortemp_mode = p.readInt32();
3887	int ret = mpTv->Tv_FactoryGetWhiteBalanceGreenOffset(source_type, colortemp_mode);
3888	r->writeInt32(ret);
3889	break;
3890	}
3891	case FACTORY_WHITE_BALANCE_SET_OFFSET_BLUE: {
3892	int source_type = p.readInt32();
3893	int colortemp_mode = p.readInt32();
3894	int value = p.readInt32();
3895	int ret = mpTv->Tv_FactorySetWhiteBalanceBlueOffset(source_type, colortemp_mode, value);
3896	r->writeInt32(ret);
3897	break;
3898	}
3899	case FACTORY_WHITE_BALANCE_GET_OFFSET_BLUE: {
3900	int source_type = p.readInt32();
3901	int colortemp_mode = p.readInt32();
3902	int ret = mpTv->Tv_FactoryGetWhiteBalanceBlueOffset(source_type, colortemp_mode);
3903	r->writeInt32(ret);
3904	break;
3905	}
3906	case FACTORY_WHITE_BALANCE_GET_COLOR_TMP: {
3907	int source_type = p.readInt32();
3908	int ret = mpTv->Tv_FactoryGetWhiteBalanceColorTempMode(source_type);
3909	r->writeInt32(ret);
3910	break;
3911	}
3912	case FACTORY_WHITE_BALANCE_SET_COLOR_TMP: {
3913	int source_type = p.readInt32();
3914	int Tempmode = p.readInt32();
3915	int is_save = p.readInt32();
3916	int ret = mpTv->Tv_FactorySetWhiteBalanceColorTempMode(source_type, Tempmode, is_save);
3917	r->writeInt32(ret);
3918	break;
3919	}
3920	case FACTORY_WHITE_BALANCE_SAVE_PRAMAS: {
3921	int source_type = p.readInt32();
3922	int mode = p.readInt32();
3923	int r_gain = p.readInt32();
3924	int g_gain = p.readInt32();
3925	int b_gain = p.readInt32();
3926	int r_offset = p.readInt32();
3927	int g_offset = p.readInt32();
3928	int b_offset = p.readInt32();
3929	int ret = mpTv->Tv_FactorySaveWhiteBalancePramas(source_type, mode, r_gain, g_gain, b_gain, r_offset, g_offset, b_offset);
3930	r->writeInt32(ret);
3931	break;
3932	}
3933	case FACTORY_WHITE_BALANCE_OPEN_GRAY_PATTERN: {
3934	int ret = mpTv->Tv_FactoryOpenWhiteBalanceGrayPattern();
3935	r->writeInt32(ret);
3936	break;
3937	}
3938	case FACTORY_WHITE_BALANCE_CLOSE_GRAY_PATTERN: {
3939	int ret = mpTv->Tv_FactoryCloseWhiteBalanceGrayPattern();
3940	r->writeInt32(ret);
3941	break;
3942	}
3943	case FACTORY_WHITE_BALANCE_SET_GRAY_PATTERN: {
3944	int value = p.readInt32();
3945	int ret = mpTv->Tv_FactorySetWhiteBalanceGrayPattern(value);
3946	r->writeInt32(ret);
3947	break;
3948	}
3949	case FACTORY_WHITE_BALANCE_GET_GRAY_PATTERN: {
3950	int ret = mpTv->Tv_FactoryGetWhiteBalanceGrayPattern();
3951	r->writeInt32(ret);
3952	break;
3953	}
3954	case FACTORY_WHITE_BALANCE_GET_ALL_PRAMAS: {
3955	int Tempmode = p.readInt32();
3956	tcon_rgb_ogo_t params;
3957	int ret = mpTv->GetColorTemperatureParams((vpp_color_temperature_mode_t)Tempmode, &params);
3958	r->writeInt32(ret);
3959	r->writeInt32(params.r_gain);
3960	r->writeInt32(params.g_gain);
3961	r->writeInt32(params.b_gain);
3962	r->writeInt32(params.r_post_offset);
3963	r->writeInt32(params.g_post_offset);
3964	r->writeInt32(params.b_post_offset);
3965	}
3966	case STOP_SCAN: {
3967	mpTv->stopScanLock();
3968	break;
3969	}
3970	case DTV_GET_SNR: {
3971	int tmpRet = 0;
3972	tmpRet = mpTv->getFrontendSNR();
3973	r->writeInt32(tmpRet);
3974	break;
3975	}
3976	case DTV_GET_BER: {
3977	int tmpRet = 0;
3978	tmpRet = mpTv->getFrontendBER();
3979	r->writeInt32(tmpRet);
3980	break;
3981	}
3982	case DTV_GET_STRENGTH: {
3983	int tmpRet = 0;
3984	tmpRet = mpTv->getFrontendSignalStrength();
3985	r->writeInt32(tmpRet);
3986	break;
3987	}
3988	case DTV_GET_AUDIO_TRACK_NUM: {
3989	int programId = p.readInt32();
3990	int retCnt = 0;
3991	retCnt = mpTv->getAudioTrackNum(programId);
3992	r->writeInt32(retCnt);
3993	break;
3994	}
3995	case DTV_GET_AUDIO_TRACK_INFO: {
3996	int progId = p.readInt32();
3997	int aIdx = p.readInt32();
3998	int aFmt = -1;
3999	int iRet = -1;
4000	String8 lang;
4001	iRet = mpTv->getAudioInfoByIndex(progId, aIdx, &aFmt, lang);
4002	r->writeInt32(aFmt);
4003	r->writeString16(String16(lang));
4004	break;
4005	}
4006	case DTV_SWITCH_AUDIO_TRACK: {
4007	int aPid = p.readInt32();
4008	int aFmt = p.readInt32();
4009	int aParam = p.readInt32();
4010	int ret = -1;
4011	ret = mpTv->switchAudioTrack(aPid, aFmt, aParam);
4012	r->writeInt32(ret);
4013	break;
4014	}
4015	case DTV_GET_CURR_AUDIO_TRACK_INDEX: {
4016	int currAduIdx = -1;
4017	int progId = p.readInt32();
4018	CTvProgram prog;
4019	CTvProgram::selectByID(progId, prog);
4020	currAduIdx = prog.getCurrAudioTrackIndex();
4021	r->writeInt32(currAduIdx);
4022	break;
4023	}
4024	case DTV_SET_AUDIO_CHANNEL_MOD: {
4025	int audioChannelIdx = p.readInt32();
4026	mpTv->setAudioChannel(audioChannelIdx);
4027	break;
4028	}
4029	case DTV_GET_AUDIO_CHANNEL_MOD: {
4030	int currChannelMod;
4031	currChannelMod = mpTv->getAudioChannel();
4032	r->writeInt32(currChannelMod);
4033	break;
4034	}
4035	case DTV_GET_CUR_FREQ: {
4036	int progId = p.readInt32();
4037	int freq = 0;
4038	int iRet = -1;
4039	CTvProgram prog;
4040	CTvChannel channel;
4041
4042	iRet = CTvProgram::selectByID(progId, prog);
4043	if (0 != iRet) return -1;
4044	prog.getChannel(channel);
4045	freq = channel.getFrequency();
4046	r->writeInt32(freq);
4047	break;
4048	}
4049	case DTV_GET_EPG_UTC_TIME: {
4050	int iRet = -1;
4051	int utcTime = 0;
4052
4053	utcTime = mpTv->getTvTime();
4054
4055	r->writeInt32(utcTime);
4056	break;
4057	}
4058	case DTV_GET_EPG_INFO_POINT_IN_TIME: {
4059	int progid = p.readInt32();
4060	int utcTime = p.readInt32();
4061	CTvProgram prog;
4062	int ret = CTvProgram::selectByID(progid, prog);
4063	CTvEvent ev;
4064	ret = ev.getProgPresentEvent(prog.getSrc(), prog.getID(), utcTime, ev);
4065	r->writeString16(String16(ev.getName()));
4066	r->writeString16(String16(ev.getDescription()));
4067	r->writeString16(String16(ev.getExtDescription()));
4068	r->writeInt32(ev.getStartTime());
4069	r->writeInt32(ev.getEndTime());
4070	r->writeInt32(ev.getSubFlag());
4071	r->writeInt32(ev.getEventId());
4072	break;
4073	}
4074	case DTV_GET_EPG_INFO_DURATION: {
4075	int iRet = -1;
4076	int iObOutSize = 0;
4077	Vector<sp<CTvEvent> > epgOut;
4078	int progid = p.readInt32();
4079	int iUtcStartTime = p.readInt32();
4080	int iDurationTime = p.readInt32();
4081	CTvProgram prog;
4082	CTvEvent ev;
4083	iRet = CTvProgram::selectByID(progid, prog);
4084	if (0 != iRet) {
4085	break;
4086	}
4087	iRet = ev.getProgScheduleEvents(prog.getSrc(), prog.getID(), iUtcStartTime, iDurationTime, epgOut);
4088	if (0 != iRet) {
4089	break;
4090	}
4091	iObOutSize = epgOut.size();
4092	if (0 == iObOutSize) {
4093	break;
4094	}
4095
4096	r->writeInt32(iObOutSize);
4097	for (int i = 0; i < iObOutSize; i ++) {
4098	r->writeString16(String16(epgOut[i]->getName()));
4099	r->writeString16(String16(epgOut[i]->getDescription()));
4100	r->writeString16(String16(ev.getExtDescription()));
4101	r->writeInt32(epgOut[i]->getStartTime());
4102	r->writeInt32(epgOut[i]->getEndTime());
4103	r->writeInt32(epgOut[i]->getSubFlag());
4104	r->writeInt32(epgOut[i]->getEventId());
4105	}
4106	break;
4107	}
4108	case DTV_SET_PROGRAM_NAME: {
4109	CTvProgram prog;
4110	int progid = p.readInt32();
4111	String16 tmpName = p.readString16();
4112	String8 strName = String8(tmpName);
4113	prog.updateProgramName(progid, strName);
4114	break;
4115	}
4116	case DTV_SET_PROGRAM_SKIPPED: {
4117	CTvProgram prog;
4118	int progid = p.readInt32();
4119	bool bSkipFlag = p.readInt32();
4120	prog.setSkipFlag(progid, bSkipFlag);
4121	break;
4122	}
4123	case DTV_SET_PROGRAM_FAVORITE: {
4124	CTvProgram prog;
4125	int progid = p.readInt32();
4126	bool bFavorite = p.readInt32();
4127	prog.setFavoriteFlag(progid, bFavorite);
4128	break;
4129	}
4130	case DTV_DETELE_PROGRAM: {
4131	CTvProgram prog;
4132	int progid = p.readInt32();
4133	prog.deleteProgram(progid);
4134	break;
4135	}
4136	case SET_BLACKOUT_ENABLE: {
4137	int enable = p.readInt32();
4138	mpTv->setBlackoutEnable(enable);
4139	break;
4140	}
4141	case START_AUTO_BACKLIGHT: {
4142	mpTv->startAutoBackLight();
4143	break;
4144	}
4145	case STOP_AUTO_BACKLIGHT: {
4146	mpTv->stopAutoBackLight();
4147	break;
4148	}
4149	case IS_AUTO_BACKLIGHTING: {
4150	int on = mpTv->getAutoBackLight_on_off();
4151	r->writeInt32(on);
4152	break;
4153	}
4154	case GET_AVERAGE_LUMA: {
4155	int ret = mpTv->getAverageLuma();
4156	r->writeInt32(ret);
4157	break;
4158	}
4159	case GET_AUTO_BACKLIGHT_DATA: {
4160	int i;
4161	int size = mpTv->getAutoBacklightData(tmp_i_buf);
4162	r->writeInt32(size);
4163	for (i = 0; i < size; i++) {
4164	r->writeInt32(tmp_i_buf[i]);
4165	}
4166	break;
4167	}
4168	case SET_AUTO_BACKLIGHT_DATA: {
4169	String16 tmp_str16;
4170	String8 value_str;
4171
4172	tmp_str16 = p.readString16();
4173	value_str = String8(tmp_str16);
4174
4175	int ret = mpTv->setAutobacklightData(value_str);
4176	r->writeInt32(ret);
4177	break;
4178	}
4179
4180	case SSM_READ_BLACKOUT_ENABLE: {
4181	int enable = mpTv->getSaveBlackoutEnable();
4182	r->writeInt32(enable);
4183	break;
4184	}
4185	case DTV_SWAP_PROGRAM: {
4186	CTvProgram prog;
4187	int firstProgId = p.readInt32();
4188	int secondProgId = p.readInt32();
4189	CTvProgram::selectByID(firstProgId, prog);
4190	int firstChanOrderNum = prog.getChanOrderNum();
4191	CTvProgram::selectByID(secondProgId, prog);
4192	int secondChanOrderNum = prog.getChanOrderNum();
4193	prog.swapChanOrder(firstProgId, firstChanOrderNum, secondProgId, secondChanOrderNum);
4194	break;
4195	}
4196	case DTV_SET_PROGRAM_LOCKED: {
4197	CTvProgram prog;
4198	int progid = p.readInt32();
4199	bool bLocked = p.readInt32();
4200	prog.setLockFlag(progid, bLocked);
4201	break;
4202	}
4203	case DTV_SET_BOOKING_FLAG: {
4204	CTvEvent ev;
4205	int iEvtId = p.readInt32();
4206	bool iBookFlag = (bool)p.readInt32();
4207	ev.bookEvent(iEvtId, iBookFlag);
4208	break;
4209	}
4210	case DTV_GET_FREQ_BY_PROG_ID: {
4211	int freq = 0;
4212	int progid = p.readInt32();
4213	CTvProgram prog;
4214	int ret = CTvProgram::selectByID(progid, prog);
4215	if (ret != 0) return -1;
4216	CTvChannel channel;
4217	prog.getChannel(channel);
4218	freq = channel.getFrequency();
4219	r->writeInt32(freq);
4220	break;
4221	}
4222	case DTV_GET_BOOKED_EVENT: {
4223	CTvBooking tvBook;
4224	Vector<sp<CTvBooking> > vTvBookOut;
4225	tvBook.getBookedEventList(vTvBookOut);
4226	int iObOutSize = vTvBookOut.size();
4227	if (0 == iObOutSize) {
4228	break;
4229	}
4230	r->writeInt32(iObOutSize);
4231	for (int i = 0; i < iObOutSize; i ++) {
4232	r->writeString16(String16(vTvBookOut[i]->getProgName()));
4233	r->writeString16(String16(vTvBookOut[i]->getEvtName()));
4234	r->writeInt32(vTvBookOut[i]->getStartTime());
4235	r->writeInt32(vTvBookOut[i]->getDurationTime());
4236	r->writeInt32(vTvBookOut[i]->getBookId());
4237	r->writeInt32(vTvBookOut[i]->getProgramId());
4238	r->writeInt32(vTvBookOut[i]->getEventId());
4239	}
4240	break;
4241	}
4242	case SET_FRONTEND_PARA: {
4243	int ret = -1;
4244	frontend_para_set_t feParms;
4245	feParms.mode = (fe_type_t)p.readInt32();
4246	feParms.freq = p.readInt32();
4247	feParms.videoStd = (atv_video_std_t)p.readInt32();
4248	feParms.audioStd = (atv_audio_std_t)p.readInt32();
4249	feParms.para1 = p.readInt32();
4250	feParms.para2 = p.readInt32();
4251	mpTv->resetFrontEndPara(feParms);
4252	r->writeInt32(ret);
4253	break;
4254	}
4255	case PLAY_PROGRAM: {
4256	int mode = p.readInt32();
4257	int freq = p.readInt32();
4258	if (mode == FE_ANALOG) {
4259	int videoStd = p.readInt32();
4260	int audioStd = p.readInt32();
4261	int fineTune = p.readInt32();
4262	int audioCompetation = p.readInt32();
4263	mpTv->playAtvProgram(freq, videoStd, audioStd, fineTune, audioCompetation);
4264	} else {
4265	int para1 = p.readInt32();
4266	int para2 = p.readInt32();
4267	int vid = p.readInt32();
4268	int vfmt = p.readInt32();
4269	int aid = p.readInt32();
4270	int afmt = p.readInt32();
4271	int pcr = p.readInt32();
4272	int audioCompetation = p.readInt32();
4273	mpTv->playDtvProgram(mode, freq, para1, para2, vid, vfmt, aid, afmt, pcr, audioCompetation);
4274	}
4275	break;
4276	}
4277	case GET_PROGRAM_LIST: {
4278	Vector<sp<CTvProgram> > out;
4279	int type = p.readInt32();
4280	int skip = p.readInt32();
4281	CTvProgram::selectByType(type, skip, out);
4282	r->writeInt32(out.size());
4283	for (int i = 0; i < (int)out.size(); i++) {
4284	r->writeInt32(out[i]->getID());
4285	r->writeInt32(out[i]->getChanOrderNum());
4286	r->writeInt32(out[i]->getMajor());
4287	r->writeInt32(out[i]->getMinor());
4288	r->writeInt32(out[i]->getProgType());
4289	r->writeString16(String16(out[i]->getName()));
4290	r->writeInt32(out[i]->getProgSkipFlag());
4291	r->writeInt32(out[i]->getFavoriteFlag());
4292	r->writeInt32(out[i]->getVideo()->getFormat());
4293	CTvChannel ch;
4294	out[i]->getChannel(ch);
4295	r->writeInt32(ch.getDVBTSID());
4296	r->writeInt32(out[i]->getServiceId());
4297	r->writeInt32(out[i]->getVideo()->getPID());
4298	r->writeInt32(out[i]->getVideo()->getPID());
4299
4300	int audioTrackSize = out[i]->getAudioTrackSize();
4301	r->writeInt32(audioTrackSize);
4302	for (int j = 0; j < audioTrackSize; j++) {
4303	r->writeString16(String16(out[i]->getAudio(j)->getLang()));
4304	r->writeInt32(out[i]->getAudio(j)->getFormat());
4305	r->writeInt32(out[i]->getAudio(j)->getPID());
4306	}
4307	Vector<CTvProgram::Subtitle *> mvSubtitles = out[i]->getSubtitles();
4308	int subTitleSize = mvSubtitles.size();
4309	r->writeInt32(subTitleSize);
4310	if (subTitleSize > 0) {
4311	for (int k = 0; k < subTitleSize; k++) {
4312	r->writeInt32(mvSubtitles[k]->getPID());
4313	r->writeString16(String16(mvSubtitles[k]->getLang()));
4314	r->writeInt32(mvSubtitles[k]->getCompositionPageID());
4315	r->writeInt32(mvSubtitles[k]->getAncillaryPageID());
4316	}
4317	}
4318	r->writeInt32(ch.getFrequency());
4319	}
4320	break;
4321	}
4322	case DTV_GET_VIDEO_FMT_INFO: {
4323	int srcWidth = 0;
4324	int srcHeight = 0;
4325	int srcFps = 0;
4326	int srcInterlace = 0;
4327	int iRet = -1;
4328
4329	iRet == mpTv->getVideoFormatInfo(&srcWidth, &srcHeight, &srcFps, &srcInterlace);
4330	r->writeInt32(srcWidth);
4331	r->writeInt32(srcHeight);
4332	r->writeInt32(srcFps);
4333	r->writeInt32(srcInterlace);
4334	r->writeInt32(iRet);
4335	}
4336	break;
4337
4338	case DTV_START_RECORD: {
4339	char buf[256];
4340	String16 tmpName = p.readString16();
4341	String8 strName = String8(tmpName);
4342	sprintf(buf, "%s", strName.string());
4343	mpTv->SetRecordFileName(buf);
4344	mpTv->StartToRecord();
4345	}
4346	break;
4347	case DTV_STOP_RECORD:
4348	mpTv->StopRecording();
4349	break;
4350	case DTV_SET_RECORD_ALL_TS: {
4351	int sel = p.readInt32();
4352	mpTv->SetRecCurTsOrCurProgram(sel);
4353	}
4354	break;
4355	case TV_PRINT_DEBUG_INFO:
4356	mpTv->printDebugInfo();
4357	break;
4358	case HDMIAV_HOTPLUGDETECT_ONOFF: {
4359	int flag = mpTv->GetHdmiAvHotplugDetectOnoff();
4360	r->writeInt32(flag);
4361	}
4362	break;
4363
4364	// 2.4G headset
4365	case START_OPEN_HEADSET_DETECT: {
4366	int flag = mpTv->StartHeadSetDetect();
4367	r->writeInt32(flag);
4368	}
4369	break;
4370
4371	// EXTAR END
4372	default:
4373	LOGD("default");
4374	break;
4375	}
4376
4377	LOGD("exit client=%d cmd=%d", getCallingPid(), cmd);
4378	return 0;
4379	}
4380
4381	sp<TvService::Client> TvService::Client::getClientFromCookie(void *user)
4382	{
4383	sp<Client> client = 0;
4384	/*
4385	TvService *service = static_cast<TvService*> (user);
4386	if (service != NULL) {
4387	Mutex::Autolock ourLock(service->mServiceLock);
4388	if (service->mClient != 0) {
4389	client = service->mClient.promote();
4390	if (client == 0) {
4391	LOGE("getClientFromCookie: client appears to have died");
4392	service->mClient.clear();
4393	}
4394	} else {
4395	LOGE("getClientFromCookie: got callback but client was NULL");
4396	}
4397	}*/
4398
4399	user = user;//for warning
4400	return client;
4401	}
4402
4403	void TvService::Client::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void *user)
4404	{
4405	LOGD("notifyCallback(%d)", msgType);
4406
4407	sp<Client> client = getClientFromCookie(user);
4408	if (client == 0) {
4409	return;
4410	}
4411
4412	switch (msgType) {
4413	//case TV_MSG_SHUTTER:
4414	// ext1 is the dimension of the yuv picture.
4415	// client->handleShutter((image_rect_type *)ext1);
4416	// break;
4417	default:
4418	sp<ITvClient> c = client->mTvClient;
4419	if (c != NULL) {
4420	//c->notifyCallback(msgType, ext1, ext2);
4421	}
4422	break;
4423	}
4424
4425	//for warning
4426	ext1 = ext1;
4427	ext2 = ext2;
4428
4429	#if DEBUG_CLIENT_REFERENCES
4430	if (client->getStrongCount() == 1) {
4431	LOGE("++++++++++++++++ (NOTIFY CALLBACK) THIS WILL CAUSE A LOCKUP!");
4432	client->printRefs();
4433	}
4434	#endif
4435	}
4436
4437	int TvService::Client::notifyCallback(const int &msgtype, const Parcel &p)
4438	{
4439	mTvClient->notifyCallback(msgtype, p);
4440	return 0;
4441	}
4442
4443	status_t TvService::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
4444	{
4445	// permission checks...
4446	switch (code) {
4447	case BnTvService::CONNECT:
4448	IPCThreadState *ipc = IPCThreadState::self();
4449	const int pid = ipc->getCallingPid();
4450	const int self_pid = getpid();
4451	if (pid != self_pid) {
4452	// we're called from a different process, do the real check
4453	/*if (!checkCallingPermission(
4454	String16("android.permission.TV")))
4455	{
4456	const int uid = ipc->getCallingUid();
4457	LOGE("Permission Denial: "
4458	"can't use the tv pid=%d, uid=%d", pid, uid);
4459	return PERMISSION_DENIED;
4460	}*/
4461	}
4462	break;
4463	}
4464
4465	status_t err = BnTvService::onTransact(code, data, reply, flags);
4466
4467	#if DEBUG_HEAP_LEAKS
4468	LOGE("+++ onTransact err %d code %d", err, code);
4469
4470	if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
4471	LOGE("+++ onTransact code %d", code);
4472
4473	CHECK_INTERFACE(ITvService, data, reply);
4474
4475	switch (code) {
4476	case 1000: {
4477	if (gWeakHeap != 0) {
4478	sp<IMemoryHeap> h = gWeakHeap.promote();
4479	IMemoryHeap *p = gWeakHeap.unsafe_get();
4480	LOGE("CHECKING WEAK REFERENCE %p (%p)", h.get(), p);
4481	if (h != 0)
4482	h->printRefs();
4483	bool attempt_to_delete = data.readInt32() == 1;
4484	if (attempt_to_delete) {
4485	// NOT SAFE!
4486	LOGE("DELETING WEAK REFERENCE %p (%p)", h.get(), p);
4487	if (p) delete p;
4488	}
4489	return NO_ERROR;
4490	}
4491	}
4492	break;
4493	default:
4494	break;
4495	}
4496	}
4497	#endif // DEBUG_HEAP_LEAKS
4498	return err;
4499	}
4500
4501