path: root/tvapi/android/tvserver/TvService.cpp (plain)
blob: 9de4fb863abb74b88a302ee9dca56cd9dc25c658

1	#include <utils/Log.h>
2	#include <binder/IServiceManager.h>
3	#include <binder/IPCThreadState.h>
4	#include <utils/String16.h>
5	#include <utils/Errors.h>
6	#include <binder/MemoryBase.h>
7	#include <binder/MemoryHeapBase.h>
8	#include <include/ITvService.h>
9	#include <hardware/hardware.h>
10	#include "TvService.h"
11	#include <cutils/atomic.h>
12	#include <cutils/properties.h>
13	#include <stdint.h>
14	#include <tvconfig/tvconfig.h>
15	#include <tvsetting/CTvSetting.h>
16	#include <audio/CTvAudio.h>
17	#include <tvutils/tvutils.h>
18	#include <version/version.h>
19	#include "../include/tvcmd.h"
20	#include "tv/CTvLog.h"
21	#include <tvdb/CTvRegion.h>
22	#include <xxxconfig.h>
23	extern "C" {
24	#include <stdio.h>
25	#include <sys/types.h>
26	#include <sys/stat.h>
27	#include <fcntl.h>
28	#include <pthread.h>
29	#include <signal.h>
30	#include "make_ext4fs.h"
31	#include "am_ver.h"
32	}
33	#define LOG_TAG "TvService"
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=%p 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("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("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, tmp_buf_size = 0, ret = 0;
2952
2953	int dev_id = p.readInt32();
2954
2955	tmp_buf_size = p.readInt32();
2956	if (tmp_buf_size > sizeof(tmp_uc_buf)) {
2957	tmp_buf_size = sizeof(tmp_uc_buf);
2958	}
2959
2960	for (i = 0; i < tmp_buf_size; i++) {
2961	tmp_uc_buf[i] = p.readInt32() & 0xFF;
2962	}
2963
2964	ret = mpTv->SendSerialData(dev_id, tmp_buf_size, 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("CHINA,Default DTMB ALL", out);
3119	r->writeInt32(out.size());
3120	for (int i = 0; i < 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	int tmpRet = mpTv->hdmi_out_towhat();
3357	r->writeInt32(tmpRet);
3358	break;
3359	}
3360	case FACTORY_FBC_UPGRADE: {
3361	String16 tmpName = p.readString16();
3362	String8 strName = String8(tmpName);
3363	sprintf((char *)tmp_uc_buf, "%s", strName.string());
3364	int mode = p.readInt32();
3365	int upgrade_blk_size = p.readInt32();
3366	int ret = mpTv->StartUpgradeFBC((char *)tmp_uc_buf, mode, upgrade_blk_size);
3367	r->writeInt32(ret);
3368	break;
3369	}
3370
3371	case FACTORY_FBC_SET_BRIGHTNESS: {
3372	int value = p.readInt32();
3373	int ret = mpTv->Tv_FactorySet_FBC_Brightness(value);
3374	r->writeInt32(ret);
3375	break;
3376	}
3377
3378	case FACTORY_FBC_GET_BRIGHTNESS: {
3379	int ret = mpTv->Tv_FactoryGet_FBC_Brightness();
3380	r->writeInt32(ret);
3381	break;
3382	}
3383
3384	case FACTORY_FBC_SET_CONTRAST: {
3385	int value = p.readInt32();
3386	int ret = mpTv->Tv_FactorySet_FBC_Contrast(value);
3387	r->writeInt32(ret);
3388	break;
3389	}
3390
3391	case FACTORY_FBC_GET_CONTRAST: {
3392	int ret = mpTv->Tv_FactoryGet_FBC_Contrast();
3393	r->writeInt32(ret);
3394	break;
3395	}
3396
3397	case FACTORY_FBC_SET_SATURATION: {
3398	int value = p.readInt32();
3399	int ret = mpTv->Tv_FactorySet_FBC_Saturation(value);
3400	r->writeInt32(ret);
3401	break;
3402	}
3403
3404	case FACTORY_FBC_GET_SATURATION: {
3405	int ret = mpTv->Tv_FactoryGet_FBC_Saturation();
3406	r->writeInt32(ret);
3407	break;
3408	}
3409
3410	case FACTORY_FBC_SET_HUE: {
3411	int value = p.readInt32();
3412	int ret = mpTv->Tv_FactorySet_FBC_HueColorTint(value);
3413	r->writeInt32(ret);
3414	break;
3415	}
3416
3417	case FACTORY_FBC_GET_HUE: {
3418	int ret = mpTv->Tv_FactoryGet_FBC_HueColorTint();
3419	r->writeInt32(ret);
3420	break;
3421	}
3422
3423	case FACTORY_FBC_SET_BACKLIGHT: {
3424	int value = p.readInt32();
3425	int ret = mpTv->Tv_FactorySet_FBC_Backlight(value);
3426	r->writeInt32(ret);
3427	break;
3428	}
3429
3430	case FACTORY_FBC_GET_BACKLIGHT: {
3431	int ret = mpTv->Tv_FactoryGet_FBC_Backlight();
3432	r->writeInt32(ret);
3433	break;
3434	}
3435	case FACTROY_FBC_SET_LIGHT_SENSOR_STATUS_N310: {
3436	int value = p.readInt32();
3437	int ret = mpTv->Tv_FactorySet_FBC_LightSensor_Status_N310(value);
3438	r->writeInt32(ret);
3439	break;
3440	}
3441
3442	case FACTROY_FBC_GET_LIGHT_SENSOR_STATUS_N310: {
3443	int ret = mpTv->Tv_FactoryGet_FBC_LightSensor_Status_N310();
3444	r->writeInt32(ret);
3445	break;
3446	}
3447	case FACTROY_FBC_SET_DREAM_PANEL_STATUS_N310: {
3448	int value = p.readInt32();
3449	int ret = mpTv->Tv_FactorySet_FBC_Dream_Panel_Status_N310(value);
3450	r->writeInt32(ret);
3451	break;
3452	}
3453
3454	case FACTROY_FBC_GET_DREAM_PANEL_STATUS_N310: {
3455	int ret = mpTv->Tv_FactoryGet_FBC_Dream_Panel_Status_N310();
3456	r->writeInt32(ret);
3457	break;
3458	}
3459	case FACTROY_FBC_SET_MULT_PQ_STATUS_N310: {
3460	int value = p.readInt32();
3461	int ret = mpTv->Tv_FactorySet_FBC_MULT_PQ_Status_N310(value);
3462	r->writeInt32(ret);
3463	break;
3464	}
3465
3466	case FACTROY_FBC_GET_MULT_PQ_STATUS_N310: {
3467	int ret = mpTv->Tv_FactoryGet_FBC_MULT_PQ_Status_N310();
3468	r->writeInt32(ret);
3469	break;
3470	}
3471	case FACTROY_FBC_SET_MEMC_STATUS_N310: {
3472	int value = p.readInt32();
3473	int ret = mpTv->Tv_FactorySet_FBC_MEMC_Status_N310(value);
3474	r->writeInt32(ret);
3475	break;
3476	}
3477
3478	case FACTROY_FBC_GET_MEMC_STATUS_N310: {
3479	int ret = mpTv->Tv_FactoryGet_FBC_MEMC_Status_N310();
3480	r->writeInt32(ret);
3481	break;
3482	}
3483
3484	case MISC_SET_2K_TO_4K_SCALE_UP_MODE : {
3485	int value = p.readInt32();
3486	int ret = mpTv->Tv_Set2k4k_ScalerUp_Mode(value);
3487	r->writeInt32(ret);
3488	break;
3489	}
3490
3491	case MISC_GET_2K_TO_4K_SCALE_UP_MODE: {
3492	int ret = mpTv->Tv_Get2k4k_ScalerUp_Mode();
3493	r->writeInt32(ret);
3494	break;
3495	}
3496	case FACTORY_FBC_SET_BACKLIGHT_EN : {
3497	int value = p.readInt32();
3498	int ret = mpTv->Tv_FactorySet_FBC_backlight_onoff(value);
3499	r->writeInt32(ret);
3500	break;
3501	}
3502
3503	case FACTORY_FBC_GET_BACKLIGHT_EN: {
3504	int ret = mpTv->Tv_FactoryGet_FBC_backlight_onoff();
3505	r->writeInt32(ret);
3506	break;
3507	}
3508	case FACTORY_FBC_TEST_PATTERN: {
3509	int value = p.readInt32();
3510	int ret = mpTv->Tv_SetTestPattern(value);
3511	r->writeInt32(ret);
3512	break;
3513	}
3514	case FACTORY_FBC_SET_LVDS_SSG: {
3515	int value = p.readInt32();
3516	int ret = mpTv->Tv_FactorySet_FBC_LVDS_SSG_Set(value);
3517	r->writeInt32(ret);
3518	break;
3519	}
3520
3521	case FACTORY_FBC_SET_ELEC_MODE: {
3522	int value = p.readInt32();
3523	int ret = mpTv->Tv_FactorySet_FBC_ELEC_MODE(value);
3524	r->writeInt32(ret);
3525	break;
3526	}
3527
3528	case FACTORY_FBC_GET_ELEC_MODE: {
3529	int ret = mpTv->Tv_FactoryGet_FBC_ELEC_MODE();
3530	r->writeInt32(ret);
3531	break;
3532	}
3533
3534	case FACTORY_FBC_SET_BACKLIGHT_N360: {
3535	int value = p.readInt32();
3536	int ret = mpTv->Tv_FactorySet_FBC_BACKLIGHT_N360(value);
3537	r->writeInt32(ret);
3538	break;
3539	}
3540
3541	case FACTORY_FBC_GET_BACKLIGHT_N360: {
3542	int ret = mpTv->Tv_FactoryGet_FBC_BACKLIGHT_N360();
3543	r->writeInt32(ret);
3544	break;
3545	}
3546
3547
3548	case FACTORY_FBC_SET_PIC_MODE: {
3549	int value = p.readInt32();
3550	int ret = mpTv->Tv_FactorySet_FBC_Picture_Mode(value);
3551	r->writeInt32(ret);
3552	break;
3553	}
3554
3555	case FACTORY_FBC_GET_PIC_MODE: {
3556	int ret = mpTv->Tv_FactoryGet_FBC_Picture_Mode();
3557	r->writeInt32(ret);
3558	break;
3559	}
3560
3561	case FACTORY_FBC_SET_TEST_PATTERN: {
3562	int value = p.readInt32();
3563	int ret = mpTv->Tv_FactorySet_FBC_Set_Test_Pattern(value);
3564	r->writeInt32(ret);
3565	break;
3566	}
3567
3568	case FACTORY_FBC_GET_TEST_PATTERN: {
3569	int ret = mpTv->Tv_FactoryGet_FBC_Get_Test_Pattern();
3570	r->writeInt32(ret);
3571	break;
3572	}
3573
3574	case FACTORY_FBC_SET_GAIN_RED: {
3575	int value = p.readInt32();
3576	int ret = mpTv->Tv_FactorySet_FBC_Gain_Red(value);
3577	r->writeInt32(ret);
3578	break;
3579	}
3580
3581	case FACTORY_FBC_GET_GAIN_RED: {
3582	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Red();
3583	r->writeInt32(ret);
3584	break;
3585	}
3586
3587	case FACTORY_FBC_SET_GAIN_GREEN: {
3588	int value = p.readInt32();
3589	int ret = mpTv->Tv_FactorySet_FBC_Gain_Green(value);
3590	r->writeInt32(ret);
3591	break;
3592	}
3593
3594	case FACTORY_FBC_GET_GAIN_GREEN: {
3595	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Green();
3596	r->writeInt32(ret);
3597	break;
3598	}
3599
3600	case FACTORY_FBC_SET_GAIN_BLUE: {
3601	int value = p.readInt32();
3602	int ret = mpTv->Tv_FactorySet_FBC_Gain_Blue(value);
3603	r->writeInt32(ret);
3604	break;
3605	}
3606
3607	case FACTORY_FBC_GET_GAIN_BLUE: {
3608	int ret = mpTv->Tv_FactoryGet_FBC_Gain_Blue();
3609	r->writeInt32(ret);
3610	break;
3611	}
3612
3613	case FACTORY_FBC_SET_OFFSET_RED: {
3614	int value = p.readInt32();
3615	int ret = mpTv->Tv_FactorySet_FBC_Offset_Red(value);
3616	r->writeInt32(ret);
3617	break;
3618	}
3619
3620	case FACTORY_FBC_GET_OFFSET_RED: {
3621	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Red();
3622	r->writeInt32(ret);
3623	break;
3624	}
3625
3626	case FACTORY_FBC_SET_OFFSET_GREEN: {
3627	int value = p.readInt32();
3628	int ret = mpTv->Tv_FactorySet_FBC_Offset_Green(value);
3629	r->writeInt32(ret);
3630	break;
3631	}
3632
3633	case FACTORY_FBC_GET_OFFSET_GREEN: {
3634	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Green();
3635	r->writeInt32(ret);
3636	break;
3637	}
3638
3639	case FACTORY_FBC_SET_OFFSET_BLUE: {
3640	int value = p.readInt32();
3641	int ret = mpTv->Tv_FactorySet_FBC_Offset_Blue(value);
3642	r->writeInt32(ret);
3643	break;
3644	}
3645
3646	case FACTORY_FBC_GET_OFFSET_BLUE: {
3647	int ret = mpTv->Tv_FactoryGet_FBC_Offset_Blue();
3648	r->writeInt32(ret);
3649	break;
3650	}
3651
3652	case FACTORY_FBC_SET_COLORTEMP_MODE: {
3653	int value = p.readInt32();
3654	int ret = mpTv->Tv_FactorySet_FBC_ColorTemp_Mode(value);
3655	r->writeInt32(ret);
3656	break;
3657	}
3658
3659	case FACTORY_FBC_GET_COLORTEMP_MODE: {
3660	int ret = mpTv->Tv_FactoryGet_FBC_ColorTemp_Mode();
3661	r->writeInt32(ret);
3662	break;
3663	}
3664
3665	case FACTORY_FBC_SET_COLORTEMP_MODE_N360: {
3666	int value = p.readInt32();
3667	int ret = mpTv->Tv_FactorySet_FBC_ColorTemp_Mode_N360(value);
3668	r->writeInt32(ret);
3669	break;
3670	}
3671
3672	case FACTORY_FBC_GET_COLORTEMP_MODE_N360: {
3673	int ret = mpTv->Tv_FactoryGet_FBC_ColorTemp_Mode_N360();
3674	r->writeInt32(ret);
3675	break;
3676	}
3677
3678	case FACTORY_FBC_SET_WB_INIT: {
3679	int value = p.readInt32();
3680	int ret = mpTv->Tv_FactorySet_FBC_WB_Initial(value);
3681	r->writeInt32(ret);
3682	break;
3683	}
3684
3685	case FACTORY_FBC_GET_WB_INIT: {
3686	int ret = mpTv->Tv_FactoryGet_FBC_WB_Initial();
3687	r->writeInt32(ret);
3688	break;
3689	}
3690
3691	case FACTORY_FBC_GET_MAINCODE_VERSION: {
3692	char sw_version[64];
3693	char build_time[64];
3694	char git_version[64];
3695	char git_branch[64];
3696	char build_name[64];
3697	CFbcCommunication *fbcIns = GetSingletonFBC();
3698	if (fbcIns != NULL) {
3699	fbcIns->cfbc_Get_FBC_MAINCODE_Version(COMM_DEV_SERIAL, sw_version, build_time, git_version, git_branch, build_name);
3700	r->writeString16(String16(sw_version));
3701	r->writeString16(String16(build_time));
3702	r->writeString16(String16(git_version));
3703	r->writeString16(String16(git_branch));
3704	r->writeString16(String16(build_name));
3705	} else {
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	r->writeString16(String16("No FBC"));
3711	}
3712	break;
3713	}
3714	case FACTORY_SET_SN: {
3715	char StrFactSN[256] = {0};
3716	String16 strTemFactorySn = p.readString16();
3717	String8 strFactorySn = String8(strTemFactorySn);
3718	sprintf((char *)StrFactSN, "%s", strFactorySn.string());
3719	CFbcCommunication *fbcIns = GetSingletonFBC();
3720	if (fbcIns != NULL) {
3721	int iRet = fbcIns->cfbc_Set_FBC_Factory_SN(COMM_DEV_SERIAL, (const char *)StrFactSN);
3722	r->writeInt32(iRet);
3723	} else {
3724	r->writeInt32(-1);
3725	}
3726	break;
3727	}
3728	case FACTORY_GET_SN: {
3729	char factorySerialNumber[256] = {0};
3730	memset((void *)factorySerialNumber, 0, 256);
3731	CFbcCommunication *fbcIns = GetSingletonFBC();
3732	if (fbcIns != NULL) {
3733	fbcIns->cfbc_Get_FBC_Factory_SN(COMM_DEV_SERIAL, factorySerialNumber);
3734	r->writeString16(String16(factorySerialNumber));
3735	} else {
3736	r->writeString16(String16("No FBC"));
3737	}
3738	break;
3739	}
3740	case FACTORY_FBC_PANEL_GET_INFO: {
3741	char panel_model[64];
3742	CFbcCommunication *fbcIns = GetSingletonFBC();
3743	if (fbcIns != NULL) {
3744	fbcIns->cfbc_Get_FBC_Get_PANel_INFO(COMM_DEV_SERIAL, panel_model);
3745	r->writeString16(String16(panel_model));
3746	} else {
3747	r->writeString16(String16(""));
3748	}
3749	break;
3750	}
3751	case FACTORY_FBC_PANEL_POWER_SWITCH: {
3752	int value = p.readInt32();
3753	CFbcCommunication *fbcIns = GetSingletonFBC();
3754	if (fbcIns != NULL) {
3755	int ret = fbcIns->cfbc_Set_FBC_panel_power_switch(COMM_DEV_SERIAL, value);
3756	r->writeInt32(ret);
3757	} else {
3758	r->writeInt32(-1);
3759	}
3760	break;
3761	}
3762	case FACTORY_FBC_PANEL_SUSPEND: {
3763	int value = p.readInt32();
3764	CFbcCommunication *fbcIns = GetSingletonFBC();
3765	if (fbcIns != NULL) {
3766	int ret = fbcIns->cfbc_Set_FBC_suspend(COMM_DEV_SERIAL, value);
3767	r->writeInt32(ret);
3768	} else {
3769	r->writeInt32(-1);
3770	}
3771	break;
3772	}
3773	case FACTORY_FBC_PANEL_USER_SETTING_DEFAULT: {
3774	int value = p.readInt32();
3775	CFbcCommunication *fbcIns = GetSingletonFBC();
3776	if (fbcIns != NULL) {
3777	int ret = fbcIns->cfbc_Set_FBC_User_Setting_Default(COMM_DEV_SERIAL, value);
3778	r->writeInt32(ret);
3779	} else {
3780	r->writeInt32(-1);
3781	}
3782	break;
3783	}
3784	case FACTORY_FBC_VIDEO_MUTE: {
3785	CFbcCommunication *fbcIns = GetSingletonFBC();
3786	if (fbcIns != NULL) {
3787	int ret = fbcIns->cfbc_Set_VMute(COMM_DEV_SERIAL, 1);
3788	r->writeInt32(ret);
3789	} else {
3790	r->writeInt32(-1);
3791	}
3792	break;
3793	}
3794	case FACTORY_FBC_POWER_REBOOT: {
3795	int value = p.readInt32();
3796	CFbcCommunication *fbcIns = GetSingletonFBC();
3797	if (fbcIns != NULL) {
3798	int ret = fbcIns->cfbc_SendRebootToUpgradeCmd(COMM_DEV_SERIAL, value);
3799	r->writeInt32(ret);
3800	} else {
3801	r->writeInt32(-1);
3802	}
3803	break;
3804	}
3805	case FACTORY_FBC_SEND_KEY_TO_FBC: {
3806	int keyCode = p.readInt32();
3807	int param = p.readInt32();
3808	CFbcCommunication *fbcIns = GetSingletonFBC();
3809	if (fbcIns != NULL) {
3810	int ret = fbcIns->cfbc_FBC_Send_Key_To_Fbc(COMM_DEV_SERIAL, keyCode, param);
3811	r->writeInt32(ret);
3812	} else {
3813	r->writeInt32(-1);
3814	}
3815	break;
3816	}
3817	case FACTORY_WHITE_BALANCE_SET_GAIN_RED: {
3818	int source_type = p.readInt32();
3819	int colortemp_mode = p.readInt32();
3820	int value = p.readInt32();
3821	int ret = mpTv->Tv_FactorySetWhiteBalanceRedGain(source_type, colortemp_mode, value);
3822	r->writeInt32(ret);
3823	break;
3824	}
3825	case FACTORY_WHITE_BALANCE_GET_GAIN_RED: {
3826	int source_type = p.readInt32();
3827	int colortemp_mode = p.readInt32();
3828	int ret = mpTv->Tv_FactoryGetWhiteBalanceRedGain(source_type, colortemp_mode);
3829	r->writeInt32(ret);
3830	break;
3831	}
3832	case FACTORY_WHITE_BALANCE_SET_GAIN_GREEN: {
3833	int source_type = p.readInt32();
3834	int colortemp_mode = p.readInt32();
3835	int value = p.readInt32();
3836	int ret = mpTv->Tv_FactorySetWhiteBalanceGreenGain(source_type, colortemp_mode, value);
3837	r->writeInt32(ret);
3838	break;
3839	}
3840	case FACTORY_WHITE_BALANCE_GET_GAIN_GREEN: {
3841	int source_type = p.readInt32();
3842	int colortemp_mode = p.readInt32();
3843	int ret = mpTv->Tv_FactoryGetWhiteBalanceGreenGain(source_type, colortemp_mode);
3844	r->writeInt32(ret);
3845	break;
3846	}
3847	case FACTORY_WHITE_BALANCE_SET_GAIN_BLUE: {
3848	int source_type = p.readInt32();
3849	int colortemp_mode = p.readInt32();
3850	int value = p.readInt32();
3851	int ret = mpTv->Tv_FactorySetWhiteBalanceBlueGain(source_type, colortemp_mode, value);
3852	r->writeInt32(ret);
3853	break;
3854	}
3855	case FACTORY_WHITE_BALANCE_GET_GAIN_BLUE: {
3856	int source_type = p.readInt32();
3857	int colortemp_mode = p.readInt32();
3858	int ret = mpTv->Tv_FactoryGetWhiteBalanceBlueGain(source_type, colortemp_mode);
3859	r->writeInt32(ret);
3860	break;
3861	}
3862	case FACTORY_WHITE_BALANCE_SET_OFFSET_RED: {
3863	int source_type = p.readInt32();
3864	int colortemp_mode = p.readInt32();
3865	int value = p.readInt32();
3866	int ret = mpTv->Tv_FactorySetWhiteBalanceRedOffset(source_type, colortemp_mode, value);
3867	r->writeInt32(ret);
3868	break;
3869	}
3870	case FACTORY_WHITE_BALANCE_GET_OFFSET_RED: {
3871	int source_type = p.readInt32();
3872	int colortemp_mode = p.readInt32();
3873	int ret = mpTv->Tv_FactoryGetWhiteBalanceRedOffset(source_type, colortemp_mode);
3874	r->writeInt32(ret);
3875	break;
3876	}
3877	case FACTORY_WHITE_BALANCE_SET_OFFSET_GREEN: {
3878	int source_type = p.readInt32();
3879	int colortemp_mode = p.readInt32();
3880	int value = p.readInt32();
3881	int ret = mpTv->Tv_FactorySetWhiteBalanceGreenOffset(source_type, colortemp_mode, value);
3882	r->writeInt32(ret);
3883	break;
3884	}
3885	case FACTORY_WHITE_BALANCE_GET_OFFSET_GREEN: {
3886	int source_type = p.readInt32();
3887	int colortemp_mode = p.readInt32();
3888	int ret = mpTv->Tv_FactoryGetWhiteBalanceGreenOffset(source_type, colortemp_mode);
3889	r->writeInt32(ret);
3890	break;
3891	}
3892	case FACTORY_WHITE_BALANCE_SET_OFFSET_BLUE: {
3893	int source_type = p.readInt32();
3894	int colortemp_mode = p.readInt32();
3895	int value = p.readInt32();
3896	int ret = mpTv->Tv_FactorySetWhiteBalanceBlueOffset(source_type, colortemp_mode, value);
3897	r->writeInt32(ret);
3898	break;
3899	}
3900	case FACTORY_WHITE_BALANCE_GET_OFFSET_BLUE: {
3901	int source_type = p.readInt32();
3902	int colortemp_mode = p.readInt32();
3903	int ret = mpTv->Tv_FactoryGetWhiteBalanceBlueOffset(source_type, colortemp_mode);
3904	r->writeInt32(ret);
3905	break;
3906	}
3907	case FACTORY_WHITE_BALANCE_GET_COLOR_TMP: {
3908	int source_type = p.readInt32();
3909	int ret = mpTv->Tv_FactoryGetWhiteBalanceColorTempMode(source_type);
3910	r->writeInt32(ret);
3911	break;
3912	}
3913	case FACTORY_WHITE_BALANCE_SET_COLOR_TMP: {
3914	int source_type = p.readInt32();
3915	int Tempmode = p.readInt32();
3916	int is_save = p.readInt32();
3917	int ret = mpTv->Tv_FactorySetWhiteBalanceColorTempMode(source_type, Tempmode, is_save);
3918	r->writeInt32(ret);
3919	break;
3920	}
3921	case FACTORY_WHITE_BALANCE_SAVE_PRAMAS: {
3922	int source_type = p.readInt32();
3923	int mode = p.readInt32();
3924	int r_gain = p.readInt32();
3925	int g_gain = p.readInt32();
3926	int b_gain = p.readInt32();
3927	int r_offset = p.readInt32();
3928	int g_offset = p.readInt32();
3929	int b_offset = p.readInt32();
3930	int ret = mpTv->Tv_FactorySaveWhiteBalancePramas(source_type, mode, r_gain, g_gain, b_gain, r_offset, g_offset, b_offset);
3931	r->writeInt32(ret);
3932	break;
3933	}
3934	case FACTORY_WHITE_BALANCE_OPEN_GRAY_PATTERN: {
3935	int ret = mpTv->Tv_FactoryOpenWhiteBalanceGrayPattern();
3936	r->writeInt32(ret);
3937	break;
3938	}
3939	case FACTORY_WHITE_BALANCE_CLOSE_GRAY_PATTERN: {
3940	int ret = mpTv->Tv_FactoryCloseWhiteBalanceGrayPattern();
3941	r->writeInt32(ret);
3942	break;
3943	}
3944	case FACTORY_WHITE_BALANCE_SET_GRAY_PATTERN: {
3945	int value = p.readInt32();
3946	int ret = mpTv->Tv_FactorySetWhiteBalanceGrayPattern(value);
3947	r->writeInt32(ret);
3948	break;
3949	}
3950	case FACTORY_WHITE_BALANCE_GET_GRAY_PATTERN: {
3951	int ret = mpTv->Tv_FactoryGetWhiteBalanceGrayPattern();
3952	r->writeInt32(ret);
3953	break;
3954	}
3955	case FACTORY_WHITE_BALANCE_GET_ALL_PRAMAS: {
3956	int Tempmode = p.readInt32();
3957	tcon_rgb_ogo_t params;
3958	int ret = mpTv->GetColorTemperatureParams((vpp_color_temperature_mode_t)Tempmode, &params);
3959	r->writeInt32(ret);
3960	r->writeInt32(params.r_gain);
3961	r->writeInt32(params.g_gain);
3962	r->writeInt32(params.b_gain);
3963	r->writeInt32(params.r_post_offset);
3964	r->writeInt32(params.g_post_offset);
3965	r->writeInt32(params.b_post_offset);
3966	}
3967	case STOP_SCAN: {
3968	mpTv->stopScanLock();
3969	break;
3970	}
3971	case DTV_GET_SNR: {
3972	int tmpRet = 0;
3973	tmpRet = mpTv->getFrontendSNR();
3974	r->writeInt32(tmpRet);
3975	break;
3976	}
3977	case DTV_GET_BER: {
3978	int tmpRet = 0;
3979	tmpRet = mpTv->getFrontendBER();
3980	r->writeInt32(tmpRet);
3981	break;
3982	}
3983	case DTV_GET_STRENGTH: {
3984	int tmpRet = 0;
3985	tmpRet = mpTv->getFrontendSignalStrength();
3986	r->writeInt32(tmpRet);
3987	break;
3988	}
3989	case DTV_GET_AUDIO_TRACK_NUM: {
3990	int programId = p.readInt32();
3991	int retCnt = 0;
3992	retCnt = mpTv->getAudioTrackNum(programId);
3993	r->writeInt32(retCnt);
3994	break;
3995	}
3996	case DTV_GET_AUDIO_TRACK_INFO: {
3997	int progId = p.readInt32();
3998	int aIdx = p.readInt32();
3999	int aFmt = -1;
4000	int iRet = -1;
4001	String8 lang;
4002	iRet = mpTv->getAudioInfoByIndex(progId, aIdx, &aFmt, lang);
4003	r->writeInt32(aFmt);
4004	r->writeString16(String16(lang));
4005	break;
4006	}
4007	case DTV_SWITCH_AUDIO_TRACK: {
4008	int aPid = p.readInt32();
4009	int aFmt = p.readInt32();
4010	int aParam = p.readInt32();
4011	int ret = -1;
4012	ret = mpTv->switchAudioTrack(aPid, aFmt, aParam);
4013	r->writeInt32(ret);
4014	break;
4015	}
4016	case DTV_GET_CURR_AUDIO_TRACK_INDEX: {
4017	int currAduIdx = -1;
4018	int progId = p.readInt32();
4019	CTvProgram prog;
4020	CTvProgram::selectByID(progId, prog);
4021	currAduIdx = prog.getCurrAudioTrackIndex();
4022	r->writeInt32(currAduIdx);
4023	break;
4024	}
4025	case DTV_SET_AUDIO_CHANNEL_MOD: {
4026	int audioChannelIdx = p.readInt32();
4027	mpTv->setAudioChannel(audioChannelIdx);
4028	break;
4029	}
4030	case DTV_GET_AUDIO_CHANNEL_MOD: {
4031	int currChannelMod;
4032	currChannelMod = mpTv->getAudioChannel();
4033	r->writeInt32(currChannelMod);
4034	break;
4035	}
4036	case DTV_GET_CUR_FREQ: {
4037	int progId = p.readInt32();
4038	int freq = 0;
4039	int iRet = -1;
4040	CTvProgram prog;
4041	CTvChannel channel;
4042
4043	iRet = CTvProgram::selectByID(progId, prog);
4044	if (0 != iRet) return -1;
4045	prog.getChannel(channel);
4046	freq = channel.getFrequency();
4047	r->writeInt32(freq);
4048	break;
4049	}
4050	case DTV_GET_EPG_UTC_TIME: {
4051	int iRet = -1;
4052	int utcTime = 0;
4053
4054	utcTime = mpTv->getTvTime();
4055
4056	r->writeInt32(utcTime);
4057	break;
4058	}
4059	case DTV_GET_EPG_INFO_POINT_IN_TIME: {
4060	int progid = p.readInt32();
4061	int utcTime = p.readInt32();
4062	CTvProgram prog;
4063	int ret = CTvProgram::selectByID(progid, prog);
4064	CTvEvent ev;
4065	ret = ev.getProgPresentEvent(prog.getSrc(), prog.getID(), utcTime, ev);
4066	r->writeString16(String16(ev.getName()));
4067	r->writeString16(String16(ev.getDescription()));
4068	r->writeString16(String16(ev.getExtDescription()));
4069	r->writeInt32(ev.getStartTime());
4070	r->writeInt32(ev.getEndTime());
4071	r->writeInt32(ev.getSubFlag());
4072	r->writeInt32(ev.getEventId());
4073	break;
4074	}
4075	case DTV_GET_EPG_INFO_DURATION: {
4076	int iRet = -1;
4077	int iObOutSize = 0;
4078	Vector<sp<CTvEvent> > epgOut;
4079	int progid = p.readInt32();
4080	int iUtcStartTime = p.readInt32();
4081	int iDurationTime = p.readInt32();
4082	CTvProgram prog;
4083	CTvEvent ev;
4084	iRet = CTvProgram::selectByID(progid, prog);
4085	if (0 != iRet) {
4086	break;
4087	}
4088	iRet = ev.getProgScheduleEvents(prog.getSrc(), prog.getID(), iUtcStartTime, iDurationTime, epgOut);
4089	if (0 != iRet) {
4090	break;
4091	}
4092	iObOutSize = epgOut.size();
4093	if (0 == iObOutSize) {
4094	break;
4095	}
4096
4097	r->writeInt32(iObOutSize);
4098	for (int i = 0; i < iObOutSize; i ++) {
4099	r->writeString16(String16(epgOut[i]->getName()));
4100	r->writeString16(String16(epgOut[i]->getDescription()));
4101	r->writeString16(String16(ev.getExtDescription()));
4102	r->writeInt32(epgOut[i]->getStartTime());
4103	r->writeInt32(epgOut[i]->getEndTime());
4104	r->writeInt32(epgOut[i]->getSubFlag());
4105	r->writeInt32(epgOut[i]->getEventId());
4106	}
4107	break;
4108	}
4109	case DTV_SET_PROGRAM_NAME: {
4110	CTvProgram prog;
4111	int progid = p.readInt32();
4112	String16 tmpName = p.readString16();
4113	String8 strName = String8(tmpName);
4114	prog.updateProgramName(progid, strName);
4115	break;
4116	}
4117	case DTV_SET_PROGRAM_SKIPPED: {
4118	CTvProgram prog;
4119	int progid = p.readInt32();
4120	bool bSkipFlag = p.readInt32();
4121	prog.setSkipFlag(progid, bSkipFlag);
4122	break;
4123	}
4124	case DTV_SET_PROGRAM_FAVORITE: {
4125	CTvProgram prog;
4126	int progid = p.readInt32();
4127	bool bFavorite = p.readInt32();
4128	prog.setFavoriteFlag(progid, bFavorite);
4129	break;
4130	}
4131	case DTV_DETELE_PROGRAM: {
4132	CTvProgram prog;
4133	int progid = p.readInt32();
4134	prog.deleteProgram(progid);
4135	break;
4136	}
4137	case SET_BLACKOUT_ENABLE: {
4138	int enable = p.readInt32();
4139	mpTv->setBlackoutEnable(enable);
4140	break;
4141	}
4142	case START_AUTO_BACKLIGHT: {
4143	mpTv->startAutoBackLight();
4144	break;
4145	}
4146	case STOP_AUTO_BACKLIGHT: {
4147	mpTv->stopAutoBackLight();
4148	break;
4149	}
4150	case IS_AUTO_BACKLIGHTING: {
4151	int on = mpTv->getAutoBackLight_on_off();
4152	r->writeInt32(on);
4153	break;
4154	}
4155	case GET_AVERAGE_LUMA: {
4156	int ret = mpTv->getAverageLuma();
4157	r->writeInt32(ret);
4158	break;
4159	}
4160	case GET_AUTO_BACKLIGHT_DATA: {
4161	int i;
4162	int size = mpTv->getAutoBacklightData(tmp_i_buf);
4163	r->writeInt32(size);
4164	for (i = 0; i < size; i++) {
4165	r->writeInt32(tmp_i_buf[i]);
4166	}
4167	break;
4168	}
4169	case SET_AUTO_BACKLIGHT_DATA: {
4170	String16 tmp_str16;
4171	String8 value_str;
4172
4173	tmp_str16 = p.readString16();
4174	value_str = String8(tmp_str16);
4175
4176	int ret = mpTv->setAutobacklightData(value_str);
4177	r->writeInt32(ret);
4178	break;
4179	}
4180
4181	case SSM_READ_BLACKOUT_ENABLE: {
4182	int enable = mpTv->getSaveBlackoutEnable();
4183	r->writeInt32(enable);
4184	break;
4185	}
4186	case DTV_SWAP_PROGRAM: {
4187	CTvProgram prog;
4188	int firstProgId = p.readInt32();
4189	int secondProgId = p.readInt32();
4190	CTvProgram::selectByID(firstProgId, prog);
4191	int firstChanOrderNum = prog.getChanOrderNum();
4192	CTvProgram::selectByID(secondProgId, prog);
4193	int secondChanOrderNum = prog.getChanOrderNum();
4194	prog.swapChanOrder(firstProgId, firstChanOrderNum, secondProgId, secondChanOrderNum);
4195	break;
4196	}
4197	case DTV_SET_PROGRAM_LOCKED: {
4198	CTvProgram prog;
4199	int progid = p.readInt32();
4200	bool bLocked = p.readInt32();
4201	prog.setLockFlag(progid, bLocked);
4202	break;
4203	}
4204	case DTV_SET_BOOKING_FLAG: {
4205	CTvEvent ev;
4206	int iEvtId = p.readInt32();
4207	bool iBookFlag = (bool)p.readInt32();
4208	ev.bookEvent(iEvtId, iBookFlag);
4209	break;
4210	}
4211	case DTV_GET_FREQ_BY_PROG_ID: {
4212	int freq = 0;
4213	int progid = p.readInt32();
4214	CTvProgram prog;
4215	int ret = CTvProgram::selectByID(progid, prog);
4216	if (ret != 0) return -1;
4217	CTvChannel channel;
4218	prog.getChannel(channel);
4219	freq = channel.getFrequency();
4220	r->writeInt32(freq);
4221	break;
4222	}
4223	case DTV_GET_BOOKED_EVENT: {
4224	CTvBooking tvBook;
4225	Vector<sp<CTvBooking> > vTvBookOut;
4226	tvBook.getBookedEventList(vTvBookOut);
4227	int iObOutSize = vTvBookOut.size();
4228	if (0 == iObOutSize) {
4229	break;
4230	}
4231	r->writeInt32(iObOutSize);
4232	for (int i = 0; i < iObOutSize; i ++) {
4233	r->writeString16(String16(vTvBookOut[i]->getProgName()));
4234	r->writeString16(String16(vTvBookOut[i]->getEvtName()));
4235	r->writeInt32(vTvBookOut[i]->getStartTime());
4236	r->writeInt32(vTvBookOut[i]->getDurationTime());
4237	r->writeInt32(vTvBookOut[i]->getBookId());
4238	r->writeInt32(vTvBookOut[i]->getProgramId());
4239	r->writeInt32(vTvBookOut[i]->getEventId());
4240	}
4241	break;
4242	}
4243	case SET_FRONTEND_PARA: {
4244	int ret = -1;
4245	frontend_para_set_t feParms;
4246	feParms.mode = (fe_type_t)p.readInt32();
4247	feParms.freq = p.readInt32();
4248	feParms.videoStd = (atv_video_std_t)p.readInt32();
4249	feParms.audioStd = (atv_audio_std_t)p.readInt32();
4250	feParms.para1 = p.readInt32();
4251	feParms.para2 = p.readInt32();
4252	mpTv->resetFrontEndPara(feParms);
4253	r->writeInt32(ret);
4254	break;
4255	}
4256	case PLAY_PROGRAM: {
4257	int mode = p.readInt32();
4258	int freq = p.readInt32();
4259	if (mode == FE_ANALOG) {
4260	int videoStd = p.readInt32();
4261	int audioStd = p.readInt32();
4262	int fineTune = p.readInt32();
4263	int audioCompetation = p.readInt32();
4264	mpTv->playAtvProgram(freq, videoStd, audioStd, fineTune, audioCompetation);
4265	} else {
4266	int para1 = p.readInt32();
4267	int para2 = p.readInt32();
4268	int vid = p.readInt32();
4269	int vfmt = p.readInt32();
4270	int aid = p.readInt32();
4271	int afmt = p.readInt32();
4272	int pcr = p.readInt32();
4273	int audioCompetation = p.readInt32();
4274	mpTv->playDtvProgram(mode, freq, para1, para2, vid, vfmt, aid, afmt, pcr, audioCompetation);
4275	}
4276	break;
4277	}
4278	case GET_PROGRAM_LIST: {
4279	Vector<sp<CTvProgram> > out;
4280	int type = p.readInt32();
4281	int skip = p.readInt32();
4282	CTvProgram::selectByType(type, skip, out);
4283	r->writeInt32(out.size());
4284	for (int i = 0; i < out.size(); i++) {
4285	r->writeInt32(out[i]->getID());
4286	r->writeInt32(out[i]->getChanOrderNum());
4287	r->writeInt32(out[i]->getMajor());
4288	r->writeInt32(out[i]->getMinor());
4289	r->writeInt32(out[i]->getProgType());
4290	r->writeString16(String16(out[i]->getName()));
4291	r->writeInt32(out[i]->getProgSkipFlag());
4292	r->writeInt32(out[i]->getFavoriteFlag());
4293	r->writeInt32(out[i]->getVideo()->getFormat());
4294	CTvChannel ch;
4295	out[i]->getChannel(ch);
4296	r->writeInt32(ch.getDVBTSID());
4297	r->writeInt32(out[i]->getServiceId());
4298	r->writeInt32(out[i]->getVideo()->getPID());
4299	r->writeInt32(out[i]->getVideo()->getPID());
4300
4301	int audioTrackSize = out[i]->getAudioTrackSize();
4302	r->writeInt32(audioTrackSize);
4303	for (int j = 0; j < audioTrackSize; j++) {
4304	r->writeString16(String16(out[i]->getAudio(j)->getLang()));
4305	r->writeInt32(out[i]->getAudio(j)->getFormat());
4306	r->writeInt32(out[i]->getAudio(j)->getPID());
4307	}
4308	Vector<CTvProgram::Subtitle *> mvSubtitles = out[i]->getSubtitles();
4309	int subTitleSize = mvSubtitles.size();
4310	r->writeInt32(subTitleSize);
4311	if (subTitleSize > 0) {
4312	for (int k = 0; k < subTitleSize; k++) {
4313	r->writeInt32(mvSubtitles[k]->getPID());
4314	r->writeString16(String16(mvSubtitles[k]->getLang()));
4315	r->writeInt32(mvSubtitles[k]->getCompositionPageID());
4316	r->writeInt32(mvSubtitles[k]->getAncillaryPageID());
4317	}
4318	}
4319	r->writeInt32(ch.getFrequency());
4320	}
4321	break;
4322	}
4323	case DTV_GET_VIDEO_FMT_INFO: {
4324	int srcWidth = 0;
4325	int srcHeight = 0;
4326	int srcFps = 0;
4327	int srcInterlace = 0;
4328	int iRet = -1;
4329
4330	iRet == mpTv->getVideoFormatInfo(&srcWidth, &srcHeight, &srcFps, &srcInterlace);
4331	r->writeInt32(srcWidth);
4332	r->writeInt32(srcHeight);
4333	r->writeInt32(srcFps);
4334	r->writeInt32(srcInterlace);
4335	r->writeInt32(iRet);
4336	}
4337	break;
4338
4339	case DTV_START_RECORD: {
4340	char buf[256];
4341	String16 tmpName = p.readString16();
4342	String8 strName = String8(tmpName);
4343	sprintf(buf, "%s", strName.string());
4344	mpTv->SetRecordFileName(buf);
4345	mpTv->StartToRecord();
4346	}
4347	break;
4348	case DTV_STOP_RECORD:
4349	mpTv->StopRecording();
4350	break;
4351	case DTV_SET_RECORD_ALL_TS: {
4352	int sel = p.readInt32();
4353	mpTv->SetRecCurTsOrCurProgram(sel);
4354	}
4355	break;
4356	case TV_PRINT_DEBUG_INFO:
4357	mpTv->printDebugInfo();
4358	break;
4359	case HDMIAV_HOTPLUGDETECT_ONOFF: {
4360	int flag = mpTv->GetHdmiAvHotplugDetectOnoff();
4361	r->writeInt32(flag);
4362	}
4363	break;
4364
4365	// 2.4G headset
4366	case START_OPEN_HEADSET_DETECT: {
4367	int flag = mpTv->StartHeadSetDetect();
4368	r->writeInt32(flag);
4369	}
4370	break;
4371
4372	// EXTAR END
4373	default:
4374	LOGD("default");
4375	break;
4376	}
4377
4378	LOGD("exit client=%d cmd=%d", getCallingPid(), cmd);
4379	return 0;
4380	}
4381
4382	sp<TvService::Client> TvService::Client::getClientFromCookie(void *user)
4383	{
4384	sp<Client> client = 0;
4385	/*
4386	TvService *service = static_cast<TvService*> (user);
4387	if (service != NULL) {
4388	Mutex::Autolock ourLock(service->mServiceLock);
4389	if (service->mClient != 0) {
4390	client = service->mClient.promote();
4391	if (client == 0) {
4392	LOGE("getClientFromCookie: client appears to have died");
4393	service->mClient.clear();
4394	}
4395	} else {
4396	LOGE("getClientFromCookie: got callback but client was NULL");
4397	}
4398	}*/
4399	return client;
4400	}
4401
4402	void TvService::Client::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void *user)
4403	{
4404	LOGD("notifyCallback(%d)", msgType);
4405
4406	sp<Client> client = getClientFromCookie(user);
4407	if (client == 0) {
4408	return;
4409	}
4410
4411	switch (msgType) {
4412	//case TV_MSG_SHUTTER:
4413	// ext1 is the dimension of the yuv picture.
4414	// client->handleShutter((image_rect_type *)ext1);
4415	// break;
4416	default:
4417	sp<ITvClient> c = client->mTvClient;
4418	if (c != NULL) {
4419	//c->notifyCallback(msgType, ext1, ext2);
4420	}
4421	break;
4422	}
4423
4424	#if DEBUG_CLIENT_REFERENCES
4425	if (client->getStrongCount() == 1) {
4426	LOGE("++++++++++++++++ (NOTIFY CALLBACK) THIS WILL CAUSE A LOCKUP!");
4427	client->printRefs();
4428	}
4429	#endif
4430	}
4431
4432	int TvService::Client::notifyCallback(const int &msgtype, const Parcel &p)
4433	{
4434	mTvClient->notifyCallback(msgtype, p);
4435	return 0;
4436	}
4437
4438	status_t TvService::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
4439	{
4440	// permission checks...
4441	switch (code) {
4442	case BnTvService::CONNECT:
4443	IPCThreadState *ipc = IPCThreadState::self();
4444	const int pid = ipc->getCallingPid();
4445	const int self_pid = getpid();
4446	if (pid != self_pid) {
4447	// we're called from a different process, do the real check
4448	/*if (!checkCallingPermission(
4449	String16("android.permission.TV")))
4450	{
4451	const int uid = ipc->getCallingUid();
4452	LOGE("Permission Denial: "
4453	"can't use the tv pid=%d, uid=%d", pid, uid);
4454	return PERMISSION_DENIED;
4455	}*/
4456	}
4457	break;
4458	}
4459
4460	status_t err = BnTvService::onTransact(code, data, reply, flags);
4461
4462	#if DEBUG_HEAP_LEAKS
4463	LOGE("+++ onTransact err %d code %d", err, code);
4464
4465	if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
4466	LOGE("+++ onTransact code %d", code);
4467
4468	CHECK_INTERFACE(ITvService, data, reply);
4469
4470	switch (code) {
4471	case 1000: {
4472	if (gWeakHeap != 0) {
4473	sp<IMemoryHeap> h = gWeakHeap.promote();
4474	IMemoryHeap *p = gWeakHeap.unsafe_get();
4475	LOGE("CHECKING WEAK REFERENCE %p (%p)", h.get(), p);
4476	if (h != 0)
4477	h->printRefs();
4478	bool attempt_to_delete = data.readInt32() == 1;
4479	if (attempt_to_delete) {
4480	// NOT SAFE!
4481	LOGE("DELETING WEAK REFERENCE %p (%p)", h.get(), p);
4482	if (p) delete p;
4483	}
4484	return NO_ERROR;
4485	}
4486	}
4487	break;
4488	default:
4489	break;
4490	}
4491	}
4492	#endif // DEBUG_HEAP_LEAKS
4493	return err;
4494	}
4495
4496