Kino: ExportMJPEG Class Reference

00292 {
00293     cerr << ">>> ExportMJPEG::startExport" << endl;
00294 
00295     // Set defaults on own controls
00296     prefs.exportMjpegFormat = g_list_index ( GTK_MENU_SHELL ( mjpegFormat ) ->children, gtk_menu_get_active( mjpegFormat ) );
00297     prefs.exportMjpegDeinterlace = g_list_index ( GTK_MENU_SHELL ( deinterlaceMenu ) ->children, gtk_menu_get_active( deinterlaceMenu ) );
00298     prefs.exportMjpegAspect = g_list_index ( GTK_MENU_SHELL ( mjpegAspect ) ->children, gtk_menu_get_active( mjpegAspect ) );
00299     prefs.exportMjpegSceneSplit = gtk_toggle_button_get_active( splitCheck );
00300     prefs.exportMjpegCleanup = gtk_toggle_button_get_active( cleanupCheck );
00301     GtkWidget* widget = lookup_widget( common->getWidget(), "optionmenu_dvd_tools" );
00302     widget = gtk_option_menu_get_menu( GTK_OPTION_MENU( widget ) );
00303     prefs.exportMjpegDvdTool = g_list_index ( GTK_MENU_SHELL( widget )->children, gtk_menu_get_active( GTK_MENU( widget ) ) );
00304 
00305     // TODO: Fix this buffer stuff.
00306     gchar *filename;
00307     enum export_result status = EXPORT_RESULT_SUCCESS;
00308 
00309     filename = g_strdup( gtk_entry_get_text( fileEntry ) );
00310 
00311     if ( !( strcmp( filename, "" ) && strpbrk( filename, "\'" ) == NULL ) )
00312     {
00313         modal_message( _( "You must enter a filename which doesn't contain quotes." ) );
00314         g_free( filename );
00315         return EXPORT_RESULT_FAILURE;
00316     }
00317     unsigned char *pixels = new unsigned char[ FRAME_MAX_WIDTH * FRAME_MAX_HEIGHT * 4 ];
00318     Frame* frame = GetFramePool()->GetFrame();
00319 
00320     // Get a sample frame to obtain recording info
00321     // TODO: Sample frames are problematic...
00322     playlist->GetFrame( begin, *frame );
00323     frame->decoder->quality = DV_QUALITY_BEST;
00324 
00325     // Get all video and audio info required
00326     int width = frame->GetWidth();
00327     int height = frame->GetHeight();
00328     bool isPAL = frame->IsPAL();
00329     bool isWide = frame->IsWide();
00330     AudioInfo info;
00331     frame->GetAudioInfo( info );
00332     short channels = info.channels;
00333     int frequency = info.frequency;
00334 
00335     // vars for collecting audio and video pipe commands
00336     bool split = false;
00337     bool author = false;
00338     bool Usercleanup = true;
00339     kino_video_pipe type = PIPE_VIDEO_MJPEG;
00340     gchar *audiopipe = NULL;
00341     gchar *videopipe = NULL;
00342     gchar *multiplex = NULL;
00343     gchar *cleanup = NULL;
00344 
00345     // list to collect the names of the generated mpeg2 files
00346     // this collection only proceeds if we are authoring an
00347     // xml file for use with dvdauthor
00348     std::vector<std::string> nameList;
00349 
00350     // MPEG and DIVX translations to commands
00351     // What started off as a simple addition is getting pretty damn messy :-/ - ho hum
00352     // Essentially the important things to remember are that only the 5 variables above
00353     // are populated in the following kludge... (this should move into seprate methods)
00354     const char *videopipeInput = "";
00355     int videoformat = 0;
00356     int deinterlaceRequest = 0;
00357     const char *audioencode = "";
00358     const char *multiplexer = "";
00359     int aspectRatio = 0;
00360     bool isY4Minterlaced = true;
00361 
00362     videopipeInput = gtk_entry_get_text( mjpegVideo );
00363     strncpy( prefs.exportMjpegVideoPipe, videopipeInput, sizeof(prefs.exportMjpegVideoPipe) );
00364     GtkWidget *active_item = gtk_menu_get_active( mjpegFormat );
00365     videoformat = g_list_index ( GTK_MENU_SHELL ( mjpegFormat ) ->children, active_item );
00366     audioencode = gtk_entry_get_text( mjpegAudio );
00367     strncpy( prefs.exportMjpegAudioPipe, audioencode, sizeof(prefs.exportMjpegAudioPipe) );
00368     multiplexer = gtk_entry_get_text( mjpegMultiplexer );
00369     strncpy( prefs.exportMjpegMultiplex, multiplexer, sizeof(prefs.exportMjpegMultiplex) );
00370     active_item = gtk_menu_get_active( deinterlaceMenu );
00371     deinterlaceRequest = g_list_index ( GTK_MENU_SHELL ( deinterlaceMenu ) ->children, active_item );
00372     split = gtk_toggle_button_get_active( splitCheck );
00373     Usercleanup = gtk_toggle_button_get_active( cleanupCheck );
00374     /* only necessary to check this option if we are creating DVD video */
00375     if( videoformat == 6 )
00376     {
00377         // Tool 0 is always "None"
00378         author = prefs.exportMjpegDvdTool > 0;
00379     }
00380     active_item = gtk_menu_get_active( mjpegAspect );
00381     aspectRatio = g_list_index ( GTK_MENU_SHELL ( mjpegAspect ) ->children, active_item );
00382     
00383     /* force deinterlace on MPEG-1 formats if not specified by user */
00384     if ( videoformat < 3 && deinterlaceRequest == 0 )
00385         deinterlaceRequest = 3;
00386 
00387     char deinterlace[ 30 ] = "";
00388     char interlace = '0';
00389     char audioOptions[ 20 ] = "";
00390 
00391     switch ( deinterlaceRequest )
00392     {
00393     case 0: // None
00394         interlace = '1';
00395         break;
00396     case 1: // Internal
00397         type = PIPE_VIDEO_DEINTERLACED_MJPEG;
00398         isY4Minterlaced = false;
00399         break;
00400     case 2: // Already deinterlaced
00401         isY4Minterlaced = false;
00402         break;
00403     case 3:
00404         strcpy( deinterlace, hasYuvDeinterlace ? "yuvdeinterlace |" : "yuvdenoise -F -f |" );
00405         break;
00406     case 4:
00407         strcpy( deinterlace, hasYuvDeinterlace ? "yuvdeinterlace -f |" : "yuvdenoise -F |" );
00408         break;
00409     }
00410 
00411     if ( !strstr( videopipeInput, "yuvscaler" ) )
00412     {
00413         char scale[ 20 ] = "";
00414         char bitrate[ 20 ] = "";
00415 
00416         switch ( videoformat )
00417         {
00418         case 1:
00419             strcpy( scale, "VCD" );
00420             frequency = 44100;
00421             if ( strstr( audioencode, "ffmpeg" ) )
00422                 strcpy( audioOptions, "-ar 44100" );
00423             else if ( strstr( audioencode, "mp2enc" ) )
00424                 strcpy( audioOptions, "-r 44100" );
00425             break;
00426         case 2:
00427             strcpy( scale, "VCD" );
00428             strcpy( bitrate, "-b 1152" );
00429             frequency = 44100;
00430             if ( strstr( audioencode, "ffmpeg" ) )
00431                 strcpy( audioOptions, "-ar 44100" );
00432             else if ( strstr( audioencode, "mp2enc" ) )
00433                 strcpy( audioOptions, "-r 44100" );
00434             break;
00435         case 3:
00436             strcpy( bitrate, "-b 4000" );
00437             break;
00438         case 4:
00439             strcpy( scale, "SVCD" );
00440             frequency = 44100;
00441             if ( strstr( audioencode, "ffmpeg" ) )
00442                 strcpy( audioOptions, "-ar 44100" );
00443             else if ( strstr( audioencode, "mp2enc" ) )
00444                 strcpy( audioOptions, "-r 44100" );
00445             break;
00446         case 5:
00447             strcpy( scale, "SVCD" );
00448             strcpy( bitrate, "-b 2500" );
00449             frequency = 44100;
00450             if ( strstr( audioencode, "ffmpeg" ) )
00451                 strcpy( audioOptions, "-ar 44100" );
00452             else if ( strstr( audioencode, "mp2enc" ) )
00453                 strcpy( audioOptions, "-r 44100" );
00454             break;
00455         case 6:
00456             videoformat = 8;
00457             strcpy( scale, "" );
00458             if ( strstr( audioencode, "ffmpeg" ) )
00459             {
00460                 frequency = 48000;
00461                 if ( !strstr( audioencode, " -ab " ) )
00462                     sprintf( audioOptions, "%s -ab 192", audioOptions );
00463             }
00464             else if ( strstr( audioencode, "mp2enc" ) )
00465             {
00466                 if ( !strstr( audioencode, " -r " ) )
00467                     sprintf( audioOptions, "%s -r 48000", audioOptions );
00468                 frequency = 48000;
00469                 if ( !strstr( audioencode, " -b " ) )
00470                     sprintf( audioOptions, "%s -b 224", audioOptions );
00471             }
00472             break;
00473         }
00474 
00475         // If the bitrate is specified then remove the defaults above
00476         if ( strstr( videopipeInput, " -b " ) || strstr( videopipeInput, "--video-bitrate" ) )
00477             strcpy( bitrate, "" );
00478 
00479         // Yuck (!) - builds the video pipe depending on data collected above...
00480         if ( strcmp( scale, "" ) )
00481             videopipe = g_strdup_printf(
00482                      "%s yuvscaler -v 0 -O %s -n %c | %s -f %d -I %c -n %c -a %d %s -o \'%s\'.mpv",
00483                      deinterlace,
00484                      scale, isPAL ? 'p' : 'n', videopipeInput, videoformat, interlace,
00485                      isPAL ? 'p' : 'n', aspectRatio ? aspectRatio : (isWide ? 3 : 2), bitrate, filename );
00486         else
00487             videopipe = g_strdup_printf( "%s %s -f %d -I %c -n %c -a %d %s -o \'%s\'.mpv",
00488                      deinterlace, videopipeInput, videoformat, interlace,
00489                      isPAL ? 'p' : 'n', aspectRatio ? aspectRatio : (isWide ? 3 : 2), bitrate, filename );
00490     }
00491     else
00492     {
00493         videopipe = g_strdup_printf( "%s %s -f %d -I %c -n %c -o \'%s\'.mpv\n",
00494                  deinterlace, videopipeInput, videoformat, interlace,
00495                  isPAL ? 'p' : 'n', filename );
00496     }
00497     if ( strstr( audioencode, "ffmpeg" ) )
00498     {
00499         audiopipe = g_strdup_printf( "|%s -f wav -i pipe: %s -y \'%s\'.%s", audioencode, audioOptions,
00500             filename, videoformat == 8 ? "ac3" : "mp2" );
00501         if ( strcmp( multiplexer, "" ) )
00502         {
00503             multiplex = g_strdup_printf( "%s -f %d -o \'%s\'%%s.mpeg \'%s\'.mpv \'%s\'.%s",
00504                     multiplexer, videoformat, filename, filename, filename,
00505                     videoformat == 8 ? "ac3" : "mp2" );
00506             cleanup = g_strdup_printf( "rm -f \'%s\'.mpv \'%s\'.%s \'%s\'.wav",
00507                     filename, filename, videoformat == 8 ? "ac3" : "mp2", filename );
00508         }
00509     }
00510     else if ( strstr( audioencode, "mp2enc" ) )
00511     {
00512         audiopipe = g_strdup_printf( "|%s %s -o \'%s\'.mp2", audioencode, audioOptions, filename );
00513         if ( strcmp( multiplexer, "" ) )
00514         {
00515             multiplex = g_strdup_printf( "%s -f %d -o \'%s\'%%s.mpeg \'%s\'.mpv \'%s\'.mp2",
00516                     multiplexer, videoformat, filename, filename, filename );
00517             cleanup = g_strdup_printf( "rm -f \'%s\'.mpv \'%s\'.mp2 \'%s\'.wav",
00518                     filename, filename, filename );
00519         }
00520     }
00521 
00522     KinoAudioPipe *wav = KinoAudioFactory::CreateAudioPipe( PIPE_AUDIO_WAV );
00523     KinoVideoPipe *video = KinoVideoFactory::CreateVideoPipe( type );
00524     KinoAVPipe *mpeg = new KinoAVPipe( wav, video );
00525 
00526     // Iterate through each scene (opening and closing audio pipes as requested)
00527     int scene = 0;
00528 
00529     for ( int sceneBegin = begin; sceneBegin <= end && exportPage->isExporting;
00530             scene ++ )
00531     {
00532         gchar *full;
00533         char sceneString[ 20 ];
00534         int sceneEnd = end;
00535         bool userMplexSplit = ( multiplex != NULL && ( strstr( multiplex, "-S" ) || 
00536             strstr( multiplex, "--max-segment-size" ) ) );
00537 
00538         // Determine if we need to split by scene or not
00539         // when splitting: Output is generated as fileNNN_MMM.mpeg where NNN is the
00540         // kino scene number and MMM is the mplex split
00541         // when not splitting: Output is generated file as fileMMM.mpeg
00542         sceneString[0] = '\0';
00543         if ( split )
00544         {
00545             sprintf( sceneString, "%03d", scene );
00546             if ( userMplexSplit )
00547                 strcat( sceneString, "_%03d" );
00548             sceneEnd = playlist->FindEndOfScene( sceneBegin );
00549             if ( sceneEnd > end )
00550                 sceneEnd = end;
00551         }
00552         else if ( userMplexSplit )
00553         {
00554             strcpy( sceneString, "%03d" );
00555         }
00556 
00557         if ( author )
00558         {
00559             char tmpFilename[512];
00560 
00561             if ( split && userMplexSplit ) {
00562                 snprintf( tmpFilename, sizeof( tmpFilename ), "%s%03d_001.mpeg", filename, scene );
00563             } else if ( split ) {
00564                 snprintf( tmpFilename, sizeof( tmpFilename ), "%s%03d.mpeg", filename, scene );
00565             } else if ( userMplexSplit ) {
00566                 snprintf( tmpFilename, sizeof( tmpFilename ), "%s001.mpeg", filename );
00567             } else {
00568                 snprintf( tmpFilename, sizeof( tmpFilename ), "%s.mpeg", filename );
00569             }
00570 
00571             nameList.push_back( std::string( tmpFilename ) );
00572         }
00573 
00574         cerr << ">>> Generated video pipe '" << videopipe << "'" << endl;
00575         if ( audiopipe )
00576         {
00577             cerr << ">>> Generated audio pipe '" << audiopipe << "'" << endl;
00578             mpeg->OpenAudio( audiopipe, channels, frequency, 2 );
00579         }
00580         mpeg->OpenVideoPipe( videopipe, width, height, isY4Minterlaced );
00581 
00582         int imagesize = width * height * 3;
00583 
00584         // first call to innerLoopUpdate initializes progress tracker, which
00585         // we want to do because calculateAdjustedRate generates paused time.
00586         innerLoopUpdate( sceneBegin, begin, end, every );
00587 
00588         // Determine correct amount of audio for duration
00589         double adjustedRate = 0;
00590         AsyncAudioResample<int16_ne_t,int16_le_t>* resampler = 0;
00591         if ( audiopipe )
00592         {
00593             adjustedRate = calculateAdjustedRate( playlist, frequency, sceneBegin, sceneEnd, every );
00594             if ( !adjustedRate )
00595                 status = EXPORT_RESULT_ABORT;
00596 
00597             // Setup a resampler
00598             resampler = new AsyncAudioResample<int16_ne_t,int16_le_t>(
00599                 AUDIO_RESAMPLE_SRC_SINC_BEST_QUALITY, playlist, frequency, sceneBegin, sceneEnd, every );
00600             if ( resampler->IsError() )
00601             {
00602                 std::cerr << ">>> Resampler error: " << resampler->GetError() << std::endl;
00603                 exportPage->isExporting = false;
00604                 status = EXPORT_RESULT_FAILURE;
00605                 break;
00606             }
00607         }
00608 
00609         /* Iterate over frames in scene */
00610         for ( int i = sceneBegin, j = 0; i <= sceneEnd && exportPage->isExporting;
00611             i += every, j++ )
00612         {
00613             innerLoopUpdate( i, begin, end, every );
00614             playlist->GetFrame( i, *frame );
00615 
00616             if ( audiopipe && resampler )
00617             {
00618                 int requestedSamples = frame->CalculateNumberSamples( frequency, j );
00619                 int nsamples = resampler->Process( adjustedRate, requestedSamples );
00620                 if ( nsamples > 0 && !mpeg->OutputAudioFrame( reinterpret_cast<int16_t *>(resampler->GetOutput()), 
00621                     nsamples * channels * sizeof(int16_t) ) )
00622                 {
00623                     modal_message( _( "Error writing to KINO/MJPEG audio filter - aborting." ) );
00624                     status = EXPORT_RESULT_FAILURE;
00625                     break;
00626                 }
00627             }
00628 
00629             if ( exportPage->isExporting )
00630             {
00631                 if ( type == PIPE_VIDEO_MJPEG )
00632                     frame->ExtractYUV( pixels );
00633                 else
00634                     frame->ExtractRGB( pixels );
00635                 if ( !mpeg->OutputVideoFrame( pixels, imagesize ) )
00636                 {
00637                     modal_message( _( "Error writing to KINO/MJPEG video filter - aborting." ) );
00638                     status = EXPORT_RESULT_FAILURE;
00639                     break;
00640                 }
00641             }
00642         }
00643 
00644         if ( status == EXPORT_RESULT_SUCCESS && !exportPage->isExporting )
00645             status = EXPORT_RESULT_ABORT;
00646 
00647         if ( !split )
00648             exportPage->isExporting = false;
00649 
00650         // Try to finish the stream to create a valid mpeg if possible
00651         if ( audiopipe )
00652             mpeg->CloseAudio();
00653         mpeg->CloseVideo();
00654         delete resampler;
00655         resampler = 0;
00656 
00657         if ( status == EXPORT_RESULT_SUCCESS && multiplex != NULL && strcmp( multiplex, "" ) )
00658         {
00659             // expand the template to accomodate the scene splits
00660             full = g_strdup_printf( multiplex, sceneString );
00661             cerr << ">>> Executing '" << full << "'" << endl;
00662             if ( 0 != mpeg->ExecuteCommand( full ) )
00663             {
00664                 // If mplex error, use user setting
00665                 //do_cleanup = Usercleanup;
00666             }
00667             g_free( full );
00668         }
00669 
00670         if ( Usercleanup && cleanup != NULL && strcmp( cleanup, "" ) )
00671             mpeg->ExecuteCommand( cleanup );
00672         
00673         // Move to start of next scene
00674         sceneBegin = sceneEnd + 1;
00675     }
00676 
00677     if ( status == EXPORT_RESULT_SUCCESS && author )
00678     {
00679         createAuthorXml( filename, nameList, split, isPAL );
00680 
00681         // Run the selected tool
00682         // -1 to account for first "None" item
00683         DVDTool *tool = m_dvdTools[ prefs.exportMjpegDvdTool - 1 ];
00684         if ( tool )
00685         {
00686             string dvdauthorFile( string( filename ) + "-dvdauthor.xml" );
00687             if ( tool->execute( dvdauthorFile, string( filename ) ) )
00688                 modal_message( _("The dvdauthor script failed, but the MPEG export succeeded.") );
00689             tool->close();
00690         }
00691     }
00692 
00693     g_free( filename );
00694     g_free( audiopipe );
00695     g_free( videopipe );
00696     g_free( multiplex );
00697     g_free( cleanup );
00698     delete mpeg;
00699     delete video;
00700     delete wav;
00701     delete[] pixels;
00702 
00703     GetFramePool()->DoneWithFrame( frame );
00704     
00705     return status;
00706 }

Public Member Functions
	ExportMJPEG (PageExport , KinoCommon )
	Constructor for page.
virtual	~ExportMJPEG ()
	Destructor for page.
void	loadTools (string directory)
void	activateTool (int tool)
void	selectTool (int tool)
Private Member Functions
void	start ()
	Empty methods - here for tracking during development.
gulong	onActivate ()
	Define active widgets.
enum export_result	doExport (PlayList *playlist, int begin, int end, int every, bool preview)
	start exporting MJPEG
void	createAuthorXml (const char *filename, std::vector< std::string > &nameList, bool split, bool isPal)
Private Attributes
Preferences &	prefs
GtkEntry *	fileEntry
GtkMenu *	mjpegFormat
GtkEntry *	mjpegVideo
GtkEntry *	mjpegAudio
GtkEntry *	mjpegMultiplexer
GtkMenu *	deinterlaceMenu
GtkToggleButton *	splitCheck
GtkToggleButton *	cleanupCheck
GtkMenu *	mjpegAspect
GtkEntry *	mjpegXMLScript
bool	hasYuvDeinterlace
bool	isAvailable
vector< DVDTool * >	m_dvdTools
ExportMJPEG Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation
