qt-faststart.c 11.1 KB
Newer Older
1
/*
2
 * qt-faststart.c, v0.2
3 4 5 6 7 8 9
 * by Mike Melanson (melanson@pcisys.net)
 * This file is placed in the public domain. Use the program however you
 * see fit.
 *
 * This utility rearranges a Quicktime file such that the moov atom
 * is in front of the data, thus facilitating network streaming.
 *
10
 * To compile this program, start from the base directory from which you
11
 * are building Libav and type:
12 13 14 15
 *  make tools/qt-faststart
 * The qt-faststart program will be built in the tools/ directory. If you
 * do not build the program in this manner, correct results are not
 * guaranteed, particularly on 64-bit platforms.
16 17 18 19 20 21 22 23 24 25 26 27 28 29
 * Invoke the program with:
 *  qt-faststart <infile.mov> <outfile.mov>
 *
 * Notes: Quicktime files can come in many configurations of top-level
 * atoms. This utility stipulates that the very last atom in the file needs
 * to be a moov atom. When given such a file, this utility will rearrange
 * the top-level atoms by shifting the moov atom from the back of the file
 * to the front, and patch the chunk offsets along the way. This utility
 * presently only operates on uncompressed moov atoms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
30
#include <string.h>
31

32 33 34 35 36
#ifdef __MINGW32__
#define fseeko(x,y,z)  fseeko64(x,y,z)
#define ftello(x)      ftello64(x)
#endif

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
#define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1])
#define BE_32(x) ((((uint8_t*)(x))[0] << 24) | \
                  (((uint8_t*)(x))[1] << 16) | \
                  (((uint8_t*)(x))[2] << 8) | \
                   ((uint8_t*)(x))[3])
#define BE_64(x) (((uint64_t)(((uint8_t*)(x))[0]) << 56) | \
                  ((uint64_t)(((uint8_t*)(x))[1]) << 48) | \
                  ((uint64_t)(((uint8_t*)(x))[2]) << 40) | \
                  ((uint64_t)(((uint8_t*)(x))[3]) << 32) | \
                  ((uint64_t)(((uint8_t*)(x))[4]) << 24) | \
                  ((uint64_t)(((uint8_t*)(x))[5]) << 16) | \
                  ((uint64_t)(((uint8_t*)(x))[6]) << 8) | \
                  ((uint64_t)((uint8_t*)(x))[7]))

#define BE_FOURCC( ch0, ch1, ch2, ch3 )             \
        ( (uint32_t)(unsigned char)(ch3) |          \
        ( (uint32_t)(unsigned char)(ch2) << 8 ) |   \
        ( (uint32_t)(unsigned char)(ch1) << 16 ) |  \
        ( (uint32_t)(unsigned char)(ch0) << 24 ) )

#define QT_ATOM BE_FOURCC
/* 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')
68
#define UUID_ATOM QT_ATOM('u', 'u', 'i', 'd')
69 70 71 72 73 74 75 76 77 78

#define CMOV_ATOM QT_ATOM('c', 'm', 'o', 'v')
#define STCO_ATOM QT_ATOM('s', 't', 'c', 'o')
#define CO64_ATOM QT_ATOM('c', 'o', '6', '4')

#define ATOM_PREAMBLE_SIZE 8
#define COPY_BUFFER_SIZE 1024

int main(int argc, char *argv[])
{
79 80
    FILE *infile  = NULL;
    FILE *outfile = NULL;
81 82
    unsigned char atom_bytes[ATOM_PREAMBLE_SIZE];
    uint32_t atom_type = 0;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
83
    uint64_t atom_size = 0;
84
    uint64_t atom_offset = 0;
85
    uint64_t last_offset;
86
    unsigned char *moov_atom = NULL;
87
    unsigned char *ftyp_atom = NULL;
88
    uint64_t moov_atom_size;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
89
    uint64_t ftyp_atom_size = 0;
90 91 92
    uint64_t i, j;
    uint32_t offset_count;
    uint64_t current_offset;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
93
    uint64_t start_offset = 0;
94 95 96 97 98 99 100 101
    unsigned char copy_buffer[COPY_BUFFER_SIZE];
    int bytes_to_copy;

    if (argc != 3) {
        printf ("Usage: qt-faststart <infile.mov> <outfile.mov>\n");
        return 0;
    }

102 103 104 105 106
    if (!strcmp(argv[1], argv[2])) {
        fprintf(stderr, "input and output files need to be different\n");
        return 1;
    }

107 108 109
    infile = fopen(argv[1], "rb");
    if (!infile) {
        perror(argv[1]);
110
        goto error_out;
111 112 113 114 115 116 117 118
    }

    /* traverse through the atoms in the file to make sure that 'moov' is
     * at the end */
    while (!feof(infile)) {
        if (fread(atom_bytes, ATOM_PREAMBLE_SIZE, 1, infile) != 1) {
            break;
        }
Baptiste Coudurier's avatar
Baptiste Coudurier committed
119
        atom_size = (uint32_t)BE_32(&atom_bytes[0]);
120 121
        atom_type = BE_32(&atom_bytes[4]);

Baptiste Coudurier's avatar
Baptiste Coudurier committed
122 123 124
        /* keep ftyp atom */
        if (atom_type == FTYP_ATOM) {
            ftyp_atom_size = atom_size;
125
            free(ftyp_atom);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
126 127
            ftyp_atom = malloc(ftyp_atom_size);
            if (!ftyp_atom) {
128
                printf ("could not allocate %"PRIu64" byte for ftyp atom\n",
Baptiste Coudurier's avatar
Baptiste Coudurier committed
129
                        atom_size);
130
                goto error_out;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
131 132 133 134
            }
            fseeko(infile, -ATOM_PREAMBLE_SIZE, SEEK_CUR);
            if (fread(ftyp_atom, atom_size, 1, infile) != 1) {
                perror(argv[1]);
135
                goto error_out;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
136 137
            }
            start_offset = ftello(infile);
138
        } else {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
139

140 141 142 143 144 145
        /* 64-bit special case */
        if (atom_size == 1) {
            if (fread(atom_bytes, ATOM_PREAMBLE_SIZE, 1, infile) != 1) {
                break;
            }
            atom_size = BE_64(&atom_bytes[0]);
146
            fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE * 2, SEEK_CUR);
147
        } else {
148
            fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE, SEEK_CUR);
149 150
        }
    }
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
        printf("%c%c%c%c %10"PRIu64" %"PRIu64"\n",
               (atom_type >> 24) & 255,
               (atom_type >> 16) & 255,
               (atom_type >>  8) & 255,
               (atom_type >>  0) & 255,
               atom_offset,
               atom_size);
        if ((atom_type != FREE_ATOM) &&
            (atom_type != JUNK_ATOM) &&
            (atom_type != MDAT_ATOM) &&
            (atom_type != MOOV_ATOM) &&
            (atom_type != PNOT_ATOM) &&
            (atom_type != SKIP_ATOM) &&
            (atom_type != WIDE_ATOM) &&
            (atom_type != PICT_ATOM) &&
            (atom_type != UUID_ATOM) &&
            (atom_type != FTYP_ATOM)) {
            printf ("encountered non-QT top-level atom (is this a Quicktime file?)\n");
            break;
        }
        atom_offset += atom_size;
