Compressor 4 breaks "Send to Compressor in FCP7"

Is there a way to set FCP7 up to send to Compressor 4, or at least link it back to 3.5? Compressor 4 IS a standalone app, after all...right, Apple? Current behavior in FCP7 after Compressor 4 install is that clicking Send to > Compressor results in an error tone.

Thanks Adam, please elaborate. What's working? Is FCP7 sending to C4? Is FCP7 sending to C3.5?
After moving apps back and forth a bit (FCPX and C4 are in Applications root, and FCP7 and C3.5 are in Applications/Final Cut Studio), FCP7 is now sending to C3.5 once again. This is fine with me, I just want my old software to integrate as it should again. Ideally, I'd like FCP7 to send to C4, but I'll take the old way.
Wish there was a trial version, I really don't like what I've seen in FCPX so far.
Also, thanks for that link J.K. ROFLing.

Similar Messages

Outlook add-in breaks sending emails

I'm loving my new iPhone 6. But my newly installed iCloud add-in for Outlook 2010 on my Windows 8.1 PC is causing some difficulties.
I can't send email, most of the time. This problem started when I installed iCloud, and stopped when I disabled the iCloud plug-in in Outlook. It's random; some emails I can send, but most, not. And, I'm not the first to have this problem and it's been going on for years, apparently. See http://community.spiceworks.com/topic/168384-outlook-2010-messages-not-sending-i n-outbox and http://aerobatgeek.blogspot.com/2013/08/outlook-when-i-send-email-message-it.htm l

Are your groups email enabled?
That was the problem. Thanks.

Compressor Quick Time error: 0

I was sending a sequence from FCP7 to Compressor, but kept getting Failed Quick Time error : 0. Went back to the time line in FCP7 tried to render the sequence but it failed too, after sometime I narrowed down the clip with the problem and found there were frames missing or shifting( not sure what they were doing, take a look at the screen shot you can see right at her shoulders a split screen effect) and a few frames latter the audio dropped out. Here are some screen shots of what it looked like. Because it would render the audio I just cut out the effected video and replaced it with some B- roll and it worked.

no any audio mp3

No connection between compressor 4 and final cut pro 7

If i send a file from FCP7 to compressor, I hear a beep, but compressor don t start-up.
I have make shure mark in / out is used, sequence sellected, still no reactie.
No i can only export to quicktime which make my move less nice. I have ask a expert to look into it but he cant find the problem. I hoop this message will help

Don't have FCP X... I have FCS 3 along with Compressor 4 and Motion 5.
'Just to be clear: You can send files from FCP7 to Compressor 3.5.'
Yes... just did a test sending a FCP 7 file to Compressor 3.5:

Compressor, FCP 7 and Snow = SLOW

Well, I am enjoying Final Cut 7, and I love the quickness of Leopard Snow. However, I am having major “beach ball” problems that I did not have when I used Leopard and Final Cut 6. I edit a few National daily and weekly TV programs, so I have a heavy workload. Now, when I am using the Compressor to create Blu-Ray files and web editions of the episodes, Final Cut Studio 7 is slowed down to a crawl. When I insert a clip or some music to my timeline and then try to play it, I get a beach ball for 15-20 seconds. After it finally plays, I click on the time line to begin an edit, and again - 15-20 seconds of a beach ball . . . you can see that this becomes annoying quickly and greatly disrupts my work flow.
Now, if I do not run compressor, then FCP7 works like a dream. I was wondering if anyone knows if it is possible to configure the features of Grand Central Station in Leopard Snow or to change hyper-threading in FCP? In my activity monitor, I see that when I have FCP open, I am still running 34 threads on something called CompressorJobController and FCP 7 runs about 46 threads. When I am using Compressor, the activity monitor reads about 40% CPU usage and 50 threads. I really need to multitask to get my work completed. Any suggestions?
Thanks,
d Starr

What Brian Gary is saying, "Was FCS already on you computer (OSX 6) and you just did an upgrade to FCS 3 from FCS 2."
What you really need to do (I think others will agree) is to do a clean install of you OS (not an archive and re-install). And then do all the updates to the OS, and repair permissions. Then do an install of FCS, with updates and repair permissions. With this proceeder everything should work. And if you have third party program install those too.
If you have an extra hard clone this over to the new hard drive as a bootable drive. And in three or six months clone this back over to your Hard Drive and you have a fresh copy of the OS and FCS to work from again. I do this every three months or so...it only takes an hour or so to clone over a fresh copy.
SuperDuper is free and will clone your hard drive.
http://www.shirt-pocket.com/
Jerry Hofmann a few weeks back posted an excellent thread on how to (step by step) install FCS. I don't have the URL. hopefully someone can post that URL.

Sending from fcp7

Trying to send from Fcp 7 but the clips will not display, I'm just seeing black frames.
I know that I can not round trip but it would be nice to send the clips from FCP7 to Motion 5 as the software has over written Motion 4.
This is the same on my laptop.
Any help would be appreciated.

Cheers Dwas - It's a bug alright, part of that problem might be that the codec I'm (trying) to work in is not present in the Pixel Aspect Ratio drop down. DVC Pro HD - Only one of the most established codecs out there.
Now Motion does not round trip and update FCP - "Media Missing in Motion File" - Sheesh!
Its going back

Sending a sequence to a multitrack project?

Hello.
I have been using final cut studio 3 for some time now. However I have not used soundtrack pro and Final cut pro 7 in a round trip since using FCE 3.5 (I upgraded). When I went to send my sequence in FCP7 to soundtrack pro 3, I realized that if I wanted to get my video and audio to the soundtrack pro 3 multitrack project I would have to render it first? This seems odd to me, because I do not remember having to render anything to get my sequence to Soundtrack when using FCE 3.5.
Is it just me, or is there a setting I am missing or...?
Thanks so much for any responses, advice, or help.

Alright, I believe I get it now, and I also think I know why it is taking longer than it normally would.
On this project I am using an external HD with a *firewire 400* cable. I am guessing that a render is normally needed to send your sequence to FCP, but it usually takes under 5 minutes? However I am an exception because I am using an external HD which is probably slower than an internal drive. Do you think this may be why it is taking so long? I would love to get some information on how long it usually takes someone else to get there footage from an FCP sequence to a STP timeline...
Thanks for any help and information and most of all responses!

CC different in Color 1.5 vs FCP7

When I send a clip from FCP7 to Color 1.5, the color correction on the clip is totally off. They're not even close. When I make a correct the clip in COlor and send it back to FCP it doesn't look anything like what the clip looked like in Color.
Is there any way I can get FCP and Color to match up so how it looks on one is how it will look on the other?

On what monitor fed by what card are you judging this?
x

Mail does not send when several accounts active

Hi,
Finally I got Tiger, as I had to have Google Earth for Mac (another story anyway) that only runs on Tiger.
Of course several things stopped working like PHP local, Postfix, and so on. These were remedied (but the new .conf files had a strange date, well, again, another story).
Now I am a bit stuck on the following problem :
I cannot anymore sent mail when I have several mail accounts configured. (I can when there is only one).
At first I thought it was SpamSieve, but it seems not, as I have removed it (it does not run and the plugin is gone). Then I rechecked my Postfix cf files, but they're ok and I send mail from localhost when using Thunderbird where several accounts are set up.
It does not matter whether I use localhost or any of the smtp servers I can use, and when beginning a new message, I cannot use the popup which lets me choose an originating account. Neither can I write anything in the message content box.
Of course I checked everything in the Preferences dialogs.
Well, well. Any hints ?

