Subversion Repositories mkgmap

/*
 * Copyright (C) 2010.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 or
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
package uk.me.parabola.imgfmt.app.srt;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import uk.me.parabola.imgfmt.app.BufferedImgFileWriter;
import uk.me.parabola.imgfmt.app.ImgFile;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.SectionWriter;
import uk.me.parabola.imgfmt.fs.ImgChannel;

/**
 * The SRT file. This contains a table showing the sort order of
 * the characters that is being used.
 *
 * @author Steve Ratcliffe
 */
public class SRTFile extends ImgFile {

        private SRTHeader header;

        private Sort sort;
        private boolean isMulti;
       
        private String description;

        private final List<Integer> srt8Starts = new ArrayList<>();

        public SRTFile(ImgChannel chan) {
                BufferedImgFileWriter fileWriter = new BufferedImgFileWriter(chan, "SRT");
                fileWriter.setMaxSize(Long.MAX_VALUE);
                setWriter(fileWriter);
        }

        /**
         * Write out the file.
         * This file has an unusual layout. There are several header like structures within
         * the main body of the file, with the real header being very small.
         */
        public void write() {
                ImgFileWriter writer = getWriter();
                writeDescription(writer);
                // Position at the start of the writable area.
                position(header.getHeaderLength());
                SectionWriter subWriter = header.makeSectionWriter(writer);
                int header3Len = sort.getHeader3Len();
                if (header3Len == 0)
                        header3Len = sort.isMulti()? SRTHeader.HEADER3_MULTI_LEN: SRTHeader.HEADER3_LEN;
                subWriter.position(header3Len);
                writeSrt4Chars(subWriter);
                writeSrt5Expansions(subWriter);
                if (sort.isMulti()) {
                        for (int i = 0; i <= sort.getMaxPage(); i++)
                                srt8Starts.add(-1);
                        writeSrt8(subWriter);
                        writeSrt7(subWriter);
                }
                subWriter.close();

                // Header 2 is just after the real header
                writer.position(header.getHeaderLength());
                header.writeHeader2(writer);

                // Header 3 is after the description
                writer.position(header.getHeaderLength() + description.length() + 1 + SRTHeader.HEADER2_LEN);
                header.writeHeader3(writer);

                header.writeHeader(writer);
        }

        private void writeDescription(ImgFileWriter writer) {
                writer.position(header.getHeaderLength() + SRTHeader.HEADER2_LEN);
                writer.put(description.getBytes(Charset.forName("ascii")));
                writer.put1u( 0);
                header.endDescription(writer.position());
        }

        /**
         * Write SRT4 the character table.
         *
         * @param writer The img file writer.
         */
        private void writeSrt4Chars(ImgFileWriter writer) {
                for (int i = 1; i < 256; i++) {
                        writer.put1u(sort.getFlags(i));
                        writeWeights(writer, i);
                }
                header.endCharTable(writer.position());
        }

        private void writeWeights(ImgFileWriter writer, int i) {
                int primary = sort.getPrimary(i);
                int secondary = sort.getSecondary(i);
                int tertiary = sort.getTertiary(i);
                if (isMulti) {
                        assert primary <= 0xffff : primary;
                        assert secondary <= 0xff : secondary;
                        assert tertiary <= 0xff : tertiary;
                        writer.put2u(primary);
                        writer.put1u(secondary);
                        writer.put1u(tertiary);
                } else {
                        assert primary <= 0xff : primary;
                        assert secondary <= 0xf : secondary;
                        assert tertiary <= 0xf : tertiary;
                        writer.put1u(primary);
                        writer.put1u((tertiary << 4) | (secondary & 0xf));
                }
        }

        /**
         * Write SRT5, the expansion table.
         *
         * Write out the expansion table. This is referenced from the character table, when
         * the top nibble of the type is set via the primary position value.
         */
        private void writeSrt5Expansions(ImgFileWriter writer) {

                int size = sort.getExpansionSize();
                for (int j = 1; j <= size; j++) {
                        CodePosition b = sort.getExpansion(j);
                        if (isMulti) {
                                writer.put2u(b.getPrimary());
                                writer.put1u(b.getSecondary());
                                writer.put1u(b.getTertiary());
                        } else {
                                writer.put1u(b.getPrimary());
                                writer.put1u((b.getTertiary() << 4) | (b.getSecondary() & 0xf));
                        }
                }

                header.endTab2(writer.position());
        }

        private void writeSrt7(SectionWriter writer) {
                assert sort.isMulti();
                for (int i = 1; i <= sort.getMaxPage(); i++) {
                        writer.put4(srt8Starts.get(i));
                }
                header.endSrt7(writer.position());
        }

        private void writeSrt8(SectionWriter writer) {
                assert sort.isMulti();

                int offset = 0;
                for (int p = 1; p <= sort.getMaxPage(); p++) {
                        if (sort.hasPage(p)) {
                                srt8Starts.set(p, offset);
                                for (int j = 0; j < 256; j++) {
                                        int ch = p * 256 + j;
                                        writer.put1u(sort.getFlags(ch));
                                        writeWeights(writer, ch);
                                        offset += 5;
                                }
                        }
                }
                header.endSrt8(writer.position());
        }

        public void setSort(Sort sort) {
                this.sort = sort;
                header = new SRTHeader(sort.getHeaderLen());
                header.setSort(sort);
                description = sort.getDescription();
                isMulti = sort.isMulti();
        }
}