172 173 174 175 176 177

        /* The atom header is 8 (or 16 bytes), if the atom size (which
         * includes these 8 or 16 bytes) is less than that, we won't be
         * able to continue scanning sensibly after this atom, so break. */
        if (atom_size < 8)
            break;
178
    }
179 180 181

    if (atom_type != MOOV_ATOM) {
        printf ("last atom in file was not a moov atom\n");
182
        free(ftyp_atom);
183 184 185 186 187 188
        fclose(infile);
        return 0;
    }

    /* moov atom was, in fact, the last atom in the chunk; load the whole
     * moov atom */
189 190
    fseeko(infile, -atom_size, SEEK_END);
    last_offset = ftello(infile);
191 192 193
    moov_atom_size = atom_size;
    moov_atom = malloc(moov_atom_size);
    if (!moov_atom) {
194
        printf ("could not allocate %"PRIu64" byte for moov atom\n",
195
            atom_size);
196
        goto error_out;
197 198 199
    }
    if (fread(moov_atom, atom_size, 1, infile) != 1) {
        perror(argv[1]);
200
        goto error_out;
201 202 203 204 205 206
    }

    /* this utility does not support compressed atoms yet, so disqualify
     * files with compressed QT atoms */
    if (BE_32(&moov_atom[12]) == CMOV_ATOM) {
        printf ("this utility does not support compressed moov atoms yet\n");
207
        goto error_out;
208 209 210 211
    }

    /* close; will be re-opened later */
    fclose(infile);
212
    infile = NULL;
