← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/quicktime/apple/quicktime_export.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/quicktime/apple/quicktime_export.c
1
1
/*
2
 
 *
3
 
 * quicktime_export.c
4
 
 *
5
 
 * Code to create QuickTime Movies with Blender
6
 
 *
7
2
 * ***** BEGIN GPL LICENSE BLOCK *****
8
3
 * This program is free software; you can redistribute it and/or
9
4
 * modify it under the terms of the GNU General Public License
29
24
 
30
25
/** \file blender/quicktime/apple/quicktime_export.c
31
26
 *  \ingroup quicktime
 
27
 *
 
28
 * Code to create QuickTime Movies with Blender
32
29
 */
33
30
 
34
31
 
82
79
#include <sys/stat.h> /* file permissions */
83
80
#endif /* __APPLE__ */
84
81
 
85
 
#define kMyCreatorType  FOUR_CHAR_CODE('TVOD')
86
 
#define kTrackStart             0
87
 
#define kMediaStart             0
 
82
#define kMyCreatorType  FOUR_CHAR_CODE('TVOD')
 
83
#define kTrackStart     0
 
84
#define kMediaStart     0
88
85
 
89
 
static void QT_StartAddVideoSamplesToMedia (const Rect *trackFrame, int rectx, int recty, struct ReportList *reports);
90
 
static void QT_DoAddVideoSamplesToMedia (int frame, int *pixels, int rectx, int recty, struct ReportList *reports);
91
 
static void QT_EndAddVideoSamplesToMedia (void);
92
 
static void QT_CreateMyVideoTrack (int rectx, int recty, struct ReportList *reports);
93
 
static void QT_EndCreateMyVideoTrack (struct ReportList *reports);
 
86
static void QT_StartAddVideoSamplesToMedia(const Rect *trackFrame, int rectx, int recty, struct ReportList *reports);
 
87
static void QT_DoAddVideoSamplesToMedia(int frame, int *pixels, int rectx, int recty, struct ReportList *reports);
 
88
static void QT_EndAddVideoSamplesToMedia(void);
 
89
static void QT_CreateMyVideoTrack(int rectx, int recty, struct ReportList *reports);
 
90
static void QT_EndCreateMyVideoTrack(struct ReportList *reports);
94
91
static void check_renderbutton_framerate(struct RenderData *rd, struct ReportList *reports);
95
92
static int get_qtcodec_settings(struct RenderData *rd, struct ReportList *reports);
96
93
 
97
94
typedef struct QuicktimeExport {
98
95
 
99
 
        FSSpec          theSpec;
100
 
        short           resRefNum;
101
 
        Str255          qtfilename;
102
 
 
103
 
        Media           theMedia;
104
 
        Movie           theMovie;
105
 
        Track           theTrack;
106
 
 
107
 
        GWorldPtr                       theGWorld;
108
 
        PixMapHandle            thePixMap;
109
 
        ImageDescription        **anImageDescription;
110
 
 
111
 
        ImBuf           *ibuf;  //imagedata for Quicktime's Gworld
112
 
        ImBuf           *ibuf2; //copy of renderdata, to be Y-flipped
 
96
        FSSpec theSpec;
 
97
        short resRefNum;
 
98
        Str255 qtfilename;
 
99
 
 
100
        Media theMedia;
 
101
        Movie theMovie;
 
102
        Track theTrack;
 
103
 
 
104
        GWorldPtr theGWorld;
 
105
        PixMapHandle thePixMap;
 
106
        ImageDescription    **anImageDescription;
 
107
 
 
108
        ImBuf       *ibuf;   /* imagedata for Quicktime's Gworld */
 
109
        ImBuf       *ibuf2;  /* copy of renderdata, to be Y-flipped */
113
110
 
114
111
} QuicktimeExport;
115
112
 
116
113
typedef struct QuicktimeComponentData {
117
114
 
118
 
        ComponentInstance       theComponent;
 
115
        ComponentInstance   theComponent;
119
116
        SCTemporalSettings  gTemporalSettings;
120
117
        SCSpatialSettings   gSpatialSettings;
121
118
        SCDataRateSettings  aDataRateSetting;
122
 
        TimeValue                       duration;
123
 
        long                            kVideoTimeScale;
 
119
        TimeValue           duration;
 
120
        long                kVideoTimeScale;
124
121
 
125
122
} QuicktimeComponentData;
126
123
 
127
124
static struct QuicktimeExport *qtexport;
128
125
static struct QuicktimeComponentData *qtdata;
129
126
 
130
 
static int      sframe;
 
127
static int sframe;
131
128
 
132
129
/* RNA functions */
133
130
 
144
141
        {kMPEG4VisualCodecType, 10, "MPEG4"},
145
142
        {kH263CodecType, 11, "H.263"},
146
143
        {kH264CodecType, 12, "H.264"},
147
 
        {0,0,NULL}};
 
144
        {0, 0, NULL}
 
145
};
148
146
 
149
147
static int qtVideoCodecCount = 12;
150
148
 
153
151
        return qtVideoCodecCount;
154
152
}
155
153
 
156
 
QuicktimeCodecTypeDesc* quicktime_get_videocodecType_desc(int indexValue)
 
