blob: 74feddbb1fd976ce44b2fa4c6ee22f6e559d7f12 [file] [log] [blame]
/*
* Copyright (c) 2013 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* This is an example of an VP8 encoder which can produce VP8 videos with alpha.
* It takes an input file in raw AYUV format, passes it through the encoder, and
* writes the compressed frames to disk in webm format.
*
* The design on how alpha encoding works can be found here: http://goo.gl/wCP1y
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <string>
// libwebm parser includes
#include "mkvparser.hpp"
#include "mkvreader.hpp"
// libwebm muxer includes
#include "mkvmuxer.hpp"
#include "mkvmuxerutil.hpp"
#include "mkvwriter.hpp"
using mkvmuxer::uint64;
using mkvmuxer::uint32;
using mkvmuxer::uint8;
namespace {
bool CreateInputFiles(const char* input, int w, int h) {
FILE* const f_input = fopen(input, "rb");
if (!f_input) {
fprintf(stderr, "Failed to open %s for reading", input);
return false;
}
FILE* const f_video = fopen("video.in", "wb");
if (!f_video) {
fprintf(stderr, "Failed to open video.in for write");
return false;
}
FILE* const f_alpha = fopen("alpha.in", "wb");
if (!f_alpha) {
fprintf(stderr, "Failed to open alpha.in for write");
return false;
}
const int uv_w = (1 + w) / 2;
const int uv_h = (1 + h) / 2;
uint8* row = new uint8[w];
bool eof = false;
while (!eof) {
for (int i = 0; i < 6 && !eof; ++i) {
const uint32 width = (i % 3) ? uv_w : w;
const uint32 height = (i % 3) ? uv_h : h;
for (uint32 j = 0; j < height; ++j) {
if (i < 4) {
if (fread(row, 1, width, f_input) != width) {
eof = true;
break;
}
} else {
memset(row, 0x80, width);
}
fwrite(row, 1, width, (i < 3) ? f_video : f_alpha);
}
}
}
fclose(f_video);
fclose(f_alpha);
fclose(f_input);
delete[] row;
return true;
}
bool Encode(const std::string& vpxenc_cmd,
const std::string& vpxenc_options,
int w, int h, std::string codec) {
// TODO(vigneshv): For now, we force the keyframe intervals to a static value
// on both the encodes so that the keyframes are aligned. Ideal way to do
// this is to encode the first file, parse it to determine key frames and
// pass that list to vpxenc for the second file.
std::ostringstream encode_cmd;
encode_cmd << vpxenc_cmd << " --width=" << w << " --height=" << h
<< " --codec=" << codec << " --kf-min-dist=150 --kf-max-dist=150 "
<< vpxenc_options << " -o video.out video.in";
fprintf(stderr, "Running %s\n", encode_cmd.str().c_str());
if (system(encode_cmd.str().c_str()))
return false;
encode_cmd.str(std::string());
encode_cmd << vpxenc_cmd << " --width=" << w << " --height=" << h
<< " --codec=" << codec << " --kf-min-dist=150 --kf-max-dist=150 "
<< vpxenc_options << " -o alpha.out alpha.in";
fprintf(stderr, "Running %s\n", encode_cmd.str().c_str());
if (system(encode_cmd.str().c_str()))
return false;
return true;
}
} // namespace
void Usage() {
printf("Usage: alpha_encoder -i input -o output -h height -w width -b "
"<path_to_vpxenc_binary> [vpxenc_options]\n");
printf("Options:\n");
printf(" -? | --help show help\n");
printf(" -i input file (raw yuva420p only)\n");
printf(" -o output file (webm with alpha)\n");
printf(" -w width of the input file\n");
printf(" -h height of the input file\n");
printf(" -c codec (vp8 or vp9). default is vp8\n");
printf(" -b absolute/relative path of vpxenc binary. "
"default is ../../libvpx/vpxenc\n");
printf(" [vpxenc_options] options to be passed to vpxenc. these options"
" are passed on to vpxenc as is. options to vpxenc should always"
" be in the end (i.e.) after all the aforementioned options\n");
printf("\n");
}
bool Init(const char* output,
mkvmuxer::MkvWriter* writer,
mkvmuxer::Segment* muxer_segment,
mkvparser::MkvReader* reader,
mkvparser::MkvReader* reader_alpha) {
if (reader->Open("video.out")) {
fprintf(stderr, "\n Error while opening video.out.\n");
return false;
}
if (reader_alpha->Open("alpha.out")) {
fprintf(stderr, "\n Error while opening alpha.out.\n");
return false;
}
if (!writer->Open(output)) {
fprintf(stderr, "\n Error while opening output file.\n");
return false;
}
if (!muxer_segment->Init(writer)) {
fprintf(stderr, "\n Could not initialize muxer segment!\n");
return false;
}
return true;
}
bool Cleanup(mkvmuxer::MkvWriter* writer,
mkvparser::MkvReader* reader,
mkvparser::MkvReader* reader_alpha,
mkvmuxer::Segment* muxer_segment,
mkvparser::Segment** parser_segment,
mkvparser::Segment** parser_segment_alpha) {
if (!muxer_segment->Finalize())
fprintf(stderr, "Finalization of segment failed.\n");
delete *parser_segment;
delete *parser_segment_alpha;
writer->Close();
reader->Close();
reader_alpha->Close();
if (remove("video.in") || remove("video.out") ||
remove("alpha.in") || remove("alpha.out")) {
fprintf(stderr, "\n Error while removing temp files.\n");
return false;
}
return true;
}
bool WriteTrack(mkvparser::MkvReader* reader,
mkvparser::MkvReader* reader_alpha,
mkvmuxer::Segment* muxer_segment,
mkvparser::Segment** parser_segment,
mkvparser::Segment** parser_segment_alpha,
std::string codec) {
long long pos = 0;
mkvparser::EBMLHeader ebml_header;
ebml_header.Parse(reader, pos);
long long pos_alpha = 0;
mkvparser::EBMLHeader ebml_header_alpha;
ebml_header_alpha.Parse(reader_alpha, pos_alpha);
long long ret = mkvparser::Segment::CreateInstance(reader,
pos,
*parser_segment);
if (ret) {
fprintf(stderr, "\n Segment::CreateInstance() failed.");
return false;
}
ret = mkvparser::Segment::CreateInstance(reader_alpha,
pos_alpha,
*parser_segment_alpha);
if (ret) {
fprintf(stderr, "\n Segment::CreateInstance() failed.");
return false;
}
ret = (*parser_segment)->Load();
if (ret < 0) {
fprintf(stderr, "\n Segment::Load() failed.");
return false;
}
ret = (*parser_segment_alpha)->Load();
if (ret < 0) {
fprintf(stderr, "\n Segment::Load() failed.");
return false;
}
const mkvparser::SegmentInfo* const segment_info =
(*parser_segment)->GetInfo();
const long long timeCodeScale = segment_info->GetTimeCodeScale();
muxer_segment->set_mode(mkvmuxer::Segment::kFile);
mkvmuxer::SegmentInfo* const info = muxer_segment->GetSegmentInfo();
info->set_timecode_scale(timeCodeScale);
info->set_writing_app("alpha_encoder");
const mkvparser::Tracks* const parser_tracks = (*parser_segment)->GetTracks();
uint64 vid_track = 0; // no track added
const mkvparser::Track* const parser_track =
parser_tracks->GetTrackByIndex(0);
if (!parser_track)
return false;
const mkvparser::VideoTrack* const pVideoTrack =
static_cast<const mkvparser::VideoTrack*>(parser_track);
const char* const track_name = pVideoTrack->GetNameAsUTF8();
const long long width = pVideoTrack->GetWidth();
const long long height = pVideoTrack->GetHeight();
// Add the video track to the muxer
vid_track = muxer_segment->AddVideoTrack(static_cast<int>(width),
static_cast<int>(height),
1);
if (!vid_track) {
fprintf(stderr, "\n Could not add video track.\n");
return false;
}
mkvmuxer::VideoTrack* const video =
static_cast<mkvmuxer::VideoTrack*>(
muxer_segment->GetTrackByNumber(vid_track));
if (!video) {
fprintf(stderr, "\n Could not get video track.\n");
return false;
}
video->set_codec_id((codec == "vp9") ?
mkvmuxer::Tracks::kVp9CodecId : mkvmuxer::Tracks::kVp8CodecId);
if (track_name)
video->set_name(track_name);
video->SetAlphaMode(1);
video->set_max_block_additional_id(1);
return true;
}
bool WriteClusters(mkvparser::MkvReader* reader,
mkvparser::MkvReader* reader_alpha,
mkvmuxer::Segment* muxer_segment,
mkvparser::Segment* parser_segment,
mkvparser::Segment* parser_segment_alpha) {
uint8* data = NULL;
int data_len = 0;
uint8* additional = NULL;
int additional_len = 0;
const mkvparser::Cluster* cluster = parser_segment->GetFirst();
const mkvparser::Cluster* cluster_alpha = parser_segment_alpha->GetFirst();
while (cluster != NULL && !cluster->EOS() &&
cluster_alpha != NULL && !cluster_alpha->EOS()) {
const mkvparser::BlockEntry* block_entry;
long status = cluster->GetFirst(block_entry);
if (status) {
fprintf(stderr, "\n Could not get first block of cluster.\n");
return false;
}
const mkvparser::BlockEntry* block_entry_alpha;
status = cluster_alpha->GetFirst(block_entry_alpha);
if (status) {
fprintf(stderr, "\n Could not get first block of cluster.\n");
return false;
}
while (block_entry != NULL && !block_entry->EOS() &&
block_entry_alpha != NULL && !block_entry_alpha->EOS()) {
const mkvparser::Block* const block = block_entry->GetBlock();
const mkvparser::Block* const block_alpha =
block_entry_alpha->GetBlock();
const long long time_ns = block->GetTime(cluster);
const int frame_count = block->GetFrameCount();
const bool is_key = block->IsKey();
for (int i = 0; i < frame_count; ++i) {
// TODO(vigneshv): Handle altref frames
const mkvparser::Block::Frame& frame = block->GetFrame(i);
const mkvparser::Block::Frame& frame_alpha = block_alpha->GetFrame(i);
if (frame.len > data_len) {
data = static_cast<uint8*>(realloc(data, sizeof(uint8) * frame.len));
if (!data)
return false;
data_len = frame.len;
}
if (frame_alpha.len > additional_len) {
additional = static_cast<uint8*>(
realloc(additional, sizeof(uint8) * frame_alpha.len));
if (!additional)
return false;
additional_len = frame_alpha.len;
}
if (frame.Read(reader, data))
return false;
if (frame_alpha.Read(reader_alpha, additional))
return false;
if (!muxer_segment->AddFrameWithAdditional(data,
frame.len,
additional,
frame_alpha.len,
1, 1,
time_ns,
is_key)) {
fprintf(stderr, "\n Could not add frame.\n");
return false;
}
}
status = cluster->GetNext(block_entry, block_entry);
if (status) {
fprintf(stderr, "\n Could not get next block of cluster.\n");
return false;
}
status = cluster_alpha->GetNext(block_entry_alpha, block_entry_alpha);
if (status) {
fprintf(stderr, "\n Could not get next block of cluster.\n");
return false;
}
}
cluster = parser_segment->GetNext(cluster);
cluster_alpha = parser_segment_alpha->GetNext(cluster_alpha);
}
free(data);
free(additional);
return true;
}
int main(int argc, const char** argv) {
const char* input = NULL;
const char* output = NULL;
std::string vpxenc_cmd = "../../libvpx/vpxenc";
std::string vpxenc_options = "";
std::string codec = "vp8";
long w = -1;
long h = -1;
int i;
// Parse command line parameters
const int argc_check = argc - 1;
for (i = 1; i < argc; ++i) {
char* end;
if (!strcmp("-?", argv[i]) || !strcmp("--help", argv[i])) {
Usage();
return EXIT_SUCCESS;
} else if (!strcmp("-i", argv[i]) && i < argc_check) {
input = argv[++i];
} else if (!strcmp("-o", argv[i]) && i < argc_check) {
output = argv[++i];
} else if (!strcmp("-w", argv[i]) && i < argc_check) {
w = strtol(argv[++i], &end, 10);
} else if (!strcmp("-h", argv[i]) && i < argc_check) {
h = strtol(argv[++i], &end, 10);
} else if (!strcmp("-b", argv[i]) && i < argc_check) {
vpxenc_cmd = argv[++i];
} else if (!strcmp("-c", argv[i]) && i < argc_check) {
codec = argv[++i];
} else {
break;
}
}
// All remaining parameters are to be passed on to vpxenc
for (; i < argc; ++i) {
vpxenc_options += argv[i];
vpxenc_options += " ";
}
// Validate input parameters
if (!input || !output || w == -1 || h == -1) {
Usage();
return EXIT_FAILURE;
}
if (codec != "vp8" && codec != "vp9") {
fprintf(stderr, "Invalid codec: '%s'. Has to be one of 'vp8' or 'vp9'.\n",
codec.c_str());
return EXIT_FAILURE;
}
if (w < 16 || h < 16) {
fprintf(stderr, "Invalid resolution: %ldx%ld", w, h);
return EXIT_FAILURE;
}
mkvparser::MkvReader reader;
mkvparser::MkvReader reader_alpha;
mkvmuxer::MkvWriter writer;
mkvmuxer::Segment muxer_segment;
mkvparser::Segment* parser_segment = NULL;
mkvparser::Segment* parser_segment_alpha = NULL;
if (!CreateInputFiles(input, w, h) ||
!Encode(vpxenc_cmd, vpxenc_options, w, h, codec) ||
!Init(output, &writer, &muxer_segment, &reader, &reader_alpha) ||
!WriteTrack(&reader, &reader_alpha, &muxer_segment,
&parser_segment, &parser_segment_alpha, codec) ||
!WriteClusters(&reader, &reader_alpha, &muxer_segment,
parser_segment, parser_segment_alpha) ||
!Cleanup(&writer, &reader, &reader_alpha, &muxer_segment,
&parser_segment, &parser_segment_alpha))
return EXIT_FAILURE;
return EXIT_SUCCESS;
}