vpxenc.c 54.7 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9 10 11 12 13 14
 */


/* This is a simple program that encodes YV12 files and generates ivf
 * files using the new interface.
 */
15
#if defined(_WIN32) || !CONFIG_OS_SUPPORT
16 17 18 19
#define USE_POSIX_MMAP 0
#else
#define USE_POSIX_MMAP 1
#endif
John Koleszar's avatar
John Koleszar committed
20 21 22 23 24

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
John Koleszar's avatar
John Koleszar committed
25
#include <limits.h>
26
#include "vpx/vpx_encoder.h"
John Koleszar's avatar
John Koleszar committed
27 28 29 30 31 32 33
#if USE_POSIX_MMAP
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#endif
John Koleszar's avatar
John Koleszar committed
34
#include "vpx_version.h"
35
#include "vpx/vp8cx.h"
John Koleszar's avatar
John Koleszar committed
36 37
#include "vpx_ports/mem_ops.h"
#include "vpx_ports/vpx_timer.h"
John Koleszar's avatar
John Koleszar committed
38
#include "tools_common.h"
39
#include "y4minput.h"
John Koleszar's avatar
John Koleszar committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
#include "libmkv/EbmlWriter.h"
#include "libmkv/EbmlIDs.h"

/* Need special handling of these functions on Windows */
#if defined(_MSC_VER)
/* MSVS doesn't define off_t, and uses _f{seek,tell}i64 */
typedef __int64 off_t;
#define fseeko _fseeki64
#define ftello _ftelli64
#elif defined(_WIN32)
/* MinGW defines off_t, and uses f{seek,tell}o64 */
#define fseeko fseeko64
#define ftello ftello64
#endif

#if defined(_MSC_VER)
#define LITERALU64(n) n
#else
#define LITERALU64(n) n##LLU
#endif
John Koleszar's avatar
John Koleszar committed
60

61 62 63 64 65 66 67 68
/* We should use 32-bit file operations in WebM file format
 * when building ARM executable file (.axf) with RVCT */
#if !CONFIG_OS_SUPPORT
typedef long off_t;
#define fseeko fseek
#define ftello ftell
#endif

John Koleszar's avatar
John Koleszar committed
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
static const char *exec_name;

static const struct codec_item
{
    char const              *name;
    const vpx_codec_iface_t *iface;
    unsigned int             fourcc;
} codecs[] =
{
#if CONFIG_VP8_ENCODER
    {"vp8",  &vpx_codec_vp8_cx_algo, 0x30385056},
#endif
};

static void usage_exit();

void die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
89 90
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
John Koleszar's avatar
John Koleszar committed
91 92 93 94 95 96 97 98 99
    usage_exit();
}

static void ctx_exit_on_error(vpx_codec_ctx_t *ctx, const char *s)
{
    if (ctx->err)
    {
        const char *detail = vpx_codec_error_detail(ctx);

100
        fprintf(stderr, "%s: %s\n", s, vpx_codec_error(ctx));
John Koleszar's avatar
John Koleszar committed
101 102

        if (detail)
103
            fprintf(stderr, "    %s\n", detail);
John Koleszar's avatar
John Koleszar committed
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

        exit(EXIT_FAILURE);
    }
}

/* This structure is used to abstract the different ways of handling
 * first pass statistics.
 */
typedef struct
{
    vpx_fixed_buf_t buf;
    int             pass;
    FILE           *file;
    char           *buf_ptr;
    size_t          buf_alloc_sz;
} stats_io_t;

int stats_open_file(stats_io_t *stats, const char *fpf, int pass)
{
    int res;

    stats->pass = pass;

    if (pass == 0)
    {
        stats->file = fopen(fpf, "wb");
        stats->buf.sz = 0;
        stats->buf.buf = NULL,
                   res = (stats->file != NULL);
    }
    else
    {
#if 0
#elif USE_POSIX_MMAP
        struct stat stat_buf;
        int fd;

        fd = open(fpf, O_RDONLY);
        stats->file = fdopen(fd, "rb");
        fstat(fd, &stat_buf);
        stats->buf.sz = stat_buf.st_size;
        stats->buf.buf = mmap(NULL, stats->buf.sz, PROT_READ, MAP_PRIVATE,
                              fd, 0);
        res = (stats->buf.buf != NULL);
#else
        size_t nbytes;

        stats->file = fopen(fpf, "rb");

        if (fseek(stats->file, 0, SEEK_END))
        {
            fprintf(stderr, "First-pass stats file must be seekable!\n");
            exit(EXIT_FAILURE);
        }

        stats->buf.sz = stats->buf_alloc_sz = ftell(stats->file);
        rewind(stats->file);

        stats->buf.buf = malloc(stats->buf_alloc_sz);

        if (!stats->buf.buf)
        {
Ralph Giles's avatar
Ralph Giles committed
166 167
            fprintf(stderr, "Failed to allocate first-pass stats buffer (%lu bytes)\n",
                    (unsigned long)stats->buf_alloc_sz);
John Koleszar's avatar
John Koleszar committed
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
            exit(EXIT_FAILURE);
        }

        nbytes = fread(stats->buf.buf, 1, stats->buf.sz, stats->file);
        res = (nbytes == stats->buf.sz);
#endif
    }

    return res;
}

int stats_open_mem(stats_io_t *stats, int pass)
{
    int res;
    stats->pass = pass;

    if (!pass)
    {
        stats->buf.sz = 0;
        stats->buf_alloc_sz = 64 * 1024;
        stats->buf.buf = malloc(stats->buf_alloc_sz);
    }

    stats->buf_ptr = stats->buf.buf;
    res = (stats->buf.buf != NULL);
    return res;
}


James Berry's avatar
James Berry committed
197
void stats_close(stats_io_t *stats, int last_pass)
John Koleszar's avatar
John Koleszar committed
198 199 200
{
    if (stats->file)
    {
James Berry's avatar
James Berry committed
201
        if (stats->pass == last_pass)
John Koleszar's avatar
John Koleszar committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215
        {
#if 0
#elif USE_POSIX_MMAP
            munmap(stats->buf.buf, stats->buf.sz);
#else
            free(stats->buf.buf);
#endif
        }

        fclose(stats->file);
        stats->file = NULL;
    }
    else
    {
James Berry's avatar
James Berry committed
216
        if (stats->pass == last_pass)
John Koleszar's avatar
John Koleszar committed
217 218 219 220 221 222 223 224
            free(stats->buf.buf);
    }
}

void stats_write(stats_io_t *stats, const void *pkt, size_t len)
{
    if (stats->file)
    {
225
        if(fwrite(pkt, 1, len, stats->file));
John Koleszar's avatar
John Koleszar committed
226 227 228 229 230 231 232 233 234 235 236 237 238
    }
    else
    {
        if (stats->buf.sz + len > stats->buf_alloc_sz)
        {
            size_t  new_sz = stats->buf_alloc_sz + 64 * 1024;
            char   *new_ptr = realloc(stats->buf.buf, new_sz);

            if (new_ptr)
            {
                stats->buf_ptr = new_ptr + (stats->buf_ptr - (char *)stats->buf.buf);
                stats->buf.buf = new_ptr;
                stats->buf_alloc_sz = new_sz;
239 240 241 242 243 244 245
            }
            else
            {
                fprintf(stderr,
                        "\nFailed to realloc firstpass stats buffer.\n");
                exit(EXIT_FAILURE);
            }
John Koleszar's avatar
John Koleszar committed
246 247 248 249 250 251 252 253 254 255 256 257 258
        }

        memcpy(stats->buf_ptr, pkt, len);
        stats->buf.sz += len;
        stats->buf_ptr += len;
    }
}

vpx_fixed_buf_t stats_get(stats_io_t *stats)
{
    return stats->buf;
}

259 260 261 262 263 264 265 266 267 268
/* Stereo 3D packed frame format */
typedef enum stereo_format
{
    STEREO_FORMAT_MONO       = 0,
    STEREO_FORMAT_LEFT_RIGHT = 1,
    STEREO_FORMAT_BOTTOM_TOP = 2,
    STEREO_FORMAT_TOP_BOTTOM = 3,
    STEREO_FORMAT_RIGHT_LEFT = 11
} stereo_format_t;

269 270 271 272 273 274 275
enum video_file_type
{
    FILE_TYPE_RAW,
    FILE_TYPE_IVF,
    FILE_TYPE_Y4M
};

276 277
struct detect_buffer {
    char buf[4];
278 279
    size_t buf_read;
    size_t position;
280 281 282
};


John Koleszar's avatar
John Koleszar committed
283
#define IVF_FRAME_HDR_SZ (4+8) /* 4 byte size + 8 byte timestamp */
284
static int read_frame(FILE *f, vpx_image_t *img, unsigned int file_type,
285
                      y4m_input *y4m, struct detect_buffer *detect)
John Koleszar's avatar
John Koleszar committed
286 287
{
    int plane = 0;
288
    int shortread = 0;
John Koleszar's avatar
John Koleszar committed
289

290
    if (file_type == FILE_TYPE_Y4M)
John Koleszar's avatar
John Koleszar committed
291
    {
292
        if (y4m_input_fetch_frame(y4m, f, img) < 1)
293
           return 0;
John Koleszar's avatar
John Koleszar committed
294
    }
295
    else
John Koleszar's avatar
John Koleszar committed
296
    {
297
        if (file_type == FILE_TYPE_IVF)
John Koleszar's avatar
John Koleszar committed
298
        {
299 300 301 302 303 304
            char junk[IVF_FRAME_HDR_SZ];

            /* Skip the frame header. We know how big the frame should be. See
             * write_ivf_frame_header() for documentation on the frame header
             * layout.
             */
305
            if(fread(junk, 1, IVF_FRAME_HDR_SZ, f));
John Koleszar's avatar
John Koleszar committed
306 307
        }

308
        for (plane = 0; plane < 3; plane++)
John Koleszar's avatar
John Koleszar committed
309
        {
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
            unsigned char *ptr;
            int w = (plane ? (1 + img->d_w) / 2 : img->d_w);
            int h = (plane ? (1 + img->d_h) / 2 : img->d_h);
            int r;

            /* Determine the correct plane based on the image format. The for-loop
             * always counts in Y,U,V order, but this may not match the order of
             * the data on disk.
             */
            switch (plane)
            {
            case 1:
                ptr = img->planes[img->fmt==VPX_IMG_FMT_YV12? VPX_PLANE_V : VPX_PLANE_U];
                break;
            case 2:
                ptr = img->planes[img->fmt==VPX_IMG_FMT_YV12?VPX_PLANE_U : VPX_PLANE_V];
                break;
            default:
                ptr = img->planes[plane];
            }

            for (r = 0; r < h; r++)
            {
333 334 335 336
                size_t needed = w;
                size_t buf_position = 0;
                const size_t left = detect->buf_read - detect->position;
                if (left > 0)
337
                {
338 339 340 341 342 343 344 345 346
                    const size_t more = (left < needed) ? left : needed;
                    memcpy(ptr, detect->buf + detect->position, more);
                    buf_position = more;
                    needed -= more;
                    detect->position += more;
                }
                if (needed > 0)
                {
                    shortread |= (fread(ptr + buf_position, 1, needed, f) < needed);
347 348
                }

349 350
                ptr += img->stride[plane];
            }
John Koleszar's avatar
John Koleszar committed
351 352 353
        }
    }

354
    return !shortread;
John Koleszar's avatar
John Koleszar committed
355 356 357
}


358
unsigned int file_is_y4m(FILE      *infile,
359 360
                         y4m_input *y4m,
                         char       detect[4])
361
{
362
    if(memcmp(detect, "YUV4", 4) == 0)
363 364 365 366 367 368
    {
        return 1;
    }
    return 0;
}

John Koleszar's avatar
John Koleszar committed
369 370 371 372
#define IVF_FILE_HDR_SZ (32)
unsigned int file_is_ivf(FILE *infile,
                         unsigned int *fourcc,
                         unsigned int *width,
373
                         unsigned int *height,
374
                         struct detect_buffer *detect)
John Koleszar's avatar
John Koleszar committed
375 376 377 378
{
    char raw_hdr[IVF_FILE_HDR_SZ];
    int is_ivf = 0;

379
    if(memcmp(detect->buf, "DKIF", 4) != 0)
380 381
        return 0;

John Koleszar's avatar
John Koleszar committed
382 383 384
    /* See write_ivf_file_header() for more documentation on the file header
     * layout.
     */
385 386
    if (fread(raw_hdr + 4, 1, IVF_FILE_HDR_SZ - 4, infile)
        == IVF_FILE_HDR_SZ - 4)
John Koleszar's avatar
John Koleszar committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
    {
        {
            is_ivf = 1;

            if (mem_get_le16(raw_hdr + 4) != 0)
                fprintf(stderr, "Error: Unrecognized IVF version! This file may not"
                        " decode properly.");

            *fourcc = mem_get_le32(raw_hdr + 8);
        }
    }

    if (is_ivf)
    {
        *width = mem_get_le16(raw_hdr + 12);
        *height = mem_get_le16(raw_hdr + 14);
403
        detect->position = 4;
John Koleszar's avatar
John Koleszar committed
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
    }

    return is_ivf;
}


static void write_ivf_file_header(FILE *outfile,
                                  const vpx_codec_enc_cfg_t *cfg,
                                  unsigned int fourcc,
                                  int frame_cnt)
{
    char header[32];

    if (cfg->g_pass != VPX_RC_ONE_PASS && cfg->g_pass != VPX_RC_LAST_PASS)
        return;

    header[0] = 'D';
    header[1] = 'K';
    header[2] = 'I';
    header[3] = 'F';
    mem_put_le16(header + 4,  0);                 /* version */
    mem_put_le16(header + 6,  32);                /* headersize */
    mem_put_le32(header + 8,  fourcc);            /* headersize */
    mem_put_le16(header + 12, cfg->g_w);          /* width */
    mem_put_le16(header + 14, cfg->g_h);          /* height */
    mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
    mem_put_le32(header + 20, cfg->g_timebase.num); /* scale */
    mem_put_le32(header + 24, frame_cnt);         /* length */
    mem_put_le32(header + 28, 0);                 /* unused */

434
    if(fwrite(header, 1, 32, outfile));
John Koleszar's avatar
John Koleszar committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
}


static void write_ivf_frame_header(FILE *outfile,
                                   const vpx_codec_cx_pkt_t *pkt)
{
    char             header[12];
    vpx_codec_pts_t  pts;

    if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
        return;

    pts = pkt->data.frame.pts;
    mem_put_le32(header, pkt->data.frame.sz);
    mem_put_le32(header + 4, pts & 0xFFFFFFFF);
    mem_put_le32(header + 8, pts >> 32);

452
    if(fwrite(header, 1, 12, outfile));
John Koleszar's avatar
John Koleszar committed
453 454
}

John Koleszar's avatar
John Koleszar committed
455 456 457 458 459 460 461 462 463 464 465 466 467

typedef off_t EbmlLoc;


struct cue_entry
{
    unsigned int time;
    uint64_t     loc;
};


struct EbmlGlobal
{
468 469
    int debug;

John Koleszar's avatar
John Koleszar committed
470
    FILE    *stream;
471
    int64_t last_pts_ms;
John Koleszar's avatar
John Koleszar committed
472 473 474 475 476 477 478 479 480 481
    vpx_rational_t  framerate;

    /* These pointers are to the start of an element */
    off_t    position_reference;
    off_t    seek_info_pos;
    off_t    segment_info_pos;
    off_t    track_pos;
    off_t    cue_pos;
    off_t    cluster_pos;

John Koleszar's avatar
John Koleszar committed
482 483 484
    /* This pointer is to a specific element to be serialized */
    off_t    track_id_pos;

John Koleszar's avatar
John Koleszar committed
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
    /* These pointers are to the size field of the element */
    EbmlLoc  startSegment;
    EbmlLoc  startCluster;

    uint32_t cluster_timecode;
    int      cluster_open;

    struct cue_entry *cue_list;
    unsigned int      cues;

};


void Ebml_Write(EbmlGlobal *glob, const void *buffer_in, unsigned long len)
{
500
    if(fwrite(buffer_in, 1, len, glob->stream));
John Koleszar's avatar
John Koleszar committed
501 502 503 504 505 506 507 508 509 510 511 512
}


void Ebml_Serialize(EbmlGlobal *glob, const void *buffer_in, unsigned long len)
{
    const unsigned char *q = (const unsigned char *)buffer_in + len - 1;

    for(; len; len--)
        Ebml_Write(glob, q--, 1);
}


John Koleszar's avatar
John Koleszar committed
513 514 515 516 517 518 519 520 521 522 523 524
/* Need a fixed size serializer for the track ID. libmkv provdes a 64 bit
 * one, but not a 32 bit one.
 */
static void Ebml_SerializeUnsigned32(EbmlGlobal *glob, unsigned long class_id, uint64_t ui)
{
    unsigned char sizeSerialized = 4 | 0x80;
    Ebml_WriteID(glob, class_id);
    Ebml_Serialize(glob, &sizeSerialized, 1);
    Ebml_Serialize(glob, &ui, 4);
}


John Koleszar's avatar
John Koleszar committed
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
static void
Ebml_StartSubElement(EbmlGlobal *glob, EbmlLoc *ebmlLoc,
                          unsigned long class_id)
{
    //todo this is always taking 8 bytes, this may need later optimization
    //this is a key that says lenght unknown
    unsigned long long unknownLen =  LITERALU64(0x01FFFFFFFFFFFFFF);

    Ebml_WriteID(glob, class_id);
    *ebmlLoc = ftello(glob->stream);
    Ebml_Serialize(glob, &unknownLen, 8);
}

