libgig/examples/riffwritedemo.cpp

// This little test application demonstrates how to create and modify
// arbitrary RIFF files with libgig 3.0.0.
//
// Date: 2006-04-29
//
// Compile with: 'g++ -lgig -o riffwritedemo riffwritedemo.cpp'

#include <RIFF.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define LIST_TYPE_FOOX  0x584F4F46
#define LIST_TYPE_GOOX  0x584F4F47
#define CHUNK_ID_AAAA   0x41414141
#define CHUNK_ID_BBBB   0x42424242
#define CHUNK_ID_CCCC   0x43434343

int main() {
    try {
        // Create a RIFF file with one list chunk <FOOX> having three
        // subchunks (<AAA>, <BBBB> and <CCCC>) and save it as
        // "footext.riff". Data for the three chunks will be directly
        // written to disk.
        {
            // create empty RIFF file with RIFF file type <GOOX>
            RIFF::File file(LIST_TYPE_GOOX);
            // add a sublist chunk with type <FOOX>
            RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
            // add three subchunks to the sublist chunk, each having a data
            // body size of one byte
            RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
            RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
            RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
            // write that new RIFF file
            file.Save("footext.riff");

            // write an arbitrary byte to the chunks
            // (by directly writing to disk)
            uint8_t c = '1';
            pChunkA->WriteUint8(&c); c = '2';
            pChunkB->WriteUint8(&c); c = '3';
            pChunkC->WriteUint8(&c);

            // resize (enlarge) chunk A and B to five bytes each
            pChunkA->Resize(5);
            pChunkB->Resize(5);
            // actually apply the resize operations to the file
            file.Save();

            // now that the file and thus the chunks are physically resized,
            // we can write more data to them
            c = 'V';
            pChunkA->WriteUint8(&c);
            c = 'E';
            pChunkA->WriteUint8(&c);
            c = 'R';
            pChunkA->WriteUint8(&c);
            c = 'A';
            pChunkA->WriteUint8(&c);
            c = '6';
            pChunkA->WriteUint8(&c);

            c = 'A';
            pChunkB->WriteUint8(&c);
            c = 'R';
            pChunkB->WriteUint8(&c);
            c = 'E';
            pChunkB->WriteUint8(&c);
            c = 'V';
            pChunkB->WriteUint8(&c);
            c = '7';
            pChunkB->WriteUint8(&c);

            // resize (shrink) chunk A to one byte
            pChunkA->Resize(1);
            file.Save();

            // write an arbitrary new byte to chunk A
            c = 'Q';
            pChunkA->WriteUint8(&c);
        }

        // Create yet another RIFF file with one list chunk <FOOX> having
        // three subchunks (<AAA>, <BBBB> and <CCCC>) and save it as
        // "footextRAM.riff". Data for the three chunks will this time be
        // 'written' to RAM and afterwards actually be written to disk by
        // the File::Save() call.
        {
            // create empty RIFF file with RIFF file type <GOOX>
            RIFF::File file(LIST_TYPE_GOOX);
            // add a sublist chunk with type <FOOX>
            RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
            // add three subchunks to the sublist chunk, each having a data
            // body size of one byte
            RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
            RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
            RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
            // write that new RIFF file
            file.Save("footextRAM.riff");
            // get the buffer to copy the chunks' data to
            char* pAData = (char*) pChunkA->LoadChunkData();
            char* pBData = (char*) pChunkB->LoadChunkData();
            char* pCData = (char*) pChunkC->LoadChunkData();
            // copy the chunks' data to the retrieved buffer
            pAData[0] = '1';
            pBData[0] = '2';
            pCData[0] = '3';

            // we already schedule to enlarge chunk A and B to a size of
            // five bytes
            pChunkA->Resize(5);
            pChunkB->Resize(5);
            // write the buffered chunk data to disk and apply the resize
            // operations in one rush
            file.Save();

            char vera6[] = "vera6";
            char arev7[] = "arev7";
            // we have to re-retrieve the buffers, as we resized the chunks
            pAData = (char*) pChunkA->LoadChunkData();
            pBData = (char*) pChunkB->LoadChunkData();
            pCData = (char*) pChunkC->LoadChunkData();
            // write arbitrary five bytes as data to the chunk's buffers
            memcpy(pAData, vera6, 5);
            memcpy(pBData, arev7, 5);
            // actually write that data to disk
            file.Save();

            // shrink chunk A to a data body size of one byte
            pChunkA->Resize(1);
            // perform shrink operation
            file.Save();

            // finally write another arbitrary byte to the shrinked chunk
            pAData = (char*) pChunkA->LoadChunkData();
            pAData[0] = 'Q';
            file.Save();
        }

        // In this example we create a RIFF file as in the previous example,
        // but this time we delete chunks afterwards.
        {
            // create empty RIFF file with RIFF file type <GOOX>
            RIFF::File file(LIST_TYPE_GOOX);
            // add a sublist chunk with type <FOOX>
            RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
            // add three subchunks to the sublist chunk, each having a data
            // body size of one byte
            RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
            RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
            RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
            // write that new RIFF file
            file.Save("footext_delete.riff");

            // write some arbitrary data to the chunks
            uint8_t c = '1';
            pChunkA->WriteUint8(&c); c = '2';
            pChunkB->WriteUint8(&c); c = '3';
            pChunkC->WriteUint8(&c);

            // schedule to enlarge chunk A and B to five bytes
            pChunkA->Resize(5);
            pChunkB->Resize(5);
            // perform scheduled enlarge operations
            file.Save();

            // write some more data to the enlarged chunks
            c = 'V';
            pChunkA->WriteUint8(&c);
            c = 'E';
            pChunkA->WriteUint8(&c);
            c = 'R';
            pChunkA->WriteUint8(&c);
            c = 'A';
            pChunkA->WriteUint8(&c);
            c = '6';
            pChunkA->WriteUint8(&c);

            c = 'A';
            pChunkB->WriteUint8(&c);
            c = 'R';
            pChunkB->WriteUint8(&c);
            c = 'E';
            pChunkB->WriteUint8(&c);
            c = 'V';
            pChunkB->WriteUint8(&c);
            c = '7';
            pChunkB->WriteUint8(&c);

            // schedule to delete chunk A
            pList->DeleteSubChunk(pChunkA);
            // apply 'delete' operation to file
            file.Save();
        }
    } catch (RIFF::Exception e) {
        e.PrintMessage();
        return -1;
    }
    return 0;
}
1	schoenebeck	1405	// This little test application demonstrates how to create and modify
2			// arbitrary RIFF files with libgig 3.0.0.
3			//
4			// Date: 2006-04-29
5			//
6			// Compile with: 'g++ -lgig -o riffwritedemo riffwritedemo.cpp'
7
8			#include <RIFF.h>
9
10			#include <stdlib.h>
11			#include <stdio.h>
12			#include <string.h>
13
14			#define LIST_TYPE_FOOX 0x584F4F46
15			#define LIST_TYPE_GOOX 0x584F4F47
16			#define CHUNK_ID_AAAA 0x41414141
17			#define CHUNK_ID_BBBB 0x42424242
18			#define CHUNK_ID_CCCC 0x43434343
19
20			int main() {
21			try {
22			// Create a RIFF file with one list chunk <FOOX> having three
23			// subchunks (<AAA>, <BBBB> and <CCCC>) and save it as
24			// "footext.riff". Data for the three chunks will be directly
25			// written to disk.
26			{
27			// create empty RIFF file with RIFF file type <GOOX>
28			RIFF::File file(LIST_TYPE_GOOX);
29			// add a sublist chunk with type <FOOX>
30			RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
31			// add three subchunks to the sublist chunk, each having a data
32			// body size of one byte
33			RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
34			RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
35			RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
36			// write that new RIFF file
37			file.Save("footext.riff");
38
39			// write an arbitrary byte to the chunks
40			// (by directly writing to disk)
41			uint8_t c = '1';
42			pChunkA->WriteUint8(&c); c = '2';
43			pChunkB->WriteUint8(&c); c = '3';
44			pChunkC->WriteUint8(&c);
45
46			// resize (enlarge) chunk A and B to five bytes each
47			pChunkA->Resize(5);
48			pChunkB->Resize(5);
49			// actually apply the resize operations to the file
50			file.Save();
51
52			// now that the file and thus the chunks are physically resized,
53			// we can write more data to them
54			c = 'V';
55			pChunkA->WriteUint8(&c);
56			c = 'E';
57			pChunkA->WriteUint8(&c);
58			c = 'R';
59			pChunkA->WriteUint8(&c);
60			c = 'A';
61			pChunkA->WriteUint8(&c);
62			c = '6';
63			pChunkA->WriteUint8(&c);
64
65			c = 'A';
66			pChunkB->WriteUint8(&c);
67			c = 'R';
68			pChunkB->WriteUint8(&c);
69			c = 'E';
70			pChunkB->WriteUint8(&c);
71			c = 'V';
72			pChunkB->WriteUint8(&c);
73			c = '7';
74			pChunkB->WriteUint8(&c);
75
76			// resize (shrink) chunk A to one byte
77			pChunkA->Resize(1);
78			file.Save();
79
80			// write an arbitrary new byte to chunk A
81			c = 'Q';
82			pChunkA->WriteUint8(&c);
83			}
84
85			// Create yet another RIFF file with one list chunk <FOOX> having
86			// three subchunks (<AAA>, <BBBB> and <CCCC>) and save it as
87			// "footextRAM.riff". Data for the three chunks will this time be
88			// 'written' to RAM and afterwards actually be written to disk by
89			// the File::Save() call.
90			{
91			// create empty RIFF file with RIFF file type <GOOX>
92			RIFF::File file(LIST_TYPE_GOOX);
93			// add a sublist chunk with type <FOOX>
94			RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
95			// add three subchunks to the sublist chunk, each having a data
96			// body size of one byte
97			RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
98			RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
99			RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
100			// write that new RIFF file
101			file.Save("footextRAM.riff");
102			// get the buffer to copy the chunks' data to
103			char* pAData = (char*) pChunkA->LoadChunkData();
104			char* pBData = (char*) pChunkB->LoadChunkData();
105			char* pCData = (char*) pChunkC->LoadChunkData();
106			// copy the chunks' data to the retrieved buffer
107			pAData[0] = '1';
108			pBData[0] = '2';
109			pCData[0] = '3';
110
111			// we already schedule to enlarge chunk A and B to a size of
112			// five bytes
113			pChunkA->Resize(5);
114			pChunkB->Resize(5);
115			// write the buffered chunk data to disk and apply the resize
116			// operations in one rush
117			file.Save();
118
119			char vera6[] = "vera6";
120			char arev7[] = "arev7";
121			// we have to re-retrieve the buffers, as we resized the chunks
122			pAData = (char*) pChunkA->LoadChunkData();
123			pBData = (char*) pChunkB->LoadChunkData();
124			pCData = (char*) pChunkC->LoadChunkData();
125			// write arbitrary five bytes as data to the chunk's buffers
126			memcpy(pAData, vera6, 5);
127			memcpy(pBData, arev7, 5);
128			// actually write that data to disk
129			file.Save();
130
131			// shrink chunk A to a data body size of one byte
132			pChunkA->Resize(1);
133			// perform shrink operation
134			file.Save();
135
136			// finally write another arbitrary byte to the shrinked chunk
137			pAData = (char*) pChunkA->LoadChunkData();
138			pAData[0] = 'Q';
139			file.Save();
140			}
141
142			// In this example we create a RIFF file as in the previous example,
143			// but this time we delete chunks afterwards.
144			{
145			// create empty RIFF file with RIFF file type <GOOX>
146			RIFF::File file(LIST_TYPE_GOOX);
147			// add a sublist chunk with type <FOOX>
148			RIFF::List* pList = file.AddSubList(LIST_TYPE_FOOX);
149			// add three subchunks to the sublist chunk, each having a data
150			// body size of one byte
151			RIFF::Chunk* pChunkA = pList->AddSubChunk(CHUNK_ID_AAAA, 1);
152			RIFF::Chunk* pChunkB = pList->AddSubChunk(CHUNK_ID_BBBB, 1);
153			RIFF::Chunk* pChunkC = pList->AddSubChunk(CHUNK_ID_CCCC, 1);
154			// write that new RIFF file
155			file.Save("footext_delete.riff");
156
157			// write some arbitrary data to the chunks
158			uint8_t c = '1';
159			pChunkA->WriteUint8(&c); c = '2';
160			pChunkB->WriteUint8(&c); c = '3';
161			pChunkC->WriteUint8(&c);
162
163			// schedule to enlarge chunk A and B to five bytes
164			pChunkA->Resize(5);
165			pChunkB->Resize(5);
166			// perform scheduled enlarge operations
167			file.Save();
168
169			// write some more data to the enlarged chunks
170			c = 'V';
171			pChunkA->WriteUint8(&c);
172			c = 'E';
173			pChunkA->WriteUint8(&c);
174			c = 'R';
175			pChunkA->WriteUint8(&c);
176			c = 'A';
177			pChunkA->WriteUint8(&c);
178			c = '6';
179			pChunkA->WriteUint8(&c);
180
181			c = 'A';
182			pChunkB->WriteUint8(&c);
183			c = 'R';
184			pChunkB->WriteUint8(&c);
185			c = 'E';
186			pChunkB->WriteUint8(&c);
187			c = 'V';
188			pChunkB->WriteUint8(&c);
189			c = '7';
190			pChunkB->WriteUint8(&c);
191
192			// schedule to delete chunk A
193			pList->DeleteSubChunk(pChunkA);
194			// apply 'delete' operation to file
195			file.Save();
196			}
197			} catch (RIFF::Exception e) {
198			e.PrintMessage();
199			return -1;
200			}
201			return 0;
202			}