static void MLOG_open()
{
char filebuf[80];
if (MLOGFP) return;
generate_filename(logdir ? logdir : MYLOGDIR, MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
if (!MLOGFP)
{
generate_homefile(MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
if (!MLOGFP)
{
generate_filename("C:\\podbclog", MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
#ifdef WIN32
if (!MLOGFP)
{
if (0 == _mkdir(PODBCLOGDIR))
MLOGFP = fopen(filebuf, PG_BINARY_A);
}
#endif /* WIN32 */
}
}
if (MLOGFP)
setbuf(MLOGFP, NULL);
}
void
forcelog(const char *fmt,...)
{
static BOOL force_on = TRUE;
va_list args;
char filebuf[80];
int gerrno = GENERAL_ERRNO;
if (!force_on)
return;
ENTER_MYLOG_CS;
va_start(args, fmt);
if (!MLOGFP)
{
generate_filename(MYLOGDIR, MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
if (MLOGFP)
setbuf(MLOGFP, NULL);
if (!MLOGFP)
{
generate_homefile(MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
}
if (!MLOGFP)
{
generate_filename("C:\\podbclog", MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
}
if (MLOGFP)
setbuf(MLOGFP, NULL);
else
force_on = FALSE;
}
if (MLOGFP)
{
#ifdef WIN_MULTITHREAD_SUPPORT
#ifdef WIN32
time_t ntime;
char ctim[128];
time(&ntime);
strcpy(ctim, ctime(&ntime));
ctim[strlen(ctim) - 1] = '\0';
fprintf(MLOGFP, "[%d.%d(%s)]", GetCurrentProcessId(), GetCurrentThreadId(), ctim);
#endif /* WIN32 */
#endif /* WIN_MULTITHREAD_SUPPORT */
#if defined(POSIX_MULTITHREAD_SUPPORT)
fprintf(MLOGFP, "[%lu]", pthread_self());
#endif /* POSIX_MULTITHREAD_SUPPORT */
vfprintf(MLOGFP, fmt, args);
}
va_end(args);
LEAVE_MYLOG_CS;
GENERAL_ERRNO_SET(gerrno);
}
DLL_DECLARE void
mylog(const char *fmt,...)
{
va_list args;
char filebuf[80];
int gerrno;
if (!mylog_on) return;
gerrno = GENERAL_ERRNO;
ENTER_MYLOG_CS;
#ifdef LOGGING_PROCESS_TIME
if (!start_time)
start_time = timeGetTime();
#endif /* LOGGING_PROCESS_TIME */
va_start(args, fmt);
if (!MLOGFP)
{
generate_filename(logdir ? logdir : MYLOGDIR, MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
if (!MLOGFP)
{
generate_homefile(MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
if (!MLOGFP)
{
generate_filename("C:\\podbclog", MYLOGFILE, filebuf);
MLOGFP = fopen(filebuf, PG_BINARY_A);
}
}
if (MLOGFP)
setbuf(MLOGFP, NULL);
else
mylog_on = 0;
}
if (MLOGFP)
{
#ifdef WIN_MULTITHREAD_SUPPORT
#ifdef LOGGING_PROCESS_TIME
DWORD proc_time = timeGetTime() - start_time;
fprintf(MLOGFP, "[%u-%d.%03d]", GetCurrentThreadId(), proc_time / 1000, proc_time % 1000);
#else
fprintf(MLOGFP, "[%u]", GetCurrentThreadId());
#endif /* LOGGING_PROCESS_TIME */
#endif /* WIN_MULTITHREAD_SUPPORT */
#if defined(POSIX_MULTITHREAD_SUPPORT)
fprintf(MLOGFP, "[%lu]", pthread_self());
#endif /* POSIX_MULTITHREAD_SUPPORT */
vfprintf(MLOGFP, fmt, args);
}
va_end(args);
LEAVE_MYLOG_CS;
GENERAL_ERRNO_SET(gerrno);
}
HRESULT Camera::selectPicture(HWND hwndOwner,LPTSTR pszFilename)
{
RHO_ASSERT(pszFilename);
#if defined( _WIN32_WCE ) && !defined( OS_PLATFORM_MOTCE )
OPENFILENAMEEX ofn = {0};
#else
OPENFILENAME ofn = {0};
#endif
pszFilename[0] = 0;
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = NULL;
ofn.lpstrFile = pszFilename;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = _T("Select an image");
#if defined( _WIN32_WCE ) && !defined( OS_PLATFORM_MOTCE )
ofn.ExFlags = OFN_EXFLAG_THUMBNAILVIEW|OFN_EXFLAG_NOFILECREATE|OFN_EXFLAG_LOCKDIRECTORY;
if (GetOpenFileNameEx(&ofn))
#else
if (GetOpenFileName(&ofn))
#endif
{
HRESULT hResult = S_OK;
/*
TCHAR rhoroot[MAX_PATH];
wchar_t* root = wce_mbtowc(rho_rhodesapp_getblobsdirpath());
wsprintf(rhoroot,L"%s",root);
free(root);
create_folder(rhoroot);*/
StringW strBlobRoot = convertToStringW( RHODESAPP().getBlobsDirPath() );
LPCTSTR szExt = wcsrchr(pszFilename, '.');
TCHAR filename[256];
generate_filename(filename, szExt);
int len = strBlobRoot.length() + wcslen(L"\\") + wcslen(filename);
wchar_t* full_name = (wchar_t*) malloc((len+2)*sizeof(wchar_t));
wsprintf(full_name,L"%s\\%s",strBlobRoot.c_str(),filename);
if (copy_file(pszFilename,full_name))
{
wcscpy( pszFilename, filename );
} else {
hResult = E_INVALIDARG;
}
free(full_name);
return hResult;
} else if (GetLastError()==ERROR_SUCCESS) {
return S_FALSE; //user cancel op
}
return E_INVALIDARG;
}
void VoiceActingManager::build_example(CString section)
{
if (section == "")
{
m_example = "";
return;
}
m_example = generate_filename(section, 1, 2);
}
HRESULT Camera::takePicture(HWND hwndOwner,LPTSTR pszFilename)
{
HRESULT hResult = S_OK;
#if defined(_WIN32_WCE) //&& !defined( OS_PLATFORM_MOTCE )
if(RHO_IS_WMDEVICE)
{
SHCAMERACAPTURE shcc;
StringW imageDir;
convertToStringW(rho_rhodesapp_getblobsdirpath(), imageDir);
StringW strFileName = generate_filename(L".jpg");
// Set the SHCAMERACAPTURE structure.
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = hwndOwner;
shcc.pszInitialDir = imageDir.c_str();
shcc.pszDefaultFileName = strFileName.c_str();
shcc.pszTitle = TEXT("Camera");
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_MESSAGING;
shcc.nResolutionWidth = 176;
shcc.nResolutionHeight = 144;
shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_LOW;
shcc.nVideoTimeLimit = 15;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
// Display the Camera Capture dialog.
hResult = lpfn_Camera_Capture(&shcc);
// The next statements will execute only after the user takes
// a picture or video, or closes the Camera Capture dialog.
if (S_OK == hResult)
{
LOG(INFO) + "takePicture get file: " + shcc.szFile;
LPTSTR fname = get_file_name( shcc.szFile, imageDir.c_str() );
if (fname) {
StringCchCopy( pszFilename, MAX_PATH, fname );
free(fname);
} else {
LOG(ERROR) + "takePicture error get file: " + shcc.szFile;
hResult = E_INVALIDARG;
}
}else
{
LOG(ERROR) + "takePicture failed with code: " + LOGFMT("0x%X") + hResult;
}
}
#endif //_WIN32_WCE
return hResult;
}
HRESULT Camera::takePicture(HWND hwndOwner,LPTSTR pszFilename)
{
HRESULT hResult = S_OK;
#if defined(_WIN32_WCE) && !defined( OS_PLATFORM_MOTCE )
SHCAMERACAPTURE shcc;
StringW root;
convertToStringW(rho_rhodesapp_getblobsdirpath(), root);
wsprintf( pszFilename, L"%s", root.c_str() );
create_folder(pszFilename);
//LPCTSTR szExt = wcsrchr(pszFilename, '.');
TCHAR filename[256];
generate_filename(filename,L".jpg");
// Set the SHCAMERACAPTURE structure.
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = hwndOwner;
shcc.pszInitialDir = pszFilename;
shcc.pszDefaultFileName = filename;
shcc.pszTitle = TEXT("Camera");
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_MESSAGING;
shcc.nResolutionWidth = 176;
shcc.nResolutionHeight = 144;
shcc.nVideoTimeLimit = 15;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
// Display the Camera Capture dialog.
hResult = SHCameraCapture(&shcc);
// The next statements will execute only after the user takes
// a picture or video, or closes the Camera Capture dialog.
if (S_OK == hResult) {
LPTSTR fname = get_file_name(shcc.szFile,pszFilename);
if (fname) {
StringCchCopy(pszFilename, MAX_PATH, fname);
free(fname);
} else {
LOG(ERROR) + "takePicture error get file: " + shcc.szFile;
hResult = E_INVALIDARG;
}
}else
{
LOG(ERROR) + "takePicture failed with code: " + LOGFMT("0x%X") + hResult;
}
#endif //_WIN32_WCE
return hResult;
}
void
qlog(char *fmt,...)
{
va_list args;
char filebuf[80];
int gerrno;
if (!qlog_on) return;
gerrno = GENERAL_ERRNO;
ENTER_QLOG_CS;
#ifdef LOGGING_PROCESS_TIME
if (!start_time)
start_time = timeGetTime();
#endif /* LOGGING_PROCESS_TIME */
va_start(args, fmt);
if (!QLOGFP)
{
generate_filename(QLOGDIR, QLOGFILE, filebuf);
QLOGFP = fopen(filebuf, PG_BINARY_A);
if (!QLOGFP)
{
generate_homefile(QLOGFILE, filebuf);
QLOGFP = fopen(filebuf, PG_BINARY_A);
}
if (QLOGFP)
setbuf(QLOGFP, NULL);
else
qlog_on = 0;
}
if (QLOGFP)
{
#ifdef LOGGING_PROCESS_TIME
DWORD proc_time = timeGetTime() - start_time;
fprintf(QLOGFP, "[%d.%03d]", proc_time / 1000, proc_time % 1000);
#endif /* LOGGING_PROCESS_TIME */
vfprintf(QLOGFP, fmt, args);
}
va_end(args);
LEAVE_QLOG_CS;
GENERAL_ERRNO_SET(gerrno);
}
HRESULT Camera::takePicture(HWND hwndOwner,LPTSTR pszFilename) {
HRESULT hResult;
SHCAMERACAPTURE shcc;
wchar_t* root = wce_mbtowc(RhoGetRootPath());
wsprintf(pszFilename,L"%s%s",root,L"apps\\public\\db-files");
free(root);
create_folder(pszFilename);
TCHAR filename[256];
generate_filename(filename);
// Set the SHCAMERACAPTURE structure.
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = hwndOwner;
shcc.pszInitialDir = pszFilename;
shcc.pszDefaultFileName = filename;
shcc.pszTitle = TEXT("Camera");
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_MESSAGING;
shcc.nResolutionWidth = 176;
shcc.nResolutionHeight = 144;
shcc.nVideoTimeLimit = 15;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
// Display the Camera Capture dialog.
hResult = SHCameraCapture(&shcc);
// The next statements will execute only after the user takes
// a picture or video, or closes the Camera Capture dialog.
if (S_OK == hResult) {
LPTSTR fname = get_file_name(shcc.szFile,pszFilename);
if (fname) {
StringCchCopy(pszFilename, MAX_PATH, fname);
free(fname);
} else {
hResult = E_INVALIDARG;
}
}
return hResult;
}
static void
generate_homefile(const char *prefix, char *filename)
{
char dir[PATH_MAX];
#ifdef WIN32
const char *ptr;
dir[0] = '\0';
if (ptr=getenv("HOMEDRIVE"), NULL != ptr)
strcat(dir, ptr);
if (ptr=getenv("HOMEPATH"), NULL != ptr)
strcat(dir, ptr);
#else
strcpy(dir, "~");
#endif /* WIN32 */
generate_filename(dir, prefix, filename);
return;
}
HRESULT Camera::selectPicture(HWND hwndOwner,LPTSTR pszFilename) {
RHO_ASSERT(pszFilename);
OPENFILENAMEEX ofn = {0};
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = NULL;
ofn.lpstrFile = pszFilename;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = _T("Select an image");
ofn.ExFlags = OFN_EXFLAG_THUMBNAILVIEW|OFN_EXFLAG_NOFILECREATE|OFN_EXFLAG_LOCKDIRECTORY;
if (GetOpenFileNameEx(&ofn)) {
HRESULT hResult = S_OK;
TCHAR rhoroot[MAX_PATH];
wchar_t* root = wce_mbtowc(RhoGetRootPath());
wsprintf(rhoroot,L"%s%s",root,L"apps\\public\\db-files");
free(root);
create_folder(rhoroot);
TCHAR filename[256];
generate_filename(filename);
int len = wcslen(rhoroot) + wcslen(L"\\") + wcslen(filename);
wchar_t* full_name = (wchar_t*) malloc((len+2)*sizeof(wchar_t));
wsprintf(full_name,L"%s\\%s",rhoroot,filename);
if (copy_file(pszFilename,full_name)) {
StringCchCopy(pszFilename, MAX_PATH, filename);
} else {
hResult = E_INVALIDARG;
}
free(full_name);
return hResult;
} else if (GetLastError()==ERROR_SUCCESS) {
return S_FALSE; //user cancel op
}
return E_INVALIDARG;
}
/*--------------------------------------------------------------
Routine : print_menu_cb
Purpose : Invoked when an item is selected in the print menu.
---------------------------------------------------------------*/
void print_menu_cb(
TREE_PIC_FOREST *tree_pic_forest,
int item_no
)
{
char *report_filename;
char *tree_filename;
tree_filename = SU_Join(tree_pic_forest->tree_pic->tree->path, tree_pic_forest->tree_pic->tree->name);
switch ( item_no ) {
case PrintQualitative : /* Qualitative report */
if (tree_pic_forest->tree_pic->tree->mcs_exists) {
report_filename =
(char *)generate_filename(
tree_filename,
MCS_REPORT_SUFFIX );
FTAFramePrintTextFile(report_filename);
strfree( report_filename );
} else {
FTAFramePostError(MCS_NOT_GENERATED_ERROR, FTA_ERROR_TITLE);
}
break;
case PrintProbability : /* Probabilities Report */
if (tree_pic_forest->tree_pic->tree->probs_exists) {
report_filename =
(char *)generate_filename(
tree_filename,
PROBS_REPORT_SUFFIX );
FTAFramePrintTextFile(report_filename);
strfree( report_filename );
} else {
FTAFramePostError(PROB_REPORT_NOT_GENERATED_ERROR, FTA_ERROR_TITLE);
}
break;
case PrintMonteCarlo : /* Monte-Carlo Report */
if (tree_pic_forest->tree_pic->tree->monte_exists) {
report_filename =
(char *)generate_filename(
tree_filename,
MONTE_CARLO_REPORT_SUFFIX );
FTAFramePrintTextFile(report_filename);
strfree( report_filename );
} else {
FTAFramePostError(MC_REPORT_NOT_GENERATED_ERROR, FTA_ERROR_TITLE);
}
break;
default:
FTAFramePostError(UNAVAILABLE_WARNING, FTA_ERROR_TITLE);
break;
}
strfree(tree_filename);
}
static void send_with_encryption(gpointer compose)
{
GSList *alist, *cur;
GHashTable *hash;
SylPluginAttachInfo *ainfo;
gboolean duplicated = FALSE;
GtkWidget *dialog;
gchar *password;
const gchar *tmp_path;
const gchar *arc_path;
gchar *zip_path;
gchar *filename;
GString *cmdline;
gint ret;
gchar *orig_to;
gchar *orig_cc;
gchar *orig_bcc;
gchar *orig_replyto;
gchar *orig_subject;
gchar *subject;
gchar *body;
gchar send_date[80];
/* Check attachments */
alist = syl_plugin_get_attach_list(compose);
if (!alist) {
syl_plugin_alertpanel_message(_("No attachment"), _("There is no attachment. Please attach files before sending."), 3);
return;
}
hash = g_hash_table_new(str_case_hash, str_case_equal);
for (cur = alist; cur != NULL; cur = cur->next) {
const gchar *base;
ainfo = (SylPluginAttachInfo *)cur->data;
debug_print("attach: file: %s (%s) name: %s\n", ainfo->file, ainfo->content_type, ainfo->name);
base = g_basename(ainfo->file);
if (g_hash_table_lookup(hash, base)) {
duplicated = TRUE;
break;
} else {
g_hash_table_insert(hash, (gpointer)base, (gpointer)base);
}
}
g_hash_table_destroy(hash);
if (duplicated) {
syl_plugin_alertpanel_message(_("Duplicate filename"), _("There are duplicate filenames. Multiple files with same name cannot be attached."), 3);
return;
}
/* Get recipients */
orig_to = syl_plugin_compose_entry_get_text(compose, 0);
orig_cc = syl_plugin_compose_entry_get_text(compose, 1);
orig_bcc = syl_plugin_compose_entry_get_text(compose, 2);
orig_replyto = syl_plugin_compose_entry_get_text(compose, 3);
orig_subject = syl_plugin_compose_entry_get_text(compose, 4);
if (orig_to) g_strstrip(orig_to);
if (orig_cc) g_strstrip(orig_cc);
if (orig_bcc) g_strstrip(orig_bcc);
if ((!orig_to || *orig_to == '\0') &&
(!orig_cc || *orig_cc == '\0') &&
(!orig_bcc || *orig_bcc == '\0')) {
syl_plugin_alertpanel_message(_("No recipients"), _("Recipient is not specified."), 3);
g_free(orig_subject);
g_free(orig_replyto);
g_free(orig_bcc);
g_free(orig_cc);
g_free(orig_to);
return;
}
/* Show processing dialog */
dialog = autoenc_processing_dialog_create();
/* Generate password */
password = generate_password();
/* Generate encrypted zip */
filename = generate_filename();
tmp_path = get_autoenc_tmp_dir();
if (!is_dir_exist(tmp_path)) {
make_dir(tmp_path);
}
arc_path = get_7z_path();
zip_path = g_strconcat(tmp_path, G_DIR_SEPARATOR_S,
filename, NULL);
cmdline = g_string_new("");
if (arc_path) {
g_string_append_printf(cmdline, "\"%s\\7z\" a -y ", arc_path);
} else {
g_string_append(cmdline, "7z a -y ");
}
g_string_append(cmdline, "-p");
g_string_append(cmdline, password);
g_string_append(cmdline, " ");
g_string_append_printf(cmdline, "\"%s\"", zip_path);
for (cur = alist; cur != NULL; cur = cur->next) {
ainfo = (SylPluginAttachInfo *)cur->data;
g_string_append(cmdline, " ");
g_string_append_printf(cmdline, "\"%s\"", ainfo->file);
}
debug_print("cmdline: %s\n", cmdline->str);
ret = execute_command_line_async_wait(cmdline->str);
/* Close processing dialog */
gtk_widget_destroy(dialog);
// check if zip was really created
if (ret != 0 || !is_file_exist(zip_path) || get_file_size(zip_path) <= 0) {
gchar message[256];
if (ret < 0) {
g_snprintf(message, sizeof(message), _("Error occurred while creating encrypted zip file.\n\n7z command could not be executed. Please check if 7-Zip is correctly installed."));
} else if (ret > 0) {
g_snprintf(message, sizeof(message), _("Error occurred while creating encrypted zip file.\n\n7z command returned error (%d)"), ret);
} else {
g_snprintf(message, sizeof(message), _("Encrypted zip file could not be created."));
}
syl_plugin_alertpanel_message(_("Encrypted zip file creation error"), message, 3);
g_string_free(cmdline, TRUE);
g_free(zip_path);
g_free(filename);
g_free(password);
g_free(orig_subject);
g_free(orig_replyto);
g_free(orig_bcc);
g_free(orig_cc);
g_free(orig_to);
g_slist_free(alist);
return;
}
g_string_free(cmdline, TRUE);
g_slist_free(alist);
/* Replace attachments */
syl_plugin_compose_attach_remove_all(compose);
syl_plugin_compose_attach_append(compose, zip_path, filename,
"application/zip");
/* Send */
get_rfc822_date(send_date, sizeof(send_date));
ret = syl_plugin_compose_send(compose, TRUE);
if (ret != 0) {
g_free(zip_path);
g_free(filename);
g_free(password);
g_free(orig_subject);
g_free(orig_replyto);
g_free(orig_bcc);
g_free(orig_cc);
g_free(orig_to);
return;
}
/* Create password mail */
subject = create_password_mail_subject(orig_subject, send_date, filename, password);
body = create_password_mail_body(orig_subject, send_date, filename, password);
debug_print("%s\n", body);
compose = syl_plugin_compose_new(NULL, NULL, body, NULL);
syl_plugin_compose_entry_set(compose, orig_to, 0);
syl_plugin_compose_entry_set(compose, orig_cc, 1);
if (orig_bcc && *orig_bcc != '\0')
syl_plugin_compose_entry_set(compose, orig_bcc, 2);
if (orig_replyto && *orig_replyto != '\0')
syl_plugin_compose_entry_set(compose, orig_replyto, 3);
syl_plugin_compose_entry_set(compose, subject, 4);
/* Cleanup */
g_free(body);
g_free(subject);
g_free(zip_path);
g_free(filename);
g_free(password);
g_free(orig_subject);
g_free(orig_replyto);
g_free(orig_bcc);
g_free(orig_cc);
g_free(orig_to);
}
int main(int argc, char **argv)
{
int count, status = EXIT_SUCCESS;
TCHAR *fn;
state *s;
/* Because the main() function can handle wchar_t arguments on Win32,
we need a way to reference those values. Thus we make a duplciate
of the argc and argv values. */
#ifndef __GLIBC__
__progname = basename(argv[0]);
#endif
s = (state *)malloc(sizeof(state));
if (NULL == s)
{
// We can't use fatal_error because it requires a valid state
print_status("%s: Unable to allocate state variable", __progname);
return EXIT_FAILURE;
}
if (initialize_state(s))
{
print_status("%s: Unable to initialize state variable", __progname);
return EXIT_FAILURE;
}
process_command_line(s,argc,argv);
if (initialize_hashing_algorithms(s))
return EXIT_FAILURE;
if (primary_audit == s->primary_function)
setup_audit(s);
#ifdef _WIN32
if (prepare_windows_command_line(s))
fatal_error(s,"%s: Unable to process command line arguments", __progname);
check_wow64(s);
#else
s->argc = argc;
s->argv = argv;
#endif
MD5DEEP_ALLOC(TCHAR,s->cwd,PATH_MAX);
s->cwd = _tgetcwd(s->cwd,PATH_MAX);
if (NULL == s->cwd)
fatal_error(s,"%s: %s", __progname, strerror(errno));
/* Anything left on the command line at this point is a file
or directory we're supposed to process. If there's nothing
specified, we should tackle standard input */
if (optind == argc)
hash_stdin(s);
else
{
MD5DEEP_ALLOC(TCHAR,fn,PATH_MAX);
count = optind;
while (count < s->argc)
{
generate_filename(s,fn,s->cwd,s->argv[count]);
#ifdef _WIN32
status = process_win32(s,fn);
#else
status = process_normal(s,fn);
#endif
++count;
}
free(fn);
}
if (primary_audit == s->primary_function)
status = display_audit_results(s);
return status;
}
int main_loop(int argc, const char **argv_) {
vpx_codec_ctx_t decoder;
char *fn = NULL;
int i;
uint8_t *buf = NULL;
size_t bytes_in_buffer = 0, buffer_size = 0;
FILE *infile;
int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
int do_md5 = 0, progress = 0;
int stop_after = 0, postproc = 0, summary = 0, quiet = 1;
int arg_skip = 0;
int ec_enabled = 0;
const VpxInterface *interface = NULL;
const VpxInterface *fourcc_interface = NULL;
uint64_t dx_time = 0;
struct arg arg;
char **argv, **argi, **argj;
int single_file;
int use_y4m = 1;
vpx_codec_dec_cfg_t cfg = {0};
#if CONFIG_VP8_DECODER
vp8_postproc_cfg_t vp8_pp_cfg = {0};
int vp8_dbg_color_ref_frame = 0;
int vp8_dbg_color_mb_modes = 0;
int vp8_dbg_color_b_modes = 0;
int vp8_dbg_display_mv = 0;
#endif
int frames_corrupted = 0;
int dec_flags = 0;
int do_scale = 0;
vpx_image_t *scaled_img = NULL;
int frame_avail, got_data;
int num_external_frame_buffers = 0;
struct ExternalFrameBufferList ext_fb_list = {0};
const char *outfile_pattern = NULL;
char outfile_name[PATH_MAX] = {0};
FILE *outfile = NULL;
MD5Context md5_ctx;
unsigned char md5_digest[16];
struct VpxDecInputContext input = {0};
struct VpxInputContext vpx_input_ctx = {0};
struct WebmInputContext webm_ctx = {0};
input.vpx_input_ctx = &vpx_input_ctx;
input.webm_ctx = &webm_ctx;
/* Parse command line */
exec_name = argv_[0];
argv = argv_dup(argc - 1, argv_ + 1);
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
memset(&arg, 0, sizeof(arg));
arg.argv_step = 1;
if (arg_match(&arg, &codecarg, argi)) {
interface = get_vpx_decoder_by_name(arg.val);
if (!interface)
die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
} else if (arg_match(&arg, &looparg, argi)) {
// no-op
} else if (arg_match(&arg, &outputfile, argi))
outfile_pattern = arg.val;
else if (arg_match(&arg, &use_yv12, argi)) {
use_y4m = 0;
flipuv = 1;
} else if (arg_match(&arg, &use_i420, argi)) {
use_y4m = 0;
flipuv = 0;
} else if (arg_match(&arg, &flipuvarg, argi))
flipuv = 1;
else if (arg_match(&arg, &noblitarg, argi))
noblit = 1;
else if (arg_match(&arg, &progressarg, argi))
progress = 1;
else if (arg_match(&arg, &limitarg, argi))
stop_after = arg_parse_uint(&arg);
else if (arg_match(&arg, &skiparg, argi))
arg_skip = arg_parse_uint(&arg);
else if (arg_match(&arg, &postprocarg, argi))
postproc = 1;
else if (arg_match(&arg, &md5arg, argi))
do_md5 = 1;
else if (arg_match(&arg, &summaryarg, argi))
summary = 1;
else if (arg_match(&arg, &threadsarg, argi))
cfg.threads = arg_parse_uint(&arg);
else if (arg_match(&arg, &verbosearg, argi))
quiet = 0;
else if (arg_match(&arg, &scalearg, argi))
do_scale = 1;
else if (arg_match(&arg, &fb_arg, argi))
num_external_frame_buffers = arg_parse_uint(&arg);
#if CONFIG_VP8_DECODER
else if (arg_match(&arg, &addnoise_level, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_ADDNOISE;
vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
} else if (arg_match(&arg, &demacroblock_level, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_DEMACROBLOCK;
vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
} else if (arg_match(&arg, &deblock, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_DEBLOCK;
} else if (arg_match(&arg, &mfqe, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_MFQE;
} else if (arg_match(&arg, &pp_debug_info, argi)) {
unsigned int level = arg_parse_uint(&arg);
postproc = 1;
vp8_pp_cfg.post_proc_flag &= ~0x7;
if (level)
vp8_pp_cfg.post_proc_flag |= level;
} else if (arg_match(&arg, &pp_disp_ref_frame, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_ref_frame = flags;
}
} else if (arg_match(&arg, &pp_disp_mb_modes, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_mb_modes = flags;
}
} else if (arg_match(&arg, &pp_disp_b_modes, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_b_modes = flags;
}
} else if (arg_match(&arg, &pp_disp_mvs, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_display_mv = flags;
}
} else if (arg_match(&arg, &error_concealment, argi)) {
ec_enabled = 1;
}
#endif
else
argj++;
}
/* Check for unrecognized options */
for (argi = argv; *argi; argi++)
if (argi[0][0] == '-' && strlen(argi[0]) > 1)
die("Error: Unrecognized option %s\n", *argi);
/* Handle non-option arguments */
fn = argv[0];
if (!fn)
usage_exit();
/* Open file */
infile = strcmp(fn, "-") ? fopen(fn, "rb") : set_binary_mode(stdin);
if (!infile) {
fprintf(stderr, "Failed to open file '%s'", strcmp(fn, "-") ? fn : "stdin");
return EXIT_FAILURE;
}
#if CONFIG_OS_SUPPORT
/* Make sure we don't dump to the terminal, unless forced to with -o - */
if (!outfile_pattern && isatty(fileno(stdout)) && !do_md5 && !noblit) {
fprintf(stderr,
"Not dumping raw video to your terminal. Use '-o -' to "
"override.\n");
return EXIT_FAILURE;
}
#endif
input.vpx_input_ctx->file = infile;
if (file_is_ivf(input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_IVF;
#if CONFIG_WEBM_IO
else if (file_is_webm(input.webm_ctx, input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_WEBM;
#endif
else if (file_is_raw(input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_RAW;
else {
fprintf(stderr, "Unrecognized input file type.\n");
#if !CONFIG_WEBM_IO
fprintf(stderr, "vpxdec was built without WebM container support.\n");
#endif
return EXIT_FAILURE;
}
outfile_pattern = outfile_pattern ? outfile_pattern : "-";
single_file = is_single_file(outfile_pattern);
if (!noblit && single_file) {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
vpx_input_ctx.width, vpx_input_ctx.height, 0);
if (do_md5)
MD5Init(&md5_ctx);
else
outfile = open_outfile(outfile_name);
}
if (use_y4m && !noblit) {
if (!single_file) {
fprintf(stderr, "YUV4MPEG2 not supported with output patterns,"
" try --i420 or --yv12.\n");
return EXIT_FAILURE;
}
#if CONFIG_WEBM_IO
if (vpx_input_ctx.file_type == FILE_TYPE_WEBM) {
if (webm_guess_framerate(input.webm_ctx, input.vpx_input_ctx)) {
fprintf(stderr, "Failed to guess framerate -- error parsing "
"webm file?\n");
return EXIT_FAILURE;
}
}
#endif
}
fourcc_interface = get_vpx_decoder_by_fourcc(vpx_input_ctx.fourcc);
if (interface && fourcc_interface && interface != fourcc_interface)
warn("Header indicates codec: %s\n", fourcc_interface->name);
else
interface = fourcc_interface;
if (!interface)
interface = get_vpx_decoder_by_index(0);
dec_flags = (postproc ? VPX_CODEC_USE_POSTPROC : 0) |
(ec_enabled ? VPX_CODEC_USE_ERROR_CONCEALMENT : 0);
if (vpx_codec_dec_init(&decoder, interface->interface(), &cfg, dec_flags)) {
fprintf(stderr, "Failed to initialize decoder: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (!quiet)
fprintf(stderr, "%s\n", decoder.name);
#if CONFIG_VP8_DECODER
if (vp8_pp_cfg.post_proc_flag
&& vpx_codec_control(&decoder, VP8_SET_POSTPROC, &vp8_pp_cfg)) {
fprintf(stderr, "Failed to configure postproc: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_ref_frame
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_REF_FRAME, vp8_dbg_color_ref_frame)) {
fprintf(stderr, "Failed to configure reference block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_mb_modes
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_MB_MODES, vp8_dbg_color_mb_modes)) {
fprintf(stderr, "Failed to configure macro block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_b_modes
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_B_MODES, vp8_dbg_color_b_modes)) {
fprintf(stderr, "Failed to configure block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_display_mv
&& vpx_codec_control(&decoder, VP8_SET_DBG_DISPLAY_MV, vp8_dbg_display_mv)) {
fprintf(stderr, "Failed to configure motion vector visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
#endif
if (arg_skip)
fprintf(stderr, "Skipping first %d frames.\n", arg_skip);
while (arg_skip) {
if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size))
break;
arg_skip--;
}
if (num_external_frame_buffers > 0) {
ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
ext_fb_list.ext_fb = (struct ExternalFrameBuffer *)calloc(
num_external_frame_buffers, sizeof(*ext_fb_list.ext_fb));
if (vpx_codec_set_frame_buffer_functions(
&decoder, get_vp9_frame_buffer, release_vp9_frame_buffer,
&ext_fb_list)) {
fprintf(stderr, "Failed to configure external frame buffers: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
}
frame_avail = 1;
got_data = 0;
/* Decode file */
while (frame_avail || got_data) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
struct vpx_usec_timer timer;
int corrupted;
frame_avail = 0;
if (!stop_after || frame_in < stop_after) {
if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
frame_avail = 1;
frame_in++;
vpx_usec_timer_start(&timer);
if (vpx_codec_decode(&decoder, buf, (unsigned int)bytes_in_buffer,
NULL, 0)) {
const char *detail = vpx_codec_error_detail(&decoder);
warn("Failed to decode frame %d: %s",
frame_in, vpx_codec_error(&decoder));
if (detail)
warn("Additional information: %s", detail);
goto fail;
}
vpx_usec_timer_mark(&timer);
dx_time += vpx_usec_timer_elapsed(&timer);
}
}
vpx_usec_timer_start(&timer);
got_data = 0;
if ((img = vpx_codec_get_frame(&decoder, &iter))) {
++frame_out;
got_data = 1;
}
vpx_usec_timer_mark(&timer);
dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
if (vpx_codec_control(&decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted)) {
warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder));
goto fail;
}
frames_corrupted += corrupted;
if (progress)
show_progress(frame_in, frame_out, dx_time);
if (!noblit && img) {
const int PLANES_YUV[] = {VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V};
const int PLANES_YVU[] = {VPX_PLANE_Y, VPX_PLANE_V, VPX_PLANE_U};
const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
if (do_scale) {
if (frame_out == 1) {
// If the output frames are to be scaled to a fixed display size then
// use the width and height specified in the container. If either of
// these is set to 0, use the display size set in the first frame
// header. If that is unavailable, use the raw decoded size of the
// first decoded frame.
int display_width = vpx_input_ctx.width;
int display_height = vpx_input_ctx.height;
if (!display_width || !display_height) {
int display_size[2];
if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE,
display_size)) {
// As last resort use size of first frame as display size.
display_width = img->d_w;
display_height = img->d_h;
} else {
display_width = display_size[0];
display_height = display_size[1];
}
}
scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, display_width,
display_height, 16);
}
if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
vpx_image_scale(img, scaled_img, kFilterBox);
img = scaled_img;
}
}
if (single_file) {
if (use_y4m) {
char buf[Y4M_BUFFER_SIZE] = {0};
size_t len = 0;
if (frame_out == 1) {
// Y4M file header
len = y4m_write_file_header(buf, sizeof(buf),
vpx_input_ctx.width,
vpx_input_ctx.height,
&vpx_input_ctx.framerate, img->fmt);
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
}
// Y4M frame header
len = y4m_write_frame_header(buf, sizeof(buf));
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
}
if (do_md5) {
update_image_md5(img, planes, &md5_ctx);
} else {
write_image_file(img, planes, outfile);
}
} else {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
img->d_w, img->d_h, frame_in);
if (do_md5) {
MD5Init(&md5_ctx);
update_image_md5(img, planes, &md5_ctx);
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
outfile = open_outfile(outfile_name);
write_image_file(img, planes, outfile);
fclose(outfile);
}
}
}
if (stop_after && frame_in >= stop_after)
break;
}
if (summary || progress) {
show_progress(frame_in, frame_out, dx_time);
fprintf(stderr, "\n");
}
if (frames_corrupted)
fprintf(stderr, "WARNING: %d frames corrupted.\n", frames_corrupted);
fail:
if (vpx_codec_destroy(&decoder)) {
fprintf(stderr, "Failed to destroy decoder: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (!noblit && single_file) {
if (do_md5) {
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
fclose(outfile);
}
}
#if CONFIG_WEBM_IO
if (input.vpx_input_ctx->file_type == FILE_TYPE_WEBM)
webm_free(input.webm_ctx);
#endif
if (input.vpx_input_ctx->file_type != FILE_TYPE_WEBM)
free(buf);
if (scaled_img) vpx_img_free(scaled_img);
for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
free(ext_fb_list.ext_fb[i].data);
}
free(ext_fb_list.ext_fb);
fclose(infile);
free(argv);
return frames_corrupted ? EXIT_FAILURE : EXIT_SUCCESS;
}
static int main_loop(int argc, const char **argv_) {
aom_codec_ctx_t decoder;
char *fn = NULL;
int i;
int ret = EXIT_FAILURE;
uint8_t *buf = NULL;
size_t bytes_in_buffer = 0, buffer_size = 0;
FILE *infile;
int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
int do_md5 = 0, progress = 0, frame_parallel = 0;
int stop_after = 0, postproc = 0, summary = 0, quiet = 1;
int arg_skip = 0;
int ec_enabled = 0;
int keep_going = 0;
const AvxInterface *interface = NULL;
const AvxInterface *fourcc_interface = NULL;
uint64_t dx_time = 0;
struct arg arg;
char **argv, **argi, **argj;
int single_file;
int use_y4m = 1;
int opt_yv12 = 0;
int opt_i420 = 0;
aom_codec_dec_cfg_t cfg = { 0, 0, 0 };
#if CONFIG_AOM_HIGHBITDEPTH
unsigned int output_bit_depth = 0;
#endif
#if CONFIG_EXT_TILE
int tile_row = -1;
int tile_col = -1;
#endif // CONFIG_EXT_TILE
int frames_corrupted = 0;
int dec_flags = 0;
int do_scale = 0;
aom_image_t *scaled_img = NULL;
#if CONFIG_AOM_HIGHBITDEPTH
aom_image_t *img_shifted = NULL;
#endif
int frame_avail, got_data, flush_decoder = 0;
int num_external_frame_buffers = 0;
struct ExternalFrameBufferList ext_fb_list = { 0, NULL };
const char *outfile_pattern = NULL;
char outfile_name[PATH_MAX] = { 0 };
FILE *outfile = NULL;
FILE *framestats_file = NULL;
MD5Context md5_ctx;
unsigned char md5_digest[16];
struct AvxDecInputContext input = { NULL, NULL };
struct AvxInputContext aom_input_ctx;
#if CONFIG_WEBM_IO
struct WebmInputContext webm_ctx;
memset(&(webm_ctx), 0, sizeof(webm_ctx));
input.webm_ctx = &webm_ctx;
#endif
input.aom_input_ctx = &aom_input_ctx;
/* Parse command line */
exec_name = argv_[0];
argv = argv_dup(argc - 1, argv_ + 1);
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
memset(&arg, 0, sizeof(arg));
arg.argv_step = 1;
if (arg_match(&arg, &codecarg, argi)) {
interface = get_aom_decoder_by_name(arg.val);
if (!interface)
die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
} else if (arg_match(&arg, &looparg, argi)) {
// no-op
} else if (arg_match(&arg, &outputfile, argi)) {
outfile_pattern = arg.val;
} else if (arg_match(&arg, &use_yv12, argi)) {
use_y4m = 0;
flipuv = 1;
opt_yv12 = 1;
} else if (arg_match(&arg, &use_i420, argi)) {
use_y4m = 0;
flipuv = 0;
opt_i420 = 1;
} else if (arg_match(&arg, &rawvideo, argi)) {
use_y4m = 0;
} else if (arg_match(&arg, &flipuvarg, argi)) {
flipuv = 1;
} else if (arg_match(&arg, &noblitarg, argi)) {
noblit = 1;
} else if (arg_match(&arg, &progressarg, argi)) {
progress = 1;
} else if (arg_match(&arg, &limitarg, argi)) {
stop_after = arg_parse_uint(&arg);
} else if (arg_match(&arg, &skiparg, argi)) {
arg_skip = arg_parse_uint(&arg);
} else if (arg_match(&arg, &postprocarg, argi)) {
postproc = 1;
} else if (arg_match(&arg, &md5arg, argi)) {
do_md5 = 1;
} else if (arg_match(&arg, &framestatsarg, argi)) {
framestats_file = fopen(arg.val, "w");
if (!framestats_file) {
die("Error: Could not open --framestats file (%s) for writing.\n",
arg.val);
}
} else if (arg_match(&arg, &summaryarg, argi)) {
summary = 1;
} else if (arg_match(&arg, &threadsarg, argi)) {
cfg.threads = arg_parse_uint(&arg);
}
#if CONFIG_AV1_DECODER
else if (arg_match(&arg, &frameparallelarg, argi))
frame_parallel = 1;
#endif
else if (arg_match(&arg, &verbosearg, argi))
quiet = 0;
else if (arg_match(&arg, &scalearg, argi))
do_scale = 1;
else if (arg_match(&arg, &fb_arg, argi))
num_external_frame_buffers = arg_parse_uint(&arg);
else if (arg_match(&arg, &continuearg, argi))
keep_going = 1;
#if CONFIG_AOM_HIGHBITDEPTH
else if (arg_match(&arg, &outbitdeptharg, argi)) {
output_bit_depth = arg_parse_uint(&arg);
}
#endif
#if CONFIG_EXT_TILE
else if (arg_match(&arg, &tiler, argi))
tile_row = arg_parse_int(&arg);
else if (arg_match(&arg, &tilec, argi))
tile_col = arg_parse_int(&arg);
#endif // CONFIG_EXT_TILE
else
argj++;
}
/* Check for unrecognized options */
for (argi = argv; *argi; argi++)
if (argi[0][0] == '-' && strlen(argi[0]) > 1)
die("Error: Unrecognized option %s\n", *argi);
/* Handle non-option arguments */
fn = argv[0];
if (!fn) {
free(argv);
usage_exit();
}
/* Open file */
infile = strcmp(fn, "-") ? fopen(fn, "rb") : set_binary_mode(stdin);
if (!infile) {
fatal("Failed to open input file '%s'", strcmp(fn, "-") ? fn : "stdin");
}
#if CONFIG_OS_SUPPORT
/* Make sure we don't dump to the terminal, unless forced to with -o - */
if (!outfile_pattern && isatty(STDOUT_FILENO) && !do_md5 && !noblit) {
fprintf(stderr,
"Not dumping raw video to your terminal. Use '-o -' to "
"override.\n");
return EXIT_FAILURE;
}
#endif
input.aom_input_ctx->file = infile;
if (file_is_ivf(input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_IVF;
#if CONFIG_WEBM_IO
else if (file_is_webm(input.webm_ctx, input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_WEBM;
#endif
else if (file_is_raw(input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_RAW;
else {
fprintf(stderr, "Unrecognized input file type.\n");
#if !CONFIG_WEBM_IO
fprintf(stderr, "aomdec was built without WebM container support.\n");
#endif
return EXIT_FAILURE;
}
outfile_pattern = outfile_pattern ? outfile_pattern : "-";
single_file = is_single_file(outfile_pattern);
if (!noblit && single_file) {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
aom_input_ctx.width, aom_input_ctx.height, 0);
if (do_md5)
MD5Init(&md5_ctx);
else
outfile = open_outfile(outfile_name);
}
if (use_y4m && !noblit) {
if (!single_file) {
fprintf(stderr,
"YUV4MPEG2 not supported with output patterns,"
" try --i420 or --yv12 or --rawvideo.\n");
return EXIT_FAILURE;
}
#if CONFIG_WEBM_IO
if (aom_input_ctx.file_type == FILE_TYPE_WEBM) {
if (webm_guess_framerate(input.webm_ctx, input.aom_input_ctx)) {
fprintf(stderr,
"Failed to guess framerate -- error parsing "
"webm file?\n");
return EXIT_FAILURE;
}
}
#endif
}
fourcc_interface = get_aom_decoder_by_fourcc(aom_input_ctx.fourcc);
if (interface && fourcc_interface && interface != fourcc_interface)
warn("Header indicates codec: %s\n", fourcc_interface->name);
else
interface = fourcc_interface;
if (!interface) interface = get_aom_decoder_by_index(0);
dec_flags = (postproc ? AOM_CODEC_USE_POSTPROC : 0) |
(ec_enabled ? AOM_CODEC_USE_ERROR_CONCEALMENT : 0) |
(frame_parallel ? AOM_CODEC_USE_FRAME_THREADING : 0);
if (aom_codec_dec_init(&decoder, interface->codec_interface(), &cfg,
dec_flags)) {
fprintf(stderr, "Failed to initialize decoder: %s\n",
aom_codec_error(&decoder));
goto fail2;
}
if (!quiet) fprintf(stderr, "%s\n", decoder.name);
#if CONFIG_AV1_DECODER && CONFIG_EXT_TILE
if (aom_codec_control(&decoder, AV1_SET_DECODE_TILE_ROW, tile_row)) {
fprintf(stderr, "Failed to set decode_tile_row: %s\n",
aom_codec_error(&decoder));
goto fail;
}
if (aom_codec_control(&decoder, AV1_SET_DECODE_TILE_COL, tile_col)) {
fprintf(stderr, "Failed to set decode_tile_col: %s\n",
aom_codec_error(&decoder));
goto fail;
}
#endif
if (arg_skip) fprintf(stderr, "Skipping first %d frames.\n", arg_skip);
while (arg_skip) {
if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) break;
arg_skip--;
}
if (num_external_frame_buffers > 0) {
ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
ext_fb_list.ext_fb = (struct ExternalFrameBuffer *)calloc(
num_external_frame_buffers, sizeof(*ext_fb_list.ext_fb));
if (aom_codec_set_frame_buffer_functions(&decoder, get_av1_frame_buffer,
release_av1_frame_buffer,
&ext_fb_list)) {
fprintf(stderr, "Failed to configure external frame buffers: %s\n",
aom_codec_error(&decoder));
goto fail;
}
}
frame_avail = 1;
got_data = 0;
if (framestats_file) fprintf(framestats_file, "bytes,qp\r\n");
/* Decode file */
while (frame_avail || got_data) {
aom_codec_iter_t iter = NULL;
aom_image_t *img;
struct aom_usec_timer timer;
int corrupted = 0;
frame_avail = 0;
if (!stop_after || frame_in < stop_after) {
if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
frame_avail = 1;
frame_in++;
aom_usec_timer_start(&timer);
if (aom_codec_decode(&decoder, buf, (unsigned int)bytes_in_buffer, NULL,
0)) {
const char *detail = aom_codec_error_detail(&decoder);
warn("Failed to decode frame %d: %s", frame_in,
aom_codec_error(&decoder));
if (detail) warn("Additional information: %s", detail);
if (!keep_going) goto fail;
}
if (framestats_file) {
int qp;
if (aom_codec_control(&decoder, AOMD_GET_LAST_QUANTIZER, &qp)) {
warn("Failed AOMD_GET_LAST_QUANTIZER: %s",
aom_codec_error(&decoder));
if (!keep_going) goto fail;
}
fprintf(framestats_file, "%d,%d\r\n", (int)bytes_in_buffer, qp);
}
aom_usec_timer_mark(&timer);
dx_time += aom_usec_timer_elapsed(&timer);
} else {
flush_decoder = 1;
}
} else {
flush_decoder = 1;
}
aom_usec_timer_start(&timer);
if (flush_decoder) {
// Flush the decoder in frame parallel decode.
if (aom_codec_decode(&decoder, NULL, 0, NULL, 0)) {
warn("Failed to flush decoder: %s", aom_codec_error(&decoder));
}
}
got_data = 0;
if ((img = aom_codec_get_frame(&decoder, &iter))) {
++frame_out;
got_data = 1;
}
aom_usec_timer_mark(&timer);
dx_time += (unsigned int)aom_usec_timer_elapsed(&timer);
if (!frame_parallel &&
aom_codec_control(&decoder, AOMD_GET_FRAME_CORRUPTED, &corrupted)) {
warn("Failed AOM_GET_FRAME_CORRUPTED: %s", aom_codec_error(&decoder));
if (!keep_going) goto fail;
}
frames_corrupted += corrupted;
if (progress) show_progress(frame_in, frame_out, dx_time);
if (!noblit && img) {
const int PLANES_YUV[] = { AOM_PLANE_Y, AOM_PLANE_U, AOM_PLANE_V };
const int PLANES_YVU[] = { AOM_PLANE_Y, AOM_PLANE_V, AOM_PLANE_U };
const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
if (do_scale) {
if (frame_out == 1) {
// If the output frames are to be scaled to a fixed display size then
// use the width and height specified in the container. If either of
// these is set to 0, use the display size set in the first frame
// header. If that is unavailable, use the raw decoded size of the
// first decoded frame.
int render_width = aom_input_ctx.width;
int render_height = aom_input_ctx.height;
if (!render_width || !render_height) {
int render_size[2];
if (aom_codec_control(&decoder, AV1D_GET_DISPLAY_SIZE,
render_size)) {
// As last resort use size of first frame as display size.
render_width = img->d_w;
render_height = img->d_h;
} else {
render_width = render_size[0];
render_height = render_size[1];
}
}
scaled_img =
aom_img_alloc(NULL, img->fmt, render_width, render_height, 16);
scaled_img->bit_depth = img->bit_depth;
}
if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
#if CONFIG_LIBYUV
libyuv_scale(img, scaled_img, kFilterBox);
img = scaled_img;
#else
fprintf(stderr,
"Failed to scale output frame: %s.\n"
"Scaling is disabled in this configuration. "
"To enable scaling, configure with --enable-libyuv\n",
aom_codec_error(&decoder));
goto fail;
#endif
}
}
#if CONFIG_AOM_HIGHBITDEPTH
// Default to codec bit depth if output bit depth not set
if (!output_bit_depth && single_file && !do_md5) {
output_bit_depth = img->bit_depth;
}
// Shift up or down if necessary
if (output_bit_depth != 0 && output_bit_depth != img->bit_depth) {
const aom_img_fmt_t shifted_fmt =
output_bit_depth == 8
? img->fmt ^ (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH)
: img->fmt | AOM_IMG_FMT_HIGHBITDEPTH;
if (img_shifted &&
img_shifted_realloc_required(img, img_shifted, shifted_fmt)) {
aom_img_free(img_shifted);
img_shifted = NULL;
}
if (!img_shifted) {
img_shifted =
aom_img_alloc(NULL, shifted_fmt, img->d_w, img->d_h, 16);
img_shifted->bit_depth = output_bit_depth;
}
if (output_bit_depth > img->bit_depth) {
aom_img_upshift(img_shifted, img, output_bit_depth - img->bit_depth);
} else {
aom_img_downshift(img_shifted, img,
img->bit_depth - output_bit_depth);
}
img = img_shifted;
}
#endif
#if CONFIG_EXT_TILE
aom_input_ctx.width = img->d_w;
aom_input_ctx.height = img->d_h;
#endif // CONFIG_EXT_TILE
if (single_file) {
if (use_y4m) {
char y4m_buf[Y4M_BUFFER_SIZE] = { 0 };
size_t len = 0;
if (img->fmt == AOM_IMG_FMT_I440 || img->fmt == AOM_IMG_FMT_I44016) {
fprintf(stderr, "Cannot produce y4m output for 440 sampling.\n");
goto fail;
}
if (frame_out == 1) {
// Y4M file header
len = y4m_write_file_header(
y4m_buf, sizeof(y4m_buf), aom_input_ctx.width,
aom_input_ctx.height, &aom_input_ctx.framerate, img->fmt,
img->bit_depth);
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)y4m_buf, (unsigned int)len);
} else {
fputs(y4m_buf, outfile);
}
}
// Y4M frame header
len = y4m_write_frame_header(y4m_buf, sizeof(y4m_buf));
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)y4m_buf, (unsigned int)len);
} else {
fputs(y4m_buf, outfile);
}
} else {
if (frame_out == 1) {
// Check if --yv12 or --i420 options are consistent with the
// bit-stream decoded
if (opt_i420) {
if (img->fmt != AOM_IMG_FMT_I420 &&
img->fmt != AOM_IMG_FMT_I42016) {
fprintf(stderr, "Cannot produce i420 output for bit-stream.\n");
goto fail;
}
}
if (opt_yv12) {
if ((img->fmt != AOM_IMG_FMT_I420 &&
img->fmt != AOM_IMG_FMT_YV12) ||
img->bit_depth != 8) {
fprintf(stderr, "Cannot produce yv12 output for bit-stream.\n");
goto fail;
}
}
}
}
if (do_md5) {
update_image_md5(img, planes, &md5_ctx);
} else {
write_image_file(img, planes, outfile);
}
} else {
generate_filename(outfile_pattern, outfile_name, PATH_MAX, img->d_w,
img->d_h, frame_in);
if (do_md5) {
MD5Init(&md5_ctx);
update_image_md5(img, planes, &md5_ctx);
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
outfile = open_outfile(outfile_name);
write_image_file(img, planes, outfile);
fclose(outfile);
}
}
}
}
if (summary || progress) {
show_progress(frame_in, frame_out, dx_time);
fprintf(stderr, "\n");
}
if (frames_corrupted) {
fprintf(stderr, "WARNING: %d frames corrupted.\n", frames_corrupted);
} else {
ret = EXIT_SUCCESS;
}
fail:
if (aom_codec_destroy(&decoder)) {
fprintf(stderr, "Failed to destroy decoder: %s\n",
aom_codec_error(&decoder));
}
fail2:
if (!noblit && single_file) {
if (do_md5) {
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
fclose(outfile);
}
}
#if CONFIG_WEBM_IO
if (input.aom_input_ctx->file_type == FILE_TYPE_WEBM)
webm_free(input.webm_ctx);
#endif
if (input.aom_input_ctx->file_type != FILE_TYPE_WEBM) free(buf);
if (scaled_img) aom_img_free(scaled_img);
#if CONFIG_AOM_HIGHBITDEPTH
if (img_shifted) aom_img_free(img_shifted);
#endif
for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
free(ext_fb_list.ext_fb[i].data);
}
free(ext_fb_list.ext_fb);
fclose(infile);
if (framestats_file) fclose(framestats_file);
free(argv);
return ret;
}
void VoiceActingManager::OnGenerateFileNames()
{
int i;
int digits;
// stuff data to variables
UpdateData(TRUE);
// command briefings
digits = calc_digits(Cmd_briefs[0].num_stages);
for (i = 0; i < Cmd_briefs[0].num_stages; i++)
{
char *filename = Cmd_briefs[0].stage[i].wave_filename;
// generate only if we're replacing or if it has a replaceable name
if (!m_no_replace || !strlen(filename) || !strnicmp(filename, "none.wav", 4) || message_filename_is_generic(filename))
{
strcpy(filename, LPCTSTR(generate_filename(m_abbrev_command_briefing, i + 1, digits)));
}
}
// briefings
digits = calc_digits(Briefings[0].num_stages);
for (i = 0; i < Briefings[0].num_stages; i++)
{
char *filename = Briefings[0].stages[i].voice;
// generate only if we're replacing or if it has a replaceable name
if (!m_no_replace || !strlen(filename) || !strnicmp(filename, "none.wav", 4) || message_filename_is_generic(filename))
{
strcpy(filename, LPCTSTR(generate_filename(m_abbrev_briefing, i + 1, digits)));
}
}
// debriefings
digits = calc_digits(Debriefings[0].num_stages);
for (i = 0; i < Debriefings[0].num_stages; i++)
{
char *filename = Debriefings[0].stages[i].voice;
// generate only if we're replacing or if it has a replaceable name
if (!m_no_replace || !strlen(filename) || !strnicmp(filename, "none.wav", 4) || message_filename_is_generic(filename))
{
strcpy(filename, LPCTSTR(generate_filename(m_abbrev_debriefing, i + 1, digits)));
}
}
// messages
digits = calc_digits(Num_messages - Num_builtin_messages);
for (i = 0; i < Num_messages - Num_builtin_messages; i++)
{
char *filename = Messages[i + Num_builtin_messages].wave_info.name;
// generate only if we're replacing or if it has a replaceable name
if (!m_no_replace || !filename || !strlen(filename) || !strnicmp(filename, "none.wav", 4) || message_filename_is_generic(filename))
{
// free existing filename
if (filename != NULL)
free(filename);
// allocate new filename
Messages[i + Num_builtin_messages].wave_info.name = strdup(LPCTSTR(generate_filename(m_abbrev_message, i + 1, digits)));
}
}
// notify
MessageBox("File name generation complete.", "Woohoo!");
}
int main(int argc, char *argv[])
{
int listenfd, connfd, dbfd, itemfd, rservfd, logfd;
int dflag, iflag, opt, n, i;
int port = 0;
pid_t childpid;
char *database, *nameitem, *logfile;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
struct sigaction act1, oact1, act2, oact2;
act1.sa_handler = sig_chld;
act1.sa_flags = SA_RESETHAND;
act2.sa_handler = sig_int;
act2.sa_flags = SA_RESETHAND;
dflag = iflag = 0; /* parameter parer flag, unset at the beginning */
// parameter parser using getopt
while ((opt = getopt(argc, argv, "d:i:p:")) != -1) {
switch (opt) {
case 'd': /* database file path */
n = strlen(optarg);
// copy the input string content to a new string
if ((database = (char *) malloc(n + 1)) == NULL) {
handle_err("[Error] main -- malloc error");
}
for (i = 0; i < n; i++) {
database[i] = optarg[i];
}
database[i] = '\0';
dflag = 1; /* has been set */
break;
case 'i': /* nameindex file path */
n = strlen(optarg);
// copy the input string content to a new string
if ((nameitem = (char *) malloc(n + 1)) == NULL) {
handle_err("[Error] main -- malloc error");
}
for (i = 0; i < n; i++) {
nameitem[i] = optarg[i];
}
nameitem[i] = '\0';
iflag = 1;
break;
case 'p': /* server port number */
port = atoi(optarg);
if (port < 65535 && port > 1024) {
fprintf(stderr, "[Error] main -- illegal port number\n");
exit(EXIT_FAILURE);
}
break;
default: /* ? */
fprintf(stderr, "[Usage] %s [-d filepath] [-r filepath]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
if (dflag == 0) { // not input database path
if (generate_filename(&database, ".db") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
}
if (iflag == 0) { // not input name index path
if (generate_filename(&nameitem, ".index") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
}
if (generate_filename(&logfile, ".log") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
// open needed file
if ((dbfd = open(database, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create database file error");
}
if ((itemfd = open(nameitem, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create nameindex table file error");
}
if ((rservfd = open(ROUTE_SERVER, O_RDONLY)) < 0) {
handle_err("[Error] main -- open routeserver config file error");
}
if ((logfd = open(logfile, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create log file error");
}
// initialize the socket and listen to request
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd == -1)
handle_err("[Error] main -- socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (port == 0) {
port = SERV_PORT;
}
servaddr.sin_port = htons(port);
if (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 )
handle_err("binding error");
if (listen(listenfd, LISTEN_BACKLOG) == -1)
handle_err("listen error");
// signal handler
if (sigaction(SIGCHLD, &act1, &oact1) < 0) {
handle_err("sig_chld error");
}
if (sigaction(SIGINT, &act2, &oact2) < 0) {
handle_err("sig_int error");
}
/* call accept, wait for a client */
for ( ; ; ) {
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
if (connfd < 0) {
if (errno == EINTR) {
continue;
} else {
handle_err("accept error");
}
}
if ((childpid = fork()) < 0)
handle_err("fork error");
else if (childpid == 0) { /* child process */
close(listenfd);
/* process the request */
name_server(connfd, dbfd, itemfd, rservfd, logfd, port);
exit(0);
}
close(connfd); /* parent closes connected socket */
}
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int count, status, goal = argc;
state *s;
TCHAR *fn, *cwd;
#ifndef __GLIBC__
__progname = basename(argv[0]);
#endif
s = (state *)malloc(sizeof(state));
if (NULL == s)
fatal_error("%s: Unable to allocate state variable", __progname);
if (initialize_state(s))
fatal_error("%s: Unable to initialize state variable", __progname);
process_cmd_line(s,argc,argv);
#ifdef _WIN32
if (prepare_windows_command_line(s))
fatal_error("%s: Unable to process command line arguments", __progname);
#else
s->argc = argc;
s->argv = argv;
#endif
// Anything left on the command line at this point is a file
// or directory we're supposed to process. If there's nothing
// specified, we should tackle standard input
if (optind == argc)
{
status = process_stdin(s);
}
else
{
MD5DEEP_ALLOC(TCHAR,fn,PATH_MAX);
MD5DEEP_ALLOC(TCHAR,cwd,PATH_MAX);
cwd = _tgetcwd(cwd,PATH_MAX);
if (NULL == cwd)
fatal_error("%s: %s", __progname, strerror(errno));
count = optind;
// The signature comparsion mode needs to use the command line
// arguments and argument count. We don't do wildcard expansion
// on it on Win32 (i.e. where it matters). The setting of 'goal'
// to the original argc occured at the start of main(), so we just
// need to update it if we're *not* in signature compare mode.
if (!(s->mode & mode_sigcompare))
{
goal = s->argc;
}
while (count < goal)
{
if (MODE(mode_sigcompare))
match_load(s,argv[count]);
else if (MODE(mode_compare_unknown))
match_compare_unknown(s,argv[count]);
else
{
generate_filename(s,fn,cwd,s->argv[count]);
#ifdef _WIN32
status = process_win32(s,fn);
#else
status = process_normal(s,fn);
#endif
}
++count;
}
// If we processed files, but didn't find anything large enough
// to be meaningful, we should display a warning message to the user.
// This happens mostly when people are testing very small files
// e.g. $ echo "hello world" > foo && ssdeep foo
if ( ! s->found_meaningful_file && s->processed_file)
{
print_error(s,"%s: Did not process files large enough to produce meaningful results", __progname);
}
}
// If the user has requested us to compare signature files, use
// our existng code to pretty-print directory matching to do the
// work for us.
if (s->mode & mode_sigcompare)
s->mode |= mode_match_pretty;
if (s->mode & mode_match_pretty)
match_pretty(s);
return (EXIT_SUCCESS);
}
HRESULT Camera::selectPicture(HWND hwndOwner,LPTSTR pszFilename)
{
RHO_ASSERT(pszFilename);
#if defined( _WIN32_WCE ) //&& !defined( OS_PLATFORM_MOTCE )
OPENFILENAMEEX ofnex = {0};
OPENFILENAME ofn = {0};
#else
OPENFILENAME ofn = {0};
#endif
pszFilename[0] = 0;
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwndOwner;
ofn.lpstrFilter = NULL;
ofn.lpstrFile = pszFilename;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = _T("Select an image");
#if defined( _WIN32_WCE ) //&& !defined( OS_PLATFORM_MOTCE )
BOOL bRes = false;
if(RHO_IS_WMDEVICE)
{
ofnex.ExFlags = OFN_EXFLAG_THUMBNAILVIEW|OFN_EXFLAG_NOFILECREATE|OFN_EXFLAG_LOCKDIRECTORY;
bRes = lpfn_GetOpen_FileEx(&ofnex);
}
else
bRes = GetOpenFileName(&ofn);
if (bRes)
#else
if (GetOpenFileName(&ofn))
#endif
{
HRESULT hResult = S_OK;
/*
TCHAR rhoroot[MAX_PATH];
wchar_t* root = wce_mbtowc(rho_rhodesapp_getblobsdirpath());
wsprintf(rhoroot,L"%s",root);
free(root);
create_folder(rhoroot);*/
StringW strBlobRoot = convertToStringW( RHODESAPP().getBlobsDirPath() );
LPCTSTR szExt = wcsrchr(pszFilename, '.');
StringW strFileName = generate_filename(szExt);
StringW strFullName = strBlobRoot + L"\\" + strFileName;
if (copy_file( pszFilename, strFullName.c_str() ))
{
wcscpy( pszFilename, strFileName.c_str() );
} else {
hResult = E_INVALIDARG;
}
return hResult;
} else if (GetLastError()==ERROR_SUCCESS) {
return S_FALSE; //user cancel op
}
return E_INVALIDARG;
}
/* Decompose an image. It returns the number of new (gray) images.
* The image IDs for the new images are returned in image_ID_dst.
* On failure, -1 is returned.
*/
static gint32
decompose (gint32 image_ID,
gint32 drawable_ID,
const gchar *extract_type,
gint32 *image_ID_dst,
gint32 *nlayers,
gint32 *layer_ID_dst)
{
const gchar *layername;
gint j, extract_idx;
gint height, width, num_layers;
GeglBuffer *src_buffer;
GeglBuffer *dst_buffer[MAX_EXTRACT_IMAGES];
GimpPrecision precision;
gboolean requirments = FALSE, decomp_has_alpha = FALSE;
extract_idx = -1; /* Search extract type */
for (j = 0; j < G_N_ELEMENTS (extract); j++)
{
if (g_ascii_strcasecmp (extract_type, extract[j].type) == 0)
{
extract_idx = j;
break;
}
}
if (extract_idx < 0)
return -1;
num_layers = extract[extract_idx].num_images;
/* Sanity checks */
src_buffer = gimp_drawable_get_buffer (drawable_ID);
precision = gimp_image_get_precision (image_ID);
for (j = 0; j < num_layers; j++)
{
/* FIXME: Not 100% reliable */
decomp_has_alpha |= !g_strcmp0 ("alpha", extract[extract_idx].component[j].babl_name);
decomp_has_alpha |= !g_strcmp0 ("A", extract[extract_idx].component[j].babl_name);
}
requirments |= (gimp_drawable_is_rgb (drawable_ID));
requirments |= (gimp_drawable_is_indexed (drawable_ID));
requirments |= (gimp_drawable_is_gray (drawable_ID)
&& gimp_drawable_has_alpha (drawable_ID)
&& (num_layers <= 2)
&& decomp_has_alpha);
requirments &= (!decomp_has_alpha || gimp_drawable_has_alpha (drawable_ID));
if (!requirments)
{
g_message (_("Image not suitable for this decomposition"));
return -1;
}
width = gegl_buffer_get_width (src_buffer);
height = gegl_buffer_get_height (src_buffer);
/* Create all new gray images */
for (j = 0; j < num_layers; j++)
{
gchar *filename;
gdouble xres, yres;
filename = generate_filename (image_ID, extract_idx, j);
gimp_image_get_resolution (image_ID, &xres, &yres);
if (decovals.as_layers)
{
layername = gettext (extract[extract_idx].component[j].channel_name);
if (j == 0)
image_ID_dst[j] = create_new_image (filename, layername,
width, height, GIMP_GRAY, precision,
xres, yres,
layer_ID_dst + j);
else
layer_ID_dst[j] = create_new_layer (image_ID_dst[0], j, layername,
width, height, GIMP_GRAY);
}
else
{
image_ID_dst[j] = create_new_image (filename, NULL,
width, height, GIMP_GRAY, precision,
xres, yres,
layer_ID_dst + j);
}
g_free (filename);
dst_buffer[j] = gimp_drawable_get_buffer (layer_ID_dst[j]);
}
copy_n_components (src_buffer, dst_buffer,
extract[extract_idx]);
if (decovals.use_registration)
transfer_registration_color (src_buffer, dst_buffer, num_layers);
gimp_progress_update (1.0);
g_object_unref (src_buffer);
for (j = 0; j < num_layers; j++)
{
g_object_unref (dst_buffer[j]);
}
*nlayers = num_layers;
return (decovals.as_layers ? 1 : num_layers);
}
int main(int argc, char **argv){
int i;
/* int a[22] = {19,20,21,22,29,30,31,32,33,39,40,41,42,43,44,49,50,51,52,53,54,55};
Vertexlist vtxlist;
char fname[] = "vertexlists/__.dat";
for (int i=0; i<22; i++) {
vtxlist=get_vertexlist(a[i]);
sprintf(fname, "vertexlists/%d.dat", a[i]);
export_vertexlist(vtxlist, fname);
}*/
clock_t start, end;
double elapsed;
int ndof=0;
/*Set default values*/
struct arguments arguments;
arguments.T=1;
arguments.whichF = 0;
arguments.d = 0;
arguments.k = 0;
arguments.vtxlist = 0;
arguments.regular = 0;
arguments.regular_file = 0;
arguments.p = 0;
arguments.nr = 0;
arguments.singular = 0;
arguments.method = 0;
arguments.qrregular = 0;
arguments.qrsingular = 0;
arguments.whichoutput = 7;
arguments.portionwise = 0;
arguments.output = 0;
/*Get Input Data*/
argp_parse(&argp, argc, argv, 0, 0, &arguments);
if(argc==1){ //no input arguments
fprintf(stderr, "Error: Need input arguments.\n");
argp_help(&argp, stderr,ARGP_HELP_USAGE,argv[0]);
exit(1);
}
/*Process Input Data*/
if(arguments.portionwise && (! arguments.whichF || arguments.method != QR_SPARSE)){
fprintf(stderr,"Error: You can only use --portionwise with --combination-method=sparse --function=NUMBER.\n");
}
if(arguments.whichF){
if(arguments.whichoutput!=7){
fprintf(stderr,"Warning: Using --no-x, --no-y or --no-z with --function has no effect.\n");
}
if(arguments.whichF==2 || arguments.whichF==4){
arguments.whichoutput=6;
}
else if(arguments.whichF==11){
arguments.whichoutput=7;
}
else{
arguments.whichoutput=1;
}
if(! arguments.vtxlist) {
fprintf(stderr,"Error: --vertexlist must be set when using --function. If --function is set, the quadrature value on parallelotopes is calculated, so the position of parallelotopes is needed.\n");
exit(1);
}
}
AffineTrafo A;
if(arguments.vtxlist) {
Vertexlist vtxlist = import_vertexlist(arguments.vtxlist);
if(arguments.d || arguments.k){
fprintf(stderr,"Warning: Using --dimension or --intersection with --vertexlist has no effect.\n");
}
//compute space dimension d and dimension of the intersection k
int d= vtxlist.s1;
int k= 2*(d+1)-vtxlist.s2-1;
if(arguments.d && arguments.d!=d){
fprintf(stderr,"Warning: Spatial dimension set with --dimension is not identical with spatial dimension given by --vertexlist!\n");
}
arguments.d = d;
if(arguments.k && arguments.k!=k){
fprintf(stderr,"Warning: Dimension of intersection set with --intersection is not identical with dimension given by --vertexlist!\n");
}
arguments.k = k;
//Calculate Affine Transformation
A=determineAffineTrafo(d, k, vtxlist);
free_vertexlist(vtxlist);
}
double alpha=-2*arguments.d+arguments.k+eps;
FILE *f;
if(!arguments.whichF){
if(!arguments.output){
arguments.output = generate_filename(arguments);
fprintf(stderr, "Warning: No output file name given, writing in \"%s\". Use --output=FILENAME to set file name.\n",arguments.output);
}
f=fopen(arguments.output, "wb");
if(f==NULL){
fprintf(stderr,"Error: Could not open file \"%s\" for writing.\n", arguments.output);
exit(1);
}
}
int K[2*arguments.d-1];
QuadRule QP1D[arguments.nr];
if(arguments.portionwise){
set_up_1dquadrules(arguments.nr,QP1D,arguments.regular);
memset(K,0,(2*arguments.d-1)*sizeof(int));
}
QuadRule QR_reg, QR_sing, QR;
int nr=0;
if(arguments.portionwise){
sparse_check(&arguments);
set_nr(arguments, &nr);
}
double Q=0;
int done = 0;
while (! done) {
if(arguments.portionwise){
if (! next_sparse(&QR_reg, arguments.nr, QP1D, K, arguments.d, arguments.p, arguments.T)) {
break;
}
}
else{
get_quadrature_rule_regular (&QR_reg, arguments, &nr);
done = 1;
}
QR_sing = get_quadrature_rule_singular(arguments, nr, alpha);
//print_quadpoints(QR_sing);
for(i=0; i<QR_sing.n; i++){
init_quadrule(&QR, QR_reg.n, QR_reg.d+1);
int m,l;
for(m=0; m<QR_reg.n; m++){
for(l=0; l<QR_reg.d; l++){
QR.t[l+1][m]=QR_reg.t[l][m];
QR.wt[m]=QR_sing.wt[i]*QR_reg.wt[m];
}
QR.t[0][m]=QR_sing.t[0][i];
}
if(arguments.whichF){
start=clock();
Q=Q+cubequad(arguments.k,arguments.d, A, arguments.whichF, arguments.whichoutput, &ndof, &QR);
end=clock();
elapsed = ((double)(end-start))/CLOCKS_PER_SEC;
}
else{
if(!arguments.vtxlist){
cubetransform(arguments.k,arguments.d,f,&QR);
}
else{
cubeaffine(arguments.k,arguments.d,A,arguments.whichoutput, &QR, f);
}
}
free_quadrule(QR);
}
free_quadrule(QR_sing);
free_quadrule(QR_reg);
}
if(arguments.whichF){
printf("%3.16lf, %d, %lf; \n", Q, ndof, elapsed);
}
if(!arguments.whichF){
fclose(f);
}
return 0;
}
int main(int argc, char **argv)
{
TCHAR *fn, *cwd;
state *s;
int count, status = STATUS_OK;
/* Because the main() function can handle wchar_t arguments on Win32,
we need a way to reference those values. Thus we make a duplciate
of the argc and argv values. */
#ifndef __GLIBC__
__progname = basename(argv[0]);
#endif
s = (state *)malloc(sizeof(state));
if (NULL == s)
{
// We can't use fatal_error because it requires a valid state
print_status("%s: Unable to allocate state variable", __progname);
return STATUS_INTERNAL_ERROR;
}
if (initialize_state(s))
{
print_status("%s: Unable to initialize state variable", __progname);
return STATUS_INTERNAL_ERROR;
}
if (process_command_line(s,argc,argv))
{
print_status("%s: Unable to process command line arguments", __progname);
return STATUS_INTERNAL_ERROR;
}
#ifdef _WIN32
if (prepare_windows_command_line(s))
fatal_error(s,"%s: Unable to process command line arguments", __progname);
#else
s->argc = argc;
s->argv = argv;
#endif
/* Anything left on the command line at this point is a file
or directory we're supposed to process. If there's nothing
specified, we should tackle standard input */
if (optind == argc)
hash_stdin(s);
else
{
MD5DEEP_ALLOC(TCHAR,fn,PATH_MAX);
MD5DEEP_ALLOC(TCHAR,cwd,PATH_MAX);
cwd = _tgetcwd(cwd,PATH_MAX);
if (NULL == cwd)
fatal_error(s,"%s: %s", __progname, strerror(errno));
count = optind;
while (count < s->argc)
{
generate_filename(s,fn,cwd,s->argv[count]);
#ifdef _WIN32
status = process_win32(s,fn);
#else
status = process_normal(s,fn);
#endif
// if (status != STATUS_OK)
// return status;
++count;
}
free(fn);
free(cwd);
}
/* We only have to worry about checking for unused hashes if one
of the matching modes was enabled. We let the display_not_matched
function determine if it needs to display anything. The function
also sets our return values in terms of inputs not being matched
or known hashes not being used */
if ((s->mode & mode_match) || (s->mode & mode_match_neg))
s->return_value = finalize_matching(s);
return s->return_value;
}
int
main (int argc, char **argv)
{
GError *err = NULL;
gchar *outputuri = NULL;
gchar *format = NULL;
gchar *aformat = NULL;
gchar *vformat = NULL;
gboolean allmissing = FALSE;
gboolean listcodecs = FALSE;
GOptionEntry options[] = {
{ "silent", 's', 0, G_OPTION_ARG_NONE, &silent,
"Don't output the information structure", NULL
},
{ "outputuri", 'o', 0, G_OPTION_ARG_STRING, &outputuri,
"URI to encode to", "URI (<protocol>://<location>)"
},
{ "format", 'f', 0, G_OPTION_ARG_STRING, &format,
"Container format", "<GstCaps>"
},
{ "vformat", 'v', 0, G_OPTION_ARG_STRING, &vformat,
"Video format", "<GstCaps>"
},
{ "aformat", 'a', 0, G_OPTION_ARG_STRING, &aformat,
"Audio format", "<GstCaps>"
},
{ "allmissing", 'm', 0, G_OPTION_ARG_NONE, &allmissing,
"encode to all matching format/codec that aren't specified", NULL
},
{ "list-codecs", 'l', 0, G_OPTION_ARG_NONE, &listcodecs,
"list all available codecs and container formats", NULL
},
{NULL}
};
GOptionContext *ctx;
GstEncodingProfile *prof;
gchar *inputuri;
ctx = g_option_context_new ("- encode URIs with GstProfile and encodebin");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
if (listcodecs) {
list_codecs ();
g_option_context_free (ctx);
exit (0);
}
if (outputuri == NULL || argc != 2) {
g_print ("%s", g_option_context_get_help (ctx, TRUE, NULL));
g_option_context_free (ctx);
exit (-1);
}
g_option_context_free (ctx);
/* Fixup outputuri to be a URI */
inputuri = ensure_uri (argv[1]);
outputuri = ensure_uri (outputuri);
if (allmissing) {
GList *muxers;
GstCaps *formats = NULL;
GstCaps *vformats = NULL;
GstCaps *aformats = NULL;
guint f, v, a, flen, vlen, alen;
if (!format)
formats = gst_caps_list_container_formats (GST_RANK_NONE);
else
formats = gst_caps_from_string (format);
if (!vformat)
vformats = gst_caps_list_video_encoding_formats (GST_RANK_NONE);
else
vformats = gst_caps_from_string (vformat);
if (!aformat)
aformats = gst_caps_list_audio_encoding_formats (GST_RANK_NONE);
else
aformats = gst_caps_from_string (aformat);
muxers =
gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_MUXER,
GST_RANK_NONE);
flen = gst_caps_get_size (formats);
for (f = 0; f < flen; f++) {
GstCaps *container =
gst_caps_new_full (gst_caps_steal_structure (formats, 0), NULL);
GstCaps *compatv =
gst_caps_list_compatible_codecs (container, vformats, muxers);
GstCaps *compata =
gst_caps_list_compatible_codecs (container, aformats, muxers);
vlen = gst_caps_get_size (compatv);
alen = gst_caps_get_size (compata);
for (v = 0; v < vlen; v++) {
GstCaps *vcodec =
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
(compatv, v)), NULL);
for (a = 0; a < alen; a++) {
GstCaps *acodec =
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
(compata, a)), NULL);
prof =
create_profile ((GstCaps *) container, (GstCaps *) vcodec,
(GstCaps *) acodec);
if (G_UNLIKELY (prof == NULL)) {
g_print ("Wrong arguments\n");
break;
}
outputuri =
ensure_uri (generate_filename (container, vcodec, acodec));
transcode_file (inputuri, outputuri, prof);
gst_encoding_profile_unref (prof);
gst_caps_unref (acodec);
}
gst_caps_unref (vcodec);
}
gst_caps_unref (container);
}
} else {
/* Create the profile */
prof = create_profile_from_string (format, vformat, aformat);
if (G_UNLIKELY (prof == NULL)) {
g_print ("Encoding arguments are not valid !\n");
return 1;
}
/* Transcode file */
transcode_file (inputuri, outputuri, prof);
/* cleanup */
gst_encoding_profile_unref (prof);
}
return 0;
}
int main(int args,char *argv[]){
const int smallOutputNumber=-1;
int i,j;
cJSON *root;
int num_chromosome;
int req_type=1;
char buffer[30];
char req_gene[20]={0};
cJSON *msg;
char req_kind[50]="E.coli K12-DH10B";
pi=0;
ini=0;
req_restrict.rfc10=0;
req_restrict.rfc12=0;
req_restrict.rfc12a=0;
req_restrict.rfc21=0;
req_restrict.rfc23=0;
req_restrict.rfc25=0;
char *req_str=argv_default;
if(args==2) req_str=argv[1];
cJSON *request=cJSON_Parse(req_str);
if(check_req(request)){
onError("illegal args");
return 0;
}
i=1;
j=1;
cJSON *cJSON_temp;
cJSON_temp=cJSON_GetObjectItem(request,"type");
if(cJSON_temp) req_type=cJSON_temp->valueint;
char req_pam[PAM_LEN+1];
int req_pam_len;
strcpy(req_pam,cJSON_GetObjectItem(request,"pam")->valuestring);
req_pam_len=(int)strlen(req_pam);
char req_specie[30];
struct return_struct rs;
int ptts_num;
int len[NUM_CHROMOSOME];
strcpy(req_specie,cJSON_GetObjectItem(request,"specie")->valuestring);
if(strcmp(req_specie,"SARS")==0){
rs=info_readin(PTT_SARS,ptts,str,wai,NULL);
}else if(strcmp(req_specie,"E.coli")==0){
cJSON_temp=cJSON_GetObjectItem(request,"kind");
if(cJSON_temp) strcpy(req_kind,cJSON_temp->valuestring);
rs=info_readin(PTT_ECOLI,ptts,str,wai,req_kind);
}else if(strcmp(req_specie,"Saccharomycetes")==0){
rs=info_readin(PTT_SACCHAROMYCETES,ptts,str,wai,NULL);
}else{
onError("no specie");
return 0;
}
ptts_num=rs.ptts_num;
num_chromosome=rs.num_chromosome;
for(i=1;i<=num_chromosome;i++) len[i]=rs.len[i];
double req_r1=0.65;
cJSON_temp=cJSON_GetObjectItem(request,"gene");
if(cJSON_temp){
req_r1=cJSON_GetObjectItem(request,"r1")->valuedouble;
}
cJSON_temp=cJSON_GetObjectItem(request,"gene");
int req_id,req_gene_start,req_gene_end;
if(cJSON_temp){
strcpy(req_gene,cJSON_temp->valuestring);
for(int i=0;i<ptts_num;i++){
if(strcmp(req_gene,ptts[i].gene)==0){
req_id=ptts[i].chromosome;
req_gene_start=ptts[i].s;
req_gene_end=ptts[i].t;
break;
}
}
}else{
char req_location[20];
strcpy(req_location,cJSON_GetObjectItem(request,"location")->valuestring);
sscanf(req_location,"%d:%d..%d",&req_id,&req_gene_start,&req_gene_end);
}
char req_rfc[10];
strcpy(req_rfc,cJSON_GetObjectItem(request,"rfc")->valuestring);
req_restrict.rfc10=req_rfc[0]-48;
req_restrict.rfc12=req_rfc[1]-48;
req_restrict.rfc12a=req_rfc[2]-48;
req_restrict.rfc21=req_rfc[3]-48;
req_restrict.rfc23=req_rfc[4]-48;
req_restrict.rfc25=req_rfc[5]-48;
generate_filename(buffer,req_specie,req_kind,req_pam,req_type);
dc_init(buffer);
/*
This part above is for read in JSON-style request.
The result stored in req_specie, req_pam, req_gene_start, req_gene_end, rfc and so on.
At the same time, it reads in ptt file for specie,
and also open files.
*/
for(int id=1;id<=num_chromosome;id++){
for(i=LEN;i<len[id]-req_pam_len;i++){ // All possible gRNAs, +direction
if(check_pam(str[id]+i,req_pam)){
psb_site[pi].index=i;
psb_site[pi].strand='+';
psb_site[pi].chromosome=id;
for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=(str[id]+i)[j];
psb_site[pi].pam[j]=0;
for(j=0;j<LEN;j++) psb_site[pi].nt[j]=(str[id]+i-LEN)[j];
psb_site[pi].nt[j]=0;
pi++;
}
}
char req_pam_rev[PAM_LEN];
int last=-1;
dna_rev(req_pam_rev,req_pam,req_pam_len);
for(i=0;i<len[id]-LEN-req_pam_len;i++){ // All possible gRNAs, -direction
if(check_pam(str[id]+i,req_pam_rev)){
psb_site[pi].index=i+req_pam_len-1;
psb_site[pi].strand='-';
psb_site[pi].chromosome=id;
if(req_pam_len!=last){
last=req_pam_len;
}
for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=dna_rev_char((str[id]+i)[req_pam_len-1-j]);
psb_site[pi].pam[j]=0;
for(j=0;j<LEN;j++) psb_site[pi].nt[j]=dna_rev_char((str[id]+i+req_pam_len)[LEN-j-1]);
psb_site[pi].nt[j]=0;
pi++;
}
}
}
for(i=0;i<pi;i++){
fflush(stdout);
if(psb_site[i].chromosome!=req_id) continue;
if(psb_site[i].strand=='+'){
if(psb_site[i].index<req_gene_start || psb_site[i].index+req_pam_len-1>req_gene_end) continue;
for(j=psb_site[i].index-LEN;j<psb_site[i].index+req_pam_len-1;j++){
if(wai[req_id][j]!=1) break;
}
if(j<psb_site[i].index+req_pam_len-1) j=0;
else j=1;
}else{
if(psb_site[i].index-req_pam_len+1<req_gene_start || psb_site[i].index>req_gene_end) continue;
for(j=psb_site[i].index-req_pam_len+1;j<psb_site[i].index+LEN;j++){
if(wai[req_id][j]!=1) break;
}
if(j<psb_site[i].index+LEN) j=0;
else j=1;
}
if(j){
score(i,&ini,req_type,req_r1);
}
}
dc_save();
sort(in_site,in_site+ini,cmp_in_site); // Sort & Output
root=cJSON_CreateObject();
cJSON_AddNumberToObject(root,"status",0);
msg=cJSON_CreateObject();
cJSON_AddStringToObject(msg,"specie",req_specie);
cJSON_AddStringToObject(msg,"kind",req_kind);
cJSON_AddStringToObject(msg,"gene",req_gene);
sprintf(buffer,"%d:%d..%d",req_id,req_gene_start,req_gene_end);
cJSON_AddStringToObject(msg,"location",buffer);
cJSON_AddItemToObject(root,"message",msg);
vector<cJSON*> list;
list.clear();
for(i=0;i<ini && i!=smallOutputNumber;i++){
cJSON *ans=cJSON_CreateObject();
sprintf(buffer,"#%d",i+1);
cJSON_AddStringToObject(ans,"key",buffer);
sprintf(buffer,"%s%s",in_site[i].nt,in_site[i].pam);
cJSON_AddStringToObject(ans,"grna",buffer);
sprintf(buffer,"%d:%d",in_site[i].chromosome,in_site[i].index);
cJSON_AddStringToObject(ans,"position",buffer);
char xs[2];
xs[0]=in_site[i].strand;
xs[1]=0;
cJSON_AddStringToObject(ans,"strand",xs);
cJSON_AddNumberToObject(ans,"total_score",(int)in_site[i].score);
cJSON_AddNumberToObject(ans,"Sspe",(int)(req_r1*in_site[i].Sspe_nor));
cJSON_AddNumberToObject(ans,"Seff",(int)((1.0-req_r1)*in_site[i].Seff_nor));
cJSON_AddNumberToObject(ans,"count",in_site[i].count);
cJSON_AddItemToObject(ans,"offtarget",in_site[i].otj);
list.push_back(ans);
}
cJSON_AddItemToObject(root,"result",Create_array_of_anything(&(list[0]),list.size()));
printf("%s\n",NomoreSpace(argv[0]=cJSON_Print(root)));
free(argv[0]);
return 0;
}
static int main_loop(int argc, const char **argv_) {
aom_codec_ctx_t decoder;
char *fn = NULL;
int i;
int ret = EXIT_FAILURE;
uint8_t *buf = NULL;
size_t bytes_in_buffer = 0, buffer_size = 0;
FILE *infile;
int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
int do_md5 = 0, progress = 0;
int stop_after = 0, postproc = 0, summary = 0, quiet = 1;
int arg_skip = 0;
int keep_going = 0;
const AvxInterface *interface = NULL;
const AvxInterface *fourcc_interface = NULL;
uint64_t dx_time = 0;
struct arg arg;
char **argv, **argi, **argj;
int single_file;
int use_y4m = 1;
int opt_yv12 = 0;
int opt_i420 = 0;
int opt_raw = 0;
aom_codec_dec_cfg_t cfg = { 0, 0, 0, CONFIG_LOWBITDEPTH, { 1 } };
unsigned int fixed_output_bit_depth = 0;
unsigned int is_annexb = 0;
int frames_corrupted = 0;
int dec_flags = 0;
int do_scale = 0;
int operating_point = 0;
int output_all_layers = 0;
int skip_film_grain = 0;
aom_image_t *scaled_img = NULL;
aom_image_t *img_shifted = NULL;
int frame_avail, got_data, flush_decoder = 0;
int num_external_frame_buffers = 0;
struct ExternalFrameBufferList ext_fb_list = { 0, NULL };
const char *outfile_pattern = NULL;
char outfile_name[PATH_MAX] = { 0 };
FILE *outfile = NULL;
FILE *framestats_file = NULL;
MD5Context md5_ctx;
unsigned char md5_digest[16];
struct AvxDecInputContext input = { NULL, NULL, NULL };
struct AvxInputContext aom_input_ctx;
memset(&aom_input_ctx, 0, sizeof(aom_input_ctx));
#if CONFIG_WEBM_IO
struct WebmInputContext webm_ctx;
memset(&webm_ctx, 0, sizeof(webm_ctx));
input.webm_ctx = &webm_ctx;
#endif
struct ObuDecInputContext obu_ctx = { NULL, NULL, 0, 0, 0 };
obu_ctx.avx_ctx = &aom_input_ctx;
input.obu_ctx = &obu_ctx;
input.aom_input_ctx = &aom_input_ctx;
/* Parse command line */
exec_name = argv_[0];
argv = argv_dup(argc - 1, argv_ + 1);
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
memset(&arg, 0, sizeof(arg));
arg.argv_step = 1;
if (arg_match(&arg, &help, argi)) {
show_help(stdout, 0);
exit(EXIT_SUCCESS);
} else if (arg_match(&arg, &codecarg, argi)) {
interface = get_aom_decoder_by_name(arg.val);
if (!interface)
die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
} else if (arg_match(&arg, &looparg, argi)) {
// no-op
} else if (arg_match(&arg, &outputfile, argi)) {
outfile_pattern = arg.val;
} else if (arg_match(&arg, &use_yv12, argi)) {
use_y4m = 0;
flipuv = 1;
opt_yv12 = 1;
opt_i420 = 0;
opt_raw = 0;
} else if (arg_match(&arg, &use_i420, argi)) {
use_y4m = 0;
flipuv = 0;
opt_yv12 = 0;
opt_i420 = 1;
opt_raw = 0;
} else if (arg_match(&arg, &rawvideo, argi)) {
use_y4m = 0;
opt_yv12 = 0;
opt_i420 = 0;
opt_raw = 1;
} else if (arg_match(&arg, &flipuvarg, argi)) {
flipuv = 1;
} else if (arg_match(&arg, &noblitarg, argi)) {
noblit = 1;
} else if (arg_match(&arg, &progressarg, argi)) {
progress = 1;
} else if (arg_match(&arg, &limitarg, argi)) {
stop_after = arg_parse_uint(&arg);
} else if (arg_match(&arg, &skiparg, argi)) {
arg_skip = arg_parse_uint(&arg);
} else if (arg_match(&arg, &postprocarg, argi)) {
postproc = 1;
} else if (arg_match(&arg, &md5arg, argi)) {
do_md5 = 1;
} else if (arg_match(&arg, &framestatsarg, argi)) {
framestats_file = fopen(arg.val, "w");
if (!framestats_file) {
die("Error: Could not open --framestats file (%s) for writing.\n",
arg.val);
}
} else if (arg_match(&arg, &summaryarg, argi)) {
summary = 1;
} else if (arg_match(&arg, &threadsarg, argi)) {
cfg.threads = arg_parse_uint(&arg);
#if !CONFIG_MULTITHREAD
if (cfg.threads > 1) {
die("Error: --threads=%d is not supported when CONFIG_MULTITHREAD = "
"0.\n",
cfg.threads);
}
#endif
} else if (arg_match(&arg, &verbosearg, argi)) {
quiet = 0;
} else if (arg_match(&arg, &scalearg, argi)) {
do_scale = 1;
} else if (arg_match(&arg, &fb_arg, argi)) {
num_external_frame_buffers = arg_parse_uint(&arg);
} else if (arg_match(&arg, &continuearg, argi)) {
keep_going = 1;
} else if (arg_match(&arg, &outbitdeptharg, argi)) {
fixed_output_bit_depth = arg_parse_uint(&arg);
} else if (arg_match(&arg, &isannexb, argi)) {
is_annexb = 1;
input.obu_ctx->is_annexb = 1;
} else if (arg_match(&arg, &oppointarg, argi)) {
operating_point = arg_parse_int(&arg);
} else if (arg_match(&arg, &outallarg, argi)) {
output_all_layers = 1;
} else if (arg_match(&arg, &skipfilmgrain, argi)) {
skip_film_grain = 1;
} else {
argj++;
}
}
/* Check for unrecognized options */
for (argi = argv; *argi; argi++)
if (argi[0][0] == '-' && strlen(argi[0]) > 1)
die("Error: Unrecognized option %s\n", *argi);
/* Handle non-option arguments */
fn = argv[0];
if (!fn) {
free(argv);
fprintf(stderr, "No input file specified!\n");
usage_exit();
}
/* Open file */
infile = strcmp(fn, "-") ? fopen(fn, "rb") : set_binary_mode(stdin);
if (!infile) {
fatal("Failed to open input file '%s'", strcmp(fn, "-") ? fn : "stdin");
}
#if CONFIG_OS_SUPPORT
/* Make sure we don't dump to the terminal, unless forced to with -o - */
if (!outfile_pattern && isatty(STDOUT_FILENO) && !do_md5 && !noblit) {
fprintf(stderr,
"Not dumping raw video to your terminal. Use '-o -' to "
"override.\n");
return EXIT_FAILURE;
}
#endif
input.aom_input_ctx->filename = fn;
input.aom_input_ctx->file = infile;
if (file_is_ivf(input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_IVF;
#if CONFIG_WEBM_IO
else if (file_is_webm(input.webm_ctx, input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_WEBM;
#endif
else if (file_is_obu(&obu_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_OBU;
else if (file_is_raw(input.aom_input_ctx))
input.aom_input_ctx->file_type = FILE_TYPE_RAW;
else {
fprintf(stderr, "Unrecognized input file type.\n");
#if !CONFIG_WEBM_IO
fprintf(stderr, "aomdec was built without WebM container support.\n");
#endif
return EXIT_FAILURE;
}
outfile_pattern = outfile_pattern ? outfile_pattern : "-";
single_file = is_single_file(outfile_pattern);
if (!noblit && single_file) {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
aom_input_ctx.width, aom_input_ctx.height, 0);
if (do_md5)
MD5Init(&md5_ctx);
else
outfile = open_outfile(outfile_name);
}
if (use_y4m && !noblit) {
if (!single_file) {
fprintf(stderr,
"YUV4MPEG2 not supported with output patterns,"
" try --i420 or --yv12 or --rawvideo.\n");
return EXIT_FAILURE;
}
#if CONFIG_WEBM_IO
if (aom_input_ctx.file_type == FILE_TYPE_WEBM) {
if (webm_guess_framerate(input.webm_ctx, input.aom_input_ctx)) {
fprintf(stderr,
"Failed to guess framerate -- error parsing "
"webm file?\n");
return EXIT_FAILURE;
}
}
#endif
}
fourcc_interface = get_aom_decoder_by_fourcc(aom_input_ctx.fourcc);
if (interface && fourcc_interface && interface != fourcc_interface)
warn("Header indicates codec: %s\n", fourcc_interface->name);
else
interface = fourcc_interface;
if (!interface) interface = get_aom_decoder_by_index(0);
dec_flags = (postproc ? AOM_CODEC_USE_POSTPROC : 0);
if (aom_codec_dec_init(&decoder, interface->codec_interface(), &cfg,
dec_flags)) {
fprintf(stderr, "Failed to initialize decoder: %s\n",
aom_codec_error(&decoder));
goto fail2;
}
if (!quiet) fprintf(stderr, "%s\n", decoder.name);
if (aom_codec_control(&decoder, AV1D_SET_IS_ANNEXB, is_annexb)) {
fprintf(stderr, "Failed to set is_annexb: %s\n", aom_codec_error(&decoder));
goto fail;
}
if (aom_codec_control(&decoder, AV1D_SET_OPERATING_POINT, operating_point)) {
fprintf(stderr, "Failed to set operating_point: %s\n",
aom_codec_error(&decoder));
goto fail;
}
if (aom_codec_control(&decoder, AV1D_SET_OUTPUT_ALL_LAYERS,
output_all_layers)) {
fprintf(stderr, "Failed to set output_all_layers: %s\n",
aom_codec_error(&decoder));
goto fail;
}
if (aom_codec_control(&decoder, AV1D_SET_SKIP_FILM_GRAIN, skip_film_grain)) {
fprintf(stderr, "Failed to set skip_film_grain: %s\n",
aom_codec_error(&decoder));
goto fail;
}
if (arg_skip) fprintf(stderr, "Skipping first %d frames.\n", arg_skip);
while (arg_skip) {
if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) break;
arg_skip--;
}
if (num_external_frame_buffers > 0) {
ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
ext_fb_list.ext_fb = (struct ExternalFrameBuffer *)calloc(
num_external_frame_buffers, sizeof(*ext_fb_list.ext_fb));
if (aom_codec_set_frame_buffer_functions(&decoder, get_av1_frame_buffer,
release_av1_frame_buffer,
&ext_fb_list)) {
fprintf(stderr, "Failed to configure external frame buffers: %s\n",
aom_codec_error(&decoder));
goto fail;
}
}
frame_avail = 1;
got_data = 0;
if (framestats_file) fprintf(framestats_file, "bytes,qp\r\n");
/* Decode file */
while (frame_avail || got_data) {
aom_codec_iter_t iter = NULL;
aom_image_t *img;
struct aom_usec_timer timer;
int corrupted = 0;
frame_avail = 0;
if (!stop_after || frame_in < stop_after) {
if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
frame_avail = 1;
frame_in++;
aom_usec_timer_start(&timer);
if (aom_codec_decode(&decoder, buf, bytes_in_buffer, NULL)) {
const char *detail = aom_codec_error_detail(&decoder);
warn("Failed to decode frame %d: %s", frame_in,
aom_codec_error(&decoder));
if (detail) warn("Additional information: %s", detail);
if (!keep_going) goto fail;
}
if (framestats_file) {
int qp;
if (aom_codec_control(&decoder, AOMD_GET_LAST_QUANTIZER, &qp)) {
warn("Failed AOMD_GET_LAST_QUANTIZER: %s",
aom_codec_error(&decoder));
if (!keep_going) goto fail;
}
fprintf(framestats_file, "%d,%d\r\n", (int)bytes_in_buffer, qp);
}
aom_usec_timer_mark(&timer);
dx_time += aom_usec_timer_elapsed(&timer);
} else {
flush_decoder = 1;
}
} else {
flush_decoder = 1;
}
aom_usec_timer_start(&timer);
if (flush_decoder) {
// Flush the decoder.
if (aom_codec_decode(&decoder, NULL, 0, NULL)) {
warn("Failed to flush decoder: %s", aom_codec_error(&decoder));
}
}
aom_usec_timer_mark(&timer);
dx_time += aom_usec_timer_elapsed(&timer);
got_data = 0;
while ((img = aom_codec_get_frame(&decoder, &iter))) {
++frame_out;
got_data = 1;
if (aom_codec_control(&decoder, AOMD_GET_FRAME_CORRUPTED, &corrupted)) {
warn("Failed AOM_GET_FRAME_CORRUPTED: %s", aom_codec_error(&decoder));
if (!keep_going) goto fail;
}
frames_corrupted += corrupted;
if (progress) show_progress(frame_in, frame_out, dx_time);
if (!noblit) {
const int PLANES_YUV[] = { AOM_PLANE_Y, AOM_PLANE_U, AOM_PLANE_V };
const int PLANES_YVU[] = { AOM_PLANE_Y, AOM_PLANE_V, AOM_PLANE_U };
const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
if (do_scale) {
if (frame_out == 1) {
// If the output frames are to be scaled to a fixed display size
// then use the width and height specified in the container. If
// either of these is set to 0, use the display size set in the
// first frame header. If that is unavailable, use the raw decoded
// size of the first decoded frame.
int render_width = aom_input_ctx.width;
int render_height = aom_input_ctx.height;
if (!render_width || !render_height) {
int render_size[2];
if (aom_codec_control(&decoder, AV1D_GET_DISPLAY_SIZE,
render_size)) {
// As last resort use size of first frame as display size.
render_width = img->d_w;
render_height = img->d_h;
} else {
render_width = render_size[0];
render_height = render_size[1];
}
}
scaled_img =
aom_img_alloc(NULL, img->fmt, render_width, render_height, 16);
scaled_img->bit_depth = img->bit_depth;
scaled_img->monochrome = img->monochrome;
scaled_img->csp = img->csp;
}
if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
#if CONFIG_LIBYUV
libyuv_scale(img, scaled_img, kFilterBox);
img = scaled_img;
#else
fprintf(
stderr,
"Failed to scale output frame: %s.\n"
"libyuv is required for scaling but is currently disabled.\n"
"Be sure to specify -DCONFIG_LIBYUV=1 when running cmake.\n",
aom_codec_error(&decoder));
goto fail;
#endif
}
}
// Default to codec bit depth if output bit depth not set
unsigned int output_bit_depth;
if (!fixed_output_bit_depth && single_file && !do_md5) {
output_bit_depth = img->bit_depth;
} else {
output_bit_depth = fixed_output_bit_depth;
}
// Shift up or down if necessary
if (output_bit_depth != 0)
aom_shift_img(output_bit_depth, &img, &img_shifted);
aom_input_ctx.width = img->d_w;
aom_input_ctx.height = img->d_h;
int num_planes = (opt_raw && img->monochrome) ? 1 : 3;
if (single_file) {
if (use_y4m) {
char y4m_buf[Y4M_BUFFER_SIZE] = { 0 };
size_t len = 0;
if (frame_out == 1) {
// Y4M file header
len = y4m_write_file_header(
y4m_buf, sizeof(y4m_buf), aom_input_ctx.width,
aom_input_ctx.height, &aom_input_ctx.framerate,
img->monochrome, img->csp, img->fmt, img->bit_depth);
if (img->csp == AOM_CSP_COLOCATED) {
fprintf(stderr,
"Warning: Y4M lacks a colorspace for colocated "
"chroma. Using a placeholder.\n");
}
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)y4m_buf, (unsigned int)len);
} else {
fputs(y4m_buf, outfile);
}
}
// Y4M frame header
len = y4m_write_frame_header(y4m_buf, sizeof(y4m_buf));
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)y4m_buf, (unsigned int)len);
y4m_update_image_md5(img, planes, &md5_ctx);
} else {
fputs(y4m_buf, outfile);
y4m_write_image_file(img, planes, outfile);
}
} else {
if (frame_out == 1) {
// Check if --yv12 or --i420 options are consistent with the
// bit-stream decoded
if (opt_i420) {
if (img->fmt != AOM_IMG_FMT_I420 &&
img->fmt != AOM_IMG_FMT_I42016) {
fprintf(stderr,
"Cannot produce i420 output for bit-stream.\n");
goto fail;
}
}
if (opt_yv12) {
if ((img->fmt != AOM_IMG_FMT_I420 &&
img->fmt != AOM_IMG_FMT_YV12) ||
img->bit_depth != 8) {
fprintf(stderr,
"Cannot produce yv12 output for bit-stream.\n");
goto fail;
}
}
}
if (do_md5) {
raw_update_image_md5(img, planes, num_planes, &md5_ctx);
} else {
raw_write_image_file(img, planes, num_planes, outfile);
}
}
} else {
generate_filename(outfile_pattern, outfile_name, PATH_MAX, img->d_w,
img->d_h, frame_in);
if (do_md5) {
MD5Init(&md5_ctx);
if (use_y4m) {
y4m_update_image_md5(img, planes, &md5_ctx);
} else {
raw_update_image_md5(img, planes, num_planes, &md5_ctx);
}
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
outfile = open_outfile(outfile_name);
if (use_y4m) {
y4m_write_image_file(img, planes, outfile);
} else {
raw_write_image_file(img, planes, num_planes, outfile);
}
fclose(outfile);
}
}
}
}
}
if (summary || progress) {
show_progress(frame_in, frame_out, dx_time);
fprintf(stderr, "\n");
}
if (frames_corrupted) {
fprintf(stderr, "WARNING: %d frames corrupted.\n", frames_corrupted);
} else {
ret = EXIT_SUCCESS;
}
fail:
if (aom_codec_destroy(&decoder)) {
fprintf(stderr, "Failed to destroy decoder: %s\n",
aom_codec_error(&decoder));
}
fail2:
if (!noblit && single_file) {
if (do_md5) {
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
fclose(outfile);
}
}
#if CONFIG_WEBM_IO
if (input.aom_input_ctx->file_type == FILE_TYPE_WEBM)
webm_free(input.webm_ctx);
#endif
if (input.aom_input_ctx->file_type == FILE_TYPE_OBU)
obudec_free(input.obu_ctx);
if (input.aom_input_ctx->file_type != FILE_TYPE_WEBM) free(buf);
if (scaled_img) aom_img_free(scaled_img);
if (img_shifted) aom_img_free(img_shifted);
for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
free(ext_fb_list.ext_fb[i].data);
}
free(ext_fb_list.ext_fb);
fclose(infile);
if (framestats_file) fclose(framestats_file);
free(argv);
return ret;
}