static void AudioTrack(format_stream* s,TrackInfo* Info,int Format,bool_t PacketBased)
{
PacketFormatClear(&s->Format);
s->Format.Type = PACKET_AUDIO;
s->Format.Format.Audio.Format = Format;
Info->AV.Audio.Channels;
s->Format.Format.Audio.Channels = Info->AV.Audio.Channels; //Mod2010:
s->Format.Format.Audio.SampleRate = mkv_TruncFloat(Info->AV.Audio.SamplingFreq); //Mod2010:
s->Format.Format.Audio.Bits = Info->AV.Audio.BitDepth; //Mod2010:
s->Fragmented = !PacketBased;
if (PacketBased)
s->Format.Format.Audio.Flags |= PCM_PACKET_BASED;
PacketFormatDefault(&s->Format);
}
void InitializeCodecContextFromMatroskaTrackInfo(TrackInfo *TI, AVCodecContext *CodecContext) {
uint8_t *PrivateDataSrc = static_cast<uint8_t *>(TI->CodecPrivate);
size_t PrivateDataSize = TI->CodecPrivateSize;
size_t BIHSize = sizeof(FFMS_BITMAPINFOHEADER); // 40 bytes
if (!strncmp(TI->CodecID, "V_MS/VFW/FOURCC", 15) && PrivateDataSize >= BIHSize) {
// For some reason UTVideo requires CodecContext->codec_tag (i.e. the FourCC) to be set.
// Fine, it can't hurt to set it, so let's go find it.
// In a V_MS/VFW/FOURCC track, the codecprivate starts with a BITMAPINFOHEADER. If you treat that struct
// as an array of uint32_t, the biCompression member (that's the FourCC) can be found at offset 4.
// Therefore the following derp.
CodecContext->codec_tag = reinterpret_cast<uint32_t *>(PrivateDataSrc)[4];
// Now skip copying the BITMAPINFOHEADER into the extradata, because lavc doesn't expect it to be there.
if (PrivateDataSize <= BIHSize) {
PrivateDataSrc = NULL;
PrivateDataSize = 0;
}
else {
PrivateDataSrc += BIHSize;
PrivateDataSize -= BIHSize;
}
}
// I think you might need to do some special handling for A_MS/ACM extradata too,
// but I don't think anyone actually uses that.
if (PrivateDataSrc && PrivateDataSize > 0) {
CodecContext->extradata = static_cast<uint8_t *>(av_mallocz(PrivateDataSize + FF_INPUT_BUFFER_PADDING_SIZE));
CodecContext->extradata_size = PrivateDataSize;
memcpy(CodecContext->extradata, PrivateDataSrc, PrivateDataSize);
}
if (TI->Type == TT_VIDEO) {
CodecContext->coded_width = TI->AV.Video.PixelWidth;
CodecContext->coded_height = TI->AV.Video.PixelHeight;
} else if (TI->Type == TT_AUDIO) {
CodecContext->sample_rate = mkv_TruncFloat(TI->AV.Audio.SamplingFreq);
CodecContext->bits_per_coded_sample = TI->AV.Audio.BitDepth;
CodecContext->channels = TI->AV.Audio.Channels;
}
}
//////////////////
// Actually parse
void MatroskaWrapper::Parse() {
// Clear keyframes and timecodes
keyFrames.Clear();
bytePos.Clear();
timecodes.clear();
// Get info
int tracks = mkv_GetNumTracks(file);
TrackInfo *trackInfo;
SegmentInfo *segInfo = mkv_GetFileInfo(file);
// Parse tracks
for (int track=0; track<tracks; track++) {
trackInfo = mkv_GetTrackInfo(file,track);
// Video track
if (trackInfo->Type == 1) {
// Variables
ulonglong startTime, endTime, filePos;
unsigned int rt, frameSize, frameFlags;
CompressedStream *cs = NULL;
// Timecode scale
__int64 timecodeScale = mkv_TruncFloat(trackInfo->TimecodeScale) * segInfo->TimecodeScale;
// Mask other tracks away
mkv_SetTrackMask(file, ~(1 << track));
// Progress bar
int totalTime = double(segInfo->Duration) / timecodeScale;
volatile bool canceled = false;
DialogProgress *progress = new DialogProgress(NULL,_("Parsing Matroska"),&canceled,_("Reading keyframe and timecode data from Matroska file."),0,totalTime);
progress->Show();
progress->SetProgress(0,1);
// Read frames
int frameN = 0;
while (mkv_ReadFrame(file,0,&rt,&startTime,&endTime,&filePos,&frameSize,&frameFlags) == 0) {
// Read value
double curTime = double(startTime) / 1000000.0;
frames.push_back(MkvFrame((frameFlags & FRAME_KF) != 0,curTime,filePos));
frameN++;
// Cancelled?
if (canceled) {
Close();
throw _T("Canceled");
}
// Update progress
progress->SetProgress(curTime,totalTime);
}
// Clean up progress
if (!canceled) progress->Destroy();
break;
}
}
// Copy raw
for (std::list<MkvFrame>::iterator cur=frames.begin(); cur!=frames.end(); cur++) {
rawFrames.push_back(*cur);
}
// Process timecodes and keyframes
frames.sort();
MkvFrame curFrame(false,0,0);
int i = 0;
for (std::list<MkvFrame>::iterator cur=frames.begin(); cur!=frames.end(); cur++) {
curFrame = *cur;
if (curFrame.isKey) keyFrames.Add(i);
bytePos.Add(curFrame.filePos);
timecodes.push_back(curFrame.time);
i++;
}
}
void MatroskaWrapper::GetSubtitles(agi::fs::path const& filename, AssFile *target) {
MkvStdIO input(filename);
char err[2048];
agi::scoped_holder<MatroskaFile*, decltype(&mkv_Close)> file(mkv_Open(&input, err, sizeof(err)), mkv_Close);
if (!file) throw MatroskaException(err);
// Get info
unsigned tracks = mkv_GetNumTracks(file);
std::vector<unsigned> tracksFound;
std::vector<std::string> tracksNames;
// Find tracks
for (auto track : boost::irange(0u, tracks)) {
auto trackInfo = mkv_GetTrackInfo(file, track);
if (trackInfo->Type != 0x11 || trackInfo->CompEnabled) continue;
// Known subtitle format
std::string CodecID(trackInfo->CodecID);
if (CodecID == "S_TEXT/SSA" || CodecID == "S_TEXT/ASS" || CodecID == "S_TEXT/UTF8") {
tracksFound.push_back(track);
tracksNames.emplace_back(agi::format("%d (%s %s)", track, CodecID, trackInfo->Language));
if (trackInfo->Name) {
tracksNames.back() += ": ";
tracksNames.back() += trackInfo->Name;
}
}
}
// No tracks found
if (tracksFound.empty())
throw MatroskaException("File has no recognised subtitle tracks.");
unsigned trackToRead;
// Only one track found
if (tracksFound.size() == 1)
trackToRead = tracksFound[0];
// Pick a track
else {
int choice = wxGetSingleChoiceIndex(_("Choose which track to read:"), _("Multiple subtitle tracks found"), to_wx(tracksNames));
if (choice == -1)
throw agi::UserCancelException("canceled");
trackToRead = tracksFound[choice];
}
// Picked track
mkv_SetTrackMask(file, ~(1 << trackToRead));
auto trackInfo = mkv_GetTrackInfo(file, trackToRead);
std::string CodecID(trackInfo->CodecID);
bool srt = CodecID == "S_TEXT/UTF8";
bool ssa = CodecID == "S_TEXT/SSA";
AssParser parser(target, !ssa);
// Read private data if it's ASS/SSA
if (!srt) {
// Read raw data
std::string priv((const char *)trackInfo->CodecPrivate, trackInfo->CodecPrivateSize);
// Load into file
boost::char_separator<char> sep("\r\n");
for (auto const& cur : boost::tokenizer<boost::char_separator<char>>(priv, sep))
parser.AddLine(cur);
}
// Load default if it's SRT
else {
target->LoadDefault(false, OPT_GET("Subtitle Format/SRT/Default Style Catalog")->GetString());
parser.AddLine("[Events]");
}
// Read timecode scale
auto segInfo = mkv_GetFileInfo(file);
int64_t timecodeScale = mkv_TruncFloat(trackInfo->TimecodeScale) * segInfo->TimecodeScale;
// Progress bar
auto totalTime = double(segInfo->Duration) / timecodeScale;
DialogProgress progress(nullptr, _("Parsing Matroska"), _("Reading subtitles from Matroska file."));
progress.Run([&](agi::ProgressSink *ps) { read_subtitles(ps, file, &input, srt, totalTime, &parser); });
}
FFMatroskaVideo::FFMatroskaVideo(const char *SourceFile, int Track,
FFMS_Index &Index, int Threads)
: FFMS_VideoSource(SourceFile, Index, Track, Threads)
, MF(0)
, Res(FFSourceResources<FFMS_VideoSource>(this))
, PacketNumber(0)
{
AVCodec *Codec = NULL;
TrackInfo *TI = NULL;
MC.ST.fp = ffms_fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
std::ostringstream buf;
buf << "Can't open '" << SourceFile << "': " << strerror(errno);
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ, buf.str());
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
std::ostringstream buf;
buf << "Can't parse Matroska file: " << ErrorMessage;
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ, buf.str());
}
TI = mkv_GetTrackInfo(MF, VideoTrack);
if (TI->CompEnabled)
TCC.reset(new TrackCompressionContext(MF, TI, VideoTrack));
CodecContext = avcodec_alloc_context3(NULL);
CodecContext->thread_count = DecodingThreads;
Codec = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
if (Codec == NULL)
throw FFMS_Exception(FFMS_ERROR_DECODING, FFMS_ERROR_CODEC,
"Video codec not found");
InitializeCodecContextFromMatroskaTrackInfo(TI, CodecContext);
if (avcodec_open2(CodecContext, Codec, NULL) < 0)
throw FFMS_Exception(FFMS_ERROR_DECODING, FFMS_ERROR_CODEC,
"Could not open video codec");
Res.CloseCodec(true);
// Always try to decode a frame to make sure all required parameters are known
DecodeNextFrame();
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
// Calculate the average framerate
if (Frames.size() >= 2) {
double PTSDiff = (double)(Frames.back().PTS - Frames.front().PTS);
// Dividing by 1000 caused too much information to be lost, when CorrectNTSCRationalFramerate runs there was a possibility
// of it outputting the wrong framerate. We still divide by 100 to protect against the possibility of overflows.
VP.FPSDenominator = (unsigned int)(PTSDiff * mkv_TruncFloat(TI->TimecodeScale) / (double)100 / (double)(Frames.size() - 1) + 0.5);
VP.FPSNumerator = 10000000;
}
// Set the video properties from the codec context
SetVideoProperties();
// Output the already decoded frame so it isn't wasted
OutputFrame(DecodeFrame);
// Set AR variables
VP.SARNum = TI->AV.Video.DisplayWidth * TI->AV.Video.PixelHeight;
VP.SARDen = TI->AV.Video.DisplayHeight * TI->AV.Video.PixelWidth;
// Set crop variables
VP.CropLeft = TI->AV.Video.CropL;
VP.CropRight = TI->AV.Video.CropR;
VP.CropTop = TI->AV.Video.CropT;
VP.CropBottom = TI->AV.Video.CropB;
}
