/[svn]/libgig/trunk/src/gig.cpp
ViewVC logotype

Diff of /libgig/trunk/src/gig.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 929 by schoenebeck, Tue Oct 24 22:24:45 2006 UTC revision 930 by schoenebeck, Sun Oct 29 17:57:20 2006 UTC
# Line 286  namespace { Line 286  namespace {
286          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
287          if (pCk3gix) {          if (pCk3gix) {
288              uint16_t iSampleGroup = pCk3gix->ReadInt16();              uint16_t iSampleGroup = pCk3gix->ReadInt16();
289              // caution: sample groups in .gig files are indexed (1..n) whereas Groups in libgig (0..n-1)              pGroup = pFile->GetGroup(iSampleGroup);
             pGroup = pFile->GetGroup(iSampleGroup - 1);  
290          } else { // '3gix' chunk missing          } else { // '3gix' chunk missing
291              // not assigned to a group by default              // by default assigned to that mandatory "Default Group"
292              pGroup = NULL;              pGroup = pFile->GetGroup(0);
293          }          }
294    
295          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
# Line 401  namespace { Line 400  namespace {
400          pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
401          if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);          if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
402          // determine appropriate sample group index (to be stored in chunk)          // determine appropriate sample group index (to be stored in chunk)
403          uint16_t iSampleGroup = 0; // no sample group by default          uint16_t iSampleGroup = 0; // 0 refers to default sample group
404          File* pFile = static_cast<File*>(pParent);          File* pFile = static_cast<File*>(pParent);
405          if (pFile->pGroups) {          if (pFile->pGroups) {
406              std::list<Group*>::iterator iter = pFile->pGroups->begin();              std::list<Group*>::iterator iter = pFile->pGroups->begin();
407              std::list<Group*>::iterator end  = pFile->pGroups->end();              std::list<Group*>::iterator end  = pFile->pGroups->end();
408              // caution: sample groups in .gig files are indexed (1..n) whereas Groups in libgig (0..n-1)              for (int i = 0; iter != end; i++, iter++) {
             for (int i = 1; iter != end; i++, iter++) {  
409                  if (*iter == pGroup) {                  if (*iter == pGroup) {
410                      iSampleGroup = i;                      iSampleGroup = i;
411                      break; // found                      break; // found
# Line 1154  namespace { Line 1152  namespace {
1152          }          }
1153      }      }
1154    
1155        /**
1156         * Returns pointer to the Group this Sample belongs to. In the .gig
1157         * format a sample always belongs to one group. If it wasn't explicitly
1158         * assigned to a certain group, it will be automatically assigned to a
1159         * default group.
1160         *
1161         * @returns Sample's Group (never NULL)
1162         */
1163        Group* Sample::GetGroup() const {
1164            return pGroup;
1165        }
1166    
1167      Sample::~Sample() {      Sample::~Sample() {
1168          Instances--;          Instances--;
1169          if (!Instances && InternalDecompressionBuffer.Size) {          if (!Instances && InternalDecompressionBuffer.Size) {
# Line 2690  namespace { Line 2700  namespace {
2700    
2701      /** @brief Constructor.      /** @brief Constructor.
2702       *       *
2703       * @param file   - pointer to the RIFF::File object of this .gig file       * @param file   - pointer to the gig::File object
2704       * @param ck3gnm - pointer to 3gnm chunk associated with this group       * @param ck3gnm - pointer to 3gnm chunk associated with this group or
2705         *                 NULL if this is a new Group
2706       */       */
2707      Group::Group(RIFF::File* file, RIFF::Chunk* ck3gnm) {      Group::Group(File* file, RIFF::Chunk* ck3gnm) {
2708          pFile      = file;          pFile      = file;
2709          pNameChunk = ck3gnm;          pNameChunk = ck3gnm;
2710          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
# Line 2709  namespace { Line 2720  namespace {
2720       */       */
2721      void Group::UpdateChunks() {      void Group::UpdateChunks() {
2722          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
2723          RIFF::List* _3gri = pFile->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
2724          if (!_3gri) _3gri = pFile->AddSubList(LIST_TYPE_3GRI);          if (!_3gri) _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);
2725          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
2726          if (!_3gnl) _3gnl = pFile->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = pFile->pRIFF->AddSubList(LIST_TYPE_3GNL);
2727          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
2728          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
2729      }      }
2730    
2731        /**
2732         * Returns the first Sample of this Group. You have to call this method
2733         * once before you use GetNextSample().
2734         *
2735         * <b>Notice:</b> this method might block for a long time, in case the
2736         * samples of this .gig file were not scanned yet
2737         *
2738         * @returns  pointer address to first Sample or NULL if there is none
2739         *           applied to this Group
2740         * @see      GetNextSample()
2741         */
2742        Sample* Group::GetFirstSample() {
2743            // FIXME: lazy und unsafe implementation, should be an autonomous iterator
2744            for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
2745                if (pSample->GetGroup() == this) return pSample;
2746            }
2747            return NULL;
2748        }
2749    
2750        /**
2751         * Returns the next Sample of the Group. You have to call
2752         * GetFirstSample() once before you can use this method. By calling this
2753         * method multiple times it iterates through the Samples assigned to
2754         * this Group.
2755         *
2756         * @returns  pointer address to the next Sample of this Group or NULL if
2757         *           end reached
2758         * @see      GetFirstSample()
2759         */
2760        Sample* Group::GetNextSample() {
2761            // FIXME: lazy und unsafe implementation, should be an autonomous iterator
2762            for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
2763                if (pSample->GetGroup() == this) return pSample;
2764            }
2765            return NULL;
2766        }
2767    
2768        /**
2769         * Move Sample given by \a pSample from another Group to this Group.
2770         */
2771        void Group::AddSample(Sample* pSample) {
2772            pSample->pGroup = this;
2773        }
2774    
2775        /**
2776         * Move all members of this group to another group (preferably the 1st
2777         * one except this). This method is called explicitly by
2778         * File::DeleteGroup() thus when a Group was deleted. This code was
2779         * intentionally not placed in the destructor!
2780         */
2781        void Group::MoveAll() {
2782            // get "that" other group first
2783            Group* pOtherGroup = NULL;
2784            for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
2785                if (pOtherGroup != this) break;
2786            }
2787            if (!pOtherGroup) throw Exception(
2788                "Could not move samples to another group, since there is no "
2789                "other Group. This is a bug, report it!"
2790            );
2791            // now move all samples of this group to the other group
2792            for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
2793                pOtherGroup->AddSample(pSample);
2794            }
2795        }
2796    
2797    
2798    
2799  // *************** File ***************  // *************** File ***************
# Line 2796  namespace { Line 2873  namespace {
2873      }      }
2874    
2875      void File::LoadSamples(progress_t* pProgress) {      void File::LoadSamples(progress_t* pProgress) {
2876            // Groups must be loaded before samples, because samples will try
2877            // to resolve the group they belong to
2878            LoadGroups();
2879    
2880          if (!pSamples) pSamples = new SampleList;          if (!pSamples) pSamples = new SampleList;
2881    
2882          RIFF::File* file = pRIFF;          RIFF::File* file = pRIFF;
# Line 2961  namespace { Line 3042  namespace {
3042    
3043      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
3044          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
3045          if (!pGroups) return NULL;          // there must always be at least one group
3046          GroupsIterator = pGroups->begin();          GroupsIterator = pGroups->begin();
3047          return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;          return *GroupsIterator;
3048      }      }
3049    
3050      Group* File::GetNextGroup() {      Group* File::GetNextGroup() {
# Line 2980  namespace { Line 3061  namespace {
3061       */       */
3062      Group* File::GetGroup(uint index) {      Group* File::GetGroup(uint index) {
3063          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
         if (!pGroups) return NULL;  
3064          GroupsIterator = pGroups->begin();          GroupsIterator = pGroups->begin();
3065          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
3066              if (i == index) return *GroupsIterator;              if (i == index) return *GroupsIterator;
# Line 2991  namespace { Line 3071  namespace {
3071    
3072      Group* File::AddGroup() {      Group* File::AddGroup() {
3073          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
3074          if (!pGroups) pGroups = new std::list<Group*>;          // there must always be at least one group
3075          __ensureMandatoryChunksExist();          __ensureMandatoryChunksExist();
3076          Group* pGroup = new Group(pRIFF, NULL);          Group* pGroup = new Group(this, NULL);
3077          pGroups->push_back(pGroup);          pGroups->push_back(pGroup);
3078          return pGroup;          return pGroup;
3079      }      }
3080    
3081      void File::DeleteGroup(Group* pGroup) {      void File::DeleteGroup(Group* pGroup) {
3082          if (!pGroups) throw gig::Exception("Could not delete group as there are no groups");          if (!pGroups) LoadGroups();
3083          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
3084          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
3085            if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
3086            // move all members of this group to another group
3087            pGroup->MoveAll();
3088          pGroups->erase(iter);          pGroups->erase(iter);
3089          delete pGroup;          delete pGroup;
3090      }      }
3091    
3092      void File::LoadGroups() {      void File::LoadGroups() {
3093          if (!pGroups) pGroups = new std::list<Group*>;          if (!pGroups) pGroups = new std::list<Group*>;
3094            // try to read defined groups from file
3095          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
3096          if (!lst3gri) return;          if (lst3gri) {
3097          RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);              RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
3098          if (!lst3gnl) return;              if (lst3gnl) {
3099          {                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
3100              RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  while (ck) {
3101              while (ck) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
3102                  if (ck->GetChunkID() == CHUNK_ID_3GNM) {                          pGroups->push_back(new Group(this, ck));
3103                      pGroups->push_back(new Group(pRIFF, ck));                      }
3104                        ck = lst3gnl->GetNextSubChunk();
3105                  }                  }
                 ck = lst3gnl->GetNextSubChunk();  
3106              }              }
3107          }          }
3108            // if there were no group(s), create at least the mandatory default group
3109            if (!pGroups->size()) {
3110                Group* pGroup = new Group(this, NULL);
3111                pGroup->Name = "Default Group";
3112                pGroups->push_back(pGroup);
3113            }
3114      }      }
3115    
3116    

Legend:
Removed from v.929  
changed lines
  Added in v.930

  ViewVC Help
Powered by ViewVC