qt-faststart.c 10.8 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 119 120
        /* keep ftyp atom */
        if (atom_type == FTYP_ATOM) {
            ftyp_atom_size = atom_size;
            ftyp_atom = malloc(ftyp_atom_size);
            if (!ftyp_atom) {
121
                printf ("could not allocate %"PRIu64" byte for ftyp atom\n",
Baptiste Coudurier's avatar
Baptiste Coudurier committed
122 123 124 125 126 127 128 129 130 131 132 133
                        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);
134
        } else {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
135

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

    if (atom_type != MOOV_ATOM) {
        printf ("last atom in file was not a moov atom\n");
        fclose(infile);
        return 0;
    }

    /* moov atom was, in fact, the last atom in the chunk; load the whole
     * moov atom */
178 179
    fseeko(infile, -atom_size, SEEK_END);
    last_offset = ftello(infile);
180 181 182
    moov_atom_size = atom_size;
    moov_atom = malloc(moov_atom_size);
    if (!moov_atom) {
183
        printf ("could not allocate %"PRIu64" byte for moov atom\n",
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
            atom_size);
        fclose(infile);
        return 1;
    }
    if (fread(moov_atom, atom_size, 1, infile) != 1) {
        perror(argv[1]);
        free(moov_atom);
        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);
        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);
                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);
                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);
        return 1;
    }
260 261 262 263 264

    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
265

266 267 268 269 270 271 272 273
    outfile = fopen(argv[2], "wb");
    if (!outfile) {
        perror(argv[2]);
        fclose(outfile);
        free(moov_atom);
        return 1;
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
274 275 276 277 278 279 280 281 282
    /* 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;
        }
    }

283
    /* dump the new moov atom */
Mike Melanson's avatar
Mike Melanson committed
284
    printf (" writing moov atom...\n");
285 286 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
    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);
313
    free(ftyp_atom);
314 315 316 317 318 319 320

    return 0;

error_out:
    fclose(infile);
    fclose(outfile);
    free(moov_atom);
321
    free(ftyp_atom);
322 323
    return 1;
}