// Copyright (c) 2010 The WebM project authors. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the LICENSE file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

#define HAVE_CONFIG_H "vpx_codecs_config.h"

#include "vpx/vpx_encoder.h"

#include "vpx/vpx_codec_impl_top.h"

#include "vpx/vpx_codec_impl_bottom.h"

#include "vpx/vp8cx.h"

#if __APPLE_CC__

#include <QuickTime/QuickTime.h>

#else

#include <ConditionalMacros.h>

#include <Endian.h>

#include <ImageCodec.h>

#endif

#include "keystone_util.h"

#include "log.h"

#include "Raw_debug.h"

#include "VP8CodecVersion.h"

#include "VP8Encoder.h"

#include "VP8EncoderEncode.h"

#include "VP8EncoderGui.h"

// Setup required for ComponentDispatchHelper.c

#define IMAGECODEC_BASENAME() VP8_Encoder_

#define IMAGECODEC_GLOBALS() VP8EncoderGlobals storage

#define CALLCOMPONENT_BASENAME() IMAGECODEC_BASENAME()

#define CALLCOMPONENT_GLOBALS() IMAGECODEC_GLOBALS()

#define QT_BASENAME() CALLCOMPONENT_BASENAME()

#define QT_GLOBALS() CALLCOMPONENT_GLOBALS()

#define COMPONENT_UPP_PREFIX() uppImageCodec

#define COMPONENT_DISPATCH_FILE "VP8EncoderDispatch.h"

#define COMPONENT_SELECT_PREFIX() kImageCodec

#if __APPLE_CC__

#include <CoreServices/Components.k.h>

#include <QuickTime/ImageCodec.k.h>

#include <QuickTime/ImageCompression.k.h>

#include <QuickTime/ComponentDispatchHelper.c>

#else

#include <Components.k.h>

#include <ImageCodec.k.h>

#include <ImageCompression.k.h>

#include <ComponentDispatchHelper.c>

#endif

// Open a new instance of the component.

// Allocate component instance storage ("globals") and associate it with the new instance so that other

// calls will receive it.

// Note that "one-shot" component calls like CallComponentVersion and ImageCodecGetCodecInfo work by opening

// an instance, making that call and then closing the instance, so you should avoid performing very expensive

// initialization operations in a component's Open function.

ComponentResult

VP8_Encoder_Open(

VP8EncoderGlobals glob,

ComponentInstance self)

{

ComponentResult err = noErr;

dbg_printf("[vp8e - %08lx] Open Called\n", (UInt32)glob);

TouchActivityFile();

glob = calloc(sizeof(VP8EncoderGlobalsRecord), 1);

if (! glob)

{

err = memFullErr;

goto bail;

}

SetComponentInstanceStorage(self, (Handle)glob);

glob->self = self;

glob->target = self;

glob->nextDecodeNumber = 1;

glob->frameCount = 0;

glob->raw = NULL;

glob->codec = NULL;

glob->stats.sz =0;

glob->stats.buf = NULL;

//default to one pass

glob->currentPass = VPX_RC_ONE_PASS;

glob->sourceQueue.size = 0;

glob->sourceQueue.max = 0;

glob->sourceQueue.queue = NULL;

glob->sourceQueue.frames_in =0;

glob->sourceQueue.frames_out =0;

glob->altRefFrame.buf =0;

glob->altRefFrame.size =0;

int i;

for (i=0;i<TOTAL_CUSTOM_VP8_SETTINGS; i++)

{

glob->settings[i]= UINT_MAX;

}

bail:

dbg_printf("[vp8e - %08lx] Open Called exit %d \n", (UInt32)glob, err);

return err;

}

// Closes the instance of the component.

// Release all storage associated with this instance.

// Note that if a component's Open function fails with an error, its Close function will still be called.

ComponentResult

VP8_Encoder_Close(

VP8EncoderGlobals glob,

ComponentInstance self)