It turns out I cannot eliminate Spamsieve as a possible culprit.
I have erased all accounts (rm /Users/myUID/Library/Preferences/com.apple.mail.plist) and SpamSieve plugin (rm -r /Users/myUID/Library/Mail/Bundles/Spamsieve*)
Then I reconstructed 5 accounts using the wizard (File->Add account) rather than reimporting from a saved plist or building from the prefs panel (seems that does not work and using the wizard at least to name the accounts is required).
Then I test the send button and it works on all accounts.
Then I reinstall SpamSieve which breaks sending mail on all accounts.
I am back with operational accounts and no SpamSieve.
I cannot explain this, I just observe.
Any idea ? Anyone made similar observations ?
I'd like to put SpamSieve back on, it is efficient.
Note : perms are fixed, caches lean, periodic tasks have run.

FCPX & Motion - trips back and forth?

I'm working in FCPX. I have a lot of stills I want to do 'smooth' moves on. Maybe I want to add things like arrows and circles.
I'm remembering, I think, that I could send a clip or sequence to Motion (from FCP7), create some effect, and then somehow send it back to FCP7. And whenever I wanted to change something I could open that clip or sequence on the FCP7 timeline ... as a Motion project ... make changes ... and see the changes back in FCP7.
Can I do this back and forth with FCPX and Motion?
If I know it can be done, I'll go read the manual like a good boy.
All ears,
Ben

There is no Send to Motion "interoperability" between FCP X and Motion.
You can open an existing effect in Motion, customize it and publish it in FCP X.
You can create a new Motion project and save it as a FCP X template…and you can export as a clip and import into FCP.
You can also send from Motion to Compressor.
Russ

Final Cut Pro 7 - Share - Blu-ray - ERROR

Fresh install of OS and FCS.
Ran a quick test to make sure this would work:
File - Share - Blu-ray
Burned to disc then and there, and it was successful on an eleven second portion of the clip with an in and out point on the timeline.
The result was a beautiful Blu-ray quality 11 second clip recorded onto a DVD-RW, and it played back fine on a PS3. (AVCHD)
Extended the in and out point on the same clip in the same timeline in order to do a 20 minute version of the same thing. 2.5 hours later, it ejected my blank DVD I had already inserted, and asked me for a Dual Layer. I put one in, and it ejected that one, too. I kept trying different blank media and eventually it tells me:
There was an error burning your disc.
Operation could not be completed. (DSPPublishing error -1006.)
Hit "Try Again" and after a few minutes it says again,
Please insert the dual layer media to burn the
disc "name-Blu-ray".
Seems to be an endless loop. It's reporting the final size will be only 1.6GB, so I don't know why it's asking for a DL disc. I spoke to Apple today and they told me this feature was not compatible with DL media at all anyway.
If anyone can help...

