static void
print_totals_robot(void)
{
char checks[CHECKS_STR_SIZE];
get_check_names(checks, totals.checks, false);
printf("totals\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
"\t%s\t%s\t%" PRIu64 "\t%" PRIu64,
totals.streams,
totals.blocks,
totals.compressed_size,
totals.uncompressed_size,
get_ratio(totals.compressed_size,
totals.uncompressed_size),
checks,
totals.stream_padding,
totals.files);
if (message_verbosity_get() >= V_DEBUG)
printf("\t%" PRIu64 "\t%s\t%" PRIu32,
totals.memusage_max,
totals.all_have_sizes ? "yes" : "no",
totals.min_version);
putchar('\n');
return;
}
static void
print_adv_helper(uint64_t stream_count, uint64_t block_count,
uint64_t compressed_size, uint64_t uncompressed_size,
uint32_t checks, uint64_t stream_padding)
{
char checks_str[CHECKS_STR_SIZE];
get_check_names(checks_str, checks, true);
printf(_(" Streams: %s\n"),
uint64_to_str(stream_count, 0));
printf(_(" Blocks: %s\n"),
uint64_to_str(block_count, 0));
printf(_(" Compressed size: %s\n"),
uint64_to_nicestr(compressed_size,
NICESTR_B, NICESTR_TIB, true, 0));
printf(_(" Uncompressed size: %s\n"),
uint64_to_nicestr(uncompressed_size,
NICESTR_B, NICESTR_TIB, true, 0));
printf(_(" Ratio: %s\n"),
get_ratio(compressed_size, uncompressed_size));
printf(_(" Check: %s\n"), checks_str);
printf(_(" Stream padding: %s\n"),
uint64_to_nicestr(stream_padding,
NICESTR_B, NICESTR_TIB, true, 0));
return;
}
int main(int argc, char * argv[]) {
struct cmd_options opts = parse_cmd_options(argc, argv);
FILE * fin = fopen(opts.infname, "r");
handle_fopen_error(fin, argv[0], "error opening input file");
FILE * fout = fopen(opts.outfname, "w");
handle_fopen_error(fout, argv[0], "error opening output file");
int64_t orig_width = 0, orig_height = 0;
size_t entriesn = get_orig_dimensions(&orig_width, &orig_height, fin);
fseek(fin, 0, SEEK_SET);
struct point_set set = {};
set.ratio.x = get_ratio(opts.width, orig_width);
set.ratio.y = get_ratio(opts.height, orig_height);
size_t alloc_size = MAX(set.ratio.x, set.ratio.y) * entriesn;
set.vec = calloc(alloc_size, sizeof *set.vec);
if (set.vec == NULL) {
fprintf(stderr, "%s: not enough memory\n", argv[0]);
return EXIT_FAILURE;
}
fill_set(&set, fin);
fclose(fin);
for (size_t i = 0; i < set.size; i++) {
fprintf(fout, "%.100Lg %.100Lg\n", set.vec[i].x, set.vec[i].y);
}
// kernel will take a better care of this:
// free(set.vec);
// free(opts.infname);
// free(opts.outfname);
// fclose(fout);
// so don't mind the valgrind "leaks"
return EXIT_SUCCESS;
}
int determine_phrase_direction(pedphrase * phrase) {
peddirection dir;
float ratio;
pedbox *box;
if (phrase == NULL)
return PEDDIRECT_UNSET;
box = phrase->phrasebox;
dir = PEDDIRECT_UNSET;
ratio = get_ratio (box);
if ( ratio > 2.0 ) {
dir = PEDDIRECT_HOR;
}
else if ( ratio < 0.5) {
dir = PEDDIRECT_VER;
}
phrase->dir = dir;
return dir;
}
static bool
print_info_basic(const xz_file_info *xfi, file_pair *pair)
{
static bool headings_displayed = false;
if (!headings_displayed) {
headings_displayed = true;
// TRANSLATORS: These are column headings. From Strms (Streams)
// to Ratio, the columns are right aligned. Check and Filename
// are left aligned. If you need longer words, it's OK to
// use two lines here. Test with "xz -l foo.xz".
puts(_("Strms Blocks Compressed Uncompressed Ratio "
"Check Filename"));
}
char checks[CHECKS_STR_SIZE];
get_check_names(checks, lzma_index_checks(xfi->idx), false);
const char *cols[7] = {
uint64_to_str(lzma_index_stream_count(xfi->idx), 0),
uint64_to_str(lzma_index_block_count(xfi->idx), 1),
uint64_to_nicestr(lzma_index_file_size(xfi->idx),
NICESTR_B, NICESTR_TIB, false, 2),
uint64_to_nicestr(lzma_index_uncompressed_size(xfi->idx),
NICESTR_B, NICESTR_TIB, false, 3),
get_ratio(lzma_index_file_size(xfi->idx),
lzma_index_uncompressed_size(xfi->idx)),
checks,
pair->src_name,
};
printf("%*s %*s %*s %*s %*s %-*s %s\n",
tuklib_mbstr_fw(cols[0], 5), cols[0],
tuklib_mbstr_fw(cols[1], 7), cols[1],
tuklib_mbstr_fw(cols[2], 11), cols[2],
tuklib_mbstr_fw(cols[3], 11), cols[3],
tuklib_mbstr_fw(cols[4], 5), cols[4],
tuklib_mbstr_fw(cols[5], 7), cols[5],
cols[6]);
return false;
}
static void
print_totals_basic(void)
{
// Print a separator line.
char line[80];
memset(line, '-', sizeof(line));
line[sizeof(line) - 1] = '\0';
puts(line);
// Get the check names.
char checks[CHECKS_STR_SIZE];
get_check_names(checks, totals.checks, false);
// Print the totals except the file count, which needs
// special handling.
printf("%5s %7s %11s %11s %5s %-7s ",
uint64_to_str(totals.streams, 0),
uint64_to_str(totals.blocks, 1),
uint64_to_nicestr(totals.compressed_size,
NICESTR_B, NICESTR_TIB, false, 2),
uint64_to_nicestr(totals.uncompressed_size,
NICESTR_B, NICESTR_TIB, false, 3),
get_ratio(totals.compressed_size,
totals.uncompressed_size),
checks);
// Since we print totals only when there are at least two files,
// the English message will always use "%s files". But some other
// languages need different forms for different plurals so we
// have to translate this with ngettext().
//
// TRANSLATORS: %s is an integer. Only the plural form of this
// message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz".
printf(ngettext("%s file\n", "%s files\n",
totals.files <= ULONG_MAX ? totals.files
: (totals.files % 1000000) + 1000000),
uint64_to_str(totals.files, 0));
return;
}
/*******************************************************************
*
* NAME : update_inverse();
*
*
* DESCRIPTION : Updates the inverse matrix for the
* active particle.
*
*/
void Slater::update_inverse() {
int i = active_particle;
Dp_inv_new = Dp_inv;
Dm_inv = Dm_inv_new;
double S;
// TMP solution for the inverse.
double R = get_ratio();
if (i < N) { // Spin up
for (int j = 0; j < N; j++) {
if (j != i) {
S = 0;
for (int l = 0; l < N; l++)
S += Dp_new(l, i) * Dp_inv(l, j);
}
for (int l = 0; l < N; l++)
Dp_inv_new(l, j) = Dp_inv(l, j) - (Dp_inv(l, i) / R) * S;
}
for (int l = 0; l < N; l++)
Dp_inv_new(l, i) = Dp_inv(l, i) / R;
} else { // Spin down
for (int j = 0; j < N; j++) {
if (j != i - N) {
S = 0;
for (int l = 0; l < N; l++)
S += Dm_new(l, i - N) * Dm_inv(l, j);
}
for (int l = 0; l < N; l++)
Dm_inv_new(l, j) = Dm_inv(l, j) - (Dm_inv(l, i - N) / R) * S;
}
for (int l = 0; l < N; l++)
Dm_inv_new(l, i - N) = Dm_inv(l, i - N) / R;
}
}
void Scene::build_laplacian(const FT scale,
const std::map<unsigned, unsigned>& indices,
SparseMatrix& A) const
{
unsigned nb = A.numRows();
for (unsigned k = 0; k < m_vertices.size(); ++k)
{
Vertex_handle vi = m_vertices[k];
if (vi->is_hidden()) continue;
unsigned i = indices.find(vi->get_index())->second;
double diagi = 0.0;
SparseArray rowi(nb);
Edge_circulator ecirc = m_rt.incident_edges(vi);
Edge_circulator eend = ecirc;
CGAL_For_all(ecirc, eend)
{
Edge edge = *ecirc;
if (!m_rt.is_inside(edge)) continue;
Vertex_handle vj = m_rt.get_source(edge);
if (vj == vi) vj = m_rt.get_target(edge);
unsigned j = vj->get_index();
j = indices.find(j)->second;
double coef = scale * get_ratio(edge);
if (std::abs(coef) < EPS) continue;
rowi.setValue(j, -coef);
diagi += coef;
}
rowi.setValue(i, diagi);
A.setRow(i, rowi);
}
void main(int argc, char **argv)
{
int row, col, row_size, col_size;
char input_image[512], qimage[512];
unsigned char **imgin;
int *bound, *reco, input, label, output, numlev, numbits, c;
int minvalue, maxvalue, range, level, stepsize, temp, end_flag;
FILE *ofp;
extern int optind;
extern char *optarg;
fprintf(stderr,"\n\n\t\tUniform Quantization of Images - Encoder\n");
ofp = stdout;
strcpy(qimage,"standard out");
numlev = -1;
numbits = -1;
minvalue = 0;
maxvalue = 255;
while((c=getopt(argc,argv,"i:o:l:b:m:t:h"))!=EOF)
{
switch (c){
case 'i':
strcpy(input_image,optarg);
break;
case 'o':
strcpy(qimage,optarg);
ofp = fopen(optarg,"wb");
break;
case 'l':
sscanf(optarg,"%d", &numlev);
break;
case 'b':
sscanf(optarg,"%d", &numbits);
break;
case 'm':
sscanf(optarg,"%d", &maxvalue);
break;
case 't':
sscanf(optarg,"%d", &minvalue);
break;
case 'x':
sscanf(optarg,"%d", &row_size);
break;
case 'y':
sscanf(optarg,"%d", &col_size);
break;
case 'h':
usage();
exit(1);
}
}
if(numlev > 0 && numbits > 0)
{
temp = (int) pow((double) 2,(double) numbits);
if(temp != numlev)
{
fprintf(stderr,"\n You have entered values for the number of levels and\n");
fprintf(stderr,"number of bits that are not compatible. The number of\n");
fprintf(stderr,"levels should be 2^(number of bits). If you want to use\n");
fprintf(stderr,"a number of levels which is not a power of 2 then only\n");
fprintf(stderr,"enter a value for the number of levels.\n");
exit(1);
}
}
if(numlev < 0 && numbits < 0)
{
fprintf(stderr,"\n Enter number of bits per pixel: ");
scanf("%d",&numbits);
numlev = (int) pow((double) 2,(double) numbits);
}
if (numbits <= 0 || numbits >= 8) {
fprintf(stderr,"\n You have entered values for the number of bits that\n");
fprintf(stderr,"are not compatible. The number of bits should between\n");
fprintf(stderr,"1 (one) - 7 (seven).\n");
exit(1);
}
if(numlev < 0 && numbits > 0)
numlev = (int) pow((double) 2,(double) numbits);
if(numlev > 0 && numbits < 0)
numbits = (int) (log((double)numlev)/log((double) 2.) + 0.99999);
/* Determine range, and stepsize for the quantizer
*/
range = maxvalue - minvalue + 1;
stepsize = range/(numlev);
/* Allocate space for the boundary values */
bound = (int *) calloc((numlev+1),sizeof(int));
/* Construct the boundary tables */
bound[0] = minvalue;
for(level=1; level<=numlev; level++)
{
bound[level] = bound[level-1] + stepsize;
}
/* Find out how large the image is */
image_size(input_image, &row_size, &col_size);
/* Allocate space for input image */
imgin = (unsigned char **) calloc(row_size,sizeof(char *));
for(row=0; row<row_size; row++)
imgin[row] = (unsigned char *) calloc((col_size),sizeof(char));
/* Read the input image */
readimage(input_image, imgin, row_size, col_size);
/* Store coding parameters in the output file */
fwrite(&numlev,1,sizeof(int),ofp);
fwrite(&numbits,1,sizeof(int),ofp);
fwrite(&maxvalue,1,sizeof(int),ofp);
fwrite(&minvalue,1,sizeof(int),ofp);
fwrite(&row_size,1,sizeof(int),ofp);
fwrite(&col_size,1,sizeof(int),ofp);
struct Queue* code_write;
code_write = (struct Queue*) malloc(sizeof(struct Queue));
code_write->front = NULL;
code_write->rear = NULL;
code_write->size = 0;
// Print(&(code_write)->front);
/* encode each pixel into an integer label and store */
end_flag = 0;
for(row=0; row<row_size; row++)
for(col=0; col<col_size; col++)
{
if(row == row_size-1 && col == col_size - 1)
end_flag = 1;
input = imgin[row][col];
label = encuqi(input,bound,numlev);
// printf("%d %d, ", input, label);
// printf("%d ", &ofp);
// stuffit(label,numbits,&ofp,end_flag);
stuffit(label,numbits,&code_write,end_flag);
}
// Print(&code_write->front);
while(code_write->size >= 8) {
write_to_file(&ofp, &code_write);
}
// printf("%d", code_write->size);
FILE *fp;
fp = fopen(input_image, "rb");
double ratio_com = get_ratio(&fp, &ofp);
printf("\n Ratio compression := %lf %%\n", ratio_com);
fclose(fp);
fclose(ofp);
}
static bool
print_info_robot(xz_file_info *xfi, file_pair *pair)
{
char checks[CHECKS_STR_SIZE];
get_check_names(checks, lzma_index_checks(xfi->idx), false);
printf("name\t%s\n", pair->src_name);
printf("file\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
"\t%s\t%s\t%" PRIu64 "\n",
lzma_index_stream_count(xfi->idx),
lzma_index_block_count(xfi->idx),
lzma_index_file_size(xfi->idx),
lzma_index_uncompressed_size(xfi->idx),
get_ratio(lzma_index_file_size(xfi->idx),
lzma_index_uncompressed_size(xfi->idx)),
checks,
xfi->stream_padding);
if (message_verbosity_get() >= V_VERBOSE) {
lzma_index_iter iter;
lzma_index_iter_init(&iter, xfi->idx);
while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_STREAM))
printf("stream\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
"\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
"\t%s\t%s\t%" PRIu64 "\n",
iter.stream.number,
iter.stream.block_count,
iter.stream.compressed_offset,
iter.stream.uncompressed_offset,
iter.stream.compressed_size,
iter.stream.uncompressed_size,
get_ratio(iter.stream.compressed_size,
iter.stream.uncompressed_size),
check_names[iter.stream.flags->check],
iter.stream.padding);
lzma_index_iter_rewind(&iter);
block_header_info bhi;
while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_BLOCK)) {
if (message_verbosity_get() >= V_DEBUG
&& parse_details(
pair, &iter, &bhi, xfi))
return true;
printf("block\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
"\t%" PRIu64 "\t%" PRIu64
"\t%" PRIu64 "\t%" PRIu64 "\t%s\t%s",
iter.stream.number,
iter.block.number_in_stream,
iter.block.number_in_file,
iter.block.compressed_file_offset,
iter.block.uncompressed_file_offset,
iter.block.total_size,
iter.block.uncompressed_size,
get_ratio(iter.block.total_size,
iter.block.uncompressed_size),
check_names[iter.stream.flags->check]);
if (message_verbosity_get() >= V_DEBUG)
printf("\t%s\t%" PRIu32 "\t%s\t%" PRIu64
"\t%" PRIu64 "\t%s",
check_value,
bhi.header_size,
bhi.flags,
bhi.compressed_size,
bhi.memusage,
bhi.filter_chain);
putchar('\n');
}
}
if (message_verbosity_get() >= V_DEBUG)
printf("summary\t%" PRIu64 "\t%s\t%" PRIu32 "\n",
xfi->memusage_max,
xfi->all_have_sizes ? "yes" : "no",
xfi->min_version);
return false;
}
static bool
print_info_adv(xz_file_info *xfi, file_pair *pair)
{
// Print the overall information.
print_adv_helper(lzma_index_stream_count(xfi->idx),
lzma_index_block_count(xfi->idx),
lzma_index_file_size(xfi->idx),
lzma_index_uncompressed_size(xfi->idx),
lzma_index_checks(xfi->idx),
xfi->stream_padding);
// Size of the biggest Check. This is used to calculate the width
// of the CheckVal field. The table would get insanely wide if
// we always reserved space for 64-byte Check (128 chars as hex).
uint32_t check_max = 0;
// Print information about the Streams.
//
// TRANSLATORS: The second line is column headings. All except
// Check are right aligned; Check is left aligned. Test with
// "xz -lv foo.xz".
puts(_(" Streams:\n Stream Blocks"
" CompOffset UncompOffset"
" CompSize UncompSize Ratio"
" Check Padding"));
lzma_index_iter iter;
lzma_index_iter_init(&iter, xfi->idx);
while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_STREAM)) {
const char *cols1[4] = {
uint64_to_str(iter.stream.number, 0),
uint64_to_str(iter.stream.block_count, 1),
uint64_to_str(iter.stream.compressed_offset, 2),
uint64_to_str(iter.stream.uncompressed_offset, 3),
};
printf(" %*s %*s %*s %*s ",
tuklib_mbstr_fw(cols1[0], 6), cols1[0],
tuklib_mbstr_fw(cols1[1], 9), cols1[1],
tuklib_mbstr_fw(cols1[2], 15), cols1[2],
tuklib_mbstr_fw(cols1[3], 15), cols1[3]);
const char *cols2[5] = {
uint64_to_str(iter.stream.compressed_size, 0),
uint64_to_str(iter.stream.uncompressed_size, 1),
get_ratio(iter.stream.compressed_size,
iter.stream.uncompressed_size),
_(check_names[iter.stream.flags->check]),
uint64_to_str(iter.stream.padding, 2),
};
printf("%*s %*s %*s %-*s %*s\n",
tuklib_mbstr_fw(cols2[0], 15), cols2[0],
tuklib_mbstr_fw(cols2[1], 15), cols2[1],
tuklib_mbstr_fw(cols2[2], 5), cols2[2],
tuklib_mbstr_fw(cols2[3], 10), cols2[3],
tuklib_mbstr_fw(cols2[4], 7), cols2[4]);
// Update the maximum Check size.
if (lzma_check_size(iter.stream.flags->check) > check_max)
check_max = lzma_check_size(iter.stream.flags->check);
}
// Cache the verbosity level to a local variable.
const bool detailed = message_verbosity_get() >= V_DEBUG;
// Information collected from Block Headers
block_header_info bhi;
// Print information about the Blocks but only if there is
// at least one Block.
if (lzma_index_block_count(xfi->idx) > 0) {
// Calculate the width of the CheckVal field.
const int checkval_width = my_max(8, 2 * check_max);
// TRANSLATORS: The second line is column headings. All
// except Check are right aligned; Check is left aligned.
printf(_(" Blocks:\n Stream Block"
" CompOffset UncompOffset"
" TotalSize UncompSize Ratio Check"));
if (detailed) {
// TRANSLATORS: These are additional column headings
// for the most verbose listing mode. CheckVal
// (Check value), Flags, and Filters are left aligned.
// Header (Block Header Size), CompSize, and MemUsage
// are right aligned. %*s is replaced with 0-120
// spaces to make the CheckVal column wide enough.
// Test with "xz -lvv foo.xz".
printf(_(" CheckVal %*s Header Flags "
"CompSize MemUsage Filters"),
checkval_width - 8, "");
}
putchar('\n');
lzma_index_iter_init(&iter, xfi->idx);
// Iterate over the Blocks.
while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_BLOCK)) {
if (detailed && parse_details(pair, &iter, &bhi, xfi))
return true;
const char *cols1[4] = {
uint64_to_str(iter.stream.number, 0),
uint64_to_str(
iter.block.number_in_stream, 1),
uint64_to_str(
iter.block.compressed_file_offset, 2),
uint64_to_str(
iter.block.uncompressed_file_offset, 3)
};
printf(" %*s %*s %*s %*s ",
tuklib_mbstr_fw(cols1[0], 6), cols1[0],
tuklib_mbstr_fw(cols1[1], 9), cols1[1],
tuklib_mbstr_fw(cols1[2], 15), cols1[2],
tuklib_mbstr_fw(cols1[3], 15), cols1[3]);
const char *cols2[4] = {
uint64_to_str(iter.block.total_size, 0),
uint64_to_str(iter.block.uncompressed_size,
1),
get_ratio(iter.block.total_size,
iter.block.uncompressed_size),
_(check_names[iter.stream.flags->check])
};
printf("%*s %*s %*s %-*s",
tuklib_mbstr_fw(cols2[0], 15), cols2[0],
tuklib_mbstr_fw(cols2[1], 15), cols2[1],
tuklib_mbstr_fw(cols2[2], 5), cols2[2],
tuklib_mbstr_fw(cols2[3], detailed ? 11 : 1),
cols2[3]);
if (detailed) {
const lzma_vli compressed_size
= iter.block.unpadded_size
- bhi.header_size
- lzma_check_size(
iter.stream.flags->check);
const char *cols3[6] = {
check_value,
uint64_to_str(bhi.header_size, 0),
bhi.flags,
uint64_to_str(compressed_size, 1),
uint64_to_str(
round_up_to_mib(bhi.memusage),
2),
bhi.filter_chain
};
// Show MiB for memory usage, because it
// is the only size which is not in bytes.
printf("%-*s %*s %-5s %*s %*s MiB %s",
checkval_width, cols3[0],
tuklib_mbstr_fw(cols3[1], 6), cols3[1],
cols3[2],
tuklib_mbstr_fw(cols3[3], 15),
cols3[3],
tuklib_mbstr_fw(cols3[4], 7), cols3[4],
cols3[5]);
}
putchar('\n');
}
}
if (detailed) {
printf(_(" Memory needed: %s MiB\n"), uint64_to_str(
round_up_to_mib(xfi->memusage_max), 0));
printf(_(" Sizes in headers: %s\n"),
xfi->all_have_sizes ? _("Yes") : _("No"));
printf(_(" Minimum XZ Utils version: %s\n"),
xz_ver_to_str(xfi->min_version));
}
return false;
}
GnashImage*
Video::getVideoFrame()
{
// If this is a video from a NetStream_as object, retrieve a video
// frame from there.
if (_ns)
{
std::auto_ptr<GnashImage> tmp = _ns->get_video();
if ( tmp.get() ) _lastDecodedVideoFrame = tmp;
}
// If this is a video from a VideoFrame tag, retrieve a video frame
// from there.
else if (_embeddedStream)
{
// Don't try to do anything if there is no decoder. If it was
// never constructed (most likely), we'll return nothing,
// otherwise the last decoded frame.
if (!_decoder.get()) return _lastDecodedVideoFrame.get();
int current_frame = get_ratio();
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug("Video instance %s need display video frame (ratio) %d",
getTarget(), current_frame);
#endif
// If current frame is the same then last decoded
// we don't need to decode more
if ( _lastDecodedVideoFrameNum == current_frame )
{
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" current frame == _lastDecodedVideoFrameNum (%d)",
current_frame);
#endif
return _lastDecodedVideoFrame.get();
}
int from_frame = _lastDecodedVideoFrameNum < 0 ?
0 : _lastDecodedVideoFrameNum + 1;
// If current frame is smaller then last decoded frame
// we restart decoding from scratch
if ( current_frame < _lastDecodedVideoFrameNum )
{
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" current frame (%d) < _lastDecodedVideoFrameNum (%d)",
current_frame, _lastDecodedVideoFrameNum);
#endif
from_frame = 0;
}
// Reset last decoded video frame number now, so it's correct
// on early return (ie: nothing more to decode)
_lastDecodedVideoFrameNum = current_frame;
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" decoding embedded frames from %d to %d for Video "
"object %s", from_frame, current_frame, getTarget());
#endif
typedef SWF::DefineVideoStreamTag::EmbeddedFrames EncodedFrames;
EncodedFrames toDecode;
m_def->getEncodedFrameSlice(from_frame, current_frame, toDecode);
// Nothing more to decode, return last decoded (possibly null)
if ( toDecode.empty() )
{
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" no defined frames, we'll return last one");
#endif
return _lastDecodedVideoFrame.get();
}
for (EncodedFrames::iterator it=toDecode.begin(),
itEnd=toDecode.end(); it!=itEnd; ++it)
{
media::EncodedVideoFrame* frame = *it;
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" pushing frame %d to decoder", frame->frameNum());
#endif
_decoder->push(*frame);
}
_lastDecodedVideoFrame = _decoder->pop();
}
return _lastDecodedVideoFrame.get();
}
static void menu_create_item(GooCanvasItem *parent, MenuItems *menuitems, GcomprisBoard *board)
{
GdkPixbuf *menu_pixmap = NULL;
GooCanvasItem *menu_button;
int difficulty;
gdouble ratio, pixmap_w, pixmap_h;
menu_pixmap = gc_pixmap_load(board->icon_name);
ratio = get_ratio (menu_pixmap, icon_size);
pixmap_w = gdk_pixbuf_get_width(menu_pixmap) * ratio;
pixmap_h = gdk_pixbuf_get_height(menu_pixmap) * ratio;
next_spot();
menu_button = goo_canvas_image_new (parent,
menu_pixmap,
current_x - pixmap_w/2,
current_y - pixmap_h/2,
NULL);
goo_canvas_item_scale(menu_button, ratio, ratio);
// display board availability due to sound voice not present
if(board->mandatory_sound_file)
{
gchar *soundfile = NULL;
/* We search a fixed path sound file */
soundfile = gc_file_find_absolute(board->mandatory_sound_file);
if (!soundfile || !gc_prop_get()->fx) {
GooCanvasItem *item = \
goo_canvas_svg_new (parent,
gc_skin_rsvg_get(),
"svg-id", "#SOUND_UNCHECKED",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
GooCanvasBounds bounds;
goo_canvas_item_get_bounds(item, &bounds);
SET_ITEM_LOCATION(item,
current_x - pixmap_w/2 - 25 -
(bounds.x2 - bounds.x1)/2,
current_y - pixmap_h/2 + 28-
(bounds.y2 - bounds.y1)/2);
}
g_free(soundfile);
}
// display menu icon ========================== BEGIN
if(g_ascii_strcasecmp(board->type, "menu") == 0)
{
GooCanvasItem *item = goo_canvas_svg_new (parent,
gc_skin_rsvg_get(),
"svg-id", "#MENUICON",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
SET_ITEM_LOCATION(item,
current_x - pixmap_w/2 - 25,
current_y - pixmap_h/2);
}
else
{
// display difficulty stars
if (board->difficulty != NULL)
{
difficulty = atoi(board->difficulty);
menu_difficulty_display(parent,
(double)current_x - pixmap_w/2 - 25,
(double)current_y - pixmap_h/2,
(double) 0.6,
difficulty);
}
if ( gc_board_is_demo_only(board) )
menu_demo_display(parent,
(gdouble)(current_x - pixmap_w/2 - 20),
(gdouble)(current_y - pixmap_h/2 + 60) );
}
#if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24
gdk_pixbuf_unref(menu_pixmap);
#else
g_object_unref(menu_pixmap);
#endif
// display menu icon ========================== END
/*
* Now everything ready, map the events
* -------------------------------------
*/
g_object_set_data (G_OBJECT (menu_button), "board", board);
g_signal_connect(menu_button, "button_press_event",
(GCallback) item_event,
menuitems);
g_signal_connect (menu_button, "enter_notify_event",
(GCallback) on_enter_notify, menuitems);
g_signal_connect (menu_button, "leave_notify_event",
(GCallback) on_leave_notify, menuitems);
gc_item_focus_init(menu_button, NULL);
}
int mc_simm::step(Plasma &Gas){
int i,j;
Vector_3 *tmp=newc;
static int sttype=1;
int m;
if(one_particle){
m=(int)(Gas.n*(0.5+random1()));
if(m>=Gas.n)m=Gas.n-1;
if(sttype){
newc[0]=Gas.x[m];
for(j=0;j<3;j++){
Gas.x[m][j]+=dc[sttype]*random1();
}
}
else{
newc[0]=Gas.v[m];
for(j=0;j<3;j++){
Gas.x[m][j]+=dc[sttype]*random1();
}
}
}
else{
m=-1;
if(sttype)tmp=Gas.x;
else tmp=Gas.v;
for(i=0;i<Gas.n;i++){
for(j=0;j<3;j++){
newc[i][j]=tmp[i][j]+dc[sttype]*random1();
}
}
if(sttype)Gas.x=newc;
else Gas.v=newc;
}
int mult=1;
double Epot_old=Gas.Epotent;
if(momentum_depend){
Gas.interaction(m);
T=Gas.getT();
Epotent=Gas.Epotent;
mult=2;
}
else{
if(sttype){
Gas.interaction(m,1);
Epotent=Gas.Epotent;
}
else T=Gas.getT();
}
double E2;
if(!diff_temp)E2=1.5*T*Gas.n+Epotent;
else E2=1.5*Gas.Ti*Gas.ni+1.5*Gas.Te*Gas.ne+Epotent;
double Temp=1.;
if(diff_temp && m>=0){
if(m<Gas.ni)Temp=Gas.ini_Ti;
else Temp=Gas.ini_Te;
}
int ac =0;
if(E2<=E1)ac=1;
else{
if(exp((E1-E2)/Temp)>0.5+random1())ac=1;
}
(accept[sttype])+=ac;
nstp++;
if(nstp%nav==0){
aold[0]=accept[0];
aold[1]=accept[1];
accept[1]=accept[0]=0;
nstp=nav;
}
double ratio=mult*get_ratio(sttype);
if(auto_adjust){
double k;
double kmax=1.1,kmax_inv=1./kmax;
if((nstp/2)%5==0){
if(ratio<0.5*kmax_inv)k=kmax_inv;
else if(ratio>0.5*kmax)k=kmax;
else k=ratio/0.5;
dc[sttype]*=k;
if(sttype && dc[sttype]>Gas.L/2)dc[sttype]=Gas.L/2;
}
//printf("%d, %f, %f\n",(one_particle ? m : sttype),ratio,dc[sttype]);
}
if(ac){
if(!one_particle)newc=tmp;
E1=E2;
}
else{ // restoring previous
if(one_particle){
for(i=0;i<Gas.n;i++){
(*Gas.umatr)(i,m)=(*Gas.umatr)(i,i);
//printf("%i -> (%d, %d) [%f]\n",i,i,m,fucktmp[i]);
}
if(sttype){
Gas.x[m]=newc[0];
Gas.rcell(m);
}
else Gas.v[m]=newc[0];
//Gas.Epotent=Epot_old;
//Gas.interaction(m);
// printf("%f\n",Gas.Epotent-Epot_old);
}
else{
if(sttype)Gas.x=tmp;
else Gas.v=tmp;
}
Gas.Epotent=Epot_old;
//Gas.Epotent=E1-1.5*T*Gas.n;
}
if(momentum_depend)sttype=1-sttype;
/*
if(nstp%4==0){
//Gas.is_matr=0;
Gas.interaction(m,1); //to check!
//Gas.is_matr=1;
}*/
return ac;
}
inline double
MorphShape::currentRatio() const
{
return get_ratio() / 65535.0;
}
image::GnashImage*
Video::getVideoFrame()
{
// If this is a video from a NetStream_as object, retrieve a video
// frame from there.
if (_ns) {
std::unique_ptr<image::GnashImage> tmp = _ns->get_video();
if (tmp.get()) _lastDecodedVideoFrame = std::move(tmp);
}
// If this is a video from a VideoFrame tag, retrieve a video frame
// from there.
else if (_embeddedStream) {
// Don't try to do anything if there is no decoder. If it was
// never constructed (most likely), we'll return nothing,
// otherwise the last decoded frame.
if (!_decoder.get()) {
LOG_ONCE(log_error(_("No Video info in video definition")));
return _lastDecodedVideoFrame.get();
}
const std::uint16_t current_frame = get_ratio();
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug("Video instance %s need display video frame (ratio) %d",
getTarget(), current_frame);
#endif
// If current frame is the same then last decoded
// we don't need to decode more
if (_lastDecodedVideoFrameNum >= 0 &&
_lastDecodedVideoFrameNum == current_frame) {
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" current frame == _lastDecodedVideoFrameNum (%d)",
current_frame);
#endif
return _lastDecodedVideoFrame.get();
}
// TODO: find a better way than using -1 to show that no
// frames have been decoded yet.
assert(_lastDecodedVideoFrameNum >= -1);
std::uint16_t from_frame = _lastDecodedVideoFrameNum + 1;
// If current frame is smaller then last decoded frame
// we restart decoding from scratch
if (current_frame < static_cast<size_t>(_lastDecodedVideoFrameNum)) {
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" current frame (%d) < _lastDecodedVideoFrameNum (%d)",
current_frame, _lastDecodedVideoFrameNum);
#endif
from_frame = 0;
}
// Reset last decoded video frame number now, so it's correct
// on early return (ie: nothing more to decode)
_lastDecodedVideoFrameNum = current_frame;
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug(" decoding embedded frames from %d to %d "
"for Video object %s", from_frame,
current_frame, getTarget());
#endif
const size_t frames = m_def->visitSlice(
std::bind(std::mem_fn(&media::VideoDecoder::push),
_decoder.get(), std::placeholders::_1),
from_frame, current_frame);
if (!frames) return _lastDecodedVideoFrame.get();
_lastDecodedVideoFrame = _decoder->pop();
}
return _lastDecodedVideoFrame.get();
}
static void
create_top(GooCanvasItem *parent, gchar *path)
{
gchar **splitted_section;
gint i = 1;
GdkPixbuf *pixmap = NULL;
gdouble ratio;
GcomprisBoard *board;
gchar *path1, *path2;
GooCanvasItem *item;
GcomprisProperties *properties = gc_prop_get();
if (!path)
return;
splitted_section = g_strsplit (path, "/", 0);
path1 = g_strdup("");
/* splitted_section[0] is always "" */
i = 1;
while (splitted_section[i] != NULL)
{
path2 = g_strdup_printf("%s/%s", path1, splitted_section[i]);
g_free(path1);
path1 = path2;
if (strcmp(path1, properties->root_menu)<0) {
i++;
continue;
}
if (current_top_x == 0.0)
{
current_top_x = top_x;
current_top_y = top_y;
}
else
{
item = \
goo_canvas_svg_new (parent,
gc_skin_rsvg_get(),
"svg-id", "#MENUICON",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
SET_ITEM_LOCATION(item,
current_top_x,
current_top_y + top_arrow_size);
// goo_canvas_item_scale(item, ratio, ratio);
current_top_x += top_arrow_size + top_int_x;
}
board = gc_menu_section_get(path1);
pixmap = gc_pixmap_load(board->icon_name);
ratio = get_ratio( pixmap, icon_size_top);
item = goo_canvas_image_new (parent,
pixmap,
0, 0,
NULL);
goo_canvas_item_translate(item,
current_top_x,
current_top_y);
goo_canvas_item_scale(item, ratio, ratio);
#if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24
gdk_pixbuf_unref(pixmap);
#else
g_object_unref(pixmap);
#endif
current_top_x += top_int_x + icon_size_top;
g_object_set_data (G_OBJECT (item), "board", board);
g_signal_connect(item, "button_press_event",
(GCallback) item_event,
menuitems);
gc_item_focus_init(item, NULL);
i++;
}
g_strfreev(splitted_section);
g_free(path1);
}
