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

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

SCSI/ASPI

开发平台：

MultiPlatform

CdTextEncoder.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998, 1999 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.  */
  20. /*
  21.  * $Log: CdTextEncoder.cc,v $
  22.  * Revision 1.1  1999/06/13 19:31:15  mueller
  23.  * Initial revision
  24.  *
  25.  */
  27. #include "CdTextEncoder.h"
  29. #include <stddef.h>
  30. #include <string.h>
  31. #include <assert.h>
  33. #include "util.h"
  34. #include "Toc.h"
  35. #include "CdTextItem.h"
  36. #include "PWSubChannel96.h"
  38. static char rcsid[] = "$Id: CdTextEncoder.cc,v 1.1 1999/06/13 19:31:15 mueller Exp mueller $";
  40. unsigned short CdTextEncoder::CRCTAB_[256] = {
  41.   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
  42.   0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
  43.   0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
  44.   0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
  45.   0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
  46.   0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
  47.   0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
  48.   0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  49.   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
  50.   0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
  51.   0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
  52.   0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
  53.   0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
  54.   0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
  55.   0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
  56.   0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  57.   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
  58.   0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
  59.   0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
  60.   0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
  61.   0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
  62.   0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
  63.   0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
  64.   0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  65.   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
  66.   0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
  67.   0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
  68.   0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
  69.   0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  70. };
  73. class CdTextPackEntry {
  74. public:
  75.   CdTextPackEntry(unsigned char packType, unsigned char trackNr, 
  76.   unsigned char packId);
  78.   int blockNr();
  79.   void blockNr(int);
  81.   void characterPos(int);
  82.   
  83.   union {
  84.     CdTextPack pack;
  85.     unsigned char packData[18];
  86.   };
  88.   CdTextPackEntry *next_;
  89. };
  91. CdTextPackEntry::CdTextPackEntry(unsigned char packType, unsigned char trackNr,
  92.  unsigned char packId)
  93. {
  94.   memset(&pack, 0, sizeof(pack));
  95.   next_ = NULL;
  97.   pack.packType = packType;
  98.   pack.trackNumber = trackNr;
  99.   pack.sequenceNumber = packId;
  100. }
  102. int CdTextPackEntry::blockNr()
  103. {
  104.   return (pack.blockCharacter >> 4) & 0x07;
  105. }
  107. void CdTextPackEntry::blockNr(int blockNr)
  108. {
  109.   pack.blockCharacter &= 0x8f;
  110.   pack.blockCharacter |= (blockNr << 4) & 0x70;
  111. }
  113. void CdTextPackEntry::characterPos(int pos)
  114. {
  115.   pack.blockCharacter &= 0xf0;
  117.   if (pos > 15) {
  118.     pack.blockCharacter |= 0x0f;
  119.   }
  120.   else {
  121.     pack.blockCharacter |= pos;
  122.   }
  123. }
  126. CdTextEncoder::CdTextEncoder(const Toc *toc)
  127. {
  128.   int i;
  130.   toc_ = toc;
  132.   packCount_ = 0;
  133.   packs_ = lastPack_ = NULL;
  134.   lastPackPos_ = 0;
  136.   subChannels_ = NULL;
  137.   subChannelCount_ = 0;
  139.   for (i = 0; i < 8; i++)
  140.     memset(&(sizeInfo_[i]), 0, sizeof(CdTextSizeInfo));
  141. }
  143. CdTextEncoder::~CdTextEncoder()
  144. {
  145.   long i;
  146.   CdTextPackEntry *pnext;
  148.   toc_ = NULL;
  150.   while (packs_ != NULL) {
  151.     pnext = packs_->next_;
  153.     delete packs_;
  154.     packs_ = pnext;
  155.   }
  157.   lastPack_ = NULL;
  159.   if (subChannels_ != NULL) {
  160.     for (i = 0; i < subChannelCount_; i++) {
  161.       delete subChannels_[i];
  162.       subChannels_[i] = NULL;
  163.     }
  164.     
  165.     delete[] subChannels_;
  166.     subChannels_ = NULL;
  167.   }
  168. }
  170. int CdTextEncoder::encode()
  171. {
  172.   buildPacks();
  174.   calcCrcs();
  176.   if (packs_ != NULL) {
  177.     message(3, "nCD-TEXT packs:");
  178.     CdTextPackEntry *prun;
  179.     for (prun = packs_; prun != NULL; prun = prun->next_) {
  180.       message(3, "%02x %02x %02x %02x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x  CRC: %02x %02x", prun->pack.packType,
  181.       prun->pack.trackNumber, prun->pack.sequenceNumber,
  182.       prun->pack.blockCharacter, prun->pack.data[0],
  183.       prun->pack.data[1], prun->pack.data[2], prun->pack.data[3],
  184.       prun->pack.data[4], prun->pack.data[5], prun->pack.data[6],
  185.       prun->pack.data[7], prun->pack.data[8], prun->pack.data[9],
  186.       prun->pack.data[10], prun->pack.data[11],
  187.       prun->pack.crc0, prun->pack.crc1);
  188.     }
  189.   }
  190.   
  191.   buildSubChannels();
  193.   return 0;
  194. }
  196. const PWSubChannel96 **CdTextEncoder::getSubChannels(long *subChannelCount)
  197. {
  198.   *subChannelCount = subChannelCount_;
  200.   return (const PWSubChannel96 **)subChannels_;
  201. }
  203. void CdTextEncoder::buildPacks()
  204. {
  205.   int blockNr;
  207.   for (blockNr = 0; blockNr <= 7; blockNr++) {
  208.     if (toc_->cdTextLanguage(blockNr) >= 0) {
  209.       // only build the packs if the language code is defined
  210.       packId_ = 0;
  211.     
  212.       buildPacks(blockNr, CdTextItem::CDTEXT_TITLE);
  213.       buildPacks(blockNr, CdTextItem::CDTEXT_PERFORMER);
  214.       buildPacks(blockNr, CdTextItem::CDTEXT_SONGWRITER);
  215.       buildPacks(blockNr, CdTextItem::CDTEXT_COMPOSER);
  216.       buildPacks(blockNr, CdTextItem::CDTEXT_ARRANGER);
  217.       buildPacks(blockNr, CdTextItem::CDTEXT_MESSAGE);
  218.       buildPacks(blockNr, CdTextItem::CDTEXT_DISK_ID);
  219.       buildPacks(blockNr, CdTextItem::CDTEXT_GENRE);
  220.       buildPacks(blockNr, CdTextItem::CDTEXT_TOC_INFO1);
  221.       buildPacks(blockNr, CdTextItem::CDTEXT_TOC_INFO2);
  222.       buildPacks(blockNr, CdTextItem::CDTEXT_UPCEAN_ISRC);
  223.     }
  224.   }
  226.   buildSizeInfoPacks();
  227. }
  229. // Build packs for specified language (blockNr) and pack type. First the
  230. // global pack is created and then the track specific packs.
  231. void CdTextEncoder::buildPacks(int blockNr, CdTextItem::PackType type)
  232. {
  233.   const CdTextItem *globalItem;
  234.   const CdTextItem *item;
  235.   int i;
  236.   int n = toc_->nofTracks();
  237.   int tracks;
  239.   if ((globalItem = toc_->getCdTextItem(0, blockNr, type)) != NULL) {
  240.     encodeCdTextItem(0, blockNr, globalItem);
  241.   }
  243.   if (CdTextItem::isTrackPack(type)) {
  244.     // count tracks that have the current pack type defined
  245.     tracks = 0;
  247.     for (i = 1; i <= n; i++) {
  248.       if (toc_->getCdTextItem(i, blockNr, type) != NULL)
  249. tracks++;
  250.     }
  252.     if (tracks > 0) {
  253.       if (globalItem == NULL && type == CdTextItem::CDTEXT_UPCEAN_ISRC) {
  254. // Special handling for UPC/EAN field. If this field is not defined
  255. // but ISRC codes are defined for the tracks an pack with an empty
  256. // string is created.
  257. CdTextItem upcEan(CdTextItem::CDTEXT_UPCEAN_ISRC, blockNr, "");
  258. encodeCdTextItem(0, blockNr, &upcEan);
  259.       }
  261.       for (i = 1; i <= n; i++) {
  262. if ((item = toc_->getCdTextItem(i, blockNr, type)) == NULL)
  263.   item = globalItem;
  265. if (item != NULL)
  266.   encodeCdTextItem(i, blockNr, item);
  267.       }
  268.     }
  269.   }
  270. }
  272. // Build CD-TEXT packs for a CdTextItem. Space from the last pack is
  273. // used if the pack type and language are matching.
  274. void CdTextEncoder::encodeCdTextItem(int trackNr, int blockNr,
  275.      const CdTextItem *item)
  276. {
  277.   long dataLen = item->dataLen();
  278.   const unsigned char *data = item->data();
  279.   long pos, n;
  280.   CdTextPackEntry *pack = NULL;
  281.   int first = 1;
  282.   
  283.   if (CdTextItem::isBinaryPack(item->packType())) {
  284.     pos = 0;
  286.     while (dataLen > 0) {
  287.       switch (item->packType()) {
  288.       case CdTextItem::CDTEXT_GENRE:
  289. pack = new CdTextPackEntry(item->packType(), 0, packId_++);
  290. if (pos > 0)
  291.   pack->characterPos((pos * 12) - 2);
  292. break;
  293.       case CdTextItem::CDTEXT_TOC_INFO1:
  294. if (pos == 0)
  295.   pack = new CdTextPackEntry(item->packType(), 0, packId_++);
  296. else
  297.   pack = new CdTextPackEntry(item->packType(), ((pos - 1) * 4) + 1,
  298.      packId_++);
  299. break;
  300.       default:
  301. pack = new CdTextPackEntry(item->packType(), pos, packId_++);
  302. break;
  303.       }
  305.       n = (dataLen > 12) ? 12 : dataLen;
  307.       memcpy(pack->pack.data, data, n);
  308.       pack->blockNr(blockNr);
  310.       appendPack(pack);
  311.       lastPackPos_ = 12;
  312.       
  313.       data += n;
  314.       dataLen -= n;
  315.       pos++;
  316.     }
  317.   }
  318.   else {
  319.     pos = 0;
  321.     while (dataLen > 0) {
  322.       if (first && lastPack_ != NULL &&
  323.   lastPack_->pack.packType == item->packType() &&
  324.   lastPack_->blockNr() == blockNr &&
  325.   lastPackPos_ < 12) {
  326. // we can use space from previous block
  327. pack = lastPack_;
  328.       }
  329.       else {
  330. pack = new CdTextPackEntry(item->packType(), trackNr, packId_++);
  331. pack->blockNr(blockNr);
  332. pack->characterPos(pos);
  333. appendPack(pack);
  334. lastPackPos_ = 0;
  335.       }
  337.       n = (dataLen > 12 - lastPackPos_) ? 12 - lastPackPos_ : dataLen;
  339.       memcpy(pack->pack.data + lastPackPos_, data, n);
  341.       data += n;
  342.       lastPackPos_ += n;
  343.       pos += n;
  344.       dataLen -= n;
  346.       first = 0;
  347.     }
  348.   }
  349. }
  351. // Create the SIZE_INFO CD-TEXT packs which contains a summary about all
  352. // CD-TEXT packs.
  353. void CdTextEncoder::buildSizeInfoPacks()
  354. {
  355.   CdTextItem *sizeInfoItem;
  356.   int i;
  357.   int b;
  359.   if (lastPack_ == NULL) {
  360.     // no packs at all -> nothing to do
  361.     return;
  362.   }
  364.   for (b = 0; b < 8; b++) {
  365.     sizeInfo_[b].characterCode = 1; // ASCII (7bit)
  367.     sizeInfo_[b].firstTrack = 1; // we always start with track 1
  368.     sizeInfo_[b].lastTrack = toc_->nofTracks();
  370.     sizeInfo_[b].copyright = 3; // to look like all other CD-TEXT CDs
  372.     for (i = 0; i < 8; i++) {
  373.       if (sizeInfo_[b].lastSequenceNumber[i] > 0) {
  374. // set language code if we have at least one pack for this language
  375. sizeInfo_[b].languageCode[i] = toc_->cdTextLanguage(i);
  376. // adjust the last sequence number for the packs we will create
  377. sizeInfo_[b].lastSequenceNumber[i] += 3;
  378.       }
  379.     }
  381.     // adjust the counter for the packs we're currently creating
  382.     sizeInfo_[b].packTypeCount[15] += 3; // we create 3 packs 
  383.   }
  385.   for (b = 0; b < 8; b++) {
  386.     if (sizeInfo_[b].lastSequenceNumber[b] > 0) {
  387.       // ' - 3' because we've already adjusted the pack count
  388.       packId_ = sizeInfo_[b].lastSequenceNumber[b] - 3 + 1;
  390.       sizeInfoItem = new CdTextItem(CdTextItem::CDTEXT_SIZE_INFO, b, 
  391.     (unsigned char*)&(sizeInfo_[b]),
  392.     sizeof(CdTextSizeInfo));
  394.       encodeCdTextItem(0, b, sizeInfoItem);
  396.       delete sizeInfoItem;
  397.     }
  398.   }
  399. }
  401. // Calculates checksum for each CD-TEXT pack.
  402. void CdTextEncoder::calcCrcs()
  403. {
  404.   CdTextPackEntry *prun;
  405.   register unsigned char data;
  406.   register unsigned short crc;
  407.   register int i;
  409.   for (prun = packs_; prun != NULL; prun = prun->next_) {
  410.     crc = 0;
  412.     for (i = 0; i < 16; i++) {
  413.       data = prun->packData[i];
  414.       crc = CRCTAB_[(crc >> 8) ^ data] ^ (crc << 8);
  415.     }
  417.     crc = ~crc;
  418.     
  419.     prun->pack.crc0 = crc >> 8;
  420.     prun->pack.crc1 = crc;
  421.   }
  422. }
  424. // Builds the R-W sub-channel data for all CD-TEXT packs. The sub-channel
  425. // data of each sector can hold 4 CD-TEXT packs.
  426. void CdTextEncoder::buildSubChannels()
  427. {
  428.   long i;
  429.   CdTextPackEntry *prun;
  430.   unsigned char buf[72];
  432.   subChannelCount_ = packCount_ / 4;
  434.   if (packCount_ % 4 != 0)
  435.     subChannelCount_ += 1;
  437.   if (subChannelCount_ == 0) {
  438.     subChannels_ = NULL;
  439.     return;
  440.   }
  442.   subChannels_ = new (PWSubChannel96*)[subChannelCount_];
  443.   
  444.   prun = packs_;
  445.   for (i = 0; i < subChannelCount_; i++) {
  446.     subChannels_[i] = new PWSubChannel96;
  448.     memset(buf, 0, 72);
  450.     memcpy(buf, prun->packData, 18);
  452.     if ((prun = prun->next_) != NULL) {
  453.       memcpy(buf + 18, prun->packData, 18);
  455.       if ((prun = prun->next_) != NULL) {
  456. memcpy(buf + 36, prun->packData, 18);
  458. if ((prun = prun->next_) != NULL) {
  459.   memcpy(buf + 54, prun->packData, 18);
  460.   prun = prun->next_;
  461. }
  462.       }
  463.     }
  465.     subChannels_[i]->setRawRWdata(buf);
  467. #if 0
  468.     int j, k;
  470.     for (j = 0; j < 6; j++) {
  471.       message(0, "%ld:%d: ", i, j);
  472.       for (k = 0; k < 16; k++) {
  473. message(0, "%02x ", subChannels_[i]->data()[j * 16 + k]);
  474.       }
  475.       message(0, "");
  476.     }
  478.     unsigned char buf1[72];
  480.     subChannels_[i]->getRawRWdata(buf1);
  482.     message(0, "Match: %d", memcmp(buf, buf1, 72));
  483. #endif
  484.   }
  485. }
  488. void CdTextEncoder::appendPack(CdTextPackEntry *pack)
  489. {
  490.   int b;
  492.   assert(pack->blockNr() >= 0 && pack->blockNr() <= 7);
  494.   pack->next_ = NULL;
  496.   if (packs_ == NULL) {
  497.     packs_ = lastPack_ = pack;
  498.   }
  499.   else {
  500.     if (pack->blockNr() >= lastPack_->blockNr()) {
  501.       lastPack_->next_ = pack;
  502.       lastPack_ = pack;
  503.     }
  504.     else {
  505.       CdTextPackEntry *prun, *ppred;
  507.       for (ppred = NULL, prun = packs_; prun != NULL;
  508.    ppred = prun, prun = prun->next_) {
  509. if (pack->blockNr() < prun->blockNr())
  510.   break;
  511.       }
  512.       
  513.       if (prun == NULL) {
  514. // this case should have been handled above
  515. lastPack_->next_ = pack;
  516. lastPack_ = pack;
  517.       }
  518.       else {
  519. if (ppred == NULL) {
  520.   pack->next_ = packs_;
  521.   packs_ = pack;
  522. }
  523. else {
  524.   ppred->next_ = pack;
  525.   pack->next_ = prun;
  526. }
  527.       }
  528.     }
  529.   }
  530.   
  531.   packCount_++;
  533.   // update summary data used for creating the SIZE_INFO pack
  534.   sizeInfo_[pack->blockNr()].packTypeCount[pack->pack.packType - 0x80] += 1;
  536.   for (b = 0; b < 8; b++) {
  537.     if (pack->pack.sequenceNumber >
  538. sizeInfo_[b].lastSequenceNumber[pack->blockNr()]) {
  539.       sizeInfo_[b].lastSequenceNumber[pack->blockNr()] =
  540. pack->pack.sequenceNumber;
  541.     }
  542.   }
  543. }