2 * riff.cc library for RIFF file format i/o
3 * Copyright (C) 2000 - 2002 Arne Schirmacher <arne@schirmacher.de>
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.
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.
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 Foundation,
17 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 * Revision 1.2 2005/07/25 07:21:39 lilo_booter
25 * + fixes for opendml dv avi
27 * Revision 1.1 2005/04/15 14:28:26 lilo_booter
30 * Revision 1.18 2005/04/01 23:43:10 ddennedy
31 * apply endian fixes from Daniel Kobras
33 * Revision 1.17 2004/10/11 01:37:11 ddennedy
34 * mutex safety locks in RIFF and AVI classes, type 2 AVI optimization, mencoder export script
36 * Revision 1.16 2003/11/25 23:01:24 ddennedy
37 * cleanup and a few bugfixes
39 * Revision 1.15 2003/10/21 16:34:34 ddennedy
40 * GNOME2 port phase 1: initial checkin
42 * Revision 1.13.2.3 2003/08/26 20:39:00 ddennedy
43 * relocate mutex unlock and add assert includes
45 * Revision 1.13.2.2 2003/01/28 12:54:13 lilo_booter
46 * New 'no change' image transition
48 * Revision 1.13.2.1 2002/11/25 04:48:31 ddennedy
49 * bugfix to report errors when loading files
51 * Revision 1.13 2002/09/13 06:49:49 ddennedy
52 * build update, cleanup, bugfixes
54 * Revision 1.12 2002/04/21 06:36:40 ddennedy
55 * kindler avc and 1394 bus reset support in catpure page, honor max file size
57 * Revision 1.11 2002/04/09 06:53:42 ddennedy
58 * cleanup, new libdv 0.9.5, large AVI, dnd storyboard
60 * Revision 1.4 2002/03/25 21:34:25 arne
61 * Support for large (64 bit) files mostly completed
63 * Revision 1.3 2002/03/10 21:28:29 arne
64 * release 1.1b1, 64 bit support for type 1 avis
66 * Revision 1.2 2002/03/04 19:22:43 arne
67 * updated to latest Kino avi code
69 * Revision 1.1.1.1 2002/03/03 19:08:08 arne
70 * import of version 1.01
103 /** make a 32 bit "string-id"
105 \param s a pointer to 4 chars
106 \return the 32 bit "string id"
107 \bugs It is not checked whether we really have 4 characters
109 Some compilers understand constants like int id = 'ABCD'; but I
110 could not get it working on the gcc compiler so I had to use this
111 workaround. We can now use id = make_fourcc("ABCD") instead. */
113 FOURCC
make_fourcc( char *s
)
118 return *( ( FOURCC
* ) s
);
122 RIFFDirEntry
::RIFFDirEntry()
126 RIFFDirEntry
::RIFFDirEntry ( FOURCC t
, FOURCC n
, int l
, int o
, int p
) : type( t
), name( n
), length( l
), offset( o
), parent( p
), written( 0 )
130 /** Creates the object without an output file.
134 RIFFFile
::RIFFFile() : fd( -1 )
136 pthread_mutex_init( &file_mutex
, NULL
);
142 Duplicate the file descriptor
145 RIFFFile
::RIFFFile( const RIFFFile
& riff
) : fd( -1 )
151 directory
= riff
.directory
;
155 /** Destroys the object.
157 If it has an associated opened file, close it. */
159 RIFFFile
::~RIFFFile()
162 pthread_mutex_destroy( &file_mutex
);
166 RIFFFile
& RIFFFile
::operator=( const RIFFFile
& riff
)
175 directory
= riff
.directory
;
181 /** Creates or truncates the file.
183 \param s the filename
186 bool RIFFFile
::Create( const char *s
)
188 fd
= open( s
, O_RDWR
| O_NONBLOCK
| O_CREAT
| O_TRUNC
, 00644 );
197 /** Opens the file read only.
199 \param s the filename
202 bool RIFFFile
::Open( const char *s
)
204 fd
= open( s
, O_RDONLY
| O_NONBLOCK
);
213 /** Destroys the object.
215 If it has an associated opened file, close it. */
217 void RIFFFile
::Close()
227 /** Adds an entry to the list of containers.
229 \param type the type of this entry
231 \param length the length of the data in the container
232 \param list the container in which this object is contained.
233 \return the ID of the newly created entry
235 The topmost object is not contained in any other container. Use
236 the special ID RIFF_NO_PARENT to create the topmost object. */
238 int RIFFFile
::AddDirectoryEntry( FOURCC type
, FOURCC name
, off_t length
, int list
)
240 /* Put all parameters in an RIFFDirEntry object. The offset is
241 currently unknown. */
243 RIFFDirEntry
entry( type
, name
, length
, 0 /* offset */, list
);
245 /* If the new chunk is in a list, then get the offset and size
246 of that list. The offset of this chunk is the end of the list
247 (parent_offset + parent_length) plus the size of the chunk
250 if ( list
!= RIFF_NO_PARENT
)
252 RIFFDirEntry parent
= GetDirectoryEntry( list
);
253 entry
.offset
= parent
.offset
+ parent
.length
+ RIFF_HEADERSIZE
;
256 /* The list which this new chunk is a member of has now increased in
257 size. Get that directory entry and bump up its length by the size
258 of the chunk. Since that list may also be contained in another
259 list, walk up to the top of the tree. */
261 while ( list
!= RIFF_NO_PARENT
)
263 RIFFDirEntry parent
= GetDirectoryEntry( list
);
264 parent
.length
+= RIFF_HEADERSIZE
+ length
;
265 SetDirectoryEntry( list
, parent
);
266 list
= parent
.parent
;
269 directory
.insert( directory
.end(), entry
);
271 return directory
.size() - 1;
275 /** Modifies an entry.
277 \param i the ID of the entry which is to modify
278 \param type the type of this entry
280 \param length the length of the data in the container
281 \param list the container in which this object is contained.
282 \note Do not change length, offset, or the parent container.
283 \note Do not change an empty name ("") to a name and vice versa */
285 void RIFFFile
::SetDirectoryEntry( int i
, FOURCC type
, FOURCC name
, off_t length
, off_t offset
, int list
)
287 RIFFDirEntry
entry( type
, name
, length
, offset
, list
);
289 assert( i
>= 0 && i
< ( int ) directory
.size() );
291 directory
[ i
] = entry
;
295 /** Modifies an entry.
297 The entry.written flag is set to false because the contents has been modified
299 \param i the ID of the entry which is to modify
300 \param entry the new entry
301 \note Do not change length, offset, or the parent container.
302 \note Do not change an empty name ("") to a name and vice versa */
304 void RIFFFile
::SetDirectoryEntry( int i
, RIFFDirEntry
&entry
)
306 assert( i
>= 0 && i
< ( int ) directory
.size() );
308 entry
.written
= false;
309 directory
[ i
] = entry
;
313 /** Retrieves an entry.
315 Gets the most important member variables.
317 \param i the ID of the entry to retrieve
324 void RIFFFile
::GetDirectoryEntry( int i
, FOURCC
&type
, FOURCC
&name
, off_t
&length
, off_t
&offset
, int &list
) const
328 assert( i
>= 0 && i
< ( int ) directory
.size() );
330 entry
= directory
[ i
];
333 length
= entry
.length
;
334 offset
= entry
.offset
;
339 /** Retrieves an entry.
341 Gets the whole RIFFDirEntry object.
343 \param i the ID of the entry to retrieve
346 RIFFDirEntry RIFFFile
::GetDirectoryEntry( int i
) const
348 assert( i
>= 0 && i
< ( int ) directory
.size() );
350 return directory
[ i
];
354 /** Calculates the total size of the file
356 \return the size the file in bytes
359 off_t RIFFFile
::GetFileSize( void ) const
362 /* If we have at least one entry, return the length field
363 of the FILE entry, which is the length of its contents,
364 which is the actual size of whatever is currently in the
365 AVI directory structure.
367 Note that the first entry does not belong to the AVI
370 If we don't have any entry, the file size is zero. */
372 if ( directory
.size() > 0 )
373 return directory
[ 0 ].length
;
379 /** prints the attributes of the entry
381 \param i the ID of the entry to print
384 void RIFFFile
::PrintDirectoryEntry ( int i
) const
391 /* Get all attributes of the chunk object. If it is contained
392 in a list, get the name of the list too (otherwise the name of
393 the list is blank). If the chunk object doesn´t have a name (only
394 LISTs and RIFFs have a name), the name is blank. */
396 entry
= GetDirectoryEntry( i
);
397 if ( entry
.parent
!= RIFF_NO_PARENT
)
399 parent
= GetDirectoryEntry( entry
.parent
);
400 list_name
= parent
.name
;
404 list_name
= make_fourcc( " " );
406 if ( entry
.name
!= 0 )
408 entry_name
= entry
.name
;
412 entry_name
= make_fourcc( " " );
415 /* Print out the ascii representation of type and name, as well as
416 length and file offset. */
418 cout
<< hex
<< setfill( '0' ) << "type: "
419 << ((char *)&entry
.type
)[0]
420 << ((char *)&entry
.type
)[1]
421 << ((char *)&entry
.type
)[2]
422 << ((char *)&entry
.type
)[3]
424 << ((char *)&entry_name
)[0]
425 << ((char *)&entry_name
)[1]
426 << ((char *)&entry_name
)[2]
427 << ((char *)&entry_name
)[3]
428 << " length: 0x" << setw( 12 ) << entry
.length
429 << " offset: 0x" << setw( 12 ) << entry
.offset
431 << ((char *)&list_name
)[0]
432 << ((char *)&list_name
)[1]
433 << ((char *)&list_name
)[2]
434 << ((char *)&list_name
)[3] << dec
<< endl
;
436 /* print the content itself */
438 PrintDirectoryEntryData( entry
);
442 /** prints the contents of the entry
444 Prints a readable representation of the contents of an index.
445 Override this to print out any objects you store in the RIFF file.
447 \param entry the entry to print */
449 void RIFFFile
::PrintDirectoryEntryData( const RIFFDirEntry
&entry
) const
453 /** prints the contents of the whole directory
455 Prints a readable representation of the contents of an index.
456 Override this to print out any objects you store in the RIFF file.
458 \param entry the entry to print */
460 void RIFFFile
::PrintDirectory() const
463 int count
= directory
.size();
465 for ( i
= 0; i
< count
; ++i
)
466 PrintDirectoryEntry( i
);
472 finds the index of a given directory entry type
474 \todo inefficient if the directory has lots of items
475 \param type the type of the entry to find
476 \param n the zero-based instance of type to locate
477 \return the index of the found object in the directory, or -1 if not found */
479 int RIFFFile
::FindDirectoryEntry ( FOURCC type
, int n
) const
482 int count
= directory
.size();
484 for ( i
= 0; i
< count
; ++i
)
485 if ( directory
[ i
].type
== type
)
496 /** Reads all items that are contained in one list
498 Read in one chunk and add it to the directory. If the chunk
499 happens to be of type LIST, then call ParseList recursively for
502 \param parent The id of the item to process
505 void RIFFFile
::ParseChunk( int parent
)
511 /* Check whether it is a LIST. If so, let ParseList deal with it */
513 read( fd
, &type
, sizeof( type
) );
514 if ( type
== make_fourcc( "LIST" ) )
516 typesize
= -sizeof( type
);
517 fail_if( lseek( fd
, typesize
, SEEK_CUR
) == ( off_t
) - 1 );
521 /* it is a normal chunk, create a new directory entry for it */
525 fail_neg( read( fd
, &length
, sizeof( length
) ) );
528 AddDirectoryEntry( type
, 0, length
, parent
);
529 fail_if( lseek( fd
, length
, SEEK_CUR
) == ( off_t
) - 1 );
534 /** Reads all items that are contained in one list
536 \param parent The id of the list to process
540 void RIFFFile
::ParseList( int parent
)
549 /* Read in the chunk header (type and length). */
550 fail_neg( read( fd
, &type
, sizeof( type
) ) );
551 fail_neg( read( fd
, &length
, sizeof( length
) ) );
556 /* The contents of the list starts here. Obtain its offset. The list
557 name (4 bytes) is already part of the contents). */
559 pos
= lseek( fd
, 0, SEEK_CUR
);
560 fail_if( pos
== ( off_t
) - 1 );
561 fail_neg( read( fd
, &name
, sizeof( name
) ) );
563 /* Add an entry for this list. */
565 list
= AddDirectoryEntry( type
, name
, sizeof( name
), parent
);
567 /* Read in any chunks contained in this list. This list is the
568 parent for all chunks it contains. */
570 listEnd
= pos
+ length
;
571 while ( pos
< listEnd
)
574 pos
= lseek( fd
, 0, SEEK_CUR
);
575 fail_if( pos
== ( off_t
) - 1 );
580 /** Reads the directory structure of the whole RIFF file
584 void RIFFFile
::ParseRIFF( void )
590 int container
= AddDirectoryEntry( make_fourcc( "FILE" ), make_fourcc( "FILE" ), 0, RIFF_NO_PARENT
);
592 pos
= lseek( fd
, 0, SEEK_SET
);
594 /* calculate file size from RIFF header instead from physical file. */
596 while ( ( read( fd
, &type
, sizeof( type
) ) > 0 ) &&
597 ( read( fd
, &length
, sizeof( length
) ) > 0 ) &&
598 ( type
== make_fourcc( "RIFF" ) ) )
601 filesize
+= length
+ RIFF_HEADERSIZE
;
603 fail_if( lseek( fd
, pos
, SEEK_SET
) == ( off_t
) - 1 );
604 ParseList( container
);
605 pos
= lseek( fd
, 0, SEEK_CUR
);
606 fail_if( pos
== ( off_t
) - 1 );
611 /** Reads one item including its contents from the RIFF file
613 \param chunk_index The index of the item to write
614 \param data A pointer to the data
618 void RIFFFile
::ReadChunk( int chunk_index
, void *data
, off_t data_len
)
622 entry
= GetDirectoryEntry( chunk_index
);
623 pthread_mutex_lock( &file_mutex
);
624 fail_if( lseek( fd
, entry
.offset
, SEEK_SET
) == ( off_t
) - 1 );
625 fail_neg( read( fd
, data
, data_len
) );
626 pthread_mutex_unlock( &file_mutex
);
630 /** Writes one item including its contents to the RIFF file
632 \param chunk_index The index of the item to write
633 \param data A pointer to the data
637 void RIFFFile
::WriteChunk( int chunk_index
, const void *data
)
641 entry
= GetDirectoryEntry( chunk_index
);
642 pthread_mutex_lock( &file_mutex
);
643 fail_if( lseek( fd
, entry
.offset
- RIFF_HEADERSIZE
, SEEK_SET
) == ( off_t
) - 1 );
644 fail_neg( write( fd
, &entry
.type
, sizeof( entry
.type
) ) );
645 DWORD length
= entry
.length
;
646 fail_neg( write( fd
, &length
, sizeof( length
) ) );
647 fail_neg( write( fd
, data
, entry
.length
) );
648 pthread_mutex_unlock( &file_mutex
);
650 /* Remember that this entry already has been written. */
652 directory
[ chunk_index
].written
= true;
656 /** Writes out the directory structure
658 For all items in the directory list that have not been written
659 yet, it seeks to the file position where that item should be
660 stored and writes the type and length field. If the item has a
661 name, it will also write the name field.
663 \note It does not write the contents of any item. Use WriteChunk to do that. */
665 void RIFFFile
::WriteRIFF( void )
669 int count
= directory
.size();
671 /* Start at the second entry (RIFF), since the first entry (FILE)
672 is needed only for internal purposes and is not written to the
675 for ( i
= 1; i
< count
; ++i
)
678 /* Only deal with entries that haven´t been written */
680 entry
= GetDirectoryEntry( i
);
681 if ( entry
.written
== false )
684 /* A chunk entry consist of its type and length, a list
685 entry has an additional name. Look up the entry, seek
686 to the start of the header, which is at the offset of
687 the data start minus the header size and write out the
690 fail_if( lseek( fd
, entry
.offset
- RIFF_HEADERSIZE
, SEEK_SET
) == ( off_t
) - 1 ) ;
691 fail_neg( write( fd
, &entry
.type
, sizeof( entry
.type
) ) );
692 DWORD length
= entry
.length
;
693 fail_neg( write( fd
, &length
, sizeof( length
) ) );
695 /* If it has a name, it is a list. Write out the extra name
698 if ( entry
.name
!= 0 )
700 fail_neg( write( fd
, &entry
.name
, sizeof( entry
.name
) ) );
703 /* Remember that this entry already has been written. */
705 directory
[ i
].written
= true;