{

dbg_printf("[vp8e - %08lx] Close Called\n", (UInt32)glob);

if (glob)

{

if (glob->stats.buf != NULL)

{

free(glob->stats.buf);

glob->stats.buf =NULL;

glob->stats.sz=0;

}

if (glob->codec) //see if i've initialized the vpx_codec

{

if (vpx_codec_destroy(glob->codec))

dbg_printf("[vp8e - %08lx] Failed to destroy codec\n", (UInt32)glob);

free(glob->codec);

}

ICMCompressionSessionOptionsRelease(glob->sessionOptions);

glob->sessionOptions = NULL;

if (glob->raw)

{

vpx_img_free(glob->raw);

free(glob->raw);

}

if (glob->sourceQueue.queue != NULL)

free(glob->sourceQueue.queue);

free(glob);

}

return noErr;

}

// Return the version of the component.

// This does not need to correspond in any way to the human-readable version numbers found in

// Get Info windows, etc.

// The principal use of component version numbers is to choose between multiple installed versions

// of the same component: if the component manager sees two components with the same type, subtype

// and manufacturer codes and either has the componentDoAutoVersion registration flag set,

// it will deregister the one with the older version. (If componentAutoVersionIncludeFlags is also

// set, it only does this when the component flags also match.)

// By convention, the high short of the component version is the interface version, which Apple

// bumps when there is a major change in the interface.

// We recommend bumping the low short of the component version every time you ship a release of a component.

// The version number in the 'thng' resource should be the same as the number returned by this function.

ComponentResult

VP8_Encoder_Version(VP8EncoderGlobals glob)

{

dbg_printf("[vp8e - %08lx] returning version %d\n", (UInt32)glob, kVP8CompressorVersion);

return kVP8CompressorVersion;

}

// Sets the target for a component instance.

// When a component wants to make a component call on itself, it should make that call on its target.

// This allows other components to delegate to the component.

// By default, a component's target is itself -- see the Open function.

ComponentResult

VP8_Encoder_Target(VP8EncoderGlobals glob, ComponentInstance target)

{

dbg_printf("[vp8e - %08lx] VP8_Encoder_Target\n", (UInt32)glob);

glob->target = target;

return noErr;

}

// Your component receives the ImageCodecGetCodecInfo request whenever an application calls the Image Compression Manager's GetCodecInfo function.

// Your component should return a formatted compressor information structure defining its capabilities.

// Both compressors and decompressors may receive this request.

ComponentResult

VP8_Encoder_GetCodecInfo(VP8EncoderGlobals glob, CodecInfo *info)

{

dbg_printf("[vp8e - %08lx] GetCodecInfo called\n", (UInt32)glob);

OSErr err = noErr;

if (info == NULL)

{

err = paramErr;

}

else

{

CodecInfo **tempCodecInfo;

err = GetComponentResource((Component)glob->self, codecInfoResourceType, 255, (Handle *)&tempCodecInfo);

if (err == noErr)

{

*info = **tempCodecInfo;

DisposeHandle((Handle)tempCodecInfo);

}

}

dbg_printf("[vp8e - %08lx] GetCodecInfo exit %d\n", (UInt32)glob, err);

return err;

}

// Return the maximum size of compressed data for the image in bytes.

// Note that this function is only used when the ICM client is using a compression sequence

// (created with CompressSequenceBegin, not ICMCompressionSessionCreate).

// Nevertheless, it's important to implement it because such clients need to know how much

// memory to allocate for compressed frame buffers.

ComponentResult

VP8_Encoder_GetMaxCompressionSize(

long *size)

{

dbg_printf("[vp8e - %08lx] VP8_Encoder_GetMaxCompressionSize\n", (UInt32)glob);

ComponentResult err = noErr;

size_t maxBytes = 0;

if (! size)

return paramErr;

//this is a very large guess... but they did ask for the max.

maxBytes = (srcRect->right - srcRect->left) * (srcRect->bottom - srcRect->top) / 4;

*size = maxBytes;

bail:

return err;

}

// Utility to add an SInt32 to a CFMutableDictionary.

static void

addNumberToDictionary(CFMutableDictionaryRef dictionary, CFStringRef key, SInt32 numberSInt32)

