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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
edc_ecc.c
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：21k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

edc_ecc.c：源码内容
  1. /* reed-solomon encoder / decoder for compact disc building project
  2.  * Copyright 1998 by Heiko Eissfeldt
  3.  * portions used& Chris Smith
  4.  */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include "ecc.h"
  11. /* these prototypes will become public when the function are implemented */
  12. static int do_decode_L2(unsigned char in[(L2_RAW+L2_Q+L2_P)],
  13. unsigned char out[L2_RAW]);
  15. static int do_decode_L1(unsigned char in[(L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR],
  16. unsigned char out[L1_RAW*FRAMES_PER_SECTOR],
  17. int delay1, int delay2, int delay3, int scramble);
  20. /* ------------- tables generated by gen_encodes --------------*/
  22. #include "encoder_tables"
  24. static int encode_L1_Q(unsigned char inout[L1_RAW + L1_Q])
  25. {
  26.   unsigned char *Q;
  27.   int i;
  29.   memmove(inout+L1_RAW/2+L1_Q, inout+L1_RAW/2, L1_RAW/2);
  30.   Q = inout + L1_RAW/2;
  32.   memset(Q, 0, L1_Q);
  33.   for (i = 0; i < L1_RAW + L1_Q; i++) {
  34. unsigned char data;
  36. if (i == L1_RAW/2) i += L1_Q;
  37.         data = inout[i];
  38. if (data != 0) {
  39. unsigned char base = rs_l12_log[data];
  41. Q[0] ^= rs_l12_alog[(base+AQ[0][i]) % ((1 << RS_L12_BITS)-1)];
  42. Q[1] ^= rs_l12_alog[(base+AQ[1][i]) % ((1 << RS_L12_BITS)-1)];
  43. Q[2] ^= rs_l12_alog[(base+AQ[2][i]) % ((1 << RS_L12_BITS)-1)];
  44. Q[3] ^= rs_l12_alog[(base+AQ[3][i]) % ((1 << RS_L12_BITS)-1)];
  45. }
  46.   }
  48.   return 0;
  49. }
  50. static int encode_L1_P(unsigned char inout[L1_RAW + L1_Q + L1_P])
  51. {
  52.   unsigned char *P;
  53.   int i;
  55.   P = inout + L1_RAW + L1_Q;
  57.   memset(P, 0, L1_P);
  58.   for (i = 0; i < L2_RAW + L2_Q + L2_P; i++) {
  59. unsigned char data;
  61.         data = inout[i];
  62. if (data != 0) {
  63. unsigned char base = rs_l12_log[data];
  65. P[0] ^= rs_l12_alog[(base+AP[0][i]) % ((1 << RS_L12_BITS)-1)];
  66. P[1] ^= rs_l12_alog[(base+AP[1][i]) % ((1 << RS_L12_BITS)-1)];
  67. P[2] ^= rs_l12_alog[(base+AP[2][i]) % ((1 << RS_L12_BITS)-1)];
  68. P[3] ^= rs_l12_alog[(base+AP[3][i]) % ((1 << RS_L12_BITS)-1)];
  69. }
  70.   }
  71.   return 0;
  72. }
  74. static int decode_L1_Q(unsigned char inout[L1_RAW + L1_Q])
  75. {
  76.   return 0;
  77. }
  78. static int decode_L1_P(unsigned char in[L1_RAW + L1_Q + L1_P])
  79. {
  80.   return 0;
  81. }
  83. static int encode_L2_Q(unsigned char inout[4 + L2_RAW + 4 + 8 + L2_P + L2_Q])
  84. {
  85.   unsigned char *Q;
  86.   int i,j;
  88.   Q = inout + 4 + L2_RAW + 4 + 8 + L2_P;
  89.   memset(Q, 0, L2_Q);
  90.   for (j = 0; j < 26; j++) {
  91.      for (i = 0; i < 43; i++) {
  92. unsigned char data;
  94.         /* LSB */
  95.         data = inout[(j*43*2+i*2*44) % (4 + L2_RAW + 4 + 8 + L2_P)];
  96. if (data != 0) {
  97. unsigned int base = rs_l12_log[data];
  99. unsigned int sum = base + DQ[0][i];
  100. if (sum >= ((1 << RS_L12_BITS)-1))
  101.   sum -= (1 << RS_L12_BITS)-1;
  103. Q[0]    ^= rs_l12_alog[sum];
  105. sum = base + DQ[1][i];
  106. if (sum >= ((1 << RS_L12_BITS)-1))
  107.   sum -= (1 << RS_L12_BITS)-1;
  109. Q[26*2] ^= rs_l12_alog[sum];
  110. }
  111.         /* MSB */
  112.         data = inout[(j*43*2+i*2*44+1) % (4 + L2_RAW + 4 + 8 + L2_P)];
  113. if (data != 0) {
  114. unsigned int base = rs_l12_log[data];
  116. unsigned int sum = base+DQ[0][i];
  117. if (sum >= ((1 << RS_L12_BITS)-1))
  118.   sum -= (1 << RS_L12_BITS)-1;
  120. Q[1]      ^= rs_l12_alog[sum];
  122. sum = base + DQ[1][i];
  123. if (sum >= ((1 << RS_L12_BITS)-1))
  124.   sum -= (1 << RS_L12_BITS)-1;
  126. Q[26*2+1] ^= rs_l12_alog[sum];
  127. }
  128.      }
  129.      Q += 2;
  130.   }
  131.   return 0;
  132. }
  134. static int encode_L2_P(unsigned char inout[4 + L2_RAW + 4 + 8 + L2_P])
  135. {
  136.   unsigned char *P;
  137.   int i,j;
  139.   P = inout + 4 + L2_RAW + 4 + 8;
  140.   memset(P, 0, L2_P);
  141.   for (j = 0; j < 43; j++) {
  142.      for (i = 0; i < 24; i++) {
  143. unsigned char data;
  145.         /* LSB */
  146.         data = inout[i*2*43];
  147. if (data != 0) {
  148. unsigned int base = rs_l12_log[data];
  150. unsigned int sum = base + DP[0][i];
  151. if (sum >= ((1 << RS_L12_BITS)-1))
  152.   sum -= (1 << RS_L12_BITS)-1;
  154. P[0]    ^= rs_l12_alog[sum];
  156. sum = base + DP[1][i];
  157. if (sum >= ((1 << RS_L12_BITS)-1))
  158.   sum -= (1 << RS_L12_BITS)-1;
  160. P[43*2] ^= rs_l12_alog[sum];
  161. }
  162.         /* MSB */
  163.         data = inout[i*2*43+1];
  164. if (data != 0) {
  165. unsigned int base = rs_l12_log[data];
  167. unsigned int sum = base + DP[0][i];
  168. if (sum >= ((1 << RS_L12_BITS)-1))
  169.   sum -= (1 << RS_L12_BITS)-1;
  171. P[1]      ^= rs_l12_alog[sum];
  173. sum = base + DP[1][i];
  174. if (sum >= ((1 << RS_L12_BITS)-1))
  175.   sum -= (1 << RS_L12_BITS)-1;
  177. P[43*2+1] ^= rs_l12_alog[sum];
  178. }
  179.      }
  180.      P += 2;
  181.      inout += 2;
  182.   }
  183.   return 0;
  184. }
  186. int decode_L2_Q(unsigned char inout[4 + L2_RAW + 12 + L2_Q])
  187. {
  188.   return 0;
  189. }
  190. int decode_L2_P(unsigned char inout[4 + L2_RAW + 12 + L2_Q + L2_P])
  191. {
  192.   return 0;
  193. }
  195. int scramble_L2(unsigned char *inout)
  196. {
  197.   unsigned char *r = inout + 12;
  198.   unsigned char *s = yellowbook_scrambler;
  199.   unsigned int i;
  200.   unsigned int *f = (unsigned int *)inout;
  202.   for (i = (L2_RAW + L2_Q + L2_P +16)/sizeof(unsigned char); i; i--) {
  203.     *r++ ^= *s++;
  204.   }
  206.   /* generate F1 frames */
  207.   for (i = (2352/sizeof(unsigned int)); i; i--) {
  208.     *f++ = ((*f & 0xff00ff00UL) >> 8) | ((*f & 0x00ff00ffUL) << 8);
  209.   }
  211.   return 0;
  212. }
  214. static int encode_LSUB_Q(unsigned char inout[LSUB_RAW + LSUB_Q])
  215. {
  216.   unsigned char *Q;
  217.   unsigned char data;
  218.   int i;
  220.   memmove(inout+LSUB_QRAW+LSUB_Q, inout+LSUB_QRAW, LSUB_RAW-LSUB_QRAW);
  221.   Q = inout + LSUB_QRAW;
  223.   memset(Q, 0, LSUB_Q);
  225. #if 0
  226.   data = inout[0] & 0x3f;
  227.   if (data != 0) {
  228. unsigned char base = rs_sub_rw_log[data];
  230. Q[0] ^= rs_sub_rw_alog[(base+26) % ((1 << RS_SUB_RW_BITS)-1)];
  231. Q[1] ^= rs_sub_rw_alog[(base+7) % ((1 << RS_SUB_RW_BITS)-1)];
  232.   }
  233.   data = inout[1] & 0x3f;
  234.   if (data != 0) {
  235. unsigned char base = rs_sub_rw_log[data];
  237. Q[0] ^= rs_sub_rw_alog[(base+6) % ((1 << RS_SUB_RW_BITS)-1)];
  238. Q[1] ^= rs_sub_rw_alog[(base+1) % ((1 << RS_SUB_RW_BITS)-1)];
  239.   }
  240. #else
  241.   for (i = 0; i < LSUB_QRAW; i++) {
  242. unsigned char data;
  244. data = inout[i] & 0x3f;
  245. if (data != 0) {
  246. unsigned char base = rs_sub_rw_log[data];
  248. Q[0] ^= rs_sub_rw_alog[(base+SQ[0][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  249. Q[1] ^= rs_sub_rw_alog[(base+SQ[1][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  250. }
  251.   }
  252. #endif
  253.   return 0;
  254. }
  257. static int encode_LSUB_P(unsigned char inout[LSUB_RAW + LSUB_Q + LSUB_P])
  258. {
  259.   unsigned char *P;
  260.   int i;
  262.   P = inout + LSUB_RAW + LSUB_Q;
  264.   memset(P, 0, LSUB_P);
  265.   for (i = 0; i < LSUB_RAW + LSUB_Q; i++) {
  266. unsigned char data;
  268. data = inout[i] & 0x3f;
  269. if (data != 0) {
  270. unsigned char base = rs_sub_rw_log[data];
  272. P[0] ^= rs_sub_rw_alog[(base+SP[0][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  273. P[1] ^= rs_sub_rw_alog[(base+SP[1][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  274. P[2] ^= rs_sub_rw_alog[(base+SP[2][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  275. P[3] ^= rs_sub_rw_alog[(base+SP[3][i]) % ((1 << RS_SUB_RW_BITS)-1)];
  276. }
  277.   }
  278.   return 0;
  279. }
  281. int decode_LSUB_Q(unsigned char inout[LSUB_QRAW + LSUB_Q])
  282. {
  283.   unsigned char Q[LSUB_Q];
  284.   int i;
  286.   memset(Q, 0, LSUB_Q);
  287.   for (i = LSUB_QRAW + LSUB_Q -1; i>=0; i--) {
  288. unsigned char data;
  290. data = inout[LSUB_QRAW + LSUB_Q -1 -i] & 0x3f;
  291. if (data != 0) {
  292. unsigned char base = rs_sub_rw_log[data];
  294. Q[0] ^= rs_sub_rw_alog[(base+0*i) % ((1 << RS_SUB_RW_BITS)-1)];
  295. Q[1] ^= rs_sub_rw_alog[(base+1*i) % ((1 << RS_SUB_RW_BITS)-1)];
  296. }
  297.   }
  299.   return (Q[0] != 0 || Q[1] != 0);
  300. }
  301. int decode_LSUB_P(unsigned char inout[LSUB_RAW + LSUB_Q + LSUB_P])
  302. {
  303.   unsigned char P[LSUB_P];
  304.   int i;
  306.   memset(P, 0, LSUB_P);
  307.   for (i = LSUB_RAW + LSUB_Q + LSUB_P-1; i>=0; i--) {
  308. unsigned char data;
  310. data = inout[LSUB_RAW + LSUB_Q + LSUB_P -1 -i] & 0x3f;
  311. if (data != 0) {
  312. unsigned char base = rs_sub_rw_log[data];
  314. P[0] ^= rs_sub_rw_alog[(base+0*i) % ((1 << RS_SUB_RW_BITS)-1)];
  315. P[1] ^= rs_sub_rw_alog[(base+1*i) % ((1 << RS_SUB_RW_BITS)-1)];
  316. P[2] ^= rs_sub_rw_alog[(base+2*i) % ((1 << RS_SUB_RW_BITS)-1)];
  317. P[3] ^= rs_sub_rw_alog[(base+3*i) % ((1 << RS_SUB_RW_BITS)-1)];
  318. }
  319.   }
  321.   return (P[0] != 0 || P[1] != 0 || P[2] != 0 || P[3] != 0);
  322. }
  324. /* Layer 1 CIRC en/decoder */
  325. #define MAX_L1_DEL1 2
  326. static unsigned char l1_delay_line1[MAX_L1_DEL1][L1_RAW];
  327. #define MAX_L1_DEL2 108
  328. static unsigned char l1_delay_line2[MAX_L1_DEL2][L1_RAW+L1_Q];
  329. #define MAX_L1_DEL3 1
  330. static unsigned char l1_delay_line3[MAX_L1_DEL3][L1_RAW+L1_Q+L1_P];
  331. static unsigned l1_del_index;
  333. int do_encode_L1(unsigned char in[L1_RAW*FRAMES_PER_SECTOR],
  334. unsigned char out[(L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR],
  335. int delay1, int delay2, int delay3, int permute)
  336. {
  337.   int i;
  339.   for (i = 0; i < FRAMES_PER_SECTOR; i++) {
  340.      int j;
  341.      unsigned char t;
  343.      if (in != out)
  344. memcpy(out, in, L1_RAW);
  346.      if (delay1) {
  347. /* shift through delay line 1 */
  348.   for (j = 0; j < L1_RAW; j++) {
  349. if (((j/4) % MAX_L1_DEL1) == 0) {
  350. t = l1_delay_line1[l1_del_index % (MAX_L1_DEL1)][j];
  351. l1_delay_line1[l1_del_index % (MAX_L1_DEL1)][j] = out[j];
  352. out[j] = t;
  353. }
  354. }
  355.      }
  357.      if (permute) {
  358. /* permute */
  359. t = out[2]; out[2] = out[8]; out[8] = out[10]; out[10] = out[18];
  360.         out[18] = out[6]; out [6] = t;
  361. t = out[3]; out[3] = out[9]; out[9] = out[11]; out[11] = out[19];
  362.         out[19] = out[7]; out [7] = t;
  363. t = out[4]; out[4] = out[16]; out[16] = out[20]; out[20] = out[14];
  364.         out[14] = out[12]; out [12] = t;
  365. t = out[5]; out[5] = out[17]; out[17] = out[21]; out[21] = out[15];
  366.         out[15] = out[13]; out [13] = t;
  367.      }
  369.      /* build Q parity */
  370.      encode_L1_Q(out);
  372.      if (delay2) {
  373. /* shift through delay line 2 */
  374.   for (j = 0; j < L1_RAW+L1_Q; j++) {
  375. if (j != 0) {
  376. t = l1_delay_line2[(l1_del_index) % MAX_L1_DEL2][j];
  377. l1_delay_line2[(l1_del_index + j*4) % MAX_L1_DEL2][j] = out[j];
  378. out[j] = t;
  379. }
  380. }
  381.      }
  383.      /* build P parity */
  384.      encode_L1_P(out);
  386.      if (delay3) {
  387. /* shift through delay line 3 */
  388.   for (j = 0; j < L1_RAW+L1_Q+L1_P; j++) {
  389. if (((j) & MAX_L1_DEL3) == 0) {
  390. t = l1_delay_line3[0][j];
  391. l1_delay_line3[0][j] = out[j];
  392. out[j] = t;
  393. }
  394. }
  395.      }
  397.      /* invert Q and P parity */
  398.      for (j = 0; j < L1_Q; j++)
  399. out[j+12] = ~out[j+12];
  400.      for (j = 0; j < L1_P; j++)
  401. out[j+28] = ~out[j+28];
  403.      l1_del_index++;
  404.      out += L1_RAW+L1_Q+L1_P;
  405.      in += L1_RAW;
  406.   }
  407.   return 0;
  408. }
  410. int do_decode_L1(unsigned char in[(L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR],
  411. unsigned char out[L1_RAW*FRAMES_PER_SECTOR],
  412. int delay1, int delay2, int delay3, int permute)
  413. {
  414.   int i;
  416.   for (i = 0; i < FRAMES_PER_SECTOR; i++) {
  417.      int j;
  418.      unsigned char t;
  420.      if (delay3) {
  421. /* shift through delay line 3 */
  422.   for (j = 0; j < L1_RAW+L1_Q+L1_P; j++) {
  423. if (((j) & MAX_L1_DEL3) != 0) {
  424. t = l1_delay_line3[0][j];
  425. l1_delay_line3[0][j] = in[j];
  426. in[j] = t;
  427. }
  428. }
  429.      }
  431.      /* invert Q and P parity */
  432.      for (j = 0; j < L1_Q; j++)
  433. in[j+12] = ~in[j+12];
  434.      for (j = 0; j < L1_P; j++)
  435. in[j+28] = ~in[j+28];
  437.      /* build P parity */
  438.      decode_L1_P(in);
  440.      if (delay2) {
  441. /* shift through delay line 2 */
  442.   for (j = 0; j < L1_RAW+L1_Q; j++) {
  443. if (j != L1_RAW+L1_Q-1) {
  444. t = l1_delay_line2[(l1_del_index) % MAX_L1_DEL2][j];
  445. l1_delay_line2[(l1_del_index + (MAX_L1_DEL2 - j*4)) % MAX_L1_DEL2][j] = in[j];
  446. in[j] = t;
  447. }
  448. }
  449.      }
  451.      /* build Q parity */
  452.      decode_L1_Q(in);
  454.      if (permute) {
  455. /* permute */
  456. t = in[2]; in[2] = in[6]; in[6] = in[18]; in[18] = in[10];
  457.         in[10] = in[8]; in [8] = t;
  458. t = in[3]; in[3] = in[7]; in[7] = in[19]; in[19] = in[11];
  459.         in[11] = in[9]; in [9] = t;
  460. t = in[4]; in[4] = in[12]; in[12] = in[14]; in[14] = in[20];
  461.         in[20] = in[16]; in [16] = t;
  462. t = in[5]; in[5] = in[13]; in[13] = in[15]; in[15] = in[21];
  463.         in[21] = in[17]; in [17] = t;
  464.      }
  466.      if (delay1) {
  467. /* shift through delay line 1 */
  468.   for (j = 0; j < L1_RAW; j++) {
  469. if (((j/4) % MAX_L1_DEL1) != 0) {
  470. t = l1_delay_line1[l1_del_index % (MAX_L1_DEL1)][j];
  471. l1_delay_line1[l1_del_index % (MAX_L1_DEL1)][j] = in[j];
  472. in[j] = t;
  473. }
  474. }
  475.      }
  477.      if (in != out)
  478. memcpy(out, in, (L1_RAW));
  480.      l1_del_index++;
  481.      in += L1_RAW+L1_Q+L1_P;
  482.      out += L1_RAW;
  483.   }
  484.   return 0;
  485. }
  487. static unsigned char bin2bcd(unsigned p)
  488. {
  489.   return ((p/10)<<4)|(p%10);
  490. }
  492. static int build_address(unsigned char inout[], int sectortype, unsigned address)
  493. {
  494.   inout[12] = bin2bcd(address / (60*75));
  495.   inout[13] = bin2bcd((address / 75) % 60);
  496.   inout[14] = bin2bcd(address % 75);
  497.   if (sectortype == MODE_0)
  498. inout[15] = 0;
  499.   else if (sectortype == MODE_1)
  500. inout[15] = 1;
  501.   else if (sectortype == MODE_2)
  502. inout[15] = 2;
  503.   else if (sectortype == MODE_2_FORM_1)
  504. inout[15] = 2;
  505.   else if (sectortype == MODE_2_FORM_2)
  506. inout[15] = 2;
  507.   else
  508. return -1;
  509.   return 0;
  510. }
  512. #include "crctable.out"
  514. unsigned int build_edc(unsigned char inout[], int from, int upto)
  515. {
  516.   unsigned char *p = inout+from;
  517.   unsigned int result = 0;
  519.   for (; from <= upto; from++)
  520.     result = EDC_crctable[(result ^ *p++) & 0xffL] ^ (result >> 8);
  522.   return result;
  523. }
  525. /* Layer 2 Product code en/decoder */
  526. int do_encode_L2(unsigned char inout[(12 + 4 + L2_RAW+4+8+L2_Q+L2_P)], int sectortype, unsigned address)
  527. {
  528.   unsigned int result;
  530. #define SYNCPATTERN "x00xffxffxffxffxffxffxffxffxffxff"
  532.   /* supply initial sync pattern */
  533.   memcpy(inout, SYNCPATTERN, sizeof(SYNCPATTERN));
  535.   if (sectortype == MODE_0) {
  536. memset(inout + sizeof(SYNCPATTERN), 0, 4 + L2_RAW + 12 + L2_P + L2_Q);
  537.         build_address(inout, sectortype, address);
  538. return 0;
  539.   }
  540.   
  541.   switch (sectortype) {
  542.     case MODE_1:
  543.         build_address(inout, sectortype, address);
  544. result = build_edc(inout, 0, 16+2048-1);
  545. inout[2064+0] = result >> 0L;
  546. inout[2064+1] = result >> 8L;
  547. inout[2064+2] = result >> 16L;
  548. inout[2064+3] = result >> 24L;
  549. memset(inout+2064+4, 0, 8);
  550.    encode_L2_P(inout+12);
  551.   encode_L2_Q(inout+12);
  552. break;
  553.     case MODE_2:
  554.         build_address(inout, sectortype, address);
  555. break;
  556.     case MODE_2_FORM_1:
  557.         result = build_edc(inout, 16, 16+8+2048-1);
  558. inout[2072+0] = result >> 0L;
  559. inout[2072+1] = result >> 8L;
  560. inout[2072+2] = result >> 16L;
  561. inout[2072+3] = result >> 24L;
  563. /* clear header for P/Q parity calculation */
  564. inout[12] = 0;
  565. inout[12+1] = 0;
  566. inout[12+2] = 0;
  567. inout[12+3] = 0;
  568.    encode_L2_P(inout+12);
  569.   encode_L2_Q(inout+12);
  570. build_address(inout, sectortype, address);
  571. break;
  572.     case MODE_2_FORM_2:
  573.         build_address(inout, sectortype, address);
  574. result = build_edc(inout, 16, 16+8+2324-1);
  575. inout[2348+0] = result >> 0L;
  576. inout[2348+1] = result >> 8L;
  577. inout[2348+2] = result >> 16L;
  578. inout[2348+3] = result >> 24L;
  579. break;
  580.     default:
  581. return -1;
  582.   }
  584.   return 0;
  585. }
  587. static int do_decode_L2(unsigned char in[(L2_RAW+L2_Q+L2_P)],
  588. unsigned char out[L2_RAW])
  589. {
  590.   return 0;
  591. }
  595. #define MAX_SUB_DEL 8
  596. static unsigned char sub_delay_line[MAX_SUB_DEL][LSUB_RAW+LSUB_Q+LSUB_P];
  597. static unsigned sub_del_index;
  599. /* R-W Subchannel en/decoder */
  600. int do_encode_sub(unsigned char in[LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME],
  601. unsigned char out[(LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME],
  602. int delay1, int permute)
  603. {
  604.   int i;
  606.   if (in == out) return -1;
  608.   for (i = 0; i < PACKETS_PER_SUBCHANNELFRAME; i++) {
  609.      int j;
  610.      unsigned char t;
  612.      memcpy(out, in, (LSUB_RAW));
  614.      /* build Q parity */
  615.      encode_LSUB_Q(out);
  617.      /* build P parity */
  618.      encode_LSUB_P(out);
  620.      if (permute) {
  621. /* permute */
  622. t = out[1]; out[1] = out[18]; out[18] = t;
  623. t = out[2]; out[2] = out[ 5]; out[ 5] = t;
  624. t = out[3]; out[3] = out[23]; out[23] = t;
  625.      }
  627.      if (delay1) {
  628. /* shift through delay_line */
  629.   for (j = 0; j < LSUB_RAW+LSUB_Q+LSUB_P; j++) {
  630. if ((j % MAX_SUB_DEL) != 0) {
  631. t = sub_delay_line[(sub_del_index) % MAX_SUB_DEL][j];
  632. sub_delay_line[(sub_del_index + j) % MAX_SUB_DEL][j] = out[j];
  633. out[j] = t;
  634. }
  635. }
  636.      }
  637.      sub_del_index++;
  638.      out += LSUB_RAW+LSUB_Q+LSUB_P;
  639.      in += LSUB_RAW;
  640.   }
  641.   return 0;
  642. }
  644. int 
  645. do_decode_sub(
  646.      unsigned char in[(LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME],
  647.      unsigned char out[LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME],
  648.      int delay1, int permute)
  649. {
  650.   int i;
  652.   if (in == out) return -1;
  654.   for (i = 0; i < PACKETS_PER_SUBCHANNELFRAME; i++) {
  655.      int j;
  656.      unsigned char t;
  658.      if (delay1) {
  659. /* shift through delay_line */
  660.   for (j = 0; j < LSUB_RAW+LSUB_Q+LSUB_P; j++) {
  661. if ((j % MAX_SUB_DEL) != MAX_SUB_DEL-1) {
  662. t = sub_delay_line[(sub_del_index) % MAX_SUB_DEL][j];
  663. sub_delay_line[(sub_del_index + (MAX_SUB_DEL - j)) % MAX_SUB_DEL][j] = in[j];
  664. in[j] = t;
  665. }
  666. }
  667.      }
  669.      if (permute) {
  670. /* permute */
  671. t = in[1]; in[1] = in[18]; in[18] = t;
  672. t = in[2]; in[2] = in[ 5]; in[ 5] = t;
  673. t = in[3]; in[3] = in[23]; in[23] = t;
  674.      }
  676.      /* build P parity */
  677.      decode_LSUB_P(in);
  679.      /* build Q parity */
  680.      decode_LSUB_Q(in);
  682.      memcpy(out, in, LSUB_QRAW);
  683.      memcpy(out+LSUB_QRAW, in+LSUB_QRAW+LSUB_Q, LSUB_RAW-LSUB_QRAW);
  685.      sub_del_index++;
  686.      in += LSUB_RAW+LSUB_Q+LSUB_P;
  687.      out += LSUB_RAW;
  688.   }
  689.   return 0;
  690. }
  692. static int sectortype = MODE_0;
  693. int get_sector_type(void)
  694. {
  695.   return sectortype;
  696. }
  698. int set_sector_type(int st)
  699. {
  700.   switch(st) {
  701.     case MODE_0:
  702.     case MODE_1:
  703.     case MODE_2:
  704.     case MODE_2_FORM_1:
  705.     case MODE_2_FORM_2:
  706.       sectortype = st;
  707.     default:
  708.       return -1;
  709.   }
  710.   return 0;
  711. }
  713. /* ------------- --------------*/
  714. #ifdef MAIN
  716. #define DO_L1 1
  717. #define DO_L2 2
  718. #define DO_SUB 4
  720. static const unsigned sect_size[8][2] = {
  721. /* nothing */
  722. {0,0},
  723. /* Layer 1 decode/encode */
  724. { (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR, L1_RAW*FRAMES_PER_SECTOR},
  725. /* Layer 2 decode/encode */
  726. { 16+L2_RAW+12+L2_Q+L2_P, L2_RAW},
  727. /* Layer 1 and 2 decode/encode */
  728. { (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR, L1_RAW*FRAMES_PER_SECTOR},
  729. /* Subchannel decode/encode */
  730. { (LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME,
  731.  LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME},
  732. /* Layer 1 and subchannel decode/encode */
  733. { (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR +
  734.    (LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME,
  735.   LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME +
  736.    L1_RAW*FRAMES_PER_SECTOR},
  737. /* Layer 2 and subchannel decode/encode */
  738. { L2_RAW+L2_Q+L2_P+
  739.    (LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME,
  740.   LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME +
  741.    L2_RAW},
  742. /* Layer 1, 2 and subchannel decode/encode */
  743. { (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR +
  744.    (LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME,
  745.   LSUB_RAW*PACKETS_PER_SUBCHANNELFRAME +
  746.    L1_RAW*FRAMES_PER_SECTOR},
  747. };
  749. int main(int argc, char **argv)
  750. {
  751.   int encode = 1;
  752.   int mask = DO_L2;
  753.   FILE *infp;
  754.   FILE *outfp;
  755.   unsigned address = 0;
  756.   unsigned char *l1_inbuf;
  757.   unsigned char *l1_outbuf;
  758.   unsigned char *l2_inbuf;
  759.   unsigned char *l2_outbuf;
  760.   unsigned char *sub_inbuf;
  761.   unsigned char *sub_outbuf;
  762.   unsigned char *last_outbuf;
  763.   unsigned char inbuf[(LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME +
  764. (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR];
  765.   unsigned char outbuf[(LSUB_RAW+LSUB_Q+LSUB_P)*PACKETS_PER_SUBCHANNELFRAME +
  766. (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR];
  767.   unsigned load_offset;
  769.   l1_inbuf = l2_inbuf = sub_inbuf = inbuf;
  770.   l1_outbuf = l2_outbuf = sub_outbuf = last_outbuf = outbuf;
  772.   infp = fopen("sectors_in", "rb");
  773.   outfp = fopen("sectors_out", "wb");
  775.   sectortype= MODE_1;
  776.   address = 0 + 75*2;
  778.   switch (sectortype) {
  779. case MODE_1:
  780. case MODE_2:
  781. load_offset = 16;
  782. break;
  783. case MODE_2_FORM_1:
  784. case MODE_2_FORM_2:
  785. load_offset = 24;
  786. break;
  787. default:
  788. load_offset = 0;
  789.   }
  790.   while(1) {
  792. if (1 != fread(inbuf+load_offset,
  793.   sect_size[mask][encode], 1, infp)) { perror(""); break; }
  794. if (encode == 1) {
  795.       if (mask & DO_L2) {
  796. switch (sectortype) {
  797. case MODE_0:
  798. break;
  799. case MODE_1:
  800. break;
  801. case MODE_2:
  802. if (1 !=
  803.   fread(inbuf+load_offset+
  804. sect_size[mask][encode],
  805.   2336 - sect_size[mask][encode],
  806. 1, infp)) { perror(""); break; }
  807. break;
  808. case MODE_2_FORM_1:
  809. break;
  810. case MODE_2_FORM_2:
  811. if (1 !=
  812.   fread(inbuf+load_offset+
  813. sect_size[mask][encode],
  814.   2324 - sect_size[mask][encode],
  815. 1, infp)) { perror(""); break; }
  816. break;
  817. default:
  818. if (1 !=
  819.   fread(inbuf+load_offset+
  820. sect_size[mask][encode],
  821.   2448 - sect_size[mask][encode],
  822. 1, infp)) { perror(""); break; }
  823. memset(inbuf,0,16);
  824. /*memset(inbuf+16+2048,0,12+272);*/
  825. break;
  826. }
  827. do_encode_L2(l2_inbuf, MODE_1, address);
  828. if (0) scramble_L2(l2_inbuf);
  829. last_outbuf = l1_inbuf = l2_inbuf;
  830. l1_outbuf = l2_inbuf;
  831. sub_inbuf = l2_inbuf + L2_RAW;
  832. sub_outbuf = l2_outbuf + 12 + 4+ L2_RAW+4+ 8+ L2_Q+L2_P;
  833.       }
  834.       if (mask & DO_L1) {
  835. do_encode_L1(l1_inbuf, l1_outbuf,1,1,1,1);
  836. last_outbuf = l1_outbuf;
  837. sub_inbuf = l1_inbuf + L1_RAW*FRAMES_PER_SECTOR;
  838. sub_outbuf = l1_outbuf + (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR;
  839.       }
  840.       if (mask & DO_SUB) {
  841. do_encode_sub(sub_inbuf, sub_outbuf, 0, 0);
  842.       }
  843. } else {
  844.       if (mask & DO_L1) {
  845. do_decode_L1(l1_inbuf, l1_outbuf,1,1,1,1);
  846. last_outbuf = l2_inbuf = l1_outbuf;
  847. l2_outbuf = l1_inbuf;
  848. sub_inbuf = l1_inbuf + (L1_RAW+L1_Q+L1_P)*FRAMES_PER_SECTOR;
  849. sub_outbuf = l1_outbuf + L1_RAW*FRAMES_PER_SECTOR;
  850.       }
  851.       if (mask & DO_L2) {
  852. do_decode_L2(l2_inbuf, l2_outbuf);
  853. last_outbuf = l2_outbuf;
  854. sub_inbuf = l2_inbuf + L2_RAW+L2_Q+L2_P;
  855. sub_outbuf = l2_outbuf + L2_RAW;
  856.       }
  857.       if (mask & DO_SUB) {
  858. do_decode_sub(sub_inbuf, sub_outbuf, 1, 1);
  859.       }
  860. }
  861. if (1 != fwrite(last_outbuf, sect_size[mask][1 - encode], 1, outfp)) {
  862. perror("");
  863. break;
  864. }
  865. address++;
  866.   }
  867. #if 0
  868.   /* flush the data from the delay lines with zeroed sectors, if necessary */
  869. #endif
  870.   return 0;
  871. }
  872. #endif