Changeset 203

Show
Ignore:
Timestamp:
03/23/08 00:48:12 (10 months ago)
Author:
Stuart Thiel
Message:

-Fixed #162, #167, #164
-A major structural change was to further abstract from the type of player. We now have Media, and the factory dynamically loads stuff based on values in the MyResources?.properties file. It loads based on file extension and OS, which means we can use different players in different OSs, meaning we could play video in Linux if I had a plugin... maybe I'll find something...
-Lots of stuff got changed when we changed the general name of what we worked with from Movie to Media.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • MediAnnotate/trunk/src/org/mediannotate/app/MAController.java

    r173 r203  
    1212import javax.swing.filechooser.FileFilter; 
    1313 
    14 import org.mediannotate.dom.Movie; 
    15 import org.mediannotate.dom.MovieFactory; 
     14import org.mediannotate.dom.Media; 
     15import org.mediannotate.dom.MediaException; 
     16import org.mediannotate.dom.MediaFactory; 
    1617 
    1718 
     
    4647                                // TODO Auto-generated method stub 
    4748                                try { 
    48                                         Pattern p = Pattern.compile("^.*\\.(avi|mov|mpg)$", Pattern.CASE_INSENSITIVE); 
     49                                        Pattern p = Pattern.compile(MediaFactory.getAcceptedExpressionPattern(), Pattern.CASE_INSENSITIVE); 
    4950                                        Matcher m = p.matcher(f.getCanonicalPath()); 
    5051                                        return m.matches() || f.isDirectory(); 
    5152                                } catch (IOException e) { 
     53                                        // TODO Auto-generated catch block 
     54                                        e.printStackTrace(); 
     55                                } catch (Exception e) { 
    5256                                        // TODO Auto-generated catch block 
    5357                                        e.printStackTrace(); 
     
    7983                synchronized (mutex) { 
    8084 
    81                         Movie previousMovie = myPlayerPanel.getCurrentMovie(); 
     85                        Media previousMovie = myPlayerPanel.getCurrentMovie(); 
    8286                         
    83                         myPlayerPanel.displayMovie(MovieFactory.getMovie(url)); 
     87                        try { 
     88                                myPlayerPanel.displayMovie(MediaFactory.getMedia(url)); 
     89                        } catch (MediaException e) { 
     90                                // TODO Auto-generated catch block 
     91                                e.printStackTrace(); 
     92                        } 
    8493                         
    8594                        if(previousMovie != null) { 
  • MediAnnotate/trunk/src/org/mediannotate/app/PlayerPanel.java

    r184 r203  
    1515import javax.swing.JPanel; 
    1616 
    17 import org.mediannotate.dom.IMovieObserver; 
    18 import org.mediannotate.dom.Movie
     17import org.mediannotate.dom.IMediaObserver; 
     18import org.mediannotate.dom.Media
    1919import org.mediannotate.ui.TimeLinePanel; 
    2020import org.mediannotate.ui.UtilityPanel; 
     
    2626import quicktime.QTException; 
    2727 
    28 public class PlayerPanel extends JPanel implements IMovieObserver, KeyListener, ComponentListener, MouseListener{ 
     28public class PlayerPanel extends JPanel implements IMediaObserver, KeyListener, ComponentListener, MouseListener{ 
    2929        /** 
    3030         *  
     
    3535        private TimeLinePanel timeLinePanel = new TimeLinePanel(); 
    3636        private UtilityPanel utilityPanel; 
    37         private Component currentMovieComponent; 
     37        private Component currentMediaComponent; 
    3838        private JPanel moviePanel = new JPanel(); 
    39         Movie currentMovie
     39        Media currentMedia
    4040 
    4141         
     
    6060        } 
    6161 
    62         public Movie getCurrentMovie() { 
    63                 return currentMovie
     62        public Media getCurrentMovie() { 
     63                return currentMedia
    6464        } 
    6565         
     
    7474         */ 
    7575        public long getTime() { 
    76                 return currentMovie.getTime(); 
     76                return currentMedia.getTime(); 
    7777        } 
    7878 
     
    8585         * @param m 
    8686         */ 
    87         public void displayMovie(Movie m) { 
     87        public void displayMovie(Media m) { 
    8888                 
    8989                try { 
    9090                        if(oldMovieComponent != null) { 
    9191                                moviePanel.remove(oldMovieComponent); 
    92                                 currentMovie.removeMovieObserver(this); 
     92                                currentMedia.removeMediaObserver(this); 
    9393                        } 
    9494                } catch (Exception e) { 
     
    9696                } 
    9797 
    98                 currentMovie = m; 
    99                 if(currentMovie != null) { 
    100                         currentMovie.addMovieObserver(this); 
    101                         currentMovieComponent = m.getComponent(); 
    102                         oldMovieComponent = currentMovieComponent; 
    103                         Dimension newD = getAspectRespectingDimension(moviePanel.getSize(), currentMovieComponent.getPreferredSize()); 
    104                         currentMovieComponent.setBounds((moviePanel.getWidth()-newD.width)/2 , (moviePanel.getHeight()-newD.height)/2, newD.width, newD.height); 
    105          
    106                         moviePanel.add(currentMovieComponent); 
    107                         currentMovieComponent.setVisible(true); 
     98                currentMedia = m; 
     99                if(currentMedia != null) { 
     100                        currentMedia.addMediaObserver(this); 
     101                        currentMediaComponent = m.getComponent(); 
     102                        oldMovieComponent = currentMediaComponent; 
     103                        Dimension newD = currentMedia.getAspectRespectingDimension(moviePanel.getSize()); 
     104                        currentMediaComponent.setBounds((moviePanel.getWidth()-newD.width)/2 , (moviePanel.getHeight()-newD.height)/2, newD.width, newD.height); 
     105         
     106                        moviePanel.add(currentMediaComponent); 
     107                        currentMediaComponent.setVisible(true); 
    108108                        moviePanel.repaint(); 
    109                         durationTime = new Time(currentMovie.getDuration()); 
    110                         utilityPanel.setDuration(currentMovie.getDuration()); 
     109                        durationTime = new Time(currentMedia.getDuration()); 
     110                        utilityPanel.setDuration(currentMedia.getDuration()); 
    111111                         
    112                         stopListener.setMovie(currentMovie); 
    113                         playListener.setMovie(currentMovie); 
    114                         timeLineListener.setMovie(currentMovie); 
     112                        stopListener.setMovie(currentMedia); 
     113                        playListener.setMovie(currentMedia); 
     114                        timeLineListener.setMovie(currentMedia); 
    115115                } 
    116116                 
     
    157157         
    158158        public void notifyOfMovieChange() { 
    159                 setTime(currentMovie.getTime()); 
     159                setTime(currentMedia.getTime()); 
    160160                try { 
    161                         currentMovie.redraw(); 
     161                        currentMedia.redraw(); 
    162162                } catch (QTException e) { 
    163163                        // TODO Auto-generated catch block 
    164164                        e.printStackTrace(); 
     165                } catch (Exception e) { 
     166                        // TODO Auto-generated catch block 
     167                        e.printStackTrace(); 
    165168                } 
    166169        } 
     
    168171        public long getInTime() { 
    169172                if(!getTimeLinePanel().isInActive()) return 0; 
    170                 return currentMovie.getIn(); 
     173                return currentMedia.getIn(); 
    171174        } 
    172175         
    173176        public long getOutTime() { 
    174177                if(!getTimeLinePanel().isOutActive()) return durationTime.getAllInMilli(); 
    175                 return currentMovie.getOut(); 
     178                return currentMedia.getOut(); 
    176179        } 
    177180         
    178181        public void setInTime(long time) { 
    179182                getTimeLinePanel().setIn(time/(float)durationTime.getAllInMilli()); 
    180                 currentMovie.setIn(time); 
     183                currentMedia.setIn(time); 
    181184        } 
    182185         
    183186        public void setOutTime(long time) { 
    184187                getTimeLinePanel().setOut(time/(float)durationTime.getAllInMilli()); 
    185                 currentMovie.setOut(time); 
     188                currentMedia.setOut(time); 
    186189        } 
    187190         
     
    213216        public void componentResized(ComponentEvent e) { 
    214217                if(oldMovieComponent!=null) { 
    215                         Dimension newD = getAspectRespectingDimension(moviePanel.getSize(), currentMovieComponent.getPreferredSize()); 
    216                         currentMovieComponent.setBounds((moviePanel.getWidth()-newD.width)/2 , (moviePanel.getHeight()-newD.height)/2, newD.width, newD.height); 
     218                        Dimension newD = currentMedia.getAspectRespectingDimension(moviePanel.getSize()); 
     219                        currentMediaComponent.setBounds((moviePanel.getWidth()-newD.width)/2 , (moviePanel.getHeight()-newD.height)/2, newD.width, newD.height); 
    217220                        repaint(); 
    218221                } 
    219222        } 
    220223 
    221         public static Dimension getAspectRespectingDimension(Dimension outter, Dimension inner) { 
    222                 float aspectRatio = inner.width/(float)inner.height; 
    223                 if(outter.width/aspectRatio < outter.height) { 
    224                         return new Dimension(outter.width, (int)(outter.width/aspectRatio)); 
    225                 } else { 
    226                         return new Dimension((int)(outter.height*aspectRatio), outter.height); 
    227                 } 
    228                  
    229         } 
     224 
    230225 
    231226        public void mouseClicked(MouseEvent e) { 
  • MediAnnotate/trunk/src/org/mediannotate/dom/IMediaObserver.java

    r116 r203  
    11package org.mediannotate.dom; 
    22 
    3 public interface IMovieObserver { 
     3public interface IMediaObserver { 
    44        public void notifyOfMovieChange(); 
    55} 
  • MediAnnotate/trunk/src/org/mediannotate/dom/IMediaSubscriber.java

    r145 r203  
    11package org.mediannotate.dom; 
    22 
    3 public interface IMovieSubscriber { 
    4         public void addMovieObserver(IMovieObserver observer); 
    5         public void removeMovieObserver(IMovieObserver observer); 
     3public interface IMediaSubscriber { 
     4        public void addMediaObserver(IMediaObserver observer); 
     5        public void removeMediaObserver(IMediaObserver observer); 
    66        public void notifyOfChange(); 
    77} 
  • MediAnnotate/trunk/src/org/mediannotate/dom/Media.java

    r150 r203  
    22 
    33import java.awt.Component; 
     4import java.awt.Dimension; 
     5import java.io.BufferedInputStream; 
     6import java.io.BufferedOutputStream; 
     7import java.io.File; 
     8import java.io.FileOutputStream; 
     9import java.io.IOException; 
     10import java.net.MalformedURLException; 
     11import java.net.URL; 
     12import java.net.URLDecoder; 
     13import java.util.HashMap; 
    414 
    5 import quicktime.QTException
     15import org.mediannotate.app.MediAnnotater
    616 
    7 public interface Movie extends IMovieSubscriber
     17public abstract class Media extends MediaSubscriber
    818 
    919        /** 
     
    1121         * @return 
    1222         */ 
    13         public long getTime(); 
    14         public void setTime(long time); 
    15         public void setIn(long time); 
    16         public void setOut(long time); 
    17         public long getIn(); 
    18         public long getOut(); 
    19         public boolean shouldStopPlaying(); 
    20         public long getDuration(); 
    21         public void start(); 
    22         public void stop(); 
    23         public Component getComponent(); 
    24         public void dispose(); 
    25         public boolean isPlaying(); 
    26         public void redraw() throws QTException; 
     23        public abstract long getTime(); 
     24        private static HashMap<String, File> knownFiles = new HashMap<String, File>(); 
     25        protected File mediaFile; 
     26         
     27         
     28        public Media(String media_url) throws MediaException{ 
     29                try { 
     30                        String original_url = media_url; 
     31                         
     32 
     33                        if(knownFiles.containsKey(original_url)) { 
     34                                mediaFile = knownFiles.get(original_url); 
     35                        } else { 
     36                         
     37                                mediaFile = new File(URLDecoder.decode(media_url, "UTF-8").replaceAll("file:\\\\*(.*)", "$1")); 
     38         
     39                                if(!mediaFile.exists()) { 
     40                                        media_url = new URL(media_url).toExternalForm(); 
     41                         
     42                                        URL myURL = new URL(media_url); 
     43                                        mediaFile = File.createTempFile("vertov_", media_url.replaceFirst("^(.*)(\\..*)$", "$2")); 
     44                                        mediaFile.deleteOnExit(); 
     45                                        MediAnnotater.tempFiles.add(mediaFile); 
     46                                         
     47                                        BufferedInputStream bis = new BufferedInputStream(myURL.openStream()); 
     48                                        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(mediaFile)); 
     49                                        byte[] myBytes = new byte[1024*1024]; 
     50                                        int myByteCount = bis.read(myBytes); 
     51                                        int totalCount = myByteCount; 
     52                                        while(myByteCount != -1) { 
     53                                                System.out.println("We've read: " + totalCount); 
     54                                                bos.write(myBytes, 0, myByteCount); 
     55                                                myByteCount = bis.read(myBytes); 
     56                                                totalCount += myByteCount; 
     57                                        } 
     58                                        System.out.println("We've finished loading the file"); 
     59                         
     60                                        bos.flush(); 
     61                                        bos.close(); 
     62                                        bis.close(); 
     63                                        media_url = mediaFile.getAbsolutePath().replaceFirst("^file:/([^/])", "file://$1"); 
     64                                } 
     65                                knownFiles.put(original_url, mediaFile); 
     66                        } 
     67 
     68                 
     69                } catch (MalformedURLException e1) { 
     70                        e1.printStackTrace(); 
     71                } catch (IOException e) { 
     72                        // TODO Auto-generated catch block 
     73                        e.printStackTrace(); 
     74                }  
     75        } 
     76         
     77        public Dimension getAspectRespectingDimension(Dimension outter) { 
     78                Dimension inner = getComponent().getPreferredSize(); 
     79                float aspectRatio = inner.width/(float)inner.height; 
     80                if(outter.width/aspectRatio < outter.height) { 
     81                        return new Dimension(outter.width, (int)(outter.width/aspectRatio)); 
     82                } else { 
     83                        return new Dimension((int)(outter.height*aspectRatio), outter.height); 
     84                } 
     85        } 
     86         
     87        public abstract void setTime(long time); 
     88        public abstract void setIn(long time); 
     89        public abstract void setOut(long time); 
     90        public abstract long getIn(); 
     91        public abstract long getOut(); 
     92        public abstract boolean shouldStopPlaying(); 
     93        public abstract long getDuration(); 
     94        public abstract void start(); 
     95        public abstract void stop(); 
     96        public abstract Component getComponent(); 
     97        public abstract void dispose(); 
     98        public abstract boolean isPlaying(); 
     99        public abstract void redraw() throws Exception; 
    27100         
    28101} 
  • MediAnnotate/trunk/src/org/mediannotate/dom/MediaFactory.java

    r116 r203  
    11package org.mediannotate.dom; 
    22 
    3 public class MovieFactory { 
     3import java.util.ResourceBundle; 
    44 
    5         public static Movie getMovie(String movie_url) { 
    6                 return new QTMovie(movie_url); 
     5public class MediaFactory { 
     6 
     7        /* 
     8         * These constatnts should have strings that can be matched against available  
     9         * OS strings from System.ge"os.name" 
     10         */ 
     11        private static final String LINUX_OS = "LINUX"; 
     12        private static final String MAC_OS = "Mac OS"; 
     13        private static final String WINDOWS_OS = "Windows"; 
     14         
     15        private static final String osProperty = System.getProperty("os.name"); 
     16         
     17        private static String os = null; 
     18        private static String extension_pattern = null; 
     19        private static final String LINUX = "linux"; 
     20        private static final String MAC = "mac"; 
     21        private static final String WINDOWS = "windows"; 
     22        public static Media getMedia(String media_url) throws MediaException{ 
     23                String extension = findExtensionFromURL(media_url); 
     24                 
     25                 
     26                System.out.println(extension); 
     27                 
     28                try { 
     29                        String className = ResourceBundle.getBundle("MyResources").getString(getOS()+extension); 
     30                        return (Media) Class.forName(className).getConstructor(String.class).newInstance(media_url); 
     31                } catch (Exception e) { 
     32                        throw new MediaException(e); 
     33                } 
     34 
     35        } 
     36         
     37         
     38         
     39        private static String getOS() { 
     40                if(os == null) { 
     41                        if(osProperty.contains(MAC_OS)) os = MAC;  
     42                        else if(osProperty.contains(LINUX_OS)) os = LINUX; 
     43                        else if(osProperty.contains(WINDOWS_OS)) os = WINDOWS; 
     44                } 
     45                return os; 
     46        } 
     47         
     48        private static String findExtensionFromURL(String url) { 
     49                return url.substring(url.lastIndexOf('.')); 
     50        } 
     51         
     52        public static String getAcceptedExpressionPattern() { 
     53                if(extension_pattern == null) { 
     54                        extension_pattern = ResourceBundle.getBundle("MyResources").getString("extension_"+getOS()); 
     55                } 
     56                return extension_pattern; 
    757        } 
    858         
  • MediAnnotate/trunk/src/org/mediannotate/dom/MediaSubscriber.java

    r145 r203  
    33import java.util.LinkedList; 
    44 
    5 public class MovieSubscriber implements IMovieSubscriber { 
     5public class MediaSubscriber implements IMediaSubscriber { 
    66 
    7         LinkedList<IMovieObserver> observers = new LinkedList<IMovieObserver>(); 
     7        LinkedList<IMediaObserver> observers = new LinkedList<IMediaObserver>(); 
    88         
    9         public void addMovieObserver(IMovieObserver observer) { 
     9        public void addMediaObserver(IMediaObserver observer) { 
    1010                observers.add(observer); 
    1111        } 
    1212 
    13         public void removeMovieObserver(IMovieObserver observer) { 
     13        public void removeMediaObserver(IMediaObserver observer) { 
    1414                observers.remove(observer); 
    1515        } 
    1616         
    1717        public void notifyOfChange() { 
    18                 for(IMovieObserver o: observers) { 
     18                for(IMediaObserver o: observers) { 
    1919                        o.notifyOfMovieChange(); 
    2020                } 
  • MediAnnotate/trunk/src/org/mediannotate/dom/QTMovie.java

    r186 r203  
    22 
    33import java.awt.Component; 
    4 import java.io.BufferedInputStream; 
    5 import java.io.BufferedOutputStream; 
    6 import java.io.File; 
    7 import java.io.FileOutputStream; 
    8 import java.io.IOException; 
    9 import java.net.MalformedURLException; 
    10 import java.net.URL; 
    11 import java.net.URLDecoder; 
    12 import java.util.HashMap; 
    134 
    145import org.mediannotate.app.MAController; 
    15 import org.mediannotate.app.MediAnnotater; 
    166 
    177import quicktime.QTException; 
     
    2414 
    2515 
    26 public class QTMovie extends MovieSubscriber implements org.mediannotate.dom.Movie
     16public class QTMovie extends org.mediannotate.dom.Media
    2717 
    28         private quicktime.std.movies.Movie innerMovie; 
     18        protected quicktime.std.movies.Movie innerMovie; 
    2919        private MoviePlayer innerMoviePlayer; 
    3020        private long inTime; 
    3121        private long outTime; 
    3222        private boolean startedPlayingAfterOutTime; 
    33         private static HashMap<String, File> knownFiles = new HashMap<String, File>(); 
    34          
    35         public QTMovie(String url) { 
    3623 
    37                  
     24        public QTMovie(String url) throws MediaException { 
     25                super(url); 
    3826                try { 
    39                         String original_url = url; 
    40                          
    41                         File f = null; 
    42  
    43                         if(knownFiles.containsKey(original_url)) { 
    44                                 f = knownFiles.get(original_url); 
    45                         } else { 
    46                          
    47                                 f = new File(URLDecoder.decode(url, "UTF-8").replaceAll("file:\\\\*(.*)", "$1")); 
    48          
    49                                 if(!f.exists()) { 
    50                                         url = new URL(url).toExternalForm(); 
    51                          
    52                                         URL myURL = new URL(url); 
    53                                         f = File.createTempFile("vertov_", url.replaceFirst("^(.*)(\\..*)$", "$2")); 
    54                                         f.deleteOnExit(); 
    55                                         MediAnnotater.tempFiles.add(f); 
    56                                          
    57                                         BufferedInputStream bis = new BufferedInputStream(myURL.openStream()); 
    58                                         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(f)); 
    59                                         byte[] myBytes = new byte[1024*1024]; 
    60                                         int myByteCount = bis.read(myBytes); 
    61                                         int totalCount = myByteCount; 
    62                                         while(myByteCount != -1) { 
    63                                                 System.out.println("We've read: " + totalCount); 
    64                                                 bos.write(myBytes, 0, myByteCount); 
    65                                                 myByteCount = bis.read(myBytes); 
    66                                                 totalCount += myByteCount; 
    67                                         } 
    68                                         System.out.println("We've finished loading the file"); 
    69                          
    70                                         bos.flush(); 
    71                                         bos.close(); 
    72                                         bis.close(); 
    73                                         url = f.getAbsolutePath().replaceFirst("^file:/([^/])", "file://$1"); 
    74                                 } 
    75                                 knownFiles.put(original_url, f); 
    76                         } 
    7727                        innerMovie = quicktime.std.movies.Movie.fromFile( 
    78                                 OpenMovieFile.asRead( 
    79                                 new QTFile(f))); 
    80                  
    81                 } catch (MalformedURLException e1) { 
    82                         e1.printStackTrace(); 
    83                 } catch (IOException e) { 
    84                         // TODO Auto-generated catch block 
    85                         e.printStackTrace(); 
    86                 } catch (QTException e) { 
    87                         // TODO Auto-generated catch block 
    88                         e.printStackTrace(); 
    89                 } 
    90                  
    91                 System.out.println("Playing: " + url); 
    92                 try { 
    93                          
     28                                        OpenMovieFile.asRead( 
     29                                        new QTFile(mediaFile))); 
     30                        System.out.println("Playing: " + url); 
    9431                        innerMoviePlayer = new MoviePlayer(innerMovie); 
    95  
    96                 } catch (QTException e) { 
    97                         e.printStackTrace(); 
     32                     
     33                } catch (QTException e1) { 
     34                        throw new MediaException(e1); 
    9835                } 
    9936        } 
     
    10542                } catch (QTException e) { 
    10643                        e.printStackTrace(); 
     44                        System.out.println(e.errorCodeToString()); 
     45                        System.out.println(e.getMessage()); 
    10746                } 
    10847                throw new NullPointerException(); 
  • MediAnnotate/trunk/src/org/mediannotate/ui/listener/PlayButtonListener.java

    r116 r203  
    44import java.awt.event.ActionListener; 
    55 
    6 import org.mediannotate.dom.Movie
     6import org.mediannotate.dom.Media
    77 
    88public class PlayButtonListener implements ActionListener { 
    99 
    10         private Movie innerMovie; 
     10        private Media innerMovie; 
    1111 
    12         public void setMovie(Movie m) { 
     12        public void setMovie(Media m) { 
    1313                innerMovie = m; 
    1414        } 
  • MediAnnotate/trunk/src/org/mediannotate/ui/listener/StopButtonListener.java

    r116 r203  
    44import java.awt.event.ActionListener; 
    55 
    6 import org.mediannotate.dom.Movie
     6import org.mediannotate.dom.Media
    77 
    88public class StopButtonListener implements ActionListener { 
    99 
    10         private Movie innerMovie; 
     10        private Media innerMovie; 
    1111 
    12         public void setMovie(Movie m) { 
     12        public void setMovie(Media m) { 
    1313                innerMovie = m; 
    1414        } 
  • MediAnnotate/trunk/src/org/mediannotate/ui/listener/TimeLineListener.java

    r150 r203  
    77import java.awt.event.MouseMotionListener; 
    88 
    9 import org.mediannotate.dom.Movie
     9import org.mediannotate.dom.Media
    1010import org.mediannotate.ui.TimeLinePanel; 
    1111 
    1212public class TimeLineListener implements MouseListener, MouseMotionListener { 
    1313 
    14         private Movie innerMovie; 
     14        private Media innerMovie; 
    1515        private TimeLinePanel myTimeLine = null; 
    1616         
    17         public void setMovie(Movie m) { 
     17        public void setMovie(Media m) { 
    1818                innerMovie = m; 
    1919        }