static void
Ebml_EndSubElement(EbmlGlobal *glob, EbmlLoc *ebmlLoc)
{
    off_t pos;
    uint64_t size;

    /* Save the current stream pointer */
    pos = ftello(glob->stream);

    /* Calculate the size of this element */
    size = pos - *ebmlLoc - 8;
    size |=  LITERALU64(0x0100000000000000);

    /* Seek back to the beginning of the element and write the new size */
    fseeko(glob->stream, *ebmlLoc, SEEK_SET);
    Ebml_Serialize(glob, &size, 8);

    /* Reset the stream pointer */
    fseeko(glob->stream, pos, SEEK_SET);
}


static void
write_webm_seek_element(EbmlGlobal *ebml, unsigned long id, off_t pos)
{
    uint64_t offset = pos - ebml->position_reference;
    EbmlLoc start;
    Ebml_StartSubElement(ebml, &start, Seek);
    Ebml_SerializeBinary(ebml, SeekID, id);
    Ebml_SerializeUnsigned64(ebml, SeekPosition, offset);
    Ebml_EndSubElement(ebml, &start);
}


static void
write_webm_seek_info(EbmlGlobal *ebml)
{

    off_t pos;

    /* Save the current stream pointer */
    pos = ftello(ebml->stream);

    if(ebml->seek_info_pos)
        fseeko(ebml->stream, ebml->seek_info_pos, SEEK_SET);
    else
        ebml->seek_info_pos = pos;

    {
        EbmlLoc start;

        Ebml_StartSubElement(ebml, &start, SeekHead);
        write_webm_seek_element(ebml, Tracks, ebml->track_pos);
        write_webm_seek_element(ebml, Cues,   ebml->cue_pos);
        write_webm_seek_element(ebml, Info,   ebml->segment_info_pos);
        Ebml_EndSubElement(ebml, &start);
    }
    {
        //segment info
        EbmlLoc startInfo;
        uint64_t frame_time;

        frame_time = (uint64_t)1000 * ebml->framerate.den
                     / ebml->framerate.num;
        ebml->segment_info_pos = ftello(ebml->stream);
        Ebml_StartSubElement(ebml, &startInfo, Info);
        Ebml_SerializeUnsigned(ebml, TimecodeScale, 1000000);
        Ebml_SerializeFloat(ebml, Segment_Duration,
                            ebml->last_pts_ms + frame_time);
607 608 609 610
        Ebml_SerializeString(ebml, 0x4D80,
            ebml->debug ? "vpxenc" : "vpxenc" VERSION_STRING);
        Ebml_SerializeString(ebml, 0x5741,
            ebml->debug ? "vpxenc" : "vpxenc" VERSION_STRING);
John Koleszar's avatar
John Koleszar committed
611 612 613 614 615 616 617 618
        Ebml_EndSubElement(ebml, &startInfo);
    }
}


static void
write_webm_file_header(EbmlGlobal                *glob,
                       const vpx_codec_enc_cfg_t *cfg,
619 620
                       const struct vpx_rational *fps,
                       stereo_format_t            stereo_fmt)
John Koleszar's avatar
John Koleszar committed
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
{
    {
        EbmlLoc start;
        Ebml_StartSubElement(glob, &start, EBML);
        Ebml_SerializeUnsigned(glob, EBMLVersion, 1);
        Ebml_SerializeUnsigned(glob, EBMLReadVersion, 1); //EBML Read Version
        Ebml_SerializeUnsigned(glob, EBMLMaxIDLength, 4); //EBML Max ID Length
        Ebml_SerializeUnsigned(glob, EBMLMaxSizeLength, 8); //EBML Max Size Length
        Ebml_SerializeString(glob, DocType, "webm"); //Doc Type
        Ebml_SerializeUnsigned(glob, DocTypeVersion, 2); //Doc Type Version
        Ebml_SerializeUnsigned(glob, DocTypeReadVersion, 2); //Doc Type Read Version
        Ebml_EndSubElement(glob, &start);
    }
    {
        Ebml_StartSubElement(glob, &glob->startSegment, Segment); //segment
        glob->position_reference = ftello(glob->stream);
        glob->framerate = *fps;
        write_webm_seek_info(glob);

        {
            EbmlLoc trackStart;
            glob->track_pos = ftello(glob->stream);
            Ebml_StartSubElement(glob, &trackStart, Tracks);
            {
                unsigned int trackNumber = 1;
                uint64_t     trackID = 0;

                EbmlLoc start;
                Ebml_StartSubElement(glob, &start, TrackEntry);
                Ebml_SerializeUnsigned(glob, TrackNumber, trackNumber);
John Koleszar's avatar
John Koleszar committed
651 652
                glob->track_id_pos = ftello(glob->stream);
                Ebml_SerializeUnsigned32(glob, TrackUID, trackID);
John Koleszar's avatar
John Koleszar committed
653 654 655 656 657 658 659 660 661 662 663
                Ebml_SerializeUnsigned(glob, TrackType, 1); //video is always 1
                Ebml_SerializeString(glob, CodecID, "V_VP8");
                {
                    unsigned int pixelWidth = cfg->g_w;
                    unsigned int pixelHeight = cfg->g_h;
                    float        frameRate   = (float)fps->num/(float)fps->den;

                    EbmlLoc videoStart;
                    Ebml_StartSubElement(glob, &videoStart, Video);
                    Ebml_SerializeUnsigned(glob, PixelWidth, pixelWidth);
                    Ebml_SerializeUnsigned(glob, PixelHeight, pixelHeight);
664
                    Ebml_SerializeUnsigned(glob, StereoMode, stereo_fmt);
John Koleszar's avatar
John Koleszar committed
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
                    Ebml_SerializeFloat(glob, FrameRate, frameRate);
                    Ebml_EndSubElement(glob, &videoStart); //Video
                }
                Ebml_EndSubElement(glob, &start); //Track Entry
            }
            Ebml_EndSubElement(glob, &trackStart);
        }
        // segment element is open
    }
}


static void
write_webm_block(EbmlGlobal                *glob,
                 const vpx_codec_enc_cfg_t *cfg,
                 const vpx_codec_cx_pkt_t  *pkt)
{
    unsigned long  block_length;
    unsigned char  track_number;
    unsigned short block_timecode = 0;
    unsigned char  flags;
686
    int64_t        pts_ms;
John Koleszar's avatar
John Koleszar committed
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
    int            start_cluster = 0, is_keyframe;

    /* Calculate the PTS of this frame in milliseconds */
    pts_ms = pkt->data.frame.pts * 1000
             * (uint64_t)cfg->g_timebase.num / (uint64_t)cfg->g_timebase.den;
    if(pts_ms <= glob->last_pts_ms)
        pts_ms = glob->last_pts_ms + 1;
    glob->last_pts_ms = pts_ms;

    /* Calculate the relative time of this block */
    if(pts_ms - glob->cluster_timecode > SHRT_MAX)
        start_cluster = 1;
    else
        block_timecode = pts_ms - glob->cluster_timecode;

    is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY);
    if(start_cluster || is_keyframe)
    {
        if(glob->cluster_open)
            Ebml_EndSubElement(glob, &glob->startCluster);

        /* Open the new cluster */
        block_timecode = 0;
        glob->cluster_open = 1;
        glob->cluster_timecode = pts_ms;
        glob->cluster_pos = ftello(glob->stream);
        Ebml_StartSubElement(glob, &glob->startCluster, Cluster); //cluster
        Ebml_SerializeUnsigned(glob, Timecode, glob->cluster_timecode);

        /* Save a cue point if this is a keyframe. */
        if(is_keyframe)
        {
719 720 721 722 723 724 725 726 727 728 729
            struct cue_entry *cue, *new_cue_list;

            new_cue_list = realloc(glob->cue_list,
                                   (glob->cues+1) * sizeof(struct cue_entry));
            if(new_cue_list)
                glob->cue_list = new_cue_list;
            else
            {
                fprintf(stderr, "\nFailed to realloc cue list.\n");
                exit(EXIT_FAILURE);
            }
John Koleszar's avatar
John Koleszar committed
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762

            cue = &glob->cue_list[glob->cues];
            cue->time = glob->cluster_timecode;
            cue->loc = glob->cluster_pos;
            glob->cues++;
        }
    }

    /* Write the Simple Block */
    Ebml_WriteID(glob, SimpleBlock);

    block_length = pkt->data.frame.sz + 4;
    block_length |= 0x10000000;
    Ebml_Serialize(glob, &block_length, 4);

    track_number = 1;
    track_number |= 0x80;
    Ebml_Write(glob, &track_number, 1);

    Ebml_Serialize(glob, &block_timecode, 2);

    flags = 0;
    if(is_keyframe)
        flags |= 0x80;
    if(pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
        flags |= 0x08;
    Ebml_Write(glob, &flags, 1);

    Ebml_Write(glob, pkt->data.frame.buf, pkt->data.frame.sz);
}


static void
John Koleszar's avatar
John Koleszar committed
763
write_webm_file_footer(EbmlGlobal *glob, long hash)
John Koleszar's avatar
John Koleszar committed
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
{

    if(glob->cluster_open)
        Ebml_EndSubElement(glob, &glob->startCluster);

    {
        EbmlLoc start;
        int i;

        glob->cue_pos = ftello(glob->stream);
        Ebml_StartSubElement(glob, &start, Cues);
        for(i=0; i<glob->cues; i++)
        {
            struct cue_entry *cue = &glob->cue_list[i];
            EbmlLoc start;

            Ebml_StartSubElement(glob, &start, CuePoint);
            {
                EbmlLoc start;

                Ebml_SerializeUnsigned(glob, CueTime, cue->time);

                Ebml_StartSubElement(glob, &start, CueTrackPositions);
                Ebml_SerializeUnsigned(glob, CueTrack, 1);
                Ebml_SerializeUnsigned64(glob, CueClusterPosition,
                                         cue->loc - glob->position_reference);
                //Ebml_SerializeUnsigned(glob, CueBlockNumber, cue->blockNumber);
                Ebml_EndSubElement(glob, &start);
            }
            Ebml_EndSubElement(glob, &start);
        }
        Ebml_EndSubElement(glob, &start);
    }

    Ebml_EndSubElement(glob, &glob->startSegment);

    /* Patch up the seek info block */
    write_webm_seek_info(glob);
John Koleszar's avatar
John Koleszar committed
802 803 804 805 806

    /* Patch up the track id */
    fseeko(glob->stream, glob->track_id_pos, SEEK_SET);
    Ebml_SerializeUnsigned32(glob, TrackUID, glob->debug ? 0xDEADBEEF : hash);

John Koleszar's avatar
John Koleszar committed
807 808 809 810
    fseeko(glob->stream, 0, SEEK_END);
}


John Koleszar's avatar
John Koleszar committed
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
/* Murmur hash derived from public domain reference implementation at
 *   http://sites.google.com/site/murmurhash/
 */
static unsigned int murmur ( const void * key, int len, unsigned int seed )
{
    const unsigned int m = 0x5bd1e995;
    const int r = 24;

    unsigned int h = seed ^ len;

    const unsigned char * data = (const unsigned char *)key;

    while(len >= 4)
    {
        unsigned int k;

        k  = data[0];
        k |= data[1] << 8;
        k |= data[2] << 16;
        k |= data[3] << 24;

        k *= m;
        k ^= k >> r;
        k *= m;

        h *= m;
        h ^= k;

        data += 4;
        len -= 4;
    }

    switch(len)
    {
    case 3: h ^= data[2] << 16;
    case 2: h ^= data[1] << 8;
    case 1: h ^= data[0];
            h *= m;
    };

    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;

    return h;
}

858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
#include "math.h"

static double vp8_mse2psnr(double Samples, double Peak, double Mse)
{
    double psnr;

    if ((double)Mse > 0.0)
        psnr = 10.0 * log10(Peak * Peak * Samples / Mse);
    else
        psnr = 60;      // Limit to prevent / 0

    if (psnr > 60)
        psnr = 60;

    return psnr;
}

John Koleszar's avatar
John Koleszar committed
875

John Koleszar's avatar
John Koleszar committed
876 877
#include "args.h"

878 879
static const arg_def_t debugmode = ARG_DEF("D", "debug", 0,
        "Debug mode (makes output deterministic)");
880 881
static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
        "Output filename");
John Koleszar's avatar
John Koleszar committed
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
static const arg_def_t use_yv12 = ARG_DEF(NULL, "yv12", 0,
                                  "Input file is YV12 ");
static const arg_def_t use_i420 = ARG_DEF(NULL, "i420", 0,
                                  "Input file is I420 (default)");
static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1,
                                  "Codec to use");
static const arg_def_t passes           = ARG_DEF("p", "passes", 1,
        "Number of passes (1/2)");
static const arg_def_t pass_arg         = ARG_DEF(NULL, "pass", 1,
        "Pass to execute (1/2)");
static const arg_def_t fpf_name         = ARG_DEF(NULL, "fpf", 1,
        "First pass statistics file name");
static const arg_def_t limit = ARG_DEF(NULL, "limit", 1,
                                       "Stop encoding after n input frames");
static const arg_def_t deadline         = ARG_DEF("d", "deadline", 1,
        "Deadline per frame (usec)");
static const arg_def_t best_dl          = ARG_DEF(NULL, "best", 0,
        "Use Best Quality Deadline");
static const arg_def_t good_dl          = ARG_DEF(NULL, "good", 0,
        "Use Good Quality Deadline");
static const arg_def_t rt_dl            = ARG_DEF(NULL, "rt", 0,
        "Use Realtime Quality Deadline");
static const arg_def_t verbosearg       = ARG_DEF("v", "verbose", 0,
        "Show encoder parameters");
static const arg_def_t psnrarg          = ARG_DEF(NULL, "psnr", 0,
        "Show PSNR in status line");
908
static const arg_def_t framerate        = ARG_DEF(NULL, "fps", 1,
909
        "Stream frame rate (rate/scale)");
John Koleszar's avatar
John Koleszar committed
910 911
static const arg_def_t use_ivf          = ARG_DEF(NULL, "ivf", 0,
        "Output IVF (default is WebM)");
John Koleszar's avatar
John Koleszar committed
912 913
static const arg_def_t *main_args[] =
{
914
    &debugmode,
915 916
    &outputfile, &codecarg, &passes, &pass_arg, &fpf_name, &limit, &deadline,
    &best_dl, &good_dl, &rt_dl,
John Koleszar's avatar
John Koleszar committed
917
    &verbosearg, &psnrarg, &use_ivf, &framerate,
John Koleszar's avatar
John Koleszar committed
918 919 920 921 922 923 924 925 926 927 928 929 930
    NULL
};

static const arg_def_t usage            = ARG_DEF("u", "usage", 1,
        "Usage profile number to use");
static const arg_def_t threads          = ARG_DEF("t", "threads", 1,
        "Max number of threads to use");
static const arg_def_t profile          = ARG_DEF(NULL, "profile", 1,
        "Bitstream profile number to use");
static const arg_def_t width            = ARG_DEF("w", "width", 1,
        "Frame width");
static const arg_def_t height           = ARG_DEF("h", "height", 1,
        "Frame height");
931 932 933 934 935 936 937 938 939 940
static const struct arg_enum_list stereo_mode_enum[] = {
    {"mono"      , STEREO_FORMAT_MONO},
    {"left-right", STEREO_FORMAT_LEFT_RIGHT},
    {"bottom-top", STEREO_FORMAT_BOTTOM_TOP},
    {"top-bottom", STEREO_FORMAT_TOP_BOTTOM},
    {"right-left", STEREO_FORMAT_RIGHT_LEFT},
    {NULL, 0}
};
static const arg_def_t stereo_mode      = ARG_DEF_ENUM(NULL, "stereo-mode", 1,
        "Stereo 3D video format", stereo_mode_enum);
John Koleszar's avatar
John Koleszar committed
941 942 943 944 945 946 947 948 949 950
static const arg_def_t timebase         = ARG_DEF(NULL, "timebase", 1,
        "Stream timebase (frame duration)");
static const arg_def_t error_resilient  = ARG_DEF(NULL, "error-resilient", 1,
        "Enable error resiliency features");
static const arg_def_t lag_in_frames    = ARG_DEF(NULL, "lag-in-frames", 1,
        "Max number of frames to lag");

static const arg_def_t *global_args[] =
{
    &use_yv12, &use_i420, &usage, &threads, &profile,
951
    &width, &height, &stereo_mode, &timebase, &framerate, &error_resilient,
John Koleszar's avatar
John Koleszar committed
952 953 954 955 956 957 958 959 960 961 962
    &lag_in_frames, NULL
};

static const arg_def_t dropframe_thresh   = ARG_DEF(NULL, "drop-frame", 1,
        "Temporal resampling threshold (buf %)");
static const arg_def_t resize_allowed     = ARG_DEF(NULL, "resize-allowed", 1,
        "Spatial resampling enabled (bool)");
static const arg_def_t resize_up_thresh   = ARG_DEF(NULL, "resize-up", 1,
        "Upscale threshold (buf %)");
static const arg_def_t resize_down_thresh = ARG_DEF(NULL, "resize-down", 1,
        "Downscale threshold (buf %)");
963 964 965 966 967 968 969 970
static const struct arg_enum_list end_usage_enum[] = {
    {"vbr", VPX_VBR},
    {"cbr", VPX_CBR},
    {"cq",  VPX_CQ},
    {NULL, 0}
};
static const arg_def_t end_usage          = ARG_DEF_ENUM(NULL, "end-usage", 1,
        "Rate control mode", end_usage_enum);
John Koleszar's avatar
John Koleszar committed
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
static const arg_def_t target_bitrate     = ARG_DEF(NULL, "target-bitrate", 1,
        "Bitrate (kbps)");
static const arg_def_t min_quantizer      = ARG_DEF(NULL, "min-q", 1,
        "Minimum (best) quantizer");
static const arg_def_t max_quantizer      = ARG_DEF(NULL, "max-q", 1,
        "Maximum (worst) quantizer");
static const arg_def_t undershoot_pct     = ARG_DEF(NULL, "undershoot-pct", 1,
        "Datarate undershoot (min) target (%)");
static const arg_def_t overshoot_pct      = ARG_DEF(NULL, "overshoot-pct", 1,
        "Datarate overshoot (max) target (%)");
static const arg_def_t buf_sz             = ARG_DEF(NULL, "buf-sz", 1,
        "Client buffer size (ms)");
static const arg_def_t buf_initial_sz     = ARG_DEF(NULL, "buf-initial-sz", 1,
        "Client initial buffer size (ms)");
static const arg_def_t buf_optimal_sz     = ARG_DEF(NULL, "buf-optimal-sz", 1,
        "Client optimal buffer size (ms)");
static const arg_def_t *rc_args[] =
{
    &dropframe_thresh, &resize_allowed, &resize_up_thresh, &resize_down_thresh,
    &end_usage, &target_bitrate, &min_quantizer, &max_quantizer,
    &undershoot_pct, &overshoot_pct, &buf_sz, &buf_initial_sz, &buf_optimal_sz,
    NULL
};


static const arg_def_t bias_pct = ARG_DEF(NULL, "bias-pct", 1,
                                  "CBR/VBR bias (0=CBR, 100=VBR)");
static const arg_def_t minsection_pct = ARG_DEF(NULL, "minsection-pct", 1,
                                        "GOP min bitrate (% of target)");
static const arg_def_t maxsection_pct = ARG_DEF(NULL, "maxsection-pct", 1,
                                        "GOP max bitrate (% of target)");
static const arg_def_t *rc_twopass_args[] =
{
    &bias_pct, &minsection_pct, &maxsection_pct, NULL
};


static const arg_def_t kf_min_dist = ARG_DEF(NULL, "kf-min-dist", 1,
                                     "Minimum keyframe interval (frames)");
static const arg_def_t kf_max_dist = ARG_DEF(NULL, "kf-max-dist", 1,
                                     "Maximum keyframe interval (frames)");
1012 1013
static const arg_def_t kf_disabled = ARG_DEF(NULL, "disable-kf", 0,
                                     "Disable keyframe placement");
John Koleszar's avatar
John Koleszar committed
1014 1015
static const arg_def_t *kf_args[] =
{
1016
    &kf_min_dist, &kf_max_dist, &kf_disabled, NULL
John Koleszar's avatar
John Koleszar committed
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
};


#if CONFIG_VP8_ENCODER
static const arg_def_t noise_sens = ARG_DEF(NULL, "noise-sensitivity", 1,
                                    "Noise sensitivity (frames to blur)");
static const arg_def_t sharpness = ARG_DEF(NULL, "sharpness", 1,
                                   "Filter sharpness (0-7)");
static const arg_def_t static_thresh = ARG_DEF(NULL, "static-thresh", 1,
                                       "Motion detection threshold");
#endif

#if CONFIG_VP8_ENCODER
static const arg_def_t cpu_used = ARG_DEF(NULL, "cpu-used", 1,
                                  "CPU Used (-16..16)");
#endif


#if CONFIG_VP8_ENCODER
static const arg_def_t token_parts = ARG_DEF(NULL, "token-parts", 1,
                                     "Number of token partitions to use, log2");
static const arg_def_t auto_altref = ARG_DEF(NULL, "auto-alt-ref", 1,
                                     "Enable automatic alt reference frames");
static const arg_def_t arnr_maxframes = ARG_DEF(NULL, "arnr-maxframes", 1,
1041
                                        "AltRef Max Frames");
John Koleszar's avatar
John Koleszar committed
1042
static const arg_def_t arnr_strength = ARG_DEF(NULL, "arnr-strength", 1,
1043
                                       "AltRef Strength");
John Koleszar's avatar
John Koleszar committed
1044
static const arg_def_t arnr_type = ARG_DEF(NULL, "arnr-type", 1,
1045
                                   "AltRef Type");
John Koleszar's avatar
John Koleszar committed
1046 1047 1048 1049 1050 1051 1052
static const struct arg_enum_list tuning_enum[] = {
    {"psnr", VP8_TUNE_PSNR},
    {"ssim", VP8_TUNE_SSIM},
    {NULL, 0}
};
static const arg_def_t tune_ssim = ARG_DEF_ENUM(NULL, "tune", 1,
                                   "Material to favor", tuning_enum);
Paul Wilkins's avatar
CQ Mode  
Paul Wilkins committed
1053 1054
static const arg_def_t cq_level = ARG_DEF(NULL, "cq-level", 1,
                                   "Constrained Quality Level");
John Koleszar's avatar
John Koleszar committed
1055 1056 1057 1058

static const arg_def_t *vp8_args[] =
{
    &cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
John Koleszar's avatar
John Koleszar committed
1059
    &token_parts, &arnr_maxframes, &arnr_strength, &arnr_type,
Paul Wilkins's avatar
CQ Mode  
Paul Wilkins committed
1060
    &tune_ssim, &cq_level, NULL
John Koleszar's avatar
John Koleszar committed
1061 1062 1063 1064 1065 1066
};
static const int vp8_arg_ctrl_map[] =
{
    VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
    VP8E_SET_NOISE_SENSITIVITY, VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
    VP8E_SET_TOKEN_PARTITIONS,
John Koleszar's avatar
John Koleszar committed
1067
    VP8E_SET_ARNR_MAXFRAMES, VP8E_SET_ARNR_STRENGTH , VP8E_SET_ARNR_TYPE,
Paul Wilkins's avatar
CQ Mode  
Paul Wilkins committed
1068
    VP8E_SET_TUNING, VP8E_SET_CQ_LEVEL, 0
John Koleszar's avatar
John Koleszar committed
1069 1070 1071 1072 1073 1074 1075 1076 1077
};
#endif

static const arg_def_t *no_args[] = { NULL };

static void usage_exit()
{
    int i;

1078 1079
    fprintf(stderr, "Usage: %s <options> -o dst_filename src_filename \n",
            exec_name);
John Koleszar's avatar
John Koleszar committed
1080

1081
    fprintf(stderr, "\nOptions:\n");
John Koleszar's avatar
John Koleszar committed
1082
    arg_show_usage(stdout, main_args);
1083
    fprintf(stderr, "\nEncoder Global Options:\n");
John Koleszar's avatar
John Koleszar committed
1084
    arg_show_usage(stdout, global_args);
1085
    fprintf(stderr, "\nRate Control Options:\n");
John Koleszar's avatar
John Koleszar committed
1086
    arg_show_usage(stdout, rc_args);
1087
    fprintf(stderr, "\nTwopass Rate Control Options:\n");
John Koleszar's avatar
John Koleszar committed
1088
    arg_show_usage(stdout, rc_twopass_args);
1089
    fprintf(stderr, "\nKeyframe Placement Options:\n");
John Koleszar's avatar
John Koleszar committed
1090 1091
    arg_show_usage(stdout, kf_args);
#if CONFIG_VP8_ENCODER
1092
    fprintf(stderr, "\nVP8 Specific Options:\n");
John Koleszar's avatar
John Koleszar committed
1093 1094
    arg_show_usage(stdout, vp8_args);
#endif
1095
    fprintf(stderr, "\n"
John Koleszar's avatar
John Koleszar committed
1096 1097 1098 1099
           "Included encoders:\n"
           "\n");

    for (i = 0; i < sizeof(codecs) / sizeof(codecs[0]); i++)
1100
        fprintf(stderr, "    %-6s - %s\n",
John Koleszar's avatar
John Koleszar committed
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
               codecs[i].name,
               vpx_codec_iface_name(codecs[i].iface));

    exit(EXIT_FAILURE);
}

#define ARG_CTRL_CNT_MAX 10

