Ruben’s blog

#!/usr/bin/perl -w
 
# this small program starts a http daeomon listening on port 1111 and provides a RSS feed
# to all .mp4 files stored in the 'videos' folder. 
# This program is intended to transfer movie files via wireless. Using the sony psp RSS feed utility
# 1. Start the server with ./rssstandaloneserver.pl 
# 2. Copy some video files on videos subfolder
# 3. Point you PSP browser to the http://<address>:<port>/ and the psp browser will display a page to
# subscribe to the feed. 
# 4. Go to Psp->Network->RSS Channel and select the new feed 
# 5. A list of items should appear and pressing X will download the video files to your VIDEO folder
#     on the PSP memory stick
# Please note that depending of your firmware and the encoder you used on your files PSP may refuse
# to play those files from the VIDEO folder. The VIDEO folder is not just like the MP_ROOT/100ANV01 
# folder, it behaves a different way. So please first check and transfer some of your files via USB to the 
# VIDEO folder and check that the PSP is able to play them from there. 
# If you encode your files using the Media Manager for PSP software then those files will work in any folder. 
# If you use 3GP encoder and QVGA MPEG-4 then those also will work in the VIDEO folder. but if you use 
# another resolution or AVC codec then it won't work. 
use HTTP::Daemon;
use HTTP::Status;
use XML::RSS;
use MP4::Info;
use File::stat;
use Time::localtime;
use URI::Escape;
use Encode;
use LWP::MediaTypes;
 
 
#configuration
my $feedtitle = "Perl Video Feed";
my $feeddesc = "ecerulm perl video feed";
my $hostname = "192.168.1.3";
my $port = 1111;
my $debug = 1;
#end of configuration
 
 
my $rootaddr="http://" . $hostname . ":" . $port;
my $ct = "video/m4v";
 
LWP::MediaTypes::add_type($ct => qw(mp4 MP4));
 
 
my $d = HTTP::Daemon->new(LocalPort => $port) || die;
 
print "Please contact me at: <URL:", $d->url, ">\n";
while (my $c = $d->accept) {
      while (my $r = $c->get_request) {	      
 
	      my $url = URI::Escape::uri_unescape($r->url->path);
		  print $r->method . " " . "$url\n" if $debug;	      
          if ($r->method eq 'GET' and $url eq "/") {
		      print "sending index.htm\n";              
              $c->send_file_response("index.htm");
          } elsif ($url eq "/index.rss") {
		         print "generating RSS content\n";
          		 my $rss = new XML::RSS (version => '2.0');
				 $rss->channel(title          => $feedtitle,
				               link           => $rootaddr,
				               description    => $feeddesc,
				               );
 
				 $rss->image(title       => 'Perl video feed',
				             url         => $rootaddr . "/images/feedimage.jpg",
				             link        => $rootaddr,
				             width       => 88,
				             height      => 115,
				             description => 'feed logo'
				             );
 
 
				 # videos
				 my @fileList = <videos/*.MP4>;
				 foreach $file (@fileList) {	 
				    my $tag = get_mp4tag($file) or die "No TAG info";
				    $date_string = ctime(stat($file)->mtime);
 
					#my $enclosurelink = "http://192.168.1.3:1111/" . URI::Escape::uri_escape_utf8($file);
					my $enclosurelink = $rootaddr . "/" . URI::Escape::uri_escape_utf8($tag->{NAM}) . ".MP4";
					#my $enclosurelink =~ s/videos%2F/videos\//;
				    $rss->add_item(title => $tag->{NAM},
					        enclosure   => { 
							    url=>$enclosurelink, 								
								type=>$ct,								
						    },
					        description => $tag->{NAM},
					        pubDate=>$date_string
 
				            );
                } 
				 # or save it to a file
				 my $rs = new HTTP::Response(RC_OK);
				 $rs->header('Content-type', "application/rss+xml");
				 $rs->content($rss->as_string) if $r->method eq 'GET';				 
				 $c->send_response($rs);
				 print "RSS content sent\n" if $debug;
 
		  } elsif (-e "." . $url) {
                print "the $url maps directly to a file in the filesystem\n" if $debug;		  
		        if ($r->method eq 'GET') {
					print  "sending " . $r->method . " " . $url . "\n";		              
			        $c->send_file_response("." . $url) if $r->method eq 'GET';
				} else {
					print "sending HEAD " . $url . "\n";
					$c->send_basic_header;
	                print $c "Content-type: $ct\n\n";
				}	
		  } else {
		      print "$url doesn't map to file directly. We assume the url is the movie title\n" if $debug;
		      my $t = $url;			  
			  $t = Encode::decode("UTF-8", $t);			  
              $t = substr($t,1,-4); #remove the ".mp4" part. 
			  print "looking for a file with movie title: $t\n" if $debug;
 
 
              my @files = <videos/*.MP4>;
			  my $found = 0;
			  foreach $f (@files) {	 
			     my $tag = get_mp4tag($f) or next;				 
				 if ($tag->{NAM} eq $t) {
					print  "sending " . $f . " file\n";		              
				    $c->send_file_response($f);
					$found = 1;
					last;
				 }				 
			  }
			  unless ($found) {
			      print "cannot find " . $url . " using method " . $r->method . "\n";
	              $c->send_error(RC_NOT_FOUND);
			  }
          }
      }
      $c->close;
      undef($c);
}

        use MP4::Info;
        my $file = 'MAQ12331.MP4';
 
        my $tag = get_mp4tag($file) or die "No TAG info";
        printf "$file title:%s encoder: %s\n", $tag->{NAM}, $tag->{TOO};

use MP4::Info;
        my $file = 'MAQ12033.MP4';
 
        my $tag = get_mp4tag($file) or die "No TAG info";
        printf "$file title is %s\n", $tag->{NAM};
 
        my $info = get_mp4info($file);
        printf "$file title is %s\n", $info->{NAM};
 
        my $mp4 = new MP4::Info $file;
        printf "$file title is %s\n", $mp4->title;

+/*********
+
+     PSP USMT->MTDT meta info block format  (some guessing)
+     
+        - Note that clips play fine without this block.
+     
+     int32    : size of MTDT block
+     char[4]  : "MTDT"
+     int16    : Number of sub-data blocks (payloads)
+                    0x0001 EOT markers have 1 block
+                    0x0004 is the most I've seen in an information block (title, date, etc)
+     
+     Some number of data blocks, which take the form of:
+     
+        int16   : size of sub-data block
+        int32   : block type ID  (possibly 2 int16s:  unk & type )
+                    0x01 = Title
+                    0x03 = Timestamp (date format = "+%Y-%m-%d %k:%M:%S")
+                    0x04 = Creator Name
+                    0x0A = End of Track Marker
+                    0x0B = UNKNOWN (appears in info MTDT blocks)
+        int16   : ?flags? - generally 0x55c4 or 0x15c7, seen 0x2a0e, possibly font or language?)
+                    - Timestamp seems to always have 0x55c4
+        int16   : type of payload that follows?  (int, string, etc..?)
+                    - Unicode strings have 0x0001
+                    - short[] data has 0x0000
+        data[]  : Payload (strings are UTF16-BE short[] with 0x0000 terminator)
+        
+        
+        BLOCK IDs
+        
+           0x000A - Appear at end of tracks
+                
+                - flags always = 0x55c4
+                - Payload looks like: 0x0000 0x0100 0x0000 0x0000
+                
+           0x000B - Appears in meta data
+                - Payload looks like: 0x0000 0x?????  
+                - (0x???? probably flags- seen 0x1c02, 0x5cfe.  Maybe something with aspect ratio or frame rate?)
+        
+********/