{

CFNumberRef number = CFNumberCreate(NULL, kCFNumberSInt32Type, &numberSInt32);

if (! number)

return;

CFDictionaryAddValue(dictionary, key, number);

CFRelease(number);

}

// Utility to add a double to a CFMutableDictionary.

static void

addDoubleToDictionary(CFMutableDictionaryRef dictionary, CFStringRef key, double numberDouble)

{

CFNumberRef number = CFNumberCreate(NULL, kCFNumberDoubleType, &numberDouble);

if (! number)

return;

CFDictionaryAddValue(dictionary, key, number);

CFRelease(number);

}

// Utility to round up to a multiple of 16.

static int

roundUpToMultipleOf16(int n)

{

if (0 != (n & 15))

n = (n + 15) & ~15;

return n;

}

// Create a dictionary that describes the kinds of pixel buffers that we want to receive.

// The important keys to add are kCVPixelBufferPixelFormatTypeKey,

// kCVPixelBufferWidthKey and kCVPixelBufferHeightKey.

// Many compressors will also want to set kCVPixelBufferExtendedPixels,

// kCVPixelBufferBytesPerRowAlignmentKey, kCVImageBufferGammaLevelKey and kCVImageBufferYCbCrMatrixKey.

static OSStatus

createPixelBufferAttributesDictionary(SInt32 width, SInt32 height,

const OSType *pixelFormatList, int pixelFormatCount,

CFMutableDictionaryRef *pixelBufferAttributesOut)

