671 lines
20 KiB
C++
671 lines
20 KiB
C++
// rpcli.cpp - Minimal RealAudio 5/6 (G2) CLI encoder using RealProducer ActiveX
|
||
// Build (MSVC example):
|
||
// cl rpcli.cpp /EHsc /D_CRT_SECURE_NO_WARNINGS ole32.lib oleaut32.lib
|
||
//
|
||
// You must also #import the RealProducer control type library (prct3260.ocx).
|
||
// Adjust the path below to wherever the control is registered/installed.
|
||
|
||
#ifndef __cplusplus
|
||
#error rpcli.cpp uses C++ COM features (#import, __uuidof). Compile with MSVC C++.
|
||
#endif
|
||
|
||
#define COBJMACROS
|
||
#include <windows.h>
|
||
#include <ole2.h>
|
||
#include <oleauto.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#import "prct3260.ocx" no_namespace named_guids raw_interfaces_only
|
||
|
||
static void die(const char *msg);
|
||
|
||
static BSTR ansi_to_bstr(const char *s) {
|
||
int wlen;
|
||
BSTR b;
|
||
if (!s) {
|
||
return NULL;
|
||
}
|
||
|
||
wlen = MultiByteToWideChar(CP_ACP, 0, s, -1, NULL, 0);
|
||
if (wlen <= 0) {
|
||
return NULL;
|
||
}
|
||
|
||
b = SysAllocStringLen(NULL, (UINT)(wlen - 1));
|
||
if (!b) {
|
||
return NULL;
|
||
}
|
||
|
||
if (MultiByteToWideChar(CP_ACP, 0, s, -1, b, wlen) <= 0) {
|
||
SysFreeString(b);
|
||
return NULL;
|
||
}
|
||
|
||
return b;
|
||
}
|
||
|
||
static void bstr_to_ansi(BSTR b, char *buf, size_t bufSize) {
|
||
if (!buf || bufSize == 0) {
|
||
return;
|
||
}
|
||
|
||
buf[0] = '\0';
|
||
if (!b) {
|
||
return;
|
||
}
|
||
|
||
WideCharToMultiByte(CP_ACP, 0, b, -1, buf, (int)bufSize, NULL, NULL);
|
||
}
|
||
|
||
static void pump_pending_messages(void) {
|
||
MSG msg;
|
||
|
||
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
||
TranslateMessage(&msg);
|
||
DispatchMessage(&msg);
|
||
}
|
||
}
|
||
|
||
static void die_last_error(IProducerControl *ctl, const char *fallback) {
|
||
long lastError = 0;
|
||
BSTR errorText = NULL;
|
||
char buf[512];
|
||
|
||
if (!ctl) {
|
||
die(fallback);
|
||
}
|
||
|
||
if (FAILED(ctl->get_LastError(&lastError)) || lastError == 0) {
|
||
die(fallback);
|
||
}
|
||
|
||
if (SUCCEEDED(ctl->GetErrorString(lastError, &errorText)) && errorText) {
|
||
bstr_to_ansi(errorText, buf, sizeof(buf));
|
||
SysFreeString(errorText);
|
||
fprintf(stderr, "error: %s (code=%ld)\n", buf[0] ? buf : fallback, lastError);
|
||
} else {
|
||
fprintf(stderr, "error: %s (code=%ld)\n", fallback, lastError);
|
||
}
|
||
|
||
ExitProcess(1);
|
||
}
|
||
|
||
// Simple helper: print and exit
|
||
static void die(const char *msg) {
|
||
fprintf(stderr, "error: %s\n", msg);
|
||
ExitProcess(1);
|
||
}
|
||
|
||
// Map rating string to something we can store as a property
|
||
static const char *rating_to_str(const char *r) {
|
||
if (_stricmp(r, "G") == 0) return "G";
|
||
if (_stricmp(r, "PG") == 0) return "PG";
|
||
if (_stricmp(r, "R") == 0) return "R";
|
||
if (_stricmp(r, "X") == 0) return "X";
|
||
return NULL;
|
||
}
|
||
|
||
// Mode → AUDIO_CONTENT_* (from docs)
|
||
static AUDIO_CONTENT mode_to_audio_content(const char *m) {
|
||
// These constants come from the RealProducer type library.
|
||
// You’ll need to confirm exact values in the imported header:
|
||
// AUDIO_CONTENT_VOICE, AUDIO_CONTENT_VOICE_OVER_MUSIC, AUDIO_CONTENT_MUSIC, AUDIO_CONTENT_STEREO, etc.
|
||
if (_stricmp(m, "voice") == 0) return AUDIO_CONTENT_VOICE;
|
||
if (_stricmp(m, "voice-bgm") == 0) return AUDIO_CONTENT_VOICE_BACKGROUND;
|
||
if (_stricmp(m, "stereo") == 0) return AUDIO_CONTENT_MUSIC_STEREO;
|
||
// default: music
|
||
return AUDIO_CONTENT_MUSIC;
|
||
}
|
||
|
||
// Target → TARGET_* + TargetXXModem property
|
||
typedef enum {
|
||
TGT_WEBTV,
|
||
TGT_56K,
|
||
TGT_ISDN,
|
||
TGT_CABLE,
|
||
TGT_PC
|
||
} target_t;
|
||
|
||
typedef struct {
|
||
ICodecCookie *cookie;
|
||
AUDIO_CONTENT content;
|
||
long codecId;
|
||
long flavorId;
|
||
char name[512];
|
||
} selected_codec_t;
|
||
|
||
static target_t parse_target(const char *s) {
|
||
if (!s) return TGT_WEBTV;
|
||
if (_stricmp(s, "WebTV") == 0) return TGT_WEBTV;
|
||
if (_stricmp(s, "56k") == 0) return TGT_56K;
|
||
if (_stricmp(s, "ISDN") == 0) return TGT_ISDN;
|
||
if (_stricmp(s, "Cable") == 0) return TGT_CABLE;
|
||
if (_stricmp(s, "PC") == 0) return TGT_PC;
|
||
return TGT_WEBTV;
|
||
}
|
||
|
||
static TARGET_AUDIENCE target_to_audience(target_t tgt) {
|
||
switch (tgt) {
|
||
case TGT_WEBTV:
|
||
return TARGET_28_MODEM;
|
||
case TGT_56K:
|
||
return TARGET_56_MODEM;
|
||
case TGT_ISDN:
|
||
return TARGET_SINGLE_ISDN;
|
||
case TGT_CABLE:
|
||
return TARGET_LAN_LOW;
|
||
case TGT_PC:
|
||
return TARGET_LAN_HIGH;
|
||
}
|
||
|
||
return TARGET_28_MODEM;
|
||
}
|
||
|
||
static AUDIO_CONTENT codec_name_to_audio_content(const char *name) {
|
||
if (!name) {
|
||
return AUDIO_CONTENT_MUSIC;
|
||
}
|
||
if (strstr(name, "Stereo") != NULL) {
|
||
return AUDIO_CONTENT_MUSIC_STEREO;
|
||
}
|
||
if (strstr(name, "Music") != NULL) {
|
||
return AUDIO_CONTENT_MUSIC;
|
||
}
|
||
return AUDIO_CONTENT_VOICE;
|
||
}
|
||
|
||
static int parse_codec_index(const char *s) {
|
||
char *end = NULL;
|
||
long value;
|
||
|
||
if (!s || !*s) {
|
||
return -1;
|
||
}
|
||
|
||
value = strtol(s, &end, 10);
|
||
if (!end || *end != '\0' || value < 0 || value > 0x7fffffffL) {
|
||
return -1;
|
||
}
|
||
|
||
return (int)value;
|
||
}
|
||
|
||
static int get_audio_codec_by_index(IProducerControl *ctl, int codecIndex, selected_codec_t *selected) {
|
||
IEnumIDispatch *enumDisp = NULL;
|
||
HRESULT hr;
|
||
LONG count = 0;
|
||
IDispatch *pDisp = NULL;
|
||
LONG i;
|
||
|
||
if (!selected) {
|
||
return 0;
|
||
}
|
||
|
||
memset(selected, 0, sizeof(*selected));
|
||
selected->codecId = -1;
|
||
selected->flavorId = -1;
|
||
selected->content = AUDIO_CONTENT_MUSIC;
|
||
|
||
hr = ctl->get_AudioCodecEnum(&enumDisp);
|
||
if (FAILED(hr) || !enumDisp) {
|
||
return 0;
|
||
}
|
||
|
||
enumDisp->GetCount(&count);
|
||
if (codecIndex < 0 || codecIndex >= count) {
|
||
enumDisp->Release();
|
||
return 0;
|
||
}
|
||
|
||
enumDisp->First(&pDisp);
|
||
for (i = 0; i < count && pDisp; ++i) {
|
||
if (i == codecIndex) {
|
||
IAudioCodecInfo *codec = NULL;
|
||
if (SUCCEEDED(pDisp->QueryInterface(__uuidof(IAudioCodecInfo), (void**)&codec))) {
|
||
BSTR name = NULL;
|
||
codec->get_CodecName(&name);
|
||
codec->get_CodecCookie(&selected->cookie);
|
||
if (selected->cookie) {
|
||
selected->cookie->get_codecId(&selected->codecId);
|
||
selected->cookie->get_flavorId(&selected->flavorId);
|
||
}
|
||
bstr_to_ansi(name, selected->name, sizeof(selected->name));
|
||
selected->content = codec_name_to_audio_content(selected->name);
|
||
if (name) SysFreeString(name);
|
||
codec->Release();
|
||
}
|
||
pDisp->Release();
|
||
enumDisp->Release();
|
||
return selected->cookie != NULL;
|
||
}
|
||
|
||
{
|
||
IDispatch *next = NULL;
|
||
enumDisp->Next(&next);
|
||
pDisp->Release();
|
||
pDisp = next;
|
||
}
|
||
}
|
||
|
||
if (pDisp) pDisp->Release();
|
||
enumDisp->Release();
|
||
return 0;
|
||
}
|
||
|
||
static int apply_audio_codec_to_target(ITargetAudienceInfo *info,
|
||
AUDIO_CONTENT content,
|
||
ICodecCookie *cookie) {
|
||
if (!info || !cookie) {
|
||
return 0;
|
||
}
|
||
|
||
return SUCCEEDED(info->put_AudioCodec(TARGET_AUDIENCES_AUDIO, content, cookie));
|
||
}
|
||
|
||
static int apply_selected_audio_codec(IProducerControl *ctl,
|
||
target_t tgt,
|
||
const selected_codec_t *selected) {
|
||
ITargetAudienceInfo *info = NULL;
|
||
TARGET_AUDIENCE audienceList[] = {
|
||
TARGET_28_MODEM,
|
||
TARGET_56_MODEM,
|
||
TARGET_SINGLE_ISDN,
|
||
TARGET_DUAL_ISDN,
|
||
TARGET_LAN_LOW,
|
||
TARGET_LAN_HIGH
|
||
};
|
||
int applied = 0;
|
||
int i;
|
||
|
||
if (!ctl || !selected || !selected->cookie) {
|
||
return 0;
|
||
}
|
||
|
||
for (i = 0; i < (int)(sizeof(audienceList) / sizeof(audienceList[0])); ++i) {
|
||
if (SUCCEEDED(ctl->get_TargetAudienceInfo(audienceList[i], &info)) && info) {
|
||
applied |= apply_audio_codec_to_target(info, selected->content, selected->cookie);
|
||
info->Release();
|
||
info = NULL;
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(ctl->get_TargetAudienceInfo(target_to_audience(tgt), &info)) && info) {
|
||
applied |= apply_audio_codec_to_target(info, selected->content, selected->cookie);
|
||
info->Release();
|
||
}
|
||
|
||
return applied;
|
||
}
|
||
|
||
// Enable only one target audience based on CLI
|
||
static void set_target_audience(IProducerControl *ctl, target_t tgt) {
|
||
// First, clear all target audiences
|
||
ctl->put_Target28KModem(VARIANT_FALSE);
|
||
ctl->put_Target56KModem(VARIANT_FALSE);
|
||
ctl->put_TargetSingleISDN(VARIANT_FALSE);
|
||
ctl->put_TargetDSLCableModem(VARIANT_FALSE);
|
||
ctl->put_TargetLAN(VARIANT_FALSE);
|
||
|
||
switch (tgt) {
|
||
case TGT_WEBTV:
|
||
ctl->put_Target28KModem(VARIANT_TRUE);
|
||
break;
|
||
case TGT_56K:
|
||
ctl->put_Target56KModem(VARIANT_TRUE);
|
||
break;
|
||
case TGT_ISDN:
|
||
ctl->put_TargetSingleISDN(VARIANT_TRUE);
|
||
break;
|
||
case TGT_CABLE:
|
||
ctl->put_TargetDSLCableModem(VARIANT_TRUE);
|
||
break;
|
||
case TGT_PC:
|
||
ctl->put_TargetLAN(VARIANT_TRUE);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// List all audio codecs using AudioCodecEnum
|
||
static void list_codecs(IProducerControl *ctl) {
|
||
IEnumIDispatch *enumDisp = NULL;
|
||
HRESULT hr = ctl->get_AudioCodecEnum(&enumDisp);
|
||
if (FAILED(hr) || !enumDisp) {
|
||
die("failed to get AudioCodecEnum");
|
||
}
|
||
|
||
LONG count = 0;
|
||
enumDisp->GetCount(&count);
|
||
|
||
printf("Available audio codecs:\n");
|
||
|
||
IDispatch *pDisp = NULL;
|
||
enumDisp->First(&pDisp);
|
||
for (LONG i = 0; i < count && pDisp; ++i) {
|
||
IAudioCodecInfo *codec = NULL;
|
||
if (SUCCEEDED(pDisp->QueryInterface(__uuidof(IAudioCodecInfo), (void**)&codec))) {
|
||
BSTR name = NULL;
|
||
ICodecCookie *cookie = NULL;
|
||
long codecId = -1;
|
||
long flavorId = -1;
|
||
codec->get_CodecName(&name);
|
||
codec->get_CodecCookie(&cookie);
|
||
if (cookie) {
|
||
cookie->get_codecId(&codecId);
|
||
cookie->get_flavorId(&flavorId);
|
||
}
|
||
|
||
char buf[512];
|
||
WideCharToMultiByte(CP_ACP, 0, name, -1, buf, sizeof(buf), NULL, NULL);
|
||
printf(" %ld: %s (codecId=%ld, flavorId=%ld)\n", i, buf, codecId, flavorId);
|
||
|
||
SysFreeString(name);
|
||
if (cookie) cookie->Release();
|
||
codec->Release();
|
||
}
|
||
IDispatch *next = NULL;
|
||
enumDisp->Next(&next);
|
||
pDisp->Release();
|
||
pDisp = next;
|
||
}
|
||
|
||
if (pDisp) pDisp->Release();
|
||
enumDisp->Release();
|
||
}
|
||
|
||
// Set basic clip properties (Title, Author, etc.)
|
||
static void set_clip_properties(IProducerControl *ctl,
|
||
const char *title,
|
||
const char *author,
|
||
const char *copyright,
|
||
const char *description,
|
||
const char *keywords,
|
||
const char *rating) {
|
||
if (title) {
|
||
BSTR b = ansi_to_bstr(title);
|
||
ctl->put_Title(b);
|
||
SysFreeString(b);
|
||
}
|
||
if (author) {
|
||
BSTR b = ansi_to_bstr(author);
|
||
ctl->put_Author(b);
|
||
SysFreeString(b);
|
||
}
|
||
if (copyright) {
|
||
BSTR b = ansi_to_bstr(copyright);
|
||
ctl->put_Copyright(b);
|
||
SysFreeString(b);
|
||
}
|
||
|
||
// Extra metadata via SetStringProperty (from docs)
|
||
if (description) {
|
||
BSTR key = SysAllocString(L"Description");
|
||
BSTR val = ansi_to_bstr(description);
|
||
ctl->SetStringProperty(key, val);
|
||
SysFreeString(key);
|
||
SysFreeString(val);
|
||
}
|
||
if (keywords) {
|
||
BSTR key = SysAllocString(L"Keywords");
|
||
BSTR val = ansi_to_bstr(keywords);
|
||
ctl->SetStringProperty(key, val);
|
||
SysFreeString(key);
|
||
SysFreeString(val);
|
||
}
|
||
if (rating) {
|
||
const char *r = rating_to_str(rating);
|
||
if (r) {
|
||
BSTR key = SysAllocString(L"Rating");
|
||
BSTR val = ansi_to_bstr(r);
|
||
ctl->SetStringProperty(key, val);
|
||
SysFreeString(key);
|
||
SysFreeString(val);
|
||
}
|
||
}
|
||
|
||
// SelectiveRecord, MobilePlay, Indexable → false via custom numeric props
|
||
// Names are inferred; adjust to actual property names if they exist directly.
|
||
{
|
||
BSTR key = SysAllocString(L"SelectiveRecord");
|
||
ctl->SetNumberProperty(key, 0);
|
||
SysFreeString(key);
|
||
}
|
||
{
|
||
BSTR key = SysAllocString(L"MobilePlay");
|
||
ctl->SetNumberProperty(key, 0);
|
||
SysFreeString(key);
|
||
}
|
||
{
|
||
BSTR key = SysAllocString(L"Indexable");
|
||
ctl->SetNumberProperty(key, 0);
|
||
SysFreeString(key);
|
||
}
|
||
}
|
||
|
||
static void usage(void) {
|
||
fprintf(stderr,
|
||
"Usage: rpcli [options] input.wav [output.ra]\n"
|
||
"Options:\n"
|
||
" --ra5 | --g2 Set PlayerCompatibility (default: G2 / PLAYER_6)\n"
|
||
" --codec-list List available audio codecs and exit\n"
|
||
" --codec N Select codec list entry N; mutually exclusive with --target\n"
|
||
" --mode voice|voice-bgm|stereo|music (default: music)\n"
|
||
" --target WebTV|56k|ISDN|Cable|PC (default: WebTV)\n"
|
||
" --title TEXT\n"
|
||
" --author TEXT\n"
|
||
" --copyright TEXT\n"
|
||
" --description TEXT\n"
|
||
" --keywords TEXT\n"
|
||
" --rating G|PG|R|X\n"
|
||
);
|
||
}
|
||
|
||
int main(int argc, char **argv) {
|
||
const char *mode = "music";
|
||
const char *target_str = "WebTV";
|
||
const char *title = NULL;
|
||
const char *author = NULL;
|
||
const char *copyright = NULL;
|
||
const char *description = NULL;
|
||
const char *keywords = NULL;
|
||
const char *rating = NULL;
|
||
int player_is_ra5 = 0;
|
||
int do_codec_list = 0;
|
||
int codec_index = -1;
|
||
int target_was_explicit = 0;
|
||
selected_codec_t selected_codec;
|
||
|
||
const char *infile = NULL;
|
||
char outbuf[MAX_PATH] = {0};
|
||
const char *outfile = NULL;
|
||
|
||
// Parse options
|
||
int i = 1;
|
||
for (; i < argc; ++i) {
|
||
if (strcmp(argv[i], "--ra5") == 0) {
|
||
player_is_ra5 = 1;
|
||
} else if (strcmp(argv[i], "--g2") == 0) {
|
||
player_is_ra5 = 0;
|
||
} else if (strcmp(argv[i], "--codec-list") == 0) {
|
||
do_codec_list = 1;
|
||
} else if (strcmp(argv[i], "--codec") == 0 && i+1 < argc) {
|
||
codec_index = parse_codec_index(argv[++i]);
|
||
if (codec_index < 0) {
|
||
die("--codec requires a non-negative integer");
|
||
}
|
||
} else if (strcmp(argv[i], "--mode") == 0 && i+1 < argc) {
|
||
mode = argv[++i];
|
||
} else if (strcmp(argv[i], "--target") == 0 && i+1 < argc) {
|
||
target_str = argv[++i];
|
||
target_was_explicit = 1;
|
||
} else if (strcmp(argv[i], "--title") == 0 && i+1 < argc) {
|
||
title = argv[++i];
|
||
} else if (strcmp(argv[i], "--author") == 0 && i+1 < argc) {
|
||
author = argv[++i];
|
||
} else if (strcmp(argv[i], "--copyright") == 0 && i+1 < argc) {
|
||
copyright = argv[++i];
|
||
} else if (strcmp(argv[i], "--description") == 0 && i+1 < argc) {
|
||
description = argv[++i];
|
||
} else if (strcmp(argv[i], "--keywords") == 0 && i+1 < argc) {
|
||
keywords = argv[++i];
|
||
} else if (strcmp(argv[i], "--rating") == 0 && i+1 < argc) {
|
||
rating = argv[++i];
|
||
} else if (strncmp(argv[i], "--", 2) == 0) {
|
||
fprintf(stderr, "unknown option: %s\n", argv[i]);
|
||
usage();
|
||
return 1;
|
||
} else {
|
||
// first non-option is input
|
||
infile = argv[i];
|
||
if (i+1 < argc) {
|
||
outfile = argv[i+1];
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!infile && !do_codec_list) {
|
||
usage();
|
||
return 1;
|
||
}
|
||
|
||
if (codec_index >= 0 && target_was_explicit) {
|
||
die("--codec is mutually exclusive with --target");
|
||
}
|
||
|
||
if (!outfile && infile) {
|
||
// derive output: input + ".ra"
|
||
const char *p = strrchr(infile, '.');
|
||
size_t len = p ? (size_t)(p - infile) : strlen(infile);
|
||
if (len >= sizeof(outbuf)-4) die("input filename too long");
|
||
memcpy(outbuf, infile, len);
|
||
strcpy(outbuf + len, ".ra");
|
||
outfile = outbuf;
|
||
}
|
||
|
||
HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||
if (FAILED(hr)) die("CoInitialize failed");
|
||
|
||
IProducerControl *ctl = NULL;
|
||
hr = CoCreateInstance(__uuidof(ProducerControl),
|
||
NULL,
|
||
CLSCTX_INPROC_SERVER,
|
||
__uuidof(IProducerControl),
|
||
(void**)&ctl);
|
||
if (FAILED(hr) || !ctl) {
|
||
CoUninitialize();
|
||
die("failed to create ProducerControl (is prct3260.ocx installed/registered?)");
|
||
}
|
||
|
||
if (do_codec_list) {
|
||
list_codecs(ctl);
|
||
ctl->Release();
|
||
CoUninitialize();
|
||
return 0;
|
||
}
|
||
|
||
memset(&selected_codec, 0, sizeof(selected_codec));
|
||
selected_codec.codecId = -1;
|
||
selected_codec.flavorId = -1;
|
||
|
||
if (codec_index >= 0 && !get_audio_codec_by_index(ctl, codec_index, &selected_codec)) {
|
||
ctl->Release();
|
||
CoUninitialize();
|
||
die("invalid codec index");
|
||
}
|
||
|
||
// Input properties
|
||
ctl->put_InputType(INPUT_SOURCE_FILE);
|
||
{
|
||
BSTR b = ansi_to_bstr(infile);
|
||
ctl->put_InputFilename(b);
|
||
SysFreeString(b);
|
||
}
|
||
ctl->put_InputDoAudio(VARIANT_TRUE);
|
||
ctl->put_InputDoVideo(VARIANT_FALSE);
|
||
ctl->put_InputDoEvents(VARIANT_FALSE);
|
||
|
||
// Output properties
|
||
ctl->put_DoOutputFile(VARIANT_TRUE);
|
||
{
|
||
BSTR b = ansi_to_bstr(outfile);
|
||
ctl->put_OutputFilename(b);
|
||
SysFreeString(b);
|
||
}
|
||
|
||
// PlayerCompatibility: RA5 vs G2 (PLAYER_5 / PLAYER_6)
|
||
ctl->put_PlayerCompatibility(player_is_ra5 ? PLAYER_5 : PLAYER_6);
|
||
|
||
// SureStream: hard-coded false (single-rate)
|
||
ctl->put_SureStream(VARIANT_FALSE);
|
||
|
||
// AudioContent (mode)
|
||
ctl->put_AudioContent(codec_index >= 0 ? selected_codec.content : mode_to_audio_content(mode));
|
||
|
||
// Target audience
|
||
set_target_audience(ctl, parse_target(target_str));
|
||
|
||
if (codec_index >= 0 && !apply_selected_audio_codec(ctl, parse_target(target_str), &selected_codec)) {
|
||
if (selected_codec.cookie) selected_codec.cookie->Release();
|
||
ctl->Release();
|
||
CoUninitialize();
|
||
die("failed to apply selected codec");
|
||
}
|
||
|
||
// Clip properties + custom props
|
||
set_clip_properties(ctl, title, author, copyright,
|
||
description, keywords, rating);
|
||
|
||
// Start encoding
|
||
hr = ctl->StartEncoding();
|
||
if (FAILED(hr)) {
|
||
ctl->Release();
|
||
CoUninitialize();
|
||
die("StartEncoding failed");
|
||
}
|
||
|
||
// RealProducer uses STA COM callbacks/messages while encoding.
|
||
// Pump the queue so the control can make progress in a console app.
|
||
VARIANT_BOOL isEnc = VARIANT_FALSE;
|
||
DWORD startTick = GetTickCount();
|
||
do {
|
||
long lastError = 0;
|
||
|
||
pump_pending_messages();
|
||
ctl->get_IsEncoding(&isEnc);
|
||
|
||
if (SUCCEEDED(ctl->get_LastError(&lastError)) && lastError != 0) {
|
||
ctl->StopEncoding();
|
||
if (selected_codec.cookie) selected_codec.cookie->Release();
|
||
die_last_error(ctl, "encoding failed");
|
||
}
|
||
|
||
if (GetTickCount() - startTick > 300000) {
|
||
ctl->StopEncoding();
|
||
if (selected_codec.cookie) selected_codec.cookie->Release();
|
||
die_last_error(ctl, "encoding timed out");
|
||
}
|
||
|
||
MsgWaitForMultipleObjects(0, NULL, FALSE, 100, QS_ALLINPUT);
|
||
} while (isEnc == VARIANT_TRUE);
|
||
|
||
{
|
||
long lastError = 0;
|
||
if (SUCCEEDED(ctl->get_LastError(&lastError)) && lastError != 0) {
|
||
if (selected_codec.cookie) selected_codec.cookie->Release();
|
||
die_last_error(ctl, "encoding completed with an error");
|
||
}
|
||
}
|
||
|
||
// StopEncoding (in case)
|
||
ctl->StopEncoding();
|
||
|
||
if (selected_codec.cookie) selected_codec.cookie->Release();
|
||
ctl->Release();
|
||
CoUninitialize();
|
||
|
||
printf("Encoded %s -> %s\n", infile, outfile);
|
||
return 0;
|
||
}
|