1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:  

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 #ifndef __VEDMOVIEIMP_H__

    23 #define __VEDMOVIEIMP_H__

    24 

    25 

    26 #include <e32base.h>

    27 #include <f32file.h>

    28 #include "VedMovie.h"

    29 #include "VedVideoClip.h"

    30 #include "VedAudioClipInfoImp.h"

    31 #include "AudObservers.h"

    32 #include "AudCommon.h"

    33 #include "Vedqualitysettingsapi.h"

    34 #include "ctrtranscoder.h"

    35 

    36 

    37 #if ( defined (__WINS__) || defined (__WINSCW__) )

    38 const TInt KVEdMaxFrameRate = 10;

    39 #else 

    40 const TInt KVEdMaxFrameRate = 15;

    41 #endif

    42 

    43 

    44 /*

    45  *  Forward declarations.

    46  */

    47 class CMovieProcessor;

    48 class CVedMovie;

    49 class CVedMovieImp;

    50 class CVedMovieAddClipOperation;

    51 class CVedMovieProcessOperation;

    52 class CAudSong;

    53 class CVedCodecChecker;

    54 

    55 

    56 /**

    57  * Video movie, which consists of zero or more video clips and zero or more audio clips.

    58  *

    59  * @see  CVedVideoClip

    60  * @see  CVedAudioClip

    61  */

    62 class CVedMovieImp : public CVedMovie, MAudSongObserver, MVedAudioClipInfoObserver

    63     {

    64 public:

    65     /* Constructors. */

    66 

    67     CVedMovieImp(RFs *aFs);

    68 

    69     void ConstructL();

    70 

    71     /**

    72      * Destroys the object and releases all resources.

    73      */

    74     ~CVedMovieImp();

    75 

    76 

    77     /* Property methods. */

    78     

    79     /**

    80      * Returns the quality setting of this movie.

    81      *

    82      * @return  quality setting of this movie

    83      */

    84     TVedMovieQuality Quality() const;

    85 

    86     /**

    87      * Sets the quality setting of this movie.

    88      *

    89      * @param aQuality  quality setting

    90      */

    91     void SetQuality(TVedMovieQuality aQuality);

    92 

    93     /**

    94      * Returns the video format of this movie. 

    95      * 

    96      * @return  video format of this movie

    97      */

    98     TVedVideoFormat Format() const;

    99 

   100     /**

   101      * Returns the video type of this movie. 

   102      * 

   103      * @return  video type of this movie

   104      */

   105     TVedVideoType VideoType() const;

   106 

   107     /**

   108      * Returns the resolution of this movie. Panics with 

   109      * <code>TVedPanic::EMovieEmpty</code> if there are no clips 

   110      * in the movie.

   111      * 

   112      * @return  resolution of the movie

   113      */

   114     TSize Resolution() const;

   115 

   116     /**

   117      * Returns the recommended maximum framerate of this movie..

   118      * <p>

   119      * Note that the returned maximum framerate is a recommendation,

   120      * not a guarantee. For example, the video clip generators inserted

   121      * in this movie should not generate frames at higher framerates 

   122      * than the recommendation. The movie may, however, exceed this

   123      * recommendation. For example, the framerate may be higher if the 

   124      * framerates of some of the video clips are higher than the 

   125      * recommendation and it is not possible to transcode them to reduce 

   126      * the framerate.

   127      *

   128      * @return  maximum framerate in frames per second

   129      */

   130     TInt MaximumFramerate() const;

   131 

   132     /**

   133      * Returns the audio type of the movie audio track.

   134      * 

   135      * @return  audio type of the movie audio track

   136      */

   137     TVedAudioType AudioType() const;

   138 

   139     /**

   140      * Returns the audio sampling rate of the movie audio track.

   141      *

   142      * @return  audio sampling rate of the movie audio track.

   143      */

   144     TInt AudioSamplingRate() const;

   145 

   146     /**

   147      * Sets the output parameters for the movie. Leaves

   148      * with KErrNotSupported if a parameter is illegal,

   149      * e.g., target bitrate is too high for the given 

   150      * codec. This method overrides the SetQuality method

   151      *

   152      * Possible leave codes:

   153      *  - <code>KErrNotSupported</code> if setting is not valid

   154      *

   155      * @param Output parameters

   156      */

   157     virtual void SetOutputParametersL(TVedOutputParameters& aOutputParams);

   158 

   159     /**

   160      * Returns the audio channel mode of the movie audio track.

   161      * 

   162      * @return  audio channel mode of the movie audio track.

   163      */

   164     TVedAudioChannelMode AudioChannelMode() const;

   165     

   166     /**

   167      * Returns the audio bitrate mode of the movie audio track.

   168      *

   169      * @return audio bitrate mode

   170      */

   171     TVedBitrateMode AudioBitrateMode() const;

   172 

   173     /**

   174      * Returns the target bitrate of the movie audio track.

   175      * 

   176      * @return  target bitrate of the movie audio track.

   177      */

   178     TInt AudioBitrate() const;

   179 

   180     /**

   181      * Returns the required bitrate of the movie video track.

   182      * If nonzero, indicates real target bitrate => requires transcoding

   183      * 

   184      * @return  Requested bitrate of the movie video track.

   185      */

   186     TInt VideoBitrate() const;

   187     

   188     /**

   189      * Returns the "standard" or default bitrate of the movie video track.

   190      * If input is something else, no transcoding is needed, but new content 

   191      * is encoded using this rate. If there is also requested bitrate, the values 

   192      * should be the same. The "standard" does not necessarily mean the bitrate

   193      * is from video coding standard, it can be, but it can be also something else,

   194      * depending on the product variant.

   195      * 

   196      * @return  Standard bitrate of the movie video track.

   197      */

   198     TInt VideoStandardBitrate() const;

   199 

   200     /**

   201      * Returns the target framerate of the movie video track.

   202      * 

   203      * @return  target framerate of the movie video track.

   204      */

   205     TReal VideoFrameRate() const;

   206 

   207     /**

   208      * Returns the total duration of this movie.

   209      * 

   210      * @return  duration in microseconds

   211      */

   212     inline TTimeIntervalMicroSeconds Duration() const;

   213 

   214     /**

   215      * Returns an estimate of the total size of this movie.

   216      * 

   217      * @return  size estimate in bytes

   218      */

   219     TInt GetSizeEstimateL() const;

   220 

   221     /**

   222      * Estimates end cutpoint with given target size and start cutpoint for current movie.

   223      *

   224      * @param aTargetSize  Target filesize for section indicated by aStartTime and aEndTime.

   225      * @param aStartTime   Start time for first frame included in cutted section. 

   226      * @param aEndTime     On return contains estimated end time with given start time and section target filesize.

   227      */

   228     void GetDurationEstimateL(TInt aTargetSize, TTimeIntervalMicroSeconds aStartTime, TTimeIntervalMicroSeconds& aEndTime);

   229 

   230     /**

   231      * Returns whether movie properties meet MMS compatibility

   232      * 

   233      * @return  ETrue if MMS compatible, else EFalse

   234      */

   235     TBool IsMovieMMSCompatible() const;

   236 

   237 

   238     /* Video clip management methods. */

   239 

   240     /**

   241      * Returns the number of video clips in this movie.

   242      *

   243      * @return  number of video clips

   244      */

   245     inline TInt VideoClipCount() const;

   246 

   247     /** 

   248      * Returns the video clip at the specified index. 

   249      * Used by underlying modules and friend classes. Not part of public API.

   250      * Panics with code <code>USER-130</code> if the clip index is invalid.

   251      *

   252      * @param aIndex  index

   253      *

   254      * @return  clip at the specified index.

   255      */ 

   256     CVedVideoClip* VideoClip(TInt aIndex) const;

   257 

   258     /** 

   259      * Inserts the specified video clip to the specified index in this movie. 

   260      * The observers are notified when the clip has been added or adding clip 

   261      * has failed. Panics with <code>EMovieAddOperationAlreadyRunning</code> 

   262      * if another add video or audio clip operation is already running.

   263      * Panics with code <code>USER-130</code> if the clip index is invalid.

   264      *

   265      * Possible leave codes:

   266      *  - <code>KErrNoMemory</code> if memory allocation fails

   267      *

   268      * @param aFileName  file name of the clip to add

   269      * @param aIndex     index the clip should be inserted at

   270      */

   271     void InsertVideoClipL(const TDesC& aFileName, TInt aIndex);

   272 

   273 

   274     void InsertVideoClipL(CVedVideoClipGenerator& aGenerator, TBool aIsOwnedByVideoClip,

   275                           TInt aIndex);

   276 

   277     /** 

   278      * Removes the video clip at the specified index from this movie.

   279      * Panics with code <code>USER-130</code> if the clip index is invalid.

   280      *

   281      * @param aIndex  index of the clip to be removed

   282      */

   283     void RemoveVideoClip(TInt aIndex);

   284 

   285 

   286     /* Transition effect management methods. */

   287 

   288     /** 

   289      * Returns the start transition effect of this movie. Panics with 

   290      * <code>TVedPanic::EMovieEmpty</code> if there are no video clips 

   291      * in the movie.

   292      *

   293      * @return  start transition effect

   294      */ 

   295     TVedStartTransitionEffect StartTransitionEffect() const;

   296 

   297     /** 

   298      * Sets the start transition effect of this movie. Panics with 

   299      * <code>TVedPanic::EMovieEmpty</code> if there are no video clips 

   300      * in the movie.

   301      *

   302      * @param aEffect  start transition effect

   303      */ 

   304     void SetStartTransitionEffect(TVedStartTransitionEffect aEffect);

   305 

   306     /**

   307      * Returns the number of middle transition effects in this movie.

   308      * Note that this is the same as the number of video clips minus one.

   309      *

   310      * @return  number of middle transition effects

   311      */

   312     TInt MiddleTransitionEffectCount() const;

   313 

   314     /** 

   315      * Returns the middle transition effect at the specified index. 

   316      * Panics with code <code>USER-130</code> if the index is invalid.

   317      *

   318      * @param aIndex  index

   319      *

   320      * @return  middle transition effect at the specified index

   321      */ 

   322     TVedMiddleTransitionEffect MiddleTransitionEffect(TInt aIndex) const;

   323 

   324     /** 

   325      * Sets the middle transition effect at the specified index. 

   326      * Panics with code <code>USER-130</code> if the index is invalid.

   327      *

   328      * @param aEffect  middle transition effect

   329      * @param aIndex   index

   330      */ 

   331     void SetMiddleTransitionEffect(TVedMiddleTransitionEffect aEffect, TInt aIndex);

   332 

   333     /** 

   334      * Returns the end transition effect of this movie. Panics with 

   335      * <code>TVedPanic::EMovieEmpty</code> if there are no video clips 

   336      * in the movie.

   337      *

   338      * @return  end transition effect

   339      */ 

   340     TVedEndTransitionEffect EndTransitionEffect() const;

   341 

   342     /** 

   343      * Sets the end transition effect of this movie. Panics with 

   344      * <code>TVedPanic::EMovieEmpty</code> if there are no video clips 

   345      * in the movie.

   346      *

   347      * @param aEffect  end transition effect

   348      */ 

   349     void SetEndTransitionEffect(TVedEndTransitionEffect aEffect);

   350     

   351 

   352     /* Audio clip management methods. */

   353 

   354     /**

   355      * Returns the number of audio clips in this movie.

   356      *

   357      * @return  number of audio clips

   358      */

   359     TInt AudioClipCount() const;    

   360 

   361     /** 

   362      * Adds the specified audio clip to this movie. The observers are notified

   363      * when the clip has been added or adding clip has failed. Panics with 

   364      * <code>EMovieAddOperationAlreadyRunning</code> if another add video or

   365      * audio clip operation is already running.

   366      * 

   367      * Possible leave codes:

   368      *  - <code>KErrNoMemory</code> if memory allocation fails

   369      *

   370      * @param aFileName   file name of the clip to add

   371      * @param aStartTime  start time of the clip in movie timebase

   372      * @param aCutInTime  cut in time of the clip

   373      * @param aCutOutTime cut out time of the clip; or 

   374      *                    <code>KVedAudioClipOriginalDuration</code> to specify

   375      *                    that the original duration of the clip should be used

   376      */

   377     void AddAudioClipL(const TDesC& aFileName,

   378             TTimeIntervalMicroSeconds aStartTime,

   379             TTimeIntervalMicroSeconds aCutInTime,

   380             TTimeIntervalMicroSeconds aCutOutTime);

   381 

   382     /** 

   383      * Removes the audio clip at the specified index from this movie.

   384      * Panics with code <code>USER-130</code> if the clip index is invalid.

   385      *

   386      * @param aIndex  index of the clip to be removed

   387      */

   388     void RemoveAudioClip(TInt aIndex);

   389     

   390     

   391     /* Whole movie management methods. */

   392     

   393     /** 

   394      * Removes all video and audio clips and clears all transitions.

   395      */

   396     void Reset();

   397 

   398 

   399     /* Processing methods. */

   400 

   401     /**

   402      * Starts a video processing operation. This method is asynchronous and 

   403      * returns immediately. The processing will happen in the background and

   404      * the observer will be notified about the progress of the operation.

   405      * Processed data is written into the specified file. Panics with 

   406      * <code>TVedPanic::EMovieEmpty</code> if there are no clips 

   407      * in the movie.

   408      * 

   409      * Possible leave codes:

   410      *  - <code>KErrNoMemory</code> if memory allocation fails

   411      *  - <code>KErrAccessDenied</code> if the file access is denied

   412      *  - <code>KErrDiskFull</code> if the disk is full

   413      *  - <code>KErrWrite</code> if not all data could be written

   414      *  - <code>KErrBadName</code> if the filename is bad

   415      *  - <code>KErrDirFull</code> if the directory is full

   416      * 

   417      * @param aObserver  observer to be notified of the processing status

   418      * @param aFileName  name of the file to be written

   419      */

   420     void ProcessL(const TDesC& aFileName,

   421                            MVedMovieProcessingObserver& aObserver);

   422 

   423     /**

   424      * Cancels the current video processing operation. If there is no 

   425      * operation in progress, the function does nothing.

   426      */

   427     void CancelProcessing();

   428 

   429 

   430     /* Observer methods. */

   431 

   432     /**

   433      * Registers a movie observer. Panics with panic code 

   434      * <code>EMovieObserverAlreadyRegistered</code> if the movie observer is 

   435      * already registered.

   436      *

   437      * @param aObserver  observer that will receive the events

   438      */

   439     void RegisterMovieObserverL(MVedMovieObserver* aObserver);

   440 

   441     /**

   442      * Unregisters a movie observer.

   443      *

   444      * @param aObserver  observer to be unregistered

   445      */

   446     void UnregisterMovieObserver(MVedMovieObserver* aObserver);

   447 

   448     /* Video Clip Methods */

   449     /**

   450      * Returns a video clip info object to get detailed information about

   451      * the original video clip. Note that the specified editing operations 

   452      * (for example, cutting or muting audio) do <em>not</em>

   453      * affect the values returned by the info object.

   454      * 

   455      * @param aIndex  index of video clip in movie

   456      * @return  pointer to a video clip info instance

   457      */

   458     CVedVideoClipInfo* VideoClipInfo(TInt aIndex) const;

   459 

   460     /**

   461      * Returns whether this video clip with the specified editing operations 

   462      * applied (for example, changing speed or muting) has an audio track or not.

   463      *

   464      * @param aIndex  index of video clip in movie

   465      * @return  <code>ETrue</code> if clip has an audio track;

   466      *          <code>EFalse</code> otherwise

   467      */

   468     TBool VideoClipEditedHasAudio(TInt aIndex) const;

   469 

   470     /**

   471      * Sets the index of this video clip in the movie. 

   472      * Panics with code <code>EVideoClipIllegalIndex</code> 

   473      * if the clip index is invalid.

   474      *

   475      * @param aIndex  index of video clip in movie

   476      * @param aNewIndex  new index of this clip

   477      */

   478     void VideoClipSetIndex(TInt aOldIndex, TInt aNewIndex);

   479 

   480     /**

   481      * Returns the playback speed of this video clip. Playback speed is

   482      * specified as parts per thousand of the normal playback speed. For example.

   483      * 1000 means the normal speed, 750 means 75% of the normal speed, and so on.

   484      *

   485      * @param aIndex  index of video clip in movie

   486      * @return  playback speed

   487      */

   488     TInt VideoClipSpeed(TInt aIndex) const;

   489 

   490     /**

   491      * Sets the playback speed of this video clip. Playback speed is

   492      * specified as parts per thousand of the normal playback speed. For example.

   493      * 1000 means the normal speed, 750 means 75% of the normal speed, and so on.

   494      * Panics with <code>EVideoClipIllegalSpeed</code> if playback speed is

   495      * illegal.

   496      *

   497      * @param aIndex  index of video clip in movie

   498      * @param aSpeed  playback speed; must be between 1 and 1000

   499      */

   500     void VideoClipSetSpeed(TInt aIndex, TInt aSpeed);

   501 

   502     /**

   503      * Returns the color effect of this video clip.

   504      *

   505      * @param aIndex  index of video clip in movie

   506      * @return  color effect

   507      */

   508     TVedColorEffect VideoClipColorEffect(TInt aIndex) const;

   509     

   510     /**

   511      * Sets the color effect of this video clip.

   512      *

   513      * @param aIndex  index of video clip in movie

   514      * @param aColorEffect  color effect

   515      */

   516     void VideoClipSetColorEffect(TInt aIndex, TVedColorEffect aColorEffect);

   517 

   518     /**

   519      * Returns whether this video clip can be muted or not (that is,

   520      * whether the mute setting has any effect). For example, if

   521      * this video clip has no audio track, it can never have audio

   522      * even if the mute setting is false.

   523      *

   524      * @param aIndex  index of video clip in movie

   525      * @return  <code>ETrue</code> if this video clip can be muted;

   526      *          <code>EFalse</code> otherwise

   527      */

   528     TBool VideoClipIsMuteable(TInt aIndex) const;

   529 

   530     /**

   531      * Returns whether the audio track of this video clip is muted or not.

   532      *

   533      * @param aIndex  index of video clip in movie

   534      * @return  <code>ETrue</code> if the audio track is muted;

   535      *          <code>EFalse</code> otherwise

   536      */

   537     TBool VideoClipIsMuted(TInt aIndex) const;

   538 

   539     /**

   540      * Sets whether the audio track of this video clip is muted or not.

   541      *

   542      * @param aIndex  index of video clip in movie

   543      * @param aVolume  <code>ETrue</code> to mute the audio track;

   544      *                 <code>EFalse</code> not to mute the audio track

   545      */

   546     void VideoClipSetMuted(TInt aIndex, TBool aMuted);

   547 

   548     /**

   549      * Returns whether the audio track of this video clip is normalized or not.

   550      *

   551      * @param aIndex  index of video clip in movie

   552      * @return  <code>ETrue</code> if the audio track is normalized;

   553      *          <code>EFalse</code> otherwise

   554      */

   555     TBool VideoClipNormalizing(TInt aIndex) const;

   556 

   557     /**

   558      * Sets whether the audio track of this video clip is normalized or not.

   559      *

   560      * @param aIndex  index of video clip in movie

   561      * @param aVolume  <code>ETrue</code> to normalize the audio track;

   562      *                 <code>EFalse</code> not to normalize the audio track

   563      */

   564     void VideoClipSetNormalizing(TInt aIndex, TBool aNormalizing);

   565 

   566     /**

   567      * Inserts a new dynamic level mark to the video clip. The mark timing

   568      * must be within the time boundaries of the video clip.

   569      *

   570      * @param aIndex  index of the video clip

   571      * @param aMark   dynamic level mark to be inserted

   572      */

   573     void VideoClipInsertDynamicLevelMarkL(TInt aIndex, TVedDynamicLevelMark aMark);

   574     

   575     /**

   576      * Removes the specified dynamic level mark from the specified video clip.

   577      * The mark index must be between 0 and number of dynamic level marks in the clip.

   578      *

   579      * @param aClipIndex  index of the video clip

   580      * @param aMarkIndex  index of the mark to be removed

   581      */

   582     void VideoClipRemoveDynamicLevelMark(TInt aClipIndex, TInt aMarkIndex);

   583 

   584     /**

   585      * Returns the number of dynamic level marks in the specified video clip.

   586      * 

   587      * @param aIndex  index of the video clip

   588      */

   589     TInt VideoClipDynamicLevelMarkCount(TInt aIndex) const;

   590 

   591     /**

   592      * Returns the specified dynamic level mark from the specified video clip.

   593      * 

   594      * @param aClipIndex  index of the video clip

   595      * @param aMarkIndex  index of the dynamic level mark

   596      */    

   597     TVedDynamicLevelMark VideoClipDynamicLevelMark(TInt aClipIndex, TInt aMarkIndex);

   598 

   599     /**

   600      * Returns the cut in time of this video clip in clip timebase.

   601      *

   602      * @param aIndex  index of video clip in movie

   603      * @return  cut in time in microseconds in clip timebase

   604      */

   605     TTimeIntervalMicroSeconds VideoClipCutInTime(TInt aIndex) const;

   606 

   607     /**

   608      * Sets the cut in time of this video clip in clip timebase.

   609      * Panics with <code>EVideoClipIllegalCutInTime</code> if

   610      * cut in time is illegal.

   611      *

   612      * @param aIndex  index of video clip in movie

   613      * @param aCutInTime  cut in time in microseconds in clip timebase

   614      */

   615     void VideoClipSetCutInTime(TInt aIndex, TTimeIntervalMicroSeconds aCutInTime);

   616 

   617     /**

   618      * Returns the cut out time of this video clip in clip timebase.

   619      *

   620      * @return  cut out time in microseconds in clip timebase

   621      */

   622     TTimeIntervalMicroSeconds VideoClipCutOutTime(TInt aIndex) const;

   623 

   624     /**

   625      * Sets the cut out time of this video clip in clip timebase. 

   626      * Panics with <code>EVideoClipIllegalCutOutTime</code> if

   627      * cut out time is illegal.

   628      *

   629      * @param aIndex  index of video clip in movie

   630      * @param aCutOutTime  cut out time in microseconds in clip timebase

   631      */

   632     void VideoClipSetCutOutTime(TInt aIndex, TTimeIntervalMicroSeconds aCutOutTime);

   633 

   634     /**

   635      * Returns the start time of this video clip in movie timebase.

   636      *

   637      * @param aIndex  index of video clip in movie

   638      * @return  start time in microseconds in movie timebase

   639      */

   640     TTimeIntervalMicroSeconds VideoClipStartTime(TInt aIndex) const;

   641 

   642     /**

   643      * Returns the end time of this video clip in movie timebase.

   644      *

   645      * @param aIndex  index of video clip in movie

   646      * @return  end time in microseconds in movie timebase

   647      */

   648     TTimeIntervalMicroSeconds VideoClipEndTime(TInt aIndex) const;

   649 

   650     /**

   651      * Returns the duration of this video clip with the specified

   652      * editing operations applied (for example, cutting 

   653      * and changing speed)

   654      * 

   655      * @param aIndex  index of video clip in movie

   656      * @return  duration in microseconds

   657      */

   658     TTimeIntervalMicroSeconds VideoClipEditedDuration(TInt aIndex) const;

   659 

   660     /* Audio Clip Methods */

   661     /**

   662      * Returns an audio clip info object to get detailed information about

   663      * the original audio clip. Note that the specified editing operations 

   664      * (for example, changing duration) do <em>not</em>

   665      * affect the values returned by the info object.

   666      * 

   667      * @param aIndex  index of audio clip in movie

   668      * @return  pointer to an audio clip info instance

   669      */

   670     CVedAudioClipInfo* AudioClipInfo(TInt aIndex) const;

   671 

   672     /**

   673      * Returns the start time of this audio clip in movie timebase.

   674      *

   675      * @param aIndex  index of audio clip in movie

   676      * @return  start time in microseconds in movie timebase

   677      */

   678     TTimeIntervalMicroSeconds AudioClipStartTime(TInt aIndex) const;

   679 

   680     /**

   681      * Sets the start time of this audio clip in movie timebase. 

   682      * Also updates the end time. Duration remains unchanged.

   683      * Note that since the audio clips are ordered based on their

   684      * start times, the index of the clip may change as a result

   685      * of changing the start time.

   686      *

   687      * @param aIndex  index of audio clip in movie

   688      * @param aStartTime  start time in microseconds in movie timebase

   689      */

   690     void AudioClipSetStartTime(TInt aIndex, TTimeIntervalMicroSeconds aStartTime);

   691 

   692     /**

   693      * Returns the end time of this audio clip in movie timebase.

   694      *

   695      * @param aIndex  index of audio clip in movie

   696      * @return  end time in microseconds in movie timebase

   697      */

   698     TTimeIntervalMicroSeconds AudioClipEndTime(TInt aIndex) const;

   699 

   700     /**

   701      * Returns the duration of the selected part of this clip.

   702      * 

   703      * @param aIndex  index of audio clip in movie

   704      * @return  duration in microseconds

   705      */

   706     TTimeIntervalMicroSeconds AudioClipEditedDuration(TInt aIndex) const;

   707 

   708     /**

   709      * Returns the cut in time of this audio clip in clip timebase.

   710      *

   711      * @param aIndex  index of audio clip in movie

   712      * @return  cut in time in microseconds in clip timebase

   713      */

   714     TTimeIntervalMicroSeconds AudioClipCutInTime(TInt aIndex) const;

   715 

   716     /**

   717      * Sets the cut in time of this audio clip in clip timebase.

   718      * Panics with <code>EAudioClipIllegalCutInTime</code> if

   719      * cut in time is illegal.

   720      *

   721      * @param aIndex  index of audio clip in movie

   722      * @param aCutInTime  cut in time in microseconds in clip timebase

   723      */

   724     void AudioClipSetCutInTime(TInt aIndex, TTimeIntervalMicroSeconds aCutInTime);

   725 

   726     /**

   727      * Returns the cut out time of this audio clip in clip timebase.

   728      *

   729      * @param aIndex  index of audio clip in movie

   730      * @return  cut out time in microseconds in clip timebase

   731      */

   732     TTimeIntervalMicroSeconds AudioClipCutOutTime(TInt aIndex) const;

   733 

   734     /**

   735      * Sets the cut out time of this audio clip in clip timebase.

   736      * Panics with <code>EAudioClipIllegalCutOutTime</code> if

   737      * cut in time is illegal.

   738      *

   739      * @param aIndex  index of audio clip in movie

   740      * @param aCutOutTime  cut out time in microseconds in clip timebase

   741      */

   742     void AudioClipSetCutOutTime(TInt aIndex, TTimeIntervalMicroSeconds aCutOutTime);

   743 

   744     /**

   745      * Returns whether this audio clip is normalized or not.

   746      *

   747      * @param aIndex  index of audio clip in movie

   748      * @return  <code>ETrue</code> if the audio clip is normalized;

   749      *          <code>EFalse</code> otherwise

   750      */

   751     TBool AudioClipNormalizing(TInt aIndex) const;

   752 

   753     /**

   754      * Sets whether this audio clip is normalized or not.

   755      *

   756      * @param aIndex  index of audio clip in movie

   757      * @param aVolume  <code>ETrue</code> to normalize the audio clip;

   758      *                 <code>EFalse</code> not to normalize the audio clip

   759      */

   760     void AudioClipSetNormalizing(TInt aIndex, TBool aNormalizing);

   761     

   762     /**

   763      * Inserts a new dynamic level mark to the audio clip. The mark timing

   764      * must be within the time boundaries of the audio clip.

   765      *

   766      * @param aIndex  index of the audio clip

   767      * @param aMark   dynamic level mark to be inserted

   768      */

   769     void AudioClipInsertDynamicLevelMarkL(TInt aIndex, TVedDynamicLevelMark aMark);

   770     

   771     /**

   772      * Removes the specified dynamic level mark from the specified audio clip.

   773      * The mark index must be between 0 and number of dynamic level marks in the clip.

   774      *

   775      * @param aClipIndex  index of the audio clip

   776      * @param aMarkIndex  index of the mark to be removed

   777      */

   778     void AudioClipRemoveDynamicLevelMark(TInt aClipIndex, TInt aMarkIndex);

   779 

   780     /**

   781      * Returns the number of dynamic level marks in the specified audio clip.

   782      * 

   783      * @param aIndex  index of the audio clip

   784      */

   785     TInt AudioClipDynamicLevelMarkCount(TInt aIndex) const;

   786 

   787     /**

   788      * Returns the specified dynamic level mark from the specified audio clip.

   789      * 

   790      * @param aClipIndex  index of the audio clip

   791      * @param aMarkIndex  index of the dynamic level mark

   792      */    

   793     TVedDynamicLevelMark AudioClipDynamicLevelMark(TInt aClipIndex, TInt aMarkIndex);

   794     

   795     /**

   796      * Returns the color tone of the specified clip.

   797      *

   798      * @return color tone

   799      */

   800     TRgb VideoClipColorTone(TInt aVideoCLipIndex) const;

   801     

   802     /**

   803      * Sets the color tone of the specified clip.

   804      *

   805      * @param aColorTone  color tone

   806      */

   807     void VideoClipSetColorTone(TInt aVideoClipIndex, TRgb aColorTone);

   808     

   809     /**

   810      * Returns a pointer to the audio song used as the sound provider for

   811      * this movie.

   812      * 

   813      * @return  song

   814      */

   815     CAudSong* Song();

   816     

   817     /**

   818      * Sets the maximum size for the movie

   819      * 

   820      * @param aLimit Maximum size in bytes

   821      */

   822     virtual void SetMovieSizeLimit(TInt aLimit);

   823     

   824     /**

   825      * Returns an estimate for total processing time

   826      * 

   827      * @return processing time

   828      */

   829     TTimeIntervalMicroSeconds GetProcessingTimeEstimateL();

   830     

   831     /**

   832      * Returns the MIME-type for the video in the movie

   833      * 

   834      * @return Video codec MIME-type

   835      */

   836     TPtrC8& VideoCodecMimeType();

   837     /**

   838     * Gets the sync interval in picture (H.263 GOB frequency)

   839     * 

   840     * @return sync interval 

   841     */

   842     TInt SyncIntervalInPicture();

   843     

   844     /**

   845     * Gets the random access rate

   846     * 

   847     * @return random access rate in pictures per second

   848     */

   849     TReal RandomAccessRate();

   850     

   851     /**

   852      * Checks if a movie observer is registered.

   853      *

   854      * @param aObserver observer to be checked

   855      * @return <code>ETrue</code> if the observer is registered

   856      *         <code>EFalse</code> otherwise

   857      */

   858     TBool MovieObserverIsRegistered(MVedMovieObserver* aObserver);

   859 

   860     /**

   861     * Set volume gain for the given video clip or all the video clips

   862     * @param aClipIndex    index of the clip; KVedClipIndexAll if applied for all the clips

   863     * @param aVolumeGain   Volume gain in +0.1 or -0.5 decibel steps

   864     * 

   865     */

   866     void SetVideoClipVolumeGainL(TInt aClipIndex, TInt aVolumeGain);

   867 

   868     /**

   869     * Get volume gain of the given video clip or all the video clips

   870     * @param aClipIndex    index of the clip; KVedClipIndexAll if applied for all the clips

   871     *

   872     * @return Volume gain in +0.1 or -0.5 decibel steps

   873     */

   874     TInt GetVideoClipVolumeGainL(TInt aClipIndex);

   875 

   876     /**

   877     * Set volume gain for the given audio clip or all the audio clips

   878     * @param aClipIndex    index of the clip; KVedClipIndexAll if applied for all the clips

   879     * @param aVolumeGain   Volume gain in +0.1 or -0.5 decibel steps 

   880     * 

   881     */

   882     void SetAudioClipVolumeGainL(TInt aClipIndex, TInt aVolumeGain);

   883 

   884     /**

   885     * Get volume gain of the given audio clip or all the audio clips

   886     * @param aClipIndex    index of the clip; KVedClipIndexAll if applied for all the clips

   887     *

   888     * @return Volume gain in +0.1 or -0.5 decibel steps

   889     */

   890     TInt GetAudioClipVolumeGainL(TInt aClipIndex);

   891     

   892     /** 

   893      * Inserts a video clip from the specified file to the specified index 

   894      * in this movie. The observers are notified when the clip has been added 

   895      * or adding clip has failed. Panics with <code>EMovieAddOperationAlreadyRunning</code> 

   896      * if another add video or audio clip operation is already running.

   897      * Panics with code <code>USER-130</code> if the clip index is invalid.

   898      * The file will be opened in EFileShareReadersOnly mode by default, 

   899      * and the same mode should be used by the client too if it need to open

   900      * the file at the same time.

   901      *  

   902      * Possible leave codes:

   903      *  - <code>KErrNoMemory</code> if memory allocation fails

   904      *

   905      * @param aFileHandle  file handle of the clip to add

   906      * @param aIndex     index the clip should be inserted at

   907      */    

   908     void InsertVideoClipL(RFile* aFileHandle, TInt aIndex);

   909     

   910     /** 

   911      * Adds the specified audio clip to this movie. The observers are notified

   912      * when the clip has been added or adding clip has failed. Panics with 

   913      * <code>EMovieAddOperationAlreadyRunning</code> if another add video or

   914      * audio clip operation is already running.

   915      * The file will be opened in EFileShareReadersOnly mode by default, 

   916      * and the same mode should be used by the client too if it need to open

   917      * the file at the same time.

   918      * 

   919      * Possible leave codes:

   920      *  - <code>KErrNoMemory</code> if memory allocation fails

   921      *

   922      * @param aFilehandle   file handle of the clip to add

   923      * @param aStartTime  start time of the clip in movie timebase

   924      * @param aCutInTime  cut in time of the clip

   925      * @param aCutOutTime cut out time of the clip; or 

   926      *                    <code>KVedAudioClipOriginalDuration</code> to specify

   927      *                    that the original duration of the clip should be used

   928      */    

   929     void AddAudioClipL(RFile* aFileHandle,

   930             TTimeIntervalMicroSeconds aStartTime,

   931             TTimeIntervalMicroSeconds aCutInTime = TTimeIntervalMicroSeconds(0),

   932             TTimeIntervalMicroSeconds aCutOutTime = KVedAudioClipOriginalDuration);

   933     

   934      

   935     /**

   936      * Starts a video processing operation. This method is asynchronous and 

   937      * returns immediately. The processing will happen in the background and

   938      * the observer will be notified about the progress of the operation.

   939      * Processed data is written into the specified file. Panics with 

   940      * <code>TVedPanic::EMovieEmpty</code> if there are no clips 

   941      * in the movie. Note that calling <code>ProcessL</code> may cause

   942      * changes in the maximum frame rates of generated clips.

   943      * 

   944      * Possible leave codes:

   945      *  - <code>KErrNoMemory</code> if memory allocation fails

   946      *  - <code>KErrAccessDenied</code> if the file access is denied

   947      *  - <code>KErrDiskFull</code> if the disk is full

   948      *  - <code>KErrWrite</code> if not all data could be written

   949      *  - <code>KErrBadName</code> if the filename is bad

   950      *  - <code>KErrDirFull</code> if the directory is full

   951      * 

   952      * @param aObserver  observer to be notified of the processing status

   953      * @param aFileHandle  handle of the file to be written

   954      */

   955     void ProcessL(RFile* aFileHandle,

   956                            MVedMovieProcessingObserver& aObserver);

   957 

   958 private:

   959     /* Movie editing methods. */

   960 

   961     /**

   962      * Match the selected audio properties with input. This is used with automatic

   963      * quality to avoid useless transcoding of audio. 

   964      */

   965     TBool MatchAudioPropertiesWithInput( TAudFileProperties& aAudioProperties );

   966 

   967     /**

   968      * Calculates the format, video type, resolution and audio type of 

   969      * this movie. 

   970      */

   971     void CalculatePropertiesL();

   972 

   973     /**

   974      * Determines the output format based on input and sets up the movie accordingly

   975      */

   976     void ApplyAutomaticPropertiesL(TAudFileProperties &aAudioProperties);

   977     

   978     /**

   979      * Sets up the movie according to requested properties

   980      */

   981     void ApplyRequestedPropertiesL(TAudFileProperties &aAudioProperties);

   982     

   983     /**

   984      * Get properties for QCIF/subQCIF from quality set and sets up video

   985      */

   986     TInt GetQCIFPropertiesL(SVideoQualitySet& aLocalQualitySet);

   987     

   988     /**

   989      * Get properties for CIF/QVGA from quality set and sets up video

   990      */

   991     TInt GetCIFQVGAPropertiesL(TSize aSize, TReal aFrameRate, SVideoQualitySet& aLocalQualitySet);

   992     

   993     /**

   994      * Get properties for VGA from quality set and sets up video

   995      */

   996     TInt GetVGAPropertiesL(SVideoQualitySet& aLocalQualitySet);

   997     

   998     /**

   999      * Get properties for VGA 16:9 from quality set and sets up video

  1000      */

  1001     TInt GetVGA16By9PropertiesL(SVideoQualitySet& aLocalQualitySet);

  1002     

  1003     /**

  1004     * Get properties for VGA from quality set and sets up video

  1005     */

  1006     TInt GetWVGAPropertiesL(SVideoQualitySet& aLocalQualitySet);

  1007     

  1008     /**

  1009      * Get properties for high quality from quality set

  1010      */

  1011     TInt GetHighPropertiesL(SVideoQualitySet& aLocalQualitySet);

  1012     

  1013     /**

  1014      * Creates temporary instance of CTRTranscoder and asks for complexity factor estimate

  1015      * when converting given video clip to movie with set parameters.

  1016      * The estimate represents how long processing of 1 sec input takes.

  1017      */

  1018     TReal AskComplexityFactorFromTranscoderL(CVedVideoClipInfo* aInfo, CTRTranscoder::TTROperationalMode aMode, TReal aInputFrameRate);

  1019     

  1020     /**

  1021      * Checks whether the specified video clip can be inserted to this movie.

  1022      *

  1023      * @param aClip  video clip

  1024      *

  1025      * @return  <code>KErrNone</code>, if the clip can be inserted; 

  1026      *          one of the system wide error codes, otherwise

  1027      */

  1028     TInt CheckVideoClipInsertable(CVedVideoClip *aClip) const;

  1029 

  1030     /**

  1031      * Calculates the maximum and minimum resolution supported by this movie.

  1032      *

  1033      * @param aMaxRes       initial upper limit for the maximum resolution; 

  1034      *                      after the method returns, contains the calculated

  1035      *                      maximum resolution supported by this movie

  1036      * @param aMinRes       initial lower limit for the minimum resolution; 

  1037      *                      after the method returns, contains the calculated

  1038      *                      minimum resolution supported by this movie

  1039      * @param aDoFullCheck  <code>ETrue</code>, if all clips should be

  1040      *                      checked to verify that they can be combined

  1041      *                      (not necessary but useful for detecting internal 

  1042      *                      errors); <code>EFalse</code>, if extra checks 

  1043      *                      should be skipped to minimize execution time

  1044      */

  1045     void CalculateMaxAndMinResolution(TSize& aMaxRes, TSize& aMinRes,

  1046                                       TBool aDoFullCheck) const;

  1047 

  1048     /**

  1049      * Recalculates video clip timings.

  1050      *

  1051      * @param aVideoClip  Video clip

  1052      */

  1053     void RecalculateVideoClipTimings(CVedVideoClip* aVideoClip);    

  1054 

  1055     /**

  1056      * Reset the movie. 

  1057      */

  1058     void DoReset();

  1059     

  1060     /**

  1061      * Set audio fade in/out on clip boundaries

  1062      */

  1063     void SetAudioFadingL();

  1064     

  1065     /**

  1066      * Internal helper function to set iVideoCodecMimeType to given value

  1067      */

  1068     void SetVideoCodecMimeType(const TText8* aVideoCodecType);

  1069 

  1070     /* Notification methods. */

  1071 

  1072     /**

  1073      * Notify observers that the video clip has been added to movie.

  1074      *

  1075      * @param aMovie This movie.

  1076      * @param aClip Added video clip.

  1077      */

  1078     void FireVideoClipAdded(CVedMovie* aMovie, CVedVideoClip* aClip);

  1079 

  1080     /**

  1081      * Notify observers that the adding of video clip failed.

  1082      *

  1083      * @param 

  1084      */

  1085     void FireVideoClipAddingFailed(CVedMovie* aMovie, TInt aError);

  1086 

  1087     /**

  1088      * Notify observers that the video clip has been removed from movie.

  1089      *

  1090      * @param aMovie This movie.

  1091      * @param aIndex Index of removed video clip.

  1092      */

  1093     void FireVideoClipRemoved(CVedMovie* aMovie, TInt aIndex);

  1094 

  1095     /**

  1096      * Notify observers that the video clip indices has changes.

  1097      *

  1098      * @param aMovie This movie.

  1099      * @param aOldIndex Old index of video clip.

  1100      * @param aNewIndex New index of video clip.

  1101      */

  1102     void FireVideoClipIndicesChanged(CVedMovie* aMovie, TInt aOldIndex, 

  1103                                      TInt aNewIndex);

  1104 

  1105     /**

  1106      * Notify observers that the video clip timings has been changed.

  1107      *

  1108      * @param aMovie This movie.

  1109      * @param aClip The video clip.

  1110      */

  1111     void FireVideoClipTimingsChanged(CVedMovie* aMovie, CVedVideoClip* aClip);

  1112 

  1113     /**

  1114      * Notify observers that the color effect of video clip has been changed.

  1115      *

  1116      * @param aMovie This movie.

  1117      * @param aClip Video clip that was changed.

  1118      */

  1119     void FireVideoClipColorEffectChanged(CVedMovie* aMovie, CVedVideoClip* aClip);

  1120 

  1121     /**

  1122      * Notify observers that the audio settings of video clip has been changed.

  1123      *

  1124      * @param aMovie This movie.

  1125      * @param aClip Video clip that audio settings has been changed.

  1126      */

  1127     void FireVideoClipAudioSettingsChanged(CVedMovie* aMovie, CVedVideoClip* aClip);

  1128 

  1129     /**

  1130      * Notify observers that the generator settings of video clip has been changed.

  1131      *

  1132      * @param aMovie This movie.

  1133      * @param aClip  Video clip whose settings has been changed

  1134      */