154
QuicktimeCodecTypeDesc *quicktime_get_videocodecType_desc(int indexValue)
157
155
{
158
 
        if ((indexValue>=0) && (indexValue < qtVideoCodecCount))
 
156
        if ((indexValue >= 0) && (indexValue < qtVideoCodecCount))
159
157
                return &qtVideoCodecList[indexValue];
160
158
        else
161
159
                return NULL;
164
162
int quicktime_rnatmpvalue_from_videocodectype(int codecType)
165
163
{
166
164
        int i;
167
 
        for (i=0;i<qtVideoCodecCount;i++) {
 
165
        for (i = 0; i < qtVideoCodecCount; i++) {
168
166
                if (qtVideoCodecList[i].codecType == codecType)
169
167
                        return qtVideoCodecList[i].rnatmpvalue;
170
168
        }
175
173
int quicktime_videocodecType_from_rnatmpvalue(int rnatmpvalue)
176
174
{
177
175
        int i;
178
 
        for (i=0;i<qtVideoCodecCount;i++) {
 
176
        for (i = 0; i < qtVideoCodecCount; i++) {
179
177
                if (qtVideoCodecList[i].rnatmpvalue == rnatmpvalue)
180
178
                        return qtVideoCodecList[i].codecType;
181
179
        }
182
180
        
183
 
        return 0;       
 
181
        return 0;
184
182
}
185
183
 
186
184
 
195
193
 
196
194
static OSErr QT_SaveCodecSettingsToScene(RenderData *rd, ReportList *reports)
197
195
{       
198
 
        QTAtomContainer         myContainer = NULL;
199
 
        ComponentResult         myErr = noErr;
200
 
        Ptr                                     myPtr;
201
 
        long                            mySize = 0;
 
196
        QTAtomContainer  myContainer = NULL;
 
197
        ComponentResult  myErr = noErr;
 
198
        Ptr              myPtr;
 
199
        long             mySize = 0;
202
200
 
203
 
        CodecInfo                       ci;
 
201
        CodecInfo        ci;
204
202
 
205
203
        QuicktimeCodecData *qcd = rd->qtcodecdata;
206
204
        
207
 
        // check if current scene already has qtcodec settings, and clear them
 
205
        /* check if current scene already has qtcodec settings, and clear them */
208
206
        if (qcd) {
209
207
                free_qtcodecdata(qcd);
210
208
        }
212
210
                qcd = rd->qtcodecdata = MEM_callocN(sizeof(QuicktimeCodecData), "QuicktimeCodecData");
213
211
        }
214
212
 
215
 
        // obtain all current codec settings
216
 
        SCSetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
217
 
        SCSetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
218
 
        SCSetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
213
        /* obtain all current codec settings */
 
214
        SCSetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
 
215
        SCSetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
216
        SCSetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
219
217
 
220
 
        // retreive codecdata from quicktime in a atomcontainer
 
218
        /* retreive codecdata from quicktime in a atomcontainer */
221
219
        myErr = SCGetSettingsAsAtomContainer(qtdata->theComponent,  &myContainer);
222
220
        if (myErr != noErr) {
223
 
                BKE_reportf(reports, RPT_ERROR, "Quicktime: SCGetSettingsAsAtomContainer failed\n"); 
 
221
                BKE_report(reports, RPT_ERROR, "Quicktime: SCGetSettingsAsAtomContainer failed");
224
222
                goto bail;
225
223
        }
226
224
 
227
 
        // get the size of the atomcontainer
 
225
        /* get the size of the atomcontainer */
228
226
        mySize = GetHandleSize((Handle)myContainer);
229
227
 
230
 
        // lock and convert the atomcontainer to a *valid* pointer
 
228
        /* lock and convert the atomcontainer to a *valid* pointer */
231
229
        QTLockContainer(myContainer);
232
230
        myPtr = *(Handle)myContainer;
233
231
 
234
 
        // copy the Quicktime data into the blender qtcodecdata struct
 
232
        /* copy the Quicktime data into the blender qtcodecdata struct */
235
233
        if (myPtr) {
236
234
                qcd->cdParms = MEM_mallocN(mySize, "qt.cdParms");
237
235
                memcpy(qcd->cdParms, myPtr, mySize);
238
236
                qcd->cdSize = mySize;
239
237
 
240
 
                GetCodecInfo (&ci, qtdata->gSpatialSettings.codecType, 0);
 
238
                GetCodecInfo(&ci, qtdata->gSpatialSettings.codecType, 0);
241
239
        }
242
240
        else {
243
 
                BKE_reportf(reports, RPT_ERROR, "Quicktime: QT_SaveCodecSettingsToScene failed\n"); 
 
241
                BKE_report(reports, RPT_ERROR, "Quicktime: QT_SaveCodecSettingsToScene failed"); 
244
242
        }
245
243
 
246
244
        QTUnlockContainer(myContainer);
255
253
 
256
254
static OSErr QT_GetCodecSettingsFromScene(RenderData *rd, ReportList *reports)
257
255
{       
258
 
        Handle                          myHandle = NULL;
259
 
        ComponentResult         myErr = noErr;
 
256
        Handle           myHandle = NULL;
 
257
        ComponentResult  myErr = noErr;
260
258
 
261
259
        QuicktimeCodecData *qcd = rd->qtcodecdata;
262
260
 
263
 
        // if there is codecdata in the blendfile, convert it to a Quicktime handle 
 
261
        /* if there is codecdata in the blendfile, convert it to a Quicktime handle */
264
262
        if (qcd) {
265
263
                myHandle = NewHandle(qcd->cdSize);
266
 
                PtrToHand( qcd->cdParms, &myHandle, qcd->cdSize);
 
264
                PtrToHand(qcd->cdParms, &myHandle, qcd->cdSize);
267
265
        }
268
266
                
269
 
        // restore codecsettings to the quicktime component
 
267
        /* restore codecsettings to the quicktime component */
270
268
        if (qcd->cdParms && qcd->cdSize) {
271
269
                myErr = SCSetSettingsFromAtomContainer((GraphicsExportComponent)qtdata->theComponent, (QTAtomContainer)myHandle);
272
270
                if (myErr != noErr) {
273
 
                        BKE_reportf(reports, RPT_ERROR, "Quicktime: SCSetSettingsFromAtomContainer failed\n"); 
 
271
                        BKE_report(reports, RPT_ERROR, "Quicktime: SCSetSettingsFromAtomContainer failed");
274
272
                        goto bail;
275
273
                }
276
274
 
277
 
                // update runtime codecsettings for use with the codec dialog
278
 
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
279
 
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
280
 
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
281
 
 
282
 
 
283
 
                //Fill the render QuicktimeCodecSettigns struct
 
275
                /* update runtime codecsettings for use with the codec dialog */
 
276
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
277
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
278
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
 
279
 
 
280
 
 
281
                /* Fill the render QuicktimeCodecSettigns struct */
284
282
                rd->qtcodecsettings.codecTemporalQuality = (qtdata->gTemporalSettings.temporalQuality * 100) / codecLosslessQuality;
285
 
                //Do not override scene frame rate (qtdata->gTemporalSettings.framerate)
 
283
                /* Do not override scene frame rate (qtdata->gTemporalSettings.framerate) */
286
284
                rd->qtcodecsettings.keyFrameRate = qtdata->gTemporalSettings.keyFrameRate;
287
285
                
288
286
                rd->qtcodecsettings.codecType = qtdata->gSpatialSettings.codecType;
293
291
                rd->qtcodecsettings.bitRate = qtdata->aDataRateSetting.dataRate;
294
292
                rd->qtcodecsettings.minSpatialQuality = (qtdata->aDataRateSetting.minSpatialQuality * 100) / codecLosslessQuality;
295
293
                rd->qtcodecsettings.minTemporalQuality = (qtdata->aDataRateSetting.minTemporalQuality * 100) / codecLosslessQuality;
296
 
                //Frame duration is already known (qtdata->aDataRateSetting.frameDuration)
 
294
                /* Frame duration is already known (qtdata->aDataRateSetting.frameDuration) */
297
295
                
298
296
        }
299
297
        else {
300
 
                BKE_reportf(reports, RPT_ERROR, "Quicktime: QT_GetCodecSettingsFromScene failed\n"); 
 
298
                BKE_report(reports, RPT_ERROR, "Quicktime: QT_GetCodecSettingsFromScene failed");
301
299
        }
302
300
bail:
303
301
        if (myHandle != NULL)
307
305
}
308
306
 
309
307
 
310
 
static OSErr QT_AddUserDataTextToMovie (Movie theMovie, char *theText, OSType theType)
 
308
static OSErr QT_AddUserDataTextToMovie(Movie theMovie, char *theText, OSType theType)
311
309
{
312
 
        UserData                                        myUserData = NULL;
313
 
        Handle                                          myHandle = NULL;
314
 
        long                                            myLength = strlen(theText);
315
 
        OSErr                                           myErr = noErr;
 
310
        UserData  myUserData = NULL;
 
311
        Handle    myHandle = NULL;
 
312
        long      myLength = strlen(theText);
 
313
        OSErr     myErr = noErr;
316
314
 
317
 
        // get the movie's user data list
 
315
        /* get the movie's user data list */
318
316
        myUserData = GetMovieUserData(theMovie);
319
317
        if (myUserData == NULL)
320
318
                return(paramErr);
321
 
        
322
 
        // copy the specified text into a new handle
 
319
 
 
320
        /* copy the specified text into a new handle */
323
321
        myHandle = NewHandleClear(myLength);
324
322
        if (myHandle == NULL)
325
323
                return(MemError());
326
324
 
327
325
        BlockMoveData(theText, *myHandle, myLength);
328
326
 
329
 
        // add the data to the movie's user data
 
327
        /* add the data to the movie's user data */
330
328
        myErr = AddUserDataText(myUserData, myHandle, theType, 1, (short)GetScriptManagerVariable(smRegionCode));
331
329
 
332
 
        // clean up
 
330
        /* clean up */
333
331
        DisposeHandle(myHandle);
334
332
        return(myErr);
335
333
}
346
344
        trackFrame.bottom = recty;
347
345
        trackFrame.right = rectx;
348
346
        
349
 
        qtexport->theTrack = NewMovieTrack (qtexport->theMovie, 
350
 
                                                        FixRatio(trackFrame.right,1),
351
 
                                                        FixRatio(trackFrame.bottom,1), 
352
 
                                                        0);
353
 
        CheckError( GetMoviesError(), "NewMovieTrack error", reports );
354
 
 
355
 
//      SetIdentityMatrix(&myMatrix);
356
 
//      ScaleMatrix(&myMatrix, fixed1, Long2Fix(-1), 0, 0);
357
 
//      TranslateMatrix(&myMatrix, 0, Long2Fix(trackFrame.bottom));
358
 
//      SetMovieMatrix(qtexport->theMovie, &myMatrix);
359
 
 
360
 
        qtexport->theMedia = NewTrackMedia (qtexport->theTrack,
361
 
                                                        VideoMediaType,
362
 
                                                        qtdata->kVideoTimeScale,
363
 
                                                        nil,
364
 
                                                        0);
365
 
        CheckError( GetMoviesError(), "NewTrackMedia error", reports );
366
 
 
367
 
        err = BeginMediaEdits (qtexport->theMedia);
368
 
        CheckError( err, "BeginMediaEdits error", reports );
369
 
 
370
 
        QT_StartAddVideoSamplesToMedia (&trackFrame, rectx, recty, reports);
 
347
        qtexport->theTrack = NewMovieTrack(qtexport->theMovie,
 
348
                                           FixRatio(trackFrame.right, 1),
 
349
                                           FixRatio(trackFrame.bottom, 1),
 
350
                                           0);
 
351
        CheckError(GetMoviesError(), "NewMovieTrack error", reports);
 
352
 
 
353
        //      SetIdentityMatrix(&myMatrix);
 
354
        //      ScaleMatrix(&myMatrix, fixed1, Long2Fix(-1), 0, 0);
 
355
        //      TranslateMatrix(&myMatrix, 0, Long2Fix(trackFrame.bottom));
 
356
        //      SetMovieMatrix(qtexport->theMovie, &myMatrix);
 
357
 
 
358
        qtexport->theMedia = NewTrackMedia(qtexport->theTrack,
 
359
                                           VideoMediaType,
 
360
                                           qtdata->kVideoTimeScale,
 
361
                                           nil,
 
362
                                           0);
 
363
        CheckError(GetMoviesError(), "NewTrackMedia error", reports);
 
364
 
 
365
        err = BeginMediaEdits(qtexport->theMedia);
 
366
        CheckError(err, "BeginMediaEdits error", reports);
 
367
 
 
368
        QT_StartAddVideoSamplesToMedia(&trackFrame, rectx, recty, reports);
371
369
} 
372
370
 
373
371
 
375
373
{
376
374
        OSErr err = noErr;
377
375
 
378
 
        QT_EndAddVideoSamplesToMedia ();
379
 
 
380
 
        err = EndMediaEdits (qtexport->theMedia);
381
 
        CheckError( err, "EndMediaEdits error", reports );
382
 
 
383
 
        err = InsertMediaIntoTrack (qtexport->theTrack,
384
 
                                                                kTrackStart,/* track start time */
385
 
                                                                kMediaStart,/* media start time */
386
 
                                                                GetMediaDuration (qtexport->theMedia),
387
 
                                                                fixed1);
388
 
        CheckError( err, "InsertMediaIntoTrack error", reports );
 
376
        QT_EndAddVideoSamplesToMedia();
 
377
 
 
378
        err = EndMediaEdits(qtexport->theMedia);
 
379
        CheckError(err, "EndMediaEdits error", reports);
 
380
 
 
381
        err = InsertMediaIntoTrack(qtexport->theTrack,
 
382
                                   kTrackStart,  /* track start time */
 
383
                                   kMediaStart,  /* media start time */
 
384
                                   GetMediaDuration(qtexport->theMedia),
 
385
                                   fixed1);
 
386
        CheckError(err, "InsertMediaIntoTrack error", reports);
389
387
} 
390
388
 
391
389
 
392
 
static void QT_StartAddVideoSamplesToMedia (const Rect *trackFrame, int rectx, int recty, ReportList *reports)
 
390
static void QT_StartAddVideoSamplesToMedia(const Rect *trackFrame, int rectx, int recty, ReportList *reports)
393
391
{
394
392
        SCTemporalSettings gTemporalSettings;
395
393
        OSErr err = noErr;
396
394
 
397
 
        qtexport->ibuf = IMB_allocImBuf (rectx, recty, 32, IB_rect);
398
 
        qtexport->ibuf2 = IMB_allocImBuf (rectx, recty, 32, IB_rect);
 
395
        qtexport->ibuf = IMB_allocImBuf(rectx, recty, 32, IB_rect);
 
396
        qtexport->ibuf2 = IMB_allocImBuf(rectx, recty, 32, IB_rect);
399
397
 
400
 
        err = NewGWorldFromPtr( &qtexport->theGWorld,
401
 
                                                        k32ARGBPixelFormat,
402
 
                                                        trackFrame,
403
 
                                                        NULL, NULL, 0,
404
 
                                                        (Ptr)qtexport->ibuf->rect,
405
 
                                                        rectx * 4 );
406
 
        CheckError (err, "NewGWorldFromPtr error", reports);
 
398
        err = NewGWorldFromPtr(&qtexport->theGWorld,
 
399
                               k32ARGBPixelFormat,
 
400
                               trackFrame,
 
401
                               NULL, NULL, 0,
 
402
                               (Ptr)qtexport->ibuf->rect,
 
403
                               rectx * 4);
 
404
        CheckError(err, "NewGWorldFromPtr error", reports);
407
405
 
408
406
        qtexport->thePixMap = GetGWorldPixMap(qtexport->theGWorld);
409
407
        LockPixels(qtexport->thePixMap);
410
408
 
411
 
        SCDefaultPixMapSettings (qtdata->theComponent, qtexport->thePixMap, true);
 
409
        SCDefaultPixMapSettings(qtdata->theComponent, qtexport->thePixMap, true);
412
410
 
413
 
        // workaround for crash with H.264, which requires an upgrade to
414
 
        // the new callback based api for proper encoding, but that's not
415
 
        // really compatible with rendering out frames sequentially
 
411
        /* workaround for crash with H.264, which requires an upgrade to
 
412
         * the new callback based api for proper encoding, but that's not
 
413
         * really compatible with rendering out frames sequentially */
416
414
        gTemporalSettings = qtdata->gTemporalSettings;
417
415
        if (qtdata->gSpatialSettings.codecType == kH264CodecType) {
418
416
                if (gTemporalSettings.temporalQuality != codecMinQuality) {
419
 
                        BKE_reportf(reports, RPT_WARNING, "Only minimum quality compression supported for QuickTime H.264.\n");
 
417
                        BKE_report(reports, RPT_WARNING, "Only minimum quality compression supported for Quicktime H.264");
420
418
                        gTemporalSettings.temporalQuality = codecMinQuality;
421
419
                }
422
420
        }
423
421
 
424
 
        SCSetInfo(qtdata->theComponent, scTemporalSettingsType, &gTemporalSettings);
425
 
        SCSetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
426
 
        SCSetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
422
        SCSetInfo(qtdata->theComponent, scTemporalSettingsType, &gTemporalSettings);
 
423
        SCSetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
424
        SCSetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
427
425
 
428
426
        err = SCCompressSequenceBegin(qtdata->theComponent, qtexport->thePixMap, NULL, &qtexport->anImageDescription); 
429
 
        CheckError (err, "SCCompressSequenceBegin error", reports );
 
427
        CheckError(err, "SCCompressSequenceBegin error", reports);
430
428
}
431
429
 
432
430
 
433
 
static void QT_DoAddVideoSamplesToMedia (int frame, int *pixels, int rectx, int recty, ReportList *reports)
 
431
static void QT_DoAddVideoSamplesToMedia(int frame, int *pixels, int rectx, int recty, ReportList *reports)
434
432
{
435
 
        OSErr   err = noErr;
436
 
        Rect    imageRect;
 
433
        OSErr err = noErr;
 
434
        Rect imageRect;
437
435
 
438
 
        int             index;
439
 
        int             boxsize;
 
436
        int index;
 
437
        int boxsize;
440
438
        unsigned char *from, *to;
441
439
 
442
 
        short   syncFlag;
443
 
        long    dataSize;
444
 
        Handle  compressedData;
445
 
        Ptr             myPtr;
446
 
 
447
 
 
448
 
        //copy and flip renderdata
449
 
        memcpy(qtexport->ibuf2->rect, pixels, 4*rectx*recty);
 
440
        short syncFlag;
 
441
        long dataSize;
 
442
        Handle compressedData;
 
443
        Ptr myPtr;
 
444
 
 
445
 
 
446
        /* copy and flip renderdata */
 
447
        memcpy(qtexport->ibuf2->rect, pixels, 4 * rectx * recty);
450
448
        IMB_flipy(qtexport->ibuf2);
451
449
 
452
 
        //get pointers to parse bitmapdata
 
450
        /* get pointers to parse bitmapdata */
453
451
        myPtr = GetPixBaseAddr(qtexport->thePixMap);
454
452
        imageRect = (**qtexport->thePixMap).bounds;
455
453
 
456
454
        from = (unsigned char *) qtexport->ibuf2->rect;
457
455
        to = (unsigned char *) myPtr;
458
456
 
459
 
        //parse RGBA bitmap into Quicktime's ARGB GWorld
 
457
        /* parse RGBA bitmap into Quicktime's ARGB GWorld */
460
458
        boxsize = rectx * recty;
461
 
        for ( index = 0; index < boxsize; index++) {
 
459
        for (index = 0; index < boxsize; index++) {
462
460
                to[0] = from[3];
463
461
                to[1] = from[0];
464
462
                to[2] = from[1];
465
463
                to[3] = from[2];
466
 
                to +=4, from += 4;
 
464
                to += 4, from += 4;
467
465
        }
468
466
 
469
467
        err = SCCompressSequenceFrame(qtdata->theComponent,
470
 
                qtexport->thePixMap,
471
 
                &imageRect,
472
 
                &compressedData,
473
 
                &dataSize,
474
 
                &syncFlag);
 
468
                                      qtexport->thePixMap,
 
469
                                      &imageRect,
 
470
                                      &compressedData,
 
471
                                      &dataSize,
 
472
                                      &syncFlag);
475
473
        CheckError(err, "SCCompressSequenceFrame error", reports);
476
474
 
477
475
        err = AddMediaSample(qtexport->theMedia,
478
 
                compressedData,
479
 
                0,
480
 
                dataSize,
481
 
                qtdata->duration,
482
 
                (SampleDescriptionHandle)qtexport->anImageDescription,
483
 
                1,
484
 
                syncFlag,
485
 
                NULL);
 
476
                             compressedData,
 
477
                             0,
 
478
                             dataSize,
 
479
                             qtdata->duration,
 
480
                             (SampleDescriptionHandle)qtexport->anImageDescription,
 
481
                             1,
 
482
                             syncFlag,
 
483
                             NULL);
486
484
        CheckError(err, "AddMediaSample error", reports);
487
485
}
488
486
 
489
487
 
490
 
static void QT_EndAddVideoSamplesToMedia (void)
 
488
static void QT_EndAddVideoSamplesToMedia(void)
491
489
{
492
490
        SCCompressSequenceEnd(qtdata->theComponent);
493
491
 
494
492
        UnlockPixels(qtexport->thePixMap);
495
493
        if (qtexport->theGWorld)
496
 
                DisposeGWorld (qtexport->theGWorld);
 
494
                DisposeGWorld(qtexport->theGWorld);
497
495
 
498
496
        if (qtexport->ibuf)
499
497
                IMB_freeImBuf(qtexport->ibuf);
507
505
{
508
506
        char txt[64];
509
507
 
510
 
        if (string==0) return;
 
508
        if (string == 0) return;
511
509
 
512
510
        strcpy(string, rd->pic);
513
511
        BLI_path_abs(string, G.main->name);
515
513
        BLI_make_existing_file(string);
516
514
 
517
515
        if (BLI_strcasecmp(string + strlen(string) - 4, ".mov")) {
518
 
                sprintf(txt, "%04d-%04d.mov", (rd->sfra) , (rd->efra) );
 
516
                sprintf(txt, "%04d-%04d.mov", (rd->sfra), (rd->efra));
519
517
                strcat(string, txt);
520
518
        }
521
519
}
529
527
        char theFullPath[255];
530
528
 
531
529
#ifdef __APPLE__
532
 
        int             myFile;
533
 
        FSRef   myRef;
 
530
        int myFile;
 
531
        FSRef myRef;
534
532
#else
535
 
        char    *qtname;
 
533
        char    *qtname;
536
534
#endif
537
 
        int success= 1;
 
535
        int success = 1;
538
536
 
539
537
        if (qtexport == NULL) qtexport = MEM_callocN(sizeof(QuicktimeExport), "QuicktimeExport");
540
538
 
564
562
        sprintf(theFullPath, "%s", name);
565
563
 
566
564
        /* hack: create an empty file to make FSPathMakeRef() happy */
567
 
        myFile = open(theFullPath, O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRUSR|S_IWUSR);
 
565
        myFile = open(theFullPath, O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRUSR | S_IWUSR);
568
566
        if (myFile < 0) {
569
 
                BKE_reportf(reports, RPT_ERROR, "error while creating movie file!\n");
 
567
                BKE_report(reports, RPT_ERROR, "Error while creating movie file!");
570
568
                /* do something? */
571
569
        }
572
570
        close(myFile);
585
583
        err = FSMakeFSSpec(0, 0L, qtexport->qtfilename, &qtexport->theSpec);
586
584
#endif
587
585
 
588
 
        err = CreateMovieFile (&qtexport->theSpec, 
589
 
                                                kMyCreatorType,
590
 
                                                smCurrentScript, 
591
 
                                                createMovieFileDeleteCurFile | createMovieFileDontCreateResFile,
592
 
                                                &qtexport->resRefNum, 
593
 
                                                &qtexport->theMovie );
 
586
        err = CreateMovieFile(&qtexport->theSpec,
 
587
                              kMyCreatorType,
 
588
                              smCurrentScript,
 
589
                              createMovieFileDeleteCurFile | createMovieFileDontCreateResFile,
 
590
                              &qtexport->resRefNum,
 
591
                              &qtexport->theMovie);
594
592
        CheckError(err, "CreateMovieFile error", reports);
595
593
 
596
594
        if (err != noErr) {
597
595
                BKE_reportf(reports, RPT_ERROR, "Unable to create Quicktime movie: %s", name);
598
 
                success= 0;
 
596
                success = 0;
599
597
#ifdef __APPLE__
600
598
                ExitMoviesOnThread();
601
599
#endif
602
600
        }
603
601
        else {
604
 
                //printf("Created QuickTime movie: %s\n", name);
 
602
                /* printf("Created QuickTime movie: %s\n", name); */
605
603
 
606
604
                QT_CreateMyVideoTrack(rectx, recty, reports);
607
605
        }
625
623
        if (qtexport->theMovie) {
626
624
                QT_EndCreateMyVideoTrack(NULL);
627
625
 
628
 
                err = AddMovieResource (qtexport->theMovie, qtexport->resRefNum, &resId, qtexport->qtfilename);
 
626
                err = AddMovieResource(qtexport->theMovie, qtexport->resRefNum, &resId, qtexport->qtfilename);
629
627
                CheckError(err, "AddMovieResource error", NULL);
630
628
 
631
629
                err = QT_AddUserDataTextToMovie(qtexport->theMovie, "Made with Blender", kUserDataTextInformation);
638
636
 
639
637
                DisposeMovie(qtexport->theMovie);
640
638
 
641
 
                //printf("Finished QuickTime movie.\n");
 
639
                /* printf("Finished QuickTime movie.\n"); */
642
640
        }
643
641
 
644
642
#ifdef __APPLE__
645
 
                ExitMoviesOnThread();
 
643
        ExitMoviesOnThread();
646
644
#endif
647
645
        
648
646
        if (qtexport) {
664
662
 
665
663
static void check_renderbutton_framerate(RenderData *rd, ReportList *reports) 
666
664
{
667
 
        // to keep float framerates consistent between the codec dialog and frs/sec button.
668
 
        OSErr   err;    
 
665
        /* to keep float framerates consistent between the codec dialog and frs/sec button. */
 
666
        OSErr err;
669
667
 
670
 
        err = SCGetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
 
668
        err = SCGetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
671
669
        CheckError(err, "SCGetInfo fr error", reports);
672
670
 
673
671
        if ( (rd->frs_sec == 24 || rd->frs_sec == 30 || rd->frs_sec == 60) &&
674
 
            (qtdata->gTemporalSettings.frameRate == 1571553 ||
675
 
             qtdata->gTemporalSettings.frameRate == 1964113 ||
676
 
             qtdata->gTemporalSettings.frameRate == 3928227))
 
672
             (qtdata->gTemporalSettings.frameRate == 1571553 ||
 
673
              qtdata->gTemporalSettings.frameRate == 1964113 ||
 
674
              qtdata->gTemporalSettings.frameRate == 3928227))
677
675
        {
678
676
                /* do nothing */
679
677
        }
680
678
        else {
681
679
                if (rd->frs_sec_base > 0)
682
680
                        qtdata->gTemporalSettings.frameRate = 
683
 
                        ((float)(rd->frs_sec << 16) / rd->frs_sec_base);
 
681
                            ((float)(rd->frs_sec << 16) / rd->frs_sec_base);
684
682
        }
685
683
        
686
 
        err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
687
 
        CheckError( err, "SCSetInfo error", reports );
 
684
        err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
 
685
        CheckError(err, "SCSetInfo error", reports);
688
686
 
689
 
        if (qtdata->gTemporalSettings.frameRate == 1571553) {                   // 23.98 fps
 
687
        if (qtdata->gTemporalSettings.frameRate == 1571553) {       /* 23.98 fps */
690
688
                qtdata->kVideoTimeScale = 24000;
691
689
                qtdata->duration = 1001;
692
690
        }
693
 
        else if (qtdata->gTemporalSettings.frameRate == 1964113) {      // 29.97 fps
 
691
        else if (qtdata->gTemporalSettings.frameRate == 1964113) {  /* 29.97 fps */
694
692
                qtdata->kVideoTimeScale = 30000;
695
693
                qtdata->duration = 1001;
696
694
        }
697
 
        else if (qtdata->gTemporalSettings.frameRate == 3928227) {      // 59.94 fps
 
695
        else if (qtdata->gTemporalSettings.frameRate == 3928227) {  /* 59.94 fps */
698
696
                qtdata->kVideoTimeScale = 60000;
699
697
                qtdata->duration = 1001;
700
698
        }
707
705
void quicktime_verify_image_type(RenderData *rd, ImageFormatData *imf)
708
706
{
709
707
        if (imf->imtype == R_IMF_IMTYPE_QUICKTIME) {
710
 
                if ((rd->qtcodecsettings.codecType== 0) ||
711
 
                        (rd->qtcodecsettings.codecSpatialQuality <0) ||
712
 
                        (rd->qtcodecsettings.codecSpatialQuality > 100)) {
713
 
                        
 
708
                if ((rd->qtcodecsettings.codecType == 0) ||
 
709
                    (rd->qtcodecsettings.codecSpatialQuality < 0) ||
 
710
                    (rd->qtcodecsettings.codecSpatialQuality > 100))
 
711
                {
714
712
                        rd->qtcodecsettings.codecType = kJPEGCodecType;
715
713
                        rd->qtcodecsettings.codec = (int)anyCodec;
716
 
                        rd->qtcodecsettings.codecSpatialQuality = (codecHighQuality*100)/codecLosslessQuality;
717
 
                        rd->qtcodecsettings.codecTemporalQuality = (codecHighQuality*100)/codecLosslessQuality;
 
714
                        rd->qtcodecsettings.codecSpatialQuality = (codecHighQuality * 100) / codecLosslessQuality;
 
715
                        rd->qtcodecsettings.codecTemporalQuality = (codecHighQuality * 100) / codecLosslessQuality;
718
716
                        rd->qtcodecsettings.keyFrameRate = 25;
719
 
                        rd->qtcodecsettings.bitRate = 5000000; //5 Mbps
 
717
                        rd->qtcodecsettings.bitRate = 5000000;  /* 5 Mbps */
720
718
                }
721
719
        }
722
720
}
724
722
int get_qtcodec_settings(RenderData *rd, ReportList *reports) 
725
723
{
726
724
        OSErr err = noErr;
727
 
                // erase any existing codecsetting
 
725
        /* erase any existing codecsetting */
728
726
        if (qtdata) {
729
727
                if (qtdata->theComponent) CloseComponent(qtdata->theComponent);
730
728
                free_qtcomponentdata();
731
729
        }
732
730
 
733
 
        // allocate new
 
731
        /* allocate new */
734
732
        qtdata = MEM_callocN(sizeof(QuicktimeComponentData), "QuicktimeComponentData");
735
733
        qtdata->theComponent = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);
736
734
 
737
 
        // get previous selected codecsetting, from qtatom or detailed settings
 
735
        /* get previous selected codecsetting, from qtatom or detailed settings */
738
736
        if (rd->qtcodecdata && rd->qtcodecdata->cdParms) {
739
737
                QT_GetCodecSettingsFromScene(rd, reports);
740
738
        }
741
739
        else {
742
 
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
743
 
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
744
 
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
 
740
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
741
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
742
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
745
743
 
746
744
                qtdata->gSpatialSettings.codecType = rd->qtcodecsettings.codecType;
747
745
                qtdata->gSpatialSettings.codec = (CodecComponent)rd->qtcodecsettings.codec;      
748
 
                qtdata->gSpatialSettings.spatialQuality = (rd->qtcodecsettings.codecSpatialQuality * codecLosslessQuality) /100;
749
 
                qtdata->gTemporalSettings.temporalQuality = (rd->qtcodecsettings.codecTemporalQuality * codecLosslessQuality) /100;
 
746
                qtdata->gSpatialSettings.spatialQuality = (rd->qtcodecsettings.codecSpatialQuality * codecLosslessQuality) / 100;
 
747
                qtdata->gTemporalSettings.temporalQuality = (rd->qtcodecsettings.codecTemporalQuality * codecLosslessQuality) / 100;
750
748
                qtdata->gTemporalSettings.keyFrameRate = rd->qtcodecsettings.keyFrameRate;   
751
749
                qtdata->aDataRateSetting.dataRate = rd->qtcodecsettings.bitRate;
752
750
                qtdata->gSpatialSettings.depth = rd->qtcodecsettings.colorDepth;
754
752
                qtdata->aDataRateSetting.minTemporalQuality = (rd->qtcodecsettings.minTemporalQuality * codecLosslessQuality) / 100;
755
753
                
756
754
                qtdata->aDataRateSetting.frameDuration = rd->frs_sec;
757
 
                SetMovieTimeScale(qtexport->theMovie, rd->frs_sec_base*1000);
758
 
                
759
 
                
760
 
                err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
 
755
                SetMovieTimeScale(qtexport->theMovie, rd->frs_sec_base * 1000);
 
756
                
 
757
                
 
758
                err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
761
759
                CheckError(err, "SCSetInfo1 error", reports);
762
 
                err = SCSetInfo(qtdata->theComponent, scSpatialSettingsType,    &qtdata->gSpatialSettings);
 
760
                err = SCSetInfo(qtdata->theComponent, scSpatialSettingsType,    &qtdata->gSpatialSettings);
763
761
                CheckError(err, "SCSetInfo2 error", reports);
764
 
                err = SCSetInfo(qtdata->theComponent, scDataRateSettingsType,   &qtdata->aDataRateSetting);
 
762
                err = SCSetInfo(qtdata->theComponent, scDataRateSettingsType,   &qtdata->aDataRateSetting);
765
763
                CheckError(err, "SCSetInfo3 error", reports);
766
764
        }
767
765
 
772
770
 
773
771
static int request_qtcodec_settings(bContext *C, wmOperator *op)
774
772
{
775
 
        OSErr   err = noErr;
 
773
        OSErr err = noErr;
776
774
        Scene *scene = CTX_data_scene(C);
777
775
        RenderData *rd = &scene->r;
778
776
 
779
 
        // erase any existing codecsetting
 
777
        /* erase any existing codecsetting */
780
778
        if (qtdata) {
781
779
                if (qtdata->theComponent) CloseComponent(qtdata->theComponent);
782
780
                free_qtcomponentdata();
783
781
        }
784
 
        
785
 
        // allocate new
 
782
 
 
783
        /* allocate new */
786
784
        qtdata = MEM_callocN(sizeof(QuicktimeComponentData), "QuicktimeComponentData");
787
785
        qtdata->theComponent = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);
788
 
        
789
 
        // get previous selected codecsetting, from qtatom or detailed settings
 
786
 
 
787
        /* get previous selected codecsetting, from qtatom or detailed settings */
790
788
        if (rd->qtcodecdata && rd->qtcodecdata->cdParms) {
791
789
                QT_GetCodecSettingsFromScene(rd, op->reports);
792
790
        }
793
791
        else {
794
 
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
795
 
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
796
 
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
 
792
                SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
793
                SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
794
                SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
797
795
                
798
796
                qtdata->gSpatialSettings.codecType = rd->qtcodecsettings.codecType;
799
797
                qtdata->gSpatialSettings.codec = (CodecComponent)rd->qtcodecsettings.codec;      
800
 
                qtdata->gSpatialSettings.spatialQuality = (rd->qtcodecsettings.codecSpatialQuality * codecLosslessQuality) /100;
801
 
                qtdata->gTemporalSettings.temporalQuality = (rd->qtcodecsettings.codecTemporalQuality * codecLosslessQuality) /100;
 
798
                qtdata->gSpatialSettings.spatialQuality = (rd->qtcodecsettings.codecSpatialQuality * codecLosslessQuality) / 100;
 
799
                qtdata->gTemporalSettings.temporalQuality = (rd->qtcodecsettings.codecTemporalQuality * codecLosslessQuality) / 100;
802
800
                qtdata->gTemporalSettings.keyFrameRate = rd->qtcodecsettings.keyFrameRate;
803
801
                qtdata->gTemporalSettings.frameRate = ((float)(rd->frs_sec << 16) / rd->frs_sec_base);
804
802
                qtdata->aDataRateSetting.dataRate = rd->qtcodecsettings.bitRate;
806
804
                qtdata->aDataRateSetting.minSpatialQuality = (rd->qtcodecsettings.minSpatialQuality * codecLosslessQuality) / 100;
807
805
                qtdata->aDataRateSetting.minTemporalQuality = (rd->qtcodecsettings.minTemporalQuality * codecLosslessQuality) / 100;
808
806
                
809
 
                qtdata->aDataRateSetting.frameDuration = rd->frs_sec;           
 
807
                qtdata->aDataRateSetting.frameDuration = rd->frs_sec;
810
808
                
811
 
                err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
 
809
                err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,   &qtdata->gTemporalSettings);
812
810
                CheckError(err, "SCSetInfo1 error", op->reports);
813
 
                err = SCSetInfo(qtdata->theComponent, scSpatialSettingsType,    &qtdata->gSpatialSettings);
 
811
                err = SCSetInfo(qtdata->theComponent, scSpatialSettingsType,    &qtdata->gSpatialSettings);
814
812
                CheckError(err, "SCSetInfo2 error", op->reports);
815
 
                err = SCSetInfo(qtdata->theComponent, scDataRateSettingsType,   &qtdata->aDataRateSetting);
 
813
                err = SCSetInfo(qtdata->theComponent, scDataRateSettingsType,   &qtdata->aDataRateSetting);
816
814
                CheckError(err, "SCSetInfo3 error", op->reports);
817
815
        }
818
 
                // put up the dialog box - it needs to be called from the main thread
 
816
        /* put up the dialog box - it needs to be called from the main thread */
819
817
        err = SCRequestSequenceSettings(qtdata->theComponent);
820
 
 
 
818
 
821
819
        if (err == scUserCancelled) {
822
820
                return OPERATOR_FINISHED;
823
821
        }
824
822
 
825
 
                // update runtime codecsettings for use with the codec dialog
826
 
        SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
827
 
        SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
828
 
        SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
829
 
        
830
 
        
831
 
                //Fill the render QuicktimeCodecSettings struct
 
823
        /* update runtime codecsettings for use with the codec dialog */
 
824
        SCGetInfo(qtdata->theComponent, scDataRateSettingsType, &qtdata->aDataRateSetting);
 
825
        SCGetInfo(qtdata->theComponent, scSpatialSettingsType,  &qtdata->gSpatialSettings);
 
826
        SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings);
 
827
        
 
828
        
 
829
        /* Fill the render QuicktimeCodecSettings struct */
832
830
        rd->qtcodecsettings.codecTemporalQuality = (qtdata->gTemporalSettings.temporalQuality * 100) / codecLosslessQuality;
833
 
                //Do not override scene frame rate (qtdata->gTemporalSettings.framerate)
 
831
        /* Do not override scene frame rate (qtdata->gTemporalSettings.framerate) */
834
832
        rd->qtcodecsettings.keyFrameRate = qtdata->gTemporalSettings.keyFrameRate;
835
833
        
836
834
        rd->qtcodecsettings.codecType = qtdata->gSpatialSettings.codecType;
841
839
        rd->qtcodecsettings.bitRate = qtdata->aDataRateSetting.dataRate;
842
840
        rd->qtcodecsettings.minSpatialQuality = (qtdata->aDataRateSetting.minSpatialQuality * 100) / codecLosslessQuality;
843
841
        rd->qtcodecsettings.minTemporalQuality = (qtdata->aDataRateSetting.minTemporalQuality * 100) / codecLosslessQuality;
844
 
                //Frame duration is already known (qtdata->aDataRateSetting.frameDuration)
 
842
        /* Frame duration is already known (qtdata->aDataRateSetting.frameDuration) */
845
843
        
846
844
        QT_SaveCodecSettingsToScene(rd, op->reports);
847
845
 
848
 
        // framerate jugglin'
849
 
        if (qtdata->gTemporalSettings.frameRate == 1571553) {                   // 23.98 fps
 
846
        /* framerate jugglin' */
 
847
        if (qtdata->gTemporalSettings.frameRate == 1571553) {           /* 23.98 fps */
850
848
                qtdata->kVideoTimeScale = 24000;
851
849
                qtdata->duration = 1001;
852
850
 
853
851
                rd->frs_sec = 24;
854
852
                rd->frs_sec_base = 1.001;
855
853
        }
856
 
        else if (qtdata->gTemporalSettings.frameRate == 1964113) {      // 29.97 fps
 
854
        else if (qtdata->gTemporalSettings.frameRate == 1964113) {  /* 29.97 fps */
857
855
                qtdata->kVideoTimeScale = 30000;
858
856
                qtdata->duration = 1001;
859
857
 
860
858
                rd->frs_sec = 30;
861
859
                rd->frs_sec_base = 1.001;
862
860
        }
863
 
        else if (qtdata->gTemporalSettings.frameRate == 3928227) {      // 59.94 fps
 
861
        else if (qtdata->gTemporalSettings.frameRate == 3928227) {  /* 59.94 fps */
864
862
                qtdata->kVideoTimeScale = 60000;
865
863
                qtdata->duration = 1001;
866
864
 
893
891
}
894
892
 
895
893
#if defined(__APPLE__) && defined(GHOST_COCOA)
896
 
//Need to set up a Cocoa NSAutoReleasePool to avoid memory leak
897
 
//And it must be done in an objC file, so use a GHOST_SystemCocoa.mm function for that
 
894
/* Need to set up a Cocoa NSAutoReleasePool to avoid memory leak
 
895
 * And it must be done in an objC file, so use a GHOST_SystemCocoa.mm function for that */
898
896
extern int cocoa_request_qtcodec_settings(bContext *C, wmOperator *op);
899
897
 
900
898
int fromcocoa_request_qtcodec_settings(bContext *C, wmOperator *op)
907
905
void SCENE_OT_render_data_set_quicktime_codec(wmOperatorType *ot)
908
906
{
909
907
        /* identifiers */
910
 
        ot->name = "Change codec";
 
908
        ot->name = "Change Codec";
911
909
        ot->description = "Change Quicktime codec Settings";
912
910
        ot->idname = "SCENE_OT_render_data_set_quicktime_codec";
913
911
        
920
918
        ot->poll = ED_operator_setqtcodec;
921
919
        
922
920
        /* flags */
923
 
        ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
921
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
924
922
}
925
923
 
926
924
#endif /* USE_QTKIT */