int main(int argc, const char **argv_)
{
    vpx_codec_ctx_t        encoder;
    const char                  *in_fn = NULL, *out_fn = NULL, *stats_fn = NULL;
    int                    i;
    FILE                  *infile, *outfile;
    vpx_codec_enc_cfg_t    cfg;
    vpx_codec_err_t        res;
    int                    pass, one_pass_only = 0;
    stats_io_t             stats;
    vpx_image_t            raw;
    const struct codec_item  *codec = codecs;
    int                    frame_avail, got_data;

    struct arg               arg;
    char                   **argv, **argi, **argj;
    int                      arg_usage = 0, arg_passes = 1, arg_deadline = 0;
    int                      arg_ctrls[ARG_CTRL_CNT_MAX][2], arg_ctrl_cnt = 0;
    int                      arg_limit = 0;
    static const arg_def_t **ctrl_args = no_args;
    static const int        *ctrl_args_map = NULL;
    int                      verbose = 0, show_psnr = 0;
    int                      arg_use_i420 = 1;
    unsigned long            cx_time = 0;
1133 1134
    unsigned int             file_type, fourcc;
    y4m_input                y4m;
1135 1136
    struct vpx_rational      arg_framerate = {30, 1};
    int                      arg_have_framerate = 0;
John Koleszar's avatar
John Koleszar committed
1137
    int                      write_webm = 1;
John Koleszar's avatar
John Koleszar committed
1138
    EbmlGlobal               ebml = {0};
John Koleszar's avatar
John Koleszar committed
1139
    uint32_t                 hash = 0;
1140 1141 1142 1143
    uint64_t                 psnr_sse_total = 0;
    uint64_t                 psnr_samples_total = 0;
    double                   psnr_totals[4] = {0, 0, 0, 0};
    int                      psnr_count = 0;
1144
    stereo_format_t          stereo_fmt = STEREO_FORMAT_MONO;
John Koleszar's avatar
John Koleszar committed
1145 1146

    exec_name = argv_[0];
1147
    ebml.last_pts_ms = -1;
John Koleszar's avatar
John Koleszar committed
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216

    if (argc < 3)
        usage_exit();


    /* First parse the codec and usage values, because we want to apply other
     * parameters on top of the default configuration provided by the codec.
     */
    argv = argv_dup(argc - 1, argv_ + 1);

    for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step)
    {
        arg.argv_step = 1;

        if (arg_match(&arg, &codecarg, argi))
        {
            int j, k = -1;

            for (j = 0; j < sizeof(codecs) / sizeof(codecs[0]); j++)
                if (!strcmp(codecs[j].name, arg.val))
                    k = j;

            if (k >= 0)
                codec = codecs + k;
            else
                die("Error: Unrecognized argument (%s) to --codec\n",
                    arg.val);

        }
        else if (arg_match(&arg, &passes, argi))
        {
            arg_passes = arg_parse_uint(&arg);

            if (arg_passes < 1 || arg_passes > 2)
                die("Error: Invalid number of passes (%d)\n", arg_passes);
        }
        else if (arg_match(&arg, &pass_arg, argi))
        {
            one_pass_only = arg_parse_uint(&arg);

            if (one_pass_only < 1 || one_pass_only > 2)
                die("Error: Invalid pass selected (%d)\n", one_pass_only);
        }
        else if (arg_match(&arg, &fpf_name, argi))
            stats_fn = arg.val;
        else if (arg_match(&arg, &usage, argi))
            arg_usage = arg_parse_uint(&arg);
        else if (arg_match(&arg, &deadline, argi))
            arg_deadline = arg_parse_uint(&arg);
        else if (arg_match(&arg, &best_dl, argi))
            arg_deadline = VPX_DL_BEST_QUALITY;
        else if (arg_match(&arg, &good_dl, argi))
            arg_deadline = VPX_DL_GOOD_QUALITY;
        else if (arg_match(&arg, &rt_dl, argi))
            arg_deadline = VPX_DL_REALTIME;
        else if (arg_match(&arg, &use_yv12, argi))
        {
            arg_use_i420 = 0;
        }
        else if (arg_match(&arg, &use_i420, argi))
        {
            arg_use_i420 = 1;
        }
        else if (arg_match(&arg, &verbosearg, argi))
            verbose = 1;
        else if (arg_match(&arg, &limit, argi))
            arg_limit = arg_parse_uint(&arg);
        else if (arg_match(&arg, &psnrarg, argi))
            show_psnr = 1;
1217 1218 1219 1220 1221
        else if (arg_match(&arg, &framerate, argi))
        {
            arg_framerate = arg_parse_rational(&arg);
            arg_have_framerate = 1;
        }
John Koleszar's avatar
John Koleszar committed
1222 1223
        else if (arg_match(&arg, &use_ivf, argi))
            write_webm = 0;
1224 1225
        else if (arg_match(&arg, &outputfile, argi))
            out_fn = arg.val;
1226 1227
        else if (arg_match(&arg, &debugmode, argi))
            ebml.debug = 1;
John Koleszar's avatar
John Koleszar committed
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
        else
            argj++;
    }

    /* Ensure that --passes and --pass are consistent. If --pass is set and --passes=2,
     * ensure --fpf was set.
     */
    if (one_pass_only)
    {
        /* DWIM: Assume the user meant passes=2 if pass=2 is specified */
        if (one_pass_only > arg_passes)
        {
1240
            fprintf(stderr, "Warning: Assuming --pass=%d implies --passes=%d\n",
John Koleszar's avatar
John Koleszar committed
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
                   one_pass_only, one_pass_only);
            arg_passes = one_pass_only;
        }

        if (arg_passes == 2 && !stats_fn)
            die("Must specify --fpf when --pass=%d and --passes=2\n", one_pass_only);
    }

    /* Populate encoder configuration */
    res = vpx_codec_enc_config_default(codec->iface, &cfg, arg_usage);

    if (res)
    {
1254 1255
        fprintf(stderr, "Failed to get config: %s\n",
                vpx_codec_err_to_string(res));
John Koleszar's avatar
John Koleszar committed
1256 1257 1258
        return EXIT_FAILURE;
    }

1259 1260 1261
    /* Change the default timebase to a high enough value so that the encoder
     * will always create strictly increasing timestamps.
     */
1262
    cfg.g_timebase.den = 1000;
1263

1264 1265 1266 1267 1268 1269
    /* Never use the library's default resolution, require it be parsed
     * from the file or set on the command line.
     */
    cfg.g_w = 0;
    cfg.g_h = 0;

John Koleszar's avatar
John Koleszar committed
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
    /* Now parse the remainder of the parameters. */
    for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step)
    {
        arg.argv_step = 1;

        if (0);
        else if (arg_match(&arg, &threads, argi))
            cfg.g_threads = arg_parse_uint(&arg);
        else if (arg_match(&arg, &profile, argi))
            cfg.g_profile = arg_parse_uint(&arg);
        else if (arg_match(&arg, &width, argi))
            cfg.g_w = arg_parse_uint(&arg);
        else if (arg_match(&arg, &height, argi))
            cfg.g_h = arg_parse_uint(&arg);
1284 1285
        else if (arg_match(&arg, &stereo_mode, argi))
            stereo_fmt = arg_parse_enum_or_int(&arg);
John Koleszar's avatar
John Koleszar committed
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
        else if (arg_match(&arg, &timebase, argi))
            cfg.g_timebase = arg_parse_rational(&arg);
        else if (arg_match(&arg, &error_resilient, argi))
            cfg.g_error_resilient = arg_parse_uint(&arg);
        else if (arg_match(&arg, &lag_in_frames, argi))
            cfg.g_lag_in_frames = arg_parse_uint(&arg);
        else if (arg_match(&arg, &dropframe_thresh, argi))
            cfg.rc_dropframe_thresh = arg_parse_uint(&arg);
        else if (arg_match(&arg, &resize_allowed, argi))
            cfg.rc_resize_allowed = arg_parse_uint(&arg);
        else if (arg_match(&arg, &resize_up_thresh, argi))
            cfg.rc_resize_up_thresh = arg_parse_uint(&arg);
        else if (arg_match(&arg, &resize_down_thresh, argi))
            cfg.rc_resize_down_thresh = arg_parse_uint(&arg);
        else if (arg_match(&arg, &resize_down_thresh, argi))
            cfg.rc_resize_down_thresh = arg_parse_uint(&arg);
        else if (arg_match(&arg, &end_usage, argi))
1303
            cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
John Koleszar's avatar
John Koleszar committed
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
        else if (arg_match(&arg, &target_bitrate, argi))
            cfg.rc_target_bitrate = arg_parse_uint(&arg);
        else if (arg_match(&arg, &min_quantizer, argi))
            cfg.rc_min_quantizer = arg_parse_uint(&arg);
        else if (arg_match(&arg, &max_quantizer, argi))
            cfg.rc_max_quantizer = arg_parse_uint(&arg);
        else if (arg_match(&arg, &undershoot_pct, argi))
            cfg.rc_undershoot_pct = arg_parse_uint(&arg);
        else if (arg_match(&arg, &overshoot_pct, argi))
            cfg.rc_overshoot_pct = arg_parse_uint(&arg);
        else if (arg_match(&arg, &buf_sz, argi))
            cfg.rc_buf_sz = arg_parse_uint(&arg);
        else if (arg_match(&arg, &buf_initial_sz, argi))
            cfg.rc_buf_initial_sz = arg_parse_uint(&arg);
        else if (arg_match(&arg, &buf_optimal_sz, argi))
            cfg.rc_buf_optimal_sz = arg_parse_uint(&arg);
        else if (arg_match(&arg, &bias_pct, argi))
        {
            cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);

            if (arg_passes < 2)
1325 1326 1327
                fprintf(stderr,
                        "Warning: option %s ignored in one-pass mode.\n",
                        arg.name);
John Koleszar's avatar
John Koleszar committed
1328 1329 1330 1331 1332 1333
        }
        else if (arg_match(&arg, &minsection_pct, argi))
        {
            cfg.rc_2pass_vbr_minsection_pct = arg_parse_uint(&arg);

            if (arg_passes < 2)
1334 1335 1336
                fprintf(stderr,
                        "Warning: option %s ignored in one-pass mode.\n",
                        arg.name);
John Koleszar's avatar
John Koleszar committed
1337 1338 1339 1340 1341 1342
        }
        else if (arg_match(&arg, &maxsection_pct, argi))
        {
            cfg.rc_2pass_vbr_maxsection_pct = arg_parse_uint(&arg);

            if (arg_passes < 2)
1343 1344 1345
                fprintf(stderr,
                        "Warning: option %s ignored in one-pass mode.\n",
                        arg.name);
John Koleszar's avatar
John Koleszar committed
1346 1347 1348 1349 1350
        }
        else if (arg_match(&arg, &kf_min_dist, argi))
            cfg.kf_min_dist = arg_parse_uint(&arg);
        else if (arg_match(&arg, &kf_max_dist, argi))
            cfg.kf_max_dist = arg_parse_uint(&arg);
