1/* 2 * Copyright (c) 2013 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * 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. 9 */ 10 11#include "./webmdec.h" 12 13#include <cstring> 14#include <cstdio> 15 16#include "third_party/libwebm/mkvparser.hpp" 17#include "third_party/libwebm/mkvreader.hpp" 18 19namespace { 20 21void reset(struct WebmInputContext *const webm_ctx) { 22 if (webm_ctx->reader != NULL) { 23 mkvparser::MkvReader *const reader = 24 reinterpret_cast<mkvparser::MkvReader*>(webm_ctx->reader); 25 delete reader; 26 } 27 if (webm_ctx->segment != NULL) { 28 mkvparser::Segment *const segment = 29 reinterpret_cast<mkvparser::Segment*>(webm_ctx->segment); 30 delete segment; 31 } 32 if (webm_ctx->buffer != NULL) { 33 delete[] webm_ctx->buffer; 34 } 35 webm_ctx->reader = NULL; 36 webm_ctx->segment = NULL; 37 webm_ctx->buffer = NULL; 38 webm_ctx->cluster = NULL; 39 webm_ctx->block_entry = NULL; 40 webm_ctx->block = NULL; 41 webm_ctx->block_frame_index = 0; 42 webm_ctx->video_track_index = 0; 43 webm_ctx->timestamp_ns = 0; 44 webm_ctx->is_key_frame = false; 45} 46 47void get_first_cluster(struct WebmInputContext *const webm_ctx) { 48 mkvparser::Segment *const segment = 49 reinterpret_cast<mkvparser::Segment*>(webm_ctx->segment); 50 const mkvparser::Cluster *const cluster = segment->GetFirst(); 51 webm_ctx->cluster = cluster; 52} 53 54void rewind_and_reset(struct WebmInputContext *const webm_ctx, 55 struct VpxInputContext *const vpx_ctx) { 56 rewind(vpx_ctx->file); 57 reset(webm_ctx); 58} 59 60} // namespace 61 62int file_is_webm(struct WebmInputContext *webm_ctx, 63 struct VpxInputContext *vpx_ctx) { 64 mkvparser::MkvReader *const reader = new mkvparser::MkvReader(vpx_ctx->file); 65 webm_ctx->reader = reader; 66 webm_ctx->reached_eos = 0; 67 68 mkvparser::EBMLHeader header; 69 long long pos = 0; 70 if (header.Parse(reader, pos) < 0) { 71 rewind_and_reset(webm_ctx, vpx_ctx); 72 return 0; 73 } 74 75 mkvparser::Segment* segment; 76 if (mkvparser::Segment::CreateInstance(reader, pos, segment)) { 77 rewind_and_reset(webm_ctx, vpx_ctx); 78 return 0; 79 } 80 webm_ctx->segment = segment; 81 if (segment->Load() < 0) { 82 rewind_and_reset(webm_ctx, vpx_ctx); 83 return 0; 84 } 85 86 const mkvparser::Tracks *const tracks = segment->GetTracks(); 87 const mkvparser::VideoTrack* video_track = NULL; 88 for (unsigned long i = 0; i < tracks->GetTracksCount(); ++i) { 89 const mkvparser::Track* const track = tracks->GetTrackByIndex(i); 90 if (track->GetType() == mkvparser::Track::kVideo) { 91 video_track = static_cast<const mkvparser::VideoTrack*>(track); 92 webm_ctx->video_track_index = track->GetNumber(); 93 break; 94 } 95 } 96 97 if (video_track == NULL || video_track->GetCodecId() == NULL) { 98 rewind_and_reset(webm_ctx, vpx_ctx); 99 return 0; 100 } 101 102 if (!strncmp(video_track->GetCodecId(), "V_VP8", 5)) { 103 vpx_ctx->fourcc = VP8_FOURCC; 104 } else if (!strncmp(video_track->GetCodecId(), "V_VP9", 5)) { 105 vpx_ctx->fourcc = VP9_FOURCC; 106 } else if (!strncmp(video_track->GetCodecId(), "V_VP10", 6)) { 107 vpx_ctx->fourcc = VP10_FOURCC; 108 } else { 109 rewind_and_reset(webm_ctx, vpx_ctx); 110 return 0; 111 } 112 113 vpx_ctx->framerate.denominator = 0; 114 vpx_ctx->framerate.numerator = 0; 115 vpx_ctx->width = static_cast<uint32_t>(video_track->GetWidth()); 116 vpx_ctx->height = static_cast<uint32_t>(video_track->GetHeight()); 117 118 get_first_cluster(webm_ctx); 119 120 return 1; 121} 122 123int webm_read_frame(struct WebmInputContext *webm_ctx, 124 uint8_t **buffer, 125 size_t *bytes_in_buffer, 126 size_t *buffer_size) { 127 // This check is needed for frame parallel decoding, in which case this 128 // function could be called even after it has reached end of input stream. 129 if (webm_ctx->reached_eos) { 130 return 1; 131 } 132 mkvparser::Segment *const segment = 133 reinterpret_cast<mkvparser::Segment*>(webm_ctx->segment); 134 const mkvparser::Cluster* cluster = 135 reinterpret_cast<const mkvparser::Cluster*>(webm_ctx->cluster); 136 const mkvparser::Block *block = 137 reinterpret_cast<const mkvparser::Block*>(webm_ctx->block); 138 const mkvparser::BlockEntry *block_entry = 139 reinterpret_cast<const mkvparser::BlockEntry*>(webm_ctx->block_entry); 140 bool block_entry_eos = false; 141 do { 142 long status = 0; 143 bool get_new_block = false; 144 if (block_entry == NULL && !block_entry_eos) { 145 status = cluster->GetFirst(block_entry); 146 get_new_block = true; 147 } else if (block_entry_eos || block_entry->EOS()) { 148 cluster = segment->GetNext(cluster); 149 if (cluster == NULL || cluster->EOS()) { 150 *bytes_in_buffer = 0; 151 webm_ctx->reached_eos = 1; 152 return 1; 153 } 154 status = cluster->GetFirst(block_entry); 155 block_entry_eos = false; 156 get_new_block = true; 157 } else if (block == NULL || 158 webm_ctx->block_frame_index == block->GetFrameCount() || 159 block->GetTrackNumber() != webm_ctx->video_track_index) { 160 status = cluster->GetNext(block_entry, block_entry); 161 if (block_entry == NULL || block_entry->EOS()) { 162 block_entry_eos = true; 163 continue; 164 } 165 get_new_block = true; 166 } 167 if (status) { 168 return -1; 169 } 170 if (get_new_block) { 171 block = block_entry->GetBlock(); 172 webm_ctx->block_frame_index = 0; 173 } 174 } while (block->GetTrackNumber() != webm_ctx->video_track_index || 175 block_entry_eos); 176 177 webm_ctx->cluster = cluster; 178 webm_ctx->block_entry = block_entry; 179 webm_ctx->block = block; 180 181 const mkvparser::Block::Frame& frame = 182 block->GetFrame(webm_ctx->block_frame_index); 183 ++webm_ctx->block_frame_index; 184 if (frame.len > static_cast<long>(*buffer_size)) { 185 delete[] *buffer; 186 *buffer = new uint8_t[frame.len]; 187 if (*buffer == NULL) { 188 return -1; 189 } 190 *buffer_size = frame.len; 191 webm_ctx->buffer = *buffer; 192 } 193 *bytes_in_buffer = frame.len; 194 webm_ctx->timestamp_ns = block->GetTime(cluster); 195 webm_ctx->is_key_frame = block->IsKey(); 196 197 mkvparser::MkvReader *const reader = 198 reinterpret_cast<mkvparser::MkvReader*>(webm_ctx->reader); 199 return frame.Read(reader, *buffer) ? -1 : 0; 200} 201 202int webm_guess_framerate(struct WebmInputContext *webm_ctx, 203 struct VpxInputContext *vpx_ctx) { 204 uint32_t i = 0; 205 uint8_t *buffer = NULL; 206 size_t bytes_in_buffer = 0; 207 size_t buffer_size = 0; 208 while (webm_ctx->timestamp_ns < 1000000000 && i < 50) { 209 if (webm_read_frame(webm_ctx, &buffer, &bytes_in_buffer, &buffer_size)) { 210 break; 211 } 212 ++i; 213 } 214 vpx_ctx->framerate.numerator = (i - 1) * 1000000; 215 vpx_ctx->framerate.denominator = 216 static_cast<int>(webm_ctx->timestamp_ns / 1000); 217 delete[] buffer; 218 219 get_first_cluster(webm_ctx); 220 webm_ctx->block = NULL; 221 webm_ctx->block_entry = NULL; 222 webm_ctx->block_frame_index = 0; 223 webm_ctx->timestamp_ns = 0; 224 webm_ctx->reached_eos = 0; 225 226 return 0; 227} 228 229void webm_free(struct WebmInputContext *webm_ctx) { 230 reset(webm_ctx); 231} 232