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 11 12 13 14 15
 * To compile this program, start from the base directory from which you
 * are building FFmpeg and type:
 *  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 30
 * 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>

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

36 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
#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')
67
#define UUID_ATOM QT_ATOM('u', 'u', 'i', 'd')
68 69 70 71 72 73 74 75 76 77 78 79 80 81

#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[])
{
    FILE *infile;
    FILE *outfile;
    unsigned char atom_bytes[ATOM_PREAMBLE_SIZE];
    uint32_t atom_type = 0;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
82
    uint64_t atom_size = 0;
83
    uint64_t atom_offset = 0;
84 85
    uint64_t last_offset;
    unsigned char *moov_atom;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
86
    unsigned char *ftyp_atom = 0;
87
    uint64_t moov_atom_size;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
88
    uint64_t ftyp_atom_size = 0;
89 90 91
    uint64_t i, j;
    uint32_t offset_count;
    uint64_t current_offset;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
92
    uint64_t start_offset = 0;
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    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;
    }

    infile = fopen(argv[1], "rb");
    if (!infile) {
        perror(argv[1]);
        return 1;
    }

    /* 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
113
        atom_size = (uint32_t)BE_32(&atom_bytes[0]);
114 115
        atom_type = BE_32(&atom_bytes[4]);

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

137 138 139 140 141 142
        /* 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]);
143
            fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE * 2, SEEK_CUR);
144
        } else {
145
            fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE, SEEK_CUR);
146 147
        }
    }
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
        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;
    }
170 171 172

    if (atom_type != MOOV_ATOM) {
        printf ("last atom in file was not a moov atom\n");
173
        free(ftyp_atom);
174 175 176 177 178 179
        fclose(infile);
        return 0;
    }

    /* moov atom was, in fact, the last atom in the chunk; load the whole
     * moov atom */
180 181
    fseeko(infile, -atom_size, SEEK_END);
    last_offset = ftello(infile);
182 183 184
    moov_atom_size = atom_size;
    moov_atom = malloc(moov_atom_size);
    if (!moov_atom) {
185
        printf ("could not allocate %"PRIu64" byte for moov atom\n",
186
            atom_size);
187
        free(ftyp_atom);
188 189 190 191 192 193
        fclose(infile);
        return 1;
    }
    if (fread(moov_atom, atom_size, 1, infile) != 1) {
        perror(argv[1]);
        free(moov_atom);
194
        free(ftyp_atom);
195 196 197 198 199 200 201 202 203
        fclose(infile);
        return 1;
    }

    /* 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");
        free(moov_atom);
204
        free(ftyp_atom);
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
        fclose(infile);
        return 1;
    }

    /* close; will be re-opened later */
    fclose(infile);

    /* 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");
                free(moov_atom);
221
                free(ftyp_atom);
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
                return 1;
            }
            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");
                free(moov_atom);
240
                free(ftyp_atom);
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
                return 1;
            }
            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]);
        free(moov_atom);
265
        free(ftyp_atom);
266 267
        return 1;
    }
268 269 270 271 272

    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
273

274 275 276 277 278
    outfile = fopen(argv[2], "wb");
    if (!outfile) {
        perror(argv[2]);
        fclose(outfile);
        free(moov_atom);
279
        free(ftyp_atom);
280 281 282
        return 1;
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
283 284 285 286 287 288 289 290 291
    /* 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;
        }
    }

292
    /* dump the new moov atom */
Mike Melanson's avatar
Mike Melanson committed
293
    printf (" writing moov atom...\n");
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
    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);
322
    free(ftyp_atom);
323 324 325 326 327 328 329

    return 0;

error_out:
    fclose(infile);
    fclose(outfile);
    free(moov_atom);
330
    free(ftyp_atom);
331 332
    return 1;
}