开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
hdd_copy.c
资源名称：8202s_8281s_050405_dvd_622.rar　[点击查看]
上传用户：caisangzi8
上传日期：2013-10-25
资源大小：15756k
文件大小：10k
源码类别：

DVD

开发平台：

C/C++

hdd_copy.c：源码内容
  1. /*=================================================================
  3.   hdd_play.c: Some FileSystem Info Function for HDD
  4.   
  5. 2002-04-28 10:00AM Created  by Verdure
  6. 2002-06-12 08:42AM Modified by cyue
  8.   Copyright(c)2000-2002 by Worldplus Technology (ShenZhen) Co., Ltd.
  9.   ALL RIGHTS RESERVED
  10. =================================================================*/
  12. #include "config.h"
  13. #include "global.h"
  14. #include "hdd_if.h"
  15. #include "hdd_fs.h"
  17. #include "fsNav.h"
  19. #include "user_init.h"
  21. #ifdef SUPPORT_HDD_ACCESS
  23. #define D printf("MIKEY: __%d__(%s:%s)n",__LINE__,__FILE__,__FUNCTION__);
  26. int ucosmain();
  27. char *strcpy();
  28. void *memcpy();
  29. unsigned strlen();
  31. BYTE ran_read();
  32. UINT32 addmsf();
  34. UINT8 FS_cd();
  35. UINT8 FS_dir();
  36. UINT8 FS_mkdir();
  37. UINT8 FS_rm();
  39. UINT8 FILE_filesize();
  40. UINT32 FILE_write();
  41. FILE_INFO *FILE_create();
  44. UINT32 mikey_timer0_count=0;
  45. UINT32 mikey_ucos_loaded=0;
  46. UINT8 f_do_copy_vcd=0;
  47. UINT8 f_vcd=0;
  48. UINT8 f_hdd=0;
  49. FILE_INFO copy_vcd_fd;
  50. extern UINT8 f_force_browser;
  51. extern UINT8 f_browser_mode;
  53. int do_copy_file()
  54. {
  55. #ifdef SUPPORT_CARD_STORAGE
  56. if (media_type==MEDIA_CARD) {
  57. fsgui_del();
  58. }
  59. else
  60. #endif
  61. if(f_browser_mode) {
  62. watchdog_onoff(0);
  63. // if(cd_type_loaded==CDVCD10 || cd_type_loaded==CDVCD20 || cd_type_loaded==CDSVCD) {
  64. if(f_browser_mode==CDVCD10 || f_browser_mode==CDVCD20 || f_browser_mode==CDSVCD) {
  65. f_vcd=1; // the vcd type
  66. }
  67. fsgui_copy();
  68. return 0;
  69. }
  70. if(cd_type_loaded==CDVCD10 || cd_type_loaded==CDVCD20 || cd_type_loaded==CDSVCD || cd_type_loaded==CDDVD) {
  71. f_force_browser++;
  72. ircmd_eject_toggle();
  73. // ircmd_eject_toggle();
  74. }
  75. else
  76. fsgui_copy();
  77. return 0;
  78. }
  80. #if 0
  81. int dvd_start_ucos()
  82. {
  83. LoadModual(MODUAL_UCOS);
  84. delay_1ms(100);
  85. mikey_ucos_loaded=1;
  86. ucosmain(0,0);
  87. D while(1);
  88. }
  89. #endif
  91. //#define COPYCOUNT (100)
  92. #define COPYCOUNT (20)
  93. #define COPYBUFSIZE (2048*COPYCOUNT)
  94. #define COPYBUFSTART (0xa03c0000+ 2048) // 0xa03c0000 40k
  95. #define COPYVCDBUFSTART (COPYBUFSTART+ COPYBUFSIZE) // 0xa03c0000 40k
  96. //#define COPYBUFSTART (JPGCDBUFSTART) // 0xA03AA800 208k MIKEY_BUG: why reinsert the CD DISK will panic!!
  98. int do_mount_hdd()
  99. {
  100. // check hdd
  101. if(f_hdd==0) {
  102. if(HDD_Mount()==1) {
  103. f_hdd=1;
  104. #ifdef MIKEY_CREATE_DIR
  105. #else
  106. FS_cd("/");
  107. // MIKEY_BUG: we need 11 chars. dirname, and donot with pathname
  108. FS_mkdir("JPEG       ");
  109. FS_mkdir("MP3        ");
  110. FS_mkdir("GAME       ");
  111. FS_mkdir("MOVIES     ");
  112. FS_dir();
  113. #endif
  114. }
  115. }
  116. return f_hdd;
  117. }
  121. UINT32 copy_cd_to_hdd(UINT8 *filename, UINT32 cd_msf, UINT32 cd_size, UINT32 fs_state)
  122. {
  123. UINT32 msf=cd_msf;
  124. UINT32 count;
  125. UINT8 *buf=(UINT8 *)(COPYBUFSTART);
  128. UINT32 i;
  129. UINT8 name[16];
  130. UINT8 dirname[16];
  131. FILE_INFO fd;
  132. FILE_INFO *fp=NULL;
  133. UINT8 f_copy=0;
  134. UINT8 f_try=0;
  135. static UINT32 f_error=0;
  136. UINT32 bufsize=COPYBUFSIZE;
  137. UINT32 lastbufsize=0;
  139. printf("nINFO: buf[%x]n",buf);
  141. count=(cd_size+COPYBUFSIZE-1) / COPYBUFSIZE;
  142. lastbufsize = cd_size % COPYBUFSIZE;
  143. printf("nINFO: COPY this file[%s] msf[%x] len(%d) fs_state[%x] count(%d)n",filename, msf, cd_size, fs_state, count);
  144. fsgui_100(0);
  146. if(do_mount_hdd()) {
  147. //MIKEY_BUG
  148. //D return;
  149. FS_cd("/");
  150. switch(fs_state) {
  151. case  FS_STATE_MP3:
  152. strcpy(dirname, "/MP3");
  153. strcpy(name, "        MP3");
  154. break;
  155. case  FS_STATE_JPEG:
  156. strcpy(dirname, "/JPEG");
  157. strcpy(name, "        JPG");
  158. break;
  159. case  FS_STATE_GAME:
  160. strcpy(dirname, "/GAME");
  161. strcpy(name, "        NES");
  162. break;
  163. case  FS_STATE_OTHER:
  164. strcpy(dirname, "/MOVIES");
  165. strcpy(name, "        MPG");
  166. break;
  167. default:
  168. strcpy(dirname, "/");
  169. strcpy(name, "        MPG");
  170. break;
  171. }
  172. for(i=0;i<strlen(filename);i++) {
  173. name[i] = filename[i];
  174. }
  175. printf("INFO: DIR[%s] filename[%s]n",dirname ,name);
  176. FS_cd(dirname);
  177. FS_dir();
  179. D FS_rm(name); //MIKEY
  180. D if((fp=FILE_create(name))!=NULL) {
  181. memcpy(&fd, fp,sizeof(FILE_INFO));
  182. if(f_do_copy_vcd) { // f_do_copy_vcd=1 skip do copy
  183. memcpy(&copy_vcd_fd, fp,sizeof(FILE_INFO));
  184. copy_vcd_fd.fsize=cd_size;
  185. }
  186. fp = &fd;
  187. printf("MIKEY: create file [%s/%s] OK!!n",dirname,name);
  188. f_copy=1;
  189. }
  190. else {
  191. printf("MIKEY: create file [%s/%s] ERROR!!n",dirname,name);
  192. f_copy=0;
  193. }
  195. }
  196. #define ATAPI_OK (0)
  197. D if(f_do_copy_vcd) { // f_do_copy_vcd=1 skip do copy
  198. printf("INFO: DO VCD/SVCD COPY [%s/%s]!!n",dirname,name);
  199. #define VCD_SECLEN 2352
  200. f_do_copy_vcd=0;
  201. buf=(UINT8 *)(COPYVCDBUFSTART);
  202. bufsize=VCD_SECLEN;
  203. count=(cd_size+bufsize-1) / bufsize;
  204. lastbufsize = cd_size % bufsize;
  205. for(i=0;i<count;i++) {
  206. if((i==(count-1)) && (lastbufsize!=0)) {
  207. bufsize=lastbufsize;
  208. printf("INFO: COPY LAST [%4d] msf[%x] bufsize[%x](%d)n",i,msf,bufsize,bufsize);
  209. }
  210. for(f_try=0;f_try<100;f_try++) {
  211. if(ran_read_vcd(buf, msf, bufsize)==ATAPI_OK)
  212. break;
  213. f_error++;
  214. printf("INFO: TRY(%d): COPY [%4d] msf[%x] f_error(%ld)n",f_try,i,msf,f_error);
  215. }
  216. if(f_copy) {
  217. stream_FILE_write(buf, bufsize);
  218. }
  219. msf = addmsf(msf, 1);
  220. fsgui_100(1+ ((i+1)*99/count) % 100);
  221. }
  222. flush_stream_FILE_write();
  223. }
  224. else { // do MP3, JPG, MPG file copy from CD to HDD
  225. for(i=0;i<count;i++) {
  226. if((i==(count-1)) && (lastbufsize!=0)) {
  227. bufsize=lastbufsize;
  228. printf("INFO: COPY LAST [%4d] msf[%x] bufsize[%x](%d)n",i,msf,bufsize,bufsize);
  229. }
  230. for(f_try=0;f_try<100;f_try++) {
  231. if(ran_read(buf, msf, bufsize)==ATAPI_OK)
  232. break;
  233. f_error++;
  234. printf("INFO: TRY(%d): COPY [%4d] msf[%x] f_error(%ld)n",f_try,i,msf,f_error);
  235. }
  236. if(f_copy) {
  237. FILE_write(fp, buf, bufsize);
  238. }
  239. msf = addmsf(msf, COPYCOUNT);
  240. fsgui_100(1+ ((i+1)*99/count) % 100);
  241. // fsgui_100((i+1)*100/count);
  242. }
  243. } //f_do_copy_vcd
  245. if(f_copy) {
  246. FILE_filesize(fp, cd_size); 
  247. }
  248. printf("INFO: COPY END!! [%s/%s]n",dirname,name);
  249. return 0;
  250. }
  253. UINT32 rm_file_from_hdd(UINT8 *filename, UINT32 cd_msf, UINT32 cd_size, UINT32 fs_state)
  254. {
  255. UINT32 i;
  256. UINT8 name[16];
  257. UINT8 dirname[16];
  259. printf("nINFO: del this file[%s] msf[%x] len(%d) fs_state[%x]n",filename, cd_msf, cd_size, fs_state);
  260. if(do_mount_hdd()) {
  261. FS_cd("/");
  262. switch(fs_state) {
  263. case  FS_STATE_MP3:
  264. strcpy(dirname, "/MP3");
  265. strcpy(name, "        MP3");
  266. break;
  267. case  FS_STATE_JPEG:
  268. strcpy(dirname, "/JPEG");
  269. strcpy(name, "        JPG");
  270. break;
  271. case  FS_STATE_GAME:
  272. strcpy(dirname, "/GAME");
  273. strcpy(name, "        NES");
  274. break;
  275. case  FS_STATE_OTHER:
  276. strcpy(dirname, "/MOVIES");
  277. strcpy(name, "        MPG");
  278. break;
  279. default:
  280. strcpy(dirname, "/");
  281. strcpy(name, "        MPG");
  282. break;
  283. }
  284. for(i=0;i<strlen(filename);i++) {
  285. name[i] = filename[i];
  286. }
  287. printf("INFO: DIR[%s] filename[%s]n",dirname ,name);
  288. FS_cd(dirname);
  289. FS_dir();
  290. FS_rm(name); //MIKEY
  291. FS_dir();
  292. }
  293. }
  296. UINT32 rename_file_from_hdd(UINT8 *newfilename, UINT8 *filename, UINT32 cd_msf, UINT32 cd_size, UINT32 fs_state)
  297. {
  298. UINT32 i;
  299. UINT8 name[16];
  300. UINT8 newname[16];
  301. UINT8 oldname[16];
  302. UINT8 dirname[16];
  304. printf("nINFO: rename this file[%s]->[%s] msf[%x] len(%d) fs_state[%x]n",filename,newfilename, cd_msf, cd_size, fs_state);
  305. if(do_mount_hdd()) {
  306. FS_cd("/");
  307. switch(fs_state) {
  308. case  FS_STATE_MP3:
  309. strcpy(dirname, "/MP3");
  310. strcpy(name, "        MP3");
  311. break;
  312. case  FS_STATE_JPEG:
  313. strcpy(dirname, "/JPEG");
  314. strcpy(name, "        JPG");
  315. break;
  316. case  FS_STATE_GAME:
  317. strcpy(dirname, "/GAME");
  318. strcpy(name, "        NES");
  319. break;
  320. case  FS_STATE_OTHER:
  321. strcpy(dirname, "/MOVIES");
  322. strcpy(name, "        MPG");
  323. break;
  324. default:
  325. strcpy(dirname, "/");
  326. strcpy(name, "        MPG");
  327. break;
  328. }
  330. strcpy(oldname, name);
  331. for(i=0;i<strlen(filename);i++) {
  332. oldname[i] = filename[i];
  333. }
  335. strcpy(newname, name);
  336. for(i=0;i<strlen(newfilename);i++) {
  337. newname[i] = newfilename[i];
  338. }
  340. printf("INFO: DIR[%s] oldname[%s]->[%s]n",dirname ,oldname, newname);
  341. FS_cd(dirname);
  342. FS_dir();
  343. FS_rename(newname, oldname); //MIKEY
  344. FS_dir();
  345. }
  346. }
  349. int cache_FILE_write(FILE_INFO *fp, void *buf, UINT32 count, UINT8 opt) // opt=1 flush_cache, force write to hdd
  350. {
  351. UINT8 *cachebuf=(BYTE *)(COPYBUFSTART);
  352. UINT8 *dst;
  353. static UINT32 leftlen=0;
  354. int newcount=0;
  356. if(opt) { // force write cache(leftlen) to hdd
  357. FILE_write(fp, cachebuf, leftlen); // write cache(200k) to hdd
  358. printf("INFO: WRITE CACHE bufsize[%x] leftlen(%d):(%d)n",COPYBUFSIZE,leftlen,count);
  359. leftlen=0;
  360. return 0; // write cache OK
  361. }
  363. while(1) {
  364. if((count+leftlen)>=COPYBUFSIZE) {
  365. if(leftlen) { // cache not empty
  366. dst=(UINT8 *) (cachebuf + leftlen);
  367. newcount = COPYBUFSIZE - leftlen;
  368. memcpy(dst, buf, newcount);
  369. FILE_write(fp, cachebuf, COPYBUFSIZE); // write cache(COPYBUFSIZE) to hdd
  370. // printf("INFO: WRITE CACHE bufsize[%x] leftlen(%d):(%d)n",COPYBUFSIZE,leftlen,count);
  371. buf= (UINT8 *)(buf + newcount);
  372. count-=newcount;
  373. leftlen=0;
  374. }
  375. else { // >=COPYBUFSIZE, write to hdd 
  376. FILE_write(fp, buf, COPYBUFSIZE);  // write buf(COPYBUFSIZE) to hdd
  377. // printf("INFO: WRITE BUF bufsize[%x] leftlen(%d):(%d)n",COPYBUFSIZE,leftlen,count);
  378. buf= (UINT8 *)(buf + COPYBUFSIZE);
  379. count-=COPYBUFSIZE;
  380. }
  381. }
  382. else { // <COPYBUFSIZE, write to cache
  383. dst=(UINT8 *) (cachebuf + leftlen);
  384. memcpy(dst, buf, count);
  385. leftlen+=count;
  386. // printf("INFO: CACHE dst[%x] leftlen(%d):(%d)n",dst,leftlen,count);
  387. return 0; // write cache OK
  388. }
  389. }
  390. }
  392. UINT32 stream_FILE_write(void *buf, UINT32 count)
  393. {
  394. FILE_INFO *fp=&copy_vcd_fd;
  395. return cache_FILE_write(fp, buf, count, 0); // opt=1 flush_cache, force write to hdd
  396. }
  398. UINT32 flush_stream_FILE_write()
  399. {
  400. FILE_INFO *fp=&copy_vcd_fd;
  401. return cache_FILE_write(fp, NULL, 0, 1); // opt=1 flush_cache, force write to hdd
  402. }
  404. #endif //#ifdef SUPPORT_HDD_ACCESS