Ejemplo n.º 1
0
  @POST
  @Consumes(MediaType.MULTIPART_FORM_DATA)
  @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
  @ApiOperation(
      value = "Returns a GEO label LML representation",
      notes = "Requires metadata/feedback documents as data stream")
  @ApiResponses({@ApiResponse(code = 400, message = "Error in feedback/metadata document")})
  public Label getLabelByStream(
      /* @ApiParam("Metadata document") */ @FormDataParam(Constants.PARAM_METADATA)
          InputStream metadataInputStream,
      /* @ApiParam("Feedback document") */ @FormDataParam(Constants.PARAM_FEEDBACK)
          InputStream feedbackInputStream)
      throws IOException {
    MetadataTransformer metadataTransformer = this.transformer.get();

    Label label = new Label();
    label.setMetadataUrl(new URL("http://not.available.for.direct.upload"));
    label.setFeedbackUrl(new URL("http://not.available.for.direct.upload"));

    PushbackInputStream tempStream;
    boolean hasData = false;
    if (metadataInputStream != null) {
      tempStream = new PushbackInputStream(metadataInputStream);
      int t = tempStream.read();
      if (t != -1) {
        tempStream.unread(t);
        log.debug("Reading from metadata stream...");
        metadataTransformer.updateGeoLabel(tempStream, label);
        hasData = true;
      } else tempStream.close();
    }
    if (feedbackInputStream != null) {
      tempStream = new PushbackInputStream(feedbackInputStream);
      int t = tempStream.read();
      if (t != -1) {
        tempStream.unread(t);
        log.debug("Reading from feedback stream...");
        metadataTransformer.updateGeoLabel(tempStream, label);
        hasData = true;
      } else tempStream.close();
    }

    if (!hasData)
      throw new WebApplicationException(
          Response.status(Response.Status.BAD_REQUEST)
              .type(MediaType.TEXT_PLAIN)
              .entity("No metadata or feedback file specified")
              .build());

    return label;
  }
Ejemplo n.º 2
0
 /**
  * Close the Bitstream.
  *
  * @throws BitstreamException
  */
 public void close() throws BitstreamException {
   try {
     source.close();
   } catch (IOException ex) {
     throw newBitstreamException(STREAM_ERROR, ex);
   }
 }
Ejemplo n.º 3
0
 /** Closes any files opened by this tokenizer. */
 public void close() {
   if (wantClose) {
     try {
       is.close();
     } catch (IOException e) {
     }
   }
 }
