As the topic mentions I would like to use a pcap capture file as the source log file instead of the capture format the library currently uses. I can't find a way to do this in the source as of now, but I think it would be possible with some modifications.
 
By f.ex using jpcap library to parse the file could be a possible way of dooing this.  
Is there a point in the code I can "hook into" and instead of displaying packets from the carnivore capture interface I instead inject my packets from the pcap?
 
I have extensive java experience so any advice or directions would be great. And if there is a way of "dumping" what carnivore captures that would also be great to learn about.

I see you use the jpcap library from sourceforge. I'm trying to use this to extract the header in bytes and parse each field. I thought the instead of reading the carnivore logfile I would just add a pcap parser there instead.
 
Source so far:  
 
import net.sourceforge.jpcap.*;
 
import net.sourceforge.jpcap.capture.*;
import net.sourceforge.jpcap.net.*;
import net.sourceforge.jpcap.util.FileUtility;
import net.sourceforge.jpcap.util.HexHelper;
import net.sourceforge.jpcap.*;
 
import net.sourceforge.jpcap.capture.*;
import net.sourceforge.jpcap.net.*;
import net.sourceforge.jpcap.util.FileUtility;
import net.sourceforge.jpcap.util.HexHelper;
 
private static final int INFINITE = -1;
 private static final int PACKET_COUNT = INFINITE;
 
// BPF filter for capturing any packet
 private static final String FILTER = "";
 
private PacketCapture pcap;
PacketHandler ph;
 RawPacketHandler rph;
 
String fileName = "testDump.pcap";
 
 
void setup(){
size(300,300, OPENGL);
background(255);  
if(isOnline) {  //online mode
    CarnivoreP5 c = new CarnivoreP5(this);
    c.setShouldSkipUDP(true); //Skip UDP packets
 
  } else {  //offline mode
    //packets = loadStrings(log_file); // Need CarnivorePE "minivore" log file in "data" folder  
    pcap = new PacketCapture();
     try {
         // open devices for capturing (requires root)
           String filepath = dataPath("") + fileName;
         pcap.openOffline(filepath);//pcap filename
 
         // add a BPF filter (see tcpdump documentation)
         pcap.setFilter(FILTER, true);
 
         // create a handler
 
         // packet
         ph = new PacketHandler("offline");
         pcap.addPacketListener(ph);
 
         // raw
         //rph = new RawPacketHandler("offline");
         //pcap.addRawPacketListener(rph);
 
         // capture packets
         pcap.capture(PACKET_COUNT);
     
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
           }
  }
}
 
class RawPacketHandler implements RawPacketListener  
     {
       private int counter = 0;
 
       public RawPacketHandler(String name) {
         this.name = name;
       }
 
       public void rawPacketArrived(RawPacket rawPacket) {
         counter++;
         System.err.println(rawPacket);
       }
 
       String name;
     }
 
class PacketHandler implements PacketListener{
  private int counter = 0;
 
       public PacketHandler(String name) {
         this.name = name;
       }
 
       public void packetArrived(Packet packet) {
         counter++;
         String type = packet.getClass().getName();
         System.out.println(name + ": Packet(" + counter +  
                            ") is of type " + type + ".");
//          System.out.println("Packet data: " + packet.toColoredString(true));
         //IPPacket ip = new IPPacket();
         
         //TCPPacket tcp = new TCPPacket(packet.getHeader().length, packet.getHeader());
//          System.out.println("IPPacket data: destination: " + ip.getDestinationAddress() + ", source: "+ip.getSourceAddress());
         //System.out.println("IPPacket data: destination: " + tcp.getDestinationAddress() + ", source: "+tcp.getSourceAddress());
         System.err.println(HexHelper.toString(packet.getData()));
         
         
         if(packet instanceof TCPPacket) {
               TCPPacket tcpPacket = (TCPPacket)packet;
               byte[] data = tcpPacket.getTCPData();
                   
               String srcHost = tcpPacket.getSourceAddress();
               String dstHost = tcpPacket.getDestinationAddress();
               String isoData = null;
                 try {
                       isoData = new String(data, "ISO-8859-1");
                 } catch (UnsupportedEncodingException e) {
                       // TODO Auto-generated catch block
                       e.printStackTrace();
                 }
 
               System.out.println(srcHost+" -> " + dstHost + ": " + isoData);
         }
         
       }
 
       String name;
}

can you describe *exactly* what your goal is, because i think we're talking across purposes. the code you posted makes it appear like you are trying to launch your own pcap sniffer instance within carnivore??  
 
is your ultimate goal to parse packet headers at the byte level? or is your ultimate goal to playback a pcap log file?

gotcha. okay a few different answers  
 
for question 1: you can capture and save packets using the standalone CarnivorePE application (not the carnivore processing library). start recording, stop recording, save a .cpe file. should be pretty easy. then you can load that .cpe file into processing.  
 
question 2 there have been some questions about this. as far as i know the lost packet problem was fixed: setting carnivore to unlimited packets per second really *does* mean unlimited. it's only when you put it at 19 or fewer packets per second that you will/might be losing packets. although i might need to roll out a new release with this fix. can't remember.
 
question 3. ah-ha! yes, the new development version of the carnivore core already does all this. so yer one step ahead of us. sounds like yer building an interesting project. btw, there's a new super secret app under development here codenamed iLAN which sounds like might be similar to yours. iLAN has a lot of nice features like being able to reassemble tcp packet sessions into the original files. i'll need to get off my butt and roll it out :)  
 
so yeah my previous suggests are probably not applicable to what you're trying to do, sorry.  
 
remember the CarnivorePacket currently provides you with a byte[] called data. you can parse this byte by byte if you feel like rolling yer own IP and TCP header parser. it's a bit tricky but definitely doable.