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

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

SCSI/ASPI

开发平台：

MultiPlatform

PWSubChannel96.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998  Andreas Mueller <mueller@daneb.ping.de>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19. /*
  20.  * $Log: PWSubChannel96.cc,v $
  21.  * Revision 1.6  1999/04/05 11:04:48  mueller
  22.  * Added decoding of media catalog number and ISRC code.
  23.  *
  24.  * Revision 1.5  1999/03/27 20:58:55  mueller
  25.  * Added various access functions.
  26.  *
  27.  * Revision 1.4  1998/09/27 19:19:39  mueller
  28.  * Added retrieval of control nibbles for track with 'analyzeTrack()'.
  29.  *
  30.  * Revision 1.3  1998/09/06 13:34:22  mueller
  31.  * Use 'message()' for printing messages.
  32.  *
  33.  * Revision 1.2  1998/08/30 19:10:32  mueller
  34.  * Added handling of Catalog Number and ISRC codes.
  35.  *
  36.  * Revision 1.1  1998/08/29 21:32:27  mueller
  37.  * Initial revision
  38.  *
  39.  *
  40.  */
  42. #include "PWSubChannel96.h"
  44. #include <stdio.h>
  45. #include <string.h>
  46. #include <assert.h>
  48. #include "util.h"
  50. PWSubChannel96::PWSubChannel96()
  51. {
  52.   memset(data_, 0, 96);
  53.   type_ = QMODE1DATA;
  54. }
  56. PWSubChannel96::PWSubChannel96(unsigned char *buf)
  57. {
  58.   init(buf);
  59. }
  61. void PWSubChannel96::init(unsigned char *buf)
  62. {
  63.   memcpy(data_, buf, 96);
  65.   switch (getChannelByte(Q_CHAN, 0) & 0x0f) {
  66.   case 1:
  67.     type_ = QMODE1DATA;
  68.     break;
  70.   case 2:
  71.     type_ = QMODE2;
  72.     break;
  74.   case 3:
  75.     type_ = QMODE3;
  76.     break;
  78.   default:
  79.     type_ = QMODE_ILLEGAL;
  80.     break;
  81.   }
  82. }
  84. PWSubChannel96::~PWSubChannel96()
  85. {
  86. }
  88. SubChannel *PWSubChannel96::makeSubChannel(Type t)
  89. {
  90.   PWSubChannel96 *chan = new PWSubChannel96;
  92.   chan->type_ = t;
  94.   switch (t) {
  95.   case QMODE1TOC:
  96.   case QMODE1DATA:
  97.     chan->setChannelByte(Q_CHAN, 0, 0x01);
  98.     break;
  99.     
  100.   case QMODE2:
  101.     chan->setChannelByte(Q_CHAN, 0, 0x02);
  102.     break;
  104.   case QMODE3:
  105.     chan->setChannelByte(Q_CHAN, 0, 0x03);
  106.     break;
  108.   case QMODE_ILLEGAL:
  109.     chan->setChannelByte(Q_CHAN, 0, 0x00);
  110.     break;
  111.   }
  113.   return chan;
  114. }
  116. SubChannel *PWSubChannel96::makeSubChannel(unsigned char *buf)
  117. {
  118.   PWSubChannel96 *chan = new PWSubChannel96(buf);
  120.   return chan;
  121. }
  123. void PWSubChannel96::setChannelByte(Channel chan, int byteNr,
  124.     unsigned char value)
  125. {
  126.   assert(byteNr >= 0 && byteNr < 12);
  128.   register unsigned char setMask = 1 << chan;
  129.   register unsigned char clearMask = ~setMask;
  131.   register unsigned char *p = data_ + (byteNr * 8);
  132.   register int i;
  134.   for (i = 0; i < 8; i++) {
  135.     if (value & 0x80)
  136.       *p |= setMask;
  137.     else
  138.       *p &= clearMask;
  140.     p++;
  141.     value <<= 1;
  142.   }
  143. }
  145. unsigned char PWSubChannel96::getChannelByte(Channel chan, int byteNr) const
  146. {
  147.   assert(byteNr >= 0 && byteNr < 12);
  149.   register unsigned char testMask = 1 << chan;
  150.   register const unsigned char *p = data_ + (byteNr * 8);
  151.   register unsigned char val = 0;
  152.   register int i;
  153.   
  154.   for (i = 0; i < 8; i++) {
  155.     val <<= 1;
  156.     if ((*p) & testMask)
  157.       val |= 0x01;
  159.     p++;
  160.   }
  162.   return val;
  163. }
  165. const unsigned char *PWSubChannel96::data() const
  166. {
  167.   return data_;
  168. }
  170. long PWSubChannel96::dataLength() const
  171. {
  172.   return 96;
  173. }
  175. // calculate the crc over Q sub channel bytes 0-9 and stores it in byte 10,11
  176. void PWSubChannel96::calcCrc()
  177. {
  178.   register unsigned short crc = 0;
  179.   register int i;
  181.   for (i = 0; i < 10; i++) {
  182.     register unsigned char data = getChannelByte(Q_CHAN, i);
  183.     crc = crctab[(crc >> 8) ^ data] ^ (crc << 8);
  184.   }
  186.   crc = ~crc;
  188.   setChannelByte(Q_CHAN, 10, crc >> 8);
  189.   setChannelByte(Q_CHAN, 11, crc);
  190. }
  192. int PWSubChannel96::checkCrc() const
  193. {
  194.   register unsigned short crc = 0;
  195.   register int i;
  197.   if (!crcValid_) {
  198.     return 1;
  199.   }
  201.   for (i = 0; i < 10; i++) {
  202.     register unsigned char data = getChannelByte(Q_CHAN, i);
  203.     crc = crctab[(crc >> 8) ^ data] ^ (crc << 8);
  204.   }
  206.   crc = ~crc;
  208.   if (getChannelByte(Q_CHAN, 10) == (crc >> 8) &&
  209.       getChannelByte(Q_CHAN, 11) == (crc & 0xff))
  210.     return 1;
  211.   else
  212.     return 0;
  213. }
  216. // sets P channel bit
  217. void PWSubChannel96::pChannel(int f)
  218. {
  219.   register int i;
  221.   if (f != 0) {
  222.     for (i = 0; i < 96; i++)
  223.       data_[i] |= 0x80;
  224.   }
  225.   else {
  226.     for (i = 0; i < 96; i++)
  227.       data_[i] &= 0x7f;
  228.   }    
  229. }
  231. // returns Q type
  232. SubChannel::Type PWSubChannel96::type() const
  233. {
  234.   return type_;
  235. }
  238. // set Q type
  239. void PWSubChannel96::type(unsigned char type)
  240. {
  241.   switch (type & 0x0f) {
  242.   case 1:
  243.     type_ = QMODE1DATA;
  244.     break;
  246.   case 2:
  247.     type_ = QMODE2;
  248.     break;
  250.   case 3:
  251.     type_ = QMODE3;
  252.     break;
  254.   default:
  255.     type_ = QMODE_ILLEGAL;
  256.     break;
  257.   }
  259.   register unsigned char val = getChannelByte(Q_CHAN, 0);
  261.   val &= 0xf0;
  262.   val |= type & 0x0f;
  264.   setChannelByte(Q_CHAN, 0, val);
  265. }
  267. // function for setting various Q sub channel fields
  269. void PWSubChannel96::ctl(int c)
  270. {
  271.   assert((c & 0x0f) == 0);
  273.   register unsigned char val = getChannelByte(Q_CHAN, 0);
  275.   val &= 0x0f;
  276.   val |= c & 0xf0;
  278.   setChannelByte(Q_CHAN, 0, val);
  279. }
  281. unsigned char PWSubChannel96::ctl() const
  282. {
  283.   register unsigned char val = getChannelByte(Q_CHAN, 0);
  285.   return val >> 4;
  286. }
  288. void PWSubChannel96::trackNr(int t)
  289. {
  290.   assert(type_ == QMODE1DATA);
  291.   setChannelByte(Q_CHAN, 1, bcd(t));
  292. }
  294. int PWSubChannel96::trackNr() const
  295. {
  296.   assert(type_ == QMODE1DATA);
  297.   return bcd2int(getChannelByte(Q_CHAN, 1));
  298. }
  300. void PWSubChannel96::indexNr(int i)
  301. {
  302.   assert(type_ == QMODE1DATA);
  303.   setChannelByte(Q_CHAN, 2, bcd(i));
  304. }
  306. int PWSubChannel96::indexNr() const
  307. {
  308.   assert(type_ == QMODE1DATA);
  309.   return bcd2int(getChannelByte(Q_CHAN, 2));
  310. }
  312. void PWSubChannel96::point(int p)
  313. {
  314.   assert(type_ == QMODE1TOC);
  315.   setChannelByte(Q_CHAN, 2, bcd(p));
  316. }
  318. void PWSubChannel96::min(int m)
  319. {
  320.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  321.   setChannelByte(Q_CHAN, 3, bcd(m));
  322. }
  324. int PWSubChannel96::min() const
  325. {
  326.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  327.   return bcd2int(getChannelByte(Q_CHAN, 3));
  328. }
  330. void PWSubChannel96::sec(int s)
  331. {
  332.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  333.   setChannelByte(Q_CHAN, 4, bcd(s));
  334. }
  336. int PWSubChannel96::sec() const
  337. {
  338.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  339.   return bcd2int(getChannelByte(Q_CHAN, 4));
  340. }
  342. void PWSubChannel96::frame(int f)
  343. {
  344.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  345.   setChannelByte(Q_CHAN, 5, bcd(f));
  346. }
  348. int PWSubChannel96::frame() const
  349. {
  350.   assert(type_ == QMODE1TOC || type_ == QMODE1DATA);
  351.   return bcd2int(getChannelByte(Q_CHAN, 5));
  352. }
  354. void PWSubChannel96::amin(int am)
  355. {
  356.   assert(type_ == QMODE1DATA);
  357.   setChannelByte(Q_CHAN, 7, bcd(am));
  358. }
  360. int PWSubChannel96::amin() const
  361. {
  362.   assert(type_ == QMODE1DATA);
  363.   return bcd2int(getChannelByte(Q_CHAN, 7));
  364. }
  366. void PWSubChannel96::asec(int as)
  367. {
  368.   assert(type_ == QMODE1DATA);
  369.   setChannelByte(Q_CHAN, 8, bcd(as));
  370. }
  372. int PWSubChannel96::asec() const
  373. {
  374.   assert(type_ == QMODE1DATA);
  375.   return bcd2int(getChannelByte(Q_CHAN, 8));
  376. }
  378. void PWSubChannel96::aframe(int af)
  379. {
  380.   assert(type_ == QMODE1DATA || type_ == QMODE2 || type_ == QMODE3);
  381.   setChannelByte(Q_CHAN, 9, bcd(af));
  382. }
  384. int PWSubChannel96::aframe() const
  385. {
  386.   assert(type_ == QMODE1DATA || type_ == QMODE2 || type_ == QMODE3);
  387.   return bcd2int(getChannelByte(Q_CHAN, 9));
  388. }
  390. void PWSubChannel96::pmin(int pm)
  391. {
  392.   assert(type_ == QMODE1TOC);
  393.   setChannelByte(Q_CHAN, 7, bcd(pm));
  394. }
  396. void PWSubChannel96::psec(int ps)
  397. {
  398.   assert(type_ == QMODE1TOC);
  399.   setChannelByte(Q_CHAN, 8, bcd(ps));
  400. }
  402. void PWSubChannel96::pframe(int pf)
  403. {
  404.   assert(type_ == QMODE1TOC);
  405.   setChannelByte(Q_CHAN, 9, bcd(pf));
  406. }
  408. void PWSubChannel96::catalog(char n1, char n2, char n3, char n4, char n5,
  409.      char n6, char n7, char n8, char n9, char n10,
  410.      char n11, char n12, char n13)
  411. {
  412.   assert(type_ == QMODE2);
  414.   unsigned char buf[8];
  415.   int i;
  416.   
  417.   encodeCatalogNumber(buf, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12,
  418.       n13);
  419.   buf[7] = 0;
  421.   for (i = 0; i < 8; i++)
  422.     setChannelByte(Q_CHAN, i + 1, buf[i]);
  423. }
  425. const char *PWSubChannel96::catalog() const
  426. {
  427.   static char buf[14];
  428.   unsigned char in[7];
  429.   int i;
  431.   for (i = 0; i < 7; i++)
  432.     in[i] = getChannelByte(Q_CHAN, i + 1);
  434.   decodeCatalogNumber(in, &buf[0], &buf[1], &buf[2], &buf[3], &buf[4],
  435.       &buf[5], &buf[6], &buf[7], &buf[8], &buf[9], &buf[10],
  436.       &buf[11], &buf[12]);
  438.   buf[13] = 0;
  440.   return buf;
  441. }
  443. void PWSubChannel96::isrc(char c1, char c2, char o1, char o2, char o3,
  444.   char y1, char y2, char s1, char s2, char s3,
  445.   char s4, char s5)
  446. {
  447.   assert(type_ == QMODE3);
  449.   unsigned char buf[8];
  450.   int i;
  452.   encodeIsrcCode(buf, c1, c2, o1, o2, o3, y1, y2, s1, s2, s3, s4, s5);
  454.   for (i = 0; i < 8; i++)
  455.     setChannelByte(Q_CHAN, i + 1, buf[i]);
  456. }
  458. const char *PWSubChannel96::isrc() const
  459. {
  460.   static char buf[13];
  461.   unsigned char in[8];
  462.   int i;
  464.   assert(type_ == QMODE3);
  466.   for (i = 0; i < 8; i++)
  467.     in[i] = getChannelByte(Q_CHAN, i + 1);
  469.   decodeIsrcCode(in, &buf[0], &buf[1], &buf[2], &buf[3], &buf[4],
  470.  &buf[5], &buf[6], &buf[7], &buf[8], &buf[9], &buf[10], 
  471.  &buf[11]);
  472.   buf[12] = 0;
  474.   return buf;
  475. }
  478. void PWSubChannel96::print() const
  479. {
  480.   if (type_ != QMODE_ILLEGAL) 
  481.     message(0, "P:%02x ", getChannelByte(P_CHAN, 0));
  483.   switch (type_) {
  484.   case QMODE1TOC:
  485.   case QMODE1DATA:
  486.     message(0, "Q: (%02x) %02x,%02x %02x:%02x:%02x %02x %02x:%02x:%02x ", 
  487.    getChannelByte(Q_CHAN, 0), getChannelByte(Q_CHAN, 1),
  488.    getChannelByte(Q_CHAN, 2), getChannelByte(Q_CHAN, 3),
  489.    getChannelByte(Q_CHAN, 4), getChannelByte(Q_CHAN, 5),
  490.    getChannelByte(Q_CHAN, 6), getChannelByte(Q_CHAN, 7),
  491.    getChannelByte(Q_CHAN, 8), getChannelByte(Q_CHAN, 9));
  492.     break;
  493.   case QMODE2:
  494.     message(0, "Q: (%02x) MCN: %s      %02x ", getChannelByte(Q_CHAN, 0),
  495.     catalog(), getChannelByte(Q_CHAN, 9));
  496.     break;
  497.   case QMODE3:
  498.     message(0, "Q: (%02x) ISRC: %s      %02x ", getChannelByte(Q_CHAN, 0),
  499.     isrc(), getChannelByte(Q_CHAN, 9));
  500.     break;
  501.   case QMODE_ILLEGAL:
  502.     message(0, "INVALID QMODE: %02x", getChannelByte(Q_CHAN, 0));
  503.     break;
  504.   }
  506.   if (type_ != QMODE_ILLEGAL) 
  507.     message(0, "%04x %d", 
  508.     (getChannelByte(Q_CHAN, 10) << 8) | getChannelByte(Q_CHAN, 11),
  509.     checkCrc());
  510. }
  512. // sets R-W channel bits from 72 byte data buffer, used for CD-TEXT
  513. void PWSubChannel96::setRawRWdata(const unsigned char *data)
  514. {
  515.   int i;
  517.   for (i = 0; i < 96; i += 4) {
  518.     data_[i]     |= (data[0] >> 2) & 0x3f;
  519.     data_[i + 1] |= ((data[0] << 4) & 0x30) | ((data[1] >> 4) & 0x0f);
  520.     data_[i + 2] |= ((data[1] << 2) & 0x3c) | ((data[2] >> 6) & 0x03);
  521.     data_[i + 3] |= data[2] & 0x3f;
  522.     
  523.     data += 3;
  524.   }
  525. }
  527. // concatenates the R-W channel bits and writes them to provided 72 byte buffer
  528. void PWSubChannel96::getRawRWdata(unsigned char *data) const
  529. {
  530.   int i;
  532.   for (i = 0; i < 96; i += 4) {
  533.     data[0] = ((data_[i] << 2) & 0xfc)     | ((data_[i + 1] >> 4) & 0x03);
  534.     data[1] = ((data_[i + 1] << 4) & 0xf0) | ((data_[i + 2] >> 2) & 0x0f);
  535.     data[2] = ((data_[i + 2] << 6) & 0xc0) | (data_[i + 3] & 0x3f);
  536.     
  537.     data += 3;
  538.   }
  539. }