/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community License, Version 2.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of the License
   * at:
   *
   *   http://opensource.org/licenses/ecl2.txt
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   *
   */
  
  package org.opencastproject.composer.impl.endpoint;
  
  import static org.opencastproject.util.doc.rest.RestParameter.Type.TEXT;
  
  import org.opencastproject.composer.api.ComposerService;
  import org.opencastproject.composer.api.EncoderException;
  import org.opencastproject.composer.api.EncodingProfile;
  import org.opencastproject.composer.api.EncodingProfileImpl;
  import org.opencastproject.composer.api.EncodingProfileList;
  import org.opencastproject.composer.api.LaidOutElement;
  import org.opencastproject.composer.layout.Dimension;
  import org.opencastproject.composer.layout.Layout;
  import org.opencastproject.composer.layout.Serializer;
  import org.opencastproject.job.api.JaxbJob;
  import org.opencastproject.job.api.Job;
  import org.opencastproject.job.api.JobProducer;
  import org.opencastproject.mediapackage.Attachment;
  import org.opencastproject.mediapackage.MediaPackageElement;
  import org.opencastproject.mediapackage.MediaPackageElementParser;
  import org.opencastproject.mediapackage.Track;
  import org.opencastproject.rest.AbstractJobProducerEndpoint;
  import org.opencastproject.serviceregistry.api.ServiceRegistry;
  import org.opencastproject.smil.api.SmilService;
  import org.opencastproject.smil.entity.api.Smil;
  import org.opencastproject.util.JsonObj;
  import org.opencastproject.util.LocalHashMap;
  import org.opencastproject.util.NotFoundException;
  import org.opencastproject.util.UrlSupport;
  import org.opencastproject.util.doc.rest.RestParameter;
  import org.opencastproject.util.doc.rest.RestParameter.Type;
  import org.opencastproject.util.doc.rest.RestQuery;
  import org.opencastproject.util.doc.rest.RestResponse;
  import org.opencastproject.util.doc.rest.RestService;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.math.NumberUtils;
  import org.osgi.service.component.ComponentContext;
  import org.osgi.service.component.annotations.Component;
  import org.osgi.service.component.annotations.Reference;
  import org.osgi.service.jaxrs.whiteboard.propertytypes.JaxrsResource;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  
  import javax.servlet.http.HttpServletResponse;
  import javax.ws.rs.DefaultValue;
  import javax.ws.rs.FormParam;
  import javax.ws.rs.GET;
  import javax.ws.rs.POST;
  import javax.ws.rs.Path;
  import javax.ws.rs.PathParam;
  import javax.ws.rs.Produces;
  import javax.ws.rs.core.MediaType;
  import javax.ws.rs.core.Response;
  
  /**
   * A REST endpoint delegating functionality to the {@link ComposerService}
   */
  @Path("/composer/ffmpeg")
  @RestService(name = "composer", title = "Composer", abstractText = "This service creates and augments Opencast media packages that include media tracks, metadata "
          + "catalogs and attachments.", notes = {
          "All paths above are relative to the REST endpoint base (something like http://your.server/files)",
          "If the service is down or not working it will return a status 503, this means the the underlying service is "
                  + "not working and is either restarting or has failed",
          "A status code 500 means a general failure has occurred which is not recoverable and was not anticipated. In "
                  + "other words, there is a bug! You should file an error report with your server logs from the time when the "
                  + "error occurred: <a href=\"https://github.com/opencast/opencast/issues\">Opencast Issue Tracker</a>" })
  @Component(
    property = {
      "service.description=Composer REST Endpoint",
      "opencast.service.type=org.opencastproject.composer",
     "opencast.service.path=/composer/ffmpeg",
     "opencast.service.jobproducer=true"
   },
   immediate = true,
   service = ComposerRestService.class
 )
 @JaxrsResource
 public class ComposerRestService extends AbstractJobProducerEndpoint {
 
   /** The logger */
   private static final Logger logger = LoggerFactory.getLogger(ComposerRestService.class);
 
   private static final String VIDEO_TRACK_DEFAULT = "<track id=\"track-1\" type=\"presentation/source\">\n"
           + "  <mimetype>video/quicktime</mimetype>\n"
           + "  <url>http://localhost:8080/workflow/samples/camera.mpg</url>\n"
           + "  <checksum type=\"md5\">43b7d843b02c4a429b2f547a4f230d31</checksum>\n"
           + "  <duration>14546</duration>\n" + "  <video>\n"
           + "    <device type=\"UFG03\" version=\"30112007\" vendor=\"Unigraf\" />\n"
           + "    <encoder type=\"H.264\" version=\"7.4\" vendor=\"Apple Inc\" />\n"
           + "    <resolution>640x480</resolution>\n"
           + "    <scanType type=\"progressive\" />\n"
           + "    <bitrate>540520</bitrate>\n"
           + "    <frameRate>2</frameRate>\n"
           + "  </video>\n"
           + "</track>";
 
   private static final String AUDIO_TRACK_DEFAULT = "<track id=\"track-2\" type=\"presentation/source\">\n"
           + "  <mimetype>audio/mp3</mimetype>\n"
           + "  <url>serverUrl/workflow/samples/audio.mp3</url>\n"
           + "  <checksum type=\"md5\">950f9fa49caa8f1c5bbc36892f6fd062</checksum>\n"
           + "  <duration>10472</duration>\n"
           + "  <audio>\n"
           + "    <channels>2</channels>\n"
           + "    <bitdepth>0</bitdepth>\n"
           + "    <bitrate>128004.0</bitrate>\n"
           + "    <samplingrate>44100</samplingrate>\n"
           + "  </audio>\n"
           + "</track>";
 
   private static final String IMAGE_ATTACHMENT_DEFAULT = "<attachment id=\"track-3\">\n"
           + "  <mimetype>image/jpeg</mimetype>\n"
           + "  <url>serverUrl/workflow/samples/image.jpg</url>\n"
           + "</attachment>";
 
   /** The base server URL */
   protected String serverUrl;
 
   /** The composer service */
   protected ComposerService composerService = null;
 
   /** The service registry */
   protected ServiceRegistry serviceRegistry = null;
 
   /** The smil service */
   protected SmilService smilService = null;
 
   @Reference
   public void setSmilService(SmilService smilService) {
     this.smilService = smilService;
   }
 
   /**
    * Callback from the OSGi declarative services to set the service registry.
    *
    * @param serviceRegistry
    *          the service registry
    */
   @Reference
   protected void setServiceRegistry(ServiceRegistry serviceRegistry) {
     this.serviceRegistry = serviceRegistry;
   }
 
   /**
    * Sets the composer service.
    *
    * @param composerService
    *          the composer service
    */
   @Reference
   public void setComposerService(ComposerService composerService) {
     this.composerService = composerService;
   }
 
   /**
    * Callback from OSGi that is called when this service is activated.
    *
    * @param cc
    *          OSGi component context
    */
   public void activate(ComponentContext cc) {
     if (cc == null || cc.getBundleContext().getProperty("org.opencastproject.server.url") == null) {
       serverUrl = UrlSupport.DEFAULT_BASE_URL;
     } else {
       serverUrl = cc.getBundleContext().getProperty("org.opencastproject.server.url");
     }
   }
 
   /**
    * Encodes a track.
    *
    * @param sourceTrackAsXml
    *          The source track
    * @param profileId
    *          The profile to use in encoding this track
    * @return A response containing the job for this encoding job in the response body.
    * @throws Exception
    */
   @POST
   @Path("encode")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "encode", description = "Starts an encoding process, based on the specified encoding profile ID and the track", restParameters = {
           @RestParameter(description = "The track containing the stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "mp4-medium.http")
     }, responses = {
           @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response encode(@FormParam("sourceTrack") String sourceTrackAsXml, @FormParam("profileId") String profileId)
           throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackAsXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();
 
     // Deserialize the track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
 
     try {
       // Asynchronously encode the specified tracks
       Job job = composerService.encode((Track) sourceTrack, profileId);
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to encode the track: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Encodes a track to multiple tracks in parallel.
    *
    * @param sourceTrackAsXml
    *          The source track
    * @param profileId
    *          The profile to use in encoding this track
    * @return A response containing the job for this encoding job in the response body.
    * @throws Exception
    */
   @POST
   @Path("parallelencode")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "parallelencode", description = "Starts an encoding process, based on the specified encoding profile ID and the track",
     restParameters = {
       @RestParameter(description = "The track containing the stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
       @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "mp4-medium.http")
     }, responses = {
       @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK)
     }, returnDescription = "")
   public Response parallelencode(@FormParam("sourceTrack") String sourceTrackAsXml, @FormParam("profileId") String profileId)
           throws Exception {
     // Ensure that the POST parameters are present
     if (sourceTrackAsXml == null || profileId == null) {
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();
     }
 
     // Deserialize the track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType())) {
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
     }
 
     // Asynchronously encode the specified tracks
     Job job = composerService.parallelEncode((Track) sourceTrack, profileId);
     if (job == null)
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Encoding failed").build();
     return Response.ok().entity(new JaxbJob(job)).build();
   }
 
   /**
    * Trims a track to a new length.
    *
    * @param sourceTrackAsXml
    *          The source track
    * @param profileId
    *          the encoding profile to use for trimming
    * @param start
    *          the new trimming start time
    * @param duration
    *          the new video duration
    * @return A response containing the job for this encoding job in the response body.
    * @throws Exception
    */
   @POST
   @Path("trim")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "trim", description = "Starts a trimming process, based on the specified track, start time and duration in ms", restParameters = {
           @RestParameter(description = "The track containing the stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
           @RestParameter(description = "The encoding profile to use for trimming", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "trim.work"),
           @RestParameter(description = "The start time in milisecond", isRequired = true, name = "start", type = Type.STRING, defaultValue = "0"),
           @RestParameter(description = "The duration in milisecond", isRequired = true, name = "duration", type = Type.STRING, defaultValue = "10000") }, responses = {
           @RestResponse(description = "Results in an xml document containing the job for the trimming task", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If the start time is negative or exceeds the track duration", responseCode = HttpServletResponse.SC_BAD_REQUEST),
           @RestResponse(description = "If the duration is negative or, including the new start time, exceeds the track duration", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response trim(@FormParam("sourceTrack") String sourceTrackAsXml, @FormParam("profileId") String profileId,
           @FormParam("start") long start, @FormParam("duration") long duration) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackAsXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();
 
     // Deserialize the track
     MediaPackageElement sourceElement = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
     if (!Track.TYPE.equals(sourceElement.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
 
     // Make sure the trim times make sense
     Track sourceTrack = (Track) sourceElement;
 
     if (sourceTrack.getDuration() == null)
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element does not have a duration")
               .build();
 
     if (start < 0) {
       start = 0;
     } else if (duration <= 0) {
       duration = (sourceTrack.getDuration() - start);
     } else if (start + duration > sourceTrack.getDuration()) {
       duration = (sourceTrack.getDuration() - start);
     }
 
     try {
       // Asynchronously encode the specified tracks
       Job job = composerService.trim(sourceTrack, profileId, start, duration);
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to trim the track: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Encodes a track.
    *
    * @param audioSourceTrackXml
    *          The audio source track
    * @param videoSourceTrackXml
    *          The video source track
    * @param profileId
    *          The profile to use in encoding this track
    * @return A response containing the job for this encoding job in the response body.
    * @throws Exception
    */
   @POST
   @Path("mux")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "mux", description = "Starts an encoding process, which will mux the two tracks using the given encoding profile", restParameters = {
           @RestParameter(description = "The track containing the audio stream", isRequired = false, name = "sourceAudioTrack", type = Type.TEXT, defaultValue = AUDIO_TRACK_DEFAULT),
           @RestParameter(description = "The track containing the video stream", isRequired = false, name = "sourceVideoTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
           @RestParameter(description = "The track containing the video stream", isRequired = false, name = "sourceTracks", type = Type.TEXT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "mp4-medium.http") }, responses = {
           @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if the source tracks aren't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response mux(@FormParam("audioSourceTrack") String audioSourceTrackXml,
           @FormParam("videoSourceTrack") String videoSourceTrackXml,
           @FormParam("sourceTracks") String sourceTracksXml, @FormParam("profileId") String profileId)
           throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(profileId)) {
       return Response.status(Response.Status.BAD_REQUEST).entity("profileId must not be null").build();
     }
     if ((StringUtils.isBlank(audioSourceTrackXml) || StringUtils.isBlank(videoSourceTrackXml))
         && StringUtils.isBlank(sourceTracksXml)) {
       return Response.status(Response.Status.BAD_REQUEST)
           .entity("audioSourceTrack, videoSourceTrack or sourceTracks must not be null").build();
     }
 
     try {
       Job job;
       Map<String, Track> sourceTracks = new HashMap<>();
       if (StringUtils.isNotBlank(sourceTracksXml)) {
         for (String sourceTrackEntry : StringUtils.splitByWholeSeparator(sourceTracksXml, "#|#")) {
           String[] sourceTrackEntryTuple = StringUtils.splitByWholeSeparator(sourceTrackEntry, "#=#", 2);
           if (sourceTrackEntryTuple.length != 2) {
             return Response.status(Response.Status.BAD_REQUEST).entity("sourceTracks value invalid").build();
           }
           sourceTracks.put(sourceTrackEntryTuple[0],
               (Track) MediaPackageElementParser.getFromXml(sourceTrackEntryTuple[1]));
         }
         // Asynchronously encode the specified tracks
         job = composerService.mux(sourceTracks, profileId);
       } else {
         // Deserialize the audio track
         MediaPackageElement audioSourceTrack = MediaPackageElementParser.getFromXml(audioSourceTrackXml);
         if (!Track.TYPE.equals(audioSourceTrack.getElementType()))
           return Response.status(Response.Status.BAD_REQUEST).entity("audioSourceTrack must be of type track").build();
 
         // Deserialize the video track
         MediaPackageElement videoSourceTrack = MediaPackageElementParser.getFromXml(videoSourceTrackXml);
         if (!Track.TYPE.equals(videoSourceTrack.getElementType()))
           return Response.status(Response.Status.BAD_REQUEST).entity("videoSourceTrack must be of type track").build();
 
         job = composerService.mux((Track) videoSourceTrack, (Track) audioSourceTrack, profileId);
       }
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to mux tracks: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Encodes a track in a media package.
    *
    * @param sourceTrackXml
    *          The source track
    * @param profileId
    *          The profile to use in encoding this track
    * @param times
    *          one or more times in seconds separated by comma
    * @return A {@link Response} with the resulting track in the response body
    * @throws Exception
    */
   @POST
   @Path("image")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "image", description = "Starts an image extraction process, based on the specified encoding profile ID and the source track", restParameters = {
           @RestParameter(description = "The track containing the video stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "player-preview.http"),
           @RestParameter(description = "The number of seconds (many numbers can be specified, separated by semicolon) into the video to extract the image", isRequired = false, name = "time", type = Type.STRING),
           @RestParameter(description = "An optional set of key=value\\n properties", isRequired = false, name = "properties", type = TEXT) }, responses = {
           @RestResponse(description = "Results in an xml document containing the image attachment", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "The image extraction job")
   public Response image(@FormParam("sourceTrack") String sourceTrackXml, @FormParam("profileId") String profileId,
           @FormParam("time") String times, @FormParam("properties") LocalHashMap localMap) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();
 
     // Deserialize the source track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
 
     boolean timeBased = false;
     double[] timeArray = null;
     if (StringUtils.isNotBlank(times)) {
       // parse time codes
       try {
         timeArray = parseTimeArray(times);
       } catch (Exception e) {
         return Response.status(Response.Status.BAD_REQUEST).entity("could not parse times: invalid format").build();
       }
       timeBased = true;
     } else if (localMap == null) {
       return Response.status(Response.Status.BAD_REQUEST).build();
     }
 
     try {
       // Asynchronously encode the specified tracks
       Job job;
       if (timeBased) {
         job = composerService.image((Track) sourceTrack, profileId, timeArray);
       } else {
         job = composerService.image((Track) sourceTrack, profileId, localMap.getMap());
       }
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to extract image(s): " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Encodes a track in a media package.
    *
    * @param sourceTrackXml
    *          The source track
    * @param profileId
    *          The profile to use in encoding this track
    * @param times
    *          one or more times in seconds separated by comma
    * @return A {@link Response} with the resulting track in the response body
    * @throws Exception
    */
   @POST
   @Path("imagesync")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "imagesync", description = "Synchronously extracts an image, based on the specified encoding profile ID and the source track", restParameters = {
       @RestParameter(description = "The track containing the video stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
       @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "player-preview.http"),
       @RestParameter(description = "The number of seconds (many numbers can be specified, separated by semicolon) into the video to extract the image", isRequired = false, name = "time", type = Type.STRING)}, responses = {
       @RestResponse(description = "Results in an xml document containing the image attachment", responseCode = HttpServletResponse.SC_OK),
       @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "The extracted image")
   public Response imageSync(@FormParam("sourceTrack") String sourceTrackXml, @FormParam("profileId") String profileId,
                         @FormParam("time") String times) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackXml) || StringUtils.isBlank(profileId) || StringUtils.isBlank(times)) {
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack, times, and profileId must not be null").build();
     }
 
     // Deserialize the source track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType())) {
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
     }
 
     double[] timeArray = null;
     // parse time codes
     try {
       timeArray = parseTimeArray(times);
     } catch (Exception e) {
       return Response.status(Response.Status.BAD_REQUEST).entity("could not parse times: invalid format").build();
     }
 
     try {
       List<Attachment> result = composerService.imageSync((Track) sourceTrack, profileId, timeArray);
       return Response.ok().entity(MediaPackageElementParser.getArrayAsXml(result)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to extract image(s): " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Compose two videos into one with an optional watermark.
    *
    * @param compositeSizeJson
    *          The composite track dimension as JSON
    * @param lowerTrackXml
    *          The lower track of the composition as XML
    * @param lowerLayoutJson
    *          The lower layout as JSON
    * @param upperTrackXml
    *          The upper track of the composition as XML
    * @param upperLayoutJson
    *          The upper layout as JSON
    * @param watermarkAttachmentXml
    *          The watermark image attachment of the composition as XML
    * @param watermarkLayoutJson
    *          The watermark layout as JSON
    * @param profileId
    *          The encoding profile to use
    * @param background
    *          The background color
    * @return A {@link Response} with the resulting track in the response body
    * @throws Exception
    */
   @POST
   @Path("composite")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "composite", description = "Starts a video compositing process, based on the specified resolution, encoding profile ID, the source elements and their layouts", restParameters = {
           @RestParameter(description = "The resolution size of the resulting video as JSON", isRequired = true, name = "compositeSize", type = Type.STRING),
           @RestParameter(description = "The lower source track containing the lower video", isRequired = true, name = "lowerTrack", type = Type.TEXT),
           @RestParameter(description = "The lower layout containing the JSON definition of the layout", isRequired = true, name = "lowerLayout", type = Type.TEXT),
           @RestParameter(description = "The upper source track containing the upper video", isRequired = false, name = "upperTrack", type = Type.TEXT),
           @RestParameter(description = "The upper layout containing the JSON definition of the layout", isRequired = false, name = "upperLayout", type = Type.TEXT),
           @RestParameter(description = "The watermark source attachment containing watermark image", isRequired = false, name = "watermarkTrack", type = Type.TEXT),
           @RestParameter(description = "The watermark layout containing the JSON definition of the layout", isRequired = false, name = "watermarkLayout", type = Type.TEXT),
           @RestParameter(description = "The background color", isRequired = false, name = "background", type = Type.TEXT, defaultValue = "black"),
           @RestParameter(description = "The name of the audio source (lower or upper or both)", isRequired = false, name = "audioSourceName", type = Type.TEXT, defaultValue = ComposerService.BOTH),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING) }, responses = {
           @RestResponse(description = "Results in an xml document containing the compound video track", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if the source elements aren't from the right type", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response composite(@FormParam("compositeSize") String compositeSizeJson,
           @FormParam("lowerTrack") String lowerTrackXml, @FormParam("lowerLayout") String lowerLayoutJson,
           @FormParam("upperTrack") String upperTrackXml, @FormParam("upperLayout") String upperLayoutJson,
           @FormParam("watermarkAttachment") String watermarkAttachmentXml,
           @FormParam("watermarkLayout") String watermarkLayoutJson, @FormParam("profileId") String profileId,
           @FormParam("background") @DefaultValue("black") String background,
           @FormParam("sourceAudioName") @DefaultValue(ComposerService.BOTH) String sourceAudioName) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(compositeSizeJson) || StringUtils.isBlank(lowerTrackXml)
             || StringUtils.isBlank(lowerLayoutJson) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("One of the required parameters must not be null")
               .build();
 
     // Deserialize the source elements
     MediaPackageElement lowerTrack = MediaPackageElementParser.getFromXml(lowerTrackXml);
     Layout lowerLayout = Serializer.layout(JsonObj.jsonObj(lowerLayoutJson));
     if (!Track.TYPE.equals(lowerTrack.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("lowerTrack element must be of type track").build();
     LaidOutElement<Track> lowerLaidOutElement = new LaidOutElement<Track>((Track) lowerTrack, lowerLayout);
 
     Optional<LaidOutElement<Track>> upperLaidOutElement = Optional.<LaidOutElement<Track>> empty();
     if (StringUtils.isNotBlank(upperTrackXml)) {
       MediaPackageElement upperTrack = MediaPackageElementParser.getFromXml(upperTrackXml);
       Layout upperLayout = Serializer.layout(JsonObj.jsonObj(upperLayoutJson));
       if (!Track.TYPE.equals(upperTrack.getElementType())) {
         return Response.status(Response.Status.BAD_REQUEST).entity("upperTrack element must be of type track").build();
       }
       upperLaidOutElement = Optional.ofNullable(new LaidOutElement<Track>((Track) upperTrack, upperLayout));
     }
     Optional<LaidOutElement<Attachment>> watermarkLaidOutElement = Optional.<LaidOutElement<Attachment>> empty();
     if (StringUtils.isNotBlank(watermarkAttachmentXml)) {
       Layout watermarkLayout = Serializer.layout(JsonObj.jsonObj(watermarkLayoutJson));
       MediaPackageElement watermarkAttachment = MediaPackageElementParser.getFromXml(watermarkAttachmentXml);
       if (!Attachment.TYPE.equals(watermarkAttachment.getElementType()))
         return Response.status(Response.Status.BAD_REQUEST).entity("watermarkTrack element must be of type track")
                 .build();
       watermarkLaidOutElement = Optional.of(new LaidOutElement<Attachment>((Attachment) watermarkAttachment,
               watermarkLayout));
     }
 
     Dimension compositeTrackSize = Serializer.dimension(JsonObj.jsonObj(compositeSizeJson));
 
     try {
       // Asynchronously composite the specified source elements
       Job job = composerService.composite(compositeTrackSize, upperLaidOutElement, lowerLaidOutElement,
               watermarkLaidOutElement, profileId, background, sourceAudioName);
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to composite video: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Concat multiple tracks having the same codec to a single track.
    *
    * @param sourceTracksXml
    *          an array of track to concat in order of the array as XML
    * @param profileId
    *          The encoding profile to use
    * @param outputDimension
    *          The output dimension as JSON
    * @return A {@link Response} with the resulting track in the response body
    * @throws Exception
    */
   @POST
   @Path("concat")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "concat", description = "Starts a video concating process from multiple videos, based on the specified encoding profile ID and the source tracks", restParameters = {
           @RestParameter(description = "The source tracks to concat as XML", isRequired = true, name = "sourceTracks", type = Type.TEXT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING),
           @RestParameter(description = "The resolution dimension of the concat video as JSON", isRequired = false, name = "outputDimension", type = Type.STRING),
           @RestParameter(description = "The  frame rate of the concat video (should be positive, e.g. 25.0). Negative values and zero will cause no FFmpeg fps filter to be used in the filter chain.",
       isRequired = false, name = "outputFrameRate", type = Type.STRING),
           @RestParameter(description = "The source files have the same codecs and should not be re-encoded", isRequired = false, name = "sameCodec",type = Type.TEXT, defaultValue = "false")}, responses = {
     @RestResponse(description = "Results in an xml document containing the video track", responseCode = HttpServletResponse.SC_OK),
     @RestResponse(description = "If required parameters aren't set or if sourceTracks aren't from the type Track or not at least two tracks are present",
             responseCode = HttpServletResponse.SC_BAD_REQUEST)}, returnDescription = "")
   public Response concat(@FormParam("sourceTracks") String sourceTracksXml, @FormParam("profileId") String profileId,
           @FormParam("outputDimension") String outputDimension, @FormParam("outputFrameRate") String outputFrameRate,
           @FormParam("sameCodec") String sameCodec) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTracksXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTracks and profileId must not be null").build();
 
     // Deserialize the source track
     List<? extends MediaPackageElement> tracks = MediaPackageElementParser.getArrayFromXml(sourceTracksXml);
     if (tracks.size() < 2)
       return Response.status(Response.Status.BAD_REQUEST).entity("At least two tracks must be set to concat").build();
 
     for (MediaPackageElement elem : tracks) {
       if (!Track.TYPE.equals(elem.getElementType()))
         return Response.status(Response.Status.BAD_REQUEST).entity("sourceTracks must be of type track").build();
     }
     float fps = NumberUtils.toFloat(outputFrameRate, -1.0f);
     try {
       // Asynchronously concat the specified tracks together
       Dimension dimension = null;
       if (StringUtils.isNotBlank(outputDimension)) {
         dimension = Serializer.dimension(JsonObj.jsonObj(outputDimension));
       }
       boolean hasSameCodec = Boolean.parseBoolean(sameCodec);
       Job job = null;
       if (fps > 0) {
         job = composerService.concat(profileId, dimension, fps, hasSameCodec, tracks.toArray(new Track[tracks.size()]));
       } else {
         job = composerService.concat(profileId, dimension, hasSameCodec, tracks.toArray(new Track[tracks.size()]));
       }
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to concat videos: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Transforms an image attachment to a video track
    *
    * @param sourceAttachmentXml
    *          The source image attachment
    * @param profileId
    *          The profile to use for encoding
    * @param timeString
    *          the length of the resulting video track in seconds
    * @return A {@link Response} with the resulting track in the response body
    * @throws Exception
    */
   @POST
   @Path("imagetovideo")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "imagetovideo", description = "Starts an image converting process to a video, based on the specified encoding profile ID and the source image attachment", restParameters = {
           @RestParameter(description = "The resulting video time in seconds", isRequired = false, name = "time", type = Type.STRING, defaultValue = "1"),
           @RestParameter(description = "The attachment containing the image to convert", isRequired = true, name = "sourceAttachment", type = Type.TEXT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING) }, responses = {
           @RestResponse(description = "Results in an xml document containing the video track", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if sourceAttachment isn't from the type Attachment", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response imageToVideo(@FormParam("sourceAttachment") String sourceAttachmentXml,
           @FormParam("profileId") String profileId, @FormParam("time") @DefaultValue("1") String timeString)
           throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceAttachmentXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceAttachment and profileId must not be null")
               .build();
 
     // parse time
     Double time;
     try {
       time = Double.parseDouble(timeString);
     } catch (Exception e) {
       logger.info("Unable to parse time {} as long value!", timeString);
       return Response.status(Response.Status.BAD_REQUEST).entity("Could not parse time: invalid format").build();
     }
 
     // Deserialize the source track
     MediaPackageElement sourceAttachment = MediaPackageElementParser.getFromXml(sourceAttachmentXml);
     if (!Attachment.TYPE.equals(sourceAttachment.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceAttachment element must be of type attachment")
               .build();
 
     try {
       // Asynchronously convert the specified attachment to a video
       Job job = composerService.imageToVideo((Attachment) sourceAttachment, profileId, time);
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to convert image to video: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Converts an image to another format.
    *
    * @param sourceImageXml
    *          The source image
    * @param profileId
    *          The profile to use in image conversion
    * @return A {@link Response} with the resulting image in the response body
    * @throws Exception
    */
   @POST
   @Path("convertimage")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "convertimage", description = "Starts an image conversion process, based on the specified encoding profile ID and the source image", restParameters = {
           @RestParameter(description = "The original image", isRequired = true, name = "sourceImage", type = Type.TEXT, defaultValue = IMAGE_ATTACHMENT_DEFAULT),
           @RestParameter(description = "A comma separated list of encoding profiles to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "image-conversion.http") }, responses = {
           @RestResponse(description = "Results in an xml document containing the image attachment", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If required parameters aren't set or if sourceImage isn't from the type Attachment", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response convertImage(@FormParam("sourceImage") String sourceImageXml, @FormParam("profileId") String profileId)
           throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceImageXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceImage and profileId must not be null").build();
 
     // Deserialize the source track
     MediaPackageElement sourceImage = MediaPackageElementParser.getFromXml(sourceImageXml);
     if (!Attachment.TYPE.equals(sourceImage.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceImage element must be of type track").build();
 
     try {
       // Asynchronously convert the specified image
       Job job = composerService.convertImage((Attachment) sourceImage, StringUtils.split(profileId, ','));
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to convert image: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Demuxes a track into multiple outputs
    *
    * @param sourceTrackAsXml
    *          The source track
    * @param profileId
    *          The profile to use in encoding this track
    * @return A response containing the job for this encoding job in the response body.
    * @throws Exception
    *           - if it fails
    */
   @POST
   @Path("demux")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "demux", description = "Starts an demux process that produces multiple outputs, based on the specified encoding profile ID and the track", restParameters = {
           @RestParameter(description = "The track containing the stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
           @RestParameter(description = "The encoding profile to use", isRequired = true, name = "profileId", type = Type.STRING, defaultValue = "demux.work") }, responses = {
                   @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK),
                   @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response demux(@FormParam("sourceTrack") String sourceTrackAsXml, @FormParam("profileId") String profileId)
           throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackAsXml) || StringUtils.isBlank(profileId))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();
 
     // Deserialize the track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
 
     try {
       // Asynchronously encode the specified tracks
       Job job = composerService.demux((Track) sourceTrack, profileId);
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to encode the track: " + e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * ProcessSmil - encode a video based on descriptions in a smil file into all format in the profileIds
    *
    * @param smilAsXml
    *          - smil describing a list of videos and clips in them to make up one video
    * @param trackId
    *          - a paramGroup Id in the smil file describing a track
    * @param mediaType
    *          - audio only, video only or both
    * @param profileIds
    *          - list of encoding profile ids
    * @return a job running the process
    * @throws Exception
    *           if it fails
    */
   @POST
   @Path("processsmil")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "processsmil", description = "Starts an encoding process, based on the tracks and edit points in the smil and specified encoding profile IDs", restParameters = {
           @RestParameter(description = "The smil containing the tracks and edit points", isRequired = true, name = "smilAsXml", type = Type.TEXT),
           @RestParameter(description = "The id (paramgroup) of the track to encode", isRequired = false, name = "trackId", type = Type.STRING, defaultValue = ""),
           @RestParameter(description = "MediaType - v for video only, a for audio only, audiovisual otherwise", isRequired = false, name = "mediaType", type = Type.STRING, defaultValue = "o"),
           @RestParameter(description = "The encoding profiles to use", isRequired = true, name = "profileIds", type = Type.STRING) }, responses = {
                   @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK),
                   @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response processSmil(@FormParam("smilAsXml") String smilAsXml, @FormParam("trackId") String trackId,
           @FormParam("mediaType") String mediaType, @FormParam("profileIds") String profileIds) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(smilAsXml) || StringUtils.isBlank(profileIds))
       return Response.status(Response.Status.BAD_REQUEST).entity("smil and profileId must not be null").build();
 
     // Deserialize the data
     String[] profiles = StringUtils.split(profileIds, ",");
     Smil smil;
     try {
       smil = smilService.fromXml(smilAsXml).getSmil();
     } catch (Exception e) {
       return Response.status(Response.Status.BAD_REQUEST).entity("smil must be readable").build();
     }
 
     try {
       // Encode the specified tracks
       Job job = composerService.processSmil(smil, trackId, mediaType, Arrays.asList(profiles));
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to process the smil: " + e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   @POST
   @Path("multiencode")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "multiencode", description = "Starts an encoding process that produces multiple outputs, based on the specified encoding profile ID and the track",
     restParameters = {
       @RestParameter(description = "The track containing the stream", isRequired = true, name = "sourceTrack", type = Type.TEXT, defaultValue = VIDEO_TRACK_DEFAULT),
       @RestParameter(description = "The comma-delimited encoding profiles to use", isRequired = true, name = "profileIds", type = Type.STRING, defaultValue = "mp4-medium.http,mp4-low.http")
     }, responses = {
       @RestResponse(description = "Results in an xml document containing the job for the encoding task", responseCode = HttpServletResponse.SC_OK),
       @RestResponse(description = "If required parameters aren't set or if sourceTrack isn't from the type Track", responseCode = HttpServletResponse.SC_BAD_REQUEST)
     }, returnDescription = "")
   public Response multiEncode(@FormParam("sourceTrack") String sourceTrackAsXml,
           @FormParam("profileIds") String profileIds) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceTrackAsXml) || StringUtils.isBlank(profileIds))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileIds must not be null").build();
 
     // Deserialize the track
     MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
     if (!Track.TYPE.equals(sourceTrack.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();
 
     try {
       // Encode the specified track with the profiles
       String[] profiles = StringUtils.split(profileIds, ",");
       Job job = composerService.multiEncode((Track) sourceTrack, Arrays.asList(profiles));
       return Response.ok().entity(new JaxbJob(job)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to encode the track: ", e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   /**
    * Synchronously converts an image to another format.
    *
    * @param sourceImageXml
    *          The source image
    * @param profileIds
    *          The encoding profiles to use in image conversion
    * @return A {@link Response} with the resulting image in the response body
    * @throws Exception
    */
   @POST
   @Path("convertimagesync")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "convertimagesync", description = "Synchronously converts an image, based on the specified encoding profiles and the source image", restParameters = {
       @RestParameter(description = "The original image", isRequired = true, name = "sourceImage", type = Type.TEXT, defaultValue = IMAGE_ATTACHMENT_DEFAULT),
       @RestParameter(description = "The encoding profiles to use", isRequired = true, name = "profileIds", type = Type.STRING, defaultValue = "image-conversion.http") }, responses = {
       @RestResponse(description = "Results in an xml document containing the image attachments", responseCode = HttpServletResponse.SC_OK),
       @RestResponse(description = "If required parameters aren't set or if sourceImage isn't from the type attachment", responseCode = HttpServletResponse.SC_BAD_REQUEST) }, returnDescription = "")
   public Response convertImageSync(@FormParam("sourceImage") String sourceImageXml, @FormParam("profileIds")
       String profileIds) throws Exception {
     // Ensure that the POST parameters are present
     if (StringUtils.isBlank(sourceImageXml) || StringUtils.isBlank(profileIds))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceImage and profileIds must not be null").build();
 
     // Deserialize the source track
     MediaPackageElement sourceImage = MediaPackageElementParser.getFromXml(sourceImageXml);
     if (!Attachment.TYPE.equals(sourceImage.getElementType()))
       return Response.status(Response.Status.BAD_REQUEST).entity("sourceImage element must be of type track").build();
 
     try {
       List<Attachment> results = composerService.convertImageSync((Attachment) sourceImage,
           StringUtils.split(profileIds, ','));
       return Response.ok().entity(MediaPackageElementParser.getArrayAsXml(results)).build();
     } catch (EncoderException e) {
       logger.warn("Unable to convert image: " + e.getMessage());
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
     }
   }
 
   @GET
   @Path("profiles.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "profiles", description = "Retrieve the encoding profiles", responses = { @RestResponse(description = "Results in an xml document describing the available encoding profiles", responseCode = HttpServletResponse.SC_OK) }, returnDescription = "")
   public EncodingProfileList listProfiles() {
     List<EncodingProfileImpl> list = new ArrayList<EncodingProfileImpl>();
     for (EncodingProfile p : composerService.listProfiles()) {
       list.add((EncodingProfileImpl) p);
     }
     return new EncodingProfileList(list);
   }
 
   @GET
   @Path("profile/{id}.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(name = "profilesID", description = "Retrieve an encoding profile", pathParameters = { @RestParameter(name = "id", description = "the profile ID", isRequired = false, type = RestParameter.Type.STRING) }, responses = {
           @RestResponse(description = "Results in an xml document describing the requested encoding profile", responseCode = HttpServletResponse.SC_OK),
           @RestResponse(description = "If profile has not been found", responseCode = HttpServletResponse.SC_NOT_FOUND) }, returnDescription = "")
   public Response getProfile(@PathParam("id") String profileId) throws NotFoundException {
     EncodingProfileImpl profile = (EncodingProfileImpl) composerService.getProfile(profileId);
     if (profile == null)
       throw new NotFoundException();
     return Response.ok(profile).build();
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.rest.AbstractJobProducerEndpoint#getService()
    */
   @Override
   public JobProducer getService() {
     if (composerService instanceof JobProducer)
       return (JobProducer) composerService;
     else
       return null;
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.rest.AbstractJobProducerEndpoint#getServiceRegistry()
    */
   @Override
   public ServiceRegistry getServiceRegistry() {
     return serviceRegistry;
   }
 
   /**
    * Parses string containing times in seconds separated by comma.
    *
    * @param times
    *          string to be parsed
    * @return array of times in seconds
    */
   protected double[] parseTimeArray(String times) {
     String[] timeStringArray = times.split(";");
     List<Double> parsedTimeArray = new LinkedList<Double>();
     for (String timeString : timeStringArray) {
       String trimmed = StringUtils.trim(timeString);
       if (StringUtils.isNotBlank(trimmed)) {
         parsedTimeArray.add(Double.parseDouble(timeString));
       }
     }
     double[] timeArray = new double[parsedTimeArray.size()];
     for (int i = 0; i < parsedTimeArray.size(); i++) {
       timeArray[i] = parsedTimeArray.get(i);
     }
     return timeArray;
   }
 
 }