1351 1352
        else if (arg_match(&arg, &kf_disabled, argi))
            cfg.kf_mode = VPX_KF_DISABLED;
John Koleszar's avatar
John Koleszar committed
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
        else
            argj++;
    }

    /* Handle codec specific options */
#if CONFIG_VP8_ENCODER

    if (codec->iface == &vpx_codec_vp8_cx_algo)
    {
        ctrl_args = vp8_args;
        ctrl_args_map = vp8_arg_ctrl_map;
    }

#endif

    for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step)
    {
        int match = 0;

        arg.argv_step = 1;

        for (i = 0; ctrl_args[i]; i++)
        {
            if (arg_match(&arg, ctrl_args[i], argi))
            {
                match = 1;

                if (arg_ctrl_cnt < ARG_CTRL_CNT_MAX)
                {
                    arg_ctrls[arg_ctrl_cnt][0] = ctrl_args_map[i];
John Koleszar's avatar
John Koleszar committed
1383
                    arg_ctrls[arg_ctrl_cnt][1] = arg_parse_enum_or_int(&arg);
John Koleszar's avatar
John Koleszar committed
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
                    arg_ctrl_cnt++;
                }
            }
        }

        if (!match)
            argj++;
    }

    /* Check for unrecognized options */
    for (argi = argv; *argi; argi++)
1395
        if (argi[0][0] == '-' && argi[0][1])
John Koleszar's avatar
John Koleszar committed
1396 1397 1398 1399 1400
            die("Error: Unrecognized option %s\n", *argi);

    /* Handle non-option arguments */
    in_fn = argv[0];

1401
    if (!in_fn)
John Koleszar's avatar
John Koleszar committed
1402 1403
        usage_exit();

1404 1405 1406
    if(!out_fn)
        die("Error: Output file is required (specify with -o)\n");

