Examples with Track org.opencastproject.mediapackage.Track used on opensource projects

Example 11 with Track

use of org.opencastproject.mediapackage.Track in project opencast by opencast.

the class TrackTest method testFlavorMarshalling.

@Test
public void testFlavorMarshalling() throws Exception {
    track.setFlavor(MediaPackageElements.PRESENTATION_SOURCE);
    JAXBContext context = JAXBContext.newInstance("org.opencastproject.mediapackage:org.opencastproject.mediapackage.track", MediaPackage.class.getClassLoader());
    Marshaller marshaller = context.createMarshaller();
    StringWriter writer = new StringWriter();
    marshaller.marshal(track, writer);
    Unmarshaller unmarshaller = context.createUnmarshaller();
    InputStream inputStream = IOUtils.toInputStream(writer.toString(), "UTF-8");
    try {
        TrackImpl t1 = unmarshaller.unmarshal(new StreamSource(inputStream), TrackImpl.class).getValue();
        Assert.assertEquals(MediaPackageElements.PRESENTATION_SOURCE, t1.getFlavor());
    } finally {
        IoSupport.closeQuietly(inputStream);
    }
    // Now again without namespaces
    String xml = "<oc:track xmlns:oc=\"http://mediapackage.opencastproject.org\" type=\"presentation/source\"><oc:tags/><oc:url>http://downloads.opencastproject.org/media/movie.m4v</oc:url><oc:duration>-1</oc:duration></oc:track>";
    inputStream = IOUtils.toInputStream(xml);
    try {
        TrackImpl t2 = unmarshaller.unmarshal(new StreamSource(inputStream), TrackImpl.class).getValue();
        Assert.assertEquals(MediaPackageElements.PRESENTATION_SOURCE, t2.getFlavor());
        Assert.assertEquals("http://downloads.opencastproject.org/media/movie.m4v", t2.getURI().toString());
    } finally {
        IoSupport.closeQuietly(inputStream);
    }
    // Get the xml from the object itself
    String xmlFromTrack = MediaPackageElementParser.getAsXml(track);
    Assert.assertTrue(xmlFromTrack.contains(MediaPackageElements.PRESENTATION_SOURCE.toString()));
    // And finally, using the element builder
    DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
    Document doc = docBuilder.parse(IOUtils.toInputStream(xml));
    Track t3 = (Track) MediaPackageElementBuilderFactory.newInstance().newElementBuilder().elementFromManifest(doc.getDocumentElement(), new DefaultMediaPackageSerializerImpl());
    Assert.assertEquals(MediaPackageElements.PRESENTATION_SOURCE, t3.getFlavor());
    Assert.assertEquals("http://downloads.opencastproject.org/media/movie.m4v", t3.getURI().toURL().toExternalForm());
}

Example 12 with Track

use of org.opencastproject.mediapackage.Track in project opencast by opencast.

the class IndexServiceImpl method createEvent.

@Override
public String createEvent(HttpServletRequest request) throws IndexServiceException {
    JSONObject metadataJson = null;
    MediaPackage mp = null;
    // regex for form field name matching an attachment or a catalog
    // The first sub items identifies if the file is an attachment or catalog
    // The second is the item flavor
    // Example form field names:  "catalog/captions/timedtext" and "attachment/captions/vtt"
    // The prefix of field name for attachment and catalog
    List<String> assetList = new LinkedList<String>();
    try {
        if (ServletFileUpload.isMultipartContent(request)) {
            mp = ingestService.createMediaPackage();
            for (FileItemIterator iter = new ServletFileUpload().getItemIterator(request); iter.hasNext(); ) {
                FileItemStream item = iter.next();
                String fieldName = item.getFieldName();
                if (item.isFormField()) {
                    if ("metadata".equals(fieldName)) {
                        String metadata = Streams.asString(item.openStream());
                        try {
                            metadataJson = (JSONObject) new JSONParser().parse(metadata);
                        } catch (Exception e) {
                            logger.warn("Unable to parse metadata {}", metadata);
                            throw new IllegalArgumentException("Unable to parse metadata");
                        }
                    }
                } else {
                    if ("presenter".equals(item.getFieldName())) {
                        mp = ingestService.addTrack(item.openStream(), item.getName(), MediaPackageElements.PRESENTER_SOURCE, mp);
                    } else if ("presentation".equals(item.getFieldName())) {
                        mp = ingestService.addTrack(item.openStream(), item.getName(), MediaPackageElements.PRESENTATION_SOURCE, mp);
                    } else if ("audio".equals(item.getFieldName())) {
                        mp = ingestService.addTrack(item.openStream(), item.getName(), new MediaPackageElementFlavor("presenter-audio", "source"), mp);
                    // For dynamic uploads, cannot get flavor at this point, so saving with temporary flavor
                    } else if (item.getFieldName().toLowerCase().matches(attachmentRegex)) {
                        assetList.add(item.getFieldName());
                        mp = ingestService.addAttachment(item.openStream(), item.getName(), new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
                    } else if (item.getFieldName().toLowerCase().matches(catalogRegex)) {
                        // Cannot get flavor at this point, so saving with temporary flavor
                        assetList.add(item.getFieldName());
                        mp = ingestService.addCatalog(item.openStream(), item.getName(), new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
                    } else if (item.getFieldName().toLowerCase().matches(trackRegex)) {
                        // Cannot get flavor at this point, so saving with temporary flavor
                        assetList.add(item.getFieldName());
                        mp = ingestService.addTrack(item.openStream(), item.getName(), new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
                    } else {
                        logger.warn("Unknown field name found {}", item.getFieldName());
                    }
                }
            }
            // MH-12085 update the flavors of any newly added assets.
            try {
                JSONArray assetMetadata = (JSONArray) ((JSONObject) metadataJson.get("assets")).get("options");
                if (assetMetadata != null) {
                    mp = updateMpAssetFlavor(assetList, mp, assetMetadata, isOverwriteExistingAsset);
                }
            } catch (Exception e) {
                // Assuming a parse error versus a file error and logging the error type
                logger.warn("Unable to process asset metadata {}", metadataJson.get("assets"), e);
                throw new IllegalArgumentException("Unable to parse metadata", e);
            }
        } else {
            throw new IllegalArgumentException("No multipart content");
        }
        // MH-10834 If there is only an audio track, change the flavor from presenter-audio/source to presenter/source.
        if (mp.getTracks().length == 1 && mp.getTracks()[0].getFlavor().equals(new MediaPackageElementFlavor("presenter-audio", "source"))) {
            Track audioTrack = mp.getTracks()[0];
            mp.remove(audioTrack);
            audioTrack.setFlavor(MediaPackageElements.PRESENTER_SOURCE);
            mp.add(audioTrack);
        }
        return createEvent(metadataJson, mp);
    } catch (Exception e) {
        logger.error("Unable to create event: {}", getStackTrace(e));
        throw new IndexServiceException(e.getMessage());
    }
}

Example 13 with Track

use of org.opencastproject.mediapackage.Track in project opencast by opencast.

the class EventIndexUtils method updateEvent.

/**
 * Update the given {@link Event} with the given {@link MediaPackage}.
 *
 * @param event
 *          the event to update
 * @param mp
 *          the mediapackage containing the metadata for the update
 * @return the updated event
 */
public static Event updateEvent(Event event, MediaPackage mp) {
    // Tracks
    List<String> trackMimeTypes = new ArrayList<String>();
    List<String> trackStreamResolutions = new ArrayList<String>();
    List<String> trackFlavors = new ArrayList<String>();
    for (Track t : mp.getTracks()) {
        if (t.getMimeType() != null)
            trackMimeTypes.add(t.getMimeType().toString());
        if (t.getFlavor() != null)
            trackFlavors.add(t.getFlavor().toString());
        VideoStream[] streams = TrackSupport.byType(t.getStreams(), VideoStream.class);
        for (VideoStream s : streams) {
            trackStreamResolutions.add(s.getFrameWidth() + "x" + s.getFrameHeight());
        }
    }
    event.setTrackMimetypes(trackMimeTypes);
    event.setTrackStreamResolutions(trackStreamResolutions);
    event.setTrackFlavors(trackFlavors);
    // Metadata
    List<String> metadataFlavors = new ArrayList<String>();
    List<String> metadataMimetypes = new ArrayList<String>();
    for (Catalog c : mp.getCatalogs()) {
        if (c.getFlavor() != null)
            metadataFlavors.add(c.getFlavor().toString());
        if (c.getMimeType() != null)
            metadataMimetypes.add(c.getMimeType().toString());
    }
    event.setMetadataFlavors(metadataFlavors);
    event.setMetadataMimetypes(metadataMimetypes);
    // Attachments
    List<String> attachmentFlavors = new ArrayList<String>();
    for (Attachment a : mp.getAttachments()) {
        if (a.getFlavor() != null)
            attachmentFlavors.add(a.getFlavor().toString());
    }
    event.setAttachmentFlavors(attachmentFlavors);
    // Publications
    List<Publication> publications = new ArrayList<Publication>();
    for (Publication p : mp.getPublications()) {
        publications.add(p);
    }
    event.setPublications(publications);
    event.setSeriesName(mp.getSeriesTitle());
    return event;
}

Example 14 with Track

use of org.opencastproject.mediapackage.Track in project opencast by opencast.

the class ImageToVideoWorkflowOperationHandler method imageToVideo.

private WorkflowOperationResult imageToVideo(MediaPackage mp, WorkflowInstance wi) throws Exception {
    // read cfg
    final List<String> sourceTags = getCfg(wi, OPT_SOURCE_TAGS).map(asList).getOrElse(nil(String.class));
    final Option<MediaPackageElementFlavor> sourceFlavor = getCfg(wi, OPT_SOURCE_FLAVOR).map(MediaPackageElementFlavor.parseFlavor);
    if (sourceFlavor.isNone() && sourceTags.isEmpty()) {
        logger.warn("No source tags or flavor are given to determine the image to use");
        return createResult(mp, Action.SKIP);
    }
    final List<String> targetTags = getCfg(wi, OPT_TARGET_TAGS).map(asList).getOrElse(nil(String.class));
    final Option<MediaPackageElementFlavor> targetFlavor = getCfg(wi, OPT_TARGET_FLAVOR).map(MediaPackageElementFlavor.parseFlavor);
    final double duration = getCfg(wi, OPT_DURATION).bind(Strings.toDouble).getOrElse(this.<Double>cfgKeyMissing(OPT_DURATION));
    final String profile = getCfg(wi, OPT_PROFILE).getOrElse(this.<String>cfgKeyMissing(OPT_PROFILE));
    // run image to video jobs
    final List<Job> jobs = Monadics.<MediaPackageElement>mlist(mp.getAttachments()).filter(sourceFlavor.map(Filters.matchesFlavor).getOrElse(Booleans.<MediaPackageElement>yes())).filter(Filters.hasTagAny(sourceTags)).map(Misc.<MediaPackageElement, Attachment>cast()).map(imageToVideo(profile, duration)).value();
    if (JobUtil.waitForJobs(serviceRegistry, jobs).isSuccess()) {
        for (final Job job : jobs) {
            if (job.getPayload().length() > 0) {
                Track track = (Track) MediaPackageElementParser.getFromXml(job.getPayload());
                track.setURI(workspace.moveTo(track.getURI(), mp.getIdentifier().toString(), track.getIdentifier(), FilenameUtils.getName(track.getURI().toString())));
                // Adjust the target tags
                for (String tag : targetTags) {
                    track.addTag(tag);
                }
                // Adjust the target flavor.
                for (MediaPackageElementFlavor flavor : targetFlavor) {
                    track.setFlavor(flavor);
                }
                // store new tracks to mediaPackage
                mp.add(track);
                logger.debug("Image to video operation completed");
            } else {
                logger.info("Image to video operation unsuccessful, no payload returned: {}", job);
                return createResult(mp, Action.SKIP);
            }
        }
        return createResult(mp, Action.CONTINUE, mlist(jobs).foldl(0L, new Function2<Long, Job, Long>() {

            @Override
            public Long apply(Long max, Job job) {
                return Math.max(max, job.getQueueTime());
            }
        }));
    } else {
        throw new WorkflowOperationException("The image to video encoding jobs did not return successfully");
    }
}

Example 15 with Track

use of org.opencastproject.mediapackage.Track in project opencast by opencast.

the class EncodeWorkflowOperationHandler method encode.

/**
 * Encode tracks from MediaPackage using profiles stored in properties and updates current MediaPackage.
 *
 * @param src
 *          The source media package
 * @param operation
 *          the current workflow operation
 * @return the operation result containing the updated media package
 * @throws EncoderException
 *           if encoding fails
 * @throws WorkflowOperationException
 *           if errors occur during processing
 * @throws IOException
 *           if the workspace operations fail
 * @throws NotFoundException
 *           if the workspace doesn't contain the requested file
 */
private WorkflowOperationResult encode(MediaPackage src, WorkflowOperationInstance operation) throws EncoderException, IOException, NotFoundException, MediaPackageException, WorkflowOperationException {
    MediaPackage mediaPackage = (MediaPackage) src.clone();
    // Check which tags have been configured
    String sourceTagsOption = StringUtils.trimToNull(operation.getConfiguration("source-tags"));
    String targetTagsOption = StringUtils.trimToNull(operation.getConfiguration("target-tags"));
    String sourceFlavorOption = StringUtils.trimToNull(operation.getConfiguration("source-flavor"));
    String sourceFlavorsOption = StringUtils.trimToNull(operation.getConfiguration("source-flavors"));
    String targetFlavorOption = StringUtils.trimToNull(operation.getConfiguration("target-flavor"));
    AbstractMediaPackageElementSelector<Track> elementSelector = new TrackSelector();
    // Make sure either one of tags or flavors are provided
    if (StringUtils.isBlank(sourceTagsOption) && StringUtils.isBlank(sourceFlavorOption) && StringUtils.isBlank(sourceFlavorsOption)) {
        logger.info("No source tags or flavors have been specified, not matching anything");
        return createResult(mediaPackage, Action.CONTINUE);
    }
    // Select the source flavors
    for (String flavor : asList(sourceFlavorsOption)) {
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }
    // Support legacy "source-flavor" option
    if (StringUtils.isNotBlank(sourceFlavorOption)) {
        String flavor = StringUtils.trim(sourceFlavorOption);
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }
    // Select the source tags
    for (String tag : asList(sourceTagsOption)) {
        elementSelector.addTag(tag);
    }
    // Find the encoding profile
    String profilesOption = StringUtils.trimToNull(operation.getConfiguration("encoding-profiles"));
    List<EncodingProfile> profiles = new ArrayList<EncodingProfile>();
    for (String profileName : asList(profilesOption)) {
        EncodingProfile profile = composerService.getProfile(profileName);
        if (profile == null)
            throw new WorkflowOperationException("Encoding profile '" + profileName + "' was not found");
        profiles.add(profile);
    }
    // Support legacy "encoding-profile" option
    String profileOption = StringUtils.trimToNull(operation.getConfiguration("encoding-profile"));
    if (StringUtils.isNotBlank(profileOption)) {
        String profileId = StringUtils.trim(profileOption);
        EncodingProfile profile = composerService.getProfile(profileId);
        if (profile == null)
            throw new WorkflowOperationException("Encoding profile '" + profileId + "' was not found");
        profiles.add(profile);
    }
    // Make sure there is at least one profile
    if (profiles.isEmpty())
        throw new WorkflowOperationException("No encoding profile was specified");
    // Target tags
    List<String> targetTags = asList(targetTagsOption);
    // Target flavor
    MediaPackageElementFlavor targetFlavor = null;
    if (StringUtils.isNotBlank(targetFlavorOption)) {
        try {
            targetFlavor = MediaPackageElementFlavor.parseFlavor(targetFlavorOption);
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Target flavor '" + targetFlavorOption + "' is malformed");
        }
    }
    // Look for elements matching the tag
    Collection<Track> elements = elementSelector.select(mediaPackage, false);
    // Encode all tracks found
    long totalTimeInQueue = 0;
    Map<Job, JobInformation> encodingJobs = new HashMap<Job, JobInformation>();
    for (Track track : elements) {
        // Encode the track with all profiles
        for (EncodingProfile profile : profiles) {
            // Check if the track supports the output type of the profile
            MediaType outputType = profile.getOutputType();
            if (outputType.equals(MediaType.Audio) && !track.hasAudio()) {
                logger.info("Skipping encoding of '{}', since it lacks an audio stream", track);
                continue;
            } else if (outputType.equals(MediaType.Visual) && !track.hasVideo()) {
                logger.info("Skipping encoding of '{}', since it lacks a video stream", track);
                continue;
            }
            logger.info("Encoding track {} using encoding profile '{}'", track, profile);
            // Start encoding and wait for the result
            encodingJobs.put(composerService.parallelEncode(track, profile.getIdentifier()), new JobInformation(track, profile));
        }
    }
    if (encodingJobs.isEmpty()) {
        logger.info("No matching tracks found");
        return createResult(mediaPackage, Action.CONTINUE);
    }
    // Wait for the jobs to return
    if (!waitForStatus(encodingJobs.keySet().toArray(new Job[encodingJobs.size()])).isSuccess()) {
        throw new WorkflowOperationException("One of the encoding jobs did not complete successfully");
    }
    // Process the result
    for (Map.Entry<Job, JobInformation> entry : encodingJobs.entrySet()) {
        Job job = entry.getKey();
        Track track = entry.getValue().getTrack();
        // add this receipt's queue time to the total
        totalTimeInQueue += job.getQueueTime();
        // it is allowed for compose jobs to return an empty payload. See the EncodeEngine interface
        if (job.getPayload().length() > 0) {
            List<Track> composedTracks = (List<Track>) MediaPackageElementParser.getArrayFromXml(job.getPayload());
            // Adjust the target tags
            for (Track encodedTrack : composedTracks) {
                for (String tag : targetTags) {
                    logger.trace("Tagging composed track {} with '{}'", encodedTrack.toString(), tag);
                    encodedTrack.addTag(tag);
                }
            }
            // Adjust the target flavor. Make sure to account for partial updates
            if (targetFlavor != null) {
                String flavorType = targetFlavor.getType();
                String flavorSubtype = targetFlavor.getSubtype();
                if ("*".equals(flavorType))
                    flavorType = track.getFlavor().getType();
                if ("*".equals(flavorSubtype))
                    flavorSubtype = track.getFlavor().getSubtype();
                for (Track encodedTrack : composedTracks) {
                    encodedTrack.setFlavor(new MediaPackageElementFlavor(flavorType, flavorSubtype));
                    logger.debug("Composed track {} has flavor '{}'", encodedTrack.toString(), encodedTrack.getFlavor());
                }
            }
            // store new tracks to mediaPackage
            for (Track encodedTrack : composedTracks) {
                mediaPackage.addDerived(encodedTrack, track);
                String fileName = getFileNameFromElements(track, encodedTrack);
                encodedTrack.setURI(workspace.moveTo(encodedTrack.getURI(), mediaPackage.getIdentifier().toString(), encodedTrack.getIdentifier(), fileName));
            }
        }
    }
    WorkflowOperationResult result = createResult(mediaPackage, Action.CONTINUE, totalTimeInQueue);
    logger.debug("Parallel encode operation completed");
    return result;
}