libextractor

demux_qt.c (96757B)

---

 /*
  * Copyright Copyright (C) 2001-2003 the xine project
  *
  * This file is part of xine, a free video player.
  *
  * xine is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * xine is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  *
  * Quicktime File Demuxer by Mike Melanson (melanson@pcisys.net)
  *  based on a Quicktime parsing experiment entitled 'lazyqt'
  *
  * Ideally, more documentation is forthcoming, but in the meantime:
  * functional flow:
  *  create_qt_info
  *  open_qt_file
  *   parse_moov_atom
  *    parse_mvhd_atom
  *    parse_trak_atom
  *    build_frame_table
  *  free_qt_info
  *
  * $Id: demux_qt.c,v 1.1 2003/04/03 14:51:25 grothoff Exp $
  *
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <stdio.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <zlib.h>
 
 #include "xine_internal.h"
 #include "xineutils.h"
 #include "demux.h"
 #include "buffer.h"
 #include "bswap.h"
 
 #include "qtpalette.h"
 
 typedef unsigned int qt_atom;
 
 #define QT_ATOM( ch0, ch1, ch2, ch3 ) \
         ( (unsigned char)(ch3) | \
         ( (unsigned char)(ch2) << 8 ) | \
         ( (unsigned char)(ch1) << 16 ) | \
         ( (unsigned char)(ch0) << 24 ) )
 
 /* top level atoms */
 #define FREE_ATOM QT_ATOM('f', 'r', 'e', 'e')
 #define JUNK_ATOM QT_ATOM('j', 'u', 'n', 'k')
 #define MDAT_ATOM QT_ATOM('m', 'd', 'a', 't')
 #define MOOV_ATOM QT_ATOM('m', 'o', 'o', 'v')
 #define PNOT_ATOM QT_ATOM('p', 'n', 'o', 't')
 #define SKIP_ATOM QT_ATOM('s', 'k', 'i', 'p')
 #define WIDE_ATOM QT_ATOM('w', 'i', 'd', 'e')
 #define PICT_ATOM QT_ATOM('P', 'I', 'C', 'T')
 #define FTYP_ATOM QT_ATOM('f', 't', 'y', 'p')
 
 #define CMOV_ATOM QT_ATOM('c', 'm', 'o', 'v')
 
 #define MVHD_ATOM QT_ATOM('m', 'v', 'h', 'd')
 
 #define VMHD_ATOM QT_ATOM('v', 'm', 'h', 'd')
 #define SMHD_ATOM QT_ATOM('s', 'm', 'h', 'd')
 
 #define TRAK_ATOM QT_ATOM('t', 'r', 'a', 'k')
 #define TKHD_ATOM QT_ATOM('t', 'k', 'h', 'd')
 #define MDHD_ATOM QT_ATOM('m', 'd', 'h', 'd')
 #define ELST_ATOM QT_ATOM('e', 'l', 's', 't')
 
 /* atoms in a sample table */
 #define STSD_ATOM QT_ATOM('s', 't', 's', 'd')
 #define STSZ_ATOM QT_ATOM('s', 't', 's', 'z')
 #define STSC_ATOM QT_ATOM('s', 't', 's', 'c')
 #define STCO_ATOM QT_ATOM('s', 't', 'c', 'o')
 #define STTS_ATOM QT_ATOM('s', 't', 't', 's')
 #define STSS_ATOM QT_ATOM('s', 't', 's', 's')
 #define CO64_ATOM QT_ATOM('c', 'o', '6', '4')
 
 #define ESDS_ATOM QT_ATOM('e', 's', 'd', 's')
 #define WAVE_ATOM QT_ATOM('w', 'a', 'v', 'e')
 
 #define IMA4_FOURCC QT_ATOM('i', 'm', 'a', '4')
 #define MP4A_FOURCC QT_ATOM('m', 'p', '4', 'a')
 #define TWOS_FOURCC QT_ATOM('t', 'w', 'o', 's')
 #define SOWT_FOURCC QT_ATOM('s', 'o', 'w', 't')
 
 #define UDTA_ATOM QT_ATOM('u', 'd', 't', 'a')
 #define CPY_ATOM QT_ATOM(0xA9, 'c', 'p', 'y')
 #define DES_ATOM QT_ATOM(0xA9, 'd', 'e', 's')
 #define CMT_ATOM QT_ATOM(0xA9, 'c', 'm', 't')
 
 #define RMDA_ATOM QT_ATOM('r', 'm', 'd', 'a')
 #define RDRF_ATOM QT_ATOM('r', 'd', 'r', 'f')
 #define RMDR_ATOM QT_ATOM('r', 'm', 'd', 'r')
 #define RMVC_ATOM QT_ATOM('r', 'm', 'v', 'c')
 #define QTIM_ATOM QT_ATOM('q', 't', 'i', 'm')
 
 /* placeholder for cutting and pasting */
 #define _ATOM QT_ATOM('', '', '', '')
 
 #define ATOM_PREAMBLE_SIZE 8
 #define PALETTE_COUNT 256
 
 #define MAX_PTS_DIFF 100000
 
 /* network bandwidth, cribbed from src/input/input_mms.c */
 const int64_t bandwidths[] = { 14400, 19200, 28800, 33600, 34430, 57600,
   115200, 262200, 393216, 524300, 1544000, 10485800
 };
 
 /* these are things that can go wrong */
 typedef enum
 {
   QT_OK,
   QT_FILE_READ_ERROR,
   QT_NO_MEMORY,
   QT_NOT_A_VALID_FILE,
   QT_NO_MOOV_ATOM,
   QT_NO_ZLIB,
   QT_ZLIB_ERROR,
   QT_HEADER_TROUBLE
 } qt_error;
 
 /* there are other types but these are the ones we usually care about */
 typedef enum
 {
 
   MEDIA_AUDIO,
   MEDIA_VIDEO,
   MEDIA_OTHER
 } media_type;
 
 typedef struct
 {
   int64_t offset;
   unsigned int size;
   int64_t pts;
   int keyframe;
 } qt_frame;
 
 typedef struct
 {
   unsigned int track_duration;
   unsigned int media_time;
 } edit_list_table_t;
 
 typedef struct
 {
   unsigned int first_chunk;
   unsigned int samples_per_chunk;
 } sample_to_chunk_table_t;
 
 typedef struct
 {
   unsigned int count;
   unsigned int duration;
 } time_to_sample_table_t;
 
 typedef struct
 {
   unsigned char *url;
   int64_t data_rate;
   int qtim_version;
 } reference_t;
 
 typedef struct
 {
 
   /* trak description */
   media_type type;
   union
   {
 
     struct
     {
       unsigned int codec_fourcc;
       unsigned int codec_buftype;
       unsigned int width;
       unsigned int height;
       int palette_count;
       palette_entry_t palette[PALETTE_COUNT];
       int depth;
       int edit_list_compensation;       /* special trick for edit lists */
     } video;
 
     struct
     {
       unsigned int codec_fourcc;
       unsigned int codec_buftype;
       unsigned int sample_rate;
       unsigned int channels;
       unsigned int bits;
       unsigned int vbr;
       unsigned int wave_present;
       xine_waveformatex wave;
 
       /* special audio parameters */
       unsigned int samples_per_packet;
       unsigned int bytes_per_packet;
       unsigned int bytes_per_frame;
       unsigned int bytes_per_sample;
       unsigned int samples_per_frame;
     } audio;
 
   } properties;
 
   /* internal frame table corresponding to this trak */
   qt_frame *frames;
   unsigned int frame_count;
   unsigned int current_frame;
 
   /* trak timescale */
   unsigned int timescale;
 
   /* flags that indicate how a trak is supposed to be used */
   unsigned int flags;
 
   /* decoder data pass information to the AAC decoder */
   void *decoder_config;
   int decoder_config_len;
 
   /* verbatim copy of the stsd atom */
   int stsd_size;
   void *stsd;
 
   /****************************************/
   /* temporary tables for loading a chunk */
 
   /* edit list table */
   unsigned int edit_list_count;
   edit_list_table_t *edit_list_table;
 
   /* chunk offsets */
   unsigned int chunk_offset_count;
   int64_t *chunk_offset_table;
 
   /* sample sizes */
   unsigned int sample_size;
   unsigned int sample_size_count;
   unsigned int *sample_size_table;
 
   /* sync samples, a.k.a., keyframes */
   unsigned int sync_sample_count;
   unsigned int *sync_sample_table;
 
   /* sample to chunk table */
   unsigned int sample_to_chunk_count;
   sample_to_chunk_table_t *sample_to_chunk_table;
 
   /* time to sample table */
   unsigned int time_to_sample_count;
   time_to_sample_table_t *time_to_sample_table;
 
 } qt_trak;
 
 typedef struct
 {
   int compressed_header;        /* 1 if there was a compressed moov; just FYI */
 
   unsigned int creation_time;   /* in ms since Jan-01-1904 */
   unsigned int modification_time;
   unsigned int timescale;       /* base clock frequency is Hz */
   unsigned int duration;
 
   int64_t moov_first_offset;
 
   int trak_count;
   qt_trak *traks;
 
   /* the trak numbers that won their respective frame count competitions */
   int video_trak;
   int audio_trak;
   int seek_flag;                /* this is set to indicate that a seek has just occurred */
 
   char *copyright;
   char *description;
   char *comment;
 
   /* a QT movie may contain a number of references pointing to URLs */
   reference_t *references;
   int reference_count;
   int chosen_reference;
 
   /* need to know base MRL to construct URLs from relative paths */
   char *base_mrl;
 
   qt_error last_error;
 } qt_info;
 
 typedef struct
 {
 
   demux_plugin_t demux_plugin;
 
   xine_stream_t *stream;
 
   config_values_t *config;
 
   fifo_buffer_t *video_fifo;
   fifo_buffer_t *audio_fifo;
 
   input_plugin_t *input;
 
   int status;
 
   qt_info *qt;
   xine_bmiheader bih;
   unsigned int current_frame;
   unsigned int last_frame;
 
   off_t data_start;
   off_t data_size;
 
   int64_t bandwidth;
 
   char last_mrl[1024];
 } demux_qt_t;
 
 typedef struct
 {
 
   demux_class_t demux_class;
 
   /* class-wide, global variables here */
 
   xine_t *xine;
   config_values_t *config;
 } demux_qt_class_t;
 
 /**********************************************************************
  * lazyqt special debugging functions
  **********************************************************************/
 
 /* define DEBUG_ATOM_LOAD as 1 to get a verbose parsing of the relevant
  * atoms */
 #define DEBUG_ATOM_LOAD 0
 
 /* define DEBUG_EDIT_LIST as 1 to get a detailed look at how the demuxer is
  * handling edit lists */
 #define DEBUG_EDIT_LIST 0
 
 /* define DEBUG_FRAME_TABLE as 1 to dump the complete frame table that the
  * demuxer plans to use during file playback */
 #define DEBUG_FRAME_TABLE 0
 
 /* define DEBUG_VIDEO_DEMUX as 1 to see details about the video chunks the
  * demuxer is sending off to the video decoder */
 #define DEBUG_VIDEO_DEMUX 0
 
 /* define DEBUG_AUDIO_DEMUX as 1 to see details about the audio chunks the
  * demuxer is sending off to the audio decoder */
 #define DEBUG_AUDIO_DEMUX 0
 
 /* Define DEBUG_DUMP_MOOV as 1 to dump the raw moov atom to disk. This is
  * particularly useful in debugging a file with a compressed moov (cmov)
  * atom. The atom will be dumped to the filename specified as
  * RAW_MOOV_FILENAME. */
 #define DEBUG_DUMP_MOOV 0
 #define RAW_MOOV_FILENAME "moovatom.raw"
 
 #if DEBUG_ATOM_LOAD
 #define debug_atom_load printf
 #else
 static inline void
 debug_atom_load (const char *format, ...)
 {
 }
 #endif
 
 #if DEBUG_EDIT_LIST
 #define debug_edit_list printf
 #else
 static inline void
 debug_edit_list (const char *format, ...)
 {
 }
 #endif
 
 #if DEBUG_FRAME_TABLE
 #define debug_frame_table printf
 #else
 static inline void
 debug_frame_table (const char *format, ...)
 {
 }
 #endif
 
 #if DEBUG_VIDEO_DEMUX
 #define debug_video_demux printf
 #else
 static inline void
 debug_video_demux (const char *format, ...)
 {
 }
 #endif
 
 #if DEBUG_AUDIO_DEMUX
 #define debug_audio_demux printf
 #else
 static inline void
 debug_audio_demux (const char *format, ...)
 {
 }
 #endif
 
 static void
 hexdump (char *buf, int length)
 {
 
   int i;
 
   printf ("demux_qt: ascii contents>");
   for (i = 0; i < length; i++)
     {
       unsigned char c = buf[i];
 
       if ((c >= 32) && (c < 128))
         printf ("%c", c);
       else
         printf (".");
     }
   printf ("\n");
 
   printf
     ("demux_qt: complete hexdump of package follows:\ndemux_qt 0x0000:  ");
   for (i = 0; i < length; i++)
     {
       unsigned char c = buf[i];
 
       printf ("%02x", c);
 
       if ((i % 16) == 15)
         printf ("\ndemux_qt 0x%04x: ", i);
 
       if ((i % 2) == 1)
         printf (" ");
 
     }
   printf ("\n");
 }
 
 static inline void
 dump_moov_atom (unsigned char *moov_atom, int moov_atom_size)
 {
 #if DEBUG_DUMP_MOOV
 
   FILE *f;
 
   f = fopen (RAW_MOOV_FILENAME, "w");
   if (!f)
     {
       perror (RAW_MOOV_FILENAME);
       return;
     }
 
   if (fwrite (moov_atom, moov_atom_size, 1, f) != 1)
     printf ("  qt debug: could not write moov atom to disk\n");
 
   fclose (f);
 
 #endif
 }
 
 /**********************************************************************
  * lazyqt functions
  **********************************************************************/
 
 /*
  * This function traverses a file and looks for a moov atom. Returns the
  * file offset of the beginning of the moov atom (that means the offset
  * of the 4-byte length preceding the characters 'moov'). Returns -1
  * if no moov atom was found.
  *
  * Note: Do not count on the input stream being positioned anywhere in
  * particular when this function is finished.
  */
 static void
 find_moov_atom (input_plugin_t * input, off_t * moov_offset,
                 int64_t * moov_size)
 {
 
   off_t atom_size;
   qt_atom atom;
   unsigned char atom_preamble[ATOM_PREAMBLE_SIZE];
 
   /* init the passed variables */
   *moov_offset = *moov_size = -1;
 
   /* take it from the top */
   if (input->seek (input, 0, SEEK_SET) != 0)
     return;
 
   /* traverse through the input */
   while (*moov_offset == -1)
     {
       if (input->read (input, atom_preamble, ATOM_PREAMBLE_SIZE) !=
           ATOM_PREAMBLE_SIZE)
         break;
 
       atom_size = BE_32 (&atom_preamble[0]);
       atom = BE_32 (&atom_preamble[4]);
 
       /* if the moov atom is found, log the position and break from the loop */
       if (atom == MOOV_ATOM)
         {
           *moov_offset = input->get_current_pos (input) - ATOM_PREAMBLE_SIZE;
           *moov_size = atom_size;
           break;
         }
 
       /* special case alert: 'free' atoms are known to contain 'cmov' atoms.
        * If this is a free atom, check for cmov immediately following.
        * QT Player can handle it, so xine should too. */
       if (atom == FREE_ATOM)
         {
 
           /* get the next atom preamble */
           if (input->read (input, atom_preamble, ATOM_PREAMBLE_SIZE) !=
               ATOM_PREAMBLE_SIZE)
             break;
 
           /* if there is a cmov, qualify this free atom as the moov atom */
           if (BE_32 (&atom_preamble[4]) == CMOV_ATOM)
             {
               /* pos = current pos minus 2 atom preambles */
               *moov_offset =
                 input->get_current_pos (input) - ATOM_PREAMBLE_SIZE * 2;
               *moov_size = atom_size;
               break;
             }
           else
             {
               /* otherwise, rewind the stream */
               input->seek (input, -ATOM_PREAMBLE_SIZE, SEEK_CUR);
             }
         }
 
       /* if this atom is not the moov atom, make sure that it is at least one
        * of the other top-level QT atom */
       if ((atom != FREE_ATOM) &&
           (atom != JUNK_ATOM) &&
           (atom != MDAT_ATOM) &&
           (atom != PNOT_ATOM) &&
           (atom != SKIP_ATOM) &&
           (atom != WIDE_ATOM) && (atom != PICT_ATOM) && (atom != FTYP_ATOM))
         break;
 
       /* 64-bit length special case */
       if (atom_size == 1)
         {
           if (input->read (input, atom_preamble, ATOM_PREAMBLE_SIZE) !=
               ATOM_PREAMBLE_SIZE)
             break;
 
           atom_size = BE_32 (&atom_preamble[0]);
           atom_size <<= 32;
           atom_size |= BE_32 (&atom_preamble[4]);
           atom_size -= ATOM_PREAMBLE_SIZE * 2;
         }
       else
         atom_size -= ATOM_PREAMBLE_SIZE;
 
       input->seek (input, atom_size, SEEK_CUR);
     }
 
   /* reset to the start of the stream on the way out */
   input->seek (input, 0, SEEK_SET);
 }
 
 /* create a qt_info structure or return NULL if no memory */
 qt_info *
 create_qt_info (void)
 {
   qt_info *info;
 
   info = (qt_info *) malloc (sizeof (qt_info));
 
   if (!info)
     return NULL;
 
   info->compressed_header = 0;
 
   info->creation_time = 0;
   info->modification_time = 0;
   info->timescale = 0;
   info->duration = 0;
 
   info->trak_count = 0;
   info->traks = NULL;
 
   info->video_trak = -1;
   info->audio_trak = -1;
 
   info->copyright = NULL;
   info->description = NULL;
   info->comment = NULL;
 
   info->references = NULL;
   info->reference_count = 0;
   info->chosen_reference = -1;
 
   info->base_mrl = NULL;
 
   info->last_error = QT_OK;
 
   return info;
 }
 
 /* release a qt_info structure and associated data */
 void
 free_qt_info (qt_info * info)
 {
 
   int i;
 
   if (info)
     {
       if (info->traks)
         {
           for (i = 0; i < info->trak_count; i++)
             {
               free (info->traks[i].frames);
               free (info->traks[i].edit_list_table);
               free (info->traks[i].chunk_offset_table);
               /* this pointer might have been set to -1 as a special case */
               if (info->traks[i].sample_size_table != (void *) -1)
                 free (info->traks[i].sample_size_table);
               free (info->traks[i].sync_sample_table);
               free (info->traks[i].sample_to_chunk_table);
               free (info->traks[i].time_to_sample_table);
               free (info->traks[i].decoder_config);
               free (info->traks[i].stsd);
             }
           free (info->traks);
         }
       if (info->references)
         {
           for (i = 0; i < info->reference_count; i++)
             free (info->references[i].url);
           free (info->references);
         }
       free (info->base_mrl);
       free (info->copyright);
       free (info->description);
       free (info->comment);
       free (info);
       info = NULL;
     }
 }
 
 /* returns 1 if the file is determined to be a QT file, 0 otherwise */
 static int
 is_qt_file (input_plugin_t * qt_file)
 {
 
   off_t moov_atom_offset = -1;
   int64_t moov_atom_size = -1;
   int i;
   unsigned char atom_preamble[ATOM_PREAMBLE_SIZE];
   unsigned char preview[MAX_PREVIEW_SIZE];
   int len;
 
   /* if the input is non-seekable, be much more stringent about qualifying
    * a QT file: In this case, the moov must be the first atom in the file */
   if ((qt_file->get_capabilities (qt_file) & INPUT_CAP_SEEKABLE) == 0)
     {
       len =
         qt_file->get_optional_data (qt_file, preview,
                                     INPUT_OPTIONAL_DATA_PREVIEW);
       if (BE_32 (&preview[4]) == MOOV_ATOM)
         return 1;
       else
         return 0;
     }
 
   find_moov_atom (qt_file, &moov_atom_offset, &moov_atom_size);
   if (moov_atom_offset == -1)
     {
       return 0;
     }
   else
     {
       /* check that the next atom in the chunk contains alphanumeric
        * characters in the atom type field; if not, disqualify the file
        * as a QT file */
       qt_file->seek (qt_file, moov_atom_offset + ATOM_PREAMBLE_SIZE,
                      SEEK_SET);
       if (qt_file->read (qt_file, atom_preamble, ATOM_PREAMBLE_SIZE) !=
           ATOM_PREAMBLE_SIZE)
         return 0;
 
       for (i = 4; i < 8; i++)
         if (!isalnum (atom_preamble[i]))
           return 0;
       return 1;
     }
 }
 
 /* fetch interesting information from the movie header atom */
 static void
 parse_mvhd_atom (qt_info * info, unsigned char *mvhd_atom)
 {
 
   info->creation_time = BE_32 (&mvhd_atom[0x0C]);
   info->modification_time = BE_32 (&mvhd_atom[0x10]);
   info->timescale = BE_32 (&mvhd_atom[0x14]);
   info->duration = BE_32 (&mvhd_atom[0x18]);
 
 }
 
 /* helper function from mplayer's parse_mp4.c */
 static int
 mp4_read_descr_len (unsigned char *s, uint32_t * length)
 {
   uint8_t b;
   uint8_t numBytes = 0;
 
   *length = 0;
 
   do
     {
       b = *s++;
       numBytes++;
       *length = (*length << 7) | (b & 0x7F);
     }
   while ((b & 0x80) && numBytes < 4);
 
   return numBytes;
 }
 
 /*
  * This function traverses through a trak atom searching for the sample
  * table atoms, which it loads into an internal trak structure.
  */
 static qt_error
 parse_trak_atom (qt_trak * trak, unsigned char *trak_atom)
 {
 
   int i, j;
   unsigned int trak_atom_size = BE_32 (&trak_atom[0]);
   qt_atom current_atom;
   unsigned int current_atom_size;
   qt_error last_error = QT_OK;
 
   /* for palette traversal */
   int color_depth;
   int color_flag;
   int color_start;
   int color_count;
   int color_end;
   int color_index;
   int color_dec;
   int color_greyscale;
   unsigned char *color_table;
 
   /* initialize trak structure */
   trak->edit_list_count = 0;
   trak->edit_list_table = NULL;
   trak->chunk_offset_count = 0;
   trak->chunk_offset_table = NULL;
   trak->sample_size = 0;
   trak->sample_size_count = 0;
   trak->sample_size_table = NULL;
   trak->sync_sample_table = 0;
   trak->sync_sample_table = NULL;
   trak->sample_to_chunk_count = 0;
   trak->sample_to_chunk_table = NULL;
   trak->time_to_sample_count = 0;
   trak->time_to_sample_table = NULL;
   trak->frames = NULL;
   trak->frame_count = 0;
   trak->current_frame = 0;
   trak->timescale = 0;
   trak->flags = 0;
   trak->decoder_config = NULL;
   trak->decoder_config_len = 0;
   trak->stsd = NULL;
   trak->stsd_size = 0;
   memset (&trak->properties, 0, sizeof (trak->properties));
 
   /* default type */
   trak->type = MEDIA_OTHER;
 
   /* search for media type atoms */
   for (i = ATOM_PREAMBLE_SIZE; i < trak_atom_size - 4; i++)
     {
       current_atom = BE_32 (&trak_atom[i]);
 
       if (current_atom == VMHD_ATOM)
         {
           trak->type = MEDIA_VIDEO;
           break;
         }
       else if (current_atom == SMHD_ATOM)
         {
           trak->type = MEDIA_AUDIO;
           break;
         }
     }
 
   debug_atom_load ("  qt: parsing %s trak atom\n",
                    (trak->type == MEDIA_VIDEO) ? "video" :
                    (trak->type == MEDIA_AUDIO) ? "audio" : "other");
 
   /* search for the useful atoms */
   for (i = ATOM_PREAMBLE_SIZE; i < trak_atom_size - 4; i++)
     {
       current_atom_size = BE_32 (&trak_atom[i - 4]);
       current_atom = BE_32 (&trak_atom[i]);
 
       if (current_atom == TKHD_ATOM)
         {
           trak->flags = BE_16 (&trak_atom[i + 6]);
 
           if (trak->type == MEDIA_VIDEO)
             {
               /* fetch display parameters */
               if (!trak->properties.video.width ||
                   !trak->properties.video.height)
                 {
 
                   trak->properties.video.width = BE_16 (&trak_atom[i + 0x50]);
                   trak->properties.video.height =
                     BE_16 (&trak_atom[i + 0x54]);
                 }
             }
         }
       else if (current_atom == ELST_ATOM)
         {
 
           /* there should only be one edit list table */
           if (trak->edit_list_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->edit_list_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load ("    qt elst atom (edit list atom): %d entries\n",
                            trak->edit_list_count);
 
           trak->edit_list_table =
             (edit_list_table_t *) malloc (trak->edit_list_count *
                                           sizeof (edit_list_table_t));
           if (!trak->edit_list_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the edit list table */
           for (j = 0; j < trak->edit_list_count; j++)
             {
               trak->edit_list_table[j].track_duration =
                 BE_32 (&trak_atom[i + 12 + j * 12 + 0]);
               trak->edit_list_table[j].media_time =
                 BE_32 (&trak_atom[i + 12 + j * 12 + 4]);
               debug_atom_load
                 ("      %d: track duration = %d, media time = %d\n", j,
                  trak->edit_list_table[j].track_duration,
                  trak->edit_list_table[j].media_time);
             }
 
         }
       else if (current_atom == MDHD_ATOM)
         trak->timescale = BE_32 (&trak_atom[i + 0x10]);
       else if (current_atom == STSD_ATOM)
         {
 
           int hack_adjust;
 
           debug_atom_load ("demux_qt: stsd atom\n");
 #if DEBUG_ATOM_LOAD
           hexdump (&trak_atom[i], current_atom_size);
 #endif
 
           /* copy whole stsd atom so it can later be sent to the decoder */
 
           trak->stsd_size = current_atom_size;
           trak->stsd = realloc (trak->stsd, current_atom_size);
           memset (trak->stsd, 0, trak->stsd_size);
 
           /* awful, awful hack to support a certain type of stsd atom that
            * contains more than 1 video description atom */
           if (BE_32 (&trak_atom[i + 8]) == 1)
             {
               /* normal case */
               memcpy (trak->stsd, &trak_atom[i], current_atom_size);
               hack_adjust = 0;
             }
           else
             {
               /* pathological case; take this route until a more definite
                * solution is found: jump over the first atom video
                * description atom */
 
               /* copy the first 12 bytes since those remain the same */
               memcpy (trak->stsd, &trak_atom[i], 12);
 
               /* skip to the second atom and copy it */
               hack_adjust = BE_32 (&trak_atom[i + 0x0C]);
               memcpy (trak->stsd + 12, &trak_atom[i + 0x0C + hack_adjust],
                       BE_32 (&trak_atom[i + 0x0C + hack_adjust]));
 
               /* use this variable to reference into the second atom, and
                * fix at the end of the stsd parser */
               i += hack_adjust;
             }
 
           if (trak->type == MEDIA_VIDEO)
             {
 
               /* initialize to sane values */
               trak->properties.video.width = 0;
               trak->properties.video.height = 0;
               trak->properties.video.depth = 0;
 
               /* assume no palette at first */
               trak->properties.video.palette_count = 0;
 
               /* fetch video parameters */
               if (BE_16 (&trak_atom[i + 0x2C]) &&
                   BE_16 (&trak_atom[i + 0x2E]))
                 {
                   trak->properties.video.width = BE_16 (&trak_atom[i + 0x2C]);
                   trak->properties.video.height =
                     BE_16 (&trak_atom[i + 0x2E]);
                 }
               trak->properties.video.codec_fourcc =
                 ME_32 (&trak_atom[i + 0x10]);
 
               /* figure out the palette situation */
               color_depth = trak_atom[i + 0x5F];
               trak->properties.video.depth = color_depth;
               color_greyscale = color_depth & 0x20;
               color_depth &= 0x1F;
 
               /* if the depth is 2, 4, or 8 bpp, file is palettized */
               if ((color_depth == 2) || (color_depth == 4)
                   || (color_depth == 8))
                 {
 
                   color_flag = BE_16 (&trak_atom[i + 0x60]);
 
                   if (color_greyscale)
                     {
 
                       trak->properties.video.palette_count = 1 << color_depth;
 
                       /* compute the greyscale palette */
                       color_index = 255;
                       color_dec = 256 /
                         (trak->properties.video.palette_count - 1);
                       for (j = 0;
                            j < trak->properties.video.palette_count; j++)
                         {
 
                           trak->properties.video.palette[j].r = color_index;
                           trak->properties.video.palette[j].g = color_index;
                           trak->properties.video.palette[j].b = color_index;
                           color_index -= color_dec;
                           if (color_index < 0)
                             color_index = 0;
                         }
 
                     }
                   else if (color_flag & 0x08)
                     {
 
                       /* if flag bit 3 is set, load the default palette */
                       trak->properties.video.palette_count = 1 << color_depth;
 
                       if (color_depth == 2)
                         color_table = qt_default_palette_4;
                       else if (color_depth == 4)
                         color_table = qt_default_palette_16;
                       else
                         color_table = qt_default_palette_256;
 
                       for (j = 0;
                            j < trak->properties.video.palette_count; j++)
                         {
 
                           trak->properties.video.palette[j].r =
                             color_table[j * 4 + 0];
                           trak->properties.video.palette[j].g =
                             color_table[j * 4 + 1];
                           trak->properties.video.palette[j].b =
                             color_table[j * 4 + 2];
 
                         }
 
                     }
                   else
                     {
 
                       /* load the palette from the file */
                       color_start = BE_32 (&trak_atom[i + 0x62]);
                       color_count = BE_16 (&trak_atom[i + 0x66]);
                       color_end = BE_16 (&trak_atom[i + 0x68]);
                       trak->properties.video.palette_count = color_end + 1;
 
                       for (j = color_start; j <= color_end; j++)
                         {
 
                           color_index = BE_16 (&trak_atom[i + 0x6A + j * 8]);
                           if (color_count & 0x8000)
                             color_index = j;
                           if (color_index <
                               trak->properties.video.palette_count)
                             {
                               trak->properties.video.palette[color_index].r =
                                 trak_atom[i + 0x6A + j * 8 + 2];
                               trak->properties.video.palette[color_index].g =
                                 trak_atom[i + 0x6A + j * 8 + 4];
                               trak->properties.video.palette[color_index].b =
                                 trak_atom[i + 0x6A + j * 8 + 6];
                             }
                         }
                     }
                 }
               else
                 trak->properties.video.palette_count = 0;
 
               debug_atom_load ("    video description\n");
               debug_atom_load
                 ("      %dx%d, video fourcc = '%c%c%c%c' (%02X%02X%02X%02X)\n",
                  trak->properties.video.width, trak->properties.video.height,
                  trak_atom[i + 0x10], trak_atom[i + 0x11],
                  trak_atom[i + 0x12], trak_atom[i + 0x13],
                  trak_atom[i + 0x10], trak_atom[i + 0x11],
                  trak_atom[i + 0x12], trak_atom[i + 0x13]);
               debug_atom_load ("      %d RGB colors\n",
                                trak->properties.video.palette_count);
               for (j = 0; j < trak->properties.video.palette_count; j++)
                 debug_atom_load ("        %d: %3d %3d %3d\n",
                                  j,
                                  trak->properties.video.palette[j].r,
                                  trak->properties.video.palette[j].g,
                                  trak->properties.video.palette[j].b);
 
             }
           else if (trak->type == MEDIA_AUDIO)
             {
 
               /* fetch audio parameters */
               trak->properties.audio.codec_fourcc =
                 ME_32 (&trak_atom[i + 0x10]);
               trak->properties.audio.sample_rate =
                 BE_16 (&trak_atom[i + 0x2C]);
               trak->properties.audio.channels = trak_atom[i + 0x25];
               trak->properties.audio.bits = trak_atom[i + 0x27];
 
               /* assume uncompressed audio parameters */
               trak->properties.audio.bytes_per_sample =
                 trak->properties.audio.bits / 8;
               trak->properties.audio.samples_per_frame =
                 trak->properties.audio.channels;
               trak->properties.audio.bytes_per_frame =
                 trak->properties.audio.bytes_per_sample *
                 trak->properties.audio.samples_per_frame;
               trak->properties.audio.samples_per_packet =
                 trak->properties.audio.samples_per_frame;
               trak->properties.audio.bytes_per_packet =
                 trak->properties.audio.bytes_per_sample;
 
               /* special case time: some ima4-encoded files don't have the
                * extra header; compensate */
               if (BE_32 (&trak_atom[i + 0x10]) == IMA4_FOURCC)
                 {
                   trak->properties.audio.samples_per_packet = 64;
                   trak->properties.audio.bytes_per_packet = 34;
                   trak->properties.audio.bytes_per_frame = 34 *
                     trak->properties.audio.channels;
                   trak->properties.audio.bytes_per_sample = 2;
                   trak->properties.audio.samples_per_frame = 64 *
                     trak->properties.audio.channels;
                 }
 
               /* it's time to dig a little deeper to determine the real audio
                * properties; if a the stsd compressor atom has 0x24 bytes, it
                * appears to be a handler for uncompressed data; if there are an
                * extra 0x10 bytes, there are some more useful decoding params */
               if (BE_32 (&trak_atom[i + 0x0C]) > 0x24)
                 {
 
                   if (BE_32 (&trak_atom[i + 0x30]))
                     trak->properties.audio.samples_per_packet =
                       BE_32 (&trak_atom[i + 0x30]);
                   if (BE_32 (&trak_atom[i + 0x34]))
                     trak->properties.audio.bytes_per_packet =
                       BE_32 (&trak_atom[i + 0x34]);
                   if (BE_32 (&trak_atom[i + 0x38]))
                     trak->properties.audio.bytes_per_frame =
                       BE_32 (&trak_atom[i + 0x38]);
                   if (BE_32 (&trak_atom[i + 0x3C]))
                     trak->properties.audio.bytes_per_sample =
                       BE_32 (&trak_atom[i + 0x3C]);
                   trak->properties.audio.samples_per_frame =
                     (trak->properties.audio.bytes_per_frame /
                      trak->properties.audio.bytes_per_packet) *
                     trak->properties.audio.samples_per_packet;
 
                 }
 
               /* see if the trak deserves a promotion to VBR */
               if (BE_16 (&trak_atom[i + 0x28]) == 0xFFFE)
                 trak->properties.audio.vbr = 1;
               else
                 trak->properties.audio.vbr = 0;
 
               /* if this is MP4 audio, mark the trak as VBR */
               if (BE_32 (&trak_atom[i + 0x10]) == MP4A_FOURCC)
                 trak->properties.audio.vbr = 1;
 
               /* check for a MS-style WAVE format header */
               if ((current_atom_size >= 0x48) &&
                   (BE_32 (&trak_atom[i + 0x44]) == WAVE_ATOM))
                 {
                   trak->properties.audio.wave_present = 1;
                   memcpy (&trak->properties.audio.wave,
                           &trak_atom[i + 0x5C],
                           sizeof (trak->properties.audio.wave));
                   xine_waveformatex_le2me (&trak->properties.audio.wave);
                 }
               else
                 {
                   trak->properties.audio.wave_present = 0;
                 }
 
               debug_atom_load ("    audio description\n");
               debug_atom_load
                 ("      %d Hz, %d bits, %d channels, %saudio fourcc = '%c%c%c%c' (%02X%02X%02X%02X)\n",
                  trak->properties.audio.sample_rate,
                  trak->properties.audio.bits, trak->properties.audio.channels,
                  (trak->properties.audio.vbr) ? "vbr, " : "",
                  trak_atom[i + 0x10], trak_atom[i + 0x11],
                  trak_atom[i + 0x12], trak_atom[i + 0x13],
                  trak_atom[i + 0x10], trak_atom[i + 0x11],
                  trak_atom[i + 0x12], trak_atom[i + 0x13]);
               if (BE_32 (&trak_atom[i + 0x0C]) > 0x24)
                 {
                   debug_atom_load
                     ("      %d samples/packet, %d bytes/packet, %d bytes/frame\n",
                      trak->properties.audio.samples_per_packet,
                      trak->properties.audio.bytes_per_packet,
                      trak->properties.audio.bytes_per_frame);
                   debug_atom_load
                     ("      %d bytes/sample (%d samples/frame)\n",
                      trak->properties.audio.bytes_per_sample,
                      trak->properties.audio.samples_per_frame);
                 }
             }
 
           i -= hack_adjust;
 
         }
       else if (current_atom == ESDS_ATOM)
         {
 
           uint32_t len;
 
           debug_atom_load ("    qt/mpeg-4 esds atom\n");
 
           if ((trak->type == MEDIA_VIDEO) || (trak->type == MEDIA_AUDIO))
             {
 
               j = i + 8;
               if (trak_atom[j++] == 0x03)
                 {
                   j += mp4_read_descr_len (&trak_atom[j], &len);
                   j++;
                 }
               j += 2;
               if (trak_atom[j++] == 0x04)
                 {
                   j += mp4_read_descr_len (&trak_atom[j], &len);
                   j += 13;
                   if (trak_atom[j++] == 0x05)
                     {
                       j += mp4_read_descr_len (&trak_atom[j], &len);
                       debug_atom_load
                         ("      decoder config is %d (0x%X) bytes long\n",
                          len, len);
                       trak->decoder_config =
                         realloc (trak->decoder_config, len);
                       trak->decoder_config_len = len;
                       memcpy (trak->decoder_config, &trak_atom[j], len);
                     }
                 }
             }
 
         }
       else if (current_atom == STSZ_ATOM)
         {
 
           /* there should only be one of these atoms */
           if (trak->sample_size_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->sample_size = BE_32 (&trak_atom[i + 8]);
           trak->sample_size_count = BE_32 (&trak_atom[i + 12]);
 
           debug_atom_load
             ("    qt stsz atom (sample size atom): sample size = %d, %d entries\n",
              trak->sample_size, trak->sample_size_count);
 
           /* allocate space and load table only if sample size is 0 */
           if (trak->sample_size == 0)
             {
               trak->sample_size_table =
                 (unsigned int *) malloc (trak->sample_size_count *
                                          sizeof (unsigned int));
               if (!trak->sample_size_table)
                 {
                   last_error = QT_NO_MEMORY;
                   goto free_trak;
                 }
               /* load the sample size table */
               for (j = 0; j < trak->sample_size_count; j++)
                 {
                   trak->sample_size_table[j] =
                     BE_32 (&trak_atom[i + 16 + j * 4]);
                   debug_atom_load ("      sample size %d: %d\n",
                                    j, trak->sample_size_table[j]);
                 }
             }
           else
             /* set the pointer to non-NULL to indicate that the atom type has
              * already been seen for this trak atom */
             trak->sample_size_table = (void *) -1;
 
         }
       else if (current_atom == STSS_ATOM)
         {
 
           /* there should only be one of these atoms */
           if (trak->sync_sample_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->sync_sample_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load
             ("    qt stss atom (sample sync atom): %d sync samples\n",
              trak->sync_sample_count);
 
           trak->sync_sample_table =
             (unsigned int *) malloc (trak->sync_sample_count *
                                      sizeof (unsigned int));
           if (!trak->sync_sample_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the sync sample table */
           for (j = 0; j < trak->sync_sample_count; j++)
             {
               trak->sync_sample_table[j] = BE_32 (&trak_atom[i + 12 + j * 4]);
               debug_atom_load
                 ("      sync sample %d: sample %d (%d) is a keyframe\n", j,
                  trak->sync_sample_table[j], trak->sync_sample_table[j] - 1);
             }
 
         }
       else if (current_atom == STCO_ATOM)
         {
 
           /* there should only be one of either stco or co64 */
           if (trak->chunk_offset_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->chunk_offset_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load
             ("    qt stco atom (32-bit chunk offset atom): %d chunk offsets\n",
              trak->chunk_offset_count);
 
           trak->chunk_offset_table =
             (int64_t *) malloc (trak->chunk_offset_count * sizeof (int64_t));
           if (!trak->chunk_offset_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the chunk offset table */
           for (j = 0; j < trak->chunk_offset_count; j++)
             {
               trak->chunk_offset_table[j] =
                 BE_32 (&trak_atom[i + 12 + j * 4]);
               debug_atom_load ("      chunk %d @ 0x%llX\n",
                                j, trak->chunk_offset_table[j]);
             }
 
         }
       else if (current_atom == CO64_ATOM)
         {
 
           /* there should only be one of either stco or co64 */
           if (trak->chunk_offset_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->chunk_offset_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load
             ("    qt co64 atom (64-bit chunk offset atom): %d chunk offsets\n",
              trak->chunk_offset_count);
 
           trak->chunk_offset_table =
             (int64_t *) malloc (trak->chunk_offset_count * sizeof (int64_t));
           if (!trak->chunk_offset_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the 64-bit chunk offset table */
           for (j = 0; j < trak->chunk_offset_count; j++)
             {
               trak->chunk_offset_table[j] =
                 BE_32 (&trak_atom[i + 12 + j * 8 + 0]);
               trak->chunk_offset_table[j] <<= 32;
               trak->chunk_offset_table[j] |=
                 BE_32 (&trak_atom[i + 12 + j * 8 + 4]);
               debug_atom_load ("      chunk %d @ 0x%llX\n",
                                j, trak->chunk_offset_table[j]);
             }
 
         }
       else if (current_atom == STSC_ATOM)
         {
 
           /* there should only be one of these atoms */
           if (trak->sample_to_chunk_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->sample_to_chunk_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load
             ("    qt stsc atom (sample-to-chunk atom): %d entries\n",
              trak->sample_to_chunk_count);
 
           trak->sample_to_chunk_table =
             (sample_to_chunk_table_t *) malloc (trak->sample_to_chunk_count *
                                                 sizeof
                                                 (sample_to_chunk_table_t));
           if (!trak->sample_to_chunk_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the sample to chunk table */
           for (j = 0; j < trak->sample_to_chunk_count; j++)
             {
               trak->sample_to_chunk_table[j].first_chunk =
                 BE_32 (&trak_atom[i + 12 + j * 12 + 0]);
               trak->sample_to_chunk_table[j].samples_per_chunk =
                 BE_32 (&trak_atom[i + 12 + j * 12 + 4]);
               debug_atom_load
                 ("      %d: %d samples/chunk starting at chunk %d (%d)\n", j,
                  trak->sample_to_chunk_table[j].samples_per_chunk,
                  trak->sample_to_chunk_table[j].first_chunk,
                  trak->sample_to_chunk_table[j].first_chunk - 1);
             }
 
         }
       else if (current_atom == STTS_ATOM)
         {
 
           /* there should only be one of these atoms */
           if (trak->time_to_sample_table)
             {
               last_error = QT_HEADER_TROUBLE;
               goto free_trak;
             }
 
           trak->time_to_sample_count = BE_32 (&trak_atom[i + 8]);
 
           debug_atom_load
             ("    qt stts atom (time-to-sample atom): %d entries\n",
              trak->time_to_sample_count);
 
           trak->time_to_sample_table = (time_to_sample_table_t *) malloc ((trak->time_to_sample_count + 1) * sizeof (time_to_sample_table_t));
           if (!trak->time_to_sample_table)
             {
               last_error = QT_NO_MEMORY;
               goto free_trak;
             }
 
           /* load the time to sample table */
           for (j = 0; j < trak->time_to_sample_count; j++)
             {
               trak->time_to_sample_table[j].count =
                 BE_32 (&trak_atom[i + 12 + j * 8 + 0]);
               trak->time_to_sample_table[j].duration =
                 BE_32 (&trak_atom[i + 12 + j * 8 + 4]);
               debug_atom_load ("      %d: count = %d, duration = %d\n",
                                j, trak->time_to_sample_table[j].count,
                                trak->time_to_sample_table[j].duration);
             }
           trak->time_to_sample_table[j].count = 0;      /* terminate with zero */
         }
     }
 
   return QT_OK;
 
   /* jump here to make sure everything is free'd and avoid leaking memory */
 free_trak:
   free (trak->edit_list_table);
   free (trak->chunk_offset_table);
   /* this pointer might have been set to -1 as a special case */
   if (trak->sample_size_table != (void *) -1)
     free (trak->sample_size_table);
   free (trak->sync_sample_table);
   free (trak->sample_to_chunk_table);
   free (trak->time_to_sample_table);
   free (trak->decoder_config);
   free (trak->stsd);
 
   return last_error;
 }
 
 /* Traverse through a reference atom and extract the URL and data rate. */
 static qt_error
 parse_reference_atom (reference_t * ref,
                       unsigned char *ref_atom, char *base_mrl)
 {
 
   int i, j;
   unsigned int ref_atom_size = BE_32 (&ref_atom[0]);
   qt_atom current_atom;
   unsigned int current_atom_size;
 
   /* initialize reference atom */
   ref->url = NULL;
   ref->data_rate = 0;
   ref->qtim_version = 0;
 
   /* traverse through the atom looking for the key atoms */
   for (i = ATOM_PREAMBLE_SIZE; i < ref_atom_size - 4; i++)
     {
 
       current_atom_size = BE_32 (&ref_atom[i - 4]);
       current_atom = BE_32 (&ref_atom[i]);
 
       if (current_atom == RDRF_ATOM)
         {
 
           /* if the URL starts with "http://", copy it */
           if (strncmp (&ref_atom[i + 12], "http://", 7) == 0)
             {
 
               /* URL is spec'd to terminate with a NULL; don't trust it */
               ref->url = xine_xmalloc (BE_32 (&ref_atom[i + 12]) + 1);
               strncpy (ref->url, &ref_atom[i + 16],
                        BE_32 (&ref_atom[i + 12]));
               ref->url[BE_32 (&ref_atom[i + 12]) - 1] = '\0';
 
             }
           else
             {
 
               int string_size =
                 strlen (base_mrl) + BE_32 (&ref_atom[i + 12]) + 1;
 
               /* otherwise, append relative URL to base MRL */
               ref->url = xine_xmalloc (string_size);
               strcpy (ref->url, base_mrl);
               strncat (ref->url, &ref_atom[i + 16],
                        BE_32 (&ref_atom[i + 12]));
               ref->url[string_size - 1] = '\0';
             }
 
           debug_atom_load ("    qt rdrf URL reference:\n      %s\n",
                            ref->url);
 
         }
       else if (current_atom == RMDR_ATOM)
         {
 
           /* load the data rate */
           ref->data_rate = BE_32 (&ref_atom[i + 8]);
           ref->data_rate *= 10;
 
           debug_atom_load ("    qt rmdr data rate = %lld\n", ref->data_rate);
 
         }
       else if (current_atom == RMVC_ATOM)
         {
 
           debug_atom_load ("    qt rmvc atom\n");
 
           /* search the rmvc atom for 'qtim'; 2 bytes will follow the qtim
            * chars so only search to 6 bytes to the end */
           for (j = 4; j < current_atom_size - 6; j++)
             {
 
               if (BE_32 (&ref_atom[i + j]) == QTIM_ATOM)
                 {
 
                   ref->qtim_version = BE_16 (&ref_atom[i + j + 4]);
                   debug_atom_load ("      qtim version = %04X\n",
                                    ref->qtim_version);
                 }
             }
         }
     }
 
   return QT_OK;
 }
 
 /* This is a little support function used to process the edit list when
  * building a frame table. */
 #define MAX_DURATION 0x7FFFFFFFFFFFFFFF
 static void
 get_next_edit_list_entry (qt_trak * trak,
                           int *edit_list_index,
                           unsigned int *edit_list_media_time,
                           int64_t * edit_list_duration,
                           unsigned int global_timescale)
 {
 
   /* if there is no edit list, set to max duration and get out */
   if (!trak->edit_list_table)
     {
 
       *edit_list_media_time = 0;
       *edit_list_duration = MAX_DURATION;
       debug_edit_list ("  qt: no edit list table, initial = %d, %lld\n",
                        *edit_list_media_time, *edit_list_duration);
       return;
 
     }
   else
     while (*edit_list_index < trak->edit_list_count)
       {
 
         /* otherwise, find an edit list entries whose media time != -1 */
         if (trak->edit_list_table[*edit_list_index].media_time != -1)
           {
 
             *edit_list_media_time =
               trak->edit_list_table[*edit_list_index].media_time;
             *edit_list_duration =
               trak->edit_list_table[*edit_list_index].track_duration;
 
             /* duration is in global timescale units; convert to trak timescale */
             *edit_list_duration *= trak->timescale;
             *edit_list_duration /= global_timescale;
 
             *edit_list_index = *edit_list_index + 1;
             break;
           }
 
         *edit_list_index = *edit_list_index + 1;
       }
 
   /* on the way out, check if this is the last edit list entry; if so,
    * don't let the duration expire (so set it to an absurdly large value)
    */
   if (*edit_list_index == trak->edit_list_count)
     *edit_list_duration = MAX_DURATION;
   debug_edit_list ("  qt: edit list table exists, initial = %d, %lld\n",
                    *edit_list_media_time, *edit_list_duration);
 }
 
 static qt_error
 build_frame_table (qt_trak * trak, unsigned int global_timescale)
 {
 
   int i, j;
   unsigned int frame_counter;
   unsigned int chunk_start, chunk_end;
   unsigned int samples_per_chunk;
   uint64_t current_offset;
   int64_t current_pts;
   unsigned int pts_index;
   unsigned int pts_index_countdown;
   unsigned int audio_frame_counter = 0;
   unsigned int edit_list_media_time;
   int64_t edit_list_duration;
   int64_t frame_duration = 0;
   unsigned int edit_list_index;
   unsigned int edit_list_pts_counter;
 
   /* AUDIO and OTHER frame types follow the same rules; VIDEO and vbr audio
    * frame types follow a different set */
   if ((trak->type == MEDIA_VIDEO) || (trak->properties.audio.vbr))
     {
 
       /* in this case, the total number of frames is equal to the number of
        * entries in the sample size table */
       trak->frame_count = trak->sample_size_count;
       trak->frames =
         (qt_frame *) malloc (trak->frame_count * sizeof (qt_frame));
       if (!trak->frames)
         return QT_NO_MEMORY;
       trak->current_frame = 0;
 
       /* initialize more accounting variables */
       frame_counter = 0;
       current_pts = 0;
       pts_index = 0;
       pts_index_countdown = trak->time_to_sample_table[pts_index].count;
 
       /* iterate through each start chunk in the stsc table */
       for (i = 0; i < trak->sample_to_chunk_count; i++)
         {
           /* iterate from the first chunk of the current table entry to
            * the first chunk of the next table entry */
           chunk_start = trak->sample_to_chunk_table[i].first_chunk;
           if (i < trak->sample_to_chunk_count - 1)
             chunk_end = trak->sample_to_chunk_table[i + 1].first_chunk;
           else
             /* if the first chunk is in the last table entry, iterate to the
                final chunk number (the number of offsets in stco table) */
             chunk_end = trak->chunk_offset_count + 1;
 
           /* iterate through each sample in a chunk */
           for (j = chunk_start - 1; j < chunk_end - 1; j++)
             {
 
               samples_per_chunk =
                 trak->sample_to_chunk_table[i].samples_per_chunk;
               current_offset = trak->chunk_offset_table[j];
               while (samples_per_chunk > 0)
                 {
 
                   /* figure out the offset and size */
                   trak->frames[frame_counter].offset = current_offset;
                   if (trak->sample_size)
                     {
                       trak->frames[frame_counter].size = trak->sample_size;
                       current_offset += trak->sample_size;
                     }
                   else
                     {
                       trak->frames[frame_counter].size =
                         trak->sample_size_table[frame_counter];
                       current_offset +=
                         trak->sample_size_table[frame_counter];
                     }
 
                   /* if there is no stss (sample sync) table, make all of the frames
                    * keyframes; otherwise, clear the keyframe bits for now */
                   if (trak->sync_sample_table)
                     trak->frames[frame_counter].keyframe = 0;
                   else
                     trak->frames[frame_counter].keyframe = 1;
 
                   /* figure out the pts situation */
                   trak->frames[frame_counter].pts = current_pts;
                   current_pts +=
                     trak->time_to_sample_table[pts_index].duration;
                   pts_index_countdown--;
                   /* time to refresh countdown? */
                   if (!pts_index_countdown)
                     {
                       pts_index++;
                       pts_index_countdown =
                         trak->time_to_sample_table[pts_index].count;
                     }
 
                   samples_per_chunk--;
                   frame_counter++;
                 }
             }
         }
 
       /* fill in the keyframe information */
       if (trak->sync_sample_table)
         {
           for (i = 0; i < trak->sync_sample_count; i++)
             trak->frames[trak->sync_sample_table[i] - 1].keyframe = 1;
         }
 
       /* initialize edit list considerations */
       edit_list_index = 0;
       get_next_edit_list_entry (trak, &edit_list_index,
                                 &edit_list_media_time, &edit_list_duration,
                                 global_timescale);
 
       /* fix up pts information w.r.t. the edit list table */
       edit_list_pts_counter = 0;
       for (i = 0; i < trak->frame_count; i++)
         {
 
           debug_edit_list ("    %d: (before) pts = %lld...", i,
                            trak->frames[i].pts);
 
           if (trak->frames[i].pts < edit_list_media_time)
             trak->frames[i].pts = edit_list_pts_counter;
           else
             {
               if (i < trak->frame_count - 1)
                 frame_duration =
                   (trak->frames[i + 1].pts - trak->frames[i].pts);
 
               debug_edit_list ("duration = %lld...", frame_duration);
               trak->frames[i].pts = edit_list_pts_counter;
               edit_list_pts_counter += frame_duration;
               edit_list_duration -= frame_duration;
             }
 
           debug_edit_list ("(fixup) pts = %lld...", trak->frames[i].pts);
 
           /* reload media time and duration */
           if (edit_list_duration <= 0)
             {
               get_next_edit_list_entry (trak, &edit_list_index,
                                         &edit_list_media_time,
                                         &edit_list_duration,
                                         global_timescale);
             }
 
           debug_edit_list ("(after) pts = %lld...\n", trak->frames[i].pts);
         }
 
       /* compute final pts values */
       for (i = 0; i < trak->frame_count; i++)
         {
           trak->frames[i].pts *= 90000;
           trak->frames[i].pts /= trak->timescale;
           debug_edit_list ("  final pts for sample %d = %lld\n", i,
                            trak->frames[i].pts);
         }
 
     }
   else
     {
 
       /* in this case, the total number of frames is equal to the number of
        * chunks */
       trak->frame_count = trak->chunk_offset_count;
       trak->frames =
         (qt_frame *) malloc (trak->frame_count * sizeof (qt_frame));
       if (!trak->frames)
         return QT_NO_MEMORY;
 
       if (trak->type == MEDIA_AUDIO)
         {
           /* iterate through each start chunk in the stsc table */
           for (i = 0; i < trak->sample_to_chunk_count; i++)
             {
               /* iterate from the first chunk of the current table entry to
                * the first chunk of the next table entry */
               chunk_start = trak->sample_to_chunk_table[i].first_chunk;
               if (i < trak->sample_to_chunk_count - 1)
                 chunk_end = trak->sample_to_chunk_table[i + 1].first_chunk;
               else
                 /* if the first chunk is in the last table entry, iterate to the
                    final chunk number (the number of offsets in stco table) */
                 chunk_end = trak->chunk_offset_count + 1;
 
               /* iterate through each sample in a chunk and fill in size and
                * pts information */
               for (j = chunk_start - 1; j < chunk_end - 1; j++)
                 {
 
                   /* figure out the pts for this chunk */
                   trak->frames[j].pts = audio_frame_counter;
                   trak->frames[j].pts *= 90000;
                   trak->frames[j].pts /= trak->timescale;
 
                   /* fetch the alleged chunk size according to the QT header */
                   trak->frames[j].size =
                     trak->sample_to_chunk_table[i].samples_per_chunk;
 
                   /* the chunk size is actually the audio frame count */
                   audio_frame_counter += trak->frames[j].size;
 
                   /* compute the actual chunk size */
                   trak->frames[j].size =
                     (trak->frames[j].size *
                      trak->properties.audio.channels) /
                     trak->properties.audio.samples_per_frame *
                     trak->properties.audio.bytes_per_frame;
                 }
             }
         }
 
       /* fill in the rest of the information for the audio samples */
       for (i = 0; i < trak->frame_count; i++)
         {
           trak->frames[i].offset = trak->chunk_offset_table[i];
           trak->frames[i].keyframe = 0;
           if (trak->type != MEDIA_AUDIO)
             trak->frames[i].pts = 0;
         }
     }
 
   return QT_OK;
 }
 
 /*
  * This function takes a pointer to a qt_info structure and a pointer to
  * a buffer containing an uncompressed moov atom. When the function
  * finishes successfully, qt_info will have a list of qt_frame objects,
  * ordered by offset.
  */
 static void
 parse_moov_atom (qt_info * info, unsigned char *moov_atom, int64_t bandwidth)
 {
   int i, j;
   unsigned int moov_atom_size = BE_32 (&moov_atom[0]);
   qt_atom current_atom;
   int string_size;
   unsigned int max_video_frames = 0;
   unsigned int max_audio_frames = 0;
 
   /* make sure this is actually a moov atom */
   if (BE_32 (&moov_atom[4]) != MOOV_ATOM)
     {
       info->last_error = QT_NO_MOOV_ATOM;
       return;
     }
 
   /* prowl through the moov atom looking for very specific targets */
   for (i = ATOM_PREAMBLE_SIZE; i < moov_atom_size - 4; i++)
     {
       current_atom = BE_32 (&moov_atom[i]);
 
       if (current_atom == MVHD_ATOM)
         {
           parse_mvhd_atom (info, &moov_atom[i - 4]);
           if (info->last_error != QT_OK)
             return;
           i += BE_32 (&moov_atom[i - 4]) - 4;
         }
       else if (current_atom == TRAK_ATOM)
         {
 
           /* create a new trak structure */
           info->trak_count++;
           info->traks = (qt_trak *) realloc (info->traks,
                                              info->trak_count *
                                              sizeof (qt_trak));
 
           parse_trak_atom (&info->traks[info->trak_count - 1],
                            &moov_atom[i - 4]);
           if (info->last_error != QT_OK)
             {
               info->trak_count--;
               return;
             }
           i += BE_32 (&moov_atom[i - 4]) - 4;
 
         }
       else if (current_atom == CPY_ATOM)
         {
 
           string_size = BE_16 (&moov_atom[i + 4]) + 1;
           info->copyright = realloc (info->copyright, string_size);
           strncpy (info->copyright, &moov_atom[i + 8], string_size - 1);
           info->copyright[string_size - 1] = 0;
 
         }
       else if (current_atom == DES_ATOM)
         {
 
           string_size = BE_16 (&moov_atom[i + 4]) + 1;
           info->description = realloc (info->description, string_size);
           strncpy (info->description, &moov_atom[i + 8], string_size - 1);
           info->description[string_size - 1] = 0;
 
         }
       else if (current_atom == CMT_ATOM)
         {
 
           string_size = BE_16 (&moov_atom[i + 4]) + 1;
           info->comment = realloc (info->comment, string_size);
           strncpy (info->comment, &moov_atom[i + 8], string_size - 1);
           info->comment[string_size - 1] = 0;
 
         }
       else if (current_atom == RMDA_ATOM)
         {
 
           /* create a new reference structure */
           info->reference_count++;
           info->references = (reference_t *) realloc (info->references,
                                                       info->reference_count *
                                                       sizeof (reference_t));
 
           parse_reference_atom (&info->references[info->reference_count - 1],
                                 &moov_atom[i - 4], info->base_mrl);
 
         }
     }
   debug_atom_load ("  qt: finished parsing moov atom\n");
 
   /* build frame tables corresponding to each trak */
   debug_frame_table ("  qt: preparing to build %d frame tables\n",
                      info->trak_count);
   for (i = 0; i < info->trak_count; i++)
     {
 
       debug_frame_table ("    qt: building frame table #%d (%s)\n", i,
                          (info->traks[i].type ==
                           MEDIA_VIDEO) ? "video" : "audio");
       build_frame_table (&info->traks[i], info->timescale);
 
       /* dump the frame table in debug mode */
       for (j = 0; j < info->traks[i].frame_count; j++)
         debug_frame_table ("      %d: %8X bytes @ %llX, %lld pts%s\n",
                            j,
                            info->traks[i].frames[j].size,
                            info->traks[i].frames[j].offset,
                            info->traks[i].frames[j].pts,
                            (info->traks[i].frames[j].
                             keyframe) ? " (keyframe)" : "");
 
       /* decide which audio trak and which video trak has the most frames */
       if ((info->traks[i].type == MEDIA_VIDEO) &&
           (info->traks[i].frame_count > max_video_frames))
         {
 
           info->video_trak = i;
           max_video_frames = info->traks[i].frame_count;
 
         }
       else if ((info->traks[i].type == MEDIA_AUDIO) &&
                (info->traks[i].frame_count > max_audio_frames))
         {
 
           info->audio_trak = i;
           max_audio_frames = info->traks[i].frame_count;
         }
     }
 
   /* check for references */
   if (info->reference_count > 0)
     {
 
       /* init chosen reference to the first entry */
       info->chosen_reference = 0;
 
       /* iterate through 1..n-1 reference entries and decide on the right one */
       for (i = 1; i < info->reference_count; i++)
         {
 
           if (info->references[i].qtim_version >
               info->references[info->chosen_reference].qtim_version)
             info->chosen_reference = i;
           else if ((info->references[i].data_rate <= bandwidth) &&
                    (info->references[i].data_rate >
                     info->references[info->chosen_reference].data_rate))
             info->chosen_reference = i;
         }
 
       debug_atom_load
         ("  qt: chosen reference is ref #%d, qtim version %04X, %lld bps\n      URL: %s\n",
          info->chosen_reference,
          info->references[info->chosen_reference].qtim_version,
          info->references[info->chosen_reference].data_rate,
          info->references[info->chosen_reference].url);
     }
 }
 
 static qt_error
 open_qt_file (qt_info * info, input_plugin_t * input, int64_t bandwidth)
 {
 
   unsigned char *moov_atom = NULL;
   off_t moov_atom_offset = -1;
   int64_t moov_atom_size = -1;
   unsigned char preview[MAX_PREVIEW_SIZE];
 
   /* zlib stuff */
   z_stream z_state;
   int z_ret_code;
   unsigned char *unzip_buffer;
 
   /* extract the base MRL if this is a http MRL */
   if (strncmp (input->get_mrl (input), "http://", 7) == 0)
     {
 
       char *slash;
 
       /* this will copy a few bytes too many, but no big deal */
       info->base_mrl = strdup (input->get_mrl (input));
       /* terminate the string after the last slash character */
       slash = strrchr (info->base_mrl, '/');
       if (slash)
         *(slash + 1) = '\0';
     }
 
   if ((input->get_capabilities (input) & INPUT_CAP_SEEKABLE))
     find_moov_atom (input, &moov_atom_offset, &moov_atom_size);
   else
     {
       input->get_optional_data (input, preview, INPUT_OPTIONAL_DATA_PREVIEW);
       if (BE_32 (&preview[4]) != MOOV_ATOM)
         {
           info->last_error = QT_NO_MOOV_ATOM;
           return info->last_error;
         }
       moov_atom_offset = 0;
       moov_atom_size = BE_32 (&preview[0]);
     }
 
   if (moov_atom_offset == -1)
     {
       info->last_error = QT_NO_MOOV_ATOM;
       return info->last_error;
     }
   info->moov_first_offset = moov_atom_offset;
 
   moov_atom = (unsigned char *) malloc (moov_atom_size);
   if (moov_atom == NULL)
     {
       info->last_error = QT_NO_MEMORY;
       return info->last_error;
     }
 
   /* seek to the start of moov atom */
   if (input->seek (input, info->moov_first_offset, SEEK_SET) !=
       info->moov_first_offset)
     {
       free (moov_atom);
       info->last_error = QT_FILE_READ_ERROR;
       return info->last_error;
     }
   if (input->read (input, moov_atom, moov_atom_size) != moov_atom_size)
     {
       free (moov_atom);
       info->last_error = QT_FILE_READ_ERROR;
       return info->last_error;
     }
 
   /* check if moov is compressed */
   if (BE_32 (&moov_atom[12]) == CMOV_ATOM)
     {
 
       info->compressed_header = 1;
 
       z_state.next_in = &moov_atom[0x28];
       z_state.avail_in = moov_atom_size - 0x28;
       z_state.avail_out = BE_32 (&moov_atom[0x24]);
       unzip_buffer = (unsigned char *) malloc (BE_32 (&moov_atom[0x24]));
       if (!unzip_buffer)
         {
           free (moov_atom);
           info->last_error = QT_NO_MEMORY;
           return info->last_error;
         }
 
       z_state.next_out = unzip_buffer;
       z_state.zalloc = (alloc_func) 0;
       z_state.zfree = (free_func) 0;
       z_state.opaque = (voidpf) 0;
 
       z_ret_code = inflateInit (&z_state);
       if (Z_OK != z_ret_code)
         {
           free (unzip_buffer);
           free (moov_atom);
           info->last_error = QT_ZLIB_ERROR;
           return info->last_error;
         }
 
       z_ret_code = inflate (&z_state, Z_NO_FLUSH);
       if ((z_ret_code != Z_OK) && (z_ret_code != Z_STREAM_END))
         {
           free (unzip_buffer);
           free (moov_atom);
           info->last_error = QT_ZLIB_ERROR;
           return info->last_error;
         }
 
       z_ret_code = inflateEnd (&z_state);
       if (Z_OK != z_ret_code)
         {
           free (unzip_buffer);
           free (moov_atom);
           info->last_error = QT_ZLIB_ERROR;
           return info->last_error;
         }
 
       /* replace the compressed moov atom with the decompressed atom */
       free (moov_atom);
       moov_atom = unzip_buffer;
       moov_atom_size = BE_32 (&moov_atom[0]);
     }
 
   if (!moov_atom)
     {
       info->last_error = QT_NO_MOOV_ATOM;
       return info->last_error;
     }
 
   /* write moov atom to disk if debugging option is turned on */
   dump_moov_atom (moov_atom, moov_atom_size);
 
   /* take apart the moov atom */
   parse_moov_atom (info, moov_atom, bandwidth);
   if (info->last_error != QT_OK)
     {
       free (moov_atom);
       return info->last_error;
     }
 
   free (moov_atom);
 
   return QT_OK;
 }
 
 /**********************************************************************
  * xine demuxer functions
  **********************************************************************/
 
 static int
 demux_qt_send_chunk (demux_plugin_t * this_gen)
 {
 
   demux_qt_t *this = (demux_qt_t *) this_gen;
   buf_element_t *buf = NULL;
   unsigned int i, j;
   unsigned int remaining_sample_bytes;
   int frame_duration;
   int first_buf;
   qt_trak *video_trak = NULL;
   qt_trak *audio_trak = NULL;
   int dispatch_audio;           /* boolean for deciding which trak to dispatch */
   int64_t pts_diff;
   xine_event_t uevent;
   xine_mrl_reference_data_t *data;
 
   /* check if it's time to send a reference up to the UI */
   if (this->qt->chosen_reference != -1)
     {
 
       uevent.type = XINE_EVENT_MRL_REFERENCE;
       uevent.stream = this->stream;
       uevent.data_length =
         strlen (this->qt->references[this->qt->chosen_reference].url) +
         sizeof (xine_mrl_reference_data_t);
       data = malloc (uevent.data_length);
       uevent.data = data;
       strcpy (data->mrl,
               this->qt->references[this->qt->chosen_reference].url);
       data->alternative = 0;
       xine_event_send (this->stream, &uevent);
 
       this->status = DEMUX_FINISHED;
       return this->status;
     }
 
   if (this->qt->video_trak != -1)
     {
       video_trak = &this->qt->traks[this->qt->video_trak];
     }
   if (this->qt->audio_trak != -1)
     {
       audio_trak = &this->qt->traks[this->qt->audio_trak];
     }
 
   if (!audio_trak && !video_trak)
     {
       /* something is really wrong if this case is reached */
       this->status = DEMUX_FINISHED;
       return this->status;
     }
 
   /* check if it is time to seek */
   if (this->qt->seek_flag)
     {
       this->qt->seek_flag = 0;
 
       /* if audio is present, send pts of current audio frame, otherwise
        * send current video frame pts */
       if (audio_trak)
         xine_demux_control_newpts (this->stream,
                                    audio_trak->frames[audio_trak->
                                                       current_frame].pts,
                                    BUF_FLAG_SEEK);
       else
         xine_demux_control_newpts (this->stream,
                                    video_trak->frames[video_trak->
                                                       current_frame].pts,
                                    BUF_FLAG_SEEK);
     }
 
   /* Decide the trak from which to dispatch a frame. Policy: Dispatch
    * the frames in offset order as much as possible. If the pts difference
    * between the current frames from the audio and video traks is too
    * wide, make an exception. This exception deals with non-interleaved
    * Quicktime files. */
   if (!audio_trak)
     {
 
       /* only video is present */
       dispatch_audio = 0;
       if (video_trak->current_frame >= video_trak->frame_count)
         {
           this->status = DEMUX_FINISHED;
           return this->status;
         }
 
     }
   else if (!video_trak)
     {
 
       /* only audio is present */
       dispatch_audio = 1;
       if (audio_trak->current_frame >= audio_trak->frame_count)
         {
           this->status = DEMUX_FINISHED;
           return this->status;
         }
 
     }
   else
     {
 
       /* both audio and video are present; start making some tough choices */
 
       /* check the frame count limits */
       if ((audio_trak->current_frame >= audio_trak->frame_count) &&
           (video_trak->current_frame >= video_trak->frame_count))
         {
 
           this->status = DEMUX_FINISHED;
           return this->status;
 
         }
       else if (video_trak->current_frame >= video_trak->frame_count)
         {
 
           dispatch_audio = 1;
 
         }
       else if (audio_trak->current_frame >= audio_trak->frame_count)
         {
 
           dispatch_audio = 0;
 
         }
       else
         {
 
           /* at this point, it is certain that both traks still have frames
            * yet to be dispatched */
           pts_diff = audio_trak->frames[audio_trak->current_frame].pts;
           pts_diff -= video_trak->frames[video_trak->current_frame].pts;
 
           if (pts_diff > MAX_PTS_DIFF)
             {
               /* if diff is +max_diff, audio is too far ahead of video */
               dispatch_audio = 0;
             }
           else if (pts_diff < -MAX_PTS_DIFF)
             {
               /* if diff is -max_diff, video is too far ahead of audio */
               dispatch_audio = 1;
             }
           else if (audio_trak->frames[audio_trak->current_frame].offset <
                    video_trak->frames[video_trak->current_frame].offset)
             {
               /* pts diff is not too wide, decide based on earlier offset */
               dispatch_audio = 1;
             }
           else
             {
               dispatch_audio = 0;
             }
         }
     }
 
   if (!dispatch_audio)
     {
       i = video_trak->current_frame++;
       remaining_sample_bytes = video_trak->frames[i].size;
       this->input->seek (this->input, video_trak->frames[i].offset, SEEK_SET);
 
       if (i + 1 < video_trak->frame_count)
         {
           /* frame duration is the pts diff between this video frame and
            * the next video frame */
           frame_duration = video_trak->frames[i + 1].pts;
           frame_duration -= video_trak->frames[i].pts;
         }
       else
         {
           /* give the last frame some fixed duration */
           frame_duration = 12000;
         }
 
       /* Due to the edit lists, some successive frames have the same pts
        * which would ordinarily cause frame_duration to be 0 which can
        * cause DIV-by-0 errors in the engine. Perform this little trick
        * to compensate. */
       if (!frame_duration)
         {
           frame_duration = 1;
           video_trak->properties.video.edit_list_compensation++;
         }
       else
         {
           frame_duration -=
             video_trak->properties.video.edit_list_compensation;
           video_trak->properties.video.edit_list_compensation = 0;
         }
 
       this->stream->stream_info[XINE_STREAM_INFO_FRAME_DURATION] =
         frame_duration;
 
       debug_video_demux
         ("  qt: sending off video frame %d from offset 0x%llX, %d bytes, %lld pts\n",
          i, video_trak->frames[i].offset, video_trak->frames[i].size,
          video_trak->frames[i].pts);
 
       while (remaining_sample_bytes)
         {
           buf = this->video_fifo->buffer_pool_alloc (this->video_fifo);
           buf->type = video_trak->properties.video.codec_buftype;
           buf->extra_info->input_pos =
             video_trak->frames[i].offset - this->data_start;
           buf->extra_info->input_length = this->data_size;
           buf->extra_info->input_time = video_trak->frames[i].pts / 90;
           buf->pts = video_trak->frames[i].pts;
 
           buf->decoder_flags |= BUF_FLAG_FRAMERATE;
           buf->decoder_info[0] = frame_duration;
 
           if (remaining_sample_bytes > buf->max_size)
             buf->size = buf->max_size;
           else
             buf->size = remaining_sample_bytes;
           remaining_sample_bytes -= buf->size;
 
           if (this->input->read (this->input, buf->content, buf->size) !=
               buf->size)
             {
               buf->free_buffer (buf);
               this->status = DEMUX_FINISHED;
               break;
             }
 
           if (video_trak->frames[i].keyframe)
             buf->decoder_flags |= BUF_FLAG_KEYFRAME;
           if (!remaining_sample_bytes)
             buf->decoder_flags |= BUF_FLAG_FRAME_END;
 
           this->video_fifo->put (this->video_fifo, buf);
         }
 
     }
   else
     {
       /* load an audio sample and packetize it */
       i = audio_trak->current_frame++;
 
       /* only go through with this procedure if audio_fifo exists */
       if (!this->audio_fifo)
         return this->status;
 
       remaining_sample_bytes = audio_trak->frames[i].size;
       this->input->seek (this->input, audio_trak->frames[i].offset, SEEK_SET);
 
       debug_audio_demux
         ("  qt: sending off audio frame %d from offset 0x%llX, %d bytes, %lld pts\n",
          i, audio_trak->frames[i].offset, audio_trak->frames[i].size,
          audio_trak->frames[i].pts);
 
       first_buf = 1;
       while (remaining_sample_bytes)
         {
           buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo);
           buf->type = audio_trak->properties.audio.codec_buftype;
           buf->extra_info->input_pos =
             audio_trak->frames[i].offset - this->data_start;
           buf->extra_info->input_length = this->data_size;
           /* The audio chunk is often broken up into multiple 8K buffers when
            * it is sent to the audio decoder. Only attach the proper timestamp
            * to the first buffer. This is for the linear PCM decoder which
            * turns around and sends out audio buffers as soon as they are
            * received. If 2 or more consecutive audio buffers are dispatched to
            * the audio out unit, the engine will compensate with pops. */
           if ((buf->type == BUF_AUDIO_LPCM_BE) ||
               (buf->type == BUF_AUDIO_LPCM_LE))
             {
               if (first_buf)
                 {
                   buf->extra_info->input_time =
                     audio_trak->frames[i].pts / 90;
                   buf->pts = audio_trak->frames[i].pts;
                   first_buf = 0;
                 }
               else
                 {
                   buf->extra_info->input_time = 0;
                   buf->pts = 0;
                 }
             }
           else
             {
               buf->extra_info->input_time = audio_trak->frames[i].pts / 90;
               buf->pts = audio_trak->frames[i].pts;
             }
 
           if (remaining_sample_bytes > buf->max_size)
             buf->size = buf->max_size;
           else
             buf->size = remaining_sample_bytes;
           remaining_sample_bytes -= buf->size;
 
           if (this->input->read (this->input, buf->content, buf->size) !=
               buf->size)
             {
               buf->free_buffer (buf);
               this->status = DEMUX_FINISHED;
               break;
             }
 
           /* Special case alert: If this is signed, 8-bit data, transform
            * the data to unsigned. */
           if ((audio_trak->properties.audio.bits == 8) &&
               ((audio_trak->properties.audio.codec_fourcc == TWOS_FOURCC) ||
                (audio_trak->properties.audio.codec_fourcc == SOWT_FOURCC)))
             for (j = 0; j < buf->size; j++)
               buf->content[j] += 0x80;
 
           if (!remaining_sample_bytes)
             {
               buf->decoder_flags |= BUF_FLAG_FRAME_END;
             }
 
           this->audio_fifo->put (this->audio_fifo, buf);
         }
     }
 
   return this->status;
 }
 
 static void
 demux_qt_send_headers (demux_plugin_t * this_gen)
 {
 
   demux_qt_t *this = (demux_qt_t *) this_gen;
   buf_element_t *buf;
   qt_trak *video_trak = NULL;
   qt_trak *audio_trak = NULL;
 
   /* for deciding data start and data size */
   int64_t first_video_offset = -1;
   int64_t last_video_offset = -1;
   int64_t first_audio_offset = -1;
   int64_t last_audio_offset = -1;
 
   this->video_fifo = this->stream->video_fifo;
   this->audio_fifo = this->stream->audio_fifo;
 
   this->status = DEMUX_OK;
 
   /* figure out where the data begins and ends */
   if (this->qt->video_trak != -1)
     {
       video_trak = &this->qt->traks[this->qt->video_trak];
       first_video_offset = video_trak->frames[0].offset;
       last_video_offset =
         video_trak->frames[video_trak->frame_count - 1].size +
         video_trak->frames[video_trak->frame_count - 1].offset;
     }
   if (this->qt->audio_trak != -1)
     {
       audio_trak = &this->qt->traks[this->qt->audio_trak];
       first_audio_offset = audio_trak->frames[0].offset;
       last_audio_offset =
         audio_trak->frames[audio_trak->frame_count - 1].size +
         audio_trak->frames[audio_trak->frame_count - 1].offset;
     }
 
   if (first_video_offset < first_audio_offset)
     this->data_start = first_video_offset;
   else
     this->data_start = first_audio_offset;
 
   if (last_video_offset > last_audio_offset)
     this->data_size = last_video_offset - this->data_size;
   else
     this->data_size = last_audio_offset - this->data_size;
 
   /* sort out the A/V information */
   if (this->qt->video_trak != -1)
     {
 
       this->bih.biSize = sizeof (this->bih);
       this->bih.biWidth = video_trak->properties.video.width;
       this->bih.biHeight = video_trak->properties.video.height;
       this->bih.biBitCount = video_trak->properties.video.depth;
 
       this->bih.biCompression = video_trak->properties.video.codec_fourcc;
       video_trak->properties.video.codec_buftype =
         fourcc_to_buf_video (this->bih.biCompression);
 
       /* hack: workaround a fourcc clash! 'mpg4' is used by MS and Sorenson
        * mpeg4 codecs (they are not compatible).
        */
       if (video_trak->properties.video.codec_buftype == BUF_VIDEO_MSMPEG4_V1)
         video_trak->properties.video.codec_buftype = BUF_VIDEO_MPEG4;
 
       if (!video_trak->properties.video.codec_buftype &&
           video_trak->properties.video.codec_fourcc)
         video_trak->properties.video.codec_buftype = BUF_VIDEO_UNKNOWN;
 
       this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = 1;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] =
         this->bih.biWidth;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] =
         this->bih.biHeight;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_FOURCC] =
         video_trak->properties.video.codec_fourcc;
 
     }
   else
     {
 
       memset (&this->bih, 0, sizeof (this->bih));
       this->bih.biSize = sizeof (this->bih);
       this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_VIDEO_FOURCC] = 0;
 
     }
 
   if (this->qt->audio_trak != -1)
     {
 
       audio_trak->properties.audio.codec_buftype =
         formattag_to_buf_audio (audio_trak->properties.audio.codec_fourcc);
 
       if (!audio_trak->properties.audio.codec_buftype &&
           audio_trak->properties.audio.codec_fourcc)
         audio_trak->properties.audio.codec_buftype = BUF_AUDIO_UNKNOWN;
 
       this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = 1;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_CHANNELS] =
         audio_trak->properties.audio.channels;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_SAMPLERATE] =
         audio_trak->properties.audio.sample_rate;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_BITS] =
         audio_trak->properties.audio.bits;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_FOURCC] =
         audio_trak->properties.audio.codec_fourcc;
 
     }
   else
     {
 
       this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_CHANNELS] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_SAMPLERATE] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_BITS] = 0;
       this->stream->stream_info[XINE_STREAM_INFO_AUDIO_FOURCC] = 0;
 
     }
 
   /* copy over the meta information like artist and title */
   if (this->qt->copyright)
     this->stream->meta_info[XINE_META_INFO_ARTIST] =
       strdup (this->qt->copyright);
   if (this->qt->description)
     this->stream->meta_info[XINE_META_INFO_TITLE] =
       strdup (this->qt->description);
   if (this->qt->comment)
     this->stream->meta_info[XINE_META_INFO_COMMENT] =
       strdup (this->qt->comment);
 
   /* send start buffers */
   xine_demux_control_start (this->stream);
 
   /* send init info to decoders */
   if (video_trak && (video_trak->properties.video.codec_buftype))
     {
       buf = this->video_fifo->buffer_pool_alloc (this->video_fifo);
       buf->decoder_flags = BUF_FLAG_HEADER;
       buf->decoder_info[0] = 0;
       /* initial video step; not necessary since each QT frame has its own
        * duration, but set it non-zero as a matter of custom */
       buf->decoder_info[1] = 3000;
       memcpy (buf->content, &this->bih, sizeof (this->bih));
       buf->size = sizeof (this->bih);
       buf->type = video_trak->properties.video.codec_buftype;
       this->video_fifo->put (this->video_fifo, buf);
 
       /* send header info to decoder. some mpeg4 streams need this */
       if (video_trak->decoder_config)
         {
           buf = this->video_fifo->buffer_pool_alloc (this->video_fifo);
           buf->type = video_trak->properties.video.codec_buftype;
           buf->size = video_trak->decoder_config_len;
           buf->content = video_trak->decoder_config;
           this->video_fifo->put (this->video_fifo, buf);
         }
 
       /* send off the palette, if there is one */
       if (video_trak->properties.video.palette_count)
         {
           buf = this->video_fifo->buffer_pool_alloc (this->video_fifo);
           buf->decoder_flags = BUF_FLAG_SPECIAL;
           buf->decoder_info[1] = BUF_SPECIAL_PALETTE;
           buf->decoder_info[2] = video_trak->properties.video.palette_count;
           buf->decoder_info_ptr[2] = &video_trak->properties.video.palette;
           buf->size = 0;
           buf->type = video_trak->properties.video.codec_buftype;
           this->video_fifo->put (this->video_fifo, buf);
         }
 
       /* send stsd to the decoder */
       buf = this->video_fifo->buffer_pool_alloc (this->video_fifo);
       buf->decoder_flags = BUF_FLAG_SPECIAL;
       buf->decoder_info[1] = BUF_SPECIAL_STSD_ATOM;
       buf->decoder_info[2] = video_trak->stsd_size;
       buf->decoder_info_ptr[2] = video_trak->stsd;
       buf->size = 0;
       buf->type = video_trak->properties.video.codec_buftype;
       this->video_fifo->put (this->video_fifo, buf);
     }
 
   if ((this->qt->audio_trak != -1) &&
       (audio_trak->properties.audio.codec_buftype) && this->audio_fifo)
     {
 
       buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo);
       buf->type = audio_trak->properties.audio.codec_buftype;
       buf->decoder_flags = BUF_FLAG_HEADER;
       buf->decoder_info[0] = 0;
       buf->decoder_info[1] = audio_trak->properties.audio.sample_rate;
       buf->decoder_info[2] = audio_trak->properties.audio.bits;
       buf->decoder_info[3] = audio_trak->properties.audio.channels;
       buf->content = (void *) &audio_trak->properties.audio.wave;
       buf->size = sizeof (audio_trak->properties.audio.wave);
       this->audio_fifo->put (this->audio_fifo, buf);
 
       if (audio_trak->decoder_config)
         {
           buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo);
           buf->type = audio_trak->properties.audio.codec_buftype;
           buf->size = 0;
           buf->decoder_flags = BUF_FLAG_SPECIAL;
           buf->decoder_info[1] = BUF_SPECIAL_DECODER_CONFIG;
           buf->decoder_info[2] = audio_trak->decoder_config_len;
           buf->decoder_info_ptr[2] = audio_trak->decoder_config;
           this->audio_fifo->put (this->audio_fifo, buf);
         }
 
       /* send stsd to the decoder */
       buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo);
       buf->decoder_flags = BUF_FLAG_SPECIAL;
       buf->decoder_info[1] = BUF_SPECIAL_STSD_ATOM;
       buf->decoder_info[2] = audio_trak->stsd_size;
       buf->decoder_info_ptr[2] = audio_trak->stsd;
       buf->size = 0;
       buf->type = audio_trak->properties.audio.codec_buftype;
       this->audio_fifo->put (this->audio_fifo, buf);
 
     }
 }
 
 /* support function that performs a binary seek on a trak; returns the
  * demux status */
 static int
 binary_seek (qt_trak * trak, off_t start_pos, int start_time)
 {
 
   int best_index;
   int left, middle, right;
   int found;
 
   /* perform a binary search on the trak, testing the offset
    * boundaries first; offset request has precedent over time request */
   if (start_pos)
     {
       if (start_pos <= trak->frames[0].offset)
         best_index = 0;
       else if (start_pos >= trak->frames[trak->frame_count - 1].offset)
         return DEMUX_FINISHED;
       else
         {
           left = 0;
           right = trak->frame_count - 1;
           found = 0;
 
           while (!found)
             {
               middle = (left + right + 1) / 2;
               if ((start_pos >= trak->frames[middle].offset) &&
                   (start_pos < trak->frames[middle + 1].offset))
                 {
                   found = 1;
                 }
               else if (start_pos < trak->frames[middle].offset)
                 {
                   right = middle - 1;
                 }
               else
                 {
                   left = middle;
                 }
             }
 
           best_index = middle;
         }
     }
   else
     {
       int64_t pts = 90000 * start_time;
 
       if (pts <= trak->frames[0].pts)
         best_index = 0;
       else if (pts >= trak->frames[trak->frame_count - 1].pts)
         return DEMUX_FINISHED;
       else
         {
           left = 0;
           right = trak->frame_count - 1;
           do
             {
               middle = (left + right + 1) / 2;
               if (pts < trak->frames[middle].pts)
                 {
                   right = (middle - 1);
                 }
               else
                 {
                   left = middle;
                 }
             }
           while (left < right);
 
           best_index = left;
         }
     }
 
   trak->current_frame = best_index;
   return DEMUX_OK;
 }
 
 static int
 demux_qt_seek (demux_plugin_t * this_gen, off_t start_pos, int start_time)
 {
 
   demux_qt_t *this = (demux_qt_t *) this_gen;
   qt_trak *video_trak = NULL;
   qt_trak *audio_trak = NULL;
 
   int64_t keyframe_pts;
 
   /* short-circuit any attempts to seek in a non-seekable stream, including
    * seeking in the forward direction; this may change later */
   if ((this->input->get_capabilities (this->input) & INPUT_CAP_SEEKABLE) == 0)
     {
       this->qt->seek_flag = 1;
       this->status = DEMUX_OK;
       return this->status;
     }
 
   /* if there is a video trak, position it as close as possible to the
    * requested position */
   if (this->qt->video_trak != -1)
     {
       video_trak = &this->qt->traks[this->qt->video_trak];
       this->status = binary_seek (video_trak, start_pos, start_time);
       if (this->status != DEMUX_OK)
         return this->status;
     }
 
   if (this->qt->audio_trak != -1)
     {
       audio_trak = &this->qt->traks[this->qt->audio_trak];
       this->status = binary_seek (audio_trak, start_pos, start_time);
       if (this->status != DEMUX_OK)
         return this->status;
     }
 
   /* search back in the video trak for the nearest keyframe */
   if (video_trak)
     while (video_trak->current_frame)
       {
         if (video_trak->frames[video_trak->current_frame].keyframe)
           {
             break;
           }
         video_trak->current_frame--;
       }
 
   /* not done yet; now that the nearest keyframe has been found, seek
    * back to the first audio frame that has a pts less than or equal to
    * that of the keyframe; do not go through with this process there is
    * no video trak */
   if (audio_trak && video_trak)
     {
       keyframe_pts = video_trak->frames[video_trak->current_frame].pts;
       while (audio_trak->current_frame)
         {
           if (audio_trak->frames[audio_trak->current_frame].pts <
               keyframe_pts)
             {
               break;
             }
           audio_trak->current_frame--;
         }
     }
 
   this->qt->seek_flag = 1;
   this->status = DEMUX_OK;
 
   /*
    * do only flush if already running (seeking).
    * otherwise decoder_config is flushed too.
    */
   if (this->stream->demux_thread_running)
     xine_demux_flush_engine (this->stream);
 
   return this->status;
 }
 
 static void
 demux_qt_dispose (demux_plugin_t * this_gen)
 {
   demux_qt_t *this = (demux_qt_t *) this_gen;
 
   free_qt_info (this->qt);
   free (this);
 }
 
 static int
 demux_qt_get_status (demux_plugin_t * this_gen)
 {
   demux_qt_t *this = (demux_qt_t *) this_gen;
 
   return this->status;
 }
 
 static int
 demux_qt_get_stream_length (demux_plugin_t * this_gen)
 {
 
   demux_qt_t *this = (demux_qt_t *) this_gen;
 
   return (int) ((int64_t) 1000 * this->qt->duration / this->qt->timescale);
 }
 
 static uint32_t
 demux_qt_get_capabilities (demux_plugin_t * this_gen)
 {
   return DEMUX_CAP_NOCAP;
 }
 
 static int
 demux_qt_get_optional_data (demux_plugin_t * this_gen,
                             void *data, int data_type)
 {
   return DEMUX_OPTIONAL_UNSUPPORTED;
 }
 
 static demux_plugin_t *
 open_plugin (demux_class_t * class_gen, xine_stream_t * stream,
              input_plugin_t * input_gen)
 {
 
   input_plugin_t *input = (input_plugin_t *) input_gen;
   demux_qt_t *this;
   xine_cfg_entry_t entry;
 
   if ((input->get_capabilities (input) & INPUT_CAP_BLOCK))
     {
       return NULL;
     }
 
   this = xine_xmalloc (sizeof (demux_qt_t));
   this->stream = stream;
   this->input = input;
 
   /* fetch bandwidth config */
   this->bandwidth = 0x7FFFFFFFFFFFFFFF; /* assume infinite bandwidth */
   if (xine_config_lookup_entry (stream->xine, "input.mms_network_bandwidth",
                                 &entry))
     {
       if ((entry.num_value >= 0) && (entry.num_value <= 11))
         this->bandwidth = bandwidths[entry.num_value];
     }
 
   this->demux_plugin.send_headers = demux_qt_send_headers;
   this->demux_plugin.send_chunk = demux_qt_send_chunk;
   this->demux_plugin.seek = demux_qt_seek;
   this->demux_plugin.dispose = demux_qt_dispose;
   this->demux_plugin.get_status = demux_qt_get_status;
   this->demux_plugin.get_stream_length = demux_qt_get_stream_length;
   this->demux_plugin.get_video_frame = NULL;
   this->demux_plugin.got_video_frame_cb = NULL;
   this->demux_plugin.get_capabilities = demux_qt_get_capabilities;
   this->demux_plugin.get_optional_data = demux_qt_get_optional_data;
   this->demux_plugin.demux_class = class_gen;
 
   this->status = DEMUX_FINISHED;
 
   switch (stream->content_detection_method)
     {
 
     case METHOD_BY_CONTENT:
 
       if (!is_qt_file (this->input))
         {
           free (this);
           return NULL;
         }
       if ((this->qt = create_qt_info ()) == NULL)
         {
           free (this);
           return NULL;
         }
       if (open_qt_file (this->qt, this->input, this->bandwidth) != QT_OK)
         {
           free_qt_info (this->qt);
           free (this);
           return NULL;
         }
 
       break;
 
     case METHOD_BY_EXTENSION:
       {
         char *ending, *mrl;
 
         mrl = input->get_mrl (input);
 
         ending = strrchr (mrl, '.');
 
         if (!ending)
           {
             free (this);
             return NULL;
           }
 
         if (strncasecmp (ending, ".mov", 4) &&
             strncasecmp (ending, ".qt", 3) && strncasecmp (ending, ".mp4", 4))
           {
             free (this);
             return NULL;
           }
       }
 
       /* we want to fall through here */
     case METHOD_EXPLICIT:
       {
 
         if (!is_qt_file (this->input))
           {
             free (this);
             return NULL;
           }
         if ((this->qt = create_qt_info ()) == NULL)
           {
             free (this);
             return NULL;
           }
         if (open_qt_file (this->qt, this->input, this->bandwidth) != QT_OK)
           {
             free_qt_info (this->qt);
             free (this);
             return NULL;
           }
       }
       break;
 
     default:
       free (this);
       return NULL;
     }
 
   strncpy (this->last_mrl, input->get_mrl (input), 1024);
 
   return &this->demux_plugin;
 }
 
 static char *
 get_description (demux_class_t * this_gen)
 {
   return "Apple Quicktime (MOV) and MPEG-4 demux plugin";
 }
 
 static char *
 get_identifier (demux_class_t * this_gen)
 {
   return "MOV/MPEG-4";
 }
 
 static char *
 get_extensions (demux_class_t * this_gen)
 {
   return "mov qt mp4";
 }
 
 static char *
 get_mimetypes (demux_class_t * this_gen)
 {
   return "video/quicktime: mov,qt: Quicktime animation;"
     "video/x-quicktime: mov,qt: Quicktime animation;"
     "application/x-quicktimeplayer: qtl: Quicktime list";
 }
 
 static void
 class_dispose (demux_class_t * this_gen)
 {
 
   demux_qt_class_t *this = (demux_qt_class_t *) this_gen;
 
   free (this);
 }
 
 static void *
 init_plugin (xine_t * xine, void *data)
 {
 
   demux_qt_class_t *this;
 
   this = xine_xmalloc (sizeof (demux_qt_class_t));
   this->config = xine->config;
   this->xine = xine;
 
   this->demux_class.open_plugin = open_plugin;
   this->demux_class.get_description = get_description;
   this->demux_class.get_identifier = get_identifier;
   this->demux_class.get_mimetypes = get_mimetypes;
   this->demux_class.get_extensions = get_extensions;
   this->demux_class.dispose = class_dispose;
 
   return this;
 }
 
 /*
  * exported plugin catalog entry
  */
 
 plugin_info_t xine_plugin_info[] = {
   /* type, API, "name", version, special_info, init_function */
   {PLUGIN_DEMUX, 20, "quicktime", XINE_VERSION_CODE, NULL, init_plugin}
   ,
   {PLUGIN_NONE, 0, "", 0, NULL, NULL}
 };