Update and WORKAROUND:
I have been experimenting and here's what I've learned:
I'm thinking the new "Create Disc" is the cause. The encoded files generated by FCP7 and Compressor 3.5 are fine. One whacky theory of mine is the programmers made a typo where if you encode a file like this over 1GB the burn fails. I don't know, I'm just saying, it's probably something simple like that.
I spoke to Apple, too. First I had someone tell me it failed because I tried a clip larger than 25 minutes, so I tried 20, and it failed, too, the same way. (I also previously encoded a 3.5 minute clip and it was excellent.) This person also told me Dual Layer was not supported at all. He was completely wrong.
I called back and this time it was a guy named Bob. If you ever call and speak to him, just do him a favor and hang up on yourself and save him the trouble. He won't let you speak to tell him the problem, and even if you are calm and try he's the type to tell you to "calm down, sir." He literally told me "there is no Blu-ray feature" in the new FCS. I merely asked if he had seen the new Compressor and he told me he knew everything, and asked me to have a nice day before hanging up on me. I know he's an anomaly at Apple.
I called back and spoke to someone else, and they gave me this link:
http://www.kenstone.net/fcphomepage/burn_br_mac_superdrivestone.html
After I read it I thought, "that's exactly what I did!" But it doesn't work and that's why I'm calling. (Even that article reports odd bugs.)
I called again, just because I know this needs to be fixed. Finally I spoke to someone who passed it along, and they are going to look into it. Get this - he checked the FCS manuals and discovered that it is indeed a feature that should work. Maybe they will name the patch after me.
So I also found a solution in the meantime. I've read hints here and there, but this is what has just worked for me and I wanted to verify before posting and sharing it:
Do the encode with Share in FCP7 or Compressor 3.5. Screw what anyone tells you about "maximum size" or 25 minutes or even what Compressor tells you regarding the number of minutes of footage the disc will hold. It's wrong. And, it will support Dual Layer discs. Go by the file size in the summary, and that's it. (I'm talking about AVCHD here, nothing else. It's the Blu-ray setting and you can change it to AVCHD to burn on a DVD-5 or DVD-9, in the manual it says "red laser media.")
If you want to burn to a DVD-5 stay under around 4GB for your video, but you can experiment with the details. You have a minimum of 5Mbps and a max of 17Mbps in a VBR. Seriously, use whatever you want, as long as it will fit on the media. This is also about H.264, not MPEG-2.
Export to files, and make sure you do NOT burn from FCP7 or Compressor 3.5, because that will cause the problem. It will even completely ruin your blank media, but you may think it's still blank because they will be detected as blank media, even in other systems. But they cannot be used, ever again, merely for trying with "Create Disc."
In the end you will have two files:
movie.264
movie.ac3
If you have two files with those extensions and they don't have the exact same file name, rename them, but keep the extensions.
I used Toast 9. Blu-ray Video option. Add - locate the two clips with the same names with .264 and .ac3. They go in, deal with the ugly menus, but make sure you do this:
In the Encoding settings:
Custom
MPEG-4 AVC
Average Bit Rate: to whatever you used in Compressor or FCP7.
Maximum Bit Rate: may as well set it to 17 (we're trying not to re-encode the files)
Motion Est - Best - check the Half-PEL box
Reencoding - Never (that might make the above a waste, but it only took a couple seconds so stop complaining.) Set the rest to the same settings in the same way.
Choose your blank media and burn it, and few seconds later you can slap it into your PS3 and watch the creamy smooth silky beautiful encode right there.
I read somewhere it retains the FCP color settings and that's probably why doing it this way is a thousand times better than using Toast to encode (which skips really bad in my tests). I've also tried Encore and it was ugly and looked like it skipped frames.
Anyway, "Create Disc" may not work right now, but the encodes are amazing. I hope this helps others from banging their heads against the wall, and from calling Bob. I just burned a 2 hour movie onto a DVD and played it back on a PS3!
For further reading, here are some interesting links I found:
http://www.shedworx.com/revolverhdmac-faq
- Talks about Apple's support of H.264 "High Profile" - they type needed for AVCHD and Blu-ray movies.
http://manuals.playstation.net/document/en/ps3/current/video/filetypes.html
- PS3 supported file types.
http://blogs.adobe.com/davtechtable/2008/03/updated_march_2008_workingwi.html
- Interesting times of various encodes on different systems. For Encore, but comparable to Compressor for time differences.
If this has helped you, Apple owes me some money, and you're welcome.

Has anyone experienced improved workflow?

Putting aside for the moment the really egregious shortcomings (no EDL, no backwards compatibility, etc.) has any seasoned FCP user experienced an improved editing workflow with FCPX?
What I mean by an improved editing workflow, for the purpose of this discussion, is everything from prepping clips up until final export.
I'm basically a one-man shop and I'm reading that FCPX has been designed for people like me. But after days playing with it, and taking Larry Jordon's tutorial, I'm still mystified as to where the advantages are.
Sure, there are a number of workarounds for procedures that formerly were very easy and fast for me in FCP7. But, despite the talk of the sleek interface, I find the editing experience actually more cumbersome than it was before, especially with regard to prepping the hours of interview footage I often need to cut into short films.
I would be encouraged and may possibly even hang in there with FCPX if any of you with lots of experience cutting with FCP7 could confirm that the editing experience itself is better.
And I would appreciate if those of you who are absolutely new to FCP or new to editing would hang back on this discussion.
Like many other professionals, I'm now looking seriously into Avid and Premiere, but I'd prefer to stay with FCP if I could see the advantages to my way of working.
Thanks.

Well when it is not crashing... it is nice to be able to move on with other work while it is rendering and processing an export in Compressor. FCP7 used to act funny if you continued editing while you had unrendered jobs out to compressor.

How to trigger xml publisher API (ex:Delivering Documents via e-Mail)?

Dear All:
How to use xml publisher API ?
In user's guide always talk API's code.(ex:Delivering Documents via e-Mail
// create delivery manager instance
DeliveryManager dm = new DeliveryManager();
// create a delivery request
DeliveryRequest req =
dm.createRequest(DeliveryManager.TYPE_SMTP_EMAIL);
// set email subject
req.addProperty(DeliveryPropertyDefinitions.SMTP_SUBJECT, "Invoice");
// set SMTP server host
req.addProperty(
DeliveryPropertyDefinitions.SMTP_HOST, "mysmtphost");
// set the sender email address
req.addProperty(DeliveryPropertyDefinitions.SMTP_FROM,
"[email protected]");
// set the destination email address
req.addProperty(
DeliveryPropertyDefinitions.SMTP_TO_RECIPIENTS,
"[email protected], [email protected]" );
// set the content type of the email body
req.addProperty(DeliveryPropertyDefinitions.SMTP_CONTENT_TYPE,
"text/html");
// set the document file name appeared in the email
req.addProperty(DeliveryPropertyDefinitions.SMTP_CONTENT_FILENAME,
"body.html");
// set the document to deliver
req.setDocument("/document/invoice.html");
// submit the request
req.submit();
// close the request
req.close(); )
Not say how to use this code to account effect !!
Having anybody to use API before?
Please tell me how to use that,thanks!!
BY Emily_ye

Hi Emily
I had the same question. After much research and a lot of deduction I produced the following:
import oracle.apps.fnd.cp.request.*;
import java.io.*;
import java.sql.*;
import java.util.Vector;
import oracle.apps.fnd.util.*;
import oracle.apps.xdo.XDOException;
import oracle.apps.xdo.common.pdf.util.PDFDocMerger;
import oracle.apps.xdo.delivery.DeliveryException;
import oracle.apps.xdo.delivery.DeliveryManager;
import oracle.apps.xdo.delivery.DeliveryPropertyDefinitions;
import oracle.apps.xdo.delivery.DeliveryRequest;
import oracle.jdbc.driver.OracleCallableStatement;
public class RunTravProgram implements JavaConcurrentProgram {
CpContext mCtx; // global reference to concurrent program context
LogFile logFile; // global reference to context logfile
OutFile outFile; // global reference to context outfile
Connection mConn = null;
ReqCompletion lRC;
//File Separator
private String mFileSeparator;
// globals for template
String XDOAppShortName = "";
String XDOtemplateCode = "";
// hard-wired constants for template addition
final String XDOLanguage = "en";
final String XDOTerritory = "US";
final String XDOFinal_format = "PDF";
final String XDOtemplateType = "TEMPLATE_SOURCE";
String PDFFile = "";
String outFilePath = "";
String progShortName = "";
String progDesc = "";
Integer iRequestID = 0;
String sWatermark = ""; // watermark text
String emailAddress = ""; // Not Implemented
String emailServer = "";
public static final String M_SUCCESS = "SUCCESS";
public static final String M_ERROR = "ERROR";
public static final String M_WARNING = "WARNING";
* Create a Java FND ConcurrentRequest objec to call fnd_request.submit_request
* The first three parameters are:
* Application Short Name -- Application Short name (ie. WAHC)
* Current Program Short Name -- Concurrent Program being called
* Current Program Description -- description for above
* These should be the first three parameters passed by the concurrent
* program in this order. The next two are constants set to null
* These are followed by the parameters passed by the first concurrent
* program that are being passed to the next concurrent program.
* I am limiting the parameter list to ten for now.
// Dynamic PLSQL statement used to get a concurrent request completion status
// This is necessary because the java class does not provide this method :-(
String mGetCompleteStatus =
"DECLARE R_VAL BOOLEAN; " + "b_phase VARCHAR2 (80) := NULL; " +
"b_status VARCHAR2 (80) := NULL; " +
"b_dev_phase VARCHAR2 (80) := NULL; " +
"b_dev_status VARCHAR2 (80) := NULL; " +
"b_message VARCHAR2 (240) := NULL; " + "BEGIN " +
"r_val := fnd_concurrent.wait_for_request (:1,5,1000," +
"b_phase,b_status,b_dev_phase,b_dev_status,b_message); " +
":2 := b_phase; " + ":3 := b_status; " + ":4 := b_message; " + "end;";
public RunTravProgram() {
// no constructor necessary for now
* Concurrent Processing provides an interface 'JavaConcurrentProgram' with abstract method
* runProgram() which passes the concurrent processing context 'CpContext'. The concurrent
* program developer will implement all of their business logic for a concurrent program in
* runProgram(). The main() method, implemented by AOL, will call runProgram() after
* performing all of the required initialization for the concurrent program, including
* establishing a database connection, initializing the required contexts, and setting up
* the log and output files. CpContext will have the request specific log and output
* file input methods
public void runProgram(CpContext pCpContext) {
mCtx = pCpContext;
OracleCallableStatement lStmt = null;
boolean bCompletion = true;
String sPhase = "";
String sStatus = "";
String sMessage = "";
//get handle on request completion object for reporting status
lRC = pCpContext.getReqCompletion();
// assign logfile
logFile = pCpContext.getLogFile();
// assign outfile
outFile = pCpContext.getOutFile();
// assign fileseparator
mFileSeparator = getFileSeparator();
// get the JDBC connection object
mConn = pCpContext.getJDBCConnection();
outFilePath =
((new File(outFile.getFileName())).getParent() == null ? "" :
(new File(outFile.getFileName())).getParent() +
mFileSeparator);
logFile.writeln("OutFile File Path: -> " + outFilePath, 0);
// get parameter list object from CpContext
// these come from the concurrent program
ParameterList lPara = pCpContext.getParameterList();
// create a temporary array and retrieve the parameters created by
// the program. Currently limiting the number of parameters to 10 for now
String pvals[] = new String[10];
int pcount = 0;
while (lPara.hasMoreElements()) {
NameValueType aNVT = lPara.nextParameter();
pvals[pcount] = aNVT.getValue();
pcount++;
if (pcount > 9)
break;
// send parameter values to the log file
logFile.writeln("Arg 1: APPL_SHORT_NAME -> " + pvals[0], 0);
logFile.writeln("Arg 2: CURR_PROG_SHORT_NAME -> " + pvals[1], 0);
logFile.writeln("Arg 3: CURR_PROG_DESCRIPTION -> " + pvals[2], 0);
logFile.writeln("Arg 4: TEMPLATE_CODE -> " + pvals[3], 0);
logFile.writeln("Arg 5: P_PLANT_CODE -> " + pvals[4], 0);
logFile.writeln("Arg 6: P_BATCH_NO -> " + pvals[5], 0);
logFile.writeln("Arg 7: P_SHOW_PROMISE -> " + pvals[6], 0);
logFile.writeln("Arg 8: P_WATERMARK -> " + pvals[7], 0);
XDOtemplateCode = pvals[3]; // store the template name globally
progShortName = pvals[1]; // store the program short name globally
XDOAppShortName = pvals[0]; // store the application short name
sWatermark = pvals[7]; // store the watermark globally
progDesc = pvals[2];
try {
// create a concurrent request object
ConcurrentRequest cr = new ConcurrentRequest(mConn);
// use the parameters to call fnd_request.submit_request
cr.addLayout(XDOAppShortName, XDOtemplateCode, XDOLanguage,
XDOTerritory, XDOFinal_format);
Vector param = new Vector();
param.add(pvals[4]); // plant code
param.add(pvals[5]); // batch ID
param.add(pvals[6]); // Show SO info flag
iRequestID =
cr.submitRequest(XDOAppShortName, progShortName, progDesc,
null, false, param);
mConn.commit();
// send the request ID to the log file
logFile.writeln("-- Request ID: ->" + Integer.toString(iRequestID),
0);
// call fnd_concurrent.wait_for_request to wait until the request
// has ended - use this to check the request status before proceeding
lStmt =
(OracleCallableStatement)mConn.prepareCall(mGetCompleteStatus);
lStmt.setInt(1, iRequestID);
lStmt.registerOutParameter(2, java.sql.Types.VARCHAR, 0, 255);
lStmt.registerOutParameter(3, java.sql.Types.VARCHAR, 0, 255);
lStmt.registerOutParameter(4, java.sql.Types.VARCHAR, 0, 255);
lStmt.execute();
// get the results of the completion
sPhase = lStmt.getString(2);
sStatus = lStmt.getString(3);
sMessage = lStmt.getString(4);
lStmt.close();
// send the results of the request processing to the log file
logFile.writeln("-- Phase: -> " + sPhase, 0);
logFile.writeln("-- Status: -> " + sStatus, 0);
logFile.writeln("-- Message: -> " + sMessage, 0);
// test here to make sure it completed correctly
if (sPhase.equals("Completed") && sStatus.equals("Normal")) {
// construct the PDF file name generated by the called request
PDFFile = progShortName + "_" + iRequestID + "_1.pdf";
// add a watermark to the generated PDF
// create an output stream for the existing PDF
// and set ouput to append
OutputStream pdfout =
new FileOutputStream(outFilePath + PDFFile, true);
// create an inputstream array (required by calling method)
InputStream pdfin[] = new InputStream[1];
pdfin[0] = new FileInputStream(outFilePath + PDFFile);
// add the watermark passed as a parameter
bCompletion = addWatermark(pdfin, pdfout);
// assign the modified file to the context out
// this will print using this request
if (bCompletion)
outFile.setOutFile(outFilePath + PDFFile);
// release the connection object
// and set the completion status for the request
if (bCompletion) {
pCpContext.getReqCompletion().setCompletion(ReqCompletion.NORMAL,
} else {
lRC.setCompletion(ReqCompletion.WARNING, M_WARNING);
pCpContext.releaseJDBCConnection();
} catch (SQLException s) {
logFile.writeln("SQL Error: Exception thrown w/ error message: " +
s.getMessage(), 0);
lRC.setCompletion(ReqCompletion.WARNING, M_WARNING);
pCpContext.releaseJDBCConnection();
} catch (IOException ioe) {
logFile.writeln("IO Error: Exception thrown w/ error message: " +
ioe.getMessage(), 0);
lRC.setCompletion(ReqCompletion.WARNING, M_WARNING);
pCpContext.releaseJDBCConnection();
} catch (Exception e) {
logFile.writeln("General Exception: " + e.getMessage(), 0);
lRC.setCompletion(ReqCompletion.WARNING, M_WARNING);
pCpContext.releaseJDBCConnection();
} finally {
try {
if (lStmt != null)
lStmt.close();
pCpContext.releaseJDBCConnection();
} catch (SQLException e) {
logFile.writeln(e.getMessage(), 0);
lRC.setCompletion(ReqCompletion.WARNING, M_WARNING);
* addWatermark()
* @param pdfin
* @param pdfout
* @return boolean
* This method will work for an existing document or a newly generated
* one. Set the outputstream append flag to false for a new document
* and true for an existing one.
* NOTE: PDFDocMerger requires an inputstream array even if it only
* contains one document.
private boolean addWatermark(InputStream[] pdfin, OutputStream pdfout) {
if (!sWatermark.equals("")) {
try {
PDFDocMerger docMerger = new PDFDocMerger(pdfin, pdfout);
//docMerger.setTextDefaultWatermark(sWatermark);
docMerger.setTextWatermark(sWatermark, 80f, 50f);
docMerger.setTextWatermarkAngle(25);
docMerger.setTextWatermarkColor(1.0f, .50f, .50f);
docMerger.setTextWatermarkFont("Garamond", 100);
docMerger.process();
docMerger = null;
return true;
} catch (XDOException e) {
logFile.writeln("Watermark process Failed: " + e.getMessage(),
0);
return false;
return true;
* Returns the file separator
private String getFileSeparator() {
return (System.getProperty("file.separator"));
* EBSEmailDelivery
* @return
* Just for testing right now.
private boolean EBSEmailDelivery() {
if (!emailAddress.equals("")) {
try {
// create delivery manager instance
DeliveryManager delMgr = new DeliveryManager();
// create a delivery request
DeliveryRequest delReq =
delMgr.createRequest(DeliveryManager.TYPE_SMTP_EMAIL);
// set email subject
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_SUBJECT,
"EBS Report:" + progDesc +
" for request: " + iRequestID);
// set SMTP server host
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_HOST,
emailServer); // need to supply the email smtp server
// set the sender email address
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_FROM,
emailAddress);
// set the destination email address
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_TO_RECIPIENTS,
emailAddress);
// set the content type of the email body
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_CONTENT_TYPE,
"application/pdf");
// set the document file name appeared in the email
delReq.addProperty(DeliveryPropertyDefinitions.SMTP_CONTENT_FILENAME,
PDFFile);
// set the document to deliver
delReq.setDocument(outFilePath + PDFFile);
// submit the request
delReq.submit();
// close the request
delReq.close();
return true;
} catch (DeliveryException de) {
logFile.writeln("email process Failed: " + de.getMessage(), 0);
return false;
return true;
This is the class for a JCP I created to perform the following:
1) Launch an existing Concurrent Program that produces PDF output
2) Grab the PDF and apply a watermark based on user input or conditions
3) associate the modified PDF to CP output for PASTA printing
It isn't elegant but it is fairly simple. I added the email capability and tested it but am not implementing it at the present time.
there is a fair amount of information out there that explains how to create a JCP councurrent program but very little that demonstrates the class needed.
I hope this helps

Axi Master DDR (MIG) tester

Hi guys I'm trying to create a DDR stresser on my project, so I created an Vivado HLS IP core that has one axi-master interface and one axi-lite-slave(for parameters) the code is bellow
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
unsigned int memDDR3Tester(unsigned int start, unsigned int size, unsigned int mode, unsigned int data, volatile unsigned int *memPtr, unsigned int *expectedVal, unsigned int *failedAddr, unsigned int *numErrors)
#pragma HLS INTERFACE s_axilite port=numErrors bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=failedAddr bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=expectedVal bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=start bundle=CRTL_BUS
#pragma HLS INTERFACE m_axi depth=512 port=memPtr
#pragma HLS INTERFACE s_axilite port=data bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=mode bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=size bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=return bundle=CRTL_BUS
unsigned int result = 0;
unsigned int idxMemAddr = 0;
unsigned int errorCounter = 0;
*numErrors = 0;
*expectedVal = 0;
*failedAddr = 0;
switch (mode)
* Send 0xAA55 (16b1010101001010101) or 0x55AA if the address is odd/even
* write then read and stop on the first error
case 0:
// Write
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
unsigned char isOdd = (idxMemAddr % 2);
unsigned int value = (isOdd)?0x55AA:0xAA55;
memPtr[idxMemAddr] = value;
// Read
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
unsigned char isOdd = (idxMemAddr % 2);
unsigned int value = (isOdd)?0x55AA:0xAA55;
if (memPtr[idxMemAddr] != value)
result = 1;
*expectedVal = value;
*failedAddr = idxMemAddr;
// Bail out on the first error
*numErrors = 1;
break;
break;
* Send an incremental value but don't stop if some error occured and return the number of errors
case 1:
// Write
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
unsigned int value = idxMemAddr;
memPtr[idxMemAddr] = value;
// Read
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
unsigned int value = idxMemAddr;
if (memPtr[idxMemAddr] != value)
result = 1;
errorCounter++;
*numErrors = errorCounter;
break;
* Send just a value and read it back
case 2:
memPtr[start] = data;
if (memPtr[start] != data)
result = 1;
*expectedVal = data;
*failedAddr = start;
break;
* Send on mode burst (memset) the value 0xAA55 (16b1010101001010101)
case 3:
//memset((unsigned int*)memPtr,(int)0xAA55,(size_t)(sizeof(unsigned int)*size));
// Write
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
memPtr[idxMemAddr] = 0xAA55;
// Read
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
if (memPtr[idxMemAddr] != 0xAA55)
result = 1;
errorCounter++;
*numErrors = errorCounter;
break;
return result;
#include <stdio.h>
unsigned int memDDR3Tester(unsigned start, unsigned int size, unsigned int mode, unsigned int data, volatile unsigned int memPtr[512000000], unsigned int *expectedVal, unsigned int *failedAddr, unsigned int *numErrors);
int main()
unsigned int memPtr[10];
unsigned int expectedVal;
unsigned int failedAddr;
unsigned int numErrors;
unsigned int result;
printf("Test mode 0\n");
result = memDDR3Tester(0,10,0,0,memPtr,&expectedVal,&failedAddr,&numErrors);
printf("Result mode 0: %d Expected: %d failedAddr:%d numErrors:%d\n",result,expectedVal,failedAddr,numErrors);
for (int idx = 0; idx < 10; idx++)
printf("DDR3[%d]=%x\n",idx,memPtr[idx]);
return 0;
The first problem is that I can simulate the on C/C++ but not co-simulate I get those errors:
Determining compilation order of HDL files.
INFO: [VRFC 10-2263] Analyzing Verilog file "C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_master_memPtr.v" into library xil_defaultlib
INFO: [VRFC 10-311] analyzing module AESL_axi_master_memPtr
INFO: [VRFC 10-2263] Analyzing Verilog file "C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v" into library xil_defaultlib
INFO: [VRFC 10-311] analyzing module AESL_axi_slave_CRTL_BUS
ERROR: [VRFC 10-46] write_start_count is already declared [C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v:201]
ERROR: [VRFC 10-46] write_start_run_flag is already declared [C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v:202]
ERROR: [VRFC 10-46] write_start is already declared [C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v:738]
ERROR: [VRFC 10-552] declarations not allowed in unnamed block [C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v:738]
ERROR: [VRFC 10-1040] module AESL_axi_slave_CRTL_BUS ignored due to previous errors [C:/Users/laraujo/memDDR3Tester/solution1/sim/verilog/AESL_axi_slave_CRTL_BUS.v:11]
ERROR: Please check the snapshot name which is created during 'xelab',the current snapshot name "xsim.dir/memDDR3Tester/xsimk.exe" does not exist
These are the results for C/C++ simulation:
Compiling ../../../test_core.cpp in debug mode
Generating csim.exe
Test mode 0
Result mode 0: 0 Expected: 0 failedAddr:0 numErrors:0
DDR3[0]=aa55
DDR3[1]=55aa
DDR3[2]=aa55
DDR3[3]=55aa
DDR3[4]=aa55
DDR3[5]=55aa
DDR3[6]=aa55
DDR3[7]=55aa
DDR3[8]=aa55
DDR3[9]=55aa
@I [SIM-1] CSim done with 0 errors.
Anyway after exporting to vivado and connecting the mig and the microblaze through an Axi Interconnect, I got this: (Artix 7 Avnet demoboard)
The addresses:
On Xilinx SDK my code to initialize the core and test it this:
#include <stdio.h>
#include <xmemddr3tester.h>
#include <xparameters.h>
#include <xil_cache.h>
XMemddr3tester doMemDDR3Test;
XMemddr3tester_Config *doMemDDR3Test_cfg;
#define SIZE_ARRAY 10
unsigned int *topMemDDR = (unsigned int *)0x80000000;
void initDDRTester()
int status = 0;
doMemDDR3Test_cfg = XMemddr3tester_LookupConfig(XPAR_MEMDDR3TESTER_0_DEVICE_ID);
if (doMemDDR3Test_cfg)
status = XMemddr3tester_CfgInitialize(&doMemDDR3Test,doMemDDR3Test_cfg);
if (status != XST_SUCCESS)
printf("Failed to inititalize\n");
int main()
int idx = 0;
unsigned int error;
initDDRTester();
for (idx = 0; idx < SIZE_ARRAY; idx++)
topMemDDR[idx] = idx*2;
printf("DDR3 tester console\n");
Xil_DCacheFlushRange((unsigned int)topMemDDR,sizeof(unsigned int)*SIZE_ARRAY);
XMemddr3tester_Set_mode(&doMemDDR3Test,0);
XMemddr3tester_Set_data(&doMemDDR3Test,0);
XMemddr3tester_Set_start(&doMemDDR3Test,0x80000000);
XMemddr3tester_Set_size(&doMemDDR3Test,(unsigned int)SIZE_ARRAY);
XMemddr3tester_Start(&doMemDDR3Test);
while (!XMemddr3tester_IsDone(&doMemDDR3Test));
error = XMemddr3tester_Get_return(&doMemDDR3Test);
printf("Test done %d\n",error);
Xil_DCacheInvalidateRange((unsigned int)topMemDDR,sizeof(unsigned int)*SIZE_ARRAY);
for (idx = 0; idx < SIZE_ARRAY; idx++)
printf("DDR3[%d]=%x\n",idx,topMemDDR[idx]);
return 0;
By some reason it seems that is the data is not been sent to the MIG (I though initialiy that could be a problem with the Cache but it seems that is not the case, anyway I disabled the cache on the microblaze)
So to resume the questions:
1) Someone knows what could be wrong on the Co-Simulation
2) The address autogenerated for the mig is also updated somehow on the HLS core? (I tried to manually set the pointer address on Vivado HLS but it didn't synthesised)
3) Do you guys seem something wrong on this design?
4) Can I use the ILA to see the DDR3 interface (Or should I use the "Mark Debug option?)
Thanks.

Hi thanks, I've changed the parameter name and the previous error on the simulation disappeared, but now I have a comsim.pc.exe crash during the C post checkign phase.
INFO: [Common 17-206] Exiting xsim at Tue Jul 14 10:48:04 2015...
@I [SIM-316] Starting C post checking ...
@E [SIM-379] Detected segmentation violation, please check C tb.
@E [SIM-362] Aborting co-simulation: C TB post check failed.
@E [SIM-4] *** C/RTL co-simulation finished: FAIL ***
So what I did was to simplify the IP core more to only send 0xaa55 or 0x55aa on the master interface:
core.cpp (Used to generate the IP core)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// 1Gb limit
#define MAX_MEM_SIZE 200000
unsigned int memDDR3Tester(unsigned int size, volatile unsigned int *memPtr, unsigned int *expectedVal, unsigned int *failedAddr, unsigned int *numErrors)
#pragma HLS INTERFACE s_axilite port=numErrors bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=failedAddr bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=expectedVal bundle=CRTL_BUS
#pragma HLS INTERFACE m_axi depth=512 port=memPtr
#pragma HLS INTERFACE s_axilite port=size bundle=CRTL_BUS
#pragma HLS INTERFACE s_axilite port=return bundle=CRTL_BUS
unsigned int result = 0;
unsigned int idxMemAddr = 0;
unsigned int errorCounter = 0;
*numErrors = 0;
*expectedVal = 0;
*failedAddr = 0;
* Send 0xAA55 (16b1010101001010101) or 0x55AA if the address is odd/even
* write then read and stop on the first error
// Write
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
#pragma HLS LOOP_TRIPCOUNT min=256000000 max=256000000 avg=256000000
unsigned char isOdd = (idxMemAddr % 2);
unsigned int value = (isOdd)?0x55AA:0xAA55;
memPtr[idxMemAddr] = value;
/*if (idxMemAddr > size)
break;*/
// Read
for (idxMemAddr = 0; idxMemAddr < size; idxMemAddr++)
#pragma HLS LOOP_TRIPCOUNT min=256000000 max=256000000 avg=256000000
unsigned char isOdd = (idxMemAddr % 2);
unsigned int value = (isOdd)?0x55AA:0xAA55;
if (memPtr[idxMemAddr] != value)
result = 1;
*expectedVal = value;
*failedAddr = idxMemAddr;
// Bail out on the first error
*numErrors = 1;
break;
/*if (idxMemAddr > size)
break;*/
return result;
test core
#include <stdio.h>
unsigned int memDDR3Tester(unsigned int size, volatile unsigned int *memPtr, unsigned int *expectedVal, unsigned int *failedAddr, unsigned int *numErrors);
unsigned int memPtr[20];
int main()
unsigned int expectedVal;
unsigned int failedAddr;
unsigned int numErrors;
unsigned int result;
printf("Test mode 0\n");
result = memDDR3Tester(10,memPtr,&expectedVal,&failedAddr,&numErrors);
printf("Result mode 0: %d Expected: %d failedAddr:%d numErrors:%d\n",result,expectedVal,failedAddr,numErrors);
for (int idx = 0; idx < 10; idx++)
printf("DDR3[%d]=%x\n",idx,memPtr[idx]);
return 0;
But again the simulation on C/C++ works but I have some trouble on the co-simulation part.
I also tried to change the for loop to hava a fixed constant iteration and on the midle of its code break if the condition size is met:
// Write
for (idxMemAddr = 0; idxMemAddr < MAX_MEM_SIZE; idxMemAddr++)
unsigned char isOdd = (idxMemAddr % 2);
unsigned int value = (isOdd)?0x55AA:0xAA55;
memPtr[idxMemAddr] = value;
if (idxMemAddr > size)
break;
The problem is that if I try to synthesize this I got this error:
Stack dump:
0. Running pass 'Generate interface primitives' on module 'C:/Users/laraujo/ddrStresserVIV_2015/solution1/.autopilot/db/a.o.2.bc'.
0x000007FEC7CBE4E0 (0x0000000000000003 0x00000000059368D0 0x00000000059368D8 0x0000000002924BF0), ?save_object_ptr@?$pointer_oserializer@Vxml_oarchive@archive@boost@@VTransition@DBFsm@fsmd@@@detail@archive@boost@@EEBAXAEAVbasic_oarchive@234@PEBX@Z() + 0x331210 bytes(s)
0x000007FEC773080A (0x0000000000000004 0x0000000005553D20 0x0000000006A51FB0 0x00000000001D8200), ?main@Syn@@YAHHPEAPEAD@Z() + 0x5A1C3A bytes(s)
0x000007FEC77300D3 (0x0000000006E80350 0x00000000001D7DC0 0x0000000006A52E60 0x00000000001D81C0), ?main@Syn@@YAHHPEAPEAD@Z() + 0x5A1503 bytes(s)
0x000007FEC7732D7A (0x0000000000000000 0x0000000006E819D0 0x0000000005553D20 0x0000000006DBEDD0), ?main@Syn@@YAHHPEAPEAD@Z() + 0x5A41AA bytes(s)
0x000007FEC7731385 (0x00000000001D8300 0x00000000001D8410 0x00000000059366F0 0x00000000059366F0), ?main@Syn@@YAHHPEAPEAD@Z() + 0x5A27B5 bytes(s)
0x000007FEC7738D25 (0x0000000000000000 0x00000000059366F0 0x0000000000000000 0x0000000000000001), ?main@Syn@@YAHHPEAPEAD@Z() + 0x5AA155 bytes(s)
0x000007FEC7C56777 (0x0000000000000004 0x0000000006E04480 0x0000000005936460 0x0000000006D8EE90), ?save_object_ptr@?$pointer_oserializer@Vxml_oarchive@archive@boost@@VTransition@DBFsm@fsmd@@@detail@archive@boost@@EEBAXAEAVbasic_oarchive@234@PEBX@Z() + 0x2C94A7 bytes(s)
0x000007FEC7C557B0 (0x0000000000000004 0x00000000001D8CD9 0x0000000006D8EE90 0x0000000000000000), ?save_object_ptr@?$pointer_oserializer@Vxml_oarchive@archive@boost@@VTransition@DBFsm@fsmd@@@detail@archive@boost@@EEBAXAEAVbasic_oarchive@234@PEBX@Z() + 0x2C84E0 bytes(s)
0x000007FEC7149148 (0x00000000000011C2 0x00000000001D8CD9 0x0000000000000000 0x000007FEC827CF70)
0x000007FEEFB2B1A4 (0x000000000235DCC0 0x000000006DED2E12 0x0000000006A303B0 0x00000000002FD600), ??1TclManager@xpcl@@QEAA@XZ() + 0x1F94 bytes(s)
0x000007FEEFB2D9C9 (0x000000006DF52B18 0x0000000000000096 0x0000000006A3CA50 0x000000006DF1937C), ?setResultObj@TclCommand@xpcl@@QEAAXPEAUTcl_Obj@@@Z() + 0x49 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000096 0x0000000006A3DA50 0x0000000000000096), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE51D9E (0x00000000002FD600 0x0000000006A3CA50 0x0000000000000096 0x0000000000000096), Tcl_EvalEx() + 0x99E bytes(s)
0x000000006DE52A28 (0x0000000000000000 0x00000000023268B8 0x0000000000000001 0x0000000000000002), TclEvalObjEx() + 0x348 bytes(s)
0x000000006DE5A88A (0x0000000000000000 0x00000000002FD600 0x00000000002FD600 0x0000000000000000), TclDumpMemoryInfo() + 0x340A bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000002 0x00000000023268B8 0x00000000023268B8), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006A0BCA0 0x000000006DF53178 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DE94464 (0x0000000003771A50 0x00000000002FD600 0x000000006DF53178 0x000000006DEE329B), Tcl_ExprObj() + 0x634 bytes(s)
0x000000006DE52AA6 (0x0000000000000753 0x0000000000000000 0x0000000000000003 0x0000000000000003), TclEvalObjEx() + 0x3C6 bytes(s)
0x000000006DE59F00 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x00000000002EFE60), TclDumpMemoryInfo() + 0x2A80 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000003 0x0000000002326848 0x0000000002326848), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006978220 0x000000000027BE36 0x6666666600000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DE94464 (0x0000000006A30110 0x00000000002FD600 0x0000000000000000 0x0000000000000000), Tcl_ExprObj() + 0x634 bytes(s)
0x000000006DE52AA6 (0x0000000002326800 0x00000000002FD600 0x0000000000000000 0x0000000000000002), TclEvalObjEx() + 0x3C6 bytes(s)
0x000000006DE6909A (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x00000000023267F0), TclDumpMemoryInfo() + 0x11C1A bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000002 0x00000000023267E8 0x00000000023267E8), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006A3C250 0x0000000000000000 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DEDFED4 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x000000006DF193BD), TclObjInterpProcCore() + 0x74 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000004 0x00000000023265B8 0x00000000023265B8), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006A46280 0x0000000000000000 0xFFFFFFFF00000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DEDFED4 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x0000000000000000), TclObjInterpProcCore() + 0x74 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000100000005 0x0000000002326348 0x0000000002326348), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006B2E270 0x0000000000000000 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DEDFED4 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x0000000000000000), TclObjInterpProcCore() + 0x74 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000001 0x00000000023261F8 0x00000000023261F8), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000006A39340 0x0000000002326040 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DE94464 (0x0000000006BA4660 0x00000000002FD600 0x0000000002325DA0 0x00000000001DBCA0), Tcl_ExprObj() + 0x634 bytes(s)
0x000000006DE52AA6 (0x0000000006A2AF20 0x0000000000000000 0x0000000000000003 0x0000000002325FF0), TclEvalObjEx() + 0x3C6 bytes(s)
0x000000006DE59F00 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x00000000002EFE60), TclDumpMemoryInfo() + 0x2A80 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000003 0x0000000002326040 0x0000000000000003), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE51D9E (0x00000000002FD600 0x00000000028FD7AB 0x0000000000000003 0x0000000000000003), Tcl_EvalEx() + 0x99E bytes(s)
0x000000006DED5952 (0x00000000002FD600 0x0000000000000002 0x0000000000000001 0x0000000000000000), Tcl_SubstObj() + 0x832 bytes(s)
0x000000006DE51991 (0x00000000002FD600 0x00000000028FD6D0 0x0000000000000002 0x000007FE00000002), Tcl_EvalEx() + 0x591 bytes(s)
0x000000006DE52638 (0x00000000029335F0 0x00000000029335F0 0x00000000001DC270 0x000007FEC7E5C184), Tcl_Eval() + 0x38 bytes(s)
0x000007FEC711D735 (0x0000000000000FD5 0x0000000000000FD5 0x00000000029335F0 0x0000000000000FD5)
0x000007FEEFB2B1F3 (0x0000000006CB7430 0x0000000006A4B554 0x0000000000000001 0x00000000002FD600), ??1TclManager@xpcl@@QEAA@XZ() + 0x1FE3 bytes(s)
0x000007FEEFB2D9C9 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x000000006DF193BD), ?setResultObj@TclCommand@xpcl@@QEAAXPEAUTcl_Obj@@@Z() + 0x49 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000005 0x0000000002325960 0x0000000002325960), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x00000000058C2F40 0x0000000000000000 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DEDFED4 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x000000006DE93BFC), TclObjInterpProcCore() + 0x74 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000001 0x0000000002325798 0x0000000002325798), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000005A24060 0x00000000023255E0 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DE94464 (0x0000000006CB4370 0x00000000002FD600 0x0000000002325340 0x00000000001DD280), Tcl_ExprObj() + 0x634 bytes(s)
0x000000006DE52AA6 (0x0000000006CB5120 0x0000000000000000 0x0000000000000003 0x0000000002325590), TclEvalObjEx() + 0x3C6 bytes(s)
0x000000006DE59F00 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x00000000002EFE60), TclDumpMemoryInfo() + 0x2A80 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000003 0x00000000023255E0 0x0000000000000003), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE51D9E (0x00000000002FD600 0x000000000564D91E 0x0000000000000003 0x0000000000000003), Tcl_EvalEx() + 0x99E bytes(s)
0x000000006DED5952 (0x00000000002FD600 0x0000000000000002 0x0000000000000001 0x0000000000000000), Tcl_SubstObj() + 0x832 bytes(s)
0x000000006DE51991 (0x00000000002FD600 0x000000000564CFB0 0x0000000000000002 0x000007FE00000002), Tcl_EvalEx() + 0x591 bytes(s)
0x000000006DE52638 (0x0000000000275870 0x0000000000275870 0x00000000001DD850 0x000007FEC7E5C184), Tcl_Eval() + 0x38 bytes(s)
0x000007FEC711D735 (0x00000000000008EB 0x00000000000008EB 0x0000000000275870 0x00000000000008EB)
0x000007FEEFB2B1F3 (0x0000000000000001 0x00000000069D3448 0x0000000000000001 0x00000000002FD600), ??1TclManager@xpcl@@QEAA@XZ() + 0x1FE3 bytes(s)
0x000007FEEFB2D9C9 (0x0000000000000000 0x0000000000000001 0x00000000055CDFE0 0x000000006DF193BD), ?setResultObj@TclCommand@xpcl@@QEAAXPEAUTcl_Obj@@@Z() + 0x49 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000009 0x0000000002324ED8 0x0000000002324ED8), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x0000000005A86490 0x0000000000000000 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DEDFED4 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x0000000000000000), TclObjInterpProcCore() + 0x74 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000001 0x0000000002324D48 0x0000000002324D48), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE95688 (0x00000000002FD600 0x00000000033DBBE0 0x0000000002324B90 0x0000000000000000), Tcl_ExprObj() + 0x1858 bytes(s)
0x000000006DE94464 (0x00000000055CC390 0x00000000002FD600 0x00000000023248F0 0x00000000001DE860), Tcl_ExprObj() + 0x634 bytes(s)
0x000000006DE52AA6 (0x00000000055CA650 0x0000000000000000 0x0000000000000003 0x0000000002324B40), TclEvalObjEx() + 0x3C6 bytes(s)
0x000000006DE59F00 (0x0000000000000000 0x00000000002FD600 0x0000000000000000 0x00000000002EFE60), TclDumpMemoryInfo() + 0x2A80 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000003 0x0000000002324B90 0x0000000000000003), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE51D9E (0x00000000002FD600 0x00000000033CBBD1 0x0000000000000003 0x0000000000000003), Tcl_EvalEx() + 0x99E bytes(s)
0x000000006DED5952 (0x00000000002FD600 0x0000000000000002 0x0000000000000001 0x0000000000000000), Tcl_SubstObj() + 0x832 bytes(s)
0x000000006DE51991 (0x00000000002FD600 0x00000000033CBA10 0x0000000000000002 0x000007FE00000002), Tcl_EvalEx() + 0x591 bytes(s)
0x000000006DE52638 (0x0000000000275CD0 0x0000000000275CD0 0x00000000001DEE30 0x000007FEC7E5C184), Tcl_Eval() + 0x38 bytes(s)
0x000007FEC711D735 (0x00000000000008EB 0x00000000000008EB 0x0000000000275CD0 0x00000000000008EB)
0x000007FEEFB2B1F3 (0x000000000286D420 0x000000006DED2E12 0x00000000055CCE70 0x00000000002FD600), ??1TclManager@xpcl@@QEAA@XZ() + 0x1FE3 bytes(s)
0x000007FEEFB2D9C9 (0x0000000005931EF0 0x0000000000000000 0x0000000000000000 0x0000000000000002), ?setResultObj@TclCommand@xpcl@@QEAAXPEAUTcl_Obj@@@Z() + 0x49 bytes(s)
0x000000006DE50E50 (0x0000000000000000 0x0000000000000001 0x0000000002324370 0x0000000000000001), Tcl_ListMathFuncs() + 0x590 bytes(s)
0x000000006DE51D9E (0x00000000002FD600 0x00000000055978F0 0x0000000000000001 0x0000000000000001), Tcl_EvalEx() + 0x99E bytes(s)
0x000000006DEBA4F0 (0x00000000002F7FD0 0x00000000002F7FD0 0x00000000002FD600 0x0000000000000000), Tcl_FSEvalFileEx() + 0x250 bytes(s)
0x000000006DEC5B24 (0x0000000000000001 0x0000000000000008 0x0001F82056300000 0x000000000020C5A0), Tcl_Main() + 0x554 bytes(s)
0x000007FEEFB2D1F1 (0x0000000000000002 0x0000000000282B3A 0x0077005C00640065 0x000007FEF5AE43B8), ?issue@TclManager@xpcl@@QEAAHHPEAPEAD_N@Z() + 0x371 bytes(s)
0x000007FEC718FC52 (0x0000000000000000 0x01D0BE1535026984 0x0000000000000000 0x0000000000000000), ?main@Syn@@YAHHPEAPEAD@Z() + 0x1082 bytes(s)
0x000000013F0B124B (0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000)
0x00000000776C652D (0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000), BaseThreadInitThunk() + 0xD bytes(s)
0x00000000778FC521 (0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000), RtlUserThreadStart() + 0x21 bytes(s)
@E [HLS-102] Encountered an internal error;
For technical support on this issue, please visit http://www.xilinx.com/support.

