connectivitymodules/SeCon/services/pcd/src/sconvideoparser.cpp
branchRCL_3
changeset 13 81da3301b632
parent 1 f8e15b44d440
equal deleted inserted replaced
12:523717cdb0ad 13:81da3301b632
    25 _LIT( KMimeType, "MimeType" );
    25 _LIT( KMimeType, "MimeType" );
    26 _LIT8( KImageEncoderMimeType, "image/jpeg" );
    26 _LIT8( KImageEncoderMimeType, "image/jpeg" );
    27 _LIT( KMimeTypeAudio, "audio/*" );
    27 _LIT( KMimeTypeAudio, "audio/*" );
    28 _LIT( KMimeTypeVideo, "video/*" );
    28 _LIT( KMimeTypeVideo, "video/*" );
    29 
    29 
    30 const TInt KVideoClipTimeout( 10000000 ); // 10 sec.
    30 const TInt KRequestTimeOut( 20000000 ); // 20 sec.
    31 
    31 
    32 // -----------------------------------------------------------------------------
    32 // -----------------------------------------------------------------------------
    33 // CSConVideoParser::CSConVideoParser()
    33 // CSConVideoParser::CSConVideoParser()
    34 // -----------------------------------------------------------------------------
    34 // -----------------------------------------------------------------------------
    35 //
    35 //
   148     TBool fileExist = BaflUtils::FileExists( aFs, aFileName );
   148     TBool fileExist = BaflUtils::FileExists( aFs, aFileName );
   149     if ( !fileExist )
   149     if ( !fileExist )
   150         {
   150         {
   151         User::Leave( KErrNotFound );
   151         User::Leave( KErrNotFound );
   152         }
   152         }
   153     
   153     iAsyncStopCalled = EFalse;
   154     iVideoClip = CTNEVideoClipInfo::NewL( aFileName, *this );
   154     iVideoClip = CTNEVideoClipInfo::NewL( aFileName, *this );
   155     
   155     
   156     iVideoUtil->OpenFileL( aFileName );
   156     iVideoUtil->OpenFileL( aFileName );
   157     
   157     
       
   158     LOGGER_WRITE("Start timeout");
       
   159     iTimeOut->Start( KRequestTimeOut );
   158     
   160     
   159     LOGGER_WRITE("iWait.Start()");
   161     LOGGER_WRITE("iWait.Start()");
   160     iWait.Start();
   162     iWait.Start();
   161     
   163     
   162     TRACE_FUNC_EXIT;
   164     TRACE_FUNC_EXIT;
   351 // -----------------------------------------------------------------------------
   353 // -----------------------------------------------------------------------------
   352 //
   354 //
   353 void CSConVideoParser::MvpuoOpenComplete( TInt aError )
   355 void CSConVideoParser::MvpuoOpenComplete( TInt aError )
   354     {
   356     {
   355     TRACE_FUNC_ENTRY;
   357     TRACE_FUNC_ENTRY;
       
   358     if ( iVideoUtilReady )
       
   359         {
       
   360         // already timeout
       
   361         LOGGER_WRITE("Already timeout");
       
   362         return;
       
   363         }
   356     LOGGER_WRITE_1( "aError: %d", aError );
   364     LOGGER_WRITE_1( "aError: %d", aError );
   357     if ( aError == KErrNone )
   365     if ( aError == KErrNone )
   358         {
   366         {
   359         iVideoUtil->Prepare();
   367         iVideoUtil->Prepare();
   360         }
   368         }
   362         {
   370         {
   363         iVideoUtilReady = ETrue;
   371         iVideoUtilReady = ETrue;
   364         iVideoUtilErr = aError;
   372         iVideoUtilErr = aError;
   365         }
   373         }
   366     
   374     
   367     if ( iVideoUtilReady && iVideoClipReady )
   375     if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )
   368         {
   376         {
       
   377         iAsyncStopCalled = ETrue;
       
   378         iTimeOut->Cancel();
   369         LOGGER_WRITE("AsyncStop");
   379         LOGGER_WRITE("AsyncStop");
   370         iWait.AsyncStop();
   380         iWait.AsyncStop();
   371         }
   381         }
   372     TRACE_FUNC_EXIT;
   382     TRACE_FUNC_EXIT;
   373     }
   383     }
   378 // -----------------------------------------------------------------------------
   388 // -----------------------------------------------------------------------------
   379 //
   389 //
   380 void CSConVideoParser::MvpuoPrepareComplete( TInt aError )
   390 void CSConVideoParser::MvpuoPrepareComplete( TInt aError )
   381     {
   391     {
   382     TRACE_FUNC_ENTRY;
   392     TRACE_FUNC_ENTRY;
       
   393     if ( iVideoUtilReady )
       
   394         {
       
   395         // already timeout
       
   396         LOGGER_WRITE("Already timeout");
       
   397         return;
       
   398         }
   383     LOGGER_WRITE_1( "aError: %d", aError );
   399     LOGGER_WRITE_1( "aError: %d", aError );
   384     
   400     
   385     iVideoUtilReady = ETrue;
   401     iVideoUtilReady = ETrue;
   386     iVideoUtilErr = aError;
   402     iVideoUtilErr = aError;
   387     
   403     
   388     if ( iVideoUtilReady && iVideoClipReady )
   404     if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )
   389         {
   405         {
       
   406         iAsyncStopCalled = ETrue;
       
   407         iTimeOut->Cancel();
   390         LOGGER_WRITE("AsyncStop");
   408         LOGGER_WRITE("AsyncStop");
   391         iWait.AsyncStop();
   409         iWait.AsyncStop();
   392         }
   410         }
   393     TRACE_FUNC_EXIT;
   411     TRACE_FUNC_EXIT;
   394     }
   412     }
   426 // -----------------------------------------------------------------------------
   444 // -----------------------------------------------------------------------------
   427 //
   445 //
   428 void CSConVideoParser::NotifyVideoClipInfoReady(CTNEVideoClipInfo& aInfo, TInt aError)
   446 void CSConVideoParser::NotifyVideoClipInfoReady(CTNEVideoClipInfo& aInfo, TInt aError)
   429     {
   447     {
   430     TRACE_FUNC_ENTRY;
   448     TRACE_FUNC_ENTRY;
       
   449     if ( iVideoClipReady )
       
   450         {
       
   451         // already timeout
       
   452         LOGGER_WRITE("Already timeout");
       
   453         return;
       
   454         }
   431     LOGGER_WRITE_1("aError: %d", aError);
   455     LOGGER_WRITE_1("aError: %d", aError);
   432     if ( aError == KErrNone )
   456     if ( aError == KErrNone )
   433         {
   457         {
   434         TSize resolution(320,240);
   458         TSize resolution(320,240);
   435         TRAPD( err, aInfo.GetThumbL(*this,KBestThumbIndex, &resolution ) );
   459         TRAPD( err, aInfo.GetThumbL(*this,KBestThumbIndex, &resolution ) );
   438             {
   462             {
   439             LOGGER_WRITE_1("aInfo.GetThumbL err: %d", err);
   463             LOGGER_WRITE_1("aInfo.GetThumbL err: %d", err);
   440             iVideoClipReady = ETrue;
   464             iVideoClipReady = ETrue;
   441             iVideoClipErr = err;
   465             iVideoClipErr = err;
   442             }
   466             }
   443         else
       
   444             {
       
   445             LOGGER_WRITE("Start timeout");
       
   446             iTimeOut->Start( KVideoClipTimeout );
       
   447             }
       
   448         }
   467         }
   449     else
   468     else
   450         {
   469         {
   451         iVideoClipReady = ETrue;
   470         iVideoClipReady = ETrue;
   452         iVideoClipErr = aError;
   471         iVideoClipErr = aError;
   453         }
   472         }
   454     
   473     
   455     if ( iVideoUtilReady && iVideoClipReady )
   474     if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )
   456         {
   475         {
       
   476         iAsyncStopCalled = ETrue;
       
   477         iTimeOut->Cancel();
   457         LOGGER_WRITE("AsyncStop");
   478         LOGGER_WRITE("AsyncStop");
   458         iWait.AsyncStop();
   479         iWait.AsyncStop();
   459         }
   480         }
   460     TRACE_FUNC_EXIT;
   481     TRACE_FUNC_EXIT;
   461     }
   482     }
   468 void CSConVideoParser::NotifyVideoClipThumbCompleted(CTNEVideoClipInfo& /*aInfo*/, 
   489 void CSConVideoParser::NotifyVideoClipThumbCompleted(CTNEVideoClipInfo& /*aInfo*/, 
   469         TInt aError, 
   490         TInt aError, 
   470         CFbsBitmap* aThumb)
   491         CFbsBitmap* aThumb)
   471     {
   492     {
   472     TRACE_FUNC_ENTRY;
   493     TRACE_FUNC_ENTRY;
       
   494     if ( iVideoClipReady )
       
   495         {
       
   496         // already timeout
       
   497         LOGGER_WRITE("Already timeout");
       
   498         delete aThumb;
       
   499         return;
       
   500         }
   473     LOGGER_WRITE_1("aError: %d", aError);
   501     LOGGER_WRITE_1("aError: %d", aError);
   474     iTimeOut->Cancel();
       
   475     if ( aError == KErrNone)
   502     if ( aError == KErrNone)
   476         {
   503         {
   477         delete iThumbnail;
   504         delete iThumbnail;
   478         iThumbnail = NULL;
   505         iThumbnail = NULL;
   479         LOGGER_WRITE("create CImageEncoder");
   506         LOGGER_WRITE("create CImageEncoder");
   495         }
   522         }
   496     delete aThumb;
   523     delete aThumb;
   497     iVideoClipReady = ETrue;
   524     iVideoClipReady = ETrue;
   498     iVideoClipErr = aError;
   525     iVideoClipErr = aError;
   499     
   526     
   500     if ( iVideoUtilReady && iVideoClipReady )
   527     if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )
   501         {
   528         {
       
   529         iAsyncStopCalled = ETrue;
       
   530         iTimeOut->Cancel();
   502         LOGGER_WRITE("AsyncStop");
   531         LOGGER_WRITE("AsyncStop");
   503         iWait.AsyncStop();
   532         iWait.AsyncStop();
   504         }
   533         }
   505     
   534     
   506     TRACE_FUNC_EXIT;
   535     TRACE_FUNC_EXIT;
   520         LOGGER_WRITE("videoclip cancelled");
   549         LOGGER_WRITE("videoclip cancelled");
   521         iVideoClipReady = ETrue;
   550         iVideoClipReady = ETrue;
   522         iVideoClipErr = KErrCancel;
   551         iVideoClipErr = KErrCancel;
   523         }
   552         }
   524     
   553     
   525     if ( iVideoUtilReady && iVideoClipReady )
   554     if ( !iVideoUtilReady )
       
   555         {
       
   556         LOGGER_WRITE("videoUtil cancelled");
       
   557         iVideoUtilReady = ETrue;
       
   558         iVideoUtilErr = KErrCancel;
       
   559         }
       
   560     
       
   561     if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )
   526         {
   562         {
   527         LOGGER_WRITE("AsyncStop");
   563         LOGGER_WRITE("AsyncStop");
       
   564         iAsyncStopCalled = ETrue;
   528         iWait.AsyncStop();
   565         iWait.AsyncStop();
   529         }
   566         }
   530     TRACE_FUNC_EXIT;
   567     TRACE_FUNC_EXIT;
   531     }
   568     }