Ejemplo n.º 4
0
 /**
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
   // TODO Auto-generated method stub
   String str = "123456.654321";
   ByteArrayInputStream b = new ByteArrayInputStream(str.getBytes());
   PushbackInputStream p = null;
   p = new PushbackInputStream(b);
   int temp = 0;
   while ((temp = p.read()) != -1) {
     if (temp != '.') {
       System.out.print((char) temp);
     } else {
       p.unread(temp);
       temp = p.read();
       System.out.println("");
       System.out.println((char) temp);
       // break;
     }
   }
   p.close();
 }
Ejemplo n.º 5
0
 public void close() throws Exception {
   in.close();
 }
    public Boolean call() throws AndroidEmulatorException {
      if (logger == null) {
        logger = listener.getLogger();
      }

      final File homeDir = Utils.getHomeDirectory(androidSdk.getSdkHome());
      final File avdDirectory = getAvdDirectory(homeDir);
      final boolean emulatorExists = getAvdConfigFile(homeDir).exists();

      // Can't do anything if a named emulator doesn't exist
      if (isNamedEmulator() && !emulatorExists) {
        throw new EmulatorDiscoveryException(Messages.AVD_DOES_NOT_EXIST(avdName, avdDirectory));
      }

      // Check whether AVD needs to be created
      boolean createSdCard = false;
      boolean createSnapshot = false;
      File snapshotsFile = new File(getAvdDirectory(homeDir), "snapshots.img");
      if (emulatorExists) {
        // AVD exists: check whether there's anything still to be set up
        File sdCardFile = new File(getAvdDirectory(homeDir), "sdcard.img");
        boolean sdCardRequired = getSdCardSize() != null;

        // Check if anything needs to be done for snapshot-enabled builds
        if (shouldUseSnapshots() && androidSdk.supportsSnapshots()) {
          if (!snapshotsFile.exists()) {
            createSnapshot = true;
          }

          // We should ensure that we start out with a clean SD card for the build
          if (sdCardRequired && sdCardFile.exists()) {
            sdCardFile.delete();
          }
        }

        // Flag that we need to generate an SD card, if there isn't one existing
        if (sdCardRequired && !sdCardFile.exists()) {
          createSdCard = true;
        }

        // If everything is ready, then return
        if (!createSdCard && !createSnapshot) {
          return true;
        }
      } else {
        AndroidEmulator.log(logger, Messages.CREATING_AVD(avdDirectory));
      }

      // We can't continue if we don't know where to find emulator images or tools
      if (!androidSdk.hasKnownRoot()) {
        throw new EmulatorCreationException(Messages.SDK_NOT_SPECIFIED());
      }
      final File sdkRoot = new File(androidSdk.getSdkRoot());
      if (!sdkRoot.exists()) {
        throw new EmulatorCreationException(Messages.SDK_NOT_FOUND(androidSdk.getSdkRoot()));
      }

      // If we need to initialise snapshot support for an existing emulator, do so
      if (createSnapshot) {
        // Copy the snapshots file into place
        File snapshotDir = new File(sdkRoot, "tools/lib/emulator");
        Util.copyFile(new File(snapshotDir, "snapshots.img"), snapshotsFile);

        // Update the AVD config file mark snapshots as enabled
        Map<String, String> configValues;
        try {
          configValues = parseAvdConfigFile(homeDir);
          configValues.put("snapshot.present", "true");
          writeAvdConfigFile(homeDir, configValues);
        } catch (IOException e) {
          throw new EmulatorCreationException(Messages.AVD_CONFIG_NOT_READABLE(), e);
        }
      }

      // If we need create an SD card for an existing emulator, do so
      if (createSdCard) {
        AndroidEmulator.log(logger, Messages.ADDING_SD_CARD(sdCardSize, getAvdName()));
        if (!createSdCard(homeDir)) {
          throw new EmulatorCreationException(Messages.SD_CARD_CREATION_FAILED());
        }

        // Update the AVD config file
        Map<String, String> configValues;
        try {
          configValues = parseAvdConfigFile(homeDir);
          configValues.put("sdcard.size", sdCardSize);
          writeAvdConfigFile(homeDir, configValues);
        } catch (IOException e) {
          throw new EmulatorCreationException(Messages.AVD_CONFIG_NOT_READABLE(), e);
        }
      }

      // Return if everything is now ready for use
      if (emulatorExists) {
        return true;
      }

      // Build up basic arguments to `android` command
      final StringBuilder args = new StringBuilder(100);
      args.append("create avd ");

      // Overwrite any existing files
      args.append("-f ");

      // Initialise snapshot support, regardless of whether we will actually use it
      if (androidSdk.supportsSnapshots()) {
        args.append("-a ");
      }

      if (sdCardSize != null) {
        args.append("-c ");
        args.append(sdCardSize);
        args.append(" ");
      }
      args.append("-s ");
      args.append(screenResolution.getSkinName());
      args.append(" -n ");
      args.append(getAvdName());
      boolean isUnix = !Functions.isWindows();
      ArgumentListBuilder builder =
          Utils.getToolCommand(androidSdk, isUnix, Tool.ANDROID, args.toString());

      // Tack on quoted platform name at the end, since it can be anything
      builder.add("-t");
      builder.add(osVersion.getTargetName());

      if (targetAbi != null) {
        builder.add("--abi");
        builder.add(targetAbi);
      }

      // Log command line used, for info
      AndroidEmulator.log(logger, builder.toStringWithQuote());

      // Run!
      boolean avdCreated = false;
      final Process process;
      try {
        ProcessBuilder procBuilder = new ProcessBuilder(builder.toList());
        if (androidSdk.hasKnownHome()) {
          procBuilder.environment().put("ANDROID_SDK_HOME", androidSdk.getSdkHome());
        }
        process = procBuilder.start();
      } catch (IOException ex) {
        throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());
      }

      // Redirect process's stderr to a stream, for logging purposes
      ByteArrayOutputStream stderr = new ByteArrayOutputStream();
      ByteArrayOutputStream stdout = new ByteArrayOutputStream();
      new StreamCopyThread("", process.getErrorStream(), stderr).start();

      // Command may prompt us whether we want to further customise the AVD.
      // Just "press" Enter to continue with the selected target's defaults.
      try {
        boolean processAlive = true;

        // Block until the command outputs something (or process ends)
        final PushbackInputStream in = new PushbackInputStream(process.getInputStream(), 10);
        int len = in.read();
        if (len == -1) {
          // Check whether the process has exited badly, as sometimes no output is valid.
          // e.g. When creating an AVD with Google APIs, no user input is requested.
          if (process.waitFor() != 0) {
            AndroidEmulator.log(logger, Messages.AVD_CREATION_FAILED());
            AndroidEmulator.log(logger, stderr.toString(), true);
            throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());
          }
          processAlive = false;
        }
        in.unread(len);

        // Write CRLF, if required
        if (processAlive) {
          final OutputStream stream = process.getOutputStream();
          stream.write('\r');
          stream.write('\n');
          stream.flush();
          stream.close();
        }

        // read the rest of stdout (for debugging purposes)
        Util.copyStream(in, stdout);
        in.close();

        // Wait for happy ending
        if (process.waitFor() == 0) {
          // Do a sanity check to ensure the AVD was really created
          avdCreated = getAvdConfigFile(homeDir).exists();
        }

      } catch (IOException e) {
        throw new EmulatorCreationException(Messages.AVD_CREATION_ABORTED(), e);
      } catch (InterruptedException e) {
        throw new EmulatorCreationException(Messages.AVD_CREATION_INTERRUPTED(), e);
      } finally {
        process.destroy();
      }

      // For reasons unknown, the return code may not be correctly reported on Windows.
      // So check whether stderr contains failure info (useful for other platforms too).
      String errOutput = stderr.toString();
      String output = stdout.toString();
      if (errOutput.contains("list targets")) {
        AndroidEmulator.log(logger, Messages.INVALID_AVD_TARGET(osVersion.getTargetName()));
        avdCreated = false;
        errOutput = null;
      } else if (errOutput.contains("more than one ABI")) {
        AndroidEmulator.log(
            logger, Messages.MORE_THAN_ONE_ABI(osVersion.getTargetName(), output), true);
        avdCreated = false;
        errOutput = null;
      }

      // Check everything went ok
      if (!avdCreated) {
        if (errOutput != null && errOutput.length() != 0) {
          AndroidEmulator.log(logger, stderr.toString(), true);
        }
        throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());
      }

      // Done!
      return false;
    }
  /** secondary PES Parser */
  public String parseStream(
      JobCollection collection,
      XInputFile aXInputFile,
      int _pes_streamtype,
      int action,
      String vptslog) {
    String fchild = collection.getOutputName(aXInputFile.getName());
    String fparent = collection.getOutputNameParent(fchild);

    if (collection.getSettings().getBooleanProperty(Keys.KEY_ExternPanel_appendExtension))
      fparent = collection.getOutputDirectory() + collection.getFileSeparator() + fchild;

    JobProcessing job_processing = collection.getJobProcessing();

    job_processing.clearStatusVariables();
    int[] clv = job_processing.getStatusVariables();

    /** split part */
    fparent += job_processing.getSplitSize() > 0 ? "(" + job_processing.getSplitPart() + ")" : "";

    String paname = fparent + ".ma1";

    String file_id = aXInputFile.getFileID();

    List tempfiles = job_processing.getTemporaryFileList();

    if (!tempfiles.isEmpty()) {
      for (int i = 0; i < tempfiles.size(); i += 4) {
        if (tempfiles.get(i + 1).toString().equals(aXInputFile.toString())) {
          Common.renameTo(tempfiles.get(i).toString(), paname);

          tempfiles.set(i, paname);

          Common.setMessage(Resource.getString("parseSecondaryPES.continue") + " " + aXInputFile);

          String str = tempfiles.get(i + 3).toString();

          if (str.equals("tt")) // vtx
          new StreamProcess(
                CommonParsing.TELETEXT,
                collection,
                tempfiles.get(i).toString(),
                tempfiles.get(i + 2).toString(),
                tempfiles.get(i + 3).toString(),
                vptslog);
          else if (str.equals("sp")) // subpics
          new StreamProcess(
                CommonParsing.SUBPICTURE,
                collection,
                tempfiles.get(i).toString(),
                tempfiles.get(i + 2).toString(),
                tempfiles.get(i + 3).toString(),
                vptslog);
          else if (str.equals("pc")) // lpcm
          new StreamProcess(
                CommonParsing.LPCM_AUDIO,
                collection,
                tempfiles.get(i).toString(),
                tempfiles.get(i + 2).toString(),
                tempfiles.get(i + 3).toString(),
                vptslog);
          else // other audio
          new StreamProcess(
                CommonParsing.MPEG_AUDIO,
                collection,
                tempfiles.get(i).toString(),
                tempfiles.get(i + 2).toString(),
                tempfiles.get(i + 3).toString(),
                vptslog);

          return vptslog;
        }
      }
    }

    boolean Message_2 = collection.getSettings().getBooleanProperty(Keys.KEY_MessagePanel_Msg2);
    boolean Debug = collection.getSettings().getBooleanProperty(Keys.KEY_DebugLog);
    boolean SimpleMPG = collection.getSettings().getBooleanProperty(Keys.KEY_simpleMPG);
    boolean GetEnclosedPackets =
        collection.getSettings().getBooleanProperty(Keys.KEY_Input_getEnclosedPackets);
    boolean IgnoreScrambledPackets =
        collection.getSettings().getBooleanProperty(Keys.KEY_TS_ignoreScrambled);

    boolean isTeletext = false;
    boolean missing_startcode = false;
    boolean scrambling_messaged = false;
    boolean pes_isMpeg2;
    boolean pes_alignment;
    boolean pes_scrambled;
    boolean containsPts = false;
    boolean foundObject;

    int pes_streamtype;
    int pes_payloadlength;
    int pes_packetlength;
    int pes_extensionlength;
    int pes_headerlength = 9;
    int pes_packetoffset = 6;
    int pes_extension2_id;
    int pesID;
    int subID;
    int offset;
    int returncode = 0;

    int tmp_value1 = 0;

    byte[] pes_packet = new byte[0x10006];
    byte[] buffered_data;

    long count = 0;
    long size;
    long qexit;

    job_processing.setMinBitrate(CommonParsing.MAX_BITRATE_VALUE);
    job_processing.setMaxBitrate(0);
    job_processing.setExportedVideoFrameNumber(0);
    job_processing.setEndPtsOfGop(-10000);
    job_processing.setSequenceHeader(true);
    job_processing.setAllMediaFilesExportLength(0);
    job_processing.setProjectFileExportLength(0);

    Hashtable substreams = new Hashtable();
    StandardBuffer sb;

    demuxList = job_processing.getSecondaryPESDemuxList();
    demuxList.clear();

    try {

      PushbackInputStream in =
          new PushbackInputStream(aXInputFile.getInputStream(), pes_packet.length);

      size = aXInputFile.length();

      Common.updateProgressBar(
          Resource.getString("parseSecondaryPES.demux.pes") + " " + aXInputFile.getName(), 0, 0);

      qexit =
          count
              + (0x100000L
                  * Integer.parseInt(
                      collection.getSettings().getProperty(Keys.KEY_ExportPanel_Infoscan_Value)));

      bigloop:
      while (true) {
        loop:
        while (count < size) {
          pes_streamtype = _pes_streamtype; // reset to original type

          Common.updateProgressBar(count, size);

          // yield();

          while (pause()) {}

          if (CommonParsing.isProcessCancelled() || (CommonParsing.isInfoScan() && count > qexit)) {
            CommonParsing.setProcessCancelled(false);
            job_processing.setSplitSize(0);

            break bigloop;
          }

          in.read(pes_packet, 0, pes_packetoffset);

          pesID = CommonParsing.getPES_IdField(pes_packet, 0);

          if ((returncode = CommonParsing.validateStartcode(pes_packet, 0)) < 0
              || pesID < CommonParsing.SYSTEM_END_CODE) {
            returncode = returncode < 0 ? -returncode : 4;

            if (Message_2 && !missing_startcode)
              Common.setMessage(
                  Resource.getString("parseSecondaryPES.missing.startcode") + " " + count);

            in.read(pes_packet, pes_packetoffset, pes_packet.length - pes_packetoffset);

            int i = returncode;

            for (; i < pes_packet.length - 3; ) {
              returncode = CommonParsing.validateStartcode(pes_packet, i);

              if (returncode < 0) {
                i += -returncode;
                continue;
              } else {
                in.unread(pes_packet, i, pes_packet.length - i);

                count += i;
                missing_startcode = true;

                continue loop;
              }
            }

            in.unread(pes_packet, i, pes_packet.length - i);

            count += i;
            missing_startcode = true;

            continue loop;
          }

          if (Message_2 && missing_startcode)
            Common.setMessage(
                Resource.getString("parseSecondaryPES.found.startcode") + " " + count);

          missing_startcode = false;

          if (pes_streamtype == CommonParsing.MPEG1PS_TYPE
              || pes_streamtype == CommonParsing.MPEG2PS_TYPE
              || SimpleMPG) {
            switch (pesID) {
              case CommonParsing.SYSTEM_END_CODE:
                in.unread(pes_packet, 4, 2);
                Common.setMessage("-> skip system_end_code @ " + count);
                count += 4;
                continue loop;

              case CommonParsing.PACK_START_CODE:
                if ((0xC0 & pes_packet[4]) == 0) // mpg1
                {
                  in.skip(6);
                  count += 12;
                  continue loop;
                } else if ((0xC0 & pes_packet[4]) == 0x40) // mpg2
                {
                  in.read(pes_packet, 6, 8);

                  offset = 7 & pes_packet[13];

                  count += 14;

                  in.read(pes_packet, 14, offset);

                  if (offset > 0) {
                    for (int i = 0; i < offset; i++)
                      if (pes_packet[14 + i] != -1) {
                        in.unread(pes_packet, 14, offset);

                        Common.setMessage("!> wrong pack header stuffing @ " + count);
                        missing_startcode = true;
                        continue loop;
                      }
                  }

                  count += offset;

                  continue loop;
                } else {
                  in.unread(pes_packet, 4, 2);
                  count += 4;
                  continue loop;
                }

              case CommonParsing.SYSTEM_START_CODE:
              case CommonParsing.PROGRAM_STREAM_MAP_CODE:
              case CommonParsing.PADDING_STREAM_CODE:
              case CommonParsing.PRIVATE_STREAM_2_CODE:
              case CommonParsing.ECM_STREAM_CODE:
              case CommonParsing.EMM_STREAM_CODE:
              case CommonParsing.DSM_CC_STREAM_CODE:
              case 0xF3:
              case 0xF4:
              case 0xF5:
              case 0xF6:
              case 0xF7:
              case 0xF8:
              case 0xF9:
              case 0xFA:
              case 0xFB:
              case 0xFC:
              case 0xFD:
              case 0xFE:
              case 0xFF:
                pes_payloadlength = CommonParsing.getPES_LengthField(pes_packet, 0);

                in.skip(pes_payloadlength);

                count += (pes_packetoffset + pes_payloadlength);
                continue loop;
            }
          }

          if ((0xF0 & pesID) != 0xE0
              && (0xE0 & pesID) != 0xC0
              && pesID != CommonParsing.PRIVATE_STREAM_1_CODE) {
            in.unread(pes_packet, 3, pes_packetoffset - 3);
            count += 3;
            continue loop;
          }

          pes_payloadlength = CommonParsing.getPES_LengthField(pes_packet, 0);

          if (pes_payloadlength == 0) {
            Common.setMessage(Resource.getString("parseSecondaryPES.packet.length") + " " + count);

            count += pes_packetoffset;
            continue loop;
          }

          in.read(pes_packet, pes_packetoffset, pes_payloadlength + 4);

          pes_packetlength = pes_packetoffset + pes_payloadlength;

          if (GetEnclosedPackets
              && CommonParsing.validateStartcode(pes_packet, pes_packetlength) < 0) {
            if (count + pes_packetlength < size) {
              if (Message_2 && !missing_startcode)
                Common.setMessage(
                    Resource.getString(
                        "parseSecondaryPES.miss.next.startcode",
                        String.valueOf(count + pes_packetlength),
                        String.valueOf(count),
                        Integer.toHexString(pesID).toUpperCase()));

              missing_startcode = true;

              in.unread(pes_packet, pes_packetoffset, pes_payloadlength + 4);
              count += pes_packetoffset;

              continue loop;
            }
          } else in.unread(pes_packet, pes_packetlength, 4);

          clv[5]++;

          if (Debug)
            System.out.print(
                "\r"
                    + Resource.getString(
                        "parseSecondaryPES.packs",
                        String.valueOf(clv[5]),
                        String.valueOf((count * 100 / size)),
                        String.valueOf(count)));

          pes_extensionlength = CommonParsing.getPES_ExtensionLengthField(pes_packet, 0);

          pes_isMpeg2 = (0xC0 & pes_packet[6]) == 0x80;
          pes_alignment = pes_isMpeg2 && (4 & pes_packet[6]) != 0;
          pes_scrambled = pes_isMpeg2 && (0x30 & pes_packet[6]) != 0;

          count += pes_packetlength;

          /** check scrambling */
          if (IgnoreScrambledPackets) {
            // cannot work with scrambled data
            if (pes_scrambled) {
              if (!scrambling_messaged) {
                scrambling_messaged = true;

                Common.setMessage(
                    Resource.getString(
                        "parseTS.scrambled",
                        Integer.toHexString(pesID).toUpperCase(),
                        String.valueOf(clv[5]),
                        String.valueOf(count - pes_packetlength)));
              }

              continue loop;
            } else if (scrambling_messaged) {
              Common.setMessage(
                  Resource.getString(
                      "parseTS.clear",
                      Integer.toHexString(pesID).toUpperCase(),
                      String.valueOf(clv[5]),
                      String.valueOf(count - pes_packetlength)));
              scrambling_messaged = false;
            }
          }

          /** vdr_dvbsub determination */
          pes_extension2_id =
              CommonParsing.getExtension2_Id(
                  pes_packet,
                  pes_headerlength,
                  pes_payloadlength,
                  pesID,
                  pes_isMpeg2,
                  count - pes_packetlength);

          isTeletext = false;
          subID = 0;

          if (pesID == CommonParsing.PRIVATE_STREAM_1_CODE && pes_payloadlength > 2) {
            offset = pes_headerlength + pes_extensionlength;

            if (offset < pes_packetlength) {
              subID = 0xFF & pes_packet[offset];
              isTeletext = pes_extensionlength == 0x24 && subID >>> 4 == 1;

              // vdr 1.5.x dvb-subs container
              if (pes_payloadlength >= 4 && subID >>> 4 == 2) {
                tmp_value1 =
                    CommonParsing.getIntValue(pes_packet, offset, 4, !CommonParsing.BYTEREORDERING);

                // vdr 1.5.x start packet of dvb-sub || subsequent packet
                // if ((pes_alignment && tmp_value1 == 0x20010000) || (!pes_alignment && tmp_value1
                // == 0x20010001))
                if ((pes_alignment && (0xF0FFFFFF & tmp_value1) == 0x20010000)
                    || (!pes_alignment && (0xF0FFFFFF & tmp_value1) == 0x20010001)) {
                  for (int i = offset, j = offset + 4; i < j; i++) pes_packet[i] = (byte) 0xFF;

                  pes_extensionlength += 4;
                  pes_packet[8] = (byte) (pes_extensionlength);
                  pes_payloadlength -= 4;

                  // pes_extension2_id = 1;
                  pes_extension2_id = subID = tmp_value1 >>> 24;
                  pes_streamtype =
                      CommonParsing.MPEG2PS_TYPE; // will be resetted before next packet

                  if (pes_alignment) pes_packet[offset + 4] = (byte) (subID);
                }
              }

              // subpic in vdr_pes before 1.5.x
              if (pes_alignment && !isTeletext && (subID >>> 4 == 2 || subID >>> 4 == 3))
                pes_streamtype = CommonParsing.MPEG2PS_TYPE; // will be resetted before next packet

              if (pes_streamtype != CommonParsing.MPEG1PS_TYPE
                  && pes_streamtype != CommonParsing.MPEG2PS_TYPE
                  && !isTeletext) subID = 0; // disables LPCM too
            } else if (pes_streamtype != CommonParsing.MPEG1PS_TYPE) // ?
            {
              pes_extensionlength = pes_payloadlength - 3;
              pes_packet[8] = (byte) (pes_extensionlength);
            }

            /** packet buffering esp. of subpics from vdr or other pes */
            if (pes_extension2_id != -1) {
              String str = String.valueOf(pes_extension2_id);
              offset = pes_headerlength + pes_extensionlength;

              if (!substreams.containsKey(str)) substreams.put(str, new StandardBuffer());

              sb = (StandardBuffer) substreams.get(str);

              // buffer raw packet data
              if (!pes_alignment) {
                sb.write(pes_packet, offset, pes_packetlength - offset);
                continue loop;
              }

              // start packet, buffer this and get last completed packet
              else {
                buffered_data = sb.getData();

                sb.reset();
                sb.write(pes_packet, 0, pes_packetlength);

                if (buffered_data == null || buffered_data.length < 10) continue loop;

                pes_packetlength = buffered_data.length;

                if (pes_packetlength > 0x10005) {
                  Common.setMessage(
                      "!> sub packet too long: 0x"
                          + Integer.toHexString(pesID).toUpperCase()
                          + " /ext2_id "
                          + pes_extension2_id);
                  pes_packetlength = 0x10005;
                }

                pes_payloadlength = pes_packetlength - pes_packetoffset;

                System.arraycopy(buffered_data, 0, pes_packet, 0, pes_packetlength);

                CommonParsing.setPES_LengthField(pes_packet, 0, pes_payloadlength);

                buffered_data = null;
              }
            }
          }

          foundObject = false;

          /** find ID object */
          for (int i = 0; i < demuxList.size(); i++) {
            streamdemultiplexer = (StreamDemultiplexer) demuxList.get(i);

            foundObject =
                pesID == streamdemultiplexer.getID()
                    && subID == streamdemultiplexer.subID()
                    && isTeletext == streamdemultiplexer.isTTX();

            if (foundObject) break;
          }

          /** create new ID object */
          if (!foundObject) {
            String IDtype = "";

            switch (0xF0 & pesID) {
              case 0xE0:
                IDtype = Resource.getString("idtype.mpeg.video.ignored");

                streamdemultiplexer = new StreamDemultiplexer(collection);
                streamdemultiplexer.setID(pesID);
                streamdemultiplexer.setsubID(0);
                streamdemultiplexer.setType(CommonParsing.MPEG_VIDEO);
                streamdemultiplexer.setStreamType(pes_streamtype);

                demuxList.add(streamdemultiplexer);
                break;

              case 0xC0:
              case 0xD0:
                IDtype = Resource.getString("idtype.mpeg.audio");

                streamdemultiplexer = new StreamDemultiplexer(collection);
                streamdemultiplexer.setID(pesID);
                streamdemultiplexer.setsubID(0);
                streamdemultiplexer.setType(CommonParsing.MPEG_AUDIO);
                streamdemultiplexer.setStreamType(pes_streamtype);

                demuxList.add(streamdemultiplexer);
                streamdemultiplexer.init(
                    collection,
                    fparent,
                    MainBufferSize / demuxList.size(),
                    demuxList.size(),
                    CommonParsing.SECONDARY_PES_PARSER);

                break;
            }

            switch (pesID) {
              case CommonParsing.PRIVATE_STREAM_1_CODE:
                IDtype = Resource.getString("idtype.private.stream");
                IDtype +=
                    (isTeletext ? " TTX " : "")
                        + (subID != 0
                            ? " (SubID 0x" + Integer.toHexString(subID).toUpperCase() + ")"
                            : "");

                streamdemultiplexer = new StreamDemultiplexer(collection);
                streamdemultiplexer.setID(pesID);
                streamdemultiplexer.setsubID(subID);

                switch (subID >>> 4) {
                  case 1:
                    streamdemultiplexer.setType(CommonParsing.TELETEXT);
                    break;

                  case 2:
                  case 3:
                    streamdemultiplexer.setType(CommonParsing.SUBPICTURE);
                    break;

                  case 8:
                    streamdemultiplexer.setType(CommonParsing.AC3_AUDIO);
                    break;

                  case 0xA:
                    streamdemultiplexer.setType(CommonParsing.LPCM_AUDIO);
                }

                streamdemultiplexer.setTTX(isTeletext);
                streamdemultiplexer.setStreamType(pes_streamtype);

                demuxList.add(streamdemultiplexer);
                streamdemultiplexer.init(
                    collection,
                    fparent,
                    MainBufferSize / demuxList.size(),
                    demuxList.size(),
                    CommonParsing.SECONDARY_PES_PARSER);

                break;
            }

            Common.setMessage(
                Resource.getString(
                    "parseSecondaryPES.found.pesid",
                    Integer.toHexString(pesID).toUpperCase(),
                    IDtype,
                    "" + (count - 6 - pes_payloadlength)));
          }

          if (!streamdemultiplexer.StreamEnabled()) continue loop;

          if (streamdemultiplexer.getType() == CommonParsing.MPEG_VIDEO) continue loop;
          else streamdemultiplexer.write(job_processing, pes_packet, 0, pes_packetlength, true);
        }

        /** loop not yet used */
        break bigloop;
      }

      Common.setMessage(
          Resource.getString(
              "parseSecondaryPES.packs",
              String.valueOf(clv[5]),
              String.valueOf(count * 100 / size),
              String.valueOf(count)));

      in.close();

      processNonVideoElementaryStreams(
          vptslog, action, clv, collection, job_processing, tempfiles, aXInputFile);

    } catch (IOException e2) {

      Common.setExceptionMessage(e2);
    }

    return vptslog;
  }