213 214 215 216 217 218 219 220 221

    /* crawl through the moov chunk in search of stco or co64 atoms */
    for (i = 4; i < moov_atom_size - 4; i++) {
        atom_type = BE_32(&moov_atom[i]);
        if (atom_type == STCO_ATOM) {
            printf (" patching stco atom...\n");
            atom_size = BE_32(&moov_atom[i - 4]);
            if (i + atom_size - 4 > moov_atom_size) {
                printf (" bad atom size\n");
222
                goto error_out;
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
            }
            offset_count = BE_32(&moov_atom[i + 8]);
            for (j = 0; j < offset_count; j++) {
                current_offset = BE_32(&moov_atom[i + 12 + j * 4]);
                current_offset += moov_atom_size;
                moov_atom[i + 12 + j * 4 + 0] = (current_offset >> 24) & 0xFF;
                moov_atom[i + 12 + j * 4 + 1] = (current_offset >> 16) & 0xFF;
                moov_atom[i + 12 + j * 4 + 2] = (current_offset >>  8) & 0xFF;
                moov_atom[i + 12 + j * 4 + 3] = (current_offset >>  0) & 0xFF;
            }
            i += atom_size - 4;
        } else if (atom_type == CO64_ATOM) {
            printf (" patching co64 atom...\n");
            atom_size = BE_32(&moov_atom[i - 4]);
            if (i + atom_size - 4 > moov_atom_size) {
                printf (" bad atom size\n");
239
                goto error_out;
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
            }
            offset_count = BE_32(&moov_atom[i + 8]);
            for (j = 0; j < offset_count; j++) {
                current_offset = BE_64(&moov_atom[i + 12 + j * 8]);
                current_offset += moov_atom_size;
                moov_atom[i + 12 + j * 8 + 0] = (current_offset >> 56) & 0xFF;
                moov_atom[i + 12 + j * 8 + 1] = (current_offset >> 48) & 0xFF;
                moov_atom[i + 12 + j * 8 + 2] = (current_offset >> 40) & 0xFF;
                moov_atom[i + 12 + j * 8 + 3] = (current_offset >> 32) & 0xFF;
                moov_atom[i + 12 + j * 8 + 4] = (current_offset >> 24) & 0xFF;
                moov_atom[i + 12 + j * 8 + 5] = (current_offset >> 16) & 0xFF;
                moov_atom[i + 12 + j * 8 + 6] = (current_offset >>  8) & 0xFF;
                moov_atom[i + 12 + j * 8 + 7] = (current_offset >>  0) & 0xFF;
            }
            i += atom_size - 4;
        }
    }

    /* re-open the input file and open the output file */
    infile = fopen(argv[1], "rb");
    if (!infile) {
        perror(argv[1]);
262
        goto error_out;
263
    }
264 265 266 267 268

    if (start_offset > 0) { /* seek after ftyp atom */
        fseeko(infile, start_offset, SEEK_SET);
        last_offset -= start_offset;
    }
Baptiste Coudurier's avatar
Baptiste Coudurier committed
269

270 271 272
    outfile = fopen(argv[2], "wb");
    if (!outfile) {
        perror(argv[2]);
273
        goto error_out;
274 275
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
276 277 278 279 280 281 282 283 284
    /* dump the same ftyp atom */
    if (ftyp_atom_size > 0) {
        printf (" writing ftyp atom...\n");
        if (fwrite(ftyp_atom, ftyp_atom_size, 1, outfile) != 1) {
            perror(argv[2]);
            goto error_out;
        }
    }

285
    /* dump the new moov atom */
Mike Melanson's avatar
Mike Melanson committed
286
    printf (" writing moov atom...\n");
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
    if (fwrite(moov_atom, moov_atom_size, 1, outfile) != 1) {
        perror(argv[2]);
        goto error_out;
    }

    /* copy the remainder of the infile, from offset 0 -> last_offset - 1 */
    printf (" copying rest of file...\n");
    while (last_offset) {
        if (last_offset > COPY_BUFFER_SIZE)
            bytes_to_copy = COPY_BUFFER_SIZE;
        else
            bytes_to_copy = last_offset;

        if (fread(copy_buffer, bytes_to_copy, 1, infile) != 1) {
            perror(argv[1]);
            goto error_out;
        }
        if (fwrite(copy_buffer, bytes_to_copy, 1, outfile) != 1) {
            perror(argv[2]);
            goto error_out;
        }

        last_offset -= bytes_to_copy;
    }

    fclose(infile);
    fclose(outfile);
    free(moov_atom);
315
    free(ftyp_atom);
316 317 318 319

    return 0;

error_out:
320
    if (infile)
Martin Storsjö's avatar
Martin Storsjö committed
321
        fclose(infile);
322
    if (outfile)
Martin Storsjö's avatar
Martin Storsjö committed
323
        fclose(outfile);
324
    free(moov_atom);
325
    free(ftyp_atom);
326 327
    return 1;
}