John Koleszar's avatar
John Koleszar committed
1407 1408 1409 1410 1411 1412
    memset(&stats, 0, sizeof(stats));

    for (pass = one_pass_only ? one_pass_only - 1 : 0; pass < arg_passes; pass++)
    {
        int frames_in = 0, frames_out = 0;
        unsigned long nbytes = 0;
1413
        struct detect_buffer detect;
John Koleszar's avatar
John Koleszar committed
1414

1415
        /* Parse certain options from the input file, if possible */
John Koleszar's avatar
John Koleszar committed
1416 1417
        infile = strcmp(in_fn, "-") ? fopen(in_fn, "rb")
                                    : set_binary_mode(stdin);
John Koleszar's avatar
John Koleszar committed
1418 1419 1420

        if (!infile)
        {
1421
            fprintf(stderr, "Failed to open input file\n");
John Koleszar's avatar
John Koleszar committed
1422 1423 1424
            return EXIT_FAILURE;
        }

1425 1426 1427
        /* For RAW input sources, these bytes will applied on the first frame
         *  in read_frame().
         */
1428 1429
        detect.buf_read = fread(detect.buf, 1, 4, infile);
        detect.position = 0;
1430

1431
        if (detect.buf_read == 4 && file_is_y4m(infile, &y4m, detect.buf))
1432
        {
1433 1434 1435 1436 1437
            if (y4m_input_open(&y4m, infile, detect.buf, 4) >= 0)
            {
                file_type = FILE_TYPE_Y4M;
                cfg.g_w = y4m.pic_w;
                cfg.g_h = y4m.pic_h;
1438

1439 1440 1441
                /* Use the frame rate from the file only if none was specified
                 * on the command-line.
                 */
1442
                if (!arg_have_framerate)
1443
                {
1444 1445
                    arg_framerate.num = y4m.fps_n;
                    arg_framerate.den = y4m.fps_d;
1446
                }
1447

1448 1449 1450
                arg_use_i420 = 0;
            }
            else
1451
            {
1452 1453
                fprintf(stderr, "Unsupported Y4M stream.\n");
                return EXIT_FAILURE;
1454 1455
            }
        }
1456
        else if (detect.buf_read == 4 &&
1457
                 file_is_ivf(infile, &fourcc, &cfg.g_w, &cfg.g_h, &detect))
1458
        {
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
            file_type = FILE_TYPE_IVF;
            switch (fourcc)
            {
            case 0x32315659:
                arg_use_i420 = 0;
                break;
            case 0x30323449:
                arg_use_i420 = 1;
                break;
            default:
                fprintf(stderr, "Unsupported fourcc (%08x) in IVF\n", fourcc);
                return EXIT_FAILURE;
            }
1472
        }
1473 1474 1475 1476
        else
        {
            file_type = FILE_TYPE_RAW;
        }
1477 1478 1479 1480 1481 1482 1483 1484

        if(!cfg.g_w || !cfg.g_h)
        {
            fprintf(stderr, "Specify stream dimensions with --width (-w) "
                            " and --height (-h).\n");
            return EXIT_FAILURE;
        }

1485 1486 1487
#define SHOW(field) fprintf(stderr, "    %-28s = %d\n", #field, cfg.field)

        if (verbose && pass == 0)
1488
        {
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
            fprintf(stderr, "Codec: %s\n", vpx_codec_iface_name(codec->iface));
            fprintf(stderr, "Source file: %s Format: %s\n", in_fn,
                    arg_use_i420 ? "I420" : "YV12");
            fprintf(stderr, "Destination file: %s\n", out_fn);
            fprintf(stderr, "Encoder parameters:\n");

            SHOW(g_usage);
            SHOW(g_threads);
            SHOW(g_profile);
            SHOW(g_w);
            SHOW(g_h);
            SHOW(g_timebase.num);
            SHOW(g_timebase.den);
            SHOW(g_error_resilient);
            SHOW(g_pass);
            SHOW(g_lag_in_frames);
            SHOW(rc_dropframe_thresh);
            SHOW(rc_resize_allowed);
            SHOW(rc_resize_up_thresh);
            SHOW(rc_resize_down_thresh);
            SHOW(rc_end_usage);
            SHOW(rc_target_bitrate);
            SHOW(rc_min_quantizer);
            SHOW(rc_max_quantizer);
            SHOW(rc_undershoot_pct);
            SHOW(rc_overshoot_pct);
            SHOW(rc_buf_sz);
            SHOW(rc_buf_initial_sz);
            SHOW(rc_buf_optimal_sz);
            SHOW(rc_2pass_vbr_bias_pct);
            SHOW(rc_2pass_vbr_minsection_pct);
            SHOW(rc_2pass_vbr_maxsection_pct);
            SHOW(kf_mode);
            SHOW(kf_min_dist);
            SHOW(kf_max_dist);
        }

1526
        if(pass == (one_pass_only ? one_pass_only - 1 : 0)) {
1527 1528 1529 1530 1531 1532 1533 1534
            if (file_type == FILE_TYPE_Y4M)
                /*The Y4M reader does its own allocation.
                  Just initialize this here to avoid problems if we never read any
                   frames.*/
                memset(&raw, 0, sizeof(raw));
            else
                vpx_img_alloc(&raw, arg_use_i420 ? VPX_IMG_FMT_I420 : VPX_IMG_FMT_YV12,
                              cfg.g_w, cfg.g_h, 1);
1535 1536
        }

John Koleszar's avatar
John Koleszar committed
1537 1538
        outfile = strcmp(out_fn, "-") ? fopen(out_fn, "wb")
                                      : set_binary_mode(stdout);
John Koleszar's avatar
John Koleszar committed
1539 1540 1541

        if (!outfile)
        {
1542
            fprintf(stderr, "Failed to open output file\n");
John Koleszar's avatar
John Koleszar committed
1543 1544 1545
            return EXIT_FAILURE;
        }

1546 1547 1548 1549 1550 1551
        if(write_webm && fseek(outfile, 0, SEEK_CUR))
        {
            fprintf(stderr, "WebM output to pipes not supported.\n");
            return EXIT_FAILURE;
        }

John Koleszar's avatar
John Koleszar committed
1552 1553 1554 1555
        if (stats_fn)
        {
            if (!stats_open_file(&stats, stats_fn, pass))
            {
1556
                fprintf(stderr, "Failed to open statistics store\n");
John Koleszar's avatar
John Koleszar committed
1557 1558 1559 1560 1561 1562 1563
                return EXIT_FAILURE;
            }
        }
        else
        {
            if (!stats_open_mem(&stats, pass))
            {
1564
                fprintf(stderr, "Failed to open statistics store\n");
John Koleszar's avatar
John Koleszar committed
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
                return EXIT_FAILURE;
            }
        }

        cfg.g_pass = arg_passes == 2
                     ? pass ? VPX_RC_LAST_PASS : VPX_RC_FIRST_PASS
                 : VPX_RC_ONE_PASS;
#if VPX_ENCODER_ABI_VERSION > (1 + VPX_CODEC_ABI_VERSION)

        if (pass)
        {
            cfg.rc_twopass_stats_in = stats_get(&stats);
        }

#endif

John Koleszar's avatar
John Koleszar committed
1581 1582 1583
        if(write_webm)
        {
            ebml.stream = outfile;
1584
            write_webm_file_header(&ebml, &cfg, &arg_framerate, stereo_fmt);
John Koleszar's avatar
John Koleszar committed
1585 1586 1587
        }
        else
            write_ivf_file_header(outfile, &cfg, codec->fourcc, 0);
John Koleszar's avatar
John Koleszar committed
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601


        /* Construct Encoder Context */
        vpx_codec_enc_init(&encoder, codec->iface, &cfg,
                           show_psnr ? VPX_CODEC_USE_PSNR : 0);
        ctx_exit_on_error(&encoder, "Failed to initialize encoder");

        /* Note that we bypass the vpx_codec_control wrapper macro because
         * we're being clever to store the control IDs in an array. Real
         * applications will want to make use of the enumerations directly
         */
        for (i = 0; i < arg_ctrl_cnt; i++)
        {
            if (vpx_codec_control_(&encoder, arg_ctrls[i][0], arg_ctrls[i][1]))
1602 1603
                fprintf(stderr, "Error: Tried to set control %d = %d\n",
                        arg_ctrls[i][0], arg_ctrls[i][1]);
John Koleszar's avatar
John Koleszar committed
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615

            ctx_exit_on_error(&encoder, "Failed to control codec");
        }

        frame_avail = 1;
        got_data = 0;

        while (frame_avail || got_data)
        {
            vpx_codec_iter_t iter = NULL;
            const vpx_codec_cx_pkt_t *pkt;
            struct vpx_usec_timer timer;
1616
            int64_t frame_start, next_frame_start;
John Koleszar's avatar
John Koleszar committed
1617 1618 1619

            if (!arg_limit || frames_in < arg_limit)
            {
1620 1621
                frame_avail = read_frame(infile, &raw, file_type, &y4m,
                                         &detect);
John Koleszar's avatar
John Koleszar committed
1622 1623 1624 1625

                if (frame_avail)
                    frames_in++;

1626 1627 1628
                fprintf(stderr,
                        "\rPass %d/%d frame %4d/%-4d %7ldB \033[K", pass + 1,
                        arg_passes, frames_in, frames_out, nbytes);
John Koleszar's avatar
John Koleszar committed
1629 1630 1631 1632 1633 1634
            }
            else
                frame_avail = 0;

            vpx_usec_timer_start(&timer);

1635 1636
            frame_start = (cfg.g_timebase.den * (int64_t)(frames_in - 1)
                          * arg_framerate.den) / cfg.g_timebase.num / arg_framerate.num;
1637 1638 1639
            next_frame_start = (cfg.g_timebase.den * (int64_t)(frames_in)
                                * arg_framerate.den)
                                / cfg.g_timebase.num / arg_framerate.num;
1640
            vpx_codec_encode(&encoder, frame_avail ? &raw : NULL, frame_start,
1641
                             next_frame_start - frame_start,
1642
                             0, arg_deadline);
John Koleszar's avatar
John Koleszar committed
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
            vpx_usec_timer_mark(&timer);
            cx_time += vpx_usec_timer_elapsed(&timer);
            ctx_exit_on_error(&encoder, "Failed to encode frame");
            got_data = 0;

            while ((pkt = vpx_codec_get_cx_data(&encoder, &iter)))
            {
                got_data = 1;

                switch (pkt->kind)
                {
                case VPX_CODEC_CX_FRAME_PKT:
                    frames_out++;
1656 1657
                    fprintf(stderr, " %6luF",
                            (unsigned long)pkt->data.frame.sz);
John Koleszar's avatar
John Koleszar committed
1658

John Koleszar's avatar
John Koleszar committed
1659 1660
                    if(write_webm)
                    {
John Koleszar's avatar
John Koleszar committed
1661 1662 1663 1664 1665
                        /* Update the hash */
                        if(!ebml.debug)
                            hash = murmur(pkt->data.frame.buf,
                                          pkt->data.frame.sz, hash);

John Koleszar's avatar
John Koleszar committed
1666 1667 1668 1669 1670
                        write_webm_block(&ebml, &cfg, pkt);
                    }
                    else
                    {
                        write_ivf_frame_header(outfile, pkt);
1671 1672
                        if(fwrite(pkt->data.frame.buf, 1,
                                  pkt->data.frame.sz, outfile));
John Koleszar's avatar
John Koleszar committed
1673
                    }
1674
                    nbytes += pkt->data.raw.sz;
John Koleszar's avatar
John Koleszar committed
1675 1676 1677
                    break;
                case VPX_CODEC_STATS_PKT:
                    frames_out++;
1678
                    fprintf(stderr, " %6luS",
John Koleszar's avatar
John Koleszar committed
1679 1680 1681 1682
                           (unsigned long)pkt->data.twopass_stats.sz);
                    stats_write(&stats,
                                pkt->data.twopass_stats.buf,
                                pkt->data.twopass_stats.sz);
1683
                    nbytes += pkt->data.raw.sz;
John Koleszar's avatar
John Koleszar committed
1684 1685 1686 1687 1688 1689 1690
                    break;
                case VPX_CODEC_PSNR_PKT:

                    if (show_psnr)
                    {
                        int i;

1691 1692
                        psnr_sse_total += pkt->data.psnr.sse[0];
                        psnr_samples_total += pkt->data.psnr.samples[0];
John Koleszar's avatar
John Koleszar committed
1693
                        for (i = 0; i < 4; i++)
1694
                        {
1695
                            fprintf(stderr, "%.3lf ", pkt->data.psnr.psnr[i]);
1696 1697 1698
                            psnr_totals[i] += pkt->data.psnr.psnr[i];
                        }
                        psnr_count++;
John Koleszar's avatar
John Koleszar committed
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
                    }

                    break;
                default:
                    break;
                }
            }

            fflush(stdout);
        }

1710 1711
        fprintf(stderr,
               "\rPass %d/%d frame %4d/%-4d %7ldB %7ldb/f %7"PRId64"b/s"
John Koleszar's avatar
John Koleszar committed
1712 1713
               " %7lu %s (%.2f fps)\033[K", pass + 1,
               arg_passes, frames_in, frames_out, nbytes, nbytes * 8 / frames_in,
1714
               nbytes * 8 *(int64_t)arg_framerate.num / arg_framerate.den / frames_in,
John Koleszar's avatar
John Koleszar committed
1715 1716 1717 1718
               cx_time > 9999999 ? cx_time / 1000 : cx_time,
               cx_time > 9999999 ? "ms" : "us",
               (float)frames_in * 1000000.0 / (float)cx_time);

1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
        if ( (show_psnr) && (psnr_count>0) )
        {
            int i;
            double ovpsnr = vp8_mse2psnr(psnr_samples_total, 255.0,
                                         psnr_sse_total);

            fprintf(stderr, "\nPSNR (Overall/Avg/Y/U/V)");

            fprintf(stderr, " %.3lf", ovpsnr);
            for (i = 0; i < 4; i++)
            {
                fprintf(stderr, " %.3lf", psnr_totals[i]/psnr_count);
            }
        }

John Koleszar's avatar
John Koleszar committed
1734 1735 1736 1737
        vpx_codec_destroy(&encoder);

        fclose(infile);

John Koleszar's avatar
John Koleszar committed
1738 1739
        if(write_webm)
        {
John Koleszar's avatar
John Koleszar committed
1740
            write_webm_file_footer(&ebml, hash);
John Koleszar's avatar
John Koleszar committed
1741 1742 1743 1744 1745 1746
        }
        else
        {
            if (!fseek(outfile, 0, SEEK_SET))
                write_ivf_file_header(outfile, &cfg, codec->fourcc, frames_out);
        }
John Koleszar's avatar
John Koleszar committed
1747 1748

        fclose(outfile);
James Berry's avatar
James Berry committed
1749
        stats_close(&stats, arg_passes-1);
1750
        fprintf(stderr, "\n");
John Koleszar's avatar
John Koleszar committed
1751 1752 1753 1754 1755 1756 1757 1758 1759

        if (one_pass_only)
            break;
    }

    vpx_img_free(&raw);
    free(argv);
    return EXIT_SUCCESS;
}