path: root/tvapi/android/tvserver/TvService.cpp (plain)
blob: 082c8768e1d85ff956aac344bb69f3c05e55614d

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