URLConnection with large amount of data causes OutOfMemoryError: Java heap

I am setting up a system where my customers can sent me their data files to my server. If I use a simple socket with a server permanently running on a chosen port, my customers are able to transfer files of any size without problem. However, If I adopt a different architecture, using a web server and a CGI program to receive their submissions, the client program that they run will crash if the file they are sending is any larger than about 30 Mbytes, with the exception OutOfMemoryError: Java heap.
The code in the two architectures is almost identical:
Socket con = new Socket( host, portno);
//URL url = new URL("http://"+host+":"+portno+path);
//URLConnection con = url.openConnection();
//con.setDoOutput(true);
File source_file = new File(file_name);
FileInputStream source = new FileInputStream(source_file);
out = new BufferedOutputStream(con.getOutputStream());
// First, Send a submission header.
data_out = submit_info.getBytes();
len = data_out.length + 1;
data_len[0] = (byte)len;
out.write(data_len, 0, 1);
out.write(data_out, 0, data_out.length);
// Then send the file content.
buff = new byte[(int)buffSize];
content_length = source_file.length();
long tot = 0;
while ( tot < content_length )
// Read data from the file.
readSize = (int) Math.min( content_length-tot, buffSize );
nRead = source.read(buff, 0, readSize);
tot += nRead;
if ( nRead == 0 ) break;
// Send data.
out.write(buff, 0, nRead);
"buffSize" is 4096. This code works fine, but if the first line is commented out and the next three are uncommented, the OutOfMemory exception is thrown within the loop when "tot" is around 30 million.
I have tried calling the garbage collector within the loop but it makes no difference. I am unable to anticipate the size of files that my customers will submit, so I cannot set the heap size in advance to cope with what they will sent. Fortunately, using a simple Socket avoids the problem, so there seems to be something wrong with how URLConnection works.

Set the URLConnection to use chunked mode. This saves it from having to buffer the entire contents before sending to ascertain its length.

Compressor 4 breaks "Send to Compressor in FCP7"

Similar Messages

Maybe you are looking for