{

OSStatus err = memFullErr;

int i;

CFMutableDictionaryRef pixelBufferAttributes = NULL;

CFNumberRef number = NULL;

CFMutableArrayRef array = NULL;

SInt32 widthRoundedUp, heightRoundedUp, extendRight, extendBottom;

pixelBufferAttributes = CFDictionaryCreateMutable(

NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

if (! pixelBufferAttributes) goto bail;

array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

if (! array) goto bail;

// Under kCVPixelBufferPixelFormatTypeKey, add the list of source pixel formats.

// This can be a CFNumber or a CFArray of CFNumbers.

for (i = 0; i < pixelFormatCount; i++)

{

number = CFNumberCreate(NULL, kCFNumberSInt32Type, &pixelFormatList[i]);

if (! number) goto bail;

CFArrayAppendValue(array, number);

CFRelease(number);

number = NULL;

}

CFDictionaryAddValue(pixelBufferAttributes, kCVPixelBufferPixelFormatTypeKey, array);

CFRelease(array);

array = NULL;

// Add kCVPixelBufferWidthKey and kCVPixelBufferHeightKey to specify the dimensions

// of the source pixel buffers. Normally this is the same as the compression target dimensions.

addNumberToDictionary(pixelBufferAttributes, kCVPixelBufferWidthKey, width);

addNumberToDictionary(pixelBufferAttributes, kCVPixelBufferHeightKey, height);

// If you want to require that extra scratch pixels be allocated on the edges of source pixel buffers,

// add the kCVPixelBufferExtendedPixels{Left,Top,Right,Bottom}Keys to indicate how much.

// Internally our encoded can only support multiples of 16x16 macroblocks;

// we will round the compression dimensions up to a multiple of 16x16 and encode that size.

// (Note that if your compressor needs to copy the pixels anyhow (eg, in order to convert to a different

// format) you may get better performance if your copy routine does not require extended pixels.)

widthRoundedUp = roundUpToMultipleOf16(width);

heightRoundedUp = roundUpToMultipleOf16(height);

extendRight = widthRoundedUp - width;

extendBottom = heightRoundedUp - height;

if (extendRight || extendBottom)

{

addNumberToDictionary(pixelBufferAttributes, kCVPixelBufferExtendedPixelsRightKey, extendRight);

addNumberToDictionary(pixelBufferAttributes, kCVPixelBufferExtendedPixelsBottomKey, extendBottom);

}

// Altivec code is most efficient reading data aligned at addresses that are multiples of 16.

// Pretending that we have some altivec code, we set kCVPixelBufferBytesPerRowAlignmentKey to

// ensure that each row of pixels starts at a 16-byte-aligned address.

addNumberToDictionary(pixelBufferAttributes, kCVPixelBufferBytesPerRowAlignmentKey, 16);

// This codec accepts YCbCr input in the form of '2vuy' format pixel buffers.

// We recommend explicitly defining the gamma level and YCbCr matrix that should be used.

addDoubleToDictionary(pixelBufferAttributes, kCVImageBufferGammaLevelKey, 2.2);

CFDictionaryAddValue(pixelBufferAttributes, kCVImageBufferYCbCrMatrixKey, kCVImageBufferYCbCrMatrix_ITU_R_601_4);

err = noErr;

*pixelBufferAttributesOut = pixelBufferAttributes;

pixelBufferAttributes = NULL;

bail:

if (pixelBufferAttributes) CFRelease(pixelBufferAttributes);

if (number) CFRelease(number);

if (array) CFRelease(array);

return err;

}

// Prepare to compress frames.

// Compressor should record session and sessionOptions for use in later calls.

// Compressor may modify imageDescription at this point.

// Compressor may create and return pixel buffer options.

ComponentResult

VP8_Encoder_PrepareToCompressFrames(

CFDictionaryRef *compressorPixelBufferAttributesOut)

{

dbg_printf("[vp8e] Prepare to Compress Frames\n", (UInt32)glob);

ComponentResult err = noErr;

CFMutableDictionaryRef compressorPixelBufferAttributes = NULL;

//This format later needs to be converted

OSType pixelFormatList[] = { k422YpCbCr8PixelFormat }; // also known as '2vuy'

Fixed gammaLevel;

int frameIndex;

SInt32 widthRoundedUp, heightRoundedUp;

// Record the compressor session for later calls to the ICM.

// Note: this is NOT a CF type and should NOT be CFRetained or CFReleased.

glob->session = session;

// Retain the session options for later use.

ICMCompressionSessionOptionsRelease(glob->sessionOptions);

glob->sessionOptions = sessionOptions;

ICMCompressionSessionOptionsRetain(glob->sessionOptions);

// Modify imageDescription here if needed.

// We'll set the image description gamma level to say "2.2".

gammaLevel = kQTCCIR601VideoGammaLevel;

err = ICMImageDescriptionSetProperty(imageDescription,

kQTPropertyClass_ImageDescription,

kICMImageDescriptionPropertyID_GammaLevel,

sizeof(gammaLevel),

&gammaLevel);

if (err)

goto bail;

// Record the dimensions from the image description.

glob->width = (*imageDescription)->width;

glob->height = (*imageDescription)->height;

dbg_printf("[vp8e - %08lx] Prepare to compress frame width %d height %d\n", (UInt32)glob, glob->width, glob->height);

if (glob->width < 16 || glob->width % 2 || glob->height < 16 || glob->height % 2)

dbg_printf("[vp8e - %08lx] Warning :: Invalid resolution: %ldx%ld", (UInt32)glob, glob->width, glob->height);

if (glob->raw == NULL)

glob->raw = calloc(1, sizeof(vpx_image_t));

//Right now I'm only using YV12, this is great for webm, as I control the spit component

if (!vpx_img_alloc(glob->raw, IMG_FMT_YV12, glob->width, glob->height, 1))

{

dbg_printf("[vp8e - %08lx] Error: Failed to allocate image %dx%d", (UInt32)glob, glob->width, glob->height);

err = paramErr;

goto bail;

}

glob->maxEncodedDataSize = glob->width * glob->height * 2;

dbg_printf("[vp8e - %08lx] currently allocating %d bytes as my max encoded size\n", (UInt32)glob, glob->maxEncodedDataSize);

// Create a pixel buffer attributes dictionary.

err = createPixelBufferAttributesDictionary(glob->width, glob->height,

pixelFormatList, sizeof(pixelFormatList) / sizeof(OSType),

&compressorPixelBufferAttributes);

if (err)

goto bail;

*compressorPixelBufferAttributesOut = compressorPixelBufferAttributes;

compressorPixelBufferAttributes = NULL;

/* Populate encoder configuration */

glob->res = vpx_codec_enc_config_default((&vpx_codec_vp8_cx_algo), &glob->cfg, 0);

if (glob->res)

{

dbg_printf("[vp8e - %08lx] Failed to get config: %s\n", (UInt32)glob, vpx_codec_err_to_string(glob->res));

err = paramErr; //this may be something different ....

goto bail;

}

glob->cfg.g_w = glob->width;

glob->cfg.g_h = glob->height;

dbg_printf("[vp8e - %08lx] resolution %dx%d\n", (UInt32)glob,

glob->cfg.g_w, glob->cfg.g_h);

bail:

if (err)

dbg_printf("[vp8e - %08lx] Error %d\n", (UInt32)glob, err);

if (compressorPixelBufferAttributes) CFRelease(compressorPixelBufferAttributes);

return err;

}

// Presents the compressor with a frame to encode.

// The compressor may encode the frame immediately or queue it for later encoding.

// If the compressor queues the frame for later decode, it must retain it (by calling ICMCompressorSourceFrameRetain)

// and release it when it is done with it (by calling ICMCompressorSourceFrameRelease).

// Pixel buffers are guaranteed to conform to the pixel buffer options returned by ImageCodecPrepareToCompressFrames.

ComponentResult

VP8_Encoder_EncodeFrame(

VP8EncoderGlobals glob,

ICMCompressorSourceFrameRef sourceFrame,

UInt32 flags)

{

dbg_printf("[vp8e - %08lx] VP8Encoder_EncodeFrame\n", (UInt32)glob);

ComponentResult err = noErr;

ICMCompressionFrameOptionsRef frameOptions;

dbg_printf("[vp8e - %08lx] flags are %x\n", (UInt32)glob, flags);

err = encodeThisSourceFrame(glob, sourceFrame);

return err;

}

// Directs the compressor to finish with a queued source frame, either emitting or dropping it.

// This frame does not necessarily need to be the first or only source frame emitted or dropped

// during this call, but the compressor must call either ICMCompressorSessionDropFrame or

// ICMCompressorSessionEmitEncodedFrame with this frame before returning.

// The ICM will call this function to force frames to be encoded for the following reasons:

// - the maximum frame delay count or maximum frame delay time in the sessionOptions

// does not permit more frames to be queued

// - the client has called ICMCompressionSessionCompleteFrames.

ComponentResult

VP8_Encoder_CompleteFrame(

VP8EncoderGlobals glob,

ICMCompressorSourceFrameRef sourceFrame,

UInt32 flags)

{

ComponentResult err = noErr;

dbg_printf("[vp8e - %08lx] VP8Encoder_CompleteFrame\n", (UInt32)glob);

ICMCompressionFrameOptionsRef frameOptions;

dbg_printf("[vp8e - %08lx] flags are %x\n", (UInt32)glob, flags);

//todo, this should verify that the source frame is complete

completeThisSourceFrame(glob, sourceFrame);

bail:

return err;

}

static ICMFrameType

getRequestedFrameType(ICMCompressorSourceFrameRef sourceFrame)

{

ICMCompressionFrameOptionsRef frameOptions = ICMCompressorSourceFrameGetFrameOptions(sourceFrame);

ICMFrameType requestedFrameType = frameOptions ? ICMCompressionFrameOptionsGetFrameType(frameOptions) : kICMFrameType_Unknown;

return requestedFrameType;

}

//These DITL functions are based off of tech notes here http://developer.apple.com/mac/library/technotes/tn2002/tn2081.html

// Item numbers

//

#define kItemOnePass 1

#define kItemTwoPass 2

#define kItemAdvanced 3

pascal ComponentResult VP8_Encoder_GetDITLForSize(VP8EncoderGlobals store,

Handle *ditl,

Point *requestedSize)

{

Handle h = NULL;

ComponentResult err = noErr;

switch (requestedSize->h) {

case kSGSmallestDITLSize:

GetComponentResource((Component)(store->self), FOUR_CHAR_CODE('DITL'),

kVP8_EncoderDITLResID, &h);

if (NULL != h) *ditl = h;

else err = resNotFound;

break;

default:

err = badComponentSelector;

break;

}

return err;

}

pascal ComponentResult VP8_Encoder_DITLInstall(VP8EncoderGlobals storage,

DialogRef d,

short itemOffset)

{

ControlRef cRef;

unsigned long onePassRadio = (*storage).settings[1] == 1;

unsigned long twoPassRadio = (*storage).settings[1] == 2;

GetDialogItemAsControl(d, kItemOnePass + itemOffset, &cRef);

SetControl32BitValue(cRef, onePassRadio);

GetDialogItemAsControl(d, kItemTwoPass + itemOffset, &cRef);

SetControl32BitValue(cRef, twoPassRadio);

return noErr;

}

pascal ComponentResult VP8_Encoder_DITLEvent(VP8EncoderGlobals storage,

Boolean *handled)

{

*handled = false;

return noErr;

}

pascal ComponentResult VP8_Encoder_DITLItem(VP8EncoderGlobals storage,

DialogRef d,

short itemOffset,

short itemNum)

{

ControlRef onePassControlRef;

ControlRef twoPassControlRef;

GetDialogItemAsControl(d, itemOffset + kItemOnePass, &onePassControlRef);

GetDialogItemAsControl(d, itemOffset + kItemTwoPass, &twoPassControlRef);

switch (itemNum - itemOffset) {

case kItemOnePass:

SetControl32BitValue(onePassControlRef, 1);

SetControl32BitValue(twoPassControlRef, 0);

break;

case kItemTwoPass:

SetControl32BitValue(onePassControlRef, 0);

SetControl32BitValue(twoPassControlRef, 1);

break;

case kItemAdvanced:

runAdvancedWindow(storage);

break;

}

return noErr;

}

pascal ComponentResult VP8_Encoder_DITLRemove(VP8EncoderGlobals storage,

DialogRef d,

short itemOffset)

{

ControlRef cRef;

UInt32 onePass;

GetDialogItemAsControl(d, kItemOnePass + itemOffset, &cRef);

onePass = GetControl32BitValue(cRef);

(*storage).settings[1] = onePass?1:2;

return noErr;

}

pascal ComponentResult VP8_Encoder_DITLValidateInput(VP8EncoderGlobals storage,

Boolean *ok)

{

if (ok)

*ok = true;

return noErr;

}

ComponentResult VP8_Encoder_GetSettings(VP8EncoderGlobals globals, Handle settings)

{

ComponentResult err = noErr;

dbg_printf("[VP8e -- %08lx] GetSettings()\n", (UInt32) globals);

if (!settings) {

err = paramErr;

dbg_printf("[VP8e -- %08lx] ParamErr\n", (UInt32) globals);

} else {

SetHandleSize(settings, TOTAL_CUSTOM_VP8_SETTINGS * 4);

((UInt32 *) *settings)[0] = 'VP80';

int i;

for (i=1;i < TOTAL_CUSTOM_VP8_SETTINGS; i++)

{

((UInt32 *) *settings)[i] = globals->settings[i];

//dbg_printf("[vp8e] get setting %d as %lu\n",i,((UInt32 *) *settings)[i]);

}

}

return err;

}

ComponentResult VP8_Encoder_SetSettings(VP8EncoderGlobals globals, Handle settings)

{

ComponentResult err = noErr;

dbg_printf("[VP8e -- %08lx] SetSettings() %d\n", (UInt32) globals, GetHandleSize(settings));

int i;

if (!settings || GetHandleSize(settings) == 0) {

dbg_printf("[VP8e] no handle\n");

for (i=1;i< TOTAL_CUSTOM_VP8_SETTINGS; i++)

globals->settings[i] = UINT_MAX; //default

}

else if (GetHandleSize(settings) == TOTAL_CUSTOM_VP8_SETTINGS * 4 && ((UInt32 *) *settings)[0] == 'VP80') {

for (i=1;i< TOTAL_CUSTOM_VP8_SETTINGS; i++)

{

globals->settings[i] = ((UInt32 *) *settings)[i];

}

} else {

dbg_printf("[VP8e] ParamErr\n");

err = paramErr;

}

return err;

}

ComponentResult VP8_Encoder_RequestSettings(VP8EncoderGlobals globals, Handle settings,

Rect *rp, ModalFilterUPP filterProc)

{

dbg_printf("[VP8e -- %08lx] RequestSettings()\n", (UInt32) globals);

return badComponentSelector;

}

pascal ComponentResult VP8_Encoder_BeginPass(VP8EncoderGlobals globals,ICMCompressionPassModeFlags passModeFlags,

UInt32 flags, ICMMultiPassStorageRef multiPassStorage )

{

ComponentResult err = noErr;

dbg_printf("[VP8e -- %08lx] VP8_Encoder_BeginPass(%lu, %lu) \n", (UInt32) globals, passModeFlags,flags);

if ((passModeFlags &kICMCompressionPassMode_OutputEncodedFrames)

&& !(passModeFlags & kICMCompressionPassMode_ReadFromMultiPassStorage))

{

dbg_printf("[VP8e -- %08lx] default 1 pass \n", (UInt32) globals);

globals->currentPass = VPX_RC_ONE_PASS;

}

else if ((passModeFlags & kICMCompressionPassMode_WriteToMultiPassStorage) &&

!(passModeFlags & kICMCompressionPassMode_OutputEncodedFrames))

{

dbg_printf("[VP8e -- %08lx] First Pass \n", (UInt32) globals);

if (globals->stats.buf != NULL)

{

free(globals->stats.buf);

globals->stats.buf =NULL;

globals->stats.sz=0;

}

globals->currentPass = VPX_RC_FIRST_PASS;

}

else if ((passModeFlags & kICMCompressionPassMode_OutputEncodedFrames)

&& (passModeFlags & kICMCompressionPassMode_ReadFromMultiPassStorage))

{

dbg_printf("[VP8e -- %08lx] Second Pass \n", (UInt32) globals);

globals->currentPass = VPX_RC_LAST_PASS;

if (globals->codec == NULL) // this should be initialized if there was a first pass

return nilHandleErr;

globals->cfg.g_pass = VPX_RC_LAST_PASS;

globals->cfg.rc_twopass_stats_in.sz = globals->stats.sz;

globals->cfg.rc_twopass_stats_in.buf = globals->stats.buf;

globals->frameCount = 0;

if(vpx_codec_enc_init(globals->codec, &vpx_codec_vp8_cx_algo, &globals->cfg, 0))

{

const char *detail = vpx_codec_error_detail(globals->codec);

dbg_printf("[VP8e] Failed to initialize encoder second pass %s\n", detail);

return notOpenErr;

}

setCustomPostInit(globals); //not sure if I this is needed just following ivfenc example

}

else

{

return paramErr;///not sure what other type of pass there is

}

return err;

}

pascal ComponentResult VP8_Encoder_EndPass(VP8EncoderGlobals globals)

{

ComponentResult err = noErr;

dbg_printf("[VP8e -- %08lx] VP8_Encoder_EndPass(%lu, %lu) \n", (UInt32) globals);

if (globals->currentPass == VPX_RC_FIRST_PASS)

{

unsigned int prevStatsSize = 0;

while (globals->stats.sz != prevStatsSize)

{

prevStatsSize = globals->stats.sz;

//send a null frame to encode frame, this ends off the encoder stats

encodeThisSourceFrame(globals, NULL);

}

//reset all my stats

globals->frameCount =0;

}

//I don't need to do anything here currently for the second pass

return err;

}

pascal ComponentResult VP8_Encoder_ProcessBetweenPasses(VP8EncoderGlobals globals, ICMMultiPassStorageRef multiPassStorage,

Boolean * interpassProcessingDoneOut,

ICMCompressionPassModeFlags * requestedNextPassModeFlagsOut)

{

ComponentResult err = noErr;

dbg_printf("[VP8e -- %08lx] VP8_Encoder_ProcessBetweenPasses \n", (UInt32) globals);

//I don't need to do anything here currently

return err;

}