annotate libmpdemux/demux_mov.c @ 6501:827f08ddf044

Allow writing to pipe.

�     1 //#define USE_QTX_CODECS
�     2 
�     3 //  QuickTime MOV file parser by A'rpi
�     4 //  additional work by Atmos
�     5 //  based on TOOLS/movinfo.c by A'rpi & Al3x
�     6 //  compressed header support from moov.c of the openquicktime lib.
�     7 //  References: http://openquicktime.sf.net/, http://www.heroinewarrior.com/
�     8 //  http://www.geocities.com/SiliconValley/Lakes/2160/fformats/files/mov.pdf
�     9 //  (above url no longer works, file mirrored somewhere? ::atmos)
�    10 //  The QuickTime File Format PDF from Apple:
�    11 //  http://developer.apple.com/techpubs/quicktime/qtdevdocs/PDF/QTFileFormat.pdf
�    12 //  (Complete list of documentation at http://developer.apple.com/quicktime/)
�    13 //  MP4-Lib sources from http://mpeg4ip.sf.net/ might be usefull fot .mp4
�    14 //  aswell as .mov specific stuff.
�    15 //  All sort of Stuff about MPEG4:
�    16 //  http://www.cmlab.csie.ntu.edu.tw/~pkhsiao/thesis.html
�    17 //  I really recommend N4270-1.doc and N4270-2.doc which are exact specs
�    18 //  of the MP4-File Format and the MPEG4 Specific extensions. ::atmos
�    19 
�    20 #include <stdio.h>
�    21 #include <stdlib.h>
�    22 #include <unistd.h>
�    23 
�    24 #include "config.h"
�    25 #include "mp_msg.h"
�    26 #include "help_mp.h"
�    27 
�    28 #include "stream.h"
�    29 #include "demuxer.h"
�    30 #include "stheader.h"
�    31 
�    32 #include "bswap.h"
�    33 
�    34 #include "qtpalette.h"
�    35 #include "parse_mp4.h" // MP3 specific stuff
�    36 
�    37 #ifdef USE_QTX_CODECS
�    38 #include "../loader/qtx/qtxsdk/components.h"
�    39 #endif
�    40 
�    41 #ifdef HAVE_ZLIB
�    42 #include <zlib.h>
�    43 #endif
�    44 
�    45 // inclusion of fcntl.h cause cygwin gcc crash
�    46 #ifndef __CYGWIN__
�    47 #include <fcntl.h>
�    48 #endif
�    49 
�    50 #define BE_16(x) (be2me_16(*(unsigned short *)(x)))
�    51 #define BE_32(x) (be2me_32(*(unsigned int *)(x)))
�    52 
�    53 #ifndef WORDS_BIGENDIAN
�    54 #define char2short(x,y) ((x[y]<<8)|x[y+1])
�    55 #define char2int(x,y) ((x[y]<<24)|(x[y+1]<<16)|(x[y+2]<<8)|x[y+3])
�    56 #else
�    57 #warning Check the implementation of char2short and char2int on BIGENDIAN!!!
�    58 #define char2short(x,y) (x[y]|(x[y+1]<<8))
�    59 #define char2int(x,y) (x[y]|(x[y+1]<<8)|(x[y+2]<<16)|(x[y+3]<<24))
�    60 #endif
�    61 
�    62 typedef struct {
�    63     unsigned int pts; // duration
�    64     unsigned int size;
�    65     off_t pos;
�    66 } mov_sample_t;
�    67 
�    68 typedef struct {
�    69     unsigned int sample; // number of the first sample in the chunk
�    70     unsigned int size;   // number of samples in the chunk
�    71     int desc;            // for multiple codecs mode - not used
�    72     off_t pos;
�    73 } mov_chunk_t;
�    74 
�    75 typedef struct {
�    76     unsigned int first;
�    77     unsigned int spc;
�    78     unsigned int sdid;
�    79 } mov_chunkmap_t;
�    80 
�    81 typedef struct {
�    82     unsigned int num;
�    83     unsigned int dur;
�    84 } mov_durmap_t;
�    85 
�    86 #define MOV_TRAK_UNKNOWN 0
�    87 #define MOV_TRAK_VIDEO 1
�    88 #define MOV_TRAK_AUDIO 2
�    89 #define MOV_TRAK_FLASH 3
�    90 #define MOV_TRAK_GENERIC 4
�    91 #define MOV_TRAK_CODE 5
�    92 
�    93 typedef struct {
�    94     int id;
�    95     int type;
�    96     off_t pos;
�    97     //
�    98     int timescale;
�    99     unsigned int length;
�   100     int samplesize;  // 0 = variable
�   101     int duration;    // 0 = variable
�   102     int width,height; // for video
�   103     unsigned int fourcc;
�   104     //
�   105     int tkdata_len;  // track data 
�   106     unsigned char* tkdata;
�   107     int stdata_len;  // stream data
�   108     unsigned char* stdata;
�   109     //
�   110     unsigned char* stream_header;
�   111     int stream_header_len; // if >0, this header should be sent before the 1st frame
�   112     //
�   113     int samples_size;
�   114     mov_sample_t* samples;
�   115     int chunks_size;
�   116     mov_chunk_t* chunks;
�   117     int chunkmap_size;
�   118     mov_chunkmap_t* chunkmap;
�   119     int durmap_size;
�   120     mov_durmap_t* durmap;
�   121     int keyframes_size;
�   122     unsigned int* keyframes;
�   123     //
�   124     void* desc; // image/sound/etc description (pointer to ImageDescription etc)
�   125 } mov_track_t;
�   126 
�   127 void mov_build_index(mov_track_t* trak){
�   128     int i,j,s;
�   129     int last=trak->chunks_size;
�   130     unsigned int pts=0;
�   131 
�   132 #if 0
�   133     if (trak->chunks_size <= 0)
�   134     {
�   135 	mp_msg(MSGT_DEMUX, MSGL_WARN, "No chunk offset table, trying to build one!\n");
�   136 	
�   137 	trak->chunks_size = trak->samples_size; /* XXX: FIXME ! */
�   138 	trak->chunks = realloc(trak->chunks, sizeof(mov_chunk_t)*trak->chunks_size);
�   139 	
�   140 	for (i=0; i < trak->chunks_size; i++)
�   141 	    trak->chunks[i].pos = -1;
�   142     }
�   143 #endif
�   144 
�   145     mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV track #%d: %d chunks, %d samples\n",trak->id,trak->chunks_size,trak->samples_size);
�   146     mp_msg(MSGT_DEMUX, MSGL_V, "pts=%d  scale=%d  time=%5.3f\n",trak->length,trak->timescale,(float)trak->length/(float)trak->timescale);
�   147 
�   148     // process chunkmap:
�   149     i=trak->chunkmap_size;
�   150     while(i>0){
�   151 	--i;
�   152 	for(j=trak->chunkmap[i].first;j<last;j++){
�   153 	    trak->chunks[j].desc=trak->chunkmap[i].sdid;
�   154 	    trak->chunks[j].size=trak->chunkmap[i].spc;
�   155 	}
�   156 	last=trak->chunkmap[i].first;
�   157     }
�   158 
�   159 #if 0
�   160     for (i=0; i < trak->chunks_size; i++)
�   161     {
�   162 	/* fixup position */
�   163 	if (trak->chunks[i].pos == -1)
�   164 	    if (i > 0)
�   165 		trak->chunks[i].pos = trak->chunks[i-1].pos + trak->chunks[i-1].size;
�   166 	    else
�   167 		trak->chunks[i].pos = 0; /* FIXME: set initial pos */
�   168     }
�   169 #endif
�   170 
�   171     // calc pts of chunks:
�   172     s=0;
�   173     for(j=0;j<trak->chunks_size;j++){
�   174         trak->chunks[j].sample=s;
�   175         s+=trak->chunks[j].size;
�   176     }
�   177 
�   178     // workaround for fixed-size video frames (dv and uncompressed)
�   179     if(!trak->samples_size && trak->type==MOV_TRAK_VIDEO){
�   180 	trak->samples_size=s;
�   181 	trak->samples=malloc(sizeof(mov_sample_t)*s);
�   182 	for(i=0;i<s;i++)
�   183 	    trak->samples[i].size=trak->samplesize;
�   184 	trak->samplesize=0;
�   185     }
�   186 
�   187     if(!trak->samples_size){
�   188 	// constant sampesize
�   189 	if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){
�   190 	    trak->duration=trak->durmap[0].dur;
�   191 	} else mp_msg(MSGT_DEMUX, MSGL_ERR, "*** constant samplesize & variable duration not yet supported! ***\nContact the author if you have such sample file!\n");
�   192 	return;
�   193     }
�   194     
�   195     // calc pts:
�   196     s=0;
�   197     for(j=0;j<trak->durmap_size;j++){
�   198 	for(i=0;i<trak->durmap[j].num;i++){
�   199 	    trak->samples[s].pts=pts;
�   200 	    ++s;
�   201 	    pts+=trak->durmap[j].dur;
�   202 	}
�   203     }
�   204     
�   205     // calc sample offsets
�   206     s=0;
�   207     for(j=0;j<trak->chunks_size;j++){
�   208 	off_t pos=trak->chunks[j].pos;
�   209 	for(i=0;i<trak->chunks[j].size;i++){
�   210 	    trak->samples[s].pos=pos;
�   211 	    mp_msg(MSGT_DEMUX, MSGL_DBG3, "Sample %5d: pts=%8d  off=0x%08X  size=%d\n",s,
�   212 		trak->samples[s].pts,
�   213 		(int)trak->samples[s].pos,
�   214 		trak->samples[s].size);
�   215 	    pos+=trak->samples[s].size;
�   216 	    ++s;
�   217 	}
�   218     }
�   219 
�   220 }
�   221 
�   222 #define MOV_MAX_TRACKS 256
�   223 
�   224 typedef struct {
�   225     off_t moov_start;
�   226     off_t moov_end;
�   227     off_t mdat_start;
�   228     off_t mdat_end;
�   229     int track_db;
�   230     mov_track_t* tracks[MOV_MAX_TRACKS];
�   231 } mov_priv_t;
�   232 
�   233 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d))
�   234 
�   235 int mov_check_file(demuxer_t* demuxer){
�   236     int flags=0;
�   237     int no=0;
�   238     mov_priv_t* priv=malloc(sizeof(mov_priv_t));
�   239     
�   240     mp_msg(MSGT_DEMUX,MSGL_V,"Checking for MOV\n");
�   241     
�   242     memset(priv,0,sizeof(mov_priv_t));
�   243     demuxer->priv=priv;
�   244     
�   245     while(1){
�   246 	int skipped=8;
�   247 	off_t len=stream_read_dword(demuxer->stream);
�   248 	unsigned int id=stream_read_dword(demuxer->stream);
�   249 	if(stream_eof(demuxer->stream)) break; // EOF
�   250 	if (len == 1) /* real size is 64bits - cjb */
�   251 	{
�   252 #ifndef _LARGEFILE_SOURCE
�   253 	    if (stream_read_dword(demuxer->stream) != 0)
�   254 		mp_msg(MSGT_DEMUX, MSGL_WARN, "64bit file, but you've compiled MPlayer without LARGEFILE support!\n");
�   255 	    len = stream_read_dword(demuxer->stream);
�   256 #else
�   257 	    len = stream_read_qword(demuxer->stream);
�   258 #endif
�   259 	    skipped += 8;
�   260 	}
�   261 #if 0
�   262 	else if (len == 0) /* deleted chunk */
�   263 	{
�   264 	    /* XXX: CJB! is this right? - alex */
�   265 	    goto skip_chunk;
�   266 	}
�   267 #endif
�   268 	else if(len<8) break; // invalid chunk
�   269 
�   270 	switch(id){
�   271 	case MOV_FOURCC('f','t','y','p'): {
�   272 	  int i;					      
�   273 	  unsigned int tmp;
�   274 	  // File Type Box (ftyp): 
�   275 	  // char[4]  major_brand	   (eg. 'isom')
�   276 	  // int      minor_version	   (eg. 0x00000000)
�   277 	  // char[4]  compatible_brands[]  (eg. 'mp41')
�   278 	  // compatible_brands list spans to the end of box
�   279 #if 1
�   280 	  tmp = stream_read_dword(demuxer->stream);
�   281 	  switch(tmp) {
�   282 	    case MOV_FOURCC('i','s','o','m'):
�   283 	      mp_msg(MSGT_DEMUX,MSGL_V,"MOV: File-Type Major-Brand: ISO Media File\n");
�   284      	      break;
�   285 	    default:
�   286 	      tmp = be2me_32(tmp);  
�   287 	      mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: File-Type unknown Major-Brand: %.4s\n",&tmp);
�   288 	  }
�   289 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: File-Type Minor-Version: %d\n",
�   290 	      stream_read_dword(demuxer->stream));
�   291 	  skipped += 8;
�   292 	  // List all compatible brands
�   293 	  for(i = 0; i < ((len-16)/4); i++) {
�   294 	    tmp = be2me_32(stream_read_dword(demuxer->stream));
�   295 	    mp_msg(MSGT_DEMUX,MSGL_V,"MOV: File-Type Compatible-Brands #%d: %.4s\n",i,&tmp);
�   296 	    skipped += 4;
�   297 	  }
�   298 #endif	  
�   299 	  } break;
�   300 	case MOV_FOURCC('m','o','o','v'):
�   301 //	case MOV_FOURCC('c','m','o','v'):
�   302 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie header found!\n");
�   303 	  priv->moov_start=(off_t)stream_tell(demuxer->stream);
�   304 	  priv->moov_end=(off_t)priv->moov_start+len-skipped;
�   305 	  mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: Movie header: start: %x end: %x\n",
�   306 	    priv->moov_start, priv->moov_end);
�   307 	  flags|=1;
�   308 	  break;
�   309 	case MOV_FOURCC('w','i','d','e'):
�   310 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: 'WIDE' chunk found!\n");
�   311 	  if(flags&2) break;
�   312 	case MOV_FOURCC('m','d','a','t'):
�   313 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie DATA found!\n");
�   314 	  priv->mdat_start=stream_tell(demuxer->stream);
�   315 	  priv->mdat_end=priv->mdat_start+len-skipped;
�   316 	  mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: Movie data: start: %x end: %x\n",
�   317 	    priv->mdat_start, priv->mdat_end);
�   318 	  flags|=2;
�   319 	  break;
�   320 	case MOV_FOURCC('f','r','e','e'):
�   321 	case MOV_FOURCC('s','k','i','p'):
�   322 	case MOV_FOURCC('j','u','n','k'):
�   323 	  mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: free space (len: %d)\n", len);
�   324 	  /* unused, if you edit a mov, you can use space provided by free atoms (redefining it) */
�   325 	  break;
�   326 	default:
�   327 	  if(no==0) return 0; // first chunk is bad!
�   328 	  id = be2me_32(id);
�   329 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len);
�   330 	}
�   331 skip_chunk:
�   332 	if(!stream_skip(demuxer->stream,len-skipped)) break;
�   333 	++no;
�   334     }
�   335     
�   336     if(flags==1)
�   337 	mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing data (mdat) chunk! Maybe broken file...\n");
�   338     else if(flags==2)
�   339 	mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing header (moov/cmov) chunk! Maybe broken file...\n");
�   340 
�   341 return (flags==3);
�   342 }
�   343 
�   344 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){
�   345     mov_priv_t* priv=demuxer->priv;
�   346 //    printf("lschunks (level=%d,endpos=%x)\n", level, endpos);
�   347     while(1){
�   348 	off_t pos;
�   349 	off_t len;
�   350 	unsigned int id;
�   351 	//
�   352 	pos=stream_tell(demuxer->stream);
�   353 //	printf("stream_tell==%d\n",pos);
�   354 	if(pos>=endpos) return; // END
�   355 	len=stream_read_dword(demuxer->stream);
�   356 //	printf("len==%d\n",len);
�   357 	if(len<8) return; // error
�   358 	len-=8;
�   359 	id=stream_read_dword(demuxer->stream);
�   360 	//
�   361 	mp_msg(MSGT_DEMUX,MSGL_DBG2,"lschunks %.4s  %d\n",&id,(int)len);
�   362 	//
�   363 	if(trak){
�   364 	  switch(id){
�   365 	    case MOV_FOURCC('m','d','a','t'): {
�   366 		mp_msg(MSGT_DEMUX,MSGL_WARN,"Hmm, strange MOV, parsing mdat in lschunks?\n");
�   367 		return;
�   368 	    }
�   369 	    case MOV_FOURCC('f','r','e','e'):
�   370 	    case MOV_FOURCC('u','d','t','a'):
�   371 		/* here not supported :p */
�   372 		break;
�   373 	    case MOV_FOURCC('t','k','h','d'): {
�   374 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sTrack header!\n",level,"");
�   375 		// read codec data
�   376 		trak->tkdata_len=len;
�   377 		trak->tkdata=malloc(trak->tkdata_len);
�   378 		stream_read(demuxer->stream,trak->tkdata,trak->tkdata_len);
�   379 		break;
�   380 	    }
�   381 	    case MOV_FOURCC('m','d','h','d'): {
�   382 		unsigned int tmp;
�   383 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia header!\n",level,"");
�   384 #if 0
�   385 		tmp=stream_read_dword(demuxer->stream);
�   386 		printf("dword1: 0x%08X (%d)\n",tmp,tmp);
�   387 		tmp=stream_read_dword(demuxer->stream);
�   388 		printf("dword2: 0x%08X (%d)\n",tmp,tmp);
�   389 		tmp=stream_read_dword(demuxer->stream);
�   390 		printf("dword3: 0x%08X (%d)\n",tmp,tmp);
�   391 		tmp=stream_read_dword(demuxer->stream);
�   392 		printf("dword4: 0x%08X (%d)\n",tmp,tmp);
�   393 		tmp=stream_read_dword(demuxer->stream);
�   394 		printf("dword5: 0x%08X (%d)\n",tmp,tmp);
�   395 		tmp=stream_read_dword(demuxer->stream);
�   396 		printf("dword6: 0x%08X (%d)\n",tmp,tmp);
�   397 #endif
�   398 		stream_skip(demuxer->stream,12);
�   399 		// read timescale
�   400 		trak->timescale=stream_read_dword(demuxer->stream);
�   401 		// read length
�   402 		trak->length=stream_read_dword(demuxer->stream);
�   403 		break;
�   404 	    }
�   405 	    case MOV_FOURCC('v','m','h','d'): {
�   406 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sVideo header!\n",level,"");
�   407 		trak->type=MOV_TRAK_VIDEO;
�   408 		// read video data
�   409 		break;
�   410 	    }
�   411 	    case MOV_FOURCC('s','m','h','d'): {
�   412 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSound header!\n",level,"");
�   413 		trak->type=MOV_TRAK_AUDIO;
�   414 		// read audio data
�   415 		break;
�   416 	    }
�   417 	    case MOV_FOURCC('g','m','h','d'): {
�   418 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sGeneric header!\n",level,"");
�   419 		trak->type=MOV_TRAK_GENERIC;
�   420 		break;
�   421 	    }
�   422 	    case MOV_FOURCC('n','m','h','d'): {
�   423 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sGeneric header!\n",level,"");
�   424 		trak->type=MOV_TRAK_GENERIC;
�   425 		break;
�   426 	    }
�   427 	    case MOV_FOURCC('s','t','s','d'): {
�   428 		int i=stream_read_dword(demuxer->stream); // temp!
�   429 		int count=stream_read_dword(demuxer->stream);
�   430 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sDescription list! (cnt:%d)\n",level,"",count);
�   431 		for(i=0;i<count;i++){
�   432 		    off_t pos=stream_tell(demuxer->stream);
�   433 		    off_t len=stream_read_dword(demuxer->stream);
�   434 		    unsigned int fourcc=stream_read_dword_le(demuxer->stream);
�   435 		    if(len<8) break; // error
�   436 		    mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s desc #%d: %.4s  (%d bytes)\n",level,"",i,&fourcc,len-16);
�   437 		    if(!i){
�   438 			trak->fourcc=fourcc;
�   439 			// read type specific (audio/video/time/text etc) header
�   440 			// NOTE: trak type is not yet known at this point :(((
�   441 			trak->stdata_len=len-8;
�   442 			trak->stdata=malloc(trak->stdata_len);
�   443 			stream_read(demuxer->stream,trak->stdata,trak->stdata_len);
�   444 		    }
�   445 		    if(fourcc!=trak->fourcc && i)
�   446 			mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVvariableFourCC);
�   447 		    if(!stream_seek(demuxer->stream,pos+len)) break;
�   448 		}
�   449 		break;
�   450 	    }
�   451 	    case MOV_FOURCC('s','t','t','s'): {
�   452 		int temp=stream_read_dword(demuxer->stream);
�   453 		int len=stream_read_dword(demuxer->stream);
�   454 		int i;
�   455 		int x=0;
�   456 		unsigned int pts=0;
�   457 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample duration table! (%d blocks)\n",level,"",len);
�   458 		trak->durmap=malloc(sizeof(mov_durmap_t)*len);
�   459 		memset(trak->durmap,0,sizeof(mov_durmap_t)*len);
�   460 		trak->durmap_size=len;
�   461 		for(i=0;i<len;i++){
�   462 		    trak->durmap[i].num=stream_read_dword(demuxer->stream);
�   463 		    trak->durmap[i].dur=stream_read_dword(demuxer->stream);
�   464 		    pts+=trak->durmap[i].num*trak->durmap[i].dur;
�   465 		}
�   466 		if(trak->length!=pts) mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! pts=%d  length=%d\n",pts,trak->length);
�   467 		break;
�   468 	    }
�   469 	    case MOV_FOURCC('s','t','s','c'): {
�   470 		int temp=stream_read_dword(demuxer->stream);
�   471 		int len=stream_read_dword(demuxer->stream);
�   472 		int ver = (temp << 24);
�   473 		int flags = (temp << 16)|(temp<<8)|temp;
�   474 		int i;
�   475 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample->Chunk mapping table!  (%d blocks) (ver:%d,flags:%ld)\n",
�   476 		    level,"",len,ver,flags);
�   477 		// read data:
�   478 		trak->chunkmap_size=len;
�   479 		trak->chunkmap=malloc(sizeof(mov_chunkmap_t)*len);
�   480 		for(i=0;i<len;i++){
�   481 		    trak->chunkmap[i].first=stream_read_dword(demuxer->stream)-1;
�   482 		    trak->chunkmap[i].spc=stream_read_dword(demuxer->stream);
�   483 		    trak->chunkmap[i].sdid=stream_read_dword(demuxer->stream);
�   484 		}
�   485 		break;
�   486 	    }
�   487 	    case MOV_FOURCC('s','t','s','z'): {
�   488 		int temp=stream_read_dword(demuxer->stream);
�   489 		int ss=stream_read_dword(demuxer->stream);
�   490 		int ver = (temp << 24);
�   491 		int flags = (temp << 16)|(temp<<8)|temp;
�   492 		int entries=stream_read_dword(demuxer->stream);
�   493 		int i;
�   494 		
�   495 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%ld)\n",
�   496 		    level,"",entries,ss,ver,flags);
�   497 		trak->samplesize=ss;
�   498 		if (!ss) {
�   499 		  // variable samplesize
�   500 		  trak->samples=realloc(trak->samples,sizeof(mov_sample_t)*entries);
�   501 		  trak->samples_size=entries;
�   502 		  for(i=0;i<entries;i++)
�   503 		    trak->samples[i].size=stream_read_dword(demuxer->stream);
�   504 		}
�   505 		break;
�   506 	    }
�   507 	    case MOV_FOURCC('s','t','c','o'): {
�   508 		int temp=stream_read_dword(demuxer->stream);
�   509 		int len=stream_read_dword(demuxer->stream);
�   510 		int i;
�   511 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sChunk offset table! (%d chunks)\n",level,"",len);
�   512 		// extend array if needed:
�   513 		if(len>trak->chunks_size){
�   514 		    trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len);
�   515 		    trak->chunks_size=len;
�   516 		}
�   517 		// read elements:
�   518 		for(i=0;i<len;i++) trak->chunks[i].pos=stream_read_dword(demuxer->stream);
�   519 		break;
�   520 	    }
�   521 	    case MOV_FOURCC('c','o','6','4'): {
�   522 		int temp=stream_read_dword(demuxer->stream);
�   523 		int len=stream_read_dword(demuxer->stream);
�   524 		int i;
�   525 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s64bit chunk offset table! (%d chunks)\n",level,"",len);
�   526 		// extend array if needed:
�   527 		if(len>trak->chunks_size){
�   528 		    trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len);
�   529 		    trak->chunks_size=len;
�   530 		}
�   531 		// read elements:
�   532 		for(i=0;i<len;i++)
�   533 		{
�   534 #ifndef	_LARGEFILE_SOURCE
�   535 		    if (stream_read_dword(demuxer->stream) != 0)
�   536 			mp_msg(MSGT_DEMUX, MSGL_WARN, "Chunk %d has got 64bit address, but you've MPlayer compiled without LARGEFILE support!\n", i);
�   537 		    trak->chunks[i].pos = stream_read_dword(demuxer->stream);
�   538 #else
�   539 		    trak->chunks[i].pos = stream_read_qword(demuxer->stream);
�   540 #endif
�   541 		}
�   542 		break;
�   543 	    }
�   544 	    case MOV_FOURCC('s','t','s','s'): {
�   545 		int temp=stream_read_dword(demuxer->stream);
�   546 		int entries=stream_read_dword(demuxer->stream);
�   547 		int ver = (temp << 24);
�   548 		int flags = (temp << 16)|(temp<<8)|temp;
�   549 		int i;
�   550 		mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%ld)\n",
�   551 		    level, "",entries, ver, flags);
�   552 		trak->keyframes_size=entries;
�   553 		trak->keyframes=malloc(sizeof(unsigned int)*entries);
�   554 		for (i=0;i<entries;i++)
�   555 		    trak->keyframes[i]=stream_read_dword(demuxer->stream)-1;
�   556 //		for (i=0;i<entries;i++) printf("%3d: %d\n",i,trak->keyframes[i]);
�   557 		break;
�   558 	    }
�   559 	    case MOV_FOURCC('m','d','i','a'): {
�   560 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia stream!\n",level,"");
�   561 		lschunks(demuxer,level+1,pos+len,trak);
�   562 		break;
�   563 	    }
�   564 	    case MOV_FOURCC('m','i','n','f'): {
�   565 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia info!\n",level,"");
�   566 		lschunks(demuxer,level+1,pos+len,trak);
�   567 		break;
�   568 	    }
�   569 	    case MOV_FOURCC('s','t','b','l'): {
�   570 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample info!\n",level,"");
�   571 		lschunks(demuxer,level+1,pos+len,trak);
�   572 		break;
�   573 	    }
�   574 	    case MOV_FOURCC('e','d','t','s'): {
�   575 		mp_msg(MSGT_DEMUX, MSGL_V, "MOV: %*sEdit atom!\n", level, "");
�   576 		lschunks(demuxer,level+1,pos+len,trak);
�   577 		break;
�   578 	    }
�   579 	    case MOV_FOURCC('e','l','s','t'): {
�   580 		int temp=stream_read_dword(demuxer->stream);
�   581 		int entries=stream_read_dword(demuxer->stream);
�   582 		int ver = (temp << 24);
�   583 		int flags = (temp << 16)|(temp<<8)|temp;
�   584 		int i;
�   585 	
�   586 		mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sEdit list table (%d entries) (ver:%d,flags:%ld)\n",
�   587 		    level, "",entries, ver, flags);
�   588 #if 0
�   589 		for (i=0;i<entries;i++)
�   590 		{
�   591 		    printf("entry#%d: dur: %ld mtime: %ld mrate: %ld\n",
�   592 			i, stream_read_dword(demuxer->stream),
�   593 			stream_read_dword(demuxer->stream),
�   594 			stream_read_dword(demuxer->stream));
�   595 		}
�   596 #endif
�   597 		break;
�   598 	    }
�   599 	    case MOV_FOURCC('c','o','d','e'):
�   600 	    {
�   601 	    /* XXX: Implement atom 'code' for FLASH support */
�   602 	    }
�   603 	    default:
�   604 		id = be2me_32(id);
�   605 		mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len);
�   606 		break;
�   607 	  }//switch(id)
�   608 	} else { /* not in track */
�   609 	  switch(id) {
�   610 	    case MOV_FOURCC('t','r','a','k'): {
�   611 //	    if(trak) printf("MOV: Warning! trak in trak?\n");
�   612 	    if(priv->track_db>=MOV_MAX_TRACKS){
�   613 		mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVtooManyTrk);
�   614 		return;
�   615 	    }
�   616 	    if(!priv->track_db) mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n");
�   617 	    trak=malloc(sizeof(mov_track_t));
�   618 	    memset(trak,0,sizeof(mov_track_t));
�   619 	    mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Track #%d:\n",priv->track_db);
�   620 	    trak->id=priv->track_db;
�   621 	    priv->tracks[priv->track_db]=trak;
�   622 	    lschunks(demuxer,level+1,pos+len,trak);
�   623 	    mov_build_index(trak);
�   624 	    switch(trak->type){
�   625 	    case MOV_TRAK_AUDIO: {
�   626 #if 0				   
�   627 		struct {
�   628 		   int16_t version;		// 0 or 1 (version 1 is qt3.0+)
�   629 		   int16_t revision;		// 0
�   630 		   int32_t vendor_id;		// 0
�   631 		   int16_t channels;		// 1 or 2  (Mono/Stereo)
�   632 		   int16_t samplesize;		// 8 or 16 (8Bit/16Bit)	
�   633 		   int16_t compression_id;	// if version 0 then 0
�   634 		  				// if version 1 and vbr then -2 else 0
�   635 		   int16_t packet_size;		// 0
�   636 		   uint16_t sample_rate;	// samplerate (Hz)
�   637 		   // qt3.0+ (version == 1)
�   638 		   uint32_t samples_per_packet;	// 0 or num uncompressed samples in a packet
�   639 		   				// if 0 below three values are also 0
�   640 		   uint32_t bytes_per_packet;	// 0 or num compressed bytes for one channel
�   641 		   uint32_t bytes_per_frame;	// 0 or num compressed bytes for all channels
�   642 		   				// (channels * bytes_per_packet)
�   643 		   uint32_t bytes_per_sample;	// 0 or size of uncompressed sample
�   644 		   // if samples_per_packet and bytes_per_packet are constant (CBR)
�   645 		   // then bytes_per_frame and bytes_per_sample must be 0 (else is VBR)
�   646 		   // ---
�   647 		   // optional additional atom-based fields
�   648 		   // ([int32_t size,int32_t type,some data ],repeat)
�   649 		} my_stdata;		  
�   650 #endif		
�   651 		sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db);
�   652 		sh->format=trak->fourcc;
�   653 
�   654 // assumptions for below table: short is 16bit, int is 32bit, intfp is 16bit
�   655 // XXX: 32bit fixed point numbers (intfp) are only 2 Byte!		
�   656 // short values are usually one byte leftpadded by zero		
�   657 //   int values are usually two byte leftpadded by zero		
�   658 //  stdata[]:
�   659 //	8   short	version
�   660 //	10  short	revision
�   661 //	12  int		vendor_id
�   662 //	16  short	channels
�   663 //	18  short	samplesize
�   664 //	20  short	compression_id
�   665 //	22  short	packet_size (==0)
�   666 //	24  intfp	sample_rate
�   667 //     (26  short)	unknown (==0)
�   668 //    ---- qt3.0+
�   669 //	28  int		samples_per_packet
�   670 //	32  int		bytes_per_packet
�   671 //	36  int		bytes_per_frame
�   672 //	40  int		bytes_per_sample
�   673 // there may be additional atoms following at 28 (version 0)
�   674 // or 44 (version 1), eg. esds atom of .MP4 files		
�   675 // esds atom:
�   676 //      28  int		atom size (bytes of int size, int type and data)
�   677 //      32  char[4]	atom type (fourc charater code -> esds)		
�   678 //      36  char[]  	atom data (len=size-8)
�   679 
�   680 		sh->samplesize=char2short(trak->stdata,18)/8;
�   681 		sh->channels=char2short(trak->stdata,16);
�   682 		/*printf("MOV: timescale: %d samplerate: %d durmap: %d (%d) -> %d (%d)\n",
�   683 		    trak->timescale, char2short(trak->stdata,24), trak->durmap[0].dur,
�   684 		    trak->durmap[0].num, trak->timescale/trak->durmap[0].dur,
�   685 		    char2short(trak->stdata,24)/trak->durmap[0].dur);*/
�   686 		sh->samplerate=char2short(trak->stdata,24);
�   687 		if((sh->samplerate < 7000) && trak->durmap) {
�   688 		  switch(char2short(trak->stdata,24)/trak->durmap[0].dur) {
�   689 		    // TODO: add more cases.
�   690 		    case 31:
�   691 		      sh->samplerate = 32000; break;
�   692 		    case 43:
�   693 		      sh->samplerate = 44100; break;
�   694 		    case 47:
�   695 		      sh->samplerate = 48000; break;
�   696 		    default:
�   697 		      mp_msg(MSGT_DEMUX, MSGL_WARN,
�   698 			  "MOV: unable to determine audio samplerate, "
�   699 			  "assuming 44.1kHz (got %d)\n",
�   700 			  char2short(trak->stdata,24)/trak->durmap[0].dur);
�   701 		      sh->samplerate = 44100;
�   702 		  }  
�   703 		}  
�   704 
�   705 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Audio bits: %d  chans: %d  rate: %d\n",
�   706 		    trak->stdata[19],trak->stdata[17],sh->samplerate);
�   707 		if((trak->stdata[9]==0) && trak->stdata_len >= 36) { // version 0 with extra atoms
�   708 		    int atom_len = char2int(trak->stdata,28);
�   709 		    switch(char2int(trak->stdata,32)) { // atom type
�   710 		      case MOV_FOURCC('e','s','d','s'): {
�   711 			mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found MPEG4 audio Elementary Stream Descriptor atom (%d)!\n", atom_len);
�   712 			if(atom_len > 8) {
�   713 			  esds_t esds; 				  
�   714 			  if(!mp4_parse_esds(&trak->stdata[36], atom_len-8, &esds)) {
�   715 			    
�   716 			    sh->i_bps = esds.avgBitrate/8; 
�   717 
�   718 			    // dump away the codec specific configuration for the AAC decoder
�   719 			    sh->codecdata_len = esds.decoderConfigLen;
�   720 			    sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
�   721 			    memcpy(sh->codecdata, esds.decoderConfig, sh->codecdata_len);
�   722 			  }
�   723 			  mp4_free_esds(&esds); // freeup esds mem
�   724 #if 0
�   725 	  		  { FILE* f=fopen("esds.dat","wb");
�   726 			  fwrite(&trak->stdata[36],atom_len-8,1,f);
�   727 			  fclose(f); }
�   728 #endif			  
�   729 			}
�   730 		      } break;
�   731 		      default:
�   732 			mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unknown audio atom %c%c%c%c (%d)!\n",
�   733 			    trak->stdata[32],trak->stdata[33],trak->stdata[34],trak->stdata[35],
�   734 			    atom_len);
�   735 		    }
�   736 		}  
�   737 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s\n",&trak->fourcc);
�   738 #if 0
�   739 		{ FILE* f=fopen("stdata.dat","wb");
�   740 		  fwrite(trak->stdata,trak->stdata_len,1,f);
�   741 		  fclose(f); }
�   742 		{ FILE* f=fopen("tkdata.dat","wb");
�   743 		  fwrite(trak->tkdata,trak->tkdata_len,1,f);
�   744 		  fclose(f); }
�   745 #endif
�   746 		// Emulate WAVEFORMATEX struct:
�   747 		sh->wf=malloc(sizeof(WAVEFORMATEX));
�   748 		memset(sh->wf,0,sizeof(WAVEFORMATEX));
�   749 		sh->wf->nChannels=(trak->stdata[16]<<8)+trak->stdata[17];
�   750 		sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19];
�   751 		// sh->wf->nSamplesPerSec=trak->timescale;
�   752 		sh->wf->nSamplesPerSec=(trak->stdata[24]<<8)+trak->stdata[25];
�   753 		sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8;
�   754 		// Selection:
�   755 		if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){
�   756 		    // (auto)selected audio track:
�   757 		    demuxer->audio->id=priv->track_db;
�   758 		    demuxer->audio->sh=sh; sh->ds=demuxer->audio;
�   759 		}
�   760 		break;
�   761 	    }
�   762 	    case MOV_TRAK_VIDEO: {
�   763 		int i, entry;
�   764 		int flag, start, count_flag, end, palette_count;
�   765 		int hdr_ptr = 76;  // the byte just after depth
�   766 		unsigned char *palette_map;
�   767 		sh_video_t* sh=new_sh_video(demuxer,priv->track_db);
�   768 		int depth = trak->stdata[75]|(trak->stdata[74]<<8);
�   769 		sh->format=trak->fourcc;
�   770 
�   771 //  stdata[]:
�   772 //	8   short	version
�   773 //	10  short	revision
�   774 //	12  int		vendor_id
�   775 //	16  int		temporal_quality
�   776 //	20  int		spatial_quality
�   777 //	24  short	width
�   778 //	26  short	height
�   779 //	28  int		h_dpi
�   780 //	32  int		v_dpi
�   781 //	36  int		0
�   782 //	40  short	frames_per_sample
�   783 //	42  char[4]	compressor_name
�   784 //	74  short	depth
�   785 //	76  short	color_table_id
�   786 // additional atoms may follow,
�   787 // eg esds atom from .MP4 files
�   788 //      78  int		atom size
�   789 //      82  char[4]	atom type
�   790 //	86  ...		atom data
�   791 
�   792 #ifdef USE_QTX_CODECS
�   793 	{	ImageDescription* id=malloc(8+trak->stdata_len);
�   794 		trak->desc=id;
�   795 		id->idSize=8+trak->stdata_len;
�   796 		id->cType=trak->fourcc;
�   797 		id->version=char2short(trak->stdata,8);
�   798 		id->revisionLevel=char2short(trak->stdata,10);
�   799 		id->vendor=char2int(trak->stdata,12);
�   800 		id->temporalQuality=char2int(trak->stdata,16);
�   801 		id->spatialQuality=char2int(trak->stdata,20);
�   802 		id->width=char2short(trak->stdata,24);
�   803 		id->height=char2short(trak->stdata,26);
�   804 		id->hRes=char2int(trak->stdata,28);
�   805 		id->vRes=char2int(trak->stdata,32);
�   806 		id->dataSize=char2int(trak->stdata,36);
�   807 		id->frameCount=char2short(trak->stdata,40);
�   808 		memcpy(&id->name,trak->stdata+42,32);
�   809 		id->depth=char2short(trak->stdata,74);
�   810 		id->clutID=char2short(trak->stdata,76);
�   811 		memcpy(((char*)&id->clutID)+2,trak->stdata+78,trak->stdata_len-78);
�   812 		if(1) // debug
�   813 		{   FILE *f=fopen("ImageDescription","wb");
�   814 		    fwrite(id,id->idSize,1,f);
�   815 		    fclose(f);
�   816 		}
�   817 	}
�   818 #endif
�   819 
�   820 		if(trak->stdata_len >= 86) { // extra atoms found
�   821 		  int pos=78;
�   822 		  int atom_len;
�   823 		  while(pos+8<=trak->stdata_len &&
�   824 		    (pos+(atom_len=char2int(trak->stdata,pos)))<=trak->stdata_len){
�   825 		   switch(char2int(trak->stdata,pos+4)) { // switch atom type
�   826 		    case MOV_FOURCC('g','a','m','a'):
�   827 		      // intfp with gamma value at which movie was captured
�   828 		      // can be used to gamma correct movie display
�   829 		      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported Gamma-Correction movie atom (%d)!\n",
�   830 			  atom_len);
�   831 		      break;
�   832 		    case MOV_FOURCC('f','i','e','l'):
�   833 		      // 2 char-values (8bit int) that specify field handling
�   834 		      // see the Apple's QuickTime Fileformat PDF for more info
�   835 		      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported Field-Handling movie atom (%d)!\n",
�   836 			  atom_len);
�   837 		      break;
�   838 		    case MOV_FOURCC('m','j','q','t'):
�   839 		      // Motion-JPEG default quantization table
�   840 		      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported MJPEG-Quantization movie atom (%d)!\n",
�   841 			  atom_len);
�   842 		      break;
�   843 		    case MOV_FOURCC('m','j','h','t'):
�   844 		      // Motion-JPEG default huffman table
�   845 		      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported MJPEG-Huffman movie atom (%d)!\n",
�   846 			  atom_len);
�   847 		      break;
�   848 		    case MOV_FOURCC('e','s','d','s'):
�   849 		      // MPEG4 Elementary Stream Descriptor header
�   850 		      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found MPEG4 movie Elementary Stream Descriptor atom (%d)!\n", atom_len);
�   851 		      // add code here to save esds header of length atom_len-8
�   852 		      // beginning at stdata[86] to some variable to pass it
�   853 		      // on to the decoder ::atmos
�   854 		      if(atom_len > 8) {
�   855       			esds_t esds; 				  
�   856 			if(!mp4_parse_esds(trak->stdata+pos+8, atom_len-8, &esds)) {
�   857     
�   858 			  // dump away the codec specific configuration for the AAC decoder
�   859 			  trak->stream_header_len = esds.decoderConfigLen;
�   860 			  trak->stream_header = (unsigned char *)malloc(trak->stream_header_len);
�   861 			  memcpy(trak->stream_header, esds.decoderConfig, trak->stream_header_len);
�   862 			}
�   863 			mp4_free_esds(&esds); // freeup esds mem
�   864 		      }	      
�   865 		      break;
�   866 		    default:
�   867 	      	      mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unknown movie atom %c%c%c%c (%d)!\n",
�   868 	      		  trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7],
�   869 	      		  atom_len);
�   870 		   }
�   871 		   pos+=atom_len;
�   872 //		   printf("pos=%d max=%d\n",pos,trak->stdata_len);
�   873 		  }
�   874 		}
�   875 		sh->fps=trak->timescale/
�   876 		    ((trak->durmap_size>=1)?(float)trak->durmap[0].dur:1);
�   877 		sh->frametime=1.0f/sh->fps;
�   878 
�   879 		sh->disp_w=trak->stdata[25]|(trak->stdata[24]<<8);
�   880 		sh->disp_h=trak->stdata[27]|(trak->stdata[26]<<8);
�   881 		// if image size is zero, fallback to display size
�   882 		if(!sh->disp_w && !sh->disp_h) {
�   883 		  sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8);
�   884 		  sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8);
�   885 		} else if(sh->disp_w!=(trak->tkdata[77]|(trak->tkdata[76]<<8))){
�   886 		  // codec and display width differ... use display one for aspect
�   887 		  sh->aspect=trak->tkdata[77]|(trak->tkdata[76]<<8);
�   888 		  sh->aspect/=trak->tkdata[81]|(trak->tkdata[80]<<8);
�   889 		}
�   890 		
�   891 		if(depth>32+8) printf("*** depth = 0x%X\n",depth);
�   892 
�   893 		// palettized?
�   894 		depth&=31; // flag 32 means grayscale
�   895 		if ((depth == 2) || (depth == 4) || (depth == 8))
�   896 		  palette_count = (1 << depth);
�   897 		else
�   898 		  palette_count = 0;
�   899 
�   900 		// emulate BITMAPINFOHEADER:
�   901 		if (palette_count)
�   902 		{
�   903 		  sh->bih=malloc(sizeof(BITMAPINFOHEADER) + palette_count * 4);
�   904 		  memset(sh->bih,0,sizeof(BITMAPINFOHEADER) + palette_count * 4);
�   905 		  sh->bih->biSize=40 + palette_count * 4;
�   906 		  // fetch the relevant fields
�   907 		  flag = BE_16(&trak->stdata[hdr_ptr]);
�   908 		  hdr_ptr += 2;
�   909 		  start = BE_32(&trak->stdata[hdr_ptr]);
�   910 		  hdr_ptr += 4;
�   911 		  count_flag = BE_16(&trak->stdata[hdr_ptr]);
�   912 		  hdr_ptr += 2;
�   913 		  end = BE_16(&trak->stdata[hdr_ptr]);
�   914 		  hdr_ptr += 2;
�   915 		  palette_map = (unsigned char *)sh->bih + 40;
�   916 		  mp_msg(MSGT_DEMUX, MSGL_INFO, "Allocated %d entries for palette\n",
�   917 		    palette_count);
�   918 		  mp_msg(MSGT_DEMUX, MSGL_DBG2, "QT palette: start: %x, end: %x, count flag: %d, flags: %x\n",
�   919 		    start, end, count_flag, flag);
�   920 
�   921 		  /* XXX: problems with sample (statunit6.mov) with flag&0x4 set! - alex*/
�   922 
�   923 		  // load default palette
�   924 		  if (flag & 0x08)
�   925 		  {
�   926 		    mp_msg(MSGT_DEMUX, MSGL_INFO, "Using default QT palette\n");
�   927 		    if (palette_count == 4)
�   928 		      memcpy(palette_map, qt_default_palette_4, 4 * 4);
�   929 		    else if (palette_count == 16)
�   930 		      memcpy(palette_map, qt_default_palette_16, 16 * 4);
�   931 		    if (palette_count == 256)
�   932 		      memcpy(palette_map, qt_default_palette_256, 256 * 4);
�   933 		  }
�   934 		  // load palette from file
�   935 		  else
�   936 		  {
�   937 		    mp_msg(MSGT_DEMUX, MSGL_INFO, "Loading palette from file\n");
�   938 		    for (i = start; i <= end; i++)
�   939 		    {
�   940 		      entry = BE_16(&trak->stdata[hdr_ptr]);
�   941 		      hdr_ptr += 2;
�   942 		      // apparently, if count_flag is set, entry is same as i
�   943 		      if (count_flag & 0x8000)
�   944 		        entry = i;
�   945 		      // only care about top 8 bits of 16-bit R, G, or B value
�   946 		      if (entry <= palette_count && entry >= 0)
�   947 		      {
�   948 		        palette_map[entry * 4 + 2] = trak->stdata[hdr_ptr + 0];
�   949 		        palette_map[entry * 4 + 1] = trak->stdata[hdr_ptr + 2];
�   950 		        palette_map[entry * 4 + 0] = trak->stdata[hdr_ptr + 4];
�   951 		        mp_dbg(MSGT_DEMUX, MSGL_DBG2, "QT palette: added entry: %d of %d (colors: R:%x G:%x B:%x)\n",
�   952 			    entry, palette_count,
�   953 			    palette_map[entry * 4 + 2], 
�   954 			    palette_map[entry * 4 + 1],
�   955 			    palette_map[entry * 4 + 0]);
�   956 		      }
�   957 		      else
�   958 		        mp_msg(MSGT_DEMUX, MSGL_V, "QT palette: skipped entry (out of count): %d of %d\n",
�   959 			    entry, palette_count);
�   960 		      hdr_ptr += 6;
�   961 		    }
�   962 		  }
�   963 		}
�   964 		else
�   965 		{
�   966 		  sh->bih=malloc(sizeof(BITMAPINFOHEADER));
�   967 		  memset(sh->bih,0,sizeof(BITMAPINFOHEADER));
�   968 		  sh->bih->biSize=40;
�   969 		}
�   970 		sh->bih->biWidth=sh->disp_w;
�   971 		sh->bih->biHeight=sh->disp_h;
�   972 		sh->bih->biPlanes=0;
�   973 		sh->bih->biBitCount=depth;
�   974 		sh->bih->biCompression=trak->fourcc;
�   975 		sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight;
�   976 
�   977 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Image size: %d x %d (%d bpp)\n",sh->disp_w,sh->disp_h,sh->bih->biBitCount);
�   978 		if(trak->tkdata_len>81)
�   979 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Display size: %d x %d\n",
�   980 		    trak->tkdata[77]|(trak->tkdata[76]<<8),
�   981 		    trak->tkdata[81]|(trak->tkdata[80]<<8));
�   982 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s  Codec: '%.*s'\n",&trak->fourcc,trak->stdata[42]&31,trak->stdata+43);
�   983 		
�   984 		if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){
�   985 		    // (auto)selected video track:
�   986 		    demuxer->video->id=priv->track_db;
�   987 		    demuxer->video->sh=sh; sh->ds=demuxer->video;
�   988 		}
�   989 		break;
�   990 	    }
�   991 	    case MOV_TRAK_GENERIC:
�   992 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Generic track - not completly understood! (id: %d)\n",
�   993 		    trak->id);
�   994 		/* XXX: Also this contains the FLASH data */
�   995 #if 0
�   996 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Extracting samples to files (possibly this is an flash anim)\n");
�   997 	    {
�   998 		int pos = stream_tell(demuxer->stream);
�   999 		int i;
�  1000 		int fd;
�  1001 		char name[20];
�  1002 		
�  1003 		for (i=0; i<trak->samples_size; i++)
�  1004 		{
�  1005 		    char buf[trak->samples[i].size];
�  1006 		    stream_seek(demuxer->stream, trak->samples[i].pos);
�  1007 		    snprintf((char *)&name[0], 20, "samp%d", i);
�  1008 		    fd = open((char *)&name[0], O_CREAT|O_WRONLY);
�  1009 		    stream_read(demuxer->stream, &buf[0], trak->samples[i].size);
�  1010 		    write(fd, &buf[0], trak->samples[i].size);
�  1011 		    close(fd);
�  1012 		 }
�  1013 		for (i=0; i<trak->chunks_size; i++)
�  1014 		{
�  1015 		    char buf[trak->length];
�  1016 		    stream_seek(demuxer->stream, trak->chunks[i].pos);
�  1017 		    snprintf((char *)&name[0], 20, "chunk%d", i);
�  1018 		    fd = open((char *)&name[0], O_CREAT|O_WRONLY);
�  1019 		    stream_read(demuxer->stream, &buf[0], trak->length);
�  1020 		    write(fd, &buf[0], trak->length);
�  1021 		    close(fd);
�  1022 		 }
�  1023 		 if (trak->samplesize > 0)
�  1024 		 {
�  1025 		    char *buf;
�  1026 		    
�  1027 		    buf = malloc(trak->samplesize);
�  1028 		    stream_seek(demuxer->stream, trak->chunks[0].pos);
�  1029 		    snprintf((char *)&name[0], 20, "trak%d", trak->id);
�  1030 		    fd = open((char *)&name[0], O_CREAT|O_WRONLY);
�  1031 		    stream_read(demuxer->stream, buf, trak->samplesize);
�  1032 		    write(fd, buf, trak->samplesize);
�  1033 		    close(fd);
�  1034 		 }
�  1035 		 stream_seek(demuxer->stream, pos);
�  1036 	    }		
�  1037 #endif
�  1038 		break;
�  1039 	    default:
�  1040 		mp_msg(MSGT_DEMUX, MSGL_INFO, "Unknown track type found (type: %d)\n", trak->type);
�  1041 		break;
�  1042 	    }
�  1043 	    mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n");
�  1044 	    priv->track_db++;
�  1045 	    trak=NULL;
�  1046 	    break;
�  1047 	}
�  1048 #ifndef HAVE_ZLIB
�  1049 	case MOV_FOURCC('c','m','o','v'): {
�  1050 	    mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr);
�  1051 	    return;
�  1052 	}
�  1053 #else
�  1054 	case MOV_FOURCC('m','o','o','v'):
�  1055 	case MOV_FOURCC('c','m','o','v'): {
�  1056 //	    mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr);
�  1057 	    lschunks(demuxer,level+1,pos+len,NULL);
�  1058 	    break;
�  1059 	}
�  1060 	case MOV_FOURCC('d','c','o','m'): {
�  1061 //	    int temp=stream_read_dword(demuxer->stream);
�  1062 	    unsigned int algo=be2me_32(stream_read_dword(demuxer->stream));
�  1063 	    mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header uses %.4s algo!\n",&algo);
�  1064 	    break;
�  1065 	}
�  1066 	case MOV_FOURCC('c','m','v','d'): {
�  1067 //	    int temp=stream_read_dword(demuxer->stream);
�  1068 	    unsigned int moov_sz=stream_read_dword(demuxer->stream);
�  1069 	    unsigned int cmov_sz=len-4;
�  1070 	    unsigned char* cmov_buf=malloc(cmov_sz);
�  1071 	    unsigned char* moov_buf=malloc(moov_sz+16);
�  1072 	    int zret;
�  1073 	    z_stream zstrm;
�  1074 	    stream_t* backup;
�  1075 
�  1076 	    mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header size: %d / %d\n",cmov_sz,moov_sz);
�  1077 
�  1078 	    stream_read(demuxer->stream,cmov_buf,cmov_sz);
�  1079 
�  1080 	      zstrm.zalloc          = (alloc_func)0;
�  1081 	      zstrm.zfree           = (free_func)0;
�  1082 	      zstrm.opaque          = (voidpf)0;
�  1083 	      zstrm.next_in         = cmov_buf;
�  1084 	      zstrm.avail_in        = cmov_sz;
�  1085 	      zstrm.next_out        = moov_buf;
�  1086 	      zstrm.avail_out       = moov_sz;
�  1087 	    
�  1088 	      zret = inflateInit(&zstrm);
�  1089 	      if (zret != Z_OK)
�  1090 		{ mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov: inflateInit err %d\n",zret);
�  1091 		return;
�  1092 		}
�  1093 	      zret = inflate(&zstrm, Z_NO_FLUSH);
�  1094 	      if ((zret != Z_OK) && (zret != Z_STREAM_END))
�  1095 		{ mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov inflate: ERR %d\n",zret);
�  1096 		return;
�  1097 		}
�  1098 #if 0
�  1099 	      else {
�  1100 		FILE *DecOut;
�  1101 		DecOut = fopen("Out.bin", "w");
�  1102 		fwrite(moov_buf, 1, moov_sz, DecOut);
�  1103 		fclose(DecOut);
�  1104 	      }
�  1105 #endif
�  1106 	      if(moov_sz != zstrm.total_out)
�  1107 	        mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! moov size differs cmov: %d  zlib: %d\n",moov_sz,zstrm.total_out);
�  1108 	      zret = inflateEnd(&zstrm);
�  1109 	      
�  1110 	      backup=demuxer->stream;
�  1111 	       demuxer->stream=new_memory_stream(moov_buf,moov_sz);
�  1112 	       stream_skip(demuxer->stream,8);
�  1113 	       lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov'
�  1114 	       //free_stream(demuxer->stream);
�  1115 	      demuxer->stream=backup;
�  1116 	      free(cmov_buf);
�  1117 	      free(moov_buf);	    
�  1118 	      break;
�  1119 	}
�  1120 #endif
�  1121 	case MOV_FOURCC('u','d','t','a'):
�  1122 	{
�  1123 	    unsigned int udta_id;
�  1124 	    off_t udta_len;
�  1125 	    off_t udta_size = len;
�  1126 	
�  1127 	    mp_msg(MSGT_DEMUX, MSGL_DBG2, "mov: user data record found\n");
�  1128 	    mp_msg(MSGT_DEMUX, MSGL_V, "Quicktime Clip Info:\n");
�  1129 
�  1130 	    while((len > 8) && (udta_size > 8))
�  1131 	    {
�  1132 		udta_len = stream_read_dword(demuxer->stream);
�  1133 		udta_id = stream_read_dword(demuxer->stream);
�  1134 		udta_size -= 8;
�  1135 		mp_msg(MSGT_DEMUX, MSGL_DBG2, "udta_id: %.4s (len: %d)\n", &udta_id, udta_len);
�  1136 		switch (udta_id)
�  1137 		{
�  1138 		    case MOV_FOURCC(0xa9,'c','p','y'):
�  1139 		    case MOV_FOURCC(0xa9,'d','a','y'):
�  1140 		    case MOV_FOURCC(0xa9,'d','i','r'):
�  1141 		    /* 0xa9,'e','d','1' - '9' : edit timestamps */
�  1142 		    case MOV_FOURCC(0xa9,'f','m','t'):
�  1143 		    case MOV_FOURCC(0xa9,'i','n','f'):
�  1144 		    case MOV_FOURCC(0xa9,'p','r','d'):
�  1145 		    case MOV_FOURCC(0xa9,'p','r','f'):
�  1146 		    case MOV_FOURCC(0xa9,'r','e','q'):
�  1147 		    case MOV_FOURCC(0xa9,'s','r','c'):
�  1148 		    case MOV_FOURCC('n','a','m','e'):
�  1149 		    case MOV_FOURCC(0xa9,'n','a','m'):
�  1150 		    case MOV_FOURCC(0xa9,'A','R','T'):
�  1151 		    case MOV_FOURCC(0xa9,'c','m','t'):
�  1152 		    case MOV_FOURCC(0xa9,'a','u','t'):
�  1153 		    case MOV_FOURCC(0xa9,'s','w','r'):
�  1154 		    {
�  1155 			off_t text_len = stream_read_word(demuxer->stream);
�  1156 			char text[text_len+2+1];
�  1157 			stream_read(demuxer->stream, (char *)&text, text_len+2);
�  1158 			text[text_len+2] = 0x0;
�  1159 			switch(udta_id)
�  1160 			{
�  1161 			    case MOV_FOURCC(0xa9,'a','u','t'):
�  1162 				demux_info_add(demuxer, "author", &text[2]);
�  1163 				mp_msg(MSGT_DEMUX, MSGL_V, " Author: %s\n", &text[2]);
�  1164 				break;
�  1165 			    case MOV_FOURCC(0xa9,'c','p','y'):
�  1166 				demux_info_add(demuxer, "copyright", &text[2]);
�  1167 				mp_msg(MSGT_DEMUX, MSGL_V, " Copyright: %s\n", &text[2]);
�  1168 				break;
�  1169 			    case MOV_FOURCC(0xa9,'i','n','f'):
�  1170 				mp_msg(MSGT_DEMUX, MSGL_V, " Info: %s\n", &text[2]);
�  1171 				break;
�  1172 			    case MOV_FOURCC('n','a','m','e'):
�  1173 			    case MOV_FOURCC(0xa9,'n','a','m'):
�  1174 				demux_info_add(demuxer, "name", &text[2]);
�  1175 				mp_msg(MSGT_DEMUX, MSGL_V, " Name: %s\n", &text[2]);
�  1176 				break;
�  1177 			    case MOV_FOURCC(0xa9,'A','R','T'):
�  1178 				mp_msg(MSGT_DEMUX, MSGL_V, " Artist: %s\n", &text[2]);
�  1179 				break;
�  1180 			    case MOV_FOURCC(0xa9,'d','i','r'):
�  1181 				mp_msg(MSGT_DEMUX, MSGL_V, " Director: %s\n", &text[2]);
�  1182 				break;
�  1183 			    case MOV_FOURCC(0xa9,'c','m','t'):
�  1184 				demux_info_add(demuxer, "comments", &text[2]);
�  1185 				mp_msg(MSGT_DEMUX, MSGL_V, " Comment: %s\n", &text[2]);
�  1186 				break;
�  1187 			    case MOV_FOURCC(0xa9,'r','e','q'):
�  1188 				mp_msg(MSGT_DEMUX, MSGL_V, " Requirements: %s\n", &text[2]);
�  1189 				break;
�  1190 			    case MOV_FOURCC(0xa9,'s','w','r'):
�  1191 				demux_info_add(demuxer, "encoder", &text[2]);
�  1192 				mp_msg(MSGT_DEMUX, MSGL_V, " Software: %s\n", &text[2]);
�  1193 				break;
�  1194 			    case MOV_FOURCC(0xa9,'d','a','y'):
�  1195 				mp_msg(MSGT_DEMUX, MSGL_V, " Creation timestamp: %s\n", &text[2]);
�  1196 				break;
�  1197 			    case MOV_FOURCC(0xa9,'f','m','t'):
�  1198 				mp_msg(MSGT_DEMUX, MSGL_V, " Format: %s\n", &text[2]);
�  1199 				break;
�  1200 			    case MOV_FOURCC(0xa9,'p','r','d'):
�  1201 				mp_msg(MSGT_DEMUX, MSGL_V, " Producer: %s\n", &text[2]);
�  1202 				break;
�  1203 			    case MOV_FOURCC(0xa9,'p','r','f'):
�  1204 				mp_msg(MSGT_DEMUX, MSGL_V, " Performer(s): %s\n", &text[2]);
�  1205 				break;
�  1206 			    case MOV_FOURCC(0xa9,'s','r','c'):
�  1207 				mp_msg(MSGT_DEMUX, MSGL_V, " Source providers: %s\n", &text[2]);
�  1208 				break;
�  1209 			}
�  1210 			udta_size -= 4+text_len;
�  1211 			break;
�  1212 		    }
�  1213 		    /* some other shits:    WLOC - window location,
�  1214 					    LOOP - looping style,
�  1215 					    SelO - play only selected frames
�  1216 					    AllF - play all frames
�  1217 		    */
�  1218 		    case MOV_FOURCC('W','L','O','C'):
�  1219 		    case MOV_FOURCC('L','O','O','P'):
�  1220 		    case MOV_FOURCC('S','e','l','O'):
�  1221 		    case MOV_FOURCC('A','l','l','F'):
�  1222 		    default:
�  1223 		    {
�  1224 			char dump[udta_len-4];
�  1225 			stream_read(demuxer->stream, (char *)&dump, udta_len-4-4);
�  1226 			udta_size -= udta_len;
�  1227 		    }
�  1228 		}
�  1229 	    }
�  1230 	    break;
�  1231 	} /* eof udta */
�  1232 	default:
�  1233 	  id = be2me_32(id);
�  1234 	  mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len);
�  1235 	} /* endof switch */
�  1236 	} /* endof else */
�  1237 
�  1238 	pos+=len+8;
�  1239 	if(pos>=endpos) break;
�  1240 	if(!stream_seek(demuxer->stream,pos)) break;
�  1241     }
�  1242 }
�  1243 
�  1244 int mov_read_header(demuxer_t* demuxer){
�  1245     mov_priv_t* priv=demuxer->priv;
�  1246     
�  1247     mp_msg(MSGT_DEMUX, MSGL_DBG3, "mov_read_header!\n");
�  1248 
�  1249     // Parse header:    
�  1250     stream_reset(demuxer->stream);
�  1251     if(!stream_seek(demuxer->stream,priv->moov_start))
�  1252     {
�  1253 	mp_msg(MSGT_DEMUX,MSGL_ERR,"MOV: Cannot seek to the beginning of the Movie header (0x%x)\n",
�  1254 	    priv->moov_start);
�  1255 	return 0;
�  1256     }
�  1257     lschunks(demuxer, 0, priv->moov_end, NULL);
�  1258 //    mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n");
�  1259 
�  1260     return 1;
�  1261 }
�  1262 
�  1263 // return value:
�  1264 //     0 = EOF or no stream found
�  1265 //     1 = successfully read a packet
�  1266 int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){
�  1267     mov_priv_t* priv=demuxer->priv;
�  1268     mov_track_t* trak=NULL;
�  1269     float pts;
�  1270     int x;
�  1271     off_t pos;
�  1272     
�  1273     if(ds->id<0 || ds->id>=priv->track_db) return 0;
�  1274     trak=priv->tracks[ds->id];
�  1275 
�  1276 if(trak->samplesize){
�  1277     // read chunk:
�  1278     if(trak->pos>=trak->chunks_size) return 0; // EOF
�  1279     stream_seek(demuxer->stream,trak->chunks[trak->pos].pos);
�  1280     pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
�  1281     if(trak->samplesize!=1)
�  1282     {
�  1283 	mp_msg(MSGT_DEMUX, MSGL_DBG2, "WARNING! Samplesize(%d) != 1\n",
�  1284 	    trak->samplesize);
�  1285 	x=trak->chunks[trak->pos].size*trak->samplesize;
�  1286     }
�  1287     else
�  1288 	x=trak->chunks[trak->pos].size;
�  1289 //    printf("X = %d\n", x);
�  1290     /* the following stuff is audio related */
�  1291     if (trak->type == MOV_TRAK_AUDIO)
�  1292     {
�  1293     if(trak->stdata_len>=36 && trak->stdata[30] && trak->stdata[31]){
�  1294 	// extended stsd header - works for CBR MP3:
�  1295 	x/=(trak->stdata[30]<<8)+trak->stdata[31];  // samples/packet
�  1296 	// x*=(trak->stdata[34]<<8)+trak->stdata[35];  // bytes/packet
�  1297 	x*=(trak->stdata[38]<<8)+trak->stdata[39];  // bytes/frame
�  1298     } else {
�  1299 	// works for ima4:   -- we should find this info in mov headers!
�  1300 	if(ds->ss_div!=1 || ds->ss_mul!=1){
�  1301 	    x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix  ! HACK !
�  1302 	} else {
�  1303 	    x*=(trak->stdata[18]<<8)+trak->stdata[19];x/=8;  // bits/sample
�  1304 	}
�  1305     }
�  1306     mp_msg(MSGT_DEMUX, MSGL_DBG2, "Audio sample %d bytes pts %5.3f\n",trak->chunks[trak->pos].size*trak->samplesize,pts);
�  1307     } /* MOV_TRAK_AUDIO */
�  1308     pos=trak->chunks[trak->pos].pos;
�  1309 } else {
�  1310     // read sample:
�  1311     if(trak->pos>=trak->samples_size) return 0; // EOF
�  1312     stream_seek(demuxer->stream,trak->samples[trak->pos].pos);
�  1313     pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale;
�  1314     x=trak->samples[trak->pos].size;
�  1315     pos=trak->samples[trak->pos].pos;
�  1316 }
�  1317 if(trak->pos==0 && trak->stream_header_len>0){
�  1318     // we have to append the stream header...
�  1319     demux_packet_t* dp=new_demux_packet(x+trak->stream_header_len);
�  1320     memcpy(dp->buffer,trak->stream_header,trak->stream_header_len);
�  1321     stream_read(demuxer->stream,dp->buffer+trak->stream_header_len,x);
�  1322     free(trak->stream_header);
�  1323     trak->stream_header = NULL;
�  1324     dp->pts=pts;
�  1325     dp->flags=0;
�  1326     dp->pos=pos; // FIXME?
�  1327     ds_add_packet(ds,dp);
�  1328 } else
�  1329     ds_read_packet(ds,demuxer->stream,x,pts,pos,0);
�  1330     
�  1331     ++trak->pos;
�  1332 
�  1333     return 1;
�  1334     
�  1335 }
�  1336 
�  1337 static float mov_seek_track(mov_track_t* trak,float pts,int flags){
�  1338 
�  1339 //    printf("MOV track seek called  %5.3f  \n",pts);
�  1340     if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale;
�  1341 
�  1342 if(trak->samplesize){
�  1343     int sample=pts/trak->duration;
�  1344 //    printf("MOV track seek - chunk: %d  (pts: %5.3f  dur=%d)  \n",sample,pts,trak->duration);
�  1345     if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative
�  1346     trak->pos=0;
�  1347     while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos;
�  1348     pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
�  1349 } else {
�  1350     unsigned int ipts;
�  1351     if(!(flags&1)) pts+=trak->samples[trak->pos].pts;
�  1352     if(pts<0) pts=0;
�  1353     ipts=pts;
�  1354     //printf("MOV track seek - sample: %d  \n",ipts);
�  1355     for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){
�  1356 	if(trak->samples[trak->pos].pts>=ipts) break; // found it!
�  1357     }
�  1358     if(trak->keyframes_size){
�  1359 	// find nearest keyframe
�  1360 	int i;
�  1361 	for(i=0;i<trak->keyframes_size;i++){
�  1362 	    if(trak->keyframes[i]>=trak->pos) break;
�  1363 	}
�  1364 	if(i>0 && (trak->keyframes[i]-trak->pos) > (trak->pos-trak->keyframes[i-1]))
�  1365 	  --i;
�  1366 	trak->pos=trak->keyframes[i];
�  1367 //	printf("nearest keyframe: %d  \n",trak->pos);
�  1368     }
�  1369     pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale;
�  1370 }
�  1371 
�  1372 //    printf("MOV track seek done:  %5.3f  \n",pts);
�  1373 
�  1374 return pts;
�  1375 }
�  1376 
�  1377 void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){
�  1378     mov_priv_t* priv=demuxer->priv;
�  1379     demux_stream_t* ds;
�  1380 
�  1381 //    printf("MOV seek called  %5.3f  flag=%d  \n",pts,flags);
�  1382     
�  1383     ds=demuxer->video;
�  1384     if(ds && ds->id>=0 && ds->id<priv->track_db){
�  1385 	mov_track_t* trak=priv->tracks[ds->id];
�  1386 	//if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
�  1387 	//if(!(flags&1)) pts+=ds->pts;
�  1388 	pts=ds->pts=mov_seek_track(trak,pts,flags);
�  1389 	flags=1; // absolute seconds
�  1390     }
�  1391 
�  1392     ds=demuxer->audio;
�  1393     if(ds && ds->id>=0 && ds->id<priv->track_db){
�  1394 	mov_track_t* trak=priv->tracks[ds->id];
�  1395 	//if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
�  1396 	//if(!(flags&1)) pts+=ds->pts;
�  1397 	ds->pts=mov_seek_track(trak,pts,flags);
�  1398     }
�  1399 
�  1400 }
�  1401