quicktime/avi_idx1.c

   1 #include "funcprotos.h"
   2 #include "quicktime.h"
   3
   4
   5
   6 typedef struct
   7 {
   8         char tag[4];
   9         int32_t flags;
  10         int32_t offset;
  11         int32_t size;
  12 } avi_tag_t;
  13
  14
  15
  16 static int is_keyframe(quicktime_trak_t *trak, int frame)
  17 {
  18         int i;
  19         quicktime_stss_t *stss = &trak->mdia.minf.stbl.stss;
  20         frame++;
  21         for(i = 0; i < stss->total_entries; i++)
  22         {
  23                 if(stss->table[i].sample == frame) return 1;
  24         }
  25         return 0;
  26 }
  27
  28
  29 void quicktime_delete_idx1(quicktime_idx1_t *idx1)
  30 {
  31         if(idx1->table) free(idx1->table);
  32 }
  33
  34 void quicktime_read_idx1(quicktime_t *file,
  35         quicktime_riff_t *riff,
  36         quicktime_atom_t *parent_atom)
  37 {
  38         int i;
  39         quicktime_riff_t *first_riff = file->riff[0];
  40         quicktime_hdrl_t *hdrl = &first_riff->hdrl;
  41         quicktime_idx1_t *idx1 = &riff->idx1;
  42
  43 //printf("quicktime_read_idx1 1 %llx\n", quicktime_position(file));
  44
  45 // Allocate table.
  46         idx1->table_size = (parent_atom->end - quicktime_position(file)) / 16;
  47         idx1->table_allocation = idx1->table_size;
  48         idx1->table = calloc(sizeof(quicktime_idx1table_t), idx1->table_size);
  49 //printf("quicktime_read_idx1 10\n");
  50
  51 // Store it in idx1 table now.
  52 // Wait for full ix table discovery before converting to stco.
  53         for(i = 0; i < idx1->table_size; i++)
  54         {
  55                 quicktime_idx1table_t *idx1table = idx1->table + i;
  56
  57                 quicktime_read_data(file, idx1table->tag, 4);
  58                 idx1table->flags = quicktime_read_int32_le(file);
  59                 idx1table->offset = quicktime_read_int32_le(file);
  60                 idx1table->size = quicktime_read_int32_le(file);
  61         }
  62
  63 //printf("quicktime_read_idx1 100\n");
  64
  65
  66
  67
  68
  69
  70
  71 }
  72
  73 void quicktime_write_idx1(quicktime_t *file,
  74         quicktime_idx1_t *idx1)
  75 {
  76         int i;
  77         quicktime_idx1table_t *table = idx1->table;
  78         int table_size = idx1->table_size;
  79
  80
  81
  82 // Write table
  83         quicktime_atom_write_header(file, &idx1->atom, "idx1");
  84
  85         for(i = 0; i < table_size; i++)
  86         {
  87                 quicktime_idx1table_t *entry = &table[i];
  88                 quicktime_write_char32(file, entry->tag);
  89                 quicktime_write_int32_le(file, entry->flags);
  90                 quicktime_write_int32_le(file, entry->offset);
  91                 quicktime_write_int32_le(file, entry->size);
  92         }
  93
  94
  95         quicktime_atom_write_footer(file, &idx1->atom);
  96 }
  97
  98 void quicktime_set_idx1_keyframe(quicktime_t *file,
  99         quicktime_trak_t *trak,
 100         int new_keyframe)
 101 {
 102         quicktime_riff_t *riff = file->riff[0];
 103         quicktime_hdrl_t *hdrl = &riff->hdrl;
 104         quicktime_strl_t *strl = hdrl->strl[trak->tkhd.track_id - 1];
 105         char *tag = strl->tag;
 106         quicktime_idx1_t *idx1 = &riff->idx1;
 107         int i;
 108         int counter = -1;
 109
 110 // Search through entire index for right numbered tag.
 111 // Since all the tracks are combined in the same index, this is unavoidable.
 112         for(i = 0; i < idx1->table_size; i++)
 113         {
 114                 quicktime_idx1table_t *idx1_table = &idx1->table[i];
 115                 if(!memcmp(idx1_table->tag, tag, 4))
 116                 {
 117                         counter++;
 118                         if(counter == new_keyframe)
 119                         {
 120                                 idx1_table->flags |= AVI_KEYFRAME;
 121                                 break;
 122                         }
 123                 }
 124         }
 125 }
 126
 127 void quicktime_update_idx1table(quicktime_t *file,
 128         quicktime_trak_t *trak,
 129         int offset,
 130         int size)
 131 {
 132         quicktime_riff_t *riff = file->riff[0];
 133         quicktime_hdrl_t *hdrl = &riff->hdrl;
 134         quicktime_strl_t *strl = hdrl->strl[trak->tkhd.track_id - 1];
 135         char *tag = strl->tag;
 136         quicktime_idx1_t *idx1 = &riff->idx1;
 137         quicktime_movi_t *movi = &riff->movi;
 138         quicktime_idx1table_t *idx1_table;
 139         quicktime_stss_t *stss = &trak->mdia.minf.stbl.stss;
 140         uint32_t flags = 0;
 141         int i;
 142         int keyframe_frame = idx1->table_size + 1;
 143
 144 // Set flag for keyframe
 145         for(i = stss->total_entries - 1; i >= 0; i--)
 146         {
 147                 if(stss->table[i].sample == keyframe_frame)
 148                 {
 149                         flags |= AVI_KEYFRAME;
 150                         break;
 151                 }
 152                 else
 153                 if(stss->table[i].sample < keyframe_frame)
 154                 {
 155                         break;
 156                 }
 157         }
 158
 159
 160 // Allocation
 161         if(idx1->table_size >= idx1->table_allocation)
 162         {
 163                 quicktime_idx1table_t *old_table = idx1->table;
 164                 int new_allocation = idx1->table_allocation * 2;
 165                 if(new_allocation < 1) new_allocation = 1;
 166                 idx1->table = calloc(1, sizeof(quicktime_idx1table_t) * new_allocation);
 167                 if(old_table)
 168                 {
 169                         memcpy(idx1->table, old_table, sizeof(quicktime_idx1table_t) * idx1->table_size);
 170                         free(old_table);
 171                 }
 172                 idx1->table_allocation = new_allocation;
 173         }
 174
 175
 176 // Appendage
 177         idx1_table = &idx1->table[idx1->table_size];
 178         memcpy(idx1_table->tag, tag, 4);
 179         idx1_table->flags = flags;
 180         idx1_table->offset = offset - 8 - movi->atom.start;
 181         idx1_table->size = size;
 182         idx1->table_size++;
 183 }
 184
 185
 186
 187