Ejemplo n.º 8
0
    public void run() {
      try {
        System.out.println(
            "accepted connection " + socket.getInetAddress() + ":" + socket.getPort());
        PushbackInputStream inStream = new PushbackInputStream(socket.getInputStream());
        // 得到客户端发来的第一行协议数据:Content-Length=143253434;filename=xxx.3gp;sourceid=
        // 如果用户初次上传文件,sourceid的值为空。
        String head = StreamTool.readLine(inStream);
        System.out.println(head);
        if (head != null) {
          // 下面从协议数据中提取各项参数值
          String[] items = head.split(";");
          String filelength = items[0].substring(items[0].indexOf("=") + 1);
          String filename = items[1].substring(items[1].indexOf("=") + 1);
          String sourceid = items[2].substring(items[2].indexOf("=") + 1);
          long id = System.currentTimeMillis(); // 生产资源id,如果需要唯一性,可以采用UUID
          FileLog log = null;
          if (sourceid != null && !"".equals(sourceid)) {
            id = Long.valueOf(sourceid);
            log = find(id); // 查找上传的文件是否存在上传记录
          }
          File file = null;
          int position = 0;
          if (log == null) { // 如果不存在上传记录,为文件添加跟踪记录
            String path = new SimpleDateFormat("yyyy/MM/dd/HH/mm").format(new Date());
            File dir = new File("file/" + path);
            if (!dir.exists()) dir.mkdirs();
            file = new File(dir, filename);
            if (file.exists()) { // 如果上传的文件发生重名,然后进行改名
              filename =
                  filename.substring(0, filename.indexOf(".") - 1)
                      + dir.listFiles().length
                      + filename.substring(filename.indexOf("."));
              file = new File(dir, filename);
            }
            save(id, file);
          } else { // 如果存在上传记录,读取已经上传的数据长度
            file = new File(log.getPath()); // 从上传记录中得到文件的路径
            if (file.exists()) {
              File logFile = new File(file.getParentFile(), file.getName() + ".log");
              if (logFile.exists()) {
                Properties properties = new Properties();
                properties.load(new FileInputStream(logFile));
                // 读取已经上传的数据长度
                position = Integer.valueOf(properties.getProperty("length"));
              }
            }
          }

          OutputStream outStream = socket.getOutputStream();
          String response = "sourceid=" + id + ";position=" + position + "\r\n";
          // 服务器收到客户端的请求信息后,给客户端返回响应信息:sourceid=1274773833264;position=0
          // sourceid由服务器端生成,唯一标识上传的文件,position指示客户端从文件的什么位置开始上传
          outStream.write(response.getBytes());
          RandomAccessFile fileOutStream = new RandomAccessFile(file, "rwd");
          // 设置文件长度
          if (position == 0) fileOutStream.setLength(Integer.valueOf(filelength));
          fileOutStream.seek(position); // 指定从文件的特定位置开始写入数据
          byte[] buffer = new byte[1024];
          int len = -1;
          int length = position;
          while ((len = inStream.read(buffer)) != -1) { // 从输入流中读取数据写入到文件中
            fileOutStream.write(buffer, 0, len);
            length += len;
            Properties properties = new Properties();
            properties.put("length", String.valueOf(length));
            FileOutputStream logFile =
                new FileOutputStream(new File(file.getParentFile(), file.getName() + ".log"));
            properties.store(logFile, null); // 实时记录已经接收的文件长度
            logFile.close();
          }
          if (length == fileOutStream.length()) delete(id);
          fileOutStream.close();
          inStream.close();
          outStream.close();
          file = null;
        }
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        try {
          if (socket != null && !socket.isClosed()) socket.close();
        } catch (IOException e) {
        }
      }
    }