eaf20transcriptionstore.java

编辑视频文件

        /*
           author: Markus
           problem: if the String starts with "file:", then it cannot be used later.
           solution (not done): find the place where "file:" is created
           solution (not done): find the place where "file:" creates a problem.
           workaround: remove "file:"
         */
        if (mediaFileName.startsWith("file:")) {
            mediaFileName = mediaFileName.substring(5);
        }

        attisTr.setMainMediaFile(mediaFileName);

        String svgFile = EAF20Parser.Instance().getSVGFile(attisTr.getPathName());

        if (svgFile != null) {
            if (!svgFile.startsWith("file:")) {
                svgFile = "file:" + mediaFileName;
            }

            attisTr.setSVGFile(svgFile);
        }

        // set author
        String author = EAF20Parser.Instance().getAuthor(attisTr.getPathName());

        if (attisTr.getAuthor().equals("")) {
            attisTr.setAuthor(author);
        }

        // make linguistic types available in transcription
        Vector linguisticTypes = EAF20Parser.Instance().getLinguisticTypes(attisTr.getPathName());

        Vector typesCopy = new Vector(linguisticTypes.size());

        for (int i = 0; i < linguisticTypes.size(); i++) {
            typesCopy.add(i, linguisticTypes.get(i));
        }

        attisTr.setLinguisticTypes(typesCopy);

        //attisTr.setLinguisticTypes(linguisticTypes);
        TimeOrder timeOrder = attisTr.getTimeOrder();

        // populate TimeOrder with TimeSlots
        Vector order = EAF20Parser.Instance().getTimeOrder(attisTr.getPathName());
        Hashtable slots = EAF20Parser.Instance().getTimeSlots(attisTr.getPathName());

        Hashtable timeSlothash = new Hashtable(); // temporarily stores map from id to TimeSlot object

        Iterator orderedIter = order.iterator();

        while (orderedIter.hasNext()) {
            TimeSlot ts = null;

            String key = (String) orderedIter.next();

            long time = Long.parseLong((String) slots.get(key));

            if (time != TimeSlot.TIME_UNALIGNED) {
                ts = new TimeSlotImpl(time, timeOrder);
            } else {
                ts = new TimeSlotImpl(timeOrder);
            }

            timeOrder.insertTimeSlot(ts);
            timeSlothash.put(key, ts);
        }

        Hashtable parentHash = new Hashtable();

        if (!attisTr.isLoaded()) {
            Iterator iter = EAF20Parser.Instance()
                                       .getTierNames(attisTr.getPathName())
                                       .iterator();

            // HB, 27 aug 03, moved earlier
            attisTr.setLoaded(true); // else endless recursion !!!!!

            while (iter.hasNext()) {
                String tierName = (String) iter.next();

                TierImpl tier = new TierImpl(null, tierName, null, attisTr, null);

                // set tier's metadata
                String participant = EAF20Parser.Instance().getParticipantOf(tierName,
                        attisTr.getPathName());
                LinguisticType linguisticType = EAF20Parser.Instance()
                                                           .getLinguisticTypeOf(tierName,
                        attisTr.getPathName());
                Locale defaultLanguage = EAF20Parser.Instance()
                                                    .getDefaultLanguageOf(tierName,
                        attisTr.getPathName());

                tier.setMetadata("PARTICIPANT", participant);
                tier.setLinguisticType(linguisticType);

                if (defaultLanguage != null) { // HB, 29 oct 02: added condition, since DEFAULT_LOCALE is IMPLIED
                    tier.setMetadata("DEFAULT_LOCALE", defaultLanguage);
                }

                // potentially, set tier's parent
                String parentId = EAF20Parser.Instance().getParentNameOf(tierName,
                        attisTr.getPathName());

                if (parentId != null) {
                    // store tier-parent_id pair until all Tiers instantiated
                    parentHash.put(tier, parentId);
                }

                attisTr.addTier(tier);
            }
        }

        // all Tiers are created. Now set all parent tiers
        Iterator parentIter = parentHash.keySet().iterator();

        while (parentIter.hasNext()) {
            TierImpl t = (TierImpl) parentIter.next();
            t.setParentTier(attisTr.getTierWithId((String) parentHash.get(t)));
        }

        //	attisTr.setLoaded(true);	// else endless recursion !!!!!
        Vector tiers = attisTr.getTiers();

        // create Annotations. Algorithm:
        // 1. loop over annotationRecords Vector. Instantiate right Annotations. Store
        //    references to annotations in intermediate data structures
        // 2. loop over intermediate structure. Realize references to Annotations by object
        //    references, iso using annotation_id's
        Hashtable idToAnnotation = new Hashtable();
        Hashtable references = new Hashtable();
        Hashtable referenceChains = new Hashtable();

        // HB, 2-1-02: temporarily store annotations, before adding them to tiers.
        // Reason: object reference have to be in place to add annotations in correct order.
        Hashtable tempAnnotationsForTiers = new Hashtable();

        // create Annotations, either AlignableAnnotations or RefAnnotations
        Iterator tierIter = tiers.iterator();

        while (tierIter.hasNext()) {
            Tier tier = (Tier) tierIter.next();
            Vector annotationRecords = EAF20Parser.Instance().getAnnotationsOf(tier.getName(),
                    attisTr.getPathName());

            // HB, 2-1-02
            Vector tempAnnotations = new Vector();

            Iterator it1 = annotationRecords.iterator();

            while (it1.hasNext()) {
                Annotation annotation = null;

                Vector annotationRecord = (Vector) it1.next();

                // annotationRecord has the following format. Either:
                // id, "alignable", time_slot_id1, time_slot_id2, value, or
                // id, "reference", annotation_ref_id, previous_annotation, value
                Iterator it2 = annotationRecord.iterator();
                int index = 0;

                String id = null;
                String annotType = null;
                String timeSlotId1 = null;
                String timeSlotId2 = null;
                String annotRefId = null;
                String annotValue = null;
                String prevRefId = null;
                String svg_ref = null;

                while (it2.hasNext()) {
                    if (index == 0) { // first element annotation id
                        id = (String) it2.next();
                    } else if (index == 1) { // second flag indicating type of annotation
                        annotType = (String) it2.next();
                    } else if (index == 2) {
                        if (annotType.equals("alignable") ||
                                annotType.equals("alignable_svg")) {
                            timeSlotId1 = (String) it2.next();
                        } else if (annotType.equals("reference")) {
                            annotRefId = (String) it2.next();
                        }
                    } else if (index == 3) {
                        if (annotType.equals("alignable") ||
                                annotType.equals("alignable_svg")) {
                            timeSlotId2 = (String) it2.next();
                        } else if (annotType.equals("reference")) {
                            prevRefId = (String) it2.next();
                        }
                    } else if (index == 4) {
                        if (annotType.equals("alignable")) {
                            annotValue = (String) it2.next();
                        } else if (annotType.equals("alignable_svg")) {
                            svg_ref = (String) it2.next();
                        } else if (annotType.equals("reference")) {
                            annotValue = (String) it2.next();
                        }
                    } else if (index == 5) {
                        if (annotType.equals("alignable_svg")) {
                            annotValue = (String) it2.next();
                        }
                    }

                    index++;
                }

                if (annotType.equals("alignable")) {
                    annotation = new AlignableAnnotation((TimeSlot) timeSlothash.get(
                                timeSlotId1),
                            (TimeSlot) timeSlothash.get(timeSlotId2), tier);
                } else if (annotType.equals("alignable_svg")) {
                    annotation = new SVGAlignableAnnotation((TimeSlot) timeSlothash.get(
                                timeSlotId1),
                            (TimeSlot) timeSlothash.get(timeSlotId2), tier,
                            svg_ref);
                } else if (annotType.equals("reference")) {
                    annotation = new RefAnnotation(null, tier);

                    references.put(id, annotRefId);

                    if (!prevRefId.equals("")) {
                        referenceChains.put(id, prevRefId);
                    }
                }

                if (annotValue != null) {
                    annotation.setValue(annotValue);
                }

                idToAnnotation.put(id, annotation);

                //	tier.addAnnotation(annotation);
                // HB, 2-1-02
                tempAnnotations.add(annotation);
            }

            // end of loop over annotation records
            // HB, 2-1-02
            tempAnnotationsForTiers.put(tier, tempAnnotations);
        }

        // end of loop over tierIter
        // realize object references
        Iterator refIter = references.keySet().iterator();

        while (refIter.hasNext()) {
            String key = (String) refIter.next();
            Annotation referedAnnotation = (Annotation) idToAnnotation.get(references.get(
                        key));
            RefAnnotation refAnnotation = null;

            try {
                refAnnotation = (RefAnnotation) idToAnnotation.get(key);
                refAnnotation.addReference(referedAnnotation);
            } catch (Exception ex) {
                //MK:02/09/17 adding exception handler
                Object o = idToAnnotation.get(key);
                System.out.println("failed to add a refanno to  (" +
                    referedAnnotation.getTier().getName() + ", " +
                    referedAnnotation.getBeginTimeBoundary() + ", " +
                    referedAnnotation.getEndTimeBoundary() + ") " +
                    referedAnnotation.getValue());

                if (o instanceof AlignableAnnotation) {
                    AlignableAnnotation a = (AlignableAnnotation) o;
                    System.out.println("  found AlignableAnnotation (" +
                        a.getTier().getName() + ", " +
                        a.getBeginTimeBoundary() + ", " +
                        a.getEndTimeBoundary() + ") " + a.getValue());
                } else {
                    System.out.println("  found " + o);
                }
            }
        }

        // realize reference chains (== within tiers)
        Iterator rIter = referenceChains.keySet().iterator();

        while (rIter.hasNext()) {
            String key = (String) rIter.next();
            RefAnnotation previous = (RefAnnotation) idToAnnotation.get(referenceChains.get(
                        key));
            RefAnnotation a = (RefAnnotation) idToAnnotation.get(key);

            if (previous != null) {
                previous.setNext(a);
            }
        }

        // HB, 2-1-01: with object references in place, add annotations to the correct tiers.
        // This is now done in the correct order (RefAnnotation.compareTo delegates comparison
        // to it's parent annotation.
        Iterator tIter = tempAnnotationsForTiers.keySet().iterator();

        while (tIter.hasNext()) {
            TierImpl t = (TierImpl) tIter.next();

            Vector annots = (Vector) tempAnnotationsForTiers.get(t);
            Iterator aIter = annots.iterator();

            while (aIter.hasNext()) {
                // HB, 14 aug 02, changed from addAnnotation
                t.insertAnnotation((Annotation) aIter.next());
            }
        }

        // HB, 4-7-02: with all annotations on the proper tiers, register implicit
        // parent-child relations between alignable annotations explicitly
        Iterator tierIter2 = tiers.iterator();

        while (tierIter2.hasNext()) {
            TierImpl t = (TierImpl) tierIter2.next();

            if (t.isTimeAlignable() && t.hasParentTier()) {
                Iterator alannIter = t.getAnnotations().iterator();

                while (alannIter.hasNext()) {
                    Annotation a = (Annotation) alannIter.next();

                    if (a instanceof AlignableAnnotation) {
                        ((AlignableAnnotation) a).registerWithParent();
                    }
                }
            }
        }
    }
}