projects / melted / blob
? search:


67412fda8cbdab34deecc949293d6a1200801934
[melted] / src / modules / kino / filehandler.cc
1 /*
2 * filehandler.cc -- saving DV data into different file formats
3 * Copyright (C) 2000 Arne Schirmacher <arne@schirmacher.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 Foundation,
17 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20 #include "config.h"
21
22 #include <string>
23 #include <iostream>
24 #include <sstream>
25 #include <iomanip>
26
27 using std::cerr;
28 using std::endl;
29 using std::ostringstream;
30 using std::setw;
31 using std::setfill;
32
33 #include <signal.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <sys/stat.h>
37 #include <assert.h>
38 #include <time.h>
39 #include <sys/time.h>
40
41 // libdv header files
42 #ifdef HAVE_LIBDV
43 #include <libdv/dv.h>
44 #endif
45
46 #include "filehandler.h"
47 #include "error.h"
48 #include "riff.h"
49 #include "avi.h"
50
51 FileTracker *FileTracker::instance = NULL;
52
53 FileTracker::FileTracker( ) : mode( CAPTURE_MOVIE_APPEND )
54 {
55 cerr << ">> Constructing File Capture tracker" << endl;
56 }
57
58 FileTracker::~FileTracker( )
59 {
60 cerr << ">> Destroying File Capture tracker" << endl;
61 }
62
63 FileTracker &FileTracker::GetInstance( )
64 {
65 if ( instance == NULL )
66 instance = new FileTracker();
67
68 return *instance;
69 }
70
71 void FileTracker::SetMode( FileCaptureMode mode )
72 {
73 this->mode = mode;
74 }
75
76 FileCaptureMode FileTracker::GetMode( )
77 {
78 return this->mode;
79 }
80
81 char *FileTracker::Get( int index )
82 {
83 return list[ index ];
84 }
85
86 void FileTracker::Add( const char *file )
87 {
88 if ( this->mode != CAPTURE_IGNORE )
89 {
90 cerr << ">>>> Registering " << file << " with the tracker" << endl;
91 list.push_back( strdup( file ) );
92 }
93 }
94
95 unsigned int FileTracker::Size( )
96 {
97 return list.size();
98 }
99
100 void FileTracker::Clear( )
101 {
102 while ( Size() > 0 )
103 {
104 free( list[ Size() - 1 ] );
105 list.pop_back( );
106 }
107 this->mode = CAPTURE_MOVIE_APPEND;
108 }
109
110 FileHandler::FileHandler() : done( false ), autoSplit( false ), maxFrameCount( 999999 ),
111 framesWritten( 0 ), filename( "" )
112 {
113 /* empty body */
114 }
115
116
117 FileHandler::~FileHandler()
118 {
119 /* empty body */
120 }
121
122
123 bool FileHandler::GetAutoSplit() const
124 {
125 return autoSplit;
126 }
127
128
129 bool FileHandler::GetTimeStamp() const
130 {
131 return timeStamp;
132 }
133
134
135 string FileHandler::GetBaseName() const
136 {
137 return base;
138 }
139
140
141 string FileHandler::GetExtension() const
142 {
143 return extension;
144 }
145
146
147 int FileHandler::GetMaxFrameCount() const
148 {
149 return maxFrameCount;
150 }
151
152 off_t FileHandler::GetMaxFileSize() const
153 {
154 return maxFileSize;
155 }
156
157 string FileHandler::GetFilename() const
158 {
159 return filename;
160 }
161
162
163 void FileHandler::SetAutoSplit( bool flag )
164 {
165 autoSplit = flag;
166 }
167
168
169 void FileHandler::SetTimeStamp( bool flag )
170 {
171 timeStamp = flag;
172 }
173
174
175 void FileHandler::SetBaseName( const string& s )
176 {
177 base = s;
178 }
179
180
181 void FileHandler::SetMaxFrameCount( int count )
182 {
183 assert( count >= 0 );
184 maxFrameCount = count;
185 }
186
187
188 void FileHandler::SetEveryNthFrame( int every )
189 {
190 assert ( every > 0 );
191
192 everyNthFrame = every;
193 }
194
195
196 void FileHandler::SetMaxFileSize( off_t size )
197 {
198 assert ( size >= 0 );
199 maxFileSize = size;
200 }
201
202
203 #if 0
204 void FileHandler::SetSampleFrame( const Frame& sample )
205 {
206 /* empty body */
207 }
208 #endif
209
210 bool FileHandler::Done()
211 {
212 return done;
213 }
214
215 #if 0
216 bool FileHandler::WriteFrame( const Frame& frame )
217 {
218 static TimeCode prevTimeCode;
219 TimeCode timeCode;
220
221 /* If the user wants autosplit, start a new file if a
222 new recording is detected. */
223 prevTimeCode.sec = -1;
224 frame.GetTimeCode( timeCode );
225 int time_diff = timeCode.sec - prevTimeCode.sec;
226 bool discontinuity = prevTimeCode.sec != -1 && ( time_diff > 1 || ( time_diff < 0 && time_diff > -59 ) );
227 if ( FileIsOpen() && GetAutoSplit() == true && ( frame.IsNewRecording() || discontinuity ) )
228 {
229 Close();
230 }
231
232 if ( FileIsOpen() == false )
233 {
234
235 string filename;
236 static int counter = 0;
237
238 if ( GetTimeStamp() == true )
239 {
240 ostringstream sb, sb2;
241 struct tm date;
242 string recDate;
243
244 if ( ! frame.GetRecordingDate( date ) )
245 {
246 struct timeval tv;
247 struct timezone tz;
248 gettimeofday( &tv, &tz );
249 localtime_r( static_cast< const time_t * >( &tv.tv_sec ), &date );
250 }
251 sb << setfill( '0' )
252 << setw( 4 ) << date.tm_year + 1900 << '.'
253 << setw( 2 ) << date.tm_mon + 1 << '.'
254 << setw( 2 ) << date.tm_mday << '_'
255 << setw( 2 ) << date.tm_hour << '-'
256 << setw( 2 ) << date.tm_min << '-'
257 << setw( 2 ) << date.tm_sec;
258 recDate = sb.str();
259 sb2 << GetBaseName() << recDate << GetExtension();
260 filename = sb2.str();
261 cerr << ">>> Trying " << filename << endl;
262 }
263 else
264 {
265 struct stat stats;
266 do
267 {
268 ostringstream sb;
269 sb << GetBaseName() << setfill( '0' ) << setw( 3 ) << ++ counter << GetExtension();
270 filename = sb.str();
271 cerr << ">>> Trying " << filename << endl;
272 }
273 while ( stat( filename.c_str(), &stats ) == 0 );
274 }
275
276 SetSampleFrame( frame );
277 if ( Create( filename ) == false )
278 {
279 cerr << ">>> Error creating file!" << endl;
280 return false;
281 }
282 framesWritten = 0;
283 framesToSkip = 0;
284 }
285
286 /* write frame */
287
288 if ( framesToSkip == 0 )
289 {
290 if ( 0 > Write( frame ) )
291 {
292 cerr << ">>> Error writing frame!" << endl;
293 return false;
294 }
295 framesToSkip = everyNthFrame;
296 ++framesWritten;
297 }
298 framesToSkip--;
299
300 /* If the frame count is exceeded, close the current file.
301 If the autosplit flag is set, a new file will be created in the next iteration.
302 If the flag is not set, we are done. */
303
304 if ( ( GetMaxFrameCount() > 0 ) &&
305 ( framesWritten >= GetMaxFrameCount() ) )
306 {
307 Close();
308 done = !GetAutoSplit();
309 }
310
311 /* If the file size could be exceeded by another frame, close the current file.
312 If the autosplit flag is set, a new file will be created on the next iteration.
313 If the flag is not set, we are done. */
314 /* not exact, but should be good enough to prevent going over. */
315 if ( FileIsOpen() )
316 {
317 AudioInfo info;
318 frame.GetAudioInfo( info );
319 if ( ( GetFileSize() > 0 ) && ( GetMaxFileSize() > 0 ) &&
320 ( GetFileSize() + frame.GetFrameSize() + info.samples * 4 + 12 )
321 >= GetMaxFileSize() )
322 { // 12 = sizeof chunk metadata
323 Close();
324 done = !GetAutoSplit();
325 }
326 }
327 prevTimeCode.sec = timeCode.sec;
328 return true;
329 }
330 #endif
331
332 RawHandler::RawHandler() : fd( -1 )
333 {
334 extension = ".dv";
335 }
336
337
338 RawHandler::~RawHandler()
339 {
340 Close();
341 }
342
343
344 bool RawHandler::FileIsOpen()
345 {
346 return fd != -1;
347 }
348
349
350 bool RawHandler::Create( const string& filename )
351 {
352 fd = open( filename.c_str(), O_CREAT | O_TRUNC | O_RDWR | O_NONBLOCK, 0644 );
353 if ( fd != -1 )
354 {
355 FileTracker::GetInstance().Add( filename.c_str() );
356 this->filename = filename;
357 }
358 return ( fd != -1 );
359 }
360
361
362 #if 0
363 int RawHandler::Write( const Frame& frame )
364 {
365 int result = write( fd, frame.data, frame.GetFrameSize() );
366 return result;
367 }
368 #endif
369
370 int RawHandler::Close()
371 {
372 if ( fd != -1 )
373 {
374 close( fd );
375 fd = -1;
376 }
377 return 0;
378 }
379
380
381 off_t RawHandler::GetFileSize()
382 {
383 struct stat file_status;
384 fstat( fd, &file_status );
385 return file_status.st_size;
386 }
387
388 int RawHandler::GetTotalFrames()
389 {
390 return GetFileSize() / ( 480 * numBlocks );
391 }
392
393
394 bool RawHandler::Open( const char *s )
395 {
396 unsigned char data[ 4 ];
397 assert( fd == -1 );
398 fd = open( s, O_RDONLY | O_NONBLOCK );
399 if ( fd < 0 )
400 return false;
401 if ( read( fd, data, 4 ) < 0 )
402 return false;
403 lseek( fd, 0, SEEK_SET );
404 numBlocks = ( ( data[ 3 ] & 0x80 ) == 0 ) ? 250 : 300;
405 filename = s;
406 return true;
407
408 }
409
410 int RawHandler::GetFrame( uint8_t *data, int frameNum )
411 {
412 assert( fd != -1 );
413 int size = 480 * numBlocks;
414 if ( frameNum < 0 )
415 return -1;
416 off_t offset = ( ( off_t ) frameNum * ( off_t ) size );
417 fail_if( lseek( fd, offset, SEEK_SET ) == ( off_t ) - 1 );
418 if ( read( fd, data, size ) > 0 )
419 return 0;
420 else
421 return -1;
422 }
423
424
425 /***************************************************************************/
426
427
428 AVIHandler::AVIHandler( int format ) : avi( NULL ), aviFormat( format ), isOpenDML( false ),
429 fccHandler( make_fourcc( "dvsd" ) ), channels( 2 ), isFullyInitialized( false ),
430 audioBuffer( NULL )
431 {
432 extension = ".avi";
433 for ( int c = 0; c < 4; c++ )
434 audioChannels[ c ] = NULL;
435 }
436
437
438 AVIHandler::~AVIHandler()
439 {
440 if ( audioBuffer != NULL )
441 {
442 delete audioBuffer;
443 audioBuffer = NULL;
444 }
445 for ( int c = 0; c < 4; c++ )
446 {
447 if ( audioChannels[ c ] != NULL )
448 {
449 delete audioChannels[ c ];
450 audioChannels[ c ] = NULL;
451 }
452 }
453
454 delete avi;
455 }
456
457 #if 0
458 void AVIHandler::SetSampleFrame( const Frame& sample )
459 {
460 Pack pack;
461 sample.GetAudioInfo( audioInfo );
462 sample.GetVideoInfo( videoInfo );
463
464 sample.GetAAUXPack( 0x50, pack );
465 dvinfo.dwDVAAuxSrc = *( DWORD* ) ( pack.data + 1 );
466 sample.GetAAUXPack( 0x51, pack );
467 dvinfo.dwDVAAuxCtl = *( DWORD* ) ( pack.data + 1 );
468
469 sample.GetAAUXPack( 0x52, pack );
470 dvinfo.dwDVAAuxSrc1 = *( DWORD* ) ( pack.data + 1 );
471 sample.GetAAUXPack( 0x53, pack );
472 dvinfo.dwDVAAuxCtl1 = *( DWORD* ) ( pack.data + 1 );
473
474 sample.GetVAUXPack( 0x60, pack );
475 dvinfo.dwDVVAuxSrc = *( DWORD* ) ( pack.data + 1 );
476 sample.GetVAUXPack( 0x61, pack );
477 dvinfo.dwDVVAuxCtl = *( DWORD* ) ( pack.data + 1 );
478
479 #ifdef WITH_LIBDV
480
481 if ( sample.decoder->std == e_dv_std_smpte_314m )
482 fccHandler = make_fourcc( "dv25" );
483 #endif
484 }
485 #endif
486
487 bool AVIHandler::FileIsOpen()
488 {
489 return avi != NULL;
490 }
491
492
493 bool AVIHandler::Create( const string& filename )
494 {
495 assert( avi == NULL );
496
497 switch ( aviFormat )
498 {
499
500 case AVI_DV1_FORMAT:
501 fail_null( avi = new AVI1File );
502 if ( avi->Create( filename.c_str() ) == false )
503 return false;
504 //avi->Init( videoInfo.isPAL ? AVI_PAL : AVI_NTSC, audioInfo.frequency, AVI_LARGE_INDEX );
505 break;
506
507 case AVI_DV2_FORMAT:
508 fail_null( avi = new AVI2File );
509 if ( avi->Create( filename.c_str() ) == false )
510 return false;
511 //if ( GetOpenDML() )
512 //avi->Init( videoInfo.isPAL ? AVI_PAL : AVI_NTSC, audioInfo.frequency,
513 //( AVI_SMALL_INDEX | AVI_LARGE_INDEX ) );
514 //else
515 //avi->Init( videoInfo.isPAL ? AVI_PAL : AVI_NTSC, audioInfo.frequency,
516 //( AVI_SMALL_INDEX ) );
517 break;
518
519 default:
520 assert( aviFormat == AVI_DV1_FORMAT || aviFormat == AVI_DV2_FORMAT );
521 }
522
523 avi->setDVINFO( dvinfo );
524 avi->setFccHandler( make_fourcc( "iavs" ), fccHandler );
525 avi->setFccHandler( make_fourcc( "vids" ), fccHandler );
526 this->filename = filename;
527 FileTracker::GetInstance().Add( filename.c_str() );
528 return ( avi != NULL );
529 }
530
531 #if 0
532 int AVIHandler::Write( const Frame& frame )
533 {
534 assert( avi != NULL );
535 try
536 {
537 return avi->WriteFrame( frame ) ? 0 : -1;
538 }
539 catch (...)
540 {
541 return -1;
542 }
543 }
544 #endif
545
546 int AVIHandler::Close()
547 {
548 if ( avi != NULL )
549 {
550 avi->WriteRIFF();
551 delete avi;
552 avi = NULL;
553 }
554 if ( audioBuffer != NULL )
555 {
556 delete audioBuffer;
557 audioBuffer = NULL;
558 }
559 for ( int c = 0; c < 4; c++ )
560 {
561 if ( audioChannels[ c ] != NULL )
562 {
563 delete audioChannels[ c ];
564 audioChannels[ c ] = NULL;
565 }
566 }
567 isFullyInitialized = false;
568 return 0;
569 }
570
571 off_t AVIHandler::GetFileSize()
572 {
573 return avi->GetFileSize();
574 }
575
576 int AVIHandler::GetTotalFrames()
577 {
578 return avi->GetTotalFrames();
579 }
580
581
582 bool AVIHandler::Open( const char *s )
583 {
584 assert( avi == NULL );
585 fail_null( avi = new AVI1File );
586 if ( avi->Open( s ) )
587 {
588 avi->ParseRIFF();
589 if ( ! (
590 avi->verifyStreamFormat( make_fourcc( "dvsd" ) ) ||
591 avi->verifyStreamFormat( make_fourcc( "DVSD" ) ) ||
592 avi->verifyStreamFormat( make_fourcc( "dvcs" ) ) ||
593 avi->verifyStreamFormat( make_fourcc( "DVCS" ) ) ||
594 avi->verifyStreamFormat( make_fourcc( "dvcp" ) ) ||
595 avi->verifyStreamFormat( make_fourcc( "DVCP" ) ) ||
596 avi->verifyStreamFormat( make_fourcc( "CDVC" ) ) ||
597 avi->verifyStreamFormat( make_fourcc( "cdvc" ) ) ||
598 avi->verifyStreamFormat( make_fourcc( "DV25" ) ) ||
599 avi->verifyStreamFormat( make_fourcc( "dv25" ) ) ) )
600 return false;
601 avi->ReadIndex();
602 if ( avi->verifyStream( make_fourcc( "auds" ) ) )
603 aviFormat = AVI_DV2_FORMAT;
604 else
605 aviFormat = AVI_DV1_FORMAT;
606 isOpenDML = avi->isOpenDML();
607 filename = s;
608 return true;
609 }
610 else
611 return false;
612
613 }
614
615 int AVIHandler::GetFrame( uint8_t *data, int frameNum )
616 {
617 int result = avi->GetDVFrame( data, frameNum );
618 #if 0
619 if ( result == 0 )
620 {
621 /* get the audio from the audio stream, if available */
622 if ( aviFormat == AVI_DV2_FORMAT )
623 {
624 WAVEFORMATEX wav;
625
626 if ( ! isFullyInitialized &&
627 avi->getStreamFormat( ( void* ) &wav, make_fourcc( "auds" ) ) )
628 {
629 if ( channels > 0 && channels < 5 )
630 {
631 // Allocate interleaved audio buffer
632 audioBuffer = new int16_t[ 2 * DV_AUDIO_MAX_SAMPLES * channels ];
633
634 // Allocate non-interleaved audio buffers
635 for ( int c = 0; c < channels; c++ )
636 audioChannels[ c ] = new int16_t[ 2 * DV_AUDIO_MAX_SAMPLES ];
637
638 // Get the audio parameters from AVI for subsequent calls to method
639 audioInfo.channels = wav.nChannels;
640 audioInfo.frequency = wav.nSamplesPerSec;
641
642 // Skip initialization on subsequent calls to method
643 isFullyInitialized = true;
644 cerr << ">>> using audio from separate AVI audio stream" << endl;
645 }
646 }
647
648 // Get the frame from AVI
649 int n = avi->getFrame( audioBuffer, frameNum, make_fourcc( "01wb" ) );
650 if ( n > 0 )
651 {
652 // Temporary pointer to audio scratch buffer
653 int16_t * s = audioBuffer;
654
655 // Determine samples in this frame
656 audioInfo.samples = n / audioInfo.channels / sizeof( int16_t );
657
658 // Convert interleaved audio into non-interleaved
659 for ( int n = 0; n < audioInfo.samples; ++n )
660 for ( int i = 0; i < audioInfo.channels; i++ )
661 audioChannels[ i ][ n ] = *s++;
662
663 // Write interleaved audio into frame
664 frame.EncodeAudio( audioInfo, audioChannels );
665 }
666 }
667
668 // Parse important metadata in DV bitstream
669 frame.ExtractHeader();
670 }
671 #endif
672 return result;
673 }
674
675
676 void AVIHandler::SetOpenDML( bool flag )
677 {
678 isOpenDML = flag;
679 }
680
681
682 bool AVIHandler::GetOpenDML() const
683 {
684 return isOpenDML;
685 }
686
687
688 /***************************************************************************/
689
690 #ifdef HAVE_LIBQUICKTIME
691
692 #ifndef HAVE_LIBDV
693 #define DV_AUDIO_MAX_SAMPLES 1944
694 #endif
695
696 QtHandler::QtHandler() : fd( NULL )
697 {
698 extension = ".mov";
699 Init();
700 }
701
702
703 QtHandler::~QtHandler()
704 {
705 Close();
706 }
707
708 void QtHandler::Init()
709 {
710 if ( fd != NULL )
711 Close();
712
713 fd = NULL;
714 samplingRate = 0;
715 samplesPerBuffer = 0;
716 channels = 2;
717 audioBuffer = NULL;
718 audioChannelBuffer = NULL;
719 isFullyInitialized = false;
720 }
721
722
723 bool QtHandler::FileIsOpen()
724 {
725 return fd != NULL;
726 }
727
728
729 bool QtHandler::Create( const string& filename )
730 {
731 Init();
732
733 if ( open( filename.c_str(), O_CREAT | O_TRUNC | O_RDWR | O_NONBLOCK, 0644 ) != -1 )
734 {
735 fd = quicktime_open( const_cast<char*>( filename.c_str() ), 0, 1 );
736 if ( fd != NULL )
737 FileTracker::GetInstance().Add( filename.c_str() );
738 }
739 else
740 return false;
741 this->filename = filename;
742 return true;
743 }
744
745 void QtHandler::AllocateAudioBuffers()
746 {
747 if ( channels > 0 && channels < 5 )
748 {
749 audioBufferSize = DV_AUDIO_MAX_SAMPLES * 2;
750 audioBuffer = new int16_t[ audioBufferSize * channels ];
751
752 audioChannelBuffer = new short int * [ channels ];
753 for ( int c = 0; c < channels; c++ )
754 audioChannelBuffer[ c ] = new short int[ audioBufferSize ];
755 isFullyInitialized = true;
756 }
757 }
758
759 inline void QtHandler::DeinterlaceStereo16( void* pInput, int iBytes,
760 void* pLOutput, void* pROutput )
761 {
762 short int * piSampleInput = ( short int* ) pInput;
763 short int* piSampleLOutput = ( short int* ) pLOutput;
764 short int* piSampleROutput = ( short int* ) pROutput;
765
766 while ( ( char* ) piSampleInput < ( ( char* ) pInput + iBytes ) )
767 {
768 *piSampleLOutput++ = *piSampleInput++;
769 *piSampleROutput++ = *piSampleInput++;
770 }
771 }
772
773 #if 0
774 int QtHandler::Write( const Frame& frame )
775 {
776 if ( ! isFullyInitialized )
777 {
778 AudioInfo audio;
779
780 if ( frame.GetAudioInfo( audio ) )
781 {
782 channels = 2;
783 quicktime_set_audio( fd, channels, audio.frequency, 16, QUICKTIME_TWOS );
784 }
785 else
786 {
787 channels = 0;
788 }
789
790 quicktime_set_video( fd, 1, 720, frame.IsPAL() ? 576 : 480,
791 frame.GetFrameRate(), QUICKTIME_DV );
792 AllocateAudioBuffers();
793 }
794
795 int result = quicktime_write_frame( fd, const_cast<unsigned char*>( frame.data ),
796 frame.GetFrameSize(), 0 );
797
798 if ( channels > 0 )
799 {
800 AudioInfo audio;
801 if ( frame.GetAudioInfo( audio ) && ( unsigned int ) audio.samples < audioBufferSize )
802 {
803 long bytesRead = frame.ExtractAudio( audioBuffer );
804
805 DeinterlaceStereo16( audioBuffer, bytesRead,
806 audioChannelBuffer[ 0 ],
807 audioChannelBuffer[ 1 ] );
808
809 quicktime_encode_audio( fd, audioChannelBuffer, NULL, audio.samples );
810 }
811 }
812 return result;
813 }
814 #endif
815
816 int QtHandler::Close()
817 {
818 if ( fd != NULL )
819 {
820 quicktime_close( fd );
821 fd = NULL;
822 }
823 if ( audioBuffer != NULL )
824 {
825 delete audioBuffer;
826 audioBuffer = NULL;
827 }
828 if ( audioChannelBuffer != NULL )
829 {
830 for ( int c = 0; c < channels; c++ )
831 delete audioChannelBuffer[ c ];
832 delete audioChannelBuffer;
833 audioChannelBuffer = NULL;
834 }
835 return 0;
836 }
837
838
839 off_t QtHandler::GetFileSize()
840 {
841 struct stat file_status;
842 fstat( fileno( fd->stream ), &file_status );
843 return file_status.st_size;
844 }
845
846
847 int QtHandler::GetTotalFrames()
848 {
849 return ( int ) quicktime_video_length( fd, 0 );
850 }
851
852
853 bool QtHandler::Open( const char *s )
854 {
855 Init();
856
857 fd = quicktime_open( ( char * ) s, 1, 0 );
858 if ( fd == NULL )
859 {
860 fprintf( stderr, "Error opening: %s\n", s );
861 return false;
862 }
863
864 if ( quicktime_has_video( fd ) <= 0 )
865 {
866 fprintf( stderr, "There must be at least one video track in the input file (%s).\n",
867 s );
868 Close();
869 return false;
870 }
871 char * fcc = quicktime_video_compressor( fd, 0 );
872 if ( strncmp( fcc, QUICKTIME_DV, 4 ) != 0 &&
873 strncmp( fcc, QUICKTIME_DV_AVID, 4 ) != 0 &&
874 strncmp( fcc, QUICKTIME_DV_AVID_A, 4 ) != 0 )
875 {
876 Close();
877 return false;
878 }
879 if ( quicktime_has_audio( fd ) )
880 channels = quicktime_track_channels( fd, 0 );
881 filename = s;
882 return true;
883 }
884
885 int QtHandler::GetFrame( uint8_t *data, int frameNum )
886 {
887 assert( fd != NULL );
888
889 quicktime_set_video_position( fd, frameNum, 0 );
890 quicktime_read_frame( fd, data, 0 );
891
892 #ifdef HAVE_LIBDV
893 if ( quicktime_has_audio( fd ) )
894 {
895 if ( ! isFullyInitialized )
896 AllocateAudioBuffers();
897
898 int frequency = quicktime_sample_rate( fd, 0 );
899 int samples = ( int )( frequency / quicktime_frame_rate( fd, 0 ) );
900 for ( int i = 0; i < channels; i++ )
901 {
902 quicktime_set_audio_position( fd, ( int64_t )( frameNum * samples ), 0 );
903 quicktime_decode_audio( fd, audioChannelBuffer[ i ], NULL, (long) samples, i );
904 }
905 dv_encoder_t *encoder = dv_encoder_new( 0, 0, 0 );
906 encoder->samples_this_frame = samples;
907 dv_encode_full_audio( encoder, audioChannelBuffer, channels, frequency, data );
908 dv_encoder_free( encoder );
909 }
910 #endif
911
912 return 0;
913 }
914 #endif
my melted branch