git-svn-id: http://svn.sourceforge.jp/svnroot/lipsync@4 b1f601f4-4f45-0410-8980-aecacb008692

trunk/LipSync/Editor/TimeTable/TimeTable.cs

@@ -0,0 +1,538 @@
+/*
+ * TimeTable.cs
+ * Copyright (c) 2007-2009 kbinani
+ *
+ * This file is part of LipSync.
+ *
+ * LipSync is free software; you can redistribute it and/or
+ * modify it under the terms of the BSD License.
+ *
+ * LipSync 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.
+ */
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.IO;
+using System.Runtime.Serialization;
+
+using CurveEditor;
+
+namespace LipSync {
+
+    [Serializable]
+    public class TimeTable : IDisposable, ICloneable, IDrawObject {
+        private List<TimeTableEntry> list;
+        private string stringValue;
+        private int type;
+        [Obsolete]
+        private Image image;
+        private Point position;
+        private int intValue;
+        private int m_zOrder;
+        private float scale;
+        [OptionalField]
+        public BezierChain mc_x;
+        [OptionalField]
+        public BezierChain mc_y;
+        [OptionalField]
+        public BezierChain mc_scale;
+        [OptionalField]
+        public BezierChain mc_alpha;
+        [OptionalField]
+        public BezierChain mc_rotate;
+        /// <summary>
+        /// aviをはっつけるモード
+        /// </summary>
+        [OptionalField]
+        private bool m_avi_mode = false;
+        [OptionalField]
+        private string m_avi_config = "";
+        [NonSerialized]
+        private AviReaderEx m_avi_reader;
+        [NonSerialized]
+        private bool m_avi_reader_opened = false;
+        [OptionalField]
+        private bool m_position_fixed = false;
+        [OptionalField]
+        private Bitmap m_image;
+
+        /// <summary>
+        /// aviファイルのOpen時に許される失敗回数
+        /// </summary>
+        const int THRESHOLD_FAILED = 10;
+
+        public bool IsXFixedAt( float time ) {
+            float min, max;
+            if ( mc_x.GetKeyMinMax( out min, out max ) ) {
+                if ( min <= time && time <= max ) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public bool IsYFixedAt( float time ) {
+            float min, max;
+            if ( mc_y.GetKeyMinMax( out min, out max ) ) {
+                if ( min <= time && time <= max ) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 描画オブジェクトの位置が固定されるかどうかを示す値を取得，または設定します
+        /// </summary>
+        public bool PositionFixed {
+            get {
+                return m_position_fixed;
+            }
+            set {
+                m_position_fixed = value;
+            }
+        }
+
+        [Browsable(false)]
+        public Size ImageSize {
+            get {
+                if ( m_avi_mode ) {
+                    if ( m_avi_reader.Opened ) {
+                        return m_avi_reader.BitmapSize;
+                    }
+                } else {
+                    if ( m_image != null ) {
+                        return m_image.Size;
+                    }
+                }
+                return new Size();
+            }
+        }
+
+        public string GetAviPath() {
+            if ( !m_avi_mode ) {
+                return "";
+            } else {
+                string[] spl = m_avi_config.Split( "\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries );
+                if ( spl.Length > 0 ) {
+                    return spl[0];
+                } else {
+                    return "";
+                }
+            }
+        }
+
+        [Browsable(false)]
+        public string AviConfig {
+            get {
+                return m_avi_config;
+            }
+        }
+
+        [Browsable(false)]
+        public bool IsAviMode {
+            get {
+                return m_avi_mode;
+            }
+        }
+
+        public void SetAvi( string avi_config ) {
+            m_avi_mode = true;
+            m_avi_config = avi_config;
+            string avi_file = GetAviPath();
+            /*if ( m_bmp != null ) {
+                m_bmp = null; //.Dispose();
+            }*/
+            if ( m_avi_reader != null ) {
+                if ( m_avi_reader.Opened ) {
+                    m_avi_reader.Close();
+                    m_avi_reader = null;
+                    m_avi_reader = new AviReaderEx();
+                }
+            } else {
+                m_avi_reader = new AviReaderEx();
+            }
+            if ( m_avi_reader.NumFailed < THRESHOLD_FAILED ) {
+                if ( File.Exists( avi_file ) ) {
+                    m_avi_reader.Open( avi_file );
+                    m_avi_reader_opened = true;
+#if DEBUG
+                    Common.DebugWriteLine( "TimeTable.SetAvi; avi_file exists" );
+#endif
+                }
+            }
+        }
+
+        public void SetImage( Image img ) {
+            /*if ( m_bmp != null ) {
+                //m_bmp.Dispose();
+                m_bmp = null;
+            }*/
+#if DEBUG
+            Common.DebugWriteLine( "TimeTable.SetImage; before clone from argument \"img\"" );
+            try {
+                int i = image.Width;
+            } catch {
+            }
+#endif
+            if ( img != null ) {
+                m_image = new Bitmap( img );
+            }
+#if DEBUG
+            Common.DebugWriteLine( "TimeTable.SetImage; after cloned from argument \"img\"" );
+            try {
+                int i = image.Width;
+            } catch {
+            }
+#endif
+            m_avi_mode = false;
+            if ( m_avi_reader_opened ) {
+                if ( m_avi_reader.Opened ) {
+                    m_avi_reader.Close();
+                }
+                m_avi_reader_opened = false;
+            }
+        }
+
+        public Bitmap GetImage( float time ) {
+#if DEBUG
+            Common.DebugWriteLine( "TimeTable.GetImage(float); m_avi_mode=" + m_avi_mode );
+#endif
+            if ( m_avi_mode ) {
+#if DEBUG
+                Common.DebugWriteLine( "TimeTable.GetImage(float); m_avi_reader_opened=" + m_avi_reader_opened );
+#endif
+                if ( !m_avi_reader_opened ) {
+                    if ( m_avi_reader == null ) {
+                        m_avi_reader = new AviReaderEx();
+                    }
+                    if ( File.Exists( GetAviPath() ) ) {
+                        try {
+                            m_avi_reader.Open( GetAviPath() );
+                            m_avi_reader_opened = m_avi_reader.Opened;
+                        } catch {
+
+                        }
+                    }
+                }
+                if ( m_avi_reader_opened ) {
+                    bool found = false;
+                    float dt = 0f;
+                    for ( int i = 0; i < list.Count; i++ ) {
+                        if ( list[i].begin <= time && time <= list[i].end ) {
+                            dt = time - list[i].begin;
+                            found = true;
+                            break;
+                        }
+                    }
+#if DEBUG
+                    Common.DebugWriteLine( "TimeTable.GetImage(float); found=" + found );
+#endif
+                    if ( found ) {
+                        int frame = (int)((double)m_avi_reader.dwRate / (double)m_avi_reader.dwScale * dt);
+                        if ( 0 <= frame && frame < m_avi_reader.CountFrames ) {
+                            return m_avi_reader.Export( frame );
+                        }
+                    }
+                }
+                return null;
+            } else {
+                if ( m_image != null ) {
+                    return m_image;
+                } else {
+                    return null;
+                }
+            }
+        }
+
+        public PointF GetPosition( float time ) {
+            return new PointF( mc_x.GetValue( time ), mc_y.GetValue( time ) );
+        }
+        
+        public float GetScale( float time ) {
+            return mc_scale.GetValue( time );
+        }
+        
+        public float GetAlpha( float time ) {
+            float a = mc_alpha.GetValue( time );
+            if ( a > 1f ) {
+                a = 1f;
+            } else if ( a < 0f ) {
+                a = 0f;
+            }
+            return a;
+        }
+        
+        public float GetRotate( float time ) {
+            float r = mc_rotate.GetValue( time );
+            if ( r > 360f ) {
+                r = r % 360f;
+            } else if ( r < 0f ) {
+                r = r % 360f + 360f;
+            }
+            return r;
+        }
+
+        [OnDeserialized]
+        private void onDeserialized( StreamingContext sc ) {
+            if ( type == 3 ) {
+                type = (int)TimeTableType.character;
+            }
+
+            if ( mc_x == null ) {
+                mc_x = new BezierChain( Common.CURVE_X );
+                mc_x.Default = position.X;
+            }
+            if ( mc_y == null ) {
+                mc_y = new BezierChain( Common.CURVE_Y );
+                mc_y.Default = position.Y;
+            }
+            if ( mc_scale == null ) {
+                mc_scale = new BezierChain( Common.CURVE_SCALE );
+                mc_scale.Default = scale;
+            }
+            if ( mc_alpha == null ) {
+                mc_alpha = new BezierChain( Common.CURVE_ALPHA );
+                mc_alpha.Default = 1.0f;
+            }
+            if ( mc_rotate == null ) {
+                mc_rotate = new BezierChain( Common.CURVE_ROTATE );
+            }
+            mc_x.Color = Common.CURVE_X;
+            mc_y.Color = Common.CURVE_Y;
+            mc_scale.Color = Common.CURVE_SCALE;
+            mc_alpha.Color = Common.CURVE_ALPHA;
+            if ( image != null ) {
+                m_image = new Bitmap( image );
+                image.Dispose();
+            }
+        }
+
+        public float Scale {
+            get {
+                return mc_scale.Default;
+            }
+            set {
+                mc_scale.Default = value;
+            }
+        }
+        
+        /// <summary>
+        /// 時刻nowにOnとなっているエントリが存在するかどうかを判定します
+        /// </summary>
+        /// <param name="now"></param>
+        /// <returns></returns>
+        public bool IsOn( float now ) {
+            foreach ( TimeTableEntry entry in list ) {
+                if ( entry.begin <= now && now <= entry.end ) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        
+        public void Dispose() {
+            if ( list != null ) {
+                list.Clear();
+            }
+            if ( image != null ) {
+                image.Dispose();
+            }
+            if ( m_image != null ) {
+                m_image.Dispose();
+            }
+            if ( mc_x != null ) {
+                mc_x.Dispose();
+            }
+            if ( mc_y != null ) {
+                mc_y.Dispose();
+            }
+            if ( mc_alpha != null ) {
+                mc_alpha.Dispose();
+            }
+            if ( mc_rotate != null ) {
+                mc_rotate.Dispose();
+            }
+            if ( mc_scale != null ) {
+                mc_scale.Dispose();
+            }
+            if ( m_avi_reader != null ) {
+                if ( m_avi_reader.Opened ) {
+                    m_avi_reader.Close();
+                }
+            }
+        }
+        
+        public void Remove( TimeTableEntry item ) {
+            int index = -1;
+            for ( int i = 0; i < list.Count; i++ ) {
+                if ( list[i].begin == item.begin && list[i].end == item.end && list[i].body == item.body ) {
+                    index = i;
+                    break;
+                }
+            }
+            if ( index >= 0 ) {
+                list.RemoveAt( index );
+            }
+        }
+        
+        public object Clone() {
+            TimeTable tmp = new TimeTable( stringValue, intValue, this.Type, m_image );
+            for ( int i = 0; i < list.Count; i++ ) {
+                tmp.list.Add( (TimeTableEntry)list[i].Clone() );
+            }
+            tmp.position = position;
+            tmp.intValue = intValue;
+            tmp.m_zOrder = m_zOrder;
+            tmp.scale = scale;
+            tmp.mc_alpha = (BezierChain)this.mc_alpha.Clone();
+            tmp.mc_rotate = (BezierChain)this.mc_rotate.Clone();
+            tmp.mc_scale = (BezierChain)this.mc_scale.Clone();
+            tmp.mc_x = (BezierChain)this.mc_x.Clone();
+            tmp.mc_y = (BezierChain)this.mc_y.Clone();
+            tmp.m_avi_config = this.m_avi_config;
+            tmp.m_avi_mode = this.m_avi_mode;
+            tmp.m_avi_reader = new AviReaderEx();
+            tmp.m_avi_reader_opened = false;
+            tmp.m_position_fixed = this.m_position_fixed;
+            return tmp;
+        }
+
+        [Browsable(false)]
+        public TimeTableType Type {
+            get {
+                foreach ( TimeTableType t in Enum.GetValues( System.Type.GetType( "LipSync.TimeTableType" ) ) ) {
+                    if ( (int)t == type ) {
+                        return t;
+                    }
+                }
+                return TimeTableType.none;
+            }
+            set {
+                type = (int)value;
+            }
+        }
+
+        public void Sort() {
+            list.Sort();
+        }
+                
+        public void RemoveAt( int entry ) {
+            list.RemoveAt( entry );
+        }
+        
+        public TimeTable( string stringValue, int intValue, TimeTableType type, Bitmap image )
+            : this( stringValue, intValue, type, image, 1f ) {
+        }
+
+        public TimeTable( string stringValue, int intValue, TimeTableType type, Bitmap img, float scale ) {
+            this.list = new List<TimeTableEntry>();
+            this.stringValue = stringValue;
+            this.type = (int)type;
+            if ( img != null ) {
+                m_image =(Bitmap)img.Clone();
+            } else {
+                m_image = null;
+            }
+            this.intValue = intValue;
+            this.position = new Point( 0, 0 );
+            this.scale = scale;
+            this.m_zOrder = 0;
+            mc_x = new BezierChain( Common.CURVE_X );
+            mc_y = new BezierChain( Common.CURVE_Y );
+            mc_scale = new BezierChain( Common.CURVE_SCALE );
+            mc_scale.Default = 1f;
+            mc_alpha = new BezierChain( Common.CURVE_ALPHA );
+            mc_alpha.Default = 1f;
+            mc_rotate = new BezierChain( Common.CURVE_ROTATE );
+            m_avi_reader = new AviReaderEx();
+            m_avi_reader_opened = false;
+        }
+
+        [Browsable(false)]
+        public int ZOrder {
+            get {
+                return m_zOrder;
+            }
+            set {
+                m_zOrder = value;
+            }
+        }
+
+        [Browsable(false)]
+        public int Value {
+            get {
+                return intValue;
+            }
+            set {
+                intValue = value;
+            }
+        }
+
+        public string Text {
+            get {
+                return stringValue;
+            }
+            set {
+                stringValue = value;
+            }
+        }
+
+        [Browsable(false)]
+        public Bitmap Image {
+            get {
+                return m_image;
+            }
+        }
+
+        [Browsable(false)]
+        public int Count {
+            get {
+                return list.Count;
+            }
+        }
+
+        public void Clear() {
+            list.Clear();
+        }
+
+        [Browsable(false)]
+        public TimeTableEntry this[int entry] {
+            get {
+                return list[entry];
+            }
+            set {
+                list[entry] = (TimeTableEntry)value;
+            }
+        }
+
+        public void Add( TimeTableEntry entry ) {
+            list.Add( entry );
+        }
+        
+        [Browsable(false)]
+        public Point Position {
+            get {
+                return new Point( (int)mc_x.Default, (int)mc_y.Default );
+            }
+            set {
+                mc_x.Default = value.X;
+                mc_y.Default = value.Y;
+            }
+        }
+
+        public Position Location {
+            get {
+                return new Position( mc_x.Default, mc_y.Default );
+            }
+            set {
+                mc_x.Default = value.X;
+                mc_y.Default = value.Y;
+            }
+        }
+    }
+    
+}

trunk/LipSync/Editor/TimeTable/TimeTableEntry.cs

@@ -0,0 +1,70 @@
+/*
+ * TimeTableEntry.cs
+ * Copyright (c) 2007-2009 kbinani
+ *
+ * This file is part of LipSync.
+ *
+ * LipSync is free software; you can redistribute it and/or
+ * modify it under the terms of the BSD License.
+ *
+ * LipSync 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.
+ */
+using System;
+
+namespace LipSync {
+
+    [Serializable]
+    public class TimeTableEntry : IComparable<TimeTableEntry>, IDisposable, ICloneable {
+        public float begin;
+        public float end;
+        public string body;
+
+        public TimeTableEntry() {
+            begin = 0.0f;
+            end = 0.0f;
+            body = "";
+        }
+
+        public float Length {
+            get {
+                return end - begin;
+            }
+        }
+
+        public void Dispose() {
+            this.body = null;
+        }
+
+        public object Clone() {
+            return new TimeTableEntry( begin, end, body );
+        }
+
+        public int CompareTo( TimeTableEntry obj ) {
+            double diff = this.begin - obj.begin;
+            if ( this.begin == obj.begin ) {
+                return 0;
+            } else if ( diff > 0.0f ) {
+                return 1;
+            } else {
+                return -1;
+            }
+        }
+
+        public bool Equals( TimeTableEntry obj ) {
+            if ( this.begin == obj.begin ) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        public TimeTableEntry( float begin, float end, string body ) {
+            this.begin = begin;
+            this.end = end;
+            this.body = body;
+        }
+    }
+
+}

trunk/LipSync/Editor/TimeTable/TimeTableType.cs

@@ -0,0 +1,27 @@
+/*
+ * TimeTableType.cs
+ * Copyright (c) 2007-2009 kbinani
+ *
+ * This file is part of LipSync.
+ *
+ * LipSync is free software; you can redistribute it and/or
+ * modify it under the terms of the BSD License.
+ *
+ * LipSync 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.
+ */
+namespace LipSync {
+
+    public enum TimeTableType {
+        vsq = 0,
+        another = 1,
+        character = 2,
+        plugin = 4,
+        none = 5,
+        top = 6,
+        telop = 7,
+        whole